java中动态代理实现机制

JAVA各种动态代理实现的比较

接口

interface AddInterface{
    int add(int a, int b);
}

interface SubInterface{
    int sub(int a, int b);
}

实现类

class Arithmetic implements AddInterface, SubInterface{
    @Override
    public int sub(int a, int b) {
        return a-b;
    }

    @Override
    public int add(int a, int b) {
        return a+b;
    }
}

方式1: JDK自带的动态代理

实现方式

　　Java在JDK1.3后引入的动态代理机制，使我们可以在运行期动态的创建代理类。使用动态代理实现AOP需要有四个角色：被代理的类，被代理类的接口，织入器，和InvocationHandler，而织入器使用接口反射机制生成一个代理类，然后在这个代理类中织入代码。被代理的类是AOP里所说的目标，InvocationHandler是切面，它包含了Advice和Pointcut。

InvocationHandler接口的实现

class JdkDPQueryHandler implements InvocationHandler{
    private Arithmetic real;
    public JdkDPQueryHandler(Arithmetic real){
        this.real = real;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        System.out.println(method);
        System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args));
        Object result = method.invoke(real, args);
        System.out.println("the method: "+methodName+"结束, 结果: " + result);
        return result;
    }
}

创建代理类并且调用代理类

public class Main{
    private static int a = 4, b = 2;

    public static Object createJDKProxy(Arithmetic real){
        Object proxyArithmetic = Proxy.newProxyInstance(real.getClass().getClassLoader(),
                real.getClass().getInterfaces(), new JdkDPQueryHandler(real));
        return proxyArithmetic;
    }

    public static void main(String[] args){
        Arithmetic real = new Arithmetic();
        Object proxyArithmetic = createJDKProxy(real);
        ((AddInterface)proxyArithmetic).add(a, b);
        ((SubInterface)proxyArithmetic).sub(a, b);
    }
}

方式2：动态字节码生成（cglib）

实现方式

　　Enhancer和MethodInterceptor。Enhancer可以用来动态的生成一个类，这个类可以继承指定的一个类，实现指定的一些接口。同时,Enhancer在生成一个类之前需要指定一个Callback，当类方法调用时，方法的执行被分配给这个Callback，MethodInterceptor是一个使用比较多的继承自Callback的接口，它只有一个方法声明。

接口InvocationHandler（jdk中）和接口MethodInterceptor（cglib中）对比

public interface MethodInterceptor extends Callback  {
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
}  
public interface InvocationHandler {
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

　  从参数构成上，methodInterceptor的输入参数比Invocationhandler多1个，其实前3个参数对象的含义与Invocationhandler的含义是相同的。

　　第一个参数表示调用方法来自哪个对象；

　　第二个参数表示调用方法的Method对象；

　　第三个参数表示此次调用的输入参数列表；

　　多出来的参数是MethodProxy 类型的，它应该是cglib生成用来代替Method对象的一个对象，使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升。

实现1

　　MethodInterceptor接口的实现

class CglibDPQueryInterceptor implements MethodInterceptor{
    private Arithmetic real;
    public CglibDPQueryInterceptor(Arithmetic real){
        this.real = real;
    }

    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        String methodName = method.getName();
        System.out.println(method);
        System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args));
        //Object result = method.invoke(real, args);//两种方式都是可以得
        Object result = proxy.invoke(real, args);
        System.out.println("the method: "+methodName+"结束, 结果: " + result);
        return result;
    }
}

　　创建代理类并调用代理类

public class Main{
    private static int a = 4, b = 2;
   public static Object createCglibProxy(Arithmetic real){
         Enhancer enhancer = new Enhancer();
         enhancer.setCallback(new CglibDPQueryInterceptor(real));
         enhancer.setInterfaces(real.getClass().getInterfaces());
         return enhancer.create();
    }

    public static void main(String[] args){
        Arithmetic real = new Arithmetic();
        Object proxyArithmetic = createCglibProxy(real);
        ((AddInterface)proxyArithmetic).add(a, b);
        ((SubInterface)proxyArithmetic).sub(a, b);
    }
}

