Java 代理模式详解静态代理,动态代理(JDK代理,CGLIB代理)

简介
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法。java 中AOP就是基于代理的设计模式。

代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象

有哪些代理模式
静态代理,动态代理(JDK动态代理,Cglib代理)

静态代理
所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。
静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成,但如果我们需要很多的代理,每一个都这么手动的去创建实属浪费时间,而且会有大量的重复代码。
静态代理的实现比较简单,代理类通过实现与目标对象相同的接口,并在类中维护一个代理对象。通过构造器塞入目标对象,赋值给代理对象,进而执行代理对象实现的接口方法,并实现前拦截,后拦截等所需的业务功能。

  • 静态代理类:由程序员创建或者由第三方工具生成,再进行编译;在程序运行之前,代理类的.class文件已经存在了。
  • 静态代理类通常只代理一个类。
  • 静态代理事先知道要代理的是什么。

静态代理示例

/**
* 共同接口
*/
public interface ProgrammerInterface {
    void goToWork();

    void goOffWork();
}
/**
* 程序员类
*/
public class Programmer implements ProgrammerInterface{
    @Override
    public void goToWork() {
        System.out.print("开始上班了\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("终于下班了\n");
    }
}
/**
* 程序员代理类
*/
public class ProgrammerProxy implements ProgrammerInterface {
    //目标类(程序员类)
    Programmer programmer;

    //构造方法,初始化目标类
    public ProgrammerProxy(Programmer programmer) {
        this.programmer = programmer;
    }

    @Override
    public void goToWork() {
        System.out.print("进入了上班代理\n");
        programmer.goToWork();
        System.out.print("上班时间为:" + new Date() + "\n\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("进入了下班代理\n");
        programmer.goOffWork();
        System.out.print("下班时间为:" + new Date() + "\n");
    }
}
/**
* main 入口
*/
public class ProxyDemoApplication {

    public static void main(String[] args) {
        Programmer programmer = new Programmer();
        ProgrammerProxy programmerProxy = new ProgrammerProxy(programmer);
        programmerProxy.goToWork();
        programmerProxy.goOffWork();
    }
}

运行结果:
在这里插入图片描述
总结:静态代理一般都是类对类,一个代理类对应一个目标类,很少能公用的,因为每个类中的方法是不一样的。所以提前就把代理类写好,这样如果需要代理的类很多,就需要创建很多的代理类。

动态代理
在程序运行时,运用反射机制动态创建而成。动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java 反射机制可以生成任意类型的动态代理类。

  • 动态代理类:在程序运行时,通过反射机制动态生成。
  • 动态代理类通常代理接口下的所有类。
  • 动态代理事先不知道要代理的是什么,只有在运行的时候才能确定。
  • 动态代理的调用处理程序必须事先InvocationHandler接口,及使用Proxy类中的newProxyInstance方法动态的创建代理类。
  • Java动态代理只能代理接口,要代理类需要使用第三方的CLIGB等类库。

动态代理示例

JDK动态代理示例

/**
* 人员工作接口
*/
public interface WorkInterface {
    void goToWork();

    void goOffWork();
}
/**
* 工程师类
*/
public class Engineer implements WorkInterface {
    @Override
    public void goToWork() {
        System.out.print("工程师某某开始上班了\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("工程师某某下班了\n");
    }
}
/**
* InvocationHandler
*/
public class WorkInvocationHandler implements InvocationHandler {
    private Object obj;

    public WorkInvocationHandler(Object obj) {
        this.obj = obj;
    }

    /**
     * proxy:代表动态代理对象
     * method:代表正在执行的方法
     * args:代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.print("进入了代理\n");
        Object result = method.invoke(obj, args);
        System.out.print("时间为:" + new Date() + "\n\n");
        return result;
    }
}
/**
* 动态代理Main方法
*
* @param args
*/
public static void main(String[] args) {
    //工程师类,Engineer是我们的代理对象
    WorkInterface engineer = new Engineer();
    //创建一个InvocationHandler,与代理对象关联
    InvocationHandler invocationHandler = new WorkInvocationHandler(engineer);
    Class<?> engineerClass = engineer.getClass();
    //新建一个代理类来代理engineer(这里就是动态生成代理类,通过实现相同接口,
    //达到在调用目标类之前先进入InvocationHandler,然后在通过method.invoke()方法调用原有的目标类中方法)
    /**
     * Proxy 代理类中 newProxyInstance方法参数说明
     * loader: 一个classloader对象,定义了由哪个classloader对象对生成的代理类进行加载
     * interfaces: 一个interface对象数组,表示我们将要给我们的代理对象提供一组什么样的接口,如果我们提供了这样一个接口对象数组,
     *             那么也就是声明了代理类实现了这些接口,代理类就可以调用接口中声明的所有方法。
     * h: 一个InvocationHandler对象,表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上,并最终由其调用。
     */
    WorkInterface engineerProxy = (WorkInterface) Proxy.newProxyInstance(engineerClass.getClassLoader(), engineerClass.getInterfaces(), invocationHandler);
    //调用工程师类中的方法
    engineerProxy.goToWork();
    engineerProxy.goOffWork();

    //将我们生成的代理类engineerProxy中相关信息打印出来
    String methodList = "";
    for (Method m : engineerProxy.getClass().getDeclaredMethods()) {
        methodList += m.getName() + "  ";
    }
    System.out.print("engineerProxy中的方法: " + methodList + "\n");
    System.out.print("engineerProxy的父类: " + engineerProxy.getClass().getSuperclass() + "\n");
    String interfaces = "";
    for (Class<?> i : engineerProxy.getClass().getInterfaces()) {
        interfaces += i.getName() + "  ";
    }
    System.out.print("engineerProxy中实现的接口: " + interfaces + "\n");
}

运行结果:
在这里插入图片描述
这就是JDK动态代理,通过反射来生成代理类,实现接口,并调用目标类中的方法。他跟静态代理的区别就是,代理类如何生成,静态代理的代理类必须提前去写,一个目标类需要写个代理类。工作量大,且代码体积大。
动态代理就是不需要针对每个类写个代理类,代理类都是动态生成的,这样就少很多代码。例如,现在需要对学生类的方法也需要加上时间打印,我们就可以共用一个InvocationHandler,不需要再写一个了。

/**
* 人员学习接口
*/
public interface StudyInterface {
    void doHomework();

