MyBatis源码解析--加载流程（5）

最新推荐文章于 2023-05-15 16:47:53 发布
最新推荐文章于 2023-05-15 16:47:53 发布
阅读量134 收藏
点赞数
分类专栏： jdbc与mybatis 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jacobbbbbbbb/article/details/106854430
版权

StaticTextSqlNode 静态文本的SqlNode实现类

public class StaticTextSqlNode implements SqlNode {
//静态文本
  private final String text;

  public StaticTextSqlNode(String text) {
    this.text = text;
  }

  @Override
  //直接拼接到context中
  public boolean apply(DynamicContext context) {
    context.appendSql(text);
    return true;
  }

}

TextSqlNode 跟static区别是不确定是否是静态文本。

public class TextSqlNode implements SqlNode {
//文本
  private final String text;
  private final Pattern injectionFilter;

  public TextSqlNode(String text) {
    this(text, null);
  }
  
  public TextSqlNode(String text, Pattern injectionFilter) {
    this.text = text;
    this.injectionFilter = injectionFilter;
  }
  //判断是否是动态文本，只要存在${XXX}就是动态文本
  public boolean isDynamic() {
  //创建 DynamicCheckerTokenParser 对象
    DynamicCheckerTokenParser checker = new DynamicCheckerTokenParser();
    //创建 GenericTokenParser 对象
    GenericTokenParser parser = createParser(checker);
    //执行解析
    parser.parse(text);
    //判断是否是动态文本
    return checker.isDynamic();
  }

  @Override
  public boolean apply(DynamicContext context) {
  //创建BindingTokenParser对象，创建GenericTokenParser对象
    GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
    //执行解析，将解析结果添加到context中
    context.appendSql(parser.parse(text));
    return true;
  }
  //只要存在${}就是动态文本
  private GenericTokenParser createParser(TokenHandler handler) {
    return new GenericTokenParser("${", "}", handler);
  }

  private static class BindingTokenParser implements TokenHandler {

    private DynamicContext context;
    private Pattern injectionFilter;

    public BindingTokenParser(DynamicContext context, Pattern injectionFilter) {
      this.context = context;
      this.injectionFilter = injectionFilter;
    }

    @Override
    public String handleToken(String content) {
    //初始化value属性到context中
      Object parameter = context.getBindings().get("_parameter");
      if (parameter == null) {
        context.getBindings().put("value", null);
      } else if (SimpleTypeRegistry.isSimpleType(parameter.getClass())) {
        context.getBindings().put("value", parameter);
      }
      //使用OGNL表达式获得对应的值
      Object value = OgnlCache.getValue(content, context.getBindings());
      String srtValue = (value == null ? "" : String.valueOf(value)); // issue #274 return "" instead of "null"
      checkInjection(srtValue);
      //返回该值
      return srtValue;
    }

    private void checkInjection(String value) {
      if (injectionFilter != null && !injectionFilter.matcher(value).matches()) {
        throw new ScriptingException("Invalid input. Please conform to regex" + injectionFilter.pattern());
      }
    }
  }
  //内部类
  private static class DynamicCheckerTokenParser implements TokenHandler {
//是否是动态文本
    private boolean isDynamic;

    public DynamicCheckerTokenParser() {
      // Prevent Synthetic Access
    }

    public boolean isDynamic() {
      return isDynamic;
    }

    @Override
    //当检查到token，标记为动态文本
    public String handleToken(String content) {
      this.isDynamic = true;
      return null;
    }
  }
  
}

MixedSqlNode

public class MixedSqlNode implements SqlNode {
  private final List<SqlNode> contents;

  public MixedSqlNode(List<SqlNode> contents) {
    this.contents = contents;
  }

  @Override
  //遍历SqlNode数组，逐个调用
  public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : contents) {
      sqlNode.apply(context);
    }
    return true;
  }
}

OgnlCache Ognl的缓存类

public final class OgnlCache {
//单例
  private static final OgnlMemberAccess MEMBER_ACCESS = new OgnlMemberAccess();
  private static final OgnlClassResolver CLASS_RESOLVER = new OgnlClassResolver();
  //表达式的缓存的映射，key是表达式，value是表达式的缓存
  private static final Map<String, Object> expressionCache = new ConcurrentHashMap<>();

