当实体类中的属性名和数据库中的字段名不一致时，会出现查不出来的现象，例如：属性名为password，字段名为pwd
解决方法：
1.查询语句取别名 select pwd as password from …

2.ResultMap
介绍：结果集映射

首先，查询语句的返回值用ResultMap不用ResultType;
然后，在mapper大标签里添加resultmap标签，里面设置标签的id,和映射的类型type
resultmap标签里，column是数据库查询的字段（列），property是需要映射成的名称。

生成ResultMap

自己写个工具类，懒得写resultmap了

1. 只适用于规范命名并且类中属性和库中名一样的，
2. 需要自己配置一下id

import com..MallOrderListV2Info;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
* @Description:
* @Param:
* @return:
* @Author: guojx_a
* @Date: 2021/8/10
*/
public class FastResultMap {



    @Test
    public void class2ResultMap() throws ClassNotFoundException {
        String resultMap = FastResultMap.generate(MallOrderListV2Info.class);
        System.out.println(resultMap);
    }
    private static Pattern humpPattern = Pattern.compile("[A-Z]");//匹配大写字母的正则
    private static final Map<String, String> TYPE_MAP = new HashMap<>();//java类型和jdbc类型的对应关系
    static {
        //以下对应规则可根据自己的实际情况做修改
        TYPE_MAP.put("string", "VARCHAR");
        TYPE_MAP.put("boolean", "BIT");
        TYPE_MAP.put("byte", "TINYINT");
        TYPE_MAP.put("short", "SMALLINT");
        TYPE_MAP.put("integer", "INTEGER");
        TYPE_MAP.put("long", "BIGINT");
        TYPE_MAP.put("float", "REAL");
        TYPE_MAP.put("double", "DOUBLE");
        TYPE_MAP.put("date", "DATE");//TIMESTAMP,DATETIME
        TYPE_MAP.put("timestamp", "TIMESTAMP");
        TYPE_MAP.put("time", "TIME");
        TYPE_MAP.put("bigdecimal", "DECIMAL");
    }
    /**
     * 生成ResultMap
     * @param clazz 实体类的Class
     * @return String
     */
    public static String generate(Class<?> clazz) throws ClassNotFoundException {
        String pkgName = clazz.getName();
        String clazzName = clazz.getSimpleName();//获取全路径
        String resultMapId = Character.toLowerCase(clazzName.charAt(0))+clazzName.substring(1)+"Map";

        StringBuilder resultMap = new StringBuilder();
        resultMap.append("<resultMap id=\"");
        resultMap.append(resultMapId);
        resultMap.append("\" type=\"");
        resultMap.append(pkgName);
        resultMap.append("\">\n");

        resultMap.append(generateResult(clazz));

        resultMap.append("</resultMap>");
        return resultMap.toString();
    }
    
    
    /**
    * @Description:  负责生成《result
    * @Param: [clazz]
    * @return: java.lang.String
    * @Author: guojx_a
    * @Date: 2021/8/10
    */
    public static String generateResult(Class<?> clazz) throws ClassNotFoundException {
        StringBuilder resultMap = new StringBuilder();
        String pkgName = clazz.getName();
        String clazzName = clazz.getSimpleName();//获取全路径
        String resultMapId = Character.toLowerCase(clazzName.charAt(0))+clazzName.substring(1)+"Map";
        Field[] fields = clazz.getDeclaredFields();
        for(Field f : fields){
            String property = f.getName();
            String javaType = f.getType().getSimpleName();
            if("serialVersionUID".equals(property)){
                continue;//忽略掉这个属性
            }
            if (javaType2jdbcType(javaType.toLowerCase())!="UNKNOWN") {
                resultMap.append("    <result column=\"");
//            resultMap.append(property2Column(property));//小写用这个
                resultMap.append(property2Column(property).toUpperCase());//大写用这个
                resultMap.append("\" jdbcType=\"");
                resultMap.append(javaType2jdbcType(javaType.toLowerCase()));
                resultMap.append("\" property=\"");
                resultMap.append(property);
                resultMap.append("\" />\n");

            }else if (f.getType().getSimpleName().equals("List")){

                resultMap.append("\n");
                resultMap.append("             <collection property=\"");
                resultMap.append(property);
                resultMap.append("\" javaType=\"java.util.ArrayList\" ofType=\"");
                //通过反射获取泛型
                ParameterizedType parameterizedType = (ParameterizedType) f.getGenericType();
                Type[] actualTypes = parameterizedType.getActualTypeArguments();
                for (Type type : actualTypes) {
                    resultMap.append(type.getTypeName());
                    resultMap.append("\">\n");
                    System.out.println(type.getTypeName()+"!!!!");
                    resultMap.append(generateResult(Class.forName(type.getTypeName())));
                }
//                resultMap.append(f.getGenericType().getTypeName());
                resultMap.append("             </collection>");
                resultMap.append("\n");
            }else  {
//                System.out.println(f.getType().getSimpleName()+"!!!!!!!!");
//                System.out.println(f.getType()); 获取路径
                resultMap.append("  <association property=\"");
                resultMap.append(property);
                resultMap.append("\" javaType=\"");
                resultMap.append(f.getType().toString().substring(6));
                resultMap.append("\" >\n");
//                System.out.println(f.getType()+"!!!!!!");
              System.out.println(f.getType().toString().substring(6)+"!!");

                resultMap.append(generateResult(Class.forName(f.getType().toString().substring(6))));//

                resultMap.append("        </association>\n");
            }
        }
        return resultMap.toString();
    }
    




