Springboot3+JDK17搭建后端学习：从入门到实践指南

Spring Boot 3和JDK 17是构建高效后端应用的理想组合，本文将详细介绍如何搭建和配置开发环境。从安装JDK 17到使用IntelliJ IDEA创建Spring Boot 3项目，每一步都清晰明了。此外，文章还涵盖了Spring Boot的核心特性和自动配置机制，帮助读者快速上手开发。

环境搭建与配置

JDK 17的安装与配置

安装Java开发工具包（JDK）是开始任何Java项目的基础。以下是安装和配置JDK 17的步骤。

1. 下载JDK 17

   访问Java官方网站（https://www.oracle.com/java/technologies/javase-jdk17-downloads.html）或OpenJDK官方页面（https://openjdk.java.net/projects/jdk/17/），根据你的操作系统（Windows、macOS、Linux）选择合适的版本进行下载。

2. 安装JDK 17

   对于Windows，下载安装文件后，运行安装程序，按照提示完成安装。对于macOS和Linux，下载压缩包后，通过终端命令解压并设置环境变量。

   • Windows:

     1. 双击下载的安装文件，选择安装路径。
     2. 选择安装选项，如默认安装或自定义安装。
     3. 点击“安装”按钮，等待安装完成。
     4. 安装完成后，配置环境变量：
        • 打开“控制面板” -> “系统和安全” -> “系统” -> “高级系统设置”。
        • 点击“环境变量”按钮。
        • 在“系统变量”区域，点击“新建”，设置JAVA_HOME为JDK安装路径。
        • 在“系统变量”区域，找到Path变量，点击“编辑”，添加%JAVA_HOME%\bin。
     5. 验证环境变量是否设置成功：
        • 打开命令提示符，输入java -version，显示Java版本信息即代表环境变量配置成功。
   • macOS/Linux:
     1. 解压JDK压缩包到指定目录，例如/usr/lib/jvm/jdk-17。
     2. 设置环境变量：
        • 打开终端，编辑~/.bashrc或~/.zshrc文件，添加以下内容：

          export JAVA_HOME=/usr/lib/jvm/jdk-17
          export PATH=$JAVA_HOME/bin:$PATH

        • 使环境变量生效：

          source ~/.bashrc
          # 或
          source ~/.zshrc

     3. 验证是否安装成功：

        java -version

Spring Boot 3的环境搭建

为了搭建一个基本的Spring Boot 3开发环境，你需要安装IDE（如IntelliJ IDEA）和Maven或Gradle构建工具。

1. 安装IntelliJ IDEA

   访问IntelliJ IDEA官方网站（https://www.jetbrains.com/idea/download/），下载并安装适合你操作系统的版本。

2. 创建Spring Boot项目

   打开IntelliJ IDEA，点击“File” -> “New” -> “Project”，选择“Spring Initializr”。

   • 在弹出的窗口中，选择Spring Boot版本为3.x.x。
   • 选择你的项目类型，如“Java”。
   • 输入项目基本信息，如项目名称、包名和Java版本。
   • 点击“Finish”按钮，等待项目生成。
   • 生成项目后，验证项目是否创建成功：
     • 打开终端（IDEA中可以使用内置终端），切换到项目根目录，运行以下命令：

       mvn -version

     • 如果成功显示Maven版本信息，说明项目创建成功。

Spring Boot 3基础概念

Spring Boot的核心特性

Spring Boot由Spring框架提供，旨在简化Spring应用的开发。以下是Spring Boot的核心特性：

1. 自动配置
   Spring Boot自动配置了许多常用的Spring功能，如数据源、Web服务器、安全设置等。你通常不需要编写大量的配置代码。

2. 独立运行的应用
   Spring Boot允许你创建一个独立运行的应用，可以将应用打包为一个可执行的jar或war文件，包含所有必要的依赖项。

3. 嵌入式服务器
   Spring Boot默认内置了Tomcat、Jetty或Undertow服务器，你无需手动安装和配置Web服务器。

4. Spring Starters
   Spring Boot提供了Spring Starters，它们是一组依赖项集合，可以帮助你快速搭建项目，而无需手动管理每个依赖项。

5. 命令行接口
   Spring Boot提供了一个命令行接口（CLI），可以用来快速创建和运行Spring Boot应用。

自动配置机制简介

Spring Boot使用自动配置机制来简化配置过程。自动配置是通过SpringBootServletInitializer和@SpringBootApplication注解完成的。

• @SpringBootApplication

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

  @SpringBootApplication注解是一个组合注解，包含了以下三个注解：

  • @Configuration: 该类是一个Spring配置类。
  • @EnableAutoConfiguration: 启用自动配置。
  • @ComponentScan: 扫描并注册标记了@Component注解的类。

  通过这三个注解的组合，Spring Boot可以自动配置应用的必要组件。

• SpringBootServletInitializer

  如果你的应用部署在传统的Tomcat或Jetty容器中，你需要继承SpringBootServletInitializer类并重写configure方法：

  public class Application extends SpringBootServletInitializer {
  
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }
  }

  这个类帮助Spring Boot应用在传统的Servlet容器中启动。

