找周杰伦唱首歌,可能是最好懂的动态代理

广告电梯第三方检测机构选[中腾检测]-专业检测×

好几天不写文章,今天来写一篇,从之前的计划表上看到还有关于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;    /**     * 初始化的时候,和明星进行签约     * @param target     */    public JayProxy(ISing target) {        this.target = target;    }    @Override    public void sing() {        target.sing();    }}联系经纪人进行唱歌,周杰伦唱完歌之后,经纪人收钱,very happypublic 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("收入 ++  ");    }}第四步,接收业务

package org.pdool.dynamic;import java.lang.reflect.Proxy;public class Aain {    public static void main(String[] args) {        JayImp jayImp = new JayImp();        ISing subjectProxy=(ISing) Proxy.newProxyInstance(jayImp.getClass().getClassLoader(), jayImp.getClass().getInterfaces(), new JayAgentFactory(jayImp));        subjectProxy.sing();    }}总结:动态代理是Java提供的实现方式,需要InvocationHandler 的实现类

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

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

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

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

接口就是你要代理的接口

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

3、原理研究

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

广告速达软件是永久使用的吗?×

1、克隆接口里函数的信息

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

3、通过反射,拿到代理类的构造函数

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

/** parameter types of a proxy class constructor */    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> {}只要实现上面的接口就可以直接操作数据库,是不是很简单?

有几个问题,你稍微思考下:

1、两个泛型什么意思?

2、数据库连接在哪?是怎么注入的?

3、只实现接口是怎么操作数据库的?

第一个问题答案:

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

Long 是表的主键类型,

第二个答案:

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

第三个答案:

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

看下类图

广告国内高匿免费http代理ip 快代理×

看下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、总结

所有的事情都解开了,下面进行总结下:

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

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

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

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

5、动态代理会生成class 到 metaspace

6、多应用在框架中

7、解密了spring data jpa的实现

常规福利

赶紧点赞!!!!