`
zhoumeng87
  • 浏览: 71579 次
文章分类
社区版块
存档分类
最新评论

JAVA静态&动态代理

JAVA静态&动态代理 
阅读更多

具体场景

  • 为了使代理类和被代理类对第三方有相同的函数，代理类和被代理类一般实现一个公共的interface，该interface定义如下
    public interface Calculator {
    public Integer add(Integer num1, Integer num2);
    public Integer minus(Integer num1, Integer num2);
}
  • 被代理类定义如下
    public class CalculatorImpl implements Calculator {

    @Override
    public Integer add(Integer num1, Integer num2) {
        int ret = num1 + num2;
        System.out.println("in calculatorImpl, res: " + ret);
        return ret;
    }
    
    @Override
    public Integer minus(Integer num1, Integer num2) {
        int ret = num1 - num2;
        System.out.println("int calculatorImpl, res: " + ret);
        return ret;
    }

}
  • 官网：www.fhadmin.org 代理需求：在add函数和minus函数调用前后分别输出before invocation和after invocation字样

静态代理解决方案

  • 代码如下：简单直接，无需赘言，如果calculator里边不仅有add和minus，还有divide，product,log,sin…呢，呵呵哒
    public class StaticCalculatorProxy implements Calculator {
    Calculator obj;
    
    public StaticCalculatorProxy(Calculator obj) {
        this.obj = obj;    
    }

    @Override
    public Integer add(Integer num1, Integer num2) {
        System.out.println("in StaticCalculatorProxy, before invocation");
        Integer ret = obj.add(num1, num2);
        System.out.println("in StaticCalculatorProxy, after invocation");
        return ret;
    }

    @Override
    public Integer minus(Integer num1, Integer num2) {
        System.out.println("in StaticCalculatorProxy, before invocation");
        Integer ret = obj.minus(num1, num2);
        System.out.println("in StaticCalculatorProxy, after invocation");
        return ret;
    }

}

动态代理解决方案

  • 首先编写实现InvocationHandler接口的类 官网：www.fhadmin.org，用于请求转发，实现如下
    public class CalculatorHandler implements InvocationHandler {
    
    private Object obj; //被代理类
    
    public CalculatorHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("in calculatorhandler, before invocation");
        
        Object ret = method.invoke(obj, args);  //执行被代理类方法
        
        System.out.println("in calculationhandler, after invocation");
        return ret;
    }

}
  • 生成动态代理
    CalculatorImpl calculatorImpl = new CalculatorImpl();//被代理类
CalculatorHandler calculatorHandler = new CalculatorHandler(calculatorImpl);
Calculator calculator = (Calculator) Proxy.newProxyInstance(calculatorImpl.getClass().getClassLoader(), calculatorImpl.getClass().getInterfaces(), calculatorHandler);
System.out.println(calculator.add(1,2));
System.out.println(calculator.minus(1, 2));

    无论calculator中包含多少函数，动态代理只需实现一次，实际工程中，System.out.println(“in calculatorhandler, before invocation”)可能是加缓存，打日志等操作

动态代理工作原理

  • 为了搞清楚动态代理如何工作，首先看看生成的动态代理的代码是什么，借助[1]中ProxyUtil代码
    public class ProxyUtils {

    /**
     * Save proxy class to path
     * 
     * @param path path to save proxy class官网：www.fhadmin.org
     * @param proxyClassName name of proxy class
     * @param interfaces interfaces of proxy class
     * @return
     */
    public static boolean saveProxyClass(String path, String proxyClassName, Class[] interfaces) {
        if (proxyClassName == null || path == null) {
            return false;
        }

        // get byte of proxy class
        byte[] classFile = ProxyGenerator.generateProxyClass(proxyClassName, interfaces);
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }
}
  • 得到了生成的动态代理代码如下：
    public final class $Proxy0 extends Proxy
    implements Calculator
{

    public $Proxy0(InvocationHandler invocationhandler)
    {
        super(invocationhandler);
    }

    public final boolean equals(Object obj)
    {
        try
        {
            return ((Boolean)super.h.invoke(this, m1, new Object[] {
                obj
            })).booleanValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final String toString()
    {
        try
        {
            return (String)super.h.invoke(this, m2, null);
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final Integer minus(Integer integer, Integer integer1)
    {
        try
        {
            return (Integer)super.h.invoke(this, m4, new Object[] {
                integer, integer1
            });
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final Integer add(Integer integer, Integer integer1)
    {
        try
        {
            return (Integer)super.h.invoke(this, m3, new Object[] {
                integer, integer1
            });
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode()
    {
        try
        {
            return ((Integer)super.h.invoke(this, m0, null)).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

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

    static 
    {
        try
        {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                Class.forName("java.lang.Object")
            });
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.langrx.mq.Calculator").getMethod("minus", new Class[] {
                Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")
            });
            m3 = Class.forName("com.langrx.mq.Calculator").getMethod("add", new Class[] {
                Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")
            });
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        }
        catch(NoSuchMethodException nosuchmethodexception)
        {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
}
  • 有点长，按照初始化顺序慢慢来分析，首先分析静态代码块：
    m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                    Class.forName("java.lang.Object")
                });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m4 = Class.forName("com.langrx.mq.Calculator").getMethod("minus", new Class[] {
                    Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")
                });
m3 = Class.forName("com.langrx.mq.Calculator").getMethod("add", new Class[] {
                    Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")
                });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

    得到公共interface中的add函数和minus函数对应的Method方法，同事也得到了equals，toString，hashCode三个函数的Method，所以调用代理类的equals，toString，hashCode也是要执行被代理类的方法的，知道这点很有必要

  • 构造函数
    public $Proxy0(InvocationHandler invocationhandler)
{
        super(invocationhandler);
}

    初始化了内部的InvocationHandler变量，也就是下文的super.h

  • 以add为例看一下请求的转发
    public final Integer add(Integer integer, Integer integer1)
{
    try
    {
        return (Integer)super.h.invoke(this, m3, new Object[] {
            integer, integer1
        });
    }
    catch(Error _ex) { }
    catch(Throwable throwable)
    {
        throw new UndeclaredThrowableException(throwable);
    }
}

    super.h.invoke就是invocationhandler.invoke就是传入的CalculatorHandler中实现的

    @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("in calculatorhandler, before invocation");
    
    Object ret = method.invoke(obj, args);  //执行被代理类方法
    
    System.out.println("in calculationhandler, after invocation");
    return ret;
}

    最终执行的就是CalculatorHandler对应的invoke函数

总结

Calculator calculator = (Calculator) Proxy.newProxyInstance(calculatorImpl.getClass().getClassLoader(), calculatorImpl.getClass().getInterfaces(), calculatorHandler);

生成动态代理的过程步骤如下[2]：

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..); 
 
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
 
// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 
 
// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

Proxy.newProxyInstance帮我们做了2，3，4步，直接返回给我们一个动态代理对象，代理对象最终执行InvocationHandler中invoke函数。顺便强推文章[2]

0
顶
0
踩
分享到：
| JAVA 单列集合总结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JAVA静态代理和动态代理

    Java提供了两种主要的代理实现方式：静态代理和动态代理。 **静态代理** 静态代理是程序员手动创建代理类并实现与目标对象相同的接口。代理类和目标类都必须实现相同的接口，这样代理类就可以在调用目标对象方法的...

    Java静态代理与动态代理demo

    Java提供了两种实现代理模式的方式：静态代理和动态代理。 **静态代理** 静态代理是在编译时就已经确定了代理类，通过继承或实现目标接口来创建代理类。以下是一个简单的静态代理实现示例： ```java // 目标接口 ...

    Java静态代理和动态代理

    与静态代理不同，动态代理在程序运行时生成，利用Java的反射API动态创建代理类。动态代理适用于那些在运行时才知道需要代理的对象或者代理行为的情况。Java提供了`java.lang.reflect.Proxy`类和`java.lang.reflect....

    java静态代理、动态代理、装饰设计模式

    Java提供了两种实现代理的主要方式：静态代理和动态代理。 **静态代理** 静态代理是最基础的形式，它需要程序员手动创建一个代理类，该类实现了与目标类相同的接口。代理类持有目标类的引用，并在调用目标类方法...

    Java设计模式——代理设计模式（静态代理和动态代理）

    代理设计模式分为静态代理和动态代理两种类型。 ### 静态代理 静态代理是在编译时就已经确定了代理关系，代理类和真实类的关系是硬编码在代理类中的。下面我们将详细介绍静态代理的实现方式： 1. **定义接口**：...

    java 静态代理和动态代理学习实例源码

    代理模式通常分为静态代理和动态代理两种类型，这两种代理方式各有特点，适用于不同的场景。 **静态代理** 静态代理是通过程序员手动创建一个代理类来实现的。代理类和真实目标类需要实现相同的接口，以便代理类...

    java提高-动态代理与静态代理.docx

    java提高-动态代理与静态代理.docx

    Java 静态代理模式

    Java静态代理模式是一种设计模式，它允许我们为一个对象提供一个代理，以便增强或扩展其功能，同时不改变原有对象的代码。在Java中，静态代理是通过在代理类中显式实现目标接口来实现的。下面将详细介绍静态代理模式...

    Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）

    Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...

    java静态代理和动态代理详解

    在Java中，代理主要分为静态代理和动态代理。 1. 静态代理： 静态代理是在编译时就已经明确代理类与被代理类关系的一种方式。为了实现静态代理，我们需要手动创建一个代理类，这个代理类通常会实现与被代理类相同的...

    java静态代理和动态代理

    Java提供了两种主要的代理实现方式：静态代理和动态代理。 ### 静态代理 静态代理是在编译时就已经确定了代理关系。首先，我们需要定义一个接口，比如`Car`，这个接口描述了汽车的行为： ```java public ...

    java静态代理与动态代理

    ### Java静态代理与动态代理详解 #### 一、代理模式概述 代理模式是软件工程领域中常用的一种设计模式，尤其在Java开发中极为常见。它主要用于控制对某个对象的访问，或者提供额外的功能如日志记录、性能追踪、...

    静态代理动态代理测试，模拟jdk实现动态代理

    代理模式分为静态代理和动态代理两种主要形式。 **静态代理**是程序员手动创建代理类，这个代理类与真实被代理的对象（目标对象）实现相同的接口。代理类在调用目标对象方法时，可以加入额外的操作，如日志记录、...

    静态代理和动态代理Demo

    静态代理和动态代理是两种常见的代理模式，它们在Java中有着广泛的应用，特别是在SpringBoot等框架中。本资源提供了一个简单的Java实现，适用于JDK1.8版本，并经过了验证，对初学者理解设计模式具有指导意义。 静态...

    静态代理和动态代理

    根据实现方式的不同，代理模式可以分为静态代理和动态代理两种。 ### 静态代理 静态代理是在编译时就已经确定了代理关系。我们需要创建一个代理类，该类实现与目标对象相同的接口，并在代理类的方法中调用目标对象...

    包含静态代理和动态代理demo代码

    在这个“包含静态代理和动态代理demo代码”的压缩包中，我们可能会看到两种常见的Java代理实现方式的示例：静态代理和动态代理。 首先，我们来详细讲解静态代理。在静态代理中，代理类和真实类（目标类）都是在编译...

Magicbox
Global site tag (gtag.js) - Google Analytics