Mybatis学习笔记

最新推荐文章于 2022-08-09 00:28:28 发布
最新推荐文章于 2022-08-09 00:28:28 发布
阅读量288 收藏
点赞数
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W15755832673/article/details/109705121
版权
本文详细介绍了Mybatis项目的结构，包括MyBatisUtil工具类的使用、db.properties配置文件、Mybatis_config.xml中的配置、以及如何进行数据库操作、分页查询、注解查询、多对一处理和动态SQL。还涵盖了缓存机制，如一级和二级缓存的开启与配置。
摘要由CSDN通过智能技术生成

Mybatis项目基本结构

MyBatisUtil工具类

package com.Mybatis.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 MyBatisUtil {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource = "Mybatis_config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
        //设置为true可以自动提交事务
        return sqlSessionFactory.openSession(true);
    }
}

db.properties连接数据库文本

driver=com.mysql.jdbc.Driver

url=jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8
userName=root
password=123456

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>
<!--外部引入配置文件,properties标签必须在最上面否则报错-->
    <properties resource="db.properties"/>
<!--日志工厂，注意标签位置-->
    <settings>
<!--标准的日志工厂，注意大小写不能错，name和value里面不能有空格，否则报错-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
<!--给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.Mybatis.bank.Student" alias="Student"/>
        <typeAlias type="com.Mybatis.bank.Teacher" alias="Teacher"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${userName}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="StudentMapper.xml"/>
        <mapper resource="TeacherMapper.xml"/>
    </mappers>
</configuration>

Mapp.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">
<!--namespace绑定目录下的接口-->
<mapper namespace="com.Mybatis.dao.BlogMapper">
</mapper>

pom.xml中导入依赖

dependencies>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <!--Mybatis依赖-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <!--junit依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
    </dependency>
</dependencies>
<!--在pom.xml下的build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <excludes>
                <exclude>**/*.properties</exclude>
                <exclude>**/*.xml</exclude>
            </excludes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

第一个Mybatis程序步骤

一、在pom.xml中导入依赖

<dependencies>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <!--Mybatis依赖-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <!--junit依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
    </dependency>
</dependencies>
<!--在pom.xml下的build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <excludes>
                <exclude>**/*.properties</exclude>
                <exclude>**/*.xml</exclude>
            </excludes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

二、连接数据库并创建实体类

注：实体类的字段要和数据库里的字段对应

package com.Mybatis.dao;
public class User {
    private int id;
    private String name;
    private String money;

    public User() {
    }
    public User(int id, String name, String money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }
    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 getMoney() {
        return money;
    }
    public void setMoney(String money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money='" + money + '\'' +
                '}';
    }
}

三、创建一个接口

package com.Mybatis.dao;

import java.util.List;

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

四、创建MybatisUtil工具类

