java动态代理的实现方法

这篇文章主要介绍“java动态代理的实现方法”，在日常操作中，相信很多人在java动态代理的实现方法问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”java动态代理的实现方法”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

目录

• 代理模式

• 动态代理

• 原理研究

• 应用

• 总结

1、代理模式

代理模式是常用的设计模式之一，也是开发中常见的设计模式。

简单的描述一下，代理模式就是将实现类隔离开，比如你想给你女朋友过个生日，找个明星唱生日歌，你女朋友的偶像是周杰伦，想找周杰伦给她过生日，唱歌，但是你不太能联系上周杰伦，即使在社交网站上联系，可能也不太理你，所以你可以联系周杰伦的经纪人进行沟通，经纪人就是周杰伦的代理。

实现过程：

定义一个唱歌的接口，代表业务

public interface ISing {   void sing();}

周杰伦有唱歌的业务，并且业务突出，实现接口

public class JayImp implements ISing {   @Override   public void sing() {       System.out.println("say happy birthday to you girl friend");  }}

经纪人接受业务, 经纪人的构造函数需要和明星绑定

经纪人接收唱歌的业务，今天可能是周杰伦唱，明天可能经纪人换了明星，比如蔡依林也是可以的

public class JayProxy implements ISing{   ISing target;      public JayProxy(ISing target) {       this.target = target;  }   @Override   public void sing() {       target.sing();  }}

联系经纪人进行唱歌，周杰伦唱完歌之后，经纪人收钱，very happy

