Mybatis principle analysis learning record, mybatis dynamic sql learning record

Posted by ScratchyAnt on Sat, 11 May 2019 16:37:13 +0200

The following personal learning notes are for reference only. You are welcome to make corrections.

MyBatis is a persistent layer framework that supports customized SQL, stored procedures, and advanced mapping. It mainly accomplishes two things:

Encapsulating JDBC operations
Using Reflection to Interchange Java Classes and SQL Statements

The main design goal of MyBatis is to make it easier for us to manage input and output data when executing SQL statements, so it is the core competitiveness of MyBatis to write SQL conveniently and obtain the execution results of SQL conveniently.

Configuration of MyBatis

spring integrates mybatis (druid data source)

  1 (1)Integrating ideas: MyBatis The core components involved in the framework are configured to Spring Container
  2 (2)Steps:
  3 -->1.Add to pom Depend on mybatis-spring，spring-tx，spring-jdbc
  4 -->2.Create entity classes( entity)
  5 -->3.Creating Data Access Interface( dao Layer interface)
  6 -->4.To configure SQL Mapping file( resource Lower mapper.xml Document)
  7 -->5.To configure mybatis Configuration file( resource Lower spring Lower mybatis-config.xml)
  8 -->6.Wherever annotations are used, services defined by scanning annotations need to be configured Bean:  <context:component-scan base-package="com.one.ssm.dao"/>
  9 and<context:annotation-config/>(Used to activate those already in place spring Registered in containers bean)
 10 
 11 
 12 <?xml version="1.0" encoding="UTF-8" ?>
 13 <!DOCTYPE configuration
 14         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 15         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 16 <configuration>
 17 <!--Configure global properties-->
 18 <settings>
 19     <!--Use jdbc Of getGeneratedKeys Getting database self-increasing primary key values-->
 20     <setting name="useGeneratedKeys" value="true"/>
 21     <!--Replace column names with column aliases by default true， eg: select name as title from table-->
 22     <setting name="useColumnLabel" value="true"/>
 23     <!--Open Hump Naming Conversion table(create_time)-->entity(createTime)
 24     <setting name="mapUnderscoreToCamelCase" value="true"/>
 25 </settings>
 26 </configuration>
 27 
 28 (3)Achieving Integration( spring-dao.xml Operation)
 29 -->1.To configure dataSource data source
 30 jdbc.properties Content:
 31     jdbc.driver=com.mysql.jdbc.Driver
 32     jdbc.url=jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=UTF-8
 33     jdbc.username=root
 34     jdbc.password=123456
 35 
 36 <!--properties File Configuration Data Source-->
 37 <context:property-placeholder location="classpath:spring/jdbc.properties"/>
 38     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
 39         <!--Configure connection pool properties-->
 40         <property name="driverClassName" value="${jdbc.driver}"/>
 41         <property name="url" value="${jdbc.url}"/>
 42         <property name="username" value="${jdbc.username}"/>
 43         <property name="password" value="${jdbc.password}"/>
 44     </bean>
 45 
 46 -->2.To configure SqlSessionFactoryBean
 47    <!--SqlSession Contains all execution databases SQL Method of statement. Able to pass directly SqlSession Instance Execution Mapping SQL-->
 48     <!--Lack sqlSessionFactory: No bean named 'sqlSessionFactory' available    Complete reading configuration files-->
 49     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 50         <!--Injecting database connection pool--><!--Otherwise, it will happen. java.lang.IllegalArgumentException: Property 'dataSource' is required-->
 51         <property name="dataSource" ref="dataSource"/>
 52 
 53         <!--scanning entity Package, using aliases, set this later Mapper In the configuration file, the parameterType
 54         No need to write the full path name for the value of ____________-->
 55         <property name="typeAliasesPackage" value="com.one.ssm.entity"/>
 56 
 57         <!--scanning mapper Needed xml file-->
 58         <property name="mapperLocations" value="classpath:mapper/*.xml"/>
 59     </bean>
 60 
 61     <!-- Configuration scan Dao Interface package,Dynamic implementation Dao Interface,Injection into spring Container -->
 62     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 63         <!-- injection sqlSessionFactory -->
 64         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
 65         <!-- Give the need to scan Dao Interface package -->
 66         <property name="basePackage" value="com.one.ssm.dao"/>
 67     </bean>
 68 
 69 (4)Two ways of injecting mappers: using mapper injection, you can write without writing dao Implementation of Layer Interface
 70 -->1.To configure MapperFactoryBean Generate mappers and inject them into business components
 71  <bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
 72         <!--mapperInterface Property specifies the mapper, which can only be an interface type-->
 73         <property name="mapperInterface" value="com.one.ssm.dao.UserDao"/>
 74         <!-- injection sqlSessionFactory -->
 75         <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
 76     </bean>
 77 
 78 -->2.To configure MapperScannerConfiger Generate mappers and inject them into business components: Priority MapperScannerConfiger，Implementation of batch generation mapper
 79 <!--mybatis-spring Provided MapperScannerConfigurer，
 80     Interfaces in specified packages can be scanned and registered directly as MapperFactoryBean，For simplification MapperFactoryBean Too many mappers lead to additional configuration items-->
 81  <!--mybatis-spring Provided MapperScannerConfigurer，Interfaces in specified packages can be scanned and registered directly as MapperFactoryBean-->
 82     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 83         <!-- injection sqlSessionFactory -->
 84         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
 85         <!-- Give the need to scan Dao Interface package -->
 86         <property name="basePackage" value="com.one.ssm.dao"/>
 87     </bean>
 88 
 89 (5)Adding declarative transactions( spring-service.xml Operation)
 90 -->Use xml Configuration Method Configuration Declarative Transactions
 91  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
 92     <property name="url" value="${jdbc.url}" />
 93     <property name="username" value="${jdbc.username}" />
 94     <property name="password" value="${jdbc.password}" />
 95     <property name="driverClassName" value="${jdbc.driver}" />
 96     </bean>
 97     <!--Configuration transaction manager (transaction is a unified commit or rollback operation for a series of database operations)-->
 98 <bean id="transactionManager"
 99           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
