【Day06-maven基础】

完球了

于 2024-09-27 16:20:21 发布

阅读量366

点赞数 11

本文链接：https://blog.csdn.net/Doshaxin/article/details/142594959

版权

Mybatis入门（重点）

什么是Mybatis?

框架可以理解为半成品软件，框架做好以后，程序员只需要在它基础上继续进行后面的开发
框架中一般都是所有程序员都需要开发的重复代码，框架把这些提供好之后，程序员就可以把精力专注在核心业务上
学习框架, 关注点: 怎么去用这个框架

简介

框架

框架可以理解为半成品软件，框架做好以后，程序员只需要在它基础上继续进行后面的开发

框架中一般都是所有程序员都需要开发的重复代码，框架将这些做好之后，程序员就可以把精力专注在核心业务上

==学习框架, 关注点: 怎么去用这个框架==

Mybatis

MyBatis是一款优秀的持久层框架，使用Mybatis可以轻松的实现Java程序向数据库发送SQL语句

而且对于SQL查询回来的结果进行方便的封装

入门案例

使用mybatis技术将一个user对象保存到数据库的user表中

准备数据环境

create database mybatis;
use mybatis;

create table user(
    id int unsigned primary key auto_increment comment 'ID',
    name varchar(100) comment '姓名',
    age tinyint unsigned comment '年龄',
    gender tinyint unsigned comment '性别, 1:男, 2:女',
    phone varchar(11) comment '手机号'
) comment '用户表';

insert into user(id, name, age, gender, phone) VALUES (null,'白眉鹰王',55,'1','18800000000');
insert into user(id, name, age, gender, phone) VALUES (null,'金毛狮王',45,'1','18800000001');
insert into user(id, name, age, gender, phone) VALUES (null,'青翼蝠王',38,'1','18800000002');
insert into user(id, name, age, gender, phone) VALUES (null,'紫衫龙王',42,'2','18800000003');
insert into user(id, name, age, gender, phone) VALUES (null,'光明左使',37,'1','18800000004');
insert into user(id, name, age, gender, phone) VALUES (null,'光明右使',48,'1','18800000005');

创建父工程(略)

创建一个父工程，方便后面子模块的管理

创建模块,添加依赖

在父工程下，创建一个子模块用于入门案例代码的编写

<dependencies>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.26</version>
        </dependency>
    </dependencies>

创建User类

创建实体类，注意类的位置和类中的各种要求

创建Mapper接口

我们要把sql写在接口中的方法上

创建配置文件

配置文件中的主要用于声明数据库信息和接口位置

测试(了解)

创建一个测试类，在测试类中使用mybatis提供的方法获取UserMapper对象，然后调用save方法进行测试

package com.itheima.test;

import com.itheima.domain.User;
import com.itheima.mapper.UserMapper;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;

public class UserMapperTest {
    @Test
    public void testSave() throws IOException {
        //0. 准备一个User对象
        User user = new User();
        user.setName("黑马");
        user.setAge(18);
        user.setGender(1);
        user.setPhone("13800138000");

        //1. 使用mybatis将user对象保存到数据库(步骤不重要, 不用记)
        //1-1 读取配置文件,读成一个输入流
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");

        //1-2 创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //1-3 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //1-4 获取UserMapper对象,调用方法
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.save(user);

        //1-5 提交事务
        sqlSession.commit();

        //1-6 释放资源
        sqlSession.close();
    }
}

api介绍(了解)

下面四个api了解一下即可

* Resources:将配置文件读取成一个输入流
    InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");   
    
* SqlSessionFactoryBuilder:用于创建SqlSessionFactory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            
* SqlSessionFactory:用于获取SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();     

* SqlSession:用于获取发送sql的代理对象,注意sqlSession要求用完立即销毁
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

mybatis增删改（重点）

Mybatis使用两步骤:

在接口中添加方法和sql语句

在测试类中添加测试方法

增加

新增一个user对象，并在控制台输出对象保存到数据之后的主键值

接口

修改UserMapper在保存方法上添加添加返回主键的注解@Options

//操作那个表就对应的起名 xxxMapper, 注意这是个接口
public interface UserMapper {

    //声明一个保存用户的方法, 然后在方法上使用@Insert声明方法对应的sql语句
    //后面只要一执行方法,mybatis就会帮我们把sql语句发送到数据库中去

