一个详细的Java后端案例，附带详细的代码讲解，助力后端大军！！！

编程星辰海

已于 2024-11-07 13:01:04 修改

阅读量1k

点赞数 11

分类专栏： # 后端 Java 文章标签： java 开发语言 spring 后端 spring boot

于 2024-11-07 12:57:49 首次发布

本文链接：https://blog.csdn.net/speaking_me/article/details/143591356

版权

Java 同时被 2 个专栏收录

14 篇文章

订阅专栏

后端

11 篇文章

订阅专栏

先给大家写清楚这个案例用了什么知识点

1. Spring Boot

Spring Boot 是一个用于创建微服务和独立应用程序的框架，它简化了基于 Spring 的应用开发。Spring Boot 的主要特点包括：

自动配置：根据添加的依赖自动配置 Spring 应用。
嵌入式服务器：内置 Tomcat、Jetty 或 Undertow 服务器，无需外部部署。
起步依赖：通过 spring-boot-starter-* 依赖简化依赖管理。

2. Maven

Maven 是一个项目管理和构建工具，它使用 XML 文件（pom.xml）来描述项目和配置构建过程。在这个案例中，pom.xml 文件定义了项目的依赖和构建配置。

3. H2 数据库

H2 是一个轻量级的关系型数据库管理系统，支持内存模式和磁盘模式。在这个案例中，我们使用 H2 作为内存数据库，方便快速开发和测试。

4. Spring Data JPA

Spring Data JPA 是 Spring Data 的一部分，用于简化数据访问层的开发。它提供了许多接口和注解，使得与数据库的交互更加简单和高效。

5. 实体类（Entity）

实体类 是表示数据库表的对象，通常使用 @Entity 注解标记。在这个案例中，User 类是一个实体类，表示 users 表。

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

6. 仓库接口（Repository）

仓库接口 是用于数据访问的接口，通常继承自 JpaRepository。在这个案例中，UserRepository 接口提供了对 User 实体的基本 CRUD 操作。

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

7. 服务层（Service）

服务层 是业务逻辑的处理层，通常包含对数据的处理和业务规则的实现。在这个案例中，UserService 类提供了对用户数据的操作方法。

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User user) {
        if (userRepository.existsById(id)) {
            user.setId(id);
            return userRepository.save(user);
        }
        return null;
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

8. 控制器层（Controller）

控制器层 是处理 HTTP 请求的层，通常使用 @RestController 注解标记。在这个案例中，UserController 类处理对用户的 CRUD 请求。

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userService.getUserById(id);
        if (user.isPresent()) {
            return ResponseEntity.ok(user.get());
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        User updatedUser = userService.updateUser(id, user);
        if (updatedUser != null) {
            return ResponseEntity.ok(updatedUser);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

9. 注解

注解是用于提供元数据的工具，Spring Boot 中常用的注解包括：

@SpringBootApplication：组合了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解。
@Entity：标记一个类为实体类。
@Id：标记实体类中的主键字段。
@GeneratedValue：指定主键的生成策略。
@Repository：标记一个类为数据访问层的组件。
@Service：标记一个类为业务逻辑层的组件。
@RestController：标记一个类为控制器层的组件。
@RequestMapping：映射 HTTP 请求到处理方法。
@GetMapping、@PostMapping、@PutMapping、@DeleteMapping：分别映射 GET、POST、PUT、DELETE 请求。
@PathVariable：提取 URL 路径中的变量。
@RequestBody：将请求体中的 JSON 数据绑定到方法参数。

10. 配置文件（application.properties）

配置文件 用于配置应用程序的各种属性，如数据库连接信息、服务器端口等。在这个案例中，application.properties 文件配置了 H2 数据库的连接信息。

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

11. 响应状态码

响应状态码 用于指示 HTTP 请求的结果。在这个案例中，我们使用 ResponseEntity 类来返回带有状态码的响应。

12. H2 控制台

H2 控制台 是一个 Web 界面，用于查看和操作 H2 数据库。通过配置 application.properties 文件中的 spring.h2.console.enabled=true 和 spring.h2.console.path=/h2-console，可以在浏览器中访问 H2 控制台。

这个案例涵盖了 Spring Boot 开发中的多个重要知识点和技术，包括项目结构、依赖管理、数据库配置、实体类、仓库接口、服务层、控制器层、注解、配置文件和响应状态码等。

下面就是这个简单的 Java 后端案例，展示如何使用 Spring Boot 构建一个 RESTful API，实现对用户的 CRUD（创建、读取、更新、删除）操作。

我们将使用 Spring Boot、Spring Data JPA 和 H2 数据库来完成这个示例。

项目结构

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── demo/
│   │   │               ├── DemoApplication.java
│   │   │               ├── controller/
│   │   │               │   └── UserController.java
│   │   │               ├── model/
│   │   │               │   └── User.java
│   │   │               ├── repository/
│   │   │               │   └── UserRepository.java
│   │   │               └── service/
│   │   │                   └── UserService.java
│   │   └── resources/
│   │       └── application.properties
└── pom.xml

1. 创建 Maven 项目

首先，我们需要创建一个 Maven 项目。在项目根目录下创建 pom.xml 文件：

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. 配置应用属性

在 src/main/resources 目录下创建 application.properties 文件，配置数据库连接：

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

3. 创建主应用类

在 src/main/java/com/example/demo 目录下创建 DemoApplication.java 文件：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

4. 创建用户模型

在 src/main/java/com/example/demo/model 目录下创建 User.java 文件：

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // Getters and Setters
    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 String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

5. 创建用户仓库

在 src/main/java/com/example/demo/repository 目录下创建 UserRepository.java 文件：

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

6. 创建用户服务

在 src/main/java/com/example/demo/service 目录下创建 UserService.java 文件：

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User user) {
        if (userRepository.existsById(id)) {
            user.setId(id);
            return userRepository.save(user);
        }
        return null;
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

7. 创建用户控制器

在 src/main/java/com/example/demo/controller 目录下创建 UserController.java 文件：

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        Optional<User> user = userService.getUserById(id);
        if (user.isPresent()) {
            return ResponseEntity.ok(user.get());
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        User updatedUser = userService.updateUser(id, user);
        if (updatedUser != null) {
            return ResponseEntity.ok(updatedUser);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

8. 运行应用

在命令行中导航到项目根目录，运行以下命令启动应用：

mvn spring-boot:run

9. 测试 API

你可以使用 Postman 或 curl 来测试 API。以下是一些示例请求：

获取所有用户：

curl -X GET http://localhost:8080/api/users

获取单个用户：

curl -X GET http://localhost:8080/api/users/{id}

创建用户：

curl -X POST http://localhost:8080/api/users -H "Content-Type: application/json" -d '{"name": "John Doe", "email": "john@example.com"}'

更新用户：

curl -X PUT http://localhost:8080/api/users/{id} -H "Content-Type: application/json" -d '{"name": "Jane Doe", "email": "jane@example.com"}'

删除用户：

curl -X DELETE http://localhost:8080/api/users/{id}

10. 访问 H2 控制台

你可以在浏览器中访问http:// http://localhost:8080/h2-console 来查看和操作 H2 数据库。