Mybatis-mapper-xml-基础

小鱼儿 2022-07-16 07:41 248阅读 0赞

今天学习http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html。关于mapper.xml的sql语句的使用。

项目路径：https://github.com/chenxing12/l4mybatis

1.  创建项目
2.  select
3.  insert
4.  update
5.  delete
6.  insert\\update\\delete参数说明
7.  sql代码段
8.  参数
9.  高级查询
    
    1.  id&reulst
    2.  构造方法
    3.  关联查询

首先，准备环境。

# 1.创建project #

在parent项目上右键，new model->maven->mybatis-mapper.

**填充pom.xml**

<?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">
        <parent>
            <artifactId>l4mybatis</artifactId>
            <groupId>com.test</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>mytatis-mapper</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <resources>
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>true</filtering>
                </resource>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.properties</include>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>true</filtering>
                </resource>
            </resources>
        </build>
    
    
    </project>

**在resources下添加log4j.properties:**

log4j.rootLogger=DEBUG, stdout, logfile
    
    
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
    
    log4j.appender.logfile=org.apache.log4j.RollingFileAppender
    log4j.appender.logfile.File=log/test.log
    log4j.appender.logfile.MaxFileSize=128MB
    log4j.appender.logfile.MaxBackupIndex=3
    log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
    log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p [%t] %c.%M(%L) - %m%n

**在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>
        <properties resource="db.properties"/>
    
        <typeAliases>
            <package name="com.test.mapper.model"/>
        </typeAliases>
    
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
        <mappers>
            <mapper resource="com.test.mapper.mapper/PersonMapper.xml"/>
        </mappers>
    </configuration>

**在resources下添加db.properties:**

#jdbc.driver=com.mysql.jdbc.Driver
    jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai&useSSL=false
    jdbc.username=root
    jdbc.password=123456

**在数据库mybatis中创建一个person表：**

/*
    Navicat MySQL Data Transfer
    
    Source Server         : localhost
    Source Server Version : 50605
    Source Host           : localhost:3306
    Source Database       : mybatis
    
    Target Server Type    : MYSQL
    Target Server Version : 50605
    File Encoding         : 65001
    
    Date: 2016-07-06 22:22:34
    */
    
    SET FOREIGN_KEY_CHECKS=0;
    
    -- ----------------------------
    -- Table structure for person
    -- ----------------------------
    DROP TABLE IF EXISTS `person`;
    CREATE TABLE `person` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of person
    -- ----------------------------
    INSERT INTO `person` VALUES ('1', 'Ryan');

**在resources下创建com.test.mapper.mapper/PersonMapper.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.test.mapper.dao.PersonMapper">
        <select id="selectPerson" parameterType="int" resultType="hashmap">
            select * from person where id = #{id}
        </select>
    
    </mapper>

**在java下新建com.test.mapper.dao.PersonMapper.java:**

package com.test.mapper.dao;
    
    import java.util.HashMap;
    
    /**
     * Created by miaorf on 2016/7/6.
     */
    public interface PersonMapper {
    
        HashMap selectPerson(int id);
    }

**在java下添加：com.test.mapper.model.Person:**

package com.test.mapper.model;
    
    import java.io.Serializable;
    
    /**
     * Created by miaorf on 2016/7/6.
     */
    public class Person implements Serializable {
    
        private Integer id;
        private String name;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

## 测试环境： ##

在test下创建com.test.mapper.dao.PersonMapperTest:

package com.test.mapper.dao;
    
    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.Before;
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.util.HashMap;
    
    import static org.junit.Assert.*;
    
    /**
     * Created by miaorf on 2016/7/6.
     */
    public class PersonMapperTest {
        private SqlSession sqlSession;
        private static SqlSessionFactory sqlSessionFactory;
    
        @BeforeClass
        public static void init() throws IOException {
            String config = "mybatis-config.xml";
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(config));
        }
    
        @Before
        public void setUp() throws Exception {
            sqlSession = sqlSessionFactory.openSession();
        }
    
        @Test
        public void selectPerson() throws Exception {
            PersonMapper mapper = sqlSession.getMapper(PersonMapper.class);
            HashMap map = mapper.selectPerson(1);
            System.out.println(map);
        }
    
    }

**运行：**

