El capítulo anterior ha terminado el método simple del mapeador general. Este capítulo hablará sobre cómo configurar el SQL combinado fácilmente.
1. Primero mire la clase de ejemplo, primero mire las propiedades dentro
public class Example implements IDynamicTableName {
protected String orderByClause;
protected boolean distinct;
protected boolean exists;
protected boolean notNull;
protected boolean forUpdate;
protected Set<String> selectColumns;
protected String countColumn;
protected List<Example.Criteria> oredCriteria;
protected Class<?> entityClass;
protected EntityTable table;
protected Map<String, EntityColumn> propertyMap;
protected String tableName;
protected Example.OrderBy ORDERBY;
public Example(Class<?> entityClass) {
this(entityClass, true);
}
public Example(Class<?> entityClass, boolean exists) {
this(entityClass, exists, false);
}
orderByClause: clasificación de una sola condición (la clasificación multicondicional también es posible, pero se requiere ortografía manual)
ORDERBY: clasificación multicondicional
distinta: deduplicación, debe usarse junto con selectColumns
existe: juzga si el atributo existe, si es verdadero, lanza una excepción si el atributo no existe, cuando es falso, si no existe, la condición del atributo no se usa
notNull: si la condición es nula, el atributo no es nulo cuando es verdadero y el valor del atributo es nulo cuando es falso
forUpdate: bloqueo a nivel de fila
selectColumns: nombre de la columna, usado con otros atributos
countColumn: resumen
tableName: nombre de la tabla (puede dejarlo en blanco, el valor predeterminado es el nombre de la tabla inyectado en la entidad @Table(name = "nombre de la tabla ")) entidadClass
: clase de entidad
oredCriteria: la colección de clases interna de Ejemplo, utilizada para unir las condiciones detrás de dónde, cada objeto es una condición y la matriz de objetos formada por él es un conjunto de condiciones
2. El papel de los atributos probablemente sea este, hablemos sobre cómo usarlos en detalle.
En comparación con los métodos CRUD integrados, la mayor ventaja de Ejemplo es que es más flexible y modificable, al igual que escribir SQL, y se puede unir dinámicamente según sus necesidades.
Hablemos de las condiciones de filtro detrás de dónde primero, que se trata de Criteria. Criteria proporciona muchos métodos de detección, como se muestra en la siguiente
figura
. Table(nombre = "usuario")
En pocas palabras, contiene algunos métodos, similares al
método andEqualTo, que equivale a agregar una condición y, y user_id = '123'. Aquí solo necesita pasar el nombre del campo de la entidad y el general Mapper lo convertirá automáticamente al nombre del campo de la base de datos.
Example example = new Example(User.class);
Example.Criteria criteria = example.createCriteria();
criteria.andEqualTo("userId","123");
El método andCondition es más flexible: puede reunir las condiciones de consulta e insertarlas. Puede unir todo el SQL que desee, como subconsultas, uniones externas, agrupaciones, etc., pero debe asegurarse de que no haya ningún problema. con la ortografía SQL; de lo contrario, se generará una excepción.
criteria.andCondition("user_id > 50 and user_id < 100");
andIn (subconsulta) El valor en este método es una matriz, unirá la matriz que pase de acuerdo con las condiciones de la subconsulta:
y user_id in ('1','2','3' )
andNotIn() resultado: y user_id no está en ('1','2','3')
List<String> ids= userList.stream().map(User::getUserId).collect(Collectors.toList());
criteria.andIn("userId",ids);
yMe gusta (consulta difusa), aquí también está el nombre del campo de la entidad entrante
criteria.andLike("name","%测试%");
Uno es equivalente a nombre no es nulo y el otro es equivalente a nombre es nulo
criteria.andIsNotNull("name");
criteria.andIsNull("name");
Al ver esto, todos deben estar muy confundidos. Se cumplen la mayoría de las condiciones. ¿Por qué no hay o? No hay ningún método directo en Criteria, por lo que será un poco problemático usar o. El siguiente código conecta dos Criterios con o
Example example = new Example(User.class);
Example.Criteria criteria = example.createCriteria();
criteria.andIsNull("name");
Example.Criteria criteria2 = example.createCriteria();
criteria.andIsNotNull("name");
example.or(criteria2);
Si le resulta problemático, existe otro método simple, que es el método andCondition, que puede deletrearlo directamente, que es mucho más simple.
criteria.andCondition("name = '测试' or name = '测试2'");
Los métodos comúnmente utilizados en Criteria probablemente estén terminados.
3. Hablemos del método en el ejemplo:
Los dos métodos orderByClause y orderBy:
Example example = new Example(User.class);
example.setOrderByClause("user_id asc");
orderByClause se puede ordenar por atributo único o por atributos múltiples, pero debe unirlo usted mismo y los atributos que contiene deben ser coherentes con los nombres de atributos en la tabla, y usted mismo puede convertir camelcase
example.setOrderByClause("user_id asc,phone desc");
Si te sientes problemático, puedes usar orderBy:
example.orderBy("userId");
Es suficiente escribir directamente el nombre del atributo en la entidad aquí, y hay 3 métodos detrás, asc, desc, orderPor
clasificación multicondicional
example.orderBy("userId").asc();
example.orderBy("phone").desc();
El método getSelectColumns puede obtener todos los nombres de atributos de la entidad entrante y usarlos según sea necesario.
Set<String> columns = example.getSelectColumns();
deduplicación distinta, puede ser única o múltiple, debe usarse junto con selectProperties (selectProperties: campos que deben deduplicarse, pueden ser uno o varios)
example.setDistinct(true);
example.selectProperties("name");
example.selectProperties(new String[]{
"name","phone"});
contar un atributo
example.setCountProperty("name");
Habilitar bloqueos a nivel de fila
example.setForUpdate(true);
borrar todas las condiciones
example.clear();
obtener el nombre de la tabla
example.getDynamicTableName();
Hablemos aquí del método de modificación, hay dos métodos de modificación:
El primero se modifica por ID:
Según la modificación de ID, debe tener la anotación @Id en su entidad, similar al siguiente código
User user = new User();
user.setUserId("111");
user.setUsername("李四");
userMapper.updateByPrimaryKeySelective(user);
equivalente a sql
update user set username = '李四' where user_id = '111'
La segunda se modifica según las condiciones:
Este es el caso en el que modifica en función de otras condiciones además del ID:
// set的值
User user = new User();
user.setPhone("1111111");
// where后的条件
Example example = new Example(User.class);
Example.Criteria criteria = example.createCriteria();
criteria.andEqualTo("username", "李四");
userMapper.updateByExampleSelective(user, example);
equivalente a sql
update user set phone= '1111111' where username= '李四'
La mayoría de los métodos básicos en el ejemplo están terminados. Cada uno es un método pequeño, que se puede combinar entre sí según las necesidades. La mayoría de SQL simple debería poder combinarse. Es posible que no esté acostumbrado al principio. Puedes usarlo varias veces. Será útil. Si crees que este conjunto también es problemático, puedes empaquetar tu propio CRUD basado en el Mapper general.
Simplemente encapsulé un conjunto de CRUD, solo encuentro una manera de verlo:
/**
* description 模糊查询
*
* @param t
* @version 1.0
* @date 2020/6/15 14:24
*/
@Override
public List<T> like(T t) throws IllegalAccessException {
StringBuilder sql = new StringBuilder();
sql.append("1!=1 ");
Field[] fields = t.getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
if (field.get(t) != null) {
String name = NameUtil.underscoreName(field.getName());
sql.append("or " + name + " like '%" + field.get(t) + "%'");
}
}
Example example = new Example(t.getClass());
example.createCriteria().andCondition(sql.toString());
return this.mapper.selectByExample(example);
}
Los métodos comúnmente utilizados, como la consulta difusa, son realmente cómodos de usar cuando están encapsulados.
Eso es todo, agregaré más si es necesario.