欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

动态代理和AOP

程序员文章站 2022-09-26 13:55:24
之前说过了我对IOC的理解,这篇文章说以下我对动态代理和基本的对AOP的理解。 所谓动态代理就是,在运行时,动态创建实现了一组指定接口的实现类对象。 比如有: 即: o实现了A和B两个接口 但是我们在运行时是无法写源代码来进行这个类的创建。 这时候我们需要用到Proxy类下的newProxyInst ......

之前说过了我对IOC的理解,这篇文章说以下我对动态代理和基本的对AOP的理解。

所谓动态代理就是,在运行时,动态创建实现了一组指定接口的实现类对象。

比如有:

interface A {
}
interface B{
}

即:

Object o = 方法(new Class[] {A.class,B.class}) ,

o实现了A和B两个接口

但是我们在运行时是无法写源代码来进行这个类的创建。

这时候我们需要用到Proxy类下的newProxyInstance()方法。

 

1.newProxyInstance()方法

Object proxyObject = Proxy.newProxyInstance(ClassLoader classLoader, Class[] interfaces, InvocationHandler h);

1. 方法作用:动态创建实现了interfaces数组中所有指定接口的实现类对象!

参数;

1. ClassLoader:类加载器!

  * 它是用来加载器的,把.class文件加载到内存,形成Class对象!

2. Class[] interfaces:指定要实现的接口们

3. InvocationHandler:代理对象的所有方法(个别不执行,getClass())都会调用InvocationHandler的invoke()方法。

我们来看这个方法的使用方式:

public class Demo1 {
    @Test
    public void fun1() {
        /* 1. ClassLoader
         * 方法需要动态生成一个类,这个类实现了A、B接口,然后创建这个类的对象!
         * 需要生成一个类,这个类也需要加载到方法区中,谁来加载,当然是ClassLoader!!!
         * 2. Class[] interfaces
         * 它是要实现的接口们
         * 3. InvocationHandler
         * 它是调用处理器 
         * 代理对象的实现的所有接口中的方法,内容都是调用InvocationHandler的invoke()方法。
         */
        ClassLoader loader = this.getClass().getClassLoader();//把当前使用的这个类的类加载器给代理对象使用
        InvocationHandler h = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out.println("动态代理!");
                return "xxx";
            }
        };
        // 使用三大参数创建代理对象!!!
        Object o = Proxy.newProxyInstance(loader, new Class[]{A.class, B.class}, h);
        // 强转成A和B类型 
        A a = (A) o;
        B b = (B) o;
        
        Object result = a.aaa("hello", 100);
        System.out.println(result);
    }
}

和两个接口:

interface A {
    public void a();
    public void aa();
    public Object aaa(String s, int i);
}

interface B {
    public void b();
    public void bb();
}

将o强转成A和B类型后,可以调用A接口中的方法和B接口中的方法,但是不论调用什么方法最中都是调用的InvocationHandler中的 invoke方法即打印输出动态代理!但是除此之外所有的Object中的非本地方法都是输出这个结果,这是因为Native方法不是用Java编写的所有就不需要管这个部分。

 

2.InvocationHandler接口其中只有invoke一种方法:

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

 

这个invoke()方法在调用代理对象所实现接口中的方法时被创建

* Object proxy:当前对象,即代理对象!在调用谁的方法!

* Method method:当前被调用的方法(目标方法)

* Object[] args:实参!

当在调用这个方法时,其对应关系为:

动态代理和AOP

 

3.用动态代理进行增强

假设一个接口Waiter以及其一个实现类,该实现类提供一个方法:

public interface Waiter {
    // 服务
    public void serve();
}
public class ManWaiter implements Waiter {
    public void serve() {
        System.out.println("服务中...");
    }
}

为了在调用ManWaiter的serve方法之外添加其他能力,就需要用动态代理来实现这样的功能:

public class Demo2 {
    @Test
    public void fun1() {
        Waiter manWaiter = new ManWaiter();//目标对象
        /*
         * 给出三个参数,来创建方法,得到代理对象
         */
        ClassLoader loader = this.getClass().getClassLoader();
        Class[] interfaces = {Waiter.class};
        InvocationHandler h = new WaiterInvocationHandler(manWaiter);//参数manWaiter表示目标对象
        // 得到代理对象,代理对象就是在目标对象的基础上进行了增强的对象!
        Waiter waiterProxy = (Waiter)Proxy.newProxyInstance(loader, interfaces, h);
        
        waiterProxy.serve();//前面添加“您好”, 后面添加“再见”
    }
}

class WaiterInvocationHandler implements InvocationHandler {
    private Waiter waiter;//目标对象
    
    public WaiterInvocationHandler(Waiter waiter) {
        this.waiter = waiter;
    }
}

public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("您好!");
        this.waiter.serve();//调用目标对象的目标方法
        System.out.println("再见!");
        return null;
    }
}

我们在invoke 中实现了对对象能力的增强,这就是使用动态代理的能力。

 

4.在之前的基础上,为了提升动态代理的能力,实现了让目标对象和增强都是可以切换的,在创建目标对象之外,还需要查创建增强对象接口,

public interface BeforeAdvice {
    public void before();
}

public interface AfterAdvice {
    public void after();
}

创建一个代理工厂,ProxyFactory:

/**
 * 1. 创建代理工厂
 * 2. 给工厂设置三样东西:
 *   * 目标对象:setTargetObject(xxx);
 *   * 前置增强:setBeforeAdvice(该接口的实现)
 *   * 后置增强:setAfterAdvice(该接口的实现)
 * 3. 调用createProxy()得到代理对象
 *   * 执行代理对象方法时:
 *   > 执行BeforeAdvice的before()
 *   > 目标对象的目标方法
 *   > 执行AfterAdvice的after()
 * @author cxf
 *
 */
public class ProxyFactory {
    private Object targetObject;//目标对象
    private BeforeAdvice beforeAdvice;//前置增强
    private AfterAdvice afterAdvice;//后置增强
    
    
    /**
     * 用来生成代理对象
     * @return
     */
    public Object createProxy() {
        /*
         * 1. 给出三大参数
         */
        ClassLoader loader = this.getClass().getClassLoader();
        Class[] interfaces = targetObject.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                /*
                 * 在调用代理对象的方法时会执行这里的内容
                 */
                // 执行前置增强
                if(beforeAdvice != null) {
                    beforeAdvice.before();
                }
                
                Object result = method.invoke(targetObject, args);//执行目标对象的目标方法
                // 执行后置增强
                if(afterAdvice != null) {
                    afterAdvice.after();
                }
                
                // 返回目标对象的返回值
                return result;
            }
        };
        /*
         * 2. 得到代理对象
         */
        Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h);
        return proxyObject;
    }
}

当我们使用代理工厂的时候就可以这样做来实现对象的增强:

public void fun1() {
        ProxyFactory factory = new ProxyFactory();//创建工厂
        factory.setTargetObject(new ManWaiter());//设置目标对象
        factory.setBeforeAdvice(new BeforeAdvice() {//设置前置增强
            public void before() {
                System.out.println("您好!");
            }
        });
        
        factory.setAfterAdvice(new AfterAdvice() {//设置后置增强
            public void after() {
                System.out.println("再见!");
            }
        });
        
        Waiter waiter = (Waiter)factory.createProxy();
        waiter.shouQian();
    }

 

动态代理类似于装饰者模式,但是比装饰者模式更加灵活,动态代理的作用就是最终实现AOP(面向切面编程)。面向切面编程中,切面是一种新的模块机制,用来描述分散在对象,类或者方法中的横切关注点,横切关注点是会影响到整个应用程序关注功能,于正常的业务是正交的,这些横切关注点可以是事务,日志和安全性等其他功能。