mybatis比mysql安全吗_MyBatis看这一篇就够了

MyBatis看这一篇就够了

​MyBatis是一个优秀的基于Java的持久层框架，它内部封装了JDBC；试用MyBatis框架开发者只需要关注SQL语句本身。而不需要花费大量精力去处理：加载驱动、创建连接、创建Statement等繁杂过程。

​MyBatis通过xml或者注解的方式将要执行的各种Statement配置起来，并通过Java对象和Statement中SQL的动态参数进行映射生成最终执行的SQL语句，最后由MyBatis框架执行SQL并将结果映射为Java对象返回。

​

MyBatis和传统JDBC比起来，优势在哪里？

数据库创建链接、释放资源造成系统浪费从而影响系统性能；虽然使用连接池也可以解决，但是MyBatis底层帮我们封装好了，简化了操作。

SQL和Java代码耦合在一起，不利于代码的维护，在开发中Java代码变化的可能性不是很大，但是SQL会因为需求经常变化。MyBatis将SQL从代码中剥离，利于项目的维护。

使用PreparedStatement使用占位符的形式不够灵活，经常要加很多判断语句。导致代码可读性，可维护性降低，对于多变的SQL，MyBatis的动态SQL更加灵活。

JDBC查询到RestSet后我们还需要对结果进行提取，而MyBatis支持将结果直接封装为JavaBean、List、Map、Java基本类型等的数据类型。

MyBatis快速入门

1、新建maven工程

2、添加maven的坐标。此处用到了mybatis、mysql-connector-java、junit、log4j

org.mybatis

mybatis

3.4.5

junit

junit

4.10

test

mysql

mysql-connector-java

5.1.6

runtime

log4j

log4j

1.2.12

3、编写实体类，这里简单的编写一个User类

package cn.rayfoo.bean;

import java.io.Serializable;

import java.util.Date;

/**

* @author: rayfoo@qq.com

* @date: 2020/6/6 1:57 上午

* @description:

*/

public class User implements Serializable {

/**用户id*/

private Integer id;

/**用户名*/

private String username;

/**生日*/

private Date birthday;

/**性别*/

private String sex;

/**住址*/

private String address;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public Date getBirthday() {

return birthday;

}

public void setBirthday(Date birthday) {

this.birthday = birthday;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

@Override

public String toString() {

return "User{" +

"id=" + id +

", username='" + username + '\'' +

", birthday=" + birthday +

", sex='" + sex + '\'' +

", address='" + address + '\'' +

'}';

}

public User(Integer id, String username, Date birthday, String sex, String address) {

this.id = id;

this.username = username;

this.birthday = birthday;

this.sex = sex;

this.address = address;

}

public User() {

}

}

4、编写持久层接口UserMapper

package cn.rayfoo.mapper;

import cn.rayfoo.bean.User;

import java.util.List;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 2:12 上午

* @Description: 用户的查询接口

*/

public interface UserMapper {

/**

* 查询所有用户

* @return 返回查询到的所有用户

*/

List findAllUser();

}

5、创建MyBatis全局配置文件和映射文件

/p>

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

/p>

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

select id,username,birthday,sex,address from `user`

6、编写测试类进行测试

package cn.rayfoo.test;

import cn.rayfoo.bean.User;

import cn.rayfoo.mapper.UserMapper;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

import java.util.List;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 10:01 下午

* @Description:

*/

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//1、读取全局配置文件

InputStream conf = Resources.getResourceAsStream("MyBatis-cfg.xml");

//2、创建工厂对象SqlSessionFactory

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(conf);

//3、使用工厂生产SqlSession

SqlSession sqlSession = sqlSessionFactory.openSession();

//4、创建接口的代理类对象

UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

//5、执行查询方法

List allUser = userMapper.findAllUser();

//6、查看结果

for (User user : allUser) {

System.out.println(user);

}

//7、释放资源

sqlSession.close();

conf.close();

}

}

