Mybatis

1.概述

​ Mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc ，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。

• Mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过java对象和 statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 Mybatis 框架执行 sql 并将结果映射为 java 对象并返回。

• 采用ORM 思想解决了实体和数据库映射的问题，对 jdbc 进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与 jdbc api打交道，就可以完成对数据库的持久化操作。

持久层技术解决方案

• JDBC技术：

  • Connection
  • PreparedStatement
  • ResultSet

• Spring的 JdbcTemplate：

  • Spring 中对 jdbc 的简单封装

• Apache 的 DBUtils：

  • 它和 Spring 的 JdbcTemplate 很像，也是对 Jdbc 的简单封装

以上这些都不是框架，JDBC是规范，Spring 的 JdbcTemplate 和 Apache 的 DBUtils 都只是工具类

ORM

Object Relational Mappging 对象关系映射

简单的说：

• 就是把数据库表和实体类及实体类的属性对应起来

• 让我们可以操作实体类就实现操作数据库表。

2.入门

2.1.环境搭建

1. 创建 maven 工程并导入坐标

2. 创建实体类和 dao 的接口

3. 创建 Mybatis 的主配置文件 ：SqlMapConifg.xml

4. 创建映射配置文件：IUserDao.xml

   • 这里可以使用@Select注解，并指定 sql ，便可以去掉该配置文件(使用注解就得去掉)
   • 同时需要在SqlMapConfig.xml中的 mapper 配置时，使用 class 属性指定dao接口的全限定类名。

   public interface IUserDao { 
    	@Select("select * from user") 
       List<User> findAll(); 
   }
   

    
   <mappers> 
       <mapper class="com.leyou.dao.IUserDao"/> 
   mappers>
   

Mapper 文件

以下内容为 IUserDao.xml

1. 在 Mybatis 中它把持久层的操作接口名称和映射文件也叫做：Mapper。所以：IUserDao ，也可以写成IUserMapper
2. Mybatis 的映射配置文件位置必须和 dao 接口的包结构相同。
3. 映射配置文件的 mapper 标签 namespace 属性的取值必须是 dao 接口的全限定类名
4. 映射配置文件的操作配置（select），id 属性的取值必须是 dao 接口的方法名
5. 当我们遵从以上几点之后，我们在开发中就无须再写 dao 的实现类。

<mapper namespace="com.leyou.dao.IUserDao"> 
     
    <select id="findAll" resultType="com.leyou.domain.User"> 
   	 	select * from user select>
mapper>

2.2.全局配置文件

<configuration>
    
    <environments default="mysql">
        
        <environment id="mysql">
            
            <transactionManager type="JDBC">transactionManager>
            
            <dataSource type="POOLED">
                
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            dataSource>
        environment>
    environments>

    
   
    <mappers>
        <mapper class="com.leyou.dao.IUserDao"/>
    mappers>
configuration>

2.3.测试类

程序编写的思路

1. 读取配置文件 加载方式区别解惑
2. 创建 SqlSessionFactory 工厂
3. 创建 SqlSession
4. 创建 Dao接口的代理对象
5. 执行 Dao 中的方法
6. 释放资源

 /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args)throws Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession();
        //4.使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println(user);
        }
        //6.释放资源
        session.close();
        in.close();
    }
}

2.4.流程分析

2.5. SqlSession

sqlSession 深入

SqlSession 的语句执行方法

• Object selectOne(String statement, Object parameter)
• List selectList(String statement, Object parameter)
• int insert(String statement, Object parameter)
• int update(String statement, Object parameter)
• int delete(String statement, Object parameter)

注意

• 一般情况下（方法重名了），这里的 statement 不能只传递方法名（如 findAll），需要前面带上 namespace，即 namespace.方法 。

selectOne 和selectList 的不同仅仅是 selectOne 必须返回一个对象。如果多余一个，或者没有返回（或返回了null），那么就会抛出异常。如果你不知道需要多少对象，使用 selectList 。如果你想检查一个对象是否存在，那么最好返回统计数（0或1）。

因为并不是所有语句都需要参数，这些方法都是有不同重载版本的，它们可以不需要参数对象。

2.6.作用域分析

参考

SqlSessionFactoryBuilder

​ 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。因此 SqlSessionFactoryBuilder 实例的最佳范围是**方法范围（**也就是局部方法变量）。你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但是最好还是不要让其一直存在以保证所有的 XML 解析资源开放给更重要的事情。

SqlSessionFactory

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由对它进行清除或重建。使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏味道（bad smell）”。因此 　SqlSessionFactory 的最佳范围是应用范围。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的范围是请求或方法范围。绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。也绝不能将 SqlSession 实例的引用放在任何类型的管理范围中，比如 Serlvet 架构中的HttpSession。如果你现在正在使用一种 Web 框架，要考虑 SqlSession 放在一个和 HTTP 请求对象相似的范围中。换句话说，每次收到的 HTTP 请求，就可以打开一个 SqlSession，返回一个响应，就关闭它。这个关闭操作是很重要的，你应该把这个关闭操作放到 finally 块中以确保每次都能执行关闭。

使用 MyBatis-Spring 之后，你不再需要直接使用 SqlSessionFactory 了，因为你的 bean 可以被注入一个线程安全的 SqlSession，它能基于 Spring 的事务配置来自动提交、回滚、关闭 session。官方文档

3. CRUD

3.1.基于xml

3.1.1. CRUD

CRUD

• insert
• delete
• update
• select

模糊查询

• 方式一：select * from user where username like #{username}
  • 没有加入%来作为模糊查询的条件,{username}也只是一个占位符，所以 sql 语句显示为？
• 方式二：select * from user where username like '%${value}%'
  • 如果用模糊查询的这种写法，那么${value}的写法就是固定的，不能写成其它名字。

#{}与${}的区别

• #{}表示一个占位符号 通过#{}可以实现preparedStatement向占位符中设置值，自动进行 java 类型和 jdbc类型转换，#{}可以有效防止 sql 注入。
  • #{}可以接收简单类型值或 pojo 属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。
• ${}表示拼接 sql 串 通过${}可以将parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换。
  • ${}可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是 value。

3.1.2.参数细节

以查询为例

 
    <select id="findById" parameterType="INT" resultMap="userMap">
        select * from user where id = #{uid}
    select>

• id="findAll"：sql 语句所要应用 在 Dao接口的 方法名
• parameterType="INT"：参数类型。传入一个类的对象，就写类的全名称（注册可使用别名）。大小写不敏感。（常使用包装类）
• resultType="int"：可以指定结果集的类型，它支持基本类型和实体类类型，规则同parameterType。
  • 实体类中的属性名称 必须和查询语句中的列名保持一致，否则无法实现封装。
  • Mysql 在windows系统中不区分大小写！
  • Linux 中就需要小心使用了
