【SpringBoot】| Funcionamiento ORM MySQL (MyBatis integrado)

News 2023-08-19 02:21:48 views: null

Tabla de contenido

Uno: ORM opera MySQL 

1. Crea un proyecto Spring Boot

2. @MapperScan

3. El archivo del mapeador y el código Java se administran por separado.

4. Soporte de transacciones

Uno: ORM opera MySQL 

Use el marco MyBatis para operar datos, integre MyBatis en el marco SpringBoot y siga los pasos:

(1) dependencia de inicio de mybatis: complete la configuración automática de los objetos de mybatis y coloque los objetos en el contenedor

(2) pom.xml especifica incluir el archivo xml en el directorio src/main/java en el classpath

(3) Crear una clase de entidad Estudiante

(4) Cree una interfaz Dao StudentDao y cree un método para consultar a los estudiantes

(5) Cree el archivo Mapper correspondiente a la interfaz Dao, el archivo xml y escriba la declaración sql

(6) Cree un objeto de capa de servicio, cree una interfaz StudentService y su clase de implementación. El método de eliminar el objeto dao para completar la operación de la base de datos.

(7) Cree un objeto Controlador y acceda al Servicio.

(8) Escriba el archivo application.properties para configurar la información de conexión de la base de datos.

1. Crea un proyecto Spring Boot

(1) Preparar la tabla de la base de datos

campos y sus tipos

 insertar datos

 (2) Crear un proyecto SpringBoot

Seleccione la dependencia de Spring Web

Dependencia de MybatisFramework, dependencia del controlador MySQL

(3) Configuración pom.xml generada y configuración de complemento de recursos agregada manualmente

Nota: La configuración del complemento de recursos significa que los archivos de configuración *.xml en src/java/main o subpaquetes finalmente se cargan en el directorio target/classes.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.9</version>
        <relativePath/>
    </parent>
    <groupId>com.zl</groupId>
    <artifactId>study-springboot-mysql</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--web的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mybatis的起步依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.3.0</version>
        </dependency>
        <!--mysql驱动依赖-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <!--手动添加resources插件-->
        <resources>
            <resource>
                <!--指定目录-->
                <directory>src/main/java</directory>
                <!--指定目录下的文件-->
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

        <!--plugins插件-->
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

(4) Clase de entidad

Prepare una clase de entidad cuyos nombres de atributos sean consistentes con los nombres de campo en la base de datos.

package com.zl.pojo;

public class Student {
    private Integer id;
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

(5) Crear una interfaz Dao

Debe agregar la anotación @Mapper a la clase : dígale a MyBatis que esta es una interfaz dao y cree un objeto proxy para esta interfaz.

package com.zl.dao;

import com.zl.pojo.Student;
import org.apache.ibatis.annotations.Mapper;

@Mapper //用来创建代理对象的
public interface StudentDao {
    // 根据id进行查询
    Student selectById(@Param("stuId") Integer id);
}

(6) Cree un archivo StudentDao.xml con el mismo nombre en la interfaz Dao

Nota: ¡La configuración de recursos que configuramos anteriormente es para este servicio de configuración StudentDao.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.zl.dao.StudentDao">
    <!--编写sql语句，id是这条sql语句的唯一表示-->
    <select id="selectById" resultType="com.zl.pojo.Student">
        select id,name,age from t_student where id = #{stuId}
    </select>
</mapper>

(7) Escriba la interfaz de servicio y la clase de implementación correspondiente

Interfaz StudentService

package com.zl.service;

import com.zl.pojo.Student;

public interface StudentService {
    // 方法调用
   Student queryStudent(Integer id);

}

Clase de implementación de la interfaz StudentService, escribir lógica empresarial

package com.zl.service.impl;

import com.zl.dao.StudentDao;
import com.zl.pojo.Student;
import com.zl.service.StudentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service // 交给Spring容器管理
public class StudentServiceImpl implements StudentService {

