Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障

这篇具有很好参考价值的文章主要介绍了Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器


Pre

Spring Boot - 利用Resilience4j-RateLimiter进行流量控制和服务降级


Resilience4j概述

Resilience4J 是一个针对 Java 8 应用程序的轻量级容错和弹性库。它设计用于在分布式系统中的服务之间提供弹性和容错性。Resilience4J 的名字来源于它提供的核心功能,即让系统(服务)能够“弹性”(resilient)地应对各种失败情况,包括网络问题、第三方服务故障等。

Resilience4J 提供了以下功能:

  1. 断路器(Circuit Breaker):当检测到服务异常或超时,断路器会打开,阻止进一步的请求发送到该服务。一段时间后(通常是秒级),断路器会进入半开状态,允许一个测试请求通过以检查服务是否恢复。如果请求成功,断路器关闭;如果失败,断路器会再次打开。
  2. 限流(Rate Limiter):限制进入系统的请求速率,防止系统过载。这可以通过令牌桶算法或滑动窗口算法实现。
  3. 隔离(Isolation):通过信号量或线程池隔离不同的服务调用,防止一个服务的失败影响到其他服务。
  4. 超时(Timeouts):为服务调用设置超时时间,超过时间后会触发超时异常。
  5. 重试(Retry):在遇到特定异常时自动重试服务调用,可以配置重试次数和间隔。
  6. 缓存(Caching):提供缓存机制,以避免重复执行计算密集型或远程调用。

Resilience4J 的一大特点是它的轻量级特性,它只使用了 Vavr 库(一个函数式编程库),没有其他外部库依赖。这使得它在集成到现有系统时非常方便,且性能开销小。

Resilience4J 设计上易于配置,支持通过代码、配置文件或运行时参数进行配置。它也支持通过 actuator 模块与 Spring Boot 的监控和管理特性集成。

由于 Resilience4J 的这些特性和优势,它在现代分布式系统和微服务架构中得到了广泛应用,尤其是在需要高可用性和弹性的环境中。


Resilience4j官方地址

https://resilience4j.readme.io/

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

https://github.com/resilience4j/resilience4j

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器


Resilience4j-Circuitbreaker

Resilience4j中的CircuitBreaker是一个核心工具,用于保护分布式系统免受故障的影响。

其工作原理主要通过一个有限状态机实现,包括CLOSED(关闭)、OPEN(打开)和HALF-OPEN(半开)三种状态。

Resilience4j 是一个为Java 8和函数式编程设计的轻量级容错库。它的主要目的是帮助开发者在分布式系统中实现弹性和容错性。

Resilience4j 提供了多种容错机制,包括断路器(CircuitBreaker)、限流器(RateLimiter)、重试(Retry)、隔离策略(Bulkhead)和超时控制(TimeLimiter)等。其中,CircuitBreaker 是 Resilience4j 的一个重要组成部分。

CircuitBreaker,即断路器,其设计原理来源于电路中的断路器,当电流超过设定值时,断路器会自动断开,以保护电路免受过大电流的损害。在软件系统中,断路器用于保护系统免受某个组件或服务故障的影响。

Resilience4j 的 CircuitBreaker 实现原理如下:

  1. 断路器的状态:CircuitBreaker 具有三种正常状态:CLOSED(关闭)、OPEN(打开)和 HALFOPEN(半开),以及两个特殊状态:DISABLED(禁用)和 FORCEDOPEN(强制打开)。这些状态通过有限状态机进行管理。

  2. 打开和关闭逻辑:当被保护的服务或资源发生故障或长时间不可用时,断路器会迅速切换到 OPEN 状态,阻止更多的请求发送到该服务或资源。在 OPEN 状态下,系统会定期发送测试请求,以检查故障是否已经解决。如果测试请求成功,断路器会切换到 HALFOPEN 状态,允许一个请求发送到该服务或资源。如果这个请求成功,断路器会切换到 CLOSED 状态,否则会重新切换到 OPEN 状态。

  3. 故障率计算:为了判断是否打开断路器,需要收集一定数量的请求数据。在 Resilience4j 中,需要至少填充一个环形缓冲区(Ring Bit Buffer),才能开始计算故障率。环形缓冲区的大小决定了需要多少次请求才能进行故障率的计算。

  4. 环形缓冲区:Resilience4j 使用环形缓冲区来存储请求状态的数据结构,这与 Hystrix 使用的滑动窗口不同。环形缓冲区使用位集合(BitSet)实现,每个位代表一个请求的状态(成功或失败)。环形缓冲区的大小决定了能够存储的请求数量。例如,一个大小为 10 的缓冲区可以存储 1024 个请求状态。

  5. 配置选项:Resilience4j 提供了丰富的配置选项,如故障率阈值、打开状态下的等待时间、半开状态下允许的最大请求数等,开发者可以根据需求进行灵活配置。

