MyBatis基础及配置

### 1.1. 作用

简化数据库编程。

当使用了MyBatis后，只需要指定操作数据的接口及抽象方法，例如添加`void insert(User user)`，然后，配置这个方法对应的SQL语句，即可，无须编写该接口的实现类，更不需要通过JDBC等技术重写该抽象方法。

### 1.2. 开发步骤

#### 1.2.1. 创建项目

创建Maven Project，Group Id为`cn.edu.siso.mybatis`，Artifact Id为`MYBATIS-01-SAMPLE`，Packaging选择`war`，后续步骤与前序项目一致。

**前序项目中的依赖、web.xml的配置、Spring的配置、Tomcat运行环境，对于单一使用MyBatis而言，都是可以不需要的。**

#### 1.2.2. 添加MyBatis的依赖

关于MyBatis的依赖：

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.6</version>
    </dependency>

MyBatis框架是可以独立使用的，但是，配置方式相对比较麻烦，通常会结合Spring一起使用，所以，还需要添加MyBatis与Spring整合使用的依赖：

    <!-- MyBatis整合Spring -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.2</version>
    </dependency>

由于MyBatis底层通过JDBC技术来实现，整合了Spring之后，还需要Spring-JDBC的支持，所以，添加：

    <!-- Spring-JDBC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>3.2.8.RELEASE</version>
    </dependency>

**注意：在同一个项目中使用的所有以 spring- 作为前缀的依赖，应该使用相同的版本！**

#### 1.2.3. 设定目标

使用编写好的的数据库与数据表，向`t_user`表中插入1条数据。

例：

1. 创建数据库`siso_ums`

    ```
    CREATE DATABASE siso_ums;
    ```

2. 在数据库中创建数据表`t_user`，并在其中添加`username`、`password`、`phone`、`email`、`birthday`字段，使用自动递增的`id`作为主键

    ```
    CREATE TABLE t_user (
        id INT AUTO_INCREMENT,
        username VARCHAR(16) UNIQUE NOT NULL,
        password VARCHAR(16) NOT NULL,
        phone VARCHAR(20),
        email VARCHAR(32),
        birthday DATETIME,
        PRIMARY KEY(id)
    ) DEFAULT CHARSET=UTF8;
    ```

3. 添加不少于5条数据，要求支持中文

    ```
    INSERT INTO t_user (
        username, email, password, phone
    ) VALUES 
    ('root', 'root@siso.cn', '123456', '13800138002'),
    ('java', 'java@siso.cn', '123456', '13800138003'),
    ('spring', 'spring@siso.cn', '123456', '13800138004'),
    ('mysql', 'mysql@siso.cn', '123456', '13800138005'),
    ('mybatis', 'mybatis@siso.cn', '123456', '13800138006');
    ```

4. 查询所有数据

    ```
    SELECT 
        id, username, password, phone, email, birthday 
    FROM 
        t_user;
    ```

5. 查询指定用户名的数据

    ```
    SELECT 
        id, username, password, phone, email, birthday 
    FROM 
        t_user
    WHERE 
        username='admin';
    ```

6. 统计数据的数量

    ```
    SELECT 
        COUNT(id) 
    FROM 
        t_user;
    ```

7. 删除指定id的数据

    ```
    DELETE FROM t_user WHERE id=1;
    ```

8. 修改指定id的数据的`password`

    ```
    UPDATE t_user SET password='newpassword' WHERE id=1;

#### 1.2.4. 创建接口并设计抽象方法

由于需要操作的是用户数据，则应该创建与数据表完全匹配的实体类，即创建`cn.siso.mybatis.entity.User`类，类中的属性与数据表保持一致。

创建`cn.siso.mybatis.mapper.UserMapper`接口，并在接口中添加抽象方法：

    Integer reg(User user);

由于MyBatis框架在执行INSERT、DELETE、UPDATE语句时，默认返回受影响的行数，所以，在设计抽象方法时，只要对应的SQL语句是增、删、改，方法的返回值就设计为Integer，且值的意义一定是受影响的行数！

#### 1.2.5. 配置抽象方法对应的SQL语句

在`src\main\resources`下创建`mappers`文件夹（因为一个完整的项目中，可能需要多个关于MyBatis配置SQL语句的文件，为了便于管理，所以创建专门的文件夹），创建xml文件`UserMapper.xml`到刚才的`mappers`文件夹下。

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

 

关于`UserMapper.xml`文件，一般称之为配置映射的文件，根节点是`<mapper>`，必须配置`namespace`属性，取值为该XML文件匹配的JAVA接口文件的名称：

    <!-- namespace：与当前XML文件对应的Java接口 -->
    <mapper namespace="cn.siso.mybatis.mapper.UserMapper">
    
   

关于数据操作，在`<mapper>`节点中，根据操作类型，可以选择`<insert>`、`<delete>`、`<update>`、`<select>`，此次，应该选择`<insert>`节点，该节点的`id`属性值是对应的抽象方法的名称，然后，手动添加`parameterType`属性，用于配置方法的参数类型，取值则是`User`的全名：

    <!-- id：该节点对应的抽象方法的名称 -->
    <!-- parameterType：对应的抽象方法的参数的数据类型 -->
    <insert id="reg"
        parameterType="cn.siso.mybatis.entity.User">
    </insert>

然后，将需要执行的SQL语句写在节点内部，值部分使用`#{}`且内部是参数`User`类的属性名称即可：

    <insert id="reg"
        parameterType="cn.siso.mybatis.entity.User">
        INSERT INTO t_user (
            username, email, 
            password, phone, birthday
        ) VALUES (
            #{username}, #{email}, 
            #{password}, #{phone}, #{birthday}
        )
    </insert>

