Mybatis学习笔记

冷不防 2022-09-09 00:23 292阅读 0赞

文章目录

    • Mybatis学习笔记
    • MyBatis
      • 如何使⽤
    • Mapper.xml
    • 级联查询
    • 逆向⼯程
      • 如何使⽤
    • MyBatis 延迟加载
    • MyBatis 缓存
    • MyBatis 动态 SQL

Mybatis学习笔记

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

MyBatis

ORMapping: Object Relationship Mapping 对象关系映射
对象指⾯向对象
关系指关系型数据库
Java 到 MySQL 的映射，开发者可以以⾯向对象的思想来管理数据库。

如何使⽤

  • 新建 Maven ⼯程，pom.xml



    org.mybatis
    mybatis
    3.4.5



    mysql
    mysql-connector-java
    8.0.11



    org.projectlombok
    lombok
    1.18.6
    provided


    src/main/java

    */.xml



  • 新建数据表

    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;
    }

  • 创建 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">










    //localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8">

1、使⽤原⽣接⼝

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

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.southwind.mapper.AccoutMapper">
  4.  <insert id="save" parameterType="com.southwind.entity.Account">
  5.      insert into t_account(username,password,age) values(#{username},#{password},#{age})
  6.  </insert>
  7. </mapper>
  • namespace 通常设置为⽂件所在包+⽂件名的形式。
  • insert 标签表示执⾏添加操作。
  • select 标签表示执⾏查询操作。
  • update 标签表示执⾏更新操作。
  • delete 标签表示执⾏删除操作。
  • id 是实际调⽤ MyBatis ⽅法时需要⽤到的参数。
  • parameterType 是调⽤对应⽅法时参数的数据类型。

2、在全局配置⽂件 config.xml 中注册 AccountMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
  3. <configuration>
  4.  <!-- 配置MyBatis运⾏环境 -->
  5.  <environments default="development">
  6.      <environment id="development">
  7.          <!-- 配置JDBC事务管理 -->
  8.          <transactionManager type="JDBC"></transactionManager>
  9.          <!-- POOLED配置JDBC数据源连接池 -->
  10.          <dataSource type="POOLED">
  11.              <property name="driver" value="com.mysql.cj.jdbc.Driver">
  12.             </property>
  13.              <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8"></property>
  14.              <property name="username" value="root"></property>
  15.              <property name="password" value="root"></property>
  16.          </dataSource>
  17.      </environment>
  18.  </environments>
  20.  <!-- 注册AccountMapper.xml -->
  21.  <mappers>
  22.      <mapper resource="com/southwind/mapper/AccountMapper.xml"></mapper>
  23.  </mappers>
  24. </configuration>

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

  1. public class Test { 
  2.  public static void main(String[] args) { 
  3.      //加载MyBatis配置⽂件
  4.      InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
  5.      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
  6.      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
  7.      SqlSession sqlSession = sqlSessionFactory.openSession();
  8.      String statement = "com.southwind.mapper.AccoutMapper.save";
  9.      Account account = new Account(1L,"张三","123123",22);
  10.      sqlSession.insert(statement,account);
  11.      sqlSession.commit();
  12.      sqlSession.close();
  13.  }
  14. }

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

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

1、⾃定义接⼝

  1. package com.southwind.repository;
  2. import com.southwind.entity.Account;
  3. import java.util.List;
  4. public interface AccountRepository { 
  5.      public int save(Account account);
  6.      public int update(Account account);
  7.      public int deleteById(long id);
  8.      public List<Account> findAll();
  9.      public Account findById(long id);
  10. }

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">



    insert into t_account(username,password,age) values(#{username},#{password},#{age})



    update t_account set username = #{username},password = #{password},age = #{age} where id = #{id}



    delete from t_account where id = #{id}

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

  1. <!-- 注册AccountMapper.xml -->
  2. <mappers>
  3.  <mapper resource="com/southwind/mapper/AccountMapper.xml"></mapper>
  4.  <mapper resource="com/southwind/repository/AccountRepository.xml"></mapper>
  5. </mappers>

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

  1. package com.southwind.test;
  2. import com.southwind.entity.Account;
  3. import com.southwind.repository.AccountRepository;
  4. import org.apache.ibatis.session.SqlSession;
  5. import org.apache.ibatis.session.SqlSessionFactory;
  6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  7. import java.io.InputStream;
  8. import java.util.List;
  9. public class Test2 { 
  10.  public static void main(String[] args) { 
  11.      InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
  12.      SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
  13.      SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
  14.      SqlSession sqlSession = sqlSessionFactory.openSession();
  15.      //获取实现接⼝的代理对象
  16.      AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
  17.      //添加对象
  18.     // Account account = new Account(3L,"王五","111111",24);
  19.     // int result = accountRepository.save(account);
  20.     // sqlSession.commit();
  21.      //查询全部对象
  22.     // List<Account> list = accountRepository.findAll();
  23.     // for (Account account:list){ 
  24.     // System.out.println(account);
  25.     // }
  26.     // sqlSession.close();
  27.      //通过id查询对象
  28.     // Account account = accountRepository.findById(3L);
  29.     // System.out.println(account);
  30.     // sqlSession.close();
  31.      //修改对象
  32.     // Account account = accountRepository.findById(3L);
  33.     // account.setUsername("⼩明");
  34.     // account.setPassword("000");
  35.     // account.setAge(18);
  36.     // int result = accountRepository.update(account);
  37.     // sqlSession.commit();
  38.     // System.out.println(result);
  39.     // sqlSession.close();
  40.      //通过id删除对象
  41.      int result = accountRepository.deleteById(3L);
  42.      System.out.println(result);
  43.      sqlSession.commit();
  44.      sqlSession.close();
  45.  }
  46. }

Mapper.xml

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

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

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

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

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

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

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

4、多个参数，通过 name 和 age 查询 Account

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

5、Java Bean

  1. <update id="update" parameterType="com.southwind.entity.Account">
  2.      update t_account set username = #{username},password = #{password},age = #{age} where id = #{id}
  3. </update>
  • resultType：结果类型

1、基本数据类型，统计 Account 总数

  1. <select id="count" resultType="int">
  2.      select count(id) from t_account
  3. </select>

2、包装类，统计 Account 总数

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

3、String 类型，通过 id 查询 Account 的 name

  1. <select id="findNameById" resultType="java.lang.String">
  2.      select username from t_account where id = #{id}
  3. </select>

4、Java Bean

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

级联查询

1、一对多

Student

  1. package com.southwind.entity;
  2. import lombok.Data;
  3. @Data
  4. public class Student { 
  5.  private long id;
  6.  private String name;
  7.  private Classes classes;
  8. }

Classes

  1. package com.southwind.entity;
  2. import lombok.Data;
  3. import java.util.List;
  4. @Data
  5. public class Classes { 
  6.  private long id;
  7.  private String name;
  8.  private List<Student> students;
  9. }

StudentRepository

  1. package com.southwind.repository;
  2. import com.southwind.entity.Student;
  3. public interface StudentRepository { 
  4.  public Student findById(long id);
  5. }

StudentRepository.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.southwind.repository.StudentRepository">
  5.  <resultMap id="studentMap" type="com.southwind.entity.Student">
  6.      <id column="id" property="id"></id>
  7.      <result column="name" property="name"></result>
  8.      <association property="classes" javaType="com.southwind.entity.Classes">
  9.         <id column="cid" property="id"></id>
  10.         <result column="cname" property="name"></result>
  11.      </association>
  12.  </resultMap>
  14.  <select id="findById" parameterType="long" resultMap="studentMap">
  15.      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
  16.  </select>
  17. </mapper>

ClassesRepository

  1. package com.southwind.repository;
  2. import com.southwind.entity.Classes;
  3. public interface ClassesRepository { 
  4.  public Classes findById(long id);
  5. }

ClassesRepository.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.southwind.repository.ClassesRepository">
  5.  <resultMap id="classesMap" type="com.southwind.entity.Classes">
  6.      <id column="cid" property="id"></id>
  7.       <result column="cname" property="name"></result>
  8.      <collection property="students" ofType="com.southwind.entity.Student">
  9.          <id column="id" property="id"/>
  10.          <result column="name" property="name"/>
  11.      </collection>
  12.  </resultMap>
  14.  <select id="findById" parameterType="long" resultMap="classesMap">
  15.      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
  16.  </select>
  17. </mapper>

2、多对多
Customer

  1. package com.southwind.entity;
  2. import lombok.Data;
  3. import java.util.List;
  4. @Data
  5. public class Customer { 
  6.  private long id;
  7.  private String name;
  8.  private List<Goods> goods;
  9. }

Goods

  1. package com.southwind.entity;
  2. import lombok.Data;
  3. import java.util.List;
  4. @Data
  5. public class Goods { 
  6.  private long id;
  7.  private String name;
  8.  private List<Customer> customers;
  9. }

CustomerRepository

  1. package com.southwind.repository;
  2. import com.southwind.entity.Customer;
  3. public interface CustomerRepository { 
  4.  public Customer findById(long id);
  5. }

CustomerRepository.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.southwind.repository.CustomerRepository">
  5.  <resultMap id="customerMap" type="com.southwind.entity.Customer">
  6.      <id column="cid" property="id"></id>
  7.      <result column="cname" property="name"></result>
  8.      <collection property="goods" ofType="com.southwind.entity.Goods">
  9.          <id column="gid" property="id"/>
  10.          <result column="gname" property="name"/>
  11.      </collection>
  12.  </resultMap>
  14.  <select id="findById" parameterType="long" resultMap="customerMap">
  15.      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
  16.  </select>
  17. </mapper>

GoodsRepository

  1. package com.southwind.repository;
  2. import com.southwind.entity.Goods;
  3. public interface GoodsRepository { 
  4.  public Goods findById(long id);
  5. }

GoodsRepository.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.southwind.repository.GoodsRepository">
  5.  <resultMap id="goodsMap" type="com.southwind.entity.Goods">
  6.      <id column="gid" property="id"></id>
  7.      <result column="gname" property="name"></result>
  8.      <collection property="customers" ofType="com.southwind.entity.Customer">
  9.          <id column="cid" property="id"/>
  10.          <result column="cname" property="name"/>
  11.      </collection>
  12.  </resultMap>
  14.  <select id="findById" parameterType="long" resultMap="goodsMap">
  15.      select c.id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where g.id = #{id} and cg.cid = c.id and cg.gid = g.id
  16.  </select>
  17. </mapper>

逆向⼯程

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

传统的开发中上述的三个组件需要开发者⼿动创建，逆向⼯程可以帮助开发者来⾃动创建三个组件，减
轻开发者的⼯作量，提⾼⼯作效率。（缺点：只能执行一次，重复则会覆盖）

如何使⽤

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

  • 新建 Maven ⼯程，pom.xml



    org.mybatis
    mybatis
    3.4.5



    mysql
    mysql-connector-java
    8.0.11



    org.mybatis.generator
    mybatis-generator-core
    1.3.2

  • 创建 MBG 配置⽂件 generatorConfig.xml

1、jdbcConnection 配置数据库连接信息。
2、javaModelGenerator 配置 JavaBean 的⽣成策略。
3、sqlMapGenerator 配置 SQL 映射⽂件⽣成策略。
4、javaClientGenerator 配置 Mapper 接⼝的⽣成策略。
5、table 配置⽬标数据表（tableName：表名，domainObjectName：JavaBean 类名）。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
  3. <generatorConfiguration>
  4.      <context id="testTables" targetRuntime="MyBatis3">
  5.          <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8" userId="root" password="root" ></jdbcConnection>
  6.          <javaModelGenerator targetPackage="com.southwind.entity" targetProject="./src/main/java"></javaModelGenerator>
  7.          <sqlMapGenerator targetPackage="com.southwind.repository" targetProject="./src/main/java"></sqlMapGenerator>
  8.          <javaClientGenerator type="XMLMAPPER" targetPackage="com.southwind.repository" targetProject="./src/main/java">
  9.         </javaClientGenerator>
  10.          <table tableName="t_user" domainObjectName="User"></table>
  11.      </context>
  12. </generatorConfiguration>

  • 创建 Generator 执⾏类

    package com.southwind.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) { 

    1.  List<String> warings = new ArrayList<String>();
    2.  boolean overwrite = true;
    3.  String genCig = "/generatorConfig.xml";
    4.  File configFile = new File(Main.class.getResource(genCig).getFile());
    5.  ConfigurationParser configurationParser = new ConfigurationParser(warings);
    6.  Configuration configuration = null;
    7.  try { 
    8.      configuration = configurationParser.parseConfiguration(configFile);
    9.  } catch (IOException e) { 
    10.      e.printStackTrace();
    11.  } catch (XMLParserException e) { 
    12.      e.printStackTrace();
    13.  }
    14.  DefaultShellCallback callback = new DefaultShellCallback(overwrite);
    15.  MyBatisGenerator myBatisGenerator = null;
    16.  try { 
    17.      myBatisGenerator = new MyBatisGenerator(configuration,callback,warings);
    18.  } catch (InvalidConfigurationException e) { 
    19.      e.printStackTrace();
    20.  }
    21.  try { 
    22.     myBatisGenerator.generate(null);
    23.  } catch (SQLException e) { 
    24.      e.printStackTrace();
    25.  } catch (IOException e) { 
    26.      e.printStackTrace();
    27.  } catch (InterruptedException e) { 
    28.      e.printStackTrace();
    29.  }

    }
    }

