struts-2.3.16.3+hibernate-3.2.5+spring-2.5全注解配置

1、新建项目  结构如下:

2、导入相关的jar

3、整合步骤先整合 Spring2.5+Hibernate3.3 成功后在整合 Struts2 这样就不容易报错,而且 报错误后也便于找出问题。
applicationContext.xml
spring配置文件模版可以到 spring自带的一些例子中进行拷贝。

 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:tx="http://www.springframework.org/schema/tx"
 4     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
 5     xmlns:jee="http://www.springframework.org/schema/jee"
 6     xsi:schemaLocation="
 7             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
 8             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
 9             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
10             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
11             http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">
12
13     <!-- 加载数据库属性配置文件 -->
14     <context:property-placeholder location="classpath:db.properties" />
15     <!-- 扫描包的范围 -->
16     <context:component-scan base-package="demo.loading.*" />
17
18     <!-- 数据库连接池c3p0配置 -->
19     <!-- destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用 -->
20     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
21         destroy-method="close">
22         <property name="driverClass" value="${driverClassName}"></property>
23         <property name="jdbcUrl" value="${url}"></property>
24         <property name="user" value="${username}"></property>
25         <property name="password" value="${password}"></property>
26
27         <!-- 连接池中的最大连接数 -->
28         <property name="maxPoolSize" value="${maxPoolSize}" />
29
30         <!-- 连接池中的最小连接数 -->
31         <property name="minPoolSize" value="${minPoolSize}" />
32
33         <!-- 初始化连接池中的 连接数,取值 在 minPoolSize 和 maxPoolSize 之间,default:3 -->
34         <property name="initialPoolSize" value="${initialPoolSize}" />
35
36         <!-- 最大空闲时间,60s内该连接没有被使用则被丢弃,若为0 永不丢弃.default:0 -->
37         <property name="maxIdleTime" value="${maxIdleTime}" />
38
39         <!-- 当连接数不够时,每次同时创建多少个连接 -->
40         <property name="acquireIncrement" value="${acquireIncrement}" />
41
42         <!-- 每60s检查连接池中的所有空间连接,如果没有被使用,就被放弃, default:0 -->
43         <property name="idleConnectionTestPeriod" value="${idleConnectionTestPeriod}" />
44     </bean>
45
46     <!-- 将Hibernate中的事物交给Spring进行接管 -->
47     <bean id="sessionFactory"
48         class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
49         <!-- 指定sessiongFactory中的数据源 -->
50         <property name="dataSource" ref="dataSource"></property>
51         <!-- 指定hibernate的属性 -->
52         <property name="hibernateProperties">
53             <props>
54                 <!-- hibernate使用的 方言 -->
55                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
56                 <!-- 根据实体的映射文件生成表结构 -->
57                 <prop key="hibernate.hbm2ddl.auto">update</prop>
58                 <!-- 是否打印出sql语句 -->
59                 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
60                 <!-- 格式化sql -->
61                 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
62             </props>
63         </property>
64         <!-- 配置自动扫描实体类 -->
65         <property name="packagesToScan">
66             <list>
67                 <value>demo.loading.*</value>
68             </list>
69         </property>
70     </bean>
71
72     <!-- 配置使用基于Hibernate的事务管理器 -->
73     <bean id="txManager"
74         class="org.springframework.orm.hibernate3.HibernateTransactionManager">
75         <!-- spring需要通过sessionFactory来开启事务 -->
76         <property name="sessionFactory" ref="sessionFactory"></property>
77     </bean>
78
79     <!--Spring中的事物配置声明.1 基于xml 配置方式 2.基于注解来声明那些类 -->
80     <tx:annotation-driven proxy-target-class="true" transaction-manager="txManager" />
81 </beans>

db.properties 数据库相关配置的信息

demo.loading.entity 新建实体User

 1 package demo.loading.entity;
 2
 3 import java.util.Date;
 4
 5 import javax.persistence.Column;
 6 import javax.persistence.Entity;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.GenerationType;
 9 import javax.persistence.Id;
