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：

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：

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：

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：

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：

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：

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：

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也关闭。可以自己写个方法测试，形如：

Java代码  

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

然后action里如此调用：

Java代码  

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

给出hibernate的映射相关，

TPerson.java：

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：

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的注解来做映射的：

Java代码  

  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：

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
时间： 2024-10-08 02:32:20

Spring3+Struts2+Hibernate4+Mybatis整合的一个maven例子的相关文章

Spring+Spring mvc+Mybatis整合教程(基于Maven)

1. 概述 1.1 Spring 轻量级:Spring是非侵入性的,基于Spring开发的应用中的对象可以不依赖于 Spring 的 API 依赖注入(DI:dependency injection.IOC) 面向切面编程(AOP:aspect oriented programming) 容器:Spring是一个容器,包含并且管理应用对象的生命周期 框架:Spring 实现了使用简单的组件配置组合成一个复杂的应用.,在Spring中可以使用XML和Java注解组合这些对象 一站式:在IOC和AO

Spring，Struts2，MyBatis，Activiti，Maven，H2，Tomcat集成（三）

1.配置h2,连接池,MyBatis Maven依赖: <!-- spring与数据库访问集成(非Hibernate) --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.1.4.RELEASE</version> </dependency> &

Struts2框架07 Struts2 + Spring + Mybatis 整合

1 导包 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 2 <m

Spring，Struts2，MyBatis，Activiti，Maven，H2，Tomcat集成（一）

1.  创建Maven Web工程 (1)       磁盘上创建Maven工程所需要的文件夹结构如下: (2)       在与src同级目录中创建pom.xml文件: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apa

Spring，Struts2，MyBatis，Activiti，Maven，H2，Tomcat集成（四）——Activiti集成

1.添加Activiti Maven依赖: <!-- ==============================activiti=========================== --> <dependency> <groupId>org.activiti</groupId> <artifactId>activiti-engine</artifactId> <version>5.17.0</version>

Struts2学习笔记--简介 第一个Struts例子

参考资料:http://blog.csdn.net/hntyzgn2010/article/details/5547753 http://chenlh.iteye.com/blog/464341 Struts是开源软件.使用Struts的目的是为了帮助我们减少在运用MVC设计模型来开发Web应用的时间.如果我们想混合使用Servlets和JSP的优点来建立可扩展的应用,struts是一个不错的选择. Struts 2是Struts的下一代产品,是在 struts 1和WebWork的技术基础上进

使用Maven搭建Struts2+Spring3+Hibernate4的整合开发环境

做了三年多的JavaEE开发了,在平时的JavaEE开发中,为了能够用最快的速度开发项目,一般都会选择使用Struts2,SpringMVC,Spring,Hibernate,MyBatis这些开源框架来开发项目,而这些框架一般不是单独使用的,经常是Struts2+Spring3+Hibernate.SpringMVC+Spring+Hibernate.SpringMVC+Spring+Mybatis这几种组合中的一种,也就是多个框架配合起来使用.今天来总结一下如何使用Maven搭建Struts

【Struts2+Hibernate3+Spring3】利用SSH整合，完成打印用户表，用户登录、注册、修改密码系统

本文视图尽可能不杂糅其它技术,尽可能少写代码,完成SSH整合.以致于各位在现有网上资料越来越天花龙凤之下,清晰地了解到传说中的三大框架SSH是怎么整合的. 一.SSH的下载 首先SSH的下载就已经是一个难点.SSH三个地方同时推出各自的新技术,已经要求利用Maven完成其版本的同步.毕竟Spring的版本,决定其能整合什么版本的Struts与Hibernate.Spring3.0.5就不能整合Hibernate4.x了.因此本文选取的SSH的版本,分别为struts 2.3.20 GA.Hibe

SSH框架手动整合——Struts2+Hibernate4+Spring4

最近遇到过一些框架方面的问题,其中有MyBatis.SSH.SpringMVC,其中SSH的一些配置有些忘的差不多了,也有一些同事问了这些问题,前几个月也整合过SSH框架,那个时候是直接拿别人的Jar包直接整合框架,好像是Struts2+Hibernate3+Spring4,这次是相关的Jar从相关的官网下的. 我整合的环境: --Win 7 64 --MySQL 5.6 --MyEclipse 2014 --Jar包:struts-2.3.28.spring-framework-4.0.4.R