100         <property name="dataSource" ref="dataSource"/>
101     </bean>
102 -->Adding declarative transactions with annotations
103  <!--How to add declarative transaction annotations-->
104     <tx:annotation-driven transaction-manager="transactionManager"/>

spring integrates mybatis

springboot integrates mybatis by adding configuration information to the yml file.

Major Members of MyBatis

Configuration: All configuration information for MyBatis is stored in the Configuration object, where most of the configuration in the configuration file is stored.

SqlSession: As the main top-level API of MyBatis, it represents the session when interacting with the database and completes the necessary database addition, deletion and modification functions.

Executor: MyBatis executor is the core of MyBatis scheduling, responsible for the generation of SQL statements and the maintenance of query cache.

Statement Handler: Encapsulated JDBC Statement operation, responsible for JDBC statement operation, such as setting parameters.

ParameterHandler: Responsible for converting parameters passed by users into data types corresponding to JDBC Statement.

ResultSetHandler: Responsible for converting the ResultSet result set object returned by JDBC into a collection of List type.

TypeHandler: Responsible for mapping and transformation between java data type and jdbc data type (also known as data table column type), for setting specific parameters to the state object, and for fetching specific columns from the result set returned by the state

MappedStatement: MappedStatement maintains the encapsulation of a < select | update | delete | Insert > node.

SqlSource: Responsible for dynamically generating SQL statements according to the parameterObject passed by users, encapsulating information into the BoundSql object and returning it.

BoundSql: Represents dynamically generated SQL statements and corresponding parameter information.

MyBatis hierarchy:

1. sqlSession - > excutor - > statementHander - > parameterHander - > typeHander - > (entering jdbc) statement (divided into: preparedStatement, simpleStatement, calleStatement) > (taking out the results) resultsetSet - > type hander - > resulthandler - > statementHandler - > sqlHandler - > excise

Initialization of MyBatis (the process of parsing configuration files and initializing Configuration)

String resource = "mybatis.xml";
// Load the mybatis configuration file (it also loads the associated mapping file)
InputStream inputStream = null;
try {
    inputStream = Resources.getResourceAsStream(resource);
} catch (IOException e) {
    e.printStackTrace();
}

// Construction of the factory of sqlSession
sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

The SqlSessionFactory builder object is created first, and then it is used to create the SqlSessionFactory. The constructor pattern is used here. The simplest understanding of the constructor pattern is not to create new objects manually, but to create objects by other classes.

// SqlSessionFactoryBuilder class
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
//The XMLConfigBuilder object parses the XML configuration file, which is actually the parsing operation of the configuration node.
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        return build(parser.parse()); // It's time to start parsing.
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

 1 public Configuration parse() {
 2     if (parsed) {
 3         throw new BuilderException("Each XMLConfigBuilder can only be used once.");
 4     }
 5     parsed = true;
 6     parseConfiguration(parser.evalNode("/configuration"));
 7     return configuration;
 8 }
 9 
10 private void parseConfiguration(XNode root) {
11     try {
12         //issue #117 read properties first
13         propertiesElement(root.evalNode("properties"));
14         Properties settings = settingsAsProperties(root.evalNode("settings"));
15         loadCustomVfs(settings);
16         typeAliasesElement(root.evalNode("typeAliases"));
17         pluginElement(root.evalNode("plugins"));
18         objectFactoryElement(root.evalNode("objectFactory"));
19         objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
20         reflectorFactoryElement(root.evalNode("reflectorFactory"));
21         settingsElement(settings);
22         // read it after objectFactory and objectWrapperFactory issue #631
23 
24         /* Processing Environment Node Data */
25         environmentsElement(root.evalNode("environments"));
26         databaseIdProviderElement(root.evalNode("databaseIdProvider"));
27         typeHandlerElement(root.evalNode("typeHandlers"));
28         mapperElement(root.evalNode("mappers"));
29     } catch (Exception e) {
30         throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
31     }
32 }

XMLConfigBuilder class

Under the configuration node, node configurations such as properties/settings/.../mappers are resolved in turn. When parsing environment nodes, transaction managers are created according to the configuration of transactionManager, and DataSource objects are created according to the configuration of dataSource, which contains information about database login. When parsing a mappers node, all mapper files under that node are read and parsed, and the parsed results are stored in the configuration object.

Programmer Think

Mybatis principle analysis learning record, mybatis dynamic sql learning record

Configuration of MyBatis

Major Members of MyBatis

MyBatis hierarchy:

Initialization of MyBatis (the process of parsing configuration files and initializing Configuration)

MyBatis's SQL Query Process

MyBatis Cache

MyBatis Dynamic sql

Hot Topics