2016-07-06 22:23:31,962 DEBUG [org.apache.ibatis.logging.LogFactory] - Logging initialized using 'class org.apache.ibatis.logging.slf4j.Slf4jImpl' adapter.
    2016-07-06 22:23:32,128 DEBUG [org.apache.ibatis.io.VFS] - Class not found: org.jboss.vfs.VFS
    2016-07-06 22:23:32,129 DEBUG [org.apache.ibatis.io.JBoss6VFS] - JBoss 6 VFS API is not available in this environment.
    2016-07-06 22:23:32,131 DEBUG [org.apache.ibatis.io.VFS] - Class not found: org.jboss.vfs.VirtualFile
    2016-07-06 22:23:32,132 DEBUG [org.apache.ibatis.io.VFS] - VFS implementation org.apache.ibatis.io.JBoss6VFS is not valid in this environment.
    2016-07-06 22:23:32,134 DEBUG [org.apache.ibatis.io.VFS] - Using VFS adapter org.apache.ibatis.io.DefaultVFS
    2016-07-06 22:23:32,135 DEBUG [org.apache.ibatis.io.DefaultVFS] - Find JAR URL: file:/D:/workspace/mybatis/l4mybatis/mytatis-mapper/target/classes/com/test/mapper/model
    2016-07-06 22:23:32,135 DEBUG [org.apache.ibatis.io.DefaultVFS] - Not a JAR: file:/D:/workspace/mybatis/l4mybatis/mytatis-mapper/target/classes/com/test/mapper/model
    2016-07-06 22:23:32,213 DEBUG [org.apache.ibatis.io.DefaultVFS] - Reader entry: Person.class
    2016-07-06 22:23:32,214 DEBUG [org.apache.ibatis.io.DefaultVFS] - Listing file:/D:/workspace/mybatis/l4mybatis/mytatis-mapper/target/classes/com/test/mapper/model
    2016-07-06 22:23:32,214 DEBUG [org.apache.ibatis.io.DefaultVFS] - Find JAR URL: file:/D:/workspace/mybatis/l4mybatis/mytatis-mapper/target/classes/com/test/mapper/model/Person.class
    2016-07-06 22:23:32,215 DEBUG [org.apache.ibatis.io.DefaultVFS] - Not a JAR: file:/D:/workspace/mybatis/l4mybatis/mytatis-mapper/target/classes/com/test/mapper/model/Person.class
    2016-07-06 22:23:32,217 DEBUG [org.apache.ibatis.io.DefaultVFS] - Reader entry: ����   1 6
    2016-07-06 22:23:32,220 DEBUG [org.apache.ibatis.io.ResolverUtil] - Checking to see if class com.test.mapper.model.Person matches criteria [is assignable to Object]
    2016-07-06 22:23:32,306 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - PooledDataSource forcefully closed/removed all connections.
    2016-07-06 22:23:32,307 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - PooledDataSource forcefully closed/removed all connections.
    2016-07-06 22:23:32,309 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - PooledDataSource forcefully closed/removed all connections.
    2016-07-06 22:23:32,310 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - PooledDataSource forcefully closed/removed all connections.
    2016-07-06 22:23:32,511 DEBUG [org.apache.ibatis.transaction.jdbc.JdbcTransaction] - Opening JDBC Connection
    2016-07-06 22:23:32,842 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - Created connection 733672688.
    2016-07-06 22:23:32,842 DEBUG [org.apache.ibatis.transaction.jdbc.JdbcTransaction] - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2bbaf4f0]
    2016-07-06 22:23:32,847 DEBUG [com.test.mapper.dao.PersonMapper.selectPerson] - ==>  Preparing: select * from person where id = ? 
    2016-07-06 22:23:32,911 DEBUG [com.test.mapper.dao.PersonMapper.selectPerson] - ==> Parameters: 1(Integer)
    2016-07-06 22:23:32,946 DEBUG [com.test.mapper.dao.PersonMapper.selectPerson] - <==      Total: 1
    {name=Ryan, id=1}

# **2.select** #

查询语句。负责拼接查询语句并将查询结果映射出来。上例中：

<select id="selectPerson" parameterType="int" resultType="hashmap">
      SELECT * FROM PERSON WHERE ID = #{id}
    </select>

*  这个语句的id为selectPerson,这个就是对应mapper接口中的方法的名字。
 *  parameterType是输入参数类型为int。
 *  resultType表示查询结果映射为HashMap
 *  \#\{id\}是占位符，相当于JDBC中采用PreparedStatement时sql语句中的问号，表示参数名为id的参数值会替换这个位置。

注意到mapper.xml的namespace就是指向所对应的mapper 接口：

