首页手记 Spring Boot企业级开发教程：从入门到实践

Spring Boot企业级开发教程：从入门到实践

标签：

SpringBoot

本文提供了详细的Spring Boot企业级开发教程，涵盖环境搭建、核心概念、数据库操作、中间件集成、安全与权限管理以及高可用与容错设计等内容。通过本文，开发者可以快速掌握Spring Boot的核心特性和实际应用方法。文章详细介绍了每个步骤和配置方法，帮助开发者构建稳定、高效的企业级应用。希望这篇教程能够成为开发者学习Spring Boot的宝贵资源。

1. Spring Boot简介与环境搭建

1.1 什么是Spring Boot

Spring Boot 是 Spring 框架的一个模块，旨在简化 Spring 应用的初始搭建以及配置过程。它致力于简化基于Spring的应用开发，在Spring框架的基础上提供了大量的自动配置功能，让开发者能够快速地创建独立的、生产级别的应用。Spring Boot 使得开发者不需要编写大量的配置代码，只需要简单的配置即可快速构建出一个功能完备的应用程序。

1.2 开发环境准备

开发 Spring Boot 应用程序通常需要以下环境：

Java 开发工具包 (JDK)：确保安装了 Java 8 或以上版本。
IDE: 推荐使用 IntelliJ IDEA 或 Eclipse。
Maven 或 Gradle: 用于项目构建和依赖管理。
Git: 版本控制系统，用于代码版本管理。

以 Maven 为例，需要配置 Maven 的环境变量，并确保 Maven 已经正确安装。同时，需要在 IDE 中配置 Maven 插件，以便能够直接在 IDE 中构建项目。

1.3 创建第一个Spring Boot项目

使用Spring Initializr创建项目

Spring Initializr 提供了一个快速搭建 Spring Boot 项目的工具，可以在线生成项目骨架。下面以使用 Spring Initializr 创建一个简单的 Spring Boot 项目为例：

访问 Spring Initializr 网站。
选择项目的基本设置，例如：Spring Boot 版本、语言（Java）、依赖（Web）。
输入项目基本信息，如：项目名（demo）、打包类型（jar）等。
点击“Generate”下载项目文件。

使用IDE创建项目

使用 IntelliJ IDEA 创建项目：

打开 IntelliJ IDEA，选择 File -> New -> Project。
在弹出的窗口中，选择 Maven，勾选 Create from archetype。
选择 maven-archetype-quickstart，点击 Next。
输入 GroupId 和 ArtifactId，例如：com.example 和 demo。
填写项目基本信息，点击 Next 和 Finish 完成项目的创建。

创建好项目之后，可以在 pom.xml 文件中添加 Spring Boot 的相关依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.10</version>
</parent>

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

#### 创建主启动类

在 `src/main/java/com/example/demo` 目录下创建一个主启动类 `DemoApplication.java`：

