SpringBoot学习：初学者快速入门指南

本文详细介绍了SpringBoot学习的相关内容，包括SpringBoot的基本概念、主要特性和与Spring的区别。文章还涵盖了环境搭建、第一个SpringBoot项目的创建以及常用注解和项目配置的实战演练。

Spring Boot 是一个由 Spring 团队设计和开发的开源框架，其主要目的是简化新Spring应用的初始搭建以及开发过程。Spring Boot 旨在通过简化配置和依赖注入，使开发者能够更加专注于业务逻辑的实现。

Spring Boot 是 Spring 开源组织下的子项目，其主要目标是简化Spring应用的初始搭建以及开发过程，它能够快速构建独立的基于 Spring 的应用，简化了 Spring 配置的繁琐过程，减少了代码样板，使得开发更加高效。

• 独立运行：基于Spring Boot的应用可以独立运行，无须部署在传统的Web服务器上，如Tomcat、Jetty等。
• 嵌入式Servlet容器：内嵌了Tomcat、Jetty或Undertow，使得应用可以直接运行，无须单独部署容器。
• 自动配置：Spring Boot会根据应用的类路径信息自动配置。
• 简化MVC：简化了Spring MVC的配置。
• 约定优于配置：根据约定，开发人员可以在最少的配置下，实现开发工作。
• 生产就绪：内嵌的Servlet容器，嵌入式数据库，自动配置等特性，使得Spring Boot的应用可以更容易地部署到生产环境中。

环境搭建

开发工具选择

Spring Boot 支持多种开发工具，如 IntelliJ IDEA, Eclipse, 和 Spring Tool Suite (STS)。STS 是专门用于 Spring 应用开发的 IDE，提供了对 Spring Boot 的良好支持，包括自动构建、启动和调试等功能。

Maven/Gradle设置

Spring Boot 支持 Maven 和 Gradle。这里以 Maven 为例进行介绍。Maven 是一个强大的项目管理工具，可以自动管理项目的依赖，编译，打包等。

1. 在 pom.xml 文件中添加 Spring Boot 的依赖，如下所示：

   <dependencies>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
          <version>2.4.1</version>
      </dependency>
   </dependencies>

2. 在 pom.xml 文件中添加 Spring Boot 的插件，如下所示：

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

Java环境配置

确保 Java 环境已安装并配置好。在命令行中输入 java -version，如果显示 Java 版本信息，则表明 Java 环境配置成功。

第一个SpringBoot项目

创建SpringBoot项目

1. 打开 IntelliJ IDEA，选择 "File" -> "New" -> "Project"。
2. 在弹出的窗口中选择 "Spring Initializr"。
3. 在 "Name" 和 "Group" 选项卡中输入项目名称，如 hello-spring-boot 和 com.example。
4. 在 "Dependencies" 选项卡中选择 "Web"。
5. 点击 "Next"，然后点击 "Finish" 完成项目创建。

项目结构介绍

一个典型的 Spring Boot 项目的目录结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── hello
│   │               ├── HelloApplication.java
│   │               └── controller
│   │                   └── HelloController.java
│   └── resources
│       ├── application.properties
│       └── static
└── test
    └── java
        └── com
            └── example
                └── hello
                    └── HelloApplicationTests.java

• src/main/java：存放 Java 源代码。
• src/main/resources：存放应用的配置文件，如 application.properties。
• src/test/java：存放测试用例。

首个Hello World程序

在 HelloApplication.java 中编写启动类，并在 HelloController.java 中编写控制器类。代码如下：

// HelloApplication.java
package com.example.hello;

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

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

// HelloController.java
package com.example.hello.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

SpringBoot常用注解

@SpringBootApplication

@SpringBootApplication 是一个组合注解，相当于 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的集合。它可以将当前类标识为配置类，并启动自动配置和组件扫描。

@RestController

@RestController 是 @Controller 和 @ResponseBody 的组合。@Controller 用于定义控制器类，@ResponseBody 用于将返回值直接写入 HTTP 响应体中。