    //#{}中的内容
    //1. 当方法参数是一个对象时, #{}里面写的是对象中的属性名

    //主键返回
    //useGeneratedKeys=true  告诉mybatis,当执行完保存操作之后,需要将数据库中新增记录的主键查询回来
    //keyProperty = "id"      查询回来的主键值需要封装到方法参数对象的哪个属性上
    @Options(useGeneratedKeys = true, keyProperty = "id")
    @Insert("insert into user values (null,#{name},#{age},#{gender},#{phone})")
    void save(User user);
}

测试

public class UserMapperTest {
    @Test
    public void testSave() throws IOException {
        //0. 准备一个User对象
        User user = new User();
        user.setName("黑马");
        user.setAge(18);
        user.setGender(1);
        user.setPhone("13800138000");

        //1. 使用mybatis将user对象保存到数据库(步骤不重要, 不用记)
        //1-1 读取配置文件,读成一个输入流
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");

        //1-2 创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //1-3 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //1-4 获取UserMapper对象,调用方法
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.save(user);

        //保存之后,打印出user中得id
        System.out.println(user);

        //1-5 提交事务
        sqlSession.commit();

        //1-6 释放资源
        sqlSession.close();
    }
}

修改

根据id修改其它列

接口

public interface UserMapper {
    //根据id更新
    @Update("update user set name = #{name},age = #{age}, gender = #{gender},phone=#{phone} where id = #{id} ")
    void update(User user);
}

测试

@Test
public void testUpdate() throws IOException {
    //1. 使用mybatis将user对象保存到数据库(步骤不重要, 不用记)
    //1-1 读取配置文件,读成一个输入流
    InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");

    //1-2 创建SqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    //1-3 获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();

    //1-4 获取UserMapper对象,调用方法
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    //准备一个User对象,必须包含id
    User user = new User();
    user.setName("李四");
    user.setAge(20);
    user.setGender(1);
    user.setPhone("13700137000");
    user.setId(1);
    userMapper.update(user);

    //1-5 提交事务
    sqlSession.commit();

    //1-6 释放资源
    sqlSession.close();
}

删除

根据id删除

接口

//#{}中的内容
//1. 当方法参数是一个对象时, #{}里面写的是对象中的属性名
//2. 当方法参数是一个简单类型参数(8种基本 + 8种包装 + Stringg)时, #{}里面可以随便写,但是推荐写方法形参
//删除
@Delete("delete from user where id = #{id}")
void delete(Integer id);

测试

@Test
public void testDelete() throws IOException {
    //1. 使用mybatis将user对象保存到数据库(步骤不重要, 不用记)
    //1-1 读取配置文件,读成一个输入流
    InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");

    //1-2 创建SqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    //1-3 获取SqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();

    //1-4 获取UserMapper对象,调用方法
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    userMapper.delete(1);

    //1-5 提交事务
    sqlSession.commit();

    //1-6 释放资源
    sqlSession.close();
}

#和$

面试题：请描述下在MyBatis中#和$的区别

* #表示占位符，使用它可以防止SQL注入问题，同类型的SQL只编译一次

* $表示字符串拼接，使用它存在SQL注入问题，每次SQL都会重新编译

SQL注入案例

@Delete("delete from user where name = ${name}")
void delete(String name);
 
delete("'紫衫龙王' or id>1")

抽取工具类

目前的测试代码中，大量的代码都是重复的，下面我们把重复代码抽取到工具类中

编写工具类

package com.itheima.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.InputStream;

//mybatis工具类
public class MyBatisUtil {

    private static SqlSessionFactory sqlSessionFactory;

