动态代理和拦截器

一、概述 

1、代理模式是常用的java设计模式，生成一个代理对象，来代替真正的对象，从而控制真实对象的访问。

　　      客户（调用者）----------商务（代理对象）-----------软件工程师（真正对象）

2、我们需要在调用者调用对象之前就生成一个代理对象，而这个代理对象需要和真正对象建立代理关系

　　　-----代理对象和真正对象建立关系

　　　-----实现代理对象的代理逻辑方法

3、常用的代理对象方法：JDK动态代理，CGLIB

二、JDK动态代理

　　  JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，JVM根据传进来的 业务实现类对象以及方法名 ，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。

1、需要借助接口生成代理对象

public interface HelloWorld {
    public void sayHelloWorld();
}

public class HelloWorldImp implements HelloWorld{
    @Override
    public void sayHelloWorld() {
        System.out.println("你好");    
    }

}

2、实现代理逻辑类：需要实现java.lang,reflect.InvocationHandler接口，重写invoke方法

package reflect;

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

import org.junit.Test;

public class JdkProxyExample implements InvocationHandler{
    //真实对象
    private Object target = null;
    //建立关系,返回代理对象
    public Object bind(Object target) {
        this.target = target;    
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);        
    }
    
    @Override
    //处理代理实例上的方法调用并返回结果。当在与其关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用真实对象服务之前的服务");
        Object obj = method.invoke(target, args);//相当于调用sayHelloWorld()
        System.out.println("调用真实对象服务之后的服务");
        return obj;
    }
    
    @Test
    public void testJdkProxyExample() {
        JdkProxyExample jdkProxyExample = new JdkProxyExample();
        HelloWorld proxy = (HelloWorld) jdkProxyExample.bind(new HelloWorldImp());
        proxy.sayHelloWorld();
    }
    
}

1、该方法返回指定接口的代理类的实例，该接口将方法调用分派给指定的invocationhandler代理     
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
                       throws IllegalArgumentException 
参数：InvocationHandler是由代理实例的调用处理程序实现的接口。每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，

　　　　　　　　　　　　　 方法调用被编码并发送到其调用处理程序的invokemethod。

2、Object invoke(Object proxy, Method method,Object[] args) throws Throwable{}
　 处理代理实例上的方法调用并返回结果。当在与其关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
　 参数：Object proxy ：就是newProxyInstance返回的代理对象

　　　　 Method method ： 当前调度的接口中的方法
　　　　 Object[] args ： 调度方法中的参数

通俗点说就是实现java.lang,reflect.InvocationHandler接口，重写invoke方法，但是重写invoke()需要给它三个参数
参数一：Object proxy ：需要通过newProxyInstance返回的获取参数proxy

三、CGLIB动态代理

1、cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。因为采用的是继承，所以不能对final修饰的类进行代理。 

 （1）首先定义一个y业务类Hello

public class Hello {
     public void sayHello() {  
            System.out.println("hello...");  
        }  
}

（2）对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。

package reflect;

import java.lang.reflect.Method;

import org.junit.Test;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGLIBProxyExample implements MethodInterceptor{
    //生成代理对象
    public Object getProxy(Class cls) {
        //增强类
        Enhancer enhance = new Enhancer();
        //设置增强的父类，即业务类
        enhance.setSuperclass(cls);
        /*setCallback()设置哪个类是它的代理类，参数是this为当前对象,
         * 要求当前对象实现MethodInterceptor接口并实现方法intercept*/        
        enhance.setCallback(this);
        return enhance.create();
    }
    @Override
    public Object intercept(Object proxy,Method method,Object[]args,
            MethodProxy methodProxy) throws Throwable {
            System.out.println("前");
            Object result = methodProxy.invokeSuper(proxy, args);
            System.out.println("后");
            return result;
        
    }
    @Test
    public void testCGLIBProxyExample() {
        CGLIBProxyExample cglibProxyExample = new CGLIBProxyExample();
        Hello proxy = (Hello) cglibProxyExample.getProxy(Hello.class);
        proxy.sayHello();
    }
}

MethodInterceptor、 Enhancer在cglib-nodep-3.2.10.jar下

四、拦截器

　1、因为拦截器可以进一步简化动态代理的使用方法，是程序变得更简单。

　2、实现步骤：（1）定义一个拦截器接口

　　　　　　      （2）定义拦截器的实现类

　　　　　　　   （3）实现拦截器的逻辑

public interface Interceptor {
    public boolean before(Object proxy,Object target,Method method,Object[] args);
    public void around(Object proxy,Object target,Method method,Object[] args);
    public void after(Object proxy,Object target,Method method,Object[] args);
}

package interceptor;

import java.lang.reflect.Method;

public class InterceptorImp implements Interceptor{

    @Override
    /*当返回值为true时，反射真实对象原来的方法
     * 当返回值为false时，则调用around方法
     */
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法前逻辑");
        return false;
    }

    @Override
　　 //对原来的方法不满意，进行调整
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("取代原方法的逻辑");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("调用原方法或around后还要执行的逻辑");
        
    }

}

package interceptor;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class InterceptorJdkProxy implements InvocationHandler{
    private Object target;    
    private String interceptorClass = null;//定义拦截器类路径
    public InterceptorJdkProxy(Object target,String interceptorClass) {
        this.target = target;
        this.interceptorClass = interceptorClass;
    }
    
    public static Object bind(Object target,String interceptorClass) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), 
                new InterceptorJdkProxy(target,interceptorClass));
    }
    
    @Override
    //第一个参数proxy的获取通过Proxy.newProxyInstance()获取
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(interceptorClass==null) {
            //没有拦截器就直接反射原来方法
            return method.invoke(target, args);
        }
        //否则，通过反射生成拦截器
        Object result = null;
        Interceptor interceptor = (Interceptor) Class.forName(interceptorClass).newInstance();
        //判断before方法
        if(interceptor.before(proxy, target, method, args)) {
            result = method.invoke(target, args);
        }else {
            interceptor.around(proxy, target, method, args);
        }
        interceptor.after(proxy, target, method, args);
        return result;
    }
       
    
    public static void main(String[] args) {
        //没有使用代理
        HelloWorld helloWorld = new HelloWorldImp();
        helloWorld.sayHelloWorld();
        //使用了代理
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImp(),
                "interceptor.InterceptorImp");
        proxy.sayHelloWorld();
    }
}