首页 / JAVA / java动态代理实现与原理详细分析

java动态代理实现与原理详细分析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java动态代理实现与原理详细分析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6779字，纯文字阅读大概需要10分钟。

内容图文

关于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。

一、代理模式

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。在后面我会

解释这种间接性带来的好处。代理模式结构图（图片来自《大话设计模式》）：

技术分享图片

二、静态代理

1、静态代理

静态代理：由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成。

2、静态代理简单实现

根据上面代理模式的类图，来写一个简单的静态代理的例子。我这儿举一个比较粗糙的例子，假如一个班的同学要向老师交班费，但是都是通过班长把自己的钱转交给老师。这里，班长就是代理学生上交班费，

班长就是学生的代理。

首先，我们创建一个Person接口。这个接口就是学生（被代理类），和班长（代理类）的公共接口，他们都有上交班费的行为。这样，学生上交班费就可以让班长来代理执行。

/**
 * 创建Person接口
 * @author Gonjan
 */
public interface Person {
    //上交班费
    void giveMoney();
}

Student类实现Person接口。Student可以具体实施上交班费的动作。

public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
       System.out.println(name + "上交班费50元");
    }
}

StudentsProxy类，这个类也实现了Person接口，但是还另外持有一个学生类对象，由于实现了Peson接口，同时持有一个学生对象，那么他可以代理学生类对象执行上交班费（执行giveMoney()方法）行为。

/**
 * 学生代理类，也实现了Person接口，保存一个学生实体，这样既可以代理学生产生行为
 * @author Gonjan
 *
 */
public class StudentsProxy implements Person{
    //被代理的学生
    Student stu;
    
    public StudentsProxy(Person stu) {
        // 只代理学生对象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班费，调用被代理学生的上交班费行为
    public void giveMoney() {
        stu.giveMoney();
    }
}

下面测试一下，看如何使用代理模式：

public class StaticProxyTest {
    public static void main(String[] args) {
        //被代理的学生张三，他的班费上交有代理对象monitor（班长）完成
        Person zhangsan = new Student("张三");
        
        //生成代理对象，并将张三传给代理对象
        Person monitor = new StudentsProxy(zhangsan);
        
        //班长代理上交班费
        monitor.giveMoney();
    }
}

运行结果：

技术分享图片

这里并没有直接通过张三（被代理对象）来执行上交班费的行为，而是通过班长（代理对象）来代理执行了。这就是代理模式。

代理模式最主要的就是有一个公共接口（Person），一个具体的类（Student），一个代理类（StudentsProxy）,代理类持有具体类的实例，代为执行具体类实例方法。上面说到，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。这里的间接性就是指不直接调用实际对象的方法，那么我们在代理过程中就可以加上一些其他用途。就这个例子来说，加入班长在帮张三上交班费之前想要先反映一下张三最近学习有很大进步，通过代理模式很轻松就能办到：

public class StudentsProxy implements Person{
    //被代理的学生
    Student stu;
    
    public StudentsProxy(Person stu) {
        // 只代理学生对象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班费，调用被代理学生的上交班费行为
    public void giveMoney() {
        System.out.println("张三最近学习有进步！");
        stu.giveMoney();
    }
}

运行结果：

技术分享图片

可以看到，只需要在代理类中帮张三上交班费之前，执行其他操作就可以了。这种操作，也是使用代理模式的一个很大的优点。最直白的就是在Spring中的面向切面编程（AOP），我们能在一个切点之前执行一些操作，在一个切点之后执行一些操作，这个切点就是一个个方法。这些方法所在类肯定就是被代理了，在代理过程中切入了一些其他操作。

三、动态代理

1.动态代理

代理类在程序运行时创建的代理方式被成为动态代理。我们上面静态代理的例子中，代理类(studentProxy)是自己定义好的，在程序运行之前就已经编译完成。然而动态代理，代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。比如说，想要在每个代理的方法前都加上一个处理方法：

