Mybatis04:延迟加载、一二级缓存、注解开发

今日内容

mybatis中的延迟加载

延迟加载的概念
立即加载的概念
如果实现延迟加载

Mybatis中的缓存

什么是缓存
为什么使用缓存
什么数据可以使用缓存，什么样的数据不能使用缓存
Mybatis中的一级缓存和二级缓存

Mybatis中的注解开发

环境搭建
单表crud操作（代理dao方式）
多表查询操作
缓存的配置

一、延迟加载

1、背景

问题：在一对多中，当有1个用户有100个账户

查询用户时，是否需要把关联的账户查出来

内存的巨大开销，但如果不查出来，无法使用
即：在查询用户时，什么时候使用账户信息，什么时候去查（根据用户的需求）

在查询账户时，是否需要把关联的用户查出来

在查询账户时，账户的所属用户信息应该随着账户查询时一起查询出来

2、延迟加载和立即加载的概念

延迟加载：在真正使用数据时才发起查询，不用的时候不查询，需要按需加载（懒加载）
立即加载：不管用不用，只要一调用方法，马上发起查询
选择：在四种表关系中

一对多，多对多：通常情况下采用延迟加载（集合浪费及内存空间）
多对一，一对一：采用立即加载

3、mybatis一对一实现延迟加载--association

查询账户对应的用户【只查账户不查用户】

<configuration>

    <properties resource="jdbcConfig.properties">

    </properties>

    <settings>

        <!--开启Mybatis支持延迟加载-->

        <setting name="lazyLoadingEnabled" value="true"/>

        <!--Mybatis每个属性都会按需加载-->

        <setting name="aggressiveLazyLoading" value="false"/>

    </settings>

<mapper namespace="com.itcast.dao.IAccountDao">

    <!--定义封装account和user的resultMap-->

    <resultMap id="accountUserMap" type="account">

        <id property="id" column="id"></id>

        <result property="uid" column="uid"></result>

        <result property="money" column="money"></result>

        <!--应当建立一对一的关系映射：配置封装user的内容-->

        <!--

            使用association标签配置延迟加载

            通过select属性指定的唯一内容，查询用户的唯一标识-根据id查询用户的配置

            column属性指定的内容：用户根据id查询时，所需要参数的值

        -->

        <association property="user" column="uid" javaType="user" select="com.itcast.dao.IUserDao.findById">

        </association>

    </resultMap>

    <select id="findAll" resultMap="accountUserMap" >

        SELECT * FROM account

    </select>

</mapper>

    <select id="findById" parameterType="int" resultType="user">

        select * from user where id = #{uid}

    </select>

   /**

     * 测试查询所有

     */

    @Test

    public void testFindAll(){

        List<Account> accounts = accountDao.findAll();

        /*for (Account account : accounts) {

            System.out.println("-----每个account的信息-----");

            System.out.println(account);

            System.out.println(account.getUser());*/

        }

4、mybatis一对多实现延迟加载--collection

查询用户下的账户信息，对账户信息进行延迟加载（一对多）【只查用户不查账户】

<mapper namespace="com.itcast.dao.IAccountDao">

    <!--定义封装account和user的resultMap-->

    <resultMap id="accountUserMap" type="account">

        <id property="id" column="id"></id>

        <result property="uid" column="uid"></result>

        <result property="money" column="money"></result>

        <!--应当建立一对一的关系映射：配置封装user的内容-->

        <!--

            使用association标签配置延迟加载

            通过select属性指定的唯一内容，查询用户的唯一标识-根据id查询用户的配置

            column属性指定的内容：用户根据id查询时，所需要参数的值

        -->

        <association property="user" column="uid" javaType="user" select="com.itcast.dao.IUserDao.findById"></association>

        <collection property="accounts" ofType="account" select="com.itcast.dao.IUserDao.findAccountByUid" column="id"></collection>

    </resultMap>

    <!--根据用户id查询账户列表-->

    <select id="findAccountByUid" resultType="account">

        SELECT * FROM account where uid = #{uid}

    </select>

</mapper>

