MyBatis详解 与配置MyBatis+Spring+MySql

Mybatis 知识点什么是 MybatisMybatis 是一个开源的持久层框架，它提供了一个可以自定义 SQL 映射的方式，以及可以很方便地进行数据库查询和操作的功能。

相比于传统的 ORM 框架，Mybatis 更加灵活，适用于复杂的 SQL 查询和自定义 SQL 语句的情况。

Mybatis 的优点1.灵活性：Mybatis 允许开发者自定义 SQL 映射，可以根据需要编写任意复杂的 SQL 查询语句，更加灵活地操作数据库。

2.性能优化：Mybatis 提供了多种性能优化的手段，比如查询缓存和预编译语句等，可以减少数据库的访问次数，提高系统性能。

3.易于集成：Mybatis 与 Spring 框架完美集成，可以很方便地与 SpringBoot 一起使用，简化开发流程。

Mybatis 的基本使用1. 引入依赖在 Maven 项目的 pom.xml 文件中，添加以下依赖：<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>2.1.4</version></dependency>2. 配置数据源在 application.properties 文件中配置数据源信息：spring.datasource.url=jdbc:mysql://localhost:3306/mydbername=rootspring.datasource.password=1234563. 创建实体类和 Mapper 接口创建与数据库表对应的实体类和对应的 Mapper 接口，如下所示：public class User {private Long id;private String name;private Integer age;// 省略 getter 和 setter 方法}public interface UserMapper {List<User> getAllUsers();User getUserById(Long id);void addUser(User user);void updateUser(User user);void deleteUser(Long id);}4. 编写 SQL 映射文件在 resources 目录下创建一个 sqlmap 目录，并在该目录下编写 XML 格式的 SQL 映射文件，如下所示：<!-- UserMapper.xml --><mapper namespace="erMapper"><select id="getAllUsers" resultType="er">SELECT * FROM user;</select><select id="getUserById" resultType="er">SELECT * FROM user WHERE id = #{id};</select><insert id="addUser">INSERT INTO user(name, age) VALUES(#{name}, #{age});</insert><update id="updateUser">UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id};</update><delete id="deleteUser">DELETE FROM user WHERE id = #{id};</delete></mapper>5. 配置 Mybatis在 application.properties 文件中配置 Mybatis 相关的配置项，如下所示：mybatis.mapper-locations=classpath*:sqlmap/**/*.xmlmybatis.configuration.map-underscore-to-camel-case=true6. 注入 Mapper在需要使用 Mapper 的地方进行注入，并调用相应的方法即可：@Servicepublic class UserServiceImpl implements UserService {@Autowiredprivate UserMapper userMapper;@Overridepublic List<User> getAllUsers() {return userMapper.getAllUsers();}// 省略其他方法实现}Mybatis 高级特性动态 SQLMybatis 提供了动态 SQL 的支持，可以根据不同的条件生成不同的 SQL 语句，实现更加灵活的查询。

SpringBoot+Mybatis-plus多数据源配置（MySQL、Sqlserver）前⾔：本章案例利⽤dynamic-datasource-spring-boot-starter集成多数据源，mybaits-plus采⽤3.3.0版本，主要讲述配置多数据源，其案例中也包含了逻辑删除、攻击SQL阻断解析器、p6spySQL性能分析打印、事务以及分页和乐观锁插件。

dynamic-datasource-spring-boot-starter 是⼀个基于springboot的快速集成多数据源的启动器，其⽀持 Jdk 1.7+, SpringBoot 1.4.x 1.5.x 2.0.x。

