java：struts框架2（方法的动态和静态调用，获取Servlet API三种方式（推荐IOC（控制反转）），拦截器，静态代理和动态代理（Spring AOP））

1.方法的静态和动态调用：　　

　　struts.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!--
        package:包，将Action（应用控制器）在逻辑上进行隔离，完成包中功能上的继承
            name:给package起的名字，就是通过name属性完成继承
            namespace:命名空间(可以理解成包在地址栏的反映),action请求url的前缀（url的构成部分）,默认空间为 "/"
            extends:值必须为某个包的名字，完成包之间的继承
            abstract:抽象的 ，如果一个package是abstract=“true”，该package必须被继承,该包下不能有action节点
        Action：描述javabean（应用控制器，具体处理请求的javabean）
            name:该javabean的请求路径
            class: javabean的完全限定名（通过反射创建javabean的对象）
            method: 指定的是处理本次请求的方法
        result:Action执行完成后需要响应的结果
           name:需要响应的结果逻辑名称
           type:表示响应的结果的类型（ajax响应，通过的跳转响应）
                   请求转化：
                   dispatcher（默认值），只能跳转到jsp
                   chain：跳转到javabean(应用控制器)
                   重定向：
                   redirect  ：  jsp
                   redirectAction   ：  javabean
                   产生一个流对象：
                   stream ：  通过流对象的方式给客户端做出响应
                   plainText：响应到客户单的内容为view的源码
     -->
    <!-- 启动方法的动态调用 --> //DMI:动态方法调用，复制default.properties里面的“struts.enable.DynamicMethodInvocation”字段粘贴到启动处
    <constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
    <!-- 方法的通配符调用(重要) -->
    <package name="crud" namespace="/user" extends="struts-default">
        <action name="user-*" class="cn.zzsxt.crud.action.UserinfoAction" method="{1}">
            <result name="list">/list.jsp</result>
            <!--
                 结果视图类型 type="结果类型名称"
                常见的结果视图
                用于JSP页面的请求转换或重定向
                dispatcher:请求转发 request.getRequestDispatcher().forword(request,response)
                redirect：重定向  response.sendRedirect()
                服务器端(action之间)的请求转发和重定向
                redirectAction：action之间的重定向,新增后为了避免重复新增，经常都利用重定向
                chain:action之前的请求转发
                stream：将结果转换为流,在下载时使用
             -->
            <result name="success" type="redirectAction">user-doList</result>
            <result name="error" type="redirect">/error.jsp</result>
            <result name="update">/update.jsp</result>
        </action>
    </package>
    <!-- 方法的动态调用(不建议) -->
    <package name="crud2" namespace="/user2" extends="struts-default">
        <action name="userAction" class="cn.zzsxt.crud.action.UserinfoAction2">
            <result name="list">/list2.jsp</result>
     　　　　<result name="success" type="redirectAction">userAction!doList</result> //命名规则：ActionName！方法名.action
        </action>
    </package>
</struts>

2.获取Servlet API三种方式：

　　方式一:（不推荐）

　　　　利用ServletActionContext中的静态方法获取
　　　　getRequest()--->request
　　　　getResponse()-->response
　　　　getServletContext()--->application
　　　　request.getSessoin()--->session

　　Action：

    public String doList()throws Exception{
        List<Userinfo> list = userinfoService.findAllUsers();
        //获取HttpServletRequest对象
        HttpServletRequest request = ServletActionContext.getRequest();
        request.setAttribute("list", list);
        //获取HttpServletResponse对象
        //HttpServletResponse response = ServletActionContext.getResponse();
        //获取HttpSessoin对象
        //HttpSession session = request.getSession();
        //获取ServletContext对象，application
        ServletContext application= ServletActionContext.getServletContext();
        return "list";
    }

package cn.zzsxt.crud.action;

import java.util.List;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.ServletActionContext;

import cn.zzsxt.crud.entity.Userinfo;
import cn.zzsxt.crud.service.UserinfoService;
import cn.zzsxt.crud.service.impl.UserinfoServiceImpl;
/**
 * 获取Servlet API的方式一:利用ServletActionContext中的静态方法获取
 * getRequest()--->request
 * getResponse()-->response
 * getServletContext()--->application
 * request.getSessoin()--->session
 * @author Think
 *
 */