　　注意了，MethodProxy在对执行函数的时候，提供了2个方法

public Object invoke (Object obj, Object[] args) throws Throwable
public Object invokeSuper(Object obj, Object[] args) throws Throwable

　　其中，javadoc上说这个invoke()方法可以用于相同类中的其他对象的方法执行，也就是说这个方法中的obj需要传入相同一个类的另一个对象（上述方法中就是传入了Arithmetic类的不同对象），否则会进入无限递归循环（测试之后还真是出现了StackOverflowError）。仔细的想一想就会发现，public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy)中的target是实现的代理类对象，通过target调用add()方法时会触发intercept()方法被调用，如果在intercept()方法中再调用method.invoke(target， args)，就相当于add()方法中又调用add()方法，导致无限的递归循环。但是如果执行method.invoke(real， args)则不会，因为real和target是同一个类不同对象，real是真实逻辑主题，target是真实主题real的代理。

　　下面一个例子来模拟一下：

interface SolveInterface{
    void solve();
}

class Real implements SolveInterface{
    public void solve(){
        System.out.println("Real Solve!");
    }
}

class Target extends Real{
    private Object obj;

    public void setObject(Object obj){
        this.obj = obj;
    }

    private void invoke(){
        try {
            Method method = SolveInterface.class.getMethod("solve", new Class[]{});
            method.invoke(obj, new Class[]{});
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void solve(){
        System.out.println("Target Solve!");
        invoke();
    }
}

　　

public class Main{public static void main(String[] args) throws Exception{
        Target target = new Target();
        target.setObject(new Real());//正确        //target.setObject(target);//发生循环调用
        target.solve();
    }
}

　　其实Method的invoke()方法会根据obj的类型去调用对应的solve()方法，也就是多态性。

实现2

　　MethodInterceptor接口的实现

class CglibDPQueryInterceptor implements MethodInterceptor{

    @Override
    public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        String methodName = method.getName();
        System.out.println(method);
        System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args));
        //  打印类信息 ：target.getClass()；省略
        Object result = proxy.invokeSuper(target, args);
        System.out.println("the method: "+methodName+"结束, 结果: " + result);
        return result;
    }
}

　　创建代理类并调用代理类

public class Main{
    private static int a = 4, b = 2;
public static Object createCglibProxy(){
         Enhancer enhancer = new Enhancer();
         enhancer.setCallback(new CglibDPQueryInterceptor());
         enhancer.setSuperclass(Arithmetic.class);
         return enhancer.create();
    }

    public static void main(String[] args){
        Arithmetic real = new Arithmetic();

        Object proxyArithmetic = createCglibProxy();

        ((AddInterface)proxyArithmetic).add(a, b);
        ((SubInterface)proxyArithmetic).sub(a, b);
    }
}

　　注意了，实现2中Enhancer 没有设置接口，因为设置了Superclass了（也就是代理类的父类是Arithmetic），我们的代理类会继承它，而Arithmetic已经实现了我们的接口。为了证明这一点，可以在MethodInterceptor的 intercept方法中打印 target.getClass()的类信息，你会发现cglib的两种方式代理类的父类是不同的。如下：

　　（如果需要打印类信息代码，请参考：http://www.cnblogs.com/hujunzheng/p/5132943.html）

　　实现1：

public class com.test.Arithmetic$$EnhancerByCGLIB$$4fa786eb extends java.lang.Object

　　实现2：

public class com.test.Arithmetic$$EnhancerByCGLIB$$4fa786eb extends com.test.Arithmetic

方式3：javassist生成动态代理（代理工厂创建 或者 动态代码创建）　　

　　Javassist是一个编辑字节码的框架，可以让你很简单地操作字节码。它可以在运行期定义或修改Class。使用Javassist实现AOP的原理是在字节码加载前直接修改需要切入的方法。这比使用Cglib实现AOP更加高效，并且没太多限制，实现原理如下图：

实现1：

接口的实现

class JavassistDPQueryHandler implements MethodHandler{

