Mybatis笔记

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量88 收藏
点赞数
分类专栏： # mybatis 文章标签： java intellij-idea maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44507558/article/details/124911069
版权

Mybatis

环境

  • JDK1.8
  • Mysql5.7
  • maven3.6.1
  • idea

需要知识点

  • JDBC
  • Mysql
  • Java基础
  • Maven
  • Junit

框架：具有配置文件的 最好的方式：看官网文档 Mybatis3中文文档

1、简介

1.1 什么是 MyBatis？

  • MyBatis 是一款优秀的持久层框架，

  • 它支持自定义 SQL、存储过程以及高级映射。

  • MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。

  • MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1.2 如何获取mybatis

maven仓库

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.7</version>
</dependency>

github开源代码

Mybatis3中文文档

1.3 持久化

数据持久化

  • 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
  • 内存：断电即失
  • 数据库(jdbc)、io文件持久化

1.4 持久层

Dao层、Service层、Controller层

  • 完成持久化工作的代码块
  • 层界限明显

1.5 为什么需要Mybatis

  • 传统的JDBC太复杂。简化。框架。自动化。
  • 更容易上手
  • 优点
    • 简单易学
    • 灵活
    • sql和代码分离，提高了可维护性
    • 提供映射标签，支持对象与数据库的orm字段关系映射
    • 提供对象关系映射标签，支持对象关系组建维护
    • 提供xml标签，支持编写动态sql

2、第一个Mybatis程序

思路：搭建环境–>导入mybatis–>编写代码–>测试

2.1 搭建环境

搭建数据库

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(100) DEFAULT NULL,
  `pwd` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4

新建项目

  1. 新建一个普通项目

  2. 删除src

  3. 导入maven依赖

    <!--  导入依赖-->
  <dependencies>
<!--    mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.9</version>
    </dependency>
<!--    mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>
<!--    junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
    </dependency>
  </dependencies>

2.2 创建一个模块

  • 编写mybatis的核心配置文件mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://10.168.31.10:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

  • 编写mybatis的工具类

