代理

代理是一种基本的设计模式，为目标对象提供另外的访问方式，通过代理访问目标对象可以扩展目标对象的功能，增加额外的功能，也就是不要修改别人的代码，但是可以扩展。
代理分为三种：静态代理、动态代理、CGLIB代理.

静态代理

静态代理就是在代码中把需要代理的类和代理的方法确定好了。

1. 创建公共接口。

public interface Worker {
    void work();
}
1
2
3

2. 创建实现类，确定具体的工作。

public class Programmer implements Worker{
    @Override
    public void work() {
        System.out.println("程序员正在使劲搬砖中。。。");
    }
}
1
2
3
4
5
6

3. 创建代理类。

public class OutSouring implements Worker{
    private Worker worker;

    public OutSouring(Worker worker) {
        this.worker = worker;
    }

    @Override
    public void work() {
        System.out.println("外包要接项目了");
        worker.work();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

代理类同样需要实现公共接口，持有相关对象，不然没有办法让真正的干活的人干活。通常持有的是具体的实现类对象。

public class OutSouring implements Worker{
    private Programmer programmer;
    public OutSouring(Programmer programmer) {
        this.programmer = programmer;
    }

    @Override
    public void work() {
        System.out.println("外包要接项目了");
        programmer.work();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

4. 代理类给实现类派活。

    public static void main(String[] args) {
        Programmer programmer = new Programmer();
        OutSouring outSouring = new OutSouring(programmer);
        outSouring.work();
    }
1
2
3
4
5

结果：

外包要接项目了
程序员正在使劲搬砖中。。。
1
2

其实就是干活时，自己指挥别人干活。

动态代理

动态代理就是根据代码的指示动态代理，并没有指明确需要代理的工作。动态代理的好处是可以对代理类的所有方法进行统一管理，比较方便，不需要对代理的方法每一个都写一遍；不好的地方在于动态代理基于反射，可能稍稍稍慢一点吧。

1. 创建公共接口，同上。
2. 创建实现类，确定具体的工作，同上。
3. 创建ProgrammerInvocationHandler类，实现InvocationHandler接口，持有被代理对象，实现invoke方法。

public class ProgrammerInvocationHandler implements InvocationHandler {
    private Object proxied;

    public ProgrammerInvocationHandler(Object proxied) {
        this.proxied = proxied;
    }
    
    /**
     * 调用方法
     * @param proxy     代理对象
     * @param method    调用的方法
     * @param args      方法传参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("准备开始干活了");
        Object result = method.invoke(proxied, args);
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

invoke就是在持有被代理对象后，通过反射执行被代理对象中的所有方法，当然也可以做自己的工作。当然这里指定了具体被代理的类型，也可以使用泛型。

public class ProgrammerInvocationHandler<T> implements InvocationHandler {
    private T proxied;

    public ProgrammerInvocationHandler(T proxied) {
        this.proxied = proxied;
    }

    /**
     * 调用方法
     * @param proxy     代理对象
     * @param method    调用的方法
     * @param args      方法传参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("准备开始干活了");
        Object result = method.invoke(proxied, args);
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4. 创建代理对象，执行代理方法。

        // 创建被代理对象
        Programmer programmer = new Programmer();
        // 创建InvocationHandler对象
        ProgrammerInvocationHandler programmerInvocationHandler = new ProgrammerInvocationHandler(programmer);
        // 创建代理对象，代理对象会自动执行相应的方法
        Worker proxy = (Worker) Proxy.newProxyInstance(Worker.class.getClassLoader(), new Class[]{Worker.class}, programmerInvocationHandler);
        proxy.work();
1
2
3
4
5
6
7

通过调用静态方法Proxy.newProxyInstance()就可以创建动态代理，需要类加载器，被实现的接口，相关方法处理入口。传入programmerInvocationHandler，其实就是指定了将要被调用的方法。

    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h) {
        Objects.requireNonNull(h);

        final Class<?> caller = System.getSecurityManager() == null
                                    ? null
                                    : Reflection.getCallerClass();

        /*
         * Look up or generate the designated proxy class and its constructor.
         */
        Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);

        return newProxyInstance(caller, cons, h);
    }
    ...
    private static Constructor<?> getProxyConstructor(Class<?> caller,
                                                      ClassLoader loader,
                                                      Class<?>... interfaces)
    {
        // optimization for single interface
        if (interfaces.length == 1) {
            Class<?> intf = interfaces[0];
            if (caller != null) {
                checkProxyAccess(caller, loader, intf);
            }
            return proxyCache.sub(intf).computeIfAbsent(
                loader,
                (ld, clv) -> new ProxyBuilder(ld, clv.key()).build()
            );
        } else {
            // interfaces cloned
            final Class<?>[] intfsArray = interfaces.clone();
            if (caller != null) {
                checkProxyAccess(caller, loader, intfsArray);
            }
            final List<Class<?>> intfs = Arrays.asList(intfsArray);
            return proxyCache.sub(intfs).computeIfAbsent(
                loader,
                (ld, clv) -> new ProxyBuilder(ld, clv.key()).build()
            );
        }
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

Proxy.newProxyInstance()实际上就是通过反射获取代理对象构造器，然后用构造器创建具体的对象。
结果：

准备开始干活了
程序员正在使劲搬砖中。。。
1
2

动态代理在代码运行时才知道具体的实现，在面向切面编程（AOP）中有使用。

CGLIB

如果被代理的类没有实现接口，那么动态代理就没有办法使用，这个时候就需要使用CGLIB代理。Cglib代理也叫作子类代理，是通过在内存中构建一个子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，然后加入自己需要的操作，这其实就是面向切面编程的思想。CGLIB不能代理final 类，因为使用的是继承。使用之前需要添加依赖。

1. 创建被代理对象。

public class ProxyObject {

    public void doWork(){
        System.out.println("干活是不可能的，除非。。。。");
    }
    
}
1
2
3
4
5
6
7

2. 创建代理工厂。

public class ProxyFactory{

	public ProxyFactory() {
	}
	public static <T> T getProxy(T proxied) {
		// 工具类
		Enhancer enhancer = new Enhancer();
		// 设置父类
		enhancer.setSuperclass(proxied.getClass());
		// 设置回调
		enhancer.setCallback(new MethodInterceptor() {
			
			@Override
			public Object intercept(Object obj, Method method, Object[] args, MethodProxy arg3) throws Throwable {
				System.out.println("准备干活了。。。。");
				Object object = method.invoke(target, args);
				return object;
			}
		});
		
		@SuppressWarnings("unchecked")
		T proxy = (T) enhancer.create();
		return proxy;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3. 开始代理。

		ProxyObject proxied= new ProxyObject ();
		ProxyObject proxy = (ProxyObject)ProxyFactory.getProxy(proxied);
		// 干活
		proxy.doWork();
1
2
3
4