Spring3+Struts2+Hibernate4+Mybatis整合的一个maven例子

说明：

1.用了maven去搞这个demo，懒得去导jar包。。。

2.这个demo用了spring去做Ioc，事务的aop；用了struts2去做“MVC”（没有用到任何UI技术，有点对不起这个MVC，就单单一个后台。。。）；用了hibernate和Mybatis两个持久层，用上MyBatis是用来应对复杂的SQL查询逻辑，结果集映射也灵活。

3.此demo目的只是一个笔记，搞java web 开发的都懂的，要学的太多，很多东西过段时间不接触就忘了，也用作一个测试环境。同时也是给自己的一个小礼物以自勉之，下周鄙人就要跳去搞外包了。。。只因实力不济啊，吾为索道不辞路远，希望未来有所长进。。。

4.很遗憾，Junit test 用不了。。。

demo的整合大致示意图：

demo的目录结构：

给出demo用到的依赖包，pom.xml：

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
3. <modelVersion>4.0.0</modelVersion>
4. <groupId>org.oham.ssh</groupId>
5. <artifactId>ssh</artifactId>
6. <packaging>war</packaging>
7. <version>0.0.1-SNAPSHOT</version>
8. <name>ssh Maven Webapp</name>
9. <url>http://maven.apache.org</url>
10. <!-- 设置一些全局常量  -->
11. <properties>
12. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
13. <spring.version>3.1.0.RELEASE</spring.version>
14. <struts2.version>2.3.15.1</struts2.version>
15. <hibernate.version>4.1.4.Final</hibernate.version>
16. <mybatis.version>3.1.1</mybatis.version>
17. </properties>
18. <!-- 设置maven build的时候环境 -->
19. <build>
20. <plugins>
21. <plugin>
22. <groupId>org.apache.maven.plugins</groupId>
23. <artifactId>maven-compiler-plugin</artifactId>
24. <version>2.3.2</version>
25. <configuration>
26. <source>1.6</source>
27. <target>1.6</target>
28. </configuration>
29. </plugin>
30. </plugins>
31. </build>
32. <!-- 项目用到的jar包依赖 -->
33. <dependencies>
34. <!-- spring start -->
35. <dependency>
36. <groupId>org.springframework</groupId>
37. <artifactId>spring-core</artifactId>
38. <version>${spring.version}</version>
39. </dependency>
40. <dependency>
41. <groupId>org.springframework</groupId>
42. <artifactId>spring-beans</artifactId>
43. <version>${spring.version}</version>
44. </dependency>
45. <dependency>
46. <groupId>org.springframework</groupId>
47. <artifactId>spring-context</artifactId>
48. <version>${spring.version}</version>
49. </dependency>
50. <dependency>
51. <groupId>org.springframework</groupId>
52. <artifactId>spring-web</artifactId>
53. <version>${spring.version}</version>
54. </dependency>
55. <dependency>
56. <groupId>org.springframework</groupId>
57. <artifactId>spring-orm</artifactId>
58. <version>3.1.1.RELEASE</version>
59. </dependency>
60. <dependency>
61. <groupId>org.springframework</groupId>
62. <artifactId>spring-tx</artifactId>
63. <version>3.1.1.RELEASE</version>
64. </dependency>
65. <!-- spring end -->
66. <!-- struts2 start -->
67. <dependency>
68. <groupId>org.apache.struts</groupId>
69. <artifactId>struts2-core</artifactId>
70. <version>${struts2.version}</version>
71. </dependency>
72. <dependency>
73. <groupId>org.apache.struts</groupId>
74. <artifactId>struts2-spring-plugin</artifactId>
75. <version>${struts2.version}</version>
76. </dependency>
77. <!-- struts2中对于注解的支持 -->
78. <dependency>
79. <groupId>org.apache.struts</groupId>
80. <artifactId>struts2-convention-plugin</artifactId>
81. <version>${struts2.version}</version>
82. </dependency>
83. <!-- 用于查看struts2中注册的action， 可不用 -->
84. <dependency>
85. <groupId>org.apache.struts</groupId>
86. <artifactId>struts2-config-browser-plugin</artifactId>
87. <version>${struts2.version}</version>
88. </dependency>
89. <!-- 用于struts2的JSON支持， 可不用 -->
90. <dependency>
91. <groupId>org.apache.struts</groupId>
92. <artifactId>struts2-json-plugin</artifactId>
93. <version>${struts2.version}</version>
94. </dependency>
95. <!-- struts2 end -->
96. <!-- c3p0数据源  start -->
97. <dependency>
98. <groupId>com.mchange.c3p0</groupId>
99. <artifactId>com.springsource.com.mchange.v2.c3p0</artifactId>
100. <version>0.9.1.2</version>
101. </dependency>
102. <!-- c3p0数据源  end -->
103. <!-- MySQL 驱动 start -->
104. <dependency>
105. <groupId>mysql</groupId>
106. <artifactId>mysql-connector-java</artifactId>
107. <version>5.1.15</version>
108. </dependency>
109. <!-- MySQL 驱动 end -->
110. <!-- Hibernate start -->
111. <dependency>
112. <groupId>org.hibernate</groupId>
113. <artifactId>hibernate-core</artifactId>
114. <version>${hibernate.version}</version>
115. </dependency>
116. <dependency>
117. <groupId>org.hibernate</groupId>
118. <artifactId>hibernate-ehcache</artifactId>
119. <version>${hibernate.version}</version>
120. </dependency>
121. <dependency>
122. <groupId>org.slf4j</groupId>
123. <artifactId>slf4j-log4j12</artifactId>
124. <version>1.6.1</version>
125. </dependency>
126. <!-- Hibernate end -->
127. <!-- MyBatis start-->
128. <dependency>
129. <groupId>org.mybatis</groupId>
130. <artifactId>mybatis</artifactId>
131. <version>${mybatis.version}</version>
132. </dependency>
133. <dependency>
134. <groupId>org.mybatis</groupId>
135. <artifactId>mybatis-spring</artifactId>
136. <version>1.1.1</version>
137. </dependency>
138. <!-- End of MyBatis -->
139. <!-- Junit test start -->
140. <dependency>
141. <groupId>junit</groupId>
142. <artifactId>junit</artifactId>
143. <version>4.8.2</version>
144. <scope>test</scope>
145. </dependency>
146. <!-- Junit test end -->
147. <!-- J2EE start -->
148. <dependency>
149. <groupId>org.apache.openejb</groupId>
150. <artifactId>javaee-api</artifactId>
151. <version>5.0-1</version>
152. <scope>provided</scope>
153. </dependency>
154. <dependency>
155. <groupId>javax.faces</groupId>
156. <artifactId>jsf-api</artifactId>
157. <version>1.2_04</version>
158. <scope>provided</scope>
159. </dependency>
160. <dependency>
161. <groupId>javax.servlet</groupId>
162. <artifactId>jstl</artifactId>
163. <version>1.2</version>
164. <scope>provided</scope>
165. </dependency>
166. <dependency>
167. <groupId>javax.servlet.jsp</groupId>
168. <artifactId>jsp-api</artifactId>
169. <version>2.1</version>
170. <scope>provided</scope>
171. </dependency>
172. <!-- J2EE end -->
173. </dependencies>
174. </project>

