采用注解的方式，也不能完全的丢掉配置文件，因为配置文件是程序的入口，是基础。服务器启动最先加载web.xml文件，读取其中的配置信息，将程序运行所需要的信息进行初始化。因为是整合SSH，所以web.xml文件中需要配置Spring以及Struts的信息，同时Spring跟Struts也需要进行一些基本的配置。
首先配置web.xml文件
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>index.jsp</welcome-file>
9. </welcome-file-list>
10.
11. <!-- 配置Spring的监听器，用于初始化ApplicationContext对象 -->
12. <listener>
13. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
14. </listener>
15. <context-param>
16. <param-name>contextConfigLocation</param-name>
17. <param-value>classpath:applicationContext*.xml</param-value>
18. </context-param>
19.
20. <!-- struts2 的配置 -->
21. <filter>
22. <filter-name>struts2</filter-name>
23. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
24. <init-param>
25. <param-name>filterConfig</param-name>
26. <param-value>classpath:struts.xml</param-value>
27. </init-param>
28.
29. <!-- 自动扫描action -->
30. <init-param>
31. <param-name>actionPackages</param-name>
32. <param-value>com.ssh</param-value>
33. </init-param>
34. </filter>
35.
36. <filter-mapping>
37. <filter-name>struts2</filter-name>
38. <url-pattern>/*</url-pattern>
39. </filter-mapping>
40. </web-app>
web.xml中包含了Spring和struts的基本配置，自动扫描Action的配置就是告诉tomcat，我要使用注解来配置struts。
applicationContext.xml
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.
9. <!-- 自动扫描与装配bean -->
10. <context:component-scan base-package="dao,biz,action"></context:component-scan>
11.
12. <!-- dbcp配置 -->
13. <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
14. <property name="driverClassName">
15. <value>oracle.jdbc.OracleDriver</value>
16. </property>
17. <property name="url">
18. <value>jdbc:oracle:thin:@localhost:1521:orcl</value>
19. </property>
20. <property name="username">
21. <value>root</value>
22. </property>
23. <property name="password">
24. <value>123456</value>
25. </property>
26. </bean>
27.
28. <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
29. <property name="dataSource">
30. <ref local="dataSource" />
31. </property>
32. <property name="hibernateProperties">
33. <props>
34. <!--配置Hibernate的方言-->
35. <prop key="hibernate.dialect">
36. org.hibernate.dialect.MySQLDialect
37. </prop>
38. <prop key="hibernate.hbm2ddl.auto">update</prop>
39.
40. <!--格式化输出sql语句-->
41. <prop key="hibernate.show_sql">true</prop>
42. <prop key="hibernate.format_sql">true</prop>
43. <prop key="hibernate.use_sql_comments">false</prop>
44. </props>
45. </property>
46.
47. <!--自动扫描实体 -->
48. <property name="packagesToScan" value="com.tgb.ssh.model" />
49. </bean>
50.
51. <!-- 用注解来实现事务管理 -->
52. <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
53. <property name="sessionFactory" ref="sessionFactory"></property>
54. </bean>
55. <tx:annotation-driven transaction-manager="txManager"/>
56.
57. </beans>
Struts.xml文件的基本配置，并有spring来管理
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.
6. <struts>
7.
8. <!-- 开启使用开发模式，详细错误提示 -->
9. <constant name="struts.devMode" value="true" />
10. <!-- 将对象交给spring管理 -->
11. <constant name="struts.objectFactory" value="spring" />
12. <!-- 指定资源编码类型 -->
13. <constant name="struts.i18n.encoding" value="UTF-8" />
14. <!-- 指定每次请求到达，重新加载资源文件 -->
15. <constant name="struts.i18n.reload" value="false" />
16. <!-- 指定每次配置文件更改后，自动重新加载 -->
17. <constant name="struts.configuration.xml.reload" value="false" />
18. <!-- 默认后缀名 -->
19. <constant name="struts.action.extension" value="action," />
20.
21. </struts>
然后就是代码的书写了：
UserAction通过注解配置Action的名字和返回的页面，通过@Resource活动Spring注入的UserManager对象，然后进行相应的操作。Action里还有@Namespace、@InterceptorRef等很多注解可以用，根据自己需要选择吧。
1. package com.tgb.ssh.action;
2.
3. import javax.annotation.Resource;
4.
5. import org.apache.struts2.convention.annotation.Action;
6. import org.apache.struts2.convention.annotation.Result;
7. import org.apache.struts2.convention.annotation.Results;
8.
9. import com.opensymphony.xwork2.ActionSupport;
10. import com.tgb.ssh.model.User;
11. import com.tgb.ssh.service.UserManager;
12.
13.
14. @Results( { @Result(name="success",location="/success.jsp"),
15. @Result(name="failure",location="/failure.jsp") })
16. public class UserAction extends ActionSupport {
17. @Resource
18. private UserManager userManager;
19. private User user;
20.
21. @Action(value="addUser")
22. public String addUser() {
23. try {
24. userManager.addUser(user);
25. } catch (Exception e) {
26. e.printStackTrace();
27. return "failure";
28. }
29. return "success";
30.
31. }
32.
33. public User getUser() {
34. return user;
35. }
36. public void setUser(User user) {
37. this.user = user;
38. }
39.
40.
41. }
对象的usermanage
UserManager通过@Service自动装配到Spring的容器，为其他组件提供服务；通过@Transactional进行事务的管理；通过@Resource注入UserDao对象。
1. package com.tgb.ssh.service;
2.
3. import javax.annotation.Resource;
4.
5. import org.springframework.stereotype.Service;
6. import org.springframework.transaction.annotation.Transactional;
7.
8. import com.tgb.ssh.dao.UserDao;
9. import com.tgb.ssh.model.User;
10.
11. @Service
12. @Transactional
13. public class UserManager {
14. @Resource
15. UserDao userDao;
16.
17. public void addUser(User user) {
18. userDao.addUser(user);
19. }
20.
21. }
Userdao的写法
UserDao通过@Repository自动装配到Spring的容器，通过@Resource获得Sessionfactory，将User对象持久化
1. package com.tgb.ssh.dao;
2.
3. import javax.annotation.Resource;
4.
5. import org.hibernate.Session;
6. import org.hibernate.SessionFactory;
7. import org.hibernate.Transaction;
8. import org.springframework.orm.hibernate4.HibernateTemplate;
9. import org.springframework.stereotype.Repository;
10.
11. import com.tgb.ssh.model.User;
12.
13. @Repository
14. public class UserDao {
15. @Resource(name="sessionFactory")
16. private SessionFactory sessionFactory;
17.
18. public void addUser(User user ) {
19. Session session = sessionFactory.getCurrentSession();
20. session.save(user);
21. }
22.
23. }
User实体类
User通过@Entity将实体类映射到数据库，生成t_user表，通过@Id定义表的Id，通过@GenerateValue定义Id的生成策略。
1. package com.tgb.ssh.model;
2.
3. import javax.persistence.Entity;
4. import javax.persistence.GeneratedValue;
5. import javax.persistence.GenerationType;
6. import javax.persistence.Id;
7.
8.
9. @Entity(name="t_user")
10. public class User {
11. @Id
12. @GeneratedValue(strategy = GenerationType.IDENTITY)
13. private int id;
14. private String name;
15. private String password;
16.
17.
18. public int getId() {
19. return id;
20. }
21.
22. public void setId(int id) {
23. this.id = id;
24. }
25.
26. public String getName() {
27. return name;
28. }
29.
30. public void setName(String name) {
31. this.name = name;
32. }
33. public String getPassword() {
34. return password;
35. }
36. public void setPassword(String password) {
37. this.password = password;
38. }
39. }
好了，到此为止，基于注解的SSH就算是搭建完成了。基础的搭建已经使注解简洁的优势初现端倪，随着开发的进行，代码不断地增加，其简洁的风格相比传统配置文件的方式会更加明显。因为如果采用配置文件的方式，每增加一个Action都需要在struts.xml和applicationContext.xml文件增加一段代码；每多一个实体，也需要多一个*.hbm.xml文件。配置文件泛滥是一件让人头疼的事情。