落地生涯
落地生涯

MyBatis配置源码浅析

配置源码

1. SqlSessionFactoryBuilder
下面是SqlSessionFactoryBuilder通过配置文件的Reader生成SqlSessionFactory的方法。

public class SqlSessionFactoryBuilder {

    //Reader读取mybatis配置文件，传入构造方法
    //除了Reader外，其实还有对应的inputStream作为参数的构造方法，
    //这也体现了mybatis配置的灵活性
    public SqlSessionFactory build(Reader reader) {
        return build(reader, null, null);
    }

    public SqlSessionFactory build(Reader reader, String environment) {
        return build(reader, environment, null);
    }

    //mybatis配置文件 + properties, 此时mybatis配置文件中可以不配置properties，也能使用${}形式
    public SqlSessionFactory build(Reader reader, Properties properties) {
        return build(reader, null, properties);
    }

    //通过XMLConfigBuilder解析mybatis配置，然后创建SqlSessionFactory对象
    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
            //下面看看这个方法的源码
            return build(parser.parse());
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {
            ErrorContext.instance().reset();
            try {
                reader.close();
            } catch (IOException e) {
                // Intentionally ignore. Prefer previous error.
            }
        }
    }

    public SqlSessionFactory build(Configuration config) {
        return new DefaultSqlSessionFactory(config);
    }
}

通过以上源码，可以知道SqlSessionFactoryBuilder通过XMLConfigBuilder去解析传入的MyBatis的配置文件，下面就是XMLConfigBuilder部分源码：

/**
 * mybatis 配置文件解析
 */
public class XMLConfigBuilder extends BaseBuilder {
    public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
    }

    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        super(new Configuration());
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        this.parsed = false;
        this.environment = environment;
        this.parser = parser;
    }

    //外部调用此方法对mybatis配置文件进行解析
    public Configuration parse() {
        if (parsed) {
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        //从根节点configuration
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
    }

    //此方法就是解析configuration节点下的子节点
    //由此也可看出，我们在configuration下面能配置的节点为以下10个节点
    private void parseConfiguration(XNode root) {
        try {
            propertiesElement(root.evalNode("properties")); //issue #117 read properties first
            typeAliasesElement(root.evalNode("typeAliases"));
            pluginElement(root.evalNode("plugins"));
            objectFactoryElement(root.evalNode("objectFactory"));
            objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            settingsElement(root.evalNode("settings"));
            environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
            databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            typeHandlerElement(root.evalNode("typeHandlers"));
            mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
    }
}

通过源码可以看出：

  1. configuration节点为根节点。
  2. 在configuration节点下，可以配置10个子节点，分别为：properties、typeAliases、plugins、objectFactory、objectWrapperFactory、setting、environment、databaseIdProvider、typeHandlers、mappers。

2. 配置文件元素
2.1 properties

上面代码指出，可以指定外部的peoperties配置文件，也可以直接配置在xml中；如果两种都同时使用，那直接配置在xml的配置有限，外部指定的properties配置其次。
2.2 environments

environments元素可以配置多个environment子节点。
2.3 解析方法-propertiesElement、environmentsElement

public class XMLConfigBuilder extends BaseBuilder {

    private boolean parsed;
    // xml解析器
    private XPathParser parser;
    private String environment;

    // 上次说到这个方法是在解析mybatis配置文件中能配置的元素节点
    // 今天首先要看的就是properties节点和environments节点
    private void parseConfiguration(XNode root) {
        try {
            // 解析properties元素
            propertiesElement(root.evalNode("properties")); //issue #117 read properties first
            typeAliasesElement(root.evalNode("typeAliases"));
            pluginElement(root.evalNode("plugins"));
            objectFactoryElement(root.evalNode("objectFactory"));
            objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            settingsElement(root.evalNode("settings"));
            // 解析environments元素
            environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
            databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            typeHandlerElement(root.evalNode("typeHandlers"));
            mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
    }

    //下面就看看解析properties的具体方法
    private void propertiesElement(XNode context) throws Exception {
        if (context != null) {
            // 将子节点的 name 以及value属性set进properties对象
            // 这儿可以注意一下顺序，xml配置优先， 外部指定properties配置其次
            Properties defaults = context.getChildrenAsProperties();
            // 获取properties节点上 resource属性的值
            String resource = context.getStringAttribute("resource");
            // 获取properties节点上 url属性的值, resource和url不能同时配置
            String url = context.getStringAttribute("url");
            if (resource != null && url != null) {
                throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
            }
            // 把解析出的properties文件set进Properties对象
            if (resource != null) {
                defaults.putAll(Resources.getResourceAsProperties(resource));
            } else if (url != null) {
                defaults.putAll(Resources.getUrlAsProperties(url));
            }
            // 将configuration对象中已配置的Properties属性与刚刚解析的融合
            // configuration这个对象会装载所解析mybatis配置文件的所有节点元素，以后也会频频提到这个对象
            // 既然configuration对象用有一系列的get/set方法， 那是否就标志着我们可以使用java代码直接配置？ 
            // 答案是肯定的， 不过使用配置文件进行配置，优势不言而喻
            Properties vars = configuration.getVariables();
            if (vars != null) {
                defaults.putAll(vars);
            }
            // 把装有解析配置propertis对象set进解析器， 因为后面可能会用到
            parser.setVariables(defaults);
            // set进configuration对象
            configuration.setVariables(defaults);
        }
    }

    //下面再看看解析enviroments元素节点的方法
    private void environmentsElement(XNode context) throws Exception {
        if (context != null) {
            if (environment == null) {
                //解析environments节点的default属性的值
                //例如: 
                environment = context.getStringAttribute("default");
            }
            //递归解析environments子节点
            for (XNode child : context.getChildren()) {
                //, 只有enviroment节点有id属性，那么这个属性有何作用？
                //environments 节点下可以拥有多个 environment子节点
                //类似于这样： ......
                //意思就是我们可以对应多个环境，比如开发环境，测试环境等， 由environments的default属性去选择对应的enviroment
                String id = child.getStringAttribute("id");
                //isSpecial就是根据由environments的default属性去选择对应的enviroment
                if (isSpecifiedEnvironment(id)) {
                    //事务， mybatis有两种：JDBC 和 MANAGED, 配置为JDBC则直接使用JDBC的事务，配置为MANAGED则是将事务托管给容器， 
                    TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                    //enviroment节点下面就是dataSource节点了，解析dataSource节点（下面会贴出解析dataSource的具体方法）
                    DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                    DataSource dataSource = dsFactory.getDataSource();
                    Environment.Builder environmentBuilder = new Environment.Builder(id)
                          .transactionFactory(txFactory)
                          .dataSource(dataSource);
                    //老规矩，会将dataSource设置进configuration对象
                    configuration.setEnvironment(environmentBuilder.build());
                }
            }
        }
    }

    //下面看看dataSource的解析方法
    private DataSourceFactory dataSourceElement(XNode context) throws Exception {
        if (context != null) {
            //dataSource的连接池
            String type = context.getStringAttribute("type");
            //子节点 name, value属性set进一个properties对象
            Properties props = context.getChildrenAsProperties();
            //创建dataSourceFactory
            DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();
            factory.setProperties(props);
            return factory;
        }
        throw new BuilderException("Environment declaration requires a DataSourceFactory.");
    } 
}

以上代码是对environments和properties的解析；上面配置中有dataSource使用了${driver}这种表达式，下面就是通过PropertyParser来解析这种表达式：

/**
 * 这个类解析${}这种形式的表达式
 */
public class PropertyParser {

    public static String parse(String string, Properties variables) {
        VariableTokenHandler handler = new VariableTokenHandler(variables);
        GenericTokenParser parser = new GenericTokenParser("${", "}", handler);
        return parser.parse(string);
    }

    private static class VariableTokenHandler implements TokenHandler {
        private Properties variables;

        public VariableTokenHandler(Properties variables) {
            this.variables = variables;
        }

        public String handleToken(String content) {
            if (variables != null && variables.containsKey(content)) {
                return variables.getProperty(content);
            }
            return "${" + content + "}";
        }
    }
}

2.4 typeAliases
typeAliases节点主要用来设置别名。


    
        
        
    

    ......

2.5 解析方法-typeAliasesElement

/**
 * 解析typeAliases节点
 */
private void typeAliasesElement(XNode parent) {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            //如果子节点是package, 那么就获取package节点的name属性， mybatis会扫描指定的package
            if ("package".equals(child.getName())) {
                String typeAliasPackage = child.getStringAttribute("name");
                //TypeAliasRegistry 负责管理别名， 这儿就是通过TypeAliasRegistry 进行别名注册， 下面就会看看TypeAliasRegistry源码
                configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {
                //如果子节点是typeAlias节点，那么就获取alias属性和type的属性值
                String alias = child.getStringAttribute("alias");
                String type = child.getStringAttribute("type");
                try {
                    Class clazz = Resources.classForName(type);
                    if (alias == null) {
                        typeAliasRegistry.registerAlias(clazz);
                    } else {
                        typeAliasRegistry.registerAlias(alias, clazz);
                    }
                } catch (ClassNotFoundException e) {
                    throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
                }
            }
        }
    }
}

下面是TypeAliasRegistry.java的源码：

public class TypeAliasRegistry {

  //这就是核心所在啊， 原来别名就仅仅通过一个HashMap来实现， key为别名， value就是别名对应的类型（class对象）
  private final Map> TYPE_ALIASES = new HashMap>();

  /**
   * 以下就是mybatis默认为我们注册的别名
   */
  public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
  }

  /**
   * 处理别名， 直接从保存有别名的hashMap中取出即可
   */
  @SuppressWarnings("unchecked")
  public  Class resolveAlias(String string) {
    try {
      if (string == null) return null;
      String key = string.toLowerCase(Locale.ENGLISH); // issue #748
      Class value;
      if (TYPE_ALIASES.containsKey(key)) {
        value = (Class) TYPE_ALIASES.get(key);
      } else {
        value = (Class) Resources.classForName(string);
      }
      return value;
    } catch (ClassNotFoundException e) {
      throw new TypeException("Could not resolve type alias '" + string + "'.  Cause: " + e, e);
    }
  }

  /**
   * 配置文件中配置为package的时候， 会调用此方法，根据配置的报名去扫描javabean ，然后自动注册别名
   * 默认会使用 Bean 的首字母小写的非限定类名来作为它的别名
   * 也可在javabean 加上注解@Alias 来自定义别名， 例如： @Alias(user)
   */
  public void registerAliases(String packageName){
    registerAliases(packageName, Object.class);
  }

  public void registerAliases(String packageName, Class superType){
    ResolverUtil> resolverUtil = new ResolverUtil>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set>> typeSet = resolverUtil.getClasses();
    for(Class type : typeSet){
      // Ignore inner classes and interfaces (including package-info.java)
      // Skip also inner classes. See issue #6
      if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
        registerAlias(type);
      }
    }
  }

  public void registerAlias(Class type) {
    String alias = type.getSimpleName();
    Alias aliasAnnotation = type.getAnnotation(Alias.class);
    if (aliasAnnotation != null) {
      alias = aliasAnnotation.value();
    } 
    registerAlias(alias, type);
  }

  //这就是注册别名的本质方法， 其实就是向保存别名的hashMap新增值而已， 呵呵， 别名的实现太简单了，对吧
  public void registerAlias(String alias, Class value) {
    if (alias == null) throw new TypeException("The parameter alias cannot be null");
    String key = alias.toLowerCase(Locale.ENGLISH); // issue #748
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    TYPE_ALIASES.put(key, value);
  }

  public void registerAlias(String alias, String value) {
    try {
      registerAlias(alias, Resources.classForName(value));
    } catch (ClassNotFoundException e) {
      throw new TypeException("Error registering type alias "+alias+" for "+value+". Cause: " + e, e);
    }
  }

  /**
   * 获取保存别名的HashMap, Configuration对象持有对TypeAliasRegistry的引用，因此，如果需要，我们可以通过Configuration对象获取
   */
  public Map> getTypeAliases() {
    return Collections.unmodifiableMap(TYPE_ALIASES);
  }

}