⼀、pom.xml<!--代码简化,⼯具相关 --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><!--SQLServer 驱动--><dependency><groupId>com.microsoft.sqlserver</groupId><artifactId>sqljdbc4</artifactId><version>4.0</version><scope>runtime</scope></dependency><!--mysql 驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.3.0</version></dependency><dependency><groupId>com.baomidou</groupId><artifactId>dynamic-datasource-spring-boot-starter</artifactId><version>2.4.2</version></dependency><dependency><groupId>p6spy</groupId><artifactId>p6spy</artifactId><version>3.8.0</version></dependency>⼆、application.ymlserver:port: 8888servlet:context-path: /serverspring:application:name: springboot-manyDataSourcesdatasource:p6spy: truedynamic:datasource:master:driver-class-name: com.p6spy.engine.spy.P6SpyDriverurl: jdbc:p6spy:mysql://localhost:3306/datasourceName?characterEncoding=utf8&useSSL=false&serverTimezone=GMTusername: rootpassword: root# url: jdbc:mysql://localhost:3306/ datasourceName?characterEncoding=utf8&useSSL=false&serverTimezone=GMT# username: root# password: root# driver-class-name: com.mysql.cj.jdbc.Driverdb2:driver-class-name: com.p6spy.engine.spy.P6SpyDriverurl: jdbc:p6spy:sqlserver://localhost:1433;DatabaseName=datasourceNameusername: sapassword: root# url: jdbc:sqlserver://localhost:1433;DatabaseName= datasourceName# username: sa# password: root# driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver#⽇志logging:level:com.example.demo : debug三、spy.propertiesmodulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory# ⾃定义⽇志打印logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger#⽇志输出到控制台appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger# 使⽤⽇志系统记录 sql#appender=com.p6spy.engine.spy.appender.Slf4JLogger# 设置 p6spy driver 代理deregisterdrivers=true# 取消JDBC URL前缀useprefix=true# 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.excludecategories=info,debug,result,commit,resultset# ⽇期格式dateformat=yyyy-MM-dd HH:mm:ss# 实际驱动可多个#driverlist=org.h2.Driver# 是否开启慢SQL记录outagedetection=true# 慢SQL记录标准 2 秒outagedetectioninterval=2四、MybatisPlusConfig@Configuration@EnableTransactionManagement//开启事务public class MybatisPlusConfig {/*** mybatisplus 分页插件* @return*/@Beanpublic PaginationInterceptor paginationInterceptor(){PaginationInterceptor paginationInterceptor = new PaginationInterceptor();List<ISqlParser> sqlParserList = new ArrayList<>();// 攻击 SQL 阻断解析器、加⼊解析链;防⽌⼩⽩或者恶意进⾏delete update 全表操作。

MyBatis框架解析与应用MyBatis是一个优秀的持久层框架，它简化了数据库操作的开发过程。

本文将对MyBatis框架进行解析，并介绍其在实际应用中的使用。

一、MyBatis概述MyBatis是一个支持定制化SQL、存储过程以及高级映射的持久层框架。

它主要由以下几个核心组件构成：1. SqlSessionFactory：用于创建SqlSession对象的工厂。

2. SqlSession：与数据库交互的会话对象。

3. Mapper接口：定义数据库操作接口。

4. Mapper.xml文件：包含SQL语句和映射关系的配置文件。

二、MyBatis的配置在使用MyBatis之前，我们需要进行相关的配置工作。

首先，在项目的配置文件中添加MyBatis的依赖。

其次，在配置文件中指定数据库的连接信息，并配置Mapper接口和Mapper.xml文件的扫描路径。

最后，创建SqlSessionFactory对象。

三、Mapper接口的定义Mapper接口是MyBatis中定义数据库操作的接口，通过它可以实现对数据库的CRUD操作。

在Mapper接口中，我们使用注解或者XML配置的方式定义SQL语句，并使用参数映射和结果集映射实现与数据库的交互。

四、Mapper.xml文件的配置Mapper.xml文件是MyBatis中配置SQL语句和映射关系的文件。

在该文件中，我们可以定义增删改查等常用的SQL语句，并进行参数映射和结果集映射。

同时，还可以使用动态SQL实现条件判断和循环操作，提高数据库操作的灵活性。

五、数据源配置在MyBatis中，我们可以配置不同的数据源，以便适应不同的数据库环境和需求。

通过配置数据源，我们可以实现对多数据源的支持，提高系统的可扩展性和灵活性。

六、MyBatis的事务管理在实际应用中，数据操作往往涉及到事务管理。

MyBatis提供了多种事务管理方式，如JDBC事务、Spring事务等。

通过配置和使用事务管理器，我们可以实现对事务的精确控制，确保数据操作的一致性和完整性。

mybatis语法和介绍详细MyBatis（原名为iBATIS）是一种开源的持久化框架，它主要用于将Java对象与SQL语句进行映射，从而实现对象关系映射(ORM)。

MyBatis有一套独立的SQL映射文件，其中定义了对象属性与数据库列之间的映射关系。

这些SQL映射文件通过XML进行定义，使得开发人员可以将SQL语句与Java代码进行解耦。

SQL映射文件可以包含各种插入、更新、删除和查询语句，同时还支持存储过程和函数的调用。

MyBatis的核心组件包括SqlSessionFactoryBuilder、SqlSessionFactory、SqlSession和Mapper。

SqlSessionFactoryBuilder负责创建SqlSessionFactory对象，SqlSessionFactory负责创建SqlSession对象，SqlSession则是与数据库进行交互的核心类，而Mapper则负责定义与数据库交互的接口。

MyBatis的使用非常灵活，可以通过注解或者XML进行配置。

注解是直接在Java代码中使用的标记，通过注解可以直接在Java代码中定义SQL语句，从而省去了编写XML文件的过程。

XML配置方式则需要额外编写SQL映射文件，但是更加灵活和可维护。