//工具类
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream stream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(stream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

2.3 编写代码

  • 实体类

    public class User {
    private int id;
    private String name;
    private String pwd;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

  • Dao/Mapper接口

    public interface UserDao {
    List<User> getUserList();
}

  • 接口实现类 mapper.xml

<mapper namespace="com.zyf.dao.UserDao">
    <select id="getUserList" resultType="com.zyf.pojo.User">
        select * from user
    </select>
</mapper>

2.4 测试

注意点:org.apache.ibatis.binding.BindingException: Type interface com.zyf.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么?

核心配置文件中注册的mapers

  • junit
public class UserDaoTest {

    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserDao mapper = sqlSession.getMapper(UserDao.class);

        List<User> userList = mapper.getUserList();
        for (User user : userList) {
            System.out.println(user.toString());
        }

        sqlSession.close();
    }
}

3、CRUD

1. namespace

namespace中的包名要和Mapper接口中的包名一致

2. select

选择查询语句

  • id:mapper接口中的方法名
  • resultType:sql语句的返回值
  • parameterType：sql语句参数

3. insert

 <insert id="addUser" parameterType="com.zyf.pojo.User">
        insert into user (name,pwd) value (#{name},#{pwd})
    </insert>

4. update

 <update id="updateUser" parameterType="com.zyf.pojo.User">
        update user set name = #{name},pwd=#{pwd} where id = #{id}
    </update>

5. delete

<delete id="deleteUser" parameterType="int">
        delete from user where id=#{id}
    </delete>

注意点：

  • 增删改需要提交事务!

4、配置解析

1.核心配置文件

  • mybatis-config.xml

  • MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息

    configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

2.环境配置(environments)

  • MyBatis 可以配置成适应多种环境
  • 不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境
  • Mybatis的默认事务管理器就是JDBC，连接池：POOLED

3.属性（properties）

我们可以同properties属性来实现引用配置文件

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置(db.properties)

编写一个配置文件

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://10.168.31.10:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
userName=root
pwd=123456

在核心配置文件中引入

<!--    引入外部配置文件-->
<properties resource="db.properties">
	<property name="userName" value="root"/>
</properties>
  • 可以直接引入外部文件
  • 可以在其中增加一下属性配置
  • 如果两个文件有同一个字段，优先使用外部配置文件的！

4.类型别名（typeAliases）

  • 类型别名可为 Java 类型设置一个缩写名字。

  • 它仅用于 XML 配置，意在降低冗余的全限定类名书写。

        <typeAliases>
        <typeAlias type="com.zyf.pojo.User" alias="User"/>
    </typeAliases>

  • 也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

    • 扫描实体类的包，它的默认别名就为这个类的类名，首字母小写。
<typeAliases>
    <typeAlias type="com.zyf.pojo.User" alias="User"/>
    <package name="com.zyf.pojo"/>
</typeAliases>

在实体类比较少的时候用类别名(可以自定义别名)

在实体类比较多的时候用包别名(无注解走默认规则 有@Alias(“name”)注解则为注解name值)

5.设置(settins)

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为,完整设置如下:

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

6.其他配置

7.映射器（mappers）

MapperRegistry:注册绑定我们的mapper文件。

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
<!-- 使用完全限定资源定位符（URL） 不使用 -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>
<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>
<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

第三、四种方式注意:

  • 接口和它的mapper配置文件必须同名
  • 接口和它的mapper配置文件必须在同一个包下

8.生命周期

生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

  • 一旦创建了SqlSessionFactory，就不需要它了
  • 局部变量

SqlSessionFactory

  • 可以理解为数据库连接池
  • SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
  • 因此 SqlSessionFactory 的最佳作用域是应用作用域
  • 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式

Sqlsession

  • 每个线程都应该有它自己的 SqlSession 实例
  • SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
  • 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession
  • 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中

5、解决属性名和字段名不一致的问题

1.resultMap

结果集映射

<!--    结果集映射-->
    <resultMap id="userMap" type="com.zyf.pojo.User">
        <!--    column为表字段 property为对象属性 -->
        <result column="name" property="name"/>
    </resultMap>
  • resultMap 元素是 MyBatis 中最重要最强大的元素
  • ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
  • ResultMap 的优秀之处——你完全可以不用显式地配置它们

6、日志

6.1日志工厂

如果数据库操作，出现了异常，我们需要拍错。日志就是最好的助手！

logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J(deprecated since 3.5.9) | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING

在mybatis中具体使用哪一个实现，在设置中设定！

STDOUT_LOGGING：标准日志输出

配置方式示例：

   <settings>
<!--        标准日志工厂实现-->
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!--        log4j日志工厂实现-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

6.2 log4j

  1. 先导入log4j的包
  <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.16</version>
    </dependency>
  1. log4j.properties
#log4j.rootCategory=INFO, stdout , R
log4j.rootCategory=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[QC] %p [%t] %C.%M(%L) | %m%n

#log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.R.File=D:\\Tomcat 5.5\\logs\\qc.log
#log4j.appender.R.layout=org.apache.log4j.PatternLayout
#log4j.appender.R.layout.ConversionPattern=%d-[TS] %p %t %c - %m%n

log4j.logger.com.neusoft=DEBUG
log4j.logger.com.opensymphony.oscache=ERROR
log4j.logger.net.sf.navigator=ERROR
log4j.logger.org.apache.commons=ERROR
log4j.logger.org.apache.struts=WARN
log4j.logger.org.displaytag=ERROR
log4j.logger.org.springframework=DEBUG
log4j.logger.com.ibatis.db=WARN
log4j.logger.org.apache.velocity=FATAL

log4j.logger.com.canoo.webtest=WARN

log4j.logger.org.hibernate.ps.PreparedStatementCache=WARN
log4j.logger.org.hibernate=DEBUG
log4j.logger.org.logicalcobwebs=WARN
  1. 配置log4j日志实现
    <settings>
<!--        标准日志工厂实现-->
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!--        log4j日志工厂实现-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

  1. 简单使用

    1. 在要使用log4j的类中引入import org.apache.log4j.Logger;
    2. 创建日志对象，参数为当前类的class 例如:
    private static Logger log = Logger.getLogger(UserMapperTest.class);
    1. 日志级别
    log.info("info");
log.debug("debug");
log.error("error");

7、分页

1.使用limit分页

select * from mybatis.user limit 0,2;

2.使用mybatis实现分页，核心sql

  1. 接口

    List<User> getUserByLimit(@Param("pageNum") int pageNum,@Param("pageSize")  int pageSize);

  2. Mapper.xml

       <select id="getUserByLimit" resultType="com.zyf.pojo.User">
        select * from user limit #{pageNum},#{pageSize}
    </select>

  3. 测试

@Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        List<User> userList = mapper.getUserByLimit(0,2);
        for (User user : userList) {
            System.out.println(user.toString());
        }

        sqlSession.close();
    }

3.RowBounds分页

不使用sql分页

  1. 接口

    List<User> getUserByRowBounds(@Param("pageNum") int pageNum,@Param("pageSize")  int pageSize);

  2. Mapper.xml

    <select id="getUserByRowBounds" resultType="com.zyf.pojo.User">
        select * from user
    </select>

  3. 测试

    @Test
    public void getUserByRowBounds(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        RowBounds rowBounds = new RowBounds(0, 2);

        List<User> userList = sqlSession.selectList("com.zyf.dao.UserMapper.getUserByRowBounds", new HashMap<>(), rowBounds);

        for (User user : userList) {
            System.out.println(user.toString());
        }

        sqlSession.close();
    }

4.分页插件

https://pagehelper.github.io/

8、使用注解开发

1.使用注解开发

  1. 直接在接口上实现

    public interface User1Mapper {
    @Select("select * from user")
    List<User> getUserList();

}

  2. 需要在核心配置文件中配置接口！

      <mappers>
        <mapper class="com.zyf.dao.User1Mapper"/>
    </mappers>

  3. 测试

     @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        List<User> userList = mapper.getUserList();
        for (User user : userList) {
            System.out.println(user.toString());
        }

        sqlSession.close();
    }

