设计模式代理模式 ( 动态代理 )
Posted 韩曙亮
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了设计模式代理模式 ( 动态代理 )相关的知识，希望对你有一定的参考价值。
文章目录
一、动态代理使用流程
动态的代理类使用流程 :
1. 内部持有 目标对象
2. 创建动态代理类 , 调用 Proxy.newProxyInstance 创建动态代理类
系统会自动创建一个类 , 该类实现了目标对象的所有接口的所有方法
最后返回一个该动态代理类的实例对象
3. 调用动态代理类实例对象的某个接口方法 , 会自动回调 动态代理类的 invoke 函数
注意 : 被代理的方法必须是 目标对象 的接口中的方法
二、动态代理代码示例
业务场景 : 保存订单信息 , 在 Service 层处理订单保存 , 在 Dao 层将订单存储到数据库 ; 使用动态代理类加强 Service 层的功能 ;
1、订单类
package proxy;
/**
* 订单类
* 存储订单时 , 通过 Service 层通接收 Order 对象进行处理
*/
public class Order {
/**
* 订单信息
*/
private Object orderInfo;
/**
* 用户 ID
*/
private Integer userId;
public Order(Object orderInfo, Integer userId) {
this.orderInfo = orderInfo;
this.userId = userId;
}
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
}
2、Service 接口
package proxy;
/**
* 服务接口
*/
public interface IOrderService {
/**
* 保存订单
* @param order 数据库生效行数
* @return
*/
int saveOrder(Order order);
}
3、Service 实现类
package proxy;
public class OrderServiceImpl implements IOrderService {
private IOrderDao iOrderDao;
public OrderServiceImpl(IOrderDao iOrderDao) {
this.iOrderDao = iOrderDao;
}
@Override
public int saveOrder(Order order) {
System.out.println("Service 层插入 Order 订单信息成功");
return this.iOrderDao.insert(order);
}
}
4、Service 静态代理类
package proxy;
/**
* 订单服务静态代理类
*/
public class OrderServiceStaticProxy {
private IOrderService iOrderService;
public OrderServiceStaticProxy(IOrderService iOrderService) {
this.iOrderService = iOrderService;
}
public int saveOrder(Order order){
beforeMethod();
int result = iOrderService.saveOrder(order);
afterMethod();
return result;
}
/**
* 在被代理对象方法之前执行的内容
*/
private void beforeMethod() {
System.out.println("静态代理 OrderServiceStaticProxy 执行 saveOrder 之前");
}
/**
* 在被代理对象方法之后执行的内容
*/
private void afterMethod() {
System.out.println("静态代理 OrderServiceStaticProxy 执行 saveOrder 之后");
}
}
5、Dao 接口
package proxy;
/**
* 数据库接口
*/
public interface IOrderDao {
/**
* 向数据库中插入订单信息
* @param order
* @return
*/
int insert(Order order);
}
6、Dao 实现类
package proxy;
public class OrderDaoImpl implements IOrderDao {
@Override
public int insert(Order order) {
System.out.println("Dao 层插入 Order 订单信息成功");
return 1;
}
}
7、Service 动态代理类
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 订单服务动态代理类
*
* 动态的代理类使用流程 :
* 1. 内部持有 目标对象
* 2. 创建动态代理类 , 调用 Proxy.newProxyInstance 创建动态代理类
* 系统会自动创建一个类 , 该类实现了目标对象的所有接口的所有方法
* 最后返回一个该动态代理类的实例对象
* 3. 调用动态代理类实例对象的某个接口方法 , 会自动回调 动态代理类的 invoke 函数
* 注意 : 被代理的方法必须是 目标对象 的接口中的方法
*/
public class OrderServiceDynamicProxy implements InvocationHandler {
private Object target;
public OrderServiceDynamicProxy(IOrderService iOrderService) {
this.target = iOrderService;
}
/**
* 绑定方法
* 将目标对象与动态代理类进行绑定
*/
public Object bind() {
// 拿到目标对象的类
Class clazz = target.getClass();
// 动态代理类时系统执行的时候自动生成的类 , 该类自动实现了指定的接口
// 动态代理类会获取目标对象的所有接口 , 并实现所有的接口中的所有的方法
// 该动态代理类 代理的是 target 的接口的方法 , 即 IOrderService 接口的方法
// 凡是调用创建的动态代理实例对象中的 IOrderService 接口方法 , 都会触发该类的 invoke 方法
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
/**
* 调用代理类的 IOrderService 接口方法 , 就会自动回调该方法
* 注意 : 所有的 IOrderService 接口方法 , 都会回调该方法
* 在回调时 , 需要判定一下 , 是哪个方法回调的 , 过滤掉不需要加强的方法
*
* @param proxy 该参数几乎用不到
* @param method 要被增强的方法对象
* @param args 要被增强的方法对象的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeMethod();
// 调用目标对象的 method 方法
Object object = method.invoke(target, args);
afterMethod();
return object;
}
/**
* 在被代理对象方法之前执行的内容
*/
private void beforeMethod() {
System.out.println("动态代理 OrderServiceStaticProxy 执行 saveOrder 之前");
}
/**
* 在被代理对象方法之后执行的内容
*/
private void afterMethod() {
System.out.println("动态代理 OrderServiceStaticProxy 执行 saveOrder 之后");
}
}
8、测试类
package proxy;
public class Main {
public static void main(String[] args) {
Order order = new Order("书籍订单", 1);
IOrderDao dao = new OrderDaoImpl();
IOrderService service = new OrderServiceImpl(dao);
// 不使用代理的情况
service.saveOrder(order);
System.out.println();
// 使用静态代理的情况
OrderServiceStaticProxy proxy = new OrderServiceStaticProxy(service);
proxy.saveOrder(order);
System.out.println();
// 使用动态代理的情况
IOrderService orderServiceDynamicProxy = (IOrderService) new OrderServiceDynamicProxy(service).bind();
orderServiceDynamicProxy.saveOrder(order);
}
}
执行结果 :
Service 层插入 Order 订单信息成功
Dao 层插入 Order 订单信息成功
静态代理 OrderServiceStaticProxy 执行 saveOrder 之前
Service 层插入 Order 订单信息成功
Dao 层插入 Order 订单信息成功
静态代理 OrderServiceStaticProxy 执行 saveOrder 之后
动态代理 OrderServiceStaticProxy 执行 saveOrder 之前
Service 层插入 Order 订单信息成功
Dao 层插入 Order 订单信息成功
动态代理 OrderServiceStaticProxy 执行 saveOrder 之后
三、动态代理源码分析
动态代理的核心步骤是 Proxy.newProxyInstance 调用 ;
传入 3 3 3 个参数分别是 : ① 目标对象类加载器 , ② 目标对象实现的接口 , ③ 动态代理类本身 ( InvocationHandler 实现类 ) ;
public class Proxy implements java.io.Serializable {
/**
* Returns an instance of a proxy class for the specified interfaces
* that dispatches method invocations to the specified invocation
* handler.
*
* <p>{@code Proxy.newProxyInstance} throws
* {@code IllegalArgumentException} for the same reasons that
* {@code Proxy.getProxyClass} does.
*
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class
* to implement
* @param h the invocation handler to dispatch method invocations to
* @return a proxy instance with the specified invocation handler of a
* proxy class that is defined by the specified class loader
* and that implements the specified interfaces
* @throws IllegalArgumentException if any of the restrictions on the
* parameters that may be passed to {@code getProxyClass}
* are violated
* @throws SecurityException if a security manager, <em>s</em>, is present
* and any of the following conditions is met:
* <ul>
* <li> the given {@code loader} is {@code null} and
* the caller's class loader is not {@code null} and the
* invocation of {@link SecurityManager#checkPermission
* s.checkPermission} with
* {@code RuntimePermission("getClassLoader")} permission
* denies access;</li>
* <li> for each proxy interface, {@code intf},
* the caller's class loader is not the same as or an
* ancestor of the class loader for {@code intf} and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to {@code intf};</li>
* <li> any of the given proxy interfaces is non-public and the
* caller class is not in the same {@linkplain Package runtime package}
* as the non-public interface and the invocation of
* {@link SecurityManager#checkPermission s.checkPermission} with
* {@code ReflectPermission("newProxyInPackage.{package name}")}
* permission denies access.</li>
* </ul>
* @throws NullPointerException if the {@code interfaces} array
* argument or any of its elements are {@code null}, or
* if the invocation handler, {@code h}, is
* {@code null}
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 进行空校验
Objects.requireNonNull(h);
// 对传入的接口进行安全检查
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
// 动态代理的思路是生成一个新类
/*
* 动态生成一个代理类
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 通过反射获取代理类的构造函数 , 并根据构造函数生成实例对象
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 返回动态代理类生成的实例对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
/**
* Generate a proxy class. Must call the checkProxyAccess method
* to perform permission checks before calling this.
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
// 判定接口数量 , 接口不能超过 65535 个
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
// 代理类生成的 Class 都缓存在此 , 如果缓存中有这个代理类 , 直接获取
// 如果缓存中 , 没有这个代理类 , 创建这个代理类
return proxyClassCache.get(loader, interfaces);
}
/**
* Look-up the value through the cache. This always evaluates the
* {@code subKeyFactory} function and optionally evaluates
* {@code valueFactory} function if there is no entry in the cache for given
* pair of (key, subKey) or the entry has already been cleared.
*
* @param key possibly null key
* @param parameter parameter used together with key to create sub-key and
* value (should not be null)
* @return the cached value (never null)
* @throws NullPointerException if {@code parameter} passed in or
* {@code sub-key} calculated by
* {@code subKeyFactory} or {@code value}
* calculated by {@code valueFactory} is null.
*/
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
// 如果找到对应的类 , 直接返回
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null) {
return value;
}
}
// 如果缓存中没有这个类 , 开始创建这个类
// else no supplier in cache
// or a supplier that returned null (could be a cleared CacheValue
// or a Factory that wasn't successful in installing the CacheValue)
// lazily construct a Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}
}
以上是关于设计模式代理模式 ( 动态代理 )的主要内容，如果未能解决你的问题，请参考以下文章