demo是web项目，web.xml：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
5. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
6. <!-- 设置spring的配置文件路径 -->
7. <context-param>
8. <param-name>contextConfigLocation</param-name>
9. <param-value>classpath:spring/applicationContext.xml,classpath:spring/**/applicationContext*.xml</param-value>
10. </context-param>
11. <!-- 设置启用log4j -->
12. <listener>
13. <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
14. </listener>
15. <!-- 设置struts的filter，给了个param，读取指定的struts配置文件 -->
16. <filter>
17. <filter-name>struts2</filter-name>
18. <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
19. <init-param>
20. <param-name>config</param-name>
21. <param-value>platform-web.xml,struts-default.xml,struts-plugin.xml,struts/struts.xml</param-value>
22. </init-param>
23. </filter>
24. <filter-mapping>
25. <filter-name>struts2</filter-name>
26. <url-pattern>*.action</url-pattern>
27. </filter-mapping>
28. <!-- 设置spring的listener -->
29. <listener>
30. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
31. </listener>
32. </web-app>

先看spring的配置，有两个，

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:util="http://www.springframework.org/schema/util"
5. xsi:schemaLocation="http://www.springframework.org/schema/beans
6. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
7. http://www.springframework.org/schema/context
8. http://www.springframework.org/schema/context/spring-context-3.0.xsd
9. http://www.springframework.org/schema/util
10. http://www.springframework.org/schema/util/spring-util-3.0.xsd">
11. <!-- 读入配置文件 -->
12. <context:property-placeholder location="classpath:config/*.properties" />
13. <!-- 设置配置文件引用变量 -->
14. <util:properties id="dbProp" location="classpath:config/db.properties" />
15. <!-- 启动 spring 的注解功能 -->
16. <context:annotation-config />
17. <!-- register annotated class with @Service, @Repository as Spring beans -->
18. <!-- 指定  spring 注解的扫描路径 -->
19. <context:component-scan base-package="org.oham.learn.ssh.controllers;org.oham.learn.ssh.services" />
20. </beans>

