Struts2的配置

第一步:下载并部署jar包

    (第一种方法:新建一个web project-->右键项目-->Build Path-->Add Libraries-->User Library-->User Libraries-->new-->填写SH-->选择jar包资源位置-->全选jar包-->确定-->确定)

   (第二种方法:window-->preferences-->输入user-->选择user -->User Libraries-->new-->填写SH-->选择jar包资源位置-->全选jar包-->确定-->确定-->新建一个web project-->右键 项目-->Build Path-->Add Libraries-->勾选SH-->确定)

  (导入源码:任意打开项目中jar包的一个类,添加struts2.rar)

第二步:web.xml的配置.配置Struts2的核心控制器:

   <filter>
     <filter-name>Struts2</filter-name>
     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>

<!-- URL映射 所有的请求都会经过过滤器 -->
  <filter-mapping>
     <filter-name>Struts2</filter-name>
     <url-pattern>/*</url-pattern>
  </filter-mapping>

第三步:struts.xml配置.将已有的struts.xml拷贝到src下.进行配置,如下一个登陆/注册/注销的一个struts.xml的配置

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <!--配置常量，修改struts2框架的一些行为  -->
    <!-- 开启动态方法，value改为true -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true" />
    <package name="default" namespace="/" extends="struts-default">
        <!-- 如果没有配置 class 属性, Struts 将把 ActionSupport 作为其默认值 -->
        <!-- 默认Action 只针对sturts请求,对jsp请求无效-->
        <default-action-ref name="defaultAction"></default-action-ref>
        <!-- 全局结果配置 -->
        <global-results>
           <result name="error">/page/fail.jsp</result>
        </global-results>
        <action name="defaultAction">
            <result name="success">/index.jsp</result>
        </action>
    </package>
    <!-- 用户模块 -->
    <package name="user" namespace="/" extends="struts-default,default">
        <!-- login请求发送给UserAction的doLogin方法处理 -->
        <action name="login" class="com.house.action.UserAction" method="doLogin">
            <result name="success" type="redirectAction">${nextAction}</result> <!-- 权限分配 转到下一个action -->
        </action>
        <!-- 普通用户 -->
        <action name="common">
            <result>/page/house_list.jsp</result>
        </action>
        <!-- 管理员 -->
        <action name="manager">
            <result>/page/manage.jsp</result>
        </action>
        <!-- 退出 -->
        <action name="out" class="com.house.action.UserAction" method="doOut">
            <result name="success">/index.jsp</result> <!-- 权限分配 转到下一个action -->
        </action>
        <!-- 注册请求 -->
        <action name="register" class="com.house.action.UserAction" method="doRegister">
            <result name="success">/index.jsp</result>
        </action>
        
        <!-- 动态方法配置 -->
        <action name="douser" class="com.house.action.UserAction2" >
            <result name="loginsucc">/page/house_list.jsp</result>
            <result name="regsucc">/index.jsp</result>
        </action>
        
        <!-- 通配符* -->
        <action name="*User" class="com.house.action.UserAction2" method="{1}" >
            <result name="loginsucc">/page/house_list.jsp</result>
            <result name="regsucc">/index.jsp</result>
        </action>
    </package>
</struts>

第四步:配置智能提示和去掉红叉

   配置智能提示: 首先,复制struts.xml配置文件中的http://struts.apache.org/dtds/struts-2.3.dtd ; 然后,window-->preferences-->输入xml-->选择xml catalog  -->Add --> 关于Location, 选择FileSystem --> JavaWeb/jar/struts2-->xmlspy-->...-->struts-2.3.dtd -->   Key Type 选择System Id --> Key 中粘贴 -->OK

   去掉红叉:window-->preferences-->输入vali-->选择validation -->除了第一个,其余全部第二列的勾勾去掉

第五步:编写UserAction

package com.house.action;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Map;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.ServletActionContext;

import com.house.biz.UserBiz;
import com.house.pojo.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
                                                       
@SuppressWarnings("serial")                             
public class UserAction extends ActionSupport implements ModelDriven<User> {          

    private User user;                                                                        // 使用ModelDriven方式接受参数(Action和JavaBean的方法的综合方法)
    private UserBiz biz = new UserBiz();                                        // 1.实现ModelDriven<User>接口
    //下一个action的名字,用于实现动态结果的配置                       // 2.重写接口的getModel()方法,取得Action中的user对象
    private String nextAction;                                                            // 3.form表单中的name属性的值为实体类的属性名
                                                                                                            // 4.尤为注意:一定要注意实体类的属性名的命名规范,驼峰命名法
    public String getNextAction() {
        return nextAction;
    }

    public void setNextAction(String nextAction) {
        this.nextAction = nextAction;
    }
    //登录
    public String doLogin() throws UnsupportedEncodingException {        
        // 调用业务逻辑层
        User temp = biz.login(user.getUserName(), user.getUserPass());
        if (temp != null) {
            //map存储的是session作用域的对象  //使用ActionContext访问Servlet API
            Map<String, Object> map = ActionContext.getContext().getSession();
            map.put("loginUser", temp);
            
            //Cookie不支持中文,设置编码
            //解码
            //URLDecoder.decode(temp.getUserName(),"UTF-8");
            //压缩编码 转码
            String loginName = URLEncoder.encode(temp.getUserName(),"UTF-8");
            //耦合的方式
            HttpServletResponse response = ServletActionContext.getResponse();
            //添加Cookie
            Cookie cookie = new Cookie("user", loginName);
            cookie.setMaxAge(10*24*3600);
            cookie.setPath("/");
            //向客户端添加Cookie
            response.addCookie(cookie);
            
            if("1".equals(temp.getIsAdmin())){
                nextAction = "common";
            } else if("0".equals(temp.getIsAdmin())){
                nextAction = "manager";
            }
            return "success";
        }
        return "error";
    }
    //注销用户
    public String doOut(){
        Map<String, Object> map = ActionContext.getContext().getSession();
        if(map.containsKey("loginUser")){
           map.remove("loginUser");
          // return "success";
        }
        return "success";
    }
    //注册
    public String doRegister() {
        user.setIsAdmin("1");
        if (biz.saveUser(user)) {
            return "success";
        }
        return "error";
    }
    //重写ModelDriven 实现类的getModel()方法
    public User getModel() {
        if (user == null) {
            user = new User();
        }
        return user;
    }
}

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

 其中UserBiz的类如下
   package com.house.biz;

import java.io.Serializable;
import java.util.List;
import com.house.pojo.User;
import com.house.util.Hib3Util;

@SuppressWarnings("unchecked")
public class UserBiz {
   //实现登录
    public User login(String userName, String userPass) {
        String hql = "from User where userName=? and userPass=?";
        Object[] params = { userName, userPass };
        List<User> list = Hib3Util.getList(hql, params);
        if (list.size() > 0) {
            return list.get(0);
        }
        return null;

    }
   //实现注册
    public boolean saveUser(User user) {
        Serializable ser = Hib3Util.save(user);
        if (ser == null) {
            return false;
        }
        return true;
    }
}

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

其中,Hib3Util工具类如下

package com.house.util;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;


/**
 * 工具类（封装）
 */
