/**
 * 模拟枚举类 (枚举类：在enum出现之前的表达 可枚举的含义的类)
 * 通常 private 构造函数
 * final class
 * private static final 本类型 成员
 *
 */

final class EnumClass{
    public static final EnumClass ONE = new EnumClass(1);
    public static final EnumClass TWO = new EnumClass(2);
    public static final EnumClass THREE = new EnumClass(3);
    public static final EnumClass FOUR = new EnumClass(4);

    @Getter
    @Setter
    private int value;
    private EnumClass(int value) {
        this.value = value;
    }
  
  	public void print() {
        System.out.println(this.toString());
    }

}

enum CountingEnum {
    ONE(1),
    TWO(2),
    THREE(3),
    FOUR(4)
    ;
    @Getter
    private int value;

    /** private */ CountingEnum (int value) {
        this.value =  value;
    }
}

// 输出 枚举 中的名字、位置、输出所有枚举
       Arrays.stream(CountingEnum.values()).forEach(e -> {
           System.out.println("输出枚举中的顺序: " + e.ordinal() + "名字：" + e.name() + "value：" + e.getValue());
       });

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
    
    private final String name;

    public final String name() {
        return name;
    }

    private final int ordinal;

   
    public final int ordinal() {
        return ordinal;
    }

   
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }

  
    public String toString() {
        return name;
    }

  
    public final boolean equals(Object other) {
        return this==other;
    }

   
    public final int hashCode() {
        return super.hashCode();
    }

    
    protected final Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException();
    }

   
    public final int compareTo(E o) {
        Enum<?> other = (Enum<?>)o;
        Enum<E> self = this;
        if (self.getClass() != other.getClass() && // optimization
            self.getDeclaringClass() != other.getDeclaringClass())
            throw new ClassCastException();
        return self.ordinal - other.ordinal;
    }

    
    @SuppressWarnings("unchecked")
    public final Class<E> getDeclaringClass() {
        Class<?> clazz = getClass();
        Class<?> zuper = clazz.getSuperclass();
        return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
    }

    
    public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

    /**
     * enum classes cannot have finalize methods.
     */
    protected final void finalize() { }

    /**
     * prevent default deserialization
     */
    private void readObject(ObjectInputStream in) throws IOException,
        ClassNotFoundException {
        throw new InvalidObjectException("can't deserialize enum");
    }

    private void readObjectNoData() throws ObjectStreamException {
        throw new InvalidObjectException("can't deserialize enum");
    }
}

enum Opration {
    PLUS,
    DIVIDE
    ;
    public double apply(double x, double y) {
        switch (this) {

            case PLUS:
                return x + y;
            case DIVIDE:
                return x - y;
        }
        throw new AssertionError("unknown");
    }
}

/**
 * 通过抽象方法， 来实现加入新的操作的时候 能符合开闭原则，只关心自己操作符抽象的实现
 */
enum OperationOptimize {
    PLUS("+"){
        @Override
        public int apply(int x, int y) {
            return x + y;
        }
    },
    DIVIDE("-") {
        @Override
        public int apply(int x, int y) {
            return x - y;
        }
    }
    ;

    @Getter
    private String str;
    private OperationOptimize(String str) {
        this.str = str;
    }

    // 抽象方法
    public abstract int apply(int x, int y);
}

final class EnumClass {
    public static final EnumClass ONE = new EnumClass(1);
    public static final EnumClass TWO = new EnumClass(2);
    public static final EnumClass THREE = new EnumClass(3);
    public static final EnumClass FOUR = new EnumClass(4);

    @Getter
    @Setter
    private int value;

    private EnumClass(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "EnumClass{" +
                "value=" + value +
                '}';
    }

    public void print() {
        System.out.println(this.toString());
    }

    /**
     * 为枚举类实现一个values方法
     */

    public static EnumClass[] values() {
        // 获取枚举类中所有字段
        return Stream.of(EnumClass.class.getDeclaredFields())
                // 过滤出 public static final的
                .filter(field -> {
                    // 修饰符
                    int modifiers = field.getModifiers();
                    return Modifier.isPublic(modifiers)
                            && Modifier.isStatic(modifiers)
                            && Modifier.isFinal(modifiers);
                })
                // 取出对应的字段值
                .map(field -> {
                    try {
                        return field.get(null);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    }
                }).toArray(EnumClass[]::new);
    }
}

jstat -gcmetacapacity 75453  1000 10

