Mybatis学习笔记——整合SpringBoot

对原生JDBC程序中的问题总结

1.假在数据库驱动
2.创建并获取数据库链接
3.创建jdbc statement对象
4.设置sql语句
5.设置sql语句中的参数（使用preparedStatement）
6.通过statement执行sql并获取结果
7.对sql执行结果进行解析处理
8.释放资源（resultSet、preparedstatement、connection）

问题总结

1.数据库连接，使用时就创建，不适用立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库性能
设想：使用数据库连接池管理数据库连接
2.将sql语句硬编码到java代码中，如果sql语句修改，需要重新编译java代码，不利于系统维护
设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对java代码进行重新编译
3.向preparedStatement中设置参数，对占位符号位置和设置参数值，硬编码在java代码中，不利于系统维护
设想：将sql语句及占位符号和参数全部配置在xml中
4.从resultSet中遍历结果集数据时，存在硬编码，将获取表的字段进行硬编码，不利于系统维护
设想：将查询的结果集，自动映射成java对象

参考代码

 

package com.iot.mybatis.jdbc;

//import java.sql.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcTest {
    public static void main(String[] args) {
        //数据库连接
        Connection connection = null;
        //预编译的Statement，使用预编译的Statement提高数据库性能
        PreparedStatement preparedStatement = null;
        //结果集
        ResultSet resultSet = null;
        try {
            //加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");

            //通过驱动管理类获取数据库链接
            connection =  DriverManager.getConnection("jdbc:mysql://120.25.162.238:3306/mybatis001?characterEncoding=utf-8", "root", "123");
            //定义sql语句 ?表示占位符
            String sql = "select * from user where username = ?";
            //获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            //设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
            preparedStatement.setString(1, "王五");
            //向数据库发出sql执行查询，查询出结果集
            resultSet =  preparedStatement.executeQuery();
            //遍历查询结果集
            while(resultSet.next()){
                System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            if(resultSet!=null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(preparedStatement!=null){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

 

mybatis概述

MyBatis是一个可以自定义sql、存储过程和高级映射的持久层框架
mybatis介绍
mybatis是一个持久层的框架，是apache下的顶级项目
mybatis让程序将主要的精力放在sql上，通过mybatis提供的映射方式，自由灵活生成满足需要sql语句
mybatis可以将向preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象
输入映射和输出映射
 ·输入映射
 ·parameterType：指定输入参数类型可以简单类型、pojo、hashmap
 ·对于综合查询，建议parameterType使用包装的pojo，有利于系统扩展
 ·输出映射
 ·resultType：查询到的列名和resultType指定的pojo的属性名一致，才能映射成功
 ·resultType：可以通过resultMap完成一些高级映射，如果查询到的列名和映射pojo的属性名不一致时，通过resultMap设置列名和属性名之间的对应关系，可以完成映射

入门程序

使用Mybatis进行简单的查询

工程结构

·SqlMapConfig.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>
    <!-- 和spring整合后 environments配置将废除-->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理，事务控制由mybatis-->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池,由mybatis管理-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://120.25.162.238:3306/mybatis001?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="123" />
            </dataSource>
        </environment>
    </environments>
</configuration>

 

映射文件

·sqlmap/User.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 命名空间，作用就是对sql进行分类化管理,理解为sql隔离
 注意：使用mapper代理方法开发，namespace有特殊重要的作用
 -->
<mapper namespace="test">
    <!-- 在映射文件中配置很多sql语句 -->
    <!--需求:通过id查询用户表的记录 -->
    <!-- 通过select执行数据库查询
     id:标识映射文件中的sql，称为statement的id
     将sql语句封装到mappedStatement对象中，所以将id称为statement的id
     parameterType:指定输入参数的类型
     #{}标示一个占位符,
     #{value}其中value表示接收输入参数的名称，如果输入参数是简单类型，那么#{}中的值可以任意。

     resultType：指定sql输出结果的映射的java对象类型，select指定resultType表示将单条记录映射成java对象
     -->
    <select id="findUserById" parameterType="int" resultType="com.iot.mybatis.po.User">
        SELECT * FROM  user  WHERE id=#{value}
    </select>

    <!-- 根据用户名称模糊查询用户信息，可能返回多条
    resultType：指定就是单条记录所映射的java对象类型
    ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接在sql中。
    使用${}拼接sql，引起 sql注入
    ${value}：接收输入参数的内容，如果传入类型是简单类型，${}中只能使用value
     -->
    <select id="findUserByName" parameterType="java.lang.String" resultType="com.iot.mybatis.po.User">
        SELECT * FROM user WHERE username LIKE '%${value}%'
    </select>
</mapper>

 

在sqlMapConfig.xml中加载User.xml

<!-- 加载映射文件-->
<mappers>
    <mapper resource="sqlmap/User.xml"/>
</mappers>

程序代码

·pojo：User.java

package com.iot.mybatis.po;

import java.util.Date;

/**
 * Created by Administrator on 2016/2/21.
 */
public class User {
    //属性名要和数据库表的字段对应
    private int id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址
    
    // 省略 set/get 方法

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", birthday=" + birthday + ", address=" + address + "]";
    }
}

测试代码

package com.iot.mybatis.first;

import com.iot.mybatis.po.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;

/**
 * Created by Administrator on 2016/2/23.
 */
public class MybatisFirst {

    //根据id查询用户信息，得到一条记录结果

    @Test
    public void findUserByIdTest() throws IOException{
        // mybatis配置文件
        String resource = "SqlMapConfig.xml";
        // 得到配置文件流
        InputStream inputStream =  Resources.getResourceAsStream(resource);
        //创建会话工厂，传入mybatis配置文件的信息
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        // 通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();

        // 通过SqlSession操作数据库
        // 第一个参数：映射文件中statement的id，等于=namespace+"."+statement的id
        // 第二个参数：指定和映射文件中所匹配的parameterType类型的参数
        // sqlSession.selectOne结果 是与映射文件中所匹配的resultType类型的对象
        // selectOne查询出一条记录
        User user = sqlSession.selectOne("test.findUserById", 1);

        System.out.println(user);

        // 释放资源
        sqlSession.close();

    }

    // 根据用户名称模糊查询用户列表
    @Test
    public void findUserByNameTest() throws IOException {
        // mybatis配置文件
        String resource = "SqlMapConfig.xml";
        // 得到配置文件流
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // 创建会话工厂，传入mybatis的配置文件信息
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(inputStream);

        // 通过工厂得到SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // list中的user和映射文件中resultType所指定的类型一致
        List<User> list = sqlSession.selectList("test.findUserByName", "小明");
        System.out.println(list);
        sqlSession.close();
    }
}

输出

·findUserByIdTest()

...
DEBUG [main] - ==>  Preparing: SELECT * FROM user WHERE id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
User [id=1, username=王五, sex=2, birthday=null, address=null]
...

SpringBoot整合Mybatis

编写配置文件application.properties

 

spring.datasource.url=jdbc:mysql://localhost:3306/book?serverTimezone = UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
logging.level.com.sxbf.demo.mapper=debug


spring.redis.host=192.168.14.107
spring.redis.port=6379
spring.redis.password=

mybatis.mapper-locations=classpath:mapper/BookMapper.xml
mybatis.type-aliases-package=com.demo.entity

 

在src/main/resources目录下创建mapper文件夹

BookMapper.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">
<mapper namespace="com.demo.mapper.BookMapper">
    <select id="findAllBook" resultType="com.demo.entity.Book">
        select * from book_list
    </select>
    <select id="findBookByName" resultType="com.demo.entity.Book">
        select * from book_list where id = #{id}
    </select>
    <update id="Update" parameterType="com.demo.entity.Book">
        update book_list set name=#{name},price=#{price},pic=#{pic} where id=#{id}
    </update>
    <insert id="insertBook" parameterType="com.demo.entity.Book">
        insert into book_list (name,price,pic) values (#{name},#{price},#{pic})
    </insert>
    <delete id="delete" parameterType="com.demo.entity.Book">
        delete from book_list where id=#{id}
    </delete>
</mapper>

在src/main/java下编写
Book.java

package com.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

import org.springframework.data.redis.core.RedisHash;

@RedisHash("Books")
@Entity
public class Book {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private Double price;
    private String pic;
    
    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 Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public String getPic() {
        return pic;
    }
    public void setPic(String pic) {
        this.pic = pic;
    }
}

Msg.java

package com.demo.entity;

public class Msg {
    //100 成功  200失败
    private int code;
    private Object data;
    //message
    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    
    public static Msg succcess(Object data)
    {
        Msg msg = new Msg();
        msg.setCode(100);
        msg.setData(data);
        return msg;
    }
}

BookMapper.java

package com.demo.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.data.repository.query.Param;

import com.demo.entity.Book;

@Mapper
public interface BookMapper {
    
    List<Book> findAllBook();
    
    List<Book> findBookByName(int id);
    
//    @Insert("insert into .. values")
    int insertBook(Book book);
    
    int delete(int id);
    
    int Update(Book book);
}

BookService.java

package com.demo.service;

import java.util.List;

import org.springframework.data.domain.Page;
import org.springframework.data.repository.CrudRepository;

import com.demo.entity.Book;

public interface BookService{
    List<Book> findAll();
    
    List<Book> findBookByName(int id);
    
    Book insertBook(Book book);
    
    int delete(int id);
    
    int Update(Book book);
}

BookServiceImpl.java

package com.demo.service;

import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.demo.entity.Book;
import com.demo.mapper.BookMapper;

@Service
public class BookServiceImpl implements BookService {
    
    @Autowired
    BookMapper bookMapper;
    
    @Override
    public List<Book> findAll() {
        // TODO Auto-generated method stub
        return bookMapper.findAllBook();
    }

    @Override
    public List<Book> findBookByName(int id) {
        // TODO Auto-generated method stub
        return bookMapper.findBookByName(id);
    }

    @Override
    public Book insertBook(Book book) {
        // TODO Auto-generated method stub
        bookMapper.insertBook(book);
        return book;
    }

    @Override
    public int delete(int id) {
        // TODO Auto-generated method stub
        return bookMapper.delete(id);
    }

    @Override
    public int Update(Book book) {
        // TODO Auto-generated method stub
        return bookMapper.Update(book);
    }

}

BookController.java

package com.demo.controller;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.demo.entity.Book;
import com.demo.entity.Msg;
import com.demo.service.BookService;

@RestController
@RequestMapping("/vip")
public class BookController {
    
    @Resource
    BookService bookService;

    @GetMapping("/query")
    public Msg findAll(){
        return Msg.succcess(bookService.findAll()) ;
    }
    
    @GetMapping("/delete")
    public String delete(int id) {
        int result=bookService.delete(id);
        if(result>=1) {
            return "删除成功";
        }else {
            return "删除失败";
        }
    }
    
    @GetMapping("/update")
    public String update(Book book) {
        int result=bookService.Update(book);
        if(result>=1) {
            return "修改成功";
        }else {
            return "修改失败";
        }
    }
    
    @GetMapping("/insert")
    public Book insert(Book book) {
        return bookService.insertBook(book);
    }
    
    @GetMapping("/select")
    public Msg findBookByName(int id){
        return Msg.succcess(bookService.findBookByName(id));
    }
    
}

有喜欢小编的可以给个关注，后面会持续更新，Redis缓存等中间件也会陆续使用