JAVA重要知识点
代理模式
定义
代理模式是一种设计模式。是使用代理对象来代替对真实对象的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
作用
扩展目标对象的功能，例如在目标对象的某个方法执行前后可以增加一些自定义的操作。
实现方式
有两种：静态代理和动态代理。
静态代理
对目标对象的每个方法的增强都是手动完成，不灵活。从实现和应用角度来说，如果接口新增一个方法，目标对象和代理对象都要进行修改，需要对每个目标类都单独写一个代理类。
从JVM层面来说，静态代理在编译时就将接口，实现类，代理类这些都变成实际的class文件
实现步骤
- 定义一个接口及其实现类
- 创建一个代理类同样实现这个接口
- 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样，就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后加入一些其他操作。
代码演示
定义发送短信的接口
public interface SmsService {
String send(String message);
}
实现发送短信的接口
public class SmsServiceImpl implements SmsService {
public String send(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 send(String message) {
//调用方法之前，我们可以添加自己的操作
System.out.println("before method send()");
smsService.send(message);
//调用方法之后，我们同样可以添加自己的操作
System.out.println("after method send()");
return null;
}
}
实际应用
public class Main {
public static void main(String[] args) {
SmsService smsService = new SmsServiceImpl();
SmsProxy smsProxy = new SmsProxy(smsService);
smsProxy.send("java");
}
}
动态代理
动态代理更加灵活。不需要针对每个目标类都单独创建一个代理类，也不需要必须实现接口，可以之间代理实现类（CGLIB动态代理机制）。
JVM角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM中。
Spring AOP和RPC框架的实现都依赖了动态代理。
动态代理的实现方式有很多种，例如JDK动态代理，CGLIB动态代理等。
JDK动态代理机制
InvocationHandler接口和Proxy类是核心。
Proxy类中使用频率最高的方法是：newProxyInstance()，这个方法主要是用来生成一个代理对象。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
......
}
- loader :类加载器，用于加载代理对象
- interfaces : 被代理类实现的一些接口
- h : 实现了 InvocationHandler 接口的对象
实现动态代理，还需要实现InvocationHandler用于自定义处理逻辑，当动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler接口类的invoke方法来调用。
public interface InvocationHandler {
/**
* 当你使用代理对象调用方法的时候实际会调用到这个方法
*/
public Object invoke(Object proxy,
Method method, Object[] args)
throws Throwable;
}
invoke() 方法有下面三个参数：
- proxy :动态生成的代理类
- method : 与代理类对象调用的方法相对应
- args : 当前 method 方法的参数
就是说：通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。
JDK动态代理类的使用步骤
- 定义一个接口及其实现类
- 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑
- 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象
代码实现
定义发送短信的接口
public interface SmsService {
String send(String message);
}
实现发送短信的接口
public class SmsServiceImpl implements SmsService {
public String send(String message) {
System.out.println("send message:" + message);
return message;
}
}
定义一个 JDK 动态代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class DebugInvocationHandler implements
InvocationHandler {
/**
* 代理类中的真实对象
*/
private final Object target;
public DebugInvocationHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method,
Object[] args)
throws InvocationTargetException, IllegalAccessException {
//调用方法之前，我们可以添加自己的操作
System.out.println("before method " + method.getName());
Object result = method.invoke(target, args);
//调用方法之后，我们同样可以添加自己的操作
System.out.println("after method " + method.getName());
return result;
}
}
invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。
获取代理对象的工厂类
public class JdkProxyFactory {
public static Object getProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
// 目标类的类加载
target.getClass().getInterfaces(),
// 代理需要实现的接口，可指定多个
new DebugInvocationHandler(target)
// 代理对象对应的自定义 InvocationHandler
);
}
}
getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象
实际应用
SmsService smsService = (SmsService) JdkProxyFactory.
getProxy(new SmsServiceImpl());
smsService.send("java");
CGLIB动态代理机制
JDK动态代理有个问题是只能代理实现了接口的类。
CGLIB可以避免这个问题。
CGLIB是一个基于ASM的字节码生成库，允许在运行时对字节码进行修改和动态生成。通过继承方式实现代理。
Spring中的AOP模块：如果目标对象实现了接口，则默认采用JDK动态代理，否则采用CGLIB动态代理。
在CGLIB动态代理机制中MethodInterceptor接口和Enhancer类是核心
需要自定义MethodInterceptor并重写intercept方法，该方法用于拦截增强被代理类的方法。
public interface MethodInterceptor
extends Callback{
// 拦截被代理类中的方法
public Object intercept(Object obj, java.lang.reflect.
Method method, Object[] args,MethodProxy proxy)
throws Throwable;
}
- obj : 被代理的对象（需要增强的对象）
- method : 被拦截的方法（需要增强的方法）
- args : 方法入参
- proxy : 用于调用原始方法
可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。
使用步骤
- 定义一个类
- 自定义MethodInterceptor并重写intercept方法，intercept用于拦截增强被代理类的方法，和JDK动态代理中的invoke方法类似
- 通过Enhancer类的create()创建代理类
代码实现
JDK动态代理不需要额外的依赖。CGLIB是一个开源项目，如果要使用它，需要手动添加相关依赖。
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
实现一个使用阿里云发送短信的类
package github.javaguide.dynamicProxy.cglibDynamicProxy;
public class AliSmsService {
public String send(String message) {
System.out.println("send message:" + message);
return message;
}
}
自定义MethodInterceptor(方法拦截器)
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* 自定义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("before method " + method.getName());
Object object = methodProxy.invokeSuper(o, args);
//调用方法之后，我们同样可以添加自己的操作
System.out.println("after method " + method.getName());
return object;
}
}
获取代理类
import net.sf.cglib.proxy.Enhancer;
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();
}
}
实际应用
AliSmsService aliSmsService = (AliSmsService)
CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");
JDK动态代理和CGLIB动态代理对比
- JDK动态代理只能代理实现了接口的类或直接代理接口，而CGLIB可以代理未实现任何接口的类。
注：CGLIB动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final类型的类和方法。
动态代理和静态代理对比
两方面进行对比，灵活性和JVM层面。
- 灵活性
动态代理更灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。
静态代理中，接口一单新增加方法，目标对象和代理对象都要进行修改，非常麻烦。 - JVM层面
静态代理在编译时就将接口，实现类，代理类变成一个个实际的class文件。而动态代理是在运行时，动态生成类字节码，并接在到JVM中。
587
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
