Java的JDK动态代理
当需要调用一个目标对象执行一个方法做某件事时,这时不方便直接用目标对象,或没有目标对象,则可以通过代理对象间接的调用目标对象的方法。
代理作用:对目标对象进行控制或功能增强
静态代理
静态代理:代理类是提前创建好的,只要直接通过代理对象调用目标对象即可(静态代理类似于装饰者模式,不过装饰者模式作用主要在于对 被装饰者的功能增强,而代理作用主要在于对目标对象(被代理对象)进行控制,装饰者模式是静态代理的一种体现)
- Singer(歌手):代理类(Agent)与被代理的类(ZhangSan)共同实现的接口
//代理对象需要有被代理对象全部的方法,代理对象与被代理对象要实现共同的接口
public interface Singer {
//唱歌
void sing(String song);
//跳舞
void dance(String danceName);
}
- ZhangSan(张三):被代理类
//被代理的类
public class ZhangSan implements Singer {
@Override
public void sing(String song) {
System.out.println("被代理对象唱:"+song);
}
@Override
public void dance(String danceName) {
System.out.println("被代理对象跳:"+danceName);
}
}
- Agent(经纪人):代理类
//代理类
public class Agent implements Singer {
private ZhangSan zhangSan;
public Agent(ZhangSan zhangSan) {
this.zhangSan = zhangSan;
}
@Override
public void sing(String song) {
/*
代理对象要做的事情(对被代理对象的控制与功能增强):
调用被代理对象同名方法之前可做一些其他操作, 调用被代理对象同名方法之后还再可做一些其他操作
*/
//调用被代理对象同名方法之前做一些其他操作
System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
song="凉凉";
//调用被代理对象同名方法
zhangSan.sing(song);
//调用被代理对象同名方法之后还再可做一些其他操作
System.out.println("代理对象——>唱完了,收场");
}
@Override
public void dance(String danceName) {
System.out.println("跳:"+danceName);
}
}
- ProxyTest:测试
public class ProxyTest {
public static void main(String[] arg){
ZhangSan zhangSan = new ZhangSan();
Agent agent = new Agent(zhangSan);
agent.sing("怒放的生命");
}
}
运行输出:直观的体现出对被代理对象的控制与功能增强
动态代理,基于接口的动态代理
动态代理:代理类不存在,在代码运行过程中,动态生成的代理类,再通过代理类对象调用目标对象。
注:JDK官方的Proxy类创建代理对象,被代理类最少要实现一个接口。
思考:生成代理对象有什么要求?
- 代理类应该与目标对象有相同方法—>需要提供代理类要实现的接口,即被代理类最少实现一个接口。
- 使用代理是要对目标对象进行控制或功能增强—>需要提供代理类要做的事情
- 在代码运行过程中,动态生成的代理类,加载到内存中,并创建代理类对象—>需要提供类加载器
动态代理分两种情况:
- 有接口,有目标对象,生成代理对象
- Singer(接口)
//代理对象需要有目标对象(被代理对象)全部的方法,代理对象与目标对象要实现共同的接口
public interface Singer {
//唱歌
String sing(String song);
//跳舞
void dance(String danceName);
}
- Zhangsan(目标类,被代理的类)
//被代理的类
public class ZhangSan implements Singer {
@Override
public String sing(String song) {
System.out.println("被代理对象唱:"+song);
return song;
}
@Override
public void dance(String danceName) {
System.out.println("被代理对象跳:"+danceName);
}
}
- ProxyTest(通过Proxy生成代理对象,让代理对象调用目标对象的方法)
public class ProxyTest {
public static void main(String[] arg){
ZhangSan zhangSan = new ZhangSan();
/*java.lang.reflect.Proxy创建代理对象的方法:newProxyInstance
方法的参数:
ClassLoader:类加载器。被代理的对象(目标对象)的类加载器,主要作用是将字节码对象载入到内存中,并对数据类型的校验。
Class[]:字节码数组。被代理对象所实现的所有接口的字节码集合,主要作用是让生成的代理对象和被代理的对象拥有相同方法。(本质是给被代理对象的接口生成一个实现类)
写法:new Class[]{Singer.class} ZhangSan.class.getInterfaces()
InvocationHanlder:写要增强的方法,实现一个接口InvoationHandler,需要提供它的实现类,通常写的是匿名内部类。
*/
Singer singerProxy = (Singer) Proxy.newProxyInstance(
ZhangSan.class.getClassLoader(),
ZhangSan.class.getInterfaces(),
new InvocationHandler() {
/**
执行 被代理对象的任何方法都都会经过该方法,该方法有拦截的作用
方法的参数:
Object proxy:代理对象的引用。
Method method:当前执行的方法 (被代理对象的方法)
Object[] args:当前方法所需的参数
返回值:
和 被代理对象的方法有相同的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//定义一个对象,存储返回结果
String invoke = null;
//获取方法名字
String name = method.getName();
if ("sing".equals(name)) {
//方法参数
String parameter = (String) args[0];
//调用目标对象的方法之前做一些其他操作(对目标对象进行控制或功能增强)
System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
parameter = "凉凉";
//反射调用目标对象的同名方法
/*方法的参数:
object:调用哪个对象的方法
parameterValues:调用方法时传递的实参
*/
invoke = (String) method.invoke(zhangSan, parameter);
//调用目标对象的方法之后再一些其他操作(对目标对象进行控制或功能增强)
System.out.println("代理对象——>唱完了,收场");
} else if ("dance".equals(name)) {
//方法参数
String parameter = (String) args[0];
System.out.println("代理对象——>把《卡路里》换成《小苹果》");
parameter = "小苹果";
method.invoke(zhangSan, parameter);
}
// 返回值的含义 和 被代理对象的方法有相同的返回值
return invoke;
}
});
/*
代理对象调用目标对象(被代理对象)的方法
执行的方法会经过invoke方法(invoke方法有拦截的作用)
执行我们功能增强的代码,在通过反射调用目标对象(被代理对象)的同名方法
调用目标对象(被代理对象)的方法后,再执行调用目标对象(被代理对象)的方法后写的功能增强的代码
*/
String song = singerProxy.sing("怒放的生命");
System.out.println("返回值:"+song);
System.out.println("---------------------------");
singerProxy.dance("卡路里");
}
}
- 有接口,没有目标对象,生成代理对象
- Singer(接口)
//代理对象需要有目标对象(被代理对象)全部的方法,代理对象与目标对象要实现共同的接口
public interface Singer {
//唱歌
String sing(String song);
//跳舞
void dance(String danceName);
}
- ProxyTest(通过Proxy生成代理对象,由代理对象完成所有工作)
public class Test {
public class ProxyTest {
public static void main(String[] arg){
/*java.lang.reflect.Proxy创建代理对象的方法:newProxyInstance
方法的参数:
ClassLoader:类加载器。被代理的对象(目标对象)的类加载器,主要作用是将字节码对象载入到内存中,并对数据类型的校验。
Class[]:字节码数组。被代理对象所实现的所有接口的字节码集合,主要作用是让生成的代理对象和被代理的对象拥有相同方法。(本质是给被代理对象的接口生成一个实现类)
写法:new Class[]{Singer.class} ZhangSan.class.getInterfaces()
InvocationHanlder:写要增强的方法,实现一个接口InvoationHandler,需要提供它的实现类,通常写的是匿名内部类。
*/
Singer singerProxy = (Singer) Proxy.newProxyInstance(
ProxyTest.class.getClassLoader(),
new Class[]{Singer.class},
new InvocationHandler() {
/**
执行 被代理对象的任何方法都都会经过该方法,该方法有拦截的作用
方法的参数:
Object proxy:代理对象的引用。
Method method:当前执行的方法 (被代理对象的方法)
Object[] args:当前方法所需的参数
返回值:
和 被代理对象的方法有相同的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//获取方法名字
String name = method.getName();
if ("sing".equals(name)) {
//方法参数
String parameter = (String) args[0];
System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
parameter = "凉凉";
System.out.println("代理对象唱:"+parameter);
System.out.println("代理对象——>唱完了,收场");
} else if ("dance".equals(name)) {
//方法参数
String parameter = (String) args[0];
System.out.println("代理对象——>把《卡路里》换成《小苹果》");
parameter = "小苹果";
System.out.println("代理对象跳:"+parameter);
}
return null;
}
});
//通过Proxy生成代理对象,由代理对象完成所有工作
singerProxy.sing("怒放的生命");
System.out.println("----------------------------");
singerProxy.dance("卡路里");
}
}
CGLib动态代理,基于普通类的动态代理
CGLib动态代理可以给一个普通类生成一个代理对象,JDK提供的动态代理则要求被代理类最少要实现一个接口,才能生成代理对象。
注:使用CGLib的Enhancer类创建代理对象,被代理类不能用final修饰的类。
- 通过maven创建项目引入依赖
<dependencies>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.1_3</version>
</dependency>
</dependencies>
- ZhangSan(张三):被代理类
//被代理的类
public class ZhangSan implements Singer {
@Override
public void sing(String song) {
System.out.println("被代理对象唱:"+song);
}
@Override
public void dance(String danceName) {
System.out.println("被代理对象跳:"+danceName);
}
}
- ProxyTest(使用CGLib的Enhancer类创建代理对象)
public class ProxyTest {
public static void main(String[] arg){
final ZhangSan zhangSan = new ZhangSan();
/*Enhancer创建代理对象的方法:create
方法的参数:
Class:写 指定对象生成代理 的字节码,即被代理对象的字节码。
Callback:写 增强的代码,通常写匿名内部类,一般使用Callback接口的子接口:MethodInterceptor
*/
ZhangSan zhangSanProxy = (ZhangSan) Enhancer.create(
zhangSan.getClass(),
new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//定义一个对象,存储返回结果
String invoke = null;
//获取方法名字
String name = method.getName();
if ("sing".equals(name)) {
//方法参数
String parameter = (String) objects[0];
//调用目标对象的方法之前做一些其他操作(对目标对象进行控制或功能增强)
System.out.println("代理对象——>把《怒放的生命》换成《凉凉》");
parameter = "凉凉";
//反射调用目标对象的同名方法
/*方法的参数:
object:调用哪个对象的方法
parameterValues:调用方法时传递的实参
*/
invoke = (String) method.invoke(zhangSan, parameter);
//调用目标对象的方法之后再一些其他操作(对目标对象进行控制或功能增强)
System.out.println("代理对象——>唱完了,收场");
} else if ("dance".equals(name)) {
//方法参数
String parameter = (String) objects[0];
System.out.println("代理对象——>把《卡路里》换成《小苹果》");
parameter = "小苹果";
method.invoke(zhangSan, parameter);
}
// 返回值的含义 和 被代理对象的方法有相同的返回值
return invoke;
}
});
String song = zhangSanProxy.sing("怒放的生命");
System.out.println("返回值:"+song);
System.out.println("---------------------------");
zhangSanProxy.dance("卡路里");
}
}