tags: [小小商城, SSM]
categories: [技术实战]

提要

　　本文是 小小商城-SSM版的 细节详解系列 之一，项目 github：https://github.com/xenv/S-mall-ssm 本文代码大部分在 github 中 可以找到。

　　中小型项目使用 Mybatis 如何减少 mapper 的工作量？市面上已经有一款产品 ，叫”通用mapper”，但是我使用之后有点失望。一个是它侵入型极强，要改掉 mybatis 的 factory，数据库的名字和列名都要改成指定格式，错一个也不行。另外，还不支持关联查询，可谓是有点鸡肋了。于是，就有了我这么一个通用 mapper 的实现，可以让 Mybatis 像 Hibernate 一样使用。只要配置好自定义注解，用 mybatis-generator 生成好代码，就可以自动处理 各种关联查询（一对多、多对一自动插入），还提供接口修改遍历填充关联查询的深度，支持手写的扩展mappper接入到填充系统。

　　那么，这套系统到底是如何工作的呢？我做了一个示意图来说明 Category 表 下面的情况，其他表同理。 （mybatis-generator 隔离手写代码和机器代码请参考我写的文章：SSM开发 | 合理配置 mybatis-generator，隔离机器生成代码和额外增加代码）

SSM开发 - 实现 Mybatis 的通用 Mapper - 图1

　　当服务层调用的时候，通用 mapper 会先查询 服务器层指定的 CategoryMapper，从数据库拿到数据。然后通用 mapper 调用 MapperCore 对 拿到的Category进行一对多和多对一对象的填充。最后填充完的 category 对象将会返回给服务层。

　　一对多和多对一如何配置呢？这需要我们在 extension 类中 用自定义注解配置，然后机器生成的 Category 类 将继承 我们的 extension，因此 我们 最终拿到的 category 就是 有关联对象变量的 对象了。

　　那么，我们如何知道 一对多 多对一 的对象应该由哪个 mapper 来填充呢，那么我们就需要在 category 类上指定好 对应的 mapper （使用泛型继承）即可，怎么让它自动指定呢？对了，就是用 mybatis-generator 自定义插件。

　　在看具体实现之前，我假定您已经对 mybatis-generator 、自定义注解、反射有一定的了解。

具体实现

1.创建 实体 extension 配置一对多、多对一信息

　　创建extension参见：：SSM开发 | 合理配置 mybatis-generator，隔离机器生成代码和额外增加代码

　　配置一对多、多对一信息使用自定义 注解，注解的定义在这里 ORMAnnotation 语法和 hibernate 差不多，临时变量不需要再使用注解，enum用了 (var=””)，取消了 OneToOne，因为本质上和 ManyToOne 是一样的，OneToOne还容易弄混。

　　配置好注解之后，效果是这样的： extension

2.定义 mybatis-generator 插件，让自动生成的 mapper 和 实体类 带上 泛型 信息，以供通用 mapper 读取

　　 自定义 mybatis-generator 插件 参见我的文章：SSM开发 | 开发自定义插件，使 mybatis-generator 支持软删除

　　插件代码见：MapperExtendsPlugin.java POJOExtendsPlugin.java

　　之后用 mybatis-generator 生成出来的代码，就会是这样的

  1. undefined
  2. public interface CategoryMapper extends BaseMapper<Category, CategoryExample> {
  3. }
  1. public class Category extends CategoryExtension implements POJOMapper<CategoryMapper> {
  2. }

　　这样，我们在填充时，读取这个类的时候，就可以通过反射，拿到 <> 中的内容，比如现在知道了一个 product 对象，里面要我们填充一个 Categorty 类，那么我们先来查 Category 类，知道对应的 Mapper 是 CategoryMapper，对应的 Example 是 CategoryEmaple，那么，我们就可以愉快的调用 CategoryMapper 拿到一个 category ，然后插回 product 即可。

3.开发通用 mapper ：静态代理+递归填充