<mapper namespace="com.itcast.dao.IUserDao">

    <!--定义user的resultMap-->

    <resultMap id="userAccountMap" type="user">

        <id property="id" column="id"></id>

        <result property="username" column="username"></result>

        <result property="address" column="address"></result>

        <result property="sex" column="sex"></result>

        <result property="birthday" column="birthday"></result>

        <!--配置user对象中account集合的映射-->

        <collection property="accounts" ofType="account">

        </collection>

    </resultMap>

    <select id="findAll" resultMap="userAccountMap" >

        SELECT * FROM USER

    </select>

</mapper>

    /**

     * 测试查询所有

     */

    @Test

    public void testFindAll(){

        List<User> users = userDao.findAll();

        /*for (User user : users) {

            System.out.println("-----每个account的信息-----");

            System.out.println(user);

            System.out.println(user.getAccounts());

        }*/

    }

二、缓存

1、缓存的概念

什么是缓存：存在于内存中的临时数据
为什么使用缓存：减少和数据库的交互次数，提高执行效率
适用于缓存的数据：

经常用于查询并且不经常改变的
数据的正确与否对最终结果影响不大

不适用于缓存：

经常改变的数据
数据的正确与否对最终结果影响很大，如商品的库存、银行的汇率、股市的牌价

2、Mybatis中的一级缓存

指的是Mybatis中SQLSession对象的缓存，即当执行查询之后，查询的结果会同时存入到SQLSession提供的一块区域中，该区域的结构是一个map；当再次查询同样数据时，Mybatis会先去SqlSession中查看是否有map，如果有的话，直接拿来使用
当SqlSession对象消失时，Mybatis的一级缓存也会消失

<?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.itcast.dao.IUserDao">

    <select id="findAll" resultType="user">

        SELECT * FROM USER

    </select>

    <select id="findById" parameterType="int" resultType="user">

        SELECT * FROM USER where id = #{uid}

    </select>

</mapper>

 	/**

     * session关闭，缓存消失

     */

    @Test

    public void testFirstLevelCache(){

        User user1 = userDao.findById(41);

        System.out.println(user1);

        //关闭sesson

        /*sqlSession.close();

        sqlSession = factory.openSession();

        userDao = sqlSession.getMapper(IUserDao.class);*/

        //SQLSession清空缓存的方法，也可以清空缓存，执行两次查询

        sqlSession.clearCache();

        User user2 = userDao.findById(41);

        System.out.println(user2);

        System.out.println(user1==user2);

    }

3、触发清空一级缓存的情况

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。

    <!--更新用户信息-->

    <update id="updateUser" parameterType="user">

        update user set username=#{username},address=#{address} where id =#{id}

    </update>

    /**

     * 测试缓存的同步

     */

    @Test

    public void testClearCache(){

        //1.根据id查询用户

        User user1 = userDao.findById(41);

        System.out.println(user1);

        //2.更新用户信息

        user1.setUsername("clear cache");

        user1.setAddress("望京");

        //userDao.updateUser(user1);

        //3.再次查询id为41的用户

        User user2 = userDao.findById(41);

        System.out.println(user2);

        System.out.println(user1==user2);

    }

8、mybatis的二级缓存

概念：指的是Mybatis中，SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。

    /**

     * session关闭，缓存消失

     */

    @Test

    public void testFirstLevelCache(){

        SqlSession sqlSession1 = factory.openSession();

        IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);

        User user1 = dao1.findById(41);

        System.out.println(user1);

        sqlSession1.close();//一级缓存消失

        SqlSession sqlSession2 = factory.openSession();

        IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);

        User user2 = dao2.findById(41);

        System.out.println(user2);

        sqlSession2.close();

        System.out.println(user1==user2);

    }

//结果不可以

使用步骤：

第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）

<configuration>

    <properties resource="jdbcConfig.properties">

    </properties>

    <settings>

        <setting name="cacheEnabled" value="true"/>

        <!--默认为true-->

    </settings>

第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）

第三步：让当前的操作支持二级缓存（在select标签中配置）

<mapper namespace="com.itcast.dao.IUserDao">

    <!--开启user支持二级缓存-->

    <select id="findAll" resultType="user" useCache="true">

        SELECT * FROM USER

    </select>

存放数据而不是对象，每次都会创建新的用户对象

