Primavera 整合 JDBC 、 Druid 、 MyBatis

Primavera 整合 JDBC 、 Druid 、 MyBatis

1. Habla sobre cómo escribir un sitio web.

1.1 Sitio web

1. Frente

• Plantilla: escrita por otros, la cambiamos a lo que necesitamos
• Marco y componentes: ¡combine y empalme manualmente usted mismo! BootStarp, Layui, semántica-ui
  • Sistema de red
  • Barra de navegación
  • Barra lateral
  • Formulario

2. Diseñar la base de datos

3.Ingeniería independiente, operación automática frontal

4. Acoplamiento de interfaz de datos: json, objeto todo en uno

5. Prueba de depuración conjunta de front-end y back-end

1.2 Requisitos

1. Hay un conjunto de plantillas de fondo con las que está familiarizado: trabajo necesario (x-admin)
2. Interfaz de front-end: al menos puede combinar una página web (índice, acerca de, blog, publicación, usuario) a través del marco de front-end
3. Deje que su propio sitio web funcione de forma independiente

2. Integrar JDBC

Introducción a SpringData

Para la capa de acceso a datos, ya sea SQL (base de datos relacional) o NOSQL (base de datos no relacional), la capa inferior de Spring Boot usa Spring Data para el procesamiento unificado.

La capa inferior de Spring Boot usa Spring Data para procesar uniformemente varias bases de datos. Spring Data también es un proyecto muy conocido en Spring con el mismo nombre que Spring Boot y Spring Cloud.

Sitio web oficial de Sping Data: https://spring.io/projects/spring-data

Lanzadores relacionados con la base de datos: puede consultar los documentos oficiales:

https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/htmlsingle/#using-boot-starter

2.1 Crear una fuente de datos de prueba del proyecto de prueba

1. Voy a crear un nuevo proyecto para probar: springboot-04-data; ¡introduce los módulos correspondientes (web, jdbc, mysql)!

2. Una vez creado el proyecto, se descubrió que los siguientes lanzadores se importaban automáticamente para nosotros:

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

3. 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/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver

4. Después de configurar estas cosas, podemos usarlas directamente, porque SpringBoot se ha configurado automáticamente para nosotros de forma predeterminada; vaya a la clase de prueba para probar

@SpringBootTest
class Springboot04DataApplicationTests {
    
    

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
    
    
        //查看以下默认的数据源 class com.zaxxer.hikari.HikariDataSource
        System.out.println(dataSource.getClass());

        //获得数据库连接
        Connection connection = dataSource.getConnection();
        //HikariProxyConnection@1765865093 wrapping com.mysql.cj.jdbc.ConnectionImpl@47b179d7
        System.out.println(connection);

        //关闭
        connection.close();
    }

}

Resultado: Podemos ver que la fuente de datos que nos configuró por defecto es: class com.zaxxer.hikari.HikariDataSource, no la configuramos manualmente

Busquemos globalmente y encontremos que todas las configuraciones automáticas de la fuente de datos están en: Archivo DataSourceAutoConfiguration:

@Import(
    {
    
    Hikari.class, Tomcat.class, Dbcp2.class, Generic.class, DataSourceJmxConfiguration.class}
)
protected static class PooledDataSourceConfiguration {
    
    
    protected PooledDataSourceConfiguration() {
    
    
    }
}

Las clases importadas aquí están todas bajo la clase de configuración DataSourceConfiguration. Se puede ver que Spring Boot 2.2.5 usa HikariDataSource de forma predeterminada, mientras que las versiones anteriores, como Spring Boot 1.5, usan org.apache.tomcat.jdbc.pool.DataSource como la fuente de datos de forma predeterminada.

HikariDataSource es conocido como la fuente de datos más rápida de Java WEB, que es más excelente que los grupos de conexiones tradicionales como C3P0, DBCP, Tomcat jdbc, etc.

Puede usar spring.datasource.type para especificar un tipo de fuente de datos personalizado. El valor es el nombre completo de la implementación del grupo de conexiones que se utilizará.

No vamos a introducir la fuente de datos. Con la conexión de la base de datos, obviamente puede operar la base de datos con CRUD. Pero primero necesitamos entender un objeto JdbcTemplate

2.2JDBCTemplate

1. Con la fuente de datos (com.zaxxer.hikari.HikariDataSource), puede obtener la conexión de la base de datos (java.sql.Connection). Con la conexión, puede usar declaraciones JDBC nativas para operar la base de datos;