2.6 TypeHandler
无论是MyBatis在预处理语句PreparedStatement中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成Java类型。MyBatis默认实现了很多TypeHanlder，当没有配置指定TypeHandler时，MyBatis会根据参数或者返回结果的不同，默认选择合适的TypeHandler处理。


    
      
      
      
      
      
      
      
      
      
  
  ......

2.7 解析方法-typeHandlerElement
解析xml：

/**
 * 解析typeHandlers节点
 */
private void typeHandlerElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        //子节点为package时，获取其name属性的值，然后自动扫描package下的自定义typeHandler
        if ("package".equals(child.getName())) {
          String typeHandlerPackage = child.getStringAttribute("name");
          typeHandlerRegistry.register(typeHandlerPackage);
        } else {
          //子节点为typeHandler时， 可以指定javaType属性， 也可以指定jdbcType, 也可两者都指定
          //javaType 是指定java类型
          //jdbcType 是指定jdbc类型（数据库类型： 如varchar）
          String javaTypeName = child.getStringAttribute("javaType");
          String jdbcTypeName = child.getStringAttribute("jdbcType");
          //handler就是我们配置的typeHandler
          String handlerTypeName = child.getStringAttribute("handler");
          //resolveClass方法就是我们上篇文章所讲的TypeAliasRegistry里面处理别名的方法
          Class javaTypeClass = resolveClass(javaTypeName);
          //JdbcType是一个枚举类型，resolveJdbcType方法是在获取枚举类型的值
          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
          Class typeHandlerClass = resolveClass(handlerTypeName);
          //注册typeHandler, typeHandler通过TypeHandlerRegistry这个类管理
          if (javaTypeClass != null) {
            if (jdbcType == null) {
              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
            } else {
              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
            }
          } else {
            typeHandlerRegistry.register(typeHandlerClass);
          }
        }
      }
    }
}

