1、代理模式
代理模式是常用的设计模式之一，也是开发中常见的设计模式。
简单的描述一下，代理模式就是将实现类隔离开，比如你想给你女朋友过个生日，找个明星唱生日歌，你女朋友的偶像是周杰伦，想找周杰伦给她过生日，唱歌，但是你不太能联系上周杰伦，即使在社交网站上联系，可能也不太理你，所以你可以联系周杰伦的经纪人进行沟通，经纪人就是周杰伦的代理。
实现过程：
1.定义一个唱歌的接口，代表业务
|
1 2 3 |
public interface ISing { void sing(); } |
2.周杰伦有唱歌的业务，并且业务突出，实现接口
|
1 2 3 4 5 6 7 8 9 |
/** * 周杰伦 */ public class JayImp implements ISing { @Override public void sing() { System.out.println( "say happy birthday to you girl friend" ); } } |
3.经纪人接受业务, 经纪人的构造函数需要和明星绑定
经纪人接收唱歌的业务，今天可能是周杰伦唱，明天可能经纪人换了明星，比如蔡依林也是可以的
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/** * 经纪人 */ public class JayProxy implements ISing{ ISing target; /** * 初始化的时候，和明星进行签约 * @param target */ public JayProxy(ISing target) { this .target = target; } @Override public void sing() { target.sing(); } } |
4.联系经纪人进行唱歌，周杰伦唱完歌之后，经纪人收钱，very happy
|
1 2 3 4 5 6 7 8 |
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 ,也不重复定义了，这次经纪人多签约了一个歌手，林俊杰，看下实现
|
1 2 3 4 5 6 7 8 9 10 |
package org.pdool.dynamic; /** * 林俊杰 */ public class JJImp implements ISing { @Override public void sing() { System.out.println( "I am JJ! happy birthday to you" ); } } |
第三步，经纪人可以动态派出签约歌手，注意经纪人要实现InvocationHandler，这样才能统一处理所有的方法调用
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
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( "收入 ++ " ); } } |
第四步，接收业务
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
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 的实现类
1、为什么编辑器可以提示接口的方法？因为强转编辑器才会能有提示
2、生成的内存class是的默认构造函数是需要InvocationHandler参数
3、创建代理class的核心参数是 类加载器，接口，还有InvocationHandler 子类。
类加载器保证和目标类在同一个加载器内，可以调用，防止不同加载器加载的类之间不能调用
接口就是你要代理的接口
InvocationHandler 子类是转发器，将所有的消息进行拦截处理转发
3、原理研究
实现看到了，探究下原理，动态代理的最根本的在于根据接口创建内存class，这一步是怎么实现的，我们跟着源码瞧一瞧
1、克隆接口里函数的信息
2、查找或生成指定的代理类，如果缓存中有，则用缓存的，没有则创建
3、通过反射，拿到代理类的构造函数
4、通过构造函数创建一个代理对象，并关联InvocationHandler 的对象
|
1 2 3 |
/** parameter types of a proxy class constructor */ private static final Class<?>[] constructorParams = { InvocationHandler. class }; |
看到了流程，我们看下代理class 到底是什么样子的，
|
1 2 3 4 5 6 7 8 |
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 到底有哪些东西，直接拖到编辑器就可以了
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
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中访问数据库的使用
|
1 2 3 4 |
import com.tao.springboot.hibernate.entity.Customer; import org.springframework.data.jpa.repository.JpaRepository; public interface CustomerRepository extends JpaRepository<Customer, Long> { } |
只要实现上面的接口就可以直接操作数据库，是不是很简单？
有几个问题，你稍微思考下：
1、两个泛型什么意思？
2、数据库连接在哪？是怎么注入的？
3、只实现接口是怎么操作数据库的？
第一个问题答案：
Customer 为表对象对应的entity实体。 Long 是表的主键类型，第二个答案：
数据库连接是在spring启动的时候自动注入到spring 容器中的，在JpaRepository 的实现类自动注入的
第三个答案：
所有的的接口在spring启动的时候会生成代理类，目标类target就是实现类SimpleJpaRepository
看下类图
看下JpaRepository的定义，都是一些常用方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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 的定义：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
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)); } |
类似下面的代码调用：
|
1 |
Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), JpaRepository. class .getInterfaces(), new SimpleJpaRepository(()); |
注：只是表达一下意思，具体的实现应该不是这样的
5、总结
所有的事情都解开了，下面进行总结下：
1、静态代理是代理模式的实现，是针对某一个具体的接口的实现
2、动态代理的是jdk提供的一种方式，必须要接口，还有其他的实现方式cglib,javassit 等等
3、动态代理是在运行的时候生成class 文件然后自动加载的class
4、动态代理是基于反射调用的技术
5、动态代理会生成class 到 metaspace
6、多应用在框架中
7、解密了spring data jpa的实现
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注的更多内容！
原文链接：https://gamwatcher.blog.csdn.net/article/details/118569408