IDEA(2024版)如何实现Spring Boot的增删改查

于由城南蝈蝈发布

本文使用的工具及其版本：

IDEA 2024.1 、jdk 1.8 、maven 3.6.3 mysql 8.x

本文源代码在文章末尾。

0.创建Spring Boot项目

创建Spring Boot项目可以参考下面的文章：

IDEA 2024版如何创建Spring Boot项目 – 每天进步一点点

也可以根据下面的流程进行创建。

点击“文件—>新建—>项目”

Server URL: 这里建议使用 https://start.aliyun.com/，否则后面的Java选项很可能没有8版本。
Name：项目名称。
Location：项目的存放位置。
Language：开发语言，一般选择Java。
Type：创建项目的方式，一般选择Maven。
JDK：一般使用JDK1.8。
Java：这里选择8版本。
Packaging：项目打包方式，一般选择Jar。

然后点击“下一步”

然后点击“下一步”

我们选择Spring Boot的版本，如果java选择的是1.8，这个地方选择SpringBoot的版本要是2.x版本

如果SpringBoot 3.x版本，JDK要17以上，否则会报错。

我们勾选“Spring Web”

然后点击“创建”。

然后等待Maven构建项目即可（一定要配置好Maven，否则构建失败）

构建完毕后，找到启动类，点击启动，就可以看到给定的默认的项目启动了

这个版本默认给我们集成了很多接口访问，比如下面这个

浏览器中访问

http://127.0.0.1:8080/user

就可以看到返回json格式的数据了

这个过程中如果出现一些报错，可以参考下面的文章进行解决。

IDEA配置maven主目录(maven home)不生效

Project ‘org.springframework.boot:spring-boot-starter-parent:2.7.7’ not found

我们做增删改查不需要demos这个文件夹，右击“demos”文件夹，直接删除就行。

1.添加依赖

打开项目的pom.xml文件

修改后的pom文件如下：

相关pom文件参考如下：

<?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>
    <groupId>com.guo</groupId>
    <artifactId>demo18</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo18</name>
    <description>demo18</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- mysql  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.guo.demo.Demo18Application</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
2.数据库脚本

设计一个数据表，表名为students，sql语句参考如下