本质：反射机制实现

底层：动态代理

2.CRUD

我们可以在工具类创建的时候实现自动提交事务！

sqlSessionFactory.openSession(true);

@Insert

@Update

@Delete

3.@Param注解

  • 基本类型的参数或者String类型，需要加上
  • 引用类型不需要加
  • 如果只有一个基本类型的话可以忽略，但是建议加上。
  • 我们sql中引用的就是就是我们这里的@Param(“id”) 中设定的值

9、Lombok

使用步骤

  1. 在IDEA中安装Lombok插件

  2. 在项目中导入lombok的jar包

        <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.10</version>
    </dependency>

  3. 在实体类上加注解即可

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
Lombok config system
Code inspections
Refactoring actions (lombok and delombok)

10、多对一处理

1.多对一概念：

  • 多个学生对应一个老师
  • 对于学生而言，关联， 多个学生关联一个老师【多对一】
  • 对于老师而言，集合，一个老师，有很多学生【一对多】

2.测试环境搭建

  1. 导入lombok

        <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.10</version>
    </dependency>

  2. 新建实体类Teacher,Student

    Teacher:

    package com.zyf.pojo;

import lombok.Data;

import java.util.List;

@Data
public class Teacher {
    private int id;
    private String name;
    private List<Student> studentList;
}

    Student:

    package com.zyf.pojo;

import lombok.Data;

@Data
public class Student {
    private int id;
    private String name;
    private Teacher teacher;
}

  3. 建立Mapper接口

    package com.zyf.dao;

public interface StudentMapper {
}

    package com.zyf.dao;

import com.zyf.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {
    @Select("select * from teacher where id = #{tid}")
    Teacher getTeacher(@Param("tid") int id);
}

  4. 建立Mapper.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.zyf.dao.StudentMapper">

