一.代理简聊
什么是代理?
所谓代理,其实就是在访问实际对象时引入一定程度的间接性,因为这种间接性,就可以增加许多操作.
这通常需要代理和原有对象之间要有相同的行为.
举个小例子:
小时候都需要交班费,一般都是统一交给班长,再又班长交给老师,那班长其实就是学生的代理,因为班长和学生都有交班费的统一行为,同时,班长在将班费交给老师时,还可以进行一些额外的操作,比如说某某最近表现良好.这就是典型的代理.
代理的优点:
- 在不修改原代码的基础上，扩展和增强实现；
- 代码解耦，在代理中通过参数可以判断真实类，做出不同的响应或调用，灵活方便；
代理的分类:
主要分为静态代理和动态代理
动态代理目前又有两种主要的实现方式:jdk动态代理和cglib
二.静态代理
静态代理的最主要特征就是由程序员创建代理类,代理类在程序运行之前就已经确定生成.
举个小李子:
还是上面那个例子,班长代理学生去交班费
*** 创建一个公共接口 ***
//创建一个公共接口
public interface Person {
void submitMoney();
}
*** 创建学生类 ***
public class Student implements Person {
private String name;
public String getName() {
return name;
}
public Student(String name) {
this.name = name;
}
//交班费方法
public void submitMoney() {
System.out.println(name+"上交班费50元");
}
}
*** 创建学生代理类 ***
public class StudentProxys implements Person{
private Student student;
public StudentProxys(Student student) {
this.student = student;
}
public void submitMoney() {
System.out.println(student.getName()+"最近表现很好");
student.submitMoney();
}
}
*** 测试方法 **
public class test {
public static void main(String[] args) {
//创建学生对象
Student student = new Student("张三");
//创建代理对象
StudentProxys studentProxys = new StudentProxys(student);
//代理执行方法
studentProxys.submitMoney();
}
}
*** 输出结果 ***
张三最近表现很好
张三上交班费50元
三.动态代理
动态代理的最大区别就是,在实现阶段不用关心代理类,代理类不是程序员写的,而是在运行时根据我们的"指示"动态生成的.
动态代理的实现方式通常有两种:jdk动态代理和cglib代理
1.jdk动态代理
jdk动态代理是Java自带的一种代理生成方式.
动态代理本质就是让别人(别人写好的程序)帮我们生成代理类,那我们就需要遵循别人的规则,在jdk动态代理中,我们可以通过Proxy类的newProxyInstances方法来动态生成代理类.
有了具体的方法,我们还需要告诉程序那个类是被代理类,要实现哪个接口,代理中具体执行的操作是什么.
jdk动态代理的大致原理?
jdk动态代理其实就是在运行时动态生成一个代理类,这个代理对象一定和原有对象实现同一个接口,这样就可以有相同的行为.所以当使用jdk动态代理时,原有对象必须要实现一个接口.
那么代理类大概是怎么样进行代理,执行操作的呢?
在具体设计中,所有代理对象要执行的方法都会被替换成invoke方法.然后在invoke方法中,根据方法名称再执行具体的实例方法.
具体实现
实现方法:
proxy.newProxyInstance(ClassLoader classLoder,class[] classes,InvacationHander)
方法参数说明:
ClassLoder: 原始对象的类加载器
Class[]:字节码对象数组, 告诉程序要实现哪一个接口
InvacationHander:提供增强机制. 告诉程序在代理中具体执行的操作是什么,一般都是会写一个InvocationHandle(调用处理)的匿名内部类.
实现举例:
- 一个公共的代理的接口
public interface ProducerProxyInterface {
void spanMoney(double money);
}
2.被代理类Producer
public class Producer implements ProducerProxyInterface {
public void spanMoney(double money) {
System.out.println("花费"+money+"元");
}
}
3.具体测试,动态生成代理类
public class Consumer {
public static void main(String[] args) {
//new一个被代理对象,因为代理类执行被代理类的方法时,需要用到被代理类的对象
final Producer producer = new Producer();
//等号右面这一大串就相当于生成了一个代理类,这个代理类肯定会实现ProducerProxyInterface接口
ProducerProxyInterface proxyInstance = (ProducerProxyInterface) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(),
new InvocationHandler() { //调用处理,
/**
*通过代理对象执行任何方法都会执行该方法
* @param proxy 代表动态处理对象
* @param method 代表正在执行的方法
* @param args 代表正在执行方法中传入的实参
* @return 和被代理对象执行方法的返回值相同
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("正在执行的方法" + method);
Double money = (Double) args[0]; //这里的args[0]就是执行方法时传入的1000.
//这一步就相当于真正执行被代理对象的方法
Object obj = method.invoke(producer, money * 0.8);
return obj;
}
});
//执行代理类中的spanMoney方法
proxyInstance.spanMoney(1000);
}
}
输出结果:
正在执行的方法public abstract void com.cc.spring.proxy.ProducerProxyInterface.spanMoney(double)
花费800.0元
2.cglib动态代理
CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口.
cglib动态代理的大致原理?
CGLIB 通过动态生成一个子类，该子类继承被代理类,重写被代理类的所有不是 final 修饰的方法，并在子类中采用方法拦截的技术拦截父类所有的方法调用.
具体实现
- 引入依赖.
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
2.通过Enhancer.create方法创建代理
参数:class:被代理类的Class对象.
Callback:用于提供增强代码.
实现举例:
1.被代理类
public class Producer {
public void spanMoney(double money) {
System.out.println("花费"+money+"元");
}
}
2.动态生成被代理类的加工,测试
public class Consumer {
public static void main(String[] args) {
//new一个被代理对象,因为代理类执行被代理类的方法时,需要用到被代理类的对象
final Producer producer = new Producer();
Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
/**
* 执行被代理类中任意方法时,都会经过该方法
* @param o 动态代理对象
* @param method 正在执行的方法
* @param arg 正在执行的方法所传的参数
* @param methodProxy 当前执行方法的代理对象
* @return 和执行方法返回的值相同
* @throws Throwable
*/
public Object intercept(Object o, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
System.out.println(methodProxy);
Double money = (Double) arg[0];
return method.invoke(producer, money*0.8);
}
});
cglibProducer.spanMoney(1000);
}
}
四.动态代理总结、注意事项
1.jdk动态代理与cglib的区别.
-
JDK 动态代理只能对接口进行代理，不能对普通的类进行代理，这是因为 JDK 动态代理生成的代理类，其父类是 Proxy，且 Java 不支持类的多继承。
-
CGLIB 能够代理接口和普通的类，但是被代理的类不能被 final 修饰，且接口中的方法不能使用 final 修饰。
-
JDK 动态代理使用 Java 反射技术进行操作，在生成类上更高效。
-
CGLIB 使用 ASM 框架直接对字节码进行修改，使用了 FastClass 的特性。在某些情况下，类的方法执行会比较高效。
2.注意事项及分析.
在使用动态代理的时候会有一些限制,比如说,不能对private,static方法进行代理.这里进行一个小总结,并继续简单分析.
×即表示不可代理
√表示可以代理
为什么cglib不能代理private,final,static方法?
因为cglib代理类是通过继承被代理类实现的,如果方法被private修饰,那么子类是无法调用超类的私有方法的;如果被final修饰,那也就无法重写需要代理的方法,也是不行的; 如果被static修饰,从技术的角度是可以实现的,但是被排除了,因为从程序的设计角度来讲,静态方法是属于类的,而不是属于某个对象的.
为什么jdk动态代理不能代理private,static方法,而可以代理final方法?
在jdk动态代理中,代理类和被代理类需要实现共同的接口,去有相同的行为,那么private,static方法都是无法修饰接口方法的,也就自然行不通了.
那final也无法修饰接口方法,为什么可以呢?这是因为我们可以将子类的方法修改成final修饰的,并且这个操作并不改变这种重写关系.
五.aop原理
其实就是通过代理实现.
在我们使用过程中会配置一个切面,和一个切点,切点中会配置一个路径,比如是* com.wind.Controller..(…).那么在spring进行容器注入的时候,就会将该路径下(Controller)的代理对象注入到容器当中,也就是存储在singleonObject(单例对象存储空间),一个concurrentHashMap中,
在我们注入对象的时候得到的就直接是代理对象,在执行代理对象的时候就可以做一些操作,前置处理,后置处理这些.
======================================================================================================
如果你需要阅读专业书籍来提升自己,可以关注博主的公众号,回复 图书即可获得几百本程序员必读书籍.
包含以下所有分类中的各种经典书籍.
今天的分享就到这里了,有问题可以在评论区留言,均会及时回复呀.
我是bling,未来不会太差,只要我们不要太懒就行, 咱们下期见.
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
