mybatis_基本使用

mybatis

中文官网 https://mybatis.org/mybatis-3/zh/index.html
GAV

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.2</version>
</dependency>

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
            <scope>provided</scope>
        </dependency>

1、第一个`mybaits`程序

1.1、搭建环境

CREATE DATABASE mybatis;

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

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'张三','123456'),
(2,'李四','123456'),
(3,'王五','123456')

新建项目

1.2mybatis创建

创建SqlSession的工具类

package top.mgy.utils;

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 工具类
 *
 * 读取 sqlSessionFactory
 */
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            String resource = "mybatis-config.xml";
            InputStream in = Resources.getResourceAsStream(resource);
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 获取 SqlSession
     * @return
     */
    public SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

1.3、编写代码

实体类

package top.mgy.pojo;

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class User {
    private int id;
    private String name;
    private String pwd;
}

Dao接口

package top.mgy.dao;

import top.mgy.pojo.User;

import java.util.List;

public interface UserDao {

    List<User> getUserList();
}

核心配置 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://localhost:3306/mp?useUnicode=true&amp;charcaterEncoding=uft8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="top/mgy/dao/UserMapper.xml"/>
    </mappers>
</configuration>

接口实现类替换为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="top.mgy.dao.UserDao">

    <select id="getUserList" resultType="top.mgy.pojo.User">
        select * from  mybatis.user;
    </select>

</mapper>

测试

package top.mgy.dao.test;


import org.apache.ibatis.session.SqlSession;
import top.mgy.dao.UserMapper;
import top.mgy.pojo.User;
import top.mgy.utils.MybatisUtils;

import java.util.List;

public class UserDaoTest {

    public static void main(String[] args) {
        test();
    }
    public static void test(){
        //step1:获取sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //执行sql
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.getUserList();
        userList.forEach(System.out::println);

        sqlSession.close();
    }
}

CRUD

1、`namespace`

namespace 中的包名要和dao/mapper接口包名一致

2、`select`

id：就是对应的namespace中的方法名
resultType: SQL语句执行的返回值。

测试代码

package top.mgy.dao.test;


import org.apache.ibatis.session.SqlSession;
import top.mgy.dao.UserMapper;
import top.mgy.pojo.User;
import top.mgy.utils.MybatisUtils;

import java.util.List;

public class UserDaoTest {

    //step1:获取sqlSession对象
    static SqlSession  sqlSession = MybatisUtils.getSqlSession();
    public static void main(String[] args) {
        //test();
        //getUserById();
        //insertUser();
        //updataUser();
        deleteUser();
    }
    public static void test(){

        //执行sql
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.getUserList();
        userList.forEach(System.out::println);

        sqlSession.close();
    }

    //根据id获取用户
    public static void getUserById(){
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.getUsetById(1);
        System.out.println(user);
    }


    public static void insertUser(){
        /**
         * 增删改需要提交事务
         */
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(4, "赵六", "79456"));
        if(res > 0){
            sqlSession.commit();
        }
        System.out.println(res);
    }

    public static void updataUser(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.updateUser(new User(4, "王琦", "456789123"));
        if(res >0){
            sqlSession.commit();
        }
        System.out.println(res);

    }

    public static void deleteUser(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.deleteUser(4);
        if(res>0){
            sqlSession.commit();
        }
        System.out.println(res);
    }
}

UserMapper

package top.mgy.dao;

import top.mgy.pojo.User;

import java.util.List;

public interface UserMapper {

    List<User> getUserList();

    User getUsetById(int id);

    int addUser(User user);

    int updateUser(User user);

    int deleteUser(int id);
}

userMapeer.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="top.mgy.dao.UserMapper">

    <select id="getUserList" resultType="top.mgy.pojo.User">
        select * from  mybatis.user;
    </select>

    <select id="getUsetById" resultType="top.mgy.pojo.User">
        select * from mybatis.user where id=#{id}
    </select>

    <!--对象中的属性可以直接取出-->
    <insert id="addUser" parameterType="top.mgy.pojo.User">
        insert into mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd});
    </insert>

    <update id="updateUser" parameterType="top.mgy.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id};
    </delete>

</mapper>

万能map

假设我们要修改一个100个字段的表中的一个字段，如果为了修改一个字段而创建一个对象，不值，可以使用map直接传值修改。