package com.Mybatis.util;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
public class MyBatisUtil {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            String resource = "Mybatis_config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }

五、创建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://localhost:3306/jdbc?useSSL=false&amp;useUnicode=true&amp;"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

六、创建查询UserMapper.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">
<!--namespace绑定目录下的接口-->
<mapper namespace="com.Mybatis.dao.UserMapper">
    <!--id绑定接口里面的泛型 resultType:类型的意思 绑定实体类 -->
    <select id="getUserList" resultType="com.Mybatis.dao.User">
        select * from jdbc.people;
    </select>
</mapper>

七、创建测试类进行测试

package com.Mybatis.dao;

import com.Mybatis.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserTest {
    @Test
    public void test(){
        //获得SqlSession对象
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        //方式一：getMapper
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //获取接口中的泛型
        List<User> userList = userMapper.getUserList();
        //遍历
        for (User user : userList) {
            System.out.println(user);
        }
        //关闭sqlSession资源
        sqlSession.close();
    }
}

Mybatis增删改查

注：增删改查需要提交事务

一、Select

选择、查询语句：
id：对应的是namespace中的方法名
resultType：Sql语句执行的返回值！

1、编写接口

//查询全部用户
List<User> getUserList();

2、编写SQL

<!--查询全部用户-->
<select id="getUserList" resultType="com.Mybatis.dao.User">
    select * from jdbc.people;
</select>

3、测试

@Test
public void test(){
    //获得SqlSession对象
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    //方式一：getMapper
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    //获取接口中的泛型
    List<User> userList = userMapper.getUserList();
    //遍历
    for (User user : userList) {
        System.out.println(user);
    }
    //关闭sqlSession资源
    sqlSession.close();
}

二、Insert

1、编写接口

//插入数据
int addUser(User user);

2、编写SQL

<!--插入数据-->
<insert id="addUser" parameterType="com.Mybatis.dao.User">
    insert into jdbc.people (id, name, money) values (#{id},#{name},#{money});
</insert>

3、测试

//插入数据
@Test
public void addUser(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();

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

    int i = mapper.addUser(new User(4, "哈哈", "5000"));
    System.out.println(i);
    //必须提交事务否则插入数据不成功
    sqlSession.commit();
    sqlSession.close();
}

三、Update

1、编写接口

//修改用户
int updateUser(User user);

2、编写SQL

<!--修改用户信息-->
<update id="updateUser" parameterType="com.Mybatis.dao.User">
    update jdbc.people set name=#{name},money=#{money} where id = #{id};
</update>

3、测试

@Test
public void updateUser(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser(new User(4,"呵呵","6000"));
    //必须提交事务否则插入数据不成功
    sqlSession.commit();
    sqlSession.close();
}

四、Delete

1、编写接口

//删除用户
int deleteUser(int id);

2、编写SQL

<!--根据ID删除用户-->
<delete id="deleteUser" parameterType="com.Mybatis.dao.User">
    delete from jdbc.people where id =#{id};
</delete>

3、测试

@Test
public void deleteUser(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser(4);
    //必须提交事务
    sqlSession.commit();
    sqlSession.close();
}

五、模糊查询

1、编写接口

//模糊查询
List<User> getUserLike(String name);

2、编写SQL

<!--模糊查询-->
<select id="getUserLike" resultType="com.Mybatis.dao.User">
    select * from jdbc.people where name like #{name};
</select>

3、测试

//模糊查询
@Test
public void getUserLike(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userLike = mapper.getUserLike("%A%");
    for (User user : userLike) {
        System.out.println(user);
    }
    sqlSession.close();

Mybatis配置解析

1、核心配置文件

Mybatis_config.xml

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

2. 环境配置 environments

MyBatis默认的事务管理器就是JDBC ，连接池：POOLED
学会使用配置多套运行环境！

<configuration>
<!--外部引入配置文件,properties标签必须在最上面否则报错-->
    <properties resource="db.properties"/>
    //根据default选择每一套的id进行使用
    <environments default="development">
    //第一套配置环境
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${userName}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
        //第二套配置环境
        <environment id="test">
            <transactionManager type=""></transactionManager>
            <dataSource type=""></dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

3. 属性 properties

我们可以通过properties属性来实现引用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.poperties】
编写一个配置文件db.poperties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8
userName=root
password=123456

在核心配置文件中引入

<!--外部引入配置文件,properties标签必须在最上面否则报错-->
    <properties resource="db.properties"/>
    <environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
        //引入外部配置文件后value的值要改成db.poperties文件中对应的字段否则报错
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${userName}"/>
            <property name="password" value="${password}"/>
        </dataSource>
    </environment>
</environments>
  • 可以直接引入外部文件
  • 可以在其中增加一些属性配置
  • 如果两个文件有同一个字段，优先使用外部配置文件的

4、给实体类起别名

第一种:直接给类起一个别名代替冗长的包名

<!--给实体类起别名-->
    <typeAliases>
        <typeAlias type="com.Mybatis.dao.User" alias="User"/>
    </typeAliases>

修改SQL

<!--查询全部用户-->
       // resultType这里可以修改成别名，不用每次都要.包名
<select id="getUserList" resultType="User">
    select * from jdbc.people;
</select>
<!--根据ID查询用户-->
<select id="getUserById" parameterType="int" resultType="com.Mybatis.dao.User">
    select * from  jdbc.people where id = #{id}
</select>

第二种：给出指定的包名然后扫描此包下面的实体类
如果要改名字必须加注解，有注解的名的实体类优先使用注解名

@Alias("aaaa")
public class User {
}

SQL

<!--查询全部用户-->
//resultType优先使用注解名
<select id="getUserList" resultType="aaaa">
    select * from jdbc.people;
</select>
<!--给实体类起别名-->
    <typeAliases>
        <package name="com.Mybatis.dao"/>
    </typeAliases>

修改SQL

<!--查询全部用户-->
//resultType此次官方建议首字母小写，有利于搜索包名
    <select id="getUserList" resultType="user">
        select * from jdbc.people;
    </select>
    <!--根据ID查询用户-->
    <select id="getUserById" parameterType="int" resultType="com.Mybatis.dao.User">
        select * from  jdbc.people where id = #{id}
    </select>

注：在实体类比较少的时候，使用第一种方式。
如果实体类十分多，建议用第二种扫描包的方式。
第一种可以自定义别名，第二种不行，如果非要改，需要在实体上增加注解。

5、作用域和生命周期

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

  1. 一旦创建了SqlSessionFactory，就不再需要它了
  2. 局部变量

SqlSessionFactory:

  1. 说白了就可以想象为：数据库连接池
  2. SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建一个实例。
  3. 因此SqlSessionFactory的最佳作用域是应用作用域（ApplocationContext）。
  4. 最简单的就是使用单例模式或静态单例模式。

SqlSession：

  1. 连接到连接池的一个请求
  2. SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
  3. 用完之后需要赶紧关闭，否则资源被占用！

Mybatis结果集映射

解决实体类属性名和数据库字段名不一致的问题

  • resultMap 元素是 MyBatis 中最重要最强大的元素。
  • ResultMap 的优秀之处——你完全可以不用显式地配置它们
    数据库字段名
    在这里插入图片描述
    实体类属性名
    在这里插入图片描述

resultMap结果集映射

<mapper namespace="com.Mybatis.dao.UserMapper">
    <!--结果集映射-->
    //这个ID绑定的是查询语句中的resultMap，type绑定的是实体类这里的User用的是别名
    <resultMap id="UserMap" type="User">
    <!--column表示数据库中的字段，property表示实体类中的属性-->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="money" property="qian"/>
    </resultMap>
    <!--根据ID查询用户-->
    //结果集映射必须用resultMap
    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from  jdbc.people where id = #{id}
    </select>
</mapper>

Mybatis日志工厂

日志是用于数据库出错来进行排除错误

1、STDOUT_LOGGING

<settings>
<!--标准的日志工厂，注意大小写不能错，name和value里面不能有空格，否则报错-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

日志工厂打印
在这里插入图片描述

2、LOG4J日志

什么是Log4j？

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

先再pom.xml中导入log4j包

<!--引入log4j包-->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

新建log4j.properties文件

#将等级为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/rzp.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.sq1.PreparedStatement=DEBUG

修改settings标签

<settings>
<!--标准的日志工厂，注意大小写不能错，name和value里面不能有空格，否则报错-->
        <setting name="logImpl" value="LOG4J"/>
</settings>

测试打印
在这里插入图片描述

使用LOG4J

在测试类中创建class对象

//LOG4J 测试
@Test
public void LOG4J(){
    Logger logger = Logger.getLogger(UserTest.class);
    logger.info("info");
    logger.debug("debug");
    logger.error("error");
}

注意引包：import org.apache.log4j.Logger;
日志级别

  1. info
  2. debug
  3. error

Mybatis分页查询

编写接口

//分页查询
List<User> getUserList(HashMap<String, Integer> map);

编写SQL

<!--分页查询-->
<select id="getUserList" parameterType="map" resultMap="UserMap">
    select *from jdbc.people limit #{Index},#{Size}
</select>

测试

//分页查询
@Test
public void getUserList(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("Index",1);
    map.put("Size",2);
    List<User> userList = mapper.getUserList(map);
    for (User user : userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

Mybatis注解查询

注：注解查询只能用于简单的SQL语句复杂的SQL语句还是要用xml
使用注解要在实体类里使用有参构成方法

public User(int id, String name, String money) {
    this.id = id;
    this.name = name;
    this.money = money;
}

注解在接口上实现

//使用注解查询所用用户
@Select("select * from people")
List<User> getS();

在配置文件上绑定接口

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

测试

/注解查询所有用户
@Test
public void getC(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = mapper.getS();
    for (User user : users) {
        System.out.println(user);
    }
    sqlSession.close();
}

注解编写接口

/使用注解用id查询用户
//方法存在多个参数，所有参数前面必须加上@Param("id")注解
@Select("select * from people where id = #{id}")
User getId(@Param("id") int id,@Param("name") String name);

在配置文件上绑定接口

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

测试

/注解用ID查询用户
@Test
public void getID(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.getId(4,"AC");

    sqlSession.close();
}

注解编写接口：使用注解插入信息

注： 插入和修改可以不用写提交事务但是前提是你要开启自动提交事务

public static SqlSession getSqlSession(){
    //设置为true可以自动提交事务
    return sqlSessionFactory.openSession(true);
}

//使用注解插入信息
@Insert("insert into user(id,name,money) values(#{id},#{name},#{money})")
int addUser(User user);

测试

//使用注解插入信息
@Test
public void get(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.addUser(new User(5,"ad","12345"));
    sqlSession.close();
}

编写接口：使用注解修改信息

//使用注解修改信息
@Update("update people set name=#{name},money=#{money} where id = #{id}")
int updateUser(User user);

测试

//使用注解修改数据
@Test
public void getT(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser(new User(5,"AP","5000"));
    sqlSession.close();
}

编写接口：使用注解根据ID删除信息

//使用注解删除信息
@Delete("DELETE from people WHERE id=#{id}")
int getDelete(int id);

测试

//使用注解根据ID删除数据
@Test
public void getO(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.getDelete(5);
    sqlSession.close();
}

Mybatis多对一处理

javaType & ofType

  1. JavaType用来指定实体类中的类型
  2. ofType用来指定映射到List或者集合中的pojo类型，泛型中的约束类型

多对一按查询嵌套处理

<resultMap id="StudentTeacher" type="Student">
    <!--此处是结果集映射，property是实体类对应的属性，column是数据库里对应的字段-->
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <association property="teacher" column="tid" javaType="Teacher" select="getID"/>
</resultMap>
<select id="getStudent" resultMap="StudentTeacher">
    select *from jdbc.student;
</select>

接口

//查询所有学生
List<Student> getStudent();

测试

@org.junit.Test
public void getStu(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> student = mapper.getStudent();
    for (Student student1 : student) {
        System.out.println(student1);
    }
    sqlSession.close();
}

多对一按结果嵌套处理

关联 - association 【多对一】

<!--按照结果嵌套处理-->
    <select id="getStudent2" resultMap="StudentTeacher2">
    //SQL查询起别名
        select s.id sid,s.name sname,t.name tname from 
        jdbc.student s,jdbc.teacher t where s.tid = t.id;
    </select>
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
<!--如果复杂的多个表则使用association,property表示实体类里面的属性，
    javaType表示第二张表对应的实体类名字-->
        <association property="teacher" javaType="Teacher">
            <!--第二张表实体类对应的字段-->
            <result property="name" column="tname"/>
        </association>
    </resultMap>

接口

List<Student> getStudent2();

测试

@org.junit.Test
public void getStu2(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> student = mapper.getStudent2();
    for (Student student1 : student) {
        System.out.println(student1);
    }
    sqlSession.close();
}

一对多按照结果嵌套处理

集合 - collection 【一对多】

更改实体类Student

public class Student {
    private int id;
    private String name;
    private Teacher teacher;
    private int tid;//加上数据对应的主键tid，并get和set
    }

更改实体类Teacher

public class Teacher {
    private int id;
    private String name;
    //一个老师拥有多个学生
    private List<Student> students;//加上泛型集合并get和set
    }

接口

List<Teacher> getTeacher(@Param("tid") int id);

查询语句

<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,s.name sname, t.name tname,t.id tid from
     jdbc.student s,jdbc.teacher t
     where s.tid = t.id and t.id = #{tid}
</select>
   <resultMap id="TeacherStudent" type="Teacher">
       <result property="id" column="tid"/>
       <result property="name" column="tname"/>
       <!--复杂的属性需要单独处理 如果是对象使用：association
       如果是集合使用：collection javaType=""
       指定属性类型，集合泛型信息使用ofType-->
       <!--students是Teacher实体类的变量 ofType表示要填的泛型信息Student
       因为一对多使用了泛型集合所有要用collection-->
       <collection property="students" ofType="Student">
           <result property="id" column="sid"/>
           <result property="name" column="sname"/>
           <result property="tid" column="tid"/>
       </collection>
   </resultMap>

测试

@org.junit.Test
public void getTeacher(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
    List<Teacher> teacher = mapper.getTeacher(1);
    for (Teacher teacher1 : teacher) {
        System.out.println(teacher1);
    }
    sqlSession.close();
}

Mybatis动态SQL

  1. 什么是动态SQL：动态SQL就是根据不同的条件生成不同的SQL语句
  2. 所谓的动态SQL，本质上还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码

创建基础项目

实体类

package com.Mybatis.pojo;
import java.util.Date;
//需要get和set
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;//和数据库字段不一样，
    //在Mybatis_config.xml开启驼峰命名映射只有下划线可以
    private int views;
    }

新东西：在Mybatis_config.xml添加驼峰命名自动映射

<settings>
<!--标准的日志工厂，注意大小写不能错，name和value里面不能有空格，否则报错-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
<!--是否开启驼峰命名自动映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

动态SQL：IF，where

这个where标签会知道如果它包含的标签中有返回值的话，它就插入一个where。此外，如果标签返回的内容是以 AND 或 OR 开头的，则它会剔除掉。

接口

//查询数据
List<Blog> getBlog(Map map);

SQL语句

<select id="getBlog" resultType="Blog">
    select * from jdbc.blog
    <where>
        <if test="title !=null">
            title = #{title}
        </if>
        <if test="author !=null">
            and author = #{author}
        </if>
    </where>
</select>

测试

@org.junit.Test
public void get(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setTitle("Java");//获取数据库title字段中带有Java的数据
    blog.setAuthor("狂神说");
    List<Blog> blog1 = mapper.getBlog(blog);
    for (Blog blog2 : blog1) {
        System.out.println(blog2);
    }
    sqlSession.close();
}

动态SQL：choose、when、otherwise

有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句

接口

List<Blog> getBlog2(Blog blog);

SQL语句

<select id="getBlog2" parameterType="Blog" resultType="Blog">
    select *from jdbc.blog
    <where>
        <choose>
            <when test="title !=null">
                title = #{title}
            </when>
            <when test="author!=null">
                and author = #{author}
            </when>
            <otherwise>
                and views = #{views}
            </otherwise>
        </choose>
    </where>
</select>

注：这里的三个条件在查询的时候只要满足一个条件的时候就可以查询处理，如果有三个指定条件，那么默认查询SQL中第一个title字段

测试

@org.junit.Test
public void get2(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setAuthor("狂神说");
    blog.setTitle("Java");//默认查询SQL中title字段
    blog.setViews(1000);
    List<Blog> blog1 = mapper.getBlog2(blog);
    for (Blog blog2 : blog1) {
        System.out.println(blog2);
    }
    sqlSession.close();
}

动态SQL：set标签

注：set元素就可以实现此功能。set元素遇到逗号，它会自动将对应的逗号去掉。

接口

//更新数据
int updateBlog(Blog blog);

SQL语句

<update id="updateBlog" parameterType="Blog">
    update jdbc.blog
    <set>
        <if test="title!=null">
            title = #{title},//后面必须加逗号
        </if>
        <if test="author!=null">
            author =#{author}
        </if>
        where views = #{views}
    </set>
</update>

测试

@org.junit.Test
public void get3(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setTitle("SpringBoot");
    blog.setAuthor("狂神");
    blog.setViews(1000);//把数据库字段views中等于1000的数据更改
    mapper.updateBlog(blog);
    sqlSession.close();
}

动态SQL：SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用！
使用SQL标签抽取公共部分可，在需要使用的地方使用Include标签引用即可
注：最好基于简单的查询来定义SQL片段
不要存在where标签

接口

List<Blog> getBlog(Blog blog);

SQL语句

<sql id="if">
    <if test="title !=null">
        title = #{title}
    </if>
    <if test="author !=null">
        and author = #{author}
    </if>
</sql>
<select id="getBlog" parameterType="Blog" resultType="Blog">
    select * from jdbc.blog
    <where>
    //引入SQL
        <include refid="if"></include>
    </where>
</select>

测试

@org.junit.Test
public void get(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setAuthor("狂神说");
    List<Blog> blog1 = mapper.getBlog(blog);
    for (Blog blog2 : blog1) {
        System.out.println(blog2);
    }
    sqlSession.close();
}

动态SQL：foreach

接口

List<Blog> ForE(Map map);

SQL语句

<select id="ForE" parameterType="map" resultType="Blog">
    select *from jdbc.blog
    <where>
    //select *from jdbc.blog where 1=1 and(id=1 or id=2 or id=3)
        //collection属性类型item要查询的字段open要拼接的开头两个字符之间必须有空格 close要拼接的尾
        <foreach collection="ids" item="id" open="and ("  separator="or" close=")">
            id = #{id}
        </foreach>
    </where>
</select>

测试

@org.junit.Test
public void get4(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
    HashMap hashMap = new HashMap();
    ArrayList<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(2);
    hashMap.put("ids",ids);
    List<Blog> blogs = mapper.ForE(hashMap);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    sqlSession.close();
}

Mybatis缓存

简介

什么是缓存[Cache]？

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

为什么使用缓存？

  1. 减少和数据库的交互次数，减少系统开销，提高系统效率

什么样的数据可以使用缓存？

  1. 经常查询并且不经常改变的数据 【可以使用缓存】

MyBatis缓存

  1. MyBatis包含一个非常强大的查询缓存特性，它可以非常方便的定制和配置缓存，缓存可以极大的提高查询效率。
  2. MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
  3. 默认情况下，只有一级缓存开启（SqlSession级别的缓存，也称为本地缓存）
  4. 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  5. 为了提高可扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。

一级缓存

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

测试步骤：

  1. 开启日志
  2. 测试在一个Session中查询两次记录
@org.junit.Test
public void test(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    PeopleMapper mapper = sqlSession.getMapper(PeopleMapper.class);
    People people = mapper.getPeople(1);
    System.out.println(people);
    System.out.println("============");
    People people2 = mapper.getPeople(1);
    System.out.println(people2);
    System.out.println(people==people2);
    sqlSession.close();
}

查看日志输出（有缓存执行了一次SQL）
在这里插入图片描述
缓存失效的情况：

  1. 查询不同的东西
  2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存
  3. 查询不同的Mapper.xml
  4. 手动清理缓存
sqlSession.clearCache();

清理缓存后再次执行（清理缓存后执行了两次次SQL）
在这里插入图片描述

二级缓存

  1. 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
  2. 基于namespace级别的缓存，一个名称空间，对应一个二级缓存

工作机制

  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
  • 如果会话关闭了，这个会话对应的一级缓存就没了；但是想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
  • 新的会话查询信息，就可以从二级缓存中获取内容
  • 不同的mapper查询出的数据会放在自己对应的缓存（map）中
    一级缓存开启（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  • 为了提高可扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来定义二级缓存。
    步骤：
    开启全局缓存
<!--开启全局缓存-->
        <setting name="cacheEnabled" value="true"/>

使用全局缓存

<cache/>

也可以自定义全局缓存

<cache
        eviction="FIFO"//创建了一个 FIFO 缓存
        flushInterval="60000"//每隔 60 秒刷新
        size="512"//最多可以存储结果对象或列表的 512 个引用
        readOnly="true"/>//而且返回的对象被认为是只读的

SQL

<!--在当前PeopleMapper.xml中使用二级缓存-->
    <cache
            eviction="FIFO"
            flushInterval="60000"
            size="512"
            readOnly="true"/>
            //useCache使用缓存
    <select id="getPeople" resultType="People" useCache="true">
        select *from jdbc.people where id = #{id}
    </select>

测试

@org.junit.Test
public void test(){
    SqlSession sqlSession = MyBatisUtil.getSqlSession();
    SqlSession sqlSession2 = MyBatisUtil.getSqlSession();
    PeopleMapper mapper = sqlSession.getMapper(PeopleMapper.class);
    People people = mapper.getPeople(1);
    System.out.println(people);
    sqlSession.close();
    PeopleMapper mapper2 = sqlSession2.getMapper(PeopleMapper.class);
    People people2 = mapper2.getPeople(1);
    System.out.println(people2);
    System.out.println(people==people2);
    sqlSession2.close();
}

注：

  1. 只要开启了二级缓存，在同一个Mapper下就有效
  2. 所有的数据都会放在一级缓存中
  3. 只有当前会话提交，或者关闭的时候，才会提交到二级缓存中
    4. 缓存顺序：先查看二级缓存中有没有数据，再看一级缓存中有没有数据最后再查询数据库
暮冬223
关注
专栏目录
MyBatis 学习笔记（全）
khxu666的博客
10-12 1593
mybatis 学习笔记 文章很长，对 Mybatis 的最常用的基础部分做了总结和概括，基本不涉及源码和深入的实现... 本文在上面引用中的两个文章（mybatis学习笔记、聊聊MyBatis缓存机制）的基础上进行整理、合并。 感谢原作者的付出。
mybatis学习笔记
iteye_8029的博客
01-28 160
mybatis的resultmap与resultclass: 1、resultMap属于直接映射，可以把结果集中的数据库字段与实体类中的属性一一对应，这样通过select语句得到的结果就会准确的对上号 2、resultclass属于隐身映射，虽然你指定resultclass=“”，具体某一个类，但是select语句得到的结果是一条实力记录，但如果数据库字段与类的属性名字不一致，这个...
Mybatis学习笔记（一）
lovely__RR的博客
04-09 306
作者最近在学ssm框架，自己学了点之后的确发现有点难啃，而且自己一开始的学习方向就错了，听了同学的建议才知道，应该先学mybatis，所以又浪费了不少的时间，所以希望大家能够借鉴 自己其实也是跟在一个大神后面学的，这里附上大神的链接大神的博客园地址 接下来就是作者自己天学的 第一创建相关的数据库以及表 create database mybatis; use mybatis; CREATE TA...
Mybatis学习笔记(一)
MineCodelife的博客
07-18 474
MyBatis 是一个可以自定义 SQL、存储过程和高级映射的持久层框架。 MyBatis 摒除了大部分的 JDBC 代码、手工设置参数和结果集重获。 MyBatis 只使用简单的 XML 和注解来配置和映射基本数据类型、Map 接口和 POJO 到数据库记录。 SqlSessionFactoryBuilder SqlSessionFactoryBuilder 用于创建 SqlSessionFa...
MyBatis学习笔记
03-12
MyBatis的学习不仅仅限于这些基础概念，还包括如何配置MyBatis、如何编写Mapper接口和XML映射文件、如何处理复杂查询和关联关系、如何利用MyBatis进行性能优化等。通过深入学习MyBatis，你可以更好地理解和掌控...
MyBatis学习笔记1
04-02
【标题】"MyBatis学习笔记1" 涉及的知识点主要集中在MyBatis这一流行的持久层框架上。MyBatis是一个优秀的Java ORM（对象关系映射）框架，它允许开发者将SQL查询与Java代码分离，使得数据库操作更加灵活且易于维护。...
MyBatis学习笔记（一）
程哥哥的一亩三分地
08-09 276
因此一个映射文件对应一个实体类，对应一张表的操作；工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象。若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中，只需要通过**此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；此时可以使用**$ {}和# {}**以任意的名称获取参数的值，注意${}需要手动加单引号。...
MyBatis学习笔记（全）
m0_45364328的博客
06-04 287
MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下， iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github。iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。1） M
MyBatis学习笔记（系统学习）
给时光以文明
08-18 448
文章目录一、简介1.MyBatis是什么2.持久层3.ORM4.回顾JDBC二、正式使用MyBatis的准备工作1. 需要在项目中添加JAR包2. 相关的配置文件的准备工作三、第一个MyBatis程序1. 数据库的设计2. 创建主配置文件3.创建映射文件4.MyBatis中数据库日志：log4j5.如何在IDEA中快速的使用数据库中的字段等信息来确定SQL语句四、基于接口的MyBatis映射文件五、MyBatis工具类六、MyBatis主配置文件的扩展：配置别名，引用属性文件七、MyBatis对数据库表的基
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值