通过上述原理,Resilience4j 的 CircuitBreaker 能够有效地保护分布式系统免受故障的影响,提高系统的可用性和健壮性。


应用场景

服务 A 调用服务 B,但不幸的是,服务 B 不可用或无法响应。因此,服务 A 可能会等待服务 B 的响应或处理遇到的异常。后续针对服务 B 的请求也会遇到类似的挑战,从而导致糟糕的用户体验。

在这种情况下,断路器可以通过在特定时间内停止请求发送,等待超时结束,启用有限数量的请求来检查服务 B 是否正常工作。如果这些请求成功,微服务就可以继续正常运行。如果没有,它将再次开始超时。

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

断路器具有三种状态:Closed、Open 和 Half_Open。

  • 闭合是断路器的初始状态。当微服务运行和交互顺利时,断路器就关闭了。它持续监控配置时间段内发生的故障数量。如果失败率超过指定的阈值,其状态将变为Open状态。如果没有,它将重置失败计数和超时时间
  • 在Open状态下,断路器会阻塞微服务之间的交互流程。请求调用将会失败,并且会抛出异常。 Open 状态保持直到超时结束,然后更改为 Half_Open 状态。
  • 在Half_Open状态下,断路器将允许有限数量的请求通过。如果失败率大于指定阈值,则再次切换到Open状态。否则为Closed状态。

微服务演示

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

有 2 个服务,名为地址服务和订单服务

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

  • 在购买之前,购物者希望查看订单的详细信息。他们向订单服务发送请求。
  • 订单服务使用邮政编码来调用地址服务以获取送货地址详细信息。
  • 收到送货地址详细信息后,订单服务会更新订单信息,然后将其发送回购物者。

Address service

首先构建地址服务,因为它是一个依赖服务.

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.edu</groupId>
    <artifactId>address-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>address-service</name>

    <properties>
        <java.version>17</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.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>


Model

package com.edu.addressservice.model;

import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "addresses")
public class Address {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String postalCode;
    private String state;
    private String city;
}


Repository

package com.edu.addressservice.repository;

import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.edu.addressservice.model.Address;

@Repository
public interface AddressRepository extends JpaRepository<Address, Integer> {
    Optional<Address> findByPostalCode(String postalCode);
}

Service

public interface AddressService {
    Address getAddressByPostalCode(String postalCode);
}
@Service
public class AddressServiceImpl implements AddressService {
    @Autowired
    private AddressRepository addressRepository;
    public Address getAddressByPostalCode(String postalCode) {
        return addressRepository.findByPostalCode(postalCode)
                .orElseThrow(() -> new RuntimeException("Address Not Found: " + postalCode));
    }
}

Controller

package com.edu.addressservice.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.edu.addressservice.model.Address;
import com.edu.addressservice.service.AddressService;

@RestController
@RequestMapping("addresses")
public class AddressController {
    @Autowired
    private AddressService addressService;
    @GetMapping("/{postalCode}")
    public Address getAddressByPostalCode(@PathVariable("postalCode") String postalCode) {
        return addressService.getAddressByPostalCode(postalCode);
    }
}


Data Init

@PostConstruct注解的方法。 Spring 将在初始化 bean 属性并填充数据后调用该方法。

package com.edu.addressservice.config;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import com.edu.addressservice.model.Address;
import com.edu.addressservice.repository.AddressRepository;

import jakarta.annotation.PostConstruct;

@Configuration
public class DataSetup {
    @Autowired
    private AddressRepository addressRepository;
    @PostConstruct
    public void setupData() {
        addressRepository.saveAll(Arrays.asList(
                Address.builder().id(1).postalCode("1000001").state("SD").city("JN")
                        .build(),
                Address.builder().id(2).postalCode("1100000").state("JS").city("NJ").build(),
                Address.builder().id(3).postalCode("2100001").state("ZJ").city("HZ")
                        .build()));
    }
}


Properties

server:
  port: 9090
spring:
  application:
    name: address-service
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: create-drop
  datasource:
    url: jdbc:h2:mem:address-db
    username: admin
    password: 1111
    driverClassName: org.h2.Driver
  h2:
    console:
      enabled: true


测试

运行并访问链接http://localhost:9090/addresses/1000001,预期响应应如下所示

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

这样就完成了地址服务的构建。


Order service

重点关注是如何配置断路器,并通过执行器监控其状态的。

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器


Model

