1、JDK动态代理
在Java动态代理机制中
InvocationHandler
接口和Proxy
类是核心。
Proxy
类中使用频率最高的方法是:newProxyInstance()
,这个方法主要用来生成一个代理对象。要实现动态代理的话,还必须需要实现
InvocationHandler
来自定义处理逻辑。 当我们的动态代理对象调用一个方法时,这个方法的调用就会被转发到实现InvocationHandler
接口类的invoke
方法来调用。
-
定义一个接口及其实现类;
-
自定义
InvocationHandler
并重写invoke
方法,在invoke
方法中我们会调用原生方法(被代理类的方法)并自定义一些处理逻辑; -
通过
Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
方法创建代理对象;
public interface SmsgService {
String send(String msg);
}
public class SmsgServiceImpl implements SmsgService {
@Override
public String send(String msg) {
System.out.println("send message:" + msg);
return msg;
}
}
public class MyInvocationHandler implements InvocationHandler {
// 被代理的真实对象
private final Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
/**
* @param proxy 代理对象
* @param method 需要代理的方法
* @param args 方法参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//调用方法之前,我们可以添加自己的操作
System.out.println("before method " + method.getName());
Object result = method.invoke(target, args);
//调用方法之后,我们同样可以添加自己的操作
System.out.println("after method " + method.getName());
return result;
}
}
public class ProxyFactory {
// 返回代理对象 利用反射获取类加载器、
public static Object getProxy(Object target) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 目标类的类加载器
target.getClass().getInterfaces(), // 代理需要实现的接口,可指定多个
new MyInvocationHandler(target) // 代理对象对应的自定义 InvocationHandler
);
}
}
public class ProxyTest {
public static void main(String[] args) {
/*
* Jdk动态代理实现步骤
* 1.接口与实现类
* 2.自定义InvocationHandler实现invoke方法,在invoke方法中实现对需要代理的方法增强
* 3.实现ProxyFactory来获取代理对象,Proxy.newProxyInstance()
*
*/
SmsgService smsgService = (SmsgService) ProxyFactory.getProxy(new SmsgServiceImpl());
smsgService.send("JDK动态代理实现");
}
}
2、cglib动态代理
JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。
为了解决这个问题,我们可以用 CGLIB 动态代理机制来避免。
在 CGLIB 动态代理机制中
MethodInterceptor
接口和Enhancer
类是核心。
-
定义一个类;
-
自定义
MethodInterceptor
并重写intercept
方法,intercept
用于拦截增强被代理类的方法,和 JDK 动态代理中的invoke
方法类似; -
通过
Enhancer
类的create()
创建代理类;
引入依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
public class SmsgService {
public String send(String msg) {
System.out.println("send msg" + msg);
return msg;
}
public String receive(String msg) {
System.out.println("receive msg" + msg);
return msg;
}
}
public class MyMethodInterceptor 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;
}
}
public class CglibProxyFactory {
public static Object getProxy(Class<?> clazz) {
// 创建动态代理增强类
Enhancer enhancer = new Enhancer();
// 设置类加载器
enhancer.setClassLoader(clazz.getClassLoader());
// 设置被代理类
enhancer.setSuperclass(clazz);
// 设置方法拦截器
enhancer.setCallback(new MyMethodInterceptor());
// 创建代理类
return enhancer.create();
}
}
public class ProxyTest {
public static void main(String[] args) {
/*
cglib动态代理实现步骤:
1.创建实现类
2.自定义MethodInterceptor
3.创建CglibProxyFactory
*/
SmsgService smsgService = (SmsgService) CglibProxyFactory.getProxy(SmsgService.class);
smsgService.receive("cglib动态代理实现receive()");
smsgService.send("cglib动态代理实现send()");
}
}
三、静态代理和动态代理的对比
灵活性:动态代理更加灵活,不需要必须实现接口,可以直接代理实现类,并且可以不需要针对每个目标类都创建一个代理类。另外,静态代理中,接口一旦新增加方法,目标对象和代理对象都要进行修改,这是非常麻烦的!
JVM 层面:静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码,并加载到 JVM 中的