在mapper接口中的方法要和mapper.xml中的id所一一对应。因此，这个查询的节点对应的mapper接口的方法为：

public interface PersonMapper {
    
        HashMap selectPerson(int id);
    }

事实上，select节点的可选参数有以下几种：

文档对各个参数含义给出了解释：

<table>  Select Attributes  
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>id</td> 
   <td>在命名空间中唯一的标识符，可以被用来引用这条语句。</td> 
  </tr> 
  <tr> 
   <td>parameterType</td> 
   <td>将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。</td> 
  </tr> 
  <tr> 
   <td>parameterMap</td> 
   <td>这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数映射和 parameterType 属性。</td> 
  </tr> 
  <tr> 
   <td>resultType</td> 
   <td>从这条语句中返回的期望类型的类的完全限定名或别名。注意如果是集合情形，那应该是集合可以包含的类型，而不能是集合本身。使用 resultType 或 resultMap，但不能同时使用。</td> 
  </tr> 
  <tr> 
   <td>resultMap</td> 
   <td>外部 resultMap 的命名引用。结果集的映射是 MyBatis 最强大的特性，对其有一个很好的理解的话，许多复杂映射的情形都能迎刃而解。使用 resultMap 或 resultType，但不能同时使用。</td> 
  </tr> 
  <tr> 
   <td>flushCache</td> 
   <td>将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：false。</td> 
  </tr> 
  <tr> 
   <td>useCache</td> 
   <td>将其设置为 true，将会导致本条语句的结果被二级缓存，默认值：对 select 元素为 true。</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td>这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。</td> 
  </tr> 
  <tr> 
   <td>fetchSize</td> 
   <td>这是尝试影响驱动程序每次批量返回的结果行数和这个设置值相等。默认值为 unset（依赖驱动）。</td> 
  </tr> 
  <tr> 
   <td>statementType</td> 
   <td>STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。</td> 
  </tr> 
  <tr> 
   <td>resultSetType</td> 
   <td>FORWARD_ONLY，SCROLL_SENSITIVE 或 SCROLL_INSENSITIVE 中的一个，默认值为 unset （依赖驱动）。</td> 
  </tr> 
  <tr> 
   <td>databaseId</td> 
   <td>如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。</td> 
  </tr> 
  <tr> 
   <td>resultOrdered</td> 
   <td>这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。</td> 
  </tr> 
  <tr> 
   <td>resultSets</td> 
   <td>这个设置仅对多结果集的情况适用，它将列出语句执行后返回的结果集并每个结果集给一个名称，名称是逗号分隔的。　　</td> 
  </tr> 
 </tbody> 
</table>

# 3.Insert #

**首先，准备数据库：**

CREATE TABLE `author` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(40) NOT NULL DEFAULT '',
      `password` varchar(128) NOT NULL DEFAULT '',
      `email` varchar(40) NOT NULL DEFAULT '',
      `bio` varchar(255) NOT NULL DEFAULT '',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

**然后，编写对应实体：com.test.mapper.model.Author**

package com.test.mapper.model;
    
    import java.io.Serializable;
    
    /**
     * Created by miaorf on 2016/7/7.
     */
    public class Author implements Serializable {
    
        private Integer id;
        private String username;
        private String password;
        private String email;
        private String bio;
    
        public Author() {
        }
    
        public Author(String username, String password, String email, String bio) {
            this.username = username;
            this.password = password;
            this.email = email;
            this.bio = bio;
        }
    
        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;
        }
    
        public String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        public String getBio() {
            return bio;
        }
    
        public void setBio(String bio) {
            this.bio = bio;
        }
    }

**编写mapper接口：com.test.mapper.dao.AuthorMapper**

package com.test.mapper.dao;
    
    import com.test.mapper.model.Author;
    
    import java.util.HashMap;
    import java.util.List;
    
    /**
     * Created by miaorf on 2016/7/6.
     */
    public interface AuthorMapper {
    
        int insertAuthor(Author author);
    
        int insertAuthors(List<Author> list);
    }