public class UserinfoAction {
    private UserinfoService userinfoService = new UserinfoServiceImpl();
    private Userinfo user;//获取表单元素的值 

    public Userinfo getUser() {
        return user;
    }

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

    /**
     * 查询用户列表
     * @return
     * @throws Exception
     */
    public String doList()throws Exception{
        List<Userinfo> list = userinfoService.findAllUsers();
        //获取HttpServletRequest对象
        HttpServletRequest request = ServletActionContext.getRequest();
        request.setAttribute("list", list);
        //获取HttpServletResponse对象
        //HttpServletResponse response = ServletActionContext.getResponse();
        //获取HttpSessoin对象
        //HttpSession session = request.getSession();
        //获取ServletContext对象，application
        ServletContext application= ServletActionContext.getServletContext();
        return "list";
    }

    public String doAdd()throws Exception{
        int count = userinfoService.addUser(user);
        if(count>0){
            return "success";
        }
        return "error";
    }
    /**
     * 删除
     * @return
     * @throws Exception
     */
    public String doDelete()throws Exception{
        int count = userinfoService.deleteUser(user.getUserId());
        if(count>0){
            return "success";
        }
        return "error";
    }
    /**
     * 查询详情
     * @return
     * @throws Exception
     */
    public String doDetail()throws Exception{
        user = userinfoService.findUserById(user.getUserId());
        return "update";
    }

    public String doUpdate()throws Exception{
        int count = userinfoService.updateUser(user);
        if(count>0){
            return "success";
        }
        return "error";
    }
}

　　方式二：（不推荐）　　　

　　　　利用ActionContext中的静态方法getContext()获取ActionContext的实例
　　　　然后就可以通过该实例调用它的众多方法得到Servlet的一些API
　　　　public Object get(Object key)方法，就相当于request.getAttribute()
　　　　public void put(Object key, Object value)对应request.setAttribute()
　　　　public Map<String, Object> getParameters()对应request.getParameterMap()
　　　　public Map<String, Object> getSession()方法对应javax.servlet.http.HttpSession
　　　　session.put(Object key, Object value)对应Servlet编程中的session.setAttribute(…)
　　　　session.get(Object key)对应Servlet编程中的session.getAttribute(…)
　　　　也就是说，ActionContext能够获得三个Map类型的Request, Session, Application对象
　　　

　　　　优点:

　　　　　　Struts2便可脱离Servlet容器进行单纯的JUnit测试

　　Action：

    public String doList()throws Exception{
        List<Userinfo> list = userinfoService.findAllUsers();
        //使用ActionContext中的getContext()获取ActionContext实例
        ActionContext actionContext = ActionContext.getContext();
        //将信息保存到request中,request.setAttribute(..)
        //actionContext.put("list", list);
        Map<String,Object> session = actionContext.getSession();
        session.put("list", list);
        return "list";
    }
    

package cn.zzsxt.crud.action;

import java.util.List;
import java.util.Map;

import com.opensymphony.xwork2.ActionContext;

import cn.zzsxt.crud.entity.Userinfo;
import cn.zzsxt.crud.service.UserinfoService;
import cn.zzsxt.crud.service.impl.UserinfoServiceImpl;
/**
 * 获取Servlet API的方式二:利用ActionContext中的静态方法getContext()获取ActionContext的实例
      然后就可以通过该实例调用它的众多方法得到Servlet的一些API
    public Object get(Object key)方法，就相当于request.getAttribute()
    public void put(Object key, Object value)对应request.setAttribute()
    public Map<String, Object> getParameters()对应request.getParameterMap()
    public Map<String, Object> getSession()方法对应javax.servlet.http.HttpSession
        session.put(Object key, Object value)对应Servlet编程中的session.setAttribute(…)
        session.get(Object key)对应Servlet编程中的session.getAttribute(…)
    也就是说，ActionContext能够获得三个Map类型的Request, Session, Application对象
    优点:Struts2便可脱离Servlet容器进行单纯的JUnit测试
 * @author Think
 *
 */
public class UserinfoAction2 {
    private UserinfoService userinfoService = new UserinfoServiceImpl();
    private Userinfo user;//获取表单元素的值 

    public Userinfo getUser() {
        return user;
    }

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