10 import javax.persistence.Table;
11 import javax.persistence.Temporal;
12 import javax.persistence.TemporalType;
13
14 @Entity        //注释指名这是一个实体Bean
15 @Table(name = "user")        //为实体Bean指定对应数据库表
16 public class User {
17     private Integer id;
18     private String username;
19     private String password;
20     private String address;
21     private String phoneNumber;
22     private Date createTime;
23     private Date updateTime;
24
25     @Id        //注解声明了该实体Bean的标识属性
26     @GeneratedValue(strategy = GenerationType.AUTO)        //注解可以定义该标识符的生成策略。自动增长
27     @Column(name = "ID", length = 20)        //
28     public Integer getId() {
29         return id;
30     }
31
32     public void setId(Integer id) {
33         this.id = id;
34     }
35
36     public String getUsername() {
37         return username;
38     }
39
40     public void setUsername(String username) {
41         this.username = username;
42     }
43
44     public String getPassword() {
45         return password;
46     }
47
48     public void setPassword(String password) {
49         this.password = password;
50     }
51
52     public String getAddress() {
53         return address;
54     }
55
56     public void setAddress(String address) {
57         this.address = address;
58     }
59
60     public String getPhoneNumber() {
61         return phoneNumber;
62     }
63
64     public void setPhoneNumber(String phoneNumber) {
65         this.phoneNumber = phoneNumber;
66     }
67
68     @Temporal(TemporalType.TIMESTAMP)
69     public Date getCreateTime() {
70         return createTime;
71     }
72
73     public void setCreateTime(Date createTime) {
74         this.createTime = createTime;
75     }
76
77     @Temporal(TemporalType.TIMESTAMP)
78     public Date getUpdateTime() {
79         return updateTime;
80     }
81
82     public void setUpdateTime(Date updateTime) {
83         this.updateTime = updateTime;
84     }
85
86 }

demo.loading.common.db   新建公用的接口IBaseDao

  1 package demo.loading.common.db;
  2
  3 import java.io.Serializable;
  4 import java.util.List;
  5
  6 /**
  7  * DAO 基类接口
  8  * @param <T> T pojo类型
  9  * @param <ID> ID类型
 10  */
 11 public interface IBaseDao<T, ID extends Serializable> {
 12     /**
 13      * 获得持久化对象的类型
 14      * @return
 15      */
 16     public abstract Class<T> getPersistentClass();
 17
 18     /**
 19      * 保存
 20      * @param entity 实体类
 21      */
 22     public abstract void save(T entity);
 23
 24     /**
 25      * 删除
 26      * @param entity 实体类
 27      */
 28     public abstract void delete(T entity);
 29
 30     /**
 31      * 与findByProperty相似,当properyName == value 时把相应的记录删除
 32      */
 33     public abstract void deleteByProperty(String propertyName, Object value);
 34
 35     /**
 36      * 更新
 37      * @param entity
 38      */
 39     public abstract void update(T entity);
 40
 41     /**
 42      * 保存或者更新
 43      * @param entity
 44      */
 45     public abstract void saveOrUpdate(T entity);
 46
 47     /**
 48      * 查询所有
 49      */
 50     public abstract List<T> findAll();
 51
 52     /**
 53      * 查找所有,并分页
 54      * @param page 要返回的页数
 55      * @param pageSize 没有记录数
 56      * @return
 57      */
 58     public abstract List<T> findAll(int page, int pageSize);
 59
 60     /**
 61      * 根据id查找
 62      * @param id
 63      * @return
 64      */
 65     public abstract T findById(ID id);
 66
 67     public abstract List<T> findByExample(T entity);
 68
 69     /**
 70      * 通过属性查找
 71      * @param propertyName 属性名称
 72      * @param value 属性的值
 73      * @return
 74      */
 75     public abstract List<T> findByProperty(String propertyName, Object value);
 76
 77     /**
 78      * 通过多个属性查找
 79      * @param propertyNames 属性名称数组
 80      * @param values  属性值数组
 81      * @return
 82      */
 83     public abstract List<T> findByPropertys(String[] propertyNames, Object[] values);
 84
 85     /**
 86      * 通过多个属性查找,并分页, 属性名称数组和属性值数组的序列要对应
 87      * @param propertyNames 属性名称数组
 88      * @param values 属性值数组
 89      * @param page 页码
 90      * @param pageSize 每页内容条数
 91      * @return
 92      */
 93     public List<T> findByPropertys(String[] propertyNames, Object[] values, int page, int pageSize);
 94
 95     /**
 96      * 通过属性查找,并分页, 属性名称数组和属性值数组的序列要对应
 97      * @param propertyNames 属性名称
 98      * @param values 属性值
 99      * @param page 页码
100      * @param pageSize 每页内容条数
101      * @return
102      */
103     public List<T> findByProperty(String propertyName, Object value, int page, int pageSize);
104
105     /**
106      * 查找并通过某一属性排序
107      * @param property 排序依据的顺序
108      * @param isSequence 是否顺序排序
109      */
110     public List<T> findAndOrderByProperty(int firstResult, int fetchSize, String propertyName, boolean isSequence);
111
112     /**
113      * 查找并通过某一属性排序
114      * @param property  排序依据的顺序
115      * @param isSequence 是否顺序排序
116      */
117     public List<T> findAllAndOrderByProperty(String propertyName, boolean isSequence);
118
119     /**
120      * 统计所有记录的总数
121      * @return 总数
122      */
123     public int totalPage();
124
125     /**
126      * 统计数据库中当propertyName=value时的记录总数
127      * @param propertyName
128      * @param value
129      * @return
130      */
131     public int totalPageByProperty(String propertyName, Object value);
132
133     /**
134      * 统计数据库中当多个propertyName=value时的记录总数
135      * @param propertyNames
136      * @param values
137      * @return
138      */
139     public int totalPageByPropertys(String[] propertyNames, Object[] values);
140
141 }

