代理模式。

代理模式

代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。

代理模式的应用场景：

代理模式最常用应用场景是，在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。Spring AOP的底层实现就是基于动态代理。

代理模式的实现：

一般情况下，我们让代理类和原始类实现同样的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的。在这种情况下，我们可以通过让代理类继承原始类的方法来实现代理模式。

JDK动态代理

// 静态代理
interface Hello {
    String sayHello(String str);
}

class HelloImpl implements Hello {
    @Override
    public String sayHello(String str) {
        return "HelloImpl:" + str;
    }
}

// HelloImplProxy作为HelloImpl的代理，实现了Hello接口
class HelloImplProxy implements Hello {
    
    private Hello hello = new HelloImpl();
    
    @Override
    public String sayHello(String str) {
        System.out.println("you said: "+ str);
        hello.sayHello(str);
    }
}

class Hello {
    
    public String sayHello(String str) {
        System.out.println("say hello " + str);
    }
}

public class HelloProxy extends Hello {

    private Hello hello;
    
    public HelloProxy(Hello hello) {
        this.hello = hello;
    }
    
    @Override
    public String sayHello(String str) {
        hello.sayHello(str);
        log.info("say hello");
    }
}

Hello hello1 = new HelloProxy(hello);

使用JDK动态代理时：

1. 首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法
2. 然后在需要使用Hello的时候，通过JDK动态代理获取Hello的代理对象

// Java Proxy
// 1. 首先实现一个InvocationHandler，方法调用会被转发到该类的invoke()方法。
class LogInvocationHandler implements InvocationHandler{
	...
	private Hello hello;
	public LogInvocationHandler(Hello hello) {
		this.hello = hello;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if("sayHello".equals(method.getName())) {
			logger.info("You said: " + Arrays.toString(args));
		}
		return method.invoke(hello, args);
	}
}
// 2. 然后在需要使用Hello的时候，通过JDK动态代理获取Hello的代理对象。
Hello hello = (Hello)Proxy.newProxyInstance(
    getClass().getClassLoader(), // 1. 类加载器
    new Class<?>[] {Hello.class}, // 2. 代理需要实现的接口，可以有多个
    new LogInvocationHandler(new HelloImp()));// 3. 方法调用的实际处理者
System.out.println(hello.sayHello("I love you!"));

Java动态代理是基于接口的，如果对象没有实现接口，可以使用CGLIB。

CGLIB动态代理

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理，无法处理final的情况。

// 没有实现任何接口的类HelloConcrete
public class HelloConcrete {
	public String sayHello(String str) {
		return "HelloConcrete: " + str;
	}
}

// CGLIB动态代理
// 1. 首先实现一个MethodInterceptor，方法调用会被转发到该类的intercept()方法。
class MyMethodInterceptor implements MethodInterceptor{
  ...
	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		logger.info("You said: " + Arrays.toString(args));
		return proxy.invokeSuper(obj, args);
	}
}
// 2. 然后在需要使用HelloConcrete的时候，通过CGLIB动态代理获取代理对象。
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HelloConcrete.class);
enhancer.setCallback(new MyMethodInterceptor());

HelloConcrete hello = (HelloConcrete)enhancer.create();
System.out.println(hello.sayHello("I love you!"));

总结

JDK原生动态代理是Java原生支持的，不需要任何外部依赖，但是它只能基于接口进行代理；CGLIB通过继承的方式进行代理，无论目标对象有没有实现接口都可以代理，但是无法处理final的情况。

态代理的代理关系在编译时就确定了，而动态代理的代理关系是在运行期确定的。静态代理实现简单，适合于代理类较少且确定的情况，而动态代理则给我们提供了更大的灵活性。Java中常见的动态代理方式有：JDK原生动态代理和CGLIB动态代理。