MyBatis执行流程

实现由SQLSessionFactoryBuilder加载配置文件

然后由SQLSessionFactoryBuilder构建一个SqlSessionFactory

SqlSessionFactory生产SqlSession

SqlSession使用Executor来调度MappedStatement执行sql语句

MappedStatement会根据参数类型和返回值类型 执行并且返回对应类型的数据

此处介绍的略为简单，源码级别的分析详见转自CSDN博客

MyBatis配置文件的顺序

MyBatis配置文件是有先后顺序的，如果顺序不对就会报错，所以要注意其顺序问题。


配置打印SQL

在MyBatis中，可以设置打印SQL来检测代码是否正常执行。在MyBatis的全局配置文件中加入如下配置即可。

配置驼峰转下划线

JavaBean中标准的属性命名规则是驼峰式，但是数据库中字段命名一般都由下划线间隔，解决这个问题就需要在MyBatis中配置驼峰转下划线。在MyBatis的全局配置文件的Settings标签中加入如下配置即可。

配置别名

MyBatis中配置别名的方法如下，直接将对应包中的所有类都配置别名

在全局配置文件中加载Mapper文件

使用MyBatis，需要告知其mapper接口对应的配置文件的位置，这个在全局配置文件中配置即可。

如果使用了Spring框架进行整合，就无须在此处配置。

MyBatis中Mapper接口使用JavaBean和Map作为参数

在MyBatis中的Mapper接口方法中，支持JavaBean或者Map作为参数直接传递。使用JavaBean需要设置为parameterType的全类名，使用map则需要设置为java.util.Map。

如果配置了别名，类名和map都可以省略包名使用首字母缩写。

#{}和#{}的区别

{}

使用#{}时，将在SQL作为一个占位符实现PreparedStatment中？的效果，占位符替换后会自动加上一对''

由于是试用占位符的形式，#{}可以防止SQL注入

{}可以接收基本数据类型和JavaBean

如果parameterType传输单个简单类型值，#{}中可以是value或者其他名称

${}

表示拼接SQL串

通过${}可以将parameterType传入的内容拼接在SQL中且不会加上''

${}可以接收基本数据类型和JavaBean

如果parameterType传输单个简单类型值，#{}中只能是value

使用模糊查询时，#{}必须在传参时加匹配符；使用字段名时(例如排序、分组)不能使用#{}只能使用\({}，因为#{}会自动加上''，模糊查询也可以使用\){}直接拼接。

MyBatis中Mapper接口的定义规则

对应的xml文件的namespace必须和Mapper接口所在包名路径一致。

对应的xml文件id必须和接口方法名一致。

parameterType必须和接口方法参数类型一致。

resultType必须和接口方法返回值一致。

接口名尽量和xml文件名保持一致。

parameterType和resultType

前者用于指定输入参数类型，MyBatis通过OGNL从输入对象中获取参数值拼接在SQL中。

后者将MyBatis查询到的结果一行映射为resultType指定的类型对象；如果有多条对象则分行进行映射，并且将对象放入List容器中。

使用Map作为resultType

如果查询的结果是一个JavaBean对象，接口的返回值可以使用该Bean的类型或者Map来接收。如果作为Map接收，其字段名会作为key，值为value。

/**

* 使用JavaBean作为返回值 查询单个

* @param custId

* @return

*/

Hero findHeroById(Integer custId);

/**

* 使用Map作为返回值 查询单个

* @param custId

* @return

*/

Map findHeroById(Integer custId);

select * from `customer` where cust_id = #{value}

select * from `customer` where cust_id = #{value}

JavaBean作为返回值输出结果:

ClassName{column1=value,column2=value}

Map作为返回值输出结果:

{column1=value,column2=value}

如果查询的结果是List，依旧可以使用Map来接收，但是必须在在Mapper的接口方法上加上@MapKey("字段名")来指定key，其中T为该字段的类型。