demo.loading.common.db   新建IBaseDao的实现类BaseDao

  1 package demo.loading.common.db;
  2
  3 import java.io.Serializable;
  4 import java.lang.reflect.ParameterizedType;
  5 import java.util.List;
  6
  7 import javax.annotation.Resource;
  8
  9 import org.hibernate.Query;
 10 import org.hibernate.SessionFactory;
 11 import org.springframework.beans.factory.annotation.Autowired;
 12 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 13 import org.springframework.stereotype.Repository;
 14
 15
 16 /**
 17  * DAO的Hibernate基类
 18  * @param <T> pojo的类型
 19  * @para <ID> id的类型
 20  */
 21 @SuppressWarnings("all")
 22 public class BaseDao<T, ID extends Serializable> extends HibernateDaoSupport implements IBaseDao<T, ID> {
 23
 24     @Resource    //把sessionfactory注入baseDao
 25     public void setMySessionFactory(SessionFactory sf) {
 26         super.setSessionFactory(sf);
 27     }
 28
 29     private Class<T> persistentClass;
 30
 31     public BaseDao() {
 32         // 获取持久化对象的类型
 33         this.persistentClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
 34     }
 35
 36     /**
 37      * 获得持久化对象的类型
 38      * @return
 39      */
 40     public Class<T> getPersistentClass() {
 41         return persistentClass;
 42     }
 43
 44     /**
 45      * 保存
 46      * @param entity 实体类
 47      */
 48     public void save(T entity) {
 49         this.getHibernateTemplate().save(entity);
 50     }
 51
 52     /**
 53      * 删除
 54      * @param entity  实体类
 55      */
 56     public void delete(T entity) {
 57         this.getHibernateTemplate().delete(entity);
 58     }
 59
 60     /**
 61      * 与findByProperty相似,当properyName == value 时把相应的记录删除
 62      */
 63     public void deleteByProperty(String propertyName, Object value) {
 64         String queryString = "delete from " + getPersistentClass().getName() + " as model where model." + propertyName + "= ?";
 65         Query query = this.getSession().createQuery(queryString);
 66         query.setParameter(0, value);
 67         query.executeUpdate();
 68     }
 69
 70     /**
 71      * 更新
 72      * @param entity
 73      */
 74     public void update(T entity) {
 75         this.getHibernateTemplate().update(entity);
 76     }
 77
 78     /**
 79      * 保存或者更新
 80      * @param entity
 81      */
 82     public void saveOrUpdate(T entity) {
 83         this.getHibernateTemplate().saveOrUpdate(entity);
 84     }
 85
 86     /**
 87      * 查询所有
 88      *
 89      */
 90     public List<T> findAll() {
 91         return this.getHibernateTemplate().find("from " + getPersistentClass().getName());
 92     }
 93
 94     /**
 95      * 查找所有,并分页
 96      * @param page 要返回的页数
 97      * @param pageSize 没有记录数
 98      * @return
 99      */
100
101     public List<T> findAll(int page, int pageSize) {
102         String queryString = "from " + getPersistentClass().getName();
103         Query query = this.getSession().createQuery(queryString);
104         int firstResult = (page - 1) * pageSize;
105         query.setFirstResult(firstResult);
106         query.setMaxResults(pageSize);
107         return query.list();
108     }
109
110     /**
111      * 通过id查找
112      * @param id
113      * @return
114      */
115     public T findById(ID id) {
116         return (T) this.getHibernateTemplate().get(getPersistentClass(), id);
117     }
118
119     /**
120      * find By Example
121      * @param entity
122      * @return
123      */
124     public List<T> findByExample(T entity) {
125         return this.getHibernateTemplate().findByExample(entity);
126     }
127
128     /**
129      * 通过属性查找
130      * @param propertyName  属性名称
131      * @param value  属性的值
132      * @return
133      */
134     public List<T> findByProperty(String propertyName, Object value) {
135         String hql = "from " + getPersistentClass().getName() + " as model where model." + propertyName + "= ?";
136         return this.getHibernateTemplate().find(hql, value);
137
138     }
139
140     /**
141      * 通过多个属性查找
142      * @param propertyNames 属性名称数组
143      * @param values 属性值数组
144      * @return
145      */
146     public List<T> findByPropertys(String[] propertyNames, Object[] values) {
147         StringBuffer sb = new StringBuffer();
148         sb.append("from " + getPersistentClass().getName());
149         sb.append(" as model where ");
150         for (int i = 0; i < propertyNames.length; i++) {
151             if (i != 0)
152                 sb.append(" and");
153             sb.append(" model.");
154             sb.append(propertyNames[i]);
155             sb.append("=");
156             sb.append("? ");
157         }
158         String hql = sb.toString();
159         return this.getHibernateTemplate().find(hql, values);
160     }
161
162     /**
163      * 通过多个属性查找,并分页, 属性名称数组和属性值数组的序列要对应
164      * @param propertyNames 属性名称数组
165      * @param values  属性值数组
166      * @param page 页码
167      * @param pageSize 每页内容条数
168      * @return
169      */
170     public List<T> findByPropertys(String[] propertyNames, Object[] values, int page, int pageSize) {
171
172         StringBuffer strBuffer = new StringBuffer();
173         strBuffer.append("from " + getPersistentClass().getName());
174         strBuffer.append(" as model where ");
175         for (int i = 0; i < propertyNames.length; i++) {
176             if (i != 0)
177                 strBuffer.append(" and");
178             strBuffer.append(" model.");
179             strBuffer.append(propertyNames[i]);
180             strBuffer.append("=");
181             strBuffer.append("? ");
182         }
183         String queryString = strBuffer.toString();
184
185         int firstResult = (page - 1) * pageSize;
186
187         Query query = this.getSession().createQuery(queryString);
188         query.setFirstResult(firstResult);
189         query.setMaxResults(pageSize);
190         for (int i = 0; i < values.length; i++) {
191             query.setParameter(i, values[i]);
192         }
193
194         return query.list();
195     }
196
197     /**
198      * 通过属性查找,并分页, 属性名称数组和属性值数组的序列要对应
199      * @param propertyNames 属性名称
200      * @param values 属性值
201      * @param page 页码
202      * @param pageSize 每页内容条数
203      * @return
204      */
205     public List<T> findByProperty(String propertyName, Object value, int page, int pageSize) {
206         return this.findByPropertys(new String[] { propertyName }, new Object[] { value }, page, pageSize);
207     }
208
209     /**
210      * 查找并通过某一属性排序
211      * @param property 排序依据的顺序
212      * @param isSequence 是否顺序排序
213      */
214     public List<T> findAndOrderByProperty(int firstResult, int fetchSize, String propertyName, boolean isSequence) {
215         String queryString = "from " + getPersistentClass().getName() + " as model order by model." + propertyName;
216         if (isSequence == false) {
217             queryString = queryString + " DESC";
218         }
219
220         Query queryObject = getSession().createQuery(queryString);
221         queryObject.setFirstResult(firstResult);
222         queryObject.setMaxResults(fetchSize);
223         return queryObject.list();
224
225     }
226
227     /**
228      * 查找并通过某一属性排序
229      * @param property 排序依据的顺序
230      * @param isSequence 是否顺序排序
231      */
232     public List<T> findAllAndOrderByProperty(String propertyName, boolean isSequence) {
233         String queryString = "from " + getPersistentClass().getName() + " as model order by model." + propertyName;
234         if (isSequence == false) {
235             queryString = queryString + " DESC";
236         }
237
238         Query queryObject = getSession().createQuery(queryString);
239         return queryObject.list();
240     }
241
242     /**
243      * 统计所有记录的总数
244      * @return 总数
245      */
246     public int totalPage() {
247         String queryString = "select count(*) from " + getPersistentClass().getName();
248         Query query = this.getSession().createQuery(queryString);
249         List list = query.list();
250         Long result = (Long) list.get(0);
251         return result.intValue();
252     }
253
254     /**
255      * 统计数据库中当propertyName=value时的记录总数
256      * @param propertyName
257      * @param value
258      * @return
259      */
260     public int totalPageByProperty(String propertyName, Object value) {
261         String[] propertyNames = new String[] { propertyName };
262         Object[] values = new Object[] { value };
263         return this.totalPageByPropertys(propertyNames, values);
264     }
265
266     /**
267      * 统计数据库中当多个propertyName=value时的记录总数
268      * @param propertyNames
269      * @param values
270      * @return
271      */
272     public int totalPageByPropertys(String[] propertyNames, Object[] values) {
273         StringBuffer strBuffer = new StringBuffer();
274         strBuffer.append("select count(*) from " + getPersistentClass().getName());
275         strBuffer.append(" as model where ");
276         for (int i = 0; i < propertyNames.length; i++) {
277             if (i != 0)
278                 strBuffer.append(" and");
279             strBuffer.append(" model.");
280             strBuffer.append(propertyNames[i]);
281             strBuffer.append("=");
282             strBuffer.append("? ");
283         }
284
285         String queryString = strBuffer.toString();
286         Query query = this.getSession().createQuery(queryString);
287         for (int i = 0; i < values.length; i++) {
288             query.setParameter(i, values[i]);
289         }
290
291         List list = query.list();
292         Long result = (Long) list.get(0);
293         return result.intValue();
294     }
295
296 }