    @Override
    public Object invoke(Object target, Method method, Method proxy, Object[] args) throws Throwable {
        String methodName = method.getName();
        System.out.println(method);
        System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args));
        Object result = proxy.invoke(target, args);
        System.out.println("the method: "+methodName+"结束, 结果: " + result);
        return result;
    }
}

创建代理类并调用代理类

public class Main{
    private static int a = 4, b = 2;
public static Object createJavassistProxy() throws Exception{
        ProxyFactory factory = new ProxyFactory();
        factory.setSuperclass(Arithmetic.class);
        factory.setHandler(new JavassistDPQueryHandler());
        return factory.createClass().newInstance();
    }

    public static void main(String[] args) throws Exception{
        Arithmetic real = new Arithmetic();

        Object proxyArithmetic = createJavassistProxy();

        ((AddInterface)proxyArithmetic).add(a, b);
        ((SubInterface)proxyArithmetic).sub(a, b);
    }
}

　　注意：MethodHandler接口中invoke方法的定义，如下：

public Object invoke(Object target, Method method, Method proxy, Object[] args)

　　method代表调用方法的Method对象，proxy是代理类产生并代替method的对象，否则用method.invoke(target, args)会产生无限循环调用。

实现2：

　　（来自：http://cuishen.iteye.com/blog/421464），代码注释很详细，仔细研究一下就会懂了！

　　javassist使用动态java代码常见代理过程和前文的方法略有不同。javassist内部可以通过动态java代码，生成字节码。这种方式创建的动态代理可以非常灵活，甚至可以在运行时产生业务逻辑。

//自定义拦截器接口interface InterceptorHandler {  

    /**
     * 调用动态代理对象的方法将反射本方法，可在本方法实现中添加类似AOP的事前事后操作，只有在本方法体中加入如下代码
     * 被代理的方法才会被执行，返回值将返回给代理最后返回给程序
     * @param obj Object 被代理的对象
     * @param method Method 被代理对象的方法
     * @param args Object[] 被代理对象的方法的参数
     * @return Object 被代理对象的方法执行后的返回值
     * @throws Throwable
     */
    public Object invoke(Object obj, Method method, Object[] args) throws Throwable;
}
//拦截器的实现
class InterceptorHandlerImpl implements InterceptorHandler{
    @Override
    public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        System.out.println(method);
        System.out.println("the method: " + methodName + "开始, 参数: "+Arrays.asList(args));
        Object result = method.invoke(obj, args);
        System.out.println("the method: "+methodName+"结束, 结果: " + result);
        return result;
    }
}

class MyProxyImpl {
    /** 动态代理类的类名后缀 */
    private final static String PROXY_CLASS_NAME_SUFFIX = "$MyProxy_";
    /** 拦截器接口 */
    private final static String INTERCEPTOR_HANDLER_INTERFACE = "com.test.InterceptorHandler";
    /** 动态代理类的类名索引，防止类名重复 */
    private static int proxyClassIndex = 1;  

    /**
     * 暴露给用户的动态代理接口，返回某个接口的动态代理对象，注意本代理实现需和com.cuishen.myAop.InterceptorHandler拦截器配合
     * 使用，即用户要使用本动态代理，需先实现com.cuishen.myAop.InterceptorHandler拦截器接口
     * @param interfaceClassName String 要动态代理的接口类名, e.g test.StudentInfoService
     * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
     * @param interceptorHandlerImplClassName String 用户提供的拦截器接口的实现类的类名
     * @return Object 返回某个接口的动态代理对象
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws NotFoundException
     * @throws CannotCompileException
     * @throws ClassNotFoundException
     * @see com.cuishen.myAop.InterceptorHandler
     */
    public static Object newProxyInstance(String interfaceClassName, String classToProxy, String interceptorHandlerImplClassName) throws InstantiationException, IllegalAccessException, NotFoundException, CannotCompileException, ClassNotFoundException {
        Class interfaceClass = Class.forName(interfaceClassName);
        Class interceptorHandlerImplClass = Class.forName(interceptorHandlerImplClassName);
        return dynamicImplementsInterface(classToProxy, interfaceClass, interceptorHandlerImplClass);
    }  

