The underlying mybatis still uses native jdbc to operate on the database. It only encapsulates these processes through several processors such as SqlSessionFactory, SqlSession Executor, StatementHandler, ParameterHandler, ResultHandler and TypeHandler.
Actuator: Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
Parameter handler: ParameterHandler (getParameterObject, setParameters)
Structure Processor ResultSetHandler (handleResultSets, handleOutputParameters)
Sql query processor: StatementHandler (prepare, parameterize, batch, update, query)
The StatementHandler uses the ParameterHandler and the ResultHandler to perform parameter precompilation and result processing respectively. Both ParameterHandler and ResultHandler are mapped using TypeHandler. As shown below:
Mybatis work process
By reading the source code of mybatis to analyze the whole process of mybatis's execution operation, we can know what each step of Mybatis has done through debug debugging. I will first take a screenshot of each step of the debug and then analyze the process.
The first step: read the configuration file to form an InputStream
1 process of creating SqlSessionFacotry
From the debug debugging, the returned sqlSessionFactory is of type DefaultSesssionFactory, but the configuration has already been initialized. After viewing the source code, draw the following diagram to create a DefaultSessionFactory:
2 process of creating a SqlSession
From debug debugging, the sqlSession returned by SqlSessinoFactory.openSession() is of type DefaultSession. This SqlSession contains a Configuration object and an Executor object. After viewing the source code, draw the timing diagram for creating the DefaultSession as follows:
3 The process of creating a Mapper
As can be seen from the debug debugging, the mapper is a Mapper proxy object, and initializes the Configuration object, the Executor object. After viewing the source code, draw the timing diagram of the Mapper as follows:
4 Perform CRUD process
1 Take select as an example to view the source code of each step execution
1.mapper.selectEmployeeList() is actually MapperProxy to execute the invoke method. This method displays whether the method of Method is a method such as ToString of Object. If not, execute MapperMethod.
Public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
/ / Determine the Method method is not the object's toString and other methods
If(Object.class.equals(method.getDeclaringClass())) {
Try {
Return method.invoke(this, args);
} catch (Throwable var5) {
Throw ExceptionUtil.unwrapThrowable(var5);
}
} else {
/ / Judging private final Map,>
MapperMethod mapperMethod = this.cachedMapperMethod(method);
Return mapperMethod.execute(this.sqlSession, args);
}
}
/ / Query level 1 cache and set level 1 cache
Private MapperMethod cachedMapperMethod(Method method) {
MapperMethod mapperMethod = (MapperMethod)this.methodCache.get(method);
If(mapperMethod == null) {
mapperMethod = new MapperMethod(this.mapperInterface, method, this.sqlSession.getConfiguration());
this.methodCache.put(method, mapperMethod);
}
Return mapperMethod;
}
After the above call, enter the MapperMethod to execute
/ / Determine the sql command type
Public Object execute(SqlSession sqlSession, Object[] args) {
Object param;
Object result;
If(SqlCommandType.INSERT == this.command.getType()) {
Param = this.method.convertArgsToSqlCommandParam(args);
Result = this.rowCountResult(sqlSession.insert(this.command.getName(), param));
} else if(SqlCommandType.UPDATE == this.command.getType()) {
Param = this.method.convertArgsToSqlCommandParam(args);
Result = this.rowCountResult(sqlSession.update(this.command.getName(), param));
} else if(SqlCommandType.DELETE == this.command.getType()) {
Param = this.method.convertArgsToSqlCommandParam(args);
Result = this.rowCountResult(sqlSession.delete(this.command.getName(), param));
} else if(SqlCommandType.SELECT == this.command.getType()) {
/ / We test the select type, then determine the return type of this method
If(this.method.returnsVoid() && this.method.hasResultHandler()) {
this.executeWithResultHandler(sqlSession, args);
Result = null;
} else if(this.method.returnsMany()) {
//We are the query list, this method is executed
Result = this.executeForMany(sqlSession, args);
} else if(this.method.returnsMap()) {
Result = this.executeForMap(sqlSession, args);
} else {
Param = this.method.convertArgsToSqlCommandParam(args);
Result = sqlSession.selectOne(this.command.getName(), param);
}
} else {
If(SqlCommandType.FLUSH != this.command.getType()) {
Throw new BindingException("Unknown execution method for: " + this.command.getName());
}
Result = sqlSession.flushStatements();
}
If(result == null && this.method.getReturnType().isPrimitive() && !this.method.returnsVoid()) {
Throw new BindingException("Mapper method '" + this.command.getName() + " attempted to return null from a method with a primitive return type (" + this.method.getReturnType() + ").");
} else {
Return result;
}
}
Private 》>
/ / Param processing is automatically processed as param1, param2.
Object param = this.method.convertArgsToSqlCommandParam(args);
List result;
If(this.method.hasRowBounds()) {
RowBounds rowBounds = this.method.extractRowBounds(args);
/ / Call the object's DefaultSqlSession selectList method
Result = sqlSession.selectList(this.command.getName(), param, rowBounds);
} else {
Result = sqlSession.selectList(this.command.getName(), param);
}
Return ! this.method.getReturnType().isAssignableFrom(result.getClass())? (this.method.getReturnType().isArray()?this.convertToArray(result):this.convertToDeclaredCollection(sqlSession.getConfiguration(), result)):result;
}
/ / Processing parameter method
Public Object convertArgsToSqlCommandParam(Object[] args) {
Int paramCount = this.params.size();
If(args != null && paramCount != 0) {
If(!this.hasNamedParameters && paramCount == 1) {
Return args[((Integer)this.params.keySet().iterator().next()).intValue()];
} else {
Map,>
Int i = 0;
For(Iterator i$ = this.params.entrySet().iterator(); i$.hasNext(); ++i) {
Entry,>
Param.put(entry.getValue(), args[((Integer)entry.getKey()).intValue()]);
String genericParamName = "param" + String.valueOf(i + 1);
If(!param.containsKey(genericParamName)) {
Param.put(genericParamName, args[((Integer)entry.getKey()).intValue()]);
}
}
Return param;
}
} else {
Return null;
}
}
Call the selectList method of DefaultSqlSession
Public 》>
List var5;
Try {
/ / Get the MappedStatement object
MappedStatement ms = this.configuration.getMappedStatement(statement);
/ / Call the cachingExecutor executor method
Var5 = this.executor.query(ms, this.wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
} catch (Exception var9) {
Throw ExceptionFactory.wrapException("Error querying database. Cause: " + var9, var9);
} finally {
ErrorContext.instance().reset();
}
Return var5;
}
//CachingExector's query method
Public 》>
//
BoundSql boundSql = ms.getBoundSql(parameterObject);
CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);
/ / Call the next 2 code
Return this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
//2 code
Public 》>
Cache cache = ms.getCache();
If(cache != null) {
this.flushCacheIfRequired(ms);
If(ms.isUseCache() && resultHandler == null) {
this.ensureNoOutParams(ms, parameterObject, boundSql);
List >
If(list == null) {
/ / Here is the query method in the Executor call. If the cache is enabled, the CachingExecutor is called. If not, the BaseExecutor is called.
List = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
this.tcm.putObject(cache, key, list);
}
Return list;
}
}
Return this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
BaseExecutor's query method
Public 》>
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
If(this.closed) {
Throw new ExecutorException("Executor was closed.");
} else {
If(this.queryStack == 0 && ms.isFlushCacheRequired()) {
this.clearLocalCache();
}
List list;
Try {
++this.queryStack;
List = resultHandler == null? (List)this.localCache.getObject(key):null;
If(list != null) {
this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
/ / If there is no cache, query from the database
List = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
--this.queryStack;
}
If(this.queryStack == 0) {
Iterator i$ = this.deferredLoads.iterator();
While(i$.hasNext()) {
BaseExecutor.DeferredLoad deferredLoad = (BaseExecutor.DeferredLoad)i$.next();
deferredLoad.load();
}
this.deferredLoads.clear();
If(this.configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
this.clearLocalCache();
}
}
Return list;
}
}
/ / Query from the database
Private 》>
/ / put into the cache
this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);
List list;
Try {
//This is the method that calls the child Executor. The ExecutorType defaults to the SimpleExecutor used.
List = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
this.localCache.removeObject(key);
}
this.localCache.putObject(key, list);
If(ms.getStatementType() == StatementType.CALLABLE) {
this.localOutputParameterCache.putObject(key, parameter);
}
Return list;
}
SimpleExecutor's doQuery method
Public 》>
Statement stmt = null;
List var9;
Try {
Configuration configuration = ms.getConfiguration();
/ / Create a StateMentHandler processor
StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
/ / Call the method of the next 3
Stmt = this.prepareStatement(handler, ms.getStatementLog());
/ / Call the method of no4
Var9 = handler.query(stmt, resultHandler);
} finally {
this.closeStatement(stmt);
}
Return var9;
}
//Next 3 methods
Private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Connection connection = this.getConnection(statementLog);
Statement stmt = handler.prepare(connection);
//SatementHanlder implements this method using the PreparedStatementHandler, and the PreparedStatementHandler calls the method of the parent interface ParameterHandler.
Handler.parameterize(stmt);
Return stmt;
}
ParameterHandler parameter handler method
Public interface ParameterHandler {
Object getParameterObject();
/ / This method is implemented with DefaultParameterHandler
Void setParameters(PreparedStatement var1) throws SQLException;
}
DefaultParameterHandler default parameter handler method
Public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(this.mappedStatement.getParameterMap().getId());
List
If(parameterMappings != null) {
For(int i = 0; i < parameterMappings.size(); ++i) {
ParameterMapping parameterMapping = (ParameterMapping)parameterMappings.get(i);
If(parameterMapping.getMode() != ParameterMode.OUT) {
String propertyName = parameterMapping.getProperty();
Object value;
If(this.boundSql.hasAdditionalParameter(propertyName)) {
Value = this.boundSql.getAdditionalParameter(propertyName);
} else if(this.parameterObject == null) {
Value = null;
} else if(this.typeHandlerRegistry.hasTypeHandler(this.parameterObject.getClass())) {
Value = this.parameterObject;
} else {
MetaObject metaObject = this.configuration.newMetaObject(this.parameterObject);
Value = metaObject.getValue(propertyName);
}
/ / Here to call the TypeHandler type mapping processor to map
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
If(value == null && jdbcType == null) {
jdbcType = this.configuration.getJdbcTypeForNull();
}
Try {
/ / type processor set parameter mapping
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException var10) {
Throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + var10, var10);
} catch (SQLException var11) {
Throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + var11, var11);
}
}
}
}
}
No4 method
Public 》>
/ / Here call the native sql processor
PreparedStatement ps = (PreparedStatement)statement;
/ / Issue the native sql command
Ps.execute();
/ / Use ResultHandler result processor to encapsulate the result set
Return this.resultSetHandler.handleResultSets(ps);
}12345678
ResultHandler code
Public interface ResultSetHandler {
//The method called DefaultResultSetHandler is called here.
》>
Void handleOutputParameters(CallableStatement var1) throws SQLException;
}
1234567
DefaultResultSetHandler method
Public List 》>
ErrorContext.instance().activity("handling results").object(this.mappedStatement.getId());
List 》>
Int resultSetCount = 0;
ResultSetWrapper rsw = this.getFirstResultSet(stmt);
List >
Int resultMapCount = resultMaps.size();
this.validateResultMapsCount(rsw, resultMapCount);
While(rsw != null && resultMapCount 》 resultSetCount) {
ResultMap resultMap = (ResultMap)resultMaps.get(resultSetCount);
this.handleResultSet(rsw, resultMap, multipleResults, (ResultMapping)null);
Rsw = this.getNextResultSet(stmt);
this.cleanUpAfterHandlingResultSet();
++resultSetCount;
}
String[] resultSets = this.mappedStatement.getResulSets();
If(resultSets != null) {
While(rsw != null && resultSetCount < resultSets.length) {
ResultMapping parentMapping = (ResultMapping)this.nextResultMaps.get(resultSets[resultSetCount]);
If(parentMapping != null) {
String nestedResultMapId = parentMapping.getNestedResultMapId();
ResultMap resultMap = this.configuration.getResultMap(nestedResultMapId);
this.handleResultSet(rsw, resultMap, (List)null, parentMapping);
}
Rsw = this.getNextResultSet(stmt);
this.cleanUpAfterHandlingResultSet();
++resultSetCount;
}
}
Return this.collapseSingleResultList(multipleResults);
}
/ / Process the result set
Private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List >>
Try {
If(parentMapping != null) {
this.handleRowValues(rsw, resultMap, (ResultHandler)null, RowBounds.DEFAULT, parentMapping);
} else if(this.resultHandler == null) {
DefaultResultHandler defaultResultHandler = new DefaultResultHandler(this.objectFactory);
this.handleRowValues(rsw, resultMap, defaultResultHandler, this.rowBounds, (ResultMapping)null);
multipleResults.add(defaultResultHandler.getResultList());
} else {
this.handleRowValues(rsw, resultMap, this.resultHandler, this.rowBounds, (ResultMapping)null);
}
} finally {
this.closeResultSet(rsw.getResultSet());
}
}
Private void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?) resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
If(resultMap.hasNestedResultMaps()) {
this.ensureNoRowBounds();
this.checkResultHandler();
this.handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
} else {
this.handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
}
}
Private void handleRowValuesForNestedResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?) resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
DefaultResultContext ">
this.skipRows(rsw.getResultSet(), rowBounds);
Object rowValue = null;
While(this.shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
ResultMap discriminatedResultMap = this.resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, (String)null);
CacheKey rowKey = this.createRowKey(discriminatedResultMap, rsw, (String)null);
Object partialObject = this.nestedResultObjects.get(rowKey);
If(this.mappedStatement.isResultOrdered()) {
If(partialObject == null && rowValue != null) {
this.nestedResultObjects.clear();
this.storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
}
/ / Get the value of the row
rowValue = this.getRowValue(rsw, discriminatedResultMap, rowKey, (String)null, partialObject);
} else {
rowValue = this.getRowValue(rsw, discriminatedResultMap, rowKey, (String)null, partialObject);
If(partialObject == null) {
this.storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
}
}
}
If(rowValue != null && this.mappedStatement.isResultOrdered() && this.shouldProcessMoreRows(resultContext, rowBounds)) {
this.storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
}
}
String resultMapId = resultMap.getId();
Object resultObject = partialObject;
If(partialObject != null) {
MetaObject metaObject = this.configuration.newMetaObject(partialObject);
this.putAncestor(partialObject, resultMapId, columnPrefix);
this.applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, false);
this.ancestorObjects.remove(resultMapId);
} else {
ResultLoaderMap lazyLoader = new ResultLoaderMap();
resultObject = this.createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
If(resultObject != null && !this.typeHandlerRegistry.hasTypeHandler(resultMap.getType())) {
MetaObject metaObject = this.configuration.newMetaObject(resultObject);
Boolean foundValues ​​= ! resultMap.getConstructorResultMappings().isEmpty();
If(this.shouldApplyAutomaticMappings(resultMap, true)) {
foundValues ​​= this.applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
}
foundValues ​​= this.applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
this.putAncestor(resultObject, resultMapId, columnPrefix);
foundValues ​​= this.applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, true) || foundValues;
this.ancestorObjects.remove(resultMapId);
foundValues ​​= lazyLoader.size() 》 0 || foundValues;
resultObject = foundValues? resultObject:null;
}
If(combinedKey != CacheKey.NULL_CACHE_KEY) {
this.nestedResultObjects.put(combinedKey, resultObject);
}
}
Return resultObject;
}
Private boolean shouldApplyAutomaticMappings(ResultMap resultMap, boolean isNested) {
Return resultMap.getAutoMapping() ! = null? resultMap.getAutoMapping().booleanValue():(isNested?AutoMappingBehavior.FULL == this.configuration.getAutoMappingBehavior():AutoMappingBehavior.NONE != this.configuration.getAutoMappingBehavior());
}
Private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
List >
Boolean foundValues ​​= false;
If(autoMapping.size() 》 0) {
Iterator i$ = autoMapping.iterator();
While(true) {
//This uses an inner class to map parameters and result sets.
DefaultResultSetHandler.UnMappedColumAutoMapping mapping;
Object value;
Do {
If(!i$.hasNext()) {
Return foundValues;
}
Mapping = (DefaultResultSetHandler.UnMappedColumAutoMapping)i$.next();
Value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
} while(value == null && !this.configuration.isCallSettersOnNulls());
If(value != null || !mapping.primitive) {
metaObject.setValue(mapping.property, value);
}
foundValues ​​= true;
}
} else {
Return foundValues;
}
}
Private static class UnMappedColumAutoMapping {
Private final String column;
Private final String property;
Private final TypeHandler<? 》 typeHandler;
Private final boolean primitive;
//The typer maps the result here.
Public UnMappedColumAutoMapping(String column, String property, TypeHandler<?" typeHandler, boolean primitive) {
This.column = column;
This.property = property;
this.typeHandler = typeHandler;
This.primitive = primitive;
}
}
| About Plastic Spool |
For package of enameled copper and aluminium wire ,we also product plastic spool.White ,black, blue, and can be producted by requirements of clients.most of products' material are ABS.
PT 25/ PT 60/ PT 90/ PT 200 and DIN 250 and etc.
Product Process:
Material Ready-Production-demolding-deburring-Quality test-packing-shipping.It depends on the parts we made. Besides, we will maintain or replace the mould by ourselves.Hot processing molding, injection molding, extrusion is process of Plastic spool or bobbin.
Plastic Spool,Plastic Small Empty Wire Bobbin,High Quality Plastic Bobbin,Small Empty Wire Bobbin
HENAN HUAYANG ELECTRICAL TECHNOLOGY GROUP CO.,LTD , https://www.huaonwire.com