Mybatis学习记录

文章目录

  • 一、mybatis概念
    • 1、什么是mybatis
    • 2、如何获得mybatis
    • 3、持久化,持久层的概念
    • 4、为什么要用mybatis
    • 5、使用Mybatis遇到的工程问题汇总
  • 二、mybatis入门案例
    • 1、搭建环境
    • 2、编写Mybatis工具类
    • 3、编写代码
    • 4、Junit测试
    • 5、测试中遇到的问题
    • 6、mybatis增删改
  • 三、配置解析
    • 1、环境变量(environments)
    • 2、属性(properties)
    • 3、类型别名(typeAliases)
    • 4、设置(settings)
    • 5、其他配置
    • 6、映射器(mappers)
  • 四、声明周期和作用域
    • 1、SqlSessionFactoryBuilder
    • 2、SqlSessionFactory
    • 3、SqlSession
  • 五、resultMap及分页
    • 1、resultMap
    • 2、分页
  • 六、日志
    • 1、STDOUT_LOGGING
    • 2、LOG4J
  • 七、使用注解开发
    • 1、面向接口编程
    • 2、自动提交事务
    • 3、使用注解完成CRUD
    • 3、Mybatis执行流程分析
  • 八、一对多和多对一处理
    • 1、关系表建立
    • 2、多对一的处理
      • 1、按照查询嵌套处理
      • 2、按照结果嵌套处理
    • 3、一对多的处理
      • 1、按照查询嵌套
      • 2、按照结果嵌套
    • 4、小结
  • 九、动态SQL
  • 十、缓存
    • 1、简介
    • 2、mybatis缓存

最近在b站关注了一个神仙up主,狂神说Java,up主讲课的风格我还是很喜欢的,听着不困,花两天把mybatis学了一下,跟着视频记录了点笔记

一、mybatis概念

1、什么是mybatis

  • MyBatis 是一款优秀的持久层框架
  • MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
  • MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息,将接口和 Java 的实体类 【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
  • MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github .

2、如何获得mybatis

  • Maven仓库:https://mvnrepository.com/artifact/org.mybatis/mybatis
  • GitHub : https://github.com/mybatis/mybatis-3
  • Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html

3、持久化,持久层的概念

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

  • 即把数据(如内存中的对象)保存到可永久保存的存储设备中(如磁盘)。持久化的主要应用是将内存中的对象存储在数据库中,或者存储在磁盘文件中、XML数据文件中等等。
  • JDBC就是一种持久化机制。文件IO也是一种持久化机制。

什么是持久层是完成持久化工作的代码块

  • dao层 【DAO (Data Access Object) 数据访问对象】
  • 大多数情况下特别是企业级应用,数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化,而持久化的实现过程则大多通过各种关系数据库来完成。

4、为什么要用mybatis

  • 传统的jdbc操作 , 有很多重复代码块 . 比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率 .
  • MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射

5、使用Mybatis遇到的工程问题汇总

二、mybatis入门案例

1、搭建环境

参考:https://mybatis.org/mybatis-3/zh/getting-started.html
1、搭建数据库环境

2、使用Maven导入Mybatis相关jar包
我碰到了无法导入的情况,根据这篇解决了:maven换源方法


    <dependencies>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.19version>
        dependency>

        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.2version>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>

    dependencies>

3、创建一个模块

  • 【先创建父工程,删除其src文件夹,配置好pom.xml后,创建子模块,这样子模块的依赖就直接用父工程的就行了】

  • 编写Mybatis核心配置文件mybatis-config.xml(连接数据库)



<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                
                <property name="url" value="jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="xxxxxx"/>
            dataSource>
        environment>
    environments>
    <mappers>
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    mappers>
configuration>

2、编写Mybatis工具类

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //1、使用Mybatis来获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //从 SqlSessionFactory获得 SqlSession 的实例。
    //你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

3、编写代码

  • 实体类User【pojo】
  • Dao接口
public interface UserDao {
    public List<User> getUserList();
}
  • 在JDBC中是用【接口实现类】UserDaoImpl,现在Mybatis中用【Mapper配置文件】代替




<mapper namespace="com.lqr.dao.UserDao">
    <select id="getUserList" resultType="com.lqr.pojo.User">
    select * from t_user
  select>
