Mybatis

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量184 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YZL___/article/details/120508430
版权

下载和安装

github下载-releases-下载mybatis.x.x.x.jar包和源码

作用域（Scope）和生命周期：

SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：

try (SqlSession session = sqlSessionFactory.openSession()) {
  	BlogMapper mapper = session.getMapper(BlogMapper.class);//映射器实例
    // 你的应用逻辑代码
}

示例：

Helloworld

1.在conf下创建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="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>    //com.mysql.jdbc.Driver
        <property name="url" value="${url}"/>          //jdbc:mysql://localhost:3306/mybatis   配置数据库地址、用户名、密码
        <property name="username" value="${username}"/>   //root
        <property name="password" value="${password}"/>   //123456
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="com/atguigu/mybatis/EmployeeMaper.xml"/>
  </mappers>
</configuration>

2.在conf下创建EmployeeMaper.xml用于写sql语句映射:

其中resultType表示返回的查询结果是Employee类型的对象

#{id}:从传过来的参数取出id

要将该文件注册到全局配置文件中： 

<?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.atguigu.mybatis.EmployeeMaper">
  <select id="selectEmployee" resultType="Employee">
    select * from tb1_employee where id = #{id}
  </select>
</mapper>

3.java代码:

public void test() thows IOException{
    //1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory
	String resource = "mybatis-config.xml";
	InputStream inputStream = Resources.getResourceAsStream(resource);
	SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	//2、获取sqlsession实例，能直接执行已经映射的sql语句
    try (SqlSession session = sqlSessionFactory.openSession()) {
  		Blog blog = (Blog) session.selectOne
	         ("com.atguigu.mybatis.EmployeeMaper.selectEmployee", 101);
	}finally{
        session.close();
    }
}

（了解）注：不使用 XML 构建 SqlSessionFactory

如果你更愿意直接从 Java 代码而不是 XML 文件中创建配置，或者想要创建你自己的配置建造器，MyBatis 也提供了完整的配置类，提供了所有与 XML 文件等价的配置项。

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(BlogMapper.class);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

接口式编程：

1、sqlSession代表和数据的一次会话；用完必须关闭。

2、sqlSession和connection一样都是非线程安全。每次使用都应该去获取新的对象

3、mapper接口没有实现类，但是mybatis会为接口生成代理对象。

4、两个重要配置文件：

​ mybatis全局配置文件包含数据库连接池信息，事务管理器信息等。。。系统运行环境

​ sql映射文件(xml)：保存了每一个sql语句的映射信息

具体步骤：

namespace改为接口的全类名“xxx.dao.EmployeeMaper”

sql语句id改为方法名

<!--全局配置文件-->
<?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.atguigu.mybatis.dao.EmployeeMaper">
  <select id="getEmpById" resultType="Employee">
    select * from tb1_employee where id = #{id}
  </select>
</mapper>

//接口类
package ....;
public interface EmployeeMaper {
  //@Select("SELECT * FROM blog WHERE id = #{id}")
  Employee getEmpById(int id);
}

public SqlSessionFactory getSqlSessionFactory() throws IOException {
	String resource = "mybatis-config.xml";
	InputStream inputStream = Resources.getResourceAsStream(resource);
	return new SqlSessionFactoryBuilder().build(inputStream);
}
//java执行代码
public void test() thows IOException{
    //1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory
	SqlSessionFactory sqlSessionFactory = getSqlSessionFactory（）;
	//2、获取sqlsession实例，能直接执行已经映射的sql语句
    SqlSession session = sqlSessionFactory.openSession())
  	try{ 
        //3、获取接口的实例对象
        //会自动为接口创建代理对象，代理对象执行增删改查。
        //接口实现通过mybatis去做
  		EmployeeMaper mapeper = session.getMapper(EmployeeMaper.class);
  		Employee employee = mapper.getEmpById(101);
	} finally{
        session.close();}
}

配置

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

注：标签要严格按照上述的先后顺序。

environments（环境配置）

注：如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。而如果是三个数据库，就需要三个实例，依此类推，记起来很简单：

数据库厂商标识（databaseIdProvider）：

<databaseIdProvider type="DB_VENDOR">
  <property name="mysql" value="MySQL"/>
  <property name="SQL Server" value="sqlserver"/>
  <property name="DB2" value="db2"/>
  <property name="Oracle" value="oracle" />
</databaseIdProvider>

在sql语句添加databaseId属性来确定是哪种数据库语言
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j1BPz9Jv-1632725119665)(C:\Users\Admin\AppData\Roaming\Typora\typora-user-images\image-20210830133250582.png)]