 public void giveMoney() {
        //调用被代理方法前加入处理方法
        beforeMethod();
        stu.giveMoney();
    }

这里只有一个giveMoney方法，就写一次beforeMethod方法，但是如果出了giveMonney还有很多其他的方法，那就需要写很多次beforeMethod方法，麻烦。那看看下面动态代理如何实现。

2、动态代理简单实现

在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

创建一个动态代理对象步骤，具体代码见后面：

创建一个InvocationHandler对象

//创建一个与代理对象相关联的InvocationHandler
 InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);

使用Proxy类的getProxyClass静态方法生成一个动态代理类stuProxyClass

  Class<?> stuProxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class<?>[] {Person.class});

获得stuProxyClass 中一个带InvocationHandler参数的构造器constructor

Constructor<?> constructor = PersonProxy.getConstructor(InvocationHandler.class);

通过构造器constructor来创建一个动态实例stuProxy

Person stuProxy = (Person) cons.newInstance(stuHandler);

就此，一个动态代理对象就创建完毕，当然，上面四个步骤可以通过Proxy类的newProxyInstances方法来简化：

 //创建一个与代理对象相关联的InvocationHandler
  InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);
//创建一个代理对象stuProxy，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
  Person stuProxy= (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);

到这里肯定都会很疑惑，这动态代理到底是如何执行的，是如何通过代理对象来执行被代理对象的方法的，先不急，我们先看看一个简单的完整的动态代理的例子。还是上面静态代理的例子，班长需要帮学生代交班费。
首先是定义一个Person接口:

/**
 * 创建Person接口
 * @author Gonjan
 */
public interface Person {
    //上交班费
    void giveMoney();
}

创建需要被代理的实际类：

public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
        try {
          //假设数钱花了一秒时间
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       System.out.println(name + "上交班费50元");
    }
}

再定义一个检测方法执行时间的工具类，在任何方法执行前先调用start方法，执行后调用finsh方法，就可以计算出该方法的运行时间，这也是一个最简单的方法执行时间检测工具。

public class MonitorUtil {
    
    private static ThreadLocal<Long> tl = new ThreadLocal<>();
    
    public static void start() {
        tl.set(System.currentTimeMillis());
    }
    
    //结束时打印耗时
    public static void finish(String methodName) {
        long finishTime = System.currentTimeMillis();
        System.out.println(methodName + "方法耗时" + (finishTime - tl.get()) + "ms");
    }
}

创建StuInvocationHandler类，实现InvocationHandler接口，这个类中持有一个被代理对象的实例target。InvocationHandler中有一个invoke方法，所有执行代理对象的方法都会被替换成执行invoke方法。

再再invoke方法中执行被代理对象target的相应方法。当然，在代理过程中，我们在真正执行被代理对象的方法前加入自己其他处理。这也是Spring中的AOP实现的主要原理，这里还涉及到一个很重要的关于java反射方面的基础知识。

public class StuInvocationHandler<T> implements InvocationHandler {
   //invocationHandler持有的被代理对象
    T target;
    
    public StuInvocationHandler(T target) {
       this.target = target;
    }
    
    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行" +method.getName() + "方法");
     */   
        //代理过程中插入监测方法,计算该方法耗时
        MonitorUtil.start();
        Object result = method.invoke(target, args);
        MonitorUtil.finish(method.getName());
        return result;
    }
}

做完上面的工作后，我们就可以具体来创建动态代理对象了，上面简单介绍了如何创建动态代理对象，我们使用简化的方式创建动态代理对象：

public class ProxyTest {
    public static void main(String[] args) {
        
        //创建一个实例对象，这个对象是被代理的对象
        Person zhangsan = new Student("张三");
        
        //创建一个与代理对象相关联的InvocationHandler
        InvocationHandler stuHandler = new StuInvocationHandler<Person>(zhangsan);
        
        //创建一个代理对象stuProxy来代理zhangsan，代理对象的每个执行方法都会替换执行Invocation中的invoke方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler)；

       //代理执行上交班费的方法
        stuProxy.giveMoney();
    }
}