    //驼峰转下划线命名
    private static String property2Column(String property){
        Matcher matcher = humpPattern.matcher(property);
        StringBuffer sb = new StringBuffer();
        while(matcher.find()){
            matcher.appendReplacement(sb, "_"+matcher.group(0).toLowerCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    //通过java类型获取jdbc类型
    private static String javaType2jdbcType(String javaType){
        String jdbcType = TYPE_MAP.get(javaType);
        return jdbcType==null ? "UNKNOWN" : jdbcType;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c9syua4r-1628751940058)(D:/desktop/%E6%88%91%E7%9A%84%E7%AC%94%E8%AE%B0/pichome/image-20210810165226479.png)]

请根据自己需求自行修改

记录报错

异常处理：java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.Parameterized

原因是有个类里面String 写出List 没泛型 加载不出来

异常处理
元素类型为 “association” 的内容必须匹配 “(constructor?,id*,result*,association*,collection*,discriminator?)”
元素类型为 “association” 的内容必须匹配 "或者元素类型为 “collection” 的内容必须匹配 "
请按照 ,id*,result*,association*,collection*,discriminator的顺序检查 resultmap
调整摆放顺序。

MyBatis的多表操作 – ResultMap封装结果集

1. 一对一查询

1.1一对一查询的模型

用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户

1.2 创建Order和User实体

public class Order {
    private int id;
    private Date ordertime;
    private double total;
    
    //代表当前订单从属于哪一个客户
    private User user;
}

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;
}

1.3 创建 OrderMapper 接口

public interface OrderMapper {
	List<Order> findAll();
}

1.4 配置OrderMapper.xml

<mapper namespace="com.itheima.mapper.OrderMapper">
    # 设置封装对象的结果集
    <resultMap id="orderMap" type="com.itheima.domain.Order">
        <result column="uid" property="user.id"></result>
        <result column="username" property="user.username"></result>
        <result column="password" property="user.password"></result>
        <result column="birthday" property="user.birthday"></result>
    </resultMap>
    
    <select id="findAll" resultMap="orderMap">
        select * from orders o,user u where o.uid=u.id
    </select>
</mapper>

还可以这样配置

<resultMap id="orderMap" type="com.itheima.domain.Order">
    <result property="id" column="id"></result>
    <result property="ordertime" column="ordertime"></result>
    <result property="total" column="total"></result>
    <association property="user" javaType="com.itheima.domain.User">
        <result column="uid" property="id"></result>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="birthday" property="birthday"></result>
    </association>
</resultMap>

1.5 测试结果

OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
List<Order> all = mapper.findAll();
for(Order order : all){
	System.out.println(order);
}

2. 一对多查询

2.1 一对多查询的模型

用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户
一对多查询的需求：查询一个用户，与此同时查询出该用户具有的订单

2.2 修改User实体

public class Order {
    private int id;
    private Date ordertime;
    private double total;
    
    //代表当前订单从属于哪一个客户
    private User user;
}

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;
    
    //代表当前用户具备哪些订单
    private List<Order> orderList;
}

public interface UserMapper {
	List<User> findAll();
}

2.3 创建UserMapper接口

public interface UserMapper {
	List<User> findAll();
}

2.4 UserMapper.xml

<mapper namespace="com.itheima.mapper.UserMapper">
    <resultMap id="userMap" type="com.itheima.domain.User">
        <result column="id" property="id"></result>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="birthday" property="birthday"></result>
        <collection property="orderList" ofType="com.itheima.domain.Order">
            <result column="oid" property="id"></result>
            <result column="ordertime" property="ordertime"></result>
            <result column="total" property="total"></result>
        </collection>
    </resultMap>
    
    <select id="findAll" resultMap="userMap">
        select *,o.id oid from user u left join orders o on u.id=o.uid
    </select>
</mapper>

2.5 测试结果

UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> all = mapper.findAll();
for(User user : all){
    System.out.println(user.getUsername());
    List<Order> orderList = user.getOrderList();
    for(Order order : orderList){
        System.out.println(order);
    }
    System.out.println("----------------------------------");
}

3. 多对多查询

3.1 多对多查询的模型

用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用
多对多查询的需求：查询用户同时查询出该用户的所有角色

3.2 创建Role实体，修改User实体

public class User {
    private int id;
    private String username;
    private String password;
    private Date birthday;
    
