- content
前言
总结Java代理相关基础知识
课程目录
- 静态代理
- 动态代理(JDK动态代理、cglib动态代理)
静态代理
优点：
- 代理对象可以在不修改目标对象的情况下扩展和拦截目标对象行为
缺点：
- 代理对象和目标对象要实现共同接口，被代理对象改变，代理对象也要跟着变
//共同接口
public interface MyInterface {
void doSomething();
}
//被代理对象
public class MyClass implements MyInterface {
@Override
public void doSomething() {
System.out.println("something...");
}
}
//代理对象
public class MyProxy implements MyInterface {
private MyInterface target;
public MyProxy(MyInterface target){
this.target = target;
}
@Override
public void doSomething() {
System.out.println("before doSomething...");
target.doSomething();
System.out.println("after doSomething...");
}
}
//测试静态代理
public class StaticProxyTest {
public static void main(String[] args) {
MyClass target=new MyClass();
MyProxy proxy=new MyProxy(target);
proxy.doSomething();
}
}
动态代理
JDK动态代理
java.lang.reflect 包提供了一个Proxy类和一个InvocationHandler接口，用来生成JDK动态代理类和动态代理对象。
//省略相同的接口及目标实现对象...
//创建一个调用处理器来通过反射的方式处理目标对象行为
public class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target){
this.target=target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before...");
Object result = method.invoke(target,args);
System.out.println("after...");
return result;
}
}
//测试类
public class DynamicProxyTest {
public static void main(String[] args) {
//目标对象
MyInterface target=new MyClass();
//代理
MyInvocationHandler myInvocationHandler=new MyInvocationHandler(target);
MyInterface proxy=(MyInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),myInvocationHandler);
proxy.doSomething();
}
}
当然每次需要代理一个对象都创建这么一个InvocationHandler很不方便，可以封装出来一个代理工厂，生产通用的代理对象
//代理工厂类
public class ProxyFactory {
//给目标对象生成代理对象
public static Object getProxyInstance(Object target){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
(proxy, method, args) -> {
System.out.println("before...");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("after...");
return returnValue;
}
);
}
}
//测试类
public class DynamicProxyTest {
public static void main(String[] args) {
MyInterface target=new MyClass();
MyInterface proxy = (MyInterface)ProxyFactory.getProxyInstance(target);
proxy.doSomething();
}
}
生成代理类的过程如下：
缺点：
- JDK动态代理也是需要目标对象实现一个接口的
- 使用反射机制来创建代理对象，性能据说较差
cglib动态代理（子类代理）
<!-- 引入cglib包 -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.7</version>
</dependency>
//目标对象
public class MyClassWithoutInterface {
public void doSomething() {
System.out.println("something...");
}
}
//代理类
public class MyCglibProxy implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("before...");
Object o1 = methodProxy.invokeSuper(o, args);
System.out.println("after...");
return o1;
}
}
//测试类
public class CglibTest {
public static void main(String[] args) {
Enhancer enhancer=new Enhancer();
enhancer.setSuperclass(MyClassWithoutInterface.class);
enhancer.setCallback(new MyCglibProxy());
MyClassWithoutInterface myClass = (MyClassWithoutInterface)enhancer.create();
myClass.doSomething();
}
}
同样的，也可以创建一个通用的代理工厂
/**
* Cglib子类代理工厂
*/
public class ProxyFactory implements MethodInterceptor {
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
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 obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("before...");
Object returnValue = method.invoke(target, args);
System.out.println("after...");
return returnValue;
}
}
//测试类
public class CglibTest {
public static void main(String[] args) {
MyClassWithoutInterface target = new MyClassWithoutInterface();
MyClassWithoutInterface proxy = (MyClassWithoutInterface)new ProxyFactory(target).getProxyInstance();
proxy.doSomething();
}
}
优点：
- 不需要目标对象实现接口，内存中动态创建子类的方式来创建代理类，所以被代理目标对象不能是final类
- 使用ASM字节码技术，性能据说好一些
在Spring的AOP编程中:
- 如果加入容器的目标对象有实现接口,用JDK代理
- 如果目标对象没有实现接口,用Cglib代理