</mapper>

    <?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.zyf.dao.TeacherMapper">

</mapper>

  5. 在核心配置文件中绑定注册我们的mapper接口或者文件

        <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
        <mapper resource="mapper/StudentMapper.xml"/>
        <mapper resource="mapper/TeacherMapper.xml"/>
        <mapper class="com.zyf.dao.User1Mapper"/>
    </mappers>

  6. 测试查询是否能够成功

        @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher userList = mapper.getTeacher(1);
        System.out.println(userList);

        sqlSession.close();
    }

3.按照查询嵌套处理

    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--
        复杂属性我们需要特殊处理
        对象：association
        集合：collection
        -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
<!--        <collection property=""/>-->
    </resultMap>

    <select id="getStudent" resultMap="StudentTeacher">
        select a.* from student a inner join teacher b on a.tid=b.id
    </select>

    <select id="getTeacher" resultType="teacher">
        select * from teacher where id = #{tid}
    </select>

4.按照结构嵌套查询

    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname, t.name tname from student s inner join teacher t on s.tid=t.id
    </select>

    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <!--
        复杂属性我们需要特殊处理
        对象：association
        集合：collection
        -->
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
        <!--        <collection property=""/>-->
    </resultMap>

11、一对多处理

比如：一个老师拥有多个学生！

对于老师而言，就是一对多的关系！

1.环境搭建

TeacherMapper

public interface TeacherMapper {
    
    Teacher getTeacher(@Param("tid") int id);
}

2.按照结果嵌套查询

<!--    按照结果接映射-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.id tid, t.name tname from student s inner join teacher t on s.tid=t.id where t.id = #{tid}
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--
       复杂属性我们需要特殊处理
       对象：association
       集合：collection
       javaType 指定属性类型
       集合中的泛型信息，我们使用ofType获取
       -->
        <collection property="studentList" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

3.按照查询嵌套查询

<select id="getTeacher2" resultMap="TeacherStudent2">
        select * from teacher where id=#{tid}
    </select>

    <resultMap id="TeacherStudent2" type="Teacher">
        <!--
       复杂属性我们需要特殊处理
       对象：association
       集合：collection
       javaType 指定属性类型
       集合中的泛型信息，我们使用ofType获取
       -->
        <collection property="studentList" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

    <select id="getStudentByTeacherId" resultType="student">
        select * from student where tid = #{id}
    </select>

4.小结

  1. 关联-association - 多对一
  2. 集合-collection - 一对多
  3. javaType & ofType
    1. javaType 用来指定实体类中的属性的类型
    2. ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型！

注意点：

  • 保证sql的可读性，尽量保证通俗易懂
  • 注意一对多和多对一中，属性名和字段的问题
  • 如果问题不好排查错误，可以使用日志，建议使用Log4j

面试高频：

  • mysql引擎
  • InnoDb底层原理
  • 索引
  • 索引优化

12、动态sql

什么事动态sql:动态sql就是指根据不同的条件生成不同的sql

1.搭建环境

create table mybatis.`blog` (
`id` varchar(50) not NULL	,
`title` varchar(100) NULL  ,
`author` varchar(30)  NULL ,
`create_time` datetime NULL  ,
`views` int(10)  NULL ,
PRIMARY KEY (`id`)
) 
ENGINE = InnoDB default charset=utf8mb4

2.if

 <select id="queryBlogIF" resultType="Blob" parameterType="map">
        select * from blog where 1=1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>

3.choose(when otherwise)

   <select id="queryBlogChoose" resultType="Blob" parameterType="map">
        select * from blog
        <where>
            <choose>
                <when test="title != null">
                    and title = #{title}
                </when>
                <when test="author != null">
                    and author = #{author}
                </when>
                <otherwise>
                    and views =#{views}
                </otherwise>
            </choose>
        </where>
    </select>