简单的实现一个注册登录的方法
demo.loading.dao.idao  新建接口IUserDao

 1 package demo.loading.dao.idao;
 2
 3 import java.util.List;
 4
 5 import demo.loading.common.db.IBaseDao;
 6 import demo.loading.entity.User;
 7
 8
 9 public interface IUserDao extends IBaseDao<User, String> {
10
11     public List<User> login(String[] params, Object[] values);
12
13 }

demo.loading.dao.imp 新建接口实现类UserDao

 1 package demo.loading.dao.imp;
 2
 3 import java.util.List;
 4
 5 import org.springframework.stereotype.Repository;
 6
 7 import demo.loading.common.db.BaseDao;
 8 import demo.loading.dao.idao.IUserDao;
 9 import demo.loading.entity.User;
10
11 @Repository("iUserDao")
12 //@Repository它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。
13 //为了让 Spring 能够扫描类路径中的类并识别出 @Repository 注解,
14 //需要在 XML 配置文件中启用Bean 的自动扫描功能
15 public class UserDaoImpl extends BaseDao<User, String> implements IUserDao {
16
17     public List<User> login(String[] params, Object[] values) {
18         List<User> list = super.findByPropertys(params, values);
19         return list;
20     }
21
22 }

demo.loading.test 新建 UserDaoImplTest 测试类

 1 package demo.loading.test;
 2
 3 import java.util.List;
 4
 5 import org.junit.Test;
 6 import org.springframework.context.ApplicationContext;
 7 import org.springframework.context.support.ClassPathXmlApplicationContext;
 8
 9 import demo.loading.dao.idao.IUserDao;