@Service, @Repository, @Component

• @Service 用于标注服务层，如业务逻辑处理。
• @Repository 用于标注数据访问层，如持久层操作。
• @Component 用于标注通用组件，如工具类。

@Autowired

@Autowired 用于实现依赖注入。Spring 会根据类型或名称自动将对应的 Bean 注入到标注了 @Autowired 的变量中。

项目配置

SpringBoot配置文件

Spring Boot 使用 application.properties 或 application.yml 文件来配置应用。默认的配置文件位于 src/main/resources 目录下。例如：

# application.properties
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# application.yml
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

配置文件的常用配置项

• server.port：设置应用端口。
• spring.datasource.url：数据库连接 URL。
• spring.datasource.username：数据库用户名。
• spring.datasource.password：数据库密码。
• spring.datasource.driver-class-name：数据库驱动类名。
• spring.jpa.hibernate.ddl-auto：设置数据库模式生成策略（如 create、update、none）。
• spring.application.name：应用名称。
• spring.profiles.active：激活的配置文件。

属性注入

在 Spring Boot 中，可以通过 @Value 注解将配置文件中的属性注入到 Java 对象中。例如：

package com.example.hello;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ConfigProperties {
    @Value("${server.port}")
    private int serverPort;

    public int getServerPort() {
        return serverPort;
    }
}

实战演练

创建一个简单的RESTful API

创建一个 RESTful API，用于返回当前时间。首先，在 controller 包下创建一个新的控制器类 TimeController。

package com.example.hello.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;

@RestController
public class TimeController {
    @GetMapping("/time")
    public LocalDateTime currentTime() {
        return LocalDateTime.now();
    }
}

数据库集成（JPA与MyBatis）

接下来，我们将为应用集成数据库。这里以 JPA 为例。

1. 在 pom.xml 文件中添加 JPA 依赖：

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

2. 在 application.properties 文件中配置数据库连接：

   spring.datasource.url=jdbc:mysql://localhost:3306/mydb
   spring.datasource.username=root
   spring.datasource.password=root
   spring.jpa.hibernate.ddl-auto=update

3. 创建一个实体类 User.java：

   package com.example.hello.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
   }

4. 创建一个 UserRepository 接口，继承自 JpaRepository：

   package com.example.hello.repository;
   
   import com.example.hello.model.User;
   import org.springframework.data.jpa.repository.JpaRepository;
   
   public interface UserRepository extends JpaRepository<User, Long> {
   }

5. 创建一个 UserService 类，用于处理与数据库相关的业务逻辑：

   package com.example.hello.service;
   
   import com.example.hello.model.User;
   import com.example.hello.repository.UserRepository;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   
   import java.util.List;
   
   @Service
   public class UserService {
      @Autowired
      private UserRepository userRepository;
   
      public List<User> getAllUsers() {
          return userRepository.findAll();
      }
   
      public User saveUser(User user) {
          return userRepository.save(user);
      }
   }

6. 创建一个 UserController 类，用于处理 RESTful API 请求：

   package com.example.hello.controller;
   
   import com.example.hello.model.User;
   import com.example.hello.service.UserService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.*;
   
   import java.util.List;
   
   @RestController
   @RequestMapping("/users")
   public class UserController {
      @Autowired
      private UserService userService;
   
      @GetMapping
      public List<User> getAllUsers() {
          return userService.getAllUsers();
      }
   
      @PostMapping
      public User saveUser(@RequestBody User user) {
          return userService.saveUser(user);
      }
   }

接下来，我们将展示如何使用 MyBatis 进行数据库集成。

1. 在 pom.xml 文件中添加 MyBatis 依赖：

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

2. 创建一个 MyBatis 配置文件 mybatis-config.xml，并设置 application.properties 中的配置：

   spring.datasource.url=jdbc:mysql://localhost:3306/mydb
   spring.datasource.username=root
   spring.datasource.password=root
   spring.mybatis.config-location=classpath:mybatis-config.xml

