本篇内容介绍了“web中动态代理模式是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
代理模式的分类：代理模式分为静态代理和动态代理
以简单的事务处理为例
interface
public interface UserDao{
void save();
}
实现类
public class UserDaoImpl implements UserDao{
public void save(){//保存}
}
事务处理代理类
public class TransactionHandler implements UserDao{
private UserDaoImpl userDao;//目标代理对象
public TransactionHandler(UserDao userDao){
this.useDao = userDao;
}
public void save(){
//开启事务
userDao.save();
//结束事务
}
}静态代理很简单，但是有一个缺点，如果要对很多类、方法进行代理只能一个一个写多个代理类，无法做到代码重用的目的
以JDK动态代理实现为例
//事务处理代理类
public class TransactionHandler implements InvocationHandler{
private Object target;//目标代理对象
public TransactionHandler(Object target){
this.target= target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//开启事务
Object result = method.invoke(target,args);
//结束事务
return result
}
}
//调用方法
public class Main {
public static void main(String[] args) {
Object target = new UserDaoImpl();
TransactionHandler handler = new TransactionHandler(target);
UserDao userDao = (UserDao)Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler);
userDao.save();
}在这里有两个疑问，我们在后面慢慢解开它们的面纱
1.如何生成代理类？2.如何执行代理方法？
我们先看Proxy.newProxyInstance方法原码
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,
InvocationHandler h) throws IllegalArgumentException {
.....
Class<?> cl = getProxyClass0(loader, intfs);//获取或生成代理类
....
final Constructor<?> cons = cl.getConstructor(constructorParams);//得到参数类型是InvocationHandler.class构造函数
....
return cons.newInstance(new Object[]{h});//生成代理实例
....
}这个方法主要就做三件事
1.获取或生成代理类
2.得到参数类型是InvocationHandler.class构造函数
3.生成代理实例
我们现在来看看它是如何生成代理类的。看getProxyClass0源码
private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {
....
return proxyClassCache.get(loader, interfaces);//proxyClassCache->WeakCache
}
public V get(K key, P parameter) {
....
Object cacheKey = CacheKey.valueOf(key, refQueue);//将ClassLoader包装成CacheKey, 作为一级缓存的key
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);//获得classload缓存
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());//以CAS方式放入, 如果不存在则put，否则返回旧值
//问题：为什么要用二级缓存？为什么要map.putIfAbsent？
}
Supplier<V> supplier = valuesMap.get(subKey);
while (true) {
if (supplier != null) {
V value = supplier.get();//得到代理类
if (value != null) {
return value;//取到了直接返回
}
}
//如果为null，生成代理类工厂
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
supplier = factory;//如果没有旧值，将新值赋给引用对象，循环退出
}//如果替换失败，说明已经有值，重新循环
}else{//其它线程修改了值, 那么就将原先的值替换
if (valuesMap.replace(subKey, supplier, factory)) {
supplier = factory;
} else {
supplier = valuesMap.get(subKey);//替换失败, 继续使用原先的值
}
}
}
}这个方法主要就是看缓存里是否存在代理工厂类，如果存在直接调用get()返回，这里缓存用的是WeakCache，新生代回收时就会被回收，不会占用内存
如果缓存中没有就通过new Factory生成一个代理工厂。这里有一些线程安全方面的处理。
这里返回的是Supperlier.get(),现在看这个方法中做了些什么事情
private final class Factory implements Supplier<V> {
....
public synchronized V get() {
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {//在这里验证supplier是否是Factory实例本身,因为可能被其它线程修改了
return null;
}
V value = null;
try{
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
//交给ProxyClassFactory去生成代理类
}finally{
if (value == null) {//如果生成代理类失败, 就将这个二级缓存删除
valuesMap.remove(subKey, this);
}
}
....
return value;
}
}这个方法比较简单主要是交给valueFactory.apply生成返回，valueFactory是ProxyClassFactory类
我们再看看这个方法里在做什么
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
....
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;//生成代理类默认是public final
String proxyName = proxyPkg + proxyClassNamePrefix + num;//包名+前缀+序号
//用ProxyGenerator来生成字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,interfaces, accessFlags);
try{
//根据字节码生成代理类
return defineClass0(loader, proxyName, proxyClassFile,0, proxyClassFile.length);
} catch (ClassFormatError e) {....}
}主要是一些规范定义，然后根据ProxyGenerator.generateProxyClass生成字节码
再这个方法里做了些什么
public static byte[] generateProxyClass(String var0, Class<?>[] var1) {
return generateProxyClass(var0, var1, 49);
}
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();
....
return var4;
}
private byte[] generateClassFile() {
//首先为代理类生成toString, hashCode, equals等代理方法
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
//遍历每一个接口的每一个方法, 并且为其生成ProxyMethod对象
for (int i = 0; i < interfaces.length; i++) {
Method[] methods = interfaces[i].getMethods();
for (int j = 0; j < methods.length; j++) {
addProxyMethod(methods[j], interfaces[i]);
}
}
....//将类的属性写入bout流中
return bout.toByteArray();
}可以看出主要是分多步将被代理类的方法属性等写到字节流中
生成的代理类就如下
public class Proxy0 extends Proxy implements UserDao {
//第一步, 生成构造器
protected Proxy0(InvocationHandler h) {
super(h);
}
//第二步, 生成静态域
private static Method m1; //hashCode方法
private static Method m2; //equals方法
private static Method m3; //toString方法
private static Method m4; //...
//第三步, 生成代理方法
@Override
public int hashCode() {
try {
return (int) h.invoke(this, m1, null);
} catch (Throwable e) {
throw new UndeclaredThrowableException(e);
}
}
@Override
public boolean equals(Object obj) {
}
@Override
public String toString() {
}
@Override
public void save(User user) {
try {
//构造参数数组, 如果有多个参数往后面添加就行了
Object[] args = new Object[] {user};
h.invoke(this, m4, args);//代理类增强方法
} catch (Throwable e) {
throw new UndeclaredThrowableException(e);
}
}
//第四步, 生成静态初始化方法
static {
try {
Class c1 = Class.forName(Object.class.getName());
Class c2 = Class.forName(UserDao.class.getName());
m1 = c1.getMethod("hashCode", null);
m2 = c1.getMethod("equals", new Class[]{Object.class});
m3 = c1.getMethod("toString", null);
m4 = c2.getMethod("save", new Class[]{User.class});
//...
} catch (Exception e) {
e.printStackTrace();
}
}
}先看纯CGLIB是如何使用
//拦截类
public class Interceptor implements MethodInterceptor {
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
//invokeSuper调用原方法，invoke对原类实例生效，调用代理方法
//前置处理
Object retVal = proxy.invokeSuper(obj, args);
//后置处理
return retVal;
}
}
public static void main(String[] args) {
//实例化一个增强器，也就是cglib中的一个class generator
Enhancer eh = new Enhancer();
//设置目标类
eh.setSuperclass(Target.class);
// 设置拦截对象
eh.setCallback(new Interceptor());
// 生成代理类并返回一个实例
Target t = (Target) eh.create();
t.method();
}具体如何生成代理类的源码就不展开了，大体思路和JDK一致，最后生成代理类的方式有所不同。
先看生成的代理类
public class Target$$EnhancerByCGLIB$$788444a0 extends Target implements Factory
{
....//equal tostring就不写了，拿一个典型
final void CGLIB$g$0()//invokeSuper调用这个方法
{
super.g();
}
public final void g()//invoke调用这个方法
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
CGLIB$BIND_CALLBACKS(this);
tmp4_1 = this.CGLIB$CALLBACK_0;
}
if (this.CGLIB$CALLBACK_0 != null) {
tmp4_1.intercept(this, CGLIB$g$0$Method, CGLIB$emptyArgs, CGLIB$g$0$Proxy);
}
else{
super.g();
}
}
}可以看出和JDK不同的是JDK是implements 原接口，CGLIB是extends原类，而且会生成两个对应的方法，供不同的调用。
CGLIB与JDK动态代理的区别 1、CGLIB代理类不需要实现接口，但是也不能是final型 2、CGLIB回调方法不再通过method.invoke反射来处理，采用效率更高的FastClass机制 FastClass机制就是对一个类的方法建立索引，通过索引来直接调用相应的方法
例如：
//先通过获得方法索引
public int getIndex(String signature){
switch(signature.hashCode()){
case 3078479:
return 1;
case 3108270:
return 2;
}
return -1;
}
//然后通过索引得到方法
public Object invoke(int index, Object o, Object[] ol){
Test t = (Test) o;
switch(index){
case 1:
t.f();
return null;
case 2:
t.g();
return null;
}
return null;
}Spring Aop默认使用JDK动态代理，除非指定使用CGLIB动态代理，但对接口类只能使用JDK动态代理 具体代码在DefaultAopProxyFactory
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface()) {
return new JdkDynamicAopProxy(config);
}
if (!cglibAvailable) {
throw new AopConfigException(
"Cannot proxy target class because CGLIB2 is not available. " +
"Add CGLIB to the class path or specify proxy interfaces.");
}
return CglibProxyFactory.createCglibProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}以JdkDynamicAopProxy为例我们来看spring是如何对方法进行有选择性的增强的
1、生成代理类
@Override
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);//hanler传入的是自己
}可以看出增强的方法不是我们自己定义的逻辑，而是JdkDynamicAopProxy 那么JdkDynamicAopProxy 必然有一个invoke方法，再看这个方法怎么处理
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
.....
//获取拦截链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
//直接调原方法返回
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}else{
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
//执行拦截链
retVal = invocation.proceed();
}
....
}“web中动态代理模式是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
