理解代理模式

是什么

代理模式属于结构型模式。给某一个对象提供一个代理，并且使用该代理的对象来访问原来的对象。

代理模式一般分为静态代理和动态代理，动态代理又分为JDK代理和CGLIB代理。

优缺点

优点

在不修改原来类的情况下，增强类的功能。

缺点

系统更复杂。

静态代理

以 spring 的事务 @translation 为例。

1. 先创建一个用户的增删改查的接口和其实现类。

/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 用户类
 */
public interface UserService {

    /**
     * 更新
     */
    void update();

}

/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 描述
 */
public class UserServiceImpl implements UserService{

    @Override
    public void update() {
        System.out.println("update......");
    }
}

一般来说，这就是一个数据库的更新操作了。

2. 静态代理实现事务

但是如果我们想要为其加入 事务控制 ，又不想修改原来的类，那就可以试试静态代理。

/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 静态代理
 */
public class TranslationProxy implements UserService {

    private UserService userService;

    public TranslationProxy(UserService service) {
        this.userService = service;
    }

    @Override
    public void update() {
        start();
        userService.update();
        commit();
    }

    private void start() {
        System.out.println("start translation");
    }
    
    private void commit() {
        System.out.println("commit translation");
    }
}

3. 测试和输出结果

/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 描述
 */
public class Main {

    public static void main(String[] args) {
        System.out.println("不使用静态代理");
        UserService userService = new UserServiceImpl();
        userService.update();
        System.out.println("-------");

        System.out.println("使用静态代理");
        UserService target = new UserServiceImpl();
        UserService proxy = new TranslationProxy(target);
        proxy.update();
        System.out.println("--------");

    }

}

不使用静态代理
update......
-------
使用静态代理
start translation
update......
commit translation
--------

优点

既达到了功能的增强，并且没有破坏入侵源代码。

缺点

代理类和委托类实现相同的接口，同时要实现相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

JDK动态代理

还是以事务为例子。

JDK动态代理主要涉及：java.lang.reflect.Proxy

1. 实现动态代理

import java.lang.reflect.Proxy;
/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 动态代理
 */
public class TranslationProxyFactory {

    //被代理的对象
    private Object target;

    public TranslationProxy(Object o) {
        this.target = o;
    }

    private void start() {
        System.out.println("start translation");
    }

    private void commit() {
        System.out.println("commit translation");
    }

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                (proxy1, method1, args1) -> {
                    start();
                    //执行目标对象方法
                    Object returnValue = method1.invoke(target, args1);
                    commit();
                    return returnValue;
                }
        );
    }
}

2. 测试和结果

public class Main {

    public static void main(String[] args) {
        System.out.println("不使用静态代理");
        UserService userService = new UserServiceImpl();
        userService.update();
        System.out.println("-------");

        System.out.println("使用动态代理");
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) new TranslationProxyFactory(target).getProxyInstance();
        proxy.update();
        System.out.println("--------");

    }
}

不使用静态代理
update......
-------
使用动态代理
start translation
update......
commit translation
--------

优点

解耦

缺点

基于Java反射机制实现，代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

CGLIB动态代理

需要引入新的包 CGLIB 。如果是使用spring的话就不需要，因为spring中默认会引入了。

Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的子类.

1. maven 引入 cglib

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

2. CGLIB动态代理工厂

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 动态代理
 */
public class TranslationProxy implements MethodInterceptor {

    //被代理的对象
    private Object target;

    public TranslationProxy(Object o) {
        this.target = o;
    }

    private void start() {
        System.out.println("start translation");
    }

    private void commit() {
        System.out.println("commit translation");
    }

    public Object getProxyInstance() {
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        start();
        Object result = method.invoke(target, objects);
        commit();
        return result;
    }
}

测试和输出

package com.wsk.utils;

/**
 * @author wsk1103
 * @date 2019/7/22
 * @description 描述
 */
public class Main {

    public static void main(String[] args) {
        System.out.println("不使用代理");
        UserService userService = new UserServiceImpl();
        userService.update();
        System.out.println("-------");

        System.out.println("使用动态代理");
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) new TranslationProxy(target).getProxyInstance();
        proxy.update();
        System.out.println("--------");

    }
}

不使用代理
update......
-------
使用动态代理
start translation
update......
commit translation
--------

优点

解耦

缺点

代理的类不能为final,否则报错；目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

java中的应用

java.lang.reflect.Proxy
Apache Commons Proxy
Mocking frameworks Mockito, Powermock, EasyMock

参考：
https://github.com/iluwatar/java-design-patterns/tree/master/proxy
https://segmentfault.com/a/1190000009235245#articleHeader7

是什么

优缺点

优点

缺点