Spring Boot serie de base de datos de operaciones JDBC

PD: El texto original se publicó por primera vez en la cuenta pública de WeChat: Jongxingzhi (jzman-blog)

Antes de leer este artículo, puede leer los primeros artículos:

• Desarrollo de una interfaz en la serie Spring Boot
• Empezando con la plantilla Thymeleaf de la serie Spring Boot
• Thymeleaf sintaxis común de la serie Spring Boot
• Diseño de plantilla Thymeleaf de la serie Spring Boot
• Proyecto de internacionalización de Spring Boot Series

JDBC (Java Data Base Connectivity, conexión a la base de datos Java), el propósito principal es conectarse a la base de datos, ejecutar declaraciones SQL, procesar resultados de ejecución SQL, etc., comenzar a aprender JDBC en Spring Boot desde cero, el contenido principal es el siguiente:

1. Instalar MySQL
2. Conectarse a MySQL
3. Crear base de datos
4. Dependencia y configuración
5. Clase de entidad
6. Logra agregar, eliminar, modificar y verificar
7. Efecto de prueba
8. Configuración de múltiples fuentes de datos

Instalar MySQL

Visite el sitio web oficial para descargar la versión correspondiente de MySQL:

https://dev.mysql.com/downloads/

Aquí, seleccione el paquete de instalación correspondiente al sistema operativo Windows a descargar, como se muestra en la siguiente figura:

Luego, seleccione Siguiente para instalar, una vez completada la instalación, puede iniciar MySQL.

Conectarse a MySQL

Después de instalar MySQL, inicie MySQL y luego use Navicat para conectarse a MySQL. La nueva conexión es la siguiente:

Ingrese el nombre de usuario, contraseña, etc. y haga clic para probar la conexión.Si la configuración es correcta, le indicará que la conexión es exitosa.

Crear base de datos y tabla

Después de conectarse a MySQL, haga clic con el botón derecho en la conexión para crear la base de datos db_student de la siguiente manera:

El comando correspondiente para crear la base de datos es el siguiente:

CREATE DATABASE `db_student` CHARACTER SET 'utf8mb4' COLLATE 'utf8mb4_0900_ai_ci';

Después de crear la base de datos, cree una tabla llamada estudiante. Puede usar Navicat para crear o usar el comando. El comando para crear la tabla es el siguiente:

CREATE TABLE `student` (
     `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
     `name` varchar(32) DEFAULT NULL COMMENT '用户名',
     `password` varchar(32) DEFAULT NULL COMMENT '密码',
     `age`  int DEFAULT NULL COMMENT '年龄',
     PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

Dependencia y configuración

Cree un proyecto Spring Boot y agregue las dependencias del controlador JDBC y MySQL en su archivo build.gradle de la siguiente manera:

dependencies {
    
    
    // jdbc依赖
    implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
    // mysql驱动
    runtime("mysql:mysql-connector-java")
    // ...
}

Luego realice la configuración básica de la base de datos en el archivo application.properties del proyecto, de la siguiente manera:

# 数据库用户名
spring.datasource.username=root
# 数据库密码
spring.datasource.password=admin
# JDBC Driver
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# JDBC URL
spring.datasource.url=jdbc:mysql://localhost:3306/db_student?serverTimezone=Asia/Shanghai

Una vez completada la configuración, puede usar la herramienta Base de datos de IDEA para probar si la configuración es correcta. La prueba es exitosa como se muestra en la siguiente figura:

Clase de entidad

Cree una tabla de datos studentcorrespondiente a la clase de entidad de datos de la siguiente manera:

/**
 * 实体类
 */
public class Student {
    
    
    private long id;
    private String name;
    private String password;
    private int age;

    public Student() {
    
    
    }

    public Student(String name, String password, int age) {
    
    
        this.name = name;
        this.password = password;
        this.age = age;
    }

    public Student(long id,String name, String password, int age) {
    
    
        this.id = id;
        this.name = name;
        this.password = password;
        this.age = age;
    }

    // setter、getter方法
}

Logra agregar, eliminar, modificar y verificar

Interfaces CRUD definidas de la IStudentRepositorysiguiente manera:

/**
 * @Desc: 定义增删查改接口
 * @Author: jzman
 */
public interface IStudentRepository {
    
    
    /**
     * 保存数据
     * @param student 单条student记录
     */
    void save(Student student);

    /**
     * 删除数据
     * @param id 学生id
     */
    void delete(long id);

    /**
     * 更新数据
     * @param student 单条student记录
     */
    void update(Student student);

    /**
     * 查询数据
     * @param name 姓名
     * @return 返回单条记录
     */
    Student findByName(String name);

    /**
     * 查询全部数据
     * @return 返回全部记录
     */
    List<Student> findAll();
}

Creación de interfaz de StudentRepositoryImplimplemento IStudentRepositoryCRUD:

/**
 * @Desc: 具体实现
 * @Author: jzman
 */
@Repository
public class StudentRepositoryImpl implements IStudentRepository {
    
    

    public JdbcTemplate mJdbcTemplate;

    /**
     * 构造方法自动装配
     * @param jdbcTemplate JdbcTemplate
     */
    public StudentRepositoryImpl(JdbcTemplate jdbcTemplate) {
    
    
        this.mJdbcTemplate = jdbcTemplate;
    }

    @Override
    public void save(Student student) {
    
    
        mJdbcTemplate.update("INSERT INTO student(name,password,age) values(?,?,?) ",
                student.getName(), student.getPassword(), student.getAge());
    }

    @Override
    public void delete(long id) {
    
    
        mJdbcTemplate.update("DELETE FROM student where id=?", id);
    }

    @Override
    public void update(Student student) {
    
    
        mJdbcTemplate.update("UPDATE student SET name=?,password=?,age=? WHERE id=?",
                student.getName(), student.getPassword(), student.getAge(), student.getId());
    }

    @Override
    public Student findByName(String name) {
    
    
        Object[] args = {
    
    name};
        return mJdbcTemplate.queryForObject("SELECT * FROM student WHERE name=?", args,
                new BeanPropertyRowMapper<Student>(Student.class));
    }

    @Override
    public List<Student> findAll() {
    
    
        return mJdbcTemplate.query("SELECT * FROM student",new BeanPropertyRowMapper<>(Student.class));
    }
}

Efecto de prueba

Escriba un programa de prueba para probar, aquí es para agregar datos como ejemplo, inserte dos piezas de datos de la siguiente manera:

 * @Desc: StudentRepositoryTests
 * @Author: jzman
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class StudentRepositoryTests {
    
    
    @Autowired
    private IStudentRepository mStudentRepository;

    @Test
    public void testSave(){
    
    
        Student student1 = new Student("躬行之", "111",3);
        Student student2 = new Student(2,"jzman", "123",20);
        mStudentRepository.save(student1);
        mStudentRepository.save(student2);
    }
}

Ejecute testSavedespués de usar las herramientas de base de datos proporcionadas por IDEA, doble tabla de estudiantes, vista la tabla de contenido, de la siguiente manera:

En este punto, la operación de inserción de datos es exitosa y lo mismo ocurre con la eliminación, modificación y consulta.

Configuración de múltiples fuentes de datos

Datos de disposición de configuración de múltiples fuentes correspondientes a la configuración principalmente DataSourcey JdbcTemplate, definiendo múltiples fuentes de datos de la siguiente manera:

/**
 * @Desc: 数据源配置
 * @Author: jzman
 */
@Configuration
public class DataSourceConfig {
    
    

    @Primary
    @Bean(name = "primaryDataSource")
    @Qualifier("primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
    
    
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "secondaryDataSource")
    @Qualifier("secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
    
    
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource){
    
    
        return new JdbcTemplate(dataSource);
    }

    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate secondaryJdbcTemplate(@Qualifier("secondaryDataSource") DataSource dataSource){
    
    
        return new JdbcTemplate(dataSource);
    }
}

Luego configure múltiples conexiones de base de datos en el archivo application.properties, de la siguiente manera:

# dataSource1
spring.datasource.primary.username=root
spring.datasource.primary.password=admin
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/data_source_one?serverTimezone=Asia/Shanghai


# dataSource1
spring.datasource.secondary.username=root
spring.datasource.secondary.password=admin
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.secondary.jdbc-url=jdbc:mysql://localhost:3306/data_source_two?serverTimezone=Asia/Shanghai

Diferentes fuentes de datos correspondientes a los JdbcTemplatedatos correspondientes a la operación a la fuente de datos, específicamente con referencia a la vista final correspondiente a los mensajes de texto fuente.

Puede seguir la cuenta pública [Jianxingzhi] para intercambiar y aprender, y responder a la palabra clave [Spring Boot] para obtener el enlace fuente del caso correspondiente.