mybatis 持久层(ORM)框架概念和基本CRUD使用

mybatis 持久层(ORM)框架概念和基本使用

mybatis 是Java的持久层框架，核心的目的是与数据库交互，进行数据库数据的增，删，改，查。mybatis框架内部封装了jdbc,使我们只需要关注sql语句本身。不需要太多去关注jdbc的底层细节，加载驱动、创建连接、创建statement等过程。使我们可以高效的进行持久层操作。

mybatis通过 xml 或 注解的方式，将我们的执行的各种statement配置起来，也就是将我们的 sql语句从代码中抽离出来，使我们的sql语句不在硬编码在代码中，实现了我们程序的解耦，方便了我们 sql 语句的变动与维护。

mybatis通过 ORM （对象关系映射）的思想解决了实体类与数据库映射的问题，通过利用ORM的机制可以自动的将我们的Java对象转换为数据库类型，完成sql语句的使用。也可以将查询结果映射成实体类型，自动完成结果集的封装与使用。通过ORM的机制屏蔽掉了 JDBC api 底层的细节，使我们不在于jdbc底层api打交道即可完成数据库持久化操作。

jdbc 编程分析

public static void main(String[] args) {
    Connection connection = null;
    PreparedStatement preparedStatement = null;
    ResultSet resultSet = null;
    try {
        //加载数据库驱动
        Class.forName("com.mysql.jdbc.Driver");
       //通过驱动管理类获取数据库链接
        connection = DriverManager
             .getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8","root","root");
        //定义 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) {
         e.printStackTrace();
       } }
     if(preparedStatement!=null){
        try {
          preparedStatement.close();
        } catch (SQLException e) {
        e.printStackTrace();
     } }
   if(connection!=null){
         try {
          connection.close();
          } catch (SQLException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
        }
      } 
     }
   }

1.需要频繁的创建数据库连接和释放资源操作造成系统资源的浪费，影响系统的性能，带来代码冗余的问题。可以通过数据库连接池解决这类问题。

2.sql语句硬编码在程序代码中，sql语句在实际应用中变化较大，造成sql语句的不易维护，带来了较大的耦合问题，一旦修改sql代码也会产生大量的修改。

3.使用预编译的preparedStatement或者拼接字符的statement,因为 sql语句条件的不确定性，例如 preparedstatement语句设置where条件可能多也可能少，修改sql会涉及到修改 java 代码。

4.对结果集的解析存在硬编码（解析列名），sql变化会涉及解析代码大的修改。系统不易维护，无法自动进行 ORM 把查询结果封装到指定的bean实体类中。

mybatis基本使用流程CRUD操作

第一步：创建 maven 工程

第二步：导入坐标

第三步：编写必要代码（实体类和持久层接口）

第四步：编写 SqlMapConfig.xml

第五步：编写映射配置文件

第六步：编写测试类

1.创建maven项目，目录结构如下

2.引入pom依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

    <groupId>com.stack</groupId>
    <artifactId>mybatis2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
    </dependencies>
</project>

3.编写SqlMapConfig mybatis环境配置

<?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="mysql">
        <!--数据库编号-->
        <environment id="mysql">
            <!--配置 jdbc 事务管理器-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源 采用mybatis提供的连接池（POOLED,UNPOOLED,JNDL）-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--xml sql 配置文件映射位置-->
    <mappers>
        <mapper resource="com/stack/mapper/UserMapper.xml"></mapper>
    </mappers>
</configuration>

4.配置日志记录信息

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
# log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

5.编写实体类用来进行ORM映射

    private int userid;

    private String username;

    private int sex;

    private int age;

    // 重写默认无参构造
    public User(){

    }

    public User( int userid,String username, int sex, int age) {
        this.userid=userid;
        this.username = username;
        this.sex = sex;
        this.age = age;
    }



    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

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

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }

6.编写Map接口（也就是我们常用的dao层负责与数据库交互）

package com.stack.mapper;

import com.stack.bean.User;

import java.util.List;

/**
 * create by stack on 2020/10/3
 */
public interface UserMapper {

    List<User> findAllUser();

    User findUserById(int userid);

    int insertUser(User user);

    int updateUser(User user);

    int deleteUser(int userid);

    User findUserByAge(int age);
    
    // 模糊查询的两种方式
    List<User> findUserByName(String username);
    
