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.     <welcome-file-list>
7.         <welcome-file>index.jsp</welcome-file>
8.     </welcome-file-list>
9.     <!– 使用ContextLoaderListener初始化Spring容器 –>
10.     <listener>
11.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
12.     </listener>
13.     <!– 定义Struts 2的FilterDispathcer的Filter –>
14.     <filter>
15.         <filter-name>struts2</filter-name>
16.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
17.     </filter>
18.     <!– FilterDispatcher用来初始化Struts 2并且处理所有的WEB请求。 –>
19.     <filter-mapping>
20.         <filter-name>struts2</filter-name>
21.         <url-pattern>/*</url-pattern>
22.     </filter-mapping>
23. </web-app>

1. <?xml version=”1.0″ encoding=”GBK”?>
2. <!– 指定Spring配置文件的Schema信息 –>
3. <beans xmlns=”http://www.springframework.org/schema/beans”
4.     xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
5.     xmlns:aop=”http://www.springframework.org/schema/aop”
6.     xmlns:tx=”http://www.springframework.org/schema/tx”
7.     xsi:schemaLocation=”http://www.springframework.org/schema/beans
8.     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
9.     http://www.springframework.org/schema/tx
10.     http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
11.     http://www.springframework.org/schema/aop
12.     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd”>
13.     <!– 定义数据源Bean，使用C3P0数据源实现 –>
14.     <bean id=”dataSource” class=”com.mchange.v2.c3p0.ComboPooledDataSource”
15.         destroy-method=”close”>
16.         <!– 指定连接数据库的驱动 –>
17.         <property name=”driverClass” value=”com.mysql.jdbc.Driver”/>
18.         <!– 指定连接数据库的URL –>
19.         <property name=”jdbcUrl” value=”jdbc:mysql://localhost/javaee”/>
20.         <!– 指定连接数据库的用户名 –>
21.         <property name=”user” value=”root”/>
22.         <!– 指定连接数据库的密码 –>
23.         <property name=”password” value=”1120″/>
24.         <!– 指定连接数据库连接池的最大连接数 –>
25.         <property name=”maxPoolSize” value=”40″/>
26.         <!– 指定连接数据库连接池的最小连接数 –>
27.         <property name=”minPoolSize” value=”1″/>
28.         <!– 指定连接数据库连接池的初始化连接数 –>
29.         <property name=”initialPoolSize” value=”1″/>
30.         <!– 指定连接数据库连接池的连接的最大空闲时间 –>
31.         <property name=”maxIdleTime” value=”20″/>
32.     </bean>
33.     <!– 定义Hibernate的SessionFactory –>
34.     <bean id=”sessionFactory”
35.         class=”org.springframework.orm.hibernate3.LocalSessionFactoryBean”>
36.         <!– 依赖注入数据源，注入正是上面定义的dataSource –>
37.         <property name=”dataSource” ref=”dataSource”/>
38.         <!– mappingResouces属性用来列出全部映射文件 –>
39.         <property name=”mappingResources”>
40.             <list>
41.                 <!– 以下用来列出Hibernate映射文件 –>
42.                 <value>com/xqh/model/Person.hbm.xml</value>
43.             </list>
44.         </property>
45.         <!– 定义Hibernate的SessionFactory的属性 –>
46.         <property name=”hibernateProperties”>
47.             <!– 配置Hibernate属性 –>
48.             <value>
49.             hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect
50.             hibernate.hbm2ddl.auto=update
51.             hibernate.show_sql=true
52.             hibernate.format_sql=true;
53.             </value>
54.         </property>
55.     </bean>
56.     <!– 定义DAO Bean–>
57.     <bean id=”personDao” class=
58.     ”com.xqh.dao.impl.PersonDaoHibernate”>
59.         <!– 注入持久化操作所需的SessionFactory –>
60.         <property name=”sessionFactory” ref=”sessionFactory”/>
61.     </bean>
62.     <!– 配置一个业务逻辑组件 –>
63.     <bean id=”service” class=
64.     ”com.xqh.service.impl.ServiceImpl”>
65.         <!– 注入持久化访问所需的DAO组件 –>
66.         <property name=”personDao” ref=”personDao”/>
67.     </bean>
70.     <!– 配置Hibernate的局部事务管理器，使用HibernateTransactionManager类 –>
71.     <!– 该类实现PlatformTransactionManager接口，是针对Hibernate的特定实现–>
72.     <bean id=”transactionManager”
73.         class=”org.springframework.orm.hibernate3.HibernateTransactionManager”>
74.         <!– 配置HibernateTransactionManager时需要依注入SessionFactory的引用 –>
75.         <property name=”sessionFactory” ref=”sessionFactory”/>
76.     </bean>
77.     <!– 配置事务增强处理,指定事务管理器 –>
78.     <tx:advice id=”txAdvice” transaction-manager=”transactionManager”>
79.         <!– 用于配置详细的事务语义 –>
80.         <tx:attributes>
81.             <!– 所有以’get’开头的方法是read-only的 –>
82.             <tx:method name=”get*” read-only=”true”/>
83.             <!– 其他方法使用默认的事务设置 –>
84.             <tx:method name=”*”/>
85.         </tx:attributes>
86.     </tx:advice>
87.     <aop:config>
88.         <!– 配置一个切入点 –>
89.         <aop:pointcut id=”pointcut”
90.             expression=”bean(service)”/>
91.         <!– 指定在pointcut切入点应用txAdvice事务增强处理 –>
92.         <aop:advisor advice-ref=”txAdvice”
93.             pointcut-ref=”pointcut”/>
94.     </aop:config>
96. </beans>

1. <?xml version=”1.0″ encoding=”GBK”?>
2. <!– 指定Struts 2配置文件的DTD信息 –>
3. <!DOCTYPE struts PUBLIC
4.     ”-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN”
5.     ”http://struts.apache.org/dtds/struts-2.1.7.dtd”>
6. <!– Struts 2配置文件的根元素 –>
7. <struts>
8.     <!– 配置了系列常量 –>
9.     <constant name=”struts.i18n.encoding” value=”GBK”/>
10.     <constant name=”struts.devMode” value=”true”/>
11.     <package name=”xqh” extends=”struts-default”>
12.         <!– 定义处理用户请求的Action，指定该Action的实现类–>
13.         <action name=”registPro”
14.             class=”com.xqh.action.RegistAction”>
15.             <!– 为两个逻辑视图配置视图页面 –>
16.             <result name=”error”>/error.jsp</result>
17.             <result name=”success”>/welcome.jsp</result>
18.         </action>
19.         <!– 让用户直接访问该应用时列出所有视图页面 –>
20.         <action name=”*”>
21.             <result>/{1}.jsp</result>
22.         </action>
23.     </package>
24. </struts>

1. package com.xqh.action;
3. import com.opensymphony.xwork2.Action;
4. import com.xqh.model.Person;
5. import com.xqh.service.Service;
7. public class RegistAction
8.     implements Action
9. {
10.     //下面是用于封装用户请求参数的属性
11.     private Person person;
12.     //用于封装处理结果的属性
13.     private String tip;
14.     //系统所用的业务逻辑组件
15.     private Service service;
16.     //设置注入业务逻辑组件所必需的setter方法
17.     public void setService(Service service)
18.     {
19.         this.service = service;
20.     }
22.     //person属性的setter和getter方法
23.     public void setPerson(Person person)
24.     {
25.         this.person = person;
26.     }
27.     public Person getPerson()
28.     {
29.         return this.person;
30.     }
32.     //tip属性的setter和getter方法
33.     public void setTip(String tip)
34.     {
35.         this.tip = tip;
36.     }
37.     public String getTip()
38.     {
39.         return this.tip;
40.     }
42.     //处理用户请求的execute方法
43.     public String execute()
44.         throws Exception
45.     {
46.         //调用业务逻辑组件的regist方法来处理请求
47.         if (service.regist(person))
48.         {
49.             setTip(“哈哈，注册成功！”);
50.             return SUCCESS;
51.         }
52.         else
53.         {
54.             return ERROR;
55.         }
56.     }
57. }

1. package com.xqh.dao;
4. import java.util.List;
6. import com.xqh.model.Person;
8. public interface PersonDao
9. {
10.     /**
11.      * 加载Person实例
12.      * @param id 需要加载的Person实例的主键值
13.      * @return 返回加载的Person实例
14.      */
15.     Person get(Integer id);
17.     /**
18.      * 保存Person实例
19.      * @param person 需要保存的Person实例
20.      * @return 刚刚保存的Person实例的标识属性值
21.      */
22.     Integer save(Person person);
24.     /**
25.      * 修改Person实例
26.      * @param person 需要修改的Person实例
27.      */
28.     void update(Person person);
30.     /**
31.      * 删除Person实例
32.      * @param id 需要删除的Person实例的标识属性值
33.      */
34.     void delete(Integer id);
36.     /**
37.      * 删除Person实例
38.      * @param person 需要删除的Person实例
39.      */
40.     void delete(Person person);
42.     /**
43.      * 根据用户名查找Person
44.      * @param name 查询的人名
45.      * @return 指定用户名对应的全部Person
46.      */
47.     List<Person> findByName(String name);
49.     /**
50.      * 查询全部Person实例
51.      * @return 全部Person实例
52.      */
53.     public List<Person> findAllPerson();
54. }