在传递多个参数的情况下，可以使用map

接口

int updateUser2(Map<String,Object> map);

sql中的参数就是map的key
<update id="updateUser2" parameterType="map">
        update mybatis.user set pwd=#{password} where id=#{id}
    </update>

test

 //通过map修改值
    public static void updateUser2(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<>();
        map.put("id",1);
        map.put("password","qqqwwwee");
        int res = mapper.updateUser2(map);
        if(res > 0){
            sqlSession.commit();
            System.out.println(res);
        }

模糊查询

//模糊查询
    public static void getUserLike(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userLike = mapper.getUserLike("%王%");
        userLike.forEach(System.out::println);
    }

<select id="getUserLike" resultType="top.mgy.pojo.User">
        select * from mybatis.user where name like #{value}
    </select>

List<User> getUserLike(String value);

配置解析

1、核心配置文件

mybatsi-config.xml

2、配置环境

mybatis可以配置成适应多环境的
不过要记住：尽管可以配置多个环境，但是每个SqlSessionFactory实例只能选择一种环境

Mybatis默认的事务管理器是JDBC,会配置多个运行环境。

3、属性

可以通过properties属性配置引用属性

编写一个配置文件
db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mp?useUnicode=true&charcaterEncoding=uft8&serverTimezone=UTC
username=root
password=root

在核心配置文件中引入

 <!--引入外部配置文件-->
    <properties resource="db.properties"/>

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

4、别名

设置一个短的名字
存在的意义是为了减少java类的完全限定名词

<!--配置别名-->
<!--配置类别名，适合少量pojo类-->
    <typeAliases>
        <typeAlias type="top.mgy.pojo.User" alias="User"/>
    </typeAliases>
    <!--配置包别名 在接口中可以使用 @Alias("User")注解配置DIY别名-->
    <typeAliases>
        <package name="top.mgy.pojo"/>
    </typeAliases>

在UserMapper.xml中即可简写类名

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

设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。下表描述了设置中各项设置的含义、默认值等。

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true \| false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。	true \| false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。否则，每个延迟加载属性会按需加载（参考 `lazyLoadTriggerMethods`)。	true \| false	false （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled	是否允许单个语句返回多结果集（需要数据库驱动支持）。	true \| false	true
useColumnLabel	使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。	true \| false	true
useGeneratedKeys	允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。	true \| false	False
autoMappingBehavior	指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集（无论是否嵌套）。	NONE, PARTIAL, FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或未知属性类型）的行为。`NONE`: 不做任何反应`WARNING`: 输出警告日志（`'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior'` 的日志等级必须设置为 `WARN`）`FAILING`: 映射失败 (抛出 `SqlSessionException`)	NONE, WARNING, FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定数据库驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	指定语句默认的滚动策略。（新增于 3.5.2）	FORWARD_ONLY \| SCROLL_SENSITIVE \| SCROLL_INSENSITIVE \| DEFAULT（等同于未设置）	未设置 (null)
safeRowBoundsEnabled	是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true \| false	False
safeResultHandlerEnabled	是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。	true \| false	True
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true \| false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。默认值为 SESSION，会缓存一个会话中执行的所有查询。若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。	SESSION \| STATEMENT	SESSION
jdbcTypeForNull	当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。	OTHER
lazyLoadTriggerMethods	指定对象的哪些方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态 SQL 生成使用的默认脚本语言。	一个类型别名或全限定类名。	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定 Enum 使用的默认 `TypeHandler` 。（新增于 3.4.5）	一个类型别名或全限定类名。	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。	true \| false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回 `null`。当开启这个设置时，MyBatis会返回一个空实例。请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true \| false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建可延迟加载对象所用到的代理工具。	CGLIB \| JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 `-parameters` 选项。（新增于 3.4.1）	true \| false	true
configurationFactory	指定一个提供 `Configuration` 实例的类。这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。这个类必须包含一个签名为`static Configuration getConfiguration()` 的方法。（新增于 3.2.3）	一个类型别名或完全限定类名。

一个配置完整的 settings 元素的示例如下：

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

插件

mybatis Generator Core 代码生成插件
MyBatis Puus mybatis加强插件

6、映射器

MapperRegistry:注册绑定我们的Mapper配置文件

