8、Spring+Struts2+MyBaits(Spring注解+jdbc属性文件+log4j属性文件)

一、注解理论

使用注解来构造IoC容器

用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。

如：在base-package指明一个包

1 <context:component-scan base-package="cn.gacl.java"/>

表明cn.gacl.java包及其子包中，如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。也可以在<context:component-scan base-package=” ”/>中指定多个包，如：

1 <context:component-scan base-package="cn.gacl.dao.impl,cn.gacl.service.impl,cn.gacl.action"/>

多个包逗号隔开。

1、@Component

@Component
是所有受Spring 管理组件的通用形式，@Component注解可以放在类的头上，@Component不推荐使用。

2、@Controller

@Controller对应表现层的Bean，也就是Action，例如：

1 @Controller
2 @Scope("prototype")
3 public class UserAction extends BaseAction<User>{
4 ……
5 }

使用@Controller注解标识UserAction之后，就表示要把UserAction交给Spring容器管理，在Spring容器中会存在一个名字为"userAction"的action，这个名字是根据UserAction类名来取的。注意：如果@Controller不指定其value【@Controller】，则默认的bean名字为这个类的类名首字母小写，如果指定value【@Controller(value="UserAction")】或者【@Controller("UserAction")】，则使用value作为bean的名字。

这里的UserAction还使用了@Scope注解，@Scope("prototype")表示将Action的范围声明为原型，可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，避免struts中Action的线程安全问题。spring 默认scope 是单例模式(scope="singleton")，这样只会创建一个Action对象，每次访问都是同一Action对象，数据不安全，struts2 是要求每次次访问都对应不同的Action，scope="prototype" 可以保证当有请求的时候都创建一个Action对象

3、@ Service

@Service对应的是业务层Bean，例如：

1 @Service("userService")
2 public class UserServiceImpl implements UserService {
3 ………
4 }

@Service("userService")注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注入给Action：在Action只需要声明一个名字叫“userService”的变量来接收由Spring注入的"userService"即可，具体代码如下：

1 // 注入userService
2 @Resource(name = "userService")
3 private UserService userService;

注意：在Action声明的“userService”变量的类型必须是“UserServiceImpl”或者是其父类“UserService”，否则由于类型不一致而无法注入，由于Action中的声明的“userService”变量使用了@Resource注解去标注，并且指明了其name = "userService"，这就等于告诉Spring，说我Action要实例化一个“userService”，你Spring快点帮我实例化好，然后给我，当Spring看到userService变量上的@Resource的注解时，根据其指明的name属性可以知道，Action中需要用到一个UserServiceImpl的实例，此时Spring就会把自己创建好的名字叫做"userService"的UserServiceImpl的实例注入给Action中的“userService”变量，帮助Action完成userService的实例化，这样在Action中就不用通过“UserService userService = new UserServiceImpl();”这种最原始的方式去实例化userService了。如果没有Spring，那么当Action需要使用UserServiceImpl时，必须通过“UserService userService = new UserServiceImpl();”主动去创建实例对象，但使用了Spring之后，Action要使用UserServiceImpl时，就不用主动去创建UserServiceImpl的实例了，创建UserServiceImpl实例已经交给Spring来做了，Spring把创建好的UserServiceImpl实例给Action，Action拿到就可以直接用了。Action由原来的主动创建UserServiceImpl实例后就可以马上使用，变成了被动等待由Spring创建好UserServiceImpl实例之后再注入给Action，Action才能够使用。这说明Action对“UserServiceImpl”类的“控制权”已经被“反转”了，原来主动权在自己手上，自己要使用“UserServiceImpl”类的实例，自己主动去new一个出来马上就可以使用了，但现在自己不能主动去new“UserServiceImpl”类的实例，new“UserServiceImpl”类的实例的权力已经被Spring拿走了，只有Spring才能够new“UserServiceImpl”类的实例，而Action只能等Spring创建好“UserServiceImpl”类的实例后，再“恳求”Spring把创建好的“UserServiceImpl”类的实例给他，这样他才能够使用“UserServiceImpl”，这就是Spring核心思想“控制反转”，也叫“依赖注入”，“依赖注入”也很好理解，Action需要使用UserServiceImpl干活，那么就是对UserServiceImpl产生了依赖，Spring把Acion需要依赖的UserServiceImpl注入(也就是“给”)给Action，这就是所谓的“依赖注入”。对Action而言，Action依赖什么东西，就请求Spring注入给他，对Spring而言，Action需要什么，Spring就主动注入给他。

