多對一處理

多個對象對應一個對象

比如：你們都是我的學生，多個學生對應一個老師

掌握兩個單詞：

association — 聯繫，關聯多個人可以關聯一個人。
collection — 集合一個人有一個集合，包含多個人。
發現是多對一業務情況，我們需要使用association 標籤進行關聯

多對一的處理方式一

使用數據庫的思想處理：聯表查詢

定義dao接口

List<Student> getStudents();

編寫查詢語句
1. 查詢學生信息 id name tid ，由於我們要得到老師的信息，我們需要聯表查詢
2. 查詢老師的信息 id name 。

<!--遇到問題：學生類中關聯老師： 多個學生對應一個老師 -->
<!--<select id="getStudents" resultType="Student">-->
    <!--select s.id,s.name,t.name from mybatis.student as s,mybatis.teacher as t-->
    <!--where s.tid = t.id-->
<!--</select>-->


<!--解決問題方式一:按查詢結果嵌套處理，模擬數據庫思想；
-->
<select id="getStudents" resultMap="StudentTeacher">
    select * from mybatis.student
</select>

<resultMap id="StudentTeacher" type="Student">
    <id column="id" property="id"/>
    <result column="name" property="name"/>
    <!--屬性和字段對應  ， 類和表對應  ， 對象和記錄
    關聯一個字段
    需求：拿到老師這個類的屬性

    association ： 關聯，多對一
        column ： 數據庫對應的列名
        property ： 對應屬性名
        javaType ： 多對一字段對應的Java類型
        select ： 關聯一個語句
    -->
    <association column="tid" property="teacher" javaType="Teacher" select="getTeacher"/>
</resultMap>

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

測試類

@Test
    public void getStudents(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();

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

        List<Student> students = mapper.getStudents();

        for (Student student : students) {
            System.out.println("學生姓名："+student.getName()+"\t老師姓名："+student.getTeacher().getName());
        }

    }

多對一的處理方式二

1.編寫接口

List<Student> getStudentsTwo();

2.編寫處理的mapper

查詢學生id，學生姓名，老師姓名，需要從學生表和老師表中查詢
學生對應的類進行映射，發現老師一個對象，所以關聯一個對象；

<!-- 解決方式二：一個resultMap解決 ， 模擬面向對象的思想-->
<select id="getStudentsTwo" resultMap="StudentTeacher2">
    select s.id,s.name,t.name as tname from mybatis.student as s, mybatis.teacher as t
    where s.tid = t.id
</select>

<!--設置結果集映射ResultMap -->
<resultMap id="StudentTeacher2" type="Student">
    <id property="id" column="id"/>
    <result property="name" column="name"/>

    <!--直接關聯一個老師-->
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

3.測試類

@Test
public void getStudentsTwo(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();

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

    List<Student> students = mapper.getStudentsTwo();

    for (Student student : students) {
        System.out.println("學生姓名："+student.getName()+"\t老師姓名："+student.getTeacher().getName());
    }

}

總結

mybatis中遇到多對一的情況，要使用關聯映射處理：使用association
兩種處理思路：
1. 數據庫思想：聯表查詢
2. OOP思想：關聯對象

項目實現：

項目結構：

數據庫建立：

CREATE DATABASE /*!32312 IF NOT EXISTS*/`mybatis` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `mybatis`;

/*Table structure for table `student` */

DROP TABLE IF EXISTS `student`;

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

/*Data for the table `student` */

INSERT  INTO `student`(`id`,`name`,`tid`) VALUES (1,'武少偉',1),(2,'李鴻彬',1),(3,'武少偉',1),(4,'姚震',1),(5,'夏彬峯',1);

/*Table structure for table `teacher` */

DROP TABLE IF EXISTS `teacher`;

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

/*Data for the table `teacher` */

INSERT  INTO `teacher`(`id`,`name`) VALUES (1,'秦老師');

porm.xml文件配置：

<?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.kuang</groupId>
    <artifactId>ssm-mybatis-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <!--子項目-->
    <modules>
        <module>Mybatis01</module>
        <module>MyBatis02</module>
        <module>MyBatis03</module>
        <module>MyBatis04</module>
        <module>MyBatis05</module>
        <module>Mybatis06</module>
        <module>Mybatis07</module>
        <module>Mybatis08</module>
        <module>MyBatis09</module>
    </modules>

    <dependencies>

        <!--單元測試-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <!--mybatis的包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.1</version>
        </dependency>

        <!--連接數據庫的驅動包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--LOG4J日誌包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

    </dependencies>


    <build>
        <!--希望maven在導出項目的時,能夠將我們的配置及資源導出-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

    </build>



</project>

其中build部分是必須的，否則最後資源導不出來!

pojo類編寫：
student

package com.kuang.pojo;