-- 创建数据库
CREATE DATABASE IF NOT EXISTS `ssm`; 
-- 使用数据库
USE `ssm`;
-- 创建学生表
CREATE TABLE student (
    id BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '学生ID',
    name VARCHAR(50) NOT NULL COMMENT '学生姓名',
    age INT NOT NULL COMMENT '学生年龄',
    gender VARCHAR(10) NOT NULL COMMENT '学生性别',
    student_no VARCHAR(20) UNIQUE NOT NULL COMMENT '学号',
    major VARCHAR(50) COMMENT '专业',
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='学生信息表';

-- 插入测试数据
INSERT INTO student (name, age, gender, student_no, major) VALUES
('张三', 20, '男', '2023001', '计算机科学'),
('李四', 19, '女', '2023002', '软件工程'),
('王五', 21, '男', '2023003', '电子信息');

我们在navicat中执行这个sql脚本

3.创建实体类

创建的完sql后，我们开始创建实体类

右击demo文件夹，选择New—>软件包

软件包的名字输入com.guo.demo.domain

右击domain文件夹，选择New—>Java类

实体类名是Student

Student类代码如下：

package com.guo.demo.domain;

import java.util.Date;

public class Student {
    private Long id;
    private String name;
    private Integer age;
    private String gender;
    private String studentNo;
    private String major;
    private Date createTime;
    private Date updateTime;
    public Long getId() {return id;}
    public void setId(Long 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;}
    public String getGender() {return gender;}
    public void setGender(String gender) {this.gender = gender;}
    public String getStudentNo() {return studentNo;}
    public void setStudentNo(String studentNo) {this.studentNo = studentNo;}
    public String getMajor() {return major;}
    public void setMajor(String major) {this.major = major;}
    public Date getCreateTime() {return createTime;}
    public void setCreateTime(Date createTime) {this.createTime = createTime;}
    public Date getUpdateTime() {return updateTime;}
    public void setUpdateTime(Date updateTime) {this.updateTime = updateTime;}
}

添加后如下：

这样实体类创建完毕

4.Mapper层创建

有的地方会写DAO层，这里我们用的是MyBatis，所以就叫mapper了

右击demo文件夹，选择New—>

这个地方的包名是com.guo.demo.mapper

继续右击mapper文件夹，选择New—>Java类

这个地方的名字叫StudentMapper

参考代码如下：

package com.guo.demo.mapper;

import com.guo.demo.domain.Student;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface StudentMapper {

    // 查询所有学生
    List<Student> selectAll();

    // 根据ID查询学生
    Student selectById(Long id);

    // 根据学号查询学生（用于判断学号是否重复）
    Student selectByStudentNo(String studentNo);

    // 新增学生
    int insert(Student student);

    // 更新学生
    int update(Student student);

    // 删除学生
    int deleteById(Long id);
}
3.Mapper映射文件（XML）

右击resources文件夹，选择New—>目录

这个地方的文件夹名写 mapper

右击mapper文件夹，注意是resources目录下的，不要选错，

选择New—>File

文件的名字为StudengMapper.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接口的全类名 -->
<mapper namespace="com.guo.demo.mapper.StudentMapper">
    <!-- 通用结果集映射（解决数据库字段与实体类属性名映射问题） -->
    <resultMap id="BaseResultMap" type="com.guo.demo.domain.Student">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
        <result column="gender" property="gender"/>
        <result column="student_no" property="studentNo"/>  <!-- 数据库字段student_no映射到实体类studentNo -->
        <result column="major" property="major"/>
        <result column="create_time" property="createTime"/>
        <result column="update_time" property="updateTime"/>
    </resultMap>
    <!-- 查询所有学生 -->
    <select id="selectAll" resultMap="BaseResultMap">
        SELECT * FROM student ORDER BY id DESC
    </select>
    <!-- 根据ID查询学生 -->
    <select id="selectById" parameterType="java.lang.Long" resultMap="BaseResultMap">
        SELECT * FROM student WHERE id = #{id}
    </select>
    <!-- 根据学号查询学生 -->
    <select id="selectByStudentNo" parameterType="java.lang.String" resultMap="BaseResultMap">
        SELECT * FROM student WHERE student_no = #{studentNo}
    </select>
    <!-- 新增学生 -->
    <insert id="insert" parameterType="com.guo.demo.domain.Student" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO student (
            name, age, gender, student_no, major
        ) VALUES (
                     #{name}, #{age}, #{gender}, #{studentNo}, #{major}
                 )
    </insert>
    <!-- 更新学生 -->
    <update id="update" parameterType="com.guo.demo.domain.Student">
        UPDATE student SET
                           name = #{name},
                           age = #{age},
                           gender = #{gender},
                           student_no = #{studentNo},
                           major = #{major}
        WHERE id = #{id}
    </update>
    <!-- 删除学生 -->
    <delete id="deleteById" parameterType="java.lang.Long">
        DELETE FROM student WHERE id = #{id}
    </delete>

</mapper>

到此，mapper层搭建完毕。

4.编写Service层

右击demo文件夹，选择New—>软件包

这里的包名是 com.guo.demo.service

继续右击service文件夹，选择New—>Java类

这个地方选择的是接口，接口名称是StudentService

StudentService中代码参考如下：

package com.guo.demo.service;

import com.guo.demo.domain.Student;
import java.util.List;

@Service
public interface StudentService {
    List<Student> getAllStudents();
    Student getStudentById(Long id);
    Student createStudent(Student student);
    Student updateStudent(Long id, Student student);
    void deleteStudent(Long id);
}

上图的代码丢了一个@Service注解，下面已经补充上。

然后继续创建接口的接口的实现层。

右击service层，选择New—>软件包

这里的包名是com.guo.demo.service.impl

这里面主要是实现接口，并调用mapper层

右击impl文件夹，选择New—>Java类

这里选的是类，类名是StudentServiceImpl

参考代码如下：

package com.guo.demo.service.impl;

import com.guo.demo.domain.Student;
import com.guo.demo.mapper.StudentMapper;
import com.guo.demo.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class StudentServiceImpl implements StudentService {
    @Autowired
    private  StudentMapper studentMapper;

    @Override
    public List<Student> getAllStudents() {
        return studentMapper.selectAll();
    }
    @Override
    public Student getStudentById(Long id) {
        Student student = studentMapper.selectById(id);
        return student;
    }
    @Override
    public Student createStudent(Student student) {
        // 插入数据库
        studentMapper.insert(student);
        return studentMapper.selectById(student.getId());
    }
    @Override
    public Student updateStudent(Long id, Student student) {
        // 执行更新
        studentMapper.update(student);
        return studentMapper.selectById(id);
    }
    @Override
    public void deleteStudent(Long id) {
        studentMapper.deleteById(id);
    }
}

界面如下：

service层搭建完毕

5.编写Controller层

右击demo文件夹，选择New—>软件包

软件包名写com.guo.demo.controller

创建完了后，继续右击controller文件夹，选择New—>Java类

类名是StudentController

参考代码如下：

package com.guo.demo.controller;

import com.guo.demo.domain.Student;
import com.guo.demo.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/students")
public class StudentController {
    @Autowired
    private StudentService studentService;
    // 获取所有学生
    @GetMapping
    public List<Student> getAllStudents() {
        return studentService.getAllStudents();
    }
    // 根据ID获取学生
    @GetMapping("/{id}")
    public Student getStudentById(@PathVariable Long id) {
        return studentService.getStudentById(id);
    }
    // 创建学生
    @PostMapping
    public Student createStudent(@RequestBody Student student) {
        return studentService.createStudent(student);
    }
    // 更新学生
    @PutMapping("/{id}")
    public Student updateStudent(@PathVariable Long id, @RequestBody Student student) {
        return studentService.updateStudent(id, student);
    }
    // 删除学生
    @DeleteMapping("/{id}")
    public void deleteStudent(@PathVariable Long id) {
        studentService.deleteStudent(id);
    }
}

添加完了后项目结构参考如下图：

6.修改启动类

我们找到启动类，在启动类中加入MapperScan注解，扫描Mapper接口

package com.guo.demo;

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

@SpringBootApplication
@MapperScan("com.guo.demo.mapper")  // 扫描MyBatis的Mapper接口
public class Demo18Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo18Application.class, args);
    }
}
7.修改配置文件