    /**
     * 查询用户列表
     * @return
     * @throws Exception
     */
    public String doList()throws Exception{
        List<Userinfo> list = userinfoService.findAllUsers();
        //使用ActionContext中的getContext()获取ActionContext实例
        ActionContext actionContext = ActionContext.getContext();
        //将信息保存到request中,request.setAttribute(..)
        //actionContext.put("list", list);
        Map<String,Object> session = actionContext.getSession();
        session.put("list", list);
        return "list";
    }

    public String doAdd()throws Exception{
        int count = userinfoService.addUser(user);
        if(count>0){
            return "success";
        }
        return "error";
    }
    /**
     * 删除
     * @return
     * @throws Exception
     */
    public String doDelete()throws Exception{
        int count = userinfoService.deleteUser(user.getUserId());
        if(count>0){
            return "success";
        }
        return "error";
    }
    /**
     * 查询详情
     * @return
     * @throws Exception
     */
    public String doDetail()throws Exception{
        user = userinfoService.findUserById(user.getUserId());
        return "update";
    }

    public String doUpdate()throws Exception{
        int count = userinfoService.updateUser(user);
        if(count>0){
            return "success";
        }
        return "error";
    }
}

　　方式三：使用IOC的方式(推荐)

　　　　
　　　　IOC:

　　　　　　控制反转,是spring的核心,原来调用者需要自己创建所依赖的对象，比如在UserinfoAction中调用UserinfoService中的方法，
　　　　　需要自己创建UserinfoService的实例，使用了控制反转后不需要手工创建依赖对象，将有容器(struts2或spring等)创建所依赖的对象，
　　　　　这种控制权发生了转移的现象称为控制反转。

　　　　实现步骤:
　　　　　　1.将业务逻辑Action实现XxxAware,Xxx代表需要的ServletAPI对象
　　　　　eg:ServletRequestAware,ServletResponseAware,SessionAware...
　　　　　　2.在业务逻辑Action中添加成员变量
　　　　　　3.实现XxxAware中的setter方法,将容器创建的Servlet API对象设置给成员变量
　

　　　Action：　　

    public String doList()throws Exception{
        List<Userinfo> list = userinfoService.findAllUsers();
        request.setAttribute("list", list);
//        session.put("list", list);
        return "list";
    }
    

package cn.zzsxt.crud.action;

import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.interceptor.SessionAware;

import com.opensymphony.xwork2.ActionContext;

import cn.zzsxt.crud.entity.Userinfo;
import cn.zzsxt.crud.service.UserinfoService;
import cn.zzsxt.crud.service.impl.UserinfoServiceImpl;
/**
 *获取ServletAPI方式三:使用IOC的方式(推荐)
 *IOC:控制反转,是spring的核心,原来调用者需要自己创建所依赖的对象，比如在UserinfoAction中调用UserinfoService中的方法，
 *        需要自己创建UserinfoService的实例，使用了控制反转后不需要手工创建依赖对象，将有容器(struts2或spring等)创建所依赖的对象，
 *        这种控制权发生了转移的现象称为控制反转。
 *实现步骤:
 *1.将业务逻辑Action实现XxxAware,Xxx代表需要的ServletAPI对象
 *  eg:ServletRequestAware,ServletResponseAware,SessionAware...
 *2.在业务逻辑Action中添加成员变量
 *3.实现XxxAware中的setter方法,将容器创建的Servlet API对象设置给成员变量
 *
 */
public class UserinfoAction3 implements ServletRequestAware,ServletResponseAware,SessionAware{
    private UserinfoService userinfoService = new UserinfoServiceImpl();
    private Userinfo user;//获取表单元素的值
    private HttpServletRequest request;
    private HttpServletResponse response;
    private Map<String,Object>  session;

    public Userinfo getUser() {
        return user;
    }
    public void setUser(Userinfo user) {
        this.user = user;
    }

    /**
     * 查询用户列表
     * @return
     * @throws Exception
     */
    public String doList()throws Exception{
        List<Userinfo> list = userinfoService.findAllUsers();
        request.setAttribute("list", list);
//        session.put("list", list);
        return "list";
    }