创建第一个Spring Boot项目

使用IDEA创建Spring Boot项目

通过IntelliJ IDEA创建一个简单的Spring Boot项目，步骤如下：

1. 打开IDEA
   打开IntelliJ IDEA，点击“File” -> “New” -> “Project”。

2. 选择Spring Initializr
   在弹出的窗口中，选择“Spring Initializr”。

3. 选择项目基本信息

   • 项目类型: 选择“Java”。
   • 语言: 选择“Java”。
   • 依赖: 选择“Web”。
   • Spring Boot版本: 选择3.x.x。
   • 项目名称: 输入项目名称，如“springboot3demo”。
   • 包名: 输入包名，如“com.example.demo”。
4. 完成创建
   点击“Finish”按钮，等待项目生成。

项目构建与启动

创建项目后，你需要配置Maven来构建和运行项目。

1. 构建项目

   打开终端（IDEA中可以使用内置终端），切换到项目根目录，运行以下命令：

   mvn clean install

   这会下载所有必要的依赖项，并构建项目。

2. 运行项目

   构建完成后，项目目录下会生成一个target文件夹，包含一个可执行的jar文件。你可以通过以下命令运行项目：

   java -jar target/springboot3demo-0.0.1-SNAPSHOT.jar

   或者，在IDEA中直接右键点击Application类，选择“Run”。

3. 访问应用

   运行项目后，打开浏览器访问http://localhost:8080，你会看到默认的欢迎页面。

常用注解与配置详解

@Controller, @Service, @Repository, @Component注解的使用

在Spring Boot中，我们经常使用一些注解来定义组件和服务。这些注解包括@Controller, @Service, @Repository, 和@Component。

• @Controller

  @Controller注解用于标记处理HTTP请求的控制器类。通常，控制器类会处理前端请求，并将请求数据传递给相应的服务层。

  @Controller
  public class UserController {
    @GetMapping("/users")
    public String getUserList(Model model) {
        List<User> users = userRepository.findAll();
        model.addAttribute("users", users);
        return "userList";
    }
  }

  上面的代码定义了一个处理/users请求的控制器方法。

• @Service

  @Service注解用于标记业务逻辑层，即服务层。通过这个注解，Spring会自动扫描并注册这个类作为服务组件。

  @Service
  public class UserService {
    @Autowired
    UserRepository userRepository;
  
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
  }

  上面的代码定义了一个UserService类，用于处理与用户相关的业务逻辑。

• @Repository

  @Repository注解用于标记数据访问层，即数据访问对象（DAO）层。通常，这个注解用来标记与数据库交互的类。

  @Repository
  public class UserRepository {
    public List<User> findAll() {
        // 数据库查询逻辑
        return new ArrayList<>();
    }
  }

  上面的代码定义了一个UserRepository类，用于从数据库中查询用户数据。

• @Component

  @Component是一个通用注解，用于标记任何组件，如业务逻辑组件、数据库访问组件等。如果你不想使用特定的@Controller, @Service, 或@Repository注解，可以使用@Component。

  @Component
  public class CommonComponent {
    // 通用组件逻辑
  }

  上面的代码定义了一个通用组件CommonComponent。

属性文件的配置

在Spring Boot中，你可以通过属性文件（如application.properties或application.yml）来配置应用的各种属性。

1. application.properties

   在src/main/resources目录下创建一个application.properties文件，配置应用的各种属性。

   server.port=8080
   spring.datasource.url=jdbc:mysql://localhost:3306/demo
   spring.datasource.username=root
   spring.datasource.password=root
   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

   上面的代码配置了服务器端口、数据源URL、用户名和密码等属性。

2. 读取属性

   在Java代码中，你可以通过@Value注解或@ConfigurationProperties注解来读取属性文件中的配置。

   • @Value

     @Value("${spring.datasource.url}")
     private String dataSourceUrl;

     上面的代码使用@Value注解读取spring.datasource.url属性。

   • @ConfigurationProperties

     @ConfigurationProperties(prefix = "spring.datasource")
     public class DataSourceProperties {
      private String url;
      private String username;
      private String password;
      private String driverClassName;
      // getters and setters
     }

     上面的代码使用@ConfigurationProperties注解读取前缀为spring.datasource的属性。

数据库操作

使用Spring Data JPA进行数据库操作

Spring Data JPA是Spring Data的一部分，用于简化数据访问操作。它通过JPA（Java Persistence API）提供了一组抽象的数据库访问层。

1. 依赖配置

   在pom.xml或build.gradle文件中引入Spring Data JPA的依赖。

   • Maven

     <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
     </dependency>

   • Gradle

     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

2. 配置数据源

   在application.properties或application.yml文件中配置数据源。

   spring.datasource.url=jdbc:mysql://localhost:3306/demo
   spring.datasource.username=root
   spring.datasource.password=root
   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
   spring.jpa.hibernate.ddl-auto=update

