aop 代理

代理,自己的事情,让其他人代理完成.

比如需要自己买火车票的,但因为有事情,就拜托中介代购火车票.其中中介不仅完成购买火车票,还在购买前或者后,回进行其他操作,如果收取中介费 送票等.

静态代理

public interface Action{
    public void doAction();
}

public class ViewAction implement Action{
    public void doAction(){
        System.out.println("实际需要执行的动作...");
    }
}

/**
*代理类,类似于中介,同样需要完成买票的动作,当然也要实现Action接口
*/
public class ProxyAction implement Action{
    private ViewAction viewAction;//需要指明对ViewAction进行代理的引用,代理用户完成自己购票动作.

    public ProxyAction ( ViewAction viewAction){
        this.viewAction = viewAction;对需要执行的代理进入注入
    }

    public void doAction(){
          doBefore();
          viewAction.doAction();//执行用户的动作
          doAfter();
    }

    public void doBefore(){
      System.out.println("执行前的动作...");
    }

    public void doAfter(){
      System.out.println("执行后的动作...");
    }
}

//测试
public class StaticTest{

    public static main(String[] args){
        //ProxyAction 对ViewAction 进行代理执行
        ProxyAction proxyAction  = new ProxyAction (new ViewAction ());
        proxyAction.doAction();
    }
}

这样就完成了一个代理,不过从上面看到,如果我还需要其他的操作,比如还需要送东西给其他人,给别人传递信息等,都不用自己完成,这样就促生了快递,邮递等.

我们如果按照上面的实现,就需要对每一种动作定义一个接口,写一个实现,还有一种代理,对于用户来说,这样就很繁杂了很多了,用户只想让一个人来完成代理这些操作,这样就有了新的需求,实际生活中,比如领导的秘书.

在java世界中,就提供了这样的需求实现,称之为动态代理.

其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现.

如下，HelloWorld接口定义的业务方法，HelloWorldImpl是HelloWorld接口的实现，HelloWorldHandler是 InvocationHandler接口实现。
代码如下：

//业务接口
public interface HelloWorld{
    public void sayHello();
}

//业务接口实现
public class HelloWorldImpl implements HelloWorld{
    public void sayHello(){
        System.out.println("say hello...");
    }
}

import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method;

public class HelloWorldHandler implements InvocationHandler{

    private Object originalObj;//要代理的原始对象

    public HelloWorldHandler (Object originalObj){
       this.originalObj = originalObj;
    }
    //同上面的比较,都是增加了doBefore和doAfter,不同的是此处代理的原始对象是不确定的,就是动态的,怎么确定是对哪个进行代理了呢?回答是使用了反射,这个结合后面的代码来解释.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        Object result = null;
        doBefore();
        result = method.invoke(this.originalObj,args);
        doAfter();
        return result;
    }

    public void doBefore(){
      System.out.println("执行前的动作...");
    }

    public void doAfter(){
      System.out.println("执行后的动作...");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

//测试
public class DynamicTest{
    public static void main(String args[]){
        //1.获取一个业务接口的实现对象
        HelloWorld helloWorld = new HelloWorldImpl();//id=19
        //2. 获取一个InvocationHandler实现，此处是HelloWorldHandler对象;
        InvocationHandler handler = new HelloWorldHandler (helloWorld);//对HelloWorld进行代理
        //3.创建动态代理对象; 
        HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(helloWorld.getClass().getClassLoader(),helloWorld.getClass().getInterfaces(), handler); //此处就是反射的使用,得到一个处理后的HelloWorld
        //4.通过动态代理对象调用sayHelloWorld()方法，此时会在原始对象HelloWorldImpl. sayHelloWorld()方法前后输出两句字符串。 
        proxy.sayHello(); //执行
    }
}

如果debug到proxy.sayHello();,可以查看变量信息.

最后的结果就是

执行前的动作...
say hello...
执行后的动作...