　　我们先通过拿到 mybatis 自带的 sqlSessionTemplate ，需要在 applicationContext.xml 中 注册一下

  1.     <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
  2.         <constructor-arg index="0" ref="sqlSession"/>
  3.     </bean>

　　然后我们开发一个 MapperFactory 工厂类，用来在Service层获取我们的通用 mapper，并且从 SqlSessionTemplate 拿到 CateogoryMapper，塞进通用 mapper 里面，最后返回通用 mapper MapperFactory.java

  1. @Component
  2. public class MapperFactory {
  3.     @Resource
  4.     private SqlSessionTemplate sqlSessionTemplate;
  5. public Mapper getMapper(Class mapperInterface) throws Exception {
  6.         Mapper mapper = new Mapper();
  7.         mapper.setSqlSessionTemplate(sqlSessionTemplate);
  8.         mapper.setMybatisMapper(mapperInterface);
  9.         return mapper;
  10.     }
  11. }

　　通用 mapper 里面其实比较简单，就是直接使用反射做通用具体mapper的静态代理，并且调用 mapperCore 中 的递归填充器 Mapper.java

  1. public class Mapper extends Mapper4ORM {
  3.     private int defaultTraversalDepth = 2;
  5.     public Object selectByPrimaryKey(Integer id) throws Exception {
  6.         return selectByPrimaryKey(id, defaultTraversalDepth);
  7.     }
  9.     public Object selectByPrimaryKey(Integer id, Integer depth) throws Exception {
  10.         Object object = mapper.getClass().getMethod("selectByPrimaryKey", Integer.class).invoke(mapper, id);
  11.         fillOnReading(object, depth);
  12.         return object;
  13.     }
  15.     public int insert(Object object) throws Exception {
  16.         fillOnWriting(object);
  17.         return (int) mapper.getClass().getMethod("insert", object.getClass()).invoke(mapper, object);
  18.     }
  20.     public int insertSelective(Object object) throws Exception {
  21.         fillOnWriting(object);
  22.         return (int) mapper.getClass().getMethod("insertSelective", Object.class).invoke(mapper, object);
  23.     }
  25.     public int updateByPrimaryKeySelective(Object object) throws Exception {
  26.         fillOnWriting(object);
  27.         return (int) mapper.getClass().
  28.                 getMethod("updateByPrimaryKeySelective", object.getClass()).invoke(mapper, object);
  29.     }
  31.     public int updateByPrimaryKey(Object object) throws Exception {
  32.         fillOnWriting(object);
  33.         return (int) mapper.getClass().getMethod("updateByPrimaryKey", object.getClass()).invoke(mapper, object);
  34.     }
  36.     public List selectByExample(Object example) throws Exception {
  37.         return selectByExample(example, defaultTraversalDepth);
  38.     }
  40.     public List selectByExample(Object example, int depth) throws Exception {
  41.         List result = (List) mapper.getClass().getMethod("selectByExample", example.getClass()).invoke(mapper, example);
  42.         for (int i = 0; i < result.size(); i++) {
  43.             Object item = result.get(i);
  44.             fillOnReading(item, depth);
  45.             result.set(i, item);
  46.         }
  47.         return result;
  48.     }
  49. }