/**

* 使用Map作为返回值 查询多个

* @return

*/

@MapKey("cust_id")

Map findAllHero();

select * from `customer`

[val1={column1=value,column2=value},val2={column1=value,column2=value},....]

推荐：亦或是使用List>作为返回值来接收

/**

* 使用List>作为返回值 查询多个

* @return

*/

List> findAllHero();

select * from `customer`

[{column1=value,column2=value},{column1=value,column2=value}....]

其打印结果类似于json串

MyBatis中的插入、删除和更新

insert、update、delete和查询基本一致不做太多说明。

注意点：

1、插入、删除、更新时的#{}以parameterType的属性名称对应，表名后的字段与数据库字段名保持一致。

2、一定要commit，否则数据库不会更新。

3、如果插入中文乱码，请检查数据库的url是否是characterEncoding=utf8，项目的编码是否为UTF8。

4、这三者一般都不设置resultType，默认返回值都是执行sql后数据库修改的行数。

案例：

insert into `customer`(cust_name,cust_profession,cust_phone,email)

values(#{custName},#{custProfession},#{custPhone},#{email})

MyBatis获取自增主键

方法1、在insert标签中加入子标签

select LAST_INSERT_ID()

方法2、设置insert标签的几个属性

​useGeneratedKeys设置为true

​keyProperty为数据库中主键字段的名称

​keyColumn为数据库中主键字段的名称

useGeneratedKeys="true" keyProperty="id" keyColumn="id"

方法2在MyBatis3.4.0以后的版本支持批量插入获取id，使用方法和普通的插入一致，主键会自动放入parameterType对应集合中对象的每一个id中。

public void addUserBatch(List list) {

this.getSqlSession().insert("userMapper.addUserBatch",list);

System.out.println(Arrays.toString(list.toArray()));

}

insert user(user_name,pass_word,address) values

( #{item.userName},#{item.passWord},#{item.address} )

MyBatis工具类

在使用MyBatis的过程中，我们需要频繁的加载配置文件，创建SqlSession等的繁杂过程，这就和原生JDBC一样有些累赘了，所以我们可以创建一个MyBatis工具类来简化这些重复的操作。

当然了，在和Spring整合后同样可以摒弃这些复杂的操作。

package cn.rayfoo.util;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;

import java.io.InputStream;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/8 10:37 下午

* @Description: Mybatis工具类

*/

public class MyBatisUtils {

/**

* 加载配置文件

*/

private static InputStream conf = null;

/**

* SqlSession工厂

*/

private static SqlSessionFactory sqlSessionFactory = null;

/**

* SqlSession

*/

public static SqlSession sqlSession = null;

/**

* Session状态，true为开启中，false为已经关闭

*/

private static boolean sessionStatus = true;

static {

//1、读取全局配置文件

try {

conf = Resources.getResourceAsStream("MyBatis-cfg.xml");

} catch (IOException e) {

e.printStackTrace();

}

//2、创建工厂对象SqlSessionFactory

sqlSessionFactory = new SqlSessionFactoryBuilder().build(conf);

//3、使用工厂生产SqlSession

sqlSession = sqlSessionFactory.openSession();

}

/**

* 获取工厂信息

* @param clazz Mapper的字节码文件

* @return

*/

public static Object getMapper(Class clazz){

//1、如果Session为空或者已经关闭，则重新生产一个Session

if(!sessionStatus){

sqlSession = sqlSessionFactory.openSession();

}

//返回Mapper

return sqlSession.getMapper(clazz);

}

/**

* 返回一个sqlSession

* @return

*/

public static SqlSession getSqlSession(){

//1、如果Session为空或者已经关闭，则重新生产一个Session

if(!sessionStatus){

sqlSession = sqlSessionFactory.openSession();

}

return sqlSession;

}

/**

* 提交、销毁SqlSession

*/

public static void destory(){

//提交、关闭sqlSession

sqlSession.commit();

sqlSession.close();

try {

//关闭文件流

conf.close();

} catch (IOException e) {

e.printStackTrace();

}

sessionStatus = false;

}

private MyBatisUtils(){

}

}

测试工具类

package cn.rayfoo.test;

import cn.rayfoo.bean.Hero;

import cn.rayfoo.mapper.HeroMapper;

import cn.rayfoo.util.MyBatisUtils;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 10:01 下午

* @Description: 测试类

*/

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

HeroMapper mapper = (HeroMapper) MyBatisUtils.getMapper(HeroMapper.class);

//创建一个英雄

Hero hero = new Hero("龙女","战士","10086","rayfoo@qq.com");

//添加英雄

mapper.insertCustomer(hero);

//提交事务

MyBatisUtils.destory();

}

}