     List<User> findUserByName2(String username);

}

7.编写map映射文件（注意包名要与map类保持一样）

<?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 与map接口绑定 全限定类名-->
<mapper namespace="com.stack.mapper.UserMapper">

    <!--id 与方法名一致 resultType 返回值类型-->
    <select id="findAllUser" resultType="com.stack.bean.User">
        select * from user;
    </select>

    <!--parameterType 传递参数类型，有别名的像 String int 等可以直接使用别名，否则的话使用全限定类名-->
    <select id="findUserById" resultType="com.stack.bean.User" parameterType="int">
        select * from user where userid = #{userid}
    </select>

   <insert id="insertUser" parameterType="com.stack.bean.User">
       insert into user(username,sex,age) values (#{username},#{sex},#{age})
   </insert>

    <update id="updateUser" parameterType="com.stack.bean.User">
        update user set username=#{username},sex=#{sex},age=#{age} where userid=#{userid}
    </update>
    <select id="findUserByAge" resultType="com.stack.bean.User" parameterType="int"  >
        select * from user where age>#{age}
    </select>

    <delete id="deleteUser" parameterType="int">
        delete from user where userid=#{userid}
    </delete>
    
     <select id="findUserByName" resultType="com.stack.bean.User" parameterType="string">
        select * from user where username like #{username}
    </select>
    
    <select id="findUserByName2" resultType="com.stack.bean.User" parameterType="string">
        select * from user where username like "%${value}%"
    </select>
    
</mapper>

8.编写Junit测试类

import com.stack.bean.User;
import com.stack.mapper.UserMapper;
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;

/**
 * create by stack on 2020/10/3
 */
public class MybatisCrudTest {

    public SqlSession sqlSession;

    public InputStream resourceAsStream;

    public UserMapper userMapper;

    @Before
    public void init() throws IOException {
        // 获取配置文件的输入流
        resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

        //创建 sqlSessionFactoryBuilder 构建器 (构件者设计模式)
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder();

        //构建 sqlSessionFactory 工厂 （工厂设计模式）
        SqlSessionFactory factory=sqlSessionFactoryBuilder.build(resourceAsStream);

        //构建 sqlSession对象
        sqlSession = factory.openSession();

        //通过反射机制+基于接口 proxy 的动态代理构建 代理类
        userMapper= sqlSession.getMapper(UserMapper.class);

    }

     @Test
     public void findAllUser(){
         List<User> allUser = userMapper.findAllUser();
         for (User user : allUser) {
             System.out.println(user);
         }
     }

     @Test
    public void findUserById(){
         User userById = userMapper.findUserById(1);
         System.out.println(userById);
     }

    @Test
    public void insertUser(){
        int flag = userMapper.insertUser(new User(0,"李斌", 1, 58));
        System.out.println(flag);
    }

    @Test
    public void updateUser(){
        int flag=userMapper.updateUser(new User(2,"李斌",1,20));
        System.out.println(flag);
    }

    @Test
    public void deleteUser(){
        int flag= userMapper.deleteUser(2);
        System.out.println(flag);
    }

    @Test
    public void findUserByAge(){
        User userByAge = userMapper.findUserByAge(20);
        System.out.println(userByAge);
    }
    
    @Test
    public void findUserByName(){
        List<User> userByName = userMapper.findUserByName("%林%");
        for (User user : userByName) {
            System.out.println(user);
        }
    }
    
    @Test
    public void findUserByName(){
        List<User> userByName = userMapper.findUserByName("林");
        for (User user : userByName) {
            System.out.println(user);
        }
    }

    @After
    public void destroy() throws IOException {
        // mybatis 默认不会自动进行事务提交
        sqlSession.commit();

        // 资源的释放
        sqlSession.close();
        resourceAsStream.close();
    }
}

基本的CRUD中的注意点（模糊查询中使用 #{} 和 ${} 之间的区别）

#{}可以实现preparedstatement向占位符中设置值，可以自动进行 Java 类型和 jdbc 类型转换，#{}相当于占位符的效果可以有效防止 sql 注入的问题。#{} 可以接收简单类型的值或实体类型的属性值。通过 pareameteType来进行设置。

${}可以实现将parameterTyper传入的内容进行拼接，不会进行jdbc类性于java 类型的转换，可以接收简单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，括号中只能是 value。

mybatis框架使用流程图