代理模式

Proxy Pattern

Provide a surrogate or placeholder for another object to control access to it.

1、静态代理：

• 知道代理人和被代理人都是谁

2、动态代理：

• 简单地说就是不知道代理谁，被代理的是谁
• 说白了，就是给明星请了保镖，你想拜访一下人家：先经过保镖的同意，该搜身搜身，该缴枪缴枪；然后你和明星该干啥干啥；你到时间该走了，人家保镖还得掏掏你身上有没有不该带走的东西，把你的枪还给你，你才能安全地离开。
• 那么动态代理中明星的保镖，呸，代理是如何把 “被代理人” 给 “包围” 的呢？

3、两种动态代理方法

• jdk动态代理和cglib动态代理
• jdk动态代理 是由java内部的反射机制来实现的，cglib动态代理 底层则是借助asm来实现的。
  • 反射机制在生成类的过程中比较高效，而asm在生成类之后的相关执行过程中比较高效（可以通过将asm生成的类进行缓存，这样解决asm生成类过程低效问题）。
  • 还有一点必须注意：jdk动态代理的应用前提，必须是目标类基于统一的接口。如果没有上述前提，jdk动态代理不能应用。所以，jdk动态代理有一定的局限性，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。JDK动态代理只是为接口产生代理，而不是为实现类产生代理，之所以需要实现类，是因为我们需要把实现接口的对象传入动态代理中，否则代理对象不知道为谁代理。

4、简单的jdk代理代码清单：

//即将被代理的主体的接口
public interface UserService {       
    public String getName(int id);          
    public Integer getAge(int id);   
}

//主体
public class UserServiceImpl implements UserService {       
    @Override       
    public String getName(int id) {           
        System.out.println("------getName------");           
        return "Tom";       
    }          

    @Override       
    public Integer getAge(int id) {           
        System.out.println("------getAge------");           
        return 10;       
    }   
}

//代理人，实现Java的InvocationHandler接口
public class MyInvocationHandler implements InvocationHandler { 
    private Object target;  //obj就是被代理者，即主体。 
    
    MyInvocationHandler() { super(); } 

    MyInvocationHandler(Object target) { 
        super(); 
        this.target = target; 
    } 

    //重写invoke方法。第一个参数是代理人，如果你想对代理人做一些操作可以使用这个参数；第二个就是被执行的方法，第三个是执行该方法所需的参数。
    //把我们想要通过代理者给被代理者追加的操作都写在invoke方法里面 
    @Override 
    public Object invoke(Object o, Method method, Object[] args) throws Throwable { 
        //对getName方法进行了方法环绕
        if("getName".equals(method.getName())){ //如果执行的方法是getName()
            System.out.println("++++++before " + method.getName() + "++++++"); 
            Object result = method.invoke(target, args); 
            System.out.println("++++++after " + method.getName() + "++++++"); 
            return result; 
        }else{ 
            Object result = method.invoke(target, args); return result; 
        } 
    } 
} 

//场景类
public class Client{ 
    public static void main(String[] args) { 
        UserService us = new UserServiceImpl(); 
        //创建一个InvocationHandler，描述我们希望代理者执行哪些操作 
        InvocationHandler handler = new MyInvocationHandler(us); 
        
        //通过刚才创建的InvocationHandler，创建真正的代理者。第一个参数是类加载器，第二个参数是这个代理者实现哪些接口(与被代理者实现的是相同的接口) 
        UserService usp =(UserService)Proxy.newProxyInstance(us.getClass().getClassLoader(), us.getClass().getInterfaces(), handler); 
       
        System.out.println(usp.getName(1)); 
        System.out.println(usp.getAge(1)); 
    } 
} 
------------------运行结果-----------------

++++++before getName++++++ 
------getName------ 
++++++after getName++++++ 
Tom 
------getAge------ 
10

5、cglib代理

• Cglib是一个优秀的动态代理框架，它的底层使用ASM在内存中动态的生成被代理类的子类，使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用，它的运行速度要远远快于JDK的Proxy动态代理。
• CGLIB的核心类（package net.sf.cglib.proxy）：

类	功能
Enhancer	主要的增强类
MethodInterceptor	主要的方法拦截类，它是Callback接口的子接口，需要用户实现
MethodProxy	JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用：Object o = methodProxy.invokeSuper(proxy, args);虽然第一个参数是被代理对象，也不会出现死循环的问题。
MethodInterceptor	接口是最通用的回调（callback）类型，它经常被基于代理的AOP用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法 public Object intercept(Object object, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable; 第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。

• 原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用，或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用，因为它更快。

6、cglib代理实现代码清单（可能有缺的，这是老早写的，刚搬过来）

//即将被代理的主体的接口
public interface UserService {       
    public String getName(int id);          
    public Integer getAge(int id);   
}

//主体
public class UserServiceImpl implements UserService {       
    @Override       
    public String getName(int id) {           
        System.out.println("------getName------");           
        return "Tom";       
    }          

    @Override       
    public Integer getAge(int id) {           
        System.out.println("------getAge------");           
        return 10;       
    }   
}

//主要的方法拦截类，它是Callback接口的子接口，需要用户实现。具体指重写父类的intercept方法。   
/*
    MethodInterceptor接口只定义了一个方法：
    public Object intercept(Object object, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable;
        参数Object object是被代理对象，不会出现死循环的问题(死循环怎么来的，怎么避免的？）。
        参数java.lang.reflect.Method method是java.lang.reflect.Method类型的被拦截方法。
        参数Object[] args是被被拦截方法的参数。
        参数MethodProxy proxy是CGLIB提供的MethodProxy类型的被拦截方法。
    注意：
        1、若原方法的参数存在基本类型，则对于第三个参数Object[] args会被转化成类的类型。
        2、若原方法为final方法，则MethodInterceptor接口无法拦截该方法。
*/  

//代理人
public class CglibProxy implements MethodInterceptor {  
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {           
        System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");           
        System.out.println(method.getName());           
        Object o = methodProxy.invokeSuper(o, args);           
        System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");           
        return o;       
    }   
}

//场景类
public class Client {    
	 public static void main(String[] args) {        
	 	CglibProxy proxy = new CglibProxy();         
		//主要的增强类 
	 	Enhancer enhancer = new Enhancer();        
	 	//设置父类，被增强的类     
	 	enhancer.setSuperclass(UserServiceImpl.class);         
	    //回调对象       
	 	enhancer.setCallback(proxy);         
	   //用cglibProxy来增强UserServiceImpl
	 	UserService o = (UserService)enhancer.create();       
	 	o.getName(1);         
	 	o.getAge(1);     
	 	} 
}
----------------------运行结果----------------------
++++++before CGLIB$getName$0++++++ 
------getName------ 
++++++before CGLIB$getName$0++++++ 
++++++before CGLIB$getAge$1++++++ 
------getAge------ 
++++++before CGLIB$getAge$1++++++