    /**
     * 动态实现要代理的接口
     * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
     * @param interfaceClass Class 要动态代理的接口类, e.g test.StudentInfoService
     * @param interceptorHandlerImplClass Class 用户提供的拦截器接口的实现类
     * @return Object 返回某个接口的动态代理对象
     * @throws NotFoundException
     * @throws CannotCompileException
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
    private static Object dynamicImplementsInterface(String classToProxy, Class interfaceClass, Class interceptorHandlerImplClass) throws NotFoundException, CannotCompileException, InstantiationException, IllegalAccessException {
        ClassPool cp = ClassPool.getDefault();
        String interfaceName = interfaceClass.getName();
        //动态指定代理类的类名
        String proxyClassName = interfaceName + PROXY_CLASS_NAME_SUFFIX + proxyClassIndex++;
        //要实现的接口的包名+接口名
        String interfaceNamePath = interfaceName;  

        CtClass ctInterface = cp.getCtClass(interfaceNamePath);
        CtClass cc = cp.makeClass(proxyClassName);
        cc.addInterface(ctInterface);
        Method [] methods = interfaceClass.getMethods();
        for(int i = 0; i < methods.length; i++) {
            Method method = methods[i];
            dynamicImplementsMethodsFromInterface(classToProxy, cc, method, interceptorHandlerImplClass, i);
        }
        return (Object)cc.toClass().newInstance();
    }  

    /**
     * 动态实现接口里的方法
     * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
     * @param implementer CtClass 动态代理类的包装
     * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装
     * @param interceptorClass Class 用户提供的拦截器实现类
     * @param methodIndex int 要实现的方法的索引
     * @throws CannotCompileException
     */
    private static void dynamicImplementsMethodsFromInterface(String classToProxy, CtClass implementer, Method methodToImpl, Class interceptorClass, int methodIndex) throws CannotCompileException {
        String methodCode = generateMethodCode(classToProxy, methodToImpl, interceptorClass, methodIndex);
        CtMethod cm = CtNewMethod.make(methodCode, implementer);
        implementer.addMethod(cm);
    }  