下面是TypeHandlerRegistry的源代码：

/**
 * typeHandler注册管理类
 */
public final class TypeHandlerRegistry {

  //源码一上来，二话不说，几个大大的HashMap就出现，这不又跟上次讲的typeAliases的注册类似么

  //基本数据类型与其包装类
  private static final Map, Class> reversePrimitiveMap = new HashMap, Class>() {
    private static final long serialVersionUID = 1L;
    {
      put(Byte.class, byte.class);
      put(Short.class, short.class);
      put(Integer.class, int.class);
      put(Long.class, long.class);
      put(Float.class, float.class);
      put(Double.class, double.class);
      put(Boolean.class, boolean.class);
      put(Character.class, char.class);
    }
  };

  //这几个MAP不用说就知道存的是什么东西吧，命名的好处
  private final Map> JDBC_TYPE_HANDLER_MAP = new EnumMap>(JdbcType.class);
  private final Map>> TYPE_HANDLER_MAP = new HashMap>>();
  private final TypeHandler UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);
  private final Map, TypeHandler> ALL_TYPE_HANDLERS_MAP = new HashMap, TypeHandler>();

  //就像上篇文章讲的typeAliases一样，mybatis也默认给我们注册了不少的typeHandler
  //具体如下
  public TypeHandlerRegistry() {
    register(Boolean.class, new BooleanTypeHandler());
    register(boolean.class, new BooleanTypeHandler());
    register(JdbcType.BOOLEAN, new BooleanTypeHandler());
    register(JdbcType.BIT, new BooleanTypeHandler());

    register(Byte.class, new ByteTypeHandler());
    register(byte.class, new ByteTypeHandler());
    register(JdbcType.TINYINT, new ByteTypeHandler());

    register(Short.class, new ShortTypeHandler());
    register(short.class, new ShortTypeHandler());
    register(JdbcType.SMALLINT, new ShortTypeHandler());

    register(Integer.class, new IntegerTypeHandler());
    register(int.class, new IntegerTypeHandler());
    register(JdbcType.INTEGER, new IntegerTypeHandler());

    register(Long.class, new LongTypeHandler());
    register(long.class, new LongTypeHandler());

    register(Float.class, new FloatTypeHandler());
    register(float.class, new FloatTypeHandler());
    register(JdbcType.FLOAT, new FloatTypeHandler());

    register(Double.class, new DoubleTypeHandler());
    register(double.class, new DoubleTypeHandler());
    register(JdbcType.DOUBLE, new DoubleTypeHandler());

    register(String.class, new StringTypeHandler());
    register(String.class, JdbcType.CHAR, new StringTypeHandler());
    register(String.class, JdbcType.CLOB, new ClobTypeHandler());
    register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
    register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());
    register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
    register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
    register(JdbcType.CHAR, new StringTypeHandler());
    register(JdbcType.VARCHAR, new StringTypeHandler());
    register(JdbcType.CLOB, new ClobTypeHandler());
    register(JdbcType.LONGVARCHAR, new ClobTypeHandler());
    register(JdbcType.NVARCHAR, new NStringTypeHandler());
    register(JdbcType.NCHAR, new NStringTypeHandler());
    register(JdbcType.NCLOB, new NClobTypeHandler());

    register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
    register(JdbcType.ARRAY, new ArrayTypeHandler());

    register(BigInteger.class, new BigIntegerTypeHandler());
    register(JdbcType.BIGINT, new LongTypeHandler());

    register(BigDecimal.class, new BigDecimalTypeHandler());
    register(JdbcType.REAL, new BigDecimalTypeHandler());
    register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
    register(JdbcType.NUMERIC, new BigDecimalTypeHandler());

    register(Byte[].class, new ByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
    register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
    register(byte[].class, new ByteArrayTypeHandler());
    register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
    register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
    register(JdbcType.BLOB, new BlobTypeHandler());

    register(Object.class, UNKNOWN_TYPE_HANDLER);
    register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
    register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);

    register(Date.class, new DateTypeHandler());
    register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
    register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
    register(JdbcType.TIMESTAMP, new DateTypeHandler());
    register(JdbcType.DATE, new DateOnlyTypeHandler());
    register(JdbcType.TIME, new TimeOnlyTypeHandler());

    register(java.sql.Date.class, new SqlDateTypeHandler());
    register(java.sql.Time.class, new SqlTimeTypeHandler());
    register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());

    // issue #273
    register(Character.class, new CharacterTypeHandler());
    register(char.class, new CharacterTypeHandler());
  }

  public boolean hasTypeHandler(Class javaType) {
    return hasTypeHandler(javaType, null);
  }

  public boolean hasTypeHandler(TypeReference javaTypeReference) {
    return hasTypeHandler(javaTypeReference, null);
  }

  public boolean hasTypeHandler(Class javaType, JdbcType jdbcType) {
    return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null;
  }

  public boolean hasTypeHandler(TypeReference javaTypeReference, JdbcType jdbcType) {
    return javaTypeReference != null && getTypeHandler(javaTypeReference, jdbcType) != null;
  }

  public TypeHandler getMappingTypeHandler(Class> handlerType) {
    return ALL_TYPE_HANDLERS_MAP.get(handlerType);
  }

  public  TypeHandler getTypeHandler(Class type) {
    return getTypeHandler((Type) type, null);
  }

  public  TypeHandler getTypeHandler(TypeReference javaTypeReference) {
    return getTypeHandler(javaTypeReference, null);
  }

  public TypeHandler getTypeHandler(JdbcType jdbcType) {
    return JDBC_TYPE_HANDLER_MAP.get(jdbcType);
  }

  public  TypeHandler getTypeHandler(Class type, JdbcType jdbcType) {
    return getTypeHandler((Type) type, jdbcType);
  }

  public  TypeHandler getTypeHandler(TypeReference javaTypeReference, JdbcType jdbcType) {
    return getTypeHandler(javaTypeReference.getRawType(), jdbcType);
  }

  private  TypeHandler getTypeHandler(Type type, JdbcType jdbcType) {
    Map> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
    TypeHandler handler = null;
    if (jdbcHandlerMap != null) {
      handler = jdbcHandlerMap.get(jdbcType);
      if (handler == null) {
        handler = jdbcHandlerMap.get(null);
      }
    }
    if (handler == null && type != null && type instanceof Class && Enum.class.isAssignableFrom((Class) type)) {
      handler = new EnumTypeHandler((Class) type);
    }
    @SuppressWarnings("unchecked")
    // type drives generics here
    TypeHandler returned = (TypeHandler) handler;
    return returned;
  }

  public TypeHandler getUnknownTypeHandler() {
    return UNKNOWN_TYPE_HANDLER;
  }

  public void register(JdbcType jdbcType, TypeHandler handler) {
    JDBC_TYPE_HANDLER_MAP.put(jdbcType, handler);
  }

  //
  // REGISTER INSTANCE
  //

  /**
   * 只配置了typeHandler, 没有配置jdbcType 或者javaType
   */
  @SuppressWarnings("unchecked")
  public  void register(TypeHandler typeHandler) {
    boolean mappedTypeFound = false;
    //在自定义typeHandler的时候，可以加上注解MappedTypes 去指定关联的javaType
    //因此，此处需要扫描MappedTypes注解
    MappedTypes mappedTypes = typeHandler.getClass().getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class handledType : mappedTypes.value()) {
        register(handledType, typeHandler);
        mappedTypeFound = true;
      }
    }
    // @since 3.1.0 - try to auto-discover the mapped type
    if (!mappedTypeFound && typeHandler instanceof TypeReference) {
      try {
        TypeReference typeReference = (TypeReference) typeHandler;
        register(typeReference.getRawType(), typeHandler);
        mappedTypeFound = true;
      } catch (Throwable t) {
        // maybe users define the TypeReference with a different type and are not assignable, so just ignore it
      }
    }
    if (!mappedTypeFound) {
      register((Class) null, typeHandler);
    }
  }

  /**
   * 配置了typeHandlerhe和javaType
   */
  public  void register(Class javaType, TypeHandler typeHandler) {
    register((Type) javaType, typeHandler);
  }

  private  void register(Type javaType, TypeHandler typeHandler) {
    //扫描注解MappedJdbcTypes
    MappedJdbcTypes mappedJdbcTypes = typeHandler.getClass().getAnnotation(MappedJdbcTypes.class);
    if (mappedJdbcTypes != null) {
      for (JdbcType handledJdbcType : mappedJdbcTypes.value()) {
        register(javaType, handledJdbcType, typeHandler);
      }
      if (mappedJdbcTypes.includeNullJdbcType()) {
        register(javaType, null, typeHandler);
      }
    } else {
      register(javaType, null, typeHandler);
    }
  }

  public  void register(TypeReference javaTypeReference, TypeHandler handler) {
    register(javaTypeReference.getRawType(), handler);
  }

  /**
   * typeHandlerhe、javaType、jdbcType都配置了
   */
  public  void register(Class type, JdbcType jdbcType, TypeHandler handler) {
    register((Type) type, jdbcType, handler);
  }

  /**
   * 注册typeHandler的核心方法
   * 就是向Map新增数据而已
   */
  private void register(Type javaType, JdbcType jdbcType, TypeHandler handler) {
    if (javaType != null) {
      Map> map = TYPE_HANDLER_MAP.get(javaType);
      if (map == null) {
        map = new HashMap>();
        TYPE_HANDLER_MAP.put(javaType, map);
      }
      map.put(jdbcType, handler);
      if (reversePrimitiveMap.containsKey(javaType)) {
        register(reversePrimitiveMap.get(javaType), jdbcType, handler);
      }
    }
    ALL_TYPE_HANDLERS_MAP.put(handler.getClass(), handler);
  }

  //
  // REGISTER CLASS
  //

  // Only handler type

  public void register(Class typeHandlerClass) {
    boolean mappedTypeFound = false;
    MappedTypes mappedTypes = typeHandlerClass.getAnnotation(MappedTypes.class);
    if (mappedTypes != null) {
      for (Class javaTypeClass : mappedTypes.value()) {
        register(javaTypeClass, typeHandlerClass);
        mappedTypeFound = true;
      }
    }
    if (!mappedTypeFound) {
      register(getInstance(null, typeHandlerClass));
    }
  }

  // java type + handler type

  public void register(Class javaTypeClass, Class typeHandlerClass) {
    register(javaTypeClass, getInstance(javaTypeClass, typeHandlerClass));
  }

  // java type + jdbc type + handler type

  public void register(Class javaTypeClass, JdbcType jdbcType, Class typeHandlerClass) {
    register(javaTypeClass, jdbcType, getInstance(javaTypeClass, typeHandlerClass));
  }

  // Construct a handler (used also from Builders)

  @SuppressWarnings("unchecked")
  public  TypeHandler getInstance(Class javaTypeClass, Class typeHandlerClass) {
    if (javaTypeClass != null) {
      try {
        Constructor c = typeHandlerClass.getConstructor(Class.class);
        return (TypeHandler) c.newInstance(javaTypeClass);
      } catch (NoSuchMethodException ignored) {
        // ignored
      } catch (Exception e) {
        throw new TypeException("Failed invoking constructor for handler " + typeHandlerClass, e);
      }
    }
    try {
      Constructor c = typeHandlerClass.getConstructor();
      return (TypeHandler) c.newInstance();
    } catch (Exception e) {
      throw new TypeException("Unable to find a usable constructor for " + typeHandlerClass, e);
    }
  }

  /**
   * 根据指定的pacakge去扫描自定义的typeHander，然后注册
   */
  public void register(String packageName) {
    ResolverUtil> resolverUtil = new ResolverUtil>();
    resolverUtil.find(new ResolverUtil.IsA(TypeHandler.class), packageName);
    Set>> handlerSet = resolverUtil.getClasses();
    for (Class type : handlerSet) {
      //Ignore inner classes and interfaces (including package-info.java) and abstract classes
      if (!type.isAnonymousClass() && !type.isInterface() && !Modifier.isAbstract(type.getModifiers())) {
        register(type);
      }
    }
  }

  // get information

  /**
   * 通过configuration对象可以获取已注册的所有typeHandler
   */
  public Collection> getTypeHandlers() {
    return Collections.unmodifiableCollection(ALL_TYPE_HANDLERS_MAP.values());
  }
}
 
 
MyBatis实现了那么多TypeHandler, 它继承自一个抽象类：BaseTypeHandler， 可以通过继承BaseTypeHandler，实现自定义的TypeHandler 。
 
 
@MappedJdbcTypes(JdbcType.VARCHAR)  
//此处如果不用注解指定jdbcType, 那么，就可以在配置文件中通过"jdbcType"属性指定， 同理， javaType 也可通过 @MappedTypes指定
public class ExampleTypeHandler extends BaseTypeHandler {

  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
    ps.setString(i, parameter);
  }

  @Override
  public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
    return rs.getString(columnName);
  }

  @Override
  public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    return rs.getString(columnIndex);
  }

  @Override
  public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    return cs.getString(columnIndex);
  }
}

 
 