public interface Type {
}
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Entity
@Table(name = "orders")
public class Order implements Type {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Integer id;
    private String orderNumber;
    private String postalCode;
    private String shippingState;
    private String shippingCity;
}
@Data
public class Failure implements Type {
    private final String msg;
}

Repository

package com.edu.orderservice.repository;

import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.edu.orderservice.model.Order;

@Repository
public interface OrderRepository extends JpaRepository<Order, Integer> {
    Optional<Order> findByOrderNumber(String orderNumber);
}


Service

业务逻辑都在这里了。

  • 从“orders”表中检索订单信息
  • 调用外部服务(地址服务)以获取送货地址信息
  • 使用送货地址详细信息更新订单信息,然后返回

如何调用外部API---------------------> Spring 提供的 RestTemplate

package com.edu.orderservice.service;

import com.edu.orderservice.model.Type;

public interface OrderService {
    Type getOrderByPostCode(String orderNumber);
}

package com.edu.orderservice.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import com.edu.orderservice.dto.AddressDTO;
import com.edu.orderservice.model.Failure;
import com.edu.orderservice.model.Order;
import com.edu.orderservice.model.Type;
import com.edu.orderservice.repository.OrderRepository;
import com.edu.orderservice.service.OrderService;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private RestTemplate restTemplate;
    private static final String SERVICE_NAME = "order-service";
    private static final String ADDRESS_SERVICE_URL = "http://localhost:9090/addresses/";

    @Override
    @CircuitBreaker(name = SERVICE_NAME, fallbackMethod = "fallbackMethod")
    public Type getOrderByPostCode(String orderNumber) {
        Order order = orderRepository.findByOrderNumber(orderNumber)
                .orElseThrow(() -> new RuntimeException("Order Not Found: " + orderNumber));
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        HttpEntity<AddressDTO> entity = new HttpEntity<>(null, headers);
        ResponseEntity<AddressDTO> response = restTemplate.exchange(
                (ADDRESS_SERVICE_URL + order.getPostalCode()), HttpMethod.GET, entity,
                AddressDTO.class);
        AddressDTO addressDTO = response.getBody();
        if (addressDTO != null) {
            order.setShippingState(addressDTO.getState());
            order.setShippingCity(addressDTO.getCity());
        }
        return order;
    }

    private Type fallbackMethod(Exception e) {
        return new Failure("Address service is not responding properly");
    }
}

@CircuitBreaker 属性

  • name”被分配为“order-service”,表名“order-service”实例的每个配置都适用于该方法。
  • fallbackMethod”属性,目的是在依赖服务(地址服务)未正确响应时调用降级方法。

Set Up

@Configuration
public class RestConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
package com.edu.orderservice.config;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import com.edu.orderservice.model.Order;
import com.edu.orderservice.repository.OrderRepository;

import jakarta.annotation.PostConstruct;

@Configuration
public class DataSetup {
    @Autowired
    private OrderRepository orderRepository;
    @PostConstruct
    public void setupData() {
        orderRepository.saveAll(Arrays.asList(
                Order.builder().id(1).orderNumber("0c70c0c2").postalCode("1000001").build(),
                Order.builder().id(2).orderNumber("7f8f9f15").postalCode("1100000").build(),
                Order.builder().id(3).orderNumber("394627b2").postalCode("2100001").build()));
    }
}


Properties

server:
  port: 1010
spring:
  application:
    name: order-service
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: create-drop
  datasource:
    url: jdbc:h2:mem:order-db
    username: root
    password: 123
    driverClassName: org.h2.Driver
  h2:
    console:
      enabled: true
management:
  endpoint:
    health:
      show-details: always
  endpoints:
    web:
      exposure:
        include: health
  health:
    circuitbreakers:
      enabled: true
resilience4j:
  circuitbreaker:
    instances:
      order-service:
        sliding-window-type: COUNT_BASED
        failure-rate-threshold: 50
        minimum-number-of-calls: 5
        automatic-transition-from-open-to-half-open-enabled: true
        wait-duration-in-open-state: 5s
        permitted-number-of-calls-in-half-open-state: 3
        sliding-window-size: 10
        register-health-indicator: true

配置中是针对 Resilience4j 库的配置

