H5W3
当前位置:H5W3 > java > 正文

【Java】【代理模式】总结,你值得拥有!

源码已收录github 查看源码,别忘了star哦!

什么是代理模式

代理模式,一个类代表另外一个类的功能。

在生活中并不缺乏代理模式的例子,比如火车票代售点,代理火车站销售火车票,代售点本身是没有火车班次的,而是代理了火车站的功能;房产中介代理房主销售房屋,中介本身没有房屋,而是代理房主的房屋进行销售。

那么问题来了,同样的功能,为什么需要代理呢?买房需要花费很多时间和精力,可能你不愿意这样,那么你可以用代理;买房可能需要复杂的程序,可能你并不熟悉,那么你需要代理来帮你处理。卖出房屋可能需要一定的宣传,你可能也不会,那么你更需要代理。那么可以看到,代理除了不具备被代理本身的功能之外,它可以在这个功能的基础上做很多事情,那这也就是代理模式的作用:隔离调用者与被调用者,功能增强

静态代理

静态代理是指类的创建编译过程在程序运行之前已经确定。即通过手动编码的方式来进行代理,案例类图结构如下。
【Java】【代理模式】总结,你值得拥有!
在案例中,SellHouse为接口,定义销售房屋方法,而HouseMaster则为销售房屋的房主,SellProxy为销售代理,由销售代理对房主的销售进行代理并增强。
具体代码如下:

SellHouse代码

package demo.pattren.proxy.statics;
public interface SellHouse {
void sell();
}

实现类HouseMaster

package demo.pattren.proxy.statics;
//房屋主人
public class HouseMaster implements SellHouse {
@Override
public void sell() {
System.out.println("我是房屋的主人,我买掉房子");
}
}

代理类SellProxy

package demo.pattren.proxy.statics;
//销售代理
public class SellProxy implements SellHouse{
//通过注入被代理对象实现代理功能
private SellHouse sellHouse;
public SellProxy(SellHouse sellHouse){
this.sellHouse = sellHouse;
}
@Override
public void sell() {
before();
//买掉房子
sellHouse.sell();
after();
}
//前置增强
private void before(){
System.out.println("新代理房屋销售");
System.out.println("我先来做一下宣传");
System.out.println("根据实际情况合房主沟通调整一下售价");
}
//后置增强
private void after(){
System.out.println("房子卖掉了,我提取佣金");
}
}

测试类

package demo.pattren.proxy.statics;
public class Test {
public static void main(String[] args) {
SellHouse house = new SellProxy(new HouseMaster());
house.sell();
}
}

动态代理

静态代理的实现是通过程序员编码代码来完成,虽然静态代理使代码有了一定的解耦,但是非常不灵活,如果做代理,那么每个接口都需要编写代理类,造成代码冗余,下面我们来看代理模式的另外一种实现——动态代理。接口类和实现类房主保持不变,而使用另外一种代理。
动态代理类SellDynamicProxy

package demo.pattren.proxy.dynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//动态代理
public class SellDynamicProxy implements InvocationHandler {
private Object object;
public SellDynamicProxy(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
//买掉房子
Object result = method.invoke(object, args);
after();
return result;
}
//前置增强
private void before(){
System.out.println("新代理房屋销售");
System.out.println("我先来做一下宣传");
System.out.println("根据实际情况合房主沟通调整一下售价");
}
//后置增强
private void after(){
System.out.println("房子卖掉了,我提取佣金");
}
}

动态代理测试类


package demo.pattren.proxy.dynamic;
import demo.pattren.proxy.statics.HouseMaster;
import demo.pattren.proxy.statics.SellHouse;
import java.io.IOException;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) throws IOException {
SellHouse sellHouse = new HouseMaster();
SellHouse proxy  = (SellHouse)Proxy.newProxyInstance(
SellHouse.class.getClassLoader(),
new Class[]{SellHouse.class},
new SellDynamicProxy(sellHouse));
proxy.sell();
}
}

类图结构如下。
【Java】【代理模式】总结,你值得拥有!
从代码看到,静态代理和动态代理的代理类和调用有明显的区别,首先,静态代理的代理类需要实现和业务类相同的接口,然后通过注入的形式调用业务类的功能,而动态代理则不同,动态代理则是实现InvocationHandler类,重写invoke方法来实现代理;而调用也有所不同,调用使用JDK提供的ProxynewProxyInstance方法来创建对象。

动态代理底层原理

动态代理创建的是SellHouse的一个子类,通过Debug来看一下创建的到底是什么对象。
【Java】【代理模式】总结,你值得拥有!
发现生成了一个类[email protected],那么JDK是如何去创建这样一个并不存在的Java类呢?我们通过代码入口Proxy.newProxyInstance来一探究竟。

Proxy.newProxyInstance

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//关键代码
Class<?> cl = getProxyClass0(loader, intfs);
}

Proxy.getProxyClass0

private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//接口数量不能大于65535
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//从缓存获取
return proxyClassCache.get(loader, interfaces);
}

WeakCache.get

public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
Object cacheKey = CacheKey.valueOf(key, refQueue);
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;
}
}
//新建并放入缓存
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
}

下面是创建类的关键代码

Proxy.ProxyClassFactory.apply

private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
//所有生成类名的前缀
private static final String proxyClassNamePrefix = "$Proxy";
//用于类名的编号
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null;     // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
//如果package为空,则使用proxy包
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成字节码数组
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//通过类加载器生成代理类
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}

现在,代理类创建完成,接下来就是通过类创建对象了。
Proxy.newProxyInstance方法接收三个参数,第一个是类加载器,第二个是代理的接口,第三个是一个
InvocationHandler,这个参数是干什么的的? 我们再回到SellDynamicProxy类, 其实现了InvocationHandler接口,而传入的对象正是SellDynamicProxy类型。而InvocationHandler与生成的代理类也是有关系的,通过源码来一探究竟。
Proxy.newProxyInstance

 @CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//创建class代理类对象