最后，我们开发我们核心类，就是开发递归填充器，对一对多、多对一进行读取、处理、回填 Mapper4ORM.java

  1. /**
  2.  *  通用 Mapper | 核心，处理一对多，多对一的插入
  3.  */
  5. @SuppressWarnings("unchecked")
  6. public class Mapper4ORM {
  7.     Object mapper;
  9.     private Class mapperInterface;
  11.     private SqlSessionTemplate sqlSessionTemplate;
  13.     void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
  14.         this.sqlSessionTemplate = sqlSessionTemplate;
  15.     }
  17.     void setMybatisMapper(Class mapperInterface) throws Exception {
  18.         this.mapperInterface = mapperInterface;
  19.         mapper = getMapper(mapperInterface);
  20.     }
  22.     public Object getMapper(Class mapperInterface) throws Exception {
  23.         return sqlSessionTemplate.getMapper(mapperInterface);
  24.     }
  26.     public BaseExample getExample(Class mapperInterface) throws Exception {
  27.         ParameterizedType t = (ParameterizedType) mapperInterface.getGenericInterfaces()[0];
  28.         Class exampleClass = (Class) t.getActualTypeArguments()[1];
  29.         return (BaseExample) exampleClass.newInstance();
  30.     }
  32.     public Class getMapperInterfaceByPOJO(Class POJOClass) throws Exception {
  33.         ParameterizedType t = (ParameterizedType) POJOClass.getGenericInterfaces()[0];
  34.         return (Class) t.getActualTypeArguments()[0];
  35.     }
  37.     /**
  38.      * 获取一个类里的，有指定annotation的，所有 Filed
  39.      *
  40.      * @param objectClass     一个类
  41.      * @param annotationClass 指定的 annotation
  42.      * @return 所有的 Filed
  43.      */
  44.     List<Field> getFieldsEquals(Class objectClass, Class annotationClass) {
  45.         if (objectClass == null) {
  46.             return null;
  47.         }
  48.         List<Field> fields = new ArrayList<>();
  49.         for (Class temp = objectClass; temp != Object.class; temp = temp.getSuperclass()) {
  50.             fields.addAll(Arrays.asList(temp.getDeclaredFields()));
  51.         }
  52.         List<Field> result = new ArrayList<>();
  53.         for (Field field : fields) {
  54.             if (field.getAnnotation(annotationClass) != null)
  55.                 result.add(field);
  56.         }
  57.         return result;
  58.     }
  60.     /**
  61.      * 读取时，处理所有 多对一 的填充
  62.      *
  63.      * @param object 被填充的对象
  64.      * @param depth  当前深度
  65.      * @throws Exception 反射异常
  66.      */
  67.     public void fillManyToOneOnReading(Object object, int depth) throws Exception {
  68.         if (object == null) {
  69.             return;
  70.         }
  71.         Class clazz = object.getClass();
  72.         // 获取所有 ManyToOne注解的Filed
  73.         List<Field> result = getFieldsEquals(clazz, ManyToOne.class);
  74.         for (Field field : result) {
  75.             //获取外键的表名
  76.             String joinColumn = field.getAnnotation(JoinColumn.class).name();
  78.             //获取要填充对象的mapper
  79.             Class targetMapperClass = getMapperInterfaceByPOJO(field.getType());
  80.             Object targetMapper = getMapper(targetMapperClass);
  81.             //获取外键值
  82.             Integer joinColumnValue = (Integer) clazz.
  83.                     getMethod("get" + StringUtils.capitalize(joinColumn)).invoke(object);
  84.             if (joinColumnValue == null) {
  85.                 continue;
  86.             }
  87.             //配置查询器example
  88.             BaseExample example = getExample(targetMapperClass);
  89.             Object criteria = example.createCriteria();
  90.             // 配置criteria
  91.             criteria.getClass().getMethod("andIdEqualTo", Integer.class).invoke(criteria, joinColumnValue);
  92.             //查询,获取结果列表
  93.             List targetResults = (List) targetMapper.getClass().getMethod("selectByExample", example.getClass()).
  94.                     invoke(targetMapper, example);
  96.             //判断是否为空 ，不为空插入 filed
  97.             if (targetResults.size() > 0) {
  98.                 Object targetResult = targetResults.get(0);
  99.                 fillOnReading(targetResult, depth - 1);
  100.                 clazz.getMethod("set" + StringUtils.capitalize(field.getName()), targetResult.getClass())
  101.                         .invoke(object, targetResult);
  102.             }
  103.         }
  104.     }
  106.     /**
  107.      * 读取时，处理所有 一对多 的填充
  108.      *
  109.      * @param object 被填充的对象
  110.      * @param depth  当前深度
  111.      * @throws Exception 反射异常
  112.      */
  113.     public void fillOneToManyOnReading(Object object, int depth) throws Exception {
  114.         if (object == null) {
  115.             return;
  116.         }
  117.         Class clazz = object.getClass();
  118.         // 获取所有 ManyToOne注解的Filed
  119.         List<Field> result = getFieldsEquals(clazz, OneToMany.class);
  120.         for (Field field : result) {
  121.             //获取外键的表名
  122.             String joinColumn = field.getAnnotation(JoinColumn.class).name();
  123.             //得到其Generic的类型
  124.             Type genericType = field.getGenericType();
  125.             ParameterizedType pt = (ParameterizedType) genericType;
  126.             //得到List泛型里的目标类型对象
  127.             Class targetClass = (Class) pt.getActualTypeArguments()[0];
  128.             //获取要填充对象的mapper
  129.             Class targetMapperClass = getMapperInterfaceByPOJO(targetClass);
  130.             Object targetMapper = getMapper(targetMapperClass);
  131.             //获取外键值
  132.             Integer joinColumnValue = (Integer) clazz.
  133.                     getMethod("getId").invoke(object);
  134.             //配置查询器example
  135.             BaseExample example = getExample(targetMapperClass);
  136.             Object criteria = example.createCriteria();
  137.             // 配置criteria
  138.             criteria.getClass().getMethod("and" + StringUtils.capitalize(joinColumn) + "EqualTo", Integer.class).invoke(criteria, joinColumnValue);
  139.             //查询,获取结果列表
  140.             List targetResults = (List) targetMapper.getClass().getMethod("selectByExample", example.getClass()).
  141.                     invoke(targetMapper, example);
  142.             for (int i = 0; i < targetResults.size(); i++) {
  143.                 Object item = targetResults.get(i);
  144.                 fillOnReading(item, depth - 1);
  145.                 targetResults.set(i, item);
  146.             }
  147.             //插入 filed
  148.             clazz.getMethod("set" + StringUtils.capitalize(field.getName()), List.class)
  149.                     .invoke(object, targetResults);
  151.         }
  152.     }
  154.     /**
  155.      * 读取时，处理所有 Enum 的填充
  156.      *
  157.      * @param object 被填充的对象
  158.      * @throws Exception 反射异常
  159.      */
  160.     public void fillEnumOnReading(Object object) throws Exception {
  161.         if (object == null) {
  162.             return;
  163.         }
  164.         Class clazz = object.getClass();
  165.         // 获取所有 ManyToOne注解的Filed
  166.         List<Field> result = getFieldsEquals(clazz, Enumerated.class);
  167.         for (Field field : result) {
  168.             //获取Enum对应的，String类型的变量名
  169.             String varName = field.getAnnotation(Enumerated.class).var();
  171.             //获取值
  172.             String enumString = (String) clazz.
  173.                     getMethod("get" + StringUtils.capitalize(varName)).invoke(object);
  175.             // 转成Enum，插回 filed
  176.             Enum resultObj = Enum.valueOf((Class<Enum>) field.getType(), enumString);
  177.             clazz.getMethod("set" + StringUtils.capitalize(field.getName()), resultObj.getClass())
  178.                     .invoke(object, resultObj);
  180.         }
  181.     }
  183.     /**
  184.      * 写入时，处理所有 Enum 的填充
  185.      *
  186.      * @param object 被填充的对象
  187.      * @throws Exception 反射异常
  188.      */
  189.     public void fillEnumOnWriting(Object object) throws Exception {
  190.         if (object == null) {
  191.             return;
  192.         }
  193.         Class clazz = object.getClass();
  194.         // 获取所有 ManyToOne注解的Filed
  195.         List<Field> result = getFieldsEquals(clazz, Enumerated.class);
  196.         for (Field field : result) {
  197.             //获取Enum对应的，String类型的变量名
  198.             String varName = field.getAnnotation(Enumerated.class).var();
  200.             //获取 Enum
  201.             Enum enumObj = (Enum) clazz.
  202.                     getMethod("get" + StringUtils.capitalize(field.getName())).invoke(object);
  204.             // 转成 String，插回 varName
  205.             String enumString = enumObj.name();
  206.             clazz.getMethod("set" + StringUtils.capitalize(varName), String.class)
  207.                     .invoke(object, enumString);
  208.         }
  209.     }
  211.     /**
  212.      * 写入时，处理所有 ManyToOne 的填充
  213.      *
  214.      * @param object 被填充的对象
  215.      * @throws Exception 反射异常
  216.      */
  217.     public void fillManyToOneOnWriting(Object object) throws Exception {
  218.         if (object == null) {
  219.             return;
  220.         }
  221.         Class clazz = object.getClass();
  222.         // 获取所有 ManyToOne注解的Filed
  223.         List<Field> result = getFieldsEquals(clazz, ManyToOne.class);
  224.         for (Field field : result) {
  225.             //获取One端的变量名
  226.             String columnName = field.getAnnotation(JoinColumn.class).name();
  228.             //获取One的对象
  229.             Object targetObj = clazz
  230.                     .getMethod("get" + StringUtils.capitalize(field.getName()))
  231.                     .invoke(object);
  232.             if (targetObj == null) {
  233.                 continue;
  234.             }
  235.             //获取 获取 id 值
  236.             int id = (int) targetObj.getClass().
  237.                     getMethod("getId").invoke(targetObj);
  239.             // 插回 columnName
  241.             clazz.getMethod("set" + StringUtils.capitalize(columnName), Integer.class)
  242.                     .invoke(object, id);
  243.         }
  244.     }
  246.     /**
  247.      * 读取时填充数据，递归调用上面的方法
  248.      * @param object 对象
  249.      * @param depth 当前递归深度
  250.      * @throws Exception 反射异常
  251.      */
  252.     public void fillOnReading(Object object, int depth) throws Exception {
  253.         if (object == null) {
  254.             return;
  255.         }
  256.         if (depth <= 0) {
  257.             return;
  258.         }
  260.         // 处理 ManyToOne
  261.         fillManyToOneOnReading(object, depth);
  262.         // 处理 OneToMany
  263.         fillOneToManyOnReading(object, depth);
  264.         // 处理 Enumerated
  265.         fillEnumOnReading(object);
  267.     }
  269.     /**
  270.      * 写入时填充数据，递归调用上面的方法
  271.      * @param object 对象
  272.      * @throws Exception 反射异常
  273.      */
  274.     public void fillOnWriting(Object object) throws Exception {
  275.         if (object == null) {
  276.             return;
  277.         }
  278.         // 处理 Enumerated
  279.         fillEnumOnWriting(object);
  280.         // 处理 ManyToOne
  281.         fillManyToOneOnWriting(object);
  282.     }
  283. }

4.在service层调用

  1.  @Resource
  2.     private MapperFactory mapperFactory;

　　拿到 mapperFactory ，如果要对CategoryMaper进行填充处理的话，就直接用mapperFactory.getMapper(mapperInterface);即可拿到对应的通用 mapper ，然后和 原来的 mybatis mapper 使用 方法一样。

后记

　　毫无疑问，这个通用 mapper 还很不完善，效率也比较低，现在的实现只相当于玩具的级别。而且市面上也已经有了一系列 jpa系统实现，这个通用mapper存在的意义也不是十分大。

　　但是，我们可以通过这个 mapper 理解到泛型、反射的一系列用法，递归的实操中的使用，还可以对mybatis-generator有了更深的理解

　　这个 mapper 也在我的 小小商城-ssm版中 完整运用了，为此我可以使用 mybatis 而不用写 一行 sql 代码。

　　时间仓促，涉及到的知识点也太多，文章非常简略，对新手也不是十分友好，在此表示歉意。如果想详细理解这个 通用 mapper ，可以到项目 github 中 查看全部源代码，或者发邮件、留言和我交流 （邮件地址在Github首页）。