mapper>

4、Junit测试

1、测试代码

public class UserDaoTest {
    @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);
        }
        sqlSession.close();
    }
}

5、测试中遇到的问题

1、【重要】配置文件没有注册
2、绑定接口错误(namespace中的包名要和接口中的包名一致)
3、方法名不对
4、返回类型不对
5、【重要】Maven静态资源过滤问题,在pom文件里插入下面的代码,并且刷新maven

<build>
    <resources>
        <resource>
            <directory>src/main/javadirectory>
            <includes>
                <include>**/*.propertiesinclude>
                <include>**/*.xmlinclude>
            includes>
            <filtering>falsefiltering>
        resource>
        <resource>
            <directory>src/main/resourcesdirectory>
            <includes>
                <include>**/*.propertiesinclude>
                <include>**/*.xmlinclude>
            includes>
            <filtering>falsefiltering>
        resource>
    resources>
build>

6、Intellij idea 报错:Error : java 不支持发行版本5
项目编译配置使用的Java版本不对,需要检查一下项目及环境使用的Java编译版本配置。
https://blog.csdn.net/qq_22076345/article/details/82392236

6、mybatis增删改

1、编写UserMapper接口中方法
2、编写UserMapper.xml中对应的sql语句
3、测试

测试的时候要注意:增删改要提交事务

sqlSession.commit();

假设我们的实体类中,或者数据库中的表,字段,参数过多,可以考虑使用Map传参,直接在sql中取出key即可

int addUser2(Map<String,Object> map);

4、模糊查询
(1)java代码执行的时候传递通配符;

List<User> userList = mapper.getUserLike("l");

(2)在xml文件sql拼接中使用通配符,【把格式写死,预防sql注入!】

<select id="getUserLike" parameterType="String" resultType="com.lqr.pojo.User">
    select * from t_user where username like "%"#{value}"%"
select>

三、配置解析

核心配置文件——mybatis-config.xml。其中能配置的内容如下:
configuration(配置)
properties(属性)
settings(设置)
typeAliases(类型别名)

typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境配置)
environment(环境变量)
transactionManager(事务管理器)
dataSource(数据源)

databaseIdProvider(数据库厂商标识)
mappers(映射器)

1、环境变量(environments)

  1. 配置MyBatis的多套运行环境,将SQL映射到多个不同的数据库上,必须指定其中一个为默认运行环境(通过default指定)
  2. 子元素节点:environment
    • dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。
    • 数据源是必须配置的。
    • 有三种内建的数据源类型:type="[UNPOOLED|POOLED|JNDI]")
  3. 数据源也有很多第三方的实现,比如dbcp,c3p0,druid等等…

2、属性(properties)

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

1、配置文件编写 db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/book?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username=root
password=xxx

2、在核心配置文件中引入properties

  • 可以直接引入外部文件
  • 可以在核心配置文件中增加属性配置
  • 如果两个文件有同一字段,优先使用外部配置文件的
<properties resource="db.properties">properties>

3、类型别名(typeAliases)

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置,意在降低冗余的全限定类名书写。 例如:
(1)typeAlias

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

(2)也可以指定一个包名,MyBatis 会在包名下面搜索每一个在包 domain.blog 中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。

    <typeAliases>
        <typeAlias type="com.lqr.pojo.User" alias="user"/>
        <package name="com.lqr.pojo"/>
    typeAliases>

(3)还可以直接使用注解

@Alias("user")
public class User{
    ...
}

4、设置(settings)

这是 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>

其中比较重要的:

  1. mapUnderscoreToCamelCase
    是否开启驼峰命名自动映射,即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn(last_name —— lastName)。可设置为true | false

  2. logImpl
    指定 MyBatis 所用日志的具体实现,未指定时将自动查找。可设置为SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING

5、其他配置

6、映射器(mappers)

MapperRegister:注册绑定我们的Mapper文件。
这些配置会告诉 MyBatis 去哪里找映射文件,剩下的细节就应该是每个 SQL 映射文件了

注意点:

  • 接口和其Mapper配置文件必须同名
  • 接口和其Mapper配置文件必须在同包下