MyBatis 延迟加载

  • 什么是延迟加载？

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

查询学⽣和班级的时，学⽣和班级是两张不同的表，如果当前需求只需要获取学⽣的信息，那么查询学
⽣单表即可，如果需要通过学⽣获取对应的班级信息，则必须查询两张表。

不同的业务需求，需要查询不同的表，根据具体的业务需求来动态减少数据表查询的⼯作就是延迟加
载。

  • 在 config.xml 中开启延迟加载

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

StudentRepository

  1. public Student findByIdLazy(long id);

StudentRepository.xml

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

ClassesRepository

  1. public Classes findByIdLazy(long id);

ClassesRepository.xml

  1. <select id="findByIdLazy" parameterType="long" resultType="com.southwind.entity.Classes">
  2.      select * from classes where id = #{id}
  3. </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) { 

    1.  InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("config.xml");
    2.  SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    3.  SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
    4.  SqlSession sqlSession = sqlSessionFactory.openSession();
    5.  AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
    6.  Account account = accountRepository.findById(1L);
    7.  System.out.println(account);
    8.  sqlSession.close();
    9.  sqlSession = sqlSessionFactory.openSession();
    10.  accountRepository = sqlSession.getMapper(AccountRepository.class);
    11.  Account account1 = accountRepository.findById(1L);
    12.  System.out.println(account1);

    }

  • ⼆级缓存