3. 实体类定义

   使用JPA注解定义实体类，如User。

   @Entity
   public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      @Column(nullable = false)
      private String name;
      @Column(nullable =.
      private String email;
      // getters and setters
   }

4. Repository接口

   创建一个JPA Repository接口，继承JpaRepository接口，定义基本的CRUD操作。

   public interface UserRepository extends JpaRepository<User, Long> {
      List<User> findByNameContaining(String name);
   }

   上面的代码定义了一个UserRepository接口，继承了JpaRepository接口，并提供了一个自定义的查询方法。

5. Service层

   在Service层中，注入UserRepository并调用其方法。

   @Service
   public class UserService {
      @Autowired
      private UserRepository userRepository;
   
      public List<User> getAllUsers() {
          return userRepository.findAll();
      }
   
      public User getUserById(Long id) {
          return userRepository.findById(id).orElse(null);
      }
   }

6. Controller层

   在Controller层中，调用Service层的方法，并将结果传递给前端。

   @Controller
   public class UserController {
      @Autowired
      private UserService userService;
   
      @GetMapping("/users")
      public String getUserList(Model model) {
          List<User> users = userService.getAllUsers();
          model.addAttribute("users", users);
          return "userList";
      }
   }

7. 单元测试

   在单元测试中，使用@DataJpaTest注解来测试JPA相关的代码。

   @DataJpaTest
   public class UserRepositoryTest {
      @Autowired
      private UserRepository userRepository;
   
      @Test
      public void testFindByNameContaining() {
          User user = new User();
          user.setName("John");
          user.setEmail("john@example.com");
          userRepository.save(user);
   
          List<User> users = userRepository.findByNameContaining("Jo");
          assertEquals(1, users.size());
      }
   }

实现简单的CRUD操作

通过上述步骤，你已经成功地配置了Spring Data JPA并实现了基本的CRUD操作。下面是一个简单的CRUD操作示例。

1. 插入数据

   @Service
   public class UserService {
      @Autowired
      private UserRepository userRepository;
   
      public void addUser(User user) {
          userRepository.save(user);
      }
   }

2. 查询数据

   @Service
   public class UserService {
      @Autowired
      private UserRepository userRepository;
   
      public User getUserById(Long id) {
          return userRepository.findById(id).orElse(null);
      }
   }

3. 更新数据

   @Service
   public class UserService {
      @Autowired
      private UserRepository userRepository;
   
      public void updateUser(User user) {
          userRepository.save(user);
      }
   }

4. 删除数据

   @Service
   public class UserService {
      @Autowired
      private UserRepository userRepository;
   
      public void deleteUser(Long id) {
          userRepository.deleteById(id);
      }
   }

测试与部署

单元测试的编写与执行

单元测试是确保代码质量的重要手段。Spring Boot提供了多种方式来编写单元测试，以下是使用JUnit进行测试的示例。

1. 添加依赖

   在pom.xml或build.gradle文件中添加JUnit依赖。

   • Maven

     <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
     </dependency>

   • Gradle

     testImplementation 'org.springframework.boot:spring-boot-starter-test'

2. 编写测试类

   创建一个测试类，继承SpringBootTest类，并使用@Test注解编写测试方法。

   @SpringBootTest
   public class UserControllerTest {
      @Autowired
      private UserRepository userRepository;
   
      @MockBean
      private UserService userService;
   
      @Test
      public void testGetUserList() {
          List<User> users = new ArrayList<>();
          User user1 = new User();
          user1.setId(1L);
          user1.setName("Alice");
          user1.setEmail("alice@example.com");
          users.add(user1);
   
          User user2 = new User();
          user2.setId(2L);
          user2.setName("Bob");
          user2.setEmail("bob@example.com");
          users.add(user2);
   
          when(userService.getAllUsers()).thenReturn(users);
   
          mockMvc.perform(get("/users"))
                  .andExpect(status().isOk())
                  .andExpect(model().attribute("users", users))
                  .andExpect(view().name("userList"));
      }
   }

3. 运行测试

   在IDEA中，右键点击测试类，选择“Run”。

项目打包与部署到本地服务器

1. 构建项目

   在终端中切换到项目根目录，运行以下命令来构建项目：

   mvn clean package

   这会生成一个可执行的jar文件，位于target目录下。

2. 运行jar文件

   使用以下命令运行生成的jar文件：

   java -jar target/springboot3demo-0.0.1-SNAPSHOT.jar

3. 部署到Tomcat服务器

   如果你希望将应用部署到Tomcat服务器，可以将jar文件转换为war文件。

   • 修改pom.xml

     在pom.xml文件中，将打包方式改为war：

     <packaging>war</packaging>

   • 构建war文件

     运行以下命令构建war文件：

     mvn clean package

   • 部署war文件

     将生成的war文件复制到Tomcat的webapps目录下，Tomcat会自动部署应用。

   • 访问应用

     启动Tomcat服务器后，访问http://localhost:8080/your-app-context-path，即可看到应用。