• sql 语句中使用#{}字符来表示占位符，它用的是 ognl 表达式
• resultMap="userMap" ：结果类型，建立查询的列名和实体类的属性名称不一致时建立对应关系
  • 在 select 标签中使用 resultMap 属性指定引用即可，这里便是一处引用。
  • 后面会详细介绍

获取新增用户 id 的返回值

​ 新增用户后，同时还要返回当前新增用户的id值，因为id是由数据库的自动增长来实现的，所以就相当于我们要在新增后将自动增长 auto_increment的值返回。

 
    <insert id="saveUser" parameterType="user">
        
        <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        selectKey>
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
    insert>

• order：定义获取 id 的时间
  • BEFORE：插入前
  • AFTER：插入后

ognl

它是 apache 提供的一种表达式语言，全称是：Object Graphic Navigation Language 对象图导航语言

• 语法格式就是使用 #{对象.对象}的方式
  • #{user.username}它会先去找 user 对象，然后在 user 对象中找到 username 属性，并调用getUsername()方法把值取出来。
  • 但是我们在parameterType属性上指定了实体类名称，所以可以省略user.而直接写username。

3.1.3.类与表名不一致

方式一：使用别名

  
<select id="findAll" resultType="com.leyou.domain.User"> 
    select id as userId,username as userName,birthday as userBirthday, sex as userSex,address as userAddress from user 
select>

该方法效率最高，但是如果查询很多，开发起来不是很方便

方式二：resultMap

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。

• 在 select 标签中使用 resultMap 属性指定引用即可。
• 同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询。

 
<resultMap type="com.leyou.domain.User" id="userMap"> 
    <id column="id" property="userId"/> 
    <result column="username" property="userName"/> 
    <result column="sex" property="userSex"/> 
resultMap>

• id 标签：用于指定主键字段
• result 标签：用于指定非主键字段
• column 属性：用于指定数据库列名
• property 属性：用于指定实体类属性名称

3.1.4.参考 Mapper 配置文件

Mapper 配置文件参考

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

    
    <resultMap id="userMap" type="com.leyou.domain.User">
        
        <id property="userId" column="id">id>
        
        <result property="userName" column="username">result>
        <result property="userAddress" column="address">result>
        <result property="userSex" column="sex">result>
        <result property="userBirthday" column="birthday">result>
    resultMap>

    
    <select id="findAll" resultMap="userMap">
        
        select * from user;
    select>

    
    <insert id="saveUser" parameterType="user">
        
        <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        selectKey>
        insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
    insert>

    
    <update id="updateUser" parameterType="USER">
        update user set username=#{userName},address=#{userAddress},sex=#{userAex},birthday=#{userBirthday} where id=#{userId}
    update>

    
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id = #{uid}
    delete>
    
    
    <select id="findById" parameterType="INT" resultMap="userMap">
        select * from user where id = #{uid}
    select>

    
    <select id="findByName" parameterType="string" resultMap="userMap">
          select * from user where username like #{name}
        
   select>

    
    <select id="findTotal" resultType="int">
        select count(id) from user;
    select>

    
    <select id="findUserByVo" parameterType="com.leyou.domain.QueryVo" resultMap="userMap">
        select * from user where username like #{user.username}
    select>
mapper>

3.2. SqlMapConfig.xml 配置文件

3.2.1.主要配置内容

-properties（属性）
	--property
-settings（全局配置参数）
	--setting
-typeAliases（类型别名）
	--typeAliase
	--package
-typeHandlers（类型处理器）
-objectFactory（对象工厂）
-plugins（插件）
-environments（环境集合属性对象）
	--environment（环境子属性对象）
		---transactionManager（事务管理）
		---dataSource（数据源）
-mappers（映射器）
	--mapper
	--package

3.2.2. properties（属性）

我们可以采用两种方式指定属性配置。

1. 直接指定

<properties> 
    <property name="jdbc.driver" value="com.mysql.jdbc.Driver"/> 
    <property name="jdbc.url" value="jdbc:mysql://localhost:3306/eesy"/>
    <property name="jdbc.username" value="root"/> <
    property name="jdbc.password" value="1234"/> 
properties>

2. 从配置文件中导入

jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/eesy 
jdbc.username=root 
jdbc.password=1234

  
<properties url="file:///D:/IdeaProjects/day02_eesy_01mybatisCRUD/src/main/resources/jdbcConfig.properties">
properties>

最后，配置 datasource

  
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}">property>
                <property name="url" value="${jdbc.url}">property>
                <property name="username" value="${jdbc.username}">property>
                <property name="password" value="${jdbc.password}">property>
            dataSource>

3.2.3. typeAliases（类型别名）

• ：单个别名定义
  • type 属性指定的是实体类全限定类名
  • alias 属性指定别名，当指定了别名就再区分大小写
• ：批量给包 别名
• 该包下的实体类都会注册别名，并且类名就是别名，不再区分大小写

    <typeAliases>
        
        <typeAlias type="com.leyou.domain.User" alias="user">typeAlias>

        
        <package name="com.leyou.domain">package>
    typeAliases>

3.2.4. mappers （映射器）

resource

使用相对于类路径的资源 ，如：

<mappers>
<mapper resource="com/leyou/dao/IUserDao.xml" /> mappers>

class

使用mapper接口类路径，此种方法要求 mapper 接口名称和 mapper映射文件名称相同，且放在同一个目录中。

<mappers>
<mapper class="com.leyou.dao.UserDao"/> mappers>

package

注册指定包下的所有 mapper 接口，此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

• 当指定了之后就不需要在写 mapper 以及 resource 或者 class 了

<mappers>
 	<package name="com.leyou.dao">package> mappers>     

3.2.5.其它标签的简介

设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

• cacheEnabled：全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。默认 true
• lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。默认 false
• aggressiveLazyLoading：开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载。默认 false

类型处理器（typeHandlers）

MyBatis 在设置预处理语句（PreparedStatement）中的参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。

对象工厂（objectFactory）

每次 MyBatis 创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成实例化工作。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认无参构造方法，要么通过存在的参数映射来调用带有参数的构造方法。 如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现。

插件（plugins）

MyBatis 允许你在映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)

如果你想做的不仅仅是监控方法的调用，那么你最好相当了解要重写的方法的行为。 因为在试图修改或重写已有方法的行为时，很可能会破坏 MyBatis 的核心模块。 这些都是更底层的类和方法，所以使用插件的时候要特别当心。

通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。

环境配置（environments）

MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者想在具有相同 Schema 的多个生产数据库中使用相同的 SQL 映射。

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

• JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
• MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。

如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

数据源（dataSource）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

• 有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）
• 后面在讲述连接池会再次介绍

3.3.基于注解

常用注解

• @Insert:实现新增
• @Update:实现更新
• @Delete:实现删除
• @Select:实现查询
• @Result:实现结果集封装
• @Results:可以与@Result一起使用，封装多个结果集
• @ResultMap:实现引用@Results定义的封装
• @One:实现一对一结果集封装
• @Many:实现一对多结果集封装
• @SelectProvider: 实现动态SQL映射
• @CacheNamespace:实现注解二级缓存的使用