1、方式1,resource标签,使用相对于类路径的资源引用


<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
mappers>

2、方式2【推荐】,class标签,使用映射器接口实现类的完全限定类名


<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
mappers>

3、方式3


<mappers>
  <package name="org.mybatis.builder"/>
mappers>

四、声明周期和作用域

不同作用域和生命周期类是至关重要的,因为错误的使用会导致非常严重的并发问题。
下图来自:狂神说公众号
Mybatis学习记录_第1张图片

1、SqlSessionFactoryBuilder

  • SqlSessionFactoryBuilder 的作用在于创建 SqlSessionFactory,创建成功后,SqlSessionFactoryBuilder 就失去了作用,所以它只能存在于创建 SqlSessionFactory 的方法中,而不要让其长期存在。
  • SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域(也就是局部方法变量)。

2、SqlSessionFactory

  • SqlSessionFactory 可以被看做一个数据库连接池,它的作用是创建 SqlSession 接口对象。
  • SqlSessionFactory 的生命周期存在于整个 MyBatis 的应用之中,所以一旦创建了 SqlSessionFactory,就要长期保存它,直至不再使用 MyBatis 应用。
  • 所以可以认为 SqlSessionFactory 的生命周期就等同于 MyBatis 的应用周期。
  • 由于 SqlSessionFactory 是一个对数据库的连接池,所以它占据着数据库的连接资源。如果创建多个 SqlSessionFactory,那么就存在多个数据库连接池,这样不利于对数据库资源的控制,也会导致数据库连接资源被消耗光,出现系统宕机等情况,所以尽量避免发生这样的情况。
  • 因此在一般的应用中SqlSessionFactory 作为一个单例,让它在应用中被共享。所以 SqlSessionFactory 的最佳作用域是应用作用域。

3、SqlSession

  • 如果SqlSessionFactory 相当于数据库连接池,那么 SqlSession 相当于一个数据库连接(Connection 对象)
  • 处理完整个请求后,应该关闭这条连接(SqlSession.close()),让它归还给 SqlSessionFactory,否则数据库资源就很快被耗费精光,系统就会瘫痪,所以用 try…catch…finally… 语句来保证其正确关闭。
  • SqlSession 的最佳的作用域是请求或方法作用域。
    Mybatis学习记录_第2张图片

五、resultMap及分页

1、resultMap

要解决的问题:属性名和字段名不一致(pojo类中字段名和数据库中字段名不一致)

比如在mapper.xml中写下

<select id="selectUserById" resultMap="UserMap">
  select id , name , pwd from user where id = #{id}
select>

这句select * from user where id = #{id} 其实可以看做在执行select id,name,pwd from user where id = #{id}
mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值
假设我们pojo中密码对应是“pwd”,而数据库中对应“password”,所以查不到pwd对应的结果,所以在这里需要用到resultMap完成一个由pwd到password的映射。

<resultMap id="UserMap" type="User">
   
   <id column="id" property="id"/>
   
   <result column="name" property="name"/>
   <result column="password" property="pwd"/>
resultMap>

2、分页

为什么要分页

查询大量数据的时候,我们往往使用分页进行查询,也就是每次处理小部分数据,这样对数据库压力就在可控范围内。

MySQL中LIMIT语法

SELECT * FROM table LIMIT stratIndex,pageSize

SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15  

#为了检索从某一个偏移量到记录集的结束所有的记录行,可以指定第二个参数为 -1:   
SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.  

#如果只给定一个参数,它表示返回最大的记录行数目:   
SELECT * FROM table LIMIT 5; //检索前 5 个记录行  

【那么如何在Mybatis中实现分页?】
我们可以用Map传参完成分页,假设参数为stratIndex,pageSize,因此建一个Map对象就ok了

1、添加接口

    //选择全部用户实现分页
    List<User> getUserByLimit(Map<String,Integer> map);

2、修改Mapper

    
    <resultMap id="UserMap" type="User">
        <result column="password" property="pwd"/>
    resultMap>

    <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
        select * from t_user limit #{startIndex}, #{pageSize}
    select>

3、测试

    @Test
    public void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> userList = mapper.getUserByLimit(map);
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }

六、日志

