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/
进入测试页面