我们执行这个ProxyTest类，先想一下，我们创建了一个需要被代理的学生张三，将zhangsan对象传给了stuHandler中，我们在创建代理对象stuProxy时，将stuHandler作为参数了的，上面也有说到所有执行代理对象的方法都会被替换成执行invoke方法，也就是说，最后执行的是StuInvocationHandler中的invoke方法。所以在看到下面的运行结果也就理所当然了。

运行结果：

技术分享图片

上面说到，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。是因为所有被代理执行的方法，都是通过在InvocationHandler中的invoke方法调用的，所以我们只要在invoke方法中统一处理，就可以对所有被代理的方法进行相同的操作了。例如，这里的方法计时，所有的被代理对象执行的方法都会被计时，然而我只做了很少的代码量。

动态代理的过程，代理对象和被代理对象的关系不像静态代理那样一目了然，清晰明了。因为动态代理的过程中，我们并没有实际看到代理类，也没有很清晰地的看到代理类的具体样子，而且动态代理中被代理对象和代理对象是通过InvocationHandler来完成的代理过程的，其中具体是怎样操作的，为什么代理对象执行的方法都会通过InvocationHandler中的invoke方法来执行。带着这些问题，我们就需要对java动态代理的源码进行简要的分析，弄清楚其中缘由。

原文：https://www.cnblogs.com/leduo-zuul/p/10697960.html

内容总结

以上是互联网集市为您收集整理的java动态代理实现与原理详细分析全部内容，希望文章能够帮你解决java动态代理实现与原理详细分析所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1268271.html

来源：【匿名】

【上一篇】JavaScript Document 【下一篇】JAVA/JSP学习系列之五

更多 ►

【java动态代理实现与原理详细分析】教程文章相关的互联网学习教程文章

java动态代理实现与原理详细分析【代码】【图】

关于Java中的动态代理，我们首先需要了解的是一种常用的设计模式--代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。一、代理模式代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身...

java动态代理复习【代码】

