前言

基于maven的mybatis，相关配置和maven的下载配置之前写过，都在一个专栏里，这篇主要写学习操作代码等

入门

ps：mybatis的导入，mybatis-config核心配置文件初步书写等见之前的idea创建基于maven的MyBatis项目

构建 SqlSessionFactory

每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
创建MybatisUtils工具类构建出 SqlSessionFactory 实例：
在这里插入图片描述

//sqlSessionFactory --> sqlSession
public class MybatisUtils {
    
    
    private static SqlSessionFactory sqlSessionFactory;
    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，顾名思义，我们可以从中获得 SqlSession 的实例
    // SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句
    public static SqlSession getSqlSession(){
    
    
        return sqlSessionFactory.openSession();//****这里openSession()可以传参，若是sqlSessionFactory.openSession(true)，意为开启事务自动提交，无参，后面sql增删改需要手动提交
    }
}

探究已映射的 SQL 语句

以此表为例：
在这里插入图片描述
再pojo包下创建User类

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

再Dao包下创建UserMapper 接口(原来的UserDao)

public interface UserMapper {
    
    
    //获取全部用户
    List<User> getUserList();

    //根据id查询用户
    User getUserById(int id);

    //insert一个用户
    int addUser(User user);

    //用map插入用户
    int addUser2(Map<String,Object> map);

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

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

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

SQL 语句映射(*)

再Dao下再建立新的文件UserMapper.xml，对应UserMapper

<?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接口-->
<mapper namespace="com.person.dao.UserMapper">
    <!--
    	select 查询语句
    	id对应UserMapper中的方法
    	resultType，返回类型为User(完整类名)
    -->
    <select id="getUserList" resultType="com.person.pojo.User">
        select * from user
    </select>

    <!--
    	根据ID查询用户
    	parameterType：参数类型
    -->
    <select id="getUserById" resultType="com.person.pojo.User" parameterType="int">
        select * from user where id=#{id}
    </select>

