坦白讲，动态代理在日常工作中真没怎么用过，也少见别人用过，网上见过不少示例，但总觉与装饰模式差别不大，都是对功能的增强，什么前置后置，其实也就那么回事，至于面试中经常被问的mybatis框架mapper接口这一块，少不了的要扯到动态代理。说起来高深莫测，其实只是在忽略自己，或者也包括面试官吧。不过，在仔细阅读了mybatis这一块的源代码之后，对动态代理的理解稍有加强。
请看下面这个jdk动态代理示例
public interface UserService {
Object sayHello(String name);
}
public class UserServiceImpl implements UserService {
@Override
public Object sayHello(String name) {
System.out.println("sayHello方法被调用。。。");
return "hello " + name;
}
}
public class UserProxy implements InvocationHandler {
private Object target;
public UserProxy(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("前置增强。。。");
Object result = method.invoke(target, args);
System.out.println("后置增强。。。");
return result;
}
}
测试代码
public class ProxyTest {
public static void main(String[] args) {
UserServiceImpl userServiceImpl = new UserServiceImpl();
UserProxy userProxy = new UserProxy(userServiceImpl);
UserService userService = (UserService) Proxy.newProxyInstance(userServiceImpl.getClass().getClassLoader(),
userServiceImpl.getClass().getInterfaces(), userProxy);
Object result = userService.sayHello("admin");
System.out.println("结果：" + result);
}
}
运行结果打印如下：
前置增强。。。
sayHello方法被调用。。。
后置增强。。。
结果：hello admin
类似于这样的示例，网上大把，单单就功能而言，此示例与装饰模式完全一样子，无非就是动态代理使用了invoke()方法，若是装饰模式，应该还会是sayHello()方法而已，
这有个鬼的区别。但是，我们再来看看mybatis框架中，是如何运用动态代理的，看了或许就会有不一样的感受了。。。
mybatis框架中Mapper接口动态代理相关的源码主要有下面两个类
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap; import org.apache.ibatis.session.SqlSession; /**
* @author Lasse Voss
*/
public class MapperProxyFactory<T> { private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<>(); public MapperProxyFactory(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
} public Class<T> getMapperInterface() {
return mapperInterface;
} public Map<Method, MapperMethod> getMethodCache() {
return methodCache;
} @SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
} public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
} }
import java.io.Serializable;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Map; import org.apache.ibatis.reflection.ExceptionUtil;
import org.apache.ibatis.session.SqlSession; /**
* @author Clinton Begin
* @author Eduardo Macarron
*/
public class MapperProxy<T> implements InvocationHandler, Serializable { private static final long serialVersionUID = -6424540398559729838L;
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache; public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (method.isDefault()) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
} private MapperMethod cachedMapperMethod(Method method) {
return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
} private Object invokeDefaultMethod(Object proxy, Method method, Object[] args)
throws Throwable {
final Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class
.getDeclaredConstructor(Class.class, int.class);
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
final Class<?> declaringClass = method.getDeclaringClass();
return constructor
.newInstance(declaringClass,
MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
| MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC)
.unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
}
}
mybatis框架的尿性，创建对象基本都是用工厂，MapperProxyFactory类就是创建MapperProxy的工厂类，而这个MapperProxy就是代替Mapper接口干活的，或许就是因为
这个原因，所以才叫代理模式吧！
Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
接着说下我对上面这个方法的理解,:
该方法就是创建一个代理对象，方法中的有三个参数。
第1个参数： ClassLoader ， 类加载器，对于理解代理模式而言，我觉得不重要。
第2个参数：interfaces， 接口类，我的理解就是，它是一个大老板，吩咐狗腿子干活，自个基本不干活。
第3个参数：InvocationHandler ，大老板的狗腿子，代替大老板的人，至于具体如何干活，就得看它的invoke()方法了。
而在mybatis框架中，Mapper接口就是大老板，狗腿子就是MapperProxy， 具体怎么干活就是下面这段代码
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (method.isDefault()) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
return mapperMethod.execute(sqlSession, args);
}
看了这点代码，瞬间觉得与最前那个动态代理的例子大不相同，什么前置，后置，这里都没有使用到，或许动态代理的目的，根本就不是为了所谓的前置后置设计的吧（或许只是顺带的吧）。通过前面篇章的源码分析知道，操作数据库时，不会走if(){}else if(){}中的逻辑，直接走后面的逻辑，后面这段逻辑其实就是对Executor对象操作数据库的封装，这里就不会说了。
为什么不进入if逻辑？
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
}
通过最前面的示例知道 ， invoke会调用method方法的真实现实，于Mapper接口而言，它根本没有实现，所以肯定不会走这段逻辑。 至于else if（） ，完全没懂！
总结：
每次想到动态代理，我就想到装饰， 在工作中该如何取舍呢 ？ 通过mybatis框架的启发，我觉得，如果接口有实现 ，使用装饰模式对原有功能进行增强便可，
而如果单单只是一个接口，并没有提供实现，这时为了完成接口的功能（接口就是个废人，啥事都干不成），就可以选择动态代理了，毕竟在使用动态代理时，真正干事的
是InvocationHandler#invoke, jdk提供的Proxy类就是将接口与真正干事InvocationHandler绑定关系。
上图县长相当于动态代理中的接口调用者; 大老板就是接口本身； 狗腿子就是InvocationHandler; 狗链子就是Proxy.
最后再用一下示例加深一下理解：
/**
* 大老板
*/
public interface IUserService {
Object sayHello(String name);
}
/**
* 狗腿子
*/
public class UserProxy implements InvocationHandler {
// 这里可以通过构造器传参，然后在invoke方法中执行业务逻辑 @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是狗腿子。。。。。");
return "hello" + args[0];
} }/**
* 县长
*/
public class UserProxyTest {
public static void main(String[] args) {
IUserService userService = (IUserService) Proxy.newProxyInstance(IUserService.class.getClassLoader(),
new Class[]{IUserService.class}, new UserProxy());
Object result = userService.sayHello("狗腿子");
System.out.println(result);
}
}
打印结果如下：
over! IUserService接口没有实现类，sayHello的具体实现是在UserProxy#invoke()方法中完成，当然，这只是个简单示例，在真正的业务代码中，完全可以通过UserProxy构造器传参数（包括对象）， 然后调用这些参数，完成复杂的业务逻辑！
通过此篇文章，应该是可以将装饰与代理的使用场景区分开了！