Mybatis

本文涉及的产品
云数据库 RDS MySQL,集群系列 2核4GB
推荐场景:
搭建个人博客
RDS MySQL Serverless 基础系列,0.5-2RCU 50GB
RDS MySQL Serverless 高可用系列,价值2615元额度,1个月
简介: Mybatis

什么是 MyBatis?

MyBatis 是一款优秀的持久层框架,它支持自定义 SQL、存储过程以及高级映射。

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

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

第一个Mybatis程序

创建数据库环境

CREATE TABLE `user`(
   `id`  int(20) not NULL PRIMARY KEY,
   `name` VARCHAR(50) DEFAULT NULL,
   `pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT into `user`(`id`,`name`,`pwd`) VALUES
(1,'ylc','123'),
(2,'ww','123'),
(3,'张三','123')

新建一个项目

1.建一个普通的maven项目

2.删除src目录,作为父工程使用

3.去官网下载Mysql驱动jar包,在pom文件中写入

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ylc</groupId>
    <artifactId>Mybatis-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Mybatis-01</module>
    </modules>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

创建一个模块

编写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://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value=""/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>
     <mappers>
        <mapper resource="com/ylc/Dao/UserMapper.xml"/>
    </mappers>
</configuration>

编写Mybatis工具类MybatisUtils

public class MybatisUtils {
    public  static SqlSessionFactory sqlSessionFactory=null;
    static {
        try {
            //使用Mybatis获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //有了sqlSessionFactory就可以创建实例了
    public  static SqlSession getSqlSeeionFactory()
    {
        SqlSession sqlSession = sqlSessionFactory.openSession();//这里设置为true可以自动提交事务
        return  sqlSession;
    }
}

编写代码

实体类

package com.ylc.pojo;
public class User {
    private  int id;
    private  String name;
    private  String pwd;
    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public String getPwd() {
        return pwd;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

Dao接口

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

接口实现配置文件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绑定一个对应的Dao、Mapper接口 resultType;返回结果类型-->
<mapper namespace="com.ylc.Dao.UserDao">
    <select id="getUserlist" resultType="com.ylc.pojo.User">
        select * from student.user
    </select>
</mapper>

student是数据库名

生成测试类

public class UserDaoTest{
    @Test
    public void testGetUserlist() {
        //获取sqlSeeionFactory对象
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        //执行sql
        UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
         //方式二
        //List<User> userlist = sqlSeeionFactory.selectList("com.ylc.Dao.UserDao.getUserlist");
        List<User> userlist = mapper.getUserlist();
        for (User user : userlist) {
            System.out.println(user);
        }
        sqlSeeionFactory.close();
    }
}

整体项目结构

增删改实现

接口

public interface UserDao {
    List<User> getUserlist();
    User getUserByID(int id);
    int AddUser(User user);
    int UpdateUser(User user);
    int DeleteUser(int id);
}

Select

  • id:就是namespace中的方法名
  • resultType:sql语句执行的返回值
  • parameterType:传入参数类型
<select id="getUserByID" resultType="com.ylc.pojo.User" parameterType="int">
        select * from student.user where id = #{id}
    </select>
@Test
public void testTestGetUserByID() {
    SqlSession sqlSeenFactors = MybatisUtils.getSqlSeeionFactory();
    UserDao mapper = sqlSeenFactors.getMapper(UserDao.class);
    User userById = mapper.getUserByID(1);
    System.out.println(userById);
    sqlSeenFactors.close();
}

Insert

<insert id="AddUser"  parameterType="com.ylc.pojo.User" >
    insert into student.user(id,name,pwd) values(#{id},#{name},#{pwd});
</insert>
@Test
    public void addUser() {
        User user1=new User(4,"yy","123456");
        SqlSession sqlSeenFactors = MybatisUtils.getSqlSeeionFactory();
        UserDao mapper = sqlSeenFactors.getMapper(UserDao.class);
        Object object = mapper.AddUser(user1);
        sqlSeenFactors.commit();
        System.out.println(object);
        sqlSeenFactors.close();
    }

Update

<update id="UpdateUser" parameterType="com.ylc.pojo.User">
    update student.user set name=#{name},pwd=#{pwd}  where id=#{id};
</update>
public  void  UpdateUser()
{
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
    System.out.println(mapper);
    int updateUser = mapper.UpdateUser(new User(3, "yyy", "11111"));
    sqlSeeionFactory.commit();
    System.out.println(updateUser);
    sqlSeeionFactory.close();
}

Delete

<delete id="DeleteUser" parameterType="int">
    delete from student.user where id=#{id};
</delete>
@Test
public void  DeleteUser()
{
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
    int i = mapper.DeleteUser(4);
    sqlSeeionFactory.commit();
    System.out.println(i);
    sqlSeeionFactory.close();
}

核心配置文件

mybatis-config.xml

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

环境变量environment

Mybatis可以配置多个环境,但是SqlsessionFactory实例只能选择一个环境

默认环境设置,更改default为其他environment的id就可以了

<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://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="19990729Yy"/>
        </dataSource>
    </environment>
    <environment id="text">
        <transactionManager type=""></transactionManager>
        <dataSource type=""></dataSource>
    </environment>
</environments>
transactionManager事务管理器

JDBCMANAGED两种类型:

  • JDBC:使用了JDBC的提交和回滚
  • MANAGED:配置几乎没做什么, 默认情况下它会关闭连接
dataSource数据源

有三种数据类型:UNPOOLEDPOOLEDJNDI

默认的是POOLED

property属性

可以通过properties来引用配置文件

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8
username=root
password=123456

在核心配置文件中映入

<!--引入外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="pwd" value="11111"/>
    </properties>
  • 可以直接引入外部文件
  • 可以在其中增加一些属性配置
  • 如果两个文件有同一个字段,优先使用外部配置文件的!
类型别名typeAliases

存在的意义仅在于用来减少类完全限定名的冗余

<!--可以给实体类起别名-->
<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

也可以指定一个包名,MyBatis 会在包名下面搜索需要的 Java Bean,比如:

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

每一个在包 domain.blog 中的 Java Bean,在没有注解的情况下,会使用 Bean 的首字母小写的非限定类名来作为它的别名。 比如 domain.blog.Author 的别名为 author;若有注解,则别名为其注解值。见下面的例子:

@Alias("author")
public class Author {
}
设置Setting

映射器Mappers

注册绑定Mapper文件

方式一:对于相对路径的资源引用

<mappers>
    <mapper resource="com/ylc/Dao/UserMapper.xml"/>
</mappers>

方式二:通过Class文件绑定注册

接口和Mapper文件必须同名和在同一个包下

<mappers>
    <mapper resource="com.ylc.Dao.UserMapper"/>
</mappers>

方式三:使用扫描包注入

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册!-->
<mappers>
    <package name="com.ylc.dao"/>
</mappers>

接口和Mapper文件必须同名和在同一个包下

生命周期和作用域

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

SqlSessionFactoryBuilder:

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

SqlSessionFactory:

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

SqlSession

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

这里面的每一个Mapper,就代表一个具体的业务!

结果映射

数据库中字段和实体类中字段不对应,会找不到数据,因为类型处理器会直接找数据库中的字段

解决方法:起别名

<select id="getUserById" resultType="com.ylc.pojo.User">
    select id,name,pwd as password from mybatis.user where id = #{id}
</select>

但是这个方法还不太灵活

<!--结果集映射-->
<resultMap id="UserMap" type="User">
    <!--column数据库中的字段,property实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>
<select id="getUserById" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>
  • resultMap 元素是 MyBatis 中最重要最强大的元素
  • ResultMap 的设计思想是,对于简单的语句根本不需要配置显式的结果映射,而对于复杂一点的语句只需要描述它们的关系就行了。
  • ResultMap 最优秀的地方在于,虽然你已经对它相当了解了,但是根本就不需要显式地用到他们。

日志

如果数据库发生了异常怎么可以查看到,需要排错,这时候就需要日志

具体在核心配置文件中设置,但注意日志名称不能输入错误

标准STDOUT_LOGGING日志配置:

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

可以查看到数据库连接情况,以及sql语句和传入的参数,以及返回行数

LOG4J

什么是Log4j?

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

导入Log4j包,在Maven官网找到包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

log4j配置文件

#将等级为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/kuang.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

配置实现

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

最后效果

基本使用

如果要使用LOG4J,需要导入import org.apache.log4j.Logger;

日志对象,参数为当前类的class

static Logger logger = Logger.getLogger(UserDaoTest.class);
public class UserDaoTest {
    static Logger logger = Logger.getLogger(UserDaoTest.class);
    @Test
    public  void  TextLOG4J()
    {
        logger.info("进入了TextLOG4J");
        logger.debug("进入了TextLOG4J");
        logger.error("进入了TextLOG4J");
    }
}

分页

使用limit分页

接口

void gerLimitUser();

Mapper.xml

<select id="gerLimitUser" parameterType="map" resultType="com.ylc.pojo.User">
        select * from student.user limit  #{startindex},#{pagesize}
    </select>

测试

@Test
    public  void  gerLimitUser()
    {
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
        HashMap<String, Integer> map = new HashMap<>();
        map.put("startindex",2);
        map.put("pagesize",2);
        List<User> users = mapper.gerLimitUser(map);
        for (User user : users) {
            System.out.println(user);
        }
        sqlSeeionFactory.close();
    }

使用RowBounds分页

不再使用SQL实现分页

接口

List<User> getUserByRowBounds();

mapper.xml

<select id="getUserByRowBounds" resultMap="UserMap">
    select * from  student.user
</select>

测试

@Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
//RowBounds实现
RowBounds rowBounds = new RowBounds(0, 2);
List<User> userList = sqlSession.selectList("com.ylc.dao.UserMapper.getUserByRowBounds",null,rowBounds);
    for (User user : userList) {
    System.out.println(user);
    }
    sqlSession.close();
    }

使用插件分页

PageHelper

使用注解开发

在接口上写一个注解

@Select("select * from student.user")
List<User> getUsers();

测试

@Test
    public  void  getUsers()
    {
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        UserDao mapper = sqlSeeionFactory.getMapper(UserDao.class);
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }
    }

这样的注解适合简单的sql语句,复杂的还是适合放在XMl里面

Lombok

Project Lombok是一个java库,它可以自动插入编辑器和构建工具,为java增添乐趣。永远不要再编写另一个getter或equals方法,只要有一个注释,您的类就有一个功能齐全的构建器、自动记录变量等等。

比如我们的类中手写了大量的get、set方法,Lombok可以帮助我们简化操作

安装Lombok

导入LomBoK的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger
@Data  //无参构造、get set、hascode、ToString
@Builder
@Singular
@Delegate
@Value
@Accessors
@Wither
@SneakyThrows

测试:

在我们类名前面加上@Data就可以自动生成相应的结构

优点:

能通过注解形式自定生成构造器:无参构造、get set、hascode、ToString等等

让代码更加简洁,便于维护

缺点:

不支持多种参数构造去重载

降低了源代码的可读性和完整性

多对一

关联查询

配置文件

<?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>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <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://waiwanga.mysql.rds.aliyuncs.com:3306?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="19990729Yy"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="StudentMapper.xml"/>
        <mapper resource="TeacherMapper.xml"/>
    </mappers>
</configuration>

proj类

package com.ylc.pojo;
import lombok.Data;
@Data
public class Student {
    private  int id;
    private String name;
    private  Teacher teacher;
}
package com.ylc.pojo;
import lombok.Data;
@Data
public class Teacher {
    private  int id;
    private  String name;
}

StudentMapper.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.ylc.Dao.StudentMapper">
    <select id="getStudent" resultMap="StudentTeacher">
      select * from student.student
    </select>
    <resultMap id="StudentTeacher" type="com.ylc.pojo.Student">
        <result property="id" column="id"></result>
        <result property="name" column="name"></result>
        <association property="teacher" column="tid" javaType="com.ylc.pojo.Teacher" select="getTeacher">
        </association>
    </resultMap>
    <select id="getTeacher" resultType="com.ylc.pojo.Teacher">
        select * from student.teacher where id = #{id}
    </select>
</mapper>

测试类

@Test
    public void getStudent()
    {
        SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
        StudentMapper mapper = sqlSeeionFactory.getMapper(StudentMapper.class);
        List<Student> student = mapper.getStudent();
        for (Student student1 : student) {
            System.out.println(student1);
        }
        sqlSeeionFactory.close();
    }

嵌套查询

<select id="getstudent2" resultMap="StudentTeacher2">
        select s.id sid, s.name sname, t.name tname,t.id tid
        from student.student s,student.teacher t
        where s.tid = t.id ;
    </select>
    <resultMap id="StudentTeacher2" type="com.ylc.pojo.Student">
        <result property="id" column="sid"></result>
        <result property="name" column="sname"></result>
        <association property="teacher" javaType="com.ylc.pojo.Teacher">
            <result property="name" column="tname"></result>
        </association>
    </resultMap>
@Test
public  void  getstudent2()
{
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    StudentMapper mapper = sqlSeeionFactory.getMapper(StudentMapper.class);
    List<Student> student = mapper.getstudent2();
    for (Student student1 : student) {
        System.out.println(student1);
    }
    sqlSeeionFactory.close();
}

一对多

实体类

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

接口

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

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.ylc.Dao.TeacherMapper">
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid, s.name sname, t.name tname,t.id tid
        from student.student s,student.teacher t
        where s.tid = t.id and t.id = #{tid}
    </select>
    <resultMap id="TeacherStudent" type="com.ylc.pojo.Teacher">
        <result column="tid" property="id"></result>
        <result column="tname" property="name"></result>
        <collection property="studentList"  ofType="com.ylc.pojo.Student">
            <result column="sid" property="id"></result>
            <result column="sname" property="name"></result>
            <result column="tid" property="tid"></result>
        </collection>
    </resultMap>
</mapper>

测试类

@Test
public void getTeacher() {
    SqlSession sqlSeeionFactory = MybatisUtils.getSqlSeeionFactory();
    TeacherMapper mapper = sqlSeeionFactory.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher(1);
    System.out.println(teacher);
    sqlSeeionFactory.close();
}

动态SQL

IF

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

choose (when, otherwise)

<select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from mybatis.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>

trim (where,set)

select * from mybatis.blog
<where>
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</where>
<update id="updateBlog" parameterType="map">
    update mybatis.blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author != null">
            author = #{author}
        </if>
    </set>
    where id = #{id}
</update>

所谓的动态SQL,本质还是SQL语句 , 只是我们可以在SQL层面,去执行一个逻辑代码

SQL片段

有的时候,我们可能会将一些功能的部分抽取出来,方便复用!

  1. 使用SQL标签抽取公共的部分
<sql id="if-title-author">
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</sql>
  1. 在需要使用的地方使用Include标签引用即可
<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <include refid="if-title-author"></include>
    </where>
</select>

注意事项:

  • 最好基于单表来定义SQL片段!
  • 不要存在where标签

Foreach

select * from user where 1=1 and 
  <foreach item="id" collection="ids"
      open="(" separator="or" close=")">
        #{id}
  </foreach>
(id=1 or id=2 or id=3)

<!--
        select * from mybatis.blog where 1=1 and (id=1 or id = 2 or id=3)
        我们现在传递一个万能的map , 这map中可以存在一个集合!
-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <foreach collection="ids" item="id" open="and (" close=")" separator="or">
            id = #{id}
        </foreach>
    </where>
</select>

缓存

经常查询并且不经常改变的数据。可以使用缓存

MyBatis系统中默认定义了两级缓存:一级缓存二级缓存

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

缓存失效的情况:

  1. 查询不同的东西
  2. 增删改操作,可能会改变原来的数据,所以必定会刷新缓存!

  3. 查询不同的Mapper.xml
  4. 手动清理缓存!

小结:一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段!

一级缓存就是一个Map。

二级缓存

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

步骤:

  1. 开启全局缓存
<!--显示的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>
  1. 在要使用二级缓存的Mapper中开启
<!--在当前Mapper.xml中使用二级缓存-->
<cache/>
  1. 也可以自定义参数
<!--在当前Mapper.xml中使用二级缓存-->
<cache  eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"/>
  1. 测试
  1. 问题:我们需要将实体类序列化!否则就会报错!
Caused by: java.io.NotSerializableException: com.kuang.pojo.User

小结:

  • 只要开启了二级缓存,在同一个Mapper下就有效
  • 所有的数据都会先放在一级缓存中;
  • 只有当会话提交,或者关闭的时候,才会提交到二级缓冲中!
  • 开启二级缓存需要序列化对象

缓存原理

自定义缓存-ehcache

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存

要在程序中使用ehcache,先要导包!

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>

在mapper中指定使用我们的ehcache缓存实现!

<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

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">
    <!--
       diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk:硬盘最大缓存个数。
      eternal:对象是否永久有效,一但设置了,timeout将不起作用。
      overflowToDisk:是否保存到磁盘,当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
      diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
      memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
      clearOnFlush:内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。
      FIFO,first in first out,这个是大家最熟的,先进先出。
      LFU, Less Frequently Used,就是上面例子中使用的策略,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
      LRU,Least Recently Used,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
</ehcache>
相关实践学习
如何在云端创建MySQL数据库
开始实验后,系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心,利用清洁计算为万物互联的新世界提供源源不断的能源动力,目前开服的区域包括中国(华北、华东、华南、香港)、新加坡、美国(美东、美西)、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程,来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品:云服务器ECS 云服务器 ECS(Elastic Compute Service)是一种弹性可伸缩的计算服务,助您降低 IT 成本,提升运维效率,使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
相关文章
|
SQL Java 数据库连接
|
3月前
|
SQL Java 数据库连接
Mybatis01
Mybatis01
33 0
|
1月前
|
SQL 缓存 Java
MyBatis系列
MyBatis系列
|
4月前
|
SQL 算法 Java
MyBatis-Plus详解(3)
MyBatis-Plus详解(3)
60 0
|
4月前
|
SQL Java 数据库连接
Mybatis(四)
Mybatis(四)
35 0
|
6月前
|
SQL Java 数据库连接
MyBatis
MyBatis
41 2
|
6月前
|
SQL Java 数据库连接
从0开始回顾Mybatis
Mybatis 1、什么是Mybatis? 概念: 1. Mybatis 是一个半 ORM(对象关系映射)框架,它内部封装了 JDBC,开发时只需要关注 SQL 语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement 等繁杂的过程。程序员直接编写原生态 sql,可以严格控制 sql 执行性能,灵活度高。 2. MyBatis 可以使用 XML 或注解来配置和映射原生信息,将 POJO 映射成数据库中的记录,避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。 缺点: 1. SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求
|
XML Java 数据库连接
MyBatis-Plus使用
MyBatis-Plus使用
|
SQL XML 存储
Mybatis总结
Mybatis总结
107 0
|
Java 数据库连接 mybatis
MyBatis总结
MyBatis总结
71 0
MyBatis总结