2. Incluso si no utiliza un marco de operación de base de datos de terceros, como MyBatis, etc., Spring ha creado un paquete ligero para JDBC nativo, llamado JdbcTemplate.

3. Todos los métodos CRUD de operaciones de bases de datos están en JdbcTemplate.

4. Spring Boot no solo proporciona una fuente de datos predeterminada, al mismo tiempo que JdbcTemplate se ha configurado de manera predeterminada y se ha colocado en el contenedor, los programadores solo necesitan inyectarse para usar

5. La configuración automática de JdbcTemplate se basa en la clase JdbcTemplateConfiguration del paquete org.springframework.boot.autoconfigure.jdbc

JdbcTemplate proporciona principalmente los siguientes métodos:

• El método de ejecución: se puede usar para ejecutar cualquier instrucción SQL, generalmente se usa para ejecutar declaraciones DDL;
• método de actualización y método batchUpdate: el método de actualización se usa para ejecutar declaraciones como agregar, modificar y eliminar; el método batchUpdate se usa para ejecutar declaraciones relacionadas con lotes;
• método de consulta y método queryForXXX: se utiliza para ejecutar declaraciones relacionadas con la consulta;
• método de llamada: se utiliza para ejecutar procedimientos almacenados y declaraciones relacionadas con la función.

2.3 Prueba

Escriba un controlador, inyecte jdbcTemplate y escriba métodos de prueba para pruebas de acceso;

@RestController
public class JDBCController {
    
    
    @Autowired
    JdbcTemplate jdbcTemplate;

    //查询数据库的所有信息
    //没有实体类，数据库中的东向西，怎么获取？Map
    @GetMapping("/userList")
    public List<Map<String,Object>> userList(){
    
    
        String sql = "select * from user";
        List<Map<String, Object>> list_maps = jdbcTemplate.queryForList(sql);
        return list_maps;
    }

    @GetMapping("addUser")
    public String addUser(){
    
    
        String sql = "insert into user(id,name,pwd)values(5,'小子','123456')";
        jdbcTemplate.update(sql);
        return "add-ok";
    }

    @GetMapping("/updateUser/{id}")
    public String updateUser(@PathVariable("id")int id){
    
    
        String sql = "update user set name=?,pwd=? where id="+id;

        //封装
        Object[] objects = new Object[2];
        objects[0] = "yong";
        objects[1] = "123456";
        jdbcTemplate.update(sql,objects);
        return "update-ok";
    }

    @GetMapping("/deleteUser/{id}")
    public String deleteUser(@PathVariable("id")int id){
    
    
        String sql = "delete from user where id="+id;
        jdbcTemplate.update(sql);
        return "delete-ok";
    }
}

Solicitud de prueba, el resultado es normal;

En este punto, la operación básica de CURD se realiza mediante JDBC.

3. Integrar a Druid

3.1 Introducción a 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.

Druid ha implementado más de 600 aplicaciones en Alibaba y ha sido probado rigurosamente en un entorno de producción a gran escala durante más de un año.

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.

Dirección de Github: https://github.com/alibaba/druid/

3.2 Configurar fuente de datos

1. Agregue la dependencia de la fuente de datos Druid.

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>

2. Cambie la fuente de datos, se ha dicho antes que Spring Boot 2.0 y superior usan la fuente de datos com.zaxxer.hikari.HikariDataSource de forma predeterminada, pero la fuente de datos se puede especificar mediante spring.datasource.type.

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

3. 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;

4. ¡El cambio es exitoso! 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; puede ver el código fuente

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

    #Spring Boot默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxWait: 60000
    timeBetweeEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，start：监控统计、log4j:日志记录、wall:防御sql注入
    #如果运行时报错 java。Lang。ClassNotFoundException：org。apache.log4j.Priority
    #则导入log4j依赖即可，Maven地址：http://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

5. Importar las dependencias de Log4j

        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

6. Ahora los programadores deben vincular los parámetros en el archivo de configuración global para DruidDataSource por sí mismos, y luego agregarlos al contenedor, en lugar de usar la generación automática de Spring Boot; necesitamos agregar el componente DruidDataSource al contenedor nosotros mismos, y unir las propiedades;

@Configuration
public class DruidConfig {
    
    

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

7. Vaya y pruebe en la clase de prueba, ¡vea si tiene éxito!

3.3 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 cuenta de inicio de sesión, contraseña, etc .; configurar la administración de back-end

DruidConfig

@Configuration
public class DruidConfig {

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