下面是对 order-service 断路器实例每个配置项的解释:

  • 滑动窗口类型: COUNT_BASED:这指定了用于跟踪失败的滑动窗口是基于失败的调用次数。Resilience4j 支持两种类型的滑动窗口:COUNT_BASED(基于次数)和 TIME_BASED(基于时间)。
  • 故障率阈值: 50:这设置了断路器打开的故障率阈值。在这种情况下,如果故障率达到 50%,则断路器将打开,并阻止对服务的进一步请求。
  • 最小调用次数: 5:这设置了在计算故障率之前必须执行的调用次数。如果小于 5 次调用,则断路器不会因故障率而打开。
  • 自动从打开状态过渡到半开放状态: true:这配置了断路器在指定的等待周期后自动从打开状态过渡到半开放状态。在半开放状态下,允许有限数量的请求通过到服务。
  • 打开状态下的等待时间: 5s:这是断路器在打开状态下持续的秒数,在此之后它会过渡到半开放状态。
  • 半开放状态下的允许调用次数: 3:这设置了在半开放状态下允许的调用次数。如果在期间有超过 3 次调用失败,则断路器将回到打开状态。
  • 滑动窗口大小: 10:这配置了用于跟踪请求和失败的滑动窗口的大小。滑动窗口的大小必须大于计算故障率所需的最小调用次数。
  • 注册健康指标: true:这个标志指示是否为断路器注册健康指标。健康指标用于提供关于组件健康状况的信息,包括断路器的状态。

综上所述,这些配置定义了 order-service 断路器的行为。断路器将监控故障率和调用次数,以确定何时打开和何时过渡到半开放状态,为系统提供一种自我保护机制,以防止级联失败。


测试

依次运行address-service和order-service,访问链接http://localhost:1010/orders?orderNumber=0c70c0c2

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器


如果地址服务未正确响应(服务已关闭),我们将收到以下响应

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

这样完成了订单服务的构建 。


探究断路器

两个服务确保都已运行,访问链接 http://localhost:1010/actuator/health 查看断路器详细信息
Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

我们可以看到以下几个关键配置:

  • bufferedCalls(缓冲调用次数)为0,这意味着从order-service到address-service没有发起任何API调用。
  • failedCalls(失败调用次数)也为0,这表示所有调用都成功了,没有失败的调用。
  • failureRate(失败率)为-1.0%,这是一个异常的值,因为失败率不可能是负数。通常,失败率应该是成功率的一部分,即0%表示100%的成功率。这里的情况可能是因为计算失败率时使用了0作为分母,导致了负数的产生。
  • state(状态)为"CLOSED"(关闭),这表明circuitBreaker(断路器)目前是关闭的,没有触发熔断机制。

调用order-service API 2次

调用order-service API 2次http://localhost:1010/orders?orderNumber=0c70c0c2

然后刷新actuator链接
Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

  • “bufferedCalls”: 2, // Total number of API calls now is 2

关闭address-service,调用order-service API 3

关闭address-service,调用order-service API 3次http://localhost:1010/orders?orderNumber=0c70c0c2,然后刷新执行器链接

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

我们注意到Circuit Breaker被触发。原因是“failureRate”现在大于“failure-rate-threshold”

  • “status”: “CIRCUIT_OPEN”, // CircuitBreaker is triggered
  • “failureRate”: “60.0%”, // this rate now is greater than “failureRateThreshold”
  • “bufferedCalls”: 5, // Total number of API calls from order-service to address-service
  • “failedCalls”: 3, // Number of failed API calls from order-service to address-service

等待5秒,刷新执行器

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

HALF_OPEN状态下,允许““permitted-number-of-calls-in-half-open-state”请求(我们将其值配置为3),然后再次计算失败率,如果失败率仍然大于“failure-rate-threshold”,断路器将再次被触发。


继续调用 order-service API 3 次

继续调用 order-service API 3 次 http://localhost:1010/orders?orderNumber=0c70c0c2,然后刷新执行器链接

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

  • “status”: “CIRCUIT_OPEN”, // // CircuitBreaker is triggered again

运行address-service,然后继续调用order-service API 3次

运行address-service,然后继续调用order-service API 3次http://localhost:1010/orders?orderNumber=0c70c0c2,刷新执行器链接
Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器

断路器已关闭 。


小结

Resilience4j的circuit breaker模式特别有用,它能够在服务调用失败达到一定次数后,自动断开电路,避免进一步的调用,从而保护应用程序不受故障服务的拖累。当服务恢复后,电路会重新闭合,允许正常的调用再次发生。

Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障,【Spring Boot2.X】,spring boot,断路器文章来源地址https://www.toymoban.com/news/detail-804620.html