    public String doAdd()throws Exception{
        int count = userinfoService.addUser(user);
        if(count>0){
            return "success";
        }
        return "error";
    }
    /**
     * 删除
     * @return
     * @throws Exception
     */
    public String doDelete()throws Exception{
        int count = userinfoService.deleteUser(user.getUserId());
        if(count>0){
            return "success";
        }
        return "error";
    }
    /**
     * 查询详情
     * @return
     * @throws Exception
     */
    public String doDetail()throws Exception{
        user = userinfoService.findUserById(user.getUserId());
        return "update";
    }

    public String doUpdate()throws Exception{
        int count = userinfoService.updateUser(user);
        if(count>0){
            return "success";
        }
        return "error";
    }

    //实现ServletRequestAware中的方法
    @Override
    public void setServletRequest(HttpServletRequest request) {
        this.request=request;
    }
    //实现ServletResponseAware中的方法
    @Override
    public void setServletResponse(HttpServletResponse response) {
        this.response=response;
    }
    //实现SessionAware中的方法
    @Override
    public void setSession(Map<String, Object> session) {
        this.session=session;
    }

}

3.拦截器：

　　struts.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <package name="inteceptor" extends="struts-default">
        <action name="timerAction" class="cn.zzsxt.action.TimerAction">
            <result name="success">/success.jsp</result>
            <!-- 引入timer拦截器 --> 
　　//在struts-default.xml文件下有各种各样的拦截器，只需要继承struts-default这个包就可以了
            <interceptor-ref name="timer"></interceptor-ref>//可以帮助打印信息，同时搜索log4j(2)粘贴到src下
            <!-- 引入默认拦截器栈 -->//相当于把所有默认的拦截类型一次性引入，上面引入了默认之外的类型“timer”，所以需要再引入一次默认类型
            <interceptor-ref name="defaultStack"></interceptor-ref>
        </action>
    </package>
</struts>

4.静态代理和动态代理（Spring AOP）　

　　OOP：面向对象编程

　　OOA：面向对象的分析

　　OOD：面向对象的设计

　　SOA：面向服务的编程

　　AOP：面向切面编程

　　　　　　AOP优点：

　　　　　　　　对OOP的补充，将共性问题集中解决，体现的设计模式为代理模式。

　　　　　　代理模式优点：

　　　　　　　　在不改变原代码的情况下，对类的功能加强。

　　静态代理：

　　

　　struts.xml:　

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <package name="inteceptor" extends="struts-default">
        <action name="timerAction" class="cn.zzsxt.action.TimerAction">
            <result name="success">/success.jsp</result>
            <!-- 引入timer拦截器 -->
            <interceptor-ref name="timer"></interceptor-ref>
            <!-- 引入默认拦截器栈 -->
            <interceptor-ref name="defaultStack"></interceptor-ref>
        </action>
    </package>
</struts>

　　index.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>
      <a href="timerAction.action">timerAction</a>
  </body>
</html>

　　success.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>
  </head>
  <body>
      <h2>success!</h2>
  </body>
</html>

　　TimerAction:

package cn.zzsxt.action;

import com.opensymphony.xwork2.ActionSupport;

public class TimerAction extends ActionSupport{
    @Override
    public String execute() throws Exception {
        Thread.sleep(2000);
        return this.SUCCESS;
    }
}

　　Test:

package cn.zzsxt.proxy;

public class Test {
    public static void main(String[] args) {
        UserDaoProxy proxy = new UserDaoProxy(new UserDaoImpl());
        proxy.add();
    }
}

　　UserDao:

package cn.zzsxt.proxy;

public interface UserDao {
    public void add();
}

　　UserDaoImpl:

package cn.zzsxt.proxy;

public class UserDaoImpl implements UserDao {

    @Override
    public void add() {
//        System.out.println("开启事务....");
        System.out.println("执行了用户新增....");
//        System.out.println("提交事务...");
    }

}

　　UserDaoProxy:

package cn.zzsxt.proxy;
/**
 * 代理模式:静态代理和动态代理(spring AOP)
 * 优点:在不该原有代码的基础之上对类的功能进行加强。
 * @author Think
 *
 */
public class UserDaoProxy {
    private UserDao target;//被代理目标
    public UserDaoProxy(UserDao target){
        this.target=target;
    }
    public void add(){
        System.out.println("开启事务....");
        target.add();//调用被代理目标中的方法
        System.out.println("提交事务...");
    }
}