资讯专栏INFORMATION COLUMN

java动态代理及原理

Forelax / 290人阅读

摘要:动态代理的产生就是这样而来的。在的方案中我们只需要这样做可以实现动态代理了。委托类实际执行类利用提供的实现动态代理代理环绕执行实际的方法利用的实现代理动态代理,有几个关键点,一个就是接口,这个方法中的方法是执行代理时会执行的方法。

什么是代理?

代理是一种设计模式,简单的说就是为某个对象提供代理,以控制这个对象的访问,在不修改原方法的情况下做方法增强,简单的可以分为两种:

静态代理

动态代理

静态代理

一般情况下的代理就是有一个接口,接口中定义了一些方法需要被实现,实现了那些方法的类被称为实现类,但是当我们需要在调用该方法前做一些额外的操作,又不想影响原来的代码,这时候就可以引入一个代理类,让代理类也实现该接口,然后将接口的那个实现类作为成员变量引入代理类中,额外操作时由代理类操作,具体到该方法时则由实现类去操作,下面举个例子;
public interface Calculator {

//需要代理的接口
public int add(int a,int b);
//接口实现类,执行真正的a+b操作
public static class CalculatorImpl implements Calculator{
    @Override
    public int add(int a, int b) {
        System.out.println("doing ");
        return a+b;
    }
}
//静态代理类的实现.代码已经实现好了.
public static class CalculatorProxy implements Calculator{
    private Calculator calculator;
    public CalculatorProxy(Calculator calculator) {
        this.calculator=calculator;
    }
    @Override
    public int add(int a, int b) {
        //执行一些操作
        System.out.println("begin ");
        int result = calculator.add(a, b);
        System.out.println("end ");
        return result;
    }
}

}

Calculator是一个计算器的接口类,定义了一个加法的接口方法,由CalculatorImpl类实现真正的加法操作.现在如果我们想对这个方法做一层静态的代理,这儿实现了一个简单的代理类实现了计算接口Calculator,构造函数传入的参数是真正的实现类,但是在调用这个代理类的add方法的时候我们在CalculatorImpl的实现方法执行的前后分别做了一些操作。这样的代理方式就叫做静态代理(这个是别人的例子,只是为了更加形象的展示静态代理,拿代码说话)。

很明显静态代理的缺点,由于我们需要事先实现代理类,那么每个方法我都都需要去实现。如果我们要实现很多的代理类,那么工作量就太大了。动态代理的产生就是这样而来的。

动态代理

使用动态代理可以让代理类在程序运行的时候生成代理类,我们只需要为一类代理写一个具体的实现类就行了,所以实现动态代理要比静态代理简单许多,省了不少重复的工作。在JDK的方案中我们只需要这样做可以实现动态代理了。
public class ProxyFactory implements InvocationHandler {

private Class target;
private Object real;
//委托类class
public ProxyFactory(Class target){
    this.target=target;
}
//实际执行类bind
public  Object bind(Object real){
    this.real=real;
    //利用JDK提供的Proxy实现动态代理
    return  Proxy.newProxyInstance(target.getClassLoader(),new Class[]{target},this);
}
@Override
public Object invoke(Object o, Method method, Object[] args) throws Throwable {
    //代理环绕
    System.out.println("begin");
    //执行实际的方法
    Object invoke = method.invoke(real, args);
    System.out.println("end");
    return invoke;
}

public static void main(String[] args) {
    Calculator proxy =(Calculator) new ProxyFactory(Calculator.class).bind(new Calculator.CalculatorImpl());
    proxy.add(1,2);
}

}
利用JDK的proxy实现代理动态代理,有几个关键点,一个就是InvocationHandler接口,这个方法中的invoke方法是执行代理时会执行的方法。所以我们所有代理需要执行的逻辑都会写在这里面,invo参数里面的method可以使用java 反射调用真实的实现类的方法,我们在这个方法周围做一些代理逻辑工作就可以了。上面的代码会把Calculator接口的所有方法全部在程序运行时代理。不用我们一个个的去写静态代理的方法。

JDK生成的代理类