    // 调用Dao
    @Resource // 给属性赋值
    private StudentDao studentDao;

    @Override
    public Student queryStudent(Integer id) {
        Student student = studentDao.selectById(id);
        return student;
    }
}

(8) Crear un controlador para llamar al servicio

package com.zl.controller;

import com.zl.pojo.Student;
import com.zl.service.StudentService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller 
public class StudentController {
    @Resource
    public StudentService studentService;
    
    @RequestMapping("/student/query")
    @ResponseBody
    public String queryStudent(Integer id){
        Student student = studentService.queryStudent(id);
        return student.toString();
    }
}

(9) Para conectarse a la base de datos, se requiere la configuración de application.properties

useUnicode utiliza la codificación Unicode, el juego de caracteres characterEncoding es utf-8, zona horaria serverTimezone.

server.port=9090
server.servlet.context-path=/orm
#连接数据库的配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123

(10) Resultado de la ejecución

2. @MapperScan

Si hay varias interfaces de Dao, debe agregar la anotación @Mapper a cada interfaz de Dao, ¡lo cual es problemático!

Interfaz StudentDao

package com.zl.dao;

import com.zl.pojo.Student;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface StudentDao {
    // 根据id进行查询
    Student selectById(Integer id);
}

interfaz UserDao

package com.zl.dao;

import com.zl.pojo.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserDao {
    // 根据id进行查询
    SUser selectById(Integer id);
}

También puede agregar el escaneo del paquete de anotaciones @MapperScan ("com.zl.dao") en la clase principal (en la clase de inicio)

Nota: basePackages es una matriz de cadenas y se pueden escribir varios paquetes para escanear.

package com.zl;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = "com.zl.dao")
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

detalle:

Si importamos un proyecto, IDEA no puede reconocer los recursos, y el ícono es el siguiente:

Haga clic con el botón derecho del mouse ----"Marcar directorio como-----"Raíz de recursos

El icono en este momento es el siguiente: 

3. El archivo del mapeador y el código Java se administran por separado.

¡El archivo xml actual y el código java se administran bajo el mismo paquete!

 ¡También se puede almacenar por separado y poner el archivo xml en el directorio de recursos! Cree un directorio de mapeador en recursos y coloque todo *.xml en él, pero no se puede encontrar en este momento, necesitamos configurarlo y especificarlo.

 En este momento, debe especificar en el archivo application.properties:

