首页 > 代码库 > struts-2.3.16.3+hibernate-3.2.5+spring-2.5全注解配置
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.xsd10 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd11 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="http://www.mamicode.com/${driverClassName}"></property>23 <property name="jdbcUrl" value="http://www.mamicode.com/${url}"></property>24 <property name="user" value="http://www.mamicode.com/${username}"></property>25 <property name="password" value="http://www.mamicode.com/${password}"></property>26 27 <!-- 连接池中的最大连接数 -->28 <property name="maxPoolSize" value="http://www.mamicode.com/${maxPoolSize}" />29 30 <!-- 连接池中的最小连接数 -->31 <property name="minPoolSize" value="http://www.mamicode.com/${minPoolSize}" />32 33 <!-- 初始化连接池中的 连接数,取值 在 minPoolSize 和 maxPoolSize 之间,default:3 -->34 <property name="initialPoolSize" value="http://www.mamicode.com/${initialPoolSize}" />35 36 <!-- 最大空闲时间,60s内该连接没有被使用则被丢弃，若为0 永不丢弃.default:0 -->37 <property name="maxIdleTime" value="http://www.mamicode.com/${maxIdleTime}" />38 39 <!-- 当连接数不够时,每次同时创建多少个连接 -->40 <property name="acquireIncrement" value="http://www.mamicode.com/${acquireIncrement}" />41 42 <!-- 每60s检查连接池中的所有空间连接,如果没有被使用,就被放弃, default:0 -->43 <property name="idleConnectionTestPeriod" value="http://www.mamicode.com/${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 //注释指名这是一个实体Bean15 @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 * @return102 */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 propertyName128 * @param value129 * @return130 */131 public int totalPageByProperty(String propertyName, Object value);132 133 /**134 * 统计数据库中当多个propertyName=value时的记录总数135 * @param propertyNames136 * @param values137 * @return138 */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 id113 * @return114 */115 public T findById(ID id) {116 return (T) this.getHibernateTemplate().get(getPersistentClass(), id);117 }118 119 /**120 * find By Example121 * @param entity122 * @return123 */124 public List<T> findByExample(T entity) {125 return this.getHibernateTemplate().findByExample(entity);126 }127 128 /**129 * 通过属性查找130 * @param propertyName 属性名称131 * @param value 属性的值132 * @return133 */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 * @return145 */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 * @return169 */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 * @return204 */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 propertyName257 * @param value258 * @return259 */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 propertyNames269 * @param values270 * @return271 */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 @Test21 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; //注入IUserDao24 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 //注入action15 public class LoginAction implements ServletRequestAware {16 @Resource IUserService userService; //注入IUserService17 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="http://www.mamicode.com/">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="http://www.mamicode.com/提交">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="http://www.mamicode.com/">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="http://www.mamicode.com/">11 12 <title>登录失败</title>13 14 </head>15 16 <body>17 登录失败18 </body>19 </html>
http://localhost:8080/demo/
进入测试页面
struts-2.3.16.3+hibernate-3.2.5+spring-2.5全注解配置
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。