Este artículo presenta principalmente el problema de optimización de consultas en mybatis plus. Este artículo lo presenta en detalle, que tiene un cierto valor de referencia para su estudio o trabajo. Los amigos que lo necesiten pueden consultar
Escritura de consultas mybatis plus tradicional
Para una consulta de tabla única mybatis regular, podemos usar la consulta LambdaQueryWrapper o la consulta QueryWrapper.
LambdaQueryWrapper tiene las ventajas de evitar errores de escritura y estandarizar el código, pero la desventaja es que no se puede utilizar en consultas complejas de varias tablas.
En comparación, usar QueryWrapper para escribir consultas es más flexible y puede adaptarse a escenarios de consultas más complejos.
Primero veamos un ejemplo de consulta QueryWrapper
public List<UserMo> list (UserForm userForm) {
QueryWrapper<UserMo> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringTool.isNotEmpty(userForm.getUserName(), "name", userForm.getUserName());
queryWrapper.eq(StringTool.isNotEmpty(userForm.getMobile(), "mobile", userForm.getMobile());
// 其它的查询条件...
return userMapper.selectList(queryWrapper);
}
Para la instrucción de consulta anterior, el valor de paso de front-end se puede procesar bien.Cuando hay un valor de paso de front-end en el formulario de usuario, se agregará una condición where a la instrucción SQL .
Pero hacer esto tendrá un punto relativamente complicado, es decir, cuando hay demasiados campos en el UserForm, es posible que tengamos que escribir más de una docena de líneas de este tipo de declaración de juicio repetida.
Resuelva el problema de demasiadas condiciones generales de consulta a través de anotaciones personalizadas
Al observar los ejemplos de mybatis plus de métodos de consulta relacionados con queryWrapper, podemos encontrar un método general y podemos 
ver que todos estos métodos pasan los mismos tres parámetros.
Creo que para estas simples condiciones generales de consulta, puede haber un método general para completar.
Primero configuro una clase de enumeración, enumero estas condiciones de consulta y, en el método de construcción, el método correspondiente se recupera por reflexión
public enum QueryConditionEnum {
EQ("eq"),
NE("ne"),
GT("gt"),
GE("ge"),
LT("lt"),
LE("le"),
LIKE("like"),
NOT_LIKE("notLike"),
LIKE_LEFT("likeLeft"),
LIKE_RIGHT("likeRight");
private String name;
private Method method;
QueryConditionEnum (String name) {
this.name = name;
try {
Method method = AbstractWrapper.class.getDeclaredMethod(name, boolean.class, Object.class, Object.class);
this.method = method;
} catch (NoSuchMethodException e) {
}
}
}
Además, quiero especificar qué método debe completarse mediante anotaciones, el valor predeterminado es EQ, y escribí una anotación QueryCondition para esto.
@Retention(RetentionPolicy.RUNTIME)
@Target({
ElementType.FIELD})
public @interface QueryCondition {
/**
* 默认查询方式
*
* @return
*/
QueryConditionEnum value() default QueryConditionEnum.EQ;
/**
* 是否填充默认查询条件
*
* @return
*/
boolean isCondition() default true;
}
然后就可以这样构造UserForm
public class UserForm {
private String name;
@QueryCondition(QueryConditionEnum.LIKE)
private String mobile;
}
Necesitamos una clase de herramienta para llenar las condiciones de consulta. Aquí hemos agregado un nuevo parámetro objeto mo. Esto se debe a que nuestro objeto principal de consulta es el objeto Mo, y el objeto Mo almacena el nombre de la tabla relevante y la información del nombre del campo de la tabla.
@TableName("user")
public class UserMo {
@TableField("name")
private String name;
@TableField("mobile")
private String mobile;
}
public class QueryTool {
/**
* 填充默认查询
* @param baseClazz mo对象class
* @param queryWrapper 查询条件
* @param form 请求对象
*/
public static void paddingDefaultConditionQuery(Class baseClazz, QueryWrapper queryWrapper, Object form) {
try {
for (Field declaredField : form.getClass().getDeclaredFields()) {
declaredField.setAccessible(true);
Object fieldValue = declaredField.get(form);
QueryCondition queryCondition = declaredField.getAnnotation(QueryCondition.class);
if (fieldValue == null) {
continue;
}
if (queryCondition == null) {
queryWrapper.eq(StringTool.isNotEmpty(fieldValue.toString()),
QueryTool.getTableName(baseClazz) + "." + QueryTool.getTableFieldName(baseClazz, declaredField),
fieldValue.toString());
continue;
}
if (queryCondition.isCondition() == false) {
continue;
}
Method method = queryCondition.value().getMethod();
method.invoke(queryWrapper, StringTool.isNotEmpty(fieldValue.toString()),
QueryTool.getTableName(baseClazz) + "." + QueryTool.getTableFieldName(baseClazz, declaredField),
fieldValue.toString());
}
} catch (Exception e) {
throw new RuntimeException("填充默认的SQL条件出错", e);
}
}
/**
* 填充默认排序
*
* @param queryWrapper
* @param pageForm
*/
public static void paddingDefaultOrderQuery(QueryWrapper queryWrapper, PageForm pageForm) {
queryWrapper.orderBy(pageForm != null && StringTool.isNotEmpty(pageForm.getColumnName()),
pageForm.getIsAsc() == null ? false : pageForm.getIsAsc(), pageForm.getColumnName());
}
/**
* 获取表名称
*
* @return
*/
public static String getTableName(Class baseClazz) {
TableName tableName = (TableName) baseClazz.getDeclaredAnnotation(TableName.class);
if (tableName != null && StringTool.isNotEmpty(tableName.value())) {
return tableName.value();
}
return StringTool.toUnderline(baseClazz.getClass().getName());
}
/**
* 获取字段名
*
* @param field
* @return
*/
public static String getTableFieldName(Class baseClazz, Field field) {
Field baseField = null;
try {
baseField = baseClazz.getDeclaredField(field.getName());
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
if (baseField == null) {
baseField = field;
}
TableId tableId = baseField.getAnnotation(TableId.class);
if (tableId != null && StringTool.isNotEmpty(tableId.value())) {
return tableId.value();
}
TableField tableField = baseField.getAnnotation(TableField.class);
if (tableField != null && StringTool.isNotEmpty(tableField.value())) {
return tableField.value();
}
return StringTool.toUnderline(baseField.getName());
}
}
Finalmente, podemos usar la clase de herramienta para llenar.
public List<UserMo> list (UserForm userForm) {
QueryWrapper<UserMo> queryWrapper = new QueryWrapper<>();
QueryTool.paddingDefaultConditionQuery(UserMo.class, queryWrapper, userForm);
return userMapper.selectList(queryWrapper);
}
Puede ver que esto reduce en gran medida los campos que deben llenarse. Si hay campos especiales, también puede usar anotaciones para omitir los campos especiales y completarlos usted mismo.
Hasta ahora, se presenta este artículo sobre la optimización de consultas en mybatis plus. Para obtener más contenido relacionado con la optimización de consultas de mybatis plus, preste atención al editor o continúe examinando los artículos relacionados a continuación. ¡Espero que ayude mucho al editor en el futuro!