java 代理模式-蒲公英云

代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。java中可以通过如下方式实现：

静态代理；
动态代理：jdk动态代理、cglib动态代理

一、静态代理

这种代理方式需要代理对象和目标对象实现一样的接口。

优点：可以在不修改目标对象的前提下扩展目标对象的功能；而且效率高（比动态代理）
缺点：

冗余：由于代理对象要实现与目标对象一致的接口，会产生过多的代理类。
不易维护：一旦接口增加方法，目标对象与代理对象都要进行修改。

看一个例子：

1、接口：

package proxy;
public interface IVehical {
    void run();
}

2、目标实现类：

package proxy;
public class Car implements IVehical{
    @Override
    public void run() {
        System.out.println("Car is running");
    }
}

3、静态代理类：

package proxy;
public class CarProxy implements IVehical{
    private IVehical target;
    public CarProxy(IVehical target) {
        this.target = target;
    }
    @Override
    public void run() {
        System.out.println("start proxy...");
        target.run();
        System.out.println("end proxy...");
    }
}

4、测试类：

IVehical car = new Car();//目标对象
IVehical proxy = new CarProxy(car);//代理
proxy.run();

输出：

start proxy...
Car is running
end proxy...

二、动态代理

动态代理是指动态地在内存中构建代理对象，实现对目标对象的代理功能。与静态代理的区别：

静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中。

上面我们看到，静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能。一个静态代理类只能为一个目标对象服务，如果目标对象过多，需要创建多个代理类。而动态代理相当于一个通用的代理类，可以为任何目标对象创建代理。动态代理主要有两种实现方式：

JDK动态代理：目标对象必须实现某个接口；
cglib动态代理：目标对象无需实现接口，达到代理类无侵入。

1、jdk动态代理：

1.1）jdk实现动态代理的思路：

获取目标对象上的接口列表；
确定要生成的代理类的类名，默认：com.sum.proxy.$ProxyXXX
根据要实现的接口信息，动态创建ProxyXXX的字节码；
创建java.lang.reflect.InvocationHandler接口实例，用来处理Proxy所有方法调用；
使用Proxy.newProxyInstance创建代理类。

综上，目标对象必须实现接口，实现InvocationHandler接口，将代理逻辑写入其中invoke方法；

注：cglib使用的是集成的思路。

1.2）jdk动态代理示例：

1）接口、目标实现类：

同上

2）动态代理类：

package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class CarProxyFactory {
    private Object target;
    public CarProxyFactory(Object target) {
        this.target = target;
    }
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), new MyHandler());
    }
    public class MyHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            System.out.println("start proxy...");
            Object returnValue = method.invoke(target, args);
            System.out.println("end proxy...");
            return returnValue;
        }
    }
}

3）测试类：

IVehical car = new Car();//目标对象
CarProxyFactory carProxyFactory = new CarProxyFactory(car);
IVehical proxyInstance = (IVehical)carProxyFactory.getProxyInstance();//代理
System.out.println(proxyInstance.getClass());
proxyInstance.run();

输出：

class com.sun.proxy.$Proxy0
start proxy...
Car is running
end proxy...

2、cglib动态代理：

cglib (Code Generation Library )是一个强大的、高性能的代码生成库，底层通过使用一个小而快的字节码处理框架ASM来转换字节码，并生成新类。它可以在运行期扩展Java类与实现Java接口，被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

1.1）cglib实现动态代理的思路：

运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。需要注意的是，因为cglib采用的是继承方式，对指定的目标类生成一个子类，并覆盖其中方法实现增强，所以目标对象的类或方法最好不要声明成final（final类或方法，是无法继承的）

1.2）cglib动态代理示例：

1）cglib mvn坐标：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

2）接口、目标实现类：

同上

3）动态代理类：