上面修改完了，我们要修改配置文件，

在spring boot中，properties这种文件用的少，所以直接删除，然后创建新的配置文件

右击resources文件夹，选择 新建—>文件

文件的名字写application.yml

内容参考如下：

server:
  port: 8082

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

# mybaits配置
mybatis:
  # 配置mapper的扫描，找到所有的mapper.xml映射文件
  mapper-locations: classpath*:mapper/**/*Mapper.xml
  # 搜索指定包别名
  type-aliases-package: com.guo.demo.demain

注意对应关系，一定不要写错

8.运行测试

（1）查询所有

接口地址：http://localhost:8082/api/students/

（2）查询id为3的学生信息

接口信息：http://localhost:8082/api/students/3

（3）新增一个学生

请求类型是POST，

请求地址是：http://localhost:8082/api/students/

请求参数参考下面的，

为什么参数是这样，因为根据设计的SQL，id是自增的，create_time和update_time也是数据库自己写的，此处没有必要传入。

{
    "name": "锅巴",
    "age": 1,
    "gender": "男",
    "studentNo": "101",
    "major": "汽修"
}

效果如下

（4）修改一个学生

接口地址：http://localhost:8082/api/students/5

请求方式：PUT

接口参数

{
    "name": "锅巴",
    "age": 1,
    "gender": "男",
    "studentNo": "101",
    "major": "汽修"
}

它的逻辑是根据传入的id进行修改，把修改完的数据返回。

效果如下：

（5）删除一个学生

我们把刚才创建的学生删除，然后查询所有学生看一下是否都删除了

接口地址：http://localhost:8082/api/students/5

请求方式：DELETE

效果如下：

完结撒花~~~

9.后记

其实上面的并不算特别完善，比如要带有一定的提示，此处是直接返回的json数据，实际开发中一般要对这些数据进行封装，加入状态码等操作。

本文源代码下载链接：(访问密码: 7381)

https://url47.ctfile.com/f/64055047-8458821623-5c39be?p=7381

Post Views: 60

Related posts:

  1. SpringBoot实现简单的增删改查(CURD)
  2. JAVA中DateTime如何获取当前时间是天的多少秒。getSecondOfDay的用法。
  3. pom文件中各个标签的含义
  4. Spring Boot集成工作流activiti(1)—基础模块创建
  5. spring boot自定义注解(1)—实现自定义操作日志注解
  6. springboot如何使用mybatis-plus
分类： java开发与创造
标签：

相关文章

开发与创造

Nix 入门：为什么说它是开发者和运维的终极利器？

你可能曾经历过这些令人抓狂的时刻： “在我的机器上明明是好的！”—— 阅读更多…

java

Spring MVC数据绑定和响应(JSON数据绑定)

0.前言 本文主要演示Spring MVC项目中的JSON数据绑定操作 阅读更多…

开发与创造

若依(ruoyi)RuoYiApp版—路由

UniApp 的路由系统是其核心特性之一，它基于页面栈的概念进行管理， 阅读更多…