一、mybatis入门案例

今天学习了mybatis框架，简单记录一下mybatis第一个入门案例，目标是使用Mybatis作为持久层框架，执行查询数据的SQL语句并且获取结果集

基本步骤：

物理建模
逻辑建模
引入依赖
创建持久层接口
加入日志框架
全局文件配置
映射文件配置
测试程序

1. 物理建模

创建数据库mybatis-example，表t_emp，添加一行数据。

CREATE DATABASE `mybatis-example`;

USE `mybatis-example`;

CREATE TABLE `t_emp`(

emp_id INT AUTO_INCREMENT,

emp_name CHAR(100),

emp_salary DOUBLE(10,5),

PRIMARY KEY(emp_id)

);

INSERT INTO `t_emp`(emp_name,emp_salary) VALUES("tom",200.33);

2. 逻辑建模

创建pojo包下的实体类Employee,并引入lombok依赖,添加注解。

@Data

@NoArgsConstructor

@AllArgsConstructor

public class Employee {

    private Integer empId;

    private String empName;

    private Double empSalary;

}

lombok的使用

第一步，安装插件，在settings的Plugins中的Marketplace里面搜索Lombok小辣椒点击下载安装

第二步，引入依赖，在pom.xml文件中引入

<dependency>

    <groupId>org.projectlombok</groupId>

    <artifactId>lombok</artifactId>

    <version>1.18.8</version>

    <scope>provided</scope>

</dependency>

3. 引入依赖

逻辑建模时已经引入了lombok依赖，但在这个案例中还需要引入以下依赖

  <!-- Mybatis核心 -->

    <dependency>

        <groupId>org.mybatis</groupId>

        <artifactId>mybatis</artifactId>

        <version>3.5.7</version>

    </dependency>

    <!-- junit测试 -->

    <dependency>

        <groupId>junit</groupId>

        <artifactId>junit</artifactId>

        <version>4.12</version>

        <scope>test</scope>

    </dependency>

    <!-- MySQL驱动 -->

    <dependency>

        <groupId>mysql</groupId>

        <artifactId>mysql-connector-java</artifactId>

        <version>5.1.3</version>

    </dependency>

4. 创建持久层接口

持久层接口就是我们之前的Dao接口，但我们在使用Mybatis框架的时候习惯给它们命名为Mapper接口。因为持久层是和数据库连接的，因此我们可以解释为什么要引入mysql依赖。

package Mapper;

import pojo.Employee;

public interface EmployeeMapper {

    /*增加*/

    void insertEmployee(Employee employee);

    /*刪除*/

    void deleteEmployee(Integer empId);

    /*根据id修改名字*/

    void updateEmployee(Integer empId,String empName);

    /*查找*/

    Employee selectEmployee(Integer id);

}

以上是实行增删改查方法，注意我们创建的是接口，不用实现类，解决了持久层代码的冗余和耦合问题。

5. 加入日志框架

因为Mybatis中内置使用log4j进行日志打印，所以我们要想观察到Mybatis框架内部的日志，就必须引入log4j的依赖，并且提供log4j的配置文件

5.1 log4j的依赖

在pom.xml引入log4j依赖

<!-- log4j日志 -->

<dependency>

    <groupId>log4j</groupId>

    <artifactId>log4j</artifactId>

    <version>1.2.17</version>

</dependency>

5.2 log4j的配置文件

第一种，xml配置，在类路径下，也就是resources下创建log4j.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

    <!--

        定义一个日志输出器:

        name表示给当前的日志输出器取一个名字

        ConsoleAppender就是一个控制台日志输出器

    -->

    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">

        <!--输出日志时候的编码-->

        <param name="Encoding" value="UTF-8" />

        <!--

            规定日志输出的格式

        -->

        <layout class="org.apache.log4j.PatternLayout">

            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" />

        </layout>

    </appender>

    <!--

        哪个包下输出哪种级别的日志

        日志的级别: debug  info  warning error

    -->

    <logger name="java.sql">

        <level value="debug" />

    </logger>

    <logger name="org.apache.ibatis">

        <level value="info" />

    </logger>

    <root>

        <level value="debug" />

        <appender-ref ref="STDOUT" />

    </root>

</log4j:configuration>

第二种，properties配置，在类路径下，也就是resources下创建log4j.properties

# 输出的日志级别

log4j.rootLogger=DEBUG,stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

#[%-5p] %t %l %d %rms:%m%n

#%d{yyyy-MM-dd HH:mm:ss,SSS\} %-5p [%t] {%c}-%m%n

log4j.appender.stdout.layout.ConversionPattern=[%-5p] %t %l %d %rms:%m%n

log4j.appender.file=org.apache.log4j.FileAppender

log4j.appender.file.File=D:\\idea_project\\mybatis.log

log4j.appender.file.layout=org.apache.log4j.PatternLayout

log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS\} %-5p [%t] {%c}-%m%n

日志的概述

1. 日志的级别

ATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)，从左到右打印的内容越来越详细

2. STDOUT