public final class Calcultor$ProxyCode extends Proxy implements Calculator {

private static Method m1;
private static Method m4;
private static Method m0;
private static Method m3;
private static Method m2;

public Calcultor$ProxyCode(InvocationHandler var1) throws  {
    super(var1);
}

public final boolean equals(Object var1) throws  {
    try {
        return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
    } catch (RuntimeException | Error var3) {
        throw var3;
    } catch (Throwable var4) {
        throw new UndeclaredThrowableException(var4);
    }
}

public final int reduce(int var1, int var2) throws  {
    try {
        return ((Integer)super.h.invoke(this, m4, new Object[]{Integer.valueOf(var1), Integer.valueOf(var2)})).intValue();
    } catch (RuntimeException | Error var4) {
        throw var4;
    } catch (Throwable var5) {
        throw new UndeclaredThrowableException(var5);
    }
}

public final int hashCode() throws  {
    try {
        return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}

public final int add(int var1, int var2) throws  {
    try {
        return ((Integer)super.h.invoke(this, m3, new Object[]{Integer.valueOf(var1), Integer.valueOf(var2)})).intValue();
    } catch (RuntimeException | Error var4) {
        throw var4;
    } catch (Throwable var5) {
        throw new UndeclaredThrowableException(var5);
    }
}

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);
    }
}

static {
    try {
        //static静态块加载每个方法的Method对象
        m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
        m4 = Class.forName("jdkproxy.Calculator").getMethod("reduce", new Class[]{Integer.TYPE, Integer.TYPE});
        m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        m3 = Class.forName("jdkproxy.Calculator").getMethod("add", new Class[]{Integer.TYPE, Integer.TYPE});
        m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
}

}

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/67722.html

相关文章

  • java动态代理RPC框架介绍

    摘要:这种语法,在中被称为动态代理。在动态代理机制中,这个角色只能是接口。动态代理就是实现的技术之一。 所谓动态代理,指的是语言提供的一种语法,能够将对对象中不同方法的调用重定向到一个统一的处理函数中来。python重写__getattr__函数能够做到这一点,就连世界上最好的语言也提供称为魔术方法的__call。这种语法除了能更好的实现动态代理外,还是RPC框架实现原理的一部分。 动态代理...

    2shou 评论0 收藏0
  • Spring自定义注解不生效原因解析解决方法

    摘要:自定义注解不生效原因解析及解决方法背景项目中,自己基于实现了一套缓存注解。但是最近出现一种情况缓存竟然没有生效,大量请求被击穿到层,导致压力过大。至此,问题得到解决。 自定义注解不生效原因解析及解决方法 背景: 项目中,自己基于spring AOP实现了一套java缓存注解。但是最近出现一种情况:缓存竟然没有生效,大量请求被击穿到db层,导致db压力过大。现在我们看一下具体代码情形(代...

    xbynet 评论0 收藏0
  • 【Spring】一次线上@Transational事务注解未生效的原因探究

    摘要:由于的限制,无法替换被代理类已经被载入的字节码,只能生成并载入一个新的子类作为代理类,被代理类的字节码依然存在于中。区别于前两者,是一种静态代理的实现,即在编译时或者载入类时直接修改被代理类文件的字节码,而非运行时实时生成代理。 现象描述 上周同事发现其基于mySql实现的分布式锁的线上代码存在问题,代码简化如下: @Controller class XService { @A...

    姘存按 评论0 收藏0
  • 慕课网_《探秘Spring AOP》学习总结

    时间:2017年09月03日星期日说明:本文部分内容均来自慕课网。@慕课网:http://www.imooc.com 教学源码:https://github.com/zccodere/s...学习源码:https://github.com/zccodere/s... 第一章:课程介绍 1-1 面向切面 课程章节 概览 AOP使用 AOP原理 AOP开源运用 课程实战 课程总结 面向切面编程是一种...

    Tony_Zby 评论0 收藏0
  • Java三种代理模式:静态代理动态代理和cglib代理

    摘要:动态代理又被称为代理或接口代理。静态代理在编译时产生字节码文件,可以直接使用,效率高。代理无需实现接口,通过生成类字节码实现代理,比反射稍快,不存在性能问题,但会继承目标对象,需要重写方法,所以目标对象不能为类。 一、代理模式介绍 代理模式是一种设计模式,提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功...

    Kaede 评论0 收藏0

发表评论

0条评论

Forelax

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<