Tabla de contenido
Prefacio
Antes de explicar el caso, permítanme presentarles la biblioteca Faker:
Faker es una biblioteca de Python para generar datos falsos pero que parecen reales. Puede generar varios tipos de datos, incluidos nombres, direcciones, números de teléfono, direcciones de correo electrónico, nombres de empresas, puestos de trabajo, fechas y horas.
El propósito de Faker es ayudar a los desarrolladores a generar rápidamente grandes cantidades de datos falsos para pruebas, creación de prototipos y análisis de datos. También se puede utilizar para crear datos simulados más realistas para usar en juegos, redes sociales y sitios web de comercio electrónico.
Faker es una biblioteca muy popular y se ha descargado millones de veces. Lo utilizan muchas empresas conocidas, incluidas Google, Amazon, Microsoft y Netflix.
Las principales ventajas de Faker incluyen:
- Fácil de usar. Faker tiene una API sencilla que permite a los desarrolladores generar fácilmente datos falsos.
- personalizable. Faker permite a los desarrolladores personalizar los datos generados para satisfacer sus necesidades específicas.
- Soporta múltiples idiomas. Faker admite varios idiomas, incluidos inglés, español, francés, alemán y chino.
- Integre con otras bibliotecas. Faker se puede integrar con otras bibliotecas de Python como SQLAlchemy y Django.
Faker es una biblioteca muy útil que ayuda a los desarrolladores a generar rápidamente grandes cantidades de datos falsos pero que parecen reales. Es ideal para realizar pruebas, crear prototipos, analizar datos y crear datos simulados más realistas.
usar:
1. Agregue la dependencia de Faker al proyecto:
<dependency>
<groupId>com.github.javafaker</groupId>
<artifactId>javafaker</artifactId>
<version>1.0.2</version>
</dependency>
2. En el código, puedes crear una instancia de Faker de las siguientes maneras:
Faker faker = new Faker();
3. Luego puedes usar Faker para generar varios tipos de datos. Por ejemplo, puedes utilizar el siguiente código para generar un nombre falso:
String name = faker.name().fullName();
4. Puedes usar Faker para generar una dirección falsa:
Address address = faker.address();
String streetAddress = address.streetAddress();
String city = address.city();
String state = address.state();
String zipCode = address.zipCode();
Faker también admite la generación de otros tipos de datos, incluidos números de teléfono, direcciones de correo electrónico, nombres de empresas, puestos de trabajo, fechas y horas. Puede encontrar más información sobre cómo utilizar Faker en la documentación oficial de Faker.
Interfaz CRUD de servicio
Descripción de la interfaz CRUD del servicio:
General Service CRUD encapsula la interfaz IService y encapsula aún más CRUD utilizando
get 查询单行remove 删除list 查询集合page 分页nombres de prefijo para distinguirMappercapas y evitar confusiones.Genérico
Tpara cualquier objeto de entidad.
1.1 Guardar
// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);Descripción de parámetros
| tipo | nombre del parámetro | describir |
|---|---|---|
| t | entidad | objeto de entidad |
| Colección<T> | lista de entidades | Colección de objetos de entidad |
| En t | tamaño del lote | Insertar cantidad de lote |
1.2 Guardar o actualizar
// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);Descripción de parámetros
| tipo | nombre del parámetro | describir |
|---|---|---|
| t | entidad | objeto de entidad |
| Envoltorio<T> | actualizarWrapper | Clase de operación de encapsulación de objetos de entidad UpdateWrapper |
| Colección<T> | lista de entidades | Colección de objetos de entidad |
| En t | tamaño del lote | Insertar cantidad de lote |
1.3 Eliminar
// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);Descripción de parámetros
| tipo | nombre del parámetro | describir |
|---|---|---|
| Envoltorio<T> | queryWrapper | Clase contenedora de entidad QueryWrapper |
| Serializable | identificación | ID de clave principal |
| Mapa<Cadena, Objeto> | columnaMapa | objeto de mapa de campo de tabla |
| Colección<? extiende Serializable> | lista de identificación | Lista de ID de clave principal |
1.4 Actualización
// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);Descripción de parámetros
| tipo | nombre del parámetro | describir |
|---|---|---|
| Envoltorio<T> | actualizarWrapper | Clase de operación de encapsulación de objetos de entidad UpdateWrapper |
| t | entidad | objeto de entidad |
| Colección<T> | lista de entidades | Colección de objetos de entidad |
| En t | tamaño del lote | Actualizar cantidad de lote |
1.5 Obtener
// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);Descripción de parámetros
| tipo | nombre del parámetro | describir |
|---|---|---|
| Serializable | identificación | ID de clave principal |
| Envoltorio<T> | queryWrapper | Clase de operación de encapsulación de objetos de entidad QueryWrapper |
| booleano | tirarEx | ¿Se lanzará una excepción si hay varios resultados? |
| t | entidad | objeto de entidad |
| Función<? superobjeto, V> | mapeador | función de conversión |
1.6 Lista
// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);Descripción de parámetros
| tipo | nombre del parámetro | describir |
|---|---|---|
| Envoltorio<T> | queryWrapper | Clase de operación de encapsulación de objetos de entidad QueryWrapper |
| Colección<? extiende Serializable> | lista de identificación | Lista de ID de clave principal |
| Mapa<Cadena, Objeto> | columnaMapa | objeto de mapa de campo de tabla |
| Función<? superobjeto, V> | mapeador | función de conversión |
Existe una interfaz Mapper CRUD que no se ha escrito, de hecho, el uso es casi el mismo. Además de los diferentes nombres de métodos, la interfaz de servicio tiene anotaciones de transacciones y lanzamiento de excepciones. La interfaz de servicio se utiliza generalmente para operar la base de datos.
Para obtener más operaciones de la interfaz de servicio, consulte el sitio web oficial .
Caso integral
package com.ycxw.mybatis_test;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.javafaker.Faker;
import com.ycxw.mybatis_test.entity.Book;
import com.ycxw.mybatis_test.mapper.BookMapper;
import com.ycxw.mybatis_test.service.IBookService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@Slf4j
@SpringBootTest
class MybatisTextApplicationTests {
@Autowired
private IBookService bookService;
@Autowired
private BookMapper bookMapper;
@Test
void contextLoads() {
}
/**
* 保存单个
*/
@Test
public void test01() {
/*创建faker实例
参数：指定使用语言和国家*/
Faker faker = new Faker(new Locale("zh", "CN"));
/*
faker.number().randomDouble(x,x,x)
* 生成一个介于 100 和 999 之间的随机浮点数，并且保留两位小数。
* */
Book book = new Book()
.setBookname(faker.book().title())
.setPrice((float) faker.number().randomDouble(2, 100, 999));
bookService.save(book);
}
/**
* 保存多个
*/
@Test
public void test02() {
/*
* Stream.generate方法：创建一个无限流，其中每个元素都是使用提供的lambda表达式生成的。
* 使用lambda表达式创建一个新的Book对象，并用Faker库生成的随机书名和价格对其进行初始化。
* limit方法：将流限制为只包含前1000个元素。
* collect方法：将流收集到一个列表中。
* */
Faker faker = new Faker(new Locale("zh", "CN"));
List<Book> list = Stream.generate(
() -> new Book()
.setBookname(faker.book().title())
.setPrice((float) faker.number().randomDouble(2, 100, 999))
).limit(10).collect(Collectors.toList());
bookService.saveBatch(list);
}
@Test
public void test03() {
Faker faker = new Faker(Locale.CHINA);
List<Book> list = Stream.generate(
() -> new Book()
.setBookname(faker.book().title())
.setPrice((float) faker.number().randomDouble(2, 100, 999))
).limit(1000).collect(Collectors.toList());
bookService.saveBatch(list, 500);
}
@Test
public void test04() {
QueryWrapper<Book> wrapper = new QueryWrapper<>();
/*条件删除
* lt小于
* */
wrapper.lt("price", 500);
// wrapper.like("name", "你");
bookService.remove(wrapper);
}
@Test
public void test05() {
Map<String, Object> ms = new HashMap<>();
ms.put("price", 100);
// ms.put("name", "你");
bookService.removeByMap(ms);
}
@Test
public void test06() {
List<Long> ids = bookService
.list()
.stream()
.limit(5)
.map(Book::getId)
.collect(Collectors.toList());
bookService.removeBatchByIds(ids);
}
@Test
public void test07() {
UpdateWrapper<Book> wrapper = new UpdateWrapper<>();
wrapper.eq("id", 493587255361727L);
wrapper.set("name", "jack");
wrapper.setSql("price=price+1");
bookService.update(wrapper);
}
@Test
public void test08() {
Faker faker = new Faker(Locale.CHINA);
Book Book = new Book()
.setBookname(faker.book().title())
.setPrice((float) faker.number().randomDouble(2, 100, 999));
UpdateWrapper<Book> wrapper = new UpdateWrapper<>();
wrapper.eq("id", 493587255361723L);
bookService.update(Book, wrapper);
}
@Test
public void test09() {
QueryWrapper<Book> wrapper = new QueryWrapper<>();
wrapper.like("name", "吕");
wrapper.gt("price", 200);
bookService.getOne(wrapper);
}
@Test
public void test10() {
QueryWrapper<Book> wrapper = new QueryWrapper<>();
/*sql条件加拼接*/
wrapper.gt("price", 200);
/*拼接sql到最后*/
wrapper.last("limit 1");
bookService.getOne(wrapper);
}
@Test
public void test11() {
QueryWrapper<Book> wrapper = new QueryWrapper<>();
wrapper.gt("price", 200);
bookService.getOne(wrapper, false);
}
@Test
public void test12() {
QueryWrapper<Book> wrapper = new QueryWrapper<>();
wrapper.gt("price", 200);
wrapper.last("limit 1");
bookService.getMap(wrapper).forEach((k, v) -> {
log.warn("{},{}", k, v);
});
}
@Test
public void test13() {
QueryWrapper<Book> wrapper = new QueryWrapper<>();
wrapper.gt("price", 200);
wrapper.last("limit 1");
bookService.getObj(wrapper, e -> {
log.warn("{}", e);
return new Object();
});
}
}