public class MapperRegistry {
  // 全局唯一的configuration对象，存放解析之后的全部Mybatis配置信息
  private final Configuration config;
  // 已知的所有映射
  // key:mapperInterface,即dao的数据库接口
  // value:MapperProxyFactory,即映射器代理工厂
  private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
}

public <T> void addMapper(Class<T> type) {
  // 要加入的肯定是接口，否则不添加
  if (type.isInterface()) {
    // 加入的是接口
    if (hasMapper(type)) {
      // 如果添加重复
      throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
    }
    boolean loadCompleted = false;
    try {
      knownMappers.put(type, new MapperProxyFactory<>(type));
      // It's important that the type is added before the parser is run
      // otherwise the binding may automatically be attempted by the
      // mapper parser. If the type is already known, it won't try.
      MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
      parser.parse();
      loadCompleted = true;
    } finally {
      if (!loadCompleted) {
        knownMappers.remove(type);
      }
    }
  }
}

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
  // 找出指定映射接口的代理工厂
  final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
  if (mapperProxyFactory == null) {
    throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
  }
  try {
    // 通过mapperProxyFactory给出对应代理器的实例
    return mapperProxyFactory.newInstance(sqlSession);
  } catch (Exception e) {
    throw new BindingException("Error getting mapper instance. Cause: " + e, e);
  }
}

public class MapperProxyFactory<T> {

  // 对应SQL的java接口类
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<>();

  /**
   * MapperProxyFactory构造方法
   * @param mapperInterface 映射接口
   */
  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);
  }

}

public class MapperProxy<T> implements InvocationHandler, Serializable {

  private static final long serialVersionUID = -6424540398559729838L;
  // 与当前mapperProxy关联的sqlSession对象 用于访问数据库
  private final SqlSession sqlSession;
  // 被代理的mapper接口
  private final Class<T> mapperInterface;
  // 该Map的键为方法，值为MapperMethod对象。通过该属性，完成了MapperProxy内（即映射接口内）方法和MapperMethod的绑定
  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())) { // 继承自Object的方法
        // 直接执行原有方法
        return method.invoke(this, args);
      } else if (method.isDefault()) { // 默认方法
        // 执行默认方法
        return invokeDefaultMethod(proxy, method, args);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
    // 找对对应的MapperMethod对象 去执行
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    // 调用MapperMethod中的execute方法
    return mapperMethod.execute(sqlSession, args);
  }

  private MapperMethod cachedMapperMethod(Method method) {
    return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
  }
}

public static class SqlCommand {

  // SQL语句的名称 即唯一标识
  private final String name;
  // SQL语句的种类，一共分为以下六种：增、删、改、查、清缓存、未知
  private final SqlCommandType type;

  /**
   * 根据传入接口和方法封装sql信息
   * @param configuration
   * @param mapperInterface
   * @param method
   */
  public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) {
    // 方法名称
    final String methodName = method.getName();
    // 方法所在的类。可能是mapperInterface，也可能是mapperInterface的子类
    final Class<?> declaringClass = method.getDeclaringClass();
    // mapper接口名称、方法名称拼起来做唯一标识
    // 到configuration全局配置对象中查找sql语句
    // mappedStatement就是Mapper.xml配置文件中一条SQL解析之后得到的对象
    MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
        configuration);
    if (ms == null) {
      if (method.getAnnotation(Flush.class) != null) {
        // 标记flush注解
        name = null;
        type = SqlCommandType.FLUSH;
      } else {
        throw new BindingException("Invalid bound statement (not found): "
            + mapperInterface.getName() + "." + methodName);
      }
    } else {
      name = ms.getId();
      type = ms.getSqlCommandType();
      if (type == SqlCommandType.UNKNOWN) {
        throw new BindingException("Unknown execution method for: " + name);
      }
    }
  }

  public String getName() {
    return name;
  }

  public SqlCommandType getType() {
    return type;
  }

  /**
   * 找出指定接口指定方法对应的MappedStatement对象
   * @param mapperInterface 映射接口
   * @param methodName 映射接口中具体操作方法名
   * @param declaringClass 操作方法所在的类。一般是映射接口本身，也可能是映射接口的子类
   * @param configuration 配置信息
   * @return MappedStatement对象
   */
  private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
      Class<?> declaringClass, Configuration configuration) {
    // 数据库操作语句的编号是：接口名.方法名
    String statementId = mapperInterface.getName() + "." + methodName;
    // configuration保存了解析后的所有操作语句，去查找该语句
    if (configuration.hasStatement(statementId)) {
      // 从configuration中找到了对应的语句，返回
      return configuration.getMappedStatement(statementId);
    } else if (mapperInterface.equals(declaringClass)) {
      // 说明递归调用已经到终点，但是仍然没有找到匹配的结果
      return null;
    }
    // 从方法的定义类开始，沿着父类向上寻找。找到接口类时停止
    for (Class<?> superInterface : mapperInterface.getInterfaces()) {
      if (declaringClass.isAssignableFrom(superInterface)) {
        // 递归查找父类
        MappedStatement ms = resolveMappedStatement(superInterface, methodName,
            declaringClass, configuration);
        if (ms != null) {
          return ms;
        }
      }
    }
    return null;
  }
}

