码迷,mamicode.com
首页 > 其他好文 > 详细

AOP-动态代理

时间:2020-05-18 00:34:17      阅读:51      评论:0      收藏:0      [点我收藏+]

标签:原则   抽象   应该   before   open   ack   closed   载器   splay   

动态代理的原理
代理设计模式的原理:使用一个代理将原本对象包装起来,然后用该代理对象”取代”原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

代理模式:可以理解为有两个对象,代理对象和目标对象,代理对象就是帮助我们完成这件事的对象,目标对象就是我们要去做的事情。动态代理就是无论目标对象是什么,都可以通过这样的一个类,去动态生成相对应的代理对象,帮助去完成相应的功能。更像是一个工具类,在任何情况下去生成一个代理对象。

代理对象生成以后,为什么也能帮助我们去实现最终的功能?

①代理对象知道要实现什么功能。②代理对象对接口中的抽象方法的实现,可以利用InvocationHandler来控制代理对象对功能的实现过程。

动态代理的方式
  1) 基于接口实现动态代理: JDK动态代理
  2) 基于继承实现动态代理: Cglib、Javassist动态代理

package com.atguigu.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {

    private MathImpl mathImpl;//目标对象,其实应该是Object
    
    public Object getProxy() {
        ClassLoader loader = this.getClass().getClassLoader();//类的加载器,创建一个代理类,动态生成一个动态代理类,执行就需要加载,需要指定一个类加载器
        Class[] interfaces = mathImpl.getClass().getInterfaces();//目标对象都有那些方法,代理对象通过获取其实现的接口确定,所以代理对象会和目标对象一样实现相同的接口
        return Proxy.newProxyInstance(loader, interfaces, new InvocationHandler() {//第三个参数:代理对象如何实现目标对象的方法
            //Java中的所有生成的动态代理类都继承于Proxy类
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return method.invoke(mathImpl, args);//代理模式原则要保证结果的一致性,可以让代理对象调用目标对象的方法就可以保证一致性
            }
        });
    }
    
}

实现对计算器的动态代理:

package com.atguigu.proxy;

import java.util.Properties;

public class Test {

    public static void main(String[] args) {
        
        /*MathI math = new MathImpl();
        int result = math.div(1, 1);
        System.out.println(result);*/
        
        ProxyUtil proxy = new ProxyUtil(new MathImpl());
        MathI math = (MathI)proxy.getProxy();  //注意不能使用目标对象类型,因为目标类可能还有接口标准之外的方法,所以要强转为接口变量引用
        int i = math.div(4, 1);
        System.out.println(i);
        
    }
    
}
package com.atguigu.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class ProxyUtil {

    private MathImpl mathImpl;
    
    
    
    public ProxyUtil(MathImpl mathImpl) {
        super();
        this.mathImpl = mathImpl;
    }



    public Object getProxy() {
        //获取当前类的类加载器,用来加载代理对象所属类
        ClassLoader loader = this.getClass().getClassLoader();
        //获取目标对象实现的所有接口的Class,代理类回合目标类实现相同的接口,最终通过代理对象实现功能
        Class[] interfaces = mathImpl.getClass().getInterfaces();
                
        return Proxy.newProxyInstance(loader, interfaces, new InvocationHandler() {
            
            //代理对象实现功能的方式
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // TODO Auto-generated method stub
                try {
                    MyLogger.before(method.getName(), Arrays.toString(args));
                    Object result = method.invoke(mathImpl, args);//动态代理对象实现功能
                    MyLogger.after(method.getName(), result);
                    return result;
                } catch (Exception e) {
                    // TODO: handle exception
                    MyLogger.throwing();
                    e.printStackTrace();
                } finally {
                    System.out.println("哪都有我");
                }
                return null;
            }
        });
    }
    
}
技术图片
package com.atguigu.proxy;

public interface MathI {

    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
    
}
interface MathI
技术图片
package com.atguigu.proxy;

public class MathImpl implements MathI {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }

    
    
}
MathImpl
技术图片
package com.atguigu.proxy;

public class MyLogger {

    public static void before(String methodName, String args) {
        System.out.println("method:"+methodName+",arguments:"+args);
    }
    
    public static void after(String methodName, Object reslut) {
        System.out.println("method:"+methodName+",reslut:"+reslut);
    }
    
    public static void throwing() {
        System.out.println("有异常了。。。。");
    }
    
}
MyLogger

 

AOP-动态代理

标签:原则   抽象   应该   before   open   ack   closed   载器   splay   

原文地址:https://www.cnblogs.com/lemonzhang/p/12907886.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!