精华内容
下载资源
问答
  • 延迟加载

    2017-09-23 16:27:00
    MyBatis中的延迟加载,也称为懒加载,是指在进行关联查询时,按照设置延迟加载规则推迟对关联对象的select查询。延迟加载可以有效的减少数据库压力。 注意:MyBatis的延迟加载只是对关联对象的查询有延迟设置,对于...

       

    MyBatis中的延迟加载,也称为懒加载,是指在进行关联查询时,按照设置延迟加载规则推迟对关联对象的select查询。延迟加载可以有效的减少数据库压力。
      注意:MyBatis的延迟加载只是对关联对象的查询有延迟设置,对于主加载对象都是直接执行查询 的

    关联对象的加载时机

    MyBatis根据对关联对象查询的select语句的执行时机,分为3种类型:
    1.直接加载
    2.侵入式延迟加载
    3.深度延迟加载

    关联查询的加载时机

    直接加载:执行完对主加载对象的select语句,马上执行对关联对象的 查询
    侵入式延迟加载:执行对主加载对象的查询时,不会执行对关联对象的查询。但是当要访问主加载对象的详情时,就会马上执行关联对象的select查询。

          即对关联对象的查询执行,侵入到了主加载对象的详情访问中。也可以这样理解:将关联对象的详情侵入到了主加载对象的详情中,即将关联对象的详情作为主加载对象详情的一部分出现了

    深度延迟加载:执行对主加载对象的查询时,不会执行对关联对象的查询。访问主加载对象的详情时也不会执行关联对象的select查询。只有当真正访问关联对象的详情时,才会执行对关联对象的select查询。

    注意:延迟加载的应用要求:关联对象的查询与主加载对象的查询必须是分别进行的select语句,不能是使用多表连接所进行的select查询。

    因为,多表连接查询,实质是对一张表的查询,对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。

    在大配置mybatis-config.xml

    <settings>
        <setting name="lazyLoadingEnabled" value="true"/> <!--延迟加载-->
        <setting name="aggressiveLazyLoading" value="false"></setting><!--侵入式加载-->
    </settings>


     

       @Test
        public void LazyLoading() {//延迟加载
        SqlSession session = MybatisUtil.getSession();
        IDeptOneToManyDao dao = session.getMapper(IDeptOneToManyDao.class);
            DeptOneToMany dept = dao.getDeptByDeptNoMultiSQL(1);
                System.out.println(dept.getDeptname() );
    
        session.close();
    }
    }

     

     



       

    转载于:https://www.cnblogs.com/cuixiaomeng/p/7581589.html

    展开全文
  • Mybatis06_延迟加载

    万次阅读 2020-08-06 19:36:01
    Mybatis06_延迟加载 将原始的关联查询SQL改为单表查询,修改Map映射 StudentRepository.xml <resultMap type="com.blu.entity.Student" id="studentLazyMap"> <id column="id" property="id"></...

    Mybatis06_延迟加载


    • 将原始的关联查询SQL改为单表查询,修改Map映射

    StudentRepository.xml

    <resultMap type="com.blu.entity.Student" id="studentLazyMap">
    	<id column="id" property="id"></id>
    	<result column="name" property="name"></result>
    	<association property="classes" javaType="com.blu.entity.Classes"
    			select="com.blu.repository.ClassesRepository.findByIdLazy" column="cid">
    	</association>
    </resultMap>
    
    <select id="findByIdLazy" parameterType="long" resultMap="studentLazyMap">
    	select * from student where id = #{id}
    </select>
    

    ClassesRepository.xml

    <select id="findByIdLazy" parameterType="long" resultType="com.blu.entity.Classes">
    	select * from classes where id = #{id}
    </select>
    

    测试:

    StudentRepository studentRepository = session.getMapper(StudentRepository.class);
    Student student = studentRepository.findByIdLazy(1L);
    System.out.println(student.getName());
    
    ==>  Preparing: select * from student where id = ? 
    ==> Parameters: 1(Long)
    <==    Columns: id, name, cid
    <==        Row: 1, 张三, 2
    ====>  Preparing: select * from classes where id = ? 
    ====> Parameters: 2(Long)
    <====    Columns: id, name
    <====        Row: 2, 2班
    <====      Total: 1
    <==      Total: 1
    张三
    
    • 开启延迟加载
    <settings>
    	<!--  打印SQL -->
    	<setting name="logImpl" value="STDOUT_LOGGING"/>
    	<!--  开启延迟加载(默认关闭) -->
    	<setting name="lazyLoadingEnabled" value="true"/>
    </settings>
    

    再次测试:

    ==>  Preparing: select * from student where id = ? 
    ==> Parameters: 1(Long)
    <==    Columns: id, name, cid
    <==        Row: 1, 张三, 2
    <==      Total: 1
    张三
    
    展开全文
  • hibernate延迟加载有以下三种: 类的延迟加载: get方法没有延迟加载 load方法默认有延迟加载。可以在配置文件中进行配置 使用lacy是否启用延迟加载延迟加载必须在同一个session中。session关闭了就不会有延迟...

    hibernate延迟加载有以下三种:

    类的延迟加载:

    get方法没有延迟加载
    load方法默认有延迟加载。可以在配置文件中进行配置 使用lacy是否启用延迟加载。
    延迟加载必须在同一个session中。session关闭了就不会有延迟加载。

    集合的延迟加载:

    通常是在一对多和多对多关系中使用。
    使用load方法的时候会有延迟加载但是还是受到 lazy的控制。
    当lazy=true的时候,如果查询集合的数量时,效率低下我们需要把lazy=extra,这样发出的sql语句比较智能,效率比较高。
    集合的延迟加载效果不受类上的延迟加载效果影响。
    类的延迟加载lazy就在class上进行设置,集合的延迟加载lazy就在set上进行设置。
    在实际工作中用的比较多的是集合的延迟加载,需要重点掌握

    单端延迟加载:

    通常使用在多对一和一对一中。
    在many-to-one标签中进行修改。
    类上的延迟加载对单端延迟加载有影响
    如果类的延迟加载 lazy=false many-to-one lazy=proxy 那么单端不会有延迟加载

    展开全文
  • HTML延迟加载图片 html图片延迟加载技术大全.zip
  • 页面延迟加载源码下载,图片延迟加载源码下载,jquery页面延迟加载,页面延迟加载技术实现分析
  • 1、延迟加载: 就是在需要用到数据时才进行加载,不需要用到数据时就不加载数据。延迟加载也称懒加载 2、好处: 先从单表查询,需要时再从关联表去关联查询,大大提高数据库性能,因为查询单表要比关联查询多张表...

    一、概述

    1、延迟加载:

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

    2、好处:

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

    3、坏处:

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

    4、MyBatis 多表查询
    在多表查询时,使用了resultMap来实现一对一,一对多,多对多关系的操作。主要是通过 associationcollection 实现一对一及一对多映射。associationcollection 具备延迟加载功能。

    二、association 延迟加载、collection 延迟加载

    association : 用于一对多(一个用户对应多个账号:User ——> Account)
    collection :用于多对一

    第一步:封装对数据库映射的实体类 User.java、Account.java
    package cn.lemon.domain;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    public class User implements Serializable {
        private Integer id;
        private Date birthday;
        private String username;
        private String sex;
        private String address;
    
        private List<Account> accountList = new ArrayList<>();
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public List<Account> getAccountList() {
            return accountList;
        }
    
        public void setAccountList(List<Account> accountList) {
            this.accountList = accountList;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", birthday=" + birthday +
                    ", username='" + username + '\'' +
                    ", sex='" + sex + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }
    123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
    package cn.lemon.domain;
    
    import java.io.Serializable;
    
    public class Account implements Serializable {
        private Integer id;
        private Integer uid;
        private Double money;
    
        private User user;//关联属性,记录关联关系
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public Integer getUid() {
            return uid;
        }
    
        public void setUid(Integer uid) {
            this.uid = uid;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", uid=" + uid +
                    ", money=" + money +
                    '}';
        }
    }
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152
    
    第二步:新建持久层(dao)接口 IUserDao.java 、IAccountDao.java,操作数据库
    package cn.lemon.dao;
    
    import cn.lemon.domain.User;
    
    import java.util.List;
    
    public interface IUserDao {
        public User findById(Integer userId);
    
        public List<User> findAll();
    }
    1234567891011
    package cn.lemon.dao;
    
    import cn.lemon.domain.Account;
    
    import java.util.List;
    
    public interface IAccountDao {
        public List<Account> findAll();
    }
    123456789
    
    第三步:新建配置文件 SqlMapConfig.xml (配置懒加载)和 jdbcConfig.properties

    在这里插入图片描述

    <?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">
    <!--mybatis配置文件-->
    <configuration>
        <!--配置属性或使用属性文件-->
        <properties resource="jdbc.properties"/>
    
        <!--全局属性配置-->
        <settings>
            <!--开启Mybatis支持延迟加载-->
            <setting name="lazyLoadingEnabled" value="true"/>
            <!--关闭积极延迟加载:任何属性都会引起延迟加载-->
            <setting name="aggressiveLazyLoading" value="false"></setting>
        </settings>
    
        <!--给包定义别名-->
        <typeAliases>
            <!--定义单个别名-->
            <!--<typeAlias type="com.lxs.domain.User" alias="user"></typeAlias>-->
            <!--配置包定义别名,别名=包中的类的名字(首字母大写小写都可以)-->
            <package name="cn.lemon.domain"/>
        </typeAliases>
        <!--配置环境-->
        <environments default="mysql">
            <environment id="mysql">
                <!--事务类型-->
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <!--配置连接池(数据源)-->
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
    
        <!--配置映射文件-->
        <mappers>
            <!--配置单个映射文件-->
            <!--<mapper resource="com/lxs/dao/IUserDao.xml"></mapper>-->
            <package name="cn.lemon.dao"/>
        </mappers>
    </configuration>
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546
    driver=com.mysql.jdbc.Driver
    url=jdbc:mysql:///db_mybatis
    username=root
    password=lemon
    1234
    
    第四步:编写持久层接口的映射文件 IUserDao.xml、IAccountDao.xml

    <?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="cn.lemon.dao.IUserDao">
        <select id="findById" resultType="user" parameterType="int">
          SELECT * FROM user WHERE id = #{uid}
        </select>
    
        <select id="findAll" resultMap="userMap">
            SELECT * FROM user
        </select>
    
        <resultMap id="userMap" type="user">
            <id column="id" property="id"></id>
            <!--collection:映射一对多的一的一方(主表方)的集合属性
                    ofType:集合的元素类型,可以写别名
                    select: 查询关联集合的select语句
                    column:查询关联集合的语句的参数
            -->
            <collection property="accountList" ofType="Account" select="cn.lemon.dao.IAccountDao.findByUid" column="id">
                <id column="id" property="id"/>
            </collection>
        </resultMap>
    </mapper>
    12345678910111213141516171819202122232425
    <?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="cn.lemon.dao.IAccountDao">
        <select id="findAll" resultMap="accountMap">
          select * from account
        </select>
    
        <resultMap id="accountMap" type="account">
            <id column="id" property="id"/><!--字段名等于属性名可以省略-->
            <result column="uid" property="uid"/>
            <!--<result property="money" column="money"></result>-->
    
            <!--association映射多对一,多的一方的实体属性
                    * select: 调用select映射的语句查询关联的user数据
                    * column: 调用select映射的语句的输入参数
            -->
            <association property="user" javaType="user" select="cn.lemon.dao.IUserDao.findById" column="uid">
                <!--主键不能省略-->
                <id column="id" property="id"/>
                <!-- 同名属性可以省略 -->
                <result property="username" column="username"/>
                <!--<result property="birthday" column="birthday"></result>-->
                <!--<result property="sex" column="sex"></result>-->
                <!--<result property="address" column="address"></result>-->
            </association>
        </resultMap>
    
        <select id="findByUid" resultType="Account" parameterType="int">
            SELECT * FROM account WHERE uid= #{aid}
        </select>
    </mapper>
    123456789101112131415161718192021222324252627282930313233
    
    第五步:测试类
    package cn.lemon.dao;
    
    import cn.lemon.domain.User;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.io.InputStream;
    import java.util.List;
    
    public class IUserDaoTest {
        private InputStream inputStream;
        private SqlSessionFactory sqlSessionFactory;
        private SqlSession sqlSession;
        private IUserDao iUserDao;
    
        @Before
        public void init() throws Exception {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession = sqlSessionFactory.openSession(true);
            iUserDao = sqlSession.getMapper(IUserDao.class);
        }
    
        @Test
        public void findById() {
        }
    
        @Test
        public void findAll() {
            List<User> userList = iUserDao.findAll();
            for (User user : userList) {
                System.out.println(user);
                System.out.println("====================================================================");
            }
            System.out.println("-------------------------------------------------------------------------");
            System.out.println("第一个用户的账户" + userList.get(0).getAccountList());
        }
    
        @After
        public void destory() throws Exception {
            sqlSession.close();
            inputStream.close();
        }
    }
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849
    package cn.lemon.dao;
    
    import cn.lemon.domain.Account;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.junit.After;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.io.InputStream;
    import java.util.List;
    
    import static org.junit.Assert.*;
    
    public class IAccountDaoTest {
        private InputStream inputStream;
        private SqlSessionFactory sqlSessionFactory;
        private SqlSession sqlSession;
        private IAccountDao iAccountDao;
    
        @Before
        public void init() throws Exception {
            inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession = sqlSessionFactory.openSession(true);
            iAccountDao = sqlSession.getMapper(IAccountDao.class);
        }
    
        @Test
        public void findAll() {
            List<Account> accountList = iAccountDao.findAll();
            for (Account account : accountList) {
                System.out.println(account);
                System.out.println("--------------------------------------------------------------------------------");
            }
            System.out.println("***************************************************************************");
            System.out.println("第一个账户的用户为:" + accountList.get(0).getUser());//当使用用户时才查询用户,称为懒加载
        }
    
        @After
        public void destory() throws Exception {
            sqlSession.close();
            inputStream.close();
        }
    }
    
    展开全文
  • mybatis 延迟加载什么是延迟加载延迟加载又叫懒加载,也叫按需加载,也就是说先加载主信息,需要的时候,再去加载从信息。代码中有查询语句,当执行到查询语句时,并不是马上去DB中查询,而是根据设置的延迟策略将...
  • Hibernae 的延迟加载是一个非常常用的技术,实体的集合属性默认会被延迟加载,实体所关联的实体默认也会被延迟加载。Hibernate 通过这种延迟加载来降低系统的内存开销,从而保证 Hibernate 的运行性能。下面先来剖析...
  • 很多刚刚接触mybatis的人都不知道应该如何去实现延迟加载,那么具体的要怎样才能实现呢?下面就让我们一起详细的来进行一下了解。其实mybatis延迟加载就是按需查询(也就是在需要时进行查询)。下面有两张表,分别是...
  • 延迟加载基本概念上面我们已经知道使用association、collection可以实现一对一及一对多映射,association、collection还有另外一个延迟加载的功能。延迟加载(lazy load)是关联对象默认的加载方式,延迟加载机制是...
  • 主要介绍了使用jquery实现的一个图片延迟加载插件,同时讲解了图片延迟加载的原理,还有无阻塞加载广告的功能哦,需要的朋友可以参考下
  • 什么是延迟加载延迟加载又叫懒加载,也叫按需加载,也就是说先加载主信息,需要的时候,再去加载从信息。代码中有查询语句,当执行到查询语句时,并不是马上去DB中查询,而是根据设置的延迟策略将查询向后推迟。什么...
  • 1. 延迟加载什么是延迟加载延迟加载 的反义词就是 立即加载,立即加载 是指在取得“省”对象时(此处的数据库表:省包含市),省中所有的“市”对象都已经提取到内存中,因此其非常耗费 CPU 和内存资源。有时只需要...
  • 延迟加载(lazy load)是(也成为懒加载)Hibernate关联关系对象默认的加载方式,延迟加载机制是为了避免一些无谓的性能开销而提出来的,所谓延迟加载就是当在真正需要数据的时候,才真正执行数据加载操作。...
  • 延迟加载,玩过hibernate的都知道那玩意叫懒加载。 在最新官方MyBatis文档里,有上面这2个属性,一个是延迟加载,一个是分层加载。 lazyLoadingEnabled 默认值为false,那么在有级联关系的resultMap里,查询后会加载...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,174
精华内容 8,469
关键字:

延迟加载