public static class MethodSignature {

  // 返回类型是否为集合类型
  private final boolean returnsMany;
  // 返回类型是否是map
  private final boolean returnsMap;
  // 返回类型是否是空
  private final boolean returnsVoid;
  // 返回类型是否是cursor类型
  private final boolean returnsCursor;
  // 返回类型是否是optional类型
  private final boolean returnsOptional;
  // 返回类型
  private final Class<?> returnType;
  // 如果返回为map,这里记录所有的map的key @MapKey注解
  private final String mapKey;
  // resultHandler参数的位置
  private final Integer resultHandlerIndex;
  // rowBounds参数的位置
  private final Integer rowBoundsIndex;
  // 引用参数名称解析器
  private final ParamNameResolver paramNameResolver;

  public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) {
    Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
    if (resolvedReturnType instanceof Class<?>) {
      this.returnType = (Class<?>) resolvedReturnType;
    } else if (resolvedReturnType instanceof ParameterizedType) {
      this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
    } else {
      this.returnType = method.getReturnType();
    }
    this.returnsVoid = void.class.equals(this.returnType);
    this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
    this.returnsCursor = Cursor.class.equals(this.returnType);
    this.returnsOptional = Optional.class.equals(this.returnType);
    this.mapKey = getMapKey(method);
    this.returnsMap = this.mapKey != null;
    // rowBoundsIndex和resultHandlerIndex
    this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
    this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
    // 解析参数名称的工具类
    this.paramNameResolver = new ParamNameResolver(configuration, method);
  }

  public Object convertArgsToSqlCommandParam(Object[] args) {
    // 通过传入实参获取 实参和参数名称的映射表
    return paramNameResolver.getNamedParams(args);
  }

  public boolean hasRowBounds() {
    return rowBoundsIndex != null;
  }

  public RowBounds extractRowBounds(Object[] args) {
    return hasRowBounds() ? (RowBounds) args[rowBoundsIndex] : null;
  }

  public boolean hasResultHandler() {
    return resultHandlerIndex != null;
  }

  public ResultHandler extractResultHandler(Object[] args) {
    return hasResultHandler() ? (ResultHandler) args[resultHandlerIndex] : null;
  }

  public String getMapKey() {
    return mapKey;
  }

  public Class<?> getReturnType() {
    return returnType;
  }

  public boolean returnsMany() {
    return returnsMany;
  }

  public boolean returnsMap() {
    return returnsMap;
  }

  public boolean returnsVoid() {
    return returnsVoid;
  }

  public boolean returnsCursor() {
    return returnsCursor;
  }

  /**
   * return whether return type is {@code java.util.Optional}.
   * @return return {@code true}, if return type is {@code java.util.Optional}
   * @since 3.5.0
   */
  public boolean returnsOptional() {
    return returnsOptional;
  }

  // 返回指定参数的index
  private Integer getUniqueParamIndex(Method method, Class<?> paramType) {
    Integer index = null;
    final Class<?>[] argTypes = method.getParameterTypes();
    for (int i = 0; i < argTypes.length; i++) {
      if (paramType.isAssignableFrom(argTypes[i])) {
        if (index == null) {
          index = i;
        } else {
          throw new BindingException(method.getName() + " cannot have multiple " + paramType.getSimpleName() + " parameters");
        }
      }
    }
    return index;
  }

  private String getMapKey(Method method) {
    String mapKey = null;
    if (Map.class.isAssignableFrom(method.getReturnType())) {
      final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.class);
      if (mapKeyAnnotation != null) {
        mapKey = mapKeyAnnotation.value();
      }
    }
    return mapKey;
  }
}