Comment implémenter l'ajout, la suppression, la modification et la requête de base dans SpringBoot en Java
- WBOYavant
- 2023-05-20 10:07:411355parcourir
Comme le montre l'image ci-dessus, nous avons 7 autres modules importants qui doivent être construits dans l'idée
# 🎜🎜# (1) Package contrôleur : si vous avez étudié ou connaissez quelque chose sur SpringMVC, vous devez savoir que le contrôleur est la couche de contrôle, qui équivaut à l'endroit où nous recevons les informations du navigateur et répondons pour envoyer des informations pertinentes. il est également combiné avec des connaissances liées au réseau informatique, comprenant comment recevoir des informations dans le navigateur et comment répondre aux informations. Sous la couche de contrôle du contrôleur, nous mettons en œuvre une manipulation de données pertinente (un merci spécial à mon frère aîné pendant ma carrière universitaire). m'expliquant les connaissances sur la programmation Web depuis longtemps. Avantages J'espère que vous pourrez utiliser le temps nécessaire pour vérifier plus d'informations et des vidéos connexes pour apprendre) ; ici, ce qui revient exactement à apprendre à créer des classes en Java, il n'y a aucune différence ; # 🎜🎜# (3) package mapper : cela s'appelle la couche de persistance dans SpringMVC (couche DAO (objet d'accès aux données)). vous pouvez exploiter directement la base de données, généralement utilisée en conjonction avec le cinquième package de mappage ; (4) Package de services : il s'appelle la couche de logique métier dans SpringMVC, donc les classes stockées ici sont toutes liées au traitement des affaires liées. logique ;
(5) Package de mappage : placé sous les ressources en tant que chemin de classe, le fichier mybatis stocké. Parce que le SpringBoot actuel est très intégré, de nombreux fichiers de configuration peuvent être rassemblés, et même les amis qui n'ont pas beaucoup de bases mybatis peuvent le faire. apprenez-le. La raison pour laquelle le package mapper et le package de mappage sont utilisés ensemble est qu'ils forment une relation de mappage et qu'ils sont utilisés en combinaison pour accéder à nos fichiers de base de données
(6) application.yml : En tant que fichier de configuration global par défaut ; , il convient à Pour l'ensemble du projet, pour intégrer une grande partie de nos informations de configuration, ce fichier de configuration est définitivement indispensable (il est préférable d'utiliser le langage yaml pour écrire le fichier de configuration ici, car l'écriture est relativement simple et claire) ;
(7) application-dev .yml : Il s'agit d'un fichier de configuration pour un environnement spécifique, qui doit être combiné avec notre projet actuel. Parce que le projet lui-même n'est pas seulement un environnement de développement, mais aussi une série d'environnements tels que les tests et la production. Lorsque nous effectuons du développement, nous utilisons l'environnement de développement pour configurer application-dev.yml. Lorsque nous effectuons des tests, nous utilisons l'environnement de test pour configurer application-test.yml. Lorsque nous effectuons la production, nous utilisons l'environnement de production pour configurer application-. pro. À l'heure actuelle, nous ne parlons que de l'environnement de développement, nous n'utilisons donc qu'un seul fichier de configuration application-dev.yml. Des informations de configuration d'environnement spécifiques remplaceront la configuration par défaut de application.yml lorsqu'elles sont utilisées, vous n'avez donc pas à vous soucier des conflits entre les instructions de la configuration par défaut et les instructions de la configuration de l'environnement.
(1) Entrée du programme
package com.example.demo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan("com.example.demo.mapper")
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}Quantity Annotation @SpringBootApplication : Elle est utilisée pour indiquer qu'il s'agit de la classe d'élément de démarrage d'un projet Springboot, dans le but d'activer la configuration automatique. (en fait, c'est un héritage. Pour la classe de configuration Configuration, une compréhension approfondie nécessite que chacun analyse les principes de SpringBoot) 
Quantity @MapperScan ("com.example.demo.mapper") consiste à analyser nos fichiers de mappeur et à accéder efficacement Mappage d'URL du fichier de base de données associé (Cette annotation est très utile !)
(2) Créer un fichier de base de données
#🎜🎜 #
CREATE TABLE `water` ( `id` int NOT NULL, `name` varchar(255) COLLATE utf8_unicode_ci NOT NULL, `salary` double(10,2) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8_unicode_ci;
(3) Créer une classe d'entité utilisateur
#🎜 🎜#package com.example.demo.entity;
/**
* @description: 实体类
* @author: Fish_Vast
* @Date: 2021/8/25
* @version: 1.0
*/
public class User {
private String name;
private Integer id;
private Double salary;
public User() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", id=" + id +
", salary=" + salary +
'}';
}
}#🎜 🎜# ●Tout le monde doit être familier avec cela. Il s'agit d'une classe qui peut être écrite sur la base de Java pur. Elle établit trois propriétés privées, un constructeur de paramètres vides, les méthodes get et set correspondantes, et réécrit également un toString. () méthode. . Le point à noter ici est que lors de la déclaration de propriétés, il est préférable d'utiliser une classe wrapper pour la déclaration. ●Dans la lecture et la saisie liées à mybatis en Java, pourquoi essayer d'utiliser des classes d'empaquetage au lieu de types de données de base ?
①Si aucune valeur n'est attribuée à un champ dans MySQL, la valeur par défaut est null Lorsque vous la vérifiez depuis la base de données, elle est également nulle Si le champ est de type int dans le code Java correspondant, null ne peut pas correspondre. au type int, car int représente les types de données de base qui ne peuvent être que des nombres de base.②Les attributs de la classe d'entité peuvent se voir attribuer une valeur ou non. Lorsque vous ne lui attribuez pas de valeur, elle a une valeur par défaut. Par exemple, la valeur par défaut de int est 0. Mais définir activement la valeur sur 0 et la valeur par défaut sur 0 sont deux concepts différents. Par exemple, le score d'une classe : 0 signifie qu'un certain élève a un score de 0, et nul signifie que l'élève n'a aucun score à l'examen. Ce sont deux concepts différents. 
（4）建立UserMapper接口
package com.example.demo.mapper;
import com.example.demo.entity.User;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface UserMapper {
//1.通过id查询用户信息
User getUser(int id);
//2.通过id删除用户信息
int delete(int id);
//3.更改用户信息
int update(User user);
//4.插入用户信息
int save(User user);
//5.查询所有用户信息
List<User> selectAll();
}●@Repository，注解它本身的作用便是标注数据访问组件，作为DAO对象，它将 DAO 导入 IoC 容器，并使未经检查的异常有资格转换为 Spring DataAccessException。通过这个注解能够报出更多发现不了的错误，更有利于对项目的维护和开发。其实@Repository不在接口上进行注明，我们的程序照样可以运行，因为在我们使用@MapperScan的时候，我们已经将我们的接口交给框架中的代理类，所以即便是我们不写，程序不会报错，只是我们在Service层写明接口的时候，IDEA会给出红色的波浪线。可以这样理解，标注@Repository是为了告诉编译器我将接口注入到了IoC容器了，你不要报错啦~
●相应地，写出增删查改和查询全部信息的五个方法。
（5）配置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.example.demo.mapper.UserMapper">
<resultMap id="BaseResultMap" type="com.example.demo.entity.User">
<result column="id" jdbcType="INTEGER" property="id" />
<result column="name" jdbcType="VARCHAR" property="name" />
<result column="salary" jdbcType="DOUBLE" property="salary" />
</resultMap>
<!--查询用户信息-->
<select id="getUser" resultType="com.example.demo.entity.User">
select * from water where id = #{id}
</select>
<!--删除用户信息-->
<delete id="delete" parameterType="int">
delete from water where id=#{id}
</delete>
<!--返回所有用户信息-->
<select id="selectAll" resultType="com.example.demo.entity.User">
select * from water
</select>
<!--增加用户信息-->
<insert id="save" parameterType="com.example.demo.entity.User" >
insert into water
<trim prefix="(" suffix=")" suffixOverrides="," >
<if test="id != null" >
id,
</if>
<if test="name != null" >
name,
</if>
<if test="salary != null" >
salary,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<if test="id != null" >
#{id,jdbcType=INTEGER},
</if>
<if test="name != null" >
#{name,jdbcType=VARCHAR},
</if>
<if test="salary != null" >
#{salary,jdbcType=DOUBLE},
</if>
</trim>
</insert>
<!--根据id更改用户信息-->
<update id="update" parameterType="com.example.demo.entity.User">
update water
<set >
<if test="name != null" >
name = #{name,jdbcType=VARCHAR},
</if>
<if test="salary != null" >
salary = #{salary,jdbcType=DOUBLE},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>●mapper namespace用于绑定mapper接口的，当你的namespace绑定接口后，你可以不用写接口实现类，mybatis会通过该绑定自动帮你找到对应要执行的SQL语句（通过mapper方法名进行绑定）；
●resultMap 定义了一个id为BaseResultMap的标识，type代表使用哪种类作为我们所要映射的类；
●
（6）建立UserService类
package com.example.demo.service;
import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* @description: 实现类，对进行相关的业务逻辑
* @author: Fish_Vast
* @Date: 2021/8/25
* @version: 1.0
*/
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public User getUser(int id){
return userMapper.getUser(id);
}
public int delete(int id){
return userMapper.delete(id);
}
public int update(User user){
return userMapper.update(user);
}
public int save(User user){
return userMapper.save(user);
}
public List<User> selectAll(){
return userMapper.selectAll();
}
}●这里我特别说明一下，private UserMapper userMapper既可以当做是引用数据类型，也可以作为接口对象进行使用，这里我们当接口对象使用（初次接触的时候肯定对这个会有些许疑问，很正常，因为我当时对于这个接口也纠结了很久哦）；
●@Service表示我们在业务逻辑层进行操纵，属于自动配置的环节；
●相应的五个方法，通过对象得到相应返回值给UserMapper接口。
（7）建立UserController类
package com.example.demo.controller;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.xml.ws.Service;
import java.util.List;
/**
* @description: 控制器，接收并响应相关信息
* @author: Fish_Vast
* @Date: 2021/8/25
* @version: 1.0
*/
@RestController
@RequestMapping("/seven")
public class UserController {
@Autowired
private UserService userService;
//通过id得到用户信息
@RequestMapping(value = "/getUser/{id}", method = RequestMethod.GET)
public String getUser(@PathVariable int id){
return userService.getUser(id).toString();
}
//通过id删除用户信息
@RequestMapping(value = "/delete", method = RequestMethod.GET)
public String delete(int id){
int result = userService.delete(id);
if(result >= 1){
return "删除成功！";
}else{
return "删除失败！";
}
}
//更改用户信息
@RequestMapping(value = "/update", method = RequestMethod.GET)
public String update(User user){
int result = userService.update(user);
if(result >= 1){
return "更新成功！";
}else{
return "更新失败！";
}
}
//插入用户信息
@RequestMapping(value = "/insert", method = RequestMethod.GET)
public int insert(User user){
return userService.save(user);
}
//查询所有用户的信息
@RequestMapping(value = "/selectAll")
@ResponseBody //理解为：单独作为响应体，这里不调用实体类的toString方法
public List<User> listUser(){
return userService.selectAll();
}
}●@RestController注解：就表示我们在控制层模块。控制层是作为SpringMVC最重要的一个环节，进行前端请求的处理，转发，重定向，还包括调用Service方法；
●@RequestMapping注解：处理请求和控制器方法之间的映射关系；
●@ResponseBody注解：将返回的数据结构转换为JSON格式响应到浏览器（这里说得比较笼统，只是简单滴给大家说明一下，水平还不够，认识还不深，不到之处还请见谅！）；
●更多的注解解释，还需要大家多去学习一下SpringMVC和SpringBoot，这里面会详细地介绍，在这里我只是做了很粗略的说明而已（本人也是正接触不久，正在努力学习当中）。
（8）配置application.yml文件
spring:
profiles:
active: dev●语句很简单，指明我们要使用的开发环境配置文件
（9）配置application-dev.yml
#服务器端口配置
server:
port: 8081
#数据库配置
spring:
datasource:
username: 数据库名称
password: 账号密码
url: jdbc:mysql://localhost:3306/user?useUnicode=true&characterEncoding=utf-8&nullCatalogMeansCurrent=true&useSSL=true&&serverTimezone=Asia/Shanghai
driver-class-name: com.mysql.cj.jdbc.Driver
#mybatis配置
mybatis:
mapper-locations: classpath:mapping/*.xml
type-aliases-package: com.example.demo.entity
#showSQL
logging:
level:
com.example.demo.entity: debug●在开发配置文件当中，我们配置好我们的服务器端口号、数据库的配置、mybatis的配置和如何展示我们的Sql；
●其中要注意的是，数据库的配置中的username和password使用我们安装MySQL数据库时使用的账号名称和密码，url中的3306/紧跟着我们的数据库名称，如果建立的数据库名称不一致，也需要进行修改。
（10）效果展示
通过以上9个步骤，我们从第（1）个步骤程序入口处点击运行按钮，在浏览器中输入相应指令即可得到不同的展示信息：（到这一步，大概知道为啥要使用@MapperScan注解了吧，可以直接将扫描到的包文件交到代理类中，SpringBoot就是很人性化的框架！）
①查询操作：http://localhost:8081/seven/getUser/1
②删除操作：http://localhost:8081/seven/delete?id=14
③Opération de changement : http://localhost:8081/seven/update?id=1&name=小 Maruko&salary=12000
# 🎜🎜 #
#🎜🎜 ##🎜🎜 #⑤Interroger toutes les informations utilisateur : http://localhost:8081/seven/selectAll
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!