三、注解开发【单表和多表】

1、注解开发的环境搭建

之前两个xml：SqlMapConfig.xml和IUserDao.xml
注解开发只是配置IUserDao.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>

    <!-- 引入外部配置文件 -->

    <properties resource="jdbcConfig.properties"></properties>

    <!-- 配置别名 -->

    <typeAliases>

        <package name="com.itheima.domain"></package>

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

    <!-- 指定带有注解的dao接口所在位置 -->

    <mappers>

        <package name="com.itheima.dao"></package>

    </mappers>

</configuration>

package com.itheima.dao;

import com.itheima.domain.User;

import org.apache.ibatis.annotations.Select;

import java.util.List;

/**

 * 在Mybatis中，针对CRUD共有4个注解

 * @Select @Insert @Update @Delete

 */

public interface IUserDao {

    /**

     * 查询所有用户

     * @return

     */

    @Select("select * from user")

    List<User> findAll();

}

2、注解开发测试和使用注意事项

package com.itheima.test;

import com.itheima.dao.IUserDao;

import com.itheima.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 java.io.IOException;

import java.io.InputStream;

import java.util.List;

public class MybatisAnnoTest {

    /**

     * 测试基于注解的Mybatis使用

     * @param args

     */

    public static void main(String[] args) throws IOException {

        //1.获取字节输入流

        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.根据字节输入流获取SqlSessionFactory

        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

        //3.根据SqlSessionFactory生产一个SqlSession

        SqlSession session = factory.openSession();

        //4.使用SqlSession获取Dao的代理对象

        IUserDao userDao = session.getMapper(IUserDao.class);

        //5.执行Dao的方法

        List<User> users = userDao.findAll();

        for (User user : users) {

            System.out.println(user);

        }

        //6.释放资源

        session.close();

        in.close();

    }

}

xml配置文件：

注解：

采用注解开发时，就不能在同一路径下进行xml开发

解决方案1：删掉xml
解决方案2：把xml放到其他不相关路径上

    <!-- 指定带有注解的dao接口所在位置 -->

    <mappers>

        <!--<package name="com.itheima.dao"></package>-->

        <!--也不可以<mapper class="com.itheima.dao.IUserDao"></mapper>-->

        <!--使用xml配置<mapper resource="com/itheima/dao/IUserDao.xml"></mapper>-->

    </mappers>

3、注解开发CRUD的其他操作

package com.itheima.dao;

import com.itheima.domain.User;

import org.apache.ibatis.annotations.Delete;

import org.apache.ibatis.annotations.Select;

import java.util.List;

/**

 * 在Mybatis中，针对CRUD共有4个注解

 * @Select @Insert @Update @Delete

 */

public interface IUserDao {

    /**

     * 查询所有用户

     * @return

     */

    @Select("select * from user")

    List<User> findAll();

    /**

     * 删除用户

     * @param userId

     */

    @Delete("delete from user where id = #{id}")

    void deleteUser(Integer userId);

    /**

     * 根据id查询用户

     * @param userId

     * @return

     */

    @Select("select * from user where id = #{id}")

    User findById(Integer userId);

    /**

     * 根据用户名称模糊查询

     * @param username

     * @return

     */

    //@Select("select * from user where username like #{username}")---字符串拼接

    //模糊查询的另外一种写法，固定属性名称value---参数占位符

    @Select("select * from user where username like '%${value}%'")

    List<User> findByName(String username);

    /**

     * 查询总用户数量

     * @return

     */

    @Select("select count(*) from user")

    int findTotal();

}

package com.itheima.test;

import com.itheima.dao.IUserDao;

import com.itheima.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.IOException;

import java.io.InputStream;

import java.util.List;