#### 1.2.6. 相关配置

首先，需要配置数据库连接相关参数，即：在`src\main\resources`下创建`db.properties`文件：

    url=jdbc:mysql://localhost:3306/siso_ums?useUnicode=true&characterEncoding=utf8
    driver=com.mysql.jdbc.Driver
    username=root
    password=root
    initialSize=5
    maxActive=50

由于需要使用到MySQL的连接jar包与数据库连接池的dbcp包，所以，还应该添加依赖：

    <!-- MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <!-- DBCP -->
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>

 

Spring-mvc,xml内容：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
</beans>

 

接下来，需要通过Spring读取以上`db.properties`文件，将其配置的值应用于数据库的连接数据源（`BasicDataSource`），由于这些配置都是和持久层操作相关的，所以，复制`spring-mvc.xml`文件（文件内容已在上面提供），并粘贴为`spring-dao.xml`，在新的`spring-dao.xml`中删除原有配置，并添加新的配置：

    <!-- 读取db.properties -->
    <util:properties id="dbConfig"
        location="classpath:db.properties" />
        
    <!-- 配置数据源：BasicDataSource -->
    <bean id="dataSource" 
        class="org.apache.commons.dbcp.BasicDataSource">
        <!-- 以下配置中 -->
        <!-- name的值是BasicDataSource中的属性名(方法名) -->
        <!-- value的值是引用以上读取的配置文件 -->
        <property name="url" 
            value="#{dbConfig.url}" />
        <property name="driverClassName" 
            value="#{dbConfig.driver}" />
        <property name="username" 
            value="#{dbConfig.username}" />
        <property name="password" 
            value="#{dbConfig.password}" />
        <property name="initialSize" 
            value="#{dbConfig.initialSize}" />
        <property name="maxActive" 
            value="#{dbConfig.maxActive}" />
    </bean>

可以创建测试类，来检验以上配置是否正确：

    public class TestDataSource {
    
        public static void main(String[] args) 
                throws SQLException {
            // 加载Spring配置，获取Spring容器
            AbstractApplicationContext ac
                = new ClassPathXmlApplicationContext(
                    "spring-dao.xml");
            
            // 从Spring容器中获取对象
            BasicDataSource ds 
                = ac.getBean("dataSource", 
                        BasicDataSource.class);
            
            // 测试
            java.sql.Connection conn = ds.getConnection();
            System.out.println(conn);
    
            // 释放资源
            ac.close();
        }
    
    }

由于MyBatis相关的配置已经交给Spring进行管理，后续，在运行时，还需要使得整个环境知道：所使用的数据源、MyBatis的接口文件的位置、MyBatis的映射文件的位置，则继续在`spring-dao.xml`添加配置：

    <!-- 配置MapperScannerConfigurer -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 配置接口文件所在的包 -->
        <property name="basePackage"
            value="cn.siso.mybatis.mapper" />
    </bean>
    
    <!-- 配置SqlSessionFactoryBean -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 配置使用哪个数据源，ref属性的值是前序配置的数据源的bean id -->
        <property name="dataSource" 
            ref="dataSource" />
        <!-- 配置XML映射文件的位置 -->
        <property name="mapperLocations"
            value="classpath:mappers/*.xml" />
    </bean>

至此，配置已经全部结束！

#### 1.2.7. 执行单元测试

在`src\test\java`下创建`TestUserMapper`类，编写测试方法：

    @Test
    public void reg() {
        // 加载Spring的配置文件，获取Spring容器
        AbstractApplicationContext ac
            = new ClassPathXmlApplicationContext(
                "spring-dao.xml");
        
        // 获取所需的对象：MyBatis接口的对象
        UserMapper userMapper 
            = ac.getBean("userMapper", UserMapper.class);
        
        // 测试执行
        User user = new User();
        user.setUsername("html");
        user.setPassword("888888");
        Integer rows = userMapper.reg(user);
        System.out.println("rows=" + rows);
        
        // 释放资源
        ac.close();
    }