    //保证SqlSessionFactory是单例的
    static {
        try {
            //1. 读取主配置文件,读成数据流
            InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");

            //2. 创建SqlSessionFactory
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    //获取SqlSession
    public static SqlSession getSqlSession() {
        //3. 获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }

    //提交事务和关闭Session
    public static void close(SqlSession sqlSession) {
        if (sqlSession != null) {
            //5. 提交事务
            sqlSession.commit();

            //6. 释放资源
            sqlSession.close();
        }
    }
}

修改测试类

package com.itheima.test;

import com.itheima.domain.User;
import com.itheima.mapper.UserMapper;
import com.itheima.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class UserMapperTest {
    @Test
    public void testSave() {
        //获取sqlSession
        SqlSession sqlSession = MyBatisUtil.getSqlSession();

        //获取UserMapper对象,调用方法
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //准备一个User对象,保存
        User user = new User();
        user.setName("黑马");
        user.setAge(18);
        user.setGender(1);
        user.setPhone("13800138000");
        userMapper.save(user);

        //保存之后,打印出user中得id
        System.out.println(user);

        //提交事务,释放资源
        MyBatisUtil.close(sqlSession);
    }

    @Test
    public void testUpdate() {
        //获取sqlSession
        SqlSession sqlSession = MyBatisUtil.getSqlSession();

        //获取UserMapper对象,调用方法
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //准备一个User对象,必须包含id
        User user = new User();
        user.setName("李四");
        user.setAge(20);
        user.setGender(1);
        user.setPhone("13700137000");
        user.setId(1);
        userMapper.update(user);

        //提交事务,释放资源
        MyBatisUtil.close(sqlSession);
    }


    @Test
    public void testDelete() {
        //获取sqlSession
        SqlSession sqlSession = MyBatisUtil.getSqlSession();

        //获取UserMapper对象,调用方法
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        userMapper.delete(1);

        //提交事务,释放资源
        MyBatisUtil.close(sqlSession);
    }
}

mybatis查询

环境准备

创建新表

-- 员工管理
create table emp (
  id int unsigned primary key auto_increment comment 'ID',
  username varchar(20) not null unique comment '用户名',
  password varchar(32) default '123456' comment '密码',
  name varchar(10) not null comment '姓名',
  gender tinyint unsigned not null comment '性别, 说明: 1 男, 2 女',
  image varchar(300) comment '图像',
  job tinyint unsigned comment '职位, 说明: 1 班主任,2 讲师, 3 学工主管, 4 教研主管, 5 咨询师',
  entrydate date comment '入职时间',
  dept_id int unsigned comment '部门ID',
  create_time datetime not null comment '创建时间',
  update_time datetime not null comment '修改时间'
) comment '员工表';

INSERT INTO emp
    (id, username, password, name, gender, image, job, entrydate,dept_id, create_time, update_time) VALUES
    (1,'jinyong','123456','金庸',1,'1.jpg',4,'2000-01-01',2,now(),now()),
    (2,'zhangwuji','123456','张无忌',1,'2.jpg',2,'2015-01-01',2,now(),now()),
    (3,'yangxiao','123456','杨逍',1,'3.jpg',2,'2008-05-01',2,now(),now()),
    (4,'weiyixiao','123456','韦一笑',1,'4.jpg',2,'2007-01-01',2,now(),now()),
    (5,'changyuchun','123456','常遇春',1,'5.jpg',2,'2012-12-05',2,now(),now()),
    (6,'xiaozhao','123456','小昭',2,'6.jpg',3,'2013-09-05',1,now(),now()),
    (7,'jixiaofu','123456','纪晓芙',2,'7.jpg',1,'2005-08-01',1,now(),now()),
    (8,'zhouzhiruo','123456','周芷若',2,'8.jpg',1,'2014-11-09',1,now(),now()),
    (9,'dingminjun','123456','丁敏君',2,'9.jpg',1,'2011-03-11',1,now(),now()),
    (10,'zhaomin','123456','赵敏',2,'10.jpg',1,'2013-09-05',1,now(),now()),
    (11,'luzhangke','123456','鹿杖客',1,'11.jpg',5,'2007-02-01',3,now(),now()),
    (12,'hebiweng','123456','鹤笔翁',1,'12.jpg',5,'2008-08-18',3,now(),now()),
    (13,'fangdongbai','123456','方东白',1,'13.jpg',5,'2012-11-01',3,now(),now()),
    (14,'zhangsanfeng','123456','张三丰',1,'14.jpg',2,'2002-08-01',2,now(),now()),
    (15,'yulianzhou','123456','俞莲舟',1,'15.jpg',2,'2011-05-01',2,now(),now()),
    (16,'songyuanqiao','123456','宋远桥',1,'16.jpg',2,'2010-01-01',2,now(),now()),
    (17,'chenyouliang','123456','陈友谅',1,'17.jpg',NULL,'2015-03-21',NULL,now(),now());

导入工程

结果封装

执行查询SQL是会有结果集返回来的，mybatis会将结果封装到我们指定的实体中

实体类属性名和数据库查询结果集中名称一致的字段，mybatis会自动封装

实体类属性名和数据库查询结果集中名称不一致的字段，不能自动封装，需要我们手动处理

① 添加查询所有的方法

//查询
    @Select("select * from emp")
    List<Emp> findAll();

② 测试

    //查询所有
    @Test
    public void testFindAll() {
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

        List<Emp> empList = empMapper.findAll();
        empList.forEach(e -> System.out.println(e));//lambda方式打印

        MybatisUtil.close(sqlSession);
    }

驼峰映射

当表中字段和类中属性的关系是_和驼峰写法时，可以开启mybatis的自动驼峰映射
<setting name="mapUnderscoreToCamelCase" value="true"/>

① 在SqlMapConfig.xml开启驼峰映射支持

② 再次执行查询方法测试

起别名

当表中字段和类中属性完全没有关系时，可以使用别名来修改sql返回集中字段的名称

① 给不对应的字段起别名

    //查询
    @Select("select id, username, password, name, gender, image, job, entrydate as ed, dept_id, create_time, update_time from emp")
    List<Emp> findAll2();

② 测试

    //查询所有
    @Test
    public void testFindAll2() {
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

        List<Emp> empList = empMapper.findAll2();
        empList.forEach(e -> System.out.println(e));//lambda方式打印

        MybatisUtil.close(sqlSession);
    }

自定义映射

当表中字段和类中属性完全没有关系时，可以通过@Results进行手动结果映射

① 自定义结果映射

    //查询
    @Results({//@Results: 自定义结果映射
            @Result(column = "entrydate", property = "ed"),//@Result一条映射规则 (column = "数据表中字段名", property = "实体类属性名")
            @Result(column = "dept_id", property = "deptId")
    })
    @Select("select * from emp")
    List<Emp> findAll3();

② 测试

    //查询所有
    @Test
    public void testFindAll3() {
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

        List<Emp> empList = empMapper.findAll3();
        empList.forEach(e -> System.out.println(e));//lambda方式打印

        MybatisUtil.close(sqlSession);
    }

条件查询

当查询方法出现多个查询条件时，需要使用@Param注解设置对应关系

① 添加条件查询的方法

    //#{} 里面的内容
    //1. 如果参数是一个对象类型, #{}写的是对象中的属性名
    //2. 如果参数是一个简单类型(8基本 + 8包装 +String) ,#{}可以随便写, 但是推荐写方法形参名
    //3. 如果参数是多个简单类型的参数, #{}中写的是@Param注解中的值
    //条件查询
    @Select("select * from emp where name = #{name} and gender = #{gender} and entrydate between #{begin} and #{end}")
    List<Emp> findList(@Param("name") String name, @Param("gender") Short gender, @Param("begin") LocalDate begin, @Param("end") LocalDate end);

② 测试

    //条件查询
    @Test
    public void testFindList() {
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

        List<Emp> empList = empMapper.findList("张三丰", (short) 1, LocalDate.of(2002, 01, 01), LocalDate.of(2023, 12, 31));
        empList.forEach(e -> System.out.println(e));//lambda方式打印

        MybatisUtil.close(sqlSession);
    }

模糊查询

当查询sql中出现模糊查询语法时，需要使用concat函数连接条件，比如根据用户名进行模糊查询

`where name like '%张%'----------------->where name like concat('%',#{username},'%')

① 添加条件查询的方法

    //模糊查询
    @Select("select * from emp where name like concat('%',#{name},'%') and gender = #{gender} and entrydate between #{begin} and #{end}")
    List<Emp> findListLike(@Param("name") String name, @Param("gender") Short gender, @Param("begin") LocalDate begin, @Param("end") LocalDate end);

② 测试

    @Select("select * from emp where name like concat('%',#{name},'%') and gender = #{gender} and entrydate between #{begin} and #{end}")
    

//模糊查询
    @Test
    public void testFindListLike() {
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

        List<Emp> empList = empMapper.findListLike("张", (short) 1, LocalDate.of(2002, 01, 01), LocalDate.of(2023, 12, 31));
        empList.forEach(e -> System.out.println(e));//lambda方式打印

        MybatisUtil.close(sqlSession);
    }

XML写SQL

目前我们的SQL都是写在了注解中，对于一些简单的SQL这么做，确实很简答，但是对于比较复杂的SQL，写在注解中就比较麻烦了

所以mybatis还提供了一种使用xml文件编写sql的做法，至于到底是用注解还是用xml，其实只要根据自己的方便程度选择就可以了

下面我们使用xml的方式完成上面的模糊查询功能

创建XML

使用xml编写sql是需要遵循一些规范的

1. XML映射文件的名称与Mapper接口名称一致，并且将XML映射文件和Mapper接口放置在相同包下（同包同名）。
2. XML映射文件的namespace属性为Mapper接口全限定名一致。
3. XML映射文件中sql语句的id与Mapper接口中的方法名一致，并保持返回类型一致。

接口

在接口中添加一个根据id查询的方法

//注意: 对于同一个方法,使用xml写sql的话,就不能在使用注解写sql了
//@Select("select * from emp where id = #{id}")
Emp findById(Integer id);

xml

在xml中添加一个查询sql

<?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.itheima.mapper.EmpMapper">
    
    <select id="findById" resultType="com.itheima.domain.Emp">
        select * from emp where id = #{id}
    </select>

</mapper>

测试

测试文件中添加测试方法

//根据id查询
@Test
public void testFindById() {
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

    Emp emp = empMapper.findById(1);
    System.out.println(emp);

    MybatisUtil.close(sqlSession);
}

常见错误

错误1

对于同一个方法来讲，注解和XML只能选择一种来用，否则会出现下面的错误

错误2

检查下约定好的对应关系，一定有一个关系写错了

插件安装

MybatisX 是一款基于 IDEA 的快速开发Mybatis的插件，为效率而生。

动态SQL

先来看一个需求：根据用户输入的内容查询员工列表（注意：每个条件都不是必填的），页面如下图

那么此时再用原来学习的知识，编写出如下的sql，还行不行呢？

select * from user where name= #{name} and gender = #{gender} and entrydate between #{begin} and #{end}

显然是有问题的，因为按照上面的sql来执行，如果用户只输入了姓名张三，得到的sql就变成了

select * from user where name= '张三' and gender = null and entrydate between null and null

很显然不符合我们的预期，我们预期是仅仅用户输入的查询条件出现在sql中，没输入的就不出现，即下面这样

select * from user where name= '张三'

像上面这样，==需要根据不同的条件来执行不同的sql语句的情况，就需要用到动态sql==。

在mybatis中，动态SQL是通过下面几个标签来实现的：

if 用于条件判断

where，set 用于格式控制

foreach 用于循环遍历

if和where

==任务：根据用户输入的内容查询员工列表（名字要采用模糊查询）==

接口

//条件查询
List<Emp> findByCondition(@Param("name") String name, @Param("gender") Short gender,
                          @Param("begin") LocalDate begin, @Param("end") LocalDate end);

映射

if：使用test进行条件判断，只有条件成立，条件中的sql才会生效
select * from emp where

<if test="name != null">
    name = #{name}
</if>
where：只会在<where>标签内部有内容的情况下才插入where子句，而且会自动去除子句的开头的AND或OR。

<!--
    字符串需要跟null和空串比较
    其他类型只要跟null比较

    if：使用test进行条件判断，只有条件成立，条件中的sql才会生效
    where：只会在<where>标签内部有内容的情况下才插入where子句，而且会自动去除子句的开头的AND或OR。
-->
<select id="findByCondition" resultType="com.itheima.domain.Emp">
    select * from emp
    <where>
        <if test="name != null and name != ''">
            name like concat('%',#{name},'%')
        </if>
        <if test="gender != null">
            and gender = #{gender}
        </if>
        <if test="begin != null and end != null">
            and entrydate between #{begin} and #{end}
        </if>
    </where>
</select>

测试

    //条件查询
    @Test
    public void testFindByCondition() {
        SqlSession sqlSession = MybatisUtil.getSqlSession();
        EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

        //List<Emp> empList = empMapper.findByCondition("张", (short) 1, LocalDate.of(2002, 01, 01), LocalDate.of(2023, 12, 31));
        //List<Emp> empList = empMapper.findByCondition("张", (short) 1, null, null);
        List<Emp> empList = empMapper.findByCondition("", (short) 1, null, null);
        empList.forEach(e -> System.out.println(e));//lambda方式打印

        MybatisUtil.close(sqlSession);
    }

if和set

==任务：根据主键修改1号员工的信息（注意只修改用户提交的字段）==

接口

//根据id更新不为空的字段
void update(Emp emp);

映射

set：动态地在set代码块之前加入SET关键字，并删掉set代码块中最后一个多余的逗号（用在update语句中）

<update id="update">
    update emp
    <set>
        <if test="username != null and username != ''">
            username = #{username},
        </if>
        <if test="password != null and password != ''">
            password = #{password},
        </if>
        <if test="name != null and name != ''">
            name = #{name},
        </if>
        <if test="gender != null">
            gender = #{gender},
        </if>
        <if test="image != null and image != ''">
            image = #{image},
        </if>
        <if test="job != null">
            job = #{job},
        </if>
        <if test="ed != null">
            entrydate = #{ed},
        </if>
        <if test="deptId != null">
            dept_id = #{deptId},
        </if>
        <if test="createTime != null">
            create_time = #{createTime},
        </if>
        <if test="updateTime != null">
            update_time = #{updateTime},
        </if>
    </set>
    where id = #{id}
</update>

测试

//更新
@Test
public void testUpdate() {
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

    Emp emp = new Emp();
    emp.setId(1);
    emp.setUsername("haha");

    empMapper.update(emp);

    MybatisUtil.close(sqlSession);
}

foreach

==任务：根据id的集合批量删除员工==

接口

//删除
void deleteByIds(@Param("ids") List<Integer> ids);

映射

foreach 用于循环遍历

* collection：集合名称
* item：集合遍历出来的元素
* separator：每一次遍历使用的分隔符
* open： 遍历开始前拼接的片段
* close：遍历结束后拼接的片段

<delete id="deleteByIds">
    delete from emp where id in
    <foreach collection="ids" item="id" separator="," open="(" close=")">
        #{id}
    </foreach>
</delete>

测试

//批量删除
@Test
public void deleteByIds() {
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);

    empMapper.deleteByIds(Arrays.asList(13, 14, 15));

    MybatisUtil.close(sqlSession);
}

sql片段

sql片段的作用是将代码中重复的部分，提取出来达到复用的目的
* 定义SQL片段:  <sql id="selectUser"></sql> 
* 引用SQL片段:  <include refid="selectUser"></include> 

总结

标签	作用
if	用于条件判断，只有条件成立，条件中的sql才会生效
where	用在where代码部分，主要作用是去除子句的开头的and或or
set	用于update语句的set部分，主要作用是删掉set代码块中最后一个多余的逗号
foreach	用于对输入的集合参数进行遍历取值，一般用于批量操作中
sql	用于抽取sql片段

配置文件

sqlMapConfig.xml 这是mybatis的主配置文件，文件中的标签有严格的顺序要求, 可以省略一部分，但是不能乱序
* settings：控制一些全局配置项的开闭
* mappers：用于指定Mapper接口的位置
* environments: 配置数据库连接信息和事务管理器

<?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>
        <!--在控制台输出发送的sql日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启驼峰映射-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <!--环境-->
    <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/mybatis"/>
                <!--用户名-->
                <property name="username" value="root"/>
                <!--密码-->
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--接口所在包-->
    <mappers>
        <package name="com.itheima.mapper"/>
    </mappers>
</configuration>

数据库连接池

* Java程序跟数据库进行数据交互是需要建立连接的，而连接的创建和销毁比较耗时，为了防止频繁的创建和销毁连接，就出现了连接池技术
* 连接池类似于前面学过的线程池，就是在项目启动的时候，就会初始化一批连接，放到池中，用的时候直接取，用完了再归还到池中
* 业界目前比较出名的有下面两款：
    Druid(德鲁伊):  阿里巴巴提供的数据库连接池技术，国内使用率很高，提供了完善的监控机制
    HikariCP:  日本人开发的连接池技术，号称性能之王，速度最快，SpringBoot2.0默认使用此连接池