然后需要将自定义的TypeHandler进行配置：
 
 

  
      
      
  
  ......


 
 
在自定义TypEHandler的时候，可以在TypeHandler通过@MappedJdbcTypes指定JdbcType，通过@MappedTypes指定JavaType，如果没有使用注解指定，那么就需要在配置文件中配置。详见MyBatis类型转换介绍
 2.8 objectFactory
 MyBatis每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。默认情况下，不需要多余配置，MyBatis会调用默认实现的ObjectFactory，除非要自定义ObjectFactory的实现，就需要手动配置。
 自定义ObjectFactory只需要继承DefaultObjectFactory，并重写其方法。
 然后进行如下配置：
 
 

    ......
    
        
    
    ......


 
 
2.9 plugins
 MyBatis中的plugin其实就是一个interceptor，它可以拦截Executor，ParameterHandler、ResultSetHandler、StatementHandler的部分方法，处理自己的逻辑。
 
 

    ......
    
      
        
      
    
    ......


 
 
2.10 mappers
 mappers 节点下，配置的mapper映射文件， 所谓的mapper映射文件，就是让mybatis 用来建立数据表和javabean映射的一个桥梁。在实际开发中，通常一个mapper文件对应一个dao接口， 这个mapper可以看做是dao的实现。所以mappers必须配置。
 
 

    ......
    
        
        

        

        
        
    
    ......


 
 