@SuppressWarnings("rawtypes")
public class Hib3Util {
    private static SessionFactory factory;
    //静态代码块（程序开始自动运行），得到SessionFactory对象  
    static{
        //1.读取并解析配置文件
        Configuration conf = new Configuration().configure();
        //2.读取并解析映射信息，创建SessionFactory对象
        factory = conf.buildSessionFactory();
    }
    /**
     * 打开Session
     * @return
     */
    public static Session getSession(){
        return factory.getCurrentSession();
    }
    
    /**
     * 保存对象到数据库中（插入）
     */
    public static void save(Object obj){
        Transaction tran = null;
        try {
            Session session = getSession();
            //开启事务
            tran = session.beginTransaction();
            //执行持久化操作
            session.save(obj);
            //提交事务
            tran.commit();
        } catch (Exception e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
    }
    
    /**
     * 查询
     */
    public static Object getObject(Class cls,Serializable id){
        Transaction tran = null;
        Object obj = null;
        try {
            //打开Session
            Session session = getSession();
            //开启事物
            tran = session.beginTransaction();
            //执行持久化操作
            obj = session.get(cls, id);
            //提交事物
            tran.commit();
        } catch (Exception e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return obj;
    }
    
    /**
     * 查询2
     */
    public static Object loadObject(Class cls,Serializable id){
        Object obj = null;
        try {
            Session session = getSession();
            //执行持久化操作
            obj = session.load(cls, id);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
    
    /**
     * 删除
     */
    public static void delete(Object obj){
        Transaction tran = null;
        try {
            //打开Session
            Session session = getSession();
            //开启事务
            tran = session.beginTransaction();
            //执行持久化操作
            session.delete(obj);
            //提交事务
            tran.commit();
        } catch (Exception e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
    }
    
    /**
     * 更新
     */
    public static void update(Object obj){
        Transaction tran = null;
        try {
            //打开Session
            Session session = getSession();
            //开启事务
            tran = session.beginTransaction();
            //执行持久化操作
            session.update(obj);
            //提交事务
            tran.commit();
        } catch (Exception e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
    }
    
    /**
     * 根据HQL语句,得到查询结果
     * @param hql
     * @param params 参数Object[]
     * @return
     */
    public static List getList(String hql,Object[] params){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.创建Query对象， session.creatQuery();
            Query query = session.createQuery(hql);
            //判断是否有参数传递
            if(params!=null){
                for (int i = 0; i < params.length; i++) {
                    query.setParameter(i, params[i]);
                }
            }
            //4.执行查询，得到结果
            list = query.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    
    
    /**
     * 根据查询实体查询(动态查询)
     * @param hql
     * @param queryObject 查询实体
     * @return
     */
    public static List getList(String hql,Object queryObject){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.创建Query对象， session.creatQuery();
            Query query = session.createQuery(hql);
            //判断是否有参数传递
            if(queryObject!=null){
                query.setProperties(queryObject);
            }
            //4.执行查询，得到结果
            list = query.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    
    /**
     * 查询得到iterator
     * @param hql
     * @return
     */
    public static Iterator getIterator(String hql){
        //Transaction tran = null;
        Iterator it = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            //tran=session.beginTransaction();
            //3.创建Query对象， session.creatQuery();
            Query query = session.createQuery(hql);
            //4.执行查询，得到结果
            it = query.iterate();
        } catch (HibernateException e) {
            e.printStackTrace();
        }
        return it;
    }
    /**
     * 查询结果是唯一的
     * @param hql
     * @return
     */
    public static Object getUniqueResult(String hql){
        Transaction tran = null;
        Object obj = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.创建Query对象， session.creatQuery();
            Query query = session.createQuery(hql);
            //判断是否有参数传递
            
            //4.执行查询，得到结果
            obj = query.uniqueResult();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return obj;
    }
    
    /**
     * 实体的更新删除
     * @param hql
     * @return
     */
    public static int executeUpdate(String hql){
        Transaction tran = null;
        int row = 0;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.创建Query对象， session.creatQuery();
            Query query = session.createQuery(hql);
            //判断是否有参数传递
            
            //4.执行查询，得到结果
            row = query.executeUpdate();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return row;
    }
    
    /**
     * 分页
     * @param hql    查询语句
     * @param params 参数
     * @param index  页数
     * @param size   每页记录数
     * @return
     */
    public static List getList(String hql,Object[] params,Integer index,Integer size){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.创建Query对象， session.creatQuery();
            Query query = session.createQuery(hql);
            //判断是否有参数传递
            if(params!=null){
                for (int i = 0; i < params.length; i++) {
                    query.setParameter(i, params[i]);
                }
            }
            
            //设置分页
            //设置从第几条开始读取
            query.setFirstResult((index-1)*size);
            //设置每页显示的条数
            query.setMaxResults(size);
            
            //4.执行查询，得到结果
            list = query.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    
    /**
     * Criteria查询
     * @param cls 实体.class
     * @param criterions 查询条件集合
     * @return
     */
    public static List QueryByCriteria(Class cls,List<Criterion> criterions){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.Criteria对象
            Criteria criteria = session.createCriteria(cls);
            //添加查询条件
            if(criterions!=null && criterions.size()>0){
                for (Criterion criterion : criterions) {
                    criteria.add(criterion);
                }
            }
            
            //4.执行查询，得到结果
            list = criteria.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    
    /**
     * Criteria 查询 + 排序
     * @param cls 实体.class
     * @param criterions 查询条件集合
     * @param ordername 排序的属性名
     * @param isdesc 是否降序
     * @return
     */
    public static List QueryByCriteria(Class cls,List<Criterion> criterions,String orderName,Boolean isDesc){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.Criteria对象
            Criteria criteria = session.createCriteria(cls);
            //添加查询条件
            if(criterions!=null && criterions.size()>0){
                for (Criterion criterion : criterions) {
                    criteria.add(criterion);
                }
            }
            //排序
            if(orderName!=null){
                if(isDesc){
                    criteria.addOrder(Order.desc(orderName));
                }else{
                    criteria.addOrder(Order.asc(orderName));
                }
            }
            
            //4.执行查询，得到结果
            list = criteria.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    /**
     * 投影查询(查询n个属性)
     * @param cls
     * @param projection 投影实例
     * @return
     */
    public static List QueryByCriteriaProjection(Class cls,Projection projection){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.Criteria对象
            Criteria criteria = session.createCriteria(cls);
            //投影查询
            if(projection!=null){
                criteria.setProjection(projection);
            }
            //4.执行查询，得到结果
            list = criteria.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    /**
     * 得到唯一结果
     * @param cls
     * @param projection
     * @return
     */
    public static Object QueryByUniqueResult(Class cls,Projection projection){
        Transaction tran = null;
        Object obj = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.Criteria对象
            Criteria criteria = session.createCriteria(cls);
            //投影查询
            if(projection!=null){
                criteria.setProjection(projection);
            }
            //4.执行查询，得到结果
            obj = criteria.uniqueResult();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return obj;
    }
    
    /**
     * 分页
     * @param cls  Class对象
     * @param index  页码
     * @param size  每页记录数
     * @param orderName  排序名称
     * @param isDesc  是否为降序
     * @return
     */
    public static List QueryByCriteria(Class cls,Integer index,Integer size,String orderName,Boolean isDesc){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.Criteria对象
            Criteria criteria = session.createCriteria(cls);
            //排序
            if(orderName!=null){
                if(isDesc){
                    criteria.addOrder(Order.desc(orderName));
                } else{
                    criteria.addOrder(Order.asc(orderName));
                }
            }
            //分页
            //设置从第几条开始读取
            criteria.setFirstResult((index-1)*size);
            //设置每页显示的条数
            criteria.setMaxResults(size);
            
            //4.执行查询，得到结果
            list = criteria.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }
    
    /**
     * 分页/条件/排序
     * @param cls  Class对象
     * @param criterions 查询条件集合  
     * @param index  页码
     * @param size  每页记录数
     * @param orderName  排序名称
     * @param isDesc  是否为降序
     * @return
     */
    public static List QueryByCriteria(Class cls,List<Criterion> criterions,Integer index,Integer size,String orderName,Boolean isDesc){
        Transaction tran = null;
        List list = null;
        try {
            //1.获取Session
            Session session = getSession();
            //2.开启事务
            tran=session.beginTransaction();
            //3.Criteria对象
            Criteria criteria = session.createCriteria(cls);
            
            //添加查询条件
            if(criterions!=null && criterions.size()>0){
                for (Criterion criterion : criterions) {
                    criteria.add(criterion);
                }
            }
            
            //排序
            if(orderName!=null){
                if(isDesc){
                    criteria.addOrder(Order.desc(orderName));
                } else{
                    criteria.addOrder(Order.asc(orderName));
                }
            }
            
            //分页
            //设置从第几条开始读取
            criteria.setFirstResult((index-1)*size);
            //设置每页显示的条数
            criteria.setMaxResults(size);
            
            //4.执行查询，得到结果
            list = criteria.list();
            tran.commit();
        } catch (HibernateException e) {
            if(tran!=null){
                tran.rollback();
            }
            e.printStackTrace();
        }
        return list;
    }  
}
------------------------------------------------------------------------------------------------------------------------------------
肯定还要配置ORM映射

pojo.hbm.xml:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 用户ORM -->
    <class name="com.house.pojo.User" table="Users">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="sequence">
               <param name="sequence">seq_reuser</param>
            </generator>
        </id>
        <property name="userName" column="name" type="java.lang.String" />
        <property name="userPass" column="password" type="java.lang.String"></property>
        <property name="telephone" column="telephone" type="java.lang.String"></property>
        <property name="realName" column="username" type="java.lang.String"></property>
        <property name="isAdmin" column="isadmin" type="java.lang.String"></property>
    </class>
</hibernate-mapping>
-------------------------------------------------------------------------------------------------------------------------------------------

当然啦,hibernate.cfg.xml也不能少

hibernate.cfg.xml:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!--数据库URL -->
        <property name="connection.url">
            jdbc:oracle:thin:@localhost:1521:orcl
        </property>
        <!--数据库用户 -->
        <property name="connection.username">house</property>
        <!--数据库用户密码 -->
        <property name="connection.password">house</property>
        <!--数据库JDBC驱动 -->
        <property name="connection.driver_class">
            oracle.jdbc.driver.OracleDriver
        </property>
        <!--每个数据库都有其对应的Dialect以匹配其平台特性 -->
        <property name="dialect">
            org.hibernate.dialect.Oracle10gDialect
        </property>

        <!-- 显示底层执行的SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 格式化SQL语句 -->
        <property name="format_sql">true</property>
        <!-- 本地JDBC事务 -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 添加映射文件 -->
        <mapping resource="com/house/pojo/pojo.hbm.xml"/>
    </session-factory>
</hibernate-configuration>