第一题. 实体类属性名和表中字段名不⼀样 ，怎么办?

第1种： 通过在查询的SQL语句中定义字段名的别名，让字段名的别名和实体类的属性名⼀致。

<select id="getOrder" parameterType="int" resultType="com.jourwon.pojo.Order">
 select order_id id, order_no orderno ,order_price price form orders where
order_id=#{id};
</select>

第2种： 通过resultMap 中的来映射字段名和实体类属性名的⼀⼀对应的关系。

<select id="getOrder" parameterType="int" resultMap="orderResultMap">
 select * from orders where order_id=#{id}
</select>
<resultMap type="com.jourwon.pojo.Order" id="orderResultMap">
 <!–⽤id属性来映射主键字段–>
 <id property="id" column="order_id">
 <!–⽤result属性来映射⾮主键字段，property为实体类属性名，column为数据库表中的属性–>
 <result property ="orderno" column ="order_no"/>
 <result property="price" column="order_price" />
</resultMap>

第二题. Mybatis是否可以映射Enum枚举类？

• Mybatis当然可以映射枚举类，不单可以映射枚举类，Mybatis可以映射任何对象到表的⼀列上。映射⽅式为⾃定义⼀个TypeHandler，实现TypeHandler的setParameter()和getResult()接⼝⽅法。
• TypeHandler有两个作⽤，⼀是完成从javaType⾄jdbcType的转换，⼆是完成jdbcType⾄javaType的转换，体现为setParameter()和getResult()两个⽅法，分别代表设置sql问号占位符参数和获取列查询结果。

第三题. Mybatis能执⾏⼀对⼀、⼀对多的关联查询吗？

当然可以，不⽌⽀持⼀对⼀、⼀对多的关联查询，还⽀持多对多、多对⼀的关联查询。
⼀对⼀ < association>
⽐如订单和⽀付是⼀对⼀的关系，这种关联的实现：
实体类:

public class Order {
 private Integer orderId;
 private String orderDesc;
 /**
 * ⽀付对象
 */
 private Pay pay;
 //……
}

结果映射

<!-- 订单resultMap -->
<resultMap id="peopleResultMap" type="cn.fighter3.entity.Order">
 <id property="orderId" column="order_id" />
 <result property="orderDesc" column="order_desc"/>
 <!--⼀对⼀结果映射-->
 <association property="pay" javaType="cn.fighter3.entity.Pay">
 <id column="payId" property="pay_id"/>
 <result column="account" property="account"/>
 </association>
</resultMap>

查询就是普通的关联查

<select id="getTeacher" resultMap="getTeacherMap" parameterType="int">
 select * from order o
 left join pay p on o.order_id=p.order_id
 where o.order_id=#{orderId}
</select>

⼀对多 < collection>
⽐如商品分类和商品，是⼀对多的关系。

实体类

public class Category {
  private int categoryId;
  private String categoryName;
  /**
  * 商品列表
  **/
  List<Product> products;
  //……
}

结果映射

<resultMap type="Category" id="categoryBean">
 <id column="categoryId" property="category_id" />
 <result column="categoryName" property="category_name" />
 <!-- ⼀对多的关系 -->
 <!-- property: 指的是集合属性的值, ofType：指的是集合中元素的类型 -->
 <collection property="products" ofType="Product">
 <id column="product_id" property="productId" />
 <result column="productName" property="productName" />
 <result column="price" property="price" />
 </collection>
</resultMap>

查询
查询就是⼀个普通的关联查询

<!-- 关联查询分类和产品表 -->
<select id="listCategory" resultMap="categoryBean">
 select c.*, p.* from category_ c left join product_ p on c.id = p.cid
</select>

多对一关系映射

在多对一关系中，一个实体对象可以关联到另一个实体对象，但是另一个实体对象只能关联到一个实体对象。比如，订单(Order)和客户(Customer)之间的关系。
实体类：

public class Order {
    private int orderId;
    private String orderName;
    private Customer customer;
    // getters and setters
}

public class Customer {
    private int customerId;
    private String customerName;
    // getters and setters
}

结果映射：

<resultMap type="Order" id="orderResultMap">
    <id property="orderId" column="order_id"/>
    <result property="orderName" column="order_name"/>
    <!-- 多对一关系 -->
    <association property="customer" javaType="Customer">
        <id property="customerId" column="customer_id"/>
        <result property="customerName" column="customer_name"/>
    </association>
</resultMap>

多对多关系映射

在多对多关系中，一个实体对象可以关联到多个另一个实体对象，反之亦然。比如，学生(Student)和课程(Course)之间的关系。

实体类：

public class Student {
    private int studentId;
    private String studentName;
    private List<Course> courses;
    // getters and setters
}

public class Course {
    private int courseId;
    private String courseName;
    private List<Student> students;
    // getters and setters
}

结果映射：

<resultMap type="Student" id="studentResultMap">
    <id property="studentId" column="student_id"/>
    <result property="studentName" column="student_name"/>
    <!-- 多对多关系 -->
    <collection property="courses" ofType="Course">
        <id property="courseId" column="course_id"/>
        <result property="courseName" column="course_name"/>
    </collection>
</resultMap>

<resultMap type="Course" id="courseResultMap">
    <id property="courseId" column="course_id"/>
    <result property="courseName" column="course_name"/>
    <!-- 多对多关系 -->
    <collection property="students" ofType="Student">
        <id property="studentId" column="student_id"/>
        <result property="studentName" column="student_name"/>
    </collection>
</resultMap>

第四题. Mybatis是否⽀持延迟加载？原理？

• Mybatis⽀持association关联对象和collection关联集合对象的延迟加载，association指的就是⼀对⼀，collection指的就是⼀对多查询。在Mybatis配置⽂件中，可以配置是否启⽤延迟加载lazyLoadingEnabled=true|false。
• 它的原理是，使⽤CGLIB创建⽬标对象的代理对象，当调⽤⽬标⽅法时，进⼊拦截器⽅法，⽐如调⽤a.getB().getName()，拦截器invoke()⽅法发现a.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调⽤a.setB(b)，于是a的对象b属性就有值了，接着完成a.getB().getName()⽅法的调⽤。这就是延迟加载的基本原理。
• 当然了，不光是Mybatis，⼏乎所有的包括Hibernate，⽀持延迟加载的原理都是⼀样的。

第五题. 如何获取⽣成的主键?

新增标签中添加：keyProperty=" ID " 即可

<insert id="insert" useGeneratedKeys="true" keyProperty="userId" >
 insert into user(
 user_name, user_password, create_time)
 values(#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
</insert>

这时候就可以完成回填主键

mapper.insert(user);
user.getId;

如果我的内容对你有帮助，请点赞，评论，收藏。创作不易，大家的支持就是我坚持下去的动力