  private OgnlCache() {
    // Prevent Instantiation of Static Class
  }

  public static Object getValue(String expression, Object root) {
    try {
    //创建OGNL Context对象
      Map context = Ognl.createDefaultContext(root, MEMBER_ACCESS, CLASS_RESOLVER, null);
      //解析表达式，获得表达式对应的值
      return Ognl.getValue(parseExpression(expression), context, root);
    } catch (OgnlException e) {
      throw new BuilderException("Error evaluating expression '" + expression + "'. Cause: " + e, e);
    }
  }
//解析表达式
  private static Object parseExpression(String expression) throws OgnlException {
    Object node = expressionCache.get(expression);
    if (node == null) {
      node = Ognl.parseExpression(expression);
      expressionCache.put(expression, node);
    }
    return node;
  }

}

OgnlMemberAccess 实现了MemberAccess接口，OGNL成员访问器实现类

class OgnlMemberAccess implements MemberAccess {
  //是否可以修改成员的可访问
  private final boolean canControlMemberAccessible;

  OgnlMemberAccess() {
    this.canControlMemberAccessible = Reflector.canControlMemberAccessible();
  }

  @Override
  public Object setup(Map context, Object target, Member member, String propertyName) {
    Object result = null;
    //判断是否可以修改
    if (isAccessible(context, target, member, propertyName)) {
      AccessibleObject accessible = (AccessibleObject) member;
      //不可访问就设置为可以访问
      if (!accessible.isAccessible()) {
        result = Boolean.FALSE;
        accessible.setAccessible(true);
      }
    }
    return result;
  }

  @Override
  public void restore(Map context, Object target, Member member, String propertyName,
      Object state) {
    if (state != null) {
    //修改为原来的可访问
      ((AccessibleObject) member).setAccessible(((Boolean) state));
    }
  }

  @Override
  public boolean isAccessible(Map context, Object target, Member member, String propertyName) {
    return canControlMemberAccessible;
  }

}

OgnlClassResolver OGNL 类解析器实现类

public class OgnlClassResolver extends DefaultClassResolver {

  @Override
  protected Class toClassForName(String className) throws ClassNotFoundException {
    return Resources.classForName(className);
  }

}

ExpressionEvaluator OGNL 表达式计算器

public class ExpressionEvaluator {
//判断表达式对应的值，是否为true
  public boolean evaluateBoolean(String expression, Object parameterObject) {
  //获得表达式对应的值
    Object value = OgnlCache.getValue(expression, parameterObject);
    //如果是Boolean类型，直接判断
    if (value instanceof Boolean) {
      return (Boolean) value;
    }
    //如果是 Number 类型，则判断不等于 0
    if (value instanceof Number) {
      return new BigDecimal(String.valueOf(value)).compareTo(BigDecimal.ZERO) != 0;
    }
    return value != null;
  }
//获得表达式对应的集合
  public Iterable<?> evaluateIterable(String expression, Object parameterObject) {
  // 获得表达式对应的值
    Object value = OgnlCache.getValue(expression, parameterObject);
    if (value == null) {
      throw new BuilderException("The expression '" + expression + "' evaluated to a null value.");
    }
    // 如果是 Iterable 类型，直接返回
    if (value instanceof Iterable) {
      return (Iterable<?>) value;
    }
    // 如果是数组类型，则返回数组
    if (value.getClass().isArray()) {
        int size = Array.getLength(value);
        List<Object> answer = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            Object o = Array.get(value, i);
            answer.add(o);
        }
        return answer;
    }
    // 如果是 Map 类型，则返回 Map.entrySet 集合
    if (value instanceof Map) {
      return ((Map) value).entrySet();
    }
    throw new BuilderException("Error evaluating expression '" + expression + "'.  Return value (" + value + ") was not iterable.");
  }

}

接下来进入SqlSource，代表着从Mapper.xml或方法注解上读取的一条SQL内容

public interface SqlSource {
	//根据传入的参数对象返回BoundSql对象
  BoundSql getBoundSql(Object parameterObject);

}

SqlSourceBuilder 负责将SQL语句中的#{XX}替换成对应的？占位符，并且获取？占位符号对应的ParamterMapping对象

public class SqlSourceBuilder extends BaseBuilder {

