MyBatis

愚笨难解

已于 2023-01-07 10:31:15 修改

阅读量235

点赞数

分类专栏： SpringMVC 文章标签： mybatis

于 2021-03-20 07:43:32 首次发布

本文链接：https://blog.csdn.net/suo_jia_hao/article/details/115019771

版权

SpringMVC 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

MyBatis

MyBatis是一个实现了数据持久化的开源框架,简单理解就是对JDBC进行封装

SQL语句写在XML里面,从程序代码中分离,降低耦合度,但是SQL语句编写工作量大,依赖于底层数据库,不能随意更换

ORMapping: Object Relationship Mapping 对象关系映射

对象指⾯向对象

关系指关系型数据库

Java 到 MySQL 的映射，开发者可以以⾯向对象的思想来管理数据库。

如何使⽤
新建 Maven ⼯程，pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.southwind</groupId>
    <artifactId>aimybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
		<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

<!--    在maven工程里,只能读取resouces目录下的xml文件,加上以下build就可以读取java目录下的文件-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

新建数据表

use mybatis;
create table t_account(
 id int primary key auto_increment,
 username varchar(11),
 password varchar(11),
 age int
)

新建数据表对应的实体类Account

package com.southwind.entity;
import lombok.Data;
@Data
public class Account {
	 private long id;
	 private String username;
	 private String password;
	 private int age; 
 }

在resources中创建 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>
    <!-- 配置MyBatis运⾏环境 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- POOLED配置JDBC数据源连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"></property>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC&amp;useSSL=false"></property>
                <property name="username" value="root"></property>
                <property name="password" value="199810"></property>
            </dataSource>
        </environment>
    </environments>
</configuration>

使⽤原⽣接⼝

1、MyBatis 框架需要开发者⾃定义 SQL 语句，写在 Mapper.xml ⽂件中，实际开发中，会为每个实体类创建对应的 Mapper.xml ，定义管理该对象数据的 SQL。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--        namespace此xml文件路径,表示被映射的位置-->
<mapper namespace="com.southwind.mapper.AccountMapper">
<!--    insert添加数据  id为save  parameterType表示以实体类Account为对象添加数据-->
    <insert id="save" parameterType="com.southwind.entity.Account">