下面是一个使用MyBatis的例子，其中使用了XML配置方式：首先，我们需要编写一个User类，用于与数据库中的user表进行映射：```javapublic class Userprivate int id;private String name;private String email;// 省略getter和setter方法```接下来，我们需要编写一个UserMapper接口，用于定义与数据库交互的方法：```javapublic interface UserMapperUser selectUser(int id);void insertUser(User user);void updateUser(User user);void deleteUser(int id);```然后，我们需要创建一个SQL映射文件UserMapper.xml，其中定义了与User类对应的SQL语句：```xmlSELECT * FROM user WHERE id = #{id}</select>INSERT INTO user (name, email) VALUES (#{name}, #{email})</insert>UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}</update><delete id="deleteUser" parameterType="int">DELETE FROM user WHERE id = #{id}</delete></mapper>```最后，我们可以通过SqlSessionFactoryBuilder来创建SqlSessionFactory对象：```javaString resource = "mybatis-config.xml";InputStream inputStream =Resources.getResourceAsStream(resource);SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder(.build(inputStream);```接下来，我们可以通过SqlSessionFactory对象创建SqlSession对象：```javaSqlSession session = sqlSessionFactory.openSession(;```然后，我们可以通过SqlSession对象获取Mapper接口的实例：```javaUserMapper userMapper = session.getMapper(UserMapper.class);```最后，我们可以通过Mapper接口的实例来调用与数据库交互的方法：```javaUser user = userMapper.selectUser(1);```以上就是一个简单的使用MyBatis的例子。

mysql注解批量添加mybatis_Mybatis注解方式实现批量插入数据库MyBatis是一个开源的持久化框架，它提供了一种简单而灵活的方式来访问关系数据库。

在MyBatis中，可以使用注解方式来实现批量插入数据库的操作。

本文将介绍如何使用MyBatis注解来实现批量插入数据。

首先，需要在Maven或Gradle中添加MyBatis依赖。

以下是使用Maven的示例配置：```xml<dependencies><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.7</version></dependency></dependencies>```接下来，需要创建一个数据模型类，用于表示数据库中的表结构。

假设我们有一个名为User的表，包含id、name和age字段，那么对应的数据模型类可以如下所示：```javapublic class Userprivate Long id;private String name;private Integer age;// 省略getter和setter方法```然后，需要创建一个Mapper接口，用于定义数据库操作的方法。

在该接口中，我们将使用注解方式来实现批量插入数据的方法。

假设我们的Mapper接口为UserMapper，那么可以如下所示：```javapublic interface UserMapper"<script>","INSERT INTO user (name, age) VALUES ","<foreach collection='list' item='user' separator=','>","(#{}, #{user.age})","</foreach>","</script>"})```接下来，需要在MyBatis的配置文件中配置Mapper接口的扫描路径，并且使用注解配置的方式来启用Mapper接口。

springboot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置⽅法此⽅法为极简配置，⽀持MySQL数据库多库连接、⽀持Hikari连接池、⽀持MyBatis（包括Dao类和xml⽂件位置的配置）。

1、pom.xml中引⼊依赖：<!-- Begin of DB related --><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.1.1</version><exclusions><exclusion><groupId>org.apache.tomcat</groupId><artifactId>tomcat-jdbc</artifactId></exclusion></exclusions></dependency><dependency><groupId>com.zaxxer</groupId><artifactId>HikariCP</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><!-- End of DB related -->我们使⽤了mybatis-spring-boot-starter，并让它把tomcat-jdbc连接池排除掉，这样spring-boot就会寻找是否有HikariCP可⽤，第⼆个依赖就被找到了，然后mysql-connector也有了。

springboot+mybatis配置双数据源（mysql,oracle,sqlserv。

以上如图为项⽬⽂件夹⽬录。

1，⾸先配置application.yml 配置⽂件server:port: 8084tomcat:uri-encoding: utf-8servlet:context-path: /services#spring:# datasource:# type: com.alibaba.druid.pool.DruidDataSource# # name: skynet# driver-class-name: com.mysql.jdbc.Driver# url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false # username: root# password: root### jpa:# show-sql: true #是否在控制台打印sql语句# ⾃定义的mysql主数据源配置信息primary:datasource:#druid相关配置druid:#监控统计拦截的filtersfilters: statdriverClassName: com.mysql.jdbc.Driver#配置基本属性url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8username: rootpassword: root#配置初始化⼤⼩/最⼩/最⼤initialSize: 1minIdle: 1maxActive: 20#获取连接等待超时时间maxWait: 60000#间隔多久进⾏⼀次检测，检测需要关闭的空闲连接timeBetweenEvictionRunsMillis: 60000#⼀个连接在池中最⼩⽣存的时间minEvictableIdleTimeMillis: 300000validationQuery: SELECT 'x'testWhileIdle: truetestOnBorrow: falsetestOnReturn: false#打开PSCache，并指定每个连接上PSCache的⼤⼩。