2.11 解析方法-objectFactoryElement、pluginElement、mapperElement
 这几个节点的源码解析，和之前的节点解析类似。
 
 
/**
 * objectFactory 节点解析
 */
private void objectFactoryElement(XNode context) throws Exception {
    if (context != null) {
      //读取type属性的值， 接下来进行实例化ObjectFactory, 并set进 configuration
      //到此，简单讲一下configuration这个对象，其实它里面主要保存的都是mybatis的配置
      String type = context.getStringAttribute("type");
      //读取propertie的值， 根据需要可以配置， mybatis默认实现的objectFactory没有使用properties
      Properties properties = context.getChildrenAsProperties();

      ObjectFactory factory = (ObjectFactory) resolveClass(type).newInstance();
      factory.setProperties(properties);
      configuration.setObjectFactory(factory);
    }
 }

  /**
   * plugins 节点解析
   */
  private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();
        //由此可见，我们在定义一个interceptor的时候，需要去实现Interceptor, 这儿先不具体讲，以后会详细讲解
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        interceptorInstance.setProperties(properties);
        configuration.addInterceptor(interceptorInstance);
      }
    }
  }

  /**
   * mappers 节点解析
   * 这是mybatis的核心之一，这儿先简单介绍，在接下来的文章会对它进行分析
   */
  private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          //如果mappers节点的子节点是package, 那么就扫描package下的文件, 注入进configuration
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          //resource, url, class 三选一

          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //mapper映射文件都是通过XMLMapperBuilder解析
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            Class mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }

 
 
2.12 settings
 
 
 
     
     
     
     
     
     
     
     


 
 
setting节点的配置的值会直接该写Configuration对应的变量值，这些变量描述的是MyBatis的全局运行方式。
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    setting说明 
  
 
 
 
 
 
 
2.13 解析方法-settingElement
 
 
private void settingsElement(XNode context) throws Exception {
    if (context != null) {
      Properties props = context.getChildrenAsProperties();
      // Check that all settings are known to the configuration class
      MetaClass metaConfig = MetaClass.forClass(Configuration.class);
      for (Object key : props.keySet()) {
        if (!metaConfig.hasSetter(String.valueOf(key))) {
          throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
        }
      }
      configuration.setAutoMappingBehavior(AutoMappingBehavior.valueOf(props.getProperty("autoMappingBehavior", "PARTIAL")));
      configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
      configuration.setProxyFactory((ProxyFactory) createInstance(props.getProperty("proxyFactory")));
      configuration.setLazyLoadingEnabled(booleanValueOf(props.getProperty("lazyLoadingEnabled"), false));
      configuration.setAggressiveLazyLoading(booleanValueOf(props.getProperty("aggressiveLazyLoading"), true));
      configuration.setMultipleResultSetsEnabled(booleanValueOf(props.getProperty("multipleResultSetsEnabled"), true));
      configuration.setUseColumnLabel(booleanValueOf(props.getProperty("useColumnLabel"), true));
      configuration.setUseGeneratedKeys(booleanValueOf(props.getProperty("useGeneratedKeys"), false));
      configuration.setDefaultExecutorType(ExecutorType.valueOf(props.getProperty("defaultExecutorType", "SIMPLE")));
      configuration.setDefaultStatementTimeout(integerValueOf(props.getProperty("defaultStatementTimeout"), null));
      configuration.setMapUnderscoreToCamelCase(booleanValueOf(props.getProperty("mapUnderscoreToCamelCase"), false));
      configuration.setSafeRowBoundsEnabled(booleanValueOf(props.getProperty("safeRowBoundsEnabled"), false));
      configuration.setLocalCacheScope(LocalCacheScope.valueOf(props.getProperty("localCacheScope", "SESSION")));
      configuration.setJdbcTypeForNull(JdbcType.valueOf(props.getProperty("jdbcTypeForNull", "OTHER")));
      configuration.setLazyLoadTriggerMethods(stringSetValueOf(props.getProperty("lazyLoadTriggerMethods"), "equals,clone,hashCode,toString"));
      configuration.setSafeResultHandlerEnabled(booleanValueOf(props.getProperty("safeResultHandlerEnabled"), true));
      configuration.setDefaultScriptingLanguage(resolveClass(props.getProperty("defaultScriptingLanguage")));
      configuration.setCallSettersOnNulls(booleanValueOf(props.getProperty("callSettersOnNulls"), false));
      configuration.setLogPrefix(props.getProperty("logPrefix"));
      configuration.setLogImpl(resolveClass(props.getProperty("logImpl")));
      configuration.setConfigurationFactory(resolveClass(props.getProperty("configurationFactory")));
    }
  }

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(MyBatis配置源码浅析)

        

            

                
    
                    
  • IK分词
                        初心myp

                        
    实现简单的分词功能，智能化分词添加依赖配置：4.10.4org.apache.lucenelucene-core${lucene.version}org.apache.lucenelucene-analyzers-common${lucene.version}org.apache.lucenelucene-queryparser${lucene.version}org.apache.lucenel
    
                    
    • 
                    
  • SpringMVC执行流程（原理），通俗易懂
                        国服冰
SpringMVCspringmvc
                        
    SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
    
                    
    • 
                    
  • Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
                        倾听铃的声
后端springjavamvc开发语言分布式
                        
    前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
    
                    
    • 
                    
  • Linux系统配置（应用程序）
                        1风天云月
Linuxlinux应用程序编译安装rpmhttp
                        
    目录前言一、应用程序概述1、命令与程序的关系2、程序的组成3、软件包封装类型二、RPM1、RPM概述2、RPM用法三、编译安装1、解包2、配置3、编译4、安装5、启用httpd服务结语前言在Linux中的应用程序被视为将软件包安装到系统中后产生的各种文档，其中包括可执行文件、配置文件、用户手册等内容，这些文档被组织为一个有机的整体，为用户提供特定的功能，因此对于“安装软件包”与“安装应用程序”这两
    
                    
    • 
                    
  • 车载诊断架构 --- 关于诊断时间参数P4的浅析
                        汽车电子实验室
