style: 优化 Mappers 类。

mybatis-flex-core/src/main/java/com/mybatisflex/core/mybatis/Mappers.java

@@ -30,60 +30,73 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
+ * 获取 {@link BaseMapper} 对象。
+ *
  * @author michael
+ * @author 王帅
  */
 @SuppressWarnings("unchecked")
 public class Mappers {
 
-    private static final Map<Class<?>, Class<?>> ENTITY_MAPPER_MAP = new ConcurrentHashMap<>();
+    private Mappers() {
+    }
 
     private static final Map<Class<?>, Object> MAPPER_OBJECTS = new ConcurrentHashMap<>();
 
+    private static final Map<Class<?>, Class<?>> ENTITY_MAPPER_MAP = new ConcurrentHashMap<>();
 
+    /**
+     * 添加 实体类 与 {@link BaseMapper} 接口实现接口 对应，两者皆为非动态代理类。
+     *
+     * @param entityClass 实体类
+     * @param mapperClass {@link BaseMapper} 实现接口
+     */
     static void addMapping(Class<?> entityClass, Class<?> mapperClass) {
         ENTITY_MAPPER_MAP.put(entityClass, mapperClass);
     }
 
-
     /**
-     * 通过 entity Class 获取 Mapper 对象
+     * 通过 实体类 获取对应 {@link BaseMapper} 对象。
      *
-     * @param entityClass
-     * @param <Entity>
-     * @return mapper 对象
+     * @param entityClass 实体类
+     * @param <E>         实体类类型
+     * @return {@link BaseMapper} 对象
      */
-    public static <Entity> BaseMapper<Entity> ofEntityClass(Class<Entity> entityClass) {
+    public static <E> BaseMapper<E> ofEntityClass(Class<E> entityClass) {
         Class<?> mapperClass = ENTITY_MAPPER_MAP.get(entityClass);
         if (mapperClass == null) {
             throw FlexExceptions.wrap("Can not find MapperClass by entity: " + entityClass.getName());
         }
-        return (BaseMapper<Entity>) ofMapperClass(mapperClass);
+        return (BaseMapper<E>) ofMapperClass(mapperClass);
     }
 
-
     /**
-     * 通过 mapperClass 直接获取 mapper 对象执行
+     * 通过 {@link BaseMapper} 接口实现的 Class 引用直接获取 {@link BaseMapper} 代理对象。
      *
-     * @param mapperClass
-     * @return mapperObject
+     * @param mapperClass {@link BaseMapper} 接口实现
+     * @return {@link BaseMapper} 对象
      */
-    public static <Mapper> Mapper ofMapperClass(Class<Mapper> mapperClass) {
+    public static <M> M ofMapperClass(Class<M> mapperClass) {
         Object mapperObject = MapUtil.computeIfAbsent(MAPPER_OBJECTS, mapperClass, clazz ->
             Proxy.newProxyInstance(mapperClass.getClassLoader()
                 , new Class[]{mapperClass}
                 , new MapperHandler(mapperClass)));
-        return (Mapper) mapperObject;
+        return (M) mapperObject;
     }
 
+    private static class MapperHandler implements InvocationHandler {
 
-    static class MapperHandler implements InvocationHandler {
-
-        private Class<?> mapperClass;
-        private final SqlSessionFactory sqlSessionFactory = FlexGlobalConfig.getDefaultConfig().getSqlSessionFactory();
-        private final ExecutorType executorType = FlexGlobalConfig.getDefaultConfig().getConfiguration().getDefaultExecutorType();
+        private final Class<?> mapperClass;
+        private final ExecutorType executorType;
+        private final SqlSessionFactory sqlSessionFactory;
 
         public MapperHandler(Class<?> mapperClass) {
             this.mapperClass = mapperClass;
+            this.executorType = FlexGlobalConfig.getDefaultConfig()
+                .getConfiguration()
+                .getDefaultExecutorType();
+            this.sqlSessionFactory = FlexGlobalConfig.getDefaultConfig()
+                .getSqlSessionFactory();
         }
 
         private SqlSession openSession() {
@@ -97,6 +110,7 @@ public class Mappers {
                 return method.invoke(mapper, args);
             }
         }
+
     }
 
 }