10 import demo.loading.entity.User;
11
12 public class UserDaoImplTest {
13     private static IUserDao userDao;
14     static{
15         String config = "applicationContext.xml";
16         ApplicationContext ac = new ClassPathXmlApplicationContext(config);
17         userDao = (IUserDao) ac.getBean("iUserDao");
18     }
19
20     @Test
21     public void testLogin() {
22         String[] params = new String[] { "username", "password" };
23         Object[] values = new Object[] { "1009", "000000" };
24         List<User> users = userDao.findByPropertys(params, values);
25         for(User user : users){
26             System.out.println(user.getUsername());
27         }
28     }
29
30 }

demo.loading.service.iservice 新建IUserService接口

1 package demo.loading.service.iservice;
2
3 import java.util.List;
4
5 import demo.loading.entity.User;
6
7 public interface IUserService {
8     public List<User> login(String[] params, Object[] values);
9 }

demo.loading.service.impl 新建IUserService的实现类

 1 package demo.loading.service.impl;
 2
 3 import java.util.List;
 4
 5 import javax.annotation.Resource;
 6
 7 import org.springframework.stereotype.Repository;
 8 import org.springframework.stereotype.Service;
 9 import org.springframework.transaction.annotation.Transactional;
10
11 import demo.loading.dao.idao.IUserDao;
12 import demo.loading.entity.User;
13 import demo.loading.service.iservice.IUserService;
14
15 @Service
16 //@Component 是一个泛化的概念,仅仅表示一个组件 (Bean) ,可以作用在任何层次。
17 //@Service 通常作用在业务层,但是目前该功能与 @Component 相同。
18 @Transactional
19 //配置事务 默认的增删改查 @Transactional(readOnly=true) 查询使用 只读
20 @Repository("iUserService")
21 public class UserServiceImpl implements IUserService {
22
23     @Resource IUserDao userDao;        //注入IUserDao
24
25     public List<User> login(String[] params, Object[] values) {
26         return userDao.login(params, values);
27     }
28 }