  private static final String parameterProperties = "javaType,jdbcType,mode,numericScale,resultMap,typeHandler,jdbcTypeName";
//构造函数
  public SqlSourceBuilder(Configuration configuration) {
    super(configuration);
  }
//解析原始SQL，成为SqlSource对象
  public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
  //创建ParameterMappingTokenHandler对象
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
    //创建 GenericTokenParser 对象
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
    //执行解析
    String sql = parser.parse(originalSql);
    //创建 StaticSqlSource 对象
    return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
  }
	//内部类。负责将#{}替换成？占位符
  private static class ParameterMappingTokenHandler extends BaseBuilder implements TokenHandler {
//ParamterMapping数组
    private List<ParameterMapping> parameterMappings = new ArrayList<>();
    //参数类型
    private Class<?> parameterType;
    //附加参数对应的MetaObject对象
    private MetaObject metaParameters;
//构造函数
    public ParameterMappingTokenHandler(Configuration configuration, Class<?> parameterType, Map<String, Object> additionalParameters) {
      super(configuration);
      this.parameterType = parameterType;
      this.metaParameters = configuration.newMetaObject(additionalParameters);
    }

    public List<ParameterMapping> getParameterMappings() {
      return parameterMappings;
    }

    @Override
    public String handleToken(String content) {
    //构建 ParameterMapping 对象，并添加到 parameterMappings 中
      parameterMappings.add(buildParameterMapping(content));
      //返回？占位符
      return "?";
    }
	//构建ParameterMapping对象
    private ParameterMapping buildParameterMapping(String content) {
    //解析成Map集合
      Map<String, String> propertiesMap = parseParameterMapping(content);
      //获得属性的名称和类型
      String property = propertiesMap.get("property");
      Class<?> propertyType;
      if (metaParameters.hasGetter(property)) { // issue #448 get type from additional params
        propertyType = metaParameters.getGetterType(property);
      } else if (typeHandlerRegistry.hasTypeHandler(parameterType)) {
        propertyType = parameterType;
      } else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) {
        propertyType = java.sql.ResultSet.class;
      } else if (property == null || Map.class.isAssignableFrom(parameterType)) {
        propertyType = Object.class;
      } else {
        MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());
        if (metaClass.hasGetter(property)) {
          propertyType = metaClass.getGetterType(property);
        } else {
          propertyType = Object.class;
        }
      }
      //创建 ParameterMapping.Builder 对象
      ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, propertyType);
      Class<?> javaType = propertyType;
      String typeHandlerAlias = null;
      for (Map.Entry<String, String> entry : propertiesMap.entrySet()) {
        String name = entry.getKey();
        String value = entry.getValue();
        if ("javaType".equals(name)) {
          javaType = resolveClass(value);
          builder.javaType(javaType);
        } else if ("jdbcType".equals(name)) {
          builder.jdbcType(resolveJdbcType(value));
        } else if ("mode".equals(name)) {
          builder.mode(resolveParameterMode(value));
        } else if ("numericScale".equals(name)) {
          builder.numericScale(Integer.valueOf(value));
        } else if ("resultMap".equals(name)) {
          builder.resultMapId(value);
        } else if ("typeHandler".equals(name)) {
          typeHandlerAlias = value;
        } else if ("jdbcTypeName".equals(name)) {
          builder.jdbcTypeName(value);
        } else if ("property".equals(name)) {
          // Do Nothing
        } else if ("expression".equals(name)) {
          throw new BuilderException("Expression based parameters are not supported yet");
        } else {
          throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content + "}.  Valid properties are " + parameterProperties);
        }
      }
      //如果typeHandlerAlias非空，就获得对应的TypeHandler对象。
      if (typeHandlerAlias != null) {
        builder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));
      }
      //创建 ParameterMapping 对象
      return builder.build();
    }
//解析成Map集合
    private Map<String, String> parseParameterMapping(String content) {
      try {
        return new ParameterExpression(content);
      } catch (BuilderException ex) {
        throw ex;
      } catch (Exception ex) {
        throw new BuilderException("Parsing error was found in mapping #{" + content + "}.  Check syntax #{property|(expression), var1=value1, var2=value2, ...} ", ex);
      }
    }
  }

}

SqlSource的实现类
StaticSqlSource