Mybatis框架什么是 MyBatis ？MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。

MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

MyBatis 可以对配置和原生Map 使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java 对象)映射成数据库中的记录。

1.下面采用web项目来简单展示实现Mybatis的使用首先建立一个web项目，项目建立成功后引入所需要的jar包，mybatis-3.1.1.jar（mybatis 架包）、mysql-connector-java-5.1.18-bin.jar（mysql数据库jar包）创建数据库mybatis，然后创建表users目录结构如下：（最好把UserMapper.xml文件和UserDao.java接口放在一个包下）然后创建与表对应的JavaBean对象public class User {private int id;private String userName;private int age;public int getId(){return id;}public void setId(int id){this.id = id;}public String getuserName(){return userName;}public void setuserName(String userName){erName = userName;}public int getAge(){return age;}public void setAge(int age){this.age = age;}public String toString(){return"User[id="+id+",userName="+userName+",age="+age+"]";}}接下来在resources包下面创建配置mybatis-config.xml文件，包括类型的别名<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC"-////DTD Config3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><!-- 别名标签，为实体类取别名为user--><typeAliases><typeAlias alias="user"type="er"/> </typeAliases><environments default="development"><environment id="development"><!-- 事务管理 --><transactionManager type="JDBC"/><!-- 配置数据库连接信息 --><dataSource type="POOLED"><property name="driver"value="com.mysql.jdbc.Driver"></property><property name="url"value="jdbc:mysql://localhost:3306/mybatis"></property><property name="username"value="root"></property><property name="password"value="123456"></property></dataSource></environment></environments><mappers><!-- 注册userMapper.xml文件，具体定位使用的是包名/userMapper.xml--><mapper resource="com/lisoft/util/userMapper.xml"/> </mappers></configuration>通过mybatis-config.xml中<mapper resource="com/lisoft/util/userMapper.xml"/>配置项，我们在包com.lisoft.util下面创建文件userMapper.xml内容如下：配置resultMap防止实体类的属性名称与表中字段的名称不一样出错的情况<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><!-- 为这个mapper指定唯一的namespace，namespace的值习惯上设置成包名+sql映射文件名，这样保证namespace的值的唯一性例如例如namespace="erMapper"就是com.lisoft.util(包名)+userMapper(userMapper.xml文件去除后缀) --> <mapper namespace="erMapper"><!-- 进行表关系映射，为了防止实体属性与表字段不一样时出错type="user"中user为实体类的别名 --><resultMap id="userResultMap"type="user"><!-- 配置信息id：为查询列指定的唯一标识，如果有多个列组成的唯一标识，配置多个idcolumn：数据库表中的列property：映射到实体的属性--><id property="id"column="id"/><result property="userName"column="name"/><result property="age"column="age"/></resultMap><!-- 在select标签中编写查询到的sql语句，设置select的id属性为getUser，id属性必须是唯一的不能够重复，使用parameterType属性指明查询时使用的参数类型，resultType指明查询时返回的结果集类型，resultType="user"就是表示将查询结果封装成一个User类对象进行返回(此时是用的实体类的别名)--><!-- <select id="getUser" parameterType="int"resultType="user">select * from users where id=#{id}</select> --><!-- resultMap表示对应实体，名称是resultMap标签的id值 --><select id="getUser"parameterType="int"resultMap="userResultMap">select * from users where id=#{id}</select><!-- 增加操作userGeneratedKeys设置为true时表示字段自动递增,如果不想使用自动递增就去掉keyProperty对应的是Java类里面的属性，而非表里面的字段--> <insert id="addUser"parameterType="user" useGeneratedKeys="true"keyProperty="id">insert into users(id,name,age)values(#{id},#{userName},#{age})</insert><!-- 更新操作 --><update id="updateUser"parameterType="user">update users set name=#{userName},age=#{age} where id=#{id} </update><!-- 删除操作 --><delete id="deleteUser"parameterType="int">delete from users where id=#{id}</delete></mapper>编写测试代码：/*** mybatis查询测试*/@WebServlet("/TestServlet")public class TestServlet extends HttpServlet {private static final long serialVersionUID = 1L;public TestServlet() {super();}protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {PrintWriter out = response.getWriter();//获取输出流对象//mybatis的配置文件String resource = "resources/mybatis-config.xml";//使用类加载器加载mybatis的配置文件(它也加载关联的配置文件)InputStream in = TestServlet.class.getClassLoader().getResourceAsStream(resourc e);//构建sqlSession的工厂SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);//创建能执行映射文件sql的SQLSessionSqlSession session = sessionFactory.openSession();/*** 映射sql的标识符字符串：* erMapper是userMapper.xml文件中mapper 标签的namespace属性值，* getUser是select标签的id的属性值，通过Select标签的id属性值就可以找到要执行的sql*///在命名空间"erMapper"中定义一个名为getUser的映射语句//这样他就允许你使用指定的完全限定名"resources.getUser"来调用映射语句//格式：命名空间(namespace)+映射语句名(id)String statement = "erMapper";//映射sql 的标识字符串//执行查询返回一个user对象的sql(查询操作)User user = session.selectOne(statement+".getUser",2);System.out.println(user.getuserName());//插入操作User addUser = new User();//实例化实体类对象addUser.setuserName("全能冰皇");addUser.setAge(23);//session.insert(statement+".addUser", addUser);//修改操作User updateUser = new User();updateUser.setId(4);updateUser.setuserName("KULi");updateUser.setAge(32);//session.update(statement+".updateUser",updateUser);//删除操作//int i = session.delete(statement+".deleteUser",4);mit();//提交事物否则增删改无效}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException {doGet(request, response);}}2.表关系实现多对一首先在数据库中建立表usres（一）和mobile（多）Usres表Mobile表创建对应的javaBean对象（多对一关系在多方添加一方的实体属性）User对象：public class User {private int id;private String userName;private int age;public int getId(){return id;}public void setId(int id){this.id = id;}public String getuserName(){return userName;}public void setuserName(String userName){erName = userName;}public int getAge(){return age;}public void setAge(int age){this.age = age;}public String toString(){return"User[id="+id+",userName="+userName+",age="+age+"]";}}Mobile对象：public class Mobile {private int id;private String telnumber;//在多方的实体配置一方的实体属性private User users;public int getId(){return id;}public void setId(int id){this.id = id;}public String getTelnumber(){return telnumber;}public void setTelnumber(String telnumber){this.telnumber = telnumber;}public User getUser(){return users;}public void setUser(User users){ers = users;}}对应的表的映射文件：userMapper.xml此时可以省略不写，这里主要是用多方的进行操作mobileMapper.xml配置如下：<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><!-- mappre的命名空间可以随意的命名但是一般遵循包名（com.lisoft.util）.类名的xml文件名（mobileMapper） --><mapper namespace="com.lisoft.util.mobileMapper"><!-- type是实体类的别名，id为找到resultMap的标识 --><resultMap id="mobileResultMap"type="mobile"><id property="id"column="id"/><result property="telnumber"column="telnumber"/><!-- 配置多对一关系javaType的值为User类的别名也可以写成er --><association property="users"javaType="user"><id property="id"column="id"></id><result property="userName"column="name"/><result property="age"column="age"></result> </association></resultMap><!-- 多表查询操作 --><!-- parameterType指明查询时使用的参数类型 --><select id="selectMobile"parameterType="int"resultMap="mobileResultMap"><!-- （写字段的形式查出来id的值为零）分别为mobile的主键id与user的主键id赋值别名，避免因为两个表字段相同而注入到对应对象冲突 --> <!-- SELECT m.id m_id,m.telnumber,u.id u_id,,u.age FROM mobile m,users u WHERE u.id=erid AND m.id=#{id} --> <!-- 这样写的查出来的数据才完整 -->SELECT * FROM mobile m,users u WHERE u.id=erid AND m.id=#{id}</select></mapper>mybatis-config.xml文件配置如下：<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC"-////DTD Config3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><!-- 别名标签，为实体类取别名为user--><typeAliases><typeAlias alias="user"type="er"/><typeAlias alias="mobile"type="com.lisoft.util.Mobile"></typeAlias><environments default="development"><environment id="development"><!-- 事务管理 --><transactionManager type="JDBC"/><!-- 配置数据库连接信息 --><dataSource type="POOLED"><property name="driver"value="com.mysql.jdbc.Driver"></property><property name="url"value="jdbc:mysql://localhost:3306/mybatis"></property><property name="username"value="root"></property><property name="password"value="123456"></property></dataSource></environment></environments><mappers><!-- 注册userMapper.xml文件，具体定位使用的是包名/userMapper.xml--><mapper resource="com/lisoft/util/userMapper.xml"/><!-- 映射mobileMapper.xml文件实现多对一查询 --><mapper resource="com/lisoft/util/mobileMapper.xml"/> </mappers></configuration>编写测试验证多对一关系：@WebServlet("/ManyToOne")public class ManyToOneTestServlet extends HttpServlet { private static final long serialVersionUID = 1L;public ManyToOneTestServlet() {super();// TODO Auto-generated constructor stub}protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {PrintWriter out = response.getWriter();//获取输出流对象//获取mybatis配置文件String config = "resources/mybatis-config.xml";//使用类加载器加载配置文件InputStream in = ManyToOneTestServlet.class.getClassLoader().getResourceAsStrea m(config);//构建sqlSession工厂SqlSessionFactory SessionFactory = new SqlSessionFactoryBuilder().build(in);//创建能执行映射文件的sql的sqlSessionSqlSession sqlSession = SessionFactory.openSession();//映射sql标识符字符串,定位到配置文件里面的配置的id属性String statement = "com.lisoft.util.mobileMapper.selectMobile";//执行一个返回mobileMobile mobile = sqlSession.selectOne(statement, 1);//通过多方的条件查询出对应的一方的信息System.out.println(mobile.getId()+mobile.getTelnumber()+mob ile.getUser());}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {doGet(request, response);}}3.表关系实现一对多首先创建表parent（代表一方的表）和son（代表多方的表）Parent表：Son表：创建JavaBean实体对象Parent实体：（在一方配置多方的集合对象）public class Parent {private int id;private String name;private List<Son> sons;//在一方配置多方的集合对象，此处也可以用setpublic int getId(){return id;}public void setId(int id){this.id = id;}public String getName(){return name;}public void setName(String name){ = name;}public List<Son> getSons(){return sons;}public void setSons(List<Son> sons){this.sons = sons;}}Son实体类：（代表多方的实体）public class Son {private int ids;private String sonName;public int getids(){return ids;}public void setids(int ids){this.ids = ids;}public String getSonName(){return sonName;}public void setSonName(String sonName){this.sonName = sonName;}}parentMapper.xml文件（在一方配置多方的集合此时必须要保证两个id的名称不一样否者查出来的只有一条）<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><!-- 命名空间namespace随意命名一般使用类名（com.lisoft.util）.相应的xml文件名（parentMapper）--><mapper namespace="com.lisoft.util.parentMapper"><!-- 进行表字段的映射为了防止实体的属性名和数据库字段不一样而出现错误type:取得是实体类的别名--><resultMap id="parentResultMap"type="Parent"><!-- property是Java实体类的属性名关联到表字段名 --><id property="id"column="id"javaType="int"jdbcType="INTEGER"/><result property="name"column="name"javaType="String" jdbcType="VARCHAR"/><!-- 配置一对多的对应关系JavaType对象的类型ofType指定集合中元素的类型即是泛型，当使用反向查询从一个mapper 中取出数据时必须用ofTypeproperty指定实体类里面的属性(多方的id值要有别于一方的id值否则查出来的只有一条) --><collection property="sons"column="parentid"ofType="Son"><id property="ids"column="ids"javaType="int" jdbcType="INTEGER"/><result property="sonName"column="sonname"javaType="String"jdbcType="VARCHAR"/></collection></resultMap><!-- 查询时一方的id作为条件,parameterType查询时使用的参数类型（返回一个list结果）--><select id="getOneToMany"parameterType="int"resultMap="parentResultMap"><!-- SELECT p.id,,s.id,s.sonname,s.parentid FROM parent as p,son as s WHERE p.id = s.parentid and p.id=#{id}--> SELECT * FROM parent as p,son as s WHERE p.id = s.parentid and p.id=#{id}</select></mapper>sonMapper.xml文件（由于是一对多关系此时多方的可以省略不写）<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><!-- 命名空间的属性规则是包名（com.lisoft.util）.xml文件名（sonMapper）--><mapper namespace="com.lisoft.util.sonMapper"><!-- type是实体类的别名，id为找到resultMap的标识 --><resultMap id="sonResultMap"type="son"><id property="ids"column="ids"/><result property="sonName"column="sonname"/></resultMap></mapper>mybatis-config.xml配置文件<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC"-////DTD Config3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><!-- 别名标签，为实体类取别名为user--><typeAliases><typeAlias alias="parent"type="com.lisoft.util.Parent"></typeAlias><typeAlias alias="son"type="com.lisoft.util.Son"></typeAlias></typeAliases><environments default="development"><environment id="development"><!-- 事务管理 --><transactionManager type="JDBC"/><!-- 配置数据库连接信息 --><dataSource type="POOLED"><property name="driver"value="com.mysql.jdbc.Driver"></property><property name="url"value="jdbc:mysql://localhost:3306/mybatis"></property><property name="username"value="root"></property><property name="password"value="123456"></property></dataSource></environment></environments><mappers><!-- 注册userMapper.xml文件，具体定位使用的是包名/userMapper.xml--><!-- 映射parentMapper.xml文件和sonMapper.xml一块实现一对多关系 --><mapper resource="com/lisoft/util/parentMapper.xml"/><!-- 映射sonMapper.xml文件 --><mapper resource="com/lisoft/util/sonMapper.xml"/> </mappers></configuration>测试一对多关系：@WebServlet("/OneToMany")public class OneToManyTestServlet extends HttpServlet { private static final long serialVersionUID = 1L;public OneToManyTestServlet() {super();}protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {//maybatis配置文件地址String config = "resources/mybatis-config.xml";//使用类加载器加载配置文件InputStream in =OneToManyTestServlet.class.getClassLoader().getResourceAsStrea m(config);//创建sqlSession的工厂SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);//创建执行映射文件sql的sqlSessionSqlSession session = sessionFactory.openSession();//定位执行的sql语句（包名+实体类xml映射文件的名（parentMapper）+sql语句的位置（例如查询标签的id）String statement ="com.lisoft.util.parentMapper.getOneToMany";//执行查询返回一个Parent对象//Parent parent = session.selectOne(statement, 1);List<Parent> parent = session.selectList(statement, 1);for(int i=0;i<parent.size();i++){for(int j=0;j<parent.get(i).getSons().size();j++){ System.out.println(parent.get(i).getSons().get(j).getSonNam e());}}}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {doGet(request, response);}}4.把mybatis与spring框架整合目录结构：创建数据库表：Son对应数据库表的实体类：public class Son {private int ids;private String sonName;public int getId(){return ids;}public void setId(int ids){this.ids = ids;}public String getSonName(){return sonName;}public void setSonName(String sonName){this.sonName = sonName;}}用于数据库操作sql的sonMapper.xml文件：<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapper PUBLIC"-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><!-- mybatis与spring整合使用时，namespace的值要定位到接口 --> <mapper namespace="com.lisoft.dao.SonMapper"><!-- resultMap使得实体类与表相关联， --><resultMap type="sons"id="sonResultMap"><id property="ids"column="ids"/><result property="sonName"column="sonname"/> </resultMap><!-- 查询整张表的方法 --><select id="getSon"resultMap="sonResultMap">select * from son</select><!-- 带查询条件的查询方法 --><select id="getSonById"parameterType="int"resultMap="sonResultMap">select * from son where ids = #{ids}</select></mapper>applicationContext.xml核心配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.1.xsd/schema/context/schema/context/spring-context-3.1.xsd/schema/mvc /schema/mvc/spring-mvc-4.0.xsd"> <description>Spring Context</description><!-- 读取jdbc.properties配置文件 --><context:property-placeholderlocation="classpath:resources/jdbc.properties"/><!-- 配置数据库连接池信息 --><bean id="c3p0Source"class="boPooledDataSource"><property name="driverClass"value="${jdbc.driver}"/><!-- 基本属性 url、user、password --><property name="jdbcUrl"value="${jdbc.url}"/><property name="user"value="${er}"/><property name="password"value="${jdbc.password}"/> </bean><bean id="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean"><!-- dataSource属性指定要用到的数据库连接池c3p0Source --><property name="dataSource"ref="c3p0Source"/><!-- 指定mybatis的核心配置文件 --><property name="configLocation"value="classpath:resources/mybatis-config.xml"/></bean><bean id="sonMappers"class="org.mybatis.spring.mapper.MapperFactoryBean"><!-- sqlSessionFactory属性指定要用到的SQLSessionFactory实例（name属性固定） --><property name="sqlSessionFactory"ref="sqlSessionFactory"/><!-- MapperInterface属性指定映射接口，用于实现此接口并生成映射器对象（name属性是固定的） --><property name="mapperInterface"value="com.lisoft.dao.SonMapper"/></bean><!-- 把SonMapper接口注入到SonService中 --><bean id="sonService"class="com.lisoft.service.SonService"> <!-- name属性值为service里面对应的相应的set的方法名 --><property name="sons"ref="sonMappers"/><property name="sonById"ref="sonMappers"/></bean></beans>mybatis-config.xml配置文件<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE configuration PUBLIC"-////DTD Config3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><!-- 为实体类配置别名 --><typeAliases><typeAlias alias="sons"type="com.lisoft.entity.Son"></typeAlias></typeAliases><!-- 映射实体类xml文件 --><mappers><mapper resource="com/lisoft/entity/sonMapper.xml"/> </mappers></configuration>jdbc.properties配置文件#-----oracle数据库连接-------------------#jdbc.driver=oracle.jdbc.driver.OracleDriver#jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:orcl#er=car#jdbc.password=123456#-----MySql数据库连接--------------------jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&c haracterEncoding=utf8er=rootjdbc.password=123456Dao层实体类接口：保证接口里面的方法和sonMapper.xml文件里面配置的增删改查标签里面的id属性一样。