public class Student  {
    private int id;
    private String name;
    private Teacher teacher;

    public Student() {
    }

    public Student(int id, String name, Teacher teacher) {
        this.id = id;
        this.name = name;
        this.teacher = teacher;
    }


    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 Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", teacher=" + teacher +
                '}';
    }
}

teacher

package com.kuang.pojo;

public class Teacher {
    private int id;
    private String name;

    public Teacher() {
    }

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

    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;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

database.properties文件編寫：

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

log4j.properties文件（日誌實現）：

### Log4j配置 ###
#定義log4j的輸出級別和輸出目的地（目的地可以自定義名稱，和後面的對應）
#[ level ] , appenderName1 , appenderName2
log4j.rootLogger=DEBUG,console,file

#-----------------------------------#
#1 定義日誌輸出目的地爲控制檯
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
####可以靈活地指定日誌輸出格式，下面一行是指定具體的格式 ###
#%c: 輸出日誌信息所屬的類目，通常就是所在類的全名
#%m: 輸出代碼中指定的消息,產生的日誌具體信息
#%n: 輸出一個回車換行符，Windows平臺爲"/r/n"，Unix平臺爲"/n"輸出日誌信息換行
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#-----------------------------------#
#2 文件大小到達指定尺寸的時候產生一個新的文件
log4j.appender.file = org.apache.log4j.RollingFileAppender
#日誌文件輸出目錄
log4j.appender.file.File=log/info.log
#定義文件最大大小
log4j.appender.file.MaxFileSize=10mb
###輸出日誌信息###
#最低級別
log4j.appender.file.Threshold=ERROR
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#-----------------------------------#
#3 druid
log4j.logger.druid.sql=INFO
log4j.logger.druid.sql.DataSource=info
log4j.logger.druid.sql.Connection=info
log4j.logger.druid.sql.Statement=info
log4j.logger.druid.sql.ResultSet=info

#4 mybatis 顯示SQL語句部分
log4j.logger.org.mybatis=DEBUG
#log4j.logger.cn.tibet.cas.dao=DEBUG
#log4j.logger.org.mybatis.common.jdbc.SimpleDataSource=DEBUG
#log4j.logger.org.mybatis.common.jdbc.ScriptRunner=DEBUG
#log4j.logger.org.mybatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG
#log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

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 resource="database.properties"/>

    <!--Mybatis設置-->
    <settings>
        <!--默認日誌實現-->
        <!--<setting name="logImpl" value="STDOUT_LOGGING"/>-->

        <!--Log4j實現-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

    <!--配置別名-->
    <typeAliases>
        <!--<typeAlias type="com.kuang.pojo.User" alias="User"/>-->
        <package name="com.kuang.pojo"/>
    </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>
        <!--class對應的是一個接口類-->
        <!--resource對應的是一個接口類的映射文件-->
        <mapper resource="com/kuang/dao/StudentMapper.xml"/>
    </mappers>

</configuration>

dao層：
StudentDao接口

package com.kuang.dao;

import com.kuang.pojo.Student;

import java.util.List;

public interface StudentDao {

    //獲得全部學生的信息以及對應的老師
    List<Student> getStudents();


    //獲得全部學生的信息以及對應的老師
    List<Student> getStudentsTwo();

}

對應的映射文件：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">

<!--namespace不能寫別名-->
<mapper namespace="com.kuang.dao.StudentDao">

    <!--遇到問題：學生類中關聯老師： 多個學生對應一個老師 -->
    <!--<select id="getStudents" resultType="Student">-->
        <!--select s.id,s.name,t.name from mybatis.student as s,mybatis.teacher as t-->
        <!--where s.tid = t.id-->
    <!--</select>-->

    <!--解決問題方式一:按查詢結果嵌套處理，模擬數據庫思想；-->
    <select id="getStudents" resultMap="StudentTeacher">
        select * from mybatis.student
    </select>

    <resultMap id="StudentTeacher" type="Student">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <!--屬性和字段對應  ， 類和表對應  ， 對象和記錄
        關聯一個字段
        需求：拿到老師這個類的屬性

        association ： 關聯，多對一
            column ： 數據庫對應的列名
            property ： 對應屬性名
            javaType ： 多對一字段對應的Java類型
            select ： 關聯一個語句
        -->
        <association column="tid" property="teacher" javaType="Teacher" select="getTeacher"/>
    </resultMap>

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




    <!-- 解決方式二：一個resultMap解決 ， 模擬面向對象的思想-->
    <select id="getStudentsTwo" resultMap="StudentTeacher2">
        select s.id,s.name,t.id as tid,t.name as tname
        from mybatis.student as s, mybatis.teacher as t
        where s.tid = t.id
    </select>

    <!--設置結果集映射ResultMap -->
    <resultMap id="StudentTeacher2" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>