具体实现

使用注解开发，则不需要 dao.xml, 但仍需要 主配置文件 sqlMapConfig.xml

直接在接口上使用标签并编写 sql 语句

    /**
     * 保存用户
     * @param user
     */
    @Insert("insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})")
    void saveUser(User user);

    /**
     * 更新用户
     * @param user
     */
    @Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
    void updateUser(User user);

    /**
     * 删除用户
     * @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} ")
    //@Select("select * from user where username like '%${value}%' ")
    List<User> findUserByName(String username);

    /**
     * 查询总用户数量
     * @return
     */
    @Select("select count(*) from user ")
    int findTotalUser();

主配置文件中需要配置

    <mappers>
        <mapper class="com.leyou.dao.IUserDao">mapper>
    mappers>

4.连接池与事务深入

4.1.连接池

我们在实际开发中都会使用连接池。因为它可以减少我们获取连接所消耗的时间。而在 Mybatis 中也有连接池技术，但是它采用的是自己的连接池技术。

池思想示意图

分类

• POOLED：常用。采用传统的 javax.sql.DataSource规范中的连接池，mybatis 中有针对规范的实现。
• UNPOOLED：采用传统的获取连接的方式（不使用连接池），虽然也实现 Javax.sql.DataSource 接口，但是并没有使用池的思想。
• JNDI：采用服务器提供的 JNDI 技术实现，来获取 DataSource 对象，不同的服务器所能拿到 DataSource 是不一样。

JNDI 注意

• 如果不是web 或者 maven 的war工程，是不能使用的。
• 我们使用的 tomcat 服务器，采用连接池就是 dbcp 连接池。

            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}">property>
                <property name="url" value="${jdbc.url}">property>
                <property name="username" value="${jdbc.username}">property>
                <property name="password" value="${jdbc.password}">property>
            dataSource>

4.1.1. JNDI

​ JNDI：Java Naming and Directory Interface。是SUN公司推出的一套规范，属于 JavaEE 技术之一。目的是模仿 windows 系统中的注册表。百科

​ tomcat 已经集成该服务（内置并默认使用DBCP连接池），简单来说就是键值对的 mapping，而且在 tomcat 服务器启动的首页 configuration 中就已经有完成的示例代码。要想使用 tomcat 的 JNDI 服务，只需要导入相关的 jar 包，建立所需的配置文件，采用 JDK 的命名服务 API 根据配置名称即可获得相应的服务。

建议参考

比较

没有JNDI的做法：
程序员开发时，知道要开发访问MySQL数据库的应用，于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码，并通过使用适当的 JDBC URL 连接到数据库。

用了JNDI之后的做法：
首先，在在 J2EE 容器中配置 JNDI 参数，定义一个数据源，也就是 JDBC 引用参数，给这个数据源设置一个名称；然后，在程序中，通过数据源名称引用数据源从而访问后台数据库。

4.2.获取连接的过程分析

配置

在 Mybatis 的SqlMapConfig.xml配置文件中，通过来实现 Mybatis 中连接池的配置。

MyBatis在初始化时，根据的 type 属性来创建相应类型的的数据源 DataSource。

• type=”POOLED”：会创建 PooledDataSource 实例
• type=”UNPOOLED” ：会创建 UnpooledDataSource 实例
• type=”JNDI”：会从 JNDI 服务上查找 DataSource 实例，然后返回使用

DataSource 的存取

• MyBatis 是通过工厂模式来创建数据源 DataSource 对象的，

• MyBatis定义了抽象的工厂接口:org.apache.ibatis.datasource.DataSourceFactory,通过其getDataSource()方法返回数据源DataSource。

过程

当我们需要创建 SqlSession 对象并需要执行 SQL 语句时，这时候 MyBatis才会去调用 dataSource对象来创建java.sql.Connection对象。也就是说，java.sql.Connection对象的创建一直延迟到执行 SQL 语句的时候。

@Test public void testSql() throws Exception { 
    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml"); 
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in); 
    SqlSession sqlSession = factory.openSession();
    List<User> list = sqlSession.selectList("findUserById",41); 
    System.out.println(list.size()); }

只有当第4句sqlSession.selectList("findUserById")，才会触发 MyBatis 在底层执行下面这个方法来创建java.sql.Connection对象。

我们可以通过断点调试，在PooledDataSource中找到如下popConnection()方法

简而言之

只有在我们执行 sql 语句时，才会去获取并打开连接。

4.3.事务

4.3.1.事务回顾

什么是事务？

如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。

事务的四大特性 ACID

• 原子性（Atomicity）：是不可分割的最小操作单位，要么同时成功，要么同时失败。
• 持久性（Consistency）：当事务提交或回滚后，数据库会持久化的保存数据。
• 隔离性（Isolation）：多个事务之间。相互独立。
• 一致性（Durability）：事务操作前后，数据总量不变

隔离性会产生的3个问题

1. 脏读（Dirty read）：一个事务，读取到另一个事务中没有提交的数据
2. 不可重复读/虚读（Unrepeatableread）：在同一个事务中，两次读取到的数据不一样。
3. 幻读（Phantom read）：一个事务操作(DML)数据表中所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

不可重复度和幻读区别：

• 不可重复读的重点是修改，（同样的条件, 你读取过的数据, 再次读取出来发现值不一样了）
• 幻读的重点在于新增或者删除。（同样的条件, 第1次和第2次读出来的记录数不一样）

解决办法：四种隔离级别

1. read uncommitted：读未提交
   • 产生的问题：脏读、不可重复读、幻读
2. read committed：读已提交 （Oracle）
   • 产生的问题：不可重复读、幻读
3. repeatable read：可重复读 （MySQL默认）
   • 产生的问题：幻读
   • 解决虚读问题，自己提交才会改变数据
4. serializable：串行化
   • 可以解决所有的问题
   • 当前事务会等待另一个事务提交，才会生效修改，效率低。

4.3.2 .Mybatis的事务控制

实现方式

通过 sqlsession 对象的 commit 方法和 rollback 方法实现事务的提交和回滚。