public class StaticSqlSource implements SqlSource {
//静态sql
  private final String sql;
  //ParameterMapping 集合
  private final List<ParameterMapping> parameterMappings;
  private final Configuration configuration;

  public StaticSqlSource(Configuration configuration, String sql) {
    this(configuration, sql, null);
  }

  public StaticSqlSource(Configuration configuration, String sql, List<ParameterMapping> parameterMappings) {
    this.sql = sql;
    this.parameterMappings = parameterMappings;
    this.configuration = configuration;
  }

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
  //创建BoundSql对象
    return new BoundSql(configuration, sql, parameterMappings, parameterObject);
  }

}

DynamicSqlSource

public class DynamicSqlSource implements SqlSource {

  private final Configuration configuration;
  //根SqlNode对象
  private final SqlNode rootSqlNode;

  public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
    this.configuration = configuration;
    this.rootSqlNode = rootSqlNode;
  }

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
  //应用rootSqlNode
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    rootSqlNode.apply(context);
    //构建SqlSourceBuilder对象
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
    //解析出SqlSource对象
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    //添加附加参数到 BoundSql 对象中
    for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
      boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
    }
    return boundSql;
  }

}

RawSqlSource

public class RawSqlSource implements SqlSource {

  private final SqlSource sqlSource;

  public RawSqlSource(Configuration configuration, SqlNode rootSqlNode, Class<?> parameterType) {
    this(configuration, getSql(configuration, rootSqlNode), parameterType);
  }

  public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
  //创建SqlSourceBuilder对象
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> clazz = parameterType == null ? Object.class : parameterType;
    //获得SqlSource对象
    sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap<String, Object>());
  }

  private static String getSql(Configuration configuration, SqlNode rootSqlNode) {
  //创建DynamicContext对象
    DynamicContext context = new DynamicContext(configuration, null);
     // 解析出 SqlSource 对象
    rootSqlNode.apply(context);
    // 获得 sql
    return context.getSql();
  }

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    return sqlSource.getBoundSql(parameterObject);
  }

}

ProviderSqlSource 基于方法上的@ProviderXXX注解的SqlSource实现类

public class ProviderSqlSource implements SqlSource {

  private final Configuration configuration;
  private final SqlSourceBuilder sqlSourceParser;
  //注解对应的类
  private final Class<?> providerType;
  //注解对应的方法
  private Method providerMethod;
  //注解的对应的方法的参数名数组
  private String[] providerMethodArgumentNames;
  //注解的对应的方法的参数类型数组
  private Class<?>[] providerMethodParameterTypes;
  //如果有ProviderContext类型就创建ProviderContext对象
  private ProviderContext providerContext;
  //ProviderContext 类型的参数，在数组中的位置
  private Integer providerContextIndex;

  /**
   * @deprecated Please use the {@link #ProviderSqlSource(Configuration, Object, Class, Method)} instead of this.
   */
  @Deprecated
  public ProviderSqlSource(Configuration configuration, Object provider) {
    this(configuration, provider, null, null);
  }