public class AnnotationCRUDTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    private SqlSessionFactory factory;

    /**

     * 在测试方法执行之前执行

     * @throws IOException

     */

    @Before

    public void init() throws IOException {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

        //3.使用工厂对象，创建dao对象

        //userDao = new UserDaoImpl(factory);

        sqlSession = factory.openSession();

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    /**

     * 释放资源

     * 在测试方法之后执行

     */

    @After

    public void destroy() throws IOException {

        //提交事务

        sqlSession.commit();

        sqlSession.close();

        in.close();

    }

    @Test

    public void testDelete(){

        /*User user = new User();

        user.setId(52);*/

        userDao.deleteUser(52);

    }

    @Test

    public void testFindOne(){

        User user = userDao.findById(53);

        System.out.println(user);

    }

    @Test

    public void testFindByName(){

        //List<User> users = userDao.findByName("%王%");

        List<User> users = userDao.findByName("王");

        for (User user : users) {

            System.out.println(user);

        }

    }

    @Test

    public void testFindTotal(){

        int total = userDao.findTotal();

        System.out.println(total);

    }

}

4、mybatis注解建立实体类属性和数据库表中列的对应关系

package com.itheima.dao;

import com.itheima.domain.User;

import org.apache.ibatis.annotations.*;

import java.util.List;

/**

 * 在Mybatis中，针对CRUD共有4个注解

 * @Select @Insert @Update @Delete

 */

public interface IUserDao {

    /**

     * 查询所有用户

     * @return

     */

    @Select("select * from user")

    @Results(id="userMap",value={

            @Result(id=true,column = "id",property = "userId"),

            @Result(column = "username",property = "userName"),

            @Result(column = "address",property = "userAddress"),

            @Result(column = "sex",property = "userSex"),

            @Result(column = "birthday",property = "userBirthday"),

    })

    List<User> findAll();

    /**

     * 根据id查询用户

     * @param userId

     * @return

     */

    @Select("select * from user where id = #{id}")

    @ResultMap(value="userMap")

    User findById(Integer userId);

    /**

     * 根据用户名称模糊查询

     * @param username

     * @return

     */

    //@Select("select * from user where username like #{username}")---字符串拼接

    //模糊查询的另外一种写法，固定属性名称value---参数占位符

    @Select("select * from user where username like '%${value}%'")

    @ResultMap("userMap")

    List<User> findByName(String username);

}

5、mybatis注解开发一对一的查询配置（多表查询）

package com.itheima.dao;

import com.itheima.domain.Account;

import org.apache.ibatis.annotations.One;

import org.apache.ibatis.annotations.Result;

import org.apache.ibatis.annotations.Results;

import org.apache.ibatis.annotations.Select;

import org.apache.ibatis.mapping.FetchType;

import java.util.List;

public interface IAccountDao {

    /**

     * 查询所有账户，并且获取每个账户的用户信息

     * @return

     */

    @Select("select * from account")

    @Results(id = "accountMap",value = {

            @Result(id = true,column = "id",property = "id"),

            @Result(column = "uid",property = "uid"),

            @Result(column = "money",property = "money"),

            @Result(property = "user",column = "uid",one=@One(select="com.itheima.dao.IUserDao.findById",fetchType= FetchType.EAGER))

    })

    List<Account> findAll();

}

public class Account implements Serializable {

    private Integer id;

    private Integer uid;

    private Double money;

    //多对一（Mybatis中称为一对一的映射）：一个账户只能属于一个用户

    //一个用户对应多个账户，一个账户只属于一个用户

    private User user;

    public User getUser() {

        return user;

    }

6、Mybatis注解开发一对多的查询配置

一对多：延迟加载

多对一/一对一：立即加载

public interface IUserDao {

    /**

     * 查询所有用户

     * @return

     */

    @Select("select * from user")

    @Results(id="userMap",value={

            @Result(id=true,column = "id",property = "userId"),

            @Result(column = "username",property = "userName"),

            @Result(column = "address",property = "userAddress"),

            @Result(column = "sex",property = "userSex"),

            @Result(column = "birthday",property = "userBirthday"),

            @Result(property = "accounts",column = "id",

                    many=@Many(select = "com.itheima.dao.IAccountDao.findAccountByUid",

                            fetchType = FetchType.LAZY))

    })

    List<User> findAll();

    @Test

    public void testFindAll(){

        List<User> users = userDao.findAll();

        for (User user : users) {

            System.out.println("---每个用户的信息：---");

            System.out.println(user);

            //实现了延迟加载，没有立即查询account

            //System.out.println(user.getAccounts());

        }

    }

public class User implements Serializable {