<mappers>
        <mapper resource="/top/mgy/dao/UserMapper.xml"/>
        <!--使用这种class的方式一定要确保UserMapper.xml和类所在包的包结构要一致才可以-->
        <mapper class="top.mgy.dao.UserMapper"/>
        <!--也可以使用包扫描，要确保xml文件和接口名称必须一致-->
        <package name="top.mgy.dao"/>
    </mappers>

7、什么周期和作用域

生命周期、和作用域，是至关重要的，因为错误的使用将会导致严重的并发问题。

SqlSessionFactoryBuilder

一旦创建了SqlSessionFactory,它就没用了
所以需要放在局部变量

SqlSessionFactory

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

SqlSession

连接池的一个请求！
SqlSession 的实例不是线程安全的，因此不能被共享的，所以它的最佳作用域是请求或者方法内。
用完之后就赶紧关了，避免资源浪费！

8、ResultMap

结果集映射。解决数据库中的字段和pojo中字段不一致问题

数据库中字段
pojo

@Alias("User1")
public class User1 {
    private int id;
    private String name;
    private String password;
}

xml

 <select id="getUsetById" resultType="User1">
        select * from mybatis.user where id=#{id}
    </select>

测试出现问题

password 没有值

User1(id=1, name=张三, password=null)

修改sql文件

<select id="getUsetById" resultType="User1">
        select id,name,pwd as password from mybatis.user where id=#{id}
    </select>

可以查出来了

说明字段没有映射上

User1(id=1, name=张三, password=qqqwwwee)

解决
- 改sql起别名
- 通过resultMap映射

<!--结果集映射 将pwd映射为password-->
    <resultMap id="User1Map" type="User1">
        <!--只需要映射不一致的字段即可-->
        <result property="password" column="pwd"/>
    </resultMap>

    <!--这里User1中的password属性和数据库中pwd字段不一致，要使用ResultMap映射-->
    <select id="getUsetById" resultMap="User1Map">
        select * from mybatis.user where id=#{id}
    </select>

这只是简单映射，但世界要这么简单就好了

更加复杂的映射

加入日志

mybatis-config.xml

 <!--配置日志-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

配置log4j

mybatis-config.xml

<!--配置日志-->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

log4j.properties

log4j.rootLogger=DEBUG,console,file
#日志输出级别
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
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/mgy.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.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

分页

写sql实现

 private static void getUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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

        Map<String,Integer> map = new HashMap<>();
        map.put("startIndex",0);
        map.put("PageSize",2);

        List<User> userByLimit = mapper.getUserByLimit(map);
        userByLimit.forEach(System.out::println);

        sqlSession.close();
    }

 <select id="getUserByLimit" parameterType="map" resultType="User">
        select * from mybatis.user limit #{startIndex},#{PageSize}
    </select>

 //分页
    List<User> getUserByLimit(Map<String,Integer> map);

分页插件
- PageHelper

使用注解开发

//开启自动提交事务
sqlSessionFactory.openSession(true);

  <!--绑定接口-->
    <mappers>
        <mapper class="mgy.dao.UserMapper"/>
    </mappers>

package mgy.dao;

import mgy.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserMapper {

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

}

-test

public static void main(String[] args) {
SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> users = mapper.getUsers();
    users.forEach(System.out::println);

    sqlSession.close();
}

多对一

-sql

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

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

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
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

步骤

1、导入lombok
2、建立实体类 Teacher，Student
3、建立对应的Mapperjiek
4、建立接口对应的XML
5、在核心配置文件中绑定Mapper接口或文件
6、查询测试

方式1(使用子查询)
查询复杂所有学生及学生对应的老师

<select id="getStudent" resultMap="StudentTeacher">
       select * from student;
   </select>
   <resultMap id="StudentTeacher" type="Student">
       <result property="id" column="id"/>
       <result property="name" column="name"/>
       <!--复杂属性，需要单独处理 对象使用：association 集合使用Collection-->
       <!--javaType表示复杂属性的类型   select可以理解为一个子查询，根据 pid=id去查询老师信息-->
       <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
   </resultMap>
   
   <select id="getTeacher" resultType="Teacher">
       select * from teacher where id = #{id}
   </select>

