MyBatis学习笔记（三）模糊查询专题

首发于我的博客 和尚的博客
本文讲解，用接口代理模式实现mybatis的模糊查询，讲解#{}和${}两个的区别，XML文件中五个特殊字符串不允许使用，小于号的解决问题。

源码获取github

1.关于接口代理模式和传统模式的区别

• 传统模式：在笔记（二）就是采用的这个模式：

  1. 需要写接口，接口实现类，测试类，
  2. 映射文件命名空间为持久化类的全路径

• 接口代理模式：本笔记之后所有采用这个模式：

  1. 只需要写接口，在测试类中调用，接口编程: 什么是接口? 简单理解:接口就是定义规范

  2. 接口返回类型跟你设置的resultMap或者resultType对应上即可,但是会根据你返回的类型完成selectone或者selectList操作

  3. 接口里方法如何写：sql语句返回的结果集类型 sql语句的id(要传的值);

     • eg:List getSkillLike02(String name);

     List为SQL语句返回的结果集类型，getSkillLike02为映射文件中SQL语句的id，String name是传给映射文件的值

  4. 映射文件命名空间为接口的全路径

  5. 可以根据接口的返回类型自动判断使用selectOne还是selectList

     • eg:返回的是一个对象的为one，返回的是list的就是List，如果是List，也是List

2.MyBatis框架中获取数据的形式有两种方案 #{}和${}的区别?

• #{}
  
  • 取值：
  • 方案一： 如果你是一个简单的数据类型,那么我们使用#{任意标识符}
  • 方案二: 对象或者Map #{属性或者KEY}
  • 如果使用#{}那么它的模式方式为预处理模式
• ${}
  
  • 你需要必须指明KEY或者属性
  • 对数据不会进行转义
  • 直接拼接到SQL语句上

3.XML文件中有五个特殊字符串不允许使用

1. 方法一：用了转义字符把>和<替换掉，然后就没有问题了。

   附:XML转义字符

   

2. 方法二：

因为这个是xml格式的，所以不允许出现类似“>”这样的字符，但是都可以使用

4.代码结构

5.数据库属性文件

jdbc.properties

jdbc.mysql.driver=com.mysql.jdbc.Driver
jdbc.mysql.url=jdbc:mysql://localhost:3306/cy42_mss
jdbc.mysql.username=root
jdbc.mysql.password=root

6.核心配置文件

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="jdbc.properties"/>
    <!--自定义设置类型的别名，也就是resultMap里的type，避免包名已修改，在映射文件里修改多处地方-->
    <typeAliases>
        <!-- 方式一、com.hs.model.Skill这个类设置了别名hs，之后要用这个的话，直接写hs -->
        <!--<typeAlias type="com.hs.model.Skill" alias="hs"/> -->
        <!-- 方式二、com.hs.model这个包下的类，要用的时候直接写类名，比如用com.hs.model.Skill，直接写Skill -->
        <package name="com.hs.model"/>
    </typeAliases>
    <!--配置数据库的环境-->
    <environments default="development">
        <environment id="development">
            <!--事务管理器:保证数据的完整性和一致性 关键信息 -->
            <!--框架：默认情况下CUD操作需要 手动提交事务 （如同在Navicat中表中输入了数据，没有点那个小√，就是没有提交事务， 但是输入insert语句，就自动提交事务了） -->
            <transactionManager type="JDBC" />
            <!--使用的是连接池：百度java如何实行连接池的原理？ -->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.mysql.driver}" />  <!--获取值，${属性文件里的变量名}，也可以直接写值-->
                <property name="url" value="${jdbc.mysql.url}" />  <!--获取值，${属性文件里的变量名}，也可以直接写值-->
                <property name="username" value="${jdbc.mysql.username}" /> <!--获取值，${属性文件里的变量名}，也可以直接写值-->
                <property name="password" value="${jdbc.mysql.password}" /> <!--获取值，${属性文件里的变量名}，也可以直接写值-->
            </dataSource>
        </environment>
    </environments>

    <!--加载映射文件 ，也就是含sql语句的文件-->
    <mappers>
         <!--告知映射文件方式1，一个一个的配置-->
        <mapper resource="com/hs/model/SkillMapper.xml"/>
        <!-- 告知映射文件方式2，自动扫描包内的Mapper接口与配置文件 -->
        <!--<package name="com.hs.model"/>-->
    </mappers>
</configuration>

7.接口代码

SkillDao.java

package com.hs.dao;
/** * 接口代理模式实现操作，在xxDao接口中，定义方法： sql语句返回的结果类型 sql语句的id(要传的值); * 不用写实现类，直接写测试类,具体实现见测试类 * sql的映射文件的命名空间跟接口的全路径一致 * 可以根据接口的返回类型自动判断使用selectOne还是selectList eg:返回的是一个对象的为one，返回的是list的就是list，如果是List<Bean>，也是list */
import com.hs.model.Skill;

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

public interface SkillDao {

    List<Skill> getSkillLike01();

    List<Skill> getSkillLike02(String name);

    List<Skill> getSkillLike03(String name);

    List<Skill> getSkillLike04(Map<String,Object> map);

    List<Skill> getSkillLike05(Map<String,Object> map);

}

8.持久化类

Skill.java

package com.hs.model;

public class Skill {
    private Integer skillid;
    private String skillname;
    private Integer num;

    public Integer getSkillid() {
        return skillid;
    }

    public void setSkillid(Integer skillid) {
        this.skillid = skillid;
    }

    public String getSkillname() {
        return skillname;
    }

    public void setSkillname(String skillname) {
        this.skillname = skillname;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "Skill{" +
                "skillid=" + skillid +
                ", skillname='" + skillname + '\'' +
                ", num=" + num +
                '}';
    }
}

