坦白讲,动态代理在日常工作中真没怎么用过,也少见别人用过,网上见过不少示例,但总觉与装饰模式差别不大,都是对功能的增强,什么前置后置,其实也就那么回事,至于面试中经常被问的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构造器传参数(包括对象), 然后调用这些参数,完成复杂的业务逻辑!

通过此篇文章,应该是可以将装饰与代理的使用场景区分开了!

mybatis框架之动态代理的更多相关文章

  1. JavaWeb_(Mybatis框架)Mapper动态代理开发_三

    系列博文: JavaWeb_(Mybatis框架)JDBC操作数据库和Mybatis框架操作数据库区别_一 传送门 JavaWeb_(Mybatis框架)使用Mybatis对表进行增.删.改.查操作_ ...

  2. mybatis框架中 动态代理的问题

    在配置文件时候 id唯一性 所以不允许重载 <select id=" querydemo"   resultType="pojo"> sql 语句  ...

  3. mybatis 05: mybatis中的动态代理

    mybatis中动态代理存在的意义 图示 图示分析 分层说明:界面层为第一层,业务逻辑层(接口层 + 实现层)为第二层,数据访问层(接口层 + 实现层)为第三层 业务逻辑层和数据访问层:分别分两层来开 ...

  4. JAVA框架 Mybaits 动态代理

    一.动态代理: mybaits给咱们提供一套动态代理,我们只需要按他的要求写接口即可,mybatis帮做动态代理,相当于咱们写的接口的实现类.底层通过反射实例化代理对象,通过代理对象调用相应的方法, ...

  5. java框架之MyBatis(1)-入门&动态代理开发

    前言 学MyBatis的原因 1.目前最主流的持久层框架为 Hibernate 与 MyBatis,而且国内公司目前使用 Mybatis 的要比 Hibernate 要多. 2.Hibernate 学 ...

  6. MyBatis笔记——Mapper动态代理

    前提概要 Mapper接口开发方法只需要程序员编写Mapper接口(相当于Dao接口),由Mybatis框架根据接口定义创建接口的动态代理对象,代理对象的方法体同上边Dao接口实现类方法. Mappe ...

  7. 【Mybatis】-- Mapper动态代理开发注意事项

    1.1. Mapper动态代理方式 1.1.1. 开发规范 Mapper接口开发方法只需要程序员编写Mapper接口(相当于Dao接口),由Mybatis框架根据接口定义创建接口的动态代理对象,代理对 ...

  8. Mybatis之Mapper动态代理

    一.什么是Mapper的动态代理 采用Mapper动态代理方法只需要编写相应的Mapper接口(相当于Dao接口),那么Mybatis框架根据接口定义创建接口的动态代理对象,代理对象的方法体同Dao接 ...

  9. MyBatis使用Mapper动态代理开发Dao层

    开发规范 Mapper接口开发方法只需要程序员编写Mapper接口(相当于Dao接口),由Mybatis框架根据接口定义创建接口的动态代理对象,代理对象的方法体同原始Dao接口实现类方法. Mappe ...

随机推荐

  1. face_recognition开源人脸识别库:离线识别率高达99.38%

    基于Python的开源人脸识别库:离线识别率高达99.38%——新开源的用了一下感受一下 原创 2017年07月28日 21:25:28 标签: 人脸识别 / 人脸自动定位 / 人脸识别开源库 / f ...

  2. Jira中的Tempo查看component以及issue的工作量汇总

    在右侧group by的地方,同时选中component和issue

  3. quick bi dashboard 控件样式控制。

    控件样式控制 1 想要的效果图 2 查询样式里面进行设置

  4. 第 4 章 前端基础之jquery

    一.jQuery是什么? 1. jQuery由美国人John Resig创建,至今已吸引了来自世界各地的众多 javascript高手加入其team. 2. jQuery是继prototype之后又一 ...

  5. 应用安全 - Web安全 - 文件包含攻防

    LFI - 无限制本地文件包含 通过目录遍历漏洞可以获取到系统中其他文件的内容 常见的敏感信息路径 Windows系统 c:\boot.ini // 查看系统版本 c:\windows\system3 ...

  6. C++ std::isnan等函数的使用

    C和C++11标准提供了类似于isnan.isfinite.isinf.isnormal.fpclassify分别用于判断是非数(NaN)值.有限制.无穷值.正常数值等. 今天在使用Modbus读取设 ...

  7. Spring切面编程之AOP

    AOP 是OOP 的延续,是Aspect Oriented Programming 的缩写,意思是面向切面编程.可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种 ...

  8. 通过Samba练习metasploit的使用

    文章学习利用metasploit通过Samba3.X获取metasploitable2的shell,从而去熟悉metasploit的使用. 环境: kali IP:192.168.137.133 me ...

  9. [Linux Test Project] [PATCH] Fix an bad variable name erro in runltp script

    [PATCH] Fix an bad variable name erro in runltp script (/opt/ltp/runltp) Hi All,   I got an error fo ...

  10. P2324 [SCOI2005]骑士精神(A*)

    P2324 [SCOI2005]骑士精神 A*与爆搜的不同就是它有一个估价函数$h(x)$ 这个估价函数一般设为从当前状态到终点状态的估计最短步数,这样可以有效剪枝 但估计值必须严格小于等于实际剩余步 ...