applicationContext-persistence.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"
4. xmlns:tx="http://www.springframework.org/schema/tx"
5. xsi:schemaLocation="
6. http://www.springframework.org/schema/beans
7. http://www.springframework.org/schema/beans/spring-beans.xsd
8. http://www.springframework.org/schema/tx
9. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"
10. >
11. <bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
12. destroy-method="close">
13. <property name="driverClass" value="#{dbProp.driverClass_MySql}" />
14. <property name="jdbcUrl" value="#{dbProp.jdbcUrl_MySql}" />
15. <property name="user" value="#{dbProp.username_MySql}" />
16. <property name="password" value="#{dbProp.password_MySql}" />
17. <property name="initialPoolSize" value="#{dbProp.initialPoolSize_MySql}" />
18. <property name="maxPoolSize" value="#{dbProp.maxPoolSize_MySql}" />
19. <property name="minPoolSize" value="#{dbProp.minPoolSize_MySql}" />
20. <property name="acquireIncrement" value="#{dbProp.acquireIncrement_MySql}" />
21. <property name="autoCommitOnClose" value="#{dbProp.autoCommitOnClose_MySql}" />
22. </bean>
23. <!-- Hibernate 的 session factory 配置 -->
24. <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
25. <property name="dataSource" ref="c3p0DataSource"/>
26. <property name="hibernateProperties">
27. <props>
28. <prop key="hibernate.dialect">#{dbProp.hibernate_dialect}</prop>
29. <prop key="hibernate.show_sql">#{dbProp.hibernate_showSql}</prop>
30. <prop key="hibernate.format_sql">#{dbProp.hibernate_formatSql}</prop>
31. <prop key="hibernate.use_sql_comments">#{dbProp.hibernate_useSqlComments}</prop>
32. <prop key="hibernate.hbm2ddl.auto">#{dbProp.hibernate_hbm2ddlAuto}</prop>
33. <!-- 配置hibernate的缓存机制的，但demo里没有具体的体现 -->
34. <prop key="hibernate.cache.provider_class">#{dbProp.hibernate_cacheProviderClass}</prop>
35. <prop key="hibernate.cache.use_query_cache">#{dbProp.hibernate_cacheUseQueryCache}</prop>
36. <prop key="hibernate.cache.use_second_level_cache">#{dbProp.hibernate_cacheUseSecondLevelCache}</prop>
37. </props>
38. </property>
39. <!-- demo用了hibernate的两种映射配置方式：xml与annotation -->
40. <property name="packagesToScan" value="org.oham.learn.ssh.beans" />
41. <property name="mappingResources">
42. <list>
43. <value>org/oham/learn/ssh/beans/TPerson.hbm.xml</value>
44. </list>
45. </property>
46. </bean>
47. <!-- Mybatis 的 session factory 配置 -->
48. <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
49. <property name="dataSource" ref="c3p0DataSource" />
50. <property name="configLocation" value="classpath:mybatis/sqlmap-config.xml" />
51. </bean>
52. <!-- 扫描  mapper 接口 -->
53. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
54. <property name="basePackage" value="org.oham.learn.ssh.sqlmapper" />
55. <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
56. </bean>
57. <!-- 这个是配置AOP形式的transaction管理，有兴趣的可以放开注释自己玩玩 -->
58. <!--
59. handle default transaction management for service - start
60. <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
61. <tx:attributes>
62. <tx:method name="update*" read-only="false" propagation="REQUIRED"/>
63. <tx:method name="save*" read-only="false" propagation="REQUIRED"/>
64. <tx:method name="insert*" read-only="false" propagation="REQUIRED"/>
65. <tx:method name="delete*" read-only="false" propagation="REQUIRED"/>
66. <tx:method name="handleLink*" read-only="false" propagation="REQUIRED"/>
67. <tx:method name="*" read-only="true" propagation="NOT_SUPPORTED"/>
68. </tx:attributes>
69. </tx:advice>
70. <aop:config>
71. <aop:pointcut id="txOperationForService"
72. expression="execution(* com.hkt.engineering.iris.ws.service.impl..*.*(..))" />
73. <aop:advisor advice-ref="transactionAdvice" pointcut-ref="txOperationForService" />
74. </aop:config>
75. -->
76. <!-- handle default transaction management for service - end -->
77. <!-- Transaction Manager -->
78. <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
79. <!-- 用于Mybatis 的事务配置 -->
80. <property name="dataSource" ref="c3p0DataSource"/>
81. <!-- 用于Hibernate 的事务配置 -->
82. <property name="sessionFactory" ref="sessionFactory"/>
83. </bean>
84. <!-- 注解形式的transaction管理 -->
85. <!-- Transaction Manager Annotation set active-->
86. <tx:annotation-driven transaction-manager="transactionManager"/>
87. </beans>