1、MyBatis ⾃带的⼆级缓存

  • config.xml 配置开启⼆级缓存

  • Mapper.xml 中配置⼆级缓存

  • 实体类实现序列化接⼝

    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 添加相关依赖


    org.mybatis
    mybatis-ehcache
    1.0.0


    net.sf.ehcache
    ehcache-core
    2.4.3

  • 添加 ehcache.xml

  • config.xml 配置开启⼆级缓存

  • Mapper.xml 中配置⼆级缓存

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

    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 标签

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

  • where 标签

where 标签可以⾃动判断是否要删除语句块中的 and 关键字，如果检测到 where 直接跟 and 拼接，则
⾃动删除 and，通常情况下 if 和 where 结合起来使⽤。

  • choose 、when 标签

  • trim 标签

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

  1. <select id="findByAccount" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
  2.      select * from t_account
  3.      <trim prefix="where" prefixOverrides="and">
  4.          <if test="id!=0">
  5.             id = #{id}
  6.          </if>
  7.          <if test="username!=null">
  8.              and username = #{username}
  9.          </if>
  10.          <if test="password!=null">
  11.              and password = #{password}
  12.          </if>
  13.          <if test="age!=0">
  14.              and age = #{age}
  15.          </if>
  16.      </trim>
  17. </select>
  • set 标签

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

  1. <update id="update" parameterType="com.southwind.entity.Account">
  2.      update t_account
  3.      <set>
  4.          <if test="username!=null">
  5.              username = #{username},
  6.          </if>
  7.          <if test="password!=null">
  8.              password = #{password},
  9.          </if>
  10.          <if test="age!=0">
  11.              age = #{age}
  12.          </if>
  13.      </set>
  14.      where id = #{id}
  15. </update>
  • foreach 标签

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

  1. <select id="findByIds" parameterType="com.southwind.entity.Account" resultType="com.southwind.entity.Account">
  2.      select * from t_account
  3.      <where>
  4.          <foreach collection="ids" open="id in (" close=")" item="id" separator=",">
  5.              #{id}
  6.          </foreach>
  7.      </where>
  8. </select>

【代码来源】参考楠哥教学视频：https://www.bilibili.com/video/BV1V7411w7VW

发表评论

表情：
评论列表 （有 0 条评论，292人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Mybatis学习笔记

    一、引言 1.框架的三层架构     表现层：是用于展示数据（SpringMVC）     业务层：是处理业务需求     持久层：是和数据库交互（MyBati

    骑猪看日落骑猪看日落/ 0 赞/ 192 阅读

    相关 Mybatis学习笔记

    学习了Mybatis。相对于hibernate来说这个框架更加灵活，开发效率更快，适用于那些改动比较频繁的项目。 首先加入mybatis的配置文件myBatisConfig.

    叁歲伎倆叁歲伎倆/ 0 赞/ 304 阅读