4、@ Repository

@Repository对应数据访问层Bean ，例如：

1 @Repository(value="userDao")
2 public class UserDaoImpl extends BaseDaoImpl<User> {
3 ………
4 }

@Repository(value="userDao")注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。

当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注入给Service即可。

1 // 注入userDao，从数据库中根据用户Id取出指定用户时需要用到
2 @Resource(name = "userDao")
3 private BaseDao<User> userDao;

二、通过注解配置bean

加上注解的类会被Spring容器管理

@Component

　　　　标注于通用实体类

@Controller

　　　　标注于Controller/Action

@Service

　　　　标注于Service

@Respository

　　　　标注于RespositoryImpl/DaoImlp

@Autowired

　　　　依据类型自动装配

@Qualifier

　　　　指定自动装载的bean的name

三、项目具体案例如下：

1、创建如下oracle数据库脚本userinfo.sql

 SQL> create table userinfo
 (id number(4),
 name varchar2(50),
 password varchar2(20
 telephone varchar2(15),
 isadmin varchar2(5));

 SQL> --4.2 用户表序列
 SQL> create sequence seq_userinfo;

 SQL> alter table userinfo add constraint pk_userinfo_id primary key(id);

 SQL> insert into userinfo values(seq_userinfo.nextval,'holly','','134518024
 ','是');

 SQL> commit;

userinfo.sql

2、创建如下所示项目结构

3、在src下的com.entity包下创建UserInfo.java

 package com.entity;

 import java.io.Serializable;

 /**
  * 用户信息表
  * @author Holly老师
  *
  */
 public class UserInfo implements Serializable {
     private static final long serialVersionUID = 1L;
     private Integer id; //编号
     private String name; //姓名
     private String password; //密码
     private String telephone; //电话
     private String isadmin; //是否是管理员

     public UserInfo() {
     }

     public UserInfo(Integer id, String name, String password, String telephone,
             String isadmin) {
         this.id = id;
         this.name = name;
         this.password = password;
         this.telephone = telephone;
         this.isadmin = isadmin;
     }

     public Integer getId() {
         return id;
     }

     public void setId(Integer id) {
         this.id = id;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }

     public String getTelephone() {
         return telephone;
     }

     public void setTelephone(String telephone) {
         this.telephone = telephone;
     }

     public String getIsadmin() {
         return isadmin;
     }

     public void setIsadmin(String isadmin) {
         this.isadmin = isadmin;
     }

 }

UserInfo.java

4、在src下的com.mapper包下创建UserInfoMapper.java

 package com.mapper;

 import java.util.List;

 import com.entity.UserInfo;
 /**
  * 数据访问层接口
  * @author Holly老师
  *
  */
 public interface UserInfoMapper {
     /**
      * 1.根据用户信息查询某个用户
      * @param userinfo
      * @return
      */
     UserInfo findNamePwd(UserInfo userinfo);

     /**
      * 2.添加用户信息
      * @param userinfo
      */
     void addUserInfo(UserInfo userinfo);

     /**
      * 3.查询所有
      * @return
      */
     List<UserInfo> findAll();

     /**
      * 4.删除
      * @param id
      */
     void deleteUser(int id);
     /**
      * 5.修改
      * @param userinfo
      */
     void updateUser(UserInfo userinfo);

     /**
      * 5.根据id查询
      */
     UserInfo findId(int id);
 }

UserInfoMapper.java

5、在src下的com.mapper包下创建UserInfoMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="com.mapper.UserInfoMapper">
   <!-- 根据用户查询用户 -->
   <select id="findNamePwd" parameterType="userinfo" resultType="userinfo">
     select * from userinfo where name=#{name} and password=#{password}
   </select>

   <!-- 插入用户信息 -->
   <insert id="addUserInfo" parameterType="userinfo">
      insert into userinfo values(seq_userinfo.nextval,#{name},#{password},#{telephone},#{isadmin})
   </insert>

   <!-- 查询所有 -->
   <select id="findAll" resultType="userinfo">
     select * from userinfo
   </select>

    <!-- 删除 -->
    <delete id="deleteUser" parameterType="int">
      delete from userinfo where id=#{id}
    </delete>

    <!-- 修改 -->
    <update id="updateUser" parameterType="userinfo">
      update userinfo set name=#{name},password=#{password},telephone=#{telephone},isadmin=#{isadmin} where id=#{id}
    </update>

    <!-- 根据id查询 -->
    <select id="findId" parameterType="int" resultType="userinfo">
     select * from userinfo where id=#{id}
    </select>

 </mapper>

UserInfoMapper.xml

6、在src下创建mybatis-config.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd" >
 <configuration>
  <!-- 定义别名 -->
  <typeAliases>
    <typeAlias type="com.entity.UserInfo" alias="userinfo"/>
  </typeAliases>
  <!-- 注册xml -->
  <mappers>
    <mapper resource="com/mapper/UserInfoMapper.xml"/>
  </mappers>
 </configuration>

mybatis-config.xml

7、在src下的com.mapper.impl包下创建UserInfoMapperImpl.java

 package com.mapper.impl;

 import java.util.List;

 import org.mybatis.spring.SqlSessionTemplate;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Repository;

 import com.entity.UserInfo;
 import com.mapper.UserInfoMapper;
 /**
  * 数据访问层实现类
  * @author Holly老师
  */
 /*@Repository表示标注dao类，相当于dao的bean
  * 或者写@Component(dao)等同于<bean id="dao" class="com.dao.impl.UserInfoDaoImpl"/>
  */
 @Repository
 public class UserInfoMapperImpl implements UserInfoMapper {
     /*采用注解方式注入sqlSessionTemplate对象
      * Autowired表示按类型自动装配方式*/
      @Autowired
     SqlSessionTemplate sqlSessionTemplate;

     public SqlSessionTemplate getSqlSessionTemplate() {
         return sqlSessionTemplate;
     }
     public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
         this.sqlSessionTemplate = sqlSessionTemplate;
     }

     /**
      * 1.根据用户信息查询用户
      * 用代理方式
      */
     public UserInfo findNamePwd(UserInfo userinfo) {

         //2.通过反射生成动态代理对象
         UserInfoMapper dao=sqlSessionTemplate.getMapper(UserInfoMapper.class);

         //3.代理对象调用接口里 的方法
         UserInfo user=dao.findNamePwd(userinfo);

         //5.数据判断
         if(user!=null){
             System.out.println("登录成功");
             return user;
         }else{
             System.out.println("登录失败");
             return null;
         }
     }
     /**
      *2. 添加操作用无代理方式
      */
     public void addUserInfo(UserInfo userinfo) {

         //2.session执行插入操作,第一个参数映射文件namespace+id.第二个参数,插入对象
         String key="com.mapper.UserInfoMapper.addUserInfo";
         int number=sqlSessionTemplate.insert(key, userinfo);
         if(number>0){
             System.out.println("注册成功");
         }else{
             System.out.println("注册失败");
         }
     }
     /**
      * 3.查询所有
      */
     public List<UserInfo> findAll() {

         //2.session执行插入操作,第一个参数映射文件namespace+id.第二个参数,插入对象
         String key="com.mapper.UserInfoMapper.findAll";
         List<UserInfo> list =sqlSessionTemplate.selectList(key);
         if(list!=null){
             System.out.println("查询所有成功");
         }else{
             System.out.println("查询所有失败");
         }
         return list;
     }
     /**
      * 4.根据id删除
      */
     public void deleteUser(int id) {
         UserInfoMapper dao=sqlSessionTemplate.getMapper(UserInfoMapper.class);
         try {
             dao.deleteUser(id);
             System.out.println("删除成功");
         } catch (Exception e) {
             System.out.println("删除失败");
             e.printStackTrace();
         }

     }
     /**
      * 5.根据id查询某个对象
      */
     public UserInfo findId(int id) {

         //2.通过反射生成动态代理对象
         UserInfoMapper dao=sqlSessionTemplate.getMapper(UserInfoMapper.class);

         //3.代理对象调用接口里 的方法
         UserInfo user=dao.findId(id);

         //5.数据判断
         if(user!=null){
             System.out.println("登录成功");
             return user;
         }else{
             System.out.println("登录失败");
             return null;
         }
     }
     /**
      * 6.修改对象
      */
     public void updateUser(UserInfo userinfo) {
         UserInfoMapper dao=sqlSessionTemplate.getMapper(UserInfoMapper.class);
         try {
             dao.updateUser(userinfo);
             System.out.println("修改成功");
         } catch (Exception e) {
             System.out.println("修改失败");
             e.printStackTrace();
         }

     }

 }

UserInfoMapperImpl.java

8、在src下的com.servicel包下创建UserInfoService.java

 package com.service;

 import java.util.List;

 import com.entity.UserInfo;
 /**
  * 服务层接口
  * @author Holly老师
  *
  */
 public interface UserInfoService {
     /**
      *1. 登录
      * @param userinfo
      * @return
      */
     UserInfo loginUser(UserInfo userinfo);

     /**
      * 2.注册
      */
     void registerUser(UserInfo userinfo);

     /**
      * 3.查询所有
      * @return
      */
     List<UserInfo> findAll();

     /**
      * 4.删除
      */
     void deleteOne(int id);
     /**
      * 5.修改
      * @param userinfo
      */
     void updateOne(UserInfo userinfo);
     /**
      * 6.根据id查询
      * @param id
      * @return
      */
     UserInfo findId(int id);

 }

UserInfoService.java

9、在src下的com.service.impl包下创建UserInfoServiceImpl.java

 package com.service.impl;

 import java.util.List;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

 import com.entity.UserInfo;
 import com.mapper.UserInfoMapper;
 import com.mapper.impl.UserInfoMapperImpl;
 import com.service.UserInfoService;
 /**
  * 服务层接口的实现类
  * @author Holly老师
  *
  */
 /*
  * @service表示标注业务逻辑类
  * @Transactional 表示用注解来声明事务处理
  * */
 @Service
 @Transactional
 public class UserInfoServiceImpl implements UserInfoService {
     /*引用数据访问层接口的对象
      * @Autowired表示按类型自动装配
      * @Qualifier(dao)表示按名称匹配*/
     @Autowired
     UserInfoMapperImpl mapper;

     /**
      * 登录
      */
     public UserInfo loginUser(UserInfo userinfo) {
         return mapper.findNamePwd(userinfo);
     }

     /**
      * 注册
      */
     public void registerUser(UserInfo userinfo) {
         mapper.addUserInfo(userinfo);
     }

     /**
      * 查询所有
      */
     public List<UserInfo> findAll() {
         return mapper.findAll();
     }
     /**
      * 根据id删除
      */
     public void deleteOne(int id) {
         mapper.deleteUser(id);
     }

     /**
      * 根据id查询
      */
     public UserInfo findId(int id) {
         return mapper.findId(id);
     }
     /**
      * 修改用户信息
      */
     public void updateOne(UserInfo userinfo) {
         mapper.updateUser(userinfo);

     }

 }

UserInfoServiceImpl.java

10、在src下的com.action包下创建UserInfoAction.java

 package com.action;

 import java.util.List;

 import javax.servlet.http.HttpServletRequest;

 import org.apache.struts2.ServletActionContext;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Scope;
 import org.springframework.stereotype.Controller;

 import com.entity.UserInfo;
 import com.opensymphony.xwork2.ActionSupport;
 import com.service.UserInfoService;
 /**
  *
  * @author Holly老师
  * ActionSupport可以最数据校验
  */
 /*@Controller 表示标注控制器类注入
  * 使用@Controller注解标识UserInfoAction之后，
  * 就表示要把UserInfoAction交给Spring容器管理，
  * 在Spring容器中会存在一个名字为"userAction"的action，
  * 这个名字是根据UserInfoAction类名来取的。
  * 注意：如果@Controller不指定其value【@Controller】，
  * 则默认的bean名字为这个类的类名首字母小写，
  * 如果指定value【@Controller(value="UserInfoAction")】或者
  * 【@Controller("UserInfoAction")】，则使用value作为bean的名字。
  *
  * @Scope("prototype")表示将Action的范围声明为原型，
  * 可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，
  * 避免struts中Action的线程安全问题。spring 默认scope 是单例模式(scope="singleton")
  * ，这样只会创建一个Action对象，每次访问都是同一Action对象，数据不安全，
  * struts2 是要求每次次访问都对应不同的Action，
  * scope="prototype" 可以保证当有请求的时候都创建一个Action对象*/

 @Controller
 @Scope("prototype")
 public class UserInfoAction extends ActionSupport  {

     /**
      * 引用服务层对象
      * @Autowired  根据类型自动装配注入
      */
     @Autowired
     private UserInfoService service;
     /**
      * 对象用于接收请求中的值
      * 必须创建setter和getter方法,代理对象才能获取或设置
      */
     private UserInfo user;

     public UserInfo getUser() {
         return user;
     }

     public void setUser(UserInfo user) {
         this.user = user;
     }

     /**
      * 登录
      * @return
      */
     public String login(){

         if(user!=null){
             System.out.println("登录表单值接收到");
             UserInfo userinfo=service.loginUser(user);
             if(userinfo!=null){
                 System.out.println("登录陈宫");
 //                nextDispose="findAll";
                 return SUCCESS;

             }else{
                 return ERROR;
             }

         }else{
             System.out.println("登录表单值没有接收到");
             return ERROR;

         }
     }

     /**
      * 注册
      * @return
      */
     public String register(){
       return SUCCESS;
     }
     /**
      * 查询所有
      * @return
      */
     public String findAll(){
       List<UserInfo> list=service.findAll();
         if(list!=null){
             System.out.println("查询所有成功");
             HttpServletRequest request=ServletActionContext.getRequest();
             request.setAttribute("list", list);
             return SUCCESS;
         }else{
             System.out.println("查询所有，失败");
             return ERROR;
         }
     }

     /**
      * 删除
      * @return
      */
     public String deleteOne(){
         HttpServletRequest request=ServletActionContext.getRequest();
         String id=request.getParameter("id");
         int uid=0;
         if(id!=null){
             System.out.println("获取id成功");
             System.out.println("id"+id);
             uid=Integer.parseInt(id);
             System.out.println("uid"+uid);
             service.deleteOne(uid);
             return SUCCESS;
         }else{
             System.out.println("获取id失败");
             return ERROR;

         }

     }

 }

UserInfoAction.java

11、在src下创建log4j.properties日志记录文件，可以将mybatis的sql打印在控制台，可以方便调试

 log4j.rootLogger=DEBUG, Console  

 #Console
 log4j.appender.Console=org.apache.log4j.ConsoleAppender
 log4j.appender.Console.layout=org.apache.log4j.PatternLayout
 log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n  

 log4j.logger.java.sql.ResultSet=INFO
 log4j.logger.org.apache=INFO
 log4j.logger.java.sql.Connection=DEBUG
 log4j.logger.java.sql.Statement=DEBUG
 log4j.logger.java.sql.PreparedStatement=DEBUG   

log4j.properties

12、在src下创建jdbc.properties属性文件

 jdbc.driver=oracle.jdbc.driver.OracleDriver
 jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl
 jdbc.username=scott
 jdbc.password=tiger

jdbc.properties

13、在src下创建applicationContext.xml文件

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx.xsd
  ">
   <!-- 采用注释的方式配置bean -->
     <context:annotation-config />  

     <!-- 配置要扫描的包 -->
     <context:component-scan base-package="com"></context:component-scan>  

     <!-- 数据库属性文件位置 -->
     <context:property-placeholder location="classpath:jdbc.properties"/>

      <!-- 2.数据源配置 -->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
         <property name="driverClassName" value="${jdbc.driver}"/>
         <property name="url" value="${jdbc.url}"/>
         <property name="username" value="${jdbc.username}"/>
         <property name="password" value="${jdbc.password}"/>
   </bean>

     <!-- 配置mybitasSqlSessionFactoryBean -->
     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
         <property name="dataSource" ref="dataSource" />
         <property name="configLocation" value="classpath:mybatis-config.xml"></property>
     </bean>  

     <!-- 配置SqlSessionTemplate -->
     <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
         <constructor-arg index="0" ref="sqlSessionFactory" />
     </bean>  

     <!-- 事务配置 -->
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <property name="dataSource" ref="dataSource" />
     </bean>  

     <!-- 使用annotation注解方式配置事务 -->
     <tx:annotation-driven transaction-manager="transactionManager"/>
 </beans>

applicationContext.xml

14、在src下创建struts.xml文件

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "struts-2.1.dtd" >
 <struts>
   <!-- 中文乱码处理 -->
     <constant name="struts.i18n.encoding" value="UTF-8"/>
     <package name="default" namespace="/" extends="struts-default">
     <!-- 全局结果配置
        <global-results>
          <result name="error" type="redirect">error.jsp</result>
        </global-results>
        -->
        <!-- 首启项配置 -->
      <!-- <default-action-ref name="findAll"/>-->

        <!-- method是对应action类的有返回值的方法名 -->
         <!-- 登录 -->
         <action name="login" class="userInfoAction" method="login">
           <result type="redirectAction">findAll</result>
           <result name="error">error.jsp</result>
         </action>

         <!-- 查询所有action -->
         <action name="findAll" class="userInfoAction" method="findAll">
           <result name="success">success.jsp</result>
         </action>
         <!-- 根据id删除的action -->
         <action name="deleteOne" class="userInfoAction" method="deleteOne">
           <result type="redirectAction">findAll</result>
         </action>

     </package>
 </struts>

struts.xml

15、编辑WebRoot下WEB-INF下的web.xml文件

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
     <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
     </context-param>
     <filter>
         <filter-name>struts2</filter-name>
         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
     </filter>

     <filter-mapping>
         <filter-name>struts2</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>

    <!-- 加载spring的配置文件 -->
     <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>  

     <welcome-file-list>
         <welcome-file>login.jsp</welcome-file>
     </welcome-file-list>

 </web-app>

web.xml

16、在WebRoot下创建login.jsp文件

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">

    <title>My JSP 'index.jsp' starting page</title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">
    <!--
    <link rel="stylesheet" type="text/css" href="styles.css">
    -->
  </head>

  <body>
    <center>
      <fieldset style="width:400px;">
        <legend>登录</legend>
        <form action="login.action" method="post">
            <table>
              <tr>
                  <td>用户名:</td>
                  <td><input type="text" name="user.name"/></td>
              </tr>
              <tr>
                   <td>密码:</td>
                   <td><input type="password" name="user.password"/></td>
               </tr>
              <tr>
                   <td><input type="submit" value="提交"/></td>
                   <td><input type="reset" value="重置"/></td>
               </tr>
            </table>

        </form>
      </fieldset>
    </center>
  </body>
</html>

login.jsp

17、在WebRoot下创建success.jsp文件

 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
 <%
 String path = request.getContextPath();
 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 %>

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
   <head>
     <base href="<%=basePath%>">

     <title>My JSP 'index.jsp' starting page</title>
     <meta http-equiv="pragma" content="no-cache">
     <meta http-equiv="cache-control" content="no-cache">
     <meta http-equiv="expires" content="0">
     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
     <meta http-equiv="description" content="This is my page">
     <!--
     <link rel="stylesheet" type="text/css" href="styles.css">
     -->
   </head>

   <body>
    <table border="1">
      <tr><td>编号</td><td>用户名</td><td>密码</td><td>电话</td><td>是否是管理员</td>
      <td>操作</td></tr>

    <c:forEach items="${requestScope.list}" var="i">
       <tr>
      <td>${i.id}</td>
      <td>${i.name}</td>
      <td>${i.password}</td>
      <td>${i.telephone}</td>
      <td>${i.isadmin }</td>
      <td><a href="deleteOne?id=${i.id}">删除</a></td>
      </tr>

    </c:forEach>

     </table>
   </body>
 </html>

success.jsp

18、在WebRoot下创建error.jsp文件

 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 <%
 String path = request.getContextPath();
 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 %>

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
   <head>
     <base href="<%=basePath%>">

     <title>My JSP 'index.jsp' starting page</title>
     <meta http-equiv="pragma" content="no-cache">
     <meta http-equiv="cache-control" content="no-cache">
     <meta http-equiv="expires" content="0">
     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
     <meta http-equiv="description" content="This is my page">
     <!--
     <link rel="stylesheet" type="text/css" href="styles.css">
     -->
   </head>

   <body>
       操作失败!
   </body>
 </html>

error.jsp

19、在WebRoot下创建register.jsp文件

 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 <%
 String path = request.getContextPath();
 String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 %>

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
   <head>
     <base href="<%=basePath%>">

     <title>My JSP 'index.jsp' starting page</title>
     <meta http-equiv="pragma" content="no-cache">
     <meta http-equiv="cache-control" content="no-cache">
     <meta http-equiv="expires" content="0">
     <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
     <meta http-equiv="description" content="This is my page">
     <!--
     <link rel="stylesheet" type="text/css" href="styles.css">
     -->
   </head>

   <body>
     <center>
       <fieldset style="width:400px;">
         <legend>注册</legend>
         <form action="register.action" method="post">
             <table>
               <tr>
                   <td>用户名:</td>
                   <td><input type="text" name="user.name"/></td>
               </tr>
               <tr>
                    <td>密码:</td>
                    <td><input type="password" name="user.password"/></td>
                </tr>
               <tr>
                    <td>电话号码:</td>
                    <td><input type="text" name="user.telephone"/></td>
                </tr>
               <tr>
                    <td>是否是管理员:</td>
                    <td>
                    <input type="radio" name="user.isadmin" value="是">
                    <input type="radio" name="user.isadmin" value="否" checked="checked"/>
                    </td>
                </tr>
               <tr>
                    <td><input type="submit" value="提交"/></td>
                    <td><input type="reset" value="重置"/></td>
                </tr>
             </table>

         </form>
       </fieldset>
     </center>
   </body>
 </html>

register.jsp

20、运行如下

也许本人写的代码有缺陷或还有需要改进的地方，希望各位路过的大神，不吝赐教！