代理模式

　　在开发过程中，尤其现在注解开发过程中代理其实运用的非常广泛，它可以让我们可以更关注业务，其他的比如日志，事务，以及aop这些公共的东西交给代理类去做。本文就来介绍代理设计模式。

一、代理模式概念

　　代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。（来自百度百科的介绍）
　　我觉得，代理就是让我们可以单纯的去关注业务，而把公共的方法交给代理类去处理，如果业务发生变化，而像一些公共的方法是不需要发生变化，我们只需要去修改业务方法就可以。

二、代理模式的优缺点

• 优点
  (1) .责任清晰，真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。
  (2) .代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。
  (3) .高扩展性
• 缺点
  (1) .静态代理，如果代理对象多的话，则会增加代理类，加重了开发人员的工作量。
  (2) .静态代理由于需要和目标对象实现相同的接口，一旦更改了接口，那么目标对象和代理对象都要同时做出调整，不方便管理。

三、代理模式的组成

• 抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
• 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
• 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

 

四、静态代理

下面写一个静态代理的例子：

• 首先需要一个抽象角色(用于定义真实角色的动作)

/**
 * 
 * @escription:此接口为代理模式的"抽象角色", 其中定义了真实角色与代理角色共同需要做的事情。
 * 此接口也可以定义为抽象类。
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午12:24:24
 */
public interface AbstractRole {
    /**
     * 
     * @Title: businessMethod   
     * @Description: 此方法为真实角色和代理角色需要实现的业务方法
     * @param:       
     * @return: void      
     * @throws
     */
    public void businessMethod();
}

• 然后是真实角色（来实现抽象角色的动作）

/**
 * @escription:(真实角色)
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午12:47:07 
 */
public class RealRole implements AbstractRole {
    /**   
     * <p>Title: businessMethod</p>   
     * <p>Description: 真实角色所以执行的方法，只需要注重业务</p>      
     * @see proxy.AbstractRole#businessMethod()   
     */  
    public void businessMethod() {
        System.out.println("业务方法！");
    }
}

• 接下来是代理角色（来代理真实角色的动作，并且加上自己的一些动作）

/**
 * @escription:(代理角色)
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午12:46:35 
 */
public class ProxyRole implements AbstractRole{
    
    private RealRole realRole;
    /**
     * 
     * @Title:ProxyRole   
     * @Description:通过构造器初始化真实角色 
     * @param:@param realRole  
     * @throws
     */
    public ProxyRole(RealRole realRole) {
        super();
        this.realRole = realRole;
    }

    /**   
     * <p>Title: businessMethod</p>   
     * <p>Description: 代理角色执行的方法，在这里处理非业务，并且公共的东西，比如日志，事务等等。</p>      
     * @see proxy.AbstractRole#businessMethod()   
     */  
    public void businessMethod() {
        prior();
        realRole.businessMethod();
        after();
    }

    /**
     * 
     * @Title: prior   
     * @Description: 在businessMethod方法执行之前执行
     * @param:       
     * @return: void      
     * @throws
     */
    private void prior() {
        System.out.println("在真实角色执行方法之前执行");
    }
    
    /**
     * 
     * @Title: after   
     * @Description: 在businessMethod方法执行之后执行
     * @param:       
     * @return: void      
     * @throws
     */
    private void after() {
        System.out.println("在真实角色执行方法之后执行");
    }
}

• 最后是使用者

/**
 * @escription:使用者，调用真实角色的方法
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午12:48:16 
 */
public class Client {
    public static void main(String[] args) {
        RealRole realRole = new RealRole();
        ProxyRole proxyRole = new ProxyRole(realRole);
        proxyRole.businessMethod();
    }
}

　　执行结果如下：

五、基于接口动态代理（jdk动态代理）

　　在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

• 原理：

1. 拿到被代理类的引用，并且获取它的所有的接口（反射获取）。
2. JDK Proxy类重新生成一个新的类，实现了被代理类所有的方法。
3. 动态生成java代码，把增强逻辑加入到新生成代码中。
4. 编译生成新的java代码的class文件。
5. 加载并运行新的class文件，得到的类就是全新的类。　　

 

 

• 首先还是创建抽象角色和真实角色，此处使用的还是上例中的AbstractRole和RealRole
• 创建动态代理类

/**
 * @escription:log的动态代理类
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午2:44:26 
 */
public class LogDynamicProxy implements InvocationHandler{

    private Object target;

    /**   
     * @Title:LogDynamicProxy   
     * @Description: 将代理对象通过构造器传入
     * @param:@param target  
     * @throws   
     */  
    public LogDynamicProxy(Object target) {
        super();
        this.target = target;
    }


    /**
     * 获取代理类
     * @return the target
     */
    public Object getTarget() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**   
     * <p>Title: invoke</p>   
     * <p>Description: </p>   
     * @param proxy : 代理类
     * @param method : 代理类的 调用处理程序的方法对象
     * @param args : 参数
     * @return
     * @throws Throwable   
     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])   
     */  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        return method.invoke(target, args);
    }

    private void log (String method) {
        System.out.println("执行" + method + "方法");
    }

}