车载电子电气架构漫谈UDS诊断协议系列架构开发语言关于网关转发性能引起的思考汽车中央控制单元HPC软件架构车载诊断进阶篇
                        
    关于诊断时间参数P4的浅析我是穿拖鞋的汉子，魔都中坚持长期主义的汽车电子工程师。老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师：所谓鸡汤，要么蛊惑你认命，要么怂恿你拼命，但都是回避问题的根源，以现象替代逻辑，以情绪代替思考，把消极接受现实的懦弱，伪装成乐观面对不幸的豁达，往不幸上面喷“香水”来掩盖问题。无人问津也好,技不如人也罢,你都要试着安静下来,去做自己该做的事.而不是让内心的烦
    
                    
    • 
                    
  • LVS+Keepalived实现高可用和负载均衡
                        2401_84412895
程序员lvs负载均衡运维
                        
    2、开启网卡子接口配置VIP[root@a~]#cd/etc/sysconfig/network-scripts/[root@anetwork-scripts]#cp-aifcfg-ens32ifcfg-ens32:0[root@anetwork-scripts]#catifcfg-ens32:0BOOTPROTO=staticDEVICE=ens32:0ONBOOT=yesIPADDR=10.1
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • uniapp微信小程序 - 详解微信小程序平台用户授权登录全流程，uniapp v3版本中小程序端开发下用户点击登录后获取手机号/昵称/性别/头像等信息完成登录（提供完整示例代码，一键复制开箱即用）
                        十一猫咪爱养鱼
前端组件与功能(开箱即用)uniapp常见问题解决uniappvue3uniapp3小程序授权登录微信小程序登录获取用户信息教程获取用户昵称手机号头像信息登录vue3版本小程序平台授权登录uniap小程序端用户登录流程uni完整的小程序平台登录源码
                        
    效果图在uniapp微信小程序端开发中，超详细实现用户授权登录完整功能源码，用户授权后获取手机号/昵称/头像/性别等，提供完整思路流程及逻辑讲解。uniappVue3和Vue2都能用，你也可以直接复制粘贴，然后改下参数放到你的项目中去就行。整体思路做功能之前，先来看一下整体流程是
    
                    
    • 
                    
  • 【Coze搞钱实战】3. 避坑指南：对话流设计中的6个致命错误（真实案例）
                        AI_DL_CODE