demo.loading.test 新建UserServiceImplTest测试类

package demo.loading.test;

import java.util.List;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import demo.loading.entity.User;
import demo.loading.service.iservice.IUserService;

public class UserServiceImplTest {

    public static  IUserService userService;
    static {
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        userService = (IUserService) ac.getBean("iUserService");
    }
    @Test
    public void testLogin() {
        String[] params = new String[] { "username", "password" };
        Object[] values = new Object[] { "1009", "000000" };
        List<User> users = userService.login(params, values);
        for(User user : users){
            System.out.println(user.getUsername());
        }
    }

}

------------------------------------------------------------------------------

hibernate+spring 整合完毕

------------------------------------------------------------------------------

整合struts2

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     <display-name></display-name>
 7
 8     <welcome-file-list>
 9         <welcome-file>login.jsp</welcome-file>
10     </welcome-file-list>
11
12     <!-- 指定spring的配置文件,默认从web根目录寻找配置文件,我们可以通过spring提供的classpath:前缀指定从类路径下寻找 -->
13     <context-param>
14         <param-name>contextConfigLocation</param-name>
15         <!-- 如果有多个文件 使用 "," 分开 -->
16         <param-value>classpath:applicationContext.xml</param-value>
17     </context-param>
18
19     <listener>
20         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
21     </listener>
22
23     <!-- 对spring容器进行实例化 -->
24     <listener>
25         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
26     </listener>
27
28      <!--配置Struts2的过滤器 -->
29     <filter>
30         <filter-name>struts2filter</filter-name>
31         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
32     </filter>
33
34     <filter-mapping>
35         <filter-name>struts2filter</filter-name>
36         <url-pattern>/*</url-pattern>
37     </filter-mapping>
38
39 </web-app>

实现一个简单的登录

demo.loading.action 新建LoginAction

 1 package demo.loading.action;
 2
 3 import java.util.List;
 4
 5 import javax.annotation.Resource;
 6 import javax.servlet.http.HttpServletRequest;
 7
 8 import org.apache.struts2.interceptor.ServletRequestAware;
 9 import org.springframework.stereotype.Controller;
10
11 import demo.loading.entity.User;
12 import demo.loading.service.iservice.IUserService;
13
14 @Controller        //注入action
15 public class LoginAction implements ServletRequestAware {
16     @Resource IUserService userService;        //注入IUserService
17     private HttpServletRequest request;
18
19     private User user;
20     private List<User> users;
21
22     public String login() {
23         String username = request.getParameter("username");
24         String password = request.getParameter("password");
25         String[] params = new String[] { "username", "password" };
26         Object[] values = new Object[] { username, password };
27         users = userService.login(params, values);
28         if (users.isEmpty()) {
29             return "fail";
30         } else {
31             return "success";
32         }
33     }
34
35     public void setServletRequest(HttpServletRequest request) {
36         this.request = request;
37     }
38
39     public User getUser() {
40         return user;
41     }
42
43     public void setUser(User user) {
44         this.user = user;
45     }
46
47     public List<User> getUsers() {
48         return users;
49     }
50
51     public void setUsers(List<User> users) {
52         this.users = users;
53     }
54
55 }

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     <!-- 把它设置为开发模式,发布时要设置为false -->
 7     <constant name="struts.devMode" value="true" />
 8     <!-- 自动动态方法的调用,使用这个设置后可以这样调用:action!method -->
 9     <constant name="struts.enable.DynamicMethodInvocation" value="true" />
10     <!-- 设置struts的对象工厂,由spring进行创建 (更换Struts2的工厂) -->
11     <constant name="struts.objectFactory" value="spring" />
12
13     <package name="base-package" extends="struts-default">
14         <action name="loginAction" class="loginAction">
15             <result name="success">success.jsp</result>
16             <result name="fail">fail.jsp</result>
17         </action>
18     </package>
19 </struts>

------------------------------------------------------------------------------

整合完毕

------------------------------------------------------------------------------

login.jsp

 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 <%
 3 String path = request.getContextPath();
 4 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 5 %>
 6
 7 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 8 <html>
 9   <head>
10     <base href="<%=basePath%>">
11
12     <title>登陆</title>
13
14   </head>
15
16   <body>
17    <form action="loginAction!login.action" method="post">
18        用户名:<input type="text" name="username"><br>
19        密码:<input type="password" name="password"><br>
20        <input type="submit" value="提交">
21    </form>
22   </body>
23 </html>

success.jsp

 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 <%
 3 String path = request.getContextPath();
 4 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 5 %>
 6
 7 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 8 <html>
 9   <head>
10     <base href="<%=basePath%>">
11
12     <title>登录成功</title>
13   </head>
14
15   <body>
16     <span>登录成功</span>
17   </body>
18 </html>

fail.jsp

 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 <%
 3 String path = request.getContextPath();
 4 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 5 %>
 6
 7 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 8 <html>
 9   <head>
10     <base href="<%=basePath%>">
11
12     <title>登录失败</title>
13
14   </head>
15
16   <body>
17     登录失败
18   </body>
19 </html>

http://localhost:8080/demo/

进入测试页面

时间: 2024-10-21 02:39:32

struts-2.3.16.3+hibernate-3.2.5+spring-2.5全注解配置的相关文章

S2SH框架集成详解(Struts 2.3.16 + Spring 3.2.6 + Hibernate 3.6.10)

近期集成了一次较新版本的s2sh,出现了不少问题,网上资料也是良莠不齐,有的甚至就是扯淡,简单的把jar包扔进去就以为是集成成功了,在这里整理一下详细的步骤,若哪位有什么不同看法,可以留言,欢迎批评改正. 首先说下集成的环境,Eclipse 4.4,Tomcat 7.0.54,Struts2.3.16,Hibernate3.6.10,Spring3.2.6 相关JAR包已上传至百度云:http://pan.baidu.com/s/1pJluA5l 搭建Struts2框架 1. 创建Java We

【SSH网上商城项目实战16】Hibernate的二级缓存处理首页的热门显示

网上商城首页都有热门商品,那么这些商品的点击率是很高的,当用户点击某个热门商品后需要进入商品的详细信息页面,就像淘宝里面那样.那么每次点击都要去后台查询一下该商品的详细信息,就会发送相应的sql语句,每次刷新一下详细页面也会发sql语句,这样的话,性能肯定会受到很大的影响.那么使用Hibernate的二级缓存就可以解决这个问题. 有些人可能会想,我们可以使用重定向,这样的话,在用户第一次访问的时候把信息查出来放到session中,以后每次用户刷新就可以去session中拿了,这样就不用去数据库中

spring4.06 hibernate4.31 struts2.3.16 全注解MAVEN环境搭建

最近使用目录最新版本的SPRING.HIBERNATE.STRUTS使用MAVEN搭建了一个全注解的环境.记录一下 POM文件: <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 htt

Hibernate中用注解配置一对多双向关联和多对一单向关联

Hibernate中用注解配置一对多双向关联和多对一单向关联 Hibernate提供了Hibernate Annotations扩展包,使用注解完成映射.在Hibernate3.3之前,需单独下载注解开发包 配置持久化类 配置关联关系 下面我们先从多对一单向关联关系讲起,多对一单向关联就是在多的一方植入一的一方的主键作为外键,下面我们先进行初始配置, 在配置的过程中我们会遇到一个问题  就是无论用load还是get都不会出现延迟加载,那么我们应该如何设置为要延迟加载,这样做的好处是可以在用的时候

Java基础103 Hibernate技术连接MySQL数据和Oracle数据库的配置方法

1.Hibernate技术连接MySQL数据 User.hbm.xml 配置文件 <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernat

【Hibernate步步为营】--核心对象+持久对象全析(二)

上篇文章讨论了Hibernate的核心对象,在开发过程中经常用到的有JTA.SessionFactory.Session.JDBC,其中SessionFactory可以看做数据库的镜像,使用它能够创建Session对象,JTA用来管理事务,在对象模型修改后同步到数据库中,另外还有Hibernate作为持久层它封装了持久层的转化过程,下面着重讨论持久对象的转换过程. 一.状态解析 Hibernate的持久对象主要分为三个状态,Transient.Persistent.Detached,其中Tran

spring+hibernate+Struts2 整合(全注解及注意事项)

最近帮同学做毕设,一个物流管理系统,一个点餐系统,用注解开发起来还是很快的,就是刚开始搭环境费了点事,今天把物流管理系统的一部分跟环境都贴出来,有什么不足的,请大神不吝赐教. 1.结构如下 2.jar包如下 3.首先是spring.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"

atitit.spring hibernate的事务机制 spring不能保存对象的解决

atitit.spring hibernate的事务机制 spring不能保存对象的解决 sessionFactory.openSession() 不能. . log黑头马sql语言.. sessionFactory.getCurrentSession().update(user); 中间走ok兰..log黑头也有累.. 在Spring中使用Hibernate.假设我们配置了TransactionManager.那么我们就不应该调用SessionFactory的openSession()来获得S

Spring MVC注解配置结合Hibernate的入门教程及其代码实例

原文:Spring MVC注解配置结合Hibernate的入门教程及其代码实例 源代码下载地址:http://www.zuidaima.com/share/1787210045197312.htm 1.概述 本文旨在搭建Spring MVC+Hibernate开发框架,通过一个简单的demo讲解Spring MVC的相关配置文件,以及通过注解方式实现简单功能. 开发框架:Spring+Spring MVC+Hibernate(Spring所用的版本为3.0.5). 数据库:MySQL(数据库名称