**之所以将测试类放在这个位置，是因为最终部署项目时，在test下的内容将不会被部署！不影响项目的实际开发！**

### 1.3. 通过MyBatis执行查询所有数据

#### 1.3.1. 设定目标

查询出当前`t_user`表中所有的数据

#### 1.3.2. 设计抽象方法

在`UserMapper.java`接口添加新的抽象方法：

    List<User> getList();

#### 1.3.3. 配置映射SQL 

在`UserMapper.xml`文件中添加配置：

    <select id="getList"
        resultType="cn.siso.mybatis.entity.User">
        SELECT 
            id, username, password, phone, email, birthday
        FROM
            t_user
    </select>

**在MyBatis中，执行的查询，必须在`<select>`节点上配置`resultType`属性！（也可以配置`resultMap`，二选一）**

**在MyBatis中，所有的查询默认返回`List`集合，所以，在指定`resultType`时，取值为`List`集合中存放的数据类型！**

### 1.4. 通过MyBatis指定条件查询

#### 1.4.1. 设定目标

根据用户名，查询某个用户的信息

#### 1.4.2. 设计抽象方法

在`UserMapper.java`接口添加新的抽象方法：

    User getUserByUsername(String username);

**在查询时，如果查询的结果定义为某种具体的数据类型，而不是List集合，则MyBatis会对查询到的List集合做进一步的处理（MyBatis的查询结果一定是List集合），尝试取出List集合中的第1个数据，如果集合中没有数据，则返回null。**

#### 1.4.3. 配置映射SQL 

在`UserMapper.xml`文件中添加配置：

    <select id="getUserByUsername"
        resultType="cn.siso.mybatis.entity.User">
        SELECT 
            id, username, password, phone, email, birthday
        FROM
            t_user
        WHERE
            username=#{username}
    </select>

**如果查询的SQL映射对应的方法只有1个参数，则不需要配置`parameterType`属性！**

### 1.5. 统计数据的数量

#### 1.5.1. 设定目标

统计当前`t_user`表中数据的数量

#### 1.5.2. 设计抽象方法

在`UserMapper.java`接口添加新的抽象方法：

    Integer getCount();

#### 1.5.3. 配置映射SQL 

在`UserMapper.xml`文件中添加配置：

    <select id="getCount" resultType="java.lang.Integer">
        SELECT COUNT(id) FROM t_user
    </select>

**即使查询结果是`Integer`这种非常常见的数据类型，也必须配置`resultType`！**

### 1.6. 删除指定id的数据

#### 1.6.1. 设定目标

根据`id`删除`t_user`表中对应的数据

#### 1.6.2. 设计抽象方法

在`UserMapper.java`接口添加新的抽象方法：

    Integer deleteUserById(Integer id);

#### 1.6.3. 配置映射SQL 

在`UserMapper.xml`文件中添加配置：

    <delete id="deleteUserById">
        DELETE FROM t_user WHERE id=#{id}
    </delete>

### 1.7. 修改指定id的数据的password

#### 1.7.1. 设定目标

修改密码

#### 1.7.2. 设计抽象方法

在`UserMapper.java`接口添加新的抽象方法：

    Integer changePassword(
            @Param("id") Integer id, 
            @Param("password") String password);

**在使用MyBatis处理持久层的数据操作时（无论是增、删、改、查中的哪一种），只要方法的参数超过1个（2个或更多），则每个参数之前必须使用`@Param()`注解，并且，在注解中定义参数的名称，后续，在配置SQL语句时，使用`#{}`语法时填写的名称也就是此时注解中使用的名称！**

#### 1.7.3. 配置映射SQL 

在`UserMapper.xml`文件中添加配置：

    <update id="changePassword">
        UPDATE 
            t_user 
        SET 
            password=#{password}
        WHERE 
            id=#{id}
    </update>

 

### 1.8. MyBatis基本使用的小结

- MyBatis的作用：简化持久层开发，无须编写JDBC相关代码；

- 每个功能都需要有抽象方法，及匹配的SQL映射；

- 如果抽象方法的参数超过1个，必须使用`@Param`注解；

- 如果执行增、删、改，抽象方法的返回值可以是`Integer`，表示受影响的行数，当然，如果不关心这个返回值，也可以将返回值设计为`void`；

- 如果执行查询操作，抽象方法的返回值可以是`List`或匹配的实体类的类型，甚至是其它例如`Integer`类型，可根据需要自行设计；其实，每次查询返回的都是`List`，只不过，如果设计的返回值是实体类的类型，则MyBatis会尝试从`List`中取出第1个数据，如果取出失败，则返回`null`；

- 配置SQL映射时，应该根据执行的SQL语句的种类来选择节点；

- 每个节点上都必须配置`id`属性，表示匹配的抽象方法的名称；

- 所有`<select>`节点必须配置`resultType`；