mapper

将写好的sql映射文件注册到全局配置文件中

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>
<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>
<!-- 使用映射器接口实现类的完全限定类名 
通过注解@Select()写sql语句，没有sql语句xml的情况。
-->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>
<!-- 批量注册：将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

XML 映射器

SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）：

  • cache – 该命名空间的缓存配置。
  • cache-ref – 引用其它命名空间的缓存配置。
  • resultMap – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。
  • parameterMap – 老式风格的参数映射。此元素已被废弃，并可能在将来被移除！请使用行内参数映射。文档中不会介绍此元素。
  • sql – 可被其它语句引用的可重用语句块。
  • insert – 映射插入语句。
  • update – 映射更新语句。
  • delete – 映射删除语句。
  • select – 映射查询语句。

增删改查

1、mybatis允许增删改定义以下返回值：

​ Integer、Long、Boolean表示影响多少行数据和是否成功，直接在接口类定义返回类型即可

2、手动提交数据？session.commit()??

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

<insert id="insertAuthor">
  insert into Author (id,username,password,email,bio)
  values (#{id},#{username},#{password},#{email},#{bio})
</insert>

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

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

属性：

<select
  id="selectPerson"
  parameterType="int" //可选，MyBatis通过类型处理器(TypeHandler)推断传入的参数，默认未设置(unset)
  parameterMap="deprecated" //目前已被废弃。请使用行内参数映射和 parameterType 属性。
  resultType="hashmap" //resultType和resultMap之间只能同时使用一个
  resultMap="personResultMap"
  flushCache="false"  //设置为true后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：（对 insert、update 和 delete 语句）true。
  useCache="true"	 //true将会导致本条语句的结果被二级缓存缓存起来，默认值：对select元素为true。
  timeout="10" //抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认为未设置（unset）(依赖数据库驱动）。
  fetchSize="256"   //尝试让驱动程序每次批量返回的结果行数等于这个设置值。默认（unset）（依赖驱动）。
  statementType="PREPARED" 
                    //默认值：PREPARED。
                    1、STATEMENT:直接操作sql，不进行预编译，获取数据：$—Statement 
                    2、PREPARED:预处理，参数，进行预编译，获取数据：#—–PreparedStatement:默认 
                    3、CALLABLE:执行存储过程————CallableStatement 
  resultSetType="FORWARD_ONLY"//FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE或
                            DEFAULT（等价于unset）中的一个，默认值为unset（依赖数据库驱动）。
  databaseID=""  //如果配置了数据库厂商标识（databaseIdProvider），MyBatis会加载所有不带
                 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。
> 
    
<insert
  id="insertAuth or"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  keyProperty="id"    //设置主键
  keyColumn=""			//
  useGeneratedKeys="true"  //true使用自增主键获取主键值策略
  timeout="20">		

<update
  id="updateAuthor"
  parameterType="domain.blog.Author"id
  flushCache="true"
  statementType="PREPARED"
  timeout="20">

<delete
  id="deleteAuthor"
  parameterType="domain.blog.Author"
  flushCache="true"
  statementType="PREPARED"
  timeout="20">

select的其他属性：

resultOrdered这个设置仅针对嵌套结果 select 语句：如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用。 这就使得在获取嵌套结果集的时候不至于内存不够用。默认值：false。
resultSets这个设置仅适用于多结果集的情况。它将列出语句执行后返回的结果集并赋予每个结果集一个名称，多个名称之间以逗号分隔。

多行插入

如果你的数据库还支持多行插入, 你也可以传入一个 Author 数组或集合，并返回自动生成的主键。

<insert id="insertAuthor" useGeneratedKeys="true"
    keyProperty="id">
  insert into Author (username, password, email, bio) values
  <foreach item="item" collection="list" separator=",">
    (#{item.username}, #{item.password}, #{item.email}, #{item.bio})
  </foreach>
</insert>

selectKey使用

<selectKey
  keyProperty="id"
  resultType="int"
  order="BEFORE"
  statementType="PREPARED">
属性描述
keyPropertyselectKey 语句结果应该被设置到的目标属性。如果生成列不止一个，可以用逗号分隔多个属性名称。
keyColumn返回结果集中生成列属性的列名。如果生成列不止一个，可以用逗号分隔多个属性名称。
resultType结果的类型。通常 MyBatis 可以推断出来，但是为了更加准确，写上也不会有什么问题。MyBatis 允许将任何简单类型用作主键的类型，包括字符串。如果生成列不止一个，则可以使用包含期望属性的 Object 或 Map。
order可以设置为 BEFORE 或 AFTER。如果设置为 BEFORE，那么它首先会生成主键，设置 keyProperty 再执行插入语句。如果设置为 AFTER，那么先执行插入语句，然后是 selectKey 中的语句 - 这和 Oracle 数据库的行为相似，在插入语句内部可能有嵌入索引调用。
statementType和前面一样，MyBatis 支持 STATEMENT，PREPARED 和 CALLABLE 类型的映射语句，分别代表 Statement, PreparedStatement 和 CallableStatement 类型。

例子：oracle不支持自增主键，oracle插入数据的方法：

image-20210830164227088 image-20210830170758754

上面的示例中，首先会运行 selectKey 元素中的语句

参数

结果映射

方式一：映射到HashMap键上
<select id="selectUsers" resultType="map">
  select id, username, hashedPassword
  from some_table
  where id = #{id}
</select>
方式二：使用JavaBean作为模型
package com.someapp.model;
public class User {
  private int id;
  private String username;
  private String hashedPassword;

  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getUsername() {
    return username;
  }
  public void setUsername(String username) {
    this.username = username;
  }
  public String getHashedPassword() {
    return hashedPassword;
  }
  public void setHashedPassword(String hashedPassword) {
    this.hashedPassword = hashedPassword;
  }
}

<!-- mybatis-config.xml 中 -->
<typeAlias type="com.someapp.model.User" alias="User"/>

<!-- SQL 映射 XML 中 -->
<select id="selectUsers" resultType="User">
  select id, username, hashedPassword
  from some_table
  where id = #{id}
</select>

如果列名和属性名不能匹配上，可以在 SELECT 语句中设置列别名（这是一个基本的 SQL 特性）来完成匹配。比如：

<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

解决列名不匹配的另外一种方式

<!-- SQL映射XML中 -->
<resultMap id="userResultMap" type="User">
  <id property="id" column="user_id" />
  <result property="username" column="user_name"/>
  <result property="password" column="hashed_password"/>
</resultMap>

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

高级结果映射

例子
<!-- 非常复杂的语句 -->
<select id="selectBlogDetails" resultMap="detailedBlogResultMap">
  select
       B.id as blog_id,
       B.title 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,
       A.favourite_section as author_favourite_section,
       P.id as post_id,
       P.blog_id as post_blog_id,
       P.author_id as post_author_id,
       P.created_on as post_created_on,
       P.section as post_section,
       P.subject as post_subject,
       P.draft as draft,
       P.body as post_body,
       C.id as comment_id,
       C.post_id as comment_post_id,
       C.name as comment_name,
       C.comment as comment_text,
       T.id as tag_id,
       T.name as tag_name
  from Blog B
       left outer join Author A on B.author_id = A.id
       left outer join Post P on B.id = P.blog_id
       left outer join Comment C on P.id = C.post_id
       left outer join Post_Tag PT on PT.post_id = P.id
       left outer join Tag T on PT.tag_id = T.id
  where B.id = #{id}
</select>

<!-- 非常复杂的结果映射 -->
<resultMap id="detailedBlogResultMap" type="Blog">
  <constructor>
    <idArg column="blog_id" javaType="int"/>
  </constructor>
  <result property="title" column="blog_title"/>
  <!--会把以下内容封装成Author类的对象
	  javaType=指定属性的对象类型，不能省略
	-->
  <association property="author" javaType="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"/>
    <result property="favouriteSection" column="author_favourite_section"/>
  </association>
  
  <collection property="posts" ofType="Post">
    <id property="id" column="post_id"/>
    <result property="subject" column="post_subject"/>
    <association property="author" javaType="Author"/>
    <collection property="comments" ofType="Comment">
      <id property="id" column="comment_id"/>
    </collection>
    <collection property="tags" ofType="Tag" >
      <id property="id" column="tag_id"/>
    </collection>
    <discriminator javaType="int" column="draft">
      <case value="1" resultType="DraftPost"/>
    </discriminator>
  </collection>
</resultMap>

constructor - 用于在实例化类时，注入结果到构造方法中
idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
arg - 将被注入到构造方法的一个普通结果
id – 一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能
result – 注入到字段或 JavaBean 属性的普通结果
association – 一个复杂类型的关联；许多结果将包装成这种类型
嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
collection – 一个复杂类型的集合
嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用
discriminator – 使用结果值来决定使用哪个 resultMap
case – 基于某些值的结果映射
嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

构造方法
public class User {
   public User(Integer id, String username, int age) {//...}
//...
}
如果存在名称和类型相同的属性，那么可以省略 javaType 。
<constructor>
   <idArg column="id" javaType="int"/>
   <arg column="username" javaType="String"/>
   <arg column="age" javaType="_int"/>
</constructor>

可以在指定参数名称的前提下，以任意顺序编写 arg 元素。
<constructor>
   <idArg column="id" javaType="int" name="id" />
   <arg column="age" javaType="_int" name="age" />
   <arg column="username" javaType="String" name="username" />
</constructor>
association关联
关联的嵌套Select——分步查询

这种方式虽然很简单，但在大型数据集或大型数据表上表现不佳。

MyBatis 能够对这样的查询进行延迟加载，因此可以将大量语句同时运行的开销分散开来。 然而，如果你加载记录列表之后立刻就遍历列表以获取嵌套的数据，就会触发所有的延迟加载查询，性能可能会变得很糟糕。

属性描述
column数据库中的列名，或者是列的别名。一般情况下，这和传递给 resultSet.getString(columnName) 方法的参数一样。 注意：在使用复合主键的时候，你可以使用 column="{prop1=col1,prop2=col2}" 这样的语法来指定多个传递给嵌套 Select 查询语句的列名。这会使得 prop1 和 prop2 作为参数对象，被设置为对应嵌套 Select 语句的参数。
select用于加载复杂类型属性的映射语句的 ID，它会从 column 属性指定的列中检索数据，作为参数传递给目标 select 语句。 具体请参考下面的例子。注意：在使用复合主键的时候，你可以使用 column="{prop1=col1,prop2=col2}" 这样的语法来指定多个传递给嵌套 Select 查询语句的列名。这会使得 prop1 和 prop2 作为参数对象，被设置为对应嵌套 Select 语句的参数。
fetchType可选的。有效值为 lazy 和 eager。 指定属性后，将在映射中忽略全局配置参数 lazyLoadingEnabled，使用属性的值。
<!-- association定义关联对象的封装规则
   select:表明dept属性是调用select指定的getDeptById方法,传入column="d_id"查出的结果
   column:指定将哪一列的值传给这个方法
   流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
   -->
<!--  id  last_name  email   gender    d_id   -->
 <resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
 	<id column="id" property="id"/>
 	<result column="last_name" property="lastName"/>
 	<result column="email" property="email"/>
 	<result column="gender" property="gender"/>
	<association property="dept" 
 		select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
 		column="d_id">
	</association>
 </resultMap>

 <!--  public Employee getEmpByIdStep(Integer id);-->
 <select id="getEmpByIdStep" resultMap="MyEmpByStep">
 	select * from tbl_employee where id=#{id}      //1.查询员工信息
 </select>

<!--DepartmentMapper.xml-->
<mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
	<!--public Department getDeptById(Integer id);  -->
	<select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
		select id,dept_name departmentName from tbl_dept where id=#{id}
	</select>
<!-- 
public class Department {
		private Integer id;
		private String departmentName;
		private List<Employee> emps;
  did  dept_name  ||  eid  last_name  email   gender  
 -->
 </mapper>
关联嵌套结果映射
属性描述
resultMap结果映射的 ID，可以将此关联的嵌套结果集映射到一个合适的对象树中。 它可以作为使用额外 select 语句的替代方案。它可以将多表连接操作的结果映射成一个单一的 ResultSet。这样的 ResultSet 有部分数据是重复的。 为了将结果集正确地映射到嵌套的对象树中, MyBatis 允许你“串联”结果映射，以便解决嵌套结果集的问题。使用嵌套结果映射的一个例子在表格以后。
columnPrefix当连接多个表时，你可能会不得不使用列别名来避免在 ResultSet 中产生重复的列名。指定 columnPrefix 列名前缀允许你将带有这些前缀的列映射到一个外部的结果映射中。 详细说明请参考后面的例子。
notNullColumn默认情况下，在至少一个被映射到属性的列不为空时，子对象才会被创建。 你可以在这个属性上指定非空的列来改变默认行为，指定后，Mybatis 将只在这些列非空时才创建一个子对象。可以使用逗号分隔来指定多个列。默认值：未设置（unset）。
autoMapping如果设置这个属性，MyBatis 将会为本结果映射开启或者关闭自动映射。 这个属性会覆盖全局的属性 autoMappingBehavior。注意，本属性对外部的结果映射无效，所以不能搭配 select 或 resultMap 元素使用。默认值：未设置（unset）。
<select id="selectBlog" resultMap="blogResult">
  select
    B.id            as blog_id,
    B.title         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="blogResult" type="Blog">
  <id property="id" column="blog_id" />
  <result property="title" column="blog_title"/>
  <association property="author" javaType="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"/>
  </association>
</resultMap>

外部方式：
<resultMap id="blogResult" type="Blog">
  <id property="id" column="blog_id" />
  <result property="title" 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>

那如果博客（blog）有一个共同作者（co-author）该怎么办？
加上columnPrefix="co_"使得authorResult更加通用。
<select id="selectBlog" resultMap="blogResult">
  select
    B.id            as blog_id,
    B.title         as blog_title,
    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,
    CA.id           as co_author_id,
    CA.username     as co_author_username,
    CA.password     as co_author_password,
    CA.email        as co_author_email,
    CA.bio          as co_author_bio
  from Blog B
  left outer join Author A on B.author_id = A.id
  left outer join Author CA on B.co_author_id = CA.id
  where B.id = #{id}
</select>

<resultMap id="blogResult" type="Blog">
  <id property="id" column="blog_id" />
  <result property="title" column="blog_title"/>
  <association property="author"
    resultMap="authorResult" />
  <association property="coAuthor"
    resultMap="authorResult"
    columnPrefix="co_" />
</resultMap>
关联的多结果集（ResultSet）
属性描述
column当使用多个结果集时，该属性指定结果集中用于与 foreignColumn 匹配的列（多个列名以逗号隔开），以识别关系中的父类型与子类型。
foreignColumn指定外键对应的列名，指定的列将与父类型中 column 的给出的列进行匹配。
resultSet指定用于加载复杂类型的结果集名字。
SELECT * FROM BLOG WHERE ID = #{id}
SELECT * FROM AUTHOR WHERE ID = #{id}

<!--resultSets 属性为每个结果集指定一个名字，多个名字使用逗号隔开。-->
<select id="selectBlog" resultSets="blogs,authors" resultMap="blogResult" statementType="CALLABLE">
  {call getBlogsAndAuthors(#{id,jdbcType=INTEGER,mode=IN})}
</select>
<!--现在我们可以指定使用 “authors” 结果集的数据来填充 “author” 关联：-->
<resultMap id="blogResult" type="Blog">
  <id property="id" column="id" />
  <result property="title" column="title"/>
  <association property="author" javaType="Author" resultSet="authors" column="author_id" foreignColumn="id">
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="password" column="password"/>
    <result property="email" column="email"/>
    <result property="bio" column="bio"/>
  </association>
</resultMap>

resultmap：

属性描述
property映射到列结果的字段或属性。如果 JavaBean 有这个名字的属性（property），会先使用该属性。否则 MyBatis 将会寻找给定名称的字段（field）。 无论是哪一种情形，你都可以使用常见的点式分隔形式进行复杂属性导航。 比如，你可以这样映射一些简单的东西：“username”，或者映射到一些复杂的东西上：“address.street.number”。
column数据库中的列名，或者是列的别名。一般情况下，这和传递给 resultSet.getString(columnName) 方法的参数一样。
javaType一个 Java 类的全限定名，或一个类型别名（关于内置的类型别名，可以参考上面的表格）。 如果你映射到一个 JavaBean，MyBatis 通常可以推断类型。然而，如果你映射到的是 HashMap，那么你应该明确地指定 javaType 来保证行为与期望的相一致。
jdbcTypeJDBC 类型，所支持的 JDBC 类型参见这个表格之后的“支持的 JDBC 类型”。 只需要在可能执行插入、更新和删除的且允许空值的列上指定 JDBC 类型。这是 JDBC 的要求而非 MyBatis 的要求。如果你直接面向 JDBC 编程，你需要对可以为空值的列指定这个类型。
typeHandler我们在前面讨论过默认的类型处理器。使用这个属性，你可以覆盖默认的类型处理器。 这个属性值是一个类型处理器实现类的全限定名，或者是类型别名。
支持的 JDBC 类型

为了以后可能的使用场景，MyBatis 通过内置的 jdbcType 枚举类型支持下面的 JDBC 类型。

BITFLOATCHARTIMESTAMPOTHERUNDEFINED
TINYINTREALVARCHARBINARYBLOBNVARCHAR
SMALLINTDOUBLELONGVARCHARVARBINARYCLOBNCHAR
INTEGERNUMERICDATELONGVARBINARYBOOLEANNCLOB
BIGINTDECIMALTIMENULLCURSORARRAY
集合Collection

若在博客类中有，

private List<Post> posts;//一个博客有很多文章（Post)

映射嵌套结果集合到一个 List 中，可以使用集合元素

<resultMap id="blogResult" type="Blog">
  <id property="id" column="blog_id" />
  <result property="title" column="blog_title"/>
    <!--读作： “posts 是一个存储 Post 的 ArrayList 集合”   javaType="ArrayList"可以省-->
  <collection property="posts" ofType="domain.blog.Post">
    <id property="id" column="post_id"/>
    <result property="subject" column="post_subject"/>
    <result property="body" column="post_body"/>
  </collection>
</resultMap>

<select id="selectBlog" resultMap="blogResult">
  select
  B.id as blog_id,
  B.title as blog_title,
  B.author_id as blog_author_id,
  P.id as post_id,
  P.subject as post_subject,
  P.body as post_body,
  from Blog B
  left outer join Post P on B.id = P.blog_id
  where B.id = #{id}
</select>

也可以将collection单独分离，以便使用columnPrefix=“ ”重用。

<resultMap id="blogResult" type="Blog">
  <id property="id" column="blog_id" />
  <result property="title" column="blog_title"/>
  <collection property="posts" ofType="Post" resultMap="blogPostResult" columnPrefix="post_"/>
</resultMap>

<resultMap id="blogPostResult" type="Post">
  <id property="id" column="id"/>
  <result property="subject" column="subject"/>
  <result property="body" column="body"/>
</resultMap>

补充知识：collection+select嵌套查询：

<resultMap id="blogResult" type="Blog">
 	<id property="id" column="blog_id"/>
    <result property="title" column="blog_title"/>
 	<collection property="posts" javaType="ArrayList" column="id" ofType="Post" select="selectPostsForBlog"/>
    <!--如果子查询传入多列，写成column="{子查询id=当前id}"-->
    <!--延迟加载：fetchtype="lazy"默认为lazy，eager立即-->
     <collection property="posts" javaType="ArrayList" column="{id}" ofType="Post" select="selectPostsForBlog" fetchtype="lazy"/>
</resultMap>

<select id="selectBlog" resultMap="blogResult">
  SELECT * FROM BLOG WHERE ID = #{id}
</select>

<select id="selectPostsForBlog" resultType="Post">
  SELECT * FROM POST WHERE BLOG_ID = #{id}
</select>

补充知识：collection分布查询+延迟加载

鉴别器
<discriminator javaType="int" column="draft">
  <case value="1" resultType="DraftPost"/>
</discriminator>

鉴别器的定义需要指定 column 和 javaType 属性。column 指定了 MyBatis 查询被比较值的地方。 而 javaType 用来确保使用正确的相等测试（虽然很多情况下字符串的相等测试都可以工作）。例如：

<resultMap id="carResult" type="Car">
  <result property="doorCount" column="door_count" />
</resultMap><resultMap id="vehicleResult" type="Vehicle">
  <id property="id" column="id" />
  <result property="vin" column="vin"/>
  <result property="year" column="year"/>
  <result property="make" column="make"/>
  <result property="model" column="model"/>
  <result property="color" column="color"/>
  <discriminator javaType="int" column="vehicle_type">
    <case value="1" resultMap="carResult"/>
    <case value="2" resultMap="truckResult"/>
    <case value="3" resultMap="vanResult"/>
    <case value="4" resultMap="suvResult"/>
  </discriminator>
</resultMap>

<resultMap id="carResult" type="Car">
  <result property="doorCount" column="door_count" />
</resultMap>

示例中，MyBatis 会从结果集中得到每条记录，然后比较它的 vehicle type 值。 如果不能匹配任何一个 case，MyBatis 就只会使用鉴别器块外定义的结果映射。

那么只有 doorCount 属性会被加载。这是为了即使鉴别器的 case 之间都能分为完全独立的一组，尽管和父结果映射可能没有什么关系。在上面的例子中，我们当然知道 cars 和 vehicles 之间有关系，也就是 Car 是一个 Vehicle。因此，我们希望剩余的属性也能被加载。而这只需要一个小修改。

<resultMap id="carResult" type="Car" extends="vehicleResult">
  <result property="doorCount" column="door_count" />
</resultMap>

现在 vehicleResult 和 carResult 的属性都会被加载了。

可能有人又会觉得映射的外部定义有点太冗长了。 因此，对于那些更喜欢简洁的映射风格的人来说，还有另一种语法可以选择。例如：

<resultMap id="vehicleResult" type="Vehicle">
  <id property="id" column="id" />
  <result property="vin" column="vin"/>
  <result property="year" column="year"/>
  <result property="make" column="make"/>
  <result property="model" column="model"/>
  <result property="color" column="color"/>
  <discriminator javaType="int" column="vehicle_type">
    <case value="1" resultType="carResult">
      <result property="doorCount" column="door_count" />
    </case>
    <case value="2" resultType="truckResult">
      <result property="boxSize" column="box_size" />
      <result property="extendedCab" column="extended_cab" />
    </case>
    <case value="3" resultType="vanResult">
      <result property="powerSlidingDoor" column="power_sliding_door" />
    </case>
    <case value="4" resultType="suvResult">
      <result property="allWheelDrive" column="all_wheel_drive" />
    </case>
  </discriminator>
</resultMap>

<!-- =======================鉴别器============================ -->
<!-- <discriminator javaType=""></discriminator>
  鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
  封装Employee：
   如果查出的是女生：就把部门信息查询出来，否则不查询；
   如果是男生，把last_name这一列的值赋值给email;
  -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
    <id column="id" property="id"/>
    <result column="last_name" property="lastName"/>
    <result column="email" property="email"/>
    <result column="gender" property="gender"/>
    <!--
    column：指定判定的列名
    javaType：列值对应的java类型  -->
    <discriminator javaType="string" column="gender">
        <!--女生  resultType:指定封装的结果类型；不能缺少。/resultMap-->
        <case value="0" resultType="com.atguigu.mybatis.bean.Employee">
            <association property="dept" 
                         select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
                         column="d_id">
            </association>
        </case>
        <!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
        <case value="1" resultType="com.atguigu.mybatis.bean.Employee">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="last_name" property="email"/>
            <result column="gender" property="gender"/>
        </case>
    </discriminator>
</resultMap>

自动映射

MyBatis 会将返回的列名映射到类中相同名字的属性（忽略大小写）。
例子：如果发现了ID列和 id 属性，MyBatis 会将列 ID 的值赋给 id 属性。

数据库和Java命名规则映射

数据库（大写+下划线）格式与Java驼峰命名法的自动映射：

1、直接在resultMap中设置autoMapping

<resultMap id="userResultMap" type="User" autoMapping="false">
  <result property="password" column="hashed_password"/>
</resultMap>

2、在ssm项目中可以如下设置：

<?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>
    <settings>
        <!--开启驼峰命名-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

3、在springboot项目中可以如下设置：

mybatis.configuration.mapUnderscoreToCamelCase=true
或
mybatis.configuration.map-underscore-to-camel-case=true

或者是创建xml文件（configuration里面设置，再mybatis配置过程中指定文件的位置）

img

自动映射等级

有三种自动映射等级：

  • NONE - 禁用自动映射。仅对手动映射的属性进行映射。
  • PARTIAL - 对除在内部定义了嵌套结果映射（也就是连接的属性）以外的属性进行映射
  • FULL - 自动映射所有属性。

默认为PARTIAL

在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>
    <settings>
        <setting name="autoMappingBehavior" value="PARTIAL"/>
    </settings>
</configuration>

缓存

LYZ___
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【MyBatis】 MyBatis与MyBatis-Plus的区别
四季轮换叶，一路招摇胜
09-12 5万+
mybatis-plus 是 mybatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
mybatis慢SQL插件
07-19
基于mybatis的慢SQL小插件，原理是mybatis拦截器。只需要在springboot的配置文件做简单的配置，mybatis拦截器将SQL中所有参数自动做了填充。拦截器监控慢SQL并将完整的可执行的SQL语句打印在日志文件中，复制该SQL...
解决:mybatis的dtd约束文件及配置文件xml自动提示问题
zcx12ZCX的博客
03-29 220
mybatis的dtd约束文件及配置文件xml自动提示_四月的萤火之光的博客-CSDN博客_mybatis-3-mapper.dtd
mybatis-plus代码生成和踩坑XML扫描异常 笔记
溪c的博客
05-26 4261
文章目录1. 简介1.1 特性2. 自己使用过程遇到的补充2.1 aplication.properties配置2.2 mybatis-plus默认开启驼峰命名2.3 自定义方法和使用自定义xml**2.4 代码生成器**2.4.1 依赖引入2.4.2 编写配置2.4.3 运行自动代码生成mapper接口扫描和xml文件扫描配置(踩坑 IDEA默认是不解析xml的) 1. 简介 ​ MyBatis-Plus官网 MyBatis-Plus (opens new window)（简称 MP）是一个 M
mybatis的parameterType属性那些情况下要写 哪些情况下不用写
HD243608836的博客
08-23 2844
如果 是基本类型，或者是java自身的引用类型，在mybatis 运行时，会自动的进行匹配，可以省略parameterType属性。 如果是你自己声明的一个类型，因为可能在引入的jar包中有同名的类，所以你需要制定，这个时候的类型是什么。 ...
Mybatis知识点
weixin_45866849的博客
07-27 236
Mybatis知识点 Mybatis 中文官网 https://mybatis.org/mybatis-3/zh/getting-started.html mybatis 数据持久层 对jdbc封装 简化70%的jdbc代码 1.概述 原是Apache的一个开源项目iBatis,2010年6月这个项目由Apache Software Foundation 迁移到了 Google Code，随着开发团队转投Google Code 旗下，iBatis3.x正式更名为MyBatis。是 一个**基于Java
Mybatis增强版MyBatis-Flex介绍
沉淀、分享、成长，让自己和他人都能有所收获！
08-14 2万+
本文介绍了 Mybatis-Flex，一个用于增强 MyBatis 的框架。相对于 MyBatis-Plus，Mybatis-Flex提供了一些显著的特点，如支持联表查询以及在Mybatis-Plus中收费的功能在Mybatis-Flex中是免费的。文章概述了 MyBatis-Flex 的功能特点，并深入介绍了联表查询的不同方案。
MyBatis
weixin_45984258的博客
12-25 3052
MyBatisMyBatis快速入门Mapper代理开发MyBatis核心配置文件配置文件完成增删改查注解完成增删改查动态SQL MyBatis快速入门 MyBatis： Mybatis 是一款优秀的持久层框架，用于简化JDBC开发 JDBC的缺点： 1、硬编码： 注册驱动 SQL与君 2、操作繁琐 手动设置参数 手动封装结果集 MyBatis本是Apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到google code，并改名
完美解决org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflec
热门推荐
05-15 7万+
org.mybatis.spring.MyBatisSystemException是MyBatis与Spring集成时可能出现的异常，主要原因是在MyBatis的配置或使用过程中出现了问题。解决此异常的方法包括以下步骤：
mybatis
01-19
mybatis　“玩转”Java 系列
mybatis-3.5.10.zip
07-21
MyBatis is a first class persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and...
mybatis3.5.6
11-04
学习mybatis 不创建maven 需要下载jar包 但是在GitHub上下载实在是太慢了，有时还可能下载不了。分享一下
mybatis笔记
12-19
mybatis知识点总结，清晰明了，一看就会，有需要的可以下载。
MyBatis学习——第三章：mybatis的mapper
良木
11-25 659
在mybatis中，每个dao类数据访问接口都对应一个此接口的操作类。关于如何配置dao接口，有两种方法，分别是使用注解和使用配置文件，两者只能出现一种，否则会出现找不到映射项目而报错。 假如我有一个dao接口名为UserDao.java，在主配置文件中，需要配置其userDao.java对应的操作接口。两种匹配方式，如下所示： 第一种为配置文件的匹配方式： <mappers> <mapper resource="com/liangmu66/dao/UserMapper.xml"/
简单的项目部署脚本（转载）
u010230019的博客
06-09 654
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
最新发布
m0_74100417的博客
06-09 1464
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 468
修改菜品——后端Java
java mybatis
04-26
Java MyBatis是一个开源的持久层框架，它是基于Java语言的ORM（对象关系映射）框架。MyBatis提供了一种将数据库操作与Java对象之间的映射关系进行配置的方式，使得开发者可以通过简单的配置文件来实现数据库的增删改查操作，而无需编写繁琐的SQL语句。 MyBatis的核心思想是将SQL语句与Java代码进行解耦，通过XML或注解的方式来配置SQL语句，然后通过MyBatis框架来执行这些SQL语句并将结果映射到Java对象中。这种方式使得开发者可以更加专注于业务逻辑的实现，而无需过多关注数据库操作的细节。 MyBatis具有以下特点： 1. 灵活性：MyBatis支持使用XML或注解来配置SQL语句，开发者可以根据实际需求选择合适的方式。 2. 易于学习和使用：MyBatis的API简单易用，学习成本较低。 3. 高性能：MyBatis使用了缓存机制和预编译等优化技术，能够提高数据库操作的性能。 4. 可扩展性：MyBatis支持自定义类型处理器、插件等扩展机制，可以满足各种复杂的业务需求。 总结一下，Java MyBatis是一个简单易用、灵活性高、性能优越的持久层框架，它可以帮助开发者更加高效地进行数据库操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值