`CollectionUtils.isEmpty()`、`MapUtils.isEmpty()` 和 `ArrayUtils.isEmpty()` 都是 Apache Commons Collections 库中的工具类方法，用于判断集合、映射或数组是否为空。  - `CollectionUtils.isEmpty(collection)`：用于判断一个集合（如 List、Set）是否为空。如果集合为 null 或者集合中没有任何元素，则返回 true；否则返回 false。 - `MapUtils.isEmpty(map)`：用于判断一个映射（如 Map）是否为空。如果映射为 null 或者映射中没有任何键值对，则返回 true；否则返回 false。 - `ArrayUtils.isEmpty(array)`：用于判断一个数组是否为空。如果数组为 null 或者数组长度为 0，则返回 true；否则返回 false。  这三个方法的区别在于它们分别针对不同类型的数据结构进行判空操作。你可以根据需要选择适合的方法来判断相应的数据结构是否为空。 

Java常用的判空函数有以下几种：使用==判断对象是否为null：if (object == null) { // do something }使用equals()方法判断字符串是否为null或空字符串：if (string == null || string.equals("")) { // do something }使用Objects.isNull()方法判断对象是否为null： ```java import java.util.Objects;if (Objects.isNull(object)) { // do something }4. 使用`StringUtils.isEmpty()`方法判断字符串是否为null或空字符串（需要引入Apache Commons Lang库）： ```java import org.apache.commons.lang3.StringUtils; if (StringUtils.isEmpty(string)) { // do something }

Object.isNull() 和 obj == null 的区别在于它们检查对象是否为空的方式不同。Object.isNull() 是一个静态方法，用于检查一个对象是否为 null。它接受一个参数，即要检查的对象。如果对象为 null，它将返回 true，否则返回 false。这个方法主要用于避免使用 == 操作符进行 null 检查时可能出现的类型转换问题。Object.isNull(null); // true Object.isNull(undefined); // false Object.isNull(""); // false Object.isNull(0); // false Object.isNull([]); // false Object.isNull({}); // false Object.isNull(true); // false Object.isNull(false); // falseobj == null 是一个比较操作符，用于检查一个对象是否等于 null。它同样接受一个参数，即要检查的对象。如果对象为 null，它将返回 true，否则返回 false。但是，当使用 == 操作符进行 null 检查时，可能会出现类型转换的问题。例如："" == null; // true，因为 "" 会被转换为 0，然后与 null 进行比较 0 == null; // true，因为 0 会被转换为字符串 "0"，然后与 null 进行比较 false == null; // true，因为 false 会被转换为数字 0，然后与 null 进行比较总结：Object.isNull() 和 obj == null 都可以用于检查对象是否为 null，但 Object.isNull() 可以避免类型转换的问题。在大多数情况下，建议使用 Object.isNull() 进行 null 检查。

 Java中使用List的流操作需要注意以下几点：  1. 性能问题：在使用流操作时，需要考虑到数据量的大小和处理方式对性能的影响。如果处理的数据量非常大，或者操作过程中创建了大量的临时对象，可能会导致性能下降或内存溢出等问题。因此，需要根据实际情况选择合适的操作方式和优化算法。  2. 异常处理：在使用流操作时，可能会出现各种异常情况，例如空指针异常、类型转换异常等。为了避免程序崩溃，需要在代码中添加适当的异常处理逻辑。  3. 并发问题：在使用流操作时，需要考虑多线程并发访问的问题。如果多个线程同时修改同一个List对象，可能会导致数据不一致或其他并发问题。因此，需要使用合适的同步机制来保证线程安全。  4. 代码可读性：在使用流操作时，需要遵循一定的编码规范和风格，以提高代码的可读性和可维护性。例如，可以使用Lambda表达式来简化代码，但需要注意不要过度使用Lambda表达式导致代码难以理解。  5. 兼容性问题：在使用流操作时，需要考虑不同版本的Java之间的兼容性问题。不同的Java版本可能对流操作的支持程度不同，因此需要根据实际情况选择合适的版本进行开发和测试。 

Java中List的常用流处理包括：过滤（filter）：根据给定的条件筛选出符合条件的元素。映射（map）：将列表中的每个元素转换为另一种形式。排序（sorted）：对列表中的元素进行排序。去重（distinct）：去除列表中的重复元素。收集（collect）：将流中的元素收集到一个新的集合中。以下是这些操作的示例代码：import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class ListStreamExample { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 过滤：筛选出偶数 List<Integer> evenNumbers = numbers.stream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); System.out.println("偶数：" + evenNumbers); // 映射：将每个数字乘以2 List<Integer> doubledNumbers = numbers.stream() .map(n -> n * 2) .collect(Collectors.toList()); System.out.println("每个数字乘以2：" + doubledNumbers); // 排序：从小到大排序 List<Integer> sortedNumbers = numbers.stream() .sorted() .collect(Collectors.toList()); System.out.println("从小到大排序：" + sortedNumbers); // 去重：去除重复元素 List<Integer> distinctNumbers = numbers.stream() .distinct() .collect(Collectors.toList()); System.out.println("去除重复元素：" + distinctNumbers); // 收集：将流中的元素收集到一个新的集合中 List<Integer> newList = numbers.stream() .collect(Collectors.toList()); System.out.println("新集合：" + newList); } }

 随着鸿蒙系统的愈发壮大，鸿蒙知识的学习也就变得越发迫切。本月给大家带来的技术干货合集就包括鸿蒙，spring，springboot，java,nginx,redis等众多内容，希望可以帮到大家。  1.Centos搭建KMS(vlmcsd)激活服务器的步骤【转】 https://bbs.huaweicloud.com/forum/thread-0251137381864278028-1-1.html  2.鸿蒙极速入门(一)-HarmonyOS简介 https://bbs.huaweicloud.com/forum/thread-0217137149871563005-1-1.html  3.鸿蒙极速入门(二)-开发准备和HelloWorld https://bbs.huaweicloud.com/forum/thread-0212137150055432004-1-1.html  4.鸿蒙极速入门(三)-TypeScript语言简介 https://bbs.huaweicloud.com/forum/thread-0217137150099699006-1-1.html  5.鸿蒙极速入门(四)-通过登录Demo了解ArkTS https://bbs.huaweicloud.com/forum/thread-0212137150569231005-1-1.html  6.鸿蒙极速入门(五)-路由管理（Router） https://bbs.huaweicloud.com/forum/thread-0217137150812608007-1-1.html      7.HarmonyOS 实战项目 https://bbs.huaweicloud.com/forum/thread-0298137147742910003-1-1.html  8.HarmonyOS 高级特性 https://bbs.huaweicloud.com/forum/thread-0263137147693666005-1-1.html  9.HarmonyOS应用开发 https://bbs.huaweicloud.com/forum/thread-02125137147620736007-1-1.html  10.HarmonyOS UI 开发 https://bbs.huaweicloud.com/forum/thread-0251137147552748004-1-1.html  11.准备HarmonyOS开发环境 https://bbs.huaweicloud.com/forum/thread-0217137147386754003-1-1.html  12.Nginx服务器安装配置SSL证书流程（实现HTTPS安装） https://bbs.huaweicloud.com/forum/thread-0224137038725392014-1-1.html  13.几款值得选的SSH客户端软件 https://bbs.huaweicloud.com/forum/thread-02107137038433887013-1-1.html  14.8个站酷免费字体且可商用 不担心字体版权 https://bbs.huaweicloud.com/forum/thread-0235137038369347011-1-1.html  15.7个加速搜索引擎收录网站实用有效方法 https://bbs.huaweicloud.com/forum/thread-02112137038294122014-1-1.html  16. Java 算法篇-深入理解递归（递归实现：青蛙爬楼梯）-转载 https://bbs.huaweicloud.com/forum/thread-0213136969605169006-1-1.html  17.【内网穿透】搭建我的世界Java版服务器，公网远程联机-转载 https://bbs.huaweicloud.com/forum/thread-02112136969569637009-1-1.html  18.【Nginx篇】Nginx轻松上手-转载 https://bbs.huaweicloud.com/forum/thread-0213136969448107005-1-1.html  19.【SpringBoot(IDEA)+Vue(Vscode)前后端交互】-转载 https://bbs.huaweicloud.com/forum/thread-02107136969215321009-1-1.html  20.【SpringBoot】| SpringBoot 集成 Redis-转载 https://bbs.huaweicloud.com/forum/thread-0240136952804547006-1-1.html  21.基于SpringBoot的个人博客管理系统的设计与实现 毕业设计开题报告-转载 https://bbs.huaweicloud.com/forum/thread-02112136952724159004-1-1.html  22.【SpringBoot篇】Spring_Task定时任务框架-转载 https://bbs.huaweicloud.com/forum/thread-02127136952689543005-1-1.html  23.【SpringCloud】Eureka基于Ribbon负载均衡的调用链路流程分析-转载 https://bbs.huaweicloud.com/forum/thread-0224136952632959005-1-1.html  24. Spring Boot单元测试-转载 https://bbs.huaweicloud.com/forum/thread-0213136952529904002-1-1.html  25.【Springboot系列】SpringBoot整合Jpa-转载 https://bbs.huaweicloud.com/forum/thread-0240136952500264005-1-1.html  26. Spring Boot + MyBatis-Plus实现数据库读写分离 -转载 https://bbs.huaweicloud.com/forum/thread-02107136952426802006-1-1.html 

一、简介         mybatis框架本身其实只有一个配置文件，及mybatis-config.xml，只是这个配置文件中有一个属性mappers（映射器），可能会包含大量的SQL映射文件，所以通常会单独扩展，形成一个个单独的xxxMapper.xml映射文件。  二、Mybatis的配置层次： -configuration（根标签，配置） -properties（属性） -settings（设置集） -setting（定义全局性设置，例如开启二级缓存） -typeAiases（类型别名集） -typeAlias（为一些类定义别名） -typeHandlers（类型处理器：定义Java类型与数据库中数据类型之间的转换关系） -objectFactory（对象工厂） -plugins（插件集） -plugin（mybatis插件或自定义插件） -environments（配置mybatis的环境） -environment（环境变量：支持多套环境变量，如开发环境，生产环境） -transactionManager（事务管理器，默认JDBC） -DataSource（数据源，一般使用连接池） -databaseIdProvider（数据库厂商标识） -mappers（指定映射文件或映射类） 三、xml核心配置 3.1 properties（属性标签） 属性标签用来提供动态的属性配置，可采用以下几种方式进行配置  1. 直接配置         例如数据源信息配置，设置好的属性值在整个配置文件中可以进行动态引用，使用${}可以引用已配置的属性值。  <properties>   <property name="driver" value="com.mysql.jdbc.Driver"/>   <property name="url" value="jdbc:mysql://127.0.0.1:3306/myDB"/>   <property name="username" value="root"/>   <property name="password" value="root"/> </properties> 2. 属性文件配置         使用java中的属性配置文件，把属性配置元素具体到配置文件中，然后在properties标签中使用resource属性引入，利用配置文件中的key名称作为占位符，就可以取到实际值  <!-- 引入属性配置文件 --> <properties resource="jdbc.properties"></properties>      <dataSource type="POOLED">   <property name="driver" value="${driver}"/>   <property name="url" value="${url}"/>   <property name="username" value="${username}"/>   <property name="password" value="${password}"/> </dataSource> 3. url引入         类似于属性文件，只是文件是使用 url 指定远程的配置文件。          注意：properties 元素允许配置 resource 属性或 url 属性，只能二选一，要么使用 resource 指定本地的配置文件，要么使用 url 指定远程的配置文件，因为 Mybatis 在加载配置时，如果发现 url 与 resource 同时存在，会抛出异常禁止  <!-- 配置url--> <properties url="http://xxxx"></properties> 4. Java代码         在代码中构建java.util.Properties 属性对象并传递到 SqlSessionFactoryBuilder.build() 方法中  // 构建属性对象 Properties props = new Properties(); props.setProperty("driver","com.mysql.jdbc.Driver");  props.setProperty("url","jdbc:mysql://127.0.0.1:3306/myDB");  props.setProperty("username","user1");  props.setProperty("password","123456"); // 传递属性构建 SqlSessionFactory SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(reader, props); 5. 优先级         除了属性文件引入和url引入不可重复外，其它的方式都允许配置，优先级别如下：  在代码中构建java.util.Properties 属性对象 属性文件引入和url引入 直接在properties内部子标签元素property中设置的属性 3.2 settings（设置标签）         settings标签用于动态改变mybatis的运行状态，mybatis提供了大量的设备属性，总结了一下如下所示  <settings>     <!-- 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存 支持 true | false 默认 true  -->   <setting name="cacheEnabled" value="true"/>        <!--  延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。    支持 true | false 默认 false -->   <setting name="lazyLoadingEnabled" value="true"/>        <!--  开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。    支持 true | false 默认 false （在 3.4.1 及之前的版本中默认为 true）  -->   <setting name="aggressiveLazyLoading" value="true"/>       <!-- 是否允许单个语句返回多结果集（需要数据库驱动支持）。 支持 true | false 默认 true   -->   <setting name="multipleResultSetsEnabled" value="true"/>       <!-- 使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。 支持 true | false 默认 true   -->   <setting name="useColumnLabel" value="true"/>       <!-- s 允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，   但仍可正常工作（如 Derby）。 支持 true | false 默认 false   -->   <setting name="useGeneratedKeys" value="false"/>       <!--  指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。   FULL 会自动映射任何复杂的结果集（无论是否嵌套）。 支持 NONE, PARTIAL, FULL 默认 PARTIAL  -->   <setting name="autoMappingBehavior" value="PARTIAL"/>       <!--  指定发现自动映射目标未知列（或未知属性类型）的行为。NONE:不做任何反应    WARNING: 输出警告日志（ org.apache.ibatis.session.AutoMappingUnknownColumnBehavior 的日志等级必须设置为 WARN）    FAILING: 映射失败 (抛出 SqlSessionException) 支持 NONE, WARNING, FAILING 默认 NONE   -->   <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>       <!--  置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）；    BATCH 执行器不仅重用语句还会执行批量更新。 支持 SIMPLE REUSE BATCH 默认 SIMPLE  -->   <setting name="defaultExecutorType" value="SIMPLE"/>       <!-- 设置超时时间，它决定数据库驱动等待数据库响应的秒数。 支持任意正整数默认未设置 (null)   -->   <setting name="defaultStatementTimeout" value="25"/>       <!--  设置结果集获取数量，此参数可以在查询设置中被覆盖。支持任意正整数默认未设置 (null)  -->   <setting name="defaultFetchSize" value="100"/>       <!--  是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。 支持 true | false 默认 false  -->   <setting name="safeRowBoundsEnabled" value="false"/>       <!--  是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。 支持 true | false 默认 false  -->   <setting name="mapUnderscoreToCamelCase" value="false"/>       <!-- MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。    若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。    支持 SESSION | STATEMENT 默认 SESSION   -->   <setting name="localCacheScope" value="SESSION"/>       <!-- 当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，   比如 NULL、VARCHAR 或 OTHER。 JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。 默认 OTHER   -->   <setting name="jdbcTypeForNull" value="OTHER"/>       <!-- 指定对象的哪些方法触发一次延迟加载。 支持 用逗号分隔的方法列表。 默认 equals,clone,hashCode,toString   -->   <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>         <!-- 指定动态 SQL 生成使用的默认脚本语言。 支持 一个类型别名或全限定类名。 默认 org.apache.ibatis.scripting.xmltags.XMLLanguageDriver  -->   <setting name="defaultScriptingLanguage" value="org.apache.ibatis.scripting.xmltags.XMLLanguageDriver"/>       <!--  指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5） 支持 一个类型别名或全限定类名。 默认 org.apache.ibatis.type.EnumTypeHandler  -->   <setting name="defaultEnumTypeHandler" value="org.apache.ibatis.type.EnumTypeHandler"/>       <!--  指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。   注意基本类型（int、boolean 等）是不能设置成 null 的。 支持 true | false 默认 false  -->   <setting name="callSettersOnNulls" value="false"/>       <!--  当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。   （新增于 3.4.2） 支持 true | false 默认 false  -->   <setting name="returnInstanceForEmptyRow" value="false"/>       <!-- 指定 MyBatis 增加到日志名称的前缀。 支持 任何字符串 默认 未设置   -->   <setting name="logPrefix" />       <!-- 定 MyBatis 所用日志的具体实现，未指定时将自动查找。 支持 SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING 默认 未设置   -->   <setting name="logImpl" />       <!-- 指定 Mybatis 创建可延迟加载对象所用到的代理工具。 支持 CGLIB | JAVASSIST 默认 JAVASSIST   -->   <setting name="proxyFactory" value="JAVASSIST"/> </settings>  3.3 typeAliases（类型别名）         用于给Java类型设置一个简称，仅用于XML配置，是为了降低冗余的全限定类名书写。类型别名在mybatis中分为系统内置和用户自定义两类，在解析配置文件时会把typeAliases实例存储进configuration对象中。使用时可直接获取。  3.3.1 自定义别名         自定义别名可以直接设置，如下，在使用com.it.learn.Author的地方可以直接使用别名Author  <typeAliases>   <typeAlias alias="Author" type="com.it.learn.Author"/> </typeAliases>         但当某个项目中特别多java类需要设置别名时，可以直接指定包名扫描，如下，每个在com.it.learn包中的Java类，都可以使用首字母小写的名称来作为别名。但如果Java类上存在@Alias注解，则使用注解value值作为别名  <typeAliases>   <package name="com.it.learn"/> </typeAliases> 3.3.2 系统内置别名         mybatis已经针对大部分常见的java类型内建了相应的类型别名，不区分大小写，基本上都是类名首字母小写，同时也支持数组类型，只需要加上'[]'即可。但需要注意的是，Java中的基本类型和包装类不区分大小写的情况下是同名的，因此基本类型的别名前缀都有下划线'_'，而包装类没有。mybatis的注册信息源码在org.apache.ibatis.type.TypeAliasRegistry#TypeAliasRegistry方法中，有兴趣的朋友可以看看。 3.4 typeHandlers（类型处理器）         mybatis在赋值预处理SQL语句（PreparedStatement）中所需要的参数或从结果集ResultSet中获取对象时，都会使用类型处理器将获取到的值转换为Java类型。也即处理Java类型和JDBC类型之间的映射关系，默认的一些类型处理器如下所示：         更多的类型转换器可以在mybatis的org.apache.ibatis.type.TypeHandlerRegistry#TypeHandlerRegistry() 方法中查看。         当默认的处理器无法满足业务需求时，也可以自定义类型处理器，只需要继承org.apache.ibatis.type.BaseTypeHandler 类即可，该类实现了 org.apache.ibatis.type.TypeHandler 接口，该接口主要定义了两种方法：setParameter 和 getResult，在预编译时设置参数（增删改查传入参数）与查询结果集后转换为 Java 类型时发挥作用。自定义类型处理器配置流程：  3.4.1 首先定义类MyExampleTypeHandler，利用注解与泛型设置映射类型 @MappedJdbcTypes(JdbcType.VARCHAR) public class MyExampleTypeHandler extends BaseTypeHandler<String> {     @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);   } }  3.4.2 在配置文件中设置类型处理器 <!-- mybatis-config.xml --> <typeHandlers>   <typeHandler handler="org.mybatis.example.MyExampleTypeHandler"/>     <!-- 或者使用包扫描处理器     -->   <package name="org.mybatis.example"/> </typeHandlers> 3.4.3 一个类型处理器就已经配置完成，但如果想要处理特殊情况，例如只希望对某个Java类中的属性生效，则可以先将@MappedJdbcTypes注解去除，直接在映射文件中编写，则自定义类型处理器，只会对 birthday 字段产生影响，其余字段均不受影响。 <resultMap id="MyResultMap" type="com.panshenlian.pojo.User">     <!-- id为int类型，但是没指定自定义类型处理器，不受影响-->     <id column="id" property="id" />     <!-- username为String类型，但是没指定自定义类型处理器，不受影响-->     <id column="username" property="username" />     <!-- password为String类型，但是没指定自定义类型处理器，不受影响-->     <id column="password" property="password" />          <!-- birthday为String类型，指定自定义类型处理器，受影响！-->     <id column="birthday" property="birthday"  typeHandler="com.mybatis.typeHandler.MyStringHandler"/>     </resultMap> 3.5 objectFactory（对象工厂）         创建结果对象的新实例时使用的对象工厂，利用该工厂的实例来完成结果对象的实例化。默认的对象工厂只会实例化目标类，也即调用无参构造或者通过存在的参数映射调用有参构造，如果进行扩展，可以创建自己的对象工厂来实，只需要继承DefaultObjectFactory类即可，一般情况下不会使用到。 ———————————————— 原文链接：https://blog.csdn.net/weixin_42189550/article/details/130326404 

1、全局配置文件SqlMapConfig 1.1 全局配置文件SqlMapConfig配置项   在使用MyBatis框架时，最重要的一步就是配置项目工程的全局参数信息，以及数据库连接信息，这些配置信息均在全局配置文件SqlMapConfig.xml中。除此之外，该配置文件中还包含了SQL应神剑的加载路径、全局参数以及类型别名等一系列MyBatis的核心配置信息。SqlMapConfig中的配置信息必须严格按照格式标准进行配置。   全局配置文件SqlMapConfig.xml中各个配置项的名称、含义及描述如下表： 配置名称    配置含义    配置简介 configuration    包裹所有配置标签    整个配置文件的顶级标签 properties    属性    该标签可以引入外部配置的属性，也可以自己配置。该配置标签所在的同一个配置文件的其他配置均可以引用此配置中的属性 setting    全局配置参数    用来配置一些改变运行时行为的信息，例如是否使用缓存机制，是否使用延迟加载，是否使用错误处理机制等。并且可以设置最大并发请求数量、最大并发事务数量，以及是否启用命名空间等 typeAliases    类型别名    用来设置一些别名来代替Java的长类型声明（如java.lang.int变为int），减少配置编码的冗余 typeHandlers    类型处理器    将SQL中返回的数据库类型转换为相应的Java类型的处理器配置 objectFactory    对象工厂    实例化目标类的工厂类配置 plugins    插件    可以通过插件修改MyBatis的核心行为，例如对语句执行的某一点进行拦截调用 environments    环境集合属性对象    数据库环境信息的集合。在一个配置文件中，可以有多种数据库环境集合，这样可以使MyBatis将SQL同时映射至多个数据库 environment    环境子属性对象    数据库环境配置的详细配置 transactionManager    事务管理    指定MyBatis的事务管理器 dataSource    数据源    使用其中的type指定数据源的连接类型，在标签对中可以使用property属性指定数据库连接池的其他信息 mappers    映射器    配置SQL映射文件的位置，告知MyBatis去哪里加载SQL映射文件   按照MyBatis的全局配置文件中的配置顺序，下面给出一个配置了全部参数的样例配置文件，配置文件仅供参考，具体示例配置如下：  <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"         "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration>     <!--1、properties属性引入外部配置文件：注册DB连接四要素的属性文件-->     <properties resource="jdbc.properties" />      <!--2、全局参数设置-->     <settings>         <!-- 配置LOG信息 -->         <setting name="logImpl" value="LOG4J" />         <!-- 延迟加载总开关 -->         <setting name="lazyLoadingEnabled" value="true"/>         <!-- 侵入式延迟加载开关 -->         <setting name="aggressiveLazyLoading" value="true"/>         <!-- 关闭二级查询缓存 -->         <!--<setting name="cacheEnabled" value="false" />-->     </settings>      <!--3、配置别名-->     <typeAliases>         <package name="com.ccff.mybatis.model"/>     </typeAliases>      <!--4、配置类型转换器-->     <typeHandlers>         <!--一个简单类型转换器-->         <typeHandler handler="org.mybatis.example.ExampleTypeHandler" />     </typeHandlers>      <!--5、对象工厂-->     <objectFactory type="org.mybatis.example.ExampleObjectFactory">         <!--对象工厂注入的参数-->         <property name="someProperty" value="100" />     </objectFactory>      <!--6、插件-->     <plugins>         <plugin interceptor="org.mybatis.example.ExamplePlugin">             <property name="someProperty" value="100" />         </plugin>     </plugins>      <!-- 7、environments数据库环境配置：和spring整合后 environments配置将废除-->     <environments default="development">         <environment id="development">             <!-- 使用jdbc事务管理-->             <transactionManager type="JDBC" />             <!-- 数据库连接池-->             <dataSource type="POOLED">                 <property name="driver" value="${jdbc.driver}"/>                 <property name="url" value="${jdbc.url}"/>                 <property name="username" value="${jdbc.username}"/>                 <property name="password" value="${jdbc.password}"/>             </dataSource>         </environment>     </environments>      <!--8、配置SQL映射文件的位置-->     <mappers>         <mapper resource="sqlmap/UserMapper.xml"/>         <mapper resource="sqlmap/StudentMapper.xml"/>         <mapper resource="sqlmap/BasketballPlayerMapper.xml"/>         <mapper resource="sqlmap/FinacialMapper.xml"/>         <mapper resource="sqlmap/NewsLabelMapper.xml" />         <mapper resource="sqlmap/LazyLoadingMapper.xml" />         <mapper resource="sqlmap/BookMapper.xml" />         <mapper resource="sqlmap/GoodsMapper.xml" />     </mappers> </configuration> 1.2 properties配置分析   在SqlMapConfig配置文件中，properties标签中的数据可以供整个配置文件中的其他配置使用。properties标签可以引入一个可动态变换的外部配置，如一个传统的Java配置文件，亦或是一个properties参数配置文件。当然，在properties标签内部也可以放置property标签，来配置子元素信息。对于配置文件中的其他配置，可以通过property子标签的name属性来取得相应的value值。   一个properties标签配置样例如下（引入了一个jdbc.properties文件） <!-- 注册DB连接四要素的属性文件 --> <properties resource="jdbc.properties">     <property name="username" value="root" />     <property name="password" value="root" /> </properties>   可以看到，其中引入了一个jdbc.properties属性文件，该配置文件样例如下：  jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8 jdbc.username=root jdbc.password=root   jdbc.properties配置文件中配置了数据库的详细连接信息，properties标签这样引入它避免了数据库信息的“硬编码”。当需要连接其他数据库时，只需要更改要连接的数据库的配置文件路径即可。    当然properties标签也可以包含property子标签，该子标签中的值也可以被配置文件中的其他配置使用，属于一种全局参数。可以看到，这里虽引入了jdbc.properties文件，但是其中的username和password还可以重新在property子标签中配置，这个时候取的就是property子标签中的value值。这样配置是因为有时候有些模块的数据库连接的用户可能需要以不同的角色登录，这样可以在property子标签中动态分配数据库连接的用户名username和密码password。    在properties标签中引入的配置文件信息以及property子标签中配置的信息，在其他标签中可以使用“$ {}”占位符的方式来获取，在“$ {}”中填写引入的配置文件中参数的name或者property子标签的name，样例配置中的数据源信息配置其实就是获取properties标签中的配置信息。  <!-- 数据库连接池--> <dataSource type="POOLED">     <property name="driver" value="${jdbc.driver}"/>     <property name="url" value="${jdbc.url}"/>     <property name="username" value="${jdbc.username}"/>     <property name="password" value="${jdbc.password}"/> </dataSource>   另外，在MyBatis 3.4.2之后，还可以在“$ {}”占位符中设置一个默认值。当然，首先要在properties标签中设置一个启用占位符默认值的配置，该配置如下：  <!-- 注册DB连接四要素的属性文件 --> <properties resource="jdbc.properties">     <property name="org.apache.ibatis.parsing.PropertyParser.enable-defaut-value" value="true" /> </properties>   然后在其他属性引用properties标签中的参数时，可以这样设置一个默认值  <!-- 数据库连接池--> <dataSource type="POOLED">     <property name="driver" value="${jdbc.driver}"/>     <property name="url" value="${jdbc.url}"/>     <property name="username" value="${jdbc.username:root}"/>     <property name="password" value="${jdbc.password}"/> </dataSource>   即在所需引入的属性名的后面添加“:”引号，然后紧跟着填写当jdbc.username不存在或为空时的默认值。 1.3 setting配置分析   setting配置也是MyBatis全局配置文件中比较重要的配置，它影响MyBatis框架在运行时的一些行为。setting配置缓存、延迟加载、结果集控制、执行器、分页设置、命名规则等一系列控制性参数，与MyBatis的运行性能息息相关。所有的setting配置都被包裹在settings标签对中，setting可配置的参数如下表所示。 ———————————————— 原文链接：https://blog.csdn.net/weixin_36378917/article/details/85246242 

MyBatis核心配置文件（mybatis-config.xml） 主要用于配置数据连接和MyBatis运行时所需的各种特性：包含了影响MyBatis行为甚深的设置（settings）和属性（properties） mybatis-config.xml是Mybatis的全局配置文件，名称可以是任意，但是一般命名都为（mybatis-config）  <configuration>元素是整个XML配置文件的根节点，其角色就相当于是MyBatis的总管，所有的配置信息都会存放在它的里面 MyBatis还提供了设置这些配置信息的方法。configuration可从配置文件里获取属性值，也可以通过程序直接设置，configuration可供配置内容 核心配置文件常用元素 configuration为配置文件的根元素节点，下面是configuration元素子节点。 （1）properties 通过resource属性从外部指定属性文件（db.properties），该属性文件描述数据库连接的相关配置（数据库驱动、连接数据库的url、数据库用户名、数据库密码），位置也是在/resources目录下 （2）settings 设置MyBatis运行中的一些行为，比如此处设置MyBatis的log日志实现为LOG4J，即使用log4j实现日志功能 （3）environments 表示配置MyBatis的多套运行环境，将SQL映射到多个不同的数据库上，该元素节点不可以配置多个environments子元素节点，但是必须指定其中一个默认运行环境（通过default指定） ①environment 配置MyBatis的一套运行环境，需指定运行环境ID、事务管理、数据源配置等相关信息 environment子元素    描述 transactionManager    事务管理器 dataSource    数据源 （4）mappers 告诉MyBatis去哪里找到SQL映射文件（开发者定义的映射SQL语句），整个项目中可以有1个或多个SQL映射文件。 mappers子元素    描述 mapper    指定SQL映射文件的路径，其中resource属性的值表述了SQL映射文件的路径（类资源路径） （5）typeAliases 为Java类型命名一个别名（简称） （6）typeHandlers 类型处理器 （7）plugins 插件 注意：mybatis-config.xml文件的元素节点是有一定顺序的，节点位置若不按顺序排位，那么XML文件会报错 配置文件（mybatis-config.xml）详细 1.properties（数据库连接） 通过该标签来读取Java配置信息 数据源信息写在db.properties文件中，可以通过properties标签来加载该文件  db.properties:  db.driver=com.mysql.jdbc.Driver db.url=jdbc:mysql://localhost:3306/my db.username=root db.password=root mybatis-config.xml使用properties标签：  <configuration>     <!-- 通过properties标签，读取java配置文件的内容 -->     <properties resource="db.properties" />     <!-- 配置mybatis的环境信息 -->     <environments default="development">         <environment id="development">             <!-- 配置JDBC事务控制，由mtybatis进行管理 -->             <transactionManager type="JDBC"></transactionManager>             <!-- 配置数据源，采用dbcp连接池 -->             <dataSource type="POOLED">                 <property name="driver" value="${db.driver}" />                 <property name="url" value="${db.url}" />                 <property name="username" value="${db.username}" />                 <property name="password" value="${db.password}" />             </dataSource>         </environment>     </environments> </configuration> 注意：  <properties resource="db.properties">         <property name="db.username" value="1234" /> 优先① </properties> （1）先加载properties中property标签声明的属性 因此在property中的name属性的值和value比properties中的resource属性先加载；后加载的db.properties会覆盖于property加载属性和值 （2）再加载properties标签引入的Java配置文件中的属性 （3）最后再读取映射文件中parameterType的值会和properties的属性值发生冲突。因此，在properties文件里的内容命名最好加上db.代表是跟数据源相关的属性，这样不容易跟后面的属性发生冲突 2.settings（运行） 设置一些非常重要的设置选项，用于设置和改变MyBatis运行中的行为 settings元素支持的属性。  设置项    描述    允许值    默认 cacheEnabled    该配置影响的所有映射器中配置的缓存的全局开关    true/false    true lazyLoadingEnabled    全局性设置懒加载。false则所有相关联的都会被初始化加载    true/false    true autoMappingBehavior    MyBatis对于resultMap自动映射的匹配级别    NONE    PARTIAL aggressiveLazyLoading    当启用时，对任意延迟属性的调用会使带有延迟加载属性的对象完整加载；反之，每种属性将会按需加载    true,false     multipleResultSetsEnabled    是否允许单一语句返回多结果集（需要兼容驱动）    true,false    true useColumnLabel    使用列标签代替列名。不同的驱动在这方面会有不同的表现， 具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果    true,false    true useGeneratedKeys    允许JDBC支持自动生成主键，需要驱动兼容。如果设置为true则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如Derby）    true,false    false defaultExecutorType    配置默认的执行器。SIMPLE就是普通的执行器；REUSE执行器会重用预处理语句（prepared statements）；BATCH执行器将重用语句并执行批量更新    SIMPLER,EUSE,BATCH    SIMPLE defaultStatementTimeout    设置超时时间，它决定驱动等待数据库响应的秒数    Any positive integer；任意正整数    Not Set (null) safeRowBoundsEnabled    允许在嵌套语句中使用分页（RowBounds）    true,false    false mapUnderscoreToCamelCase    是否开启自动驼峰命名规则（camel case）映射。即从经典数据库列名A_COLUMN到经典Java属性名aColumn的类似映射    true, false    false localCacheScope    MyBatis利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为SESSION，这种情况下会缓存一个会话中执行的所有查询。若设置值为STATEMENT，本地会话仅用在语句执行上，对相同SqlSession 的不同调用将不会共享数据    SESSION,STATEMENT    SESSION jdbcTypeForNull    当没有为参数提供特定的JDBC类型时。为空值指定JDBC类型。某些驱动需要指定列的JDBC类型，多数情况直接用一般类型即可，比如NULL、VARCHAR或OTHER    JdbcType enumeration. Most common are: NULL, VARCHAR and OTHER    OTHER lazyLoadTriggerMethods    指定哪个对象的方法触发一次延迟加载    用逗号分隔的方法名列表    equals,clone,hashCode,toString defaultScriptingLanguage    指定动态SQL生成的默认语言    类型别名或完全限定类名    org.apache.ibatis.scripting.xmltags.XMLDynamicLanguageDriver callSettersOnNulls    指定当结果集中值为null的时候，是否调用映射对象的setter（map对象时为put）方法，这对于有 Map.keySet()依赖或null值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null的    true,false    false logPrefix    指定MyBatis增加到日志名称的前缀    指定MyBatis所用日志的具体实现，未指定时将自动查找    SLF4J,LOG4J,LOG4J2,JDK_LOGGING,COMMONS_LOGGING,STDOUT_LOGGING,NO_LOGGING proxyFactory    指定Mybatis创建具有延迟加载能力的对象所用到的代理工具    CGLIB,JAVASSIST    CGLIB  3.environments（环境） MyBatis可以配置成适应多种环境，这种机制有助于将SQL映射应用于多种数据库之中  例如：开发、测试和生产环境需要有不同的配置；或者共享相同Schema的多个生产数据库，像使用相同的SQL映射。 注意：尽管可以配置多个环境，每个SqlSessionFactory实例只能选择其一 所以，如果想连接两个数据库，就需要创建两个SqlSessionFactory实例，每个数据库对应一个。而如果是三个数据库，就需要三个实例，依此类推。 指定创建哪种环境，只要将它作为可选的参数传递给SqlSessionFactoryBuilder即可。 SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment); SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment,properties); 如果忽略了环境参数，那么默认环境将会被加载  SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader); SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader,properties);  使用environments 环境元素定义了如何配置环境。  <environments default="development">     <!-- default="development"默认的环境ID，id="development"自定义的环境ID -->     <environment id="development">          <!-- type事务管理器配置 -->         <transactionManager type="JDBC">             <property name="..." value="..."/>         </transactionManager>          <!--  type数据源的配置 -->         <dataSource type="POOLED">              <property name="driver" value="${driver}"/>             <property name="url" value="${url}"/>             <property name="username" value="${username}"/>             <property name="password" value="${password}"/>         </dataSource>          </environment> </environments> transactionManager（事务管理器） 在MyBatis中有两种类型的事务管理器（type=“[JDBC|MANAGED]”） JDBC 直接使用了JDBC的提交和回滚设置，它依赖于从数据源得到的连接来管理事务范围 MANAGED 几乎没做什么，它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如：JEE应用服务器的上下文ServeltContext） 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需将closeConnection属性设置为false来阻止它默认的关闭行为。  <transactionManager type="MANAGED">      <property name="closeConnection" value="false"/> </transactionManager> 如果正在使用Spring + MyBatis，则没有必要配置事务管理器，因为Spring模块会使用自带的管理器来覆盖前面的配置  这两种事务管理器类型都不需要任何属性。它们不过是类型别名，换句话说，可以使用 TransactionFactory接口的实现类的完全限定名或类型别名代替它们  public interface TransactionFactory {     void setProperties(Properties props);     Transaction newTransaction(Connection conn);     Transaction newTransaction(DataSource dataSource, TrarnsactionIsolationLevel level, boolean autoCommit); } 任何在XML中配置的属性在实例化之后将会被传递给setProperties()方法。也需要创建一个Transaction接口的实现类，这个接口也很简单：  public interface Transaction {     Connection getConnection() throws SQLException;     void commit() throws SQLException;     void rollback() throws SQLException;     void close() throws SQLException; } 使用这两个接口，可以完全自定义MyBatis对事务的处理  dataSource（数据源） dataSource元素使用标准的JDBC数据源接口来配置JDBC连接对象的资源 许多MyBatis的应用程序将会按示例中的例子来配置数据源。然而它并不是必须的。要知道为了方便使用延迟加载，数据源才是必须的。  有三种内建的数据源类型（也就是type=“[UNPOOLED|POOLED|JNDI]”） （1）UNPOOLED 数据源的实现只是每次被请求时打开和关闭连接。虽然一点慢，它对在及时可用连接方面没有性能要求的简单应用程序是一个很好的选择（某些数据库对连接池不重要，这个配置是理想的） ———————————————— 原文链接：https://blog.csdn.net/qq_45305209/article/details/130347108 

一、mybatis-config.xml 的作用 mybatis-config.xml是MyBatis核心配置文件，该文件配置了MyBatis的一些全局信息，包含数据库连接信息和Mybatis运行时所需的各种特性，以及设置和影响Mybatis行为的一些属性 二、Mybatis核心配置文件结构 configuration配置     properties 可以配置在Java属性配置文件中     settings 修改Mybatis在运行时的行为方式     typeAliases 为Java类型命名一个别名（简称）     typeHandlers 类型处理器     objectFactory 对象工厂     plugins 插件     environments 环境         environment 环境变量             transactionManager 事务管理器             dataSource 数据源            mappers 映射器 三、配置文件讲解 configuration configuration元素是整个XML配置文件的根节点，相当于MyBatis的总管 MyBatis所有的配置信息都会存放在这里面。Mybatis提供了设置这些配置信息的方法。 Configuration可从配置文件里获取属性值，也可以通过程序直接设置  properties元素 properties元素描述的都是外部化、可替代的属性  通过外部指定的方式（通过在典型Java属性配置文件 如database.properties） database.properties driver=com.mysql.jdbc.Driver url=jdbc:mysql://127.0.0.1:3306/smbms user=root password=root mybatis-config.xml 引入database.properties !--引入 database.properties 文件--> <properties resource="database.properties"/>     ……     <dataSource type="POOLED">         <property name="driver" value="${driver}"/>         <property name="url" value="${url}"/>         <property name="username" value="${user}"/>         <property name="password" value="${password}"/>     </dataSource> 上述代码中，driver url username password属性将会用database.properties文件中的值来替换  直接配置为xml，并使用这些属性对配置项实现动态配置 mybatis-config.xml  !-- properties元素中直接配置property属性--> <properties>     <property name="driver" value="com.mysql.jdbc.Driver"/>     <property name="url" value="jdbc:mysql://127.0.0.1:3306/smbms"/>    <property name="user" value="root"/>     <property name="password" value="root"/></properties>     ……     <dataSource type="POOLED">         <property name="driver" value="${driver}"/>         <property name="url" value="${url}"/>         <property name="username" value="${user}"/>         <property name="password" value="${password}"/>     </dataSource> 在上述代码中,driver url username password将会由properties元素中设置的值来替换 两种方式优先级 resource属性值的优先级高于property子节点配置的值 settings元素 settings元素的作用是设置一些非常重要的选项，用于设置和改变Mybatis运行中的行为 settings元素支持的属性 cacheEnabled ： 对在此配置文件下的所有cache进行全局性开/关设置 - true|false lazyLoadingEnabled ： 全局性设置懒加载。如果设为false，则所有相关联的设置都会被初始化加载 -true|false autoMappingBehavior ： Mybatis对于resultMap自动映射的匹配级别 -PAPTLAL|NONE|FULL type Aliases元素 配置类型别名，通过与MyBatis的SQL映射文件相关联，减少输入多余的完整类名，以简化操作  1.基础配置 <typeAliases>     <!--这里给实体类取别名，方便在mapper配置文件中使用-->     <typeAlias alias="user" type="cn.smbms.pojo.User"/>     <typeAlias alias="provider" type="cn.smbms.pojo.Provider"/>     …… </typeAliases> 2.简便配置 第一种方法弊端在于：如果一个项目中有多个POJO，需要一一进行配置。所以在第二种方法中，我们通过name属性直接指定包名，让Mybatis自动去扫描指定包下的JavaBean，并设置一个别名  <typeAliases>     <package name="cn.smbms.pojo"/> </typeAliases>  <mapper namespace="cn.smbms.dao.user.User Mapper">     <!--查询用户表记录数-->     <select id="count" result Type="int">select count(1) as count from smbms_user     </select>     <!--查询用户列表-->     <select id="get User List" result Type="User">select * from smbms_user/select> </mapper> 另外，Mybatis已经为许多常见的Java基础数据类型内建了相应的类型别名。一般都与其映射类型一致，并且都是大小写不敏感的，比如映射的类型int Boolean String Integer等，它们的别名都是int Boolean String Integer  environments元素 配置不同的运行环境  但是不管增加几套运行环境，都必须要明确选择出当前唯一的一个运行环境。这是因为每个数据库都对应一个Sql Session Factory实例，需要指明哪个运行环境被创建，并把运行环境中设置的参数传递个Sql Session Factory Builder  配置如下 <environments default="development"> <!--开发环境-->     <environment id="development">         <transaction Manager type="JDBC"/>         <dataSource type="POOLED">             <property name="driver" value="${driver}"/>             <property name="url" value="${url}"/>             <property name="username" value="${user}"/>             <property name="password" value="${password}"/>         </dataSource>     </environment>     <!--测试环境-->     <environment id="test">         ……     </environment>  </environments> 上述代码中，需要注意以下几个关键点： （1）默认的运行环境ID：通过default属性来指定当前的运行环境ID为development，对于环境ID的命名要确保唯一。 （2）transactionManager事务管理器：设置其类型为JDBC（My Batis有两种事务管理类型，即JDBC和MANAGED），直接使用JDBC的提交和回滚功能，依赖于从数据源获得连接来管理事务的生命周期。 （3）dataSource元素：使用标准的JDBC数据源接口来配置JDBC连接对象的资源。My Batis提供了三种数据源类型UNPOOLED、POOLED、JNDI），这里使用POOLED数据源类型。该类型利用“池”的概念将JDBC连接对象组织起来，减少了创建新的连接实例时所必需的初始化和认证时间，是My Batis实现的简单的数据库连接池类型，它使数据库连接可被复用，不必在每次请求时都去创建一个物理连接。对于高并发的Web应用，这是一种流行的处理方式，有利于快速响应请求。  mappers 用来定义SQL的映射语句  1.使用类资源路径获取资源 <mappers>     <mapper resource="cn/smbms/dao/user/User Mapper.xml"/>     <mapper resource="cn/smbms/dao/provider/Provider Mapper.xml"/></mappers>  2.使用URL获取资源 <mappers>     <mapper url="file:///E:/sqlmappers/User Mapper.xml"/>     <mapper url="file:///E:/sqlmappers/Provider Mapper.xml"/> </mappers> ———————————————— 原文链接：https://blog.csdn.net/qq_43795348/article/details/109553684 

大部分时候，我们都是在Spring 里面去集成MyBatis。因为Spring 对MyBatis 的一些操作进行的封装，我们不能直接看到它的本质，所以先看下不使用容器的时候，也就是编程的方式，MyBatis 怎么使用。先引入mybatis jar 包。 　　首先我们要创建一个全局配置文件，这里面是对MyBatis 的核心行为的控制，比如mybatis-config.xml。 　　第二个就是我们的映射器文件，Mapper.xml，通常来说一张表对应一个，我们会在这个里面配置我们增删改查的SQL 语句，以及参数和返回的结果集的映射关系。跟JDBC 的代码一样，我们要执行对数据库的操作，必须创建一个会话，这个在MyBatis 里面就是SqlSession。SqlSession 又是工厂类根据全局配置文件创建的。所以整个的流程就是这样的（如下代码）。最后我们通过SqlSession 接口上的方法，传入我们的Statement ID 来执行SQL。这是第一种方式。  　　这种方式有一个明显的缺点，就是会对Statement ID 硬编码，而且不能在编译时进行类型检查，所以通常我们会使用第二种方式，就是定义一个Mapper 接口的方式。这个接口全路径必须跟Mapper.xml 里面的namespace 对应起来，方法也要跟StatementID 一一对应。  public void testMapper() throws IOException { 　　String resource = "mybatis-config.xml"; 　　InputStream inputStream = Resources.getResourceAsStream(resource); 　　SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); 　　SqlSession session = sqlSessionFactory.openSession(); 　　try { 　　　　BlogMapper mapper = session.getMapper(BlogMapper.class); 　　　　Blog blog = mapper.selectBlogById(1); 　　　　System.out.println(blog); 　　} finally { 　　　　session.close(); 　　} } 这个就是我们单独使用MyBatis 的基本流程。  核心对象的生命周期 　　在编程式使用的这个demo 里面，我们看到了MyBatis 里面的几个核心对象：SqlSessionFactoryBuiler、SqlSessionFactory、SqlSession 和Mapper 对象。这几个核心对象在MyBatis 的整个工作流程里面的不同环节发挥作用。如果说我们不用容器，自己去管理这些对象的话，我们必须思考一个问题：什么时候创建和销毁这些对象？在一些分布式的应用里面，多线程高并发的场景中，如果要写出高效的代码，必须了解这四个对象的生命周期。这四个对象的声明周期的描述在官网上面也可以找到。我们从每个对象的作用的角度来理解一下，只有理解了它们是干什么的，才知道什么时候应该创建，什么时候应该销毁。  SqlSessionFactoryBuilder 　　这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但是最好还是不要让其一直存在，以保证所有的 XML 解析资源可以被释放给更重要的事情。  SqlSessionFactory 　　SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏味道（bad smell）”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。  SqlSession 　　每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，要考虑 SqlSession 放在一个和 HTTP 请求对象相似的作用域中。 换句话说，每次收到的 HTTP 请求，就可以打开一个 SqlSession，返回一个响应，就关闭它。 这个关闭操作是很重要的，你应该把这个关闭操作放到 finally 块中以确保每次都能执行关闭。 下面的示例就是一个确保 SqlSession 关闭的标准模式：  SqlSession session = sqlSessionFactory.openSession(); try {   // 你的应用逻辑代码 } finally {   session.close(); } 在你的所有的代码中一致地使用这种模式来保证所有数据库资源都能被正确地关闭。  映射器实例（Mapper） 　　映射器是一些由你创建的、绑定你映射的语句的接口。映射器接口的实例是从 SqlSession 中获得的。因此从技术层面讲，任何映射器实例的最大作用域是和请求它们的 SqlSession 相同的。尽管如此，映射器实例的最佳作用域是方法作用域。 也就是说，映射器实例应该在调用它们的方法中被请求，用过之后即可丢弃。 并不需要显式地关闭映射器实例，尽管在整个请求作用域保持映射器实例也不会有什么问题，但是你很快会发现，像 SqlSession 一样，在这个作用域上管理太多的资源的话会难于控制。 为了避免这种复杂性，最好把映射器放在方法作用域内。下面的示例就展示了这个实践：  SqlSession session = sqlSessionFactory.openSession(); try {   BlogMapper mapper = session.getMapper(BlogMapper.class);   // 你的应用逻辑代码 } finally {   session.close(); } 　这个就是我们在编程式的使用里面看到的四个对象的生命周期的总结。 核心配置解读 　　第一个是config 文件。大部分时候我们只需要很少的配置就可以让MyBatis 运行起来。其实MyBatis 里面提供的配置项非常多，我们没有配置的时候使用的是系统的默认值。  　　目前最新的版本是3.5.1，大家可以从官方上下载到最新的源码。中文地址：http://www.mybatis.org/mybatis-3/zh/index.html  <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration>       <properties resource="db.properties"></properties>     <settings>         <!-- 打印查询语句 -->         <setting name="logImpl" value="STDOUT_LOGGING" />         <!-- 控制全局缓存（二级缓存）-->         <setting name="cacheEnabled" value="true"/>         <!-- 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。默认 false  -->         <setting name="lazyLoadingEnabled" value="true"/>         <!-- 当开启时，任何方法的调用都会加载该对象的所有属性。默认 false，可通过select标签的 fetchType来覆盖-->         <setting name="aggressiveLazyLoading" value="false"/>         <!--  Mybatis 创建具有延迟加载能力的对象所用到的代理工具，默认JAVASSIST -->         <!--<setting name="proxyFactory" value="CGLIB" />-->         <!-- STATEMENT级别的缓存，使一级缓存，只针对当前执行的这一statement有效 -->         <!--                 <setting name="localCacheScope" value="STATEMENT"/>         -->         <setting name="localCacheScope" value="SESSION"/>     </settings>       <typeAliases>         <typeAlias alias="blog" type="com.wuzz.domain.Blog" />     </typeAliases>   <!--    <typeHandlers>         <typeHandler handler="com.wuzz.type.MyTypeHandler"></typeHandler>     </typeHandlers>-->       <!-- 对象工厂 --> <!--    <objectFactory type="com.wuzz.objectfactory.GPObjectFactory">         <property name="wuzz" value="666"/>     </objectFactory>-->   <!--    <plugins>         <plugin interceptor="com.wuzz.interceptor.SQLInterceptor">             <property name="wuzz" value="betterme" />         </plugin>         <plugin interceptor="com.wuzz.interceptor.MyPageInterceptor">         </plugin>     </plugins>-->       <environments default="development">         <environment id="development">             <transactionManager type="JDBC"/><!-- 单独使用时配置成MANAGED没有事务 -->             <dataSource type="POOLED">                 <property name="driver" value="${jdbc.driver}"/>                 <property name="url" value="${jdbc.url}"/>                 <property name="username" value="${jdbc.username}"/>                 <property name="password" value="${jdbc.password}"/>             </dataSource>         </environment>     </environments>       <mappers>         <mapper resource="BlogMapper.xml"/>         <mapper resource="BlogMapperExt.xml"/>     </mappers>   </configuration>  configuration 　　configuration 是整个配置文件的根标签，实际上也对应着MyBatis 里面最重要的配置类Configuration。它贯穿MyBatis 执行流程的每一个环节。这里面有很多的属性，跟其他的子标签也能对应上。  　　注意：MyBatis 全局配置文件顺序是固定的，否则启动的时候会报错。  properties 　　第一个是properties 标签，用来配置参数信息，比如最常见的数据库连接信息。为了避免直接把参数写死在xml 配置文件中，我们可以把这些参数单独放在properties 文件中，用properties 标签引入进来，然后在xml 配置文件中用${}引用就可以了。可以用resource 引用应用里面的相对路径，也可以用url 指定本地服务器或者网络的绝对路径。  　　我们为什么要把这些配置独立出来？有什么好处？或者说，公司的项目在打包的时候，有没有把properties 文件打包进去？  提取，利于多处引用，维护简单； 把配置文件放在外部，避免修改后重新编译打包，只需要重启应用； 程序和配置分离，提升数据的安全性，比如生产环境的密码只有运维人员掌握。 settings　　 　　这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项的意图、默认值等 ———————————————— 原文链接：https://blog.csdn.net/MaNong125/article/details/122455518 

前提提要 本系列Mybatis笔记基于mybatis3.5.2 , https://github.com/mybatis/mybatis-3/releases/tag/mybatis-3.5.2中有详细的文档说明，可以进行下载阅读，本文只是对Mybatis的一些常用操作进行汇总总结。 推荐视频资料：https://www.bilibili.com/video/BV1VP4y1c7j7?p=1 所需前提：对maven有些了解。（maven v3.6.1）如果对maven不是很熟悉推荐博主文章。Maven常用知识梳理总结 MyBatis系列文章索引页✋ IDE: IntelliJ IDEA 2021.3 构建工具： apache-maven-3.6.3 MySQL版本：MySQL 5.7.35 MyBatis版本：MyBatis 3.5.7 文章目录 前提提要 一.全局配置文件 1. properties: 通过配置文件动态绑定值 2. setting :对全局设置相关属性值 3. typeAliases（ alias,package） 设置类型的别名 4. environments：设置数据库环境 4.1 transactionManager：设置事务管理方式 5. mappers：引入映射文件 6.总结 一.全局配置文件 全局配置文件，见名知意就是对当前MyBatis的一些全局属性进行设置。也就是对各种数据操作进行统一规定。 全局配置文件包含了全局设置（setting）和properties两个大的部分，通过这两个大的部分动态的影响MyBatis的行为。下面我从几个方面去介绍： 大致来看看最简单的全局配置文件：  <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"         "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration>     ...      <typeAliases>       <environments default="development">      <mappers>      ... </configuration> 但是，上面各个标签的顺序，我绝对不是随便给的。MyBatis对各个标签的顺序有规定。 如果标签的顺序不正确，会出现错误，如下图：  核心配置文件中的标签必须按照固定的顺序(有的标签可以不写，但顺序一定不能乱)： properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、reflectorFactory、plugins、environments、databaseIdProvider、mappers 那我就按照上述的顺序来将一些常见的进行介绍：  1. properties: 通过配置文件动态绑定值 <properties>表名的是可外部化，可替换的一些属性。在典型的JAVA属性中配置他们文件的实例。比如jdbc.properties文件的导入。      <!--引入配置文件-->     <properties resource="jdbc.properties"/> [jdbc.properties]  jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3307/mybatis jdbc.username=root jdbc.password=admin 然后，我们就可以在数据源中动态的设置这些值。  <environment id="test">             <!--事务管理器通过jdbc来进行管理-->             <transactionManager type="JDBC"/>             <!--数据源，从数据连接池中进行取用 -->             <dataSource type="POOLED">                 <property name="driver" value="${jdbc.driver}"/>                 <property name="url" value="${jdbc.url}"/>                 <property name="username" value="${jdbc.username}"/>                 <property name="password" value="${jdbc.password}"/>             </dataSource> 2. setting :对全局设置相关属性值 <setting>是在mybatis运行过程中修改运行行为一个非常重要的方式。其中规定了很多属性的值，如是否开启全局缓存，懒加载是否开启等等. 我只截取其中的一部分，其他详细的请查阅相关文档。  3. typeAliases（ alias,package） 设置类型的别名 设置别名：为一些比较长的类名起一个比较短的代称。 里面有的属性有 type: 需要设置别名的全类型名。 alias: 设置此类型的别名，并且不进行区分大小写 ，如果这项不进行设定的话，框架给一个默认的别名——以类名作为别名。  <typeAliases>     <typeAlias type="com.fangshaolei.mybatis.Account" alias="account" />     <typeAlias type="com.fangshaolei.mybatis.User" alias="uu" /> </typeAliases> 但是，对于开发中，这种操作一般比较繁琐。一般使用扫描包的方式来做。通过以包为单位，设置和修改包下的所有类都拥有默认的别名（即是类名），并且所有的别名都不区分大小写。  <package name="com.fangshaolei.mybatis.bean"/> 系统中默认配置的别名： 4. environments：设置数据库环境 <environments>用于设置多个连接数据库的环境。比如说一些其他数据库，Oracle,MySQL等等，在需要的使用达到动态切换的目的。 而对于<environments>要使用哪个环境，是通过default属性来设置对应environment的id来实现的。 一个environments有很多的environment，但是只能有一个作为项目的数据库环境。  <environments default="development">         <!--开发环境             environment: 用来配置某个具体的环境             属性：                 id: 表示连接数据库环境的唯一标识，不能重复                 属性：                     type: = "JDBC | MANAGED"                     JDBC: 表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式， 事务的提交和回滚需要手动来进行处理                     MANAGED: 被管理，例如spring         -->         <environment id="development">             <!--事务管理器通过jdbc来进行管理-->             <transactionManager type="JDBC"/>             <!--数据源，从数据连接池中进行取用                 datasource: 配置数据源                 属性：                     type: 设置数据源类型                     type = "POOLED | UNPOOLED | JNDI"                     POOLED: 表示使用数据库连接池缓存数据库连接                     UNPOOLED: 表示不使用数据库中的连接词                     JNDI: 表示使用上下文中的数据源连接池             -->             <dataSource type="POOLED">                 <!--设施连接数据库的驱动-->                 <property name="driver" value="com.mysql.jdbc.Driver"/>                 <!--设置连接地址-->                 <property name="url" value="jdbc:mysql://localhost:3307/mybatis"/>                 <!--用户名-->                 <property name="username" value="root"/>                 <!--密码-->                 <property name="password" value="admin"/>             </dataSource>         </environment>         <!--测试-->         <environment id="test">         </environment>     </environments> 4.1 transactionManager：设置事务管理方式 属性：type=“JDBC/MANAGED”  JDBC: 在当前环境中，执行sql时，使用的是jdbc原生的事务管理方式，需要手动的提交和回滚事务 MANAGED：被管理，例如Spring 5. mappers：引入映射文件 mappers引入映射文件有三种方式（严格来说是四种）。而这里博主只介绍一种常用的方式：🍒以包围单位引入配置文件 但是，以包为单位引入配置文件，有两个要求：  mapper接口所在的包要和映射文件所在的包要一致。 mapper接口要和映射文件的名称一致。 满足了上述两个要求之后，就可以在<mappers>标签内利用<package>标签实现批量引入映射文件。  <mappers>         <package name="com.fangshaolei.mybatis.mapper"/>     </mappers> Notice：还有一个需要注意的点，在resources中，如果一次性创建多个层级目录，不能使用如图所示，使用.来创建。而要使用com/fangshaolei/mybatis/mapper才能创建出和类包一样的目录结构。 否则会报：BindingException: Type interface com.atguigu.mybatis.mapper.UserMapper is not known to the MapperRegistry. 6.总结 本节内容，没有什么特殊的tips,对于还有一些其他的配置信息，可以在MyBatis官方文档中有详细说明，博主不在班门弄斧的解释。 一份完整的mybatis-config.xml配置示例：  <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"         "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration>      <!--引入配置文件-->     <properties resource="jdbc.properties"/>     <!--         mybatis配置文件中一定要按照顺序来进行配置         properties?,settings?,typeAliases?,typeHandlers?,objectFactory?,         objectWrapperFactory?,reflectorFactory?,plugins?,environments?,         databaseIdProvider?,mappers?)".     -->     <typeAliases>         <!--进行书写别名             类型别名他不进行区分大小写 ，如果alias不进行设置就会拥有一个默认的别名，默认的就是当前的类名             typealias: 设置某个类型的别名             属性：                 type:  设置需要设置别名的类型                 alias: 设置某个类型的别名，若不设置该属性，就会拥有一个默认的别名，默认的别名就是当前的类名。         -->         <!--<typeAlias type="com.fangshaolei.mybatis.pojo.User"  alias="user"/>-->         <package name="com.fangshaolei.mybatis.pojo"/> <!--通过以包为单位来进行设置-->     </typeAliases>     <!--         environments: 配置多个连接数据的环境         属性：             default: 设置默认使用的环境id     -->     <environments default="development">         <!--开发环境             environment: 用来配置某个具体的环境             属性：                 id: 表示连接数据库环境的唯一标识，不能重复                 属性：                     type: = "JDBC | MANAGED"                     JDBC: 表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式， 事务的提交和回滚需要手动来进行处理                     MANAGED: 被管理，例如spring         -->         <environment id="development">             <!--事务管理器通过jdbc来进行管理-->             <transactionManager type="JDBC"/>             <!--数据源，从数据连接池中进行取用                 datasource: 配置数据源                 属性：                     type: 设置数据源类型                     type = "POOLED | UNPOOLED | JNDI"                     POOLED: 表示使用数据库连接池缓存数据库连接                     UNPOOLED: 表示不使用数据库中的连接词                     JNDI: 表示使用上下文中的数据源连接池             -->             <dataSource type="POOLED">                 <!--设施连接数据库的驱动-->                 <property name="driver" value="com.mysql.jdbc.Driver"/>                 <!--设置连接地址-->                 <property name="url" value="jdbc:mysql://localhost:3307/mybatis"/>                 <!--用户名-->                 <property name="username" value="root"/>                 <!--密码-->                 <property name="password" value="admin"/>             </dataSource>         </environment>         <!--测试-->         <environment id="test">             <!--事务管理器通过jdbc来进行管理-->             <transactionManager type="JDBC"/>             <!--数据源，从数据连接池中进行取用 -->             <dataSource type="POOLED">                 <property name="driver" value="${jdbc.driver}"/>                 <property name="url" value="${jdbc.url}"/>                 <property name="username" value="${jdbc.username}"/>                 <property name="password" value="${jdbc.password}"/>             </dataSource>         </environment>     </environments>     <!--映入配置文件-->     <mappers>        <!-- <mapper resource="mappers/UserMapper.xml"/>-->         <!--             以包围单位引入映射文件             要求：             1.mapper接口所在的包要和映射文件所在的包一致             2. mapper接口要和映射文件的名字是一致的         -->         <package name="com.fangshaolei.mybatis.mapper"/>     </mappers> </configuration> ———————————————— 原文链接：https://blog.csdn.net/qq_41860497/article/details/123450860 

一、概述开发中的遇到一个有关于统计需求，而这个需求需要根据两个数据库才能实现，而如果直接通过两个模块之间的交互也可以实现，但是这样一来，如果加入了搜索条件，而这搜索条件又分散在不同的库中，这样依赖数据处理起来就很复杂，而且还没有对数据进行有效的分页处理，考虑目前数据库都放再一台服务器中，还没有不同数据库放在不同服务器的需求，在sql中引入了库名。虽然引入了库名，对应的业务能跑起来了，但是也遇到过一个比较奇特的问题，也就是数据库中存在了同名的库，因为之前的sql中引入了库名，在不改变代码的情况下，直接修改配置文件和数据库的库名会导致引入了库名的sql无法使用，为此，引入了.xml文件中动态修改数据库库名的功能，具体的话通过mybatis的全局变量实现。二、实现方案经过摸索，大致的得到了三种实现方案2.1 mybaits自带全局变量定义在springboot中yml文件中加入如下全局变量配置mybatis: configuration: variables: myConfigName: "`base1`"然后再sql中 <select id="selectTest" resultType="java.util.Map"> select * from ${myConfigName}.table1 </select>需要注意的是反引号 " ` "，如果不再库名上加上反引号，那么sql就无法顺利的跑起来，此外占位符要使用$，因为$才获取到全局变量这样，就可以动态的配置库名，但是这样的话，有一个缺点，无法设置默认值，如果myConfigName没有进行配置，那么这个sql就无法执行2.2 使用@value和mybatis进行全局变量的定义使用@value为java的一个成员变量复制，并且实则hi默认值，这样我们通过yml文件配置对应库名了 /** * 数据库名称 */ public static String dataBaseName; //注意引号 @Value("${data-conf.dataBaseName:`test`}") private void setUserDataBaseName(String name){ dataBaseName=name; }mapper定义和对应的sql调用List<Object> getInfoFromtaba(@Param("dataBaseName") String dataBaseName); List<Object> result=xxxmapper.getInfoFromtaba(xxx.dataBaseName).xml写法<!-- 注意，这里可以使用#占位符 ---> <select id="selectTest" resultType="java.util.Map"> select * from #{dataBaseName}.table1 </select>这种方式解决了默认数据库名的问题，但是也存在一个问题，就是mapper的接口中多了数据库名作为参数，这种形参的设置看着很别扭。2.3 使用@value和mybatis进行全局变量的定义这种方式类似于上述2.2 的方案，只是他能减少mapper接口的不必要的数据库名形参，只要不去细看sql，一般情况，开发人员感受不到库名的动态配置 /** * 数据库名称 */ public static String dataBaseName; //注意引号 @Value("${data-conf.dataBaseName:`test`}") private void setUserDataBaseName(String name){ dataBaseName=name; }<!-- 注意，这里可以使用#占位符 ---> <select id="selectTest" resultType="java.util.Map"> select * from <choose> <when test="null != @com.project.mapper.config.TestClass@dataBaseName"> ${@com.project.mapper.config.TestClass@dataBaseName}.table1 AS tu </when> <otherwise> `pre-base`.table1 AS tu </otherwise> </choose> </select>注：这里@com.project.mapper.config.TestClass@dataBaseName 的第一个@com.project.mapper.config.TestClass是类的路径，后面的@dataBaseName是库名。注意再test中boolean表达式子中不需要$占位符，而后续具体数据的位置需要展示位符号$，使用<chose>的原因一是为了保险，这样就是对应的变量的默认值丢失了，也能使用默认库，二是为了避免${}报变量过长的错原文链接：https://huaweicloud.csdn.net/64eea6cea3cccc782cc579d6.html

Spring Boot定义全局变量在Spring Boot应用程序中，我们经常需要定义一些全局变量，这些变量可以在应用的任何地方访问。Spring Boot提供了多种方式来定义全局变量，本文将介绍其中的几种方法，并提供相应的代码示例。1. 使用配置文件Spring Boot支持使用属性配置文件来定义全局变量。我们可以将全局变量的值配置在application.properties或application.yml文件中，然后通过@Value注解将其注入到代码中。首先，我们在application.properties文件中定义一个全局变量：myapp: globalVar: Hello World然后，在使用该全局变量的类中使用@Value注解进行注入：@Component public class MyBean { @Value("${myapp.globalVar}") private String globalVar; // ... }这样，globalVar变量的值就会被注入为Hello World。2. 使用静态变量另一种定义全局变量的方法是使用静态变量。我们可以在一个类中定义一个静态变量，并通过@Component注解将该类交由Spring管理。@Component public class GlobalVariables { public static final String GLOBAL_VAR = "Hello World"; // ... }然后，在代码的任何地方，我们都可以通过GlobalVariables.GLOBAL_VAR访问到该全局变量。3. 使用单例模式我们还可以使用单例模式来定义全局变量。通过将变量定义在一个单例类中，可以确保全局变量只有一个实例，并且可以在应用的任何地方访问到。首先，定义一个单例类，并在其中定义全局变量：@Component public class GlobalVariablesSingleton { private static GlobalVariablesSingleton instance; private String globalVar; private GlobalVariablesSingleton() { // 初始化全局变量 globalVar = "Hello World"; } public static GlobalVariablesSingleton getInstance() { if (instance == null) { instance = new GlobalVariablesSingleton(); } return instance; } public String getGlobalVar() { return globalVar; } // ... }然后，在代码的任何地方，我们都可以通过GlobalVariablesSingleton.getInstance().getGlobalVar()访问到该全局变量。总结本文介绍了几种在Spring Boot应用程序中定义全局变量的方法。使用配置文件、静态变量或单例模式都可以实现全局变量的定义。选择合适的方法取决于具体的需求和场景。希望本文对你在Spring Boot中定义全局变量有所帮助。通过合理的使用全局变量，我们可以在应用程序中方便地共享数据和配置信息。注意：本文示例代码基于Spring Boot 2.x版本。原文链接：https://blog.csdn.net/weixin_45131680/article/details/133810260

网上有很多springboot的入门教程，自己也因为项目要使用springboot，所以利用业余时间自学了下springboot和springcloud，使用下来发现springboot还是挺简单的，体现了极简的编程风格，大部分通用都是通过注解就可以完成，下面就来详细讲解下如何使用springboot来开发一个简单的restful api网关功能，可以提供给H5或者android、ios进行接口开发，还是很方便的。1. 使用spring initialization创建SpringBoot项目有很多方法可以快速创建Springboot项目，可以通过idea的springboot initialization来创建，也可以通过手工新建一个maven工程，然后引入springboot的dependency来完成sprignboot的工程导入，还可以通过spring官网的来创建springboot项目，因为有些同学可能没装idea，这里就通过官网的工程初始化指引来创建一个springboot空工程。首先输入网址 https://start.spring.io，打开后可以看到下图：在serch for dependency输入web，即可完成基本的restful接口网关的功能，如果要JPA或者oauth安全相关的组件，可以增加rest repository、spring security等相关组件依赖库，spring提供的配套组件还是很多的，基本涵盖了所有应用场合。加入web组件后，点击下方的绿色按钮Generate Project即可创建一个springboot工程，并且自动下载到本地，接下来直接在idea或者eclipse打开该工程就可以了，在创建的时候可以选择Maven工程或者Gradle工程，这里我们使用了大家比较熟悉的Maven工程。2. 工程结构下面我们在ide中打开工程，这里使用的ide是idea，工程的目录结构为：可以看到工程中有maven的pom文件，也自动创建了SpringbootStartApplication.java该类为springboot的启动类，待会儿我们一起看下这个类，先看下maven的pom文件有哪些。这里主要是依赖了springboot的1.4.7版本，目前最新已经更新到1.5.6了，这里没有用最新版本，还是不当小白鼠了，在dependency中依赖了spring-boot-starter-web还有个test测试的组件，如果不写测试代码，可以不使用该test组件，最后还加入了支持springboot的maven plugin组件。 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.4.7.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>刚看完了pom文件，在导入工程的时候，ide一般会自动导入依赖库，在国内访问maven的依赖库速度感人，建议使用阿里云的maven镜像服务器，或者使用公司的maven私服，如果公司没有私服或者自己学习可以直接使用阿里云的镜像速度还是不错的，maven setting.xml中需要添加mirror地址，具体如何配置这里就不详细描述了，可以自行百度，这里也顺便附上阿里云maven地址：<mirror> <id>nexus-aliyun</id> <mirrorOf>*</mirrorOf> <name>Nexus aliyun</name> <url>http://maven.aliyun.com/nexus/content/groups/public</url> </mirror>配置好了pom后，我们一起看下自动生成的Application.java这个类相当于我们程序的main函数入口，这里再顺便介绍下因为springboot集成了Tomcat和Jetty，默认使用Tomcat作为应用容器，开发者只需要将工程打成jar包直接丢到服务器上就可以执行了，不需要再单独部署到was、jboss、tomcat这些应用服务器上。SpringBootStartApplication.java@SpringBootApplication public class SpringbootStartApplication { public static void main(String[] args) { SpringApplication.run(SpringbootStartApplication.class, args); } }所有的springboot application启动类都需要在类级别上加上@SpringBootApplication注解，其他参数不用任何调整，后续可以把一些初始化的动作放到该类中进行，目前本例中就不加其他的启动加载项了。这样一个api网关的架子就搭好了，是不是很简单！下面我们就可以将主要精力聚焦在业务逻辑代码上了，这里为了简化程序，不会将项目进行深入的分层设计，在实际项目中，一般都会对项目进行分层设计，如果是api网关，没有view层但是起码也会有对外接入decontroller层、处理业务逻辑的service层、处理数据持久化的dao层，同时也会有一些POJO业务实体类，这里就不详细展开了，后续也会对互联网架构设计进行详细讲述，这里我们只创建了一个UserController类，里面只有获取用户信息的方法，分别根据参数和请求方式的不同用三种方法进行了重写，下面就来一一道来。先来讲述下最简单的使用get请求用户信息的实现方式，代码如下,写好后直接在Application类点击右键有个RunAs，点击后会自动运行，运行成功后可以使用http发包工具进行测试，这里推荐使用chrome的postman或者使用firefox的httprequester插件，都是比较简单的发包工具，get请求的上送为http://localhost:8081/springboot/getUserByGet?userName=feiweiwei//@RestController注解能够使项目支持Rest @RestController @SpringBootApplication //表示该controller类下所有的方法都公用的一级上下文根 @RequestMapping(value = "/springboot") public class UserController { //这里使用@RequestMapping注解表示该方法对应的二级上下文路径 @RequestMapping(value = "/getUserByGet", method = RequestMethod.GET) String getUserByGet(@RequestParam(value = "userName") String userName){ return "Hello " + userName; } }这里用到的注解主要有@RequestMapping表示请求的URL上下文路径，该路径不能重复，为了保证与团队其他同事写的不重复，一般会在每个controller前面加一个一级上下文目录，具体路径参数放在value后面，在每个方法前加一个二级目录，这样可以有效的避免路径冲突。还有注解是@RequestParam，该注解可以通过value指定入参，这里return的返回值就是实际的接口返回。下面介绍下POST的请求方式，可以通过在@RequestMapping注解中设置method为POST来表示该请求为POST请求，除了get、post还有put、delete等请求方式，都可以通过该参数设置。 //通过RequestMethod.POST表示请求需要时POST方式 @RequestMapping(value = "/getUserByPost", method = RequestMethod.POST) String getUserByPost(@RequestParam(value = "userName") String userName){ return "Hello " + userName; }下面介绍下请求参数为JSON格式的请求方法的写法，这里需要注意下如果请求参数是像上面那样通过url form形式提交的请求参数，那么必须使用@RequestParam注解来标示参数，如果使用的请求报文是POST形势的JSON串，那么这里在入参的注解一定要使用@RequestBody，否则会报json解析错误。 //在入参设置@RequestBody注解表示接收整个报文体，这里主要用在接收整个POST请求中的json报文体， //目前主流的请求报文也都是JSON格式了，使用该注解就能够获取整个JSON报文体作为入参，使用JSON解析工具解析后获取具体参数 @RequestMapping(value = "/getUserByJson",method = RequestMethod.POST) String getUserByJson(@RequestBody String data){ return "Json is " + data; }3. 小结到此一个简单的restful风格的api网关就完成了，对于移动开发人员可以自己写简单的服务端进行全栈开发了，原来做spring的同学也可以很快上手springboot，springboot总体上来说还是简化了原先复杂的配置，让大家更容易快速上手和搭建服务端，代码的git地址在下方，欢迎大家下载，谢谢。git代码地址：https://github.com/feiweiwei/springboot-start.git作者：monkey01链接：https://www.jianshu.com/p/af3d5800f763