    /**
     * 动态组装方法体，当然代理里面的方法实现并不是简单的方法拷贝，而是反射调用了拦截器里的invoke方法，并将接收到的参数进行传递
     * @param classToProxy String 要动态代理的接口的实现类的类名, e.g test.StudentInfoServiceImpl
     * @param methodToImpl Method 动态代理类里面要实现的接口方法的包装
     * @param interceptorClass Class 用户提供的拦截器实现类
     * @param methodIndex int 要实现的方法的索引
     * @return String 动态组装的方法的字符串
     */
    private static String generateMethodCode(String classToProxy, Method methodToImpl, Class interceptorClass, int methodIndex) {
        String methodName = methodToImpl.getName();
        String methodReturnType = methodToImpl.getReturnType().getName();
        Class[] parameters = methodToImpl.getParameterTypes();
        Class[] exceptionTypes = methodToImpl.getExceptionTypes();
        StringBuffer exceptionBuffer = new StringBuffer();
        //组装方法的Exception声明
        if(exceptionTypes.length > 0) exceptionBuffer.append(" throws ");
        for(int i = 0; i < exceptionTypes.length; i++) {
            if(i != exceptionTypes.length - 1) exceptionBuffer.append(exceptionTypes[i].getName()).append(",");
            else exceptionBuffer.append(exceptionTypes[i].getName());
        }
        StringBuffer parameterBuffer = new StringBuffer();
        //组装方法的参数列表
        for(int i = 0; i < parameters.length; i++) {
            Class parameter = parameters[i];
            String parameterType = parameter.getName();
            //动态指定方法参数的变量名
            String refName = "a" + i;
            if(i != parameters.length - 1) parameterBuffer.append(parameterType).append(" " + refName).append(",");
            else parameterBuffer.append(parameterType).append(" " + refName);
        }
        StringBuffer methodDeclare = new StringBuffer();
        //方法声明，由于是实现接口的方法，所以是public
        methodDeclare.append("public ").append(methodReturnType).append(" ").append(methodName).append("(").append(parameterBuffer).append(")").append(exceptionBuffer).append(" {\n");
        String interceptorImplName = interceptorClass.getName();
        //方法体
        methodDeclare.append(INTERCEPTOR_HANDLER_INTERFACE).append(" interceptor = new ").append(interceptorImplName).append("();\n");
        //反射调用用户的拦截器接口
        methodDeclare.append("Object returnObj = interceptor.invoke(Class.forName(\"" + classToProxy + "\").newInstance(), Class.forName(\"" + classToProxy + "\").getMethods()[" + methodIndex + "], ");
        //传递方法里的参数
        if(parameters.length > 0) methodDeclare.append("new Object[]{");
        for(int i = 0; i < parameters.length; i++) {
            //($w) converts from a primitive type to the corresponding wrapper type: e.g.
            //Integer i = ($w)5;
            if(i != parameters.length - 1) methodDeclare.append("($w)a" + i + ",");
            else methodDeclare.append("($w)a" + i);
        }
        if(parameters.length > 0) methodDeclare.append("});\n");
        else methodDeclare.append("null);\n");
        //对调用拦截器的返回值进行包装
        if(methodToImpl.getReturnType().isPrimitive()) {
            if(methodToImpl.getReturnType().equals(Boolean.TYPE)) methodDeclare.append("return ((Boolean)returnObj).booleanValue();\n");
            else if(methodToImpl.getReturnType().equals(Integer.TYPE)) methodDeclare.append("return ((Integer)returnObj).intValue();\n");
            else if(methodToImpl.getReturnType().equals(Long.TYPE)) methodDeclare.append("return ((Long)returnObj).longValue();\n");
            else if(methodToImpl.getReturnType().equals(Float.TYPE)) methodDeclare.append("return ((Float)returnObj).floatValue();\n");
            else if(methodToImpl.getReturnType().equals(Double.TYPE)) methodDeclare.append("return ((Double)returnObj).doubleValue();\n");
            else if(methodToImpl.getReturnType().equals(Character.TYPE)) methodDeclare.append("return ((Character)returnObj).charValue();\n");
            else if(methodToImpl.getReturnType().equals(Byte.TYPE)) methodDeclare.append("return ((Byte)returnObj).byteValue();\n");
            else if(methodToImpl.getReturnType().equals(Short.TYPE)) methodDeclare.append("return ((Short)returnObj).shortValue();\n");
        } else {
            methodDeclare.append("return (" + methodReturnType + ")returnObj;\n");
        }
        methodDeclare.append("}");
        System.out.println(methodDeclare.toString());
        return methodDeclare.toString();
    }  

}  

public class Main{
    public static void main(String[] args) throws Exception{    　　　　 //分别对应 代理类要实现的接口类名， 需要代理类的类名， 用户自定义拦截器实现类的类名
        Object proxyArithmetic = MyProxyImpl.newProxyInstance("com.test.ArithmeticInterface", "com.test.Arithmetic", 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　"com.test.InterceptorHandlerImpl");
        ((ArithmeticInterface)proxyArithmetic).add(a, b);
        ((ArithmeticInterface)proxyArithmetic).sub(a, b);
    }
}

　　打印一下动态实现接口的代码如下：

public int add(int a0,int a1) {
com.test.InterceptorHandler interceptor = new com.test.InterceptorHandlerImpl();
Object returnObj = interceptor.invoke(Class.forName("com.test.Arithmetic").newInstance(), Class.forName("com.test.Arithmetic").getMethods()[0], new Object[]{($w)a0,($w)a1});
return ((Integer)returnObj).intValue();
}
public int sub(int a0,int a1) {
com.test.InterceptorHandler interceptor = new com.test.InterceptorHandlerImpl();
Object returnObj = interceptor.invoke(Class.forName("com.test.Arithmetic").newInstance(), Class.forName("com.test.Arithmetic").getMethods()[1], new Object[]{($w)a0,($w)a1});
return ((Integer)returnObj).intValue();
}
时间： 2024-08-08 01:09:09