struts.xml：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE struts PUBLIC
3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
4. "http://struts.apache.org/dtds/struts-2.0.dtd">
5. <struts>
6. <!-- 开启使用开发模式，详细错误提示 -->
7. <constant name="struts.devMode" value="true" />
8. <!-- 指定每次配置文件更改后，自动重新加载 -->
9. <constant name="struts.configuration.xml.reload" value="true" />
10. <!-- 将对象交给spring管理 -->
11. <!--   <constant name="struts.objectFactory" value="spring" />-->
12. <!-- 指定资源编码类型 -->
13. <constant name="struts.i18n.encoding" value="UTF-8" />
14. <!-- 指定struts-convention插件扫描的本demo里action所在的路径，若没有被扫描，注解了的action类是不会被注册为action的，此处我尝试使用
15. struts的注解形式的action配置
16. -->
17. <constant name="struts.convention.action.packages" value="org.oham.learn.ssh.controllers" />
18. <!-- 配置注解action默认的result视图文件路径 -->
19. <!--    <constant name="struts.convention.result.path" value="/WEB-INF/jsp" />-->
20. <!-- 默认的package，此处只搞了个json的 -->
21. <package name="ssh-default" namespace="/" extends="struts-default">
22. <result-types>
23. <result-type name="json" class="org.apache.struts2.json.JSONResult"/>
24. </result-types>
25. <interceptors>
26. <interceptor name="json" class="org.apache.struts2.json.JSONInterceptor"/>
27. </interceptors>
28. </package>
29. <!-- 传统的以xml的形式注册了action，注意action的class，是spring bean的id -->
30. <package name="testStruts" namespace="/struts" extends="ssh-default">
31. <action name="testCall" method="testCall" class="testStrutsAction">
32. <result name="success">/WEB-INF/jsp/Main.jsp</result>
33. <result name="json" type="json"/>
34. </action>
35. <action name="testAnnotationCall" method="testAnnotationCall" class="testStrutsAction">
36. <result name="success">/WEB-INF/jsp/Main.jsp</result>
37. </action>
38. </package>
39. </struts>

基本配置写完了，现在挑选一个action试试，TestStrutsAction.java：

1. package org.oham.learn.ssh.controllers;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. import javax.annotation.Resource;
6. import org.oham.learn.ssh.beans.TGroup;
7. import org.oham.learn.ssh.beans.TPerson;
8. import org.oham.learn.ssh.beans.TUser;
9. import org.oham.learn.ssh.services.TestHibernateService;
10. import org.oham.learn.ssh.sqlmapper.TUserMapper;
11. import org.springframework.context.annotation.Scope;
12. import org.springframework.stereotype.Service;
13. import com.opensymphony.xwork2.ActionSupport;
14. /**
15. * 此处的action由spring去负责实例化，默认是单例的，
16. * 为迎合struts的action，现设置器scope为protoype
17. */
18. @Service(value="testStrutsAction")
19. @Scope("prototype")
20. public class TestStrutsAction extends ActionSupport {
21. private static final long serialVersionUID = 3362122496775495186L;
22. @Resource(name="TestHibernate")
23. private TestHibernateService testHibernateService;
24. @Resource
25. private TUserMapper tUserMapper;
26. private Map<String, Object> jsonMap;
27. /**
28. * 该action为xml方式配置的，此处测试其方法的调用，
29. * 用Hibernate执行了查询，此处的映射配置基于xml
30. */
31. public String testCall() {
32. List<TPerson> list = testHibernateService.getTpersonList();
33. for(TPerson p : list) {
34. System.out.println(p.getName());
35. }
36. return "success";
37. }
38. /**
39. * 用Hibernate执行了查询，此处的映射配置基于annotation
40. */
41. public String testAnnotationCall() {
42. List<TGroup> list = testHibernateService.getTGroupList();
43. for(TGroup g : list) {
44. System.out.println(g.getName());
45. }
46. return "success";
47. }
48. /**
49. * 测试json interceptor是否起作用
50. */
51. public String testJsonCall() {
52. jsonMap = new HashMap<String, Object>();
53. jsonMap.put("a", "aa");
54. jsonMap.put("b", "b");
55. return "json";
56. }
57. /**
58. * 测试MyBatis 整合
59. */
60. public String testMybatisCall() {
61. TUser user = new TUser();
62. user.setId(1);
63. user.setName("oham");
64. List<TUser> list = tUserMapper.selectTUserByExample(user);
65. for(TUser t : list) {
66. System.out.println(t.getName());
67. }
68. return SUCCESS;
69. }
70. public Map<String, Object> getJsonMap() {
71. return jsonMap;
72. }
73. }