到了这里,关于Spring Boot - 利用Resilience4j-Circuitbreaker实现断路器模式_防止级联故障的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring Boot利用Kaptcha生成验证码

    我们在登录或注册某个网站的时候,会需要我们输入验证码,才能登录注册,那么如何生成验证码呢?其实,生成验证码我们可以用Java Swing在后台内存里的区域画一个出来,但是非常麻烦,所以我们选择一些现成的工具——Kaptcha,接下来就看看如何使用这个工具在内存中画

    2024年02月22日
    浏览(41)
  • Spring Boot进阶(19):探索ElasticSearch:如何利用Spring Boot轻松实现高效数据搜索与分析

            ElasticSearch是一款基于Lucene的开源搜索引擎,具有高效、可扩展、分布式的特点,可用于全文搜索、日志分析、数据挖掘等场景。Spring Boot作为目前最流行的微服务框架之一,也提供了对ElasticSearch的支持。本篇文章将介绍如何在Spring Boot项目中整合ElasticSearch,并展

    2024年02月11日
    浏览(48)
  • Spring Boot:利用JPA进行数据库的查删

    DAO 层负责数据库访问,它 封装了对数据库的访问操作 ,例如查询、插入、更新和删除等。 Service 层负责业务逻辑, Service 层位于 DAO 层之上 ,Service 层可以 调用多个 DAO 层的接口 来完成复杂的业务操作,也可以将多个 DAO 层的接口组合成一个新的接口,并将其返回给客户端

    2024年02月07日
    浏览(44)
  • 利用Spring Boot实现客户端IP地理位置获取

    在当今互联的世界中,了解客户端的地理位置对于提供个性化服务和增强用户体验至关重要。无论是根据地区偏好定制内容,还是确保符合本地法规,访问客户端IP位置都是一项宝贵的资产。如抖音评论区、用户页都会展示用户的IP属地信息。 在本文中,我们将探讨一个Spri

    2024年02月20日
    浏览(56)
  • Spring Boot进阶(63):「超详细」利用 Redis 实现高效延时队列:踩坑、优化、实践

            提到延时队列,相信各位同学并不会陌生,JDK原生提供了延时队列的使用,当然我们这里介绍的不是这种;在实际的项目中,如果我们有延时队列的场景,可以怎样去实现呢?举一个常见的例子,比如淘宝下单30分钟内,若没有支付,则自动取消订单,这该如何实现

    2024年02月07日
    浏览(43)
  • spring boot中常用的安全框架 Security框架 利用Security框架实现用户登录验证token和用户授权(接口权限控制)

    spring boot中常用的安全框架 Security 和 Shiro 框架 Security 两大核心功能 认证 和 授权 重量级 Shiro 轻量级框架 不限于web 开发 在不使用安全框架的时候 一般我们利用过滤器和 aop自己实现 权限验证 用户登录 Security 实现逻辑 输入用户名和密码 提交 把提交用户名和密码封装对象

    2024年02月06日
    浏览(52)
  • 【Spring Boot学习】Spring Boot的创建,第一个Spring Boot页面.

    前言: 大家好,我是 良辰丫 ,前面几篇文章,我们系统的学习了Spring框架,今天开始,我们就要学习更高级的SpringBoot框架了,不要着急哦,我们一起畅游SpringBoot框架的世界.💌💌💌 🧑个人主页:良辰针不戳 📖所属专栏:javaEE进阶篇之框架学习 🍎励志语句:生活也许会让我们遍体

    2024年02月08日
    浏览(51)
  • Spring Boot——Spring Boot启动原理

    2.1.1Spring Boot入口 2.1.2初始化SpringApplication 准备阶段,在程序运行之前初始化一些属性,用于在后序启动应用程序过程中。 2.1.2.1判断当前应用程序类型 2.1.2.2设置应用程序的所有初始化器(initializers) 上面这段代码主要是通过加载 “spring.factories” 配置文件中指定类型的工厂名

    2024年02月15日
    浏览(46)
  • Spring Boot整理-Spring Boot是什么?

    Spring Boot 是一个开源的 Java 基础框架,它旨在简化基于 Spring 的应用开发。其核心特点在于“约定优于配置”的设计哲学,意味着它提供了一系列默认配置,从而帮助开发者更快地启动和运行新的 Spring 应用。Spring Boot 的主要特点包括: 自动配置: Spring Boot 可以根据

    2024年01月17日
    浏览(65)
  • 【Spring Boot 】Spring Boot 统一功能处理

    🎉🎉🎉 点进来你就是我的人了 博主主页: 🙈🙈🙈 戳一戳,欢迎大佬指点! 欢迎志同道合的朋友一起加油喔 🤺🤺🤺 目录 前言 1. Spring 拦截器 1.1 自定义拦截器 1.2 将自定义拦截器加入到系统配置中 1.3 拦截器实现原理 统一访问前缀添加 (扩展) 2. 统一异常的处理 (@Co

    2024年02月09日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包