1. package com.xqh.dao.impl;
3. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
5. import com.xqh.dao.PersonDao;
6. import com.xqh.model.Person;
8. import java.util.*;
10. public class PersonDaoHibernate
11.     extends HibernateDaoSupport implements PersonDao
12. {
13.     /**
14.      * 加载Person实例
15.      * @param id 需要加载的Person实例的标识属性值
16.      * @return 指定id对应的Person实例
17.      */
18.     public Person get(Integer id)
19.     {
20.         return getHibernateTemplate()
21.             .get(Person.class, id);
22.     }
24.     /**
25.      * 保存Person实例
26.      * @param person 需要保存的Person实例
27.      * @return 刚刚保存的Person实例的标识属性值
28.      */
29.     public Integer save(Person person)
30.     {
31.         return (Integer)getHibernateTemplate()
32.             .save(person);
33.     }
35.     /**
36.      * 修改Person实例
37.      * @param person 需要修改的Person实例
38.      */
39.     public void update(Person person)
40.     {
41.         getHibernateTemplate().update(person);
42.     }
44.     /**
45.      * 删除Person实例
46.      * @param id 需要删除的Person实例的标识属性值
47.      */
48.     public void delete(Integer id)
49.     {
50.         getHibernateTemplate().delete(get(id));
51.     }
53.     /**
54.      * 删除Person实例
55.      * @param person 需要删除的Person实例
56.      */
57.     public void delete(Person person)
58.     {
59.         getHibernateTemplate().delete(person);
60.     }
62.     /**
63.      * 根据用户名查找Person
64.      * @param name 查询的人名
65.      * @return 指定用户名对应的全部Person
66.      */
67.     @SuppressWarnings(“unchecked”)
68.     public List<Person> findByName(String name)
69.     {
70.         return (List<Person>)getHibernateTemplate()
71.             .find(“from Person p where p.name like ?” , name);
72.     }
74.     /**
75.      * 查询全部Person实例
76.      * @return 全部Person实例
77.      */
78.     @SuppressWarnings(“unchecked”)
79.     public List<Person> findAllPerson()
80.     {
81.         return (List<Person>)getHibernateTemplate()
82.             .find(“from Person”);
83.     }
84. }