9.映射文件

SkillMapper.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.hs.dao.SkillDao">  <!--命名空间规则 传统模式：（持久化类（实体化Bean）的类名全路径com.hs.Skill） 接口代理模式：接口的全路径-->

    <resultMap id="BaseResultMap" type="com.hs.model.Skill">
        <id column="skill_id" property="skillid"/>    <!--若有主键，主键用id标签，其余用result标签-->
        <result column="skill_name" property="skillname"/>
        <result column="num" property="num"/>
    </resultMap>

    <!--1.模糊条件查询是固定的，写死在sql语句里了-->
    <select id="getSkillLike01" resultMap="BaseResultMap">
        select skill_id,skill_name,num from skill where skill_name like '%s%'
    </select>

    <!--2.模糊条件是一个简单的数据类型 当你传递的为一个简单的数据类型，那么我们可以通过#{任意写}进行传值， #{xx}是一种预处理模式，先sql语句里是？ 然后接收到值了，再写进去,会给你默认加 '',即为'#{}' -->
        <!--A、通过java代码拼接字符串-->
    <select id="getSkillLike02" parameterType="string" resultMap="BaseResultMap">
        select skill_id,skill_name,num from skill where skill_name like #{name}
    </select>
        <!--B、通过SQL语句函数拼接字符串 concat函数指字符串拼接，-->
    <select id="getSkillLike03" parameterType="string" resultMap="BaseResultMap">
        select skill_id,skill_name,num from skill where skill_name like concat('%',#{name},'%')
    </select>
        <!--C、通过${}完成模糊查询！！！但是不太推荐，${}不会默认加 '' ，也不是预处理模式，是直接在把值写在了sql语句中， 一般用于order by ${key或者属性},一般只接受map或者对象 -->
    <select id="getSkillLike04" parameterType="map" resultMap="BaseResultMap">
        select skill_id,skill_name,num from skill where skill_name like concat('%','${name}','%')
    </select>
    <!--${}的应用，排序-->
    <select id="getSkillLike05" parameterType="map" resultMap="BaseResultMap">
        select * from skill order by skill_id ${fs}
    </select>
</mapper>

10.封装好的工具类

MyBatis.java

package com.hs.util;
/**
 * 知识点：
 * final修饰类：不能被继承
 * 修饰方法：不能被重写
 * 修饰变量：常量不可用变，但如果是对象，对象里的值可以变
 *
 */
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

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

public class MyBatisUtils {

    private MyBatisUtils() { }  //不允许实例化

    private static final String PATH = "mybatis-config.xml";
    private static InputStream inputStream;
    private static SqlSessionFactory sqlSessionFactory;

    static { //1.静态代码块，只是加载一次
        try {
            inputStream = Resources.getResourceAsStream(PATH);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("加载核心配置文件失败");
        }
    }

    public static SqlSession getSqlsession() {
        return sqlSessionFactory.openSession();
    }

    public static void closeSqlSession(SqlSession sqlSession) {
        if (sqlSession != null) {
            sqlSession.close();
        }
    }

}

11.日志框架配置

log4j.properties

# 日志配置文件Global logging configuration
log4j.rootLogger=ERROR, stdout
# MyBatis logging configuration...
# 如果要显示SQL语句，那么这个位置需要配置为命名空间log4j.logger.命名空间
log4j.logger.com.hs.dao.SkillDao=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

12.测试类

MyBatis.java

package com.hs.test;

import com.hs.dao.SkillDao;
import com.hs.util.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

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

/** * 接口代理模式实现操作，在xxDao接口中，定义方法： sql语句返回的结果类型 sql语句的id(要传的值); * 不用写实现类，直接写测试类,具体实现见测试类 * sql的映射文件的命名空间跟接口的全路径一致 * 可以根据接口的返回类型自动判断使用selectOne还是selectList eg:返回的是一个对象的为one，返回的是list的就是list，如果是List<Bean>，也是list */
public class MyBatisTest {

    /** * 1.模糊条件查询是固定的，写死在sql语句里了 */
    @Test
    public void getSkillLike01() {
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
// 根据xml映射文件，接口创建实现类代理 有点类似传统模式的new UserMapperImpl()
            SkillDao skillDao = sqlSession.getMapper(SkillDao.class);
            System.out.println(skillDao.getSkillLike01());
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }

    }
    /** * 2.通过java代码拼接字符串进行模糊查询 */
    @Test
    public void getSkillLike02() {
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            String name = "%a%";
            SkillDao skillDao = sqlSession.getMapper(SkillDao.class);
            System.out.println(skillDao.getSkillLike02(name));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }

    }
    /** * 3.通过sql语句函数拼接字符串进行模糊查询 */
    @Test
    public void getSkillLike03() {
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            String name = "s";
            SkillDao skillDao = sqlSession.getMapper(SkillDao.class);
            System.out.println(skillDao.getSkillLike03(name));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }

    }

    /** * 4.通过${}拼接字符串进行模糊查询 */
    @Test
    public void getSkillLike04() {
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("name", "s");
            SkillDao skillDao = sqlSession.getMapper(SkillDao.class);
            System.out.println(skillDao.getSkillLike04(map));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }

    }

    /** * 4.通过${}进行排序操作 */
    @Test
    public void getSkillLike05() {
        SqlSession sqlSession = null;
        try {
            sqlSession = MyBatisUtils.getSqlsession();
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("fs", "DESC");
            SkillDao skillDao = sqlSession.getMapper(SkillDao.class);
            System.out.println(skillDao.getSkillLike05(map));
        } finally {
            MyBatisUtils.closeSqlSession(sqlSession);
        }

    }

}