Serie SpringBoot (7) -SpringBoot y acceso a datos

SpringBoot y acceso a datos

Con respecto a la capa de acceso a datos, ya sea SQL o NOSQL, SpringBoot adopta el método de integrar Spring Data para el procesamiento unificado por defecto, agregando una gran cantidad de configuraciones automáticas y protegiendo muchas configuraciones. En éste, SpringBoot introducir varios xxxTemplate, xxxRepositorypara simplificar las operaciones en la capa de acceso a datos. Para nosotros, solo se requieren configuraciones simples.

SpringBoot utiliza los siguientes tres métodos de acceso a datos

• JDBC
• MyBatis
• JPA

Usando JDBC en SpringBoot

• Cree una nueva prueba de proyecto: springboot_data_jdbc; ¡introduzca el módulo correspondiente! Módulo básico
  
• Después de que se construyó el proyecto, se descubrió que los siguientes lanzadores se importaron automáticamente para nosotros:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

• Escriba un archivo de configuración de yaml para conectarse a la base de datos;

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver

• Después de configurar estas cosas, podemos ir directamente a usar, porque SpringBoot se ha configurado automáticamente para nosotros por defecto; ve a la clase de prueba para probar

@SpringBootTest
class SrpingBootDataJdbc1ApplicationTests {
    
    

    //DI注入数据源
    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
    
    
        //看一下默认数据源
        System.out.println(dataSource.getClass());
        //获得连接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        //关闭连接
        connection.close();
    }
}

Aquí podemos ver el registro de salida de la consola, podemos saber que SpringBoot usa class com.zaxxer.hikari.HikariDataSourcecomo fuente de datos por defecto y la configuración relevante de la fuente de datos está en DataSourcePropertiesél.

Principio de configuración automática

Busquemos globalmente y encontremos que toda la configuración automática de la fuente de datos está en: Archivo DataSourceConfiguration:

Las clases importadas están todas bajo la DataSourceConfigurationclase de configuración. Se puede ver que Spring Boot 2.x usa la HikariDataSourcefuente de datos por defecto , mientras que la versión anterior , como Spring Boot 1 .x se utiliza org.apache.tomcat.jdbc.pool.DataSourcede forma predeterminada como fuente de datos;

HikariDataSource 号称 Java WEB 当前速度最快的数据源，相比于传统的 C3P0 、DBCP、Tomcat jdbc 等连接池更加优秀；

• En primer lugar, de acuerdo con la convención, busque la clase de configuración automática de jdbc, y luego analícela consultando la clase de configuración automática, y la clase de configuración automática de jdbc esorg.springframework.boot.autoconfigure.jdbc
• Como referencia DataSourceConfiguration, cree una fuente de datos de acuerdo con la configuración y use el grupo de conexiones Tomcat de forma predeterminada; puede usar el spring.datasource.typetipo de fuente de datos personalizado especificado;
• Las fuentes de datos que SpringBoot puede admitir de forma predeterminada son las siguientes;
  • org.apache.tomcat.jdbc.pool.DataSource
  • HikariDataSource
  • BasicDataSource

Dado que existe una fuente de datos predeterminada, podemos, por supuesto, personalizar el tipo de fuente de datos

/**
 * Generic DataSource configuration.
 */
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic {
    
    

   @Bean
   public DataSource dataSource(DataSourceProperties properties) {
    
    
       //使用DataSourceBuilder创建数据源，利用反射创建响应type的数据源，并且绑定相关属性
      return properties.initializeDataSourceBuilder().build();
   }

}

• DataSourceInitializer: ApplicationListener；
  • efecto:
    • runSchemaScripts (); Ejecute la declaración de creación de la tabla;
    • runDataScripts (); Ejecute la instrucción sql que inserta los datos;

De forma predeterminada, solo necesita nombrar el archivo:

schema-*.sql、data-*.sql
默认规则：schema.sql，schema-all.sql；
可以使用   
	schema:
      - classpath:department.sql
      指定位置

Base de datos de operaciones: la base de datos de operaciones de JdbcTemplate se configura automáticamente

• Escriba JdbcController:

@Controller
@RequestMapping("/jdbc")
public class JdbcController {
    
    

    @Autowired
    JdbcTemplate jdbcTemplate;