1. package com.xqh.model;
3. public class Person
4. {
5.     private Integer id;
6.     private String name;
7.     private int age;
9.     //无参数的构造器
10.     public Person()
11.     {
12.     }
13.     //初始化全部属性的构造器
14.     public Person(String name , int age)
15.     {
16.         this.name = name;
17.         this.age = age;
18.     }
20.     //id属性的setter和getter方法
21.     public void setId(Integer id)
22.     {
23.         this.id = id;
24.     }
25.     public Integer getId()
26.     {
27.         return this.id;
28.     }
30.     //name属性的setter和getter方法
31.     public void setName(String name)
32.     {
33.         this.name = name;
34.     }
35.     public String getName()
36.     {
37.         return this.name;
38.     }   //age属性的setter和getter方法
39.     public void setAge(int age)
40.     {
41.         this.age = age;
42.     }
43.     public int getAge()
44.     {
45.         return this.age;
46.     }
47. }

1. <?xml version=”1.0″ encoding=”GBK”?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3.     ”-//Hibernate/Hibernate Mapping DTD 3.0//EN”
4.     ”http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd”>
5. <hibernate-mapping package=”com.xqh.model”>
6.     <class name=”Person” table=”tb_person”>
7.         <!– 映射标识属性 –>
8.         <id name=”id” column=”Id”
9.             type=”int”>
10.             <!– 指定主键生成器策略 –>
11.             <generator class=”increment”/>
12.         </id>
13.         <!– 映射普通属性 –>
14.         <property name=”name” type=”string”/>
15.         <property name=”age” type=”int”/>
16.     </class>
17. </hibernate-mapping>

1. package com.xqh.service;
3. import com.xqh.model.Person;
5. public interface Service
6. {
7.     //注册用户
8.     boolean regist(Person person);
9. }

1. package com.xqh.service.impl;
3. import com.xqh.dao.PersonDao;
4. import com.xqh.model.Person;
5. import com.xqh.service.Service;
7. public class ServiceImpl
8.     implements Service
9. {
10.     private PersonDao personDao;
11.     //依赖注入DAO组件所需的setter方法
12.     public void setPersonDao(PersonDao personDao)
13.     {
14.         this.personDao = personDao;
15.     }
16.     //注册用户
17.     public boolean regist(Person person)
18.     {
19.         //调用DAO组件的方法来实现业务逻辑
20.         int result = personDao.save(person);
21.         if (result > 0)
22.         {
23.             return true;
24.         }
25.         return false;
26.     }
27. }

本文链接地址: Struts2+Hibernate+Spring 整合示例http://www.hongyanliren.com/2014m11/19220.html

相关文章

• JavaSocket学习—NIO实现非阻塞的通信 以及几篇好文章 好好
• java多线程互斥实战-模拟串口资源互斥
• Java总结篇系列：Java多线程（一）
• Java多线程学习（总结很详细！！！）
• [App Inventor] Web客戶端元件 POST 傳值的使用方式
• 访问图灵机器人——用App Inventor开发web应用（案例）
• APPInventor网络数据库浏览器（TinyWebDB查询API）
• java.net.BindException: Address already in use: JVM_Bind解决方案