```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);
    }
}

测试运行项目

为了测试项目是否创建成功，可以在 src/main/java/com/example/demo 目录下创建一个简单的控制器类 HelloController.java：

package com.example.demo;

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, World!";
    }
}

然后启动项目，访问 http://localhost:8080/hello，可以看到返回的 Hello, World!，说明项目已经成功运行。

2. Spring Boot核心概念与配置

2.1 Spring Boot自动配置

Spring Boot 自动配置是 Spring Boot 的核心特性之一，它通过一些约定和配置类实现对 Spring 应用程序的自动配置。开发人员只需关注业务逻辑，而无需编写大量配置代码。

例如，如果项目中引入了 spring-boot-starter-web 依赖，Spring Boot 会自动配置相关的 Web 服务器，如 Tomcat。

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

2.2 配置文件详解

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
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

application.yml 示例

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

2.3 依赖管理和打包发布

在 Spring Boot 项目中，依赖管理主要通过 Maven 或 Gradle 实现。例如，通过 Maven 的 pom.xml 文件管理和引入依赖。

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

打包发布也十分简单，只需运行以下 Maven 命令：

mvn clean package

生成的可执行的 jar 文件位于 target 目录下。

3. 数据访问与集成

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

Spring Data JPA 是 Spring Boot 中用于简化数据库操作的一个工具，它基于 JPA 规范，提供了强大的数据访问功能。

创建实体类

首先定义一个实体类 User.java：

package com.example.demo.entity;

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;

    // 省略 getter 和 setter 方法
}

创建仓库接口

接着定义一个仓库接口 UserRepository.java：

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

创建服务类

最后定义一个服务类 UserService.java：

package com.example.demo.service;

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

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

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

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

3.2 集成MyBatis操作数据库

MyBatis 是一个优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。Spring Boot 中集成 MyBatis 主要通过 MyBatis-Spring 项目实现。

添加依赖

在 pom.xml 中添加 MyBatis 相关依赖：

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

配置文件

在 application.properties 文件中添加数据库配置：

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

创建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.demo.mapper.UserMapper">
    <insert id="insertUser" parameterType="com.example.demo.entity.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>

创建接口

定义一个 MyBatis 映射接口 UserMapper.java：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Insert;

@Mapper
public interface UserMapper {
    @Insert("INSERT INTO users (name, email) VALUES (#{name}, #{email})")
    int insertUser(User user);
}

创建服务类

定义一个服务类 UserService.java：

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;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public int saveUser(User user) {
        return userMapper.insertUser(user);
    }
}

3.3 数据库连接池配置

在 application.properties 文件中进行数据库连接池配置：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.maximum-pool-size=10

4. 常用中间件集成

4.1 集成Redis缓存

Redis 是一个高性能的键值对存储系统，常用于缓存、消息队列和数据库等场景。Spring Boot 中集成 Redis 可以使用 spring-boot-starter-data-redis 依赖。

添加依赖

在 pom.xml 中添加 Redis 依赖：

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

配置文件

在 application.properties 文件中添加 Redis 配置：

spring.redis.host=localhost
spring.redis.port=6379

创建缓存服务

定义一个缓存服务类 RedisService.java：

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public void setKeyValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public String getKeyValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

4.2 使用RabbitMQ实现消息队列

RabbitMQ 是一个开源的消息代理和队列服务器，支持多种消息协议，包括 AMQP。Spring Boot 中通过 spring-rabbit 依赖集成 RabbitMQ。

添加依赖

在 pom.xml 中添加 RabbitMQ 依赖：

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

配置文件

在 application.properties 文件中添加 RabbitMQ 配置：

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

创建消息队列

定义一个消息消费者类 MessageReceiver.java：

package com.example.demo.rabbitmq;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageReceiver {
    @RabbitListener(queues = "myQueue")
    public void receiveMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

定义一个消息生产者类 MessageSender.java：

package com.example.demo.rabbitmq;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MessageSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend("myQueue", message);
    }
}

4.3 集成Elasticsearch进行全文搜索

Elasticsearch 是一个分布式的搜索和分析引擎，基于 Lucene，可以用于全文搜索。Spring Boot 中通过 spring-data-elasticsearch 依赖集成 Elasticsearch。

添加依赖

在 pom.xml 中添加 Elasticsearch 依赖：

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

配置文件

在 application.properties 文件中添加 Elasticsearch 配置：

spring.elasticsearch.rest.uris=http://localhost:9200

创建索引实体

定义一个索引实体类 Product.java：

package com.example.demo.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

@Document(indexName = "products", type = "product")
public class Product {
    @Id
    private String id;
    @Field(type = FieldType.text)
    private String name;
    @Field(type = FieldType.text)
    private String description;

    // 省略 getter 和 setter 方法
}

创建索引仓库

定义一个索引仓库接口 ProductRepository.java：

package com.example.demo.repository;

import com.example.demo.entity.Product;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

public interface ProductRepository extends ElasticsearchRepository<Product, String> {
}

创建搜索服务

定义一个搜索服务类 ProductService.java：

package com.example.demo.service;

import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;

    public List<Product> searchProducts(String keyword) {
        return productRepository.search(keyword);
    }
}

5. 企业级安全与权限管理

5.1 实现基本的用户认证与授权

Spring Boot 提供了 spring-boot-starter-security 依赖来实现用户认证与授权。

添加依赖

在 pom.xml 中添加安全依赖：

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

配置文件

在 application.properties 文件中添加安全配置：

spring.security.user.name=admin
spring.security.user.password=admin

创建认证配置

定义一个认证配置类 SecurityConfig.java：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("admin")
            .password("{noop}admin")
            .roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN")
            .and().formLogin()
            .and().csrf().disable();
    }

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

5.2 使用JWT进行安全Token管理

JWT (JSON Web Tokens) 是一种开放标准 (RFC 7519)，它定义了一种紧凑且自包含的格式，用于在各方之间安全地传输信息。Spring Boot 中可以使用 jjwt 依赖来实现 JWT 令牌管理。

添加依赖

在 pom.xml 中添加 JWT 依赖：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

创建Token工具类

定义一个生成和验证令牌的工具类 JwtTokenUtil.java：

package com.example.demo.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class JwtTokenUtil {
    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";

    @Value("${jwt.secret}")
    private String secret;

    @Value("${jwt.expiration}")
    private Long expiration;

    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
        return claims.getSubject();
    }

    public Date getCreatedDateFromToken(String token) {
        Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
        return claims.getIssuedAt();
    }

    public Date getExpirationDateFromToken(String token) {
        Claims claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
        return claims.getExpiration();
    }

    public String generateToken(String username) {
        return Jwts.builder().setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + expiration))
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    public boolean isTokenExpired(String token) {
        Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
}

创建认证过滤器

定义一个认证过滤器类 JwtAuthenticationFilter.java：

package com.example.demo.security;

import com.example.demo.utils.JwtTokenUtil;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
    private JwtTokenUtil jwtTokenUtil;

    public JwtAuthenticationFilter(AuthenticationManager authManager, JwtTokenUtil jwtTokenUtil) {
        super("/api/**");
        this.jwtTokenUtil = jwtTokenUtil;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
        String token = request.getHeader("Authorization");
        if (token != null) {
            String username = jwtTokenUtil.getUsernameFromToken(token);
            return getAuthenticationManager().authenticate(new JwtAuthenticationToken(username, token));
        }
        return null;
    }

    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        SecurityContextHolder.getContext().setAuthentication(authResult);
        chain.doFilter(request, response);
    }
}

创建认证提供者

定义一个认证提供者类 JwtAuthenticationProvider.java：

package com.example.demo.security;

import com.example.demo.utils.JwtTokenUtil;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;

public class JwtAuthenticationProvider implements AuthenticationProvider {
    private JwtTokenUtil jwtTokenUtil;
    private UserDetailsService userDetailsService;

    public JwtAuthenticationProvider(JwtTokenUtil jwtTokenUtil, UserDetailsService userDetailsService) {
        this.jwtTokenUtil = jwtTokenUtil;
        this.userDetailsService = userDetailsService;
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        String token = authentication.getCredentials().toString();
        if (jwtTokenUtil.isTokenExpired(token)) {
            throw new BadCredentialsException("Token expired");
        }
        String username = jwtTokenUtil.getUsernameFromToken(token);
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        return new JwtAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities(), token);
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return JwtAuthenticationToken.class.isAssignableFrom(authentication);
    }
}

5.3 接口访问控制

定义一个访问控制配置类 SecurityConfig.java：

package com.example.demo.config;

import com.example.demo.security.JwtAuthenticationFilter;
import com.example.demo.security.JwtAuthenticationProvider;
import com.example.demo.utils.JwtTokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("admin")
            .password("admin")
            .roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .sessionManagement()
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager(), jwtTokenUtil))
            .addFilter(new JwtAuthenticationProvider(authenticationManager(), jwtTokenUtil))
            .authorizeRequests()
            .antMatchers("/api/admin/**").hasRole("ADMIN")
            .and().httpBasic();
    }

    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

用户登录接口示例

定义一个用户登录接口类 AuthenticationController.java：

package com.example.demo.controller;

import com.example.demo.utils.JwtTokenUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
public class AuthenticationController {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtTokenUtil jwtTokenUtil;

    @PostMapping("/login")
    public Map<String, String> login(@RequestBody Map<String, String> loginRequest) {
        UserDetails userDetails = userDetailsService.loadUserByUsername(loginRequest.get("username"));
        authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(loginRequest.get("username"), loginRequest.get("password")));
        String token = jwtTokenUtil.generateToken(userDetails.getUsername());
        Map<String, String> tokenResponse = new HashMap<>();
        tokenResponse.put("token", token);
        return tokenResponse;
    }
}

6. 高可用与容错设计

6.1 使用Spring Boot实现服务熔断与降级

Spring Boot 中可以通过 spring-cloud-starter-circuitbreaker-resilience4j 依赖来实现服务熔断和降级。

添加依赖

在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
   .  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.0</version>
</dependency>

配置文件

在 application.properties 文件中添加熔断配置：

resilience4j.circuitbreaker.instances.default.max-failures=5
resilience4j.circuitbreaker.instances.default.slow-call-duration-threshold=1000
resilience4j.circuitbreaker.instances.default.waiting-state-duration=5000

创建熔断服务

定义一个熔断服务类 ServiceWithCircuitBreaker.java：

package com.example.demo.service;

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ServiceWithCircuitBreaker {
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;

    public String callService() {
        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("myService");
        try {
            return circuitBreaker.executeSupplier(() -> {
                // 调用外部服务
                return "Service Result";
            });
        } catch (Exception e) {
            return "Service Error";
        }
    }
}

6.2 接口限流与异常监控

接口限流

Spring Boot 中可以通过 spring-cloud-starter-gateway 依赖来实现接口限流。

添加依赖

在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

配置文件

在 application.yml 文件中添加限流配置：

spring:
  cloud:
  gateway:
    routes:
    - id: limit-rate
      uri: http://localhost:8080
      predicates:
      - Path=/api/**
      filters:
      - name: RequestRateLimiter
        args:
          key-resolver: "#{@userKeyResolver}"
          redis-rate-limiter.request-factor: 10
          redis-rate-limiter.burst-size: 20

定义一个限流器解析器 UserKeyResolver.java：

package com.example.demo.resolver;

import org.springframework.cloud.gateway.route.to.KeyResolver;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Mono;

@Component
public class UserKeyResolver implements KeyResolver {
    @Override
    public Mono<String> resolve(Mono<String> request) {
        return request.map(uri -> "user_" + uri.toOpaque());
    }
}

异常监控

使用 spring-boot-starter-actuator 依赖来实现异常监控。

添加依赖

在 pom.xml 中添加依赖：

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

配置文件

在 application.properties 文件中添加监控配置：

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

示例代码

定义一个全局异常处理器 GlobalExceptionHandler.java：

package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ResponseBody
    public String handleException(Exception e) {
        return "Internal Server Error";
    }
}

6.3 日志管理与异常处理

日志管理

Spring Boot 通过 spring-boot-starter-logging 依赖提供日志功能，通常使用 logback 作为默认的日志框架。

添加依赖

在 pom.xml 中添加依赖：

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

配置文件

在 logback-spring.xml 文件中配置日志：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

日志使用场景

定义一个简单的服务类 UserService.java，展示如何记录日志：

package com.example.demo.service;

import com.example.demo.entity.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    @Autowired
    private UserRepository userRepository;

    public User saveUser(User user) {
        logger.info("Saving user: {}", user.getName());
        return userRepository.save(user);
    }

    public User getUserById(Long id) {
        logger.info("Fetching user with ID: {}", id);
        return userRepository.findById(id).orElse(null);
    }
}

通过以上步骤，可以实现 Spring Boot 企业级应用开发的基础功能，包括数据库操作、中间件集成、安全与权限管理、高可用与容错设计等。希望这篇教程能够帮助开发者快速掌握 Spring Boot 的核心概念和技术实践。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

呼如林

手记
篇

粉丝

103

获赞与收藏

363

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30948 346

网络编程入门教程

20个小节 12735 240

Pandas 入门教程

25个小节 18632 342

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Spring Boot企业级开发教程：从入门到实践

1.1 什么是Spring Boot

1.2 开发环境准备

1.3 创建第一个Spring Boot项目

使用Spring Initializr创建项目

使用IDE创建项目

测试运行项目

2.1 Spring Boot自动配置

2.2 配置文件详解

application.properties 示例

application.yml 示例

2.3 依赖管理和打包发布

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

创建实体类

创建仓库接口

创建服务类

3.2 集成MyBatis操作数据库

添加依赖

配置文件

创建MyBatis映射

创建接口

创建服务类

3.3 数据库连接池配置

4.1 集成Redis缓存

添加依赖

配置文件

创建缓存服务

4.2 使用RabbitMQ实现消息队列

添加依赖

配置文件

创建消息队列

4.3 集成Elasticsearch进行全文搜索

添加依赖

配置文件

创建索引实体

创建索引仓库

创建搜索服务

5.1 实现基本的用户认证与授权

添加依赖

配置文件

创建认证配置

5.2 使用JWT进行安全Token管理

添加依赖

创建Token工具类

创建认证过滤器

创建认证提供者

5.3 接口访问控制

用户登录接口示例

6.1 使用Spring Boot实现服务熔断与降级

添加依赖

配置文件

创建熔断服务

6.2 接口限流与异常监控

接口限流

添加依赖

配置文件

异常监控

添加依赖

配置文件

示例代码

6.3 日志管理与异常处理

日志管理

添加依赖

配置文件

日志使用场景

阅读免费教程