    private Integer userId;

    private String userName;

    private String userAddress;

    private String userSex;

    private Date userBirthday;

    //包含一对多关系映射：一个用户对应多个账户

    private List<Account> accounts;

    public List<Account> getAccounts() {

        return accounts;

    }

7、mybatis注解开发使用二级缓存

package com.itheima.test;

import com.itheima.dao.IUserDao;

import com.itheima.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.IOException;

import java.io.InputStream;

import java.util.List;

public class AnnotationCRUDTest {

    private InputStream in;

    private SqlSession sqlSession;

    private IUserDao userDao;

    private SqlSessionFactory factory;

    /**

     * 在测试方法执行之前执行

     * @throws IOException

     */

    @Before

    public void init() throws IOException {

        //1.读取配置文件，生成字节输入流

        in = Resources.getResourceAsStream("SqlMapConfig.xml");

        //2.获取SqlSessionFactory

        factory = new SqlSessionFactoryBuilder().build(in);

        //3.使用工厂对象，创建dao对象

        //userDao = new UserDaoImpl(factory);

        sqlSession = factory.openSession();

        //4.获取dao的代理对象

        userDao = sqlSession.getMapper(IUserDao.class);

    }

    /**

     * 释放资源

     * 在测试方法之后执行

     */

    @After

    public void destroy() throws IOException {

        //提交事务

        sqlSession.commit();

        sqlSession.close();

        in.close();

    }

    @Test

    public void testFindAll(){

        List<User> users = userDao.findAll();

        for (User user : users) {

            System.out.println("---每个用户的信息：---");

            System.out.println(user);

            //实现了延迟加载，没有立即查询account

            //System.out.println(user.getAccounts());

        }

    }

    @Test

    public void testFindOne(){

        User user = userDao.findById(41);

        System.out.println(user);

        User user2 = userDao.findById(41);

        System.out.println(user2);

        System.out.println(user==user2);

    }

    @Test

    public void testFindByName(){

        //List<User> users = userDao.findByName("%王%");

        List<User> users = userDao.findByName("王");

        for (User user : users) {

            System.out.println(user);

        }

    }

}

<configuration>

    <!-- 引入外部配置文件 -->

    <properties resource="jdbcConfig.properties"></properties>

    <!--全局配置：开启二级缓存（默认开启）-->

    <settings>

        <setting name="cacheEnabled" value="true"/>