public class MoneyOwner {   public static void main(String[] args) {       JayImp jay = new JayImp();       // 周杰伦和经纪人进行签约，这一步可以放在内部实现       JayProxy jayProxy = new JayProxy(jay);       jayProxy.sing();  }}

看下执行结果，皆大欢喜，你女朋友很开心。

上面这一套就是代理模式的实现，

但是代理类只能代理一种类，如果为每一个服务都创建一个代理类，有点傻

而且接口如果改变的情况下代理类也需要改变，非常不方便，周杰伦又是拍电影，做综艺，写歌，业务很多

好了，静态代理该说的也说了，相信看到这里你应该没有什么不理解的，下面我们正式开始今天的正餐，动态代理

2、动态代理

动态代理是Java提供的一种代理方式，这个技术的核心点就是在运行期的时候对接口进行增强，生成class 对象，然后加载进虚拟机，说简单点就是虚拟机帮你创建了一个实现你接口的class

废话少说，先来实现一个动态代理

第一步定义接口，上面代码已经有了 ISing 就不重复定义了

第二步 实现接口，上面代码也已经实现了 JayImp ,也不重复定义了，这次经纪人多签约了一个歌手，林俊杰，看下实现

package org.pdool.dynamic;public class JJImp implements ISing {   @Override   public void sing() {       System.out.println("I am JJ! happy birthday to you");  }}

第三步，经纪人可以动态派出签约歌手，注意经纪人要实现InvocationHandler，这样才能统一处理所有的方法调用

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class JayAgentFactory implements InvocationHandler {   Object target;   public JayAgentFactory(Object target) {       this.target = target;  }   // 生成代理类   public ISing CreatProxyedObj() {       return (ISing) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);  }   @Override   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {       Object invoke = method.invoke(target, args);       logAfter(invoke);       return invoke;  }   public void logAfter(Object invoke) {       System.out.println("结果 " + invoke);       System.out.println("收入 ++ ");  }}

第四步，接收业务

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class JayAgentFactory implements InvocationHandler {   Object target;   public JayAgentFactory(Object target) {       this.target = target;  }   // 生成代理类   public ISing CreatProxyedObj() {       return (ISing) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);  }   @Override   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {       Object invoke = method.invoke(target, args);       logAfter(invoke);       return invoke;  }   public void logAfter(Object invoke) {       System.out.println("结果 " + invoke);       System.out.println("收入 ++ ");  }}

总结：动态代理是Java提供的实现方式，需要InvocationHandler 的实现类

为什么编辑器可以提示接口的方法？因为强转编辑器才会能有提示

生成的内存class是的默认构造函数是需要InvocationHandler参数

创建代理class的核心参数是 类加载器，接口，还有InvocationHandler 子类。

类加载器保证和目标类在同一个加载器内，可以调用，防止不同加载器加载的类之间不能调用

接口就是你要代理的接口

InvocationHandler 子类是转发器，将所有的消息进行拦截处理转发

3、原理研究

实现看到了，探究下原理，动态代理的最根本的在于根据接口创建内存class，这一步是怎么实现的，我们跟着源码瞧一瞧

克隆接口里函数的信息

查找或生成指定的代理类，如果缓存中有，则用缓存的，没有则创建

通过反射，拿到代理类的构造函数

通过构造函数创建一个代理对象，并关联InvocationHandler 的对象

     private static final Class<?>[] constructorParams =      { InvocationHandler.class };

看到了流程，我们看下代理class 到底是什么样子的，

import sun.misc.ProxyGenerator;public class Test {   public static void main(String[] args) {       //开启保存代码class属性       System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");       ProxyGenerator.generateProxyClass("XianGCai", JayImp.class.getInterfaces());  }}

执行上面的函数，可以看到在项目的路径下生成Xiangcai.class

接着看看xiangcai.class 到底有哪些东西，直接拖到编辑器就可以了

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;import org.pdool.dynamic.ISing;public final class xiangcai extends Proxy implements ISing {   private static Method m1;   private static Method m2;   private static Method m3;   private static Method m0;   public xiangcai(InvocationHandler var1) throws {       super(var1);  }   public final boolean equals(Object var1) throws {       try {           return (Boolean)super.h.invoke(this, m1, new Object[]{var1});      } catch (RuntimeException | Error var3) {           throw var3;      } catch (Throwable var4) {           throw new UndeclaredThrowableException(var4);      }  }   public final String toString() throws {       try {           return (String)super.h.invoke(this, m2, (Object[])null);      } catch (RuntimeException | Error var2) {           throw var2;      } catch (Throwable var3) {           throw new UndeclaredThrowableException(var3);      }  }//注意看这里！！！其他的都不重要   public final void sing() throws {       try {           super.h.invoke(this, m3, (Object[])null);      } catch (RuntimeException | Error var2) {           throw var2;      } catch (Throwable var3) {           throw new UndeclaredThrowableException(var3);      }  }   public final int hashCode() throws {       try {           return (Integer)super.h.invoke(this, m0, (Object[])null);      } catch (RuntimeException | Error var2) {           throw var2;      } catch (Throwable var3) {           throw new UndeclaredThrowableException(var3);      }  }   static {       try {           m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));           m2 = Class.forName("java.lang.Object").getMethod("toString");           m3 = Class.forName("org.pdool.dynamic.ISing").getMethod("sing");           m0 = Class.forName("java.lang.Object").getMethod("hashCode");      } catch (NoSuchMethodException var2) {           throw new NoSuchMethodError(var2.getMessage());      } catch (ClassNotFoundException var3) {           throw new NoClassDefFoundError(var3.getMessage());      }  }}

可以看到实现了sing的接口，并且调用了invokehandler的方法invoke.好了，真相大白了，你明白了吗？

有人会说，道理我都懂，可是不会用啊，但是没看到好的应用场景，所以有段时间是没掌握这些的，下面我们就具体一下应用场景

4、应用

在切面编程（aop）中，需要拦截特定的方法，通常，会选择动态代理方式。看个具体的例子 spring-data-jpa 的实现

具体的使用：

spring中访问数据库的使用

import com.tao.SpringBoot.hibernate.entity.Customer;import org.springframework.data.jpa.repository.JpaRepository;public interface CustomerRepository extends JpaRepository<Customer, Long> {}

只要实现上面的接口就可以直接操作数据库，是不是很简单？

有几个问题，你稍微思考下：

两个泛型什么意思？

数据库连接在哪？是怎么注入的？

只实现接口是怎么操作数据库的？

第一个问题答案：

• Customer 为表对象对应的entity实体。

• Long 是表的主键类型，

第二个答案：

数据库连接是在spring启动的时候自动注入到spring 容器中的，在JpaRepository 的实现类自动注入的

第三个答案：

所有的的接口在spring启动的时候会生成代理类，目标类target就是实现类SimpleJpaRepository

看下类图

看下JpaRepository的定义，都是一些常用方法

public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {   List<T> findAll();   List<T> findAll(Sort var1);   List<T> findAllById(Iterable<ID> var1);   <S extends T> List<S> saveAll(Iterable<S> var1);   void flush();   <S extends T> S saveAndFlush(S var1);   void deleteInBatch(Iterable<T> var1);   void deleteAllInBatch();   T getOne(ID var1);   <S extends T> List<S> findAll(Example<S> var1);   <S extends T> List<S> findAll(Example<S> var1, Sort var2);}

看下SimpleJpaRepository 的定义：

public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {   private static final String ID_MUST_NOT_BE_NULL = "The given id must not be null!";   private final JpaEntityInfORMation<T, ?> entityInformation;  private final EntityManager em;//看这里！！！   private final PersistenceProvider provider;   @Nullable   private CrudMethodMetadata metadata;   //具体的实现方法      @Transactional   public void delete(T entity) {       Assert.notNull(entity, "The entity must not be null!");       this.em.remove(this.em.contains(entity) ? entity : this.em.merge(entity));  }

类似下面的代码调用：

Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), JpaRepository.class.getInterfaces(), new SimpleJpaRepository(());

注：只是表达一下意思，具体的实现应该不是这样的

5、总结

所有的事情都解开了，下面进行总结下：

静态代理是代理模式的实现，是针对某一个具体的接口的实现

动态代理的是jdk提供的一种方式，必须要接口，还有其他的实现方式cglib,javassit 等等

动态代理是在运行的时候生成class 文件然后自动加载的class

动态代理是基于反射调用的技术

动态代理会生成class 到 metaspace

多应用在框架中

解密了spring data jpa的实现

到此，关于“java动态代理的实现方法”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！