package proxy;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CarProxyFactory2 implements MethodInterceptor{
    private Object target;
    public CarProxyFactory2(Object target) {
        this.target = target;
    }
     //为目标对象生成代理对象
    public Object getProxyInstance() {
        Enhancer en = new Enhancer();//工具类
        en.setSuperclass(target.getClass());//设置父类
        en.setCallback(this);//设置回调函数
        return en.create();//创建子类对象代理
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
        System.out.println("start proxy...");
        Object returnValue = method.invoke(target, args);
        System.out.println("end proxy...");
        return returnValue;
    }
}

4）测试：

IVehical car = new Car();//目标对象
CarProxyFactory2 carProxyFactory = new CarProxyFactory2(car);
IVehical proxyInstance = (IVehical)carProxyFactory.getProxyInstance();//代理
System.out.println(proxyInstance.getClass());
proxyInstance.run();

输出：

class proxy.Car$$EnhancerByCGLIB$$5e966720
start proxy...
Car is running
end proxy...

3、jdk和cglib动态代理区别：

1）何时使用JDK还是CGLIB？

如果目标对象实现了接口，默认情况下会采用JDK的动态代理，也可以强制使用cglib；
如果目标对象没有实现了接口，必须采用CGLIB库；

Spring会自动在JDK动态代理和CGLIB之间转换。强制使用cglib的方法：

引入cglib库；
在spring配置文件中加入：

2）CGlib比JDK快？

CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在jdk6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。

在jdk6、jdk7、jdk8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，但是到jdk8的时候，jdk代理效率高于CGLIB代理，总之，每一次jdk版本升级，jdk代理效率都得到提升，而CGLIB代理消息确有点跟不上步伐。

三、应用：

java中很多框架都是使用了动态代理模式，常见的有：通过动态代理实现远程rpc调用，在代理类中实现复杂的远程调用功能，在使用中就像调用本地方法一样。

利用反射（注解）+动态代理，我们可以实现很多框架功能，例如：OWNER框架

从宏观上看动态代理有哪些作用：

解决特定问题：一个接口的实现在编译时无法知道，需要在运行时才能实现
实现某些设计模式：适配器(Adapter)或修饰器(Decorator)
面向切面编程：如AOP in Spring

示例：使用动态代理，获取配置文件中的key和value，非常方便且有优势

1）注解、映射接口：

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {
    /**
     * The actual value expression: e.g. "#{systemProperties.myProp}".
     */
    String value();
}
/**
 * config interfaces, map the config properties file:
 * db.url = 
 * db.validation = true
 * db.pool.size = 100
 */
public interface IConfig {
    @Value("db.url")
    String dbUrl();
    @Value("db.validation")
    boolean isValidated();
    @Value("db.pool.size")
    int poolSize();
}

2）代理：

public final class ConfigFactory {
    private ConfigFactory() {}
    public static IConfig create(final InputStream is) throws IOException{
        final Properties properties = new Properties();
        properties.load(is);
        return (IConfig) Proxy.newProxyInstance(IConfig.class.getClassLoader(),
            new Class[] { IConfig.class }, new PropertyMapper(properties));
    }
    public static final class PropertyMapper implements InvocationHandler {
        private final Properties properties;
        public PropertyMapper(Properties properties) {
            this.properties = properties;
        }
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            final Value value = method.getAnnotation(Value.class);
            if (value == null) return null;
            String property = properties.getProperty(value.value());
            if (property == null) return (null);
            final Class<?> returns = method.getReturnType();
            if (returns.isPrimitive()) {
                if (returns.equals(int.class)) return (Integer.valueOf(property));
                else if (returns.equals(long.class)) return (Long.valueOf(property));
                else if (returns.equals(double.class)) return (Double.valueOf(property));
                else if (returns.equals(float.class)) return (Float.valueOf(property));
                else if (returns.equals(boolean.class)) return (Boolean.valueOf(property));
            }
            return property;
        }
    }
}

3）测试类：

public static void main(String[] args) throws FileNotFoundException, IOException {
    IConfig config = ConfigFactory.create(new FileInputStream("config/config.properties"));
    String dbUrl = config.dbUrl();
    boolean isLoginValidated = config.isValidated();
    int dbPoolSize = config.poolSize();
}