是standard output的缩写，意思是标准输出。对于Java程序来说，打印到标准输出就是打印到控制台。

6. 全局配置文件

在类路径下，即resources，建立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="dev">

        <environment id="dev">

            <transactionManager type="JDBC"></transactionManager>

            <dataSource type="POOLED">

                <!--

               dataSource:数据源

                   1. POOLED 表示使用内置连接池

                   2. UNPOOLED 表示不使用连接池

                   3. JNDI

           -->

                <property name="username" value="root"></property>

                <property name="password" value="888888"></property>

                <property name="driver" value="com.mysql.jdbc.Driver"></property>

                <property name="url" value="jdbc:mysql://localhost:3306/mybatis-example"></property>

            </dataSource>

        </environment>

    </environments>

    <mappers>

        <!--resource=映射路径-->

        <mapper resource="mappers/EmployeeMapper.xml"/>

    </mappers>

</configuration>

7. 映射配置文件

一个映射配置文件对应一个Mapper接口，映射配置文件中的一个子标签对应Mapper接口中的一个方法。在resources 路径下键一个文件夹mappers,在mappers下创建映射配置文件。

要求:

名称空间要和对应的Mapper接口的全限定名保持一致
Mapper接口中的增、删、改、查方法分别对应映射配置文件中的insert、delete、update、select标签
1. 标签的id对应方法的名字
2. 标签的parameterType属性对应方法的参数类型
3. 标签的resultType属性(只有select标签有)对应方法的返回值类型

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

 <!--

        获取用户的输入信息的方式有两种:

            1. #{}  使用"?"占位符，预编译设置参数

            2. ${}  直接将用户的输入信息拼接到SQL语句

        结论: 我们绝大多数情况下必然会选择使用#{}

    -->

<mapper namespace="Mapper.EmployeeMapper">

    <insert id="insertEmployee">

        insert into t_emp (emp_name,emp_salary) values (#{empName},#{empSalary})

    </insert>

    <delete id="deleteEmployee">

        delete from t_emp where emp_id=#{empId}

    </delete>

    <update id="updateEmployee">

        update t_emp set emp_name=#{param2} where emp_id=#{param1}

    </update>

    <select id="selectEmployee" resultType="pojo.Employee">

        select emp_id empId, emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}

    </select>

</mapper>

补充数据输入和输出

7.1. 输入

7.1.1 获取输入信息的方式

#{} (推荐）

Mybatis会在运行过程中，把配置文件中的SQL语句里面的 #{} 转换为“ ? ”占位符，发送给数据库执行。

映射文件的配置：

<delete id="deleteEmployee">

    delete from t_emp where emp_id=#{empId}

</delete>

实际sql语句：

delete from t_emp where emp_id=？

${} (不推荐，会有sql注入问题)

Mybatis会在运行过程中，将来会根据${}拼字符串

7.2. 输出

只有select标签有输出，我们目前是使用resultType属性来指定输出的类型。详细的在另一篇提到：数据输出

<select id="selectEmployee" resultType="pojo.Employee">

    select emp_id empId, emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}

</select>

8. 测试程序

目的为了获取Mapper接口的代理对象，并且调用方法执行SQL语句，之后用spring框架，（以下代码就可以不写了）

import Mapper.EmployeeMapper;

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 pojo.Employee;

import java.io.InputStream;

public class Test {

    private EmployeeMapper employeeMapper;

    private InputStream is;

    private SqlSession sqlSession;

    @Before

    public void init() throws Exception{

        //目标:获取EmployeeMapper接口的代理对象，并且使用该对象调用selectEmployee(1)方法,然后返回Employee对象

        //1. 将全局配置文件转成字节输入流

        is = Resources.getResourceAsStream("mybatis-config.xml");

        //2. 创建SqlSessionFactoryBuilder对象

        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        //3. 使用构建者模式创建SqlSessionFactory对象

        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);

        //4. 使用工厂模式创建一个SqlSession对象

        sqlSession = sqlSessionFactory.openSession();

        //5. 使用动态代理模式，创建EmployeeMapper接口的代理对象

        employeeMapper = sqlSession.getMapper(EmployeeMapper.class);

    }

    @org.junit.Test

    public void testInsertEmployee(){

        Employee employee = new Employee(null, "Amy", 500d);

        //调用employeeMapper对象的insertEmployee()方法

        employeeMapper.insertEmployee(employee);

    }

    @After

    public void after() throws Exception{

        //提交事务!!!

        sqlSession.commit();

        //7. 关闭资源

        is.close();

        sqlSession.close();

    }

    @org.junit.Test

    public void testDeleteEmployee(){

        employeeMapper.deleteEmployee(2);

    }

    @org.junit.Test

    public void testUpdateEmployee(){

        employeeMapper.updateEmployee(3,"Salar");

    }

    @org.junit.Test

    public void testSelectEmployee(){

        Employee employee=employeeMapper.selectEmployee(1);

        System.out.println(employee);

    }

}

以上就是mybatis第一个入门案例的步骤