    </settings>

@CacheNamespace(blocking = true)

public interface IUserDao {

来自为知笔记(Wiz)

Mybatis04:延迟加载、一二级缓存、注解开发的更多相关文章

mybatis多参数传递，延迟加载，缓存，注解开发
1.Mybatis的多参数传递方式需求:更具id 和名字查询用户: select * from user where id = ? and name = ?: 1):QueryVo 或者 User ...
SSM框架之Mybatis（7）延迟加载、缓存及注解
Mybatis(7)延迟加载.缓存及注解 1.延迟加载延迟加载: 就是在需要用到数据时才进行加载,不需要用到数据时就不加载数据.延迟加载也称懒加载. **好处:**先从单表查询,需要时再从关联表去关 ...
Hibernate的应用与注解开发
Hibernate注解可以帮助我们大大简化hbm映射文件的配置,学习记录之. 先看示例: 1 package com.webShop.domain; 2 import java.io.Serializ ...
Mybatis注解开发
mybatis 的常用注解: @Insert:实现新增 @Update:实现更新 @Delete:实现删除 @Select:实现查询 @Result:实现结果集封装 @Results:可以与 @Res ...
mybatis 源码分析（四）一二级缓存分析
本篇博客主要讲了 mybatis 一二级缓存的构成,以及一些容易出错地方的示例分析: 一.mybatis 缓存体系 mybatis 的一二级缓存体系大致如下: 首先当一二级缓存同时开启的时候,首先命中 ...
MyBatis基础_连接池与事务、动态SQL、注解开发
一.MyBatis连接池及事务控制 1.连接池在实际开发中,都会使用连接池,因为它可以减少获取连接缩消耗的时间.所谓连接池,就是存储数据库连接的容器.连接池中存储一定数量的数据库连接,当线程需要使用 ...
【MyBatis】MyBatis 注解开发
MyBatis 注解开发文章源码环境搭建 Mybatis 也可以使用注解开发方式,这样就可以减少编写 Mapper 映射文件. 常用注解说明: @Insert 实现新增 @Update 实现更新 ...
mybatis 加载策略及注解开发
1. 延迟策略在需要用到数据时在加载相关数据,常用于一对多关系, 优点:先从单表查询,需要时再从关联表去关联查询,大大提高数据库性能, 缺点:当需要用到数据时,才会进行数据库查询,这样在大批量数据查 ...
Spring+SpringMVC+MyBatis深入学习及搭建(十六)——SpringMVC注解开发（高级篇）
转载请注明出处:http://www.cnblogs.com/Joanna-Yan/p/7085268.html 前面讲到:Spring+SpringMVC+MyBatis深入学习及搭建(十五)——S ...
Hibernate注解开发详解
*****************关于注解的简单介绍详细介绍请点击这里注解详细教程 package com.tomowork.pojo; import org.hibernate.annotatio ...

随机推荐

彻底掌握Makefile（一）
彻底掌握Makefile(一) 介绍 makefile就是一个可以被make命令解析的文件,他定义了一系列编译的规则,帮助我们更加方便.简洁的去完成编译的过程.在一个大工程当中我们会有各种各样的文件, ...
11. 第十篇网络组件flanneld安装及使用
文章转载自:https://mp.weixin.qq.com/s?__biz=MzI1MDgwNzQ1MQ==&mid=2247483834&idx=1&sn=b04ec193 ...
从nuxt开始的SEO之路
故事从一个"美好"的早上开始...... 大清早的来到公司,打开电脑,emm, 还是熟悉的味道,鱼儿被我摸熟了的味道......就在开始准备一天的摸鱼之旅的时候,一种不详的预感涌上 ...
20_IO
IO框架一. 流的概念概念:内存与存储设备之间传输数据的通道水借助管道传输:数据借助流传输二. 流的分类按方向[重点] 输入流:将<存储设备>中的内容读入到<内存>中 ...
市面上erp软件那么多，为什么很多卖家选择定制erp？
为什么选择定制ERP?适合自己的才是最好的啊!就连头部ERP企业提供给用户的ERP系统,应该也没有不进行个性化定制的吧,匹配很重要!规模不同.行业不同.发展阶段不同.生产模式不同.管理理念不同,适用的 ...
改善C#程序的方法-1 操作字符串
正确操作字符串引言: 字符串是使用很频繁的一种数据类型. 如果使用不慎,则会为一次字符串操作所带来的额外性能开销而付出代价. 下面从这几个方面来探讨如何正确操作字符串: 1.确保尽量少的装箱,尽可能 ...
一个C#开发者学习SpringCloud搭建微服务的心路历程
前言 Spring Cloud很火,很多文章都有介绍如何使用,但对于我这种初学者,我需要从创建项目开始学起,所以这些文章对于我的启蒙,帮助不大,所以只好自己写一篇文章,用于备忘. SpringClou ...
洛谷P2517 HAOI2010 订货（费用流）
标准的费用流问题,关键在于巧妙地建模一共有n个月份,源点设为0,汇点设为n+1 1.源点向所有月份连边,容量为正无穷,费用为该月进货的费用 2.每个月向下一个月连边,容量为仓库容量,费用为存货费用 ...
CEOI2020 道路（Roads） Solution
直接来构造. 考虑扫描线.从左到右扫,考虑当前扫到了一个左端点,我们把这个左端点连到其他点上. 我们可以找到这个点下方离他最近的线段,并且记下每条线段上方在扫描线左侧且最靠右,与这条线段中间没有其他线 ...
【SDOI2013】项链题解
Solution 将原问题分为两个问题求解. Part 1 首先求珍珠的种类数. 设\(f_i\)表示满足\(gcd = i\)的本质不同珍珠个数, \(g_i\)表示满足\(gcd\)为\(i\)的 ...

Mybatis04:延迟加载、一二级缓存、注解开发

Mybatis04:延迟加载、一二级缓存、注解开发的更多相关文章

随机推荐

热门专题