Mybatis（一）Mybatis的基本使用与工作原理

本系列文章：
  Mybatis（一）Mybatis的基本使用与工作原理
  Mybatis（二）Mybatis的高级使用
  Mybatis（三）配置文件解析流程
  Mybatis（四）映射文件解析流程
  Mybatis（五）SQL执行流程
  Mybatis（六）数据源、缓存机制、插件机制

一、初始MyBatis

1.1 ORM

  要了解ORM，先了解下面概念：

• 持久化
    把数据（如内存中的对象）保存到可永久保存的存储设备中。持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中、XML数据文件中等等。
• 持久层
    即专注于实现数据持久化应用领域的某个特定系统的一个逻辑层面，将数据使用者和数据实体相关联。

  ORM，即Object-Relational Mapping（对象关系映射），它的作用是在关系型数据库和业务实体对象之间作一个映射。这样在具体的操作业务对象的时候，就不需要再去和复杂的SQL语句打交道，只需简单的操作对象的属性和方法。
  总结：

1. 它是一种将内存中的对象保存到关系型数据库中的技术；
2. 主要负责实体对象的持久化，封装数据库访问细节；
3. 提供了实现持久化层的另一种模式，采用映射元数据（XML）来描述对象-关系的映射细节，使得ORM中间件能在任何一个Java应用的业务逻辑层和数据库之间充当桥梁。

  Java典型的ORM框架：
   1）hibernate：全自动的框架，强大、复杂、笨重、学习成本较高；
   2）Mybatis：半自动的框架， 必须要自己写sql；
   3）JPA：JPA全称Java Persistence API、JPA通过JDK 5.0注解或XML描述对象-表的映射关系，是Java自带的框架。

1.2 MyBatis

  MyBatis是一款持久层半ORM框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和Java的POJO（Plain Old Java Objects，普通老式Java对象）为数据库中的记录。
  MyBatis的核心配置文件是mybatis-config.xml。

1.2.1 MyBatis特点

• 1、定制化SQL
    同为持久层框架的Hibernate，对操作数据库的支持方式较多，完全面向对象的、原生SQL的和HQL的方式。MyBatis只支持原生的SQL语句，这个“定制化”是相对Hibernate完全面向对象的操作方式的。
• 2、存储过程
    储存过程是实现某个特定功能的一组sql语句集，是经过编译后存储在数据库中。当出现大量的事务回滚或经常出现某条语句时，使用存储过程的效率往往比批量操作要高得多。
    MyBatis是支持存储过程的，可以看个例子。假设有一张表student：

	create table student
	(
	  id bigint not null,
	  name varchar(30),
	  sex char(1),
	  primary key (id)
	);

  有一个添加记录的存储过程：

	create procedure pro_addStudent (IN id bigint, IN name varchar(30), IN sex char(1))
	begin
	   insert into student values (id, name, sex);
	end

  此时就可以在mapper.xml文件中调用存储过程：