        <!--直接關聯一個老師-->
        <association property="teacher" javaType="Teacher">
            <id property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>


</mapper>

測試文件：StudentDaoTest

package com.kuang.dao;

import com.kuang.pojo.Student;
import com.kuang.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class StudentDaoTest {
    @Test
    public void getStudents(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();

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

        List<Student> students = mapper.getStudents();

        for (Student student : students) {
            System.out.println("學生姓名："+student.getName()+"\t老師姓名："+student.getTeacher().getName());
        }

    }
    StudentDao ma

    @Test
    public void getStudentsTwo(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
pper = sqlSession.getMapper(StudentDao.class);

        List<Student> students = mapper.getStudentsTwo();

        for (Student student : students) {
            System.out.println("學生姓名："+student.getName()+"\t老師姓名："+student.getTeacher().getName()
            +student.getTeacher().getId());
        }

    }



}

結果輸出：

一對多處理

一個老師對應多個學生

一對多的業務：使用collection處理

環境搭建

一個老師對應多個學生

public class Teacher {
    private int id;
    private String name;

    //一個老師對應對個學生
    private List<Student> students;
}

編寫代碼

編寫dao接口

package com.kuang.dao;

import com.kuang.pojo.Teacher;

public interface TeacherDao {

    //獲得一個老師下的所有學生信息； 老師是包含學生的集合；
    Teacher getTeacher(int id);

    Teacher getTeacherTwo(int id);

}

對應mapper文件:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.kuang.dao.TeacherDao">

    <!--一對多的處理-->
    <!--面向對象方式解決-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.name sname,s.id sid,t.id tid, t.name tname
        from mybatis.student as s,mybatis.teacher as t
        where s.tid = t.id and t.id = #{id}
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <id property="id" column="sid"/>
            <result property="name" column="sname"/>
        </collection>
    </resultMap>


    <!--數據庫思想-->
    <select id="getTeacherTwo" resultMap="TeacherStudent2">
        select * from mybatis.teacher where id = #{id}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="T2"/>
    </resultMap>
    <select id="T2" resultType="Student">
        select * from mybatis.student where tid = #{id}
    </select>

</mapper>

測試類

package com.kuang.dao;

import com.kuang.pojo.Teacher;
import com.kuang.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;


public class TeacherDaoTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        TeacherDao mapper = sqlSession.getMapper(TeacherDao.class);
        Teacher teacher = mapper.getTeacher(1);

        System.out.println(teacher.getName());
        System.out.println(teacher.getStudents());

    }

    @Test
    public void getTeacherTwo(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        TeacherDao mapper = sqlSession.getMapper(TeacherDao.class);
        Teacher teacher = mapper.getTeacherTwo(1);

        System.out.println(teacher.getName());
        System.out.println(teacher.getStudents());

    }
}

總結：

多對一：association 關聯

一對多：collection 集合

兩種解決方式：

面對對象的思想：關聯對象
SQL語句思想：聯表查詢

項目實現

項目結構：

porm.xml文件resources同上；

TeacherMapper.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.kuang.dao.TeacherDao">

    <!--一對多的處理-->
    <!--面向對象方式解決-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.name sname,s.id sid, t.name tname
        from mybatis.student as s,mybatis.teacher as t
        where s.tid = t.id and t.id = #{id}
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="id"/>
        <result property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <id property="id" column="sid"/>
            <result property="name" column="sname"/>
        </collection>
    </resultMap>


    <!--數據庫思想-->
    <select id="getTeacherTwo" resultMap="TeacherStudent2">
        select * from mybatis.teacher where id = #{id}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="T2"/>
    </resultMap>
    <select id="T2" resultType="Student">
        select * from mybatis.student where tid = #{id}
    </select>

</mapper>

結果輸出：

動態SQL & 緩存

MyBatis 的強大特性之一便是它的動態 SQL。如果你有使用 JDBC 或其它類似框架的經驗，你就能體會到根據不同條件拼接 SQL 語句的痛苦。

動態SQL就是指根據不同查詢條件，生成不同的SQL語句

在 MyBatis 之前的版本中，有很多元素需要花時間瞭解。MyBatis 3 大大精簡了元素種類，現在只需學習原來一半的元素便可。MyBatis 採用功能強大的基於 OGNL 的表達式來淘汰其它大部分元素。

if

參數test：裏面的表達式如果爲ture則執行，否則不執行

if（title != null）
<if test="title != null">
AND title like #{title}
</if>

choose

有時我們不想應用到所有的條件語句，而只想從中擇其一項。針對這種情況，MyBatis 提供了 choose 元素，它有點像 Java 中的 switch 語句。

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  <choose>
    <when test="title != null">
      AND title like #{title}
    </when>
    <when test="author != null and author.name != null">
      AND author_name like #{author.name}
    </when>
    <otherwise>
      AND featured = 1
    </otherwise>
  </choose>
    
    
    switch (exp){
    	case 1:
    		break;
    	case 2:
    		break;
    }
    