详解Mybatis拦截器安全加解密MySQL数据实战需求背景公司为了通过⼀些⾦融安全指标（政策问题）和防⽌数据泄漏，需要对⽤户敏感数据进⾏加密，所以在公司项⽬中所有存储了⽤户信息的数据库都需要进⾏数据加密改造。

包括Mysql、redis、mongodb、es、HBase等。

因为在项⽬中是使⽤springboot+mybatis⽅式连接数据库进⾏增删改查，并且项⽬是中途改造数据。

所以为了不影响正常业务，打算这次改动尽量不侵⼊到业务代码，加上mybatis开放的各种拦截器接⼝，所以就以此进⾏改造数据。

本篇⽂章讲述如何在现有项⽬中尽量不侵⼊业务⽅式进⾏Mysql加密数据，最后为了不降低查询性能使⽤了注解，所以最后还是部分侵⼊业务。

Mybatis拦截器Mybatis只能拦截指定类⾥⾯的⽅法：Executor、ParameterHandler、StatementHandler、ResultSetHandler。

Executor：拦截执⾏器⽅法；ParameterHandler：拦截参数⽅法；StatementHandler：拦截sql构建⽅法；ResultSetHandler：拦截查询结果⽅法；Mybatis提供的拦截器接⼝Interceptorpublic interface Interceptor {Object intercept(Invocation invocation) throws Throwable;default Object plugin(Object target) {return Plugin.wrap(target, this);}default void setProperties(Properties properties) {// NOP}}- Object intercept()：代理对象都会调⽤的⽅法，这⾥可以执⾏⾃定义拦截处理；- Object plugin()：可以⽤于判断拦截器执⾏类型；- void setProperties()：指定配置⽂件的属性；⾃定义拦截器中除了要实现Interceptor接⼝，还需要添加@Intercepts注解指定拦截对象。

springmybatis3.2调⽤mysql存储过程返回多结果集（完整、亲测、可⽤）最近，有个开发提了个需求，希望中间件⽀持调⽤mysql存储过程时⽀持多结果集返回，因为某些原因我们使⽤了不少的存储过程，很多复杂的逻辑⽬前来看交互⾮常的多，所以从当前的现状来说，这个需求还是蛮合理的。

中午抽空特地搜了下，整合完整⽰例如下：1、创建测试存储过程delimiter $$CREATE PROCEDURE sp_multi_resultset(IN p_operator_company_no int,IN p_operator_no int,OUT p_error_code varchar(32),OUT p_error_info varchar(255))BEGINselect1as col1,2as col2;select11as col11,22as col21;end $$delimiter ;call sp_multi_resultset(1,1,@error_code,@error_info);2、mapper⽂件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="MultiResultset"><resultMap type="test.Test" id="test1"><result column="col1" property="col1" jdbcType="INTEGER" javaType="Integer"/><result column="col2" property="col2" jdbcType="INTEGER" javaType="Integer"/></resultMap><resultMap type="test.Test2" id="test2"><result column="col1" property="col1" jdbcType="INTEGER" javaType="Integer"/><result column="col3" property="col3" jdbcType="INTEGER" javaType="Integer"/></resultMap><select id="getTests" statementType="CALLABLE" parameterType="Map" resultMap="test1,test2">{call sp_multi_resultset(#{param1,mode=IN,jdbcType=INTEGER},#{param2,mode=IN,jdbcType=INTEGER},#{errorCode,mode=OUT,jdbcType=VARCHAR},#{errorInfo,mode=OUT,jdbcType=VARCHAR})}</select></mapper>3、java代码/****/package com.medsoft.top10.dao;import java.util.HashMap;import java.util.List;import java.util.Map;import org.mybatis.spring.SqlSessionTemplate;import org.springframework.beans.factory.InitializingBean;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import com.cyl.kernel.util.JsonUtils;/*** @author zhjh256@* {@link} /zhjh256*/@Servicepublic class TestMultiResultSet implements InitializingBean {@Autowiredprivate SqlSessionTemplate sqlSession;/* (non-Javadoc)* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()*/@Overridepublic void afterPropertiesSet() throws Exception {Map<String,String> map = new HashMap<String,String>();map.put("param1", "1");map.put("param2", "1");map.put("errorCode", "");map.put("errorInfo", "");List<List<?>> multiResult = sqlSession.selectList("MultiResultset.getTests",map);System.out.println(JsonUtils.toJson(multiResult.get(0)));System.out.println(JsonUtils.toJson(multiResult.get(1)));}}输出：[{"col1":1,"col2":2}][{"col1":1,"col3":2}]昨天测试的时候，漏掉了property="colX"导致返回的是[null]，罪过啊。