    //代表当前用户具备哪些订单
    private List<Order> orderList;
    //代表当前用户具备哪些角色
    private List<Role> roleList;
}

public class Role {
    private int id;
    private String rolename;
}

3.3 创建UserMapper接口

List<User> findAllUserAndRole();

3.4 UserMapper.xml

<resultMap id="userRoleMap" type="com.itheima.domain.User">
    <result column="id" property="id"></result>
    <result column="username" property="username"></result>
    <result column="password" property="password"></result>
    <result column="birthday" property="birthday"></result>
    <collection property="roleList" ofType="com.itheima.domain.Role">
        <result column="rid" property="id"></result>
        <result column="rolename" property="rolename"></result>
    </collection>
</resultMap>

<select id="findAllUserAndRole" resultMap="userRoleMap">
    select u.*,r.*,r.id rid from user u left join user_role ur on 
    u.id=ur.user_id
    inner join role r on ur.role_id=r.id
</select>

3.5 测试结果

UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> all = mapper.findAllUserAndRole();
for(User user : all){
    System.out.println(user.getUsername());
    List<Role> roleList = user.getRoleList();
    for(Role role : roleList){
        System.out.println(role);
    }
    System.out.println("----------------------------------");
}

4. MyBatis多表配置方式：

一对一配置：使用做配置
一对多配置：使用+做配置
多对多配置：使用+做配置

5. association 和 collection区别

1、关联-association 集合-collection
2、所以association是用于一对一和多对一，而collection是用于一对多的关系
3、JavaType和ofType都是用来指定对象类型的
JavaType是用来指定pojo中属性的类型
ofType指定的是映射到list集合属性中pojo的类型

6. resultMap的基础知识

<!--column不做限制，可以为任意表的字段，而property须为type 定义的pojo属性-->
<resultMap id="唯一的标识" type="映射的pojo对象">
  <id column="表的主键字段，或者可以为查询语句中的别名字段" jdbcType="字段类型" property="映射pojo对象的主键属性" />
  <result column="表的一个字段（可以为任意表的一个字段）" jdbcType="字段类型" property="映射到pojo对象的一个属性（须为type定义的pojo对象中的一个属性）"/>
    
  <association property="pojo的一个对象属性" javaType="pojo关联的pojo对象">
    <id column="关联pojo对象对应表的主键字段" jdbcType="字段类型" property="关联pojo对象的主席属性"/>
    <result  column="任意表的字段" jdbcType="字段类型" property="关联pojo对象的属性"/>
  </association>
    
  <!-- 集合中的property须为oftype定义的pojo对象的属性-->
  <collection property="pojo的集合属性" ofType="集合中的pojo对象">
    <id column="集合中pojo对象对应的表的主键字段" jdbcType="字段类型" property="集合中pojo对象的主键属性" />
    <result column="可以为任意表的字段" jdbcType="字段类型" property="集合中的pojo对象的属性" />  
  </collection>
    
</resultMap>

 <collection column="传递给嵌套查询语句的字段参数" property="pojo对象中集合属性" ofType="集合属性中的pojo对象" select="嵌套的查询语句" > 
 </collection>

7. association

嵌套结果集

<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则  -->
	<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
		<!-- 
			collection定义关联集合类型的属性的封装规则 
			ofType:指定集合里面元素的类型
		-->
		<collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
			<!-- 定义这个集合中元素的封装规则 -->
			<id column="eid" property="id"/>
			<result column="last_name" property="lastName"/>
			<result column="email" property="email"/>
			<result column="gender" property="gender"/>
		</collection>
	</resultMap>
	<!-- public Department getDeptByIdPlus(Integer id); -->
	<select id="getDeptByIdPlus" resultMap="MyDept">
		SELECT d.id did,d.dept_name dept_name,
				e.id eid,e.last_name last_name,e.email email,e.gender gender
		FROM tbl_dept d
		LEFT JOIN tbl_employee e
		ON d.id=e.d_id
		WHERE d.id=#{id}
	</select>

association-分段查询

<!-- collection：分段查询 -->
	<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
		<id column="id" property="id"/>
		<id column="dept_name" property="departmentName"/>
		<collection property="emps" 
			select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
			column="{deptId=id}" fetchType="lazy"></collection>
	</resultMap>

	<!-- public Department getDeptByIdStep(Integer id); -->
	<select id="getDeptByIdStep" resultMap="MyDeptStep">
		select id,dept_name from tbl_dept where id=#{id}
	</select>
	
	<!-- 扩展：多列的值传递过去：
			将多列的值封装map传递；
			column="{key1=column1,key2=column2}"
		fetchType="lazy"：表示使用延迟加载；
				- lazy：延迟
				- eager：立即
	 -->

8.association-分段查询&延迟加载

<settings>
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <setting name="jdbcTypeForNull" value="NULL"/>

    <!--显式的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题  -->
    <setting name="cacheEnabled" value="true"/>
    <!-- 延迟加载 --->
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载.

好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

<!--显式的指定每个我们需要更改的配置的值，即使他是默认的。防止版本更新带来的问题  -->
<setting name="cacheEnabled" value="true"/>
<!-- 延迟加载 --->
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>

延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载.

好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。