**编写mapper.xml:com.test.mapper.mapper/AuthorMapper.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.test.mapper.dao.AuthorMapper">
        <insert id="insertAuthor" useGeneratedKeys="true" keyProperty="id">
            INSERT INTO author(username,password,email,bio)
            VALUES (#{username},#{password},#{email},#{bio})
        </insert>
    
        <insert id="insertAuthors" useGeneratedKeys="true" keyProperty="id">
            INSERT INTO author(username,password,email,bio) VALUES
            <foreach collection="list" item="item" separator=",">
                (#{item.username},#{item.password},#{item.email},#{item.bio})
            </foreach>
        </insert>
    
    
    
    
    
    
    
    
    
    
    
    </mapper>

**编写测试用例：com.test.mapper.dao.AuthorMapperTest**

package com.test.mapper.dao;
    
    import com.test.mapper.model.Author;
    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.Before;
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import static org.junit.Assert.*;
    
    /**
     * Created by miaorf on 2016/7/7.
     */
    public class AuthorMapperTest {
        private SqlSession sqlSession;
        private static SqlSessionFactory sqlSessionFactory;
    
        @BeforeClass
        public static void init() throws IOException {
            String config = "mybatis-config.xml";
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream(config));
        }
    
        @Before
        public void setUp() throws Exception {
            sqlSession = sqlSessionFactory.openSession();
        }
    
        @Test
        public void insertAuthorTest() throws  Exception{
            AuthorMapper mapper = sqlSession.getMapper(AuthorMapper.class);
            Author ryan = new Author("Ryan", "123456", "qweqwe@qq.com", "this is a blog");
            int result = mapper.insertAuthor(ryan);
            sqlSession.commit();
    
            assertNotNull(ryan.getId());
        }
    
        @Test
        public void insertAuthorsTest() throws  Exception{
            AuthorMapper mapper = sqlSession.getMapper(AuthorMapper.class);
            List<Author> list = new ArrayList<Author>();
            for (int i = 0; i < 3; i++) {
                list.add(new Author("Ryan"+i, "123456", "qweqwe@qq.com", "this is a blog"));
            }
    
            int result = mapper.insertAuthors(list);
            sqlSession.commit();
    
            assertNotNull(list.get(2).getId());
        }
    
    }

以上就是一个简单的插入了，数据库为支持主键自增的，比如Mysql。可以返回主键到对应实体中。下面来分析每个参数：

## 3.1 AuthorMapperTest ##

前文讲过mybatis的SqlSessionFactory 的最佳范围是应用范围。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。所以，这个必须是要可以暴露出啦的bean。每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的范围是请求或方法范围。绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。

因此，将SqlSessionFactory设置成静态成员变量，在类初始化的时候就加载。而SqlSession则要在每次请求数据库的时候生成，这里放到Before里是为了复用在多个Test中，如果是在一个dao中，就不可以将SqlSession放到成员变量了，应该为局部变量。

## 3.2 insert 返回值 ##

通过获取mapper接口，然后调用方法来实现sql的执行。insert方法的返回值是整形，对应mysql中执行成功的结果数。插入一条成功则返回1，插入n条成功，则返回n，插入失败，返回0. 当然，失败通常会抛出异常。这个在更新的时候有用，如果不需要更新，则返回0，更新成功n条返回n。

## 3.3 AuthorMapper.xml ##

使用完全限定名来指定对应的mappr接口：

用insert节点来编写插入语句：

<insert id="insertAuthor" useGeneratedKeys="true" keyProperty="id">
            INSERT INTO author(username,password,email,bio)
            VALUES (#{username},#{password},#{email},#{bio})
      </insert>

*  id表示mapper接口的方法名，要一致
 *  useGeneratedKeys="true"表示数据库支持主键自增
 *  keyProperty="id"表示自增字段为id，这个属性和useGeneratedKeys配合使用
 *  发现这里没有指定parameterType，因为mybatis可以通过 TypeHandler 推断出具体传入语句的参数
 *  也没有指定resultType，MyBatis 通常可以推算出来，但是为了更加确定写上也不会有什么问题

到这里是理想插入，但如果其中一个字段是null，而我们设置数据库字段不允许为null，则会抛出异常。也就是说，在执行这条语句前一定要检查各项参数是否满足要求。

@Test(expected = PersistenceException.class)
        public void insertAuthorExceptionTest() throws  Exception{
            AuthorMapper mapper = sqlSession.getMapper(AuthorMapper.class);
            Author ryan = new Author("Ryan", null, "qweqwe@qq.com", "this is a blog");
            int result = mapper.insertAuthor(ryan);
            sqlSession.commit();
    
            assertNotNull(ryan.getId());
        }

# 4.update #

更新前需要先有一个实体，这里先来查询一个出来：

## 4.1添加selectById ##

在com.test.mapper.mapper/AuthorMapper.xml中添加一个select节点：

<select id="selectAuthorById" resultType="author">
            SELECT * FROM author WHERE id = #{id}
    </select>

和insert不同的是，这里必须制定resultType或者resultMap，否则无法映射查询结果。

在com.test.mapper.dao.AuthorMapper中添加对应的方法：

Author selectAuthorById(int id);

添加测试用例：

@Test
        public void selectAuthorByIdTest() throws Exception{
            AuthorMapper mapper = sqlSession.getMapper(AuthorMapper.class);
            Author author = mapper.selectAuthorById(3);
            assertNotNull(author);
        }

## 4.2 添加update节点 ##

AuthorMapper.xml:

<update id="updateAuthor" >
            update Author set
                username = #{username},
                password = #{password},
                email = #{email},
                bio = #{bio}
            where id = #{id}
    </update>

AuthorMapper.java:

int updateAuthor(Author author);

AuthorMapperTest.java:

@Test
        public void TestUpdateAuthorEffective() throws Exception{
            Author author = mapper.selectAuthorById(3);
            author.setBio("I have changed the bio");
            int i = mapper.updateAuthor(author);
            sqlSession.commit();
            assertTrue(i>0);
        }
        @Test
        public void TestUpdateAuthorInEffective() throws Exception{
            Author author = mapper.selectAuthorById(3);
            author.setId(1024);
            int i = mapper.updateAuthor(author);
            sqlSession.commit();
            assertTrue(i==0);
        }

update和insert一样，mybatis自动判断输入和输出。

#  5.delete #

添加delete节点：

<delete id="deleteAuthor">
            delete from Author where id = #{id}
    </delete>

添加delete方法：

int deleteAuthor(int id);

添加delete测试：

@Test
        public void TestDeleteAuthorEffective() throws Exception{
            int i = mapper.deleteAuthor(3);
            assertTrue(i==1);
        }
        @Test
        public void TestDeleteAuthorInEffective() throws Exception{
            int i = mapper.deleteAuthor(3000);
            assertTrue(i==0);
        }

delete节点也不用指定输入和输出，当然也可以指定。

# 6.insert,update,delete参数表 #

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>id</td> 
   <td>命名空间中的唯一标识符，可被用来代表这条语句。</td> 
  </tr> 
  <tr> 
   <td>parameterType</td> 
   <td>将要传入语句的参数的完全限定类名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。</td> 
  </tr> 
  <tr> 
   <td>parameterMap</td> 
   <td>这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数映射和 parameterType 属性。</td> 
  </tr> 
  <tr> 
   <td>flushCache</td> 
   <td>将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：true（对应插入、更新和删除语句）。</td> 
  </tr> 
  <tr> 
   <td>timeout</td> 
   <td>这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。</td> 
  </tr> 
  <tr> 
   <td>statementType</td> 
   <td>STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。</td> 
  </tr> 
  <tr> 
   <td>useGeneratedKeys</td> 
   <td>（仅对 insert 和 update 有用）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系数据库管理系统的自动递增字段），默认值：false。</td> 
  </tr> 
  <tr> 
   <td>keyProperty</td> 
   <td>（仅对 insert 和 update 有用）唯一标记一个属性，MyBatis 会通过 getGeneratedKeys 的返回值或者通过 insert 语句的 selectKey 子元素设置它的键值，默认：unset。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。</td> 
  </tr> 
  <tr> 
   <td>keyColumn</td> 
   <td>（仅对 insert 和 update 有用）通过生成的键值设置表中的列名，这个设置仅在某些数据库（像 PostgreSQL）是必须的，当主键列不是表中的第一列的时候需要设置。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。</td> 
  </tr> 
  <tr> 
   <td>databaseId</td> 
   <td>如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。</td> 
  </tr> 
 </tbody> 
</table>

#  7.SQL代码段 #

为了提高代码重复利用率，mybatis提供了将部分sql片段提炼出来的, 作为公共代码使用。

<sql id="userColumns">
            ${alias}.id,${alias}.username,${alias}.password,${alias}.email,${alias}.bio
    </sql>
    <select id="selectAuthor" resultType="map">
            SELECT 
              <include refid="userColumns"><property name="alias" value="t1"/></include>
            FROM author t1
    </select>

List<Author> selectAuthor();

@Test
        public void TestSelectAuthor() throws Exception{
            List<Author> authors = mapper.selectAuthor();
            assertTrue(authors.size()>0);
        }

# 　8.Parameters(参数) #

前文在insert的时候提到过，输入参数不指定，可以通过对象判断出来。然而遇到复杂的输入参数的时候就需要指定.将要传入语句的参数的完全限定类名或别名.

修改insert节点，增加parameterType:

<insert id="insertAuthor" useGeneratedKeys="true" keyProperty="id" parameterType="author">
            INSERT INTO author(username,password,email,bio)
            VALUES (#{username},#{password},#{email},#{bio})
    </insert>

parameterType指定为author。这个的全称是：com.test.mapper.model.Author,之所以简写是因为在mybatis-config.xml中配置了名称简化：

该配置指定model下的类都可以简写为类名首字母小写。

username，password等属性可以通过查找输入对象Author的getter属性获得。

注意：

输入参数是简单类型int,short,long,char,byte,boolean,float,double可以直接写基本类型。如果是类，则要写全称，比java.lang.String.

## 输出参数 ##

输出参数用resultType表示，用来和查询出来的结果集映射。下面是一个简单的查询：

<select id="selectAuthorById" resultType="author">
            SELECT * FROM author WHERE id = #{id}
    </select>

查询出来的字段和resultType中author映射。

如果列名和bean的属性不一致如何映射？需要使用查询的别名：

<select id="selectUsers" resultType="User">
      select
        user_id             as "id",
        user_name           as "userName",
        hashed_password     as "hashedPassword"
      from some_table
      where id = #{id}
    </select>

还有一种做法是将结果集单独拿出来，使用resultMap而不是resultType：

对应的，查询语句的返回类型为resultMap:

<select id="selectUsers" resultMap="userResultMap">
      select user_id, user_name, hashed_password
      from some_table
      where id = #{id}
    </select>

其实，很容易看出来，resultType和resultMap的作用都是将结果集映射成java bean，因此二者只能使用一个，不然无法确定究竟转换成哪个bean。而当我们涉及联合查询的时候，查询的结果集并没有创建的bean可以映射，这时候resultMap就可以为结果集提供映射方案。下面学习resultMap的各种参数

## 高级结果映射 ##

### 1. id&result ###

在上述查询中，看到了id和result节点。相信很容易就猜出来。id就是表的主键字段映射，result则表示主键以外的映射。标注id对性能缓存等有帮助。

<table>  Id and Result Attributes  
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>property</td> 
   <td>映射到列结果的字段或属性。如果匹配的是存在的,和给定名称相同 的 JavaBeans 的属性,那么就会使用。否则 MyBatis 将会寻找给定名称 property 的字段。这两种情形你可以使用通常点式的复杂属性导航。比如,你 可以这样映射一些东西: “username” ,或者映射到一些复杂的东西: “address.street.number” 。</td> 
  </tr> 
  <tr> 
   <td>column</td> 
   <td>从数据库中得到的列名,或者是列名的重命名标签。这也是通常和会 传递给 resultSet.getString(columnName)方法参数中相同的字符串。</td> 
  </tr> 
  <tr> 
   <td>javaType</td> 
   <td>一个 Java 类的完全限定名,或一个类型别名(参考上面内建类型别名 的列表) 。如果你映射到一个 JavaBean,MyBatis 通常可以断定类型。 然而,如果你映射到的是 HashMap,那么你应该明确地指定 javaType 来保证所需的行为。</td> 
  </tr> 
  <tr> 
   <td>jdbcType</td> 
   <td>在这个表格之后的所支持的 JDBC 类型列表中的类型。JDBC 类型是仅 仅需要对插入,更新和删除操作可能为空的列进行处理。这是 JDBC jdbcType 的需要,而不是 MyBatis 的。如果你直接使用 JDBC 编程,你需要指定 这个类型-但仅仅对可能为空的值。</td> 
  </tr> 
  <tr> 
   <td>typeHandler</td> 
   <td>我们在前面讨论过默认的类型处理器。使用这个属性,你可以覆盖默 认的类型处理器。这个属性值是类的完全限定名或者是一个类型处理 器的实现,或者是类型别名。</td> 
  </tr> 
 </tbody> 
</table>

## 2.构造方法 ##

上述方法中，id可以映射主键，result可以映射其他列，貌似已经完全了。也确实完全了，但对于属性注入，构造方法显然是个很好的办法。Mybatis提供了构造方法的映射：

首先，给Author增加一个构造方法：

public Author(Integer id, String username, String password) {
            this.id = id;
            this.username = username;
            this.password = password;
    }

然后，在com.test.mapper.mapper/AuthorMapper.xml中添加select：

<resultMap id="authorByConstructor" type="author">
            <constructor>
                <idArg column="id" javaType="int"/>
                <arg column="username" javaType="String"/>
                <arg column="password" javaType="String"/>
            </constructor>
            <result column="email" property="email"/>
        </resultMap>
        <select id="selectAuthor2Construct" resultMap="authorByConstructor">
            SELECT * FROM author
        </select>

添加对应的接口：com.test.mapper.dao.AuthorMapper：

List<Author> selectAuthor2Construct();

测试：

@Test
        public void testSelectAuthor2Construct() throws Exception{
            List<Author> authors = mapper.selectAuthor2Construct();
            assertTrue(authors.get(0).getUsername()!=null);
        }

## 3. 关联查询 ##

做查询之前，先修改几个配置。mapper.xml是在mybatis-config.xml中指定，那么我们每增加一个mapper都要增加一个配置，很麻烦。为了简化配置。需要将mapper接口和mapper.xml放到同一个文件下，并且接口和xml文件命名一致。使用mybatis的自动扫描：![686418-20160720224306685-1994426277.png][].这样，当我们新增接口的时候，直接创建接口和对应xml文件就可以了：

### 3.1prepare ###

增加一个表blog :

CREATE TABLE `blog` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      `author_id` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

创建实体类com.test.mapper.model.Blog:

package com.test.mapper.model;
    
    /**
     * Created by miaorf on 2016/7/20.
     */
    public class Blog {
        private Integer id;
        private String name;
        private Author author;
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Author getAuthor() {
            return author;
        }
    
        public void setAuthor(Author author) {
            this.author = author;
        }
    
        @Override
        public String toString() {
            return "Blog{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", author=" + author +
                    '}';
        }
    }

创建接口：com/test/mapper/dao/BlogMapper.xml

package com.test.mapper.dao;
    
    import com.test.mapper.model.Blog;
    
    import java.util.List;
    
    /**
     * Created by miaorf on 2016/7/20.
     */
    public interface BlogMapper {
    
        List<Blog> selectBlog(Integer id);
    }

` 创建xml：com/test/mapper/dao/BlogMapper.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.test.mapper.dao.BlogMapper">
     <resultMap id="blogResult" type="blog">
         <association property="author" column="author_id" javaType="author" select="com.test.mapper.dao.AuthorMapper.selectAuthorById"/>
     </resultMap>
     <select id="selectBlog" resultMap="blogResult">
         select * from blog where id = #{id}
     </select>
 
 </mapper>`

### 3.2含义 ###

首先，修改了mybatis配置文件中mapper扫描配置，因此可以直接在扫描包下添加接口和xml文件。

其次，关于mybatis的命名空间namespace的用法，这个是唯一的，可以代表这个xml文件本身。因此，当我想要引用Author的查询的时候，我可以直接使用AuthorMapper.xml的命名空间点select的id来唯一确定select片段。即：

select="com.test.mapper.dao.AuthorMapper.selectAuthorById"

然后，关联查询，blog的author\_id字段和author的id字段关联。因此，将Author作为Blog的一个属性，先查询blog，然后根据author\_id字段去查询author。也就是说，查询了两次。这里也是我困惑的地方，为什么mybatis要这样处理，命名可以一次查询取得数据非要两次查询。（待求证）

注意：association节点中

*  column字段是author\_id，是当做参数传递给查询Author的查询语句的，如果查询语句的参数有多个则：column= ” \{prop1=col1,prop2=col2\} ” 这种语法来传递给嵌套查询语 句。这会引起 prop1 和 prop2 以参数对象形式来设置给目标嵌套查询语句。
 *  property则表示在Blog类中对应的属性。

> 我们有两个查询语句:一个来加载博客,另外一个来加载作者,而且博客的结果映射描 述了“selectAuthor”语句应该被用来加载它的 author 属性。
> 
> 其他所有的属性将会被自动加载,假设它们的列和属性名相匹配。
> 
> 这种方式很简单, 但是对于大型数据集合和列表将不会表现很好。 问题就是我们熟知的 “N+1 查询问题”。概括地讲,N+1 查询问题可以是这样引起的:
> 
>  *  你执行了一个单独的 SQL 语句来获取结果列表(就是“+1”)。
>  *  对返回的每条记录,你执行了一个查询语句来为每个加载细节(就是“N”)。
> 
> 这个问题会导致成百上千的 SQL 语句被执行。这通常不是期望的。
> 
> MyBatis 能延迟加载这样的查询就是一个好处,因此你可以分散这些语句同时运行的消 耗。然而,如果你加载一个列表,之后迅速迭代来访问嵌套的数据,你会调用所有的延迟加 载,这样的行为可能是很糟糕的。
> 
> 所以还有另外一种方法

## 3.3 关联查询结果 ##

上述关联查询主要是为了延迟加载，做缓存用的，如果你不调用blog.getAuthor()来获取author,那么mybatis就不会去查询Author。也就是说，mybatis把博客和作者的查询当做两步来执行。实现信息分段加载，在某些场合是有用的。然而在博客这里，显然不太合适，因为我们看到博客的同时都会看到作者，那么必然会导致查询数据库两次。下面，来测试另一种方式，像sql关联查询一样，一次查出结果。

<select id="selectBlogWithAuthor" resultMap="blogResultWithAuthor">
            SELECT
              b.id        as blog_id,
              b.name      as blog_title,
              b.author_id as blog_author_id,
              a.id        as author_id,
              a.username  as author_username,
              a.password  as author_password,
              a.email     as author_email,
              a.bio       as author_bio
            FROM blog b LEFT OUTER JOIN author a ON b.author_id=a.id
            WHERE b.id = #{id}
        </select>
        <resultMap id="blogResultWithAuthor" type="blog">
            <id property="id" column="blog_id"/>
            <result property="name" column="blog_title"/>
            <association property="author" column="blog_author_id" javaType="author" resultMap="authorResult"/>
        </resultMap>
        <resultMap id="authorResult" type="author">
            <id property="id" column="author_id"/>
            <result property="username" column="author_username"/>
            <result property="password" column="author_password"/>
            <result property="email" column="author_email"/>
            <result property="bio" column="author_bio"/>
        </resultMap>

和3.1里的查询一样，都是查询出blog和Author。但这个只查询数据库一次，也就是说实现了我们的关联查询。这几行代码乍一看有点复杂，仔细分析一下就很明了了。

1> 首先看到的是select标签，这个表示查询。其中id表示对应的接口的方法名；resultMap的值是一个resultMap节点的id，这个表示select查询结果的映射          方式。

2> select中间就是我熟悉的关联查询语句，这里不做赘述

3> 然后就是resultMap所指向的节点blogResultWithAuthor。

*  resultMap节点的id就是唯一标识这个节点的，type表示这个resultMap最终映射成的实体类Blog。
 *  id是主键映射，这个和mybatis缓存有关。
 *  ![686418-20160722232206060-1211044993.png][]
 *  ![686418-20160722234709544-1295511091.png][]
 *  
 *  result:
 *  ![686418-20160722233120107-374014612.png][]
 *  association:
 *  ![686418-20160722234407138-615204477.png][]
 *  authorResult同理。

可以看到控制台打印的日志：

2016-07-22 23:01:00,148 DEBUG [org.apache.ibatis.transaction.jdbc.JdbcTransaction] - Opening JDBC Connection
    2016-07-22 23:01:11,017 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - Created connection 1893960929.
    2016-07-22 23:01:19,281 DEBUG [org.apache.ibatis.transaction.jdbc.JdbcTransaction] - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@70e38ce1]
    2016-07-22 23:01:27,018 DEBUG [com.test.mapper.dao.BlogMapper.selectBlogWithAuthor] - ==>  Preparing: SELECT b.id as blog_id, b.name as blog_title, b.author_id as blog_author_id, a.id as author_id, a.username as author_username, a.password as author_password, a.email as author_email, a.bio as author_bio FROM blog b LEFT OUTER JOIN author a ON b.author_id=a.id WHERE b.id = ? 
    2016-07-22 23:01:29,697 DEBUG [com.test.mapper.dao.BlogMapper.selectBlogWithAuthor] - ==> Parameters: 1(Integer)
    2016-07-22 23:01:30,091 DEBUG [com.test.mapper.dao.BlogMapper.selectBlogWithAuthor] - <==      Total: 1

[686418-20160720224306685-1994426277.png]: /images/20220716/d01461ae955e4ff2a01ca5071397973b.png
[686418-20160722232206060-1211044993.png]: /images/20220716/1be1a35036774ee0bd84016b549d5d28.png
[686418-20160722234709544-1295511091.png]: /images/20220716/46097692ecf34cb7a54945a5729988e4.png
[686418-20160722233120107-374014612.png]: /images/20220716/78feaf4dc0524b6dbf99ac849b3e85a2.png
[686418-20160722234407138-615204477.png]: /images/20220716/bb27cdec4636481d810b7c5027d9202c.png