java知识点 --- 静态代理模式与动态代理模式

代理模式为其他对象提供了一种代理以控制对这个对象的访问，根据代理类的创建时机和创建方式的不同，可以将其分为静态代理和动态代理两种形式：在程序运行前就已经存在的编译好的代理类是为静态代理，在程序运行期间根据需要动态创建代理类及其实例来完成具体的功能是为动态代理。代理模式的目的就是为真实业务对象提供一个代理对象以控制对真实业务对象的访问。

代理模式主要包含三个角色，即抽象主题角色(Subject)、委托类角色(被代理角色，Proxied)以及代理类角色(Proxy)，如上图所示：

• 抽象主题角色:可以是接口，也可以是抽象类；
• 委托类角色：真实主题角色，业务逻辑的具体执行者；
• 代理类角色：内部含有对真实对象RealSubject的引用，负责对真实主题角色的调用，并在真实主题角色处理前后做预处理和后处理。

一、静态代理模式

静态代理是代理模式的实现方式之一，是相对于动态代理而言的。所谓静态代理是指，在程序运行前，由程序员创建或特定工具自动生成源代码并对其编译生成.class文件。静态代理的实现只需要三步：首先，定义业务接口；其次，实现业务接口；然后，定义代理类并实现业务接口；最后便可通过客户端进行调用。例如，

 第一步：创建服务类接口

public interface BuyHouse {
    void buyHosue();
}

第二步：实现服务接口

public class BuyHouseImpl implements BuyHouse { 
     @Override
     public void buyHosue() {
         System.out.println("我要买房");
     }
 }

第三步：创建代理类

public class BuyHouseProxy implements BuyHouse {
 
     private BuyHouse buyHouse;
 
     public BuyHouseProxy(final BuyHouse buyHouse) {
         this.buyHouse = buyHouse;
     }
 
     @Override
     public void buyHosue() {
         System.out.println("买房前准备");
         buyHouse.buyHosue();
         System.out.println("买房后装修");
 
     }
 }

第四步：编写测试类

public class ProxyTest {
    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        buyHouse.buyHosue();
        BuyHouseProxy buyHouseProxy = new BuyHouseProxy(buyHouse);
        buyHouseProxy.buyHosue();
    }
}

静态代理总结：

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。  

二、JDK动态代理

在动态代理中，代理类是在运行时期生成的。因此，相比静态代理，动态代理可以很方便地对委托类的相关方法进行统一增强处理，如添加方法调用次数、添加日志功能等等。动态代理主要分为JDK动态代理和cglib动态代理两大类。

JDK动态代理机制的相关类/接口：

1>java.lang.reflect.Proxy：该类用于动态生成代理类，只需传入目标接口、目标接口的类加载器以及InvocationHandler便可为目标接口生成代理类及代理对象。

// 方法 1: 该方法用于获取指定代理对象所关联的InvocationHandler
static InvocationHandler getInvocationHandler(Object proxy) 

// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) 

// 方法 3：该方法用于判断指定类是否是一个动态代理类
static boolean isProxyClass(Class cl) 

// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
    InvocationHandler h)

2>java.lang.reflect.InvocationHandler：该接口包含一个invoke方法，通过该方法实现对委托类的代理的访问，是代理类完整逻辑的集中体现，包括要切入的增强逻辑和进行反射执行的真实业务逻辑。

// 该方法代理类完整逻辑的集中体现。第一个参数既是代理类实例，第二个参数是被调用的方法对象，
// 第三个方法是调用参数。通常通过反射完成对具体角色业务逻辑的调用，并对其进行增强。
Object invoke(Object proxy, Method method, Object[] args)

3>java.lang.ClassLoader：类加载器类，负责将类的字节码装载到Java虚拟机中并为其定义类对象，然后该类才能被使用。Proxy静态方法生成动态代理类同样需要通过类加载器来进行加载才能使用，它与普通类的唯一区别就是其字节码是由JVM在运行时动态生成的而非预存在于任何一个.class 文件中。

JDK动态代理使用步骤：

1>创建被代理的接口和类；

2>实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；

3>调用Proxy的静态方法，创建代理类并生成相应的代理对象；

4>使用代理。

第一步：编写动态处理器

public class DynamicProxyHandler implements InvocationHandler {
 
     private Object object;
 
     public DynamicProxyHandler(final Object object) {
         this.object = object;
     }
 
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("买房前准备");
         Object result = method.invoke(object, args);
         System.out.println("买房后装修");
         return result;
     }
 }

第二步：编写测试类

public class DynamicProxyTest {
     public static void main(String[] args) {
         BuyHouse buyHouse = new BuyHouseImpl();
         BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new
                 Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
         proxyBuyHouse.buyHosue();
     }
 }

三、CGLIB动态代理

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

CGLIB动态代理机制的相关类/接口：

org.springframework.cglib.proxy.InvocationHandler

第一步：创建CGLIB代理类

public class CglibProxy implements InvocationHandler {
 
     private Object target; // 真实对象
 
     public <T>T getProxy(final Object target) {
         this.target = target;
         Enhancer enhancer = new Enhancer();
         enhancer.setSuperclass(this.target.getClass());
         enhancer.setCallback(this);
         return enhancer.create();
     }

     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("买房前准备");
         Object result = proxy.invoke(method, args);
         System.out.println("买房后装修");
         return result;
     }
 }

第二步：创建测试类

public class CglibProxyTest {
     public static void main(String[] args){
         BuyHouse buyHouse = new BuyHouseImpl();
         CglibProxy cglibProxy = new CglibProxy();
         BuyHouseImpl buyHouseCglibProxy = (BuyHouseImpl) cglibProxy.getProxy(buyHouse);
         buyHouseCglibProxy.buyHosue();
     }
 }