day01 mybatis

day01 mybatis

Mybatis介绍

它是基于Java编写的持久层框架，使开发者不必关心传统jdbc的api，只关心sql语句本身。

采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc 进行了封装，屏蔽了 jdbc api 底层访问细节，使我们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。

传统JDBC的缺点

1 每次都需要获取链接，然后关闭链接，导致影响性能

2 直接写死了SQL语句，导致硬编码

3 执行完成SQL语句之后，还需要自己封装javabean对象

mybatis的优点

1 直接使用数据库连接池

2 mybatis是直接把SQL语句写到配置文件，会更加灵活

3 mybatis框架执行CRUD的时候，会自动封装javabean

入门案例

首先配置maven仓库，配置两个setting，两个setting里面的maven必须配置一模一样

创建项目名称 day43MyBatis

添加pom的文件，下载相关包

<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.0modelVersion>

    <groupId>com.atguigugroupId>
    <artifactId>day43MybatisartifactId>
    <version>1.0-SNAPSHOTversion>


    <dependencies>

        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.6version>
        dependency>


        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.16version>
        dependency>


        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>


        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
    dependencies>
project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

创建数据库mybatis

create database mybatis;
1

创建表user

CREATE TABLE `user` (
  `id` int(11) NOT NULL auto_increment,
  `username` varchar(32) NOT NULL COMMENT '名称',
  `password` varchar(32) NOT NULL COMMENT '密码',
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
1
2
3
4
5
6

创建实体类User

package com.atguigu.pojo;

public class User {
    private Integer id;
    private String username;
    private String password;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

在资源文件文件夹下面，新建一个核心配置文件, 文件的名字随意

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">


<configuration>

    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC">transactionManager>
            <dataSource type="POOLED">
                <property name="username" value="root"/>
                <property name="password" value="123456"/>

                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
             
                <property name="url" value="jdbc:mysql:///mybatis?userSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true"/>
            dataSource>
        environment>
    environments>



    <mappers>

        <mapper resource="com/atguigu/dao/UserDao.xml">mapper>


    mappers>
configuration>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

创建dao

package com.atguigu.dao;
import com.atguigu.pojo.User;
import java.util.List;

public interface UserDao {

    /**
     * 查询所有
     */
    List<User> findAll();
}

1
2
3
4
5
6
7
8
9
10
11
12

配置sql的映射文件

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">



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



    <select id="findAll" resultType="com.atguigu.pojo.User">
        select * from user
    select>
mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

测试代码

package com.atguigu;

import com.atguigu.dao.UserDao;
import com.atguigu.pojo.User;
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 org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {

    @Test
    public void testFindAll() throws IOException {
        // 1.读取配置文件
        InputStream is = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 2.根据配置文件构建会话工厂
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 3.读取配置文件里面的io流
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        // 4.获取会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 5.通过会话工厂 获取userDao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        // 6.调用userDao里面的findall方法
        List<User> userList = userDao.findAll();
        for (User user : userList) {
            System.out.println(user);

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

使用注解的方式

1 需要删除配置文件

2 修改mybatis的核心配置文件

<mappers>
        
        
        
        <mapper class="com.atguigu.dao.UserDao">mapper>
    mappers>
1
2
3
4
5
6

3 在userdao这个类身上添加我们需要的注解

public interface UserDao {
    /**
     * 查询所有
     */
    @Select("select * from user")
    List<User> findAll();
}
1
2
3
4
5
6
7

插入数据

UserDao

    /**
     * 添加数据
     */
    void insert(User user);
1
2
3
4

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

<!--
mapper:表示配置映射文件
namespace:表示命名空间
com.atguigu.dao.UserDao 设置全限定名 实际上就是dao的完整路径
-->

<mapper namespace="com.atguigu.dao.UserDao">
    <!--配置添加操作后 获取插入数据的id
    新增用户后，同时还要返回当前新增用户的id值， 因为id是由数据库的自动增长来实现的
    所以就相当于我们要在新增后将自动增长 auto_increment的值返回-->
    <!--        实现方式一 在 标签中使用 useGeneratedKeys 和 keyProperty 两个属性来获取自动生成的主键值。-->
<!--    <insert id="insert" parameterType="com.atguigu.pojo.User" useGeneratedKeys="true" keyProperty="id">-->

<!--            insert into user(username,password) values(#{username}, #{password});-->
<!--    </insert>-->

    <!--        第二种实现方式：
            selectKey: 表示查询主键
            keyProperty="id"：表示类的属性id
            keyColumn="id": 表示主键id
            resultType="int"：主键的返回值类型是int
            order="AFTER": 表示执行顺序
            select last_insert_id(): 固定的语法 插入之后 查询id-->
            <insert id="insert" parameterType="com.atguigu.pojo.User">
                <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
                    select last_insert_id()
                </selectKey>
                insert into user(username, password) values(#{username}, #{password})
            </insert>


<!--   id:表示唯一标识符 这个标识符需要跟类里面的方法名保持一致-->
<!--    resultType:叫做返回值的类型 返回值的类型 如果是集合 写的是集合封装的对象-->
    <select id="findAll" resultType="com.atguigu.pojo.User">
        select * from user
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

测试代码

package com.atguigu;

import com.atguigu.dao.UserDao;
import com.atguigu.pojo.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MybatisTest {

//    ctrl + alt + f:抽取成员变量
    private SqlSession sqlSession;
    private UserDao userDao;
    private InputStream is;

    // 用于在测试方法执行之前执行
    @Before
    public void before() throws IOException {
        // 1.读取配置文件
        is = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 2.根据配置文件构建会话工厂
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 3.读取配置文件里面的io流
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        // 4.获取会话对象
        sqlSession = sqlSessionFactory.openSession();
        // 5.通过会话工厂 获取userDao对象
        userDao = sqlSession.getMapper(UserDao.class);
    }

    // 测试保存操作
    // 对MySQL数据库进行增、删、改操作需要提交事务 才能生效
    // 用于在测试方法执行之后执行
    @After
    public void after() throws IOException {
        // 提交事务
        sqlSession.commit();
        // 释放资源
        sqlSession.close();
        is.close();

    }

    @Test
    public void testInsert(){
        // 添加数据
        User user = new User();
        user.setUsername("王安石");
        user.setPassword("123123");
        System.out.println("保存操作之前：" + user);  // 保存操作之前：User{id=null, username='王安石', password='123123'}
        userDao.insert(user);
        System.out.println("保存操作之后：" + user);  // 保存操作之后：User{id=53, username='王安石', password='123123'}


    }

    @Test
    public void testFindAll() throws IOException {
        // 1.读取配置文件
        InputStream is = Resources.getResourceAsStream("sqlMapConfig.xml");
        // 2.根据配置文件构建会话工厂
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        // 3.读取配置文件里面的io流
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        // 4.获取会话对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 5.通过会话工厂 获取userDao对象
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        // 6.调用userDao里面的findall方法
        List<User> userList = userDao.findAll();
        for (User user : userList) {
            System.out.println(user);

        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

更新数据

UserDao

    /**
     * 更新数据
     */
    void update(User user);
1
2
3
4

UserDao.xml

 <update id="update" parameterType="com.atguigu.pojo.User">
        update user set username=#{username},password=#{password} where id=#{id}
    update>
1
2
3

测试代码

	@Test
    public void testUpdate(){
        // 修改数据
        User user = new User();
        user.setId(42);
        user.setUsername("李清照");
        user.setPassword("111111");
        // 调用userDao的方法进行更新数据
        userDao.update(user);

    }
1
2
3
4
5
6
7
8
9
10
11

删除数据

UserDao

    /**
     * 删除数据
     */
    void delete(Integer userId);

1
2
3
4
5

UserDao.xml

    <delete id="delete" parameterType="com.atguigu.pojo.User">
        delete from user where id = #{id}
    delete>
1
2
3

测试代码

    @Test
    public void testDelete(){
        // 调用userDao的方法根据id进行删除
        userDao.delete(45);
    }
1
2
3
4
5