Mybatis内置的日志工厂提供日志功能,具体的日志实现有以下几种工具:

  • SLF4J
  • Apache Commons Logging
  • Log4j 2
  • Log4j 【掌握】
  • JDK logging
  • STDOUT_LOGGING【掌握】

具体选择哪个日志实现工具由MyBatis的内置日志工厂确定。它会使用最先找到的(按上文列举的顺序查找)。如果一个都未找到,日志功能就会被禁用。

    <settings>
        <setting name="logImpl" value="LOG4J"/>
    settings>

1、STDOUT_LOGGING

Mybatis学习记录_第3张图片

2、LOG4J

配置文件:
https://www.cnblogs.com/wangzhuxing/p/7753420.html

什么是LOG4J?

  • Log4j是Apache的一个开源项目
  • 通过使用Log4j,我们可以控制日志信息输送的目的地:控制台,文本,GUI组件…
  • 我们也可以控制每一条日志的输出格式
  • 通过定义每一条日志信息的级别,我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是,这些可以通过一个配置文件来灵活地进行配置,而不需要修改应用的代码。

Mybatis学习记录_第4张图片

简单实用:

1、导入log4j的包
2、配置文件编写

#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/lqr.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

3、setting设置日志实现

    <settings>
        
        <setting name="logImpl" value="LOG4J"/>
    settings>

4、在程序中使用Log4j进行输出!

    static Logger logger = Logger.getLogger(UserMapperTest.class);

    @Test
    public void testLOG4J(){
        logger.info("info:进入selectUser方法");
        logger.debug("debug:进入selectUser方法");
        logger.error("error: 进入selectUser方法");
    }

七、使用注解开发

1、面向接口编程

  • 根本原因 : 【解耦】 (可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好)
  • 接口从更深层次的理解,应是定义(规范,约束)与实现(名实分离的原则)的分离。

2、自动提交事务

在MybatisUtils中设置:sqlSessionFactory.openSession(true);

public class MybatisUtils {
    //提升作用域
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //1、使用Mybatis来获取SqlSessionFactory对象(来自官方文档)
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //2、通过SqlSessionFactor 获得 SqlSession 的实例。
    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。通过 SqlSession 实例来直接执行已映射的 SQL 语句
    public static SqlSession getSqlSession(){

        //设置为true就是自动提交事务
        return sqlSessionFactory.openSession(true);
    }
}

3、使用注解完成CRUD

mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。【但是Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建】

1、我们在我们的接口中添加注解
2、注意【在mybatis的核心配置文件中注入
3、关于@Param()注解:基本类型和String需要加上,引用类型不需要加,如果只有一个基本类型可以忽略(不过建议加上)

    
    <mappers>
        <mapper class="com.lqr.dao.UserMapper"/>
    mappers>

3、代码
编写接口UserMapper ,在接口方法上添加注解。
这里有一点要注意,@Param中的参数一定要和注解中的参数统一。

public interface UserMapper {
    //查询所有结果
    @Select("select * from t_user")
    List<User> getUserList();
    
    //方法前有多个参数,都在前面加上@Param
    @Select("select * from t_user where id = #{id}")
    User getUserById(@Param("id") int id);
    //插入
    @Insert("insert into t_user(id,username,password,email) values(#{id},#{username},#{pwd},#{email})")
    int addUser(User user);
    //更新
    @Update("update t_user set username = #{username} where id = #{id}")
    int updateUser(User user);
    //删除
    @Delete("delete from t_user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
}

测试:UserMapperTest.java

public class UserMapperTest {
    @Test
    public void getUserList(){
        SqlSession session = MybatisUtils.getSqlSession();
        //本质上利用了jvm的动态代理机制
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> users = mapper.getUserList();
        for (User user : users){
            System.out.println(user);
        }
        session.close();
    }

    @Test
    public void getUserById(){
        SqlSession session = MybatisUtils.getSqlSession();
        //本质上利用了jvm的动态代理机制
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        session.close();
    }

    @Test
    public void addUser(){
        SqlSession session = MybatisUtils.getSqlSession();
        //本质上利用了jvm的动态代理机制
        UserMapper mapper = session.getMapper(UserMapper.class);
        mapper.addUser(new User(6,"johnson","000","[email protected]"));
        session.close();
    }