Coze平台对话流设计客服Bot避坑用户流失封号风险智能客服配置故障修复指南
                        
    摘要：对话流设计是智能客服Bot能否落地的核心环节，直接影响用户体验与业务安全。本文基于50+企业Bot部署故障分析，聚焦导致用户流失、投诉甚至封号的6大致命错误：无限循环追问、人工移交超时、敏感词过滤缺失、知识库冲突、未处理否定意图、跨平台适配失败。通过真实案例拆解每个错误的表现形式、技术根因及工业级解决方案，提供可直接复用的Coze配置代码、工作流模板和检测工具。文中包含对话流健康度检测工具使
    
                    
    • 
                    
  • Pktgen-DPDK：开源网络测试工具的深度解析与应用
                        艾古力斯

                        
    本文还有配套的精品资源，点击获取简介：Pktgen-DPDK是基于DPDK的高性能流量生成工具，适用于网络性能测试、硬件验证及协议栈开发。它支持多种网络协议，能够模拟高吞吐量的数据包发送。本项目通过利用DPDK的高速数据包处理能力，允许用户自定义数据包内容，并实现高效的数据包管理与传输。文章将指导如何安装DPDK、编译Pktgen、配置工具以及使用方法，最终帮助开发者和网络管理员深入理解并优化网络
    
                    
    • 
                    
  • 环境搭建 | Python + Anaconda / Miniconda + PyCharm 的安装、配置与使用
                        

                        
    本文将分别介绍Python、Anaconda/Miniconda、PyCharm的安装、配置与使用，详细介绍Python环境搭建的全过程，涵盖Python、Pip、PythonLauncher、Anaconda、Miniconda、Pycharm等内容，以官方文档为参照，使用经验为补充，内容全面而详实。由于图片太多，就先贴一个无图简化版吧，详情请查看Python+Anaconda/Minicond
    
                    
    • 
                    
  • MySQL复习题
                        

                        
    一.填空题1.关系数据库的标准语言是SQL。2.数据库发展的3个阶段中，数据独立性最高的是阶段数据库系统。3.概念模型中的3种基本联系分别是一对一、一对多和多对多。4.MySQL配置文件的文件名是my.ini或my.cnf。5.在MySQL配置文件中，datadir用于指定数据库文件的保存目录。6.添加IFNOTEXISTS可在创建的数据库已存在时防止程序报错。7.MySQL提供的SHOWCREA
    
                    
    • 
                    
  • [spring6: Mvc-网关]-源码解析
                        

                        
    推荐阅读：[spring6:Mvc-函数式编程]-源码解析GatewayServerMvcAutoConfiguration@AutoConfiguration(after={HttpClientAutoConfiguration.class,RestTemplateAutoConfiguration.class,RestClientAutoConfiguration.class,FilterAu
    
                    
    • 
                    
  • centos7安装配置 Anaconda3
                        

                        
    Anaconda是一个用于科学计算的Python发行版,Anaconda于Python，相当于centos于linux。下载[root@testsrc]#mwgethttps://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-5.2.0-Linux-x86_64.shBegintodownload:Anaconda3-5.2.0-L
    
                    
    • 
                    
  • qemu virt-manager 创建虚拟机设置虚拟机桥接网络
                        三希
网络php开发语言
                        
    在virt-manager中设置虚拟机桥接网络的步骤如下：确认主机网络桥接已配置打开终端，执行brctlshow命令查看是否已有桥接接口（通常名为br0或类似名称）如果没有桥接接口，需先创建：sudonano/etc/netplan/01-netcfg.yaml添加类似以下配置（根据实际网卡调整）：yamlnetwork:version:2renderer:networkdethernets:en
    
                    
    • 
                    
  • ubuntu 查看防火墙 相关操作
                        三希
windows
                        
    在Ubuntu系统里，查看防火墙状态和配置主要借助ufw（UncomplicatedFirewall）工具，它是Ubuntu默认的防火墙配置界面。下面为你介绍常用的查看命令：一、查看防火墙状态要查看防火墙是否处于运行状态，可以使用以下命令：bashsudoufwstatus或者使用更详细的版本：bashsudoufwstatusverbose输出结果里，Status:active意味着防火墙正在运
    
                    
    • 
                    
  • 新手如何通过github pages静态网站托管搭建个人网站和项目站点
                        vvandre
Web技术github
                        
    一、githubpages静态网站托管介绍githubpages它是一个免费快捷的静态网站托管服务。对比传统建站，它有哪些优点呢？在传统方式中，首先要租用服务器，服务器上需要运行外部程序，还需要再购买域名，要配置SSL证书，最后还要配置DNS，将域名解析到服务器。这一套繁琐操作，基本上就把小白劝退了。graphTDA[租用服务器]-->B[部署Web应用(运行外部程序，如Nginx)]B-->C[
    
                    
    • 
                    
  • mac os 10.9 mysql_MAC OSX 10.9 apache php mysql 环境配置
                        AY05
macos10.9mysql
                        
    ＃终端内运行sudoapachectlstart#启动Apachesudoapachectlrestart#重启Apachesudoapachectlstop#停止Apache＃配置Apachesudovi/private/etc/apache2/httpd.conf#将里面的这一行去掉前面的##LoadModulephp5_modulelibexec/apache2/libphp5.so＃配置P
    
                    
    • 
                    
  • 二级域名分发系统商业版全开源v3版
                        CloseAi论坛
程序源码二级域名分发系统商业版开源
                        
    介绍：名分发-快乐二级域名分发源码主要是二级域名分发网站源码，域名接口配置自己研究吧网盘下载地址：https://zijiewangpan.com/NbX6950sYLn图片：
    
                    
    • 
                    
  • 修改CentOS的SSH登录端口(22端口)
                        ❀͜͡傀儡师
centossshlinux
                        
    要修改CentOS系统的SSH服务默认端口(22端口)，请按照以下步骤操作：备份SSH配置文件sudocp/etc/ssh/sshd_config/etc/ssh/sshd_config.bak编辑SSH配置文件sudovi/etc/ssh/sshd_config查找并修改端口设置找到以下行(大约在第13行左右)：#Port22取消注释并添加新端口(例如使用56001)：#Port22Port56
    
                    
    • 
                    
  • 二级域名分发网站源码 商业版全开源
                        lskelasi
程序源码二级域名分发源码二级域名分发网站源码源码
                        
    介绍：快乐二级域名分发-快乐二级域名分发源码主要是二级域名分发网站源码，不懂的不要下载了。本套源码可设置收费使用，有充值接口，域名接口配置自己研究吧网盘下载地址：https://zijiewangpan.com/jsX0JAuRE01图片：
    
                    
    • 
                    
  • 最新二级域名分发系统网站源码 可商用
                        huihuixxx
程序源码小鬼授权系统源码全解密源码授权代码二级域名分发系统网站源码
                        
    介绍：1.源码楼主网上买的没有后门是旧版本2.支付接口调用的是码支付来进行的3.支付接口需要登陆管理员后台安装4.支付接口必须信息正确只能装一次5.在线充值默认的充值比例是1：1【搭建教程】1.把源码上传主机并解压2.绑定根目录和域名并解析3.访问你的域名即可提示安装4.后台登陆地址：你的域名/admin5.登陆后台安装你的支付接口（需要的话）6.码支付怎么使用方法百度一下！网盘下载地址：http
    
                    
    • 
                    
  • 微服务日志追踪，Skywalking接入TraceId功能
                        Victor刘
微服务skywalkingjava
                        
    文章目录一、借助skywalking追加traceIdlogbacklog4j2效果二、让skywalking显示日志内容版本差异logback配置文件log4j2配置文件一、借助skywalking追加traceId背景：在微服务或多副本中难以观察一个链路的日志，需要通过唯一traceId标识来查找，下面介绍Skywalking-traceId在Java中的配置方法。介绍两种java日志的配置方
    
                    
    • 
                    
  • 探索高效文档转换新路径：Aspose.Words v18.7助力Word无缝变PDF
                        邴卉露Robust

                        
    探索高效文档转换新路径：Aspose.Wordsv18.7助力Word无缝变PDF【下载地址】Aspose.Wordsv18.7C示例源码Word转PDF无需安装Office本仓库提供了一个使用Aspose.Wordsv18.7将Word文档转换为PDF文档的C#示例源码。Aspose.Words是一个强大的.NET控件，允许开发者在不安装MicrosoftOffice的情况下读写Word文档，并
    
                    
    • 
                    
  • 全局修改GitLab14默认语言为中文
                        

                        
    GitLab安装成功后默认语言是英语，只有登录后才能手动指定为中文，且这个配置只对自己生效，经查阅资料后，总结全局修改GitLab14默认语言为中文方法如下：0.进入容器如果你用Docker部署的GitLab，那么需要使用命令sudodockerexec-itgitlab/bin/bash进入容器1.修改rails配置文件打开/opt/gitlab/embedded/service/gitlab-
    
                    
    • 
                    
  • Charles 配置 https
                        Monkey_猿
httpCharles配置https
                        
    Charles一.Iphone(MAC版;win可参照使用):首先，对Charles进行配置：菜单：Proxy->ProxySettings...->勾选EnabletransparentHTTPproxyingProxy->ProxySettings然后找到电脑的局域网IP地址：这里自己去找吧接着，打开你的iPhone：设置->Wifi->连接上和电脑同一路由器的Wifi，点击右边的i进入配置配
    
                    
    • 
                    
  • Claude Code 超详细完整指南（2025最新版）
                        笙囧同学
python
                        
    终端AI编程助手|高频使用点+生态工具+完整命令参考+最新MCP配置目录快速开始（5分钟上手）详细安装指南系统要求Windows安装（WSL方案）macOS安装Linux安装安装验证配置与认证首次认证环境变量配置代理配置⚡基础命令详解启动命令会话管理文件操作Think模式完全指南MCP服务器配置详解MCP基础概念添加MCP服务器10个必备MCP服务器MCP故障排除记忆系统详解高级使用技巧成本控制策
    
                    
    • 
                    
  • qt报错说no suitable kits found
                        

                        
    看起来你的QtCreator在试图找一个"kit"来编译你的程序,但是没有找到合适的kit.Kit是QtCreator中用来配置编译环境的一种东西,它包含了编译器、编译选项、以及所要使用的Qt库等信息.当QtCreator试图找一个kit来编译你的程序时,如果没有找到合适的kit,就会出现这个错误.要解决这个问题,你需要在QtCreator中配置一个合适的kit.具体来说,你需要安装Qt库和编译器
    
                    
    • 
                    
  • 彻底搞懂Cache-Control
                        qu木木
网络http缓存
                        
    文章目录一、是什么？二、核心作用三、指令详解（常用）四、常见场景配置示例五、重要注意事项一、是什么？Cache-Control是HTTP头部中最关键、最灵活的控制缓存的字段，用于定义在客户端（浏览器）和代理服务器（如CDN）上的缓存策略。它取代了HTTP/1.0时代较为简单的Expires和Pragma头部，提供了更精细的控制。二、核心作用是否缓存：明确支出响应是否可以缓存，以及可以被谁缓存（浏览
    
                    
    • 
                    
  • 001 Configuration结构体构造
                        盖世灬英雄z
DramSysc++人工智能
                        
    目录DramSys代码分析1Configuration结构体构造1.1`from_path`函数详解1.2构造过程总结这种设计的好处2Simulator例化过程2.1instantiateInitiatorDramSys代码分析1Configuration结构体构造好的，我们来详细解释一下DRAMSysConfiguration.cpp文件中from_path函数的配置构造过程。这个文件是DRAM
    
                    
    • 
                                
  • Linux的Initrd机制
                                    被触发
linux
                                    
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
    
                                
    • 
                                
  • maven本地仓库路径修改
                                    bitcarter
maven
                                    
    默认maven本地仓库路径：C:\Users\Administrator\.m2 
 
修改maven本地仓库路径方法： 
    
1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml 
    
2.找到 
       
    
                                
    • 
                                
  • XSD和XML中的命名空间
                                    darrenzhu
xmlxsdschemanamespace命名空间
                                    
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml 

http://blog.csdn.net/wanghuan203/article/details/9203621 

http://blog.csdn.net/wanghuan203/article/details/9204337 
 

http://www.cn
    
                                
    • 
                                
  • Java 求素数运算
                                    周凡杨
java算法素数
                                    
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。   
第一种：    
  
原理: 6N(+-)1法              任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)    
    
                                
    • 
                                
  • java 单例模式
                                    g21121
java
                                    
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式： 
  
class Singleton {
  private static Singleton instance=new Singleton();
  private Singleton(){}
  static Singleton getInstance() {
      return instance;
  }
    
                                
    • 
                                
  • Linux下Mysql源码安装
                                    510888780
mysql
                                    
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz 
 
(1)创建mysql的安装目录及数据库存放目录       
解压缩下载的源码包，目录结构，特殊指定的目录除外： 
          
    
                                
    • 
                                
  • 32位和64位操作系统
                                    墙头上一根草
32位和64位操作系统
                                    
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
    
                                
    • 
                                
  • 我的spring学习笔记10-轻量级_Spring框架
                                    aijuans
Spring 3
                                    
    一、问题提问： 
 
    → 请简单介绍一下什么是轻量级？ 
 
    轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。 
 
 
    
                                
    • 
                                
  • mongodb 环境搭建及简单CURD
                                    antlove
WebInstallcurdNoSQLmongo
                                    
    一 搭建mongodb环境 
1. 在mongo官网下载mongodb 
2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 
3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
    
                                
    • 
                                
  • 数据字典和动态视图
                                    百合不是茶
oracle数据字典动态视图系统和对象权限
                                    
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含 
  
 
 数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 
 数据库为一
    
                                
    • 
                                
  • 多线程编程一般规则
                                    bijian1013
javathread多线程java多线程
                                    
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。 
       不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。 

    
                                
    • 
                                
  • 将文件或目录拷贝到另一个Linux系统的命令scp
                                    bijian1013
linuxunixscp
                                    
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
    
                                
    • 
                                
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询
                                    bit1129
Mybatis3
                                    
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。 
  示例数据：
  
  
地址表： 
  
CREATE TABLE ADDRESSES 
(
  ADDR_ID INT(11) NOT NULL AUTO_INCREMENT,
  STREET VAR
    
                                
    • 
                                
  • cookie状态判断引发的查找问题
                                    bitcarter
formcgi
                                    
    先说一下我们的业务背景： 
1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 
2.form中action是一个cgi服务 
3.后台cgi服务同时供PC，H5，APP 
4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 
 
问题：（折腾两天。。。。） 
1.PC端cgi服务正常调用，cookie判断没
    
                                
    • 
                                
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时
                                    ronin47

                                    
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 
nginx.conf使用配置方式： 
log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
    
                                
    • 
                                
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。
                                    bylijinnan
java
                                    
    

public class ProbabilityOfDice {

	/**
	 * Q67 n个骰子的点数
	 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。
	 * 在以下求解过程中，我们把骰子看作是有序的。
	 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况
	 */
	private stati
    
                                
    • 
                                
  • 看别人的博客，觉得心情很好
                                    Cb123456
博客心情
                                    
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客: 
   职业规划: 
   http://www.iteye.com/blogs/subjects/zhiyeguihua 
  
   android学习: 
   1.http://byandby.i
    
                                
    • 
                                
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析
                                    comsci
工作流
                                    
     
    我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误 
 
     在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
    
                                
    • 
                                
  • JS常用的事件及方法
                                    cwqcwqmax9
js
                                    
    事件 描述 
onactivate 当对象设置为活动元素时触发。 
onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 
onbeforeactivate 对象要被设置为当前元素前立即触发。 
onbeforecut 当选中区从文档中删除之前在源对象触发。 
onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
    
                                
    • 
                                
  • 正则表达式验证日期格式
                                    dashuaifu
正则表达式IT其它java其它
                                    
                     正则表达式验证日期格式

function isDate(d){
 var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i);
 if(!v) {
  this.focus();
  return false;
 }
}
<input value="2000-8-8" onblu
    
                                
    • 
                                
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证
                                    dcj3sjt126com
yii
                                    
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation 
    
                                
    • 
                                
  • UITextAttributeTextColor = deprecated in iOS 7.0
                                    dcj3sjt126com
ios
                                    
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." 
Ins
    
                                
    • 
                                
  • 判断一个数是质数的几种方法
                                    EmmaZhao
Mathpython
                                    
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 
判断一个数是质数的最简单的方法如下： 
 

def isPrime1(n):
	for i in range(2, n):
		if n % i == 0:
			return False
	return True
 
但是在上面的方法中有一些冗余的计算，所以
    
                                
    • 
                                
  • SpringSecurity工作原理小解读
                                    坏我一锅粥
SpringSecurity
                                    
     
   SecurityContextPersistenceFilter 
   ConcurrentSessionFilter 
   WebAsyncManagerIntegrationFilter 
   HeaderWriterFilter 
   CsrfFilter 
   LogoutFilter 
   Use
    
                                
    • 
                                
  • JS实现自适应宽度的Tag切换
                                    ini
JavaScripthtmlWebcsshtml5
                                    
    效果体验：http://hovertree.com/texiao/js/3.htm 
  
该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 
HTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
    
                                
    • 
                                
  • Hbase Rest API : 数据查询
                                    kane_xie
RESThbase
                                    
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。 
  
启动命令：./bin/hbase rest s
    
                                
    • 
                                
  • JQuery实现鼠标拖动元素移动位置（源码+注释）
                                    明子健
jqueryjs源码拖动鼠标
                                    
    欢迎讨论指正！ 
  
print.html代码： 
<!DOCTYPE html>
<html>
<head>
<meta http-equiv=Content-Type content="text/html;charset=utf-8">
<title>发票打印</title>
&l
    
                                
    • 
                                
  • Postgresql 连表更新字段语法 update
                                    qifeifei
PostgreSQL
                                    
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： 
UPDATE tops_visa.visa_order
SET op_audit_abort_pass_date = now()
FROM
	tops_visa.visa_order as  t1
INNER JOIN tops_visa.visa_visitor as t2 
ON t1. 
    
                                
    • 
                                
  • 将redis,memcache结合使用的方案?
                                    tcrct
rediscache
                                    
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
    
                                
    • 
                                
  • 开发中遇到的诡异的bug
                                    wudixiaotie
bug
                                    
    今天我们服务器组遇到个问题： 
我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
    
                                
    •