18.5.2 动态代理和AOP

开发实际应用的软件系统时,通常会存在相同代码段重复出现的情况,对于这种情况

• 初级的开发只会复制粘贴这些代码.
• 稍有经验的开发者会将这些重复的代码封装一个方法,然后直接调用该方法即可。但采用这种方式来实现代码复用依然产生一个重要问题:那就是调用者和这个方法耦合了。

最理想的情况是即可以执行这个相同的代码段,又无须调用封装的方法,这时就可以通过动态代理来达到这种效果。
由于**JDK动态代理只能为接口创建动态代理**,所以下面先提供一个Dog接口,该接口代码非常简单,仅仅在该接口里定义了两个方法。

public interface Dog
{
    // info方法声明
    void info();
    // run方法声明
    void run();
}

上面接口里只是简单地定义了两个方法,并未提供方法实现。如果直接使用Poxy为该接口创建动态代理对象,则动态代理对象的所有方法的执行效果又将完全一样。实际情况通常是,软件系统会为该Dog接口提供一个或多个实现类。此处先提供一个简单的实现类: GunDog。

public class GunDog implements Dog
{
    // 实现info()方法，仅仅打印一个字符串
    public void info()
    {
        System.out.println("我是一只猎狗");
    }
    // 实现run()方法，仅仅打印一个字符串
    public void run()
    {
        System.out.println("我奔跑迅速");
    }
}

上面代码没有丝毫的特别之处,该Dog的实现类仅仅为每个方法提供了一个简单实现。
下面提供一个DogUtil类,该类里包含两个通用方法:

public class DogUtil
{
    // 第一个拦截器方法
    public void method1()
    {
        System.out.println("=====模拟第一个通用方法=====");
    }
    // 第二个拦截器方法
    public void method2()
    {
        System.out.println("=====模拟通用方法二=====");
    }
}

借助于Proxy和InvocationHandler就可以实现——当程序调用info()方法和run()方法时,系统可以自动”将method1()和method2()两个通用方法插入info()和run()方法中执行。
这个程序的关键在于下面的MylnvokationHandler类,该类是一个InvocationHandler实现类,该实现类的invoke()方法将会作为代理对象的方法实现。

import java.lang.reflect.*;

public class MyInvokationHandler implements InvocationHandler
{
    // 需要被代理的对象
    private Object target;
    public void setTarget(Object target)
    {
        this.target = target;
    }
    // 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Exception
    {
        DogUtil du = new DogUtil();
        // 执行DogUtil对象中的method1。
        du.method1();
        // 以target作为主调来执行method方法
        Object result = method.invoke(target , args);//关键代码
        // 执行DogUtil对象中的method2。
        du.method2();
        return result;
    }
}

上面程序实现invoke()方法时包含了一行关键代码,这行代码通过反射以target作为主调来执行method方法,这就是回调了target对象的原有方法。在粗体字代码之前调用DogUtil对象的method1()方法,在粗体字代码之后调用DogUti对象的method2()方法。
下面再为程序提供一个MyProxyFactory类,该类对象专为指定的target生成动态代理实例。

import java.lang.reflect.*;

public class MyProxyFactory
{
    // 为指定target生成动态代理对象
    public static Object getProxy(Object target)
        throws Exception
        {
        // 创建一个MyInvokationHandler对象
        MyInvokationHandler handler =new MyInvokationHandler();
        // 为MyInvokationHandler设置target对象
        handler.setTarget(target);
        // 创建、并返回一个动态代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader()
            , target.getClass().getInterfaces() , handler);
    }
}

上面的动态代理工厂类提供了一个getProxy()方法,该方法为target对象生成一个动态代理对象,这个动态代理对象与target实现了相同的接口,所以具有相同的public方法——一从这个意义上来看,动态代理对象可以当成target对象使用。当程序调用动态代理对象的指定方法时,实际上将变为执行MylnvokationHandler对象的invoke方法。例如,调用动态代理对象的info方法,程序将开始执行invoke方法,其执行步骤如下。
下面提供一个主程序来测试这种动态代理的效果。

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        // 创建一个原始的GunDog对象，作为target
        Dog target = new GunDog();
        // 以指定的target来创建动态代理
        Dog dog = (Dog)MyProxyFactory.getProxy(target);
        dog.info();
        dog.run();
    }
}

上面程序中的dog对象实际上是动态代理对象,只是该动态代理对象也实现了Dog接口,所以也可以当成Dog对象使用。程序执行dog的info()和run()方法时,实际上会先执行DogUtil的method1()方法,再执行target对象的info()和run()方法,最后执行DogUtil的method2()方法。运行结果如下:

=====模拟第一个通用方法=====
我是一只猎狗
=====模拟通用方法二=====
=====模拟第一个通用方法=====
我奔跑迅速
=====模拟通用方法二=====

采用动态代理可以非常灵活地实现解耦。通常而言,使用Proxy生成一个动态代理时,往往并不会凭空产生一个动态代理,这样没有太大的实际意义。通常都是为指定的目标对象生成动态代理。
这种动态代理在AOP( Aspect Orient Programming,面向切面编程)中被称为AOP代理,AOP代理可代替目标对象,AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异:AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。

本文重点

JDK动态代理只能为接口创建动态代理
创建代理对象的步骤:

1. 编写自定义InvocationHandler实现类,重写invoke()方法,nvoke方法的第一个参数proxy代表要动态代理的对象,第二个参数method：代表要执行的目标方法第三个参数args：代表调用目标方法时传入的实参。在invoke()方法中,在目标方法的前面和后面添加增强的方法.
2. 编写接口,以及该接口的实现类,然后创建实现类,赋值给接口引用(多态),这样就得到了一个接口的实例对象(目标对象)
3. 调用Proxy.newProxyInstance()方法生成代理对象,newProxyInstance方法的第一个参数是要代理的目标对象的类加载器,第二个参数是目标对象的接口,第三个参数是自定义InvocationHandler实现类。
4. 由于代理类和被代理类都实现相同的接口,所以可以调用同名的方法.