Mapper接口中多参数问题

在开发过程中Mapper接口难免会遇到需要多个参数的时候，那么此时在xml中如何映射呢？

1、在MyBatis中，Mapper接口中的方法如果使用了多个参数，MyBatis会将这些参数打包到一个Map中，Map的key是param1、param2。。。以此类推，值也就是参数对应的值。MyBatis也允许使用#{arg0}、#{arg1}。。。的形式，如果是对象类型，就要使用#{param1.属性名}

2、MyBatis中还可以使用@Param注解来指定该属性的Key值，直接在参数之前加上@Param("key")即可。如果指定自定义key，仍然可以使用param1、param2。。的形式，但是不再允许使用arg0、arg1。。的形式了。

3、注意：尽量不要使用arg0、arg1。。。的形式，param是从1开始，arg是从0开始。

resultMap

resultType使用JavaBean作为返回值时，要求JavaBean的属性名和数据库字段名保持一致(驼峰转下划线为特例)，使用resultMap可以解决这个问题。它的一大作用就是来映射数据库的字段名和JavaBean的属性名。如果查询时只想查询部分字段，同样可以使用resultMap来实现。

在Mapper接口对应的XML文件中加入resultMap标签，一般写在xml的最上方且命名为javaBean首字母小写+Map的形式。

其id属性必须唯一，可以被其他标签的resultMap属性指定。

type属性用于指定其对应的JavaBean的全类名(或者别名，但必须配置别名)。

id子标签用于指定数据库中的主键

result子标签用于指定数据库中普通字段

如果映射的不是全部字段，则查询时不会查询没有被映射的字段。

id和result都存在column和property两个属性，其中column映射数据库字段名，property映射JavaBean的属性名。

id和result都存在javaType和jdbcType两个属性，分别用来指定该标签中数据库和Java类型的属性，如果是一般类型的数据，这两个属性可以省略。

多表操作

一对多关系

在数据库中，经常会遇到一对多查询，那么常见的一对多关系比如部门>员工，班级>学员。。等等。遇到这类的数据库关系，就需要进行一对多映射。

一对多关系如何在数据库中建立？

在一对多关系中，通常会在多的一方建立一个外键用于保存一的一方的主键。

例如已有客户表，现在建立一个订单表，那么客户表无需更改，只需要在新建立的订单表中加入order原有的"order_id"、“order_name”、“order_num”以及"cust_id"四个字段即可。其中“cust_id”添加外键约束。

一对一关系如何在Java中映射？

在java类中，如果要映射一对多关系，一般是在多的一方中取消一对多中的“一方”外键属性的声明，使用一对多中的“一方”所在的java类取代。

public class Order {

/** 订单号 */

private Integer orderId;

/** 订单名称 */

private String orderName;

/** 订单金额 */

private Double orderPrice;

/** 下单人 */

private Customer customer;

getter setter 构造...

}

一对多关系如何在MyBatis中映射？

MyBatis中映射对多关系有多种方法，其中比较简单易于理解的就是使用连缀的方式，映射多对一中的“一方”的字段和属性。

案例：

select * from `order` o left join `customer` c on o.cust_id = c.cust_id