--         sql语句 因为Account已经变成对象,添加的数据只要从Account类中调用即可,#{}可以直接调用类对象
        insert into t_account(username,password,age) values (#{username},#{password},#{age})
    </insert>
</mapper>

namespace 通常设置为⽂件所在包+⽂件名的形式。
insert 标签表示执⾏添加操作。
select 标签表示执⾏查询操作。
update 标签表示执⾏更新操作。
delete 标签表示执⾏删除操作。
id 是实际调⽤ MyBatis ⽅法时需要⽤到的参数。
parameterType 是调⽤对应⽅法时参数的数据类型。

2、在全局配置⽂件 confifig.xml 中注册 AccountMapper.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>
    <!-- 配置MyBatis运⾏环境 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置JDBC事务管理 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- POOLED配置JDBC数据源连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"></property>
                <property name="url"
                          value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"></property>
                <property name="username" value="root"></property>
                <property name="password" value="199810"></property>
            </dataSource>
        </environment>
    </environments>
<!--    注册AccountMapper.xml-->
    <mappers>
<!--        文件带着后缀.xml所以用/分割-->
        <mapper resource="com/southwind/mapper/AccountMapper.xml"></mapper>
    </mappers>
</configuration>

3、调⽤ MyBatis 的原⽣接⼝执⾏添加操作。

public class Test {
    public static void main(String[] args) {
        //加载MyBatis的配置文件
        //先读取配置文件为数据流
        InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
        System.out.println(inputStream);
        //1.先实例化  sql会话工厂建造类  SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //2.通过建造类Builder以 inputStream数据流为对象 创建 sql会话工厂 sqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //3.通过工厂对象的openSession()方法创建 SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //statement为即将要加载的AccountMapper.xml中的sql语句位置信息
        String statement = "com.southwind.mapper.AccountMapper.save";
        //实例化实体类对象
        Account account = new Account(1,"张三","123123",22);
        //把statement位置和account对象都传进去
        sqlSession.insert(statement,account);
        //提交事务
        sqlSession.commit();

    }
}

通过 Mapper 代理实现⾃定义接⼝

⾃定义接⼝，定义相关业务⽅法。
编写与⽅法相对应的 Mapper.xml。
1、⾃定义接⼝

package com.southwind.repository;
import com.southwind.entity.Account;
import java.util.List;
public interface AccountRepository {
 	public int save(Account account);//增
    public int update(Account account);//改
    public long deleteById(long id);//通过id删除对象
    public List<Account> findAll();//查询所有结果
    public Account fondById(long id);通过id查询结果
}

2、创建接⼝对应的 Mapper.xml，定义接⼝⽅法对应的 SQL 语句。

statement 标签可根据 SQL 执⾏的业务选择 insert、delete、update、select。

MyBatis 框架会根据规则⾃动创建接⼝实现类的代理对象。

规则：

Mapper.xml 中 namespace 为接⼝的全类名。
Mapper.xml 中 statement 的 id 为接⼝中对应的⽅法名。
Mapper.xml 中 statement 的 parameterType 和接⼝中对应⽅法的参数类型⼀致。
Mapper.xml 中 statement 的 resultType 和接⼝中对应⽅法的返回值类型⼀致。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--此文件虽然是xml文件,但本质是一个mapper文件-->
<mapper namespace="com.southwind.repository.AccountRepository">
    <insert id="save" parameterType="com.southwind.entity.Account">
        insert into t_account(username,password,age) values(#{username},#{password},#{age})
    </insert>
    <update id="update" parameterType="com.southwind.entity.Account">
        update t_account set username = #{username},password = #{password},age = #{age} where id = #{id}
    </update>
    <delete id="deleteById" parameterType="long">
        delete from t_account where id = #{id}
    </delete>
    <select id="findAll" resultType="com.southwind.entity.Account">
        select * from t_account
    </select>
    <select id="findById" parameterType="long" resultType="com.southwind.entity.Account">
        select * from t_account where id = #{id}
    </select>
</mapper>

3、在 confifig.xml 中注册 AccountRepository.xml

<!-- 注册AccountMapper.xml -->
<mappers>
 <mapper resource="com/southwind/mapper/AccountMapper.xml"></mapper>
 <mapper resource="com/southwind/repository/AccountRepository.xml"></mapper>
</mappers>

4.创建一个MyBatisUtils工具类专门写配置代码

package com.southwind.utils;

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;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
        String resource = "config.xml";
        try {
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //返回一个sqlsession对象
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

5、调⽤接⼝的代理对象完成相关的业务操作

package com.southwind.test;

import com.southwind.entity.Account;
import com.southwind.repository.AccountRepository;
import com.southwind.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

/****通过 Mapper 代理实现⾃定义接⼝**
 * 1.实体类Account
 * 2.repository中创建接口及其方法
 * 3.接口同包下创建mapper动态代理
 * 4.在resources资源中配置config.xml
 * 5.创建调⽤接⼝的代理对象完成相关的业务操作
 */

public class Test2 {
    @Test
    public void testAccount(){
        //通过MyBatisUtils调用配置文件获取一个SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();

        ///通过反射获取实现接口的代理对象
        AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);

        //代理对象可以直接对mapper进行操作
        //添加
        Account account = new Account(4L,"张三","222222",22);
        int result = accountRepository.save(account);//返回影响的行数
        System.out.println("影响了"+result+"行");
        sqlSession.commit();
        //通过id查找
        account = accountRepository.findById(7L);
        System.out.println(account);

        //关闭
        sqlSession.close();
    }

}

Mapper.xml

statement 标签：select、update、delete、insert 分别对应查询、修改、删除、添加操作。
parameterType：参数数据类型

1、基本数据类型，通过 id 查询 Account

<select id="findById" parameterType="long" resultType="com.southwind.entity.Account">
 select * from t_account where id = #{id}
</select>

2、String 类型，通过 name 查询 Account

<select id="findByName" parameterType="java.lang.String" resultType="com.southwind.entity.Account"> 
    select * from t_account where username = #{username}
</select>

3、包装类，通过 id 查询 Account

<select id="findById2" parameterType="java.lang.Long" resultType="com.southwind.entity.Account">
 select * from t_account where id = #{id}
</select>

4、多个参数，通过 name 和 age 查询 Account(parameterType只允许有一个,而name和age分别是String和int类型,所以干脆不写parameterType)(param和arg都可以按顺序读取参数,但是param从1开始,arg从0开始)

<select id="findByNameAndAge" resultType="com.southwind.entity.Account">
 select * from t_account where username = #{arg0} and age = #{arg1}
</select>

5、Java Bean(参数对象类型)

<update id="update" parameterType="com.southwind.entity.Account">
 update t_account set username = #{username},password = #{password},age = #{age} where id = #{id}
</update>

resultType：结果类型
1、基本数据类型，统计 Account 总数

<select id="count" resultType="int">
 select count(id) from t_account
</select>

2、包装类，统计 Account 总数

<select id="count2" resultType="java.lang.Integer">
 select count(id) from t_account
</select>

4、Java Bean

<select id="findById" parameterType="long" resultType="com.southwind.entity.Account">
 select * from t_account where id = #{id}
</select>

及联查询

⼀对多
Student

package com.southwind.entity;
import lombok.Data;
@Data
public class Student {
 	private long id;
 	private String name;
 	private Classes classes;
}

Classes

package com.southwind.entity;
import lombok.Data;
import java.util.List;
@Data
public class Classes {
 	private long id;
 	private String name;
 	private List<Student> students;
}

StudentRepository

package com.southwind.repository;
import com.southwind.entity.Student;
public interface StudentRepository {
 	public Student findById(long id);
}

StudentRepository.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.southwind.repository.StudentRepository">
    <!--    当结果集中出现重名的列-->
    <resultMap id="studentMap" type="com.southwind.entity.Student">
        <!--        id主键,result其他的-->
        <id column="id" property="id"></id>
        <result column="name" property="name"></result>
        <!--一个学生只对应一个班级,一对一用association-->
        <association property="classes" javaType="com.southwind.entity.Classes">
            <id column="cid" property="id"></id>
            <result column="cname" property="name"></result>
        </association>
    </resultMap>

    <select id="findById" parameterType="long" resultMap="studentMap">
        select s.id,s.name,c.id as cid,c.name as cname from student s,classes c where s.id = #{id} and s.cid = c.id
    </select>
</mapper>

ClassesRepository

package com.southwind.repository;
import com.southwind.entity.Classes;
public interface ClassesRepository {
 	public Classes findById(long id);
}

ClassesRepository.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--此文件虽然是xml文件,但本质是一个mapper文件-->
<mapper namespace="com.southwind.repository.Classesrepository">
    <!--    当结果集中出现重名的列-->
    <resultMap id="classesMap" type="com.southwind.entity.Classes">
        <!--把cid当主键,result其他的列-->
        <id column="cid" property="id"></id>
        <result column="cname" property="name"></result>
        <!--由于一个班级可能有多个学生,所以用集合存储    一对多集合  students对应实体类Classes中的students-->
        <collection property="students" ofType="com.southwind.entity.Student">
            <id column="id" property="id"/>
            <result column="name" property="name"/>
        </collection>
    </resultMap>

<!--    由于一对多,所以不再是resultType而是resultMap="classesMap",classesMap与上面的id对应-->
    <select id="findById" parameterType="long" resultMap="classesMap">
        select s.id,s.name,c.id as cid,c.name as cname from student s,classes c where c.id = #{id} and s.cid=c.id
    </select>
</mapper>

多对多(多对多建立一个中间表,中间表联系着两个多对多表,最后把结果集通过映射与实体集对应起来)

多对多本质还是一对多,最终关联的是实体类表,需要把查找的视图转成实体类对应的属性
Customer

package com.southwind.entity;
import lombok.Data;
import java.util.List;
@Data
public class Customer {
 private long id;
 private String name;
 private List<Goods> goods;
}

Goods

package com.southwind.entity;
import lombok.Data;
import java.util.List;
@Data
public class Goods {
 private long id;
 private String name;
 private List<Customer> customers;
}

CustomerRepository

package com.southwind.repository;
import com.southwind.entity.Customer;
public interface CustomerRepository {
 public Customer findById(long id);
}

CustomeRepository.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--此文件虽然是xml文件,但本质是一个mapper文件-->
<mapper namespace="com.southwind.repository.CustomeRepository">
    <!--    当结果集中出现重名的列-->
    <resultMap id="customerMap" type="com.southwind.entity.Customer">
        <id column="cid" property="id"></id>
        <result column="cname" property="name"></result>
        <collection property="goods" ofType="com.southwind.entity.Goods">
            <id column="gid" property="id"/>
            <result column="gname" property="name"/>
        </collection>
    </resultMap>

    <!--    把结果集通过映射与实体集对应起来-->
    <select id="findById" parameterType="long" resultMap="customerMap">
        select c.id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where c.id=#{id} and cg.cid = c.id and cg.gid = g.id;
    </select>
</mapper>

GoodsRepository

package com.southwind.repository;
import com.southwind.entity.Goods;
public interface GoodsRepository {
 	public Goods findById(long id);
}

GoodsRepository.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.southwind.repository.GoodsRepository">

    <resultMap id="goodsMap" type="com.southwind.entity.Goods">
        <id column="gid" property="id"/>
        <result column="gname" property="name"/>
        <collection property="customers" ofType="com.southwind.entity.Customer">
            <id column="cid" property="id"/>
            <result column="cname" property="name"/>
        </collection>
    </resultMap>


    <select id="findById" resultMap="goodsMap">
        select c.id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where g.id=3 and cg.cid = c.id and cg.gid = g.id;
    </select>
</mapper>

逆向⼯程(不能在中文路径下创建)

MyBatis 框架需要：实体类、⾃定义 Mapper 接⼝、Mapper.xml

传统的开发中上述的三个组件需要开发者⼿动创建，逆向⼯程可以帮助开发者来⾃动创建三个组件，减轻开发者的⼯作量，提⾼⼯作效率。

如何使⽤

MyBatis Generator，简称 MBG，是⼀个专⻔为 MyBatis 框架开发者定制的代码⽣成器，可⾃动⽣成MyBatis 框架所需的实体类、Mapper 接⼝、Mapper.xml，⽀持基本的 CRUD 操作，但是⼀些相对复杂的 SQL 需要开发者⾃⼰来完成。

新建 Maven ⼯程，pom.xml

<dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
<!--        逆向工程引用包-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
        </dependency>

    </dependencies>

创建 MBG 配置⽂件 generatorConfifig.xml

1、jdbcConnection 配置数据库连接信息。

2、javaModelGenerator 配置 JavaBean 的⽣成策略。

3、sqlMapGenerator 配置 SQL 映射⽂件⽣成策略。

4、javaClientGenerator 配置 Mapper 接⼝的⽣成策略。

5、table 配置⽬标数据表（tableName：表名，domainObjectName：JavaBean 类名）。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
<!--    context全局类配置 targetRuntime="MyBatis3"必须写这样-->
    <context id="testTables" targetRuntime="MyBatis3">

        <jdbcConnection
                driverClass="com.mysql.cj.jdbc.Driver"
                connectionURL="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;useSSL=false&amp;serverTimezone=UTC"
                userId="root"
                password="199810">
        </jdbcConnection>
        <!--实体类信息,配置 JavaBean 的⽣成策略-->
        <javaModelGenerator targetPackage="com.southwind.entity" targetProject="./src/main/java"></javaModelGenerator>
        <!--配置 SQL 映射⽂件⽣成策略。-->
        <sqlMapGenerator targetPackage="com.southwind.repository" targetProject="./src/main/java"></sqlMapGenerator>
        <!--配置 Mapper 接⼝的⽣成策略。-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.southwind.repository" targetProject="./src/main/java"></javaClientGenerator>
        <!--将要映射的表t_user,映射生成的实体类名字User-->
        <table tableName="t_user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

配置逆向工程时在connectionURL中要加上serverTimezone=UTC且不能在中文路径下

创建 Generator 执⾏类。

package test;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> warings = new ArrayList<>();
        Boolean overwrite = true;
//        配置文件路径
        String genCig = "/generatorConfig.xml";
//        根据配置文件创建一个file
        File configFile = new File(Main.class.getResource(genCig).getFile());
        ConfigurationParser configurationParser = new ConfigurationParser(warings);
        Configuration configuration = null;
        try {
            configuration = configurationParser.parseConfiguration(configFile);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (XMLParserException e) {
            e.printStackTrace();
        }
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = null;
        try {
            myBatisGenerator = new MyBatisGenerator(configuration,callback,warings);
        } catch (InvalidConfigurationException e) {
            e.printStackTrace();
        }
        try {
            myBatisGenerator.generate(null);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

MyBatis 延迟加载

什么是延迟加载？

延迟加载也叫懒加载、惰性加载，使⽤延迟加载可以提⾼程序的运⾏效率，针对于数据持久层的操作，在某些特定的情况下去访问特定的数据库，在其他情况下可以不访问某些表，从⼀定程度上减少了 Java应⽤与数据库的交互次数。

(在级联查询中只需要查询其中一张表时用延迟加载)
(比如前端页面显示学生姓名,id,当点击班级后才显示班级信息,后端是把学生和班级表级联了,但是只显示一个表信息)查询学⽣和班级的时，学⽣和班级是两张不同的表，如果当前需求只需要获取学⽣的信息，那么查询学⽣单表即可，如果需要通过学⽣获取对应的班级信息，则必须查询两张表。不同的业务需求，需要查询不同的表，根据具体的业务需求来动态减少数据表查询的⼯作就是延迟加载。
在 confifig.xml 中开启延迟加载

<settings>
 <!-- 打印SQL-->
 <setting name="logImpl" value="STDOUT_LOGGING" />
 <!-- 开启延迟加载 -->
 <setting name="lazyLoadingEnabled" value="true"/>
</settings>

将多表关联查询拆分成多个单表查询

StudentRepository

public Student findByIdLazy(long id);

StudentRepository.xml

<resultMap id="studentMapLazy" type="com.southwind.entity.Student">
 <id column="id" property="id"></id>
 <result column="name" property="name"></result>
 <association property="classes" javaType="com.southwind.entity.Classes" select="com.southwind.repository.ClassesRepository.findByIdLazy" column="cid">
</association>
</resultMap>
<select id="findByIdLazy" parameterType="long" resultMap="studentMapLazy">
 select * from student where id = #{id}
</select>

ClassesRepository

public Classes findByIdLazy(long id);

ClassesRepository.xml

<select id="findByIdLazy" parameterType="long"
resultType="com.southwind.entity.Classes">
 select * from classes where id = #{id}
</select>

MyBatis 缓存

什么是 MyBatis 缓存

使⽤缓存可以减少 Java 应⽤与数据库的交互次数，从⽽提升程序的运⾏效率。⽐如查询出 id = 1 的对象，第⼀次查询出之后会⾃动将该对象保存到缓存中，当下⼀次查询时，直接从缓存中取出对象即可，⽆需再次访问数据库。

MyBatis 缓存分类

1、⼀级缓存：SqlSession 级别，默认开启，并且不能关闭。

操作数据库时需要创建 SqlSession 对象，在对象中有⼀个 HashMap ⽤于存储缓存数据，不同的SqlSession 之间缓存数据区域是互不影响的。

⼀级缓存的作⽤域是 SqlSession 范围的，当在同⼀个 SqlSession 中执⾏两次相同的 SQL 语句事，第⼀次执⾏完毕会将结果保存到缓存中，第⼆次查询时直接从缓存中获取。需要注意的是，如果 SqlSession 执⾏了 DML 操作（insert、update、delete），MyBatis 必须将缓存清空以保证数据的准确性。

2、⼆级缓存：Mapper 级别，默认关闭，可以开启。

使⽤⼆级缓存时，多个 SqlSession 使⽤同⼀个 Mapper 的 SQL 语句操作数据库，得到的数据会存在⼆级缓存区，同样是使⽤ HashMap 进⾏数据存储，相⽐较于⼀级缓存，⼆级缓存的范围更⼤，多个SqlSession 可以共⽤⼆级缓存，⼆级缓存是跨 SqlSession 的。

⼆级缓存是多个 SqlSession 共享的，其作⽤域是 Mapper 的同⼀个 namespace，不同的 SqlSession

两次执⾏相同的 namespace 下的 SQL 语句，参数也相等，则第⼀次执⾏成功之后会将数据保存到⼆级缓存中，第⼆次可直接从⼆级缓存中取出数据。

代码

⼀级缓存

package com.southwind.test;
import com.southwind.entity.Account;
import com.southwind.repository.AccountRepository;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
public class Test4 {
 public static void main(String[] args) {
 InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
 SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
 SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
 SqlSession sqlSession = sqlSessionFactory.openSession();
 AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
     
 Account account = accountRepository.findById(1L);//第一次执行sql语句
 System.out.println(account);
 //sqlSession.close();
 //注释打开就会创建一个新的sqlSession,会重新执行sql语句
 //sqlSession = sqlSessionFactory.openSession();
 //accountRepository = sqlSession.getMapper(AccountRepository.class);
 Account account1 = accountRepository.findById(1L);//虽然再次调用了一次findById方法,但是原来的数据已经存到了sqlSession中,一共只执行了一次sql语句
 System.out.println(account1);
 }
}

⼆级缓存
1、MyBatis ⾃带的⼆级缓存
confifig.xml 配置开启⼆级缓存

<settings>
 <!-- 打印SQL-->
 <setting name="logImpl" value="STDOUT_LOGGING" />
 <!-- 开启延迟加载 -->
 <setting name="lazyLoadingEnabled" value="true"/>
 <!-- 开启⼆级缓存 -->
 <setting name="cacheEnabled" value="true"/>
</settings>

Mapper.xml 中配置⼆级缓存(在下添加)

<cache></cache>

实体类实现序列化接口

package com.southwind.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account implements Serializable {
 private long id;
 private String username;
 private String password;
 private int age;
}

2、ehcache ⼆级缓存

pom.xml 添加相关依赖

<dependency>
 <groupId>org.mybatis</groupId>
 <artifactId>mybatis-ehcache</artifactId>
 <version>1.0.0</version>
</dependency>
<dependency>
 <groupId>net.sf.ehcache</groupId>
 <artifactId>ehcache-core</artifactId>
 <version>2.4.3</version>
</dependency>

添加 ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
 <diskStore/>
 <defaultCache
 maxElementsInMemory="1000"
 maxElementsOnDisk="10000000"
 eternal="false"
 overflowToDisk="false"
 timeToIdleSeconds="120"
 timeToLiveSeconds="120"
 diskExpiryThreadIntervalSeconds="120"
 memoryStoreEvictionPolicy="LRU">
 </defaultCache>
</ehcache>

confifig.xml 配置开启⼆级缓存

<settings>
 <!-- 打印SQL-->
 <setting name="logImpl" value="STDOUT_LOGGING" />
 <!-- 开启延迟加载 -->
 <setting name="lazyLoadingEnabled" value="true"/>
 <!-- 开启⼆级缓存 -->
 <setting name="cacheEnabled" value="true"/>
</settings>

Mapper.xml 中配置⼆级缓存

<cache type="org.mybatis.caches.ehcache.EhcacheCache">
 <!-- 缓存创建之后，最后⼀次访问缓存的时间⾄缓存失效的时间间隔 -->
 <property name="timeToIdleSeconds" value="3600"/>
 <!-- 缓存⾃创建时间起⾄失效的时间间隔 -->
 <property name="timeToLiveSeconds" value="3600"/>
 <!-- 缓存回收策略，LRU表示移除近期使⽤最少的对象 -->
 <property name="memoryStoreEvictionPolicy" value="LRU"/>
</cache>

实体类不需要实现序列化接⼝。

package com.southwind.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
 private long id;
 private String username;
 private String password;
 private int age;
}

MyBatis 动态 SQL

使⽤动态 SQL 可简化代码的开发，减少开发者的⼯作量，程序可以⾃动根据业务参数来决定 SQL 的组

成。

if 标签

<!--    动态sql,-->
    <select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
        select * from t_account where
        <if test="id!=0">
            id = #{id}
        </if>
        <if test="username!=null">
            and username = #{username}
        </if>
--         后台没有setPassword时,默认把password=null,不执行下面语句即不加password=?条件
        <if test="password!=null">
            and password = #{password}
        </if>
        <if test="age!=0">
            and age = #{age}
        </if>
    </select>

if 标签可以⾃动根据表达式的结果来决定是否将对应的语句添加到 SQL 中，如果条件不成⽴则不添加，

如果条件成⽴则添加。

where 标签

<select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
        select * from t_account
        <where>
            <if test="id!=0">
                id = #{id}
            </if>
            <if test="username!=null">
                and username = #{username}
            </if>
            <if test="password!=null">
                and password = #{password}
            </if>
            <if test="age!=0">
                and age = #{age}
            </if>
        </where>
    </select>

where 标签可以⾃动判断是否要删除语句块中的 and 关键字，如果检测到 where 直接跟 and 拼接(即id为null,没有添加id=?语句,直接跟and username = ?语句,where and不是sql语法)，则⾃动删除 and，通常情况下 if 和 where 结合起来使⽤。

choose 、when 标签(若第一个when成立,直接跳出循环体,不去执行下面的标签)

<select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
        select * from t_account
        <where>
            <choose>
                <when test="id!=0">
                    id = #{id}
                </when>
                <when test="username!=null">
                    and username = #{username}
                </when>
                <when test="password!=null">
                    and password = #{password}
                </when>
                <when test="age!=0">
                    and age = #{age}
                </when>
            </choose>
        </where>
    </select>

trim 标签

trim 标签中的 prefix 和 suffix 属性会被⽤于⽣成实际的 SQL 语句，会和标签内部的语句进⾏拼接，如果语句前后出现了 prefixOverrides 或者 suffixOverrides 属性中指定的值，MyBatis 框架会⾃动将其删除。

<!--    trim标签-->
    <select id="findByAccount" parameterType="com.southwind.entity.Account"
            resultType="com.southwind.entity.Account">
        select * from t_account
        <trim prefix="where" prefixOverrides="and">
            <if test="id!=0">
                id = #{id}
            </if>
            <if test="username!=null">
                and username = #{username}
            </if>
            <if test="password!=null">
                and password = #{password}
            </if>
            <if test="age!=0">
                and age = #{age}
            </if>
        </trim>
    </select>
    <!--前后出现了AND 或OR,会自动删除-->
    <select id="findByAccount" parameterType="com.southwind.entity.Account"
            resultType="com.southwind.entity.Account">
    		select * from t_account S where 
    	 <trim prefix="and(" prefixOverrides="AND|OR" suffix=")">
			<if test="policyType.indexOf('province')>=0">
				or 1 = 1
			</if>
			<if test="age!=0">
                or age = #{age}
            </if>
		</trim>
		</select>

prefix=“where” where拼接,prefixOverrides=“and” and删除
set 标签

set 标签⽤于 update 操作，会⾃动根据参数选择⽣成 SQL 语句。

<update id="update" parameterType="com.southwind.entity.Account">
        update t_account
        <set>
            <if test="username!=null">
                username = #{username},
            </if>
            <if test="password!=null">
                password = #{password},
            </if>
            <if test="age!=0">
                age = #{age}
            </if>
        </set>
        where id = #{id}
    </update>

foreach 标签

foreach 标签可以迭代⽣成⼀系列值，这个标签主要⽤于 SQL 的 in 语句。

    <select id="findByIds" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
--      select * from t_account where id in (1,2,4,6)
        select * from t_account
        <where>
            <foreach collection="ids" open="id in (" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>
        <select id="findByIds" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
--      select * from t_account where BRACE_COMPANY in (1,2,4,6)
        select * from t_account
        <where>
        	<!--一对多的查找关系-->
            <if test="braceCompanys != null and braceCompanys.length > 0">
			AND BRACE_COMPANY IN
			<foreach  item="item" collection="braceCompanys" index="index"  open="(" separator="," close=")">
				#{item}
			</foreach>
			<!--多对多的查找关系-->
			<if test="supportContents != null and supportContents.length">
			and
			<foreach collection="supportContents" item="item" index="index" open="(" close=")" separator="or">
				INSTR( S.SUPPORT_CONTENT , #{item} ) > 0
			</foreach>
			</if>
		    </if>
		    <!--like查找-->
		    <if test='dimension != null and dimension == "ICT_SUPPORT_DIMENSION_1"'>
			AND DIMENSION LIKE '%' || #{dimension,jdbcType=VARCHAR} || '%'
		    </if>
        </where>
    </select>

collection:代表ids集合

“id in (” 数据前的 ")"数据后的

item="id"每次取出来的一个变量名为id

separator=","中间用逗号分隔

愚笨难解

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
MyBatis

MyBatisMyBatis是一个实现了数据持久化的开源框架,简单理解就是对JDBC进行封装SQL语句写在XML里面,从程序代码中分离,降低耦合度,但是SQL语句编写工作量大,依赖于底层数据库,不能随意更换ORMapping: Object Relationship Mapping 对象关系映射对象指⾯向对象关系指关系型数据库Java 到 MySQL 的映射，开发者可以以⾯向对象的思想来管理数据库。如何使⽤新建 Maven ⼯程，pom.xml<?xml version="1.0"
复制链接

扫一扫