    @Test
    public void updateUser(){
        SqlSession session = MybatisUtils.getSqlSession();
        //本质上利用了jvm的动态代理机制
        UserMapper mapper = session.getMapper(UserMapper.class);
        mapper.updateUser(new User(8,"贺老板","000","[email protected]"));
        session.close();
    }

    @Test
    public void deleteUser(){
        SqlSession session = MybatisUtils.getSqlSession();
        //本质上利用了jvm的动态代理机制
        UserMapper mapper = session.getMapper(UserMapper.class);
        mapper.deleteUser(8);
        session.close();
    }
}

3、Mybatis执行流程分析

Mybatis学习记录_第5张图片

八、一对多和多对一处理

第一次理解起来比较晦涩,建议结合子查询和连接查询好理解点。

1、关系表建立

【student表和teacher表】

CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');

	
CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`), 
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');


SELECT * FROM teacher;
SELECT * FROM student;

2、多对一的处理

1、pojo包下
【在代码中添加注解,这里用到了lombok】

@Data //GET,SET,ToString,有参,无参构造
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
   private int id;
   private String name;
}
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
   private int id;
   private String name;
   //多个学生可以是同一个老师,即多对一
   private Teacher teacher;
}

2、在dao包下编写两个pojo类对应的mapper 接口

3、思考:
按照查询进行嵌套处理就像SQL中的子查询
按照结果进行嵌套处理就像SQL中的联表查询


1、按照查询嵌套处理

1、给StudentMapper接口增加方法

//获取所有学生及对应老师的信息
public List<Student> getStudents();

2、编写对应的StudentMapper文件



<mapper namespace="com.kuang.mapper.StudentMapper">
   
   <select id="getStudents" resultMap="StudentTeacher">
   	select * from student
   select>
   
   <resultMap id="StudentTeacher" type="Student">
       
       <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
   resultMap>
   
   <select id="getTeacher" resultType="teacher">
      select * from teacher where id = #{id}
   select>
mapper>

2、按照结果嵌套处理

1、接口方法编写

public List<Student> getStudents2();

2、编写对应的mapper文件


<select id="getStudents2" resultMap="StudentTeacher2" >
  select s.id sid, s.name sname , t.name tname
  from student s,teacher t
  where s.tid = t.id
select>

<resultMap id="StudentTeacher2" type="Student">
   <id property="id" column="sid"/>
   <result property="name" column="sname"/>
   
   <association property="teacher" javaType="Teacher">
       <result property="name" column="tname"/>
   association>
resultMap>

3、一对多的处理

1、pojo包下
在代码中添加注释

@Data
public class Student {
   private int id;
   private String name;
   private int tid;
}
@Data 
public class Teacher {
   private int id;
   private String name;
   //一个老师多个学生
   private List<Student> students;
}

1、按照查询嵌套

2、按照结果嵌套

4、小结

1、关联-association
2、集合-collection
3、所以association是用于一对一和多对一,而collection是用于一对多的关系
4、JavaType和ofType都是用来指定对象类型的

  • JavaType是用来指定pojo中属性的类型
  • ofType指定的是映射到list集合属性中pojo的类型。

九、动态SQL

动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.

根据作者名字和博客名字来查询博客,如果作者名字为空,那么只根据博客名字查询,反之,则根据作者名来查询

1、写接口类

List<Blog> queryBlogIf(Map map);

2、用if标签写xml


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

十、缓存

1、简介

1、什么是缓存 [ Cache ]?

  • 存在内存中的临时数据。
  • 将用户经常查询的数据放在缓存(内存)中,用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问题。

2、为什么使用缓存?

  • 减少和数据库的交互次数,减少系统开销,提高系统效率。

3、什么样的数据能使用缓存?

  • 经常查询并且不经常改变的数据

2、mybatis缓存

MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
MyBatis系统中默认定义了两级缓存:

  • 一级缓存和二级缓存默认情况下,只有一级缓存开启。
  • SqlSession级别的缓存,也称为本地缓存
  • 二级缓存需要手动开启和配置,他是基于namespace级别的缓存。
  • 为了提高扩展性,MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

你可能感兴趣的:(Java后端)