This is the 24th day of my participation in the August Text Challenge.More challenges in August
Sequence diagram
sequenceDiagram
participant A as Client
participant F as PurchaseMapper
participant B as MapperProxy
participant E as MapperMethod
participant C as SqlCommand
participant D as MethodSignature
participant G as ParamNameResolver
A -->> F : findByCondition
A ->> B : invoke
B ->> E : new
E ->> C : new
C -->> E : SqlCommand
E ->> D : new
D ->> G : new
G -->> D : ParamNameResolver
D -->> E : MethodSignature
E -->> B : MapperMethod
B ->> E : execute
E -->> A : ArrayList<Purchase>
The detailed steps
Client
QueryCondition condition = new QueryCondition();
condition.setId(1);
condition.setCategory(1);
// Call the mapper method to execute the query
List<Purchase> purchaseList = mapper.findByCondition(condition);
Copy the codePurchaseMapper#findByCondition
/** ** select */
List<Purchase> findByCondition(QueryCondition condition);
Copy the codeMapperProxy#invoke
/** * proxy method *@paramProxy Proxy object *@paramMethod Proxy method *@paramParameter * to the args proxy method@returnMethod execution result *@throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) { // A method inherited from Object
// Execute the old method directly
return method.invoke(this, args);
} else if (method.isDefault()) { // The default method
// Execute the default method
returninvokeDefaultMethod(proxy, method, args); }}catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
/** * 1. Use method as the key and cache MapperMethod * 2. Return value */ if method key exists
final MapperMethod mapperMethod = cachedMapperMethod(method);
// Call the execute method in MapperMethod, perform the operation, get the result and return it
return mapperMethod.execute(sqlSession, args);
}
private MapperMethod cachedMapperMethod(Method method) {
If there is a key, return the corresponding MapperMethod. If there is no MapperMethod, create a new MapperMethod
return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
}
Copy the codeMapperMethod
/** * MapperMethod constructor **@paramMapperInterface Mapping interface *@paramMethod Specifies the method * in the mapping interface@paramConfig Configuration information Configuration */
public MapperMethod(Class
mapperInterface, Method method, Configuration config) {
this.command = new SqlCommand(config, mapperInterface, method);
this.method = new MethodSignature(config, mapperInterface, method);
}
Copy the codeSqlCommand
- MappedStatement mapping, SqlCommandType fetch, see Mybatis source mappers tag parsing
public SqlCommand(Configuration configuration, Class
mapperInterface, Method method) {
// Method name
final String methodName = method.getName();
// The class in which the method resides may be mapperInterface or a subclass of mapperInterface
finalClass<? > declaringClass = method.getDeclaringClass();/ / get MappedStatement
MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
configuration);
if (ms == null) {
if(method.getAnnotation(Flush.class) ! =null) {
name = null;
type = SqlCommandType.FLUSH;
} else {
throw new BindingException("Invalid bound statement (not found): "
+ mapperInterface.getName() + "."+ methodName); }}else {
// Get the ID of MappedStatement
name = ms.getId();
/ / get SqlCommandType
type = ms.getSqlCommandType();
if (type == SqlCommandType.UNKNOWN) {
throw new BindingException("Unknown execution method for: "+ name); }}}/** * Find the MappedStatement object * corresponding to the specified method on the specified interface@paramMapperInterface Mapping interface *@paramMethodName specifies the operation methodName * in the mapping interface@paramDeclaringClass Specifies the class in which the action methods are located. Generally, it is the mapping interface itself, or it may be a subclass of the mapping interface *@paramConfiguration Indicates the configuration information *@returnMappedStatement object, which contains a complete database operation statement */
private MappedStatement resolveMappedStatement(Class
mapperInterface, String methodName, Class
declaringClass, Configuration configuration) {
// The number of the database operation statement is: interface name. The method name
String statementId = mapperInterface.getName() + "." + methodName;
// Configuration saves all parsed operation statements
if (configuration.hasStatement(statementId)) {
// The corresponding statement is found in configuration
return configuration.getMappedStatement(statementId);
} else if (mapperInterface.equals(declaringClass)) {
// Indicates that the recursive call has reached the end point, but still no matching result has been found
return null;
}
// Start with the method's definition class and work up the parent class. Stop when the interface class is found
for(Class<? > superInterface : mapperInterface.getInterfaces()) {if (declaringClass.isAssignableFrom(superInterface)) {
MappedStatement ms = resolveMappedStatement(superInterface, methodName,
declaringClass, configuration);
if(ms ! =null) {
returnms; }}}return null;
}
Copy the codeMethodSignature
public MethodSignature(Configuration configuration, Class
mapperInterface, Method method) {
// Get the return value type
Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
if (resolvedReturnType instanceofClass<? >) {this.returnType = (Class<? >) resolvedReturnType; }else if (resolvedReturnType instanceof ParameterizedType) {
this.returnType = (Class<? >) ((ParameterizedType) resolvedReturnType).getRawType(); }else {
this.returnType = method.getReturnType();
}
// Determine the return value type
this.returnsVoid = void.class.equals(this.returnType);
this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
this.returnsCursor = Cursor.class.equals(this.returnType);
this.returnsOptional = Optional.class.equals(this.returnType);
// Handle the case where the return value is MAP
this.mapKey = getMapKey(method);
this.returnsMap = this.mapKey ! =null;
// Resolve the position of the RowBounds object in the argument
this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
// Resolve the location of the ResultHandler object in the argument
this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
// Parameter name resolution
this.paramNameResolver = new ParamNameResolver(configuration, method);
}
Copy the codeParamNameResolver
- Parameter name of the processing method
/** * The argument name parser constructor **@paramConfig Configuration information *@paramMethod The method to be analyzed */
public ParamNameResolver(Configuration config, Method method) {
// Get a list of method parameter types
finalClass<? >[] paramTypes = method.getParameterTypes();Param (0,Param); Param (1,Param);
final Annotation[][] paramAnnotations = method.getParameterAnnotations();
final SortedMap<Integer, String> map = new TreeMap<>();
int paramCount = paramAnnotations.length;
// get names from @Param annotations
// Loop through each argument
for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
// Skip RowBounds and ResultHandler arguments
if (isSpecialParameter(paramTypes[paramIndex])) {
// skip special parameters
// Skip special arguments
continue;
}
// Parameter name
String name = null;
for (Annotation annotation : paramAnnotations[paramIndex]) {
// Find the annotation @param for the parameter
if (annotation instanceof Param) {
// If the annotation is Param
hasParamAnnotation = true;
// Take the value in Param as the parameter name
name = ((Param) annotation).value();
break; }}if (name == null) {
// If there is no @param annotation and useActualParamName=true is configured in the configuration file, the actual name of the parameter is used
In order to use this feature, however, you must compile using Java8 with the -parameters option, otherwise the actual parameter name looks like arg0
// @Param was not specified.
if (config.isUseActualParamName()) {
name = getActualParamName(method, paramIndex);
}
if (name == null) {
// use the parameter index as the name ("0", "1", ...)
// gcode issue #71
// If the parameter name cannot be obtained, use the index name of the parametername = String.valueOf(map.size()); }}// Parameter order: parameter name
map.put(paramIndex, name);
}
// Lock map and cannot be modified
names = Collections.unmodifiableSortedMap(map);
}
Copy the codeMapperMethod#execute
/** * The MapperMethod class binds a database operation statement to a Java method: its MethodSignature property holds the method details; * Its SqlCommand property holds the SQL statement corresponding to this method. Therefore, by calling the execute method of the MapperMethod object, specific database operations can be triggered, and the database operations are converted to method * *@paramSqlSession Instance of the sqlSession interface through which database operations can be performed *@paramThe argument * passed in when args executes the interface method@return* /
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) { // Perform different operations depending on the type of SQL statement
case INSERT: { // If insert statement
// Match the sequence of arguments to the arguments
Object param = method.convertArgsToSqlCommandParam(args);
// Perform the operation and return the result
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: { // If it is an update statement
// Match the sequence of arguments to the arguments
Object param = method.convertArgsToSqlCommandParam(args);
// Perform the operation and return the result
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: { // If delete statement
// Match the sequence of arguments to the arguments
Object param = method.convertArgsToSqlCommandParam(args);
// Perform the operation and return the result
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT: // If it is a query statement
if (method.returnsVoid() && method.hasResultHandler()) { // Return returns void with result handlers
// Use the result handler to execute the query
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) { // Multiple result queries
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) { // Map result query
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) { // cursor type result query
result = executeForCursor(sqlSession, args);
} else { // Single result query
// Match the sequence of arguments to the arguments
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
case FLUSH: // Clear the cache
result = sqlSession.flushStatements();
break;
default: // Unknown statement type, throw exception
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null&& method.getReturnType().isPrimitive() && ! method.returnsVoid()) {// The query result is null, but the return type is basic. Therefore, the return variable cannot receive the query result, and an exception is thrown.
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
// Returns the execution result
return result;
}
Copy the codeThe above is the Mapper method execution process in Mybatis.