#指定mapper文件的位置
mybatis.mapper-locations=classpath:mapper/*.xml

Nota: En este momento, la versión inferior de Springboot puede tener el archivo application.properties no compilado en el directorio target/classes En este momento, debe modificar la configuración del complemento de recursos:

<resources>
     <resource>
       <directory>src/main/resources</directory>
       <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>  
       </includes>
     </resource>
</resources>

Para ver la información de la instrucción SQL, debe agregar el marco de registro en application.properties

#指定mybatis的日志，使用StdOutImpl输出到控制台
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

En este punto, puede ver la información de registro de la instrucción SQL

4. Soporte de transacciones

Transacciones en el marco Spring:

(1) Usar objetos que administren transacciones: administradores de transacciones (interfaces, las interfaces tienen muchas clases de implementación)

Ejemplo: use Jdbc o mybatis para acceder a la base de datos, el administrador de transacciones usó: DataSourceTransactionManager

(2) Transacción declarativa: describa el contenido del control de transacción en el archivo de configuración xml o use anotaciones

Transacciones de control: nivel de aislamiento, comportamiento de propagación, tiempo de espera, etc.

(3) Método de procesamiento de transacciones:

① @Transactional en el marco Spring;

② El framework aspectj puede declarar el contenido del control de transacciones en el archivo de configuración xml;

Es muy simple usar transacciones en SpringBoot, y la capa inferior todavía usa la gestión de transacciones proporcionada por Spring.

① Agregue @Transactional sobre el método comercial y, después de agregar la anotación, el método tiene una función de transacción.

②Agregue @EnableTransactionManager arriba de la clase de inicio principal para habilitar el soporte de transacciones.

Nota: solo agregar @Transactional también puede completar la función de transacción, y también se recomienda agregar @EnableTransactionManager.

Paso 1: Cree un proyecto SpringBoot e introduzca: Spring Web, MybatisFramework, MySQL Driver

Paso 2: use el complemento de ingeniería inversa mybatis para generar una clase pojo y una interfaz dao

①Agregue el complemento de ingeniería inversa Mybatis

Nota: este complemento requiere dependencias del controlador MySQL. Si no se introdujo ninguna dependencia del controlador MySQL, entonces se requiere la etiqueta <classPathEntry> en la configuración de generatorConfig.xml a continuación para especificar la ubicación del paquete del controlador JDBC que se conecta a la base de datos. y especifíquelo en su máquina local.La ruta completa, por ejemplo: <classPathEntry location="E:\mysql-connector-java-5.1.38.jar"/>.

<!--mybatis逆向⼯程插件-->
<plugin>
     <!--插件的GAV坐标-->
     <groupId>org.mybatis.generator</groupId>
     <artifactId>mybatis-generator-maven-plugin</artifactId>
     <version>1.4.1</version>
    
     <configuration>
            <!--配置文件的位置，放在项目根目录下必须指定一下-->
	       <!--<configurationFile>GeneratorMapper.xml</configurationFile>-->
            <!--允许覆盖-->
           <overwrite>true</overwrite>
     </configuration>
     <!--插件的依赖-->
     <dependencies>
         <!--mysql驱动依赖-->
         <dependency>
               <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.23</version>
         </dependency>
      </dependencies>
</plugin>

② Escribir el archivo de configuración generatorConfig.xml

Nota: Si el siguiente archivo de configuración generatorConfig.xml se coloca en el directorio de recursos de src, el nombre del archivo de configuración debe ser generatorConfig.xml (no distingue entre mayúsculas y minúsculas) y no es necesario especificar la etiqueta <configurationFile> anterior.

Nota: si colocamos el archivo de configuración generatorConfig.xml directamente en el directorio raíz del proyecto (directorio del mismo nivel que src), entonces el nombre del archivo de configuración generatorConfig.xml es arbitrario en este momento, pero debe usar el < anterior configurationFile> etiqueta para especificarlo (Ambos pueden ser consistentes).

Nota: Por supuesto, no puede colocarlo directamente en el directorio raíz del proyecto, por ejemplo: colóquelo en el directorio src/main, luego debe especificar src/main/generatorConfig.xml para la etiqueta <configurationFile> ( ambos deben ser consistentes)

Nota: para la versión superior del controlador MySQL, la zona horaria debe seguir la URL, pero & no se puede reconocer en xml, por lo que debe usar & para reemplazarlo, por ejemplo:

connectionURL="jdbc:mysql://localhost:3306/springdb?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT%2B8"

Finalmente, se generará la configuración *.xml.Si desea que se compile y se coloque en destino/clases, debe configurar el directorio de recursos de procesamiento

<!--处理资源目录-->
<resources>
    <resource>
       <directory>src/main/java</directory>
       <includes>
             <include>**/*.xml</include>
             <include>**/*.properties</include>
       </includes>
    </resource>
    <resource>
       <directory>src/main/resources</directory>
       <includes>
             <include>**/*.xml</include>
             <include>**/*.properties</include>
       </includes>
    </resource>
</resources>

 configuración de generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>


    <!-- 指定连接数据库的JDBC驱动包所在位置，如果前面插件中指定了，这里就不要指定了 -->
    <!--<classPathEntry location="E:\mysql-connector-java-5.1.38.jar"/>-->

    <!--
        targetRuntime有两个值：
            MyBatis3Simple：生成的是基础版，只有基本的增删改查。
            MyBatis3：生成的是增强版，除了基本的增删改查之外还有复杂的增删改查。
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!--防止生成重复代码-->
        <plugin type="org.mybatis.generator.plugins.UnmergeableXmlMappersPlugin"/>

        <commentGenerator>
            <!--是否去掉生成日期-->
            <property name="suppressDate" value="true"/>
            <!--是否去除注释-->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>

        <!--连接数据库信息-->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springboot"
                        userId="root"
                        password="123">
        </jdbcConnection>

        <!-- 生成pojo包名和位置 -->
        <javaModelGenerator targetPackage="com.zl.pojo" targetProject="src/main/java">
            <!--是否开启子包-->
            <property name="enableSubPackages" value="true"/>
            <!--是否去除字段名的前后空白-->
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>

        <!-- 生成SQL映射文件的包名和位置 -->
        <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">
            <!--是否开启子包-->
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <!-- 生成Mapper接口的包名和位置 -->
        <javaClientGenerator
                type="xmlMapper"
                targetPackage="com.zl.mapper"
                targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!-- 表名和对应的实体类名-->
        <table tableName="t_Student" domainObjectName="Student"/>

    </context>
</generatorConfiguration>

Haga doble clic en el complemento, el resultado de la ejecución es el siguiente:

Paso 3: Escriba la configuración de application.properties

Nota: Si el directorio StudentMapper.xml es consistente con el directorio StudentMapper, no se requiere la siguiente configuración mybatis.mapper-locations=classpath:mapper/*.xml, aquí definimos el directorio mapper y colocamos el archivo mapper.xml en él , por lo que debemos especificar su ubicación.

#设置端口
server.port=8082
#配置项目根路径context-path
server.servlet.context-path=/myboot
#配置数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123
#配置mybatis
mybatis.mapper-locations=classpath:mapper/*.xml
#配置日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

Paso 4: Escriba la interfaz de servicio y la clase de implementación

Interfaz StudentService

package com.zl.service;

import com.zl.pojo.Student;

public interface StudentService {
    int addStudent(Student student);
}

La clase de implementación StudentServiceImpl de la interfaz StudentService

package com.zl.service.impl;

import com.zl.mapper.StudentMapper;
import com.zl.pojo.Student;
import com.zl.service.StudentService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

@Service // 交给Spring容器管理
public class StudentServiceImpl implements StudentService {

    @Resource // 属性赋值
    private StudentMapper studentDao;

    @Transactional // 事务控制
    @Override
    public int addStudent(Student student) {
        System.out.println("准备执行sql语句");
        int count = studentDao.insert(student);
        System.out.println("已完成sql语句的执行");
        // 模拟异常，回滚事务
        int sum = 10 / 0;

        return count;
    }
}

Paso 5: escriba la clase de controlador para llamar al servicio

package com.zl.controller;

import com.zl.pojo.Student;
import com.zl.service.StudentService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;

@Controller
public class StudentController {

    @Resource
    private StudentService studentService;


    @RequestMapping("/addStudent")
    @ResponseBody
    public String addStudent(String name,Integer age){
        Student s = new Student();
        s.setName(name);
        s.setAge(age);
        int count = studentService.addStudent(s);
        return "添加的Student个数是："+count;
    }
}

Paso 6: agregue anotaciones de escaneo de paquetes y anotaciones del administrador de transacciones de inicio a la clase de inicio

package com.zl;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@MapperScan(basePackages = "com.zl.mapper") // 添加包扫描
@EnableTransactionManagement // 启动事务管理器
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

Paso siete: Ejecute la prueba

Se produce una excepción, la transacción se revertirá y no se pueden insertar datos

 No ocurre ninguna anormalidad, inserte los datos normalmente

Supongo que te gusta

Origin blog.csdn.net/m0_61933976/article/details/129344765
Recomendado
Clasificación
Diario
Más
2024-05-17(4)
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)

Code World

© 2018 codetd.com