public interface OrderMapper {

List findOrders();

}

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

OrderMapper mapper = (OrderMapper) MyBatisUtils.getMapper(OrderMapper.class);

//获取全部订单

List orders = mapper.findOrders();

for (Order order : orders) {

System.out.println(order);

}

//销毁

MyBatisUtils.destory();

}

}

不映射直接使用Map同样可以解多对一多映射问题

select * from `order` o left join `customer` c on o.cust_id = c.cust_id

public interface OrderMapper {

List> findAllOrder();

}

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

OrderMapper mapper = (OrderMapper) MyBatisUtils.getMapper(OrderMapper.class);

//获取全部订单

List> allOrder = mapper.findAllOrder();

for (Map item : allOrder) {

System.out.println(item);

}

//销毁

MyBatisUtils.destory();

}

}

{cust_profession=战士, order_price=1536.29, cust_name=龙女, order_id=1, cust_id=13, cust_phone=10086, email=rayfoo@qq.com, order_name=花呗还款}

{cust_profession=战士, order_price=4000.0, cust_name=龙女, order_id=2, cust_id=14, cust_phone=10086, email=rayfoo@qq.com, order_name=基金加仓}

{cust_profession=战士, order_price=3298.0, cust_name=龙女, order_id=3, cust_id=13, cust_phone=10086, email=rayfoo@qq.com, order_name=购买手机}

使用association映射多对一关系

MyBatis提供的对多映射的另一种方式就是使用association，在resultMap中加入association子标签，在该标签中添加property和javaType，分别映射一对多中的“一方”在java类中的属性名，和其类型。在association中可以继续添加id和result来映射一对多中的“一方”。

association级联查询-分步查询

在association标签中，存在一个select属性，其值可以指定一个查询方法的id，如果该查询需要使用到参数，还可以指定column属性为查询参数。

select="cn.rayfoo.mapper.CustomerMapper.findCustomer" column="cust_id">

association级联查询-分步查询-懒加载

使用association进行分步查询，默认是查询时一定会执行select中的语句，无论是否用到了association中的元素。开启懒加载可以实现当用到association中的元素时执行才执行其对应的select语句。

修改mybatis的全局配置文件即可，当mybatis3.4.1以前都为true，之后的版本默认为false

但是当调用toString方法时，不管是否使用了association中映射的属性值，都会触发延迟加载，去掉lazyLoadTriggerMethods的value中的toString即可。

一对多的添加操作

对于一对多映射中的添加操作，应该先添加一的一方获取到一的一方的id才能添加多的一方。例如存在客户表和订单表，要进行客户和订单的添加，那么就需要先添加客户，获取客户的自增id，才能进而添加订单。

insert into `customer`(cust_name,cust_profession,cust_phone,email)

values(#{custName},#{custProfession},#{custPhone},#{email})

insert into `order`(order_name,order_price,cust_id)

values(#{orderName},#{orderPrice},#{customer.custId})

package cn.rayfoo.test;

import cn.rayfoo.bean.Customer;

import cn.rayfoo.bean.Order;

import cn.rayfoo.mapper.CustomerMapper;

import cn.rayfoo.mapper.OrderMapper;

import cn.rayfoo.util.MyBatisUtils;

import java.util.List;

import java.util.Map;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 10:01 下午

* @Description: 测试类

*/

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

CustomerMapper customerMapper = (CustomerMapper) MyBatisUtils.getMapper(CustomerMapper.class);

OrderMapper orderMapper = (OrderMapper) MyBatisUtils.getMapper(OrderMapper.class);

//创建顾客

Customer customer = new Customer("盖伦","战士","10011","rayfooQqq.com");

customerMapper.insertCustomer(customer);

//创建订单

Order order1 = new Order("MacBook Pro",888.88,customer);

Order order2 = new Order("MacBook Air",999.99,customer);

orderMapper.insertOrder(order1);

orderMapper.insertOrder(order2);

//销毁

MyBatisUtils.destory();

}

}