• 创建使用者

/**
 * @escription:使用者，调用真实角色的方法
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午12:48:16 
 */
public class Client {

    public static void main(String[] args) {
        RealRole realRole = new RealRole();
        LogDynamicProxy logProxy = new LogDynamicProxy(realRole);
        AbstractRole abstractRole = (AbstractRole)logProxy.getTarget();
        abstractRole.businessMethod();
    }
}

 

　　下面对上述代码进行简单分析，首相我们在创建LogDynamicProxy时，调用其构造器，将真实角色传入在LogDynamicProxy的get方法中调用了Proxy类的newProxyInstance方法，这个方法是用于动态创建代理类的，其中有三个参数，第一个参数是代理类的类加载器ClassLoader，第二个是真实角色的接口数组，第三参数是代理类。我们简单看下其源码，就可以很容易的看到使用反射去创建代理类。

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)throws IllegalArgumentException
    {
        //判断代理类是否为null
        Objects.requireNonNull(h);
        //克隆接口
        final Class<?>[] intfs = interfaces.clone();
        //权限检查
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         * 生成代理类，如果有直接从缓存中取，如果没有则生成
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //动态获取构造
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //返回代理对象
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

　　最后使用代理类去调用真实角色的方法，在调用时其实是调用的代理类的invoke方法，而这个invoke方法是重写了InvocationHandler接口的方法，这个方法有3个参数，第一个为代理类，第二个则为方法，第三为参数，在这个方法中我们动态的调用真实角色的方法，并且在其中加入一些log。
　　所以说每个动态代理类，都可以去代理一类的业务，这样可以减轻程序员的代码量，而且可以更好的管理代理类。

六、基于类动态代理（cglib动态代理）

　　上面的jdk动态代理是实现接口的方式去实现动态代理，而接下来说的则是继承类去实现动态代理。
　　要想使用cglib的动态代理，首先，我们需要去导一个cglib-nodep的jar包，下面是maven的坐标

<!-- https://mvnrepository.com/artifact/cglib/cglib-nodep -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib-nodep</artifactId>
    <version>2.1_3</version>
</dependency> 

• 首先需要创建真实角色，这个还是使用上例中的RealRole类
• 创建cglib代理类

/**
 * @escription:cglig代理类
 * @author: Herrt灬凌夜
 * @date: 2018年11月25日 下午12:29:14 
 */
public class LogCglibProxy  implements MethodInterceptor {

    /**   
     * <p>Title: intercept</p>   
     * <p>Description: 在Client中调用通过动态代理获取到的真实对象调用方法时，其实调用的是此方法</p>   
     * @param obj
     * @param method
     * @param args
     * @param proxy
     * @return
     * @throws Throwable   
     * @see net.sf.cglib.proxy.MethodInterceptor#intercept(java.lang.Object, java.lang.reflect.Method, java.lang.Object[], net.sf.cglib.proxy.MethodProxy)   
     */  
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        log(method.getName());
        return proxy.invokeSuper(obj, args); //动态调用真实角色的方法
    }

    /**
     * @Title: getInstance   
     * @Description: 动态获取代理对象
     * @param: @param target 真实对象
     * @return 代理对象
     * @throws
     */
    public Object getInstance (Object target) {
        Enhancer enhancer = new Enhancer(); //创建加强器，用来创建动态代理类
        enhancer.setSuperclass(target.getClass()); //给加强器指定父类，即真实角色
        enhancer.setCallback(this); //设置回调，调用上面的 intercept 方法
        return enhancer.create();//动态创建代理类，并返回
    }

    private void log (String method) {
        System.out.println("执行" + method + "方法");
    }
} 

• 创建使用者

/**
 * @escription:使用者，调用真实角色的方法
 * @author: Herrt灬凌夜
 * @date: 2018年11月24日 下午12:48:16 
 */
public class Client {

    public static void main(String[] args) {
        RealRole realRole = new RealRole();
        LogCglibProxy cglibProxy = new LogCglibProxy();
        RealRole cglibRealRole = (RealRole)cglibProxy.getInstance(realRole);
        cglibRealRole.businessMethod();
    }
} 

对上面代码进行简单分析，首先创建真实角色，代理类，调用其getInstance方法，动态创建代理类，其中代码的含义已经在代码中备注，所以在此不再赘述。而在使用代理类调用真实角色方法时，其实在调用intercept方法，这个方法是重写了MethodInterceptor 接口的方法，可以在其中加入log的一些方法。

 

 

-------------------- END ---------------------

 

 

最后附上作者的微信公众号地址和博客地址 

 

 

公众号：wuyouxin_gzh

 

 

 

 

 

 

 

Herrt灬凌夜：https://www.cnblogs.com/wuyx/