    void read();
}
/**
* 学生类
*/
public class Student implements StudyInterface {
    @Override
    public void doHomework() {
        System.out.print("学生某某开始写作业了\n");
    }

    @Override
    public void read() {
        System.out.print("学生某某读书了\n");
    }
}

main方法中只要在加上下面这段代码,就可以了,可以看到 用的同一个WorkInvocationHandler,没有重新去写个InvocationHandler。因为构造函数里面参数是Object的,可以实现任何对象的代理。

StudyInterface student = new Student();
InvocationHandler studentInvocationHandler = new WorkInvocationHandler(student);
StudyInterface studentProxy = (StudyInterface) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), studentInvocationHandler);
studentProxy.doHomework();
studentProxy.read();

String stuProxyMethodList = "";
for (Method m : studentProxy.getClass().getDeclaredMethods()) {
    stuProxyMethodList += m.getName() + "  ";
}
System.out.print("studentProxy中的方法: " + stuProxyMethodList + "\n");
System.out.print("studentProxy的父类: " + studentProxy.getClass().getSuperclass() + "\n");
String stuProxyInterfaces = "";
for (Class<?> i : studentProxy.getClass().getInterfaces()) {
    stuProxyInterfaces += i.getName() + "  ";
}
System.out.print("studentProxy中实现的接口: " + stuProxyInterfaces + "\n\n");

运行结果:
在这里插入图片描述
可以看到,JDK动态代理只能用在目标类中实现了接口的,如果没有实现接口会怎么样那?
我们把代码稍微改造下,直接使用Student,不用接口了,看看运行结果。

Student student = new Student();
InvocationHandler studentInvocationHandler = new WorkInvocationHandler(student);
Student studentProxy = (Student) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), studentInvocationHandler);
studentProxy.doHomework();
studentProxy.read();

运行结果:
在这里插入图片描述
$Proxy1 为代码动态生成的代理类,为什么?可以看我们的运行结果中

engineerProxy中的方法: equals  toString  hashCode  goOffWork  goToWork  
engineerProxy的父类: class java.lang.reflect.Proxy
engineerProxy中实现的接口: dynamicproxy.EngineerWorkInterface 

studentProxy中的方法: equals  toString  hashCode  read  doHomework  
studentProxy的父类: class java.lang.reflect.Proxy
studentProxy中实现的接口: dynamicproxy.StudyInterface  

总结:engineerProxy的父类为Proxy,也就是说我们的代理类其实已经继承了一个类了,java不能多继承,现在通过反射我们需要知道目标类中有哪些方法。如果不能再去继承类,就只能通过代理接口去实现代理。所以JDK动态代理只支持代理实现了接口的类,代理的是接口。具体为什么要继承Proxy,然后如何生成代理类的,代理类源码是什么样的会在其他文章写。既然JDK动态代理只能代理接口,不能代理类,那我们如果遇到目标类中没有实现接口怎么办那?就是使用CGLIB代理,下面我们看看CGLIB代理是如何实现动态代理的。

CGLIB动态代理示例
引包

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.2.12</version>
</dependency>
/**
* 教师类
*/
public class Teacher {
    public void attendClass() {
        System.out.print("老师某某上课了\n");
    }
}
/**
* 代理类拦截
*/
public class TeacherProxyCglib implements MethodInterceptor {
    /**
     * 实现接口,拦截方法执行增强方法,然后在回调
     *
     * @param obj
     * @param method
     * @param args
     * @param proxy
     * @return
     * @throws Throwable
     */
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.print("进入了代理\n");
        proxy.invokeSuper(obj, args);   //回调父类方法,也就是目标类的方法
        System.out.print("时间为:" + new Date() + "\n\n");
        return null;
    }
}
/**
* 动态代理Main方法
*
* @param args
*/
public static void main(String[] args) {
    Enhancer enhancer = new Enhancer(); //创建加强器
    enhancer.setSuperclass(Teacher.class);  //设置父类
    enhancer.setCallback(new TeacherProxyCglib());  //设置回调
    Teacher teacher = (Teacher) enhancer.create();  //创建代理类
    teacher.attendClass();  //执行教师上课方法

    //将我们生成的代理类teacher中相关信息打印出来
    String methodList = "";
    for (Method m : teacher.getClass().getDeclaredMethods()) {
        methodList += m.getName() + "  ";
    }
    System.out.print("teacher中的方法: " + methodList + "\n");
    System.out.print("teacher的父类: " + teacher.getClass().getSuperclass() + "\n");
    String interfaces = "";
    for (Class<?> i : teacher.getClass().getInterfaces()) {
        interfaces += i.getName() + "  ";
    }
    System.out.print("teacher中实现的接口: " + interfaces + "\n\n");
}

运行结果:
在这里插入图片描述
总结:可以看到实现了代理增强,且我们的目标类并没有实现接口,CGLIB是通过继承目标类,生成子类,重写父类方法进行的代理。所以不能代理final修饰的方法,因为final修饰过的方法不可被重写。

也是看了很多文章,才整理出来,感谢那些写文章的大神。

  • 3
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值