看其testCall方法, 用到一个注入的testHibernateService，进入看看，TestHibernateServiceImpl.java：

1. package org.oham.learn.ssh.services.impl;
2. import java.util.List;
3. import javax.annotation.Resource;
4. import org.hibernate.Criteria;
5. import org.hibernate.Session;
6. import org.hibernate.SessionFactory;
7. import org.oham.learn.ssh.beans.TGroup;
8. import org.oham.learn.ssh.beans.TPerson;
9. import org.oham.learn.ssh.services.TestHibernateService;
10. import org.springframework.stereotype.Service;
11. import org.springframework.transaction.annotation.Propagation;
12. import org.springframework.transaction.annotation.Transactional;
13. @Service(value="TestHibernate")
14. public class TestHibernateServiceImpl implements TestHibernateService {
15. @Resource(name="sessionFactory")
16. private SessionFactory factory;
17. @Transactional(readOnly=true, propagation=Propagation.REQUIRED)
18. public List<TPerson> getTpersonList() {
19. Session session = factory.getCurrentSession();
20. Criteria criteria = session.createCriteria(TPerson.class);
21. List<TPerson> list = criteria.list();
22. return list;
23. }
24. @Transactional(readOnly=true, propagation=Propagation.REQUIRED)
25. public List<TGroup> getTGroupList() {
26. Session session = factory.getCurrentSession();
27. Criteria criteria = session.createCriteria(TGroup.class);
28. List<TGroup> list = criteria.list();
29. return list;
30. }
31. }

factory.getCurrentSession();这句，若当前没有事务，抛session closed异常的，可以注释@Transactional试试，方法调用结束，随着事务关闭，session也关闭。可以自己写个方法测试，形如：

1. @Transactional(readOnly=true, propagation=Propagation.REQUIRED)
2. public Session testSession() {
3. Session session = factory.getCurrentSession();
4. return session;
5. }

然后action里如此调用：

1. Session session = testHibernateService.testSession();
2. Criteria criteria = session.createCriteria(TPerson.class);
3. List<TPerson> list = criteria.list();

给出hibernate的映射相关，

TPerson.java：

1. package org.oham.learn.ssh.beans;
2. import java.io.Serializable;
3. public class TPerson implements Serializable{
4. private static final long serialVersionUID = 4135349486988951197L;
5. private int id;
6. private String name;
7. private String address;
8. private String tel;
9. private String zipCode;
10. public int getId() {
11. return id;
12. }
13. public void setId(int id) {
14. this.id = id;
15. }
16. public String getName() {
17. return name;
18. }
19. public void setName(String name) {
20. this.name = name;
21. }
22. public String getAddress() {
23. return address;
24. }
25. public void setAddress(String address) {
26. this.address = address;
27. }
28. public String getTel() {
29. return tel;
30. }
31. public void setTel(String tel) {
32. this.tel = tel;
33. }
34. public String getZipCode() {
35. return zipCode;
36. }
37. public void setZipCode(String zipCode) {
38. this.zipCode = zipCode;
39. }
40. }

TPerson.hbm.xml：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
4. <hibernate-mapping package="org.oham.learn.ssh.beans">
5. <class name="TPerson" table="t_person">
6. <id name="id" column="id" type="java.lang.Integer">
7. <generator class="native"/>
8. </id>
9. <property name="name" column="name" type="java.lang.String"/>
10. <property name="address" column="address" type="java.lang.String"/>
11. <property name="tel" column="tel" type="java.lang.String"/>
12. <property name="zipCode" column="zipcode" type="java.lang.String"/>
13. </class>
14. </hibernate-mapping>

