静态代理与动态代理

一、代理模式介绍

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

二、静态代理

这种代理方式需要代理对象和目标对象实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能。

缺点：冗余。由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。不易维护。一旦接口增加方法，目标对象与代理对象都要进行修改。

举例：明星代理

//定义代理类接口
public interface Star {
    /**
     * 
     * 面谈
     */
    public void confer();
    /**
     * 签合同
     */
    public void signContract();
    /**
     * 订票
     */
    public void bookTicket();
    /**
     * 唱歌
     */
    public void sing();
    /**
     * 收钱
     */
    public void collectMoney();

}

//定义被代理目标对象实现Star接口
public class RealStar implements Star{

    @Override
    public void confer() {
        System.out.println("明星面谈");
        
    }

    @Override
    public void signContract() {
        System.out.println("明星签合同");
        
    }

    @Override
    public void bookTicket() {
        System.out.println("明星订票");
        
    }

    @Override
    public void sing() {
        System.out.println("明星唱歌");
        
    }

    @Override
    public void collectMoney() {
        System.out.println("明星收钱");
        
    }
}

//静态代理对象去代理实际对象也实现Star接口
public class ProxyStar implements Star {
    private Star star;
    
    public ProxyStar() {
        super();
    }

    public ProxyStar(Star star) {
        super();
        this.star = star;
    }

    @Override
    public void confer() {
        System.out.println("代理面谈");
        
    }

    @Override
    public void signContract() {
        System.out.println("代理签合同");
        
    }

    @Override
    public void bookTicket() {
        System.out.println("代理订票");
        
    }

    @Override
    public void sing() {
        
        star.sing();
        
    }

    @Override
    public void collectMoney() {
        System.out.println("代理收钱");
        
    }
}

//静态代理测试
public class DonTaiDaiLi {
    public static void main(String[] args) {
        Star realStar = new RealStar();
        Star proxy =new ProxyStar(realStar);
        proxy.bookTicket();
        proxy.collectMoney();
        proxy.sing();
}

三、动态代理

动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

静态代理与动态代理的区别主要在：

• 静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
• 动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中

特点：
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

JDK中生成代理对象主要涉及的类有

• java.lang.reflect Proxy，主要方法为

 

static Object    newProxyInstance(ClassLoader loader,  //指定当前目标对象使用类加载器

 Class<?>[] interfaces,    //目标对象实现的接口的类型
 InvocationHandler h      //事件处理器
) 
//返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

• java.lang.reflect InvocationHandler，主要方法为

 Object    invoke(Object proxy, Method method, Object[] args) 
// 在代理实例上处理方法调用并返回结果。

举例：明星代理

//定义代理类接口
public interface Star {
    /**
     * 
     * 面谈
     */
    public void confer();
    /**
     * 签合同
     */
    public void signContract();
    /**
     * 订票
     */
    public void bookTicket();
    /**
     * 唱歌
     */
    public void sing();
    /**
     * 收钱
     */
    public void collectMoney();

}

//定义被代理目标对象实现Star接口
public class RealStar implements Star{

    @Override
    public void confer() {
        System.out.println("明星面谈");
        
    }

    @Override
    public void signContract() {
        System.out.println("明星签合同");
        
    }

    @Override
    public void bookTicket() {
        System.out.println("明星订票");
        
    }

    @Override
    public void sing() {
        System.out.println("明星唱歌");
        
    }

    @Override
    public void collectMoney() {
        System.out.println("明星收钱");
        
    }
}

//动态代理对象去代理真实代理对象RealStar
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler{
    Star realstar;    
    public StarHandler(Star realstar) {
        super();
        this.realstar = realstar;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object object= null;
        System.out.println("真正的方法执行前");
        if (method.getName().equals("sing")) {
            object = method.invoke(realstar, args);
        }
        System.out.println("真正的方法执行后");
        return object;
    }

}

//动态代理测试
import java.lang.reflect.Proxy;
public class DonTaiDaiLi {
    public static void main(String[] args) {
        Star realStar = new RealStar();
        StarHandler handler = new StarHandler(realStar);
        Star proxy=(Star)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Star.class}, handler);
    
        proxy.sing();
    }
}

四、cglib代理

cglib is a powerful, high performance and quality Code Generation Library. It can extend JAVA classes and implement interfaces at runtime.

cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。

cglib特点

• JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。
  如果想代理没有实现接口的类，就可以使用CGLIB实现。
• CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。
  它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
• CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
  不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。

cglib与动态代理最大的区别就是

• 使用动态代理的对象必须实现一个或多个接口
• 使用cglib代理的对象则无需实现接口，达到代理类无侵入。

使用cglib需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

• cglib的Maven坐标

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

举例：保存用户功能的动态代理实现

• 目标对象：UserDao

package com.cglib;

public class UserDao{

    public void save() {
        System.out.println("保存数据");
    }
}

• 代理对象：ProxyFactory

package com.cglib;

import java.lang.reflect.Method;

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

public class ProxyFactory implements MethodInterceptor{

    private Object target;//维护一个目标对象
    public ProxyFactory(Object target) {
        this.target = target;
    }
    
    //为目标对象生成代理对象
    public Object getProxyInstance() {
        //工具类
        Enhancer en = new Enhancer();
        //设置父类
        en.setSuperclass(target.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建子类对象代理
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开启事务");
        // 执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("关闭事务");
        return null;
    }
}

• 测试类：TestProxy

package com.cglib;

import org.junit.Test;

public class TestProxy {

    @Test
    public void testCglibProxy(){
        //目标对象
        UserDao target = new UserDao();
        System.out.println(target.getClass());
        //代理对象
        UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
        System.out.println(proxy.getClass());
        //执行代理对象方法
        proxy.save();
    }
}

• 输出结果

class com.cglib.UserDao
class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6
开启事务
保存数据
关闭事务

五、总结

1. 静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
2. JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口。
3. 动态代理生成的类为 lass com.sun.proxy.$Proxy4，cglib代理生成的类为class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6。
4. 静态代理在编译时产生class字节码文件，可以直接使用，效率高。
5. 动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
6. cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。

六、相关资料

代理模式相关知识

• 代理模式及Java实现动态代理
• 设计模式读书笔记 - 代理模式
• JDK动态代理实现原理
• Java 动态代理机制分析及扩展
• Java代理(jdk静态代理、动态代理和cglib动态代理)
• AOP的底层实现-CGLIB动态代理和JDK动态代理
• 深入浅出CGlib-打造无入侵的类代理
• Spring AOP 实现原理与 CGLIB 应用

UML相关知识

• 博客 - UML类图与类的关系详解
• goole图书 -《UML建模实例详解》