一对多的查询操作

当映射的一方是多的一方，JavaBean中使用List来映射，resultMap也不能使用association了，association替换为collection，javaType替换为ofType，其余都没有变化。

分步查询并不见得更快，要结合实际的使用情况，分步查询会发送更多次的sql(每一条数据都会发送一条sql，相当于sql的循环调用)，但是分步查询支持懒加载。

select * from `customer` as c left join `order` as o on c.cust_id = o.cust_id

package cn.rayfoo.test;

import cn.rayfoo.bean.Customer;

import cn.rayfoo.mapper.CustomerMapper;

import cn.rayfoo.util.MyBatisUtils;

import java.util.List;

import java.util.Map;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 10:01 下午

* @Description: 测试类

*/

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

CustomerMapper customerMapper = (CustomerMapper) MyBatisUtils.getMapper(CustomerMapper.class);

List allCustomer = customerMapper.findAllCustomer();

for (Customer customer : allCustomer) {

System.out.print(customer);

}

//销毁

MyBatisUtils.destory();

}

}

一对多分步查询(不建议使用)

select * from `order` where order_id = #{value}

/**

* 根据cust_id查询

* @param cust_id

* @return

*/

List findOrderById(Integer cust_id);

package cn.rayfoo.test;

import cn.rayfoo.bean.Customer;

import cn.rayfoo.bean.Order;

import cn.rayfoo.mapper.CustomerMapper;

import cn.rayfoo.mapper.OrderMapper;

import cn.rayfoo.util.MyBatisUtils;

import java.util.List;

import java.util.Map;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 10:01 下午

* @Description: 测试类

*/

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

CustomerMapper customerMapper = (CustomerMapper) MyBatisUtils.getMapper(CustomerMapper.class);

List allCustomer = customerMapper.findAllCustomer();

for (Customer customer : allCustomer) {

System.out.println(customer);

}

//销毁

MyBatisUtils.destory();

}

}

一对多删除

此时需要注意，如果用户已经不存在了，那么它对应的订单就是垃圾数据了，此时删除用户后应该同时删除掉用户的订单数据。

如果只想删除客户，不删除其关联的订单，可以先打破订单和客户之间的关系。使用update语句将符合条件的客户编号外键改为null即可。

多对多关系

在数据库中，也会遇到一对多查询，那么常见的多对多关系比如老师-学生，学生-课程，用户-角色。。等等。遇到这类的数据库关系，就需要进行多对多映射。

多对多建表原则

多对多关系，一般会建立一个中间表，中间表中创建两个外键存储两个表的主键。

例如现在存在学生表、教师表、则需要创建中间表教师_学生。

-- student table

create table student

(

student_id int auto_increment

primary key,

student_name varchar(20) null

);

-- teacher table

create table teacher

(

teacher_id int auto_increment

primary key,

teacher_name varchar(20) null

);

-- teacher_student table

create table teacher_student

(

id int auto_increment

primary key,

student_id int null,

teacher_id int null,

constraint teacher_student_student_student_id_fk

foreign key (student_id) references student (student_id),

constraint teacher_student_teacher_teacher_id_fk

foreign key (teacher_id) references teacher (teacher_id)

);

在javaBean中创建实体时，无需创建中间表的Bean对象。只需要创建Student、Teacher即可。

在MyBatis的映射中，我们可以将多对多转换为两个一对多，在两方别进行对多映射即可。和一对多的不同之处只有SQL语句。多对多同样支持分步查询。

多对多的添加分为三步，添加学生、添加老师、添加中间表。关系表的插入可以在学生、老师任意一段进行。

/**

* 添加一个学生

* @param student

*/

void insertStudent(Student student);

/**

* 更新学生和老师的关系

* @param teacherId

* @param studentId

*/

void updateRelation(@Param("teacherId") Integer teacherId, @Param("studentId") Integer studentId);