  /**
   * @since 3.4.5
   */
  public ProviderSqlSource(Configuration configuration, Object provider, Class<?> mapperType, Method mapperMethod) {
    String providerMethodName;
    try {
      this.configuration = configuration;
      //创建SqlSourceBuilder对象
      this.sqlSourceParser = new SqlSourceBuilder(configuration);
      //获得 @ProviderXXX 注解的对应的类
      this.providerType = (Class<?>) provider.getClass().getMethod("type").invoke(provider);
      //获得 @ProviderXXX 注解的对应的方法相关的信息
      providerMethodName = (String) provider.getClass().getMethod("method").invoke(provider);

      for (Method m : this.providerType.getMethods()) {
        if (providerMethodName.equals(m.getName()) && CharSequence.class.isAssignableFrom(m.getReturnType())) {
          if (providerMethod != null){
            throw new BuilderException("Error creating SqlSource for SqlProvider. Method '"
                    + providerMethodName + "' is found multiple in SqlProvider '" + this.providerType.getName()
                    + "'. Sql provider method can not overload.");
          }
          this.providerMethod = m;
          this.providerMethodArgumentNames = new ParamNameResolver(configuration, m).getNames();
          this.providerMethodParameterTypes = m.getParameterTypes();
        }
      }
    } catch (BuilderException e) {
      throw e;
    } catch (Exception e) {
      throw new BuilderException("Error creating SqlSource for SqlProvider.  Cause: " + e, e);
    }
    if (this.providerMethod == null) {
      throw new BuilderException("Error creating SqlSource for SqlProvider. Method '"
          + providerMethodName + "' not found in SqlProvider '" + this.providerType.getName() + "'.");
    }
    //初始化 providerContext 和 providerContextIndex 属性
    for (int i = 0; i< this.providerMethodParameterTypes.length; i++) {
      Class<?> parameterType = this.providerMethodParameterTypes[i];
      if (parameterType == ProviderContext.class) {
        if (this.providerContext != null){
          throw new BuilderException("Error creating SqlSource for SqlProvider. ProviderContext found multiple in SqlProvider method ("
              + this.providerType.getName() + "." + providerMethod.getName()
              + "). ProviderContext can not define multiple in SqlProvider method argument.");
        }
        this.providerContext = new ProviderContext(mapperType, mapperMethod);
        this.providerContextIndex = i;
      }
    }
  }

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
  //创建SqlSource对象
    SqlSource sqlSource = createSqlSource(parameterObject);
    //获得 BoundSql 对象
    return sqlSource.getBoundSql(parameterObject);
  }

  private SqlSource createSqlSource(Object parameterObject) {
    try {
    //获得SQL
      int bindParameterCount = providerMethodParameterTypes.length - (providerContext == null ? 0 : 1);
      String sql;
      if (providerMethodParameterTypes.length == 0) {
        sql = invokeProviderMethod();
      } else if (bindParameterCount == 0) {
        sql = invokeProviderMethod(providerContext);
      } else if (bindParameterCount == 1 &&
              (parameterObject == null || providerMethodParameterTypes[(providerContextIndex == null || providerContextIndex == 1) ? 0 : 1].isAssignableFrom(parameterObject.getClass()))) {
        sql = invokeProviderMethod(extractProviderMethodArguments(parameterObject));
      } else if (parameterObject instanceof Map) {
        @SuppressWarnings("unchecked")
        Map<String, Object> params = (Map<String, Object>) parameterObject;
        sql = invokeProviderMethod(extractProviderMethodArguments(params, providerMethodArgumentNames));
      } else {
        throw new BuilderException("Error invoking SqlProvider method ("
                + providerType.getName() + "." + providerMethod.getName()
                + "). Cannot invoke a method that holds "
                + (bindParameterCount == 1 ? "named argument(@Param)": "multiple arguments")
                + " using a specifying parameterObject. In this case, please specify a 'java.util.Map' object.");
      }
      //获得参数
      Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
      //替换掉Sql上的属性，解析出SqlSource对象
      return sqlSourceParser.parse(replacePlaceholder(sql), parameterType, new HashMap<String, Object>());
    } catch (BuilderException e) {
      throw e;
    } catch (Exception e) {
      throw new BuilderException("Error invoking SqlProvider method ("
          + providerType.getName() + "." + providerMethod.getName()
          + ").  Cause: " + e, e);
    }
  }
//获得方法参数
  private Object[] extractProviderMethodArguments(Object parameterObject) {
    if (providerContext != null) {
      Object[] args = new Object[2];
      args[providerContextIndex == 0 ? 1 : 0] = parameterObject;
      args[providerContextIndex] = providerContext;
      return args;
    } else {
      return new Object[] { parameterObject };
    }
  }

  private Object[] extractProviderMethodArguments(Map<String, Object> params, String[] argumentNames) {
    Object[] args = new Object[argumentNames.length];
    for (int i = 0; i < args.length; i++) {
      if (providerContextIndex != null && providerContextIndex == i) {
        args[i] = providerContext;
      } else {
        args[i] = params.get(argumentNames[i]);
      }
    }
    return args;
  }
//执行方法，生成SQL
  private String invokeProviderMethod(Object... args) throws Exception {
    Object targetObject = null;
    if (!Modifier.isStatic(providerMethod.getModifiers())) {
      targetObject = providerType.newInstance();
    }
    CharSequence sql = (CharSequence) providerMethod.invoke(targetObject, args);
    return sql != null ? sql.toString() : null;
  }

  private String replacePlaceholder(String sql) {
    return PropertyParser.parse(sql, configuration.getVariables());
  }

}

