目录
十四、GoF之代理模式
14.1对代理模式的理解
-
场景：拍电影的时候，替身演员去代理演员完成表演。这就是一个代理模式。
-
演员为什么要找替身呢？（为什么要使用代理模式？）
-
怕自己受伤。（保护自己）
-
自己完成不了高难度动作。（功能增强）
-
-
在java程序中代理模式的作用：
-
当一个对象需要受到保护的时候，可以考虑使用代理对象去完成某个行为。
-
需要给某个对象的功能进行增强的时候，可以考虑找一个代理进行增强。
-
A对象无法和B对象直接交互，也可以使用代理模式来解决。
-
-
代理模式中有三个角色：
-
目标对象（演员）
-
代理对象（替身演员）
-
目标对象和代理对象的公共接口。（演员和替身演员应该具有相同的行为动作）
-
-
为什么演员和替身演员要有相同的行为动作呢？
-
不想让观众知道是替身演员，这里的观众其实就是“客户端程序”。
-
-
使用代理模式，对于客户端程序来说，客户端是无法察觉到的，客户端在使用代理对象的时候就像在使用目标对象。
-
代理模式是GoF23种设计模式之一，属于结构化设计模式。
-
代理模式在代码实现上，包括两种形式：
-
静态代理
-
动态代理
-
14.2静态代理
OrderService接口
package com.hhb.proxy.service;
//订单业务接口
public interface OrderService {//代理对象和目标对象的公共接口
//生产订单
void generate();
//修改订单信息
void modify();
//查看订单详情
void detail();
}OrderServiceImpl
package com.hhb.proxy.service;
public class OrderServiceImpl implements OrderService {
/**
* 问题：统计所有业务接口的每一个业务方法的耗时。
* 解决方案一：硬编码，在每一个业务接口中的每一个业务方法中直接添加统计耗时的程序
* 缺点：1.违背OCP开闭原则 2.代码没有得到复用
* 解决方案二：编写业务类的子类，让子类继承业务类，对每个业务方法进行重写
* 缺点：1.虽然解决了OCP开闭原则，但是代码耦合度很高，因为采用了继承关系。
* 2.代码没有得到复用
* 解决方案三：代理模式
* 优点：1.解决了OCP问题 2.采用代理模式的has a，可以降低耦合度
*
* 目前使用的是静态代理，这个静态代理的缺点是：类爆炸
* 解决方法：使用动态代理模式来解决这个问题。
* 动态代理还是代理模式，只不过添加了字节码生成技术，可以在内存中为我们动态生成一个class字节码，这个字节码就是代理类
* 在内存中动态生成字节码代理类的技术叫做：动态代理
*/
@Override
public void generate() {//目标方法
//模拟生成订单的耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("订单已生成");
}
@Override
public void modify() {//目标方法
//模拟修改订单的耗时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("订单已修改");
}
@Override
public void detail() {//目标方法
//模拟查询订单的耗时
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("请看订单详情");
}
}OrderServiceProxy
package com.hhb.proxy.service;
//代理对象（代理对象和目标对象要具有相同的行为，就要实现同一个或同一些接口）
//客户端在使用代理对象的时候就像在使用目标对象一样。
public class OrderServiceProxy implements OrderService {
//将目标对象作为代理对象的一个属性，这种关系叫做关联关系，比继承关系的耦合度低
//代理对象中含有目标对象的引用。关联关系：has a
//注意：这里要写一个公共接口类型，因为公共接口耦合度低
private OrderService target;//这就是目标对象，目标对象一定实现了OrderService接口
//创建代理对象的时候，传一个目标对象给代理对象。
public OrderServiceProxy(OrderService target) {
this.target = target;
}
@Override
public void generate() {//代理方法
//增强
long begin = System.currentTimeMillis();
//调用目标对象的目标方法
target.generate();
long end = System.currentTimeMillis();
System.out.println("耗时" + (end - begin) + "");
}
@Override
public void modify() {
long begin = System.currentTimeMillis();
target.modify();
long end = System.currentTimeMillis();
System.out.println("耗时" + (end - begin) + "");
}
@Override
public void detail() {
long begin = System.currentTimeMillis();
target.detail();
long end = System.currentTimeMillis();
System.out.println("耗时" + (end - begin) + "");
}
}客户端
package com.hhb.proxy.client;
import com.hhb.proxy.service.OrderServiceImpl;
import com.hhb.proxy.service.OrderServiceProxy;
public class Test {
public static void main(String[] args) {
//创建目标对象
OrderServiceImpl target = new OrderServiceImpl();
//创建代理对象
OrderServiceProxy proxy = new OrderServiceProxy(target);
//调用代理对象的代理方法
proxy.generate();
proxy.modify();
proxy.detail();
}
}-
以上就是代理模式中的静态代理，其中OrderService接口是代理类和目标类的共同接口。
-
OrderServiceImpl是目标类，OrderServiceProxy是代理类。
14.3动态代理
-
在程序运行阶段，在内存中动态生成代理类，被称为动态代理，目的是为了减少代理类的数量，解决代码复用的问题。
-
在内存当中动态生成类的技术常见的包括：
-
JDK动态代理技术：只能代理接口。
-
CGLIB动态代理技术：CGLIB是一个开源项目，是一个强大的、高性能、高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。它既可以代理接口，又可以代理类，底层是通过继承的方式实现的。性能比JDK动态代理要好。（底层有一个小而快的字节码处理框架ASM。）
-
Javassist动态代理技术。
-
14.3.1JDK动态代理
OrderService接口
package com.hhb.proxy.service;
//订单业务接口
public interface OrderService {//代理对象和目标对象的公共接口
//生产订单
void generate();
//修改订单信息
void modify();
//查看订单详情
void detail();
}OrderServiceImpl
package com.hhb.proxy.service;
public class OrderServiceImpl implements OrderService {
@Override
public void generate() {//目标方法
//模拟生成订单的耗时
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("订单已生成");
}
@Override
public void modify() {//目标方法
//模拟修改订单的耗时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("订单已修改");
}
@Override
public void detail() {//目标方法
//模拟查询订单的耗时
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("请看订单详情");
}
}-
在动态代理中，OrderServiceProxy代理类是可以动态生成的，这个类不需要写，直接写客户端程序即可。
Client
package com.hhb.proxy.client;
import com.hhb.proxy.service.OrderService;
import com.hhb.proxy.service.OrderServiceImpl;
import com.hhb.proxy.service.TimerInvocationHandler;
import com.hhb.proxy.util.ProxyUtil;
import java.lang.reflect.Proxy;
public class Client {
//客户端程序
public static void main(String[] args) {
//创建目标对象
OrderService target = new OrderServiceImpl();
//创建代理对象
/* OrderService proxyObj = (OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new TimerInvocationHandler(target));*/
//使用工具类
OrderService proxyObj = (OrderService) ProxyUtil.newProxyInstance(target);
//调用代理对象的代理方法
proxyObj.modify();
proxyObj.detail();
proxyObj.generate();
String name = proxyObj.getName();
System.out.println(name);
}
}-
创建代理对象
-
newProxyInstance翻译为：新建代理对象，也就是说，通过调用这个方法可以创建代理对象。本质上，这个Proxy.newProxyInstance()方法的执行做了两件事：
-
在内存中动态的生成了一个代理类的字节码class。
-
new对象了，通过内存中生成的代理类这个代码，实例化了代理对象。
-
-
关于newProxyInstance()方法的三个重要的参数：
-
第一个参数：ClassLoader loader
-
它是类加载器。在内存中生成的字节码也是class文件，要执行也得先加载到内存当中。加载类就需要类加载器，所以这里需要指定类加载器。并且JDK要求，目标类的类加载器必须和代理类的类加载器使用同一个。
-
-
第二个参数：Class<?>[] interfaces
-
代理类和目标类要实现同一个接口或同一些接口。
-
在内存中生成代理类的时候，这个代理类是需要你告诉它实现哪些接口的。
-
-
第三个参数：InvocationHandler h
-
InvocationHandler 被翻译为：调用处理器，是一个接口。
-
在调用处理器接口中编写的就是：增强代码。
-
既然是接口，就要写接口的实现类。
-
-
-
TimerInvocationHandler
package com.hhb.proxy.service;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class TimerInvocationHandler implements InvocationHandler {
//目标对象
private Object target;
public TimerInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//这个接口的作用是写增强代码
long begin = System.currentTimeMillis();
//调用目标对象上的目标方法
//方法四要素：哪个对象，哪个方法，传什么参数，返回什么值
Object retValue = method.invoke(target, args);
long end = System.currentTimeMillis();
System.out.println("耗时" + (end - begin) + "毫秒");
//注意：这个invoke方法的返回值，如果代理对象调用代理方法之后，需要返回结果的话，invoke方法必须将目标对象的目标方法执行结果继续返回
return retValue;
}
}-
为什么要强行要求你必须实现InvocationHandler接口？
-
因为一个类实现接口就必须实现接口中的方法。
-
方法必须是invoke()，因为JDK在底层调用invoke()方法的程序已经提前写好了。
-
注意：invoke方法不是程序员调用的，是JDK负责调用。
-
-
invoke方法什么时候被调用？
-
当代理对象调用代理方法的时候，注册在InvocationHandler调用处理器当中的invoke()方法被调用。
-
-
invoke方法的三个参数
-
invoke方法是JDK负责调用的，所以JDK调用这个方法的时候会自动给我们传过来这三个参数，可以在invoke方法的大括号中直接使用。
-
第一个参数：Object proxy 代理对象的引用，这个参数使用较少。
-
第二个参数：Method method 目标对象上的目标方法。
-
第三个参数：Object[] args 目标方法上的实参。
-
invoke方法执行过程中，使用method来调用目标对象的目标方法。
-
工具类：ProxyUtil
package com.hhb.proxy.util;
import com.hhb.proxy.service.TimerInvocationHandler;
import java.lang.reflect.Proxy;
public class ProxyUtil {
/**
* 封装一个工具方法，可以通过这个方法获取代理对象
*
* @param target
* @return
*/
public static Object newProxyInstance(Object target) {
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new TimerInvocationHandler(target));
}
}14.3.2CGLIB动态代理
-
CGLIB既可以代理接口，又可以代理类。底层采用继承的方式实现，所以被代理的目标类不能使用final修饰。
引入依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>UserService
package com.hhb.proxy.service;
//目标类
public class UserService {
//目标方法
public boolean login(String username, String password) {
System.out.println("系统正在验证身份");
if ("admin".equals(username) && "123".equals(password)) {
return true;
}
return false;
}
//目标方法
public void logout() {
System.out.println("系统正在退出");
}
}-
使用CGLIB在内存中为UserService类生成代理类，并创建对象：
Client
package com.hhb.proxy.client;
import com.hhb.proxy.service.TimerMethodInterceptor;
import com.hhb.proxy.service.UserService;
import net.sf.cglib.proxy.Enhancer;
public class Client {
public static void main(String[] args) {
//创建字节码增强器对象
//这个对象是CGLIB库当中的核心对象，就是依靠它来生成代理类
Enhancer enhancer = new Enhancer();
//告诉CGLIB父类是谁，告诉CGLIB目标类是谁
enhancer.setSuperclass(UserService.class);
//设置回调(等同于JDK动态代理当中的调用处理器。InvocationHandler)
//在CGLIB当中不是InvocatioHandler接口，是方法拦截器：MethodInterceptor
enhancer.setCallback(new TimerMethodInterceptor());
//创建代理对象
//1.在内存中生成UserService类的子类，其实就是代理类的字节码。
//2.创建代理对象
UserService userServiceProxy = (UserService) enhancer.create();
//调用代理对象的代理方法
boolean succes = userServiceProxy.login("admin", "123");
System.out.println(succes ? "登录成功" : "登录失败");
userServiceProxy.logout();
}
}编写MethodInterceptor接口实现类
package com.hhb.proxy.service;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class TimerMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//前面增强
long begin = System.currentTimeMillis();
//调用目标对象的目标方法
Object retValue = methodProxy.invokeSuper(target, objects);
//后面增强
long end = System.currentTimeMillis();
System.out.println("耗时" + (end - begin) + "毫秒");
return retValue;
}
}
扫一扫
333
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