方式2(按照结果查询)

   <select id="getStudent2" resultMap="StudentTeacher2">
       select s.id sid,s.name sname,t.name tname from student s left join teacher t on s.tid = t.id
   </select>
   <resultMap id="StudentTeacher2" type="Student">
       <result property="id" column="sid"/>
       <result property="name" column="sname"/>
       <!--这里应该Teacher是一个复杂类型，所以需要通过 association 映射里面的值-->
       <association property="teacher" javaType="Teacher">
           <result property="name" column="tname"/>
       </association>
   </resultMap>

 private static void getStudent2(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();

       StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
       List<Student> student2 = mapper.getStudent2();
       student2.forEach(System.out::println);

       sqlSession.close();
   }

一对多查询

pojo

student

package top.mgy.pojo;

import lombok.Data;

@Data
public class Student1 {

    private int id;
    private String name;
    //学生关联老师
    private int tid;
}

teacher

package top.mgy.pojo;

import lombok.Data;

import java.util.List;

/**
 * 一对多 一个老师对应多个学生
 */
@Data
public class Teacher1 {

    private int id;
    private String name;
    private List<Student1> students;

}

xml sql 按结果查询

<select id="getTeacher2" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.id tid,t.name tname 
        from student s left join teacher t 
        on s.tid = t.id 
        where t.id=#{id}
    </select>
    
    <resultMap id="TeacherStudent" type="Teacher1">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--list需要使用collection   ， ofType和javaType差不多，只不过ofType是取泛型-->
        <collection property="students" ofType="Student1">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

查询结果

Teacher1(id=1, name=秦老师, students=[Student1(id=1, name=小明, tid=1), Student1(id=2, name=小红, tid=1), Student1(id=3, name=小张, tid=1), Student1(id=4, name=小李, tid=1), Student1(id=5, name=小王, tid=1)])

动态SQL

动态SQL就是指：根据不同条件生成不用的SQL语句

if
choose(when,otherwise)
foreach

环境

CREATE TABLE `blog`(
  `id` VARCHAR(50) NOT NULL COMMENT '博客id',
  `title` VARCHAR(100) NOT NULL COMMENT '博客标题',
  `author` VARCHAR(30) NOT NULL COMMENT '博客作者',
  `create_time` DATETIME NOT NULL COMMENT '创建时间',
  `views` INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8

实体类

package top.mgy.pojo;

import lombok.Data;

import java.util.Date;

@Data
public class Blog {
    private int id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}

IDUtils

package top.mgy.utils;

import java.util.UUID;

@SuppressWarnings("all") //抑制警告
public class IDUtils {

    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }

    public static void main(String[] args) {
        System.out.println(getId());
    }
}

IF

<?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="top.mgy.dao.BlogMapper">
    <insert id="addBlok" parameterType="Blog">
        insert into mybatis.blog(id, title, author, create_time, views)
        values (#{id}, #{title}, #{author}, #{createTime}, #{views})
    </insert>

    <select id="getBlogIf" 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>
</mapper>

添加数据

private static void addBlog() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        Blog blog = new Blog();
        blog.setId(IDUtils.getId());
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("Mgy");
        blog.setCreateTime(new Date());
        blog.setViews(9999);
        mapper.addBlok(blog);


        blog.setId(IDUtils.getId());
        blog.setTitle("Spring如此简单");
        blog.setCreateTime(new Date());
        mapper.addBlok(blog);


        blog.setId(IDUtils.getId());
        blog.setTitle("Spring Boot如此简单");
        blog.setCreateTime(new Date());
        mapper.addBlok(blog);

        sqlSession.close();
    }

查询

可根据title，author是否传入动态查询

 SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        Map map = new HashMap();
        //传入title，就按照title查询
        map.put("title","Mybatis如此简单");
        List<Blog> blogIf = mapper.getBlogIf(map);
        blogIf.forEach(System.out::println);
        sqlSession.close();

结果

Blog(id=e09e92980a51496c81da1f929913e891, title=Mybatis如此简单, author=Mgy, createTime=Fri Apr 17 18:15:51 CST 2020, views=9999)

where

可以使用where更好的处理 where后面的查询条件，
在where的查询条件中，如果是所有添加都不符合，会自动去掉where，如果第一个条件不符合，会自动去掉后面变为第一个条件的 and 或者 or 关键字。保证sql的拼接正确。

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

choose
set
sql片段
注意
最好基于单表来定义SQL片段
不要存在where标签
foreach

posted @ 2020-12-31 10:52 告一段落阅读(103) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部