<select id="findStudentById" parameterType="java.lang.Long" statementType="CALLABLE" 
    resultType="com.mybatis.entity.Student">
    {call pro_getStudent(#{id,jdbcType=BIGINT,mode=IN})}
select>

 <parameterMap type="java.util.Map" id="studentMap">
     <parameter property="id" mode="IN" jdbcType="BIGINT"/>
parameterMap>



<select id="findStudentById" parameterMap="studentMap" statementType="CALLABLE" 
    resultType="com.mybatis.entity.Student">
    {call pro_getStudent(?)}
select>

• 3、高级映射
    可以简单理解为支持关联查询。
• 4、避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。使用Mybatis时，数据库的连接配置信息，是在mybatis-config.xml文件中配置的。同时，获取查询结果的代码，也是尽量做到了简洁。以模糊查询为例，需要做两步工作：
    1）首先在配置文件中写上SQL语句，示例：

    <mapper namespace="com.test.pojo">
        <select id="listCategoryByName"  parameterType="string" resultType="Category">
            select * from   category_  where name like concat('%',#{0},'%')
        select>    
    mapper>

    2）在Java代码中调用此语句，示例：

        List<Category> cs = session.selectList("listCategoryByName","cat");
        for (Category c : cs) {
            System.out.println(c.getName());
        }

• 5、Mybatis中ORM的映射方式也是比较简单的
    "resultType"参数的值指定了SQL语句返回对象的类型。示例代码：

    <mapper namespace="com.test.pojo">
        <select id="listCategory" resultType="Category">
            select * from   category_     
        </select>
    </mapper>

1.2.2 Mybatis的适用场景

  MyBatis专注于SQL本身，是一个足够灵活的DAO层解决方案。
  MyBatis框架的适用场景：对性能的要求很高，或者需求变化较多的项目，如互联网项目。

1.2.3 为什么说Mybatis是半自动ORM映射工具

  Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。
  而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

  MyBatis作为半自动ORM映射工具与全自动ORM工具相比，有几个主要的区别点：

• 1、SQL的灵活性
    MyBatis作为半自动ORM映射工具，开发人员可以灵活地编写SQL语句，充分发挥数据库的特性和优势。而全自动ORM工具通常会在一定程度上限制开发人员对SQL的灵活控制。
• 2、映射关系的可定制性
    MyBatis允许开发人员通过配置文件（或注解）自定义对象和数据库表之间的映射关系，可以满足各种复杂的映射需求。而全自动ORM工具通常根据约定和规则自动生成映射关系，对于某些特殊需求无法满足。
• 3、SQL的可复用性
    MyBatis支持SQL的可复用性，可以将常用的SQL语句定义为独立的SQL片段，并在需要的地方进行引用。而全自动ORM工具通常将SQL语句直接与对象的属性绑定在一起，缺乏可复用性。
• 4、性能调优的灵活性
    MyBatis作为半自动ORM映射工具，允许开发人员对SQL语句进行灵活的调优，通过手动编写SQL语句和使用高级特性进行性能优化。而全自动ORM工具通常将性能优化的控制权交给框架，开发人员无法灵活地对SQL进行调优。

  MyBatis作为一种半自动ORM映射工具，相对于全自动ORM工具具有更高的灵活性和可定制性。通过灵活的SQL控制、自定义的映射关系、可复用的SQL以及灵活的性能调优，MyBatis可以满足各种复杂的映射需求和性能优化需求。虽然MyBatis相对于全自动ORM工具需要开发人员编写更多的SQL语句，但正是由于这种半自动的特性，使得MyBatis在某些复杂场景下更加灵活和可控。
  因此，我们可以说MyBatis是一种半自动ORM映射工具，与全自动的ORM工具相比，它更适用于那些对SQL灵活性和性能调优需求较高的场景。

1.2.4 Mybatis的优缺点

  Mybatis有以下优点：

• 1、基于SQL语句编程，相当灵活
    SQL写在XML里，解除sql与程序代码的耦合，便于统一管理；提供XML标签，支持编写动态SQL语句，并可重用。
• 2、代码量少
    与JDBC相比，减少了50%以上的代码量，消除了JDBC大量冗余的代码，不需要手动开关连接。
• 3、很好的与各种数据库兼容
• 4、数据库字段和对象之间可以有映射关系
    提供映射标签，支持对象与数据库的ORM字段关系映射。
• 5、能够与Spring很好的集成

  --------------------------------------------------------------------------------------------------------
  Mybatis有以下缺点：

• 1、SQL语句的编写工作量较大
    尤其当字段多、关联表多时，SQL语句较复杂。
• 2、数据库移植性差
    SQL语句依赖于数据库，不能随意更换数据库（可以通过在mybatis-config.xml配置databaseIdProvider来弥补），示例：

    <databaseIdProvider type="DB_VENDOR">
        <property name="MySQL" value="mysql"/>
        <property name="SQL Server" value="sqlserver"/>
        <property name="Oracle" value="oracle"/>
    databaseIdProvider>

  然后在xml文件中，就可以针对不同的数据库，写不同的sql语句。

• 3、字段映射标签和对象关系映射标签仅仅是对映射关系的描述，具体实现仍然依赖于sql
    示例：

public class Student{
	String name;	
	List<Interest>  interests;
}

public class Interest{
	String studentId;
	String name;
	String direction;
}

	<resultMap id="ResultMap" type="com.test.Student">
        <result column="name" property="name" />
        <collection property="interests" ofType="com.test.Interest">
            <result column="name" property="name" />
            <result column="direction" property="direction" />
        collection>
    resultMap>

  在该例子中，如果查询sql中，没有关联Interest对应的表，则查询出数据映出的Student对象中，interests属性值就会为空。

• 4、DAO层过于简单，对象组装的工作量较大
    即Mapper层Java代码过少，XxxMapper.xml文件中维护数据库字段和实体类字段的工作量较大。
• 5、不支持级联更新、级联删除
    仍以上面的Student和Interest为例，当要更新/删除某个Student的信息时，需要在两个表进行手动更新/删除。

1.2.5 Mybatis使用时可能会产生什么问题

• 1、使用不当，会导致N+1的sql性能问题
    “N+1”问题具体指的是：

1. 执行了一个单独的SQL语句来获取结果的一个列表（就是“1”）。
2. 对列表返回的每条记录，执行一个select查询语句来为每条记录加载详细信息（就是“N”）。

  其实就是相关联的两步查询，可能会出现"N+1"的情况。修改方法如下：

1、在sql语句中使用join语句连接多张表并进行查询（常用）。
2、使用懒加载技术，延迟“N查询”部分中各操作被执行的时间节点；
3、合并N查询为一个查询，通过使用Sql的关键字in。

• 2、使用不当，会分页BUG
    写法1：

	//错误写法
	startPage();
	List<User> list;
	if(user != null){
	    list = userService.selectUserList(user);
	} else {
	    list = new ArrayList<User>();
	}
	Post post = postService.selectPostById(1L);
	return getDataTable(list);
	
	//正确写法
	List<User> list;
	if(user != null){
		startPage();
		list = userService.selectUserList(user);
	} else {
		list = new ArrayList<User>();
	}
	Post post = postService.selectPostById(1L);
	return getDataTable(list);

  以上代码错误的原因是：由于user存在null的情况，就会导致pageHelper生产了一个分页参数，但是没有被消费，这个参数就会一直保留在这个线程上。 当这个线程再次被使用时，就可能导致不该分页的方法去消费这个分页参数，这就产生了莫名其妙的分页。
  写法2：

	//错误写法
	startPage();
	Post post = postService.selectPostById(1L);
	List<User> list = userService.selectUserList(user);
	return getDataTable(list);

	//正确写法
	Post post = postService.selectPostById(1L);
	startPage();
	List<User> list = userService.selectUserList(user);
	return getDataTable(list);

  以上代码错误的原因是：只对开启分页后的第一个查询sql语句查到的数据进行分页。

• 3、使用不当，会产生脏数据
    产生脏数据的原因是Mybatis的二级缓存机制。
    MyBatis二级缓存是和命名空间绑定的 ，所以通常情况下不同的Mapper映射文件都拥有自己的二级缓存，不同Mapper之间的二级缓存互不影响 。在关联多表查询时肯定会将该查询放到某个命名空间下的映射文件中，这样一个多表的查询就会缓存在该命名空间的二级缓存中。
    因此，对于同一个表的数据，在一个Mapper文件了进行了增删改查，该Mapper文件对应的二级缓存发生了变化。该表所在的别的Mapper文件的二级缓存可能没发生变化，这种情况下就会产生脏数据。
    脏数据解决方法：不使用Mybatis的二级缓存，使用Redis的缓存。

1.3 Mybatis和JDBC、Hibernate的区别

1.3.1 JDBC和Mybatis的比较

  JDBC(Java Data Base Connection，java数据库连接)是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。
  传统的JDBC开发，通常是如下的流程：

	加载驱动;
	建立连接;
	定义sql语句;
	准备静态处理块对象;
	执行sql语句;
	处理结果集;
	关闭连接.

  传统的JDBC开发的最原始的开发方式，有以下问题：

• 1、频繁创建数据库连接对象、释放，容易造成系统资源浪费，影响系统性能。可以使用连接池解决这个问题，但是使用JDBC需要自己实现连接池。
• 2、sql语句定义、参数设置、结果集处理存在硬编码。实际项目中sql语句变化的可能性较大，一旦发生变化，需要修改java代码，系统需要重新编译，重新发布，不好维护。
• 3、使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。
• 4、结果集处理存在重复代码，处理麻烦。如果可以映射成Java对象会比较方便。 这点也容易理解，在使用JDBC时，需要用 ResultSet之类的方式来遍历数据库中查询出来的一条条字段，这是不方便的，示例：

    /*ResultSet:查询结果集*/
    ResultSet rs = s.executeQuery(sql);
    while (rs.next()) {
        /*可以使用字段名获取该列内容*/
        int id = rs.getInt("id");
        /*也可以使用字段的顺序，需要注意的是：顺序是从1开始的*/
        String name = rs.getString(2);
        float hp = rs.getFloat("hp");
        int damage = rs.getInt(4);
        System.out.printf("%d\t%s\t%f\t%d%n", id, name, hp, damage);
    }

• JDBC编程有哪些不足之处，MyBatis是如何解决这些问题的

1. 数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能。
     MyBatis：在mybatis-config.xml中配置数据连接池，使用连接池管理数据库连接。
2. Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变Java代码。
     MyBatis：将Sql语句配置在XXXXmapper.xml文件中，与Java代码分离。
3. 向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。
     MyBatis： Mybatis自动将Java对象映射至sql语句。
4. 对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。
     MyBatis：Mybatis可以自动将sql执行结果映射至Java对象（一般是DTO对象）。

1.3.2 Hibernate和MyBatis的比较

  相同点：都是对JDBC的封装，都是持久层的框架，都用于dao层的开发。

• 不同点1：映射关系
    MyBatis是一个半自动映射的框架，配置Java对象与sql语句执行结果的对应关系，多表关联关系配置简单。
    Hibernate是一个全表映射的框架，配置Java对象与数据库表的对应关系，多表关联关系配置复杂。

• 不同点2：SQL优化和移植性
    Hibernate对SQL语句封装，提供了日志、缓存、级联（级联比MyBatis强大）等特性， 此外还提供HQL（Hibernate Query Language）操作数据库，数据库无关性支持好，但会多消耗性能。如果项目需要支持多种数据库，代码开发量少，但SQL语句优化困难。
    MyBatis需要手动编写SQL，支持动态SQL、处理列表、动态生成表名、支持存储过程。 开发工作量相对大些。直接使用SQL语句操作数据库，不支持数据库无关性，但sql语句优 化容易。

• 不同点3：开发难易程度和学习成本
    Hibernate是重量级框架，学习使用门槛高，适合于需求相对稳定，中小型的项目，比如： 办公自动化系统。
    MyBatis是轻量级框架，学习使用门槛低，适合于需求变化频繁，大型的项目，比如：互 联网电子商务系统。

• Hibernate优势
    1）Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。
    2）Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
    3）Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
    4）Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

• Mybatis优势
    1）MyBatis可以进行更为细致的SQL优化，可以减少查询字段。
    2）MyBatis容易掌握，而Hibernate门槛较高。
    3）sql语句和Java代码耦合性低。

• 总结
    MyBatis是一个小巧、方便、高效、简单、直接、半自动化的持久层框架，
    Hibernate是一个强大、方便、高效、复杂、间接、全自动化的持久层框架。

二、Mybatis的基础使用

  以下两种方式了解即可，实际开发中不会这样使用Mybatis。

2.1 MyBatis编程步骤

• 第一种步骤

1. 创建SqlSessionFactory；
2. 通过SqlSessionFactory创建SqlSession；
3. 通过sqlsession执行数据库操作；
4. 调用session.commit()提交事务；
5. 调用session.close()关闭会话。

  示例：

        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();
 
        Category c = new Category();
        c.setName("新增加的Category");
        session.insert("addCategory",c);
         
        session.commit();
        session.close();

• 第二种步骤

1. 创建SqlSessionFactory对象。
2. 通过SqlSessionFactory获取SqlSession对象。
3. 通过SqlSession获得Mapper代理对象。
4. 通过Mapper代理对象，执行数据库操作。
5. 执行成功，则使用SqlSession提交事务。
6. 执行失败，则使用SqlSession回滚事务。
7. 关闭session会话。

  示例：

        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();
        CategoryMapper mapper = session.getMapper(CategoryMapper.class);
  
        List<Category> cs = mapper.list();
        for (Category c : cs) {
            System.out.println(c.getName());
        }
        session.commit();
        session.close();

2.1 Mybatis使用示例

  同理，以下两种方式了解即可。
  先在数据库建一张表：表名为student，字段有id、name、score、age、gender。

2.1.1 实体类

package com.test.po;
import lombok.*;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Student {
	private Integer id;
	private String name;
	private Integer score;
	private Integer age;
	private Integer gender;
}

2.1.2 Mapper.xml

DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="test">
    <select id="findAll" resultType="com.test.po.Student">
        SELECT * FROM student;
    select>

    <insert id="insert" parameterType="com.test.po.Student">
        INSERT INTO student (name,score,age,gender) VALUES (#{name},#{score},#{age},#{gender});
    insert>
    
    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id};
    delete>
mapper>

2.1.3 数据库连接配置文件

  配置数据库连接信息：

	db.url=jdbc:mysql://localhost:3306/yogurt?characterEncoding=utf8
	db.user=root
	db.password=root
	db.driver=com.mysql.jdbc.Driver

2.1.4 mybatis-config.xml

DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <properties resource="properties/db.properties">properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                
                <property name="driver" value="${db.driver}"/>
                <property name="url" value="${db.url}"/>
                <property name="username" value="${db.user}"/>
                <property name="password" value="${db.password}"/>
            dataSource>
        environment>
    environments>

    <mappers>
        
        <mapper resource="StudentMapper.xml"/>
    mappers>

configuration>

2.1.4 DAO类

  此处调用XXXMapper.xml文件中的SQL语句。

package com.test.dao;

import com.test.po.Student;
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 StudentDao {

	private SqlSessionFactory sqlSessionFactory;

	public StudentDao(String configPath) throws IOException {
		InputStream inputStream = Resources.getResourceAsStream(configPath);
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}

	public List<Student> findAll() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		List<Student> studentList = sqlSession.selectList("findAll");
		sqlSession.close();
		return studentList;
	}

	public int addStudent(Student student) {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		int rowsAffected = sqlSession.insert("insert", student);
		sqlSession.commit();
		sqlSession.close();
		return rowsAffected;
	}

	public int deleteStudent(int id) {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		int rowsAffected = sqlSession.delete("delete",id);
		sqlSession.commit();
		sqlSession.close();
		return rowsAffected;
	}
}

2.1.5 业务类

  此处用测试类代替：

public class SimpleTest {
	private StudentDao studentDao;

	@Before
	public void init() throws IOException {
		studentDao = new StudentDao("mybatis-config.xml");
	}

	@Test
	public void insertTest() {
		Student student = new Student();
		student.setName("yogurt");
		student.setAge(24);
		student.setGender(1);
		student.setScore(100);
		studentDao.addStudent(student);
	}

	@Test
	public void findAllTest() {
		List<Student> all = studentDao.findAll();
		all.forEach(System.out::println);
	}
}

  结果示例：

2.3 mybatis-config.xml

  mybatis-config.xml是Mybatis使用的核心配置文件。在该文件中，各个标签是有顺序的，因为mybatis加载配置文件的源码中是按照这个顺序进行解析的：

<configuration>
	
configuration>

• 1、
    一般将数据源的信息单独放在一个properties文件中，然后用这个标签引入，在下面environment标签中，就可以用${}占位符快速获取数据源的信息。
• 2、
    用来开启或关闭mybatis的一些特性，比如可以用来开启延迟加载，可以用来开启二级缓存。
• 3、
    在XXXMapper.xml中需要使用parameterType和resultType属性来配置SQL语句的输入参数类型和输出参数类型，类必须要写上全限定名，比如一个SQL的返回值映射为Student类，则resultType属性要写com.test.po.Student，可以用别名来简化书写，示例：

	<typeAliases>
	    <typeAlias type="com.test.po.Student" alias="student"/>
	typeAliases>

  之后就可以在resultType上直接写student，mybatis会根据别名配置自动找到对应的类。当然，如果想要一次性给某个包下的所有类设置别名，可以用如下的方式：

	<typeAliases>
	   <package name="com.test.po"/>
	typeAliases>

  如此，指定包下的所有类，都会以简单类名的小写形式，作为它的别名。
  别名使用时是不区分大小写的。
  另外，对于基本的Java类型 -> 8大基本类型以及包装类，以及String类型，mybatis提供了默认的别名，别名为其简单类名的小写，比如原本需要写java.lang.String，其实可以简写为string。
  Mybatis默认的别名在TypeAliasRegistry中进行注册的，这个类就是Mybatis注册别名使用的，别名和具体的类型关联是放在这个类的一个map属性（typeAliases）中。
  Mybatis默认为很多类型提供的别名：

别名	对应的实际类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

  别名的原理：Mybatis允许我们给某种类型注册一个别名，别名和类型之间会建立映射关系，这个映射关系存储在一个map对象中，key为别名的名称，value为具体的类型。当我们通过一个名称访问某种类型的时候，Mybatis根据类型的名称，先在别名和类型映射的map中按照key进行查找，如果找到了直接返回对应的类型。如果没找到，会将这个名称当做完整的类名去解析成Class对象，如果这2步解析都无法识别这种类型，就会报错。

• 4、
    用于处理Java类型和Jdbc类型之间的转换，mybatis有许多内置的TypeHandler，比如StringTypeHandler，会处理Java类型String和Jdbc类型CHAR和VARCHAR。
• 5、
    mybatis会根据resultType或resultMap的属性来将查询得到的结果封装成对应的Java类，它有一个默认的DefaultObjectFactory，用于创建对象实例。
• 6、
    可以用来配置mybatis的插件，比如在开发中经常需要对查询结果进行分页，就需要用到pageHelper分页插件，这些插件就是通过这个标签进行配置的。示例：

<plugins>
  <plugin interceptor="com.github.pagehelper.PageInterceptor">
     <property name="helperDialect" value="mysql"/>
  plugin>
plugins>

• 7、
    配置数据源。
• 8、
    用来配置XXXMapper.xml映射文件。

三、Mybatis原理

3.1 MyBatis的工作原理

  工作原理图示：

• 1、读取MyBatis配置文件
    mybatis-config.xml为MyBatis的全局配置文件，配置了MyBatis的运行环境等信息，例如数据库连接信息。
• 2、加载映射文件（SQL映射文件，一般是XXXMapper.xml）
    该文件中配置了操作数据库的SQL语句，需要在MyBatis配置文件mybatis-config.xml中加载。XXXMapper.xml可以在mybatis-config.xml文件可以加载多个映射文件，每个文件对应数据库中的一张表。
• 3、构造会话工厂
    通过MyBatis的环境等配置信息构建会话工厂SqlSessionFactory。
• 4、创建会话对象
    由会话工厂创建SqlSession对象，该对象中包含了执行SQL语句的所有方法。
• 5、Executor执行器
    MyBatis底层定义了一个Executor接口来操作数据库，它将根据SqlSession传递的参数动态地生成需要执行的SQL语句，同时负责查询缓存的维护。
• 6、MappedStatement对象
    在 Executor接口的执行方法中有一个MappedStatement类型的参数，该参数是对映射信息的封装，用于存储要映射的SQL语句的id、参数等信息。
• 7、输入参数映射
    输入参数类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输入参数映射过程类似于JDBC对preparedStatement对象设置参数的过程。
• 8、输出结果映射
    输出结果类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输出结果映射过程类似于JDBC对结果集的解析过程。

3.2 MyBatis架构

3.2.1 API接口层

  提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
  MyBatis和数据库的交互有两种方式：使用传统的MyBatis提供的API、使用Mapper接口。

• 1、使用传统的MyBatis提供的API
    这是传统的传递Statement Id和查询参数给SqlSession对象，使用SqlSession对象完成和数据库的交互；MyBatis提供了非常方便和简单的API，供用户实现对数据库的增删改查数据操作，以及对数据库连接信息和MyBatis自身配置信息的维护操作。
  
    示例：

    SqlSession session = sqlSessionFactory.openSession();
    Category c = new Category();
    c.setName("新增加的Category");
    session.insert("addCategory",c);

  上述使用MyBatis的方法，是创建一个和数据库打交道的SqlSession对象，然后根据Statement Id和参数来操作数据库，这种方式固然很简单和实用，但是它不符合面向对象语言的概念和面向接口编程的编程习惯。

• 2、使用Mapper接口
    MyBatis将配置文件中的每一个节点抽象为一个Mapper接口，而这个接口中声明的方法和跟节点中的节点项对应，即节点的id值为Mapper接口中的方法名称，parameterType值表示Mapper对应方法的入参类型，而resultMap值则对应了Mapper接口表示的返回值类型或者返回结果集的元素类型。
    示例：

    SqlSession session = sqlSessionFactory.openSession();
    CategoryMapper mapper = session.getMapper(CategoryMapper.class);
    List<Category> cs = mapper.list();
    for (Category c : cs) {
        System.out.println(c.getName());
    }

   根据MyBatis的配置规范配置后，通过SqlSession.getMapper(XXXMapper.class)方法，MyBatis会根据相应的接口声明的方法信息，通过动态代理机制生成一个Mapper实例。使用Mapper接口的某一个方法时，MyBatis会根据这个方法的方法名和参数类型，确定Statement Id，底层还是通过SqlSession.select("statementId",parameterObject)或者SqlSession.update("statementId",parameterObject)等等来实现对数据库的操作。
   MyBatis引用Mapper接口这种调用方式，纯粹是为了满足面向接口编程的需要。

3.2.2 数据处理层

  负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

• 1、参数映射和动态SQL语句生成
    动态语句生成可以说是MyBatis框架非常优雅的一个设计，MyBatis通过传入的参数值，使用OGNL表达式来动态地构造SQL语句，使得MyBatis有很强的灵活性和扩展性。
  
    参数映射指的是对于Java数据类型和JDBC数据类型之间的转换：这里有包括两个过程：查询阶段，我们要将java类型的数据，转换成JDBC类型的数据，通过preparedStatement.setXXX()来设值；另一个就是对ResultSet查询结果集的JdbcType 数据转换成Java数据类型。
• 2、SQL语句的执行以及封装查询结果集成List< E>
    动态SQL语句生成之后，MyBatis将执行SQL语句，并将可能返回的结果集转换成List 。MyBatis 在对结果集的处理中，支持结果集关系一对多和多对一的转换，并且有两种支持方式，一种为嵌套查询语句的查询，还有一种是嵌套结果集的查询。

3.2.3 基础支撑层

  负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

3.2.4 Mybatis层次结构

3.3 Executor执行器

3.3.1 Executor的类别

  Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。

• 1、SimpleExecutor
    每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
• 2、ReuseExecutor
    执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map内，供下一次使用。简言之，就是重复使用Statement对象。
• 3、BatchExecutor
    执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

  作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。

3.3.2 Executor的配置

  指定Executor方式有两种：

• 1、在配置文件中指定

<settings>
    <setting name="defaultExecutorType" value="BATCH" />
settings>

• 2、在代码中指定
    在获取SqlSession时设置，需要注意的时是，如果选择的是批量执行器时，需要手工提交事务（默认不传参就是SimpleExecutor）。示例：

	// 获取指定执行器的sqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
	// 获取批量执行器时, 需要手动提交事务
	sqlSession.commit();

3.4 Mybatis是否支持延迟加载

3.4.1 延迟加载是什么

  MyBatis中的延迟加载，也称为懒加载，是指在进行表的关联查询时，按照设置延迟规则推迟对关联对象的select查询。例如在进行一对多查询的时候，只查询出一方，当程序中需要多方的数据时，mybatis再发出sql语句进行查询，这样子延迟加载就可以的减少数据库压力。MyBatis 的延迟加载只是对关联对象的查询有迟延设置，对于主加载对象都是直接执行查询语句的。
  假如Clazz 类中有子对象HeadTeacher。两者的关系：

public class Clazz {
	private Set<HeadTeacher> headTeacher;
	//...
}

  是否查出关联对象的示例：

    @Test
        public void testClazz() {
        ClazzDao clazzDao = sqlSession.getMapper(ClazzDao.class);
        Clazz clazz = clazzDao.queryClazzById(1);
        //只查出主对象
        System.out.println(clazz.getClassName());            
        //需要查出关联对象 
        System.out.println(clazz.getHeadTeacher().size());   
    }

3.4.2 延迟加载的设置

  在Mybatis中，延迟加载可以分为两种：延迟加载属性和延迟加载集合，association关联对象和collection关联集合对象的延迟加载，association指的就是一对一，collection指的就是一对多查询。在Mybatis配置文件中，可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

• 延迟加载的全局设置
    延迟加载默认是关闭的。如果需要打开，需要在mybatis-config.xml中修改：

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

  比如class班级与student学生之间是一对多关系。在加载时，可以先加载class数据，当需要使用到student数据时，我们再加载 student 的相关数据。

  侵入式延迟加载，指的是只要主表的任一属性加载，就会触发延迟加载，比如：class的name被加载，student信息就会被触发加载。
  深度延迟加载指的是只有关联的从表信息被加载，延迟加载才会被触发。通常，更倾向使用深度延迟加载。

• 延迟加载的局部设置
    如果设置了全局加载，但是希望在某一个sql语句查询的时候不适用延时策略，可以配置局部的加载策略。示例：

    <association 
    	property="dept" select="com.test.dao.DeptDao.getDeptAndEmpsBySimple" 
    	column="deptno" fetchType="eager"/>

  fetchType值有2种，eager：立即加载；lazy：延迟加载。 由于局部的加载策略的优先级高于全局的加载策略。指定属性后，将在映射中忽略全局配置参数lazyLoadingEnabled，使用属性的值。

3.4.3 延迟加载的原理

  MyBatis使用Java动态代理来为查询对象生成一个代理对象。当访问代理对象的属性时，MyBatis会检查该属性是否需要进行延迟加载。如果需要延迟加载，则MyBatis将再次执行SQL查询，并将查询结果填充到代理对象中。

四、Mybatis缓存

  缓存分为一级缓存和二级缓存。一级缓存：线程级别的缓存，sqlSession级别的缓存；二级缓存：全局范围的缓存。默认情况下一级缓存是开启的，而且是不能关闭的。
  Mybatis缓存机制示意图：

4.1 一级缓存

  一级缓存是Session会话级别的，一般而言，一个SqlSession对象会使用一个Executor对象来完成会话操作，Executor对象会维护一个Cache缓存，以提高查询性能。
  每当使用MyBatis开启一次和数据库的会话，MyBatis会创建出一个SqlSession对象表示一次数据库会话。
  一级缓存是指SqlSession级别的缓存，当在同一个SqlSession中进行相同的SQL语句查询时，第二次以后的查询不会从数据库查询，而是直接从缓存中获取。一级缓存最多缓存1024条SQL。
  在对数据库的一次会话中，我们有可能会反复地执行完全相同的查询语句，如果不采取一些措施的话，每一次查询都会查询一次数据库,而我们在极短的时间内做了完全相同的查询，那么它们的结果极有可能完全相同，由于查询一次数据库的代价很大，这有可能造成很大的资源浪费。为了解决这一问题，减少资源的浪费，MyBatis会在表示会话的SqlSession对象中建立一个简单的缓存，将每次查询到的结果结果缓存起来，当下次查询的时候，如果判断先前有个完全一样的查询，会直接从缓存中直接将结果取出，返回给用户，不需要再进行一次数据库查询了。这就是一级缓存。

  一级缓存默认开启，同一个SqlSesion级别共享的缓存，在一个SqlSession的生命周期内，执行2次相同的SQL查询，则第二次SQL查询会直接取缓存的数据，而不走数据库。
  当然，若第一次和第二次相同的SQL查询之间，执行DML(增删改)，则一级缓存会被清空，第二次查询相同SQL仍然会走数据库。
  一级缓存在下面情况会被清除：

• 1、在同一个SqlSession下执行增删改操作时，会清除一级缓存；
• 2、SqlSession提交或关闭时（关闭时会自动提交），会清除一级缓存；
• 3、对mapper.xml中的某个CRUD标签，设置属性flushCache=true，即强制刷新缓存。默认情况下，增删改默认flushCache=true。sql执行以后，会同时清空一级和二级缓存。查询默认flushCache=false。
• 4、在全局配置文件中如下设置：

	<setting name="localCacheScope" value="STATEMENT"/>`

   localCacheScope，用于控制一级缓存的级别，该参数的取值为SESSION、STATEMENT。当指定localCacheScope参数值为SESSION时，缓存对整个SqlSession有效，只有执行DML语句（更新语句）时，缓存才会被清除。当localCacheScope值为STATEMENT时，缓存仅对当前执行的语句有效，当语句执行完毕后，缓存就会被清空。

• 5、传递的参数发生了变化。
• 6、在两次查询期间，手动去清空缓存（sqlSession.clearCache()），也会让缓存失效。

4.1.1 一级缓存原理

  当创建了一个SqlSession对象时，MyBatis会为这个SqlSession对象创建一个新的Executor执行器，而缓存信息就被维护在这个Executor执行器中，MyBatis将缓存和对缓存相关的操作封装成了Cache接口中。SqlSession、Executor、Cache之间的关系图示：

  Executor接口的实现类BaseExecutor中，拥有一个Cache接口的实现类 PerpetualCache，对于BaseExecutor对象而言，它将使用PerpetualCache对象维护缓存。

  PerpetualCache实现原理其实很简单，其内部就是通过一个简单的HashMap来实现的，没有其他的任何限制。

4.1.2 生命周期

1. MyBatis在开启一个数据库会话时，会创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象，Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。
2. 如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用。
3. 如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用。
4. SqlSession中执行了任何一个update 操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用。

• 一级缓存原理（sqlsession级别）
    第一次发出一个查询sql，sql查询结果写入 sqlsession 的一级缓存中，缓存使用的数据结构是一个map。

  key：MapperID+offset+limit+Sql+所有的入参
  value：查到的数据。

  同一个sqlsession再次发出相同的sql，就从缓存中取出数据。如果两次中间出现commit操作（修改、添加、删除），本sqlsession中的一级缓存区域全部清空，下次再去缓存中查询不到所以要从数据库查询，从数据库查询到再写入缓存。

4.1.3 工作流程

  1）对于某个查询，根据statementId、params、rowBounds来构建一个key值，根据这个key值去缓存Cache中取出对应的key值存储的缓存结果；
  2）判断从Cache中根据特定的key值取的数据数据是否为空，即是否命中；
  3）如果命中，则直接将缓存结果返回；
  4）如果没命中：

1. 去数据库中查询数据，得到查询结果；
2. 将key和查询到的结果分别作为key,value对存储到Cache中；
3. 将查询结果返回。

  图示：

  怎样判断某两次查询是完全相同的查询？也就是说：如何确定Cache中的key值？MyBatis认为，对于两次查询，如果以下条件都完全一样，那么就认为它们是完全相同的两次查询：

1. 传入的 statementId；
2. 查询时要求的结果集中的结果范围（结果的范围通过rowBounds.offset和rowBounds.limit表示）；
3. 这次查询所产生的最终要传递给JDBC的Sql语句字符串（boundSql.getSql() ）；
4. 传递给java.sql.Statement要设置的参数值。

  也就是说：Cache Key由以下条件决定： statementId、rowBounds、传递给JDBC的SQL、传递给JDBC的参数值。

4.2 二级缓存

  一个SqlSession对象会使用一个Executor对象来完成会话操作，MyBatis的二级缓存机制的关键就是对这个Executor对象做文章。如果用户配了"cacheEnabled=true"，那么MyBatis在为SqlSession对象创建Executor对象时，会对Executor对象加上一个装饰者：CachingExecutor，这时SqlSession使用CachingExecutor对象来完成操作请求。
  CachingExecutor对于查询请求，会先判断该查询请求在Application级别的二级缓存中是否有缓存结果，如果有查询结果，则直接返回缓存结果；如果缓存中没有，再交给真正的Executor对象来完成查询操作，之后CachingExecutor会将真正Executor返回的查询结果放置到缓存中，然后在返回给用户。
  二级缓存是全局作用域缓存（Mapper级别的缓存），默认是不开启的，需要手动进行配置。二级缓存实现的时候要求实体类实现Serializable接口，二级缓存在sqlSession关闭或提交之后才会生效。
  二级缓存是指可以跨 SqlSession 的缓存。是 mapper 级别的缓存，对于 mapper 级别的缓存不同的 sqlsession 是可以共享的。
  MyBatis的二级缓存设计得比较灵活，你可以使用MyBatis自己定义的二级缓存实现；你也可以通过实现org.apache.ibatis.cache.Cache接口自定义缓存；也可以使用第三方内存缓存库。

4.2.1 二级缓存原理

  当开一个会话时，一个SqlSession对象会使用一个Executor对象来完成会话操作，MyBatis的二级缓存机制的关键就是对这个Executor对象做文章 。如果用户配置了"cacheEnabled=true"，那么MyBatis在为SqlSession对象创建Executor对象时，会对Executor对象加上一个装饰者：CachingExecutor，这时SqlSession使用CachingExecutor对象来完成操作请求。
  CachingExecutor对于查询请求，会先判断该查询请求在Application级别的二级缓存中是否有缓存结果，如果有查询结果，则直接返回缓存结果；如果缓存中没有，再交给真正的Executor对象来完成查询操作，之后CachingExecutor会将真正Executor返回的查询结果放置到缓存中，然后再返回给用户。

  CachingExecutor是Executor的装饰者，以增强Executor的功能，使其具有缓存查询的功能，这里用到了设计模式中的装饰者模式。

• 二级缓存原理
    二级缓存的范围是mapper级别（mapper同一个命名空间），mapper以命名空间为key创建缓存数据结构，结构是map。mybatis的二级缓存是通过CacheExecutor实现的。CacheExecutor其实是Executor的代理对象。所有的查询操作，在CacheExecutor 中都会先匹配缓存中是否存在，不存在则查询数据库。
    key：MapperID+offset+limit+Sql+所有的入参。
    具体使用需要配置：

1. Mybatis 全局配置中启用二级缓存配置
2. 在对应的 Mapper.xml 中配置 cache 节点
3. 在对应的 select 查询节点中添加 useCache=true

4.2.2 二级缓存分类

  MyBatis并不是简单地对整个Application，只有一个Cache缓存对象。它将缓存划分的更细，是Mapper级别的，即每一个Mapper都可以拥有一个Cache对象，具体：

a.为每一个Mapper分配一个Cache缓存对象（使用节点配置）；
b.多个Mapper共用一个Cache缓存对象（使用节点配置）；

  对于每一个Mapper.xml，如果在其中使用了节点，则MyBatis会为这个Mapper创建一个Cache缓存对象，图示：

  上述的每一个Cache对象，都会有一个自己所属的namespace命名空间，并且会将Mapper的namespace作为它们的ID。
  如果想让多个Mapper公用一个Cache的话，你可以使用节点，来指定你的这个Mapper使用到了哪一个Mapper的Cache缓存。

  

4.2.3 配置二级缓存

  要开启二级缓存总开关，需要进行3个步骤的配置：

• 1、需要在全局配置文件中添加配置

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

• 2、在某个具体的mapper.xml中增加配置

	<cache />

  标签的效果：

1. 映射语句文件中的所有 select 语句的结果将会被缓存。
2. 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
3. 缓存会使用最近最少使用算法（LRU）算法来清除不需要的缓存。
4. 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
5. 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
6. 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

• 3、实体类必须要实现Serializable接口

  经过以上三步配置，就开启了该mapper.xml的二级缓存。二级缓存是mapper级别的缓存，粒度比一级缓存大，多个SqlSession可以共享同一个mapper的二级缓存。注意开启二级缓存后，SqlSession需要提交，查询的数据才会被刷新到二级缓存当中。
  MyBatis对二级缓存的支持粒度很细，它会指定某一条查询语句是否使用二级缓存。虽然在Mapper中配置了，并且为此Mapper分配了Cache对象，这并不表示使用Mapper中定义的查询语句查到的结果都会放置到Cache对象之中，我们必须指定Mapper中的某条选择语句是否支持缓存，即如下所示，在节点中配置useCache="true"，Mapper才会对此Select的查询支持缓存特性，否则，不会对此Select查询，不会经过Cache缓存。

4.2.4 二级缓存的属性

  在二级缓存使用时，有一些属性：

• eviction
    表示缓存回收策略，默认是LRU。
    LRU：最近最少使用的，移除最长时间不被使用的对象
    FIFO：先进先出，按照对象进入缓存的顺序来移除
    SOFT：软引用，移除基于垃圾回收器状态和软引用规则的对象
    WEAK：弱引用，更积极地移除基于垃圾收集器状态和弱引用规则的对象
• flushInternal
    刷新间隔，单位毫秒，默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新。
• size
    引用数目，正整数，代表缓存最多可以存储多少个对象，太大容易导致内存溢出。
• readonly
    只读。
    设置为true：只读缓存，会给所有调用这返回缓存对象的相同实例，因此这些对象不能被修改。
    设置为false：读写缓存，会返回缓存对象的拷贝（序列化实现），这种方式比较安全，默认值。

  二级缓存跟一级缓存中不会同时存在数据，因为二级缓存中的数据是在sqlsession关闭之后才生效的。缓存查询的顺序是先查询二级缓存再查询一级缓存。
  在开启了完全局的二级缓存后，还可以在每一个单独的select语句进行特殊的缓存设置：

1. 在setting中设置，配置二级缓存开启，一级缓存默认一直开启

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

2. select标签的useCache属性：在每一个select的查询中可以设置当前查询是否要使用二级缓存，只对二级缓存有效。useCache默认为true,表示会将本条语句的结果进行二级缓存。设置为false时不使用二级缓存。
3. sql标签的flushCache属性：增删改操作默认值为true，sql执行之后会清空一级缓存和二级缓存，而查询操作默认是false。
4. sqlSession.clearCache()：用来清除一级缓存。

4.3 缓存的相关问题

4.3.1 一级缓存什么时候会失效

  一级缓存指的是sqlsession（回话）级别的缓存，关闭回话之后自动失效，默认情况下是开启的。会失效的情况：

• 1、不在同一个session中执行相同的sql语句；
• 2、当传递对象的时候，如果对象中的属性值不同，也不会走缓存；
• 3、在同一次查询过程中，如果数据库中数据发生了修改，那么缓存会失效。不同回话之间是不受影响的；
• 4、如果在一个会话过程中，手动清空了缓存（sqlSession.clearCache()），那么缓存也会失效。

4.3.2 二级缓存怎么开启

  二级缓存：表示的是全局缓存，必须要等到sqlsession关闭之后才会生效（这意味着二级缓存跟一级缓存中不会同时存在数据，因为二级缓存中的数据是在sqlsession关闭之后才生效的）。
  要想使某条Select查询支持二级缓存，需要进行如下设置：

1. 修改全局配置文件，在settings中添加配置。

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

2. 指定在哪个映射文件中使用缓存的配置。

   <cache>cache>

3. 对应的java实体类必须要实现序列化的接口。
4. 该select语句的参数useCache=true。

4.3.3 一集缓存和二级缓存的查询顺序

  如果MyBatis使用了二级缓存，并且Mapper和select语句也配置使用了二级缓存。那么在执行select查询的时候，MyBatis会先从二级缓存中取输入，其次才是一级缓存，即MyBatis查询数据的顺序是：先查二级缓存，再查一级缓存，再查数据库。
  即使在一个sqlSession中，也会先查二级缓存；一个namespace中的查询更是如此。

  一集缓存和二级缓存的具体查询顺序：

• 1、先判断二级缓存是否开启，如果没开启，再判断一级缓存是否开启，如果没开启，直接查数据库。
• 2、如果一级缓存关闭，即使二级缓存开启也没有数据，因为二级缓存的数据从一级缓存获取。
• 3、一般不会关闭一级缓存。
• 4、二级缓存默认不开启。
• 5、如果二级缓存关闭，直接判断一级缓存是否有数据，如果没有就查数据库。
• 6、如果二级缓存开启，先判断二级缓存有没有数据，如果有就直接返回；如果没有，就查询一级缓存，如果有就返回，没有就查询数据库。

4.3.4 Mybatis默认使用的二级缓存框架

  Ehcache，这是一个Java进程内的缓存框架。
  Ehcache的主要特性：

快速；
简单；
多种缓存策略；
缓存数据有内存和磁盘两级，无须担心容量问题；缓存数据会在虚拟机重启的过程中写入磁盘；
可以通过RMI、可插入API等方式进行分布式缓存；
具有缓存和缓存管理器的监听接口；
支持多级缓存管理器实例以及一个实例的多个缓存区域。

4.3.5 清空或者跳过二级缓存的3种方式

1. 对应的mapper中执行增删改查会清空二级缓存中数据。
2. select元素的flushCache属性置为true，会先清空二级缓存。存中的数据，然后再去db中查询数据，然后将数据再放到二级缓存中
3. select元素的useCache属性置为true，可以使这个查询跳过二级缓存，然后去查询数据。

你可能感兴趣的:(【Mybatis】,java,mybatis)

• Apache Doris中都用了哪些开发语言，编译过程中用到了哪些编译器，以及用到了哪些成熟的技术框架 fzip Dorisapache开发语言
  ApacheDoris作为一款高性能的实时分析型数据库，其技术栈涉及多语言开发、多种编译器支持以及多个成熟技术框架的集成。以下是综合多个来源的详细分析：一、开发语言Java•应用场景：主要用于开发Frontend（FE），负责元数据管理、查询解析、集群管理等模块。•关键模块：◦FE的元数据持久化通过BDBJE（BerkeleyDBJavaEdition）实现。◦MySQL协议兼容和HTTP服务分别
• 正则表达式 yuren_xia 前端技术后端技术正则表达式javajavascript
  正则表达式（RegularExpression）是一种用于描述字符模式的规则，主流语言对其都有良好的支持。文章目录一、元字符二、常见校验1、校验数字的表达式2、校验字符的表达式3、特殊需求表达式三、JavaScript中使用正则表达式四、在java中使用正则表达式一、元字符正则表达式中有许多元字符，它们具有特殊的含义：1、字符类相关点号（.）匹配除换行符之外的任意单个字符。例如，在表达式a.b中，
• Day08-综合练习 坚持学习每一天 Java基础java算法排序算法
  importjava.util.Random;publicclasstest3{/*定义方法实现随机产生一个5位的验证码验证码格式：长度为s前四位是大写字母或者小写字母最后一位是数字*///方法：//在一堆没有什么规律的数据中随机抽取//可以先把这些数据放到数组当中//再随机抽取一个索引publicstaticvoidmain(String[]args){char[]chs=newchar[52]
• java实体数据校验validation 秋风未动蝉已先觉 javajava
  javax.validationvalidation-api1.1.0.Finalorg.hibernatehibernate-validator5.4.1.Final//实体publicclassEntity{@NotNull(message="name字段值不能为空")privateStringname;@Max(value=20,message="address最大长度为20")privat
• React Native svygh123 问题解决过程编程jsreactnativereact.jsjavascript
  ReactNative是一个用于构建原生移动应用的框架，它使用JavaScript和React（一个用于构建用户界面的JavaScript库）来开发iOS和Android平台的应用程序。ReactNative由Facebook开发并维护，并且是开源的。特点跨平台开发：ReactNative允许开发者使用相同的代码库为多个平台（如iOS和Android）编写应用，极大地提高了开发效率。热重载：开发者
• Java函数式接口四部曲之Consumer sundawei2016 java前端开发语言
  Consumer是一个函数式接口，位于java.util.function包中。它表示一个接受单个输入参数并且不返回任何结果的操作。Consumer通常用于需要对输入参数执行某些操作但不产生返回值的场景。Consumer接口定义了一个抽象方法：accept(Tt)：接受一个类型为T的参数，并对其执行操作。Consumerdisplay=System.out::println;display.acc
• （十六）Java-File Kyrie_Li Java体系java开发语言
  File类是Java中最基础的文件处理类，它用于表示文件和目录（文件路径）。File类不能直接进行读写操作，它仅用于描述文件或目录的元数据，比如文件名、路径、大小等。一、File类的构造方法1.通过提供文件的路径字符串来创建一个File对象。路径可以是绝对路径也可以是相对路径。Filefile=newFile("D:\\test\\555.txt");2.通过父目录路径和子文件/目录路径来创建Fi
• （六）Java-BigDecimal Kyrie_Li Java体系java开发语言
  一、概述BigDecimal类用于高精度计算，特别适用于需要进行精确浮点数运算的场合，例如货币计算、金融应用或科学计算。二、优势由于double和float类型是浮点数类型，它们在表示一些十进制数时会出现精度丢失问题，而BigDecimal则可以避免这些问题，提供任意精度的数值表示。三、特点1.任意精度：BigDecimal的精度仅受限于计算机的内存，而不像float和double有固定的精度限制
• MyBatis Plus 在 Java 项目中的高效使用 随风九天 匠心数据库javaspringjavamybatisMyBatisPlus
  1.前言1.1MyBatisPlus简介MyBatisPlus是一个MyBatis的增强工具，旨在简化开发人员在数据库操作上的工作量。它提供了丰富的功能，如自动化的CRUD操作、条件构造器、分页查询等，极大地提高了开发效率。1.2为什么选择MyBatisPlus简化代码：自动生成基础的CRUD方法，减少重复代码。提高效率：内置多种插件和工具，提升开发速度。易于维护：代码结构清晰，便于后续维护和扩展
• java--数据校验Validator 郑*杰 java开发语言spring
  一、基于注解进行数据校验1、配置依赖java--常用依赖配置_郑*杰的博客-CSDN博客2、创建一个配置类packagecom.ruqi.aditainoal;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.ComponentScan;importorg.s
• Apipost一站式API工具评测：整合Postman+Swagger+JMeter三大功能，打造全流程开发解决方案
  作为一名Java开发者，始终追求开发过程的高效性。使用IntelliJIDEA编写代码只是开始。一般来说，代码完成后，我们会切换到Postman进行API调试。在确保API表现符合预期后，我们会使用Swagger为前端团队生成文档。最后，再使用JMeter进行性能和负载测试，以确保API工作流顺畅且自动化。Apipost=Postman+Swagger+JMeter然而，这种多工具的方法存在诸多挑
• VScode使用小技巧 前端CV攻城狮 vscodejavascript前端
  代码片段快捷键设置设置位置：文件—首选项—用户代码片段----搜javaScript,进入JavaScript.json,自定义快捷键（setting→ConfigureUserSnippets→JavaScripts.json）例：log快速输入console.log()"Printtoconsole":{"prefix":"log","body":["console.log('$1')"],"
• Java基于redis实现进度条 冰糖码奇朵 javaredis
  一.问题背景为了提升用户体验，开发中有很多场景需要用到进度条，比如导入、导出、大规模更新操作等。进度条在许多大型系统中使用频率较高，反复编写既麻烦又不利于维护，因此基于Redis抽成公共方法供不同功能调用。二.实现方案1.引入依赖如果系统已集成Redis，直接跳到第5步，进度条实现。org.springframework.bootspring-boot-starter-data-redis2.配置
• Mysql、MyBatis一键删除重复数据实现方案 冰糖码奇朵 数据库mysqlmybatissql
  一.问题背景项目中有全表数据一键剔除重复的需求场景，也就是一张数据表中除了主键、创建时间、修改时间等基本字段，其他业务字段均参与剔重校验，任何两行数据中，参与剔重校验的所有字段值完全相同则为重复，重复数据仅保留一行，其余删除。二.实现思路将所有参与剔重校验的字段进行分组，保留分组数据中id最大的那一条，其余删除。三.实现代码此处展示MyBatis代码，转换为sql同理。update`${table
• 数据监控工具Mixpanel的简易使用教程 alankuo 大数据
  Mixpanel的使用教程如下：注册与准备创建账号：访问Mixpanel官方网站，按照提示填写相关信息创建账号。登录后，在项目设置中可以获取项目密钥。了解基本概念：明确事件、用户属性等基本概念。事件是用户在应用中的操作，如点击按钮、完成注册等；用户属性是描述用户特征的信息，像年龄、城市、会员等级等。集成SDKWeb应用：在HTML文件中引入MixpanelJavaScriptSDK。在页面的标签内
• 如何实现集群中的session共享存储？思维导图 代码示例（java 架构) 用心去追梦 java架构开发语言
  集群中Session共享存储的实现在分布式系统或集群环境中，确保用户会话（Session）能够在所有节点之间共享是一个关键问题。为了实现这一点，可以采用多种策略和技术。以下是关于如何在Java架构中实现集群中的Session共享存储的主要方面：1.使用集中式存储服务Memcached：轻量级、高性能的内存缓存系统，适用于存储短期的session数据。Redis：功能更强大的键值存储数据库，不仅支持
• Java常用集合与映射的线程安全问题深度解析 yang789022 编程学习java安全python
  Java常用集合与映射的线程安全问题深度解析一、线程安全基础认知二、典型非线程安全集合问题分析1.ArrayList的并发陷阱2.HashMap的并发灾难3.HashSet的隐藏风险三、线程安全解决方案对比1.同步包装方案2.传统线程安全集合3.现代并发容器（java.util.concurrent包）3.1CopyOnWriteArrayList3.2ConcurrentHashMap3.3Co
• java 连接oracle 字符集_Java连接Oracle数据库，编码格式转换 东京客 java连接oracle字符集
  学习东西不忘记下笔记：dbhelper类，各种数据库都合适。publicclassDBHelper{//mysql数据库//publicstaticfinalStringurl="jdbc:mysql://127.0.0.1:3306/test";//publicstaticfinalStringname="com.mysql.jdbc.Driver";//publicstaticfinalStr
• java 读取resource文件夹文件_Java 获取Resource目录下的文件解决办法 鬼斧神工119 java读取resource文件夹文件
  该楼层疑似违规已被系统折叠隐藏此楼查看此楼Java获取Resource目录下的文件有两种方式：Java代码中的类，要获取Resource资源文件目录下文件绝对路径寻址注意这个/址的是根目录，用绝对路径，可能会出现的问题是，你的程序在windows上可以用，但是在linux不能用，原因在于，你这根目录在windows环境址你的src目录放到linux环境，就可能执行你linux的根目录了，会导致fi
• jvm堆外内存(直接内存) 不坠青云之志 JavaJvmdirectmemory
  堆外内存(直接内存)堆外内存，又被称为直接内存。这部分内存不是由jvm管理和回收的。需要我们手动的回收。堆内内存是属于jvm的，由jvm进行分配和管理，属于"用户态"，而推外内存是由操作系统管理的，属于"内核态"在jdk1.4中新加入了NIO类，他可以调用native函数库直接分配堆外内存，然后通过java堆中的DirectByteBuffer对象来指向这块内存，进行内存分配等工作。可以这样申请堆
• JVM内存深度解析：堆内与堆外内存的监控与诊断 猿泰山 Java核心技术jvm
  JVM内存深度解析：堆内与堆外内存的监控与诊断一、引言在Java应用中，JVM（JavaVirtualMachine）的内存管理至关重要。其中，堆内内存和堆外内存是两个核心概念。堆内内存主要存储Java对象实例，而堆外内存则与Java的NIO（NewI/O）库密切相关，主要用于存储不受Java堆大小限制的直接缓冲区。本文将深入探讨如何监控和诊断这两种类型的内存使用。二、堆内内存监控与诊断JVM参数
• 【从零开始学java】第1章，基础知识入门，小白零基础可看，笔记整理 莉莉鸟 java学习
  java基础11注释标志符关键字注释注释并不会被执行，是写给人类看的，书写注释是一个很好的习惯平时写代码一定要注意规范单行注释//多行注释/*注释*/文档注释/**注释*/2标识符关键字abstract：用于声明抽象类或抽象方法。assert：用于调试时进行断言。boolean：表示布尔类型（true或false）。break：跳出当前循环或switch语句。byte：表示字节数据类型。case：
• 查看 jvm 堆外内存大小 Horizon_Zy JVM相关java开发语言后端
  java.nio.Bits#reservedMemor该值为堆外内存占用大小。可以通过arthasattach后用ognl进行输出。[email protected]@reservedMemory.value
• 最新网络安全-跨站脚本攻击(XSS)的原理、攻击及防御_xsstrike原理 2401_84239830 程序员web安全xss安全
  XSS的类型反射型XSS/不持久型XSS存储型XSS/持久型XSS基于DOM的XSS常用Payload与工具XSS扫描工具Payloadsscript标签类结合js的html标签伪协议绕过危害防御简介跨站脚本攻击(全称CrossSiteScripting,为和CSS（层叠样式表）区分，简称为XSS)是指恶意攻击者在Web页面中插入恶意javascript代码（也可能包含html代码），当用户浏览网
• 如何使用Java和ElasticSearch实现全文搜索 微赚淘客系统开发者@聚娃科技 javaelasticsearch开发语言
  如何使用Java和ElasticSearch实现全文搜索大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们来探讨如何使用Java和ElasticSearch实现全文搜索。ElasticSearch是一个分布式搜索和分析引擎，能够处理大规模数据并提供实时搜索功能。在本文中，我们将介绍如何使用Java客户端与ElasticSearch进行交互，实现简单的全文搜索功能
• 基于大数据架构的就业岗位推荐系统的设计与实现【java或python】—计算机毕业设计源码+LW文档 qq_375279829 大数据架构python课程设计算法
  摘要随着互联网技术的迅猛发展和大数据时代的到来，就业市场日益复杂多变，求职者与招聘方之间的信息不对称问题愈发突出。为解决这一难题，本文设计并实现了一个基于大数据架构的就业岗位推荐系统。该系统通过收集、整合并分析大量求职者简历信息、企业招聘信息以及市场动态数据，运用先进的机器学习算法，为求职者提供个性化的岗位推荐服务，同时帮助企业快速定位到合适的候选人。本文将从系统设计的背景与意义、技术基础、需求分
• Java 基础核心总结 仅此而已丶 Java基础教程系列开发语言java
  目录前言介绍1、基本语法2、面向对象编程3、异常处理4、集合框架5、IO流6、多线程专栏地址前言Java是一种广泛使用的程序设计语言，具有跨平台、面向对象、安全性高、灵活性强等特点，广泛应用于企业级应用程序和移动应用程序等领域。在学习Java语言时，需要掌握一些基础核心知识，本文将为您总结Java基础核心知识点，以便于您的学习和参考。介绍Java基础核心知识点包括基本语法、面向对象编程、异常处理、
• java 金额转中文大写 两眼墨黑 javapython开发语言
  publicclassNumberChinese{publicstaticStringnumberChinese(Stringstr){BigDecimalnum=newBigDecimal(str);StringstrOutput;StringstrUnit="仟佰拾亿仟佰拾万仟佰拾元角分";StringstrNum="零壹贰叁肆伍陆柒捌玖";num=num.setScale(2,Roundin
• java基础知识点详解一：Java概述及三种技术架构 我是老实人辶 java程序员架构
  Java语言是一门随时代快速发展的计算机语言程序，其深刻展示了程序编写的精髓，加上其简明严谨的结构及简洁的语法编写为其将来的发展及维护提供了保障。由于提供了网络应用的支持和多媒体的存取，会推动Internet和企业网络的Web的应用java概述：1991年Sun公司的JamesGosling等人开始开发名称为Oak的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言
• Java 的三种技术架构 hhappy0123456789 jvmjava开发语言
  JAVAEE：JavaPlatformEnterpriseEdition，开发企业环境下的应用程序，主要针对web程序开发;JAVASE：JavaPlatformStandardEdition，完成桌面应用程序的开发，是其它两者的基础;JAVAME：JavaPlatformMicroEdition，开发电子消费产品和嵌入式设备，如手机中的程序;1，JDK：JavaDevelopmentKit，ja
• java类加载顺序 3213213333332132 java
  package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
• Hibernate与mybitas的比较 BlueSkator sqlHibernate框架ibatisorm
  第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
• php多维数组排序以及实际工作中的应用 dcj3sjt126com PHPusortuasort
  自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
• DOM改变字体大小 周华华 前端
  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
• c3p0的配置 g21121 c3p0
  c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 以在spring中配置dataSource为例： <!-- spring加载资源文件 --> <bean name="prope
• Java获取工程路径的几种方法 510888780 java
  第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
• 在类Unix系统下实现SSH免密码登录服务器 Harry642 免密ssh
  1.客户机     (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址     (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址     (3)执行cat
• Java新手入门的30个基本概念一 aijuans javajava 入门新手
  在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
• Memcached for windows 简单介绍 antlove javaWebwindowscachememcached
  1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
• 数据库对象的视图和索引 百合不是茶 索引oeacle数据库视图
    视图     视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图       为什么oracle需要视图;    &
• Mockito(一) --入门篇 bijian1013 持续集成mockito单元测试
          Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。  &nb
• 精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle数据库plsql
  /* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
• 【Log4j一】Log4j总体介绍 bit1129 log4j
  Log4j组件：Logger、Appender、Layout   Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 日志的输出目标 日志的输出格式 日志的输出级别(是否抑制日志的输出)  logger继承特性 A logger is said to be an ancestor of anothe
• Java IO笔记 白糖_ java
  public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
• Docker 监控 ronin47 docker监控
           目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 额外的，因为是docker的
• java-顺时针打印图形 bylijinnan java
  一个画图程序 要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
• 关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
  对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   # ${HOME} will be replaced by user home directory accordin
• [并行计算]论宇宙的可计算性 comsci 并行计算
        现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......       那么,这种概念让我们推论出一个结论     &nb
• 用OpenGL实现无限循环的coverflow dai_lm androidcoverflow
  网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
• JAVA数据计算的几个解决方案1 datamachine javaHibernate计算
  老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线-------------------------------------     数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J  &nbs
• 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
  怎么创建一个简单的(非 RBAC)用户授权系统 通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 在配置文件(一般为 protecte
• 未选之路 dcj3sjt126com 诗
  作者:罗伯特*费罗斯特   黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处.   但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹.   那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
• Java处理15位身份证变18位 蕃薯耀 18位身份证变15位15位身份证变18位身份证转换
    15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
• SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
  从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。   Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml   <!-- 激活自动代理功能 参看：
• Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScripthtmlandroid脚本
    在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序    要在webview中,调用addJavascriptInterface(OBJ,int
• 8个最佳Web开发资源推荐 lampcy 编程Web程序员
  Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 这里列出10个最佳Web开发资源，它们都是受
• 架构师之面试------jdk的hashMap实现 nannan408 HashMap
  1.前言。   如题。 2.详述。   (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
• html禁止清除input文本输入缓存 Rainbow702 html缓存input输入框change
  多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。 如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off";  <input type="text" autocomplete="off" n
• POJO和JavaBean的区别和联系 tjmljw POJOjava beans
  POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
• java中单例的五种写法 liuxiaoling java单例
  /** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、 双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

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

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