事务提交方式

  @Before//用于在测试方法执行之前执行
    public void init()throws Exception{
        //1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3.获取SqlSession对象
        sqlSession = factory.openSession();
        //4.获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }

• 在 JDBC 中，，通过setAutoCommit()方法就可以调整
• Mybatis 中，本质上就是调用 JDBC 的 setAutoCommit()来实现事务控制。
  • 设置session = factory.openSession(true);来自动提交
  • 无参时，默认调用connection.setAutoCommit(false)，所以需要手动提交。

5.动态 sql

5.1. if 标签

我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。

• 标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。
• where 1=1 的作用：因 where 后的筛选条件是不确定的（0或n），该式子，很好地解决了后续条件的拼接问题。

<select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user where 1=1
        <if test="userName != null">
          and username = #{userName}
        if>
        <if test="userSex != null">
            and sex = #{userSex}
        if>
select>

5.2. where 标签

为了简化上面where 1=1的条件拼装，我们可以采用标签来简化开发。

<select id="findUserByCondition" resultMap="userMap" parameterType="user">
        select * from user
        <where>
            <if test="userName != null">
                and username = #{userName}
            if>
            <if test="userSex != null">
                and sex = #{userSex}
            if>
        where>
    select>

5.3. for each 标签

SQL语句： select 字段from user where id in (?)

标签用于遍历集合，它的属性：

• collection: 代表要遍历的集合元素，注意编写时不要写#{}
• open: 代表语句的开始部分
• close代表结束部分
• item: 代表遍历集合的每个元素，生成的变量名
• sperator: 代表分隔符

抽取重复代码

• 可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

   
    <sql id="defaultUser">
        select * from user
    sql>

    <select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
        <include refid="defaultUser">include>
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                    #{uid}
                foreach>
            if>
        where>
    select>

5.4.@SelectProvider注解

@SelectProvider: 实现动态SQL映射。参考

简易示例

SelectSqlProvider:

public class SelectSqlProvider {

    public String selectByUserId(Long id) {
        StringBuffer buffer = new StringBuffer();
        buffer.append("SELECT * FROM user where ");
        buffer.append("id = ").append(id).append(";");
        return buffer.toString();
    }
}

UserMapper:

@ResultMap("BaseResultMap")
@SelectProvider(type = SelectSqlProvider.class, method = "selectByUserId")
User getUserByUserId(long id);

这一个方法在 xml 中没有对应的 sql ，在该方法上也没有 @Select 注解修饰，只有 @SelectProvider 注解，@SelectProvider 中两个属性，type 为提供 sql 的 class 类，method 为指定方法。

6.多表查询

多表之间的关系分类

6.1.一对一

• 如：用户和账户
• 分析：一个账户只能属于一个用户

实现方式：

• 定义专门的 po 类（AccountUser）作为输出类型，其中定义了 sql 查询结果集所有的字段。（编写一个子类方式）

  • 在定义 AccountUser 类时可以继承 User 类（不常用）
  • 这里不需要使用 resultMap，查询时直接使用 resultType 。

• 使用 resultMap ，定义专门的 resultMap 用于映射一对一查询结果。（从表实体类中引用一个主表实体类对象）

  • 在 Account 类中直接加入一个User类的对象（常用方式）

说明

• 使用 association 来建立一对一（多对一）关系映射
• javaType 定义封装到的对象

    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid">id>
        <result property="uid" column="uid">result>
        <result property="money" column="money">result>
        
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id">id>
            <result column="username" property="username">result>
            <result column="address" property="address">result>
            <result column="sex" property="sex">result>
            <result column="birthday" property="birthday">result>
        association>
    resultMap>

	
    <select id="findAll" resultMap="accountUserMap">
        select u.*,a.id as aid,a.uid,a.money from account a , user u where u.id = a.uid;
    select>

    
    <select id="findAllAccount" resultType="accountuser">
        select a.*,u.username,u.address from account a , user u where u.id = a.uid;
    select>

6.2.一对多(多对一)

• 如：用户和账户
• 分析：一个用户可以有多个账户，多个账户也可以属于同一个用户

实现方式：

• 建立两张表：用户表，账户表；让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加

• 建立两个实体类：用户实体类和账户实体类；让用户和账户的实体类能体现出来一对多的关系

  • 具体为：定义sql 时 使用左外连接查询，User类加入List

说明

collection 部分定义了用户关联的账户信息。表示关联查询结果集 ，一对多的关系使用

• property="accounts"： 关联查询的结果集存储在 User 对象的上哪个属性。
• ofType="account"： 指定关联查询的结果集中的对象类型即 List 中的对象类型。此处可以使用别名，也可以使用全限定名。

 
    <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>
        
        <collection property="accounts" ofType="account">
            <id column="aid" property="id">id>
            <result column="uid" property="uid">result>
            <result column="money" property="money">result>
        collection>
    resultMap>

    
    <select id="findAll" resultMap="userAccountMap">
        select * from user u left outer join account a on u.id = a.uid
    select>

    
    <select id="findById" parameterType="INT" resultType="user">
        select * from user where id = #{uid}
    select>

6.3.多对多

• 如：用户和角色
• 分析：一个用户可以有多个角色，一个角色可以赋予多个用户

实现方式：

• 建立两张表：用户表，角色表；让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
• 建立两个实体类：用户实体类和角色实体类；让用户和角色的实体类能体现出来多对多的关系；各自包含对方一个集合引用
• 就是两个 一对多，只需要注意查询时 sql 语句

 
    <resultMap id="userMap" 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>
        
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid">id>
            <result property="roleName" column="role_name">result>
            <result property="roleDesc" column="role_desc">result>
        collection>
    resultMap>

    
    <select id="findAll" resultMap="userMap">
        select u.*,r.id as rid,r.role_name,r.role_desc from user u
         left outer join user_role ur  on u.id = ur.uid
         left outer join role r on r.id = ur.rid
    select>


 
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid">id>
        <result property="roleName" column="role_name">result>
        <result property="roleDesc" column="role_desc">result>
        <collection property="users" ofType="user">
            <id column="id" property="id">id>
            <result column="username" property="username">result>
            <result column="address" property="address">result>
            <result column="sex" property="sex">result>
            <result column="birthday" property="birthday">result>
        collection>
    resultMap>

    
    <select id="findAll" resultMap="roleMap">
       select u.*,r.id as rid,r.role_name,r.role_desc from role r
        left outer join user_role ur  on r.id = ur.rid
        left outer join user u on u.id = ur.uid
    select>

6.4.使用注解

实现复杂关系映射之前我们可以在映射文件中通过配置来实现，在使用注解开发时我们需要借助@Results注解，@Result注解，@One注解，@Many注解。

@Results 注解

代替的是标签,该注解中可以使用单个@Result 注解，也可以使用@Result 集合

• 配置 id="userMap",供其它接口引用

@Resutl 注解

代替了标签和标签

• id 是否是主键字段
• column 数据库的列名
• property 需要装配的属性名
• one 需要使用的@One 注解（@Result（one=@One）（）））
• many 需要使用的@Many 注解（@Result（many=@many）（）））

@ResultMap注解

实现引用 @Results定义的封装，

• @ResultMap("userMap")，这是省略写法（单个的情况下）
• 可以引用多个 results 的 id ，@ResultMap(value={"userMap","userMap2"})

 /**
     * 查询所有用户
     * @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.leyou.dao.IAccountDao.findAccountByUid",
                                fetchType = FetchType.LAZY))
    })
    List<User> findAll();

    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user  where id=#{id} ")
    @ResultMap("userMap")
    User findById(Integer userId);

@One 注解（一对一）

代替了标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。

• select 指定用来多表查询的 sqlmapper
• fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。如果要延迟加载都设置为LAZY 的值

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

@Many 注解（多对一）

代替了标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。

• 聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType（一般为 ArrayList）但是注解中可以不定义；

@Result(property = "accounts",column = "id",
                    many = @Many(select = "com.leyou.dao.IAccountDao.findAccountByUid",
                                fetchType = FetchType.LAZY)

7.延迟加载

延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载.
好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速
度要快。

坏处：

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

使用要求

关联对象的查询与主加载对象的查询必须是分别进行的select语句，不能是使用多表连接所进行的select查询。因为，多表连接查询，实质是对一张表的查询，对由多个表连接后形成的一张表的查询。会一次性将多张表的所有信息查询出来。

实现原理

它的原理是，使用CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName()，拦截器 invoke()方法发现 a.getB()是 null 值，那么就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName()方法的调用。这就是延迟加载的基本原理。

当然了，不光是 Mybatis，几乎所有的包括 Hibernate，支持延迟加载的原理都是一样的。

延迟加载的实现

修改配置文件

实现原理：在需要查询时，调用对方配置文件 中的配置来实现查询功能，所以进行如下配置：

• select="com.leyou.dao.IAccountDao.findAccountByUid",用于指定查询 account 列表的 sql 语句（账户的 dao 全限定类名加上方法名称）
• column="id">,用于指定 select 属性的 sql 语句的参数来源

修改 Dao.xml

   
<association property="user" column="uid" javaType="user" select="com.leyou.dao.IUserDao.findById">association>
  
   
        <collection property="accounts" ofType="account" select="com.leyou.dao.IAccountDao.findAccountByUid" column="id">collection>

Mybatis 中默认是不开启延迟加载的，我们需要在 Mybatis 的主配置文件 SqlMapConfig.xml文件中添加延迟加载的配置。

 
    <settings>
        
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false">setting>
    settings>

总结

• 延迟加载：在真正使用数据时才发起查询，不用的时候不查询。按需加载（懒加载）

• 立即加载：不管用不用，只要一调用方法，马上发起查询。

在对应的四种表关系中：一对多，多对一，一对一，多对多

• 一对多，多对多：通常情况下我们都是采用延迟加载。

• 多对一，一对一：通常情况下我们都是采用立即加载。

8.缓存机制

什么是缓存？

• 存在于内存中的临时数据。
• 减少和数据库的交互次数，提高执行效率。

什么样的数据能使用缓存，什么样的数据不能使用？

适用于缓存：

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

不适用于缓存：

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

什么是一级缓存？

它指的是Mybatis中 **SqlSession 对象的缓存。**当我们执行查询之后，查询的结果会同时存入到 SqlSession 为我们提供一块区域中。该区域的结构是一个Map。当我们再次查询同样的数据，mybatis 会先去 sqlsession 中查询是否有，有的话直接拿出来用。

特点：

• 当 SqlSession 对象消失时，mybatis 的一级缓存也就消失了。
• 只要 SqlSession 没有 flush 或 close，它就存在。
• 当调用 SqlSession 的修改，添加，删除，commit()，close() 等方法时，就会清空一级缓存。

什么是二级缓存？

它指的是 Mybatis 中 SqlSessionFactory 对象的缓存。由同一个 SqlSessionFactory 对象创建的 SqlSession 共享其缓存。建议参考

特点：

• 二级缓存是 mapper映射级别的缓存，多个SqlSession去操作同一个Mapper映射的sql语句，多个 SqlSession可以共用二级缓存，二级缓存是跨 SqlSession 的。
• 二级缓存 存放的内容为数据，不是对象，使用时会new一个新的 user对象，所以对象地址会变
• 同样的，增删改会清空缓存
• 缓存是以namespace为单位的，不同namespace下的操作互不影响。
• 多表操作一定不要使用二级缓存，因为多表操作进行更新操作，一定会产生脏数据。

使用

在 SqlMapConfig.xml 文件开启二级缓存，默认为 true ，也可以不配置

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

配置相关的 Mapper 映射文件

• 标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。

• 将 UserDao.xml映射文件中的标签中设置 useCache=”true”代表当前这个 statement 要使用

  二级缓存，如果不使用二级缓存可以设置为 false。

  针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存。

  <mapper namespace="com.leyou.dao.IUserDao">
      
      <cache/>
  
      
      <select id="findAll" resultType="user">
          select * from user
      select>
  
      
      <select id="findById" parameterType="INT" resultType="user" useCache="true">
          select * from user where id = #{uid}
      select>
  
      
      <update id="updateUser" parameterType="user">
          update user set username=#{username},address=#{address} where id=#{id}
      update>
  mapper>
  

  使用注解方式

  在 dao（mapper） 接口上 配置

  @CacheNamespace(blocking = true)
  public interface IUserDao {
     }
  

  注意

  • 当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化

    方式来保存对象

  9.其它拓展

  9.1.通用Mapper

  • 主页
  • 通用Mappper接口方法

  简单讲述几个常用方法

  Select：

  • List select(T record);：根据实体中的属性值进行查询
  • T selectByPrimaryKey(Object key);：根据主键字段进行查询
  • List selectAll();：查询全部结果，select(null)方法能达到同样的效果

  Insert：

  • int insert(T record);：保存一个实体，null的属性也会保存，不会使用数据库默认值
  • int insertSelective(T record);：保存一个实体，null的属性不会保存，会使用数据库默认值

  区别：

  • 后者会根据你设置的字段插入，未设置则不插入(主键是自动添加的，默认插入为空)
  • 前者会全部插入，未设置则传递 null
  • 只想插入某一字段就是用后者，往后同理

  Update：

  • int updateByPrimaryKey(T record);：根据主键更新实体全部字段，null值会被更新
  • int updateByPrimaryKeySelective(T record);：根据主键更新属性不为null的值

  Delete：

  • int delete(T record);：根据实体属性作为条件进行删除
  • int deleteByPrimaryKey(Object key);：根据主键字段进行删除

  Example 方法：

  • List selectByExample(Object example);：根据Example条件进行查询

  Example.Criteria：

  Example类用于构造复杂的筛选条件。它包含一个名为Criteria的内部静态类，它包含将在where子句中一起结合的条件列表。Criteria类的集合允许您生成几乎无限类型的where子句。

    //初始化example对象
          Example example = new Example(Brand.class);
          Example.Criteria criteria = example.createCriteria();
          //根据name模糊查询，或者根据首字母查询
          if (StringUtils.isNotBlank(sortBy)) {
              criteria.andLike("name", "%" + key + "%").orEqualTo("letter", key);
          }
   		List<Brand> brands = this.brandMapper.selectByExample(example);
  

  表实体类写法

  • 以下供参考
  • 详细参见
  • 注意使用 @Transient 注解来忽略字段

  @Table(name = "tb_sku")
  public class Sku {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      private Long spuId;
      private String title;
      private String images;
      private Long price;
      private String ownSpec;// 商品特殊规格的键值对
      private String indexes;// 商品特殊规格的下标
      private Boolean enable;// 是否有效，逻辑删除用
      private Date createTime;// 创建时间
      private Date lastUpdateTime;// 最后修改时间
      @Transient  //忽略字段
      private Integer stock;// 库存
  
  }
  

  9.2.分页插件

  Spring Boot 集成 MyBatis, 分页插件 PageHelper, 通用 Mapper

   /**
       * 根据条件分页查询spu
       *
       * @param key
       * @param saleable
       * @param page
       * @param rows
       * @return
       */
      public PageResult<SpuBo> querySpuBoByPage(String key, Boolean saleable, Integer page, Integer rows) {
          Example example = new Example(Spu.class);
          Example.Criteria criteria = example.createCriteria();
          //添加查询条件
          if (StringUtils.isNotBlank(key)) {
              criteria.andLike("title", "%" + key + "%");
          }
          //添加上下架的过滤条件
          if (saleable != null) {
              criteria.andEqualTo("saleable", saleable);
          }
          //添加分页
          PageHelper.startPage(page, rows);
          //执行查询，获取spu集合
          List<Spu> spus = this.spuMapper.selectByExample(example);
          PageInfo<Spu> PageInfo = new PageInfo<>(spus);
          //spu集合转化成spubo集合
          List<SpuBo> spuBos = spus.stream().map(spu -> {
                      SpuBo spuBo = new SpuBo();
                      //copy共同属性的值到新对象
                      BeanUtils.copyProperties(spu, spuBo);
                      //查询品牌名称
                      Brand brand = this.brandMapper.selectByPrimaryKey(spu.getBrandId());
                      spuBo.setBname(brand.getName());
                      //查询分类名称
                      List<String> names = this.categoryService.queryNameByIds(Arrays.asList(spu.getCid1(), spu.getCid2(), spu.getCid3()));
                      spuBo.setCname(StringUtils.join(names, "/"));
                      return spuBo;//勿忘
                  }
          ).collect(Collectors.toList());
  
          //返回pageResult
          return new PageResult<>(PageInfo.getTotal(), spuBos);
  
      }
  

  9.3. Mybatis-Plus

  Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。这是官方给的定义，关于mybatis-plus 的更多介绍及特性，可以参考 mybatis-plus 官网。那么它是怎么增强的呢？其实就是它已经封装好了一些 crud方 法，我们不需要再写 xml 了，直接调用这些方法就行，就类似于 JPA。参考地址

  你可能感兴趣的:(学习笔记)

  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • 《转介绍方法论》学习笔记 小可乐的妈妈
    一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • 新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通 其他笔记汽车BMS经验分享新能源电池
    一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
  • 吴恩达深度学习笔记(30)-正则化的解释 极客Array
    正则化（Regularization）深度学习可能存在过拟合问题——高方差，有两个解决方法，一个是正则化，另一个是准备更多的数据，这是非常可靠的方法，但你可能无法时时刻刻准备足够多的训练数据或者获取更多数据的成本很高，但正则化通常有助于避免过拟合或减少你的网络误差。如果你怀疑神经网络过度拟合了数据，即存在高方差问题，那么最先想到的方法可能是正则化，另一个解决高方差的方法就是准备更多数据，这也是非常
  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐 浪子L 深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • 碎片化学习笔记分享 剑客写作
    现在生活节奏很快，学习力成为了我们拥有的最大财富。碎片化学习是最好的。首先，不要太过自信，学会虚心学习，是我们面对现实的好方法，才能够常保新鲜。平时我们要拥有什么工具呢？1.思维导图2.写在印象笔记里3.听书，消燥耳机4.教学输出5.录音笔里面最好的方式就是教学输出法，记忆里最好。当输出时我们集中精力记忆里最好。有人认为缩短睡眠时间来学习，其实最好的方式是保持最好的睡眠，记忆力会更好。剥夺睡眠，会
  • 《随园诗话》学习笔记三百零六 飞鸿雪舞
    卷五凡诗之传者，都在灵性五、五斗米与诗【原文】丁丑，余觅一抄书人，或荐黄生，名之纪，号星岩者，人甚朴野。偶过其案头，得句云；“破庵僧卖临街瓦，独井人争向晚泉。”余大奇之，即饷米五斗。自此欣然大用力于诗。五言句云：“云开日脚直，雨落水纹圆。竹锐穿泥壁，蝇酣落酒尊。钓久知鱼性，樵多识树名。笔残芦并用，墨尽指同磨。＂七言云：＂小窗近水寒偏觉，古木遮天曙不知。旧生萍处泥犹绿，新落花时水亦香。旧甓恐闲都贮水
  • D15 论语学习笔记 许小兔Angelina
    悟：上级对下级的宽容：凡事成定局，就不你说了；已接近完结的事，也没必要匡正和挽回了；既然是过去的事，也没必要追究得失和责任了。对待孩子教育也是，不用“问责制”，这样容易让孩子因为害怕担责而说谎。应当循循善诱，避免再犯错才是最重要的。3.16：【原文】子曰：“射不主皮，为力不同科，古之道也。”【译文】孔子说：“射箭比赛不以射透为主，而主要看是否射得准确，因为人的力量不同，自古如此。”3.17：【原文
  • 网络工程师学习笔记（一） 专业白嫖怪 网络工程师学习笔记学习笔记网络
    为了备战下半年的软考——网络工程师，利用每天的下班的闲暇时间看书听课，然后自己手敲整理的系列资料。希望能够对你们有所帮助第一章__计算机网络概述计算机网络的定义：将分散的具有独立运算功能的计算机系统，通过通信线路和通信设备进行连接起来的实现资源的共享。ARPAnet网络的特征：资源共享、分散控制、分组交换1946年第一台通用计算机—埃尼亚克能够相互连通进行数据交换。1960年提出巨型网络，出现了对
  • K8S学习笔记02——K8S组件 沉淅尘 #Docker#K8Skubernetes
    Kubernetes组件一、控制平面组件（ControlPlaneComponents）(1)kube-apiserver(2)etcd(3)kube-scheduler(4)kube-controller-manager(5)cloud-controller-manager二、Node组件1.kubelet2.kube-proxy3.容器运行时（ContainerRuntime）三、插件（Add
  • 「Python」2020.04.08学习笔记 | 第六章文件（a+）模式+把随机手机号写入文件小练习 Yetta的书影屋
    学习测试开发的Day97，真棒！学习时间为40M第九次全天课(下午视频二20M-50M）>>>fp.seek(0)0>>>fp.read()'你好11你好12你好13你好14你好15\n你好16\n你好17\n你好18\n'>>>fp.seek(0,0)0>>>fp.write("*********************************\n")34>>>fp.seek(0,0)0>>>f
  • 《金文成〈中庸〉学习笔记401。2020-2-24》 金吾生
    《金文成〈中庸〉学习笔记401。2020-2-24》今天是庚子年戊寅月丁酉日，二月初二，2020年2月24日星期一。二月二龙抬头。第二十二章【唯天下至诚，为能尽其性；能尽其性，则能尽人之性；能尽人之性，则能尽物之性；能尽物之性，则能赞天地之化育；能赞天地之化育，则可以与天地参矣。】上一节，船山讲解说，性作为天用之本体，于圣人和匹夫匹妇而言并无二致，区别来自于诚。诚的区别来自于纯粹与掺杂。掺杂什么呢
  • CDGA学习笔记三-《数据安全》 zy_chris 网络安全
    七、数据安全7.1引言数据安全包括安全策略和过程的规划、建立与执行，为数据和信息资产提供正确的身份验证、授权、访问和审计。要求来自以下方面：（1）利益相关方（2）政府法规（3）特定业务关注点（4）合法访问需求（5）合同义务7.1.1业务驱动因素1、降低风险信息安全首先对组织数据进行分级分类，对组织数据进行分类分级的整个流程：1）识别敏感数据资产并分类分级2）在企业中查找敏感数据3）确定保护每项资产
  • vue学习笔记——关于对Vue3 ref(), toRef(), toRefs(), unref(), isRef(), reactive()方法的理解。 chen_sir_sh vue学习笔记javascript前端vue
    VUE3出现了很多新的API，下面是自己的一些理解进行的总结。欢迎大家一起交流补充。ref()使用ref创建一个数据类型，ref有value这个属性constname1={age:"14",name:"bob1"};constname2=ref({name:"bob2"});//使用ref创建一个数据类型相对于reactive，ref有value属性name2.value="bob3"consol
  • 遇到僵尸进程，怎么处理---学习笔记 summer@彤妈 性能优化linux
    僵尸进程解释当iowait升高时，进程很可能因为得不到硬件的响应，而长时间处于不可中断状态。从ps或者top命令的输出中，你可以发现它们都处于D状态，也就是不可中断状态（UninterruptibleSleep）。既然说到了进程的状态，进程有哪些状态你还记得吗？我们先来回顾一下。top和ps是最常用的查看进程状态的工具，我们就从top的输出开始。下面是一个top命令输出的示例，S列（也就是Stat
  • C++学习笔记----6、内存管理（五）---- 智能指针（3） 王俊山IT c++学习笔记开发语言
    2、shared_ptr有时候吧，有些对象或者一部分代码需要同一个指针的拷贝。那么unique_ptr不能被拷贝，因此就不能用于些场景。这样的话，std::shared_ptr就是一个支持能够被拷贝的拥有共享属主的智能指针。但是，如果有指向同一个资源的多个shared_ptr实例，那么怎么知道什么时候去释放资源呢？这可以通过对于引用记数来解决，这个我们以后再聊。首先，让我们看一下怎么构造与使用sh
  • 【学习笔记】武志红心理学—潜意识决定命运 万万千千
    冰山一角什么构成了我们的命运？命运是由我们的显意识和潜意识来决定的。我们可以用一张图做一个比喻。看过“冰山一角”图片的都知道，潜意识就是水面以下的部分，显意识是水面以上的部分，从体积来看，潜意识占了大部分，而显意识只是冰山一角，纵向来看，庞大的潜意识支撑着冰山一角的显意识，才得以让冰山漂浮在水面。延伸到我们的人生，我们对自己显意识层面的想法很容易感知到，所以我们会说这是“我”自己做的选择。而潜意识
  • Prism 教程 yang_B621 PrismIOC
    http://t.csdnimg.cn/VXSSvhttps://blog.csdn.net/u010476739/article/details/119341731Prism-随笔分类-Hello——寻梦者！-博客园(cnblogs.com)C#IoC学习笔记-缥缈的尘埃-博客园(cnblogs.com)WPF_SchuylerEX的博客-CSDN博客
  • 绘本讲师训练营【第30期】2/21阅读原创《绘本之力》学习笔记2 郑贤钰
    30028郑贤钰今天读了绘本之力《留在灵魂里的东西》读了心里有非常大的感触！两个年幼什么都不懂的孩子，为了自己心爱的东西，攒下来自己的零花钱，却买了一个自己不知道怎么用的东西，当他们觉得这个东西根本就不好，准备扔掉的时候，这是故事中的有趣有爱的老爷爷出现了，帮助孩子们再一次发现之前别人拉出优美的音乐，原来自己买的这一个琴，自认为没用的琴也能够经过老爷爷熟练的演奏也能拉出这样优美的声音，这让孩子们十
  • 仿老师悟 耕海者
    毕业十年了，今天去拜访老师，看到老师的学习笔记，看到老师努力学习，积极提高的状态，我觉着自己真是有些懈怠了，孩子们，老师的老师都在孜孜不倦，我们岂能偷懒！
  • C++学习笔记----7、使用类与对象获得高性能（一）---- 书写类（2） 王俊山IT c++学习笔记开发语言
    2.2、定义成员函数前面对SpreadsheetCell类的定义足以让你生成类的对象。然而，如果想调用setValue()或者getValue()成员函数，连接器就会抱怨这些函数没有定义。这是因为到目前为止，这些成员函数只有原型，而还没有实现。通常，类的定义会在模块接口文件。对于成员函数的定义，你有一个选择：可以在模块定义文件或者在模块实现文件。下面是SpreadsheetCell类，在类内对成员
  • Spring6学习笔记4：事务 ·云扬· SSMJava#Spring学习笔记spring
    1JdbcTemplate1.1简介Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作准备工作①搭建子模块搭建子模块：spring-jdbc-tx②加入依赖org.springframeworkspring-jdbc6.0.2mysqlmysql-connector-java8.0.30com.alibabadruid1.2.15③创建jdbc.propertie
  • 连通无向图一般中心的算法及其matlab程序详解 夏天天天天天天天# 图论算法matlab图论
    #################本文为学习《图论算法及其MATLAB实现》的学习笔记#################若服务点只允许取在各顶点上,而服务对象却取在各顶点及各边(或弧)上的点,则在所有顶点中选定一个顶点作为图的一般中心其条件是该点离它本身的最远服务对象(包括顶点及各边(或弧)上的点)的距离达到极小值。寻找无向图的一般中心对解决网络最佳服务点确定的问题是十分有效的，使得服务对象的范围
  • 学习笔记：FW内容安全概述 TKE_yinian
    内容安全概述信息安全概述主要威胁关于防护简介内容安全威胁应用层威胁内容安全技术WEB安全应用安全入侵防御检测邮件安全数据安全网络安全反病毒全局环境感知沙箱检测信息安全概述•信息安全是对信息和信息系统进行保护，防止未授权的访问、使用、泄露、中断、修改、破坏并以此提供保密性、完整性和可用性。•为关键资产提供机密性、完整性和可用性（CIA三元组）保护是信息安全的核心目标。CIA（Confidential
  • java的socket实现一个九宫棋游戏 睡不醒的小泽
    前言一个简单的socket小作品=v=一个机酱在大三实验课中接触到很基础的JAVA语言socket编程。至于你问为什么嵌入式的机酱会弄些Java吗？emmmmm，可能是当初C语言版的不够好玩吧，另外如果碰巧有用，欢迎抱走的yoo在之前的笔记《网络基础知识和网络编程》中有讲解过关于网络编程的一些基本知识，以及一些LinuxC的socket编程，希望粗浅了解socket内部肌理的同学，右转咱的学习笔记
  • 【每日一词】D33 edge 宠辱不惊的中年少女
    1）学习笔记：edge：优势，=advantagebeanabsoluteedge有绝对优势AhasanedgeoverB表示A比B更好maintainone'sedge保持优势loseone'sedge失去优势innovativeedge创新方面的优势2）查字典延伸：A.就工作经验而言，她显然要比我们面试过的其他人都胜出一筹。Intermsofexperience,shedefinitelyha
  • xml解析 小猪猪08 xml
    1、DOM解析的步奏 准备工作：    1.创建DocumentBuilderFactory的对象    2.创建DocumentBuilder对象    3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件    4.通过Document的getElem
  • 每个开发人员都需要了解的一个SQL技巧 brotherlamp linuxlinux视频linux教程linux自学linux资料
      对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。 使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： CREATE TABLE books (   id &
  • Quartz——CronTrigger触发器 eksliang quartzCronTrigger
    转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。 二.Cron表达式介绍 1）Cron表达式规则表 Quartz
  • Informatica基础 18289753290 InformaticaMonitormanagerworkflowDesigner
    1. 1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 2）Workflow  Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 3）Workflow  Monitor：监控Workflow和Session运行情况，生成日志和报告 4）Repository  Manager：
  • linux下为程序创建启动和关闭的的sh文件，scrapyd为例 酷的飞上天空 scrapy
    对于一些未提供service管理的程序  每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件   下面以scrapy启动server为例，文件名为run.sh：   #端口号，根据此端口号确定PID PORT=6800 #启动命令所在目录 HOME='/home/jmscra/scrapy/' #查询出监听了PORT端口
  • 人--自私与无私 永夜-极光
                今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么?               从客观的角度来看,人有自私的行为,也有无私的
  • Ubuntu安装NS-3 环境脚本 随便小屋 ubuntu
      将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令：   sudo ./ns3environment.sh >>result   这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示     com
  • 创业的简单感受 aijuans 创业的简单感受
           2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。      今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。 当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
  • 如何经营自己的独立人脉 aoyouzi 如何经营自己的独立人脉
    独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。   现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。   以一个普通的银行柜员
  • JSP基础 百合不是茶 jsp注释隐式对象
      1,JSP语句的声明 <%! 声明 %> 　　 声明：这个就是提供java代码声明变量、方法等的场所。 表达式 <%= 表达式 %> 　　 这个相当于赋值，可以在页面上显示表达式的结果， 程序代码段/小型指令　<% 程序代码片段 %>   2,JSP的注释   <!-- -->
  • web.xml之session-config、mime-mapping bijian1013 javaweb.xmlservletsession-configmime-mapping
    session-config 1.定义： <session-config> <session-timeout>20</session-timeout> </session-config> 2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。   mime-mapping 1.定义： <mime-m
  • 互联网开放平台（1） Bill_chen 互联网qq新浪微博百度腾讯
    现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 1.淘宝开放平台(TOP) 网址：http://open.taobao.com/ 依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。 目前TOP的三条主线： TOP访问网站：open.taobao.com ISV后台：my.open.ta
  • 【MongoDB学习笔记九】MongoDB索引 bit1129 mongodb
    索引 可以在任意列上建立索引 索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 使用索引可以加快查询,但同时会降低修改,插入等的性能 内嵌文档照样可以建立使用索引 测试数据     var p1 = { "name":"Jack", "age&q
  • JDBC常用API之外的总结 白糖_ jdbc
    做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。     ResultSetMetaData获取ResultSet对象的元数据信息
  • apache VelocityEngine使用记录 bozch VelocityEngine
    VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。   使用方法如下：     VelocityEngine engine = new VelocityEngine();// 定义模板引擎     Properties properties = new Properties();// 模板引擎属
  • 编程之美-快速找出故障机器 bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; public class TheLostID { /*编程之美 假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。 1.假设在某个时间得到一个数据文件ID的列表，是
  • 关于Java中redirect与forward的区别 chenbowen00 javaservlet
    在Servlet中两种实现： forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); redirect方式：response.sendRedirect(“/somePage.jsp”); forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
  • [信号与系统]人体最关键的两个信号节点 comsci 系统
            如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做 百汇穴, 另外一个节点在腰部,中医的名称叫做 命门         如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
  • oracle 存储过程执行权限 daizj oracle存储过程权限执行者调用者
    在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 CREATE OR REPLACE PROCEDURE TestProc  IS    fla
  • 为mysql数据库建立索引 dengkane mysql性能索引
    前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。  最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
  • 学习C语言常见误区 如何看懂一个程序 如何掌握一个程序以及几个小题目示例 dcj3sjt126com c算法
    如果看懂一个程序，分三步   1、流程   2、每个语句的功能   3、试数   如何学习一些小算法的程序 尝试自己去编程解决它，大部分人都自己无法解决 如果解决不了就看答案 关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点 看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义 照着答案去敲 调试错误
  • centos6.3安装php5.4报错 dcj3sjt126com centos6
    报错内容如下: Resolving Dependencies --> Running transaction check ---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed --> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for
  • JSONP请求 flyer0126 jsonp
          使用jsonp不能发起POST请求。 It is not possible to make a JSONP POST request. JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
  • Spring Security（03）——核心类简介 234390216 Authentication
    核心类简介 目录 1.1     Authentication 1.2     SecurityContextHolder 1.3     AuthenticationManager和AuthenticationProvider 1.3.1  &nb
  • 在CentOS上部署JAVA服务 java--hhf javajdkcentosJava服务
        本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行     第一步：卸载旧Linux自带的JDK ①查看本机JDK版本 java -version    结果如下 java version "1.6.0"
  • oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date] ldzyz007 oraclemysqlSQL Server
    oracle                                &n
  • 记Protocol Oriented Programming in Swift of WWDC 2015 ningandjin protocolWWDC 2015Swift2.0
    其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭， 把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。 通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
  • 搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS rensanning keepalived
    （一）Keepalived （1）安装 # cd /usr/local/src # wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz # tar zxvf keepalived-1.2.15.tar.gz # cd keepalived-1.2.15 # ./configure # make &a
  • ORACLE数据库SCN和时间的互相转换 tomcat_oracle oraclesql
    SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换； 　　 用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了； 　 　操作方法： 　　1、通过dbms_f
  • Spring MVC 方法注解拦截器 xp9802 spring mvc
    应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理 先看一个实例,使用@access_required拦截： ?

  按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

  首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.