    <!--insert一个用户-->
    <insert id="addUser" parameterType="com.person.pojo.User">
        insert into user(name,pwd) values (#{name},#{pwd})
    </insert>

    <!--
        map可以灵活的运用
        用map插入用户：
    -->
    <insert id="addUser2" parameterType="map">
        insert into user(name,pwd) values (#{username},#{password})
    </insert>

    <!--修改一个用户-->
    <update id="updateUser" parameterType="com.person.pojo.User">
        update user set `name`=#{name},`pwd`=#{pwd} where `id`=#{id} ;
    </update>

    <!--删除一个用户-->
    <delete id="deleteUser" parameterType="int">
        delete from user where id=#{id};
    </delete>

    <!--模糊查询--><!--select * from user where name like #{value}-->
    <select id="getUserLike" resultType="com.person.pojo.User">
        select * from user where name like "%"#{value}"%"
    </select>

</mapper>

映射器（mapper）

在mybatis核心配置文件mybatis-config.xml中配置映射器：

<mappers>
    <mapper resource="com/person/dao/UserMapper.xml" />
</mappers>

resource中写UserMapper.xml的地址,注意：com/person，包间用/不是.点号
附带一些完整UserMapper.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核心配置文件-->
<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/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="xxxx"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/person/dao/UserMapper.xml" />
    </mappers>
</configuration>

到此，第一个mybatis程序就完成了，接下来是测试

测试

测试采用junit4，之前没有的导下包，导包后在UserMapper接口中按快捷键CTRL+SHIFT+T,生成测试
在这里插入图片描述

测试代码都放一起了：

public class UserMapperTest {
    
    
    @Test
    public void getUserList() {
    
    
        //1.获取SqlSession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        //执行sql,方式一：getMapper
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
        List<User> userList= userMapper.getUserList();
        //方式二：
//        List<User> userList=sqlSession.selectList("com.person.dao.UserMapper.getUserList");
        for (User user:userList){
    
    
            System.out.println(user);
        }
        //关闭sqlSession，必须要关
        sqlSession.close();
    }
    @Test
    public void getUserById() {
    
    
        //1.获取SqlSession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        //执行sql,方式一：getMapper
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
        User user= userMapper.getUserById(1);
        System.out.println(user);
        //关闭sqlSession
        sqlSession.close();
    }
    @Test
    public void addUser() {
    
    
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
        //执行添加语句
        int count=userMapper.addUser(new User(4,"Lili","123456"));
        System.out.println(count);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void updateUser() {
    
    
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
        int i=userMapper.updateUser(new User(5,"黄土","123456"));
        System.out.println(i);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void deleteUser() {
    
    
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
        int i=userMapper.deleteUser(5);
        System.out.println(i);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void addUser2() {
    
    
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<String,Object>();
        map.put("username","王二");
        map.put("password","123456");
        int i=userMapper.addUser2(map);
        System.out.println(i);
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void getUserLike() {
    
    
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);

        /*List<User> userList=userMapper.getUserLike("%王%");*/
        List<User> userList=userMapper.getUserLike("王");
        for (User user:userList){
    
    
            System.out.println(user);
        }
        sqlSession.close();
    }
}

别名

MyBatis可以配置成适应多种环境
学会使用配置多套运行环境
Mybatis默认的事务管理器就是JDBC，连接池：POOLED

类型别名：(typeAliases)
    1.类型别名是为Java类型设置一个短的名字
    2.存在的意义仅在用于减少类完全限定名的冗余

<select id="getUserList" resultType="com.person.pojo.User">
    select * from user
</select>
resultType等若是太长可以优化:

    1.在mybatis-config中设置别名
        <typeAliases>
            <typeAlias type="com.person.pojo.User" alias="User12" />
        </typeAliases>

         <select id="getUserList" resultType="User12">
            select * from user
         </select>

    2. 在mybatis-config中设置别名类名
        <typeAliases>
            <package name="com.person.pojo"/>
        </typeAliases>

         <select id="getUserList" resultType="user">
            select * from user
         </select>

别名补充

补充----若想改名字类似别名，加注解即可
   给User类加注解()
         @Alias("userAlias")
         public class User {}

         <select id="getUserList" resultType="userAlias">
             select * from user
         </select>

映射器(扩展)

MapperRegistry:注册绑定我们的Mapper文件
   方式一：【推荐】
       <mappers>
           <mapper resource="com/person/dao/UserMapper.xml" />
       </mappers>

   方式二：用class文件绑定注册
       <mappers>
           <mapper class="com.person.dao.UserMapper" />
       </mappers>

       注意：
           1.此方法UserMapper和xml文件必须在一个包下
           2.接口和他的配置文件必须同名

   方式三:使用扫描包进行注入绑定
       <mappers>
           <package name="com.person.dao"/>
       </mappers>

           注意：
                1.此方法UserMapper和xml文件必须在一个包下
                2.接口和他的配置文件必须同名

生命周期和作用域

- 错误的使用生命周期和作用域会导致严重的并发问题

SqlSessionFactoryBuilder:
    - 一旦创建了SqlSessionFactoryBuilder，就不再需要它了
    - 局部变量

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

SqlSession：
    - 连接到连接池的一个请求！
    - SqlSession的实例不是线程安全的，因此不能被共享，所以它的最佳作用域是请求或方法作用域
    - 用完就要关闭，否则资源被占用！

XML配置和映射器

先看一下官方文档：
在这里插入图片描述

这里只说部分

属性

先在 mybatis-config.xml同级目录下创建properties文件
在这里插入图片描述
mybatis-config.xml中引入properties文件

db.properties文件：
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8
password=xxxx

完整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核心配置文件-->
<configuration>

    <!--引入外部配置文件-->
    <!--
    	***注意内外配置优先级
    	内外配置重名时。优先外部配置
    	所以最终：
    	driver=com.mysql.jdbc.Driver
		url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8
		password=xxxx
		username=root
    -->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="12xx34"/>
    </properties>

    <!--别名-->
    <typeAliases>
        <!--<typeAlias type="com.person.pojo.User" alias="User" />-->
        <package name="com.person.pojo"/>
    </typeAliases>
	
	<!--
		 <environments default="development">
		 默认环境，可以改<environments default="test">

		<property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
        取上面的赋值
	-->
    <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="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="xxxx"/>
            </dataSource>
        </environment>

    </environments>

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

</configuration>

结果映射

resultMap 元素是 MyBatis 中最重要最强大的元素。
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
resultMap最优秀的地方在于，如果你已经对它相当了解了，你就根本就不需要显式地用到他们。
看一下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接口-->
<mapper namespace="com.person.dao.UserMapper">

	<!--
		<result column="pwd" property="password" />
		column：数据库中列的名称，property：类中的属性
		一致可省
	-->
    <resultMap id="UserMap" type="User">
        <!--column数据库中的字段，property实体类中的属性-->
        <!--<result column="id" property="id" />
        <result column="name" property="name" />-->
        <result column="pwd" property="password" />
    </resultMap>

    <!--根据ID查询用户-->
    <select id="getUserById" resultType="User" resultMap="UserMap">
        select * from user where id=#{id}
    </select>

</mapper>

日志

还是先看看官方文档：
在这里插入图片描述

日志：
    日志工厂：
        如果一个数据库操作出现了异常，我们需要排错，日志就是最好的助手！
            以前：sout，debug
            现在：日志工厂！

        - SLF4J
        - LOG4J【掌握】
        - LOG4J2【这个以后会用】
        - JDK_LOGGING
        - COMMONS_LOGGING
        - STDOUT_LOGGING【掌握】
        - NO_LOGGING

    在Mybatis中具体使用哪一个日志实现，在设置中设定
    STDOUT_LOGGING 标准日志输出

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

日志级别：
    logger.info("info:进入了testLog4j方法");
    logger.debug("debug:进入了testLog4j方法");
    logger.error("error:进入了testLog4j方法");

直接去maven库搜索log4j
在这里插入图片描述
在pom.xml中导入库
在mybatis-config中导入配置,注意顺序，配置顺序错误会报错

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

这之后就是配置log4j，这个很复杂，可以直接拿别人的用，这里给个事例
在mybatis-config.xml同级目录下创建db.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/person.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

在这里插入图片描述
随便运行之前的某个程序

自定义标签:

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

运行结果：

[com.person.dao.UserMapperTest]-info:进入了testLog4j方法
[com.person.dao.UserMapperTest]-debug:进入了testLog4j方法
[com.person.dao.UserMapperTest]-error:进入了testLog4j方法

简单提一下分页

<!--分页查询-->
<select id="getUserByLimit" parameterType="map" resultType="user" resultMap="UserMap">
    select * from user limit #{startIndex},#{pageSize}
</select>

        @Test
        public void getUserByLimit() {
            SqlSession sqlSession= MybatisUtils.getSqlSession();
            UserMapper userMapper =sqlSession.getMapper(UserMapper.class);

            Map<String,Integer> map=new HashMap<String, Integer>();
            map.put("startIndex",2);
            map.put("pageSize",2);
            List<User> userList= userMapper.getUserByLimit(map);
            for (User user:userList){
                System.out.println(user);
            }

            sqlSession.close();
        }

<!--RowBounds分页(了解)-->
<select id="getUserByRowBounds"  resultType="user" resultMap="UserMap">
    select * from user
</select>

        //RowBounds分页(了解)
        @Test
        public void getUserByRowBounds() {
            SqlSession sqlSession= MybatisUtils.getSqlSession();

            //RowBounds实现
            RowBounds rowBounds = new RowBounds(2, 2);

            //通过Java代码层面实现分页
            List<User> userList= sqlSession.selectList(
                    "com.person.dao.UserMapper.getUserByRowBounds",null,rowBounds);
            for (User user:userList){
                System.out.println(user);
            }

            sqlSession.close();
        }

注解开发

sql注解

步骤：
    1.使用注解：		
        @Select("select * from user")
        List<User> getUsers();
        ps:使用注解后，就可以删除UserMapper.xml文件了，简单来说，注解代替了sql映射语句，
    2.绑定：
            <!--绑定接口-->
            <mappers>
                <mapper class="com.person.dao.UserMapper" />
            </mappers>
	除了这两个地方外，再删除UserMapper.xml文件，
	   @Test
	   public void getUsers(){
	        SqlSession sqlSession = MybatisUtils.getSqlSession();
	        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
	        List<User> userList=mapper.getUsers();
	        for (User user:userList){
	            System.out.println(user);
	        }
	        sqlSession.close();
	    }
	可以正常运行

UserMapper接口

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

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

    @Insert("insert into user(id,name,pwd) values(#{id},#{name},#{password})")
    int addUser(User user);

@Param() 注解

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

    - 基本类型的参数或者String类型，需要加上
    - 引用类型不需要加
    - 如果只有一个基本类型的话，可以忽略，但是建议都加上
    - 我们在SQL中引用的就是我们这里的@Param()中设定的属性名

    #{} ${} 区别：
        #{}可以很大程度上防止sql注入

注解开发–lombok(偷懒神器–工作好像不给用)

一样去maven库搜索lombok：

 <!--https://mvnrepository.com/artifact/org.projectlombok/lombok -->
 <dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <version>1.18.12</version>
 </dependency>

导入库后，idea还要安装插件：
再setting里安装Lombok，目前是个小辣椒图标，安装完会提醒重启idea
修改User类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    private int id;
    private String name;
    private String password;
}

简单介绍一下这三个注解，其它的就不说了，都差不多
@Data注解 --生成所有基本方法，setter，getter，toString，equals…
@AllArgsConstructor–生成有参构造
@NoArgsConstructor–生成无参构造，因为生成有参构造，无参也需要手动创建了
在这里插入图片描述

复杂查询环境搭建

先拿老师和学生给个例子：
框架，资源文件不变
在这里插入图片描述

pojo下创建Student和Teacher类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    
    
    private int id;
    private String name;

    //学生需要关联一个老师！
    private Teacher teacher;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Teacher {
    
    
    private int id;
    private String name;
}

dao下创建对应的Mapper

public interface StudentMapper {
    
    
    //  查询所有的学生信息，以及对应的老师的信息！
    List<Student> getStudent();
    List<Student> getStudent2();
}

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

创建对应的xml文件
*注意：此时dao下不止一个文件，为防止各种问题，我们再resource文件下创建Mapper.xml，注意包要对应
在这里插入图片描述

多对一

按照查询嵌套处理：

<select id="getStudent" resultMap="StudentTeacher">
 		select * from student;
</select>

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

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

按照结果嵌套处理：

   <!--按照结果嵌套处理-->
 <select id="getStudent2" resultMap="StudentTeacher2" >
     select s.id sid,s.name sname,t.name tname,t.id tid
     from student s,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="teacher" javaType="Teacher">
         <result property="id" column="tid" />
         <result property="name" column="tname" />
     </association>
 </resultMap>

一对多

其它不变，Mapper.xml变

1.按照结果嵌套查询

<!--按照结果嵌套查询-->
  <select id="getTeacherById" resultMap="TeacherStudent">
      select s.id sid,s.name sname,t.name tname,t.id tid
      from student s,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" />
      <!--
          集合用collection
          javaType="" 指定属性的类型！
          集合中的泛型信息，我们使用ofType获取
      -->
      <collection property="students" ofType="Student">
          <result property="id" column="sid" />
          <result property="name" column="sname" />
          <result property="tid" column="tid" />
      </collection>
  </resultMap>

2.按照查询嵌套处理

<!--子查询-->
<select id="getTeacherById2" resultMap="TeacherStudent2">
    select * from teacher where id=#{tid};
</select>

<resultMap id="TeacherStudent2" type="Teacher">
    <result property="id" column="id" />
    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudent" column="id" />
</resultMap>

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

需要注意：

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

动态SQL

动态SQL：就是根据不同的条件生成不同的SQL语句
所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码
动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

以下面的数据库表为例：
在这里插入图片描述

if:

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

** choose(when,otherwise)**
choose:类比jstl的choose，可以认为是switch…case

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

trim(where,set)

where:
where中若是没有语句执行，where不显示，且where会自动去除第一个and或者or

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

set:
set会自动去除, 逗号

<update id="updateBlog" parameterType="map">
  update blog
  <set>
      <if test="title !=null">
          title =#{title},
      </if>
      <if test="author !=null">
          author=#{author}
      </if>
  </set>
  where id=#{id}
</update>

trim: 自定义设置WHERE，SET需不需要AND |OR

<trim prefix="" prefixOverrides="" suffix="" suffixOverrides="">

</trim>

<trim prefix="WHERE" prefixOverrides="AND |OR ">
...
</trim>

<trim prefix="SET" suffixOverrides=",">
...
</trim>

SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用
SQL:使用SQL标签抽取公共部分

<sql id="if-title-author" >
    <if test="title !=null">
        and title=#{title}
    </if>
    <if test="author!=null">
        and author=#{author}
    </if>
<sql>

然后在需要使用的地方使用include标签引用即可

<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from blog
    <where>
        <include refid="if-title-author" />
    </where>
</select>

注意：

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

foreach

<select id="queryBlogForeach" parameterType="map" resultType="blog">
    select * from blog
    <where>
        <foreach collection="ids" item="id" open="and (" close=")" separator="or" >
            id=#{id}
        </foreach>
    </where>
</select>

根据传入的集合，or会自动增加，假设传入的集合是1，2，3
select * from blog WHERE ( id=? or id=? )
那么执行语句就为：

[com.person.dao.BlogMapper.queryBlogForeach]-==>  Preparing: select * from blog WHERE ( id=? or id=? or id=? ) 
[com.person.dao.BlogMapper.queryBlogForeach]-==> Parameters: 1(Integer), 2(Integer), 3(Integer)

缓存简介

一级缓存

    SqlSession sqlSession= MybatisUtils.getSqlSession();
    ....
    sqlSession.close();

    在上述范围内sqlSession中select的数据会被缓存
        User user=userMapper.queryUserById(6);
        System.out.println(user);

        User user2=userMapper.queryUserById(6);
        System.out.println(user2);

        System.out.println(user==user2);
        //输出true，可见内存地址也一样，知是从缓存中取的数据

注意以下情况缓存失效：

查询不同的东西
语句中出现insert，update，delete 时，缓存失效
查询不同的Mapper.xml
手动清理缓存（ sqlSession.clearCache(); //手动清理缓存）

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

二级缓存：全局缓存

开启步骤：

1.开启全局缓存

 <!--mybatis-config.xml中-->
 <settings>
     <setting name="cacheEnabled" value="true"/><!--显示的开启全局缓存-->
 </settings>

2.在当前Mapper.xml中使用二级缓存

<!--
    在当前Mapper.xml中使用二级缓存
    属性是自定义参数，没写默认
    eviction="FIFO"         创建一个FIFO缓存
    flushInterval="60000"   每隔60s刷新
    size="512"              最多可以储存结果对象或列表的512个引用
    readOnly="true"         返回的对象被认为是只读的

    因此对它们的进行修改可能会在不同线程中的调用者产生冲突
-->
<cache eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true" />

<select id="queryUserById" resultType="user" useCache="true"><!-- useCache="true" 可以选择字段是否开启缓存-->
    select * from user where id=#{id}
</select>

注意：如果cache 没填参数(eviction)我们需要将实体类序列化，否则就会报错

小结：

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

自定义缓存

<cache type="org.mybatis.caches.ehcache.EhcacheCache" />    //可以导入第三方缓存，但是要导入配置cache.xml

public class MyCache implements Cache {}        //可以自定义缓存类

个人java学习路线-mybatis