TGroup.java，这个是基于hibernate的注解来做映射的：

1. package org.oham.learn.ssh.beans;
2. import java.io.Serializable;
3. import javax.persistence.Column;
4. import javax.persistence.Entity;
5. import javax.persistence.Id;
6. import javax.persistence.Table;
7. @Entity
8. @Table(name="t_group")
9. public class TGroup implements Serializable {
10. private static final long serialVersionUID = 2177231731375781687L;
11. @Id
12. @Column(name="id")
13. private int id;
14. @Column(name="name", nullable= true)
15. private String name;
16. public int getId() {
17. return id;
18. }
19. public void setId(int id) {
20. this.id = id;
21. }
22. public String getName() {
23. return name;
24. }
25. public void setName(String name) {
26. this.name = name;
27. }
28. }

然后试着调用：http://你的IP加端口/ssh/struts/testCall.action，看看可否。也可调用本action的其他方法，诸如：http://你的IP加端口/ssh/struts/testCall!testJsonCall.action，再看看。

再给出基于struts注解形式注册的另一个action，TestStrutsAnnotationAction.java：

1. package org.oham.learn.ssh.controllers;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. import javax.annotation.Resource;
6. import org.apache.struts2.convention.annotation.Action;
7. import org.apache.struts2.convention.annotation.Namespace;
8. import org.apache.struts2.convention.annotation.ParentPackage;
9. import org.apache.struts2.convention.annotation.Result;
10. import org.oham.learn.ssh.beans.TGroup;
11. import org.oham.learn.ssh.beans.TPerson;
12. import org.oham.learn.ssh.beans.TUser;
13. import org.oham.learn.ssh.services.TestHibernateService;
14. import org.oham.learn.ssh.sqlmapper.TUserMapper;
15. import org.springframework.context.annotation.Scope;
16. import org.springframework.stereotype.Component;
17. import com.opensymphony.xwork2.ActionSupport;
18. @ParentPackage("ssh-default")
19. @Namespace("/sa")
20. @Scope(value="prototype")
21. @Component("saAction")
22. public class TestStrutsAnnotationAction extends ActionSupport{
23. private static final long serialVersionUID = -2793512785203051741L;
24. private Map<String, Object> jsonMap;
25. @Resource(name="TestHibernate")
26. private TestHibernateService testHibernateService;
27. @Resource
28. private TUserMapper tUserMapper;
29. @Action(value="testSACall",
30. results={
31. @Result(name="success", location="/WEB-INF/jsp/Main.jsp")
32. })
33. public String testAnnotaionCall() {
34. List<TPerson> list = testHibernateService.getTpersonList();
35. for(TPerson p : list) {
36. System.out.println(p.getName());
37. }
38. List<TGroup> list2 = testHibernateService.getTGroupList();
39. for(TGroup g : list2) {
40. System.out.println(g.getName());
41. }
42. return "success";
43. }
44. @Action(value="testSAMyBatis",
45. results={
46. @Result(name="success", location="/WEB-INF/jsp/Main.jsp")
47. })
48. public String testMyBatisCall() {
49. List<TUser> list = tUserMapper.selectTUserByExample(null);
50. for(TUser t : list) {
51. System.out.println(t.getName());
52. }
53. return SUCCESS;
54. }
55. @Action(value="testJ",
56. results={@Result(name="json", type="json")})
57. public String testJ() {
58. jsonMap = new HashMap<String, Object>();
59. jsonMap.put("a", "aa");
60. jsonMap.put("b", "b");
61. return "json";
62. }
63. public Map<String, Object> getJsonMap() {
64. return jsonMap;
65. }
66. }

调用：诸如，http://你的IP加端口/ssh/sa/testSACall.action试试可否。

本demo用到了struts2-config-browser-plugin这个插件，主要用来看看注册的action有哪些，因为鄙人为了搞基于注解的struts action搞半天没成，起初不知原因为何，后来struts.xml中加上：<constant name="struts.convention.action.packages" value="org.oham.learn.ssh.controllers" />就行了，但看别人的一些demo他们没加，所以至今也不太敢确定是否就是这个原因了。

调用http://你的IP加端口/ssh/config-browser/actionNames.action就可以看到成功注册的action。

完了，希望对诸君有所助。

附上项目源码ssh.zip，解压——>导入Existing Maven Project。

• ssh.zip (62.8 KB)
• 下载次数: 176