动态代理以及动态代理如何实现AOP

                                                    动态代理以及动态代理如何实现AOP

一、代理设计模式

         什么是代理模式呢？我很忙，忙的没空理你，那你要找我呢就先找我的代理人吧，那代理人总要知道被代理人能做哪些事情不能做哪些事情吧，那就是两个人具备同一个接口，代理人虽然不能干活，但是被代理的人能干活呀。

        举例：晚会的主办方要举行歌舞表演，要找歌手唱歌和跳舞 ，主办方会找歌手的经纪人来确认沟通直至签合同，这样在晚会时歌手就会在舞台上唱歌和跳舞。实际上经纪人就是歌手的代理人

1）唱歌跳舞接口      

public interface SingerService {

    public void sing(String songName);

    public void dance(String danceName);
}

2）某个歌手来进行唱歌跳舞

public class SingerServiceImpl implements SingerService {

    public void sing(String songName) {
        System.out.println("唱歌曲名为" + songName+"的歌曲");
    }

    public void dance(String danceName){
        System.out.println("跳舞蹈名为" + danceName+"的舞蹈");
    }
}

3）歌手的经纪人通过让歌手唱歌和跳舞来实现唱歌跳舞接口

public class SingerProxy implements SingerService {

    private SingerService singerService;

    public SingerProxy(SingerService singerService){
        this.singerService = singerService;
    }

    public void sing(String songName){
        System.out.println("将要执行方法名为sing的方法");
        singerService.sing(songName);
        System.out.println("已经执行完方法名为sing的方法");
    }

    public void dance(String danceName){
        System.out.println("将要执行方法名为dance的方法");
        singerService.dance(danceName);
        System.out.println("已经执行完方法名为dance的方法");
    }
}

4）晚会主办方邀请歌手进行歌舞表演

public class TestProxy {

    public static void main(String args[]){
        SingerService singerService = new SingerServiceImpl();
        SingerProxy proxy = new SingerProxy(singerService);

        proxy.sing("日不落");
        System.out.println("");
        proxy.dance("霓裳羽衣舞");
    }
}

运行结果：

    代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口。

    由于我们现在不希望静态地有SingerProxy类存在，希望在代码中，动态生成器二进制代码，加载进来,所以才有了动态代理

二、动态代理

    动态代理其实就是java.lang.reflect.Proxy类动态的根据您指定的所有接口生成一个class byte，该class会继承Proxy类，并实现所有你指定的接口（您在参数中传入的接口数组）；然后再利用您指定的classloader将 class byte加载进系统，最后生成这样一个类的对象，并初始化该对象的一些值,初始化之后将对象返回给调用的客户端。这样客户端拿到的就是一个实现你所有的接口的Proxy对象

   动态代理就是在运行时生成一个类，这个类会实现你指定的一组接口，而这个类没有.java文件，是在运行时生成的，你也不用去关心它是什么类型的，你只需要知道它实现了哪些接口即可.

public class MyInvocationHandler implements InvocationHandler {
    private Object service;

    public MyInvocationHandler(Object service) {
        this.service = service;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("将要执行方法名为" + method.getName() + "的方法");
        Object result = method.invoke(service, args);
        System.out.println("已经执行完方法名为" + method.getName() + "的方法");
        System.out.println(method.getName()+"方法的返回值result="+result);
        System.out.println("");
        return result;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                service.getClass().getInterfaces(), this);
    }
}

public class TestDynamicProxy {

    public static void main(String args[]){
        SingerService singerService = new SingerServiceImpl();
        MyInvocationHandler myInvocationHandler =  new MyInvocationHandler(singerService);
        SingerService proxy = (SingerService)myInvocationHandler.getProxy();

        proxy.sing("日不落");
        proxy.dance("霓裳羽衣舞");

    }
}

     运行结果：

     

    1.Proxy类的newInstance()方法

        该方法有有三个参数：
　　　　i)ClassLoader loader：它是类加载器类型,用来加载动态生成的Proxy类
　　　　ii)Class[] interfaces：指定newProxyInstance()方法返回的对象要实现哪些接口，没错，可以指定多个接口，例如上面例子只我们只指定了一个接口，即SingerServiceImpl类所实现的接口也就是SingerService这个接口
　　　　iii)InvocationHandler h：它是最重要的一个参数！它是一个接口！它的名字叫调用处理器！你想一想，上面例子中proxy对象是SingerService接口的实现类对象，那么它一定是可以调用sing(String songName)和dance(String danceName)方法了，其实无论你调用代理对象的什么方法，它都是在调用MyInvocationHandler的invoke()方法

    2 .Invocation Handler管理器

      为了构造出具有通用性和简单性的代理类，可以将所有的触发真实角色动作交给一个触发的管理器，让这个管理器统一地管理触发。这种管理器就是Invocation Handler。

      InvocationHandler接口只有一个方法，即invoke()方法！它是对代理对象所有方法的唯一实现。也就是说，无论你调用代理对象上的哪个方法，其实都是在调用InvocationHandler的invoke()方法。

　　InvocationHandler的invoke()方法的参数有三个：
　　    i)Object proxy：代理对象，也就是Proxy.newProxyInstance()方法返回的对象，通常我们用不上它；
　　    ii)Method method：表示当前被调用方法的反射对象，例如 proxy.sing("日不落");，那么method就是sing(String songName)方法的反射对象；
　　　iii)Object[] args：表示当前被调用方法的参数，如proxy.sing("日不落");参数是"日不落"
 最后要说的是invoke()方法的返回值为Object类型，它表示当前被调用的方法的返回值，当然proxy.sing("日不落");方法是没有返回值的，所以invoke()返回的就必须是null了。

  三、java动态代理实现AOP

     1.什么是AOP

        AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

      AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

     使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

  2.动态代理实现AOP

import java.lang.reflect.Method;

public interface AOPMethod {

    //执行前切入
    public void before(Object proxy, Method method, Object[] args);

    //执行后切入
    public void after(Object proxy, Method method, Object[] args);
}

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

public class MyAOPInvocationHandler implements InvocationHandler {
    private Object service;
    private AOPMethod aopMethod;

    public MyAOPInvocationHandler(Object service,AOPMethod aopMethod) {
        this.service = service;
        this.aopMethod = aopMethod;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.aopMethod.before(proxy, method,args);//执行前切入
        Object result = method.invoke(service, args);
        this.aopMethod.after(proxy, method,args);//执行后切入
        System.out.println("");
        return result;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                service.getClass().getInterfaces(), this);
    }
}

import java.lang.reflect.Method;

public class TestAOPDynamicProxy {
    public static void main(String args[]){
        SingerService singerService = new SingerServiceImpl();
        MyAOPInvocationHandler myAOPInvocationHandler =  new MyAOPInvocationHandler(singerService, new AOPMethod() {
            public void before(Object proxy, Method method, Object[] args) {
                System.out.println("将要执行方法名为" + method.getName() + "的方法");
            }

            public void after(Object proxy, Method method, Object[] args) {
                System.out.println("已经执行完方法名为" + method.getName() + "的方法");
            }
        });
        SingerService proxy = (SingerService)myAOPInvocationHandler.getProxy();

        proxy.sing("日不落");
        proxy.dance("霓裳羽衣舞");

    }
}

   运行结果：