代理相关的知识集
目录
说到代理我们要先知道代理的分类
代理大方向分为两类：
Ⅰ静态代理
Ⅱ动态代理
jdk动态代理
cglib动态代理
下面我们来看看各种代理之间的区别和实现方式吧
静态代理
静态代理的实现方法：
静态代理的实际应用：
动态代理
JDK动态代理
实现原理：
说到代理我们要先知道代理的分类
代理大方向分为两类：
Ⅰ静态代理
Ⅱ动态代理
jdk动态代理
cglib动态代理
下面我们来看看各种代理之间的区别和实现方式吧
静态代理
静态代理是一种代理模式，它通过手动编写代理类的代码，将被代理对象的方法调用委托给代理类，从而实现对被代理对象的控制。静态代理的实现方法包括两个关键角色：代理类和被代理类。
静态代理的实现方法：
-
定义接口： 定义一个接口，包含被代理对象和代理对象都需要实现的方法。
public interface Subject { void request(); } -
实现被代理类： 被代理类实现接口，提供具体的业务逻辑。
public class RealSubject implements Subject { @Override public void request(){ System.out.println("RealSubject: Handling request."); } } -
实现代理类： 代理类也实现接口，并在其中包含一个对被代理对象的引用，代理类中的方法实际上是对被代理对象方法的调用，可以在调用前后添加额外的逻辑。
public class ProxySubject implements Subject { private RealSubject realSubject; public ProxySubject(RealSubject realSubject) { this.realSubject = realSubject; } @Override public void request() { System.out.println("ProxySubject: Before request."); realSubject.request(); System.out.println("ProxySubject: After request."); } } -
使用代理： 在客户端代码中使用代理对象。
public class Client { public static void main(String[] args) { RealSubject realSubject = new RealSubject(); ProxySubject proxy = new ProxySubject(realSubject); proxy.request(); } }
静态代理的实际应用：
- 安全检查： 在调用被代理对象的方法前进行权限或安全检查。
- 日志记录： 在方法调用前后记录日志信息。
- 性能监控： 统计方法的执行时间等性能指标。
动态代理
JDK动态代理
实现原理：
使用 java.lang.reflect.Proxy 类和 java.lang.reflect.接口。
在运行时动态生成一个实现被代理接口的代理类。
通过 InvocationHandler 接口的 invoke 方法进行方法的调用处理。
适用场景：
被代理类必须实现接口。
适用于横切关注点与业务逻辑之间耦合较弱的情况。
实现方法：
1.定义一个被代理类
/**
* @author tong
*/
public class Calculator {
public int add(int i, int j) {
int result = i + j;
System.out.println("方法内部 result = " + result);
return result;
}
public int sub(int i, int j) {
int result = i - j;
System.out.println("方法内部 result = " + result);
return result;
}
public int mul(int i, int j) {
int result = i * j;
System.out.println("方法内部 result = " + result);
return result;
}
public int div(int i, int j) {
int result = i / j;
System.out.println("方法内部 result = " + result);
return result;
}
}
2.生产代理对象的工厂类 ProxyFactory：
/**
* 动态代理有两种：
* 1. jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口，在com.sun.proxy包下，类名为$proxy+数字 （例如：$proxy6）
* 2. cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
*/
public class ProxyFactory {
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 通过该方法可以生成任意目标类所对应的代理类
public Object getProxy(){
/**
* newProxyInstance()：创建一个代理实例
* 其中有三个参数：
* 1、classLoader：指定加载动态生成的代理类的类加载器（注：所有引入的第三方类库以及
自己编写的java类 都是由 应用类加载器 负责加载的）
【根类加载器（Bootstrap）> 扩展类加载器（Extension）> 系统类加载器（System）
系统类加载器又称为应用类加载器】
* 2、interfaces：获取目标对象实现的所有接口的class对象所组成的数组
* 3、invocationHandler：设置代理对象实现目标对象的接口的方法的过程，即代理类中如何
重写接口中的抽象方法
*/
//第一个参数,获取代理对象的类加载器 （类加载器是程序中默认的类加载器，一般来说，Java
应用的类都是由它来完成加载。所以，此处通过代理类或者被代理类获取到的类加载器都是同一个，
或通过任何一个类获取到的类加载器都是同一个。）
ClassLoader classLoader = this.getClass().getClassLoader();
//第二个参数,被代理对象实现的所有接口数组
Class[] interfaces = target.getClass().getInterfaces();
//当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
//代理实例的调用处理程序
//第三个参数InvocationHandler的实现类,这里用了匿名内部类的方式
InvocationHandler invocationHandler = new InvocationHandler() {
//重写InvocationHandler的invoke方法,他有三个参数可以供我们使用
@Override
public Object invoke(Object proxy, Method method, Object[] args){
/**
* proxy：表示代理对象
* method：表示要执行的方法（代理对象需要实现的抽象方法，即其中需要重写的和
目标类同名的方法）
* args：表示要执行的方法的参数列表（method所对应方法的参数列表）
*/
Object result = null;
try {
//method.getName(): 返回此method对象表示的方法的名称，作为字符串
System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
//通过反射调用method对象所表示的方法,并获取该方法的返回值
//在具有指定参数的指定对象上调用此method对象表示的底层方法。
//此处就是通过target来确定调用的是具体哪个类中的方法
result = method.invoke(target, args);
System.out.println("[动态代理][日志] "+method.getName()+"，结 果："+ result);
} catch (Exception e) {
e.printStackTrace();
System.out.println("[动态代理][日志] "+method.getName()+"，异常："+e.getMessage());
} finally {
System.out.println("[动态代理][日志] "+method.getName()+"，方法执行完毕");
}
return result;
}
};
//返回指定接口的代理类的实例，该实例将方法调用分派给指定的调用处理程序。
return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
}
}
3.测试类ProxyTest
package com.tong.proxy;
import com.tong.spring.calculator.Calculator;
import com.tong.spring.calculator.proxy.ProxyFactory;
import org.junit.Test;
/**
* @author tong
*/
public class ProxyTest {
@Test
public void testDynamicProxy(){
ProxyFactory factory = new ProxyFactory(new Calculator());
Calculator proxy = factory.getProxy();
/*创建好了代理对象,代理对象就可以执行被代理类实现的接口的方法；当通过代理类的对象
发起对被重写的方法的调用时，都会转换为对调用处理器实现类中的invoke方法的调用，
invoke方法中就可以对被代理类进行功能增强.*/
proxy.add(1, 5);
// proxy.div(1,0);
}
}
CGLIB动态代理
实现原理
使用第三方库，通过修改字节码生成目标类的子类。
在子类中对方法进行增强
由于生成的是类的子类，因此可以代理没有实现接口的类。
适用场景
被代理类不需要实现接口。
适用于横切关注点与业务逻辑之间耦合较紧密的情况。
实现方式
1.创建被代理类
package com.tong;
/**
* @author tong
* @Description：被代理类
*/
public class Star {
public void sing() {
System.out.println("唱.......");
}
public void dance() {
System.out.println("跳......");
}
}
2.生成代理工厂
package com.tong;
import com.oracle.jrockit.jfr.Producer;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* @author tong
* @Description：生成代理类的工厂
*/
public class ProxyFactory {
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
// 通过该方法可以生成任意目标类所对应的代理类
public static Object getProxy(Object target) {
// proxy就是我们创建的代理对象，这个对象可以执行被代理类中所有的方法，并且我们可以
在代理对象中对被代理类的方法进行增强
Object proxy = Enhancer.create(target.getClass(), new MethodInterceptor() {
/**
* 这一步是整个过程的关键，代理类的实现要通过Enhancer类，我们需要通过Enhancer
类中的create方法创建一个代理对象
* @param o 是一个代理对象的引用 (即：增强对象)
* @param method 是当前执行，即被拦截的被代理类方法
* @param objects 是当前执行方法所用的参数，索引顺序即为方法定义时参数的顺序
* @param methodProxy 指的是当前执行的方法的代理对象
* @return 通过反射调用method对象所表示的方法, 并获取该方法的返回值
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) {
Object result = null;
try {
// 提供增强代码
System.out.println("[cglib动态代理][日志] " + method.getName() +"
，参数：" + Arrays.toString(objects));
//通过反射调用method对象所表示的方法,并获取该方法的返回值
//在具有指定参数的指定对象上调用此method对象表示的底层方法。
//此处就是通过target来确定调用的是具体哪个类中的方法
result = method.invoke(target, objects);
System.out.println("[cglib动态代理][日志] " + method.getName() + "，
结果
：" + result);
} catch (Exception e) {
e.printStackTrace();
System.out.println("[cglib动态代理][日志] " + method.getName() + "，
异常：
" + e.getMessage());
} finally {
System.out.println("[cglib动态代理][日志] " + method.getName() + "，
方法执行完毕");
}
return result;
}
});
// 返回代理对象
return proxy;
}
}
3.生成测试类
package com.tong;
import org.junit.Test;
/**
* @author tong
* @Description：测试类
*/
public class ProxyTest {
@Test
public void test(){
Star star = new Star();
/* proxy就是我们创建的代理对象，这个对象可以执行被代理类中所有的方法，
并且我们可以在代理对象中对被代理类的方法进行增强，
注意这里使用了强转，因为getProxy方法的返回值是Object类型的对象*/
Star proxy = (Star)ProxyFactory.getProxy(star);
proxy.sing();
System.out.println("-----------------分割线------------------");
proxy.dance();
System.out.println("-----------------分割线------------------");
}
}
4.运行结果
JDK动态代理和CGLIB动态代理的区别
实现原理：
①JDK 动态代理是基于接口的代理，生成的代理类实现了被代理接口。
②CGLIB 动态代理是通过生成目标类的子类，代理类继承了被代理类。
适用场景：
①JDK 动态代理适用于被代理类实现了接口的情况。
②CGLIB 动态代理适用于被代理类没有实现接口的情况。
性能：
①JDK 动态代理的性能较好，因为它是基于接口的代理，直接使用 java.lang.reflect 包中的方法。
②CGLIB 动态代理生成的字节码较大，可能在性能上略逊于 JDK 动态代理，但在某些场景下性能差异并不明显。
使用方式：
①JDK 动态代理需要实现 InvocationHandler 接口，并使用 Proxy.newProxyInstance 方法创建代理对象。
②CGLIB 动态代理直接使用第三方库，不需要实现接口，通过 Enhancer.create 方法创建代理对象。
总体来说，选择使用 JDK 动态代理还是 CGLIB 动态代理取决于具体的业务场景和需求。如果被代理类已经实现接口，推荐使用 JDK 动态代理；如果被代理类没有实现接口或者想要在运行时对类进行增强，可以考虑使用 CGLIB 动态代理。
静态代理和动态代理的区别
实现方式：
①静态代理： 手动编写代理类的代码。
②动态代理： 在运行时生成代理类的字节码，无需手动编写代理类。
灵活性：
①静态代理： 代理类在编译时就确定，不够灵活。
②动态代理： 代理类在运行时生成，可以根据需要动态地创建代理类。
维护成本：
①静态代理： 每添加一个被代理类，都需要手动编写一个对应的代理类。
②动态代理： 通过动态生成代理类，可以更容易地维护和扩展。
性能：
①静态代理： 在编译时就确定了代理类，运行时性能相对较好。
②动态代理： 生成代理类的过程可能会带来一些性能开销。
动态代理常用的实现方式有基于java.lang.reflect.Proxy和基于CGLIB的动态代理。在实际应用中，根据需要选择静态代理或动态代理。