4.trim(where set)

  <select id="queryBlogIF" resultType="Blob" parameterType="map">
        select * from blog
        <where>
            <if test="title != null">
                and title = #{title}
            </if>
            <if test="author != null">
                and author = #{author}
            </if>
        </where>

    </select>

 <update id="updateBlob" parameterType="map">
        update blob
        <set>
            <if test="title !=null">
                title = #{title},
            </if>
            <if test="athor !=null">
                athor = #{athor},
            </if>
        </set>
    </update>

   <trim prefix="WHERE" prefixOverrides="and|or" suffix="" suffixOverrides="">

        </trim>

5.foreach

and id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
	#{item}
</foreach>

6.sql片段

   <sql id="commonWhereIf">
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </sql>
    
    <select id="queryBlogIF" resultType="Blob" parameterType="map">
        select * from blog
        <where>
        <include refid="commonWhereIf"/>
        </where>

    </select>

13、缓存

1.简介

查询：链接数据库 耗费资源
一次查询的结果，给他暂存在一个可以直接取到的地方

我们再次查询相同数据的时候，直接走缓存，就不用走数据库了

2.一级缓存

  • 一级缓存也叫本地缓存：sqlsession
    • 与数据库同一次会话期间查询到的数据会放在本地缓存中
    • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

缓存失效的情况：

  1. 查询不同的东西(语句 参数)

  2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存(即使操作的数据跟之前查询的数据没有任何关系 也会导致缓存刷新)

  3. 查询不同的Mapper.xml

  4. 对mybatis查询的结果进行修改操作

  5. 手动清理缓存

    sqlSession.clearCache();

小结：一级缓存是默认开启的，只在一次SQLSession中有效，也就是拿到链接到关闭链接这个区间段！

  • 尽量使用短生命周期的SqlSession！
  • 避免使用SqlSession的一级缓存。

为了避免使用MyBatis一级缓存，程序有两种方式：

  • 每个SqlSession永远只执行单次查询。如果要执行第二次查询，请重新打开另一个SqlSession！上面示例之所以产生脏数据，关键就因为程序用同一个SqlSession两次查询了id为1的News对象。如果每个SqlSession只执行单次查询，那么一级缓存几乎就不会产生作用了，这样可避免一级缓存产生脏数据。
  • 将localCacheScope设为STATEMENT级，这样可避免在SqlSession范围内使用一级缓存，但这种方式依然有产生脏数据的风险。

3.二级缓存

  • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
  • 基于namespace(Mapper)的缓存,一个命名空间，对应一个二级缓存
  • 工作机制
    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
    • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中。
    • 新的会话查询信息，就可以从二级缓存中获取内容
    • 不同mapper查出的数据会放在自己对应的缓存中

步骤:

  1. 开启全局缓存 默认开启

        <settings>
<!--        标准日志工厂实现-->
<!--        <setting name="logImpl" value="STDOUT_LOGGING"/>-->
<!--        log4j日志工厂实现-->
        <setting name="logImpl" value="LOG4J"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
<!--        显示开启全局缓存-->
        <setting name="cacheEnable" value="true"/>
    </settings>

  2. 在要是用二级缓存的mapper中开启

    <!--    开启二级缓存-->
    <cache/>

<!--    开启二级缓存-->
    <cache eviction="FIFO"
    flushInterval="60000"
    size="512"
    readOnly="true"/>

    问题：

    1. 我们需要将实体类序列化！否则会报错!

小结:

  • 只要开启了二级缓存，在同一个Mapper下就有效
  • 所有数据都会先放到一级缓存中！
  • 只有当会话提交，或者关闭的时候，才会提交到二级缓存中!

4.缓存原理

  1. 先看二级缓存有没有
  2. 再看一级缓存中有没有
  3. 两层缓存都没有则查询数据库

5.自定义缓存-ehcache

ehcache是一种广泛使用的java分布式缓存。主要面向通用缓存