/**

* 添加一个教师

* @param teacher

*/

void insertTeacher(Teacher teacher);

insert into student(student_name) values(#{studentName})

insert into teacher_student(teacher_id,student_id)

values(#{teacherId},#{studentId})

insert into teacher(teacher_name) values(#{teacherName})

package cn.rayfoo.test;

import cn.rayfoo.bean.Customer;

import cn.rayfoo.bean.Order;

import cn.rayfoo.bean.Student;

import cn.rayfoo.bean.Teacher;

import cn.rayfoo.mapper.CustomerMapper;

import cn.rayfoo.mapper.OrderMapper;

import cn.rayfoo.mapper.StudentMapper;

import cn.rayfoo.mapper.TeacherMapper;

import cn.rayfoo.util.MyBatisUtils;

import java.util.List;

import java.util.Map;

/**

* @Author: rayfoo@qq.com

* @Date: 2020/6/6 10:01 下午

* @Description: 测试类

*/

public class MyBatisTest {

public static void main(String[] args) throws Exception {

//获取Mapper

TeacherMapper teacherMapper = (TeacherMapper) MyBatisUtils.getMapper(TeacherMapper.class);

StudentMapper studentMapper = (StudentMapper) MyBatisUtils.getMapper(StudentMapper.class);

//创建学生和老师

Student student = new Student("全浩");

Teacher teacher1 = new Teacher("李怡霖");

Teacher teacher2 = new Teacher("闫洪波");

//添加

studentMapper.insertStudent(student);

teacherMapper.insertTeacher(teacher1);

teacherMapper.insertTeacher(teacher2);

//更新关系

studentMapper.updateRelation(teacher1.getTeacherId(),student.getStudentId());

studentMapper.updateRelation(teacher2.getTeacherId(),student.getStudentId());

//销毁

MyBatisUtils.destory();

}

}

MySQL insert语句中中value和values的区别

这里补充一个知识点，在MySQL的insert语句中使用value和values都可以，建议在插入单行的时候使用VALUES，在插入多行的时候使用VALUE;在大多数情况下使用这样的方案效率比较高。而SQL Server中只支持values关键字。

动态SQL

MyBatis中提供了动态SQL的机制，所谓动态sql其实就是动态的拼接sql。MyBatis为我们提供了很多的标签，可以实现类似于java代码中的选择、分支、 循环等功能。通过这些标签可以动态的拼接sql。

if标签

if标签用于判断一个布尔值或者布尔表达式，来判定是否拼接标签内的SQL。一般用于where后条件的非空、忽略等判断。一般都会配合where标签一起使用。

where标签

在使用if标签的过程中会遇到一些问题，比如当if的test都为false时，就会多出一个where标签，当第一个条件为空时，就会多出一个and标签。此时就需要用到where标签

where标签可以自动的生成和删除where关键字、还可以删除where后第一个and关键字。

所以在使用where和if标签的时候 ， 尽量使用前置and，不要使用后置and。

trim标签

此标签可以代替where标签来使用，主要的功能是对前缀、后缀的一些操作。

select * from `customer`

and cust_name = #{custName}

and profession = #{profession} and

此案例中，会在条件之前增加where，去掉条件之前的and、条件之后的and。

choose when otherwise标签

这个标签类似于java中的if else

当when中test的条件成立就只执行when中的语句，不再继续执行。否则执行otherwise中的内容。

其中when可以存在多个，otherwise只能存在一个。

select * from `customer`

and custName = #{cust_name}

and profession = #{profession}

and 1=1

set标签

在update的操作中 set后同样可以使用if来进行判断，此时如果存在多个if，就可能会出现多出“逗号”的情况，此时可以使用set标签来代替set关键字，set标签可以帮我们去掉最后一个逗号。一般使用set标签时，逗号都放在后面。

update `customer`

cust_name = #{custName},

cust_profession = #{custProfession}

cust_id = #{custId}

foreach标签

当查询的内容是多个时，可以使用foreach标签。foreach标签可以遍历list或者array类型的数据。

collection属性：指定参数类型，可选list和array，如果是array，那mybatis标签中的参数类型需要指定为对应类型的数组形式，例如parameterType="Integer[]",list则需要设置为java.util.List

open属性：开始标志一般用(

close属性：结束标志一般用)

separator属性：间隔符 一般用逗号

item属性：迭代变量 任意名称

在标签体内可以直接使用#{item对应的值}进行遍历

select * from `customer`

`cust_id` in

#{id}

foreach的高级用法：如果要遍历一个bean对象中的array或者list类型的属性，需要先将parameterType=指定为该对象。collection则指定此属性 其他用法相同。

select * from `customer`

`cust_id` in

#{id}

bind标签

该标签可以取出传入的值，重新处理，赋值给另一个值。

注意点：如果是普通类型的单值，必须加@Param注解，才能正常取出。如果是对象直接可以获取。

SQL片段

动态SQL支持将一段SQL封装为一个片段，此片段可以在多处执行。

用法：使用标签创建sql片段，使用引入。

sql片段中可以使用choose、if、等的逻辑判断

缓存机制

MyBatis中使用了缓存机制来提高性能，当查询数据时，会先从缓存中取出数据，如果缓存中没有，再到数据库中查询。

MyBatis中的缓存有两种：一级缓存和二级缓存

一级缓存

一级缓存是SqlSession(一次会话)级别的，二级缓存是Mapper级别的。

一级缓存默认是开启的状态，在SqlSession没有关闭之前，再去查询时，会从缓存中取出数据，不会重新发送新的sql。

一级缓存的失效：发生如下场景时，一级缓存会失效。

如果在下次查询之前进行了增、删、改操作，缓存就会失效。

手动清空了缓存(sqlSession.clearCache()方法)

两次查询的条件不一样，缓存也会失效

如果两个查询在不同的SqlSession当中

二级缓存

二级缓存是全局作用域缓存，一个namespace对应一个缓存，如果会话关闭，一级缓存的数据会被保存到二级缓存中，不同的namespace查出的数据，也会放到自己对应的缓存中，默认也是打开的，早期版本呢是false。

二级缓存使用的注意事项

1、确保全局配置文件中已经打开了二级缓存，settings->setting->cacheEnable == true

2、在对应的mapper中添加cache标签

​属性介绍

​eviction:回收策略LRU(默认)【移除最近最少使用】、FIFO【先进先出】、SOFT、WEAK

​flushInterval：刷新间距，单位是毫秒，默认不清空

​readOnly：是否只读，取值为true或false，为true是只读mybatis会直接给缓存的引用不安全，但是速度快，非只读mybatis会利用序列化和反序列化复制一份 速度慢

​size：可以存放多少个元素 默认的即可，也不能设置的太大，太大容易溢出

​type：可以用来指定自定义的缓存，例如redis

3、JavaBean要实现Serializable接口，因为readOnly设置为只读的话，需要进行复制操作。

注意：只要会话关闭后一级缓存中数据才会保存到二级缓存中！

缓存的相关配置

是否可以设置每个mapper方法的缓存是否开启？

在MyBatis的mapper方法中，可以单独的设置是否需要开启缓存，它的优先级是最高的。但是它只能控制二级缓存是否有用，无法影响一级缓存。

如何清空二级缓存？

增删改查标签中存在一个flushCache属性，默认为true，作用是清空一级、二级缓存。

可以手动调用sqlSession.clearCache()手动清空一级缓存。

如何禁用一级缓存？

在settings->setting->localCacheScope设置为STATEMENT，默认为SESSION，设置为STATEMENT可以关闭一级缓存。

缓存使用顺序

1、先到二级缓存找

2、二级缓存没有就去一级缓存找

3、一级缓存也没有就去数据库中找