java中动态代理实现机制的相关文章

java中动态代理

一.在java中怎样实现动态代理 1.我们要有一个接口,还要有一个接口的实现类,而这个实现类呢就是我们要代理的对象 接口: 1 package org.dynamicproxy.test; 2 3 public interface UserDao { 4 public void addUser(User user); 5 } 接口的实现类(即要代理的对象): 1 package org.dynamicproxy.test; 2 3 public class UserDaoMysqlImpl im

Java中动态代理技术生成的类与原始类的区别 （转）

用动态代理的时候,对它新生成的类长什么样子感到好奇.有幸通过一些资料消除了心里的疑惑. 平时工作使用的Spring框架里面有一个AOP(面向切面)的机制,只知道它是把类重新生成了一遍,在切面上加上了后来定义的逻辑.这样就达到了动态的在原有类上增加一些功能.比如日志打印,拦截信息等. 这里只关心动态代理技术生成新的类,先不管虚拟机是如何去生成类,用了什么字节码生成技术,怎么产生字节码等这一系列动作.现在只关心最后生成的新类长什么样,它和老类有什么区别.为了获取到生成后的代理类的字节码并且反编译成我

Java中动态代理实现原理深究

一.前言 笔者平时开发使用"动态代理"不多,最近在看设计模式的时候,"动态代理"又在面前晃了几次,所以这次想从源码的角度去分析动态代理的实现原理,以窥探其精妙~ 二.正文 2.1 静态代理  本文源码基于:jdk1.6.0_33 在正式剖析动态代理的源码之前,我们可以先来看看"静态代理"(就是我们普通的代理模式)的UML图: 从上图可以看出,代理类"ProxySubject"和被代理类"RealSubject&quo

java中动态代理的实现

动态代理的实现 使用的模式:代理模式.代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问.类似租房的中介. 两种动态代理:(1)jdk动态代理,jdk动态代理是由Java内部的反射机制来实现的,目标类基于统一的接口(InvocationHandler)(2)cglib动态代理,cglib动态代理底层则是借助asm来实现的,cglib这种第三方类库实现的动态代理应用更加广泛,且在效率上更有优势. 主要应用的框架:Spring中的AOP,Struts2中的拦截器 具体实现: 1.定义接口

java JDK动态代理的机制

一:前言 自己在稳固spring的一些特性的时候在网上看到了遮掩的一句话“利用接口的方式,spring aop将默认通过JDK的动态代理来实现代理类,不适用接口时spring aop将使用通过cglib 来实现代理类",我对JDK的动态代理机制其实一点都不了解,学习java的时候也是只是知道会用,会去查api的文档就行,所以这些底层的操作方式我自己不是很清楚,现在既然要了解一些底层的代码,就谢谢自己的想发,大部分都是差不多的. 二:实现 先给出接口和实现类的代码: UserDao.java: p

Java中动态代理方式：

JDK中生成代理对象的API 代理类所在包:java.lang.reflect.ProxyJDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是: static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h ) 注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为: ClassLoader loader,:指定当

java的动态代理机制详解

在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于 Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是 java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾. 在java的动态代理机制中,有两个重要的类或接口,一个是 InvocationHandler(Interface).另一个则是 Proxy(Cla

（转）java的动态代理机制详解

原文出自:http://www.cnblogs.com/xiaoluo501395377/p/3383130.html 在学习Spring的时候,我们知道Spring主要有两大思想,一个是IoC,另一个就是AOP,对于IoC,依赖注入就不用多说了,而对于Spring的核心AOP来说,我们不但要知道怎么通过AOP来满足的我们的功能,我们更需要学习的是其底层是怎么样的一个原理,而AOP的原理就是java的动态代理机制,所以本篇随笔就是对java的动态机制进行一个回顾. 在java的动态代理机制中,有

[转载] java的动态代理机制详解

转载自http://www.cnblogs.com/xiaoluo501395377/p/3383130.html 代理模式 代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务. 按照代理的创建时期,代理类可以分为两种. 静态代理