package com.free.testProxy;import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;/** * 动态代理的三个条件 * 1.有接口 * 2.被代理类实现了该接口 * 3.创建代理类 * */publicclass ProxyConnection {private Connection connection;public Connection Getproxy() {Connection connection = (Connection)Proxy.newProxyInstance(jdbcConnection.class.getClassLoader()...

java 获取动态代理生成的 Class 文件【代码】

一获取 JDK 动态代理生成的 Class 文件　　1.1 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");此方式只能在爱main函数中使用　　1.2　　　　　　　FileOutputStream out = null;try {byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", DaoImpl.class.getInterfaces());out = new FileOutputStream(filePath[0] + "$Proxy0.class");out.write(classFile);} catch (Excepti...

java反射机制与动态代理

在学习HadoopRPC时，用到了函数调用，函数调用都是采用的java的反射机制和动态代理来实现的，所以现在回顾下java的反射和动态代理的相关知识。一、反射JAVA反射机制定义： JAVA反射机制是java程序在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。反射就是把Java类中的各种成分映射成相...

JAVA 动态代理

与oc的消息转发类似。原文出处： forever具体场景为了使代理类和被代理类对第三方有相同的函数，代理类和被代理类一般实现一个公共的interface，该interface定义如下1234public interface Calculator { public Integer add(Integer num1, Integer num2); public Integer minus(Integer num1, Integer num2);}被代理类定义如下1234567891011121314151617public class CalculatorImpl implements Calculator { @Override ...

java动态代理简述

代理模式一个典型的动态代理创建对象过程可分为以下四个步骤：1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型Constructor constructor = clazz....

java动态代理【代码】

一接口和实现类interface Subject {publicvoid hello(); }class RealSubject implements Subject {@Overridepublicvoid hello() {System.out.println("hello");} }二、创建代理实现类class DynamicProxy implements InvocationHandler {// 代理的真实对象private Object target;public DynamicProxy(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Thr...

Java学习之动态代理篇【代码】

Java学习之动态代理篇0x00 前言在后面的漏洞研究的学习中，必须要会的几个知识点。反射机制和动态代理机制。至于反射的前面已经讲到过了，这里就不做更多的赘述了。0x01 动态代理这里先来讲一些动态代理的一个定义。动态代理是给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。（[手动滑稽]其实动态代理就是一个中间商，间接的把东西送到客户手里，但是在此之前肯定要赚点差价）我们开发中使用动态代理的主要目的是...

Java动态代理详解【代码】

Java动态代理只对实现了接口方法的实现类有效，接口和实现类代码如下：package com.coshaho.reflect;publicinterface Subject {String doSomething(); }package com.coshaho.reflect;publicclass RealSubject implements Subject {@Overridepublic String doSomething() {System.out.println("Execute Service.");return "Done";}}Java动态代理使用步骤：1、创建动态代理方法处理器（实现InvocationHandler接口）；package com.c...

Java进阶学习第24天——动态代理与类加载器【代码】

文档版本开发工具测试平台工程名字日期作者备注V1.02016.06.17lutianfeinone动态代理代理对象存在的价值：主要用于拦截对真实业务对象的访问。代理对象有什么方法？现在要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。如何编写生成代理对象的类，两个要素：代理谁如何生成代理对象代理谁？设计一个类变量，以及一个构造函数，记住代理类代理哪个对象。如何生成代理对象...

Java的动态代理【代码】

何为动态代理：其实Struts2的Action请求也是用动态代理的，比如Action需要调用很多拦截器，但是如果用Action实例去一一调用拦截器，是不是好麻烦，而且代码的耦合度很高吖，那我能不能为每个Action都自动生成一个动态代理对象呢，让这个对象代替Action实例去干活，答案是可以的，代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法...

代理模式（静态代理+动态代理）——JAVA【图】

代理模式是常用的java设计模式，他的特征是代理类与目标类有同样的接口，代理类主要负责为目标类预处理消息、过滤消息、把消息转发给目标类，以及事后处理消息等。代理类与目标类之间通常会存在关联关系，一个代理类的对象与一个目标类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用目标类的对象的相关方法，来提供特定的服务。结构图如下：按照代理的创建时期，代理类可以分为静态代...

(转)Java动态代理与CGLib代理

本文通过spring aop的代理实现简述了java动态代理和cglib的区别，有助于理解java的代理模式转载自：http://www.iteye.com/topic/182654 Java代码 public class UserDAOImpl{ public void save() { // TODO Auto-generated method stub System.out.println("user saved"); } } //相关配置，省略了一些不相关内容 <bean id="userDAO" class="UserDAOImpl"> <b...

Java反射机制剖析（三）-简单谈谈动态代理【代码】

通过Java反射机制剖析（一）和Java反射机制剖析（二）的学习，已经对反射有了一定的了解，这一篇通过动态代理的例子来进一步学习反射机制。1. 代理模式代理模式就是为其他对象提供一种代理来控制对这个对象的访问。其实代理模式是在访问的对象时引入一定程度的间接性，这种间接性可以附加多种用途。它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息...

Java动态代理【代码】【图】

代理的基本构成：代理模式上，基本上有Subject角色，RealSubject角色，Proxy角色。其中：Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来真正完成业务服务功能；Proxy角色负责将自身的Request请求，调用realsubject 对应的request功能来实现业务功能，自己不真正做业务。上面的这幅代理结构图是典型的静态的代理模式： ...

首页 / JAVA / java动态代理实现与原理详细分析

java动态代理实现与原理详细分析

内容导读

内容图文

一、代理模式

二、静态代理

三、动态代理

内容总结

内容备注

内容手机端

【java动态代理实现与原理详细分析】教程文章相关的互联网学习教程文章

动态代理 - 相关标签

分析 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程