使用步骤

  1. 导包

    <dependency>
      <groupId>org.mybatis.caches</groupId>
      <artifactId>mybatis-ehcache</artifactId>
      <version>1.1.0</version>
    </dependency>

  2. 引入ehcache配置文件

    ehcache.xml

    <?xml version="1.0" encoding="UTF-8"?>

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
          磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
           path:指定在硬盘上存储对象的路径
    -->
    <diskStore path="./tempdir/Tmp_EhCache"/>

    <!--
         defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
         maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
         eternal:代表对象是否永不过期
         overflowToDisk:当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中
    -->
    <defaultCache
            maxElementsInMemory="100"
            eternal="true"
            overflowToDisk="true"/>

    <!--
        maxElementsInMemory设置成1，overflowToDisk设置成true，只要有一个缓存元素，就直接存到硬盘上去
        eternal设置成true，代表对象永久有效
        maxElementsOnDisk设置成0 表示硬盘中最大缓存对象数无限大
        diskPersistent设置成true表示缓存虚拟机重启期数据
     -->
    <cache
            name="a"
            maxElementsInMemory="1"
            eternal="true"
            overflowToDisk="true"
            maxElementsOnDisk="0"
            diskPersistent="true"/>

</ehcache>

  3. 在mapper中指定使用ehcache缓存实现

     <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
weixin_44507558
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
老杜Mybatis笔记
chenyu_Yang的博客
03-06 305
https://www.yuque.com/zuihoudewu/java_note/mt2812?singleDoc#《老杜MyBatis--原版》
mybatis笔记
11-07
mybatis笔记
MyBatis笔记
热门推荐
qq_19387933的博客
03-03 4万+
尚硅谷2022新版MyBatis笔记
狂神Mybatis笔记
weixin_51779902的博客
06-26 1139
1.MyBatis 是一款优秀的持久层框架 2.它支持自定义 SQL、存储过程以及高级映射 3.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作 4.MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java............
MyBatis笔记(尚硅谷完整笔记)
zhb111z的博客
08-21 1583
打包方式：jar引入依赖 创建MyBatis的核心配置文件 创建mapper接口 创建MyBatis的映射文件 相关概念：ORM（Object Relationship Mapping）对象关系映射。 对象：Java的实体类对象 关系：关系型数据库 映射：二者之间的对应关系 Java概念 数据库概念 类 表 属性 字段/列 对象 记录/行 映射文件的命名规则 表所对应的实体类的类名+Mapper.xml 例如：表t_user，映射的实体类为User，所对
黑马程序员-MyBatis笔记
小白的博客
01-29 1万+
看这篇就够了，真的！！！
【Mybatis笔记】狂神Mybatis笔记（有道云笔记链接）
慢热型网友的博客
11-02 197
1、Mybatis简介 2、第一个Mybatis程序 3、CRUD(增删改查) 4、配置解析 5、解决属性名和字段名不一致的问题ResultMap 6、日志 7、分页 8、使用注解开发 9、Lombok 10、动态SQL 11、缓存（了解）
Mybatis笔记详解
数据知道的博客
05-23 4244
Mybatis笔记 一. 引言 现有jdbc代码实现的dao不足:代码冗余,只有sql命令不一样.sql命令硬编码程序中部利于升级维护.建立数据库连接需要手动建立, 效率差 ( 没有应用”连接池”技术) Mybatis框架 Mybatis是个做数据持久化的框架,对jdbc代码的合理封装,主要完成数据库的访问操作( 增删改查 ) Mybatis提供了一种新的实现方式替换jdbc实现的dao ...
mybatis笔记（老杜版本）
OriginalSword的博客
12-04 2012
mybatis笔记
mybatis笔记mybatis笔记mybatis笔记
11-06
mybatis笔记
mybatis笔记.zip
04-13
mybatis笔记
传智播客mybatis笔记
11-18
传智播客中mybatis课堂笔记。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1008
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 805
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 296
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 260
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 510
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
老杜mybatis笔记
05-29
很好，您想了解老杜的MyBatis笔记。老杜是一位非常资深的Java开发工程师，他在MyBatis方面有很深的研究和实践经验。他的MyBatis笔记主要包括以下内容： 1. MyBatis基础知识：包括MyBatis的架构、Mapper接口和XML...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值