    @ResponseBody
    @GetMapping("/list")
    public List<Map<String, Object>> userList(){
    
    
        String sql = "select * from account";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }
}
//其他的方法大家有兴趣可以自己添加

Integrar fuentes de datos de Druid

Una gran parte del programa Java tiene que operar la base de datos, para mejorar el rendimiento al operar la base de datos, debe usar el grupo de conexiones de la base de datos.

Druid es una implementación de grupo de conexiones de base de datos en la plataforma de código abierto de Alibaba, que combina las ventajas de C3P0, DBCP y otros grupos de bases de datos, y agrega monitoreo de registros.

Druid puede monitorear bien la conexión del grupo de bases de datos y la ejecución de SQL, y ha nacido para ser un grupo de conexiones de base de datos para el monitoreo.

Spring Boot 2.0 y superior usan la fuente de datos Hikari de forma predeterminada. Se puede decir que Hikari y Driud son las mejores fuentes de datos en la Web Java actual. Centrémonos en cómo Spring Boot integra las fuentes de datos Druid y cómo implementar el monitoreo de la base de datos.

Configurar fuente de datos

• Importar dependencias

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.21</version>
</dependency>

• Cambie la fuente de datos; especifique la fuente de datos a través de spring.datasource.type.
  

• Después de cambiar la fuente de datos, inyecte la fuente de datos en la clase de prueba, luego consígala y la salida le dirá si el cambio es exitoso o no;
  

• ¡Cambiado exitosamente! Ahora que el cambio es exitoso, puede configurar el tamaño de inicialización de la conexión de la fuente de datos, el número máximo de conexiones, el tiempo de espera, el número mínimo de conexiones y otras configuraciones;

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/springboot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    #自定义数据源
    type: com.alibaba.druid.pool.DruidDataSource
    
    #   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

server:
  port: 8081

• Ahora debe vincular los parámetros en el archivo de configuración global al DruidDataSource usted mismo, y luego agregarlo al contenedor, en lugar de usar la generación automática de Spring Boot; necesitamos agregar el componente DruidDataSource al contenedor por nosotros mismos, y vincular las propiedades;

@Configuration
public class DruidConfig {
    
    

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
    
    
        return new DruidDataSource();
    }
}

• Pruébelo en la clase de prueba

@SpringBootTest
class SrpingBootDataJdbc1ApplicationTests {
    
    

    //DI注入数据源
    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
    
    
        //获得连接
        Connection connection = dataSource.getConnection();
        DruidDataSource druidDataSource = (DruidDataSource) dataSource;
        System.out.println("druidDataSource 数据源最大连接数：" + druidDataSource.getMaxActive());
        System.out.println("druidDataSource 数据源初始化连接数：" + druidDataSource.getInitialSize());
        //关闭连接
        connection.close();
    }
}

• resultado de la operación:
  

Configurar el monitoreo de la fuente de datos de Druid

• La fuente de datos Druid tiene la función de monitoreo y proporciona una interfaz web para que los usuarios la vean, similar a cuando el enrutador está instalado, otros también brindan una página web predeterminada.

Entonces, el primer paso es configurar la página de administración de back-end de Druid, como la cuenta de inicio de sesión, contraseña, etc .; configurar la administración de back-end;

@Configuration
public class DruidConfig {
    
    

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
    
    
        return new DruidDataSource();
    }

    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    //配置 Druid 监控管理后台的Servlet；
    //内置 Servlet 容器时没有web.xml文件，所以使用 Spring Boot 的注册 Servlet 方式
    @Bean
    public ServletRegistrationBean statViewServlet(){
    
    
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String, String> initParam = new HashMap<>();
        initParam.put("loginUsername","admin");//后台管理界面的登录账号
        initParam.put("loginPassword","123456");//后台管理界面的登录密码
        initParam.put("allow","");//默认就是允许所有访问
        //deny：Druid 后台拒绝谁访问
        //initParams.put("xiaozhang", "192.168.1.20");表示禁止此ip访问
        bean.setInitParameters(initParam);
        return bean;
    }

    //2、配置一个web监控的filter
    public FilterRegistrationBean webStatFilter(){
    
    
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String, String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}

Podemos encontrar después de ejecutar la consulta anterior:

SpringBoot integra MyBatis

