精华内容
下载资源
问答
  • resultmap
    2020-12-30 18:22:45

    resultmap与resulttype的区别为:对象不同、描述不同、类型适用不同

    一、对象不同

    1、resultmap:resultMap如果查询出来的列名和pojo的属性名不一致,通过定义一个resultMap对列名和pojo属性名之间作一个映射关系。

    2、resultType:resultType使用resultType进行输出映射,只有查询出来的列

    看源码都要带着问题去看,比如

    UserMapper.java只有接口而没有实现类,那么是如何执行的呢?mybatis中一级缓存是如何进行缓存与维护的?底层是如何执行query查询的查询后的结果是如何处理的,为什么可以将结果集自动映射到对象中去?

    让我们带着上面的问题来到mybatis框架底层一探究

    MyBatis 提供了XML配置和注解配置两种方式。今天就来搞搞这两种方式是如何实现的。

    MyBatis 的真正强大在于它的语句映射,这是它的魔力所在。由于它的异常强大,映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的JDBC 代码进行对比,你会立即发现省掉了将近 95% 的代码。MyBa

    ResultMap2020-11-27 22:03:50

    ResultMap

    要解决的问题,属性名和数据库表格字段名不一致问题

    在项目中,新建一个模块mybatis-02,内容和mybatis-01一样。

    1、查看数据库user表的字段名

    2、修改Java中的实体类,使其属性名与数据库的字段名不一致

    public class User {

    private int id;

    private String userna

    Mybatis 的输出结果封装

    1.resultType 配置结果类型

    1.1基本类型示例

    List findAll();

    User findById(Integer userId);

    List findByName(String username);

    int findTotal();

    List findUserByVo(QueryVo vo);

    Mybatis之resultMap2020-11-24 15:00:47

    resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来,并在一些情形下允许你进行一些 JDBC 不支持的操作。实际上,在为一些比如连接的复杂语句编写映射代码的时候,一份 resultMap 能够代替实现同等功能的数千行代码。Re

    说明

    项目如果需要动态的生成SQL语句,那么语句中的字段名是一个比较麻烦的事情,虽然Entity对象和数据表一般是一比一按照驼峰命名法和下划线命名法标准转换来映射的,但是简单的将Entity对象中的属性转为字段名是一个有风险的操作

    有没有哪里记录了实体类属性和数据表字段的映射关系呢

    1.生命周期,和作用域,是至关重要的,因为错误的使用会导致严重的并发问题

    并发问题流程图

    注意:每一个sqlSession对应一个业务

    在用sqlSession去写增删改相关的业务时用提交事务(sqlSession.commit();)

    在每个持久层操作完毕后要将sqlSession关闭(sqlSession.close())

    本文讲述获取当前项目的所有restful请求的详细信息,含url、接口描述、请求方式等信息,主要用到了swagger的相关特性,最终返回的数据格式如下:

    [{

    "className": "cn.miao.controller.InfoController",

    "classDesc": "InfoController",

    "methodName": "getTimeStam

    封装MyBatis输出结果2020-08-07 22:01:51

    目录一、resultType1. 简单类型(掌握)2. 对象类型(掌握)3. Map(了解)二、resultMap(了解)三、实体类属性名和列名不同1. 使用resultMap2. 使用列别名和resultType四、模糊查询like1. 第一种2. 第二种五、总结1. resultType2. resultMap3. 列名和属性名不同4. like

    一、resultType

    6、ResultMap

    要解决的问题:属性名和字段名不一致

    1、查看之前的数据库的字段名

    2、Java中的实体类设计

    public class User {

    private int id; //id

    private String name; //姓名

    private String password; //密码和数据库不一样!

    //构造

    //set/get

    //

    Mybatis创建statement和结果集生成statementHandler结果集处理后记

    前文:Mybatis(3)执行sql过程

    statementHandler

    在Mybatis的Configuration类中, 存在下面三个方法, 我们想要生成一个statment就需要通过一个statemeng的处理器

    public ParameterHandler newParameterHand

    Mybatis 自定义映射关系2020-06-19 21:53:31

    原由

    最近做项目,由于数据库的字段名和pojo对象中的名称不一样,导致 Mybatis查出来的数据没有办法直接绑定到POJO对象上,所以我就去回顾了以下mybatis的集合绑定。

    代码

    (4)输出参数为HashMap

    <

    mybatis的pageHelper分页遇上collection时,total统计会是根据sql查询出来的数量进行统计的,而我们页面上的总数应该显示我们resultMap的数量。resultMap不要使用直接嵌套结果的方式,可是使用嵌套查询:

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200309102905637.png

    一的一方College.java:

    多的一方Student.java

    College的sqlmapper文件配置

    更多相关内容
  • 主要介绍了MyBatis中resultMap和resultType的区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了mybatis 不同Mapper文件引用resultMap的实例代码,非常不错具有参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了mybatis的mapper.xml中resultMap标签的使用详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • MyBatis中在查询进行select映射的时候,返回类型可以用resultType,也可以用resultMap,那么MyBatis中关于resultType和resultMap的区别是什么呢?下面小编通过本文给大家解答下
  • ResultMap

    2021-05-15 10:48:05
    2.ResultMap 介绍:结果集映射 首先,查询语句的返回值用ResultMap不用ResultType; 然后,在mapper大标签里添加resultmap标签,里面设置标签的id,和映射的类型type resultmap标签里,column是数据库查询的字段(列...

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

    2.ResultMap
    介绍:结果集映射
    在这里插入图片描述

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

    展开全文
  • 给大家介绍了mybatis中的resultType和resultMap的用法实例讲解,MyBatis中在查询进行select映射的时候,返回类型可以用resultType,也可以用resultMap,至于两种用法区别,通过本文一起学习吧
  • mybatis 一对多collection的使用 在mybatis如何进行一对多的多表查询呢?这里用一个简单的例子说明
  • 主要介绍了mybatis教程之resultmap,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • resultMap 标签用来描述如何从数据库结果集中来加载对象,这篇文章重点给大家介绍mybatis中resultMap 标签的使用,感兴趣的朋友一起看看吧
  • mybatis-demo4-resultMap手动映射.zip
  • 生成ResultMap

    2021-08-12 15:05:49
    生成ResultMap 自己写个工具类,懒得写resultmap了 只适用于规范命名并且类中属性和库中名一样的, 需要自己配置一下id import com..MallOrderListV2Info; import org.junit.Test; import java.lang.reflect....

    生成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封装结果集

    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"/>
    
    ```

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

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

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

    展开全文
  • Mybatis--自定义映射ResultMap

    千次阅读 多人点赞 2022-04-02 22:23:04
    select> 1.3方法三 使用ResultMap进行自定义映射 因为ResultMap是自定义映射,所以需要设置字段和属性的关系 <resultMap id="empResultMap" type="Emp"> <id property="eid" column="eid">id> ...
  • Mybatis resultMap 嵌套集合

    千次阅读 2021-12-20 00:34:22
    resultMap 是 Mybatis 最强大的元素,它可以将查询到的复杂数据(比如查询到几个表中数据)映射到一个结果集当中。resultMap 包含的元素:<!--column不做...
  • 是Maybatis的结果集封装,搭配等标签的resultMap属性使用 属性: id:该封装规则的唯一标识 type:封装出来的类型,可以是jdk自带的,比如Map,应该可以是自定义的,比如Employee autoMapping:自动封装,如果数据库...
  • Mybatis中强大的resultMap

    2020-12-23 17:08:47
    前言在Mybatis中,有一个强大的功能元素resultMap。当我们希望将JDBC ResultSets中的数据,转化为合理的Java对象时,你就能感受到它的非凡之处。正如其官方所述的那样:resultMap元素是 MyBatis 中最重要最强大的...
  • 在Mybatis中,有一个强大的功能元素resultMap。当我们希望将JDBC ResultSets中的数据,转化为合理的Java对象时,你就能感受到它的非凡之处。正如其官方所述的那样: resultMap元素是 MyBatis 中最重要最强大的元素...
  • MyBatis06-自定义ResultMap

    2022-03-08 14:29:04
    比如:emp_name->empName <settings> <setting name="mapUnderscoreToCamelCase" value="true"/> settings> 方式3:使用resultMap,自定义结果集 resultMap的id:resultMap唯一标识 type:对应实体类 id:设置主键...
  • 前言在Mybatis中,有一个强大的功能元素resultMap。当我们希望将JDBC ResultSets中的数据,转化为合理的Java对象时,你就能感受到它的非凡之处。正如其官方所述的那样:resultMap元素是 MyBatis 中最重要最强大的...
  • MyBatis中ResultMap使用实例解析

    千次阅读 2020-02-06 15:15:14
    select元素和resultMap元素使用resultMap中的id属性与select元素中的resultMap属性进行关联。select中若使用resultMap则resultType属性则会失效。 resultMap元素中,type属性指明返回集的类型。 和元素都是...
  • 建立SQL查询结果字段与实体属性的映射关系,简单说就是若字段名和实体类中的属性名不一致,则可以通过resultMap设置自定义映射
  • MyBatis——详解ResultMap结果映射

    千次阅读 2021-11-30 23:53:28
    用通俗易懂的文笔讲解MyBatis的ResultMap结果映射,让我们一起来感受ResultMap的迷人之处。
  • Mybatis的映射文件中顶级的标签并不多,之前有说过select、update、delete、insert、sql等标签,resultMap在之前的文章也有提过,但是当时也是简单的提过,其实这个标签里面的内容很多,可简单可复杂。正常开发中...
  • ResultMap collection多层嵌套使用

    千次阅读 热门讨论 2019-12-04 23:46:37
    ResultMap collection多层嵌套使用 ResultMap介绍 在Mybatis使用中,ResultMap是最复杂的一种结构,也是功能最强大的结构之一。通过ResultMap能够将复杂的1对多的结果集映射到一个实体当中去,可以借助Mybatis来将...
  • MyBatis中resultMap详解

    千次阅读 2020-11-08 20:45:26
    MyBatis 中 resultMap 详解 resultMap 是 Mybatis 最强大的元素之一,它可以将查询到的复杂数据(比如查询到几个表中数据)映射到一个结果集当中。如在实际应用中,有一个表为(用户角色表),通过查询用户表信息...
  • 在 mybatis 中, resultMap 节点定义了结果集和结果对象(JavaBean)之间的映射规则。 本文主要讲解的是 resultMap 的解析。 两个基础类 在阅读本文之前, 最好能对这两个类有相应的理解。 1.1、列映射...
  • resultMap使用方法

    千次阅读 2021-12-21 16:25:52
    resultMap的使用方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 127,560
精华内容 51,024
关键字:

resultmap

友情链接: mathjiexi.rar