ProviderContext ProviderSqlSource的上下文

public final class ProviderContext {
	//Mapper接口
  private final Class<?> mapperType;
  //Mapper的方法
  private final Method mapperMethod;

  ProviderContext(Class<?> mapperType, Method mapperMethod) {
    this.mapperType = mapperType;
    this.mapperMethod = mapperMethod;
  }

  public Class<?> getMapperType() {
    return mapperType;
  }

  public Method getMapperMethod() {
    return mapperMethod;
  }

}
jacobbbbbbbb
关注
专栏目录
Mybatis | 动态 SQL 基石 —— Ognl
u010141779的博客
12-30 2258
动态 SQL 是 MyBatis 的强大特性之一。如果使用过 JDBC 或其它类似的框架，应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。除了 if， Mybatis 还支持 choose，when，otherwise，trim，where 等动态 SQL 元素，值得注意的是，这些元素中有些属性是需要通过表达式计算的，比如 if 元素的 test 属性。
MyBatis源码通~OGNL的应用
一只打杂的码农
05-21 1402
OGNL表达式(Object Graphic Navigation Language) 一、原生OGNL表达式 1、表达式 ONGL表达式执行的所有操作都是根据表达式解析得到的。 例如： “对象名.方法名”表示调用指定对象的指定方法； “@[类的完全限定名]@[静态方法或者静态字段]”表示调用指定类的静态方法或访问静态字段； OGNL表达式还可以完成变量赋值、操作集合等操作。 2、 root对...
Mybatis值ResolverUtil的使用
最新发布
qq_30429435的博客
05-15 134
ResolverUtil工具类主要用于在指定的包下查找接口的实现类。
MyBatis - 初始化（十一）SQL初始化（下）
热门推荐
Zack_tzh的博客
01-06 2万+
MyBatis - 初始化（十一）SQL初始化（下） 该系列文档是本人在学习 Mybatis 的源码过程中总结下来的，可能对各位读者会不太友好，阅读前需要对 MyBatis 和 Spring 有一定的了解。比较适合刚接触，会使用但是一直没去探究底层的同学。 MyBatis 版本：3.5.6 MyBatis-Spring 版本：2.0.3 MyBatis-Spring-Boot-Starter 版本：2.1.4 该系列其他文档请查看：《 MyBatis 系列 - 导读》 一、MyBatis的初始化 在My
Mybatis3源码分析(13)-Sql解析执行-BoundSql的加载-2
ashan
12-22 2173
前面分析到SqlNode.apply()后，Sql还是个半成口。只处理了"${}"这种占位符，"#{}"这种占位符还没有处理，而且Sql执行时的参数也没有生成。 再来看DynamicSqlSource.getBoundSql()方法 public BoundSql getBoundSql(Object parameterObject) { DynamicContext con
MyBatis源码解析--加载流程（1）
jacobbbbbbbb的博客
06-14 222
分析完11个提供支持的模块，接下来就完整地debug一遍加载的流程。 首先看下简单的流程： 1.初始化会加载mybatis-config.xml配置文件、mapper映射配置文件以及Mapper接口中的注解信息，这些信息都会形成相应的对象并保存到Configuration中。 2.利用Configuration创建SqlSessionFactory对象。 3.通过SqlSessionFactory创建SqlSession对象进行相关的数据库操作。 那么首先就从加载mybatis-config.xml文件开始
Mybatis源码解析之SpringBoot集成mybatis-spring-boot-starter分析
翻身已碰头的博客
03-28 1万+
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 Mybatis源码解析之数据库连接和连接池 Mybatis源码解析之事务管理 Mybatis源码解析之缓存机制（一）：一级缓存 Mybatis源码解析之缓存机制（二）：二级缓存 Mybatis源码解析之插件机制 Mybatis源码解析之mapper接口的代理模式 Mybatis源码解析之D...
MyBatis源码解析--加载流程（7）
jacobbbbbbbb的博客
06-26 114
SimpleExecutor 前面已经介绍了BaseExecutor，是Executor接口的直接继承，作用是提供模版，为它的继承类可以直接继承方法，其中SimpleExecutor会不需要关心一级缓存的问题，只要实现四个基本方法就可以。 public class SimpleExecutor extends BaseExecutor { public SimpleExecutor(Configuration configuration, Transaction transaction) {
Mybatis源码分析-上课笔记1
08-03
在分析MyBatis源码时，可以采用宏观和微观两种视角。宏观上理解整个框架的架构和流程，微观上深入到具体的类和方法，通过阅读和调试代码来理解其实现细节。同时，绘制流程图或UML图能帮助更好地梳理组件间的交互。 ...
mybatis-3-mybatis-3.5.4-src-read.zip
04-28
在本压缩包“mybatis-3-mybatis-3.5.4-src-read.zip”中，包含了作者对MyBatis 3.5.4版本源码的阅读理解，特别进行了关键部分的注解和流程解析，对于学习和深入理解MyBatis的工作原理非常有帮助。 1. **MyBatis架构...
struts2对Ognl的封装--ClassResolver
java12345678
03-19 279
Ognl的扩展点： http://java12345678.iteye.com/blog/2031790   OGNL ClassResolver接口 :     用于由类名到类路径中找到Class文件，并加载生成Class对象，以支持静态属性或方法的调用 Struts对ClassResolver 的扩展：     Struts中ClassResolver的加载：   Ognl...
MyBatis源码简读——2.2 SQL的解析
大风的博客
04-21 314
SQL初始化被分为主要几个内容 SQL初始化以LanguageDriver接口为主要内容，以获得SqlSource为结束。主要涉及到的几个内容为 LanguageDriver 语言驱动 XMLScriptBuilder SqlSource的构造器 LanguageDriverRegistry 注册表 NodeHandler 节点处理 DynamicContext 动态环境上下文 SqlNod...
精通Mybatis之动态sql全流程解析
a1032722788的博客
05-14 590
前言 小编的精通mybatis之讲解就快结束了，希望大家坚持不懈坚持到底了。好了进入今天的正题，动态sql全流程。 动态Sql定义 动态SQL是MyBatis 强大功能之一，他免除了在JAVA代码中拼装SQL字符串麻烦，同时保留了我们对SQL的自主控制，更方便进行SQL性能优化改造。这也是大部分的编程伙伴喜欢用mybatis的原因。 对动态sql的使用大家应该很熟悉了吧，如果有需要大家可以看官网使用动态 SQL。首先小编带大家看下sql脚本元素： 如果你之前用过 JSTL 或任何基于类 XML 语言的文本
MyBatis if 标签的坑，居然被我踩到了。。。
架构文摘
12-09 645
事件的原因是这样的，需求是按条件查数据然后给前端展示就行了，写的时候想着挺简单的，不就是使用 MyBatis 动态 SQL 去查询数据吗？ 现实还是很残酷的，等我写完上完 UAT 后，前端同学说根据state查的数据与理想的数据不一致，这个state当时设计时只有两个值：0和1。 /** * 数据状态 */ @Range(min = 0, max = 1, message = "状态只能为0（未处理），1（已处理）") private Integer state; 理想情况下通过前端传递过来的值，然
Ognl的扩展
java12345678
03-16 261
OGNL提供的扩展方式，见官网:http://commons.apache.org/proper/commons-ognl/developer-guide.html   一、PropertyAccessor:提供了对属性赋值和提取属性值的方法。                              因为不同的类的获取属性值和赋值方式不同，如Map、List、javabean，因此有多...
Mybatis动态元素if使用
7me
07-22 1743
Mybatis动态元素if遇到0时出现问题
第08篇:Mybatis事务处理
西魏陶渊明的博客
07-12 1472
一、Jdk底层实现 Java JDK中提供了标准接口Connection,不同的数据库驱动负责具体的实现。后面无论是Spring还是Mybatis对事务的处理，无论怎么的封装,最终究其到底都是由Connection来提供的能力。 public interface Connection  extends Wrapper, AutoCloseable {    Statement create
《Mybatis源码》第14章 LanguageDriver
迦南学院
11-25 1008
总结 LanguageDriver借助XMLScriptBuilder解析标签，创建SqlSource XMLScriptBuilder负责解析XML标签，也就是这里负责解析，封装成SqlNode，然后在调用的时候，再根据参数解析，拼接成最后的SQL 引入 在执行器执行query()方法的时候，会直接在MappedStatement里面获取BoundSql @Override public <E> List<E> query(MappedStatement ms, Obj
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值