行为模式--代理Proxy模式（Java）

代理（AOP切面的雏形）：

题记：顾名思义就是将某件事，某个东西的使用权进行为让授权转移。代理相当于中介（不同于中介者模式），在原本操作的类之间添加了一个桥梁。但代理不能去修改原有目标。比如：一个人要买       房，让中介帮忙给看个房，但中介不能将原有看房这件事变更为看车。他可以对看房提出各种要求和咨询。

回到程序的角度，调用者将调用某些共性类的处理交由代理类处理，代理类根据调用者的要求即满足什么情况可以调用，什么情况不能调用，（卖房者委托中介100万以上卖，100万以下不卖）对处理做前后的包装，但是代理类不能去改变被调用类的内部处理（可口可乐中国区可修改可口可乐包装，但不能在没授权情况下去更改可口可乐饮料）。

1.静态代理

2.动态代理

1.静态代理：对指定接口类做代理，通过对执行方法前后做处理，来实现代理的作用。因对指定接口类，因此可做某些特定类的特殊处理。

/**
 * 静态代理，也被称为decate模式
 * 
 * @author DennyZhao
 * @date 2017年6月13日
 * @version 1.0
 */
public class AnimalProxyFactory implements AnimalFactory {
    /**
     * 序列号
     */
    private static final long serialVersionUID = -3421761900236678842L;
    
    
    private AnimalFactory animal;
    
    public AnimalProxyFactory(AnimalFactory animal){
        this.animal = animal;
    }
    @Override
    public int getLegs() {
        System.out.println("before....action");
        int legs = animal.getLegs();
        System.out.println("after....action");
        return legs;
    }

}

测试Main：

　　// 静态代理
　　Rabit rabit = new Rabit();
　　AnimalProxyFactory proxyFactory = new AnimalProxyFactory(rabit);
　　System.out.println(proxyFactory.getLegs());    

运行结果： 

　　>>>before....action
　　>>>after....action
　　>>>4  

       2.动态代理：动态代理通过Proxy类创建代理，通过InvokationHandler去调用方法。

package pattern.creation.factory;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Proxy;
import java.util.Properties;

/**
 * 动态代理模式
 * 
 * @author DennyZhao
 * @date 2017年6月13日
 * @version 1.0
 */
public class ProxyFactory {
    private static final String CLASS_NAME_PATH = "pattern/classname.properties";
    @SuppressWarnings("unchecked")
    public static <T> T getInstance(String name) throws IllegalArgumentException, InstantiationException, IllegalAccessException{
        String className = getClassName(name);
        T result = null;
        try {
            Class clazz = Class.forName(className);
            result = (T)Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new MyInvocationHandler(clazz.newInstance()));
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 获取类名称
     * @return
     */
    private static String getClassName(String name) {
        Properties pro = new Properties();
        try {
            String url = ProxyFactory.class.getClassLoader().getResource("").getPath() + CLASS_NAME_PATH;
            pro.load(new FileInputStream(url));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (String)pro.get(name);
    }
}

     注意* ： 代理面向的是接口，因此委托的类都需要实现指定的接口。

　　　　　　result = (T)Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new MyInvocationHandler(clazz.newInstance()));

 　　　　　　clazz.getInterfaces()：如果一个clazz实现多个接口，此处要传入接口Class。

　　　　　　MyInvocationHandler 实现 InvocationHandler接口，里面要实现一个invoke方法，在这个invoke方法中填写处理。

MyInvocationHandler 

// 可通过放射机制，来处理特殊类的特殊请求。

测试Main:

// 动态代理，AOP切面的雏形做法
AnimalFactory sheep = ProxyFactory.getInstance("sheep");
sheep.getLegs();

// 动态代理，AOP切面的做法
PlantFactory plum = ProxyFactory.getInstance("plum");
plum.getColor();

// 动态代理，AOP切面的做法
AnimalFactory rabit0 = ProxyFactory.getInstance("rabit");
rabit0.getLegs();

结果：

before-------
sheep has 4 legs....
after-------
before-------
plum green purple....
after-------
before-------
兔子是特殊的
after-------

深入理解静态代理和动态代理：

静态代理：需要代理类和实体类拥有同一个接口，这样才能保证口径一致，即代理商不能随意改变原实体类的行为。在代理类中将实体类注入进去，实现代理类和实体类的关联。这样在调用代理类时，会找到对应的实体类触发其行为，在调用前后又可以写入其它信息比如轨迹日志。

// 静态代理
IAnimal animal = new Sheep();
IAnimal proxy = new ProxyAnimal(animal);
System.out.println(proxy.getName());

jdk动态代理：动态代理的本质和静态代理是一致的。只不过动态代理是因为事前根本不知道要去代理谁，且原静态代理类，如果要实现代理需要写相同的实体类的相关接口，和好多代理类，扩展维护很麻烦。因此就采用一种动态代理。 通过定义一个类 实现 InvocationHandler接口的方法，即统一的代理行为，之后的所有代理信息都会进入到这个方法中，包括目标方法和目标参数。然后再由一个Proxy静态类，去在运行时创建一个类class $Proxy0，这个类会由ProxyGenerate根据传入的所有的接口，通过反射获取他们的方法，实现他们的方法，同时把Invocationhandler注入到这个类中，生成类似我们静态代理的临时类。坦白的说只是把我们自己写代理的这个过程交给机器来编写实现。

 InvocationHandler invocation = new AnimalInvocation(new Sheep());
        // 动态代理
        Object animals = Proxy.newProxyInstance(invocation.getClass().getClassLoader(), new Class[]{IAnimal.class, IPlant.class}, invocation);
        IPlant plant = (IPlant) animals;
        IAnimal animal = (IAnimal) animals;

在这个 invocation中我们可以传入我们的实体对象（构造带参的构造器），也可以不传递通过rpc或者远端http请求获取Feign。

public class AnimalInvocation implements InvocationHandler {

    private Object obj;

    /**
     * 创建代理对象
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(proxy.getClass());
        // rcp调用远端接口处理数据，返回   method， obj ，args
        return "其实我什么都不是";
        //return method.invoke(obj, args);
    }

spring有个AOP的切面使用的也是反向代理，只不过他的实现机理和我们JDK的内部的有些不一样。spring用的是cJlib,通过创建一个子类继承当前的service类。在调用中通过super来调用父类的方法实现代理。祥见  spring-AOP切面

因service中可以不定义接口，yi'ni'c