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/ 

进入测试页面

 

转载于:https://www.cnblogs.com/ninetales/p/4081851.html