Java设计模式之代理模式

代理模式

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

1. 代理模式之静态代理

• 优点：可以在不修改目标对象的前提下扩展目标对象的功能。

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

• 实例：以发送信息服务为例，在发送信息前后添加额外的操作。

• 类图：
  

• 代码：

/**
 * 发送短信的接口
 */
public interface SmsService {

    /**
     * 发送短信的方法
     *
     * @param message
     * @return
     */
    String sendMsg(String message);
}

/**
 * 发送短信接口的实现类
 */
public class SmsServiceImpl implements SmsService {
    @Override
    public String sendMsg(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

/**
 * 发送短息代理类：同样实现发送短信的接口，并注入发送短信的类
 */
public class SmsProxy implements SmsService {

    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String sendMsg(String message) {
        //调用方法之前,添加自己的操作
        System.out.println("do something before send message.");
        smsService.sendMsg(message);
        System.out.println("do something after send message.");
        return null;
    }
}

/**
 * 测试静态代理
 */
public class TestStaticProxy {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.sendMsg("java");
    }
}

2. 代理模式之动态代理

• 实现方式：动态代理利用了JDKAPI，动态代理类的字节码在程序运行时由Java反射机制动态生成，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。

• 优点：1）动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。2）动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java反射机制可以生成任意类型的动态代理类。

• 缺点：动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。

• 实例：以发送信息服务为例，在发送信息前后添加额外的操作。在运行时动态生成类字节码，并加载到JVM中。

• 类图：
  

• 代码：

/**
 * 发送短信的接口
 */
public interface SmsService {

    /**
     * 发送短信的方法
     *
     * @param message
     * @return
     */
    String sendMsg(String message);
}

/**
 * 发送短信接口的实现类
 */
public class SmsServiceImpl implements SmsService {
    @Override
    public String sendMsg(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

/**
 * 动态代理类
 */
public class DebugInvocationHandler implements InvocationHandler {
    //代理类真实对象
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //调用方法之前,添加自己的操作
        System.out.println("do something before send message.");
        Object res = method.invoke(target, args);//通过反射调用方法
        //调用方法之后添加操作
        System.out.println("do something after send message.");
        return res;
    }
}

/**
 * 代理对象工厂类
 */
public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        //三个参数：
        // 目标类的类加载器
        // 代理需要实现的接口，可指定多个
        // 代理对象对应的自定义 InvocationHandler
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new DebugInvocationHandler(target));
    }
}

/**
 * 测试动态代理
 */
public class TestDynamicProxy {
    public static void main(String[] args) {

        SmsService smsService = new SmsServiceImpl();
        SmsService smsProxy = (SmsService) JdkProxyFactory.getProxy(smsService);
        smsProxy.sendMsg("java");

    }
}

3. 代理模式之CGLIB代理

• 优点：cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题

• 缺点：cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。

• 博客：https://segmentfault.com/a/1190000011291179

• 实例：以cglib的方式进行具体类的代理。

• 类图：
  

• 代码：（需要引入CGLIB第三方库）

/**
 * 发送短信类
 */
public class AliSmsService {
    public String sendMsg(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

/**
 * 自定义 MethodInterceptor（方法拦截器）
 */
public class DebugMethodInterceptor implements MethodInterceptor {


    /**
     * @param o           被代理的对象（需要增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        //调用方法之前,添加自己的操作
        System.out.println("do something before send message.");
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("do something after send message.");
        return object;
    }
}

/**
 * 代理类
 */
public class CglibProxyFactory {
    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

/**
 * 测试CGLIB代理
 */
public class TestCglibProxy {
    public static void main(String[] args) {
        AliSmsService aliSmsService = new AliSmsService();
        AliSmsService aliSmsProxy = (AliSmsService) CglibProxyFactory.getProxy(aliSmsService.getClass());
        aliSmsProxy.sendMsg("java");

    }
}