• Importar las dependencias requeridas por MyBatis

<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.4</version>
</dependency>

• Configurar la información de conexión de la base de datos

Igual que la integración de Druid anterior

• Crea una tabla para la base de datos
• Crear un JavaBean es crearlo basándose en los atributos de la tabla de datos El nombre del atributo es mejor para coincidir con el nombre del atributo de la base de datos.

Versión anotada

• Cree el directorio del asignador y la interfaz del asignador correspondiente

@Mapper//指定这是一个操作数据库的mapper
public interface UserMapper {
    
    

    @Select("select * from user where id=#{id}")
    public User getUserById(Integer id);

    @Delete("delete from user where id=#{id}")
    public int deleteUserById(Integer id);

    @Options(useGeneratedKeys = true,keyProperty = "id")
    @Insert("insert into user(username) values(#{username})")
    public int insertUser(User user);

    @Update("update user set username=#{username} where id=#{id}")
    public int updateUser(User user);
}

• Escribir clase de control

@RestController
public class UserController {
    
    

    @Autowired
    UserMapper userMapper ;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Integer id){
    
    
        return userMapper .getUserById(id);
    }

    @GetMapping("/user")
    public User insertUser(User user){
    
    
        userMapper .insertUser(user);
        return user;
    }
}

• Luego ingrese localhost: 8080 / user / id en el navegador
  

• Cuando el nombre del atributo de nuestra clase de entidad no coincide con el de la base de datos, no se pueden encontrar datos, etc. En el pasado, los alias se podían establecer en xml. ¿Qué debemos hacer ahora?

• Podemos personalizar las reglas de configuración de MyBatis, agregar una al contenedor ConfigurationCustomizer;

@org.springframework.context.annotation.Configuration
public class MyBatisConfig {
    
    

    @Bean
    public ConfigurationCustomizer configurationCustomizer(){
    
    
        return new ConfigurationCustomizer(){
    
    

            @Override
            public void customize(Configuration configuration) {
    
    
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}

• Cuando tenemos muchos mapeadores, cada mapeador debe obtener una anotación @Mapper. Podemos agregar en el archivo principal:
  

Versión del archivo de configuración

mybatis:
  config-location: classpath:mybatis/mybatis-config.xml 指定全局配置文件的位置
  mapper-locations: classpath:mybatis/mapper/*.xml  指定sql映射文件的位置

• Para más uso, consulte el documento SpringBoot oficial de Mybatis

Integrar SpringData JPA

SpringData nos proporciona una API unificada para operar la capa de acceso a datos; esto es implementado principalmente por el proyecto Spring Data Commons. Spring Data Commons nos permite utilizar tecnologías de acceso a datos relacionales o no relacionales basadas en los estándares unificados proporcionados por Spring. Los estándares incluyen operaciones relacionadas con CRUD (crear, obtener, actualizar, eliminar), consultar, ordenar y paginar.

Y SpringDataJPA tiene una interfaz de repositorio unificada como

• Repository<T, ID extends Serializable>Interfaz unificada
• RevisionRepository<T, ID extends Serializable, N extends Number & Comparable>Basado en un mecanismo de bloqueo optimista
• CrudRepository<T, ID extends Serializable>Operaciones CRUD básicas
• PagingAndSortingRepository<T, ID extends Serializable>: CRUD básico y paginación

Integrar SpringData JPA

• Primero introduzca nuestras dependencias Después de introducir las dependencias, diferente del método de acceso a datos original, podemos escribir una clase de entidad (bean) para mapear la tabla de datos y configurar la relación de mapeo;

//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user；
public class User {
    
    

    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;

    @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
    private String lastName;
    @Column //省略默认列名就是属性名
    private String email;

• Después de crear la clase de entidad y configurar la relación de mapeo, escribimos una interfaz Dao para manipular la tabla de datos (Repositorio) correspondiente a la clase de entidad.

//继承JpaRepository来完成对数据库的操作
public interface UserRepository extends JpaRepository<User,Integer> {
    
    
}

• Nuestro jpa usa hibernar por defecto, por lo que podemos realizar la siguiente configuración básica en el archivo de configuración

spring:  
 jpa:
    hibernate:
#     更新或者创建数据表结构
      ddl-auto: update
#    控制台显示SQL
    show-sql: true