2020-02-26 16:38 已编辑门头沟学院 Java

关注

MyBatis-映射文件

映射文件指导着MyBatis如何进行数据库增删改查，有着非常重要的意义；这些编写在myMapper.xml中

cache –命名空间的二级缓存配置
cache-ref – 其他命名空间缓存配置的引用。
resultMap – 自定义结果集映射
parameterMap – 已废弃！老式风格的参数映射
sql –抽取可重用语句块。
insert – 映射插入语句
update – 映射更新语句
delete – 映射删除语句
select – 映射查询语句

insert、update、delete元素

图片说明

主键生成方式

若数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server），则可以设置 useGeneratedKeys=”true”，然后再把 keyProperty 设置到目标属性上。
而对于不支持自增型主键的数据库（例如 Oracle），则可以使用 selectKey 子元素：selectKey 元素将会首先运行，id 会被设置，然后插入语句会被调用

selectKey

图片说明

 <insert id="insertBook" useGeneratedKeys="true" keyProperty="id" >
      insert into book(book_name,price,isbn) values(#{book_name},#{price},#{isbn}) 
  </insert>
获取当前数据库自增的Mysql.book.id，并赋值给java.book.id

如果没有自增id 也可以利用selectKey 从数据库中获取自己需要的值然后赋值到对应的对象参数中

<insert id="insertBook" parameterType="com.project.bean.Book" >
     <selectKey order="BEFORE" keyProperty="id">
         SELECT max(id)+1 FROM book
     </selectKey>
获取的值会赋值到id中 供后面使用
      insert into book(book_name,price,isbn) values(#{book_name},#{price},#{isbn}) 
  </insert>

参数（Parameters）传递

单个参数
可以接受基本类型，对象类型，集合类型的值。这种情况MyBatis可直接使用这个参数，不需要经过任何处理。
多个参数
任意多个参数，都会被MyBatis重新包装成一个Map传入。Map的key是param1，param2，0，1…，值就是参数的值。
命名参数
为参数使用@Param起一个名字，MyBatis就会将这些参数封装进map中，key就是我们自己指定的名字
POJO
当这些参数属于我们业务POJO时，我们直接传递POJO
Map
我们也可以封装多个参数为map，直接传递

传参到底能传哪些

public Book getBookByPriceAndBookName(Integer price ,String book_name );

多参数直接按名传参（报错）能用的参数可用[arg1, arg0, param1, param2] 而参数名无效

<select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE price=#{price} AND book_name=#{book_name}
  </select>

图片说明

多参数按默认参数传参 [arg1, arg0, param1, param2]
只要传入了多个参数：mybatis会自动的将这些参数封装在一个map中，封装时使用的key就是参数的索引和参数的第几个表示
Map<String ,Object> map = new HashMap<>();
map.put("1",value)、map.put("2",value);’#‘{key}就是从这个map中取值
```
<select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE price=#{arg0} AND book_name=#{arg1}
  </select>
```

单个参数基本类型：取值#{参数名/随便写}

  <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE  book_name=#{ahha}
  </select>

图片说明

我们可以告诉mybatis，封装参数map的时候使用我们指定的key@Param()【命名参数】

  <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE price=#{price} AND book_name=#{book_name}
  </select>
  public Book getBookByPriceAndBookName(@Param("price") Integer price ,@Param("book_name")String book_name );

图片说明

传入pojo（javabean）单个参数自动解析

public Book getBookByPriceAndBookName( Book book );
  <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE price=#{price} AND book_name=#{book_name}
  </select>

图片说明

传入map：将多个要使用的参数封装起来

  @Test
  public void getBookByPriceAndBookName() {
      openSession  = sqlSessionFactory.openSession();
      MyMapper myMapper = openSession.getMapper(MyMapper.class);
      Map<String, Object> map = new HashMap<String, Object>();
      map.put("price", 400);
      map.put("book_name", "book04");
      Book book = myMapper.getBookByPriceAndBookName(map);
      System.out.println(book);
  }
  <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE price=#{price} AND book_name=#{book_name}
  </select>
public Book getBookByPriceAndBookName( Map map );

扩展多类型混合

  public Book getBookByPriceAndBookName(Integer price ,String book_name, Book book );

  <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
      SELECT * FROM book WHERE price=#{arg2.price} AND book_name=#{arg2.book_name}
  </select>

参数处理

图片说明
参数也可以指定一个特殊的数据类型：

javaType 通常可以从参数对象中来去确定
如果 null 被当作值来传递，对于所有可能为空的列，jdbcType 需要被设置
对于数值类型，还可以设置小数点后保留的位数：
mode 属性允许指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像在获取输出参数时所期望的那样。

参数位置支持的属性

javaType、jdbcType、mode、numericScale、
resultMap、typeHandler、jdbcTypeName
实际上通常被设置的是：
可能为空的列名指定 jdbcType
"#"{key}：获取参数的值，预编译到SQL中。安全。
：获取参数的值，拼接到SQL中。有SQL注入问题。ORDER BY ${name}
'#'{jdbcType=INT}只有jdbcType才可能是需要被指定的
默认不指定jdbcType；MySql没问题，oracle没问题，万一传入的数据是null，mysql插入null没问题，oracle不知道null是什么

'#'{} 和 ”$“{}的区别

'#'{属性名}：是参数预编译的方式，参数的位置都是用?代替，参数后来都是预编译设置进去的，安全，不会有sql注入
”$“{属性名}：不是预编译的方式，而是直接和sql语句进行拼接，不安全
一般都是使用‘#’{}，在不支持参数预编译的位置要进行取值就用第二种【sql语句只有参数位置是支持预编译的】

    public Book getBookByPriceAndBookName(Integer price ,String book_name,String tableName );

    <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
        SELECT * FROM ${arg2} WHERE price=#{arg0} AND book_name=#{arg1}
    </select>

select元素

Select元素来定义查询操作。
Id：唯一标识符。
用来引用这条语句，需要和接口的方法名一致
parameterType：参数类型。
可以不传，MyBatis会根据TypeHandler自动推断
resultType：返回值类型。
别名或者全类名，如果返回的是集合，定义集合中元素的类型。不能和resultMap同时使用

查询多个封装的map

  <select id="getBookByPriceAndBookName" resultType="map">
      SELECT * FROM book WHERE price=#{arg0} AND book_name=#{arg1}
  </select>
  public Map<String ,Object> getBookByPriceAndBookName(Integer price ,String book_name);

用map装多条数据且自定义key的值

@MapKey("isbn")
  public Map<String ,Book> getBookByPriceAndBookName(Integer price ,String book_name);
  <select id="getBookByPriceAndBookName" resultType="map">
      SELECT * FROM book WHERE price=#{arg0} 
  </select>

用Map封装到List

  public List<Map> getBookByPriceAndBookName(Integer price ,String book_name);
  <select id="getBookByPriceAndBookName" resultType="map">
      SELECT * FROM book WHERE price=#{arg0} 
  </select>

自动映射

全局setting设置

autoMappingBehavior默认是PARTIAL，开启自动映射的功能。唯一的要求是列名和javaBean属性名一致
如果autoMappingBehavior设置为null则会取消自动映射
数据库字段命名规范，POJO属性符合驼峰命名法，如A_COLUMN->aColumn，我们可以开启自动驼峰命名规则映射功能，mapUnderscoreToCamelCase=true。

自定义resultMap，实现高级结果集映射

resultMap

public class Book {
    public String bisbn;
    public String book_name;
    public Integer bprice;
}

图片说明
处理映射问题：就是java字段跟数据库字段匹配不上
第一种解决方法的情况 sql语句起别名：

    <select id="getBookByPriceAndBookName" resultType="com.project.bean.Book">
        SELECT isbn bisbn, book_name, price bprice FROM book WHERE price=#{arg0} AND book_name=#{arg1}
    </select>

图片说明
第二种解决方法的情况，mapper配置文件进行配置映射

<!-- 使用默认规则，属性列名一一对应 -->
    <select id="getBookByPriceAndBookName" resultMap="mybook">
        SELECT * FROM book WHERE price=#{arg0} AND book_name=#{arg1}
    </select>
    <resultMap type="com.project.bean.Book" id="mybook">
    <!-- 
        指定主键列的对应规则
        column="id":指定哪一列是主键列
        property=""指定book的哪个属性封装id这个数据
     -->
        <!--主键列的定义-->
         <id property="bprice" column="price"/>
        <!-- 普通列 -->
         <result property="bisbn" column="isbn"/>
         <result property="bprice" column="price"/>
    </resultMap>

constructor - 类在实例化时, 用来注入结果到构造方法中

idArg - ID 参数; 标记结果作为 ID 可以帮助提高整体效能
arg - 注入到构造方法的一个普通结果

id – 一个 ID 结果; 标记结果作为 ID 可以帮助提高整体效能

result – 注入到字段或 JavaBean 属性的普通结果

association – 一个复杂的类型关联;许多结果将包成这种类型

嵌入结果映射 – 结果映射自身的关联,或者参考一个

collection – 复杂类型的集

嵌入结果映射 – 结果映射自身的集,或者参考一个

discriminator – 使用结果值来决定使用哪个结果映射

case – 基于某些值的结果映射
嵌入结果映射 – 这种情形结果也映射它本身,因此可以包含很多相同的元素,或者它可以参照一个外部的结果映射。

也就是满足什么条件才运行

         <discriminator javaType="">
             <case value="">
                 <association property="book" javaType="com.project.bean.Book">
                 <id property="bisbn" column="bisbn"/>
                 <result property="book_name" column="book_name"/>
                 <result property="bprice" column="price"/>
                 </association>
             </case>
         </discriminator>

id & result

id 和 result 映射一个单独列的值到简单数据类型(字符串,整型,双精度浮点数,日期等)的属性或字段。
图片说明

association

复杂对象映射

POJO中的属性可能会是一个对象
javabean：

public class Book {
  public String bisbn;
  public String book_name;
  public Integer bprice;
}
public class user {
  private Integer id;
  private String username;
  private String isbn;
  private Book book;
}

我们可以使用联合查询，并以级联属性的方式封装对象。

使用普通的result来映射

首先sql 语句可以有两种写法 采用第二种 写法不会忽略一些细节
SELECT user.id,user.username,user.isbn , book.isbn , book.book_name ,book.price 
      FROM book,user 
      WHERE user.isbn = book.isbn AND user.id =  1
SELECT user.id,user.username,user.isbn , book.isbn , book.book_name ,book.price 
      FROM user  LEFT JOIN book ON user.isbn = book.isbn
      WHERE user.id = 1;
mymapper的配置文件
  <select id="getUserAndBookByuserId" resultMap="myUser">
      SELECT id , username, user.isbn isbn , book.isbn bisbn , book_name , price 
          FROM user  LEFT JOIN book ON user.isbn = book.isbn
          WHERE user.id = #{id}
  </select>
  <resultMap type="com.project.bean.User" id="myUser">
       <id property="id" column="id"/>
       <result property="username" column="username"/>
       <result property="isbn" column="isbn"/>
       <result property="book.bisbn" column="bisbn"/>
       <result property="book.book_name" column="book_name"/>
       <result property="book.bprice" column="price"/>
  </resultMap>

图片说明

使用association标签定义对象的封装规则

  <select id="getUserAndBookByuserId" resultMap="myUser">
      SELECT id , username, user.isbn isbn , book.isbn bisbn , book_name , price 
          FROM user  LEFT JOIN book ON user.isbn = book.isbn
          WHERE user.id = #{id}
  </select>
  <resultMap type="com.project.bean.User" id="myUser">
       <id property="id" column="id"/>
       <result property="username" column="username"/>
       <result property="isbn" column="isbn"/>
       <!-- 接下来的属性是一个对象，自定义这个对象的封装规则，使用下面标签 -->
       <association property="book" javaType="com.project.bean.Book">
           <id property="bisbn" column="bisbn"/>
           <result property="book_name" column="book_name"/>
           <result property="bprice" column="price"/>
       </association>
  </resultMap>

表表之间的关系采用中间表解决 1：n n:n n:1

1-1关联一把钥匙开一把锁
1-n关联一把锁有多把钥匙【多打几把】
n-1关联：从钥匙的角度看锁
n-n 学生跟老师的关系需要用中间表存储对应关系
中间表

association-嵌套结果集

javabean

public class User {
    private Integer id;
    private String username;
    private String isbn;
    private List<Book> ls;
}

两种sql语句

SELECT book.* , user.* 
    FROM user , book , ass 
    WHERE ass.userId = user.id AND book.isbn = ass.bookIsbn AND user.id = 1 ;
SELECT book.* , user.* 
    FROM ass LEFT JOIN user 
    ON ass.userId = user.id LEFT JOIN book ON book.isbn = ass.bookIsbn WHERE user.id = 1 ;

mymapper的配置文件

    <select id="getUserAndBookByuserId" resultMap="myUser">
        SELECT isbn,book_name,price , user.id id , username  
            FROM ass LEFT JOIN user 
            ON ass.userId = user.id LEFT JOIN book ON book.isbn = ass.bookIsbn WHERE user.id = #{id}     
    </select>
    <resultMap type="com.project.bean.User" id="myUser">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <collection property="ls" ofType="com.project.bean.Book">
            <id property="bisbn" column="isbn"/>
            <result property="book_name" column="book_name"/>
            <result property="bprice" column="price"/>
        </collection>
    </resultMap>

图片说明

Collection-集合类型&嵌套结果集/association-分步查询且一个是一一个是n

两个mapper的配置文件

    <select id="getUserByuserId" resultMap="myUser">
        select * from user WHERE id = #{id};
    </select>
    <resultMap type="com.project.bean.User" id="myUser">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <collection property="ls" select="com.project.mapper.BookMapper.getBookByIsbn" column="id">
        </collection>
    </resultMap>

    <select id="getBookByIsbn" resultType="com.project.bean.Book">
        select book.isbn isbn, book.price price, book.book_name book_name from ass LEFT JOIN book ON book.isbn = ass.bookIsbn WHERE ass.userId = #{id}
    </select>

图片说明

Collection-分步查询&延迟加载&&分段查询&延迟加载

开启延迟加载和属性按需加载

  <settings>
      <!-- 开启延迟加载开关 -->
      <setting name="lazyLoadingEnabled" value="true"/>
      <!-- 开启属性按需加载 -->
      <setting name="aggressiveLazyLoading" value="false"/>
  </settings>

就会按需加载
图片说明
第二种

resultMap多个值传递

分步查询的时候通过column指定，将对应的列的数据传递过去，我们有时需要传递多列数据。
使用{key1=column1,key2=column2…}的形式
association或者collection标签的fetchType=eager/lazy可以覆盖全局的延迟加载策略，指定立即加载（eager）或者延迟加载（lazy）