基于注解的SSH将配置精简到极致(1)

很早之前就想写一篇关于SSH整合的博客了，但是一直觉得使用SSH的时候那么多的配置文件，严重破坏了我们代码整体性，比如你要看两个实体的关系还得对照*.hbm.xml文件，要屡清一个Action可能需要对照applicationContext*.xml和struts*.xml文件。总之过多的配置文件坏破坏代码的整体性，会打乱代码的连续性，因为很多情况下你需要一边看Java代码，一边看xml的配置，采用注解就能很好的解决这个问题。

当然，即使采用注解的方式，也不能完全的丢掉配置文件，因为配置文件是程序的入口，是基础。服务器启动最先加载web.xml文件，读取其中的配置信息，将程序运行所需要的信息进行初始化。因为是整合SSH，所以web.xml文件中需要配置Spring以及Struts的信息，同时Spring跟Struts也需要进行一些基本的配置。

使用注解的方式，配置文件最少可以精简到三个，web.xml、applicationContext.xml和struts.xml。Hibernate可以完全交给Spring来管理，这样连hibernate.cfg.xml也省了。下面就一起看看这些基本的配置吧！

web.xml

[html] view
plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xmlns="http://java.sun.com/xml/ns/javaee"
4. xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="SSH" version="2.5">
6. <display-name>ssh</display-name>
7. <welcome-file-list>
8. <welcome-file>addUser.jsp</welcome-file>
9. </welcome-file-list>
10. <!-- 配置Spring的监听器，用于初始化ApplicationContext对象 -->
11. <listener>
12. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
13. </listener>
14. <context-param>
15. <param-name>contextConfigLocation</param-name>
16. <param-value>classpath:applicationContext*.xml</param-value>
17. </context-param>
18. <!-- struts2 的配置 -->
19. <filter>
20. <filter-name>struts2</filter-name>
21. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
22. <init-param>
23. <param-name>filterConfig</param-name>
24. <param-value>classpath:struts.xml</param-value>
25. </init-param>
26. <!-- 自动扫描action -->
27. <init-param>
28. <param-name>actionPackages</param-name>
29. <param-value>com.ssh</param-value>
30. </init-param>
31. </filter>
32. <filter-mapping>
33. <filter-name>struts2</filter-name>
34. <url-pattern>/*</url-pattern>
35. </filter-mapping>
36. </web-app>

web.xml中包含了Spring和struts的基本配置，自动扫描Action的配置就是告诉tomcat，我要使用注解来配置struts。

applicationContext.xml

[html] view
plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
4. xmlns:tx="http://www.springframework.org/schema/tx"
5. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
6. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
7. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
8. <!-- 自动扫描与装配bean -->
9. <context:component-scan base-package="com.tgb.ssh"></context:component-scan>
10. <!-- dbcp配置 -->
11. <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
12. <property name="driverClassName">
13. <value>com.mysql.jdbc.Driver</value>
14. </property>
15. <property name="url">
16. <value>jdbc:mysql://127.0.0.1:3307/ssh</value>
17. </property>
18. <property name="username">
19. <value>root</value>
20. </property>
21. <property name="password">
22. <value>123456</value>
23. </property>
24. </bean>
25. <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
26. <property name="dataSource">
27. <ref local="dataSource" />
28. </property>
29. <property name="hibernateProperties">
30. <props>
31. <!--配置Hibernate的方言-->
32. <prop key="hibernate.dialect">
33. org.hibernate.dialect.MySQLDialect
34. </prop>
35. <prop key="hibernate.hbm2ddl.auto">update</prop>
36. <!--格式化输出sql语句-->
37. <prop key="hibernate.show_sql">true</prop>
38. <prop key="hibernate.format_sql">true</prop>
39. <prop key="hibernate.use_sql_comments">false</prop>
40. </props>
41. </property>
42. <!--自动扫描实体 -->
43. <property name="packagesToScan"  value="com.tgb.ssh.model" />
44. </bean>
45. <!-- 用注解来实现事务管理 -->
46. <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
47. <property name="sessionFactory" ref="sessionFactory"></property>
48. </bean>
49. <tx:annotation-driven transaction-manager="txManager"/>
50. </beans>

applicationContext.xml里配置了数据库连接的基本信息（对hibernate的管理），还有对所有bean的自动装配管理和事务的管理。

struts.xml

[html] view
plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE struts PUBLIC
3. "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
4. "http://struts.apache.org/dtds/struts-2.3.dtd">
5. <struts>
6. <!-- 开启使用开发模式，详细错误提示 -->
7. <constant name="struts.devMode" value="true" />
8. <!-- 将对象交给spring管理 -->
9. <constant name="struts.objectFactory" value="spring" />
10. <!-- 指定资源编码类型 -->
11. <constant name="struts.i18n.encoding" value="UTF-8" />
12. <!-- 指定每次请求到达，重新加载资源文件 -->
13. <constant name="struts.i18n.reload" value="false" />
14. <!-- 指定每次配置文件更改后，自动重新加载 -->
15. <constant name="struts.configuration.xml.reload" value="false" />
16. <!-- 默认后缀名 -->
17. <constant name="struts.action.extension" value="action," />
18. </struts>

struts.xml里配置了一些struts的基本参数，并告诉容器用Spring来管理自己。

到这里一个基本的SSH的配置就算完成了，配置很简单，而且每一项配置都有说明，相信理解上不会有什么问题。基础的配置就这么多，下面就是我们的注解发挥作用的时候了。

userAdd.jsp

[html] view
plaincopy

1. <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
3. <html>
4. <head>
5. <title>添加用户</title>
6. </head>
7. <body>
8. <form method="post" action="addUser">
9. 用户名：<input type="text" name="user.name"><br>
10. 密码：<input type="password" name="user.password"><br>
11. <input type="submit" value="登录"/>
12. </form>
13. </body>
14. </html>

用户添加页面，将用户信息提交给UserAction。

UserAction

[java] view
plaincopy

1. package com.tgb.ssh.action;
2. import javax.annotation.Resource;
3. import org.apache.struts2.convention.annotation.Action;
4. import org.apache.struts2.convention.annotation.Result;
5. import org.apache.struts2.convention.annotation.Results;
6. import com.opensymphony.xwork2.ActionSupport;
7. import com.tgb.ssh.model.User;
8. import com.tgb.ssh.service.UserManager;
9. @Results( { @Result(name="success",location="/success.jsp"),
10. @Result(name="failure",location="/failure.jsp") })
11. public class UserAction extends ActionSupport {
12. @Resource
13. private UserManager userManager;
14. private User user;
15. @Action(value="addUser")
16. public String addUser() {
17. try {
18. userManager.addUser(user);
19. } catch (Exception e) {
20. e.printStackTrace();
21. return "failure";
22. }
23. return "success";
24. }
25. public User getUser() {
26. return user;
27. }
28. public void setUser(User user) {
29. this.user = user;
30. }
31. }

UserAction通过注解配置Action的名字和返回的页面，通过@Resource活动Spring注入的UserManager对象，然后进行相应的操作。Action里还有@Namespace、@InterceptorRef等很多注解可以用，根据自己需要选择吧。

UserManager

[java] view
plaincopy

1. package com.tgb.ssh.service;
2. import javax.annotation.Resource;
3. import org.springframework.stereotype.Service;
4. import org.springframework.transaction.annotation.Transactional;
5. import com.tgb.ssh.dao.UserDao;
6. import com.tgb.ssh.model.User;
7. @Service
8. @Transactional
9. public class UserManager {
10. @Resource
11. UserDao userDao;
12. public void addUser(User user) {
13. userDao.addUser(user);
14. }
15. }

UserManager通过@Service自动装配到Spring的容器，为其他组件提供服务；通过@Transactional进行事务的管理；通过@Resource注入UserDao对象。

UserDao

[java] view
plaincopy

1. package com.tgb.ssh.dao;
2. import javax.annotation.Resource;
3. import org.hibernate.Session;
4. import org.hibernate.SessionFactory;
5. import org.hibernate.Transaction;
6. import org.springframework.orm.hibernate4.HibernateTemplate;
7. import org.springframework.stereotype.Repository;
8. import com.tgb.ssh.model.User;
9. @Repository
10. public class UserDao {
11. @Resource(name="sessionFactory")
12. private SessionFactory sessionFactory;
13. public void addUser(User user ) {
14. Session session = sessionFactory.getCurrentSession();
15. session.save(user);
16. }
17. }

UserDao通过@Repository自动装配到Spring的容器，通过@Resource获得Sessionfactory，将User对象持久化。

User

[java] view
plaincopy

1. package com.tgb.ssh.model;
2. import javax.persistence.Entity;
3. import javax.persistence.GeneratedValue;
4. import javax.persistence.GenerationType;
5. import javax.persistence.Id;
6. @Entity(name="t_user")
7. public class User {
8. @Id
9. @GeneratedValue(strategy = GenerationType.IDENTITY)
10. private int id;
11. private String name;
12. private String password;
13. public int getId() {
14. return id;
15. }
16. public void setId(int id) {
17. this.id = id;
18. }
19. public String getName() {
20. return name;
21. }
22. public void setName(String name) {
23. this.name = name;
24. }
25. public String getPassword() {
26. return password;
27. }
28. public void setPassword(String password) {
29. this.password = password;
30. }
31. }

User通过@Entity将实体类映射到数据库，生成t_user表，通过@Id定义表的Id，通过@GenerateValue定义Id的生成策略。

好了，到此为止，基于注解的SSH就算是搭建完成了。基础的搭建已经使注解简洁的优势初现端倪，随着开发的进行，代码不断地增加，其简洁的风格相比传统配置文件的方式会更加明显。因为如果采用配置文件的方式，每增加一个Action都需要在struts.xml和applicationContext.xml文件增加一段代码；每多一个实体，也需要多一个*.hbm.xml文件。配置文件泛滥是一件让人头疼的事情。

注解好处多多，而且也越来越流行，但配置文件也并不是一无是处。注解有注解的好，配置文件有配置文件的妙。还是那句话，技术没有好坏之分，只有合适不合适之别。一味的追求技术的好与坏不是明智之举，选择一个合适的才是真正的设计之道。本文主旨不在于告诉你注解比配置文件好，而是向大家介绍另一种方式，可以多一种选择，也许你会找到一种更合适的方式。

基于注解的SSH将配置精简到极致(1),布布扣,bubuko.com