动态代理

增强的手段
1、继承
*被增强对象不能变
*增强内容不能变
2.装饰者模式
*被增强对象可变
*但增强内容不可变
3.动态代理
*被增强对象可变
*增强内容可变

首先一个方法：

Proxy.newProxyInstance(ClassLoader classLoader,Class[] interfaces,invocationHandler h);

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

参数：

1、ClassLoader：类加载器
它是用来加载类的，把.class文件加载到内存形成Class对象！
2、Class[] interfaces:指定要执行的接口
3、invocationHandler：代理对象的所有方法（个别方法不执行）都会调用InvocationHandler的invoke方法

第一个测试类：

package com.itcast.demo1;

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

import org.junit.Test;

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() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                System.out.println("你好，动态代理！");
                return null;
            }
        };
        //使用三大参数创建代理对象
        Object o=Proxy.newProxyInstance(loader, new Class[]{A.class,B.class}, h);
        
        //强转成A和B类型，成功了！
        A a=(A) o;
        B b=(B) o;
        a.a();
        b.b();
        a.aa();
        b.bb();
        System.out.println(a.getClass().getName());
        
    }
}
interface A{
    public void a();
    public void aa();
}
interface B{
    public void b();
    public void bb();
}

证实几点：

　　1、该方法生成了实现指定接口的代理对象。

　　2、代理类的几乎所有方法的执行都是调用invocation的invoke方法。

　　3、类加载器使用this.getClass().getClassLoader()得到。

动态代理的作用
最终是学习AOP（面向切面编程），它与装饰者模式有点相似，它比装饰者模式还要灵活！

方法：

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

这个invoke方法什么时候被调用！
1、在代理对象呗创建时？错误的
2、在调用代理对象所实现接口中的方法时？正确的！

*Object proxy：当前对象，即代理对象！在调用谁的方法！
*Method method：当前被调用的方法（目标方法）
*Object[] args:实参！

实现

（*被增强对象可变*但增强内容不可变）：

package com.itcast.demo2;
//服务员
public interface Waiter {
    //服务
    public void server();

}

package com.itcast.demo2;

public class ManWaiter implements Waiter {

    @Override
    public void server() {
        System.out.println("服务中！");
    }

}

package com.itcast.demo2;

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

import org.junit.Test;
/**
 * 我们必须要掌握的是当前这个案例！
 * @author Administrator
 *
 */
public class Demo2 {

    @Test
    public void fun1(){
        Waiter manWaiter=new ManWaiter();
        /*
         * 给出三个参数，来调用方法得到代理对象
         */
        ClassLoader loader=this.getClass().getClassLoader();
        Class[] interfaces={Waiter.class};
        InvocationHandler h=new WaitInvocationHanlder(manWaiter); //被增强的目标对象
        Waiter waiter=(Waiter) Proxy.newProxyInstance(loader, interfaces, h);
        
        waiter.server();//前面加你好，后面加再见
    }
    
}
class WaitInvocationHanlder implements InvocationHandler{
    private Waiter waiter;//目标对象
    public WaitInvocationHanlder(Waiter waiter){
        this.setWaiter(waiter);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("你好！");
        this.waiter.server();//调用目标对象的方法
        System.out.println("再见！");
        return null;//return 的值是执行的方法的返回值，这个方法的proxy表示的是本代理对象，所以不能使用method.invoke(proxy,args).这样会走死循环。
    }

    public void setWaiter(Waiter waiter) {
        this.waiter = waiter;
    }

    public Waiter getWaiter() {
        return waiter;
    }
    
}

使用工厂模式，实现增强内容也可变。

目标对象：被增强的对象
代理对象：需要增强的对象，
目标：

　　执行前增强

　　执行后增强

package com.itcast.demo3;
/**
 * 前置增强
 */
public interface BeforeAdvice {
    public void before();

}

package com.itcast.demo3;
/*
 * 后置增强
 */
public interface AfterAdvice {
    
    public void after();
}

package com.itcast.demo3;

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

/**
 * 它用来生成代理对象
 * 它需要所有的参数
 *     *目标对象
 *  *增强
 */
/**
 * 1、创建代理工厂
 * 2、改工厂设置三样东西：
 *     *目标对象setTargetObject
 *     *前置增强：setBeforeAdvice
 *     *后置增强：setAfterAdvice
 * 3、调用createProxy()得到代理对象
 *     *执行代理对象方法时：
 *         执行BeforeAdvice的before()
 *         目标对象的目标方法
 *         执行AfterAdvice的after()
 */
public class ProxyFactory {
    private Object targetObject;//目标对象
    private BeforeAdvice beforeAdvice;//前置增强
    private AfterAdvice afterAdvice;//后置增强
    public Object getTargetObject() {
        return targetObject;
    }
    
    /**
     * 用来生成代理对象
     * @return
     */
    public Object createProxy(){
        /*
         * 给出三大参数
         */
        ClassLoader loader=this.getClass().getClassLoader();
        Class[] interfaces=targetObject.getClass().getInterfaces();
        InvocationHandler h=new InvocationHandler() {
            
            @Override
            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;
            }
        };
        
        //得到代理对象
        Object obj=Proxy.newProxyInstance(loader, interfaces, h);
        
        //返回代理
        return obj;
    }
    
    
    
    public void setTargetObject(Object targetObject) {
        this.targetObject = targetObject;
    }
    public BeforeAdvice getBeforeAdvice() {
        return beforeAdvice;
    }
    public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
        this.beforeAdvice = beforeAdvice;
    }
    public AfterAdvice getAfterAdvice() {
        return afterAdvice;
    }
    public void setAfterAdvice(AfterAdvice afterAdvice) {
        this.afterAdvice = afterAdvice;
    }
    

}

主要代码就这些：

这里实现增强内容可变的方法是代理对象的执行体令它是可变的，所以使用工厂进行创建，进行了一些包装操作。我们必须透彻理解如何进行的增强，增强的步骤等。

难点在于：

　　1、思路。明确知道自己需要什么怎么办。

　　2、proxy中的invoke方法的书写。