    //后台监控 web.xml
    //因为SpringBoot内置了servlet容器，所以没有web.xml 替代方法：ServletRegistrationBean
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
        //后台需要有人登录，账号密码配置
        HashMap<String, String> initParameters = new HashMap<>();

        //增加配置
        initParameters.put("loginUsername","admin");//登录的key是固定的
        initParameters.put("loginPassword","123456");
        bean.setInitParameters(initParameters);//设置初始化参数

        //允许谁可以访问
        initParameters.put("allow","");//谁都可以访问

        //禁止谁能访问
        initParameters.put("shen","192.168.11.123");
        return bean;
    }
}

Después de la configuración, podemos optar por visitar: http: // localhost: 8080 / druid / login.html

3.4 Filtro de filtro de monitoreo de web Druid

DruidConfig

    //filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
    
    
        FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
        bean.setFilter(new WebStatFilter());
        //可以过滤哪些请求呢？
        HashMap<String, String> initParameters = new HashMap<>();

        //这些请求不进行统计
        initParameters.put("exclusions","*.js,*.css,/druid/**");

        bean.setInitParameters(initParameters);
        return bean;
    }

En el trabajo normal, puede configurarlo según sus necesidades, ¡principalmente para monitoreo!

4. Integrar el marco MyBatis

Documento oficial: http://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

Dirección del almacén de Maven: https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter/2.1.1

4.1 pasos

1. Importar paquete
2. Archivo de configuración
3. configuración de mybatis
4. Escribir sql
5. La capa empresarial llama a la capa dao
6. El controlador llama a la capa de servicio

4.2 prueba

1. Importe las dependencias requeridas por MyBatis

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

2. Configurar la información de conexión de la base de datos (sin cambios)

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

    #Spring Boot默认是不注入这些属性值的，需要自己绑定
    #druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxWait: 60000
    timeBetweeEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    poolPreparedStatements: true

    #配置监控统计拦截的filters，start：监控统计、log4j:日志记录、wall:防御sql注入
    #如果运行时报错 java。Lang。ClassNotFoundException：org。apache.log4j.Priority
    #则导入log4j依赖即可，Maven地址：http://mvnrepository.com/artifact/log4j/log4j
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

3. ¡Pruebe si la base de datos está conectada correctamente!

@SpringBootTest
class Springboot05MybatisApplicationTests {
    
    

    @Autowired
    private DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
    
    
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }

}

4. ¡Cree una clase de entidad e importe Lombok!

Department.java

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    private int id;
    private String name;
    private String pwd;
}

5. Cree el directorio del asignador y la interfaz del asignador correspondiente.

UserMapper

//这个注解表示了这是一个mybatis的mapper类
@Mapper
@Repository
public interface UserMapper {
    
    

    List<User> queryUserList();

    User queryUserById(int id);

    int addUser(User user);

    int updateUser(User user);

    int deleteUser(int id);
}

6. Configurar alias

application.yml

# 整合mybatis
mybatis:
  type-aliases-package: com.simpleteen.pojo
  mapper-locations: classpath:mybatis/mapper/*.xml

7. Archivo de mapeo de Mapper correspondiente

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.simpleteen.mapper.UserMapper">

    <select id="queryUserList" resultType="User">
        select * from user
    </select>

    <select id="selectUserById" resultType="User">
        select * from user where id = #{id}
    </select>

    <insert id="addUser" parameterType="User">
        insert into user(id,name,pwd) values (#{id},#{name},#{pwd})
    </insert>

    <update id="updateUser" parameterType="User">
        update user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from user where id =#{id}
    </delete>
</mapper>

8. ¡Controlador para probar!

@RestController
public class UserController {
    @Autowired
    private UserMapper userMapper;

    @GetMapping("/queryUserList")
    public List<User> queryUserList(){
        List<User> userList = userMapper.queryUserList();
        return userList;
    }

    @GetMapping("/addUser")
    public String addUser(){
        userMapper.addUser(new User(5,"小勇","123456"));
        return "ok";
    }

    @GetMapping("/updateUser")
    public String updateUser(){
        userMapper.updateUser(new User(5,"大勇","123456"));
        return "ok";
    }

    @GetMapping("deleteUser")
    public String deleteUser(){
        userMapper.deleteUser(5);
        return "ok";
    }
}

¡Inicie la visita del proyecto para probarlo!