</select>

trim[where,set]

<select id="findActiveBlogLike"
     resultType="Blog">
  SELECT * FROM BLOG
  <where>
    <if test="state != null">
         state = #{state}
    </if>
    <if test="title != null">
        AND title like #{title}
    </if>
    <if test="author != null and author.name != null">
        AND author_name like #{author.name}
    </if>
  </where>
</select>

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

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},</if>
      <if test="password != null">password=#{password},</if>
      <if test="email != null">email=#{email},</if>
      <if test="bio != null">bio=#{bio}</if>
    </set>
  where id=#{id}
</update>

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

foreach

<select id="selectPostIn" resultType="domain.blog.Post">
  SELECT *
  FROM POST P
  WHERE ID in
  <foreach item="item" index="index" collection="list"
      open="(" separator="," close=")">
        #{item}
  </foreach>
</select>

代碼測試

測試模糊查詢

接口編寫

//模糊查詢，可以通過自定義條件查詢
List<User> getUserByLike(Map<String,Object> map);

映射文件編寫

<select id="getUser" resultType="User">
    select * from mybatis.user
</select>

<select id="getUserByLike" resultType="User" parameterType="Map">
    select * from mybatis.user
    <where>
        <if test="name!=null">
            name like CONCAT('%',#{name},'%')
        </if>
        <if test="id!=null">
            and id = #{id}
        </if>
    </where>
</select>

測試類

@Test
public void getUserByLike(){
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    UserDao mapper = sqlSession.getMapper(UserDao.class);

    Map<String,Object> map = new HashMap<String,Object>();

    map.put("name","秦");
    map.put("id",1);

    List<User> users = mapper.getUserByLike(map);
    for (User user : users) {
        System.out.println(user);
    }
}

注意點：太過複雜的邏輯不建議使用動態SQL，簡單的話可以直接使用動態SQL實現；

緩存

如果開啓緩存，

在mapper映射文件中，添加一個標籤

<!--開啓緩存-->
<cache/>

如果要CRUD操作要查詢結果需要緩存，可以使用usrCache；

<!--
useCache: 是否開啓緩存
使用緩存可以解決問題：
    查詢出來的結果暫時保存着，消耗內存資源；
    如果短時間查詢同樣的語句比較多，可以提高速度；
-->
<select id="getUser" resultType="User" useCache="true">
    select * from mybatis.user
</select>

項目實現：
項目結構：

UserDao層：

package com.kuang.dao;

import com.kuang.pojo.User;

import java.util.List;
import java.util.Map;

public interface UserDao {
    //查詢全部用戶
    List<User> getUser();

    //模糊查詢，可以通過自定義條件查詢
    List<User> getUserByLike(Map<String,Object> map);


}

對應的mapper文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.kuang.dao.UserDao">

    <!--開啓緩存-->
    <cache/>

    <!--
    useCache: 是否開啓緩存
    使用緩存可以解決問題：
        查詢出來的結果暫時保存着，消耗內存資源；
        如果短時間查詢同樣的語句比較多，可以提高速度；
    -->
    <select id="getUser" resultType="User" useCache="true">
        select * from mybatis.user
    </select>

    <select id="getUserByLike" resultType="User" parameterType="Map">
        select * from mybatis.user
        <where>
            <if test="name!=null">
                name like CONCAT('%',#{name},'%')
            </if>
            <if test="id!=null">
                and id = #{id}
            </if>
        </where>
    </select>

</mapper>

測試類；

package com.kuang.dao;

import com.kuang.pojo.User;
import com.kuang.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

//
public class UserDaoTest {

    @Test
    public void getUser(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> users = mapper.getUser();
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void getUserByLike(){
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);

        Map<String,Object> map = new HashMap<String,Object>();

        map.put("name","秦");
        map.put("id",1);

        List<User> users = mapper.getUserByLike(map);
        for (User user : users) {
            System.out.println(user);
        }
    }

}

測試結果：

Java框架之mybatis(四)——多對一& 一對多處理、動態SQL & 緩存

多對一處理

多對一的處理方式一

多對一的處理方式二

總結

項目實現：

一對多處理

環境搭建

編寫代碼

總結：

項目實現

動態SQL & 緩存

if

choose

trim[where,set]

foreach

代碼測試

緩存

SQL優化-20231016

筆試題--斐波那契數列

筆試題-找到最長連續不重複子串

筆試題-最佳找零錢方案

面試題-生成10個1至20不重複的隨機數

面試題--模擬鬥地主洗牌發牌看牌

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結