Class<?> cl = getProxyClass0(loader, intfs);
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;
}
});
}
//通过反射创建对象,并且InvocationHandler是构造函数的一个参数
return cons.newInstance(new Object[]{h});
//...more code
}

现在整个结构基本清楚了,首先通过Java反射与Proxy代理动态的在内存中创建class对象,并通过反射创建对象。而创建对象使用了InvocationHandler作为参数,由此可以证明动态生成的代理类有一个InvocationHandler的有参构造器。
下面通过文件流的方式,讲class字节码写入硬盘。

//生成class字节码,在源码中能够看到也有使用这个方法
byte[] $Proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{SellHouse.class});
//将字节码写入硬盘
FileOutputStream fileOutputStream = new FileOutputStream("D://$Proxy0.class");
fileOutputStream.write($Proxy0s);
fileOutputStream.close();

然后通过反编译(如果是IDEA,直接将文件拖动到IDEA即可查看),查看生成的源码。
如果上面的代码看得比较晃眼,那么也不用去看。但是一定要清楚这样一个方法做了什么事情。

import demo.pattren.proxy.statics.SellHouse;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements SellHouse {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws  {
//调用Proxy的方法,为Proxy的h属性赋值
super(var1);
}
//省略代码
public final boolean equals(Object var1) {}
//省略代码
public final String toString(){}
//重写sell方法
public final void sell() throws  {
try {
//调用SellDynamicProxy的sell方法,m3就是SellHouse定义的sell方法,在静态代码块中查看
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//省略代码
public final int hashCode(){}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("demo.pattren.proxy.statics.SellHouse").getMethod("sell");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}

看了这么多代码已然晕车,没关系,来画个图。
【Java】【代理模式】总结,你值得拥有!

CgLib动态代理

JDK的动态代理技术使用还是很方便的,但是也有一定的限制,那就是被代理的类需要有一个接口,当被代理类没有接口的情况下,可以选择另外一种动态代理方式——Cglib。

CgLib动态代理底层使用基于ASM的字节码技术,Cglib的代理结构非常简单,即应用Java集成机制实现代理效果。

【Java】【代理模式】总结,你值得拥有!

目标类使用上一个案例的HouseMaster,下面编写拦截器类CgLibInteceptor

package demo.pattren.proxy.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CgLibInteceptor implements MethodInterceptor {
//被代理的目标对象
private Object target;
public Object getInstance(final Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.target.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
//买掉房子
Object result = method.invoke(target, objects);
after();
return result;
}
//前置增强
private void before() {
System.out.println("新代理房屋销售");
System.out.println("我先来做一下宣传");
System.out.println("根据实际情况合房主沟通调整一下售价");
}
//后置增强
private void after() {
System.out.println("房子卖掉了,我提取佣金");
}
}

然后编写测试类:

package demo.pattren.proxy.cglib;
import demo.pattren.proxy.statics.HouseMaster;
import org.springframework.cglib.core.DebuggingClassWriter;
import java.io.IOException;
public class CgLibTest {
static{
//将cglib生产的class写入本地,然后再使用idea反编译查看,写入static即保证在运行期执行
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\ideaWorkspace\\demo2\\src\\main\\java\\demo\\pattren\\proxy\\cglib");
}
public static void main(String[] args) throws IOException {
HouseMaster sellHouse = new HouseMaster();
CgLibInteceptor cgLibProxy = new CgLibInteceptor();
HouseMaster h = (HouseMaster)cgLibProxy.getInstance(sellHouse);
h.sell();
}
}

与预期一致,通过Inteceptor类成功实现了sell()方法的前后增强功能。但是前面也提到了Cglib是通过集成来实现代理的,在测试类中,我们加入了一段static静态代码块,目的是将Cglib在运行过程中生成的代理类写入硬盘。
通过Idea的反编译,我们来查看代理类的代码,由于代码过多,仅截取关键部分。
【Java】【代理模式】总结,你值得拥有!
通过反编译的代码发现,生成的代理类确实是目标类的实现。
【Java】【代理模式】总结,你值得拥有!

另外,使用继承的方式有一个弊端,那就是对于定义了final属性的方法是无法实现代理的。

常用框架的动态代理

  1. SpringAop

Spring的面向切面编程极大的简化了我们的日常开发工作,而Spring的Aop则是应用了动态代理技术,并且支持JDK动态代理和Cglib代理两种方式,这个问题也经常出现于面试题中。

问:请解释Spring动态代理?
答:Spring动态代理有两种方式,当目标类是接口时,默认使用JDK动态代理,而没有接口的情况下使用Cglib代理。
问:他们的区别?
答:JDK动态代理使用Proxy与InvocationHandler实现,其使用反射机制生成被代理的实现类,要求目标类有实现接口。Cglib使用ASM字节码技术生成被代理类的子类,是继承关系。在JDK低版本时,JDK动态代理的生成效率较高,而运行效率较低,而Cglib的生成效率低但是运行效率高,但随着JDK的优化,在1.8时运行差距已经非常小。 参考 : https://blog.csdn.net/xlgen15…

  1. MyBatis动态代理

相信大家对Mybatis的Mapper接口 + XML的开发模式已经非常熟悉,在开发的时候,我们只需要编写Mapper接口与XML就可以实现DAO操作。 通过本篇文章的学习,相信你已经知道MyBatis的套路,其实就是使用JDK动态代理生成了Mapper接口的实现类,从而根据XML的定义完成DAO操作。

本文地址:H5W3 » 【Java】【代理模式】总结,你值得拥有!

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址