Mybatis掌握第一章—入门

目录

简介
MyBatis第一个程序
增删改查实现
map和模糊查询拓展

简介：

学习前需要掌握：
JDBC
MySQL
Java 基础
Maven
Junit
什么是MyBatis：

• MyBatis 是一款优秀的持久层框架
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
• MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
• MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code，并且改名为MyBatis 。
• 2013年11月迁移到Github : https://github.com/mybatis/mybatis-3
• Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
  获取mybatis：

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.5</version>
</dependency>

1.2持久化

数据持久化
持久化就是将程序的数据在持久状态和瞬时状态转化的过程
即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。

JDBC就是一种持久化机制。文件IO也是一种持久化机制。
为什么需要持久化？
有一些对象，不能让他丢失
内存太贵

1.3持久层

什么是持久层？
Dao层，Service层，Controller层
完成持久化工作的代码块
层界限十分明显
大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。

为什么需要Mybatis：

Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率 .
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别

MyBatis的优点

简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。

灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。

解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。

提供xml标签，支持编写动态sql。

MyBatis第一个程序：

思路流程：搭建环境–>导入Mybatis—>编写代码—>测试

1、搭建实验数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
`id` int(20) NOT NULL,
`name` varchar(30) DEFAULT NULL,
`pwd` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user`(`id`,`name`,`pwd`) values (1,'小明','123456'),(2,'小红','abcdef'),(3,'小猪','987654');

导入MyBatis相关 jar 包

<!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

什么是MyBatis映射器？
MyBatis框架包括两种类型的XML文件：
一类是配置文件（mybatis-config.xml）；
另外一类是映射文件（XXXMapper.xml）等。
在 MyBatis的配置文件mybatis-config.xml 包含了节点，这里就是MyBatis映射器。

映射器的使用方法：
编写MyBatis核心配置文件
在这里打包成一个工具类：
编写MyBatis工具类
查看帮助文档
从 XML 中构建 SqlSessionFactory
每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。
而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器

<?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.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatistest?useSSL=true&amp;serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="dao/UserMapper.xml"/>
    </mappers>
</configuration>

从 SqlSessionFactory 中获取 SqlSession：
我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。

try (SqlSession session = sqlSessionFactory.openSession()) {
  Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
}

封装成一个工具类：

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;

//SqlSessionFactory工厂模式，必定是用来构建sqlSession
public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //第一步，获取SqlSessionFactory对象
            String resource = "mybatis.xml";// 读取mybatis-config.xml文件
            InputStream inputStream = Resources.getResourceAsStream(resource);//用io流加载进来
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);//通过builder将流加载进来，初始化mybatis，创建SqlSessionFactory类的实例
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获得 SqlSession 的实例
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

探究已映射的 SQL 语句：
现在你可能很想知道 SqlSession 和 Mapper 到底具体执行了些什么操作：
一个语句既可以通过 XML 定义，也可以通过注解定义，这里给出一个基于 XML 映射语句的示例，它应该可以满足上个示例中 SqlSession 的调用。

<?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="dao.UserDao">
    <select id="getUserList" resultType="pojo.User"><!--查询语句，id是dao层的方法名-->
    select * from user
  </select>
</mapper>

写出第一个实例：

创建实体类User：(温馨提示，这里省略篇幅，用了lombok，maven自己添加，因为还不是web项目，所以别忘了加上toString方法，不然你拿到的会是一个地址)

@NoArgsConstructor
@AllArgsConstructor
public class User {

    private int id;
    private String name;
    private String pwd;
    
}

编写Mapper（dao）接口类：

import pojo.User;

import java.util.List;

//接口
public interface UserMapper {
    List<User> selectUser();
}

编写Mapper.xml配置文件

namespace 十分重要，不能写错

<?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="dao.UserMapper">
    <select id="selectUser" resultType="pojo.User"><!--查询语句，id是dao层的方法名-->
    select * from user
  </select>
</mapper>

编写测试类
Junit 包测试

import dao.UserDao;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import pojo.User;
import utils.MybatisUtils;
import java.util.List;
public class UserDaoTest {
    @Test
    public void selectUser() {
        SqlSession session = MybatisUtils.getSession();
        //方法一:纯xml映射器，利用SqlSession的各种方法实现增删改查。例如：
        //List<User> users = session.selectList("com.kuang.mapper.UserMapper.selectUser");
        //方法二:xml映射器+接口映射器的混合类型
        UserDao mapper = session.getMapper(UserDao.class);
        List<User> users = mapper.selectUser();

        for (User user: users){
            System.out.println(user);
        }
        session.close();//关闭
    }
}

结果：

官方不做成工具类直接使用，看起来更直观：

public static void main(String[] args) throws Exception
{
    // 读取mybatis-config.xml文件
    InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");

    // 初始化mybatis，创建SqlSessionFactory类的实例
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    // 创建Session实例
    SqlSession session = sqlSessionFactory.openSession();

-------------------------------------------------以上固定使用

    // 操作数据库方法一：获得xml映射文件中定义的操作语句
    User s = session.selectOne("getuser", 1);
    // 打印User对象
    System.out.println(s);

    // 操作数据库方法二：获得mapper接口的代理对象
    UserMapper sm = session.getMapper(UserMapper.class);
    // 直接调用接口的方法，查询id为1的User数据
    User s2 = sm.getuser(1);
    // 打印Peson对象
    System.out.println(s2);

    // 提交事务
    session.commit();
    // 关闭Session
    session.close();
}

可能遇到的问题
1，配置文件没有注册
2，绑定接口错误
3，方法名不对
4，返回类型不对
5，Maven导出过滤资源
maven资源过滤代码要加上：

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

思路过程，创建数据库–>创建maven项目（空的就可以）–>导入jar包就是下载依赖–>需要sqlsessionactory对象实例，官网看，一上来三行代码–>编写配置文件，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器–>从 SqlSessionFactory 中获取 SqlSession–>建立实体类–>建立接口–>jdbc中需要建立接口实现类，那么mybatis中就只需要建立一个mapper.xml，写下sql语句，绑定接口的方法–>将mapper.xml注册到核心配置文件–>编写测试类
这一章节好好阅读：官方帮助文档

增删改查

mapper.xml
namespace:namespace中的包名要和Dao/mapper接口的包名保持一致
select查询语句
id：就是对应的namespace中的方法名；
resultType：Sql语句执行的返回值！
parameType：参数类型
思路：编写接口–>编写对应的mapper中的sql语句–>
测试中要添加事务提交，增删改

//接口
public interface UserDao {
    List<User> selectUser();
    User getUserID(int id);
    int updateUser(User user);
    int addUser(User user);
    int deleteUser(int id);
}

<?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="dao.UserDao">
    <select id="selectUser" resultType="pojo.User">
  select * from user
 </select>
    <select id="getUserID" resultType="pojo.User">
        select * from user where id= #{id}
    </select>
    <update id="updateUser" parameterType="pojo.User" >
        update user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>
    <insert id="addUser" parameterType="pojo.User">
        insert into user (id,name,pwd)value (#{id},#{name},#{pwd})
    </insert>
    <delete id="deleteUser" parameterType="pojo.User">
        delete from user where id=#{id}
    </delete>
</mapper>

import dao.UserDao;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import pojo.User;
import utils.MybatisUtils;
import java.util.List;
public class UserDaoTest {
    @Test
    public void selectUser() {
        SqlSession session = MybatisUtils.getSession();
        //方法一:
        //List<User> users = session.selectList("com.kuang.mapper.UserMapper.selectUser");
        //方法二:
        UserDao mapper = session.getMapper(UserDao.class);
        List<User> users = mapper.selectUser();

        for (User user : users) {
            System.out.println(user);
        }
        session.close();
    }

    @Test
    public void selectUserid() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        User userID = mapper.getUserID(2);
        System.out.println(userID);
        session.close();
    }

    @Test
    public void inserUser() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        int res = mapper.addUser(new User(4, "哈哈", "132155"));
        if (res > 0) {
            System.out.println("插入成功");
        }
        session.commit();
        session.close();
    }

    @Test
    public void updateUser() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        mapper.updateUser(new User(4, "呵呵", "132155"));
        session.commit();
        session.close();
    }

    @Test
    public void deleteUser() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        mapper.deleteUser(1);
        session.commit();
        session.close();
    }
}

万能map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map！

//接口
public interface UserDao {
    List<User> selectUser();
    User getUserID(int id);
    int updateUser(User user);
    int addUser(User user);
    int deleteUser(int id);
    int addUser2(Map<String,Object>map);//map
    User getUserID2(Map<String,Object> map);
}

 <!--对象中的属性，可以直接取出来-->
    <!--传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into user (id,name,pwd)value (#{userid},#{username},#{password})
    </insert>
       <select id="getUserID2" resultType="pojo.User" parameterType="map">
        select * from user where id= #{helloid}
    </select>

   @Test
    public void addUser2(){
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
        stringObjectHashMap.put("userid",5);
        stringObjectHashMap.put("username","哈哈哈");
        mapper.addUser2(stringObjectHashMap);
        session.commit();
        session.close();
    }

 @Test
    public void getUserID2(){
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
        stringObjectHashMap.put("helloid",2);
        User userID2 = mapper.getUserID2(stringObjectHashMap);
        System.out.println(userID2);
        session.close();
    }

结果：你可以只插入两条数据


Map传递参数，直接在sql中取出key即可{parameterType=“map”}
对象传递参数，直接在sql中取对象的属性即可{parameterType=“Object”}
只有一个基本类型参数的情况下，可以直接在sql中取到
多个参数用map，或者注解

模糊查询

模糊查询怎么写，在工作中一定会遇到，两种方式
1，java代码执行的时候，传递通配符%%

List<User>userList=mapper.getUserLike("%李%")

2，在sql萍姐中使用通配符

 select * from user where name like "%" #{value}"%"

以下是这一章的全部代码，我直接回来看的时候也不混乱

//接口
public interface UserDao {
    List<User> selectUser();
    User getUserID(int id);
    int updateUser(User user);
    int addUser(User user);
    int deleteUser(int id);
    int addUser2(Map<String,Object>map);//map
    User getUserID2(Map<String,Object> map);

    List<User> getUserlike(String value);
}

<?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="dao.UserDao">
    <select id="selectUser" resultType="pojo.User">
  select * from user
 </select>
    <select id="getUserID" resultType="pojo.User">
        select * from user where id= #{id}
    </select>
    <update id="updateUser" parameterType="pojo.User" >
        update user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>
    <insert id="addUser" parameterType="pojo.User">
        insert into user (id,name,pwd)value (#{id},#{name},#{pwd})
    </insert>
    <!--对象中的属性，可以直接取出来-->
    <!--传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into user (id,name,pwd)value (#{userid},#{username},#{password})
    </insert>
    <select id="getUserID2" resultType="pojo.User" parameterType="map">
        select * from user where id= #{helloid}
    </select>

    <select id="getUserlike" resultType="pojo.User">
        select * from user where name like "%" #{value}"%"
    </select>



    <delete id="deleteUser" parameterType="pojo.User">
        delete from user where id=#{id}
    </delete>
</mapper>

import dao.UserDao;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import pojo.User;
import utils.MybatisUtils;

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

public class UserDaoTest {
    @Test
    public void selectUser() {
        SqlSession session = MybatisUtils.getSession();
        //方法一:
        //List<User> users = session.selectList("com.kuang.mapper.UserMapper.selectUser");
        //方法二:
        UserDao mapper = session.getMapper(UserDao.class);
        List<User> users = mapper.selectUser();

        for (User user : users) {
            System.out.println(user);
        }
        session.close();
    }

    @Test
    public void selectUserid() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        User userID = mapper.getUserID(2);
        System.out.println(userID);
        session.close();
    }

    @Test
    public void inserUser() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        int res = mapper.addUser(new User(4, "哈哈", "132155"));
        if (res > 0) {
            System.out.println("插入成功");
        }
        session.commit();
        session.close();
    }

    @Test
    public void updateUser() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        mapper.updateUser(new User(4, "呵呵", "132155"));
        session.commit();
        session.close();
    }

    @Test
    public void deleteUser() {
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        mapper.deleteUser(1);
        session.commit();
        session.close();
    }


    @Test
    public void addUser2(){
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
        stringObjectHashMap.put("userid",5);
        stringObjectHashMap.put("username","哈哈哈");
        mapper.addUser2(stringObjectHashMap);
        session.commit();
        session.close();
    }

    @Test
    public void getUserID2(){
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
        stringObjectHashMap.put("helloid",2);
        User userID2 = mapper.getUserID2(stringObjectHashMap);
        System.out.println(userID2);
        session.close();
    }


    @Test
    public void getUserlike(){
        SqlSession session = MybatisUtils.getSession();
        UserDao mapper = session.getMapper(UserDao.class);
        List<User> ree = mapper.getUserlike("小");
        for (User user : ree) {
            System.out.println(user);
        }
        session.close();
    }
}