3. 创建一个 MyBatis 映射文件 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.hello.mapper.UserMapper">
      <select id="selectUser" resultType="com.example.hello.model.User">
          SELECT * FROM users WHERE id = #{id}
      </select>
   </mapper>

4. 创建一个 MyBatis 映射接口 UserMapper.java：

   package com.example.hello.mapper;
   
   import com.example.hello.model.User;
   import org.apache.ibatis.annotations.Mapper;
   
   @Mapper
   public interface UserMapper {
      User selectUser(Long id);
   }

5. 创建一个 MyBatis 服务类 MybatisService.java：

   package com.example.hello.service;
   
   import com.example.hello.mapper.UserMapper;
   import com.example.hello.model.User;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   
   @Service
   public class MybatisService {
      @Autowired
      private UserMapper userMapper;
   
      public User getUserById(Long id) {
          return userMapper.selectUser(id);
      }
   }

6. 创建一个控制类 MybatisController.java，用于处理 RESTful API 请求：

   package com.example.hello.controller;
   
   import com.example.hello.mapper.UserMapper;
   import com.example.hello.model.User;
   import com.example.hello.service.MybatisService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.*;
   
   @RestController
   @RequestMapping("/mybatis")
   public class MybatisController {
      @Autowired
      private MybatisService mybatisService;
   
      @GetMapping("/{id}")
      public User getUserById(@PathVariable Long id) {
          return mybatisService.getUserById(id);
      }
   }

访问控制（Spring Security）

接下来，我们将为应用集成 Spring Security 进行访问控制。

1. 在 pom.xml 文件中添加 Spring Security 依赖：

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

2. 创建一个 SecurityConfig 类，用于配置 Spring Security：

   package com.example.hello.config;
   
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.security.config.annotation.web.builders.HttpSecurity;
   import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
   import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
   import org.springframework.security.web.SecurityFilterChain;
   
   @Configuration
   @EnableWebSecurity
   public class SecurityConfig {
      @Bean
      public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
          http
                  .authorizeRequests(authorizeRequests ->
                          authorizeRequests
                                  .antMatchers("/", "/home").permitAll()
                                  .anyRequest().authenticated()
                  )
                  .formLogin(formLogin ->
                          formLogin
                                  .loginPage("/login")
                                  .permitAll()
                  )
                  .logout(logout ->
                          logout
                                  .permitAll()
                  );
          return http.build();
      }
   }

3. 创建一个 LoginController 类，用于处理登录请求：

   package com.example.hello.controller;
   
   import org.springframework.stereotype.Controller;
   import org.springframework.web.bind.annotation.GetMapping;
   
   @Controller
   public class LoginController {
      @GetMapping("/login")
      public String login() {
          return "login";
      }
   }

4. 创建一个 index.html 文件，位于 src/main/resources/templates 目录下，用于显示登录页面：

   <!DOCTYPE html>
   <html xmlns:th="http://www.thymeleaf.org">
   <head>
      <title>Spring Boot Security Example</title>
   </head>
   <body>
      <h1>Welcome to Spring Boot Security Example</h1>
      <a th:href="@{/login}">Login</a>
   </body>
   </html>

5. 创建一个 login.html 文件，位于 src/main/resources/templates 目录下，用于显示登录页面：

   <!DOCTYPE html>
   <html xmlns:th="http://www.thymeleaf.org">
   <head>
      <title>Login Page</title>
   </head>
   <body>
      <h1>Login Page</h1>
      <form th:action="@{/login}" method="post">
          <label for="username">Username:</label>
          <input type="text" id="username" name="username" />
          <label for="password">Password:</label>
          <input type="password" id="password" name="password" />
          <input type="submit" value="Login" />
      </form>
   </body>
   </html>

通过以上步骤，我们成功地为 Spring Boot 应用集成了数据库和访问控制。