Spring Boot 3 + Resilience4j 简单入门 + Redis Cache 整合

news2024/9/9 0:48:35

1. 项目结构

2. Maven依赖

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/io.github.resilience4j/resilience4j-spring-boot3 -->
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-spring-boot3</artifactId>
            <version>2.2.0</version>
        </dependency>

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

    </dependencies>

注：Resilience4j 需要 AOP（面向切面编程）相关的依赖，因为它利用 AOP 来动态地拦截和处理方法调用。

3. application.yml

spring:
  application:
    name: spring_resilience4j # Spring Boot 应用程序名称
  cache:
    type: redis # 缓存类型，使用 Redis
  data:
    redis:
      host: 192.168.186.77 # Redis 服务器主机地址
      port: 6379 # Redis 服务器端口号

resilience4j:
  timelimiter:
    instances:
      timeoutService:
        timeoutDuration: 2s # 超时时间为2秒
  circuitbreaker:
    instances:
      circuitbreakerService:
        slidingWindowSize: 10 # 滑动窗口大小为10
        failureRateThreshold: 50 # 失败率阈值为50%
        waitDurationInOpenState: 10s # 打开状态等待时间为10秒
  ratelimiter:
    instances:
      ratelimiterService:
        limitForPeriod: 1 # 每个周期允许的最大请求数为1
        limitRefreshPeriod: 10s # 速率限制刷新周期为10秒
        timeoutDuration: 500ms # 等待许可的超时时间为500毫秒
  retry:
    instances:
      retryService:
        maxAttempts: 5 # 最大重试次数为5次
        waitDuration: 1000ms # 重试间隔为1000毫秒（1秒）
        enableExponentialBackoff: true # 启用指数回退
        exponentialBackoffMultiplier: 1.5 # 指数回退倍数为1.5
        retryExceptions:
          - java.lang.RuntimeException # 需要重试的异常类型
  bulkhead:
    instances:
      bulkheadService:
        maxConcurrentCalls: 5 # 批隔离允许的最大并发调用数为5
        maxWaitDuration: 1s # 等待许可的最大时间为1秒

4. SpringResilience4jApplication.java

package org.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching //开启缓存
public class SpringResilience4jApplication {

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

5. Common.java

package org.example.controller;

import org.example.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

@RestController
public class Common {
    @Autowired
    TimeoutService timeoutService;
    @Autowired
    RateLimiterService rateLimiterService;
    @Autowired
    CircuitBreakerService circuitBreakerService;
    @Autowired
    RetryService retryService;
    @Autowired
    BulkheadService bulkheadService;

    //模拟超时
    @GetMapping("/timeout")
    public CompletableFuture<String> timeout() {
        return timeoutService.timeoutExample();
    }

    //模拟限速
    @GetMapping("/rateLimiter")
    public CompletableFuture<String> rateLimiter() {
        return rateLimiterService.rateLimiterExample();
    }

    //模拟回退
    @GetMapping("/circuitBreaker")
    public ResponseEntity<String> circuitBreaker() {
        return ResponseEntity.ok(circuitBreakerService.CircuitBreaker());
    }

    //模拟重试
    @GetMapping("/retry/{id}")
    public String getItemById(@PathVariable String id) {
        return retryService.getItemById(id);
    }

    // 模拟批隔离
    @GetMapping("/process/{id}")
    public String processRequest(@PathVariable String id) {
        return bulkheadService.processRequest(id);
    }
}

6. BulkheadService.java（批隔离）

package org.example.service;

import io.github.resilience4j.bulkhead.BulkheadFullException;
import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;


@Service
public class BulkheadService {
    private static final Logger logger = LoggerFactory.getLogger(BulkheadService.class);
    @Bulkhead(name = "bulkheadService", fallbackMethod = "fallback")
    public String processRequest(String id) {
        logger.info("Processing request: {}", id);
        try {
            // 模拟处理延迟
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Processed: " + id;
    }

    // 回退方法
    public String fallback(String id, BulkheadFullException ex) {
        logger.error("Bulkhead is full. Falling back for request: {}",id,ex);
        return "Bulkhead is full. Please try again later.";
    }
}

application.yml对应的配置信息：

  bulkhead:
    instances:
      bulkheadService:
        maxConcurrentCalls: 5
        maxWaitDuration: 1s

解释： 

  • maxConcurrentCalls：

    • 最大并发调用数。在此示例中，设置为 5，表示同一时间最多允许 5 个并发调用。如果超过这个数量，额外的调用将被阻塞，直到有空闲的调用资源。

  • maxWaitDuration：

    • 在被阻塞的调用被拒绝之前，最大等待时间。在此示例中，设置为 1 秒，表示如果一个调用在 1 秒内没有获取到许可，将会被拒绝并抛出BulkheadFullException。

 结果：

先启动（目录12BulkheadTest测试类）模拟并发。

出现该结果证明并发调用数已经满。

 

7. CircuitBreakerService.java（熔断）

package org.example.service;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;

@Service
public class CircuitBreakerService {

    @CircuitBreaker(name = "circuitbreakerService", fallbackMethod = "fallback")
    public String CircuitBreaker() {
        if (Math.random() > 0.5) {
            throw new RuntimeException("It is Failure!");
        }
        return "It is Successfully!";
    }

    public String fallback(Throwable ex) {
        return "Fallback : " + ex.getMessage();
    }
}

application.yml对应的配置信息：

  circuitbreaker:
    instances:
      circuitbreakerService:
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10s

解释：

  • slidingWindowSize：

    • 滑动窗口大小。在此示例中，设置为10，表示 CircuitBreaker 将根据最近的10个调用的结果来计算失败率。

  • failureRateThreshold：

    • 失败率阈值。在此示例中，设置为 50，表示如果滑动窗口中的调用失败率超过 50%，CircuitBreaker 将打开（短路）。

  • waitDurationInOpenState：

    • CircuitBreaker打开状态的等待时间。在此示例中，设置为10秒，表示 CircuitBreaker在打开状态下会保持10秒，然后进入半开状态以重新测试服务的可用性。

  • 闭合状态（Closed）：

    • 默认状态，所有请求正常通过并进行监控。
    • 如果失败率超过阈值，进入打开状态。

  • 打开状态（Open）：

    • 在打开状态下，所有请求将立即失败，不会调用实际的方法。
    • 在等待时间结束后，进入半开状态。

  • 半开状态（Half-Open）：

    • 在半开状态下，会允许部分请求通过以测试服务是否恢复。
    • 如果请求成功率恢复正常，恢复到闭合状态；否则重新进入打开状态。

结果：

监听消息：

CircuitBreaker Event: 2024-07-29T23:12:41.621862900+08:00[Asia/Shanghai]: CircuitBreaker 'circuitbreakerService' recorded an error: 'java.lang.RuntimeException: It is Failure!'. Elapsed time: 0 ms

8. RateLimiterService.java（限速）

package org.example.service;

import io.github.resilience4j.ratelimiter.annotation.RateLimiter;
import org.springframework.stereotype.Service;

import java.util.concurrent.CompletableFuture;

@Service
public class RateLimiterService {
    @RateLimiter(name = "ratelimiterService", fallbackMethod = "fallbackRateLimiter")
    public CompletableFuture<String> rateLimiterExample() {
        return CompletableFuture.supplyAsync(() -> "It is Success!");
    }

    public CompletableFuture<String> fallbackRateLimiter(Exception e) {
        return CompletableFuture.completedFuture("Too many requests");
    }
}

application.yml对应的配置信息 ：

  ratelimiter:
    instances:
      ratelimiterService:
        limitForPeriod: 1
        limitRefreshPeriod: 10s
        timeoutDuration: 500ms

解释：

  • limitForPeriod：

    • 指定每个刷新周期内允许的最大请求数。在此示例中，设置为1，表示每个刷新周期只允许1个请求通过。

  • limitRefreshPeriod：

    • 指定速率限制器的刷新周期。在此示例中，设置为10秒，表示每10秒刷新一次，重置允许的请求数。

  • timeoutDuration：

    • 指定在速率限制器中等待许可的最大时间。如果请求在timeoutDuration内未获得许可，则会被拒绝。在此示例中，设置为 500 毫秒。

结果（10s内发送两次请求）：

 

监听消息：

 RateLimiter Event: RateLimiterEvent{type=SUCCESSFUL_ACQUIRE, rateLimiterName='ratelimiterService', creationTime=2024-07-29T23:03:37.189104500+08:00[Asia/Shanghai]}
 RateLimiter Event: RateLimiterEvent{type=SUCCESSFUL_ACQUIRE, rateLimiterName='ratelimiterService', creationTime=2024-07-29T23:03:38.995416700+08:00[Asia/Shanghai]}
RateLimiter Event: RateLimiterEvent{type=FAILED_ACQUIRE, rateLimiterName='ratelimiterService', creationTime=2024-07-29T23:03:40.927729300+08:00[Asia/Shanghai]}

9. Resilience4jEventListener.java（事件监听）

package org.example.service;

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.ratelimiter.RateLimiter;
import io.github.resilience4j.ratelimiter.RateLimiterRegistry;
import io.github.resilience4j.retry.Retry;
import io.github.resilience4j.retry.RetryRegistry;
import io.github.resilience4j.timelimiter.TimeLimiter;
import io.github.resilience4j.timelimiter.TimeLimiterRegistry;
import jakarta.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class Resilience4jEventListener {

    private static final Logger logger = LoggerFactory.getLogger(Resilience4jEventListener.class);

    private final RetryRegistry retryRegistry;
    private final TimeLimiterRegistry timeLimiterRegistry;
    private final CircuitBreakerRegistry circuitBreakerRegistry;
    private final RateLimiterRegistry rateLimiterRegistry;

    @Autowired
    public Resilience4jEventListener(CircuitBreakerRegistry circuitBreakerRegistry,
                                     RateLimiterRegistry rateLimiterRegistry,
                                     RetryRegistry retryRegistry,
                                     TimeLimiterRegistry timeLimiterRegistry) {
        this.circuitBreakerRegistry = circuitBreakerRegistry;
        this.rateLimiterRegistry = rateLimiterRegistry;
        this.retryRegistry = retryRegistry;
        this.timeLimiterRegistry = timeLimiterRegistry;
    }

    @PostConstruct
    public void postConstruct() {

        //  注册 Retry 事件监听器
        Retry retry = retryRegistry.retry("retryService");
        retry.getEventPublisher()
                .onEvent(event -> logger.info("Retry event: {}", event));

        // 注册 CircuitBreaker 事件监听器
        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("circuitbreakerService");
        circuitBreaker.getEventPublisher()
                .onEvent(event -> logger.info("CircuitBreaker Event: {}", event));

        // 注册 RateLimiter 事件监听器
        RateLimiter rateLimiter = rateLimiterRegistry.rateLimiter("ratelimiterService");
        rateLimiter.getEventPublisher()
                .onEvent(event -> logger.info("RateLimiter Event: {}", event));

        // 注册 TimeLimiter 事件监听器
        TimeLimiter timeLimiter = timeLimiterRegistry.timeLimiter("timeoutService");
        timeLimiter.getEventPublisher()
                .onEvent(event -> logger.info("TimeLimiter Event: {}", event));
    }
}

调试运行的信息如下：

2024-07-29T23:02:39.073+08:00  INFO 27996 --- [pool-2-thread-1] o.e.service.Resilience4jEventListener    : TimeLimiter Event: 2024-07-29T23:02:39.073307500+08:00[Asia/Shanghai]: TimeLimiter 'timeoutService' recorded a timeout exception.
2024-07-29T23:03:37.189+08:00  INFO 27996 --- [nio-8080-exec-4] o.e.service.Resilience4jEventListener    : RateLimiter Event: RateLimiterEvent{type=SUCCESSFUL_ACQUIRE, rateLimiterName='ratelimiterService', creationTime=2024-07-29T23:03:37.189104500+08:00[Asia/Shanghai]}
2024-07-29T23:03:38.995+08:00  INFO 27996 --- [nio-8080-exec-5] o.e.service.Resilience4jEventListener    : RateLimiter Event: RateLimiterEvent{type=SUCCESSFUL_ACQUIRE, rateLimiterName='ratelimiterService', creationTime=2024-07-29T23:03:38.995416700+08:00[Asia/Shanghai]}
2024-07-29T23:03:40.927+08:00  INFO 27996 --- [nio-8080-exec-6] o.e.service.Resilience4jEventListener    : RateLimiter Event: RateLimiterEvent{type=FAILED_ACQUIRE, rateLimiterName='ratelimiterService', creationTime=2024-07-29T23:03:40.927729300+08:00[Asia/Shanghai]}
2024-07-29T23:12:41.623+08:00  INFO 27996 --- [nio-8080-exec-9] o.e.service.Resilience4jEventListener    : CircuitBreaker Event: 2024-07-29T23:12:41.621862900+08:00[Asia/Shanghai]: CircuitBreaker 'circuitbreakerService' recorded an error: 'java.lang.RuntimeException: It is Failure!'. Elapsed time: 0 ms
2024-07-29T23:23:15.612+08:00  INFO 27996 --- [nio-8080-exec-3] org.example.service.RetryService         : Fetching item with id 2
2024-07-29T23:27:22.607+08:00  INFO 27996 --- [nio-8080-exec-6] org.example.service.RetryService         : Fetching item with id 3
2024-07-29T23:34:40.837+08:00  INFO 27996 --- [nio-8080-exec-2] org.example.service.RetryService         : Fetching item with id 4
2024-07-29T23:34:42.973+08:00  INFO 27996 --- [nio-8080-exec-1] org.example.service.RetryService         : Fetching item with id 5
2024-07-29T23:34:44.777+08:00  INFO 27996 --- [nio-8080-exec-3] org.example.service.RetryService         : Fetching item with id 6
2024-07-29T23:34:44.793+08:00  INFO 27996 --- [nio-8080-exec-3] o.e.service.Resilience4jEventListener    : Retry event: 2024-07-29T23:34:44.793527800+08:00[Asia/Shanghai]: Retry 'retryService', waiting PT1S until attempt '1'. Last attempt failed with exception 'java.lang.RuntimeException: Simulated database error'.
2024-07-29T23:34:45.817+08:00  INFO 27996 --- [nio-8080-exec-3] org.example.service.RetryService         : Fetching item with id 6
2024-07-29T23:34:45.822+08:00  INFO 27996 --- [nio-8080-exec-3] o.e.service.Resilience4jEventListener    : Retry event: 2024-07-29T23:34:45.822567400+08:00[Asia/Shanghai]: Retry 'retryService' recorded a successful retry attempt. Number of retry attempts: '1', Last exception was: 'java.lang.RuntimeException: Simulated database error'.

 注：该类进行事件监听，便于调试。

10. RetryService.java（缓存+重试）

package org.example.service;

import io.github.resilience4j.retry.annotation.Retry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

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

    @Cacheable(value = "items", key = "#id")
    @Retry(name = "retryService", fallbackMethod = "fallback")
    public String getItemById(String id) {
        logger.info("Fetching item with id {}", id);
        // 模拟数据库调用，可能会引发异常
        if (Math.random() > 0.8) {
            throw new RuntimeException("Simulated database error");
        }
        return "Cache " + id;
    }

    // 回退方法
    public String fallback(String id, RuntimeException e) {
        return "Fallback : " + id;
    }
}

注：该类简单的使用redis缓存，重试机制可以自动重新执行失败的操作。通过配置重试次数和重试间隔，可以在遇到暂时性错误时增加操作成功的机会。

application.yml对应的配置信息：

  retry:
    instances:
      retryService:
        maxAttempts: 5
        waitDuration: 1000
        enableExponentialBackoff: true
        exponentialBackoffMultiplier: 1.5
        retryExceptions:
          - java.lang.RuntimeException

 解释：

  • maxAttempts：

    • 最大重试次数。在此示例中，设置为 5，表示如果方法调用失败，将最多重试 5 次。

  • waitDuration：

    • 重试之间的等待时间（以毫秒为单位）。在此示例中，设置为 1000 毫秒（1 秒），表示每次重试之间等待 1 秒。

  • enableExponentialBackoff：

    • 启用指数回退策略。设置为true 表示启用指数回退。

  • exponentialBackoffMultiplier：

    • 指数回退的倍数。在此示例中，设置为1.5，表示每次重试之间的等待时间将乘以 1.5。

  • retryExceptions：

    • 需要重试的异常类型列表。在此示例中，指定了 java.lang.RuntimeException，表示当方法抛出RuntimeException时会进行重试。

结果：

直接访问（保证redis正常运行），然后不断的尝试把路径1依次累加，然后发送请求，直到出现监听消息的内容即可看到重试，当方法上使用了 @Cacheable 注解时，如果请求的缓存存在且未过期，那么该方法不会实际执行，而是直接返回缓存中的数据。这意味着在这种情况下，@Retry 注解可能不会生效，因为方法调用不会实际发生，导致没有机会触发重试机制。

监听消息： 

2024-07-29T23:23:15.612+08:00  INFO 27996 --- [nio-8080-exec-3] org.example.service.RetryService         : Fetching item with id 2
2024-07-29T23:27:22.607+08:00  INFO 27996 --- [nio-8080-exec-6] org.example.service.RetryService         : Fetching item with id 3
2024-07-29T23:34:40.837+08:00  INFO 27996 --- [nio-8080-exec-2] org.example.service.RetryService         : Fetching item with id 4
2024-07-29T23:34:42.973+08:00  INFO 27996 --- [nio-8080-exec-1] org.example.service.RetryService         : Fetching item with id 5
2024-07-29T23:34:44.777+08:00  INFO 27996 --- [nio-8080-exec-3] org.example.service.RetryService         : Fetching item with id 6
2024-07-29T23:34:44.793+08:00  INFO 27996 --- [nio-8080-exec-3] o.e.service.Resilience4jEventListener    : Retry event: 2024-07-29T23:34:44.793527800+08:00[Asia/Shanghai]: Retry 'retryService', waiting PT1S until attempt '1'. Last attempt failed with exception 'java.lang.RuntimeException: Simulated database error'.
2024-07-29T23:34:45.817+08:00  INFO 27996 --- [nio-8080-exec-3] org.example.service.RetryService         : Fetching item with id 6
2024-07-29T23:34:45.822+08:00  INFO 27996 --- [nio-8080-exec-3] o.e.service.Resilience4jEventListener    : Retry event: 2024-07-29T23:34:45.822567400+08:00[Asia/Shanghai]: Retry 'retryService' recorded a successful retry attempt. Number of retry attempts: '1', Last exception was: 'java.lang.RuntimeException: Simulated database error'.
 

11. TimeoutService.java（超时）

package org.example.service;

import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class TimeoutService {

    @TimeLimiter(name = "timeoutService", fallbackMethod = "fallback")
    public CompletableFuture<String> timeoutExample() {
        return CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000); // 模拟长时间处理，这里设置为5秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "Success";
        });
    }

    public CompletableFuture<String> fallback(Throwable t) {
        return CompletableFuture.completedFuture("fallback: timeout!");
    }
}

application.yml对应的配置信息：

  timelimiter:
    instances:
      timeoutService:
        timeoutDuration: 2s

解释：设置为 2 秒。如果方法调用在 2 秒内未完成，TimeLimiter 会中断调用并执行回退方法。

结果：

监听消息：

TimeLimiter Event: 2024-07-29T23:02:39.073307500+08:00[Asia/Shanghai]: TimeLimiter 'timeoutService' recorded a timeout exception. 

12. BulkheadTest.java（批隔离测试）

package org.example.test;

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BulkheadTest {

    public static void main(String[] args) {
        // 创建一个固定大小的线程池，线程数为6
        ExecutorService executor = Executors.newFixedThreadPool(6);
        // 初始化一个 CountDownLatch，用于控制所有任务的开始
        CountDownLatch latch = new CountDownLatch(1);

        // 提交6个任务到线程池
        for (int i = 1; i <= 6; i++) {
            final int id = i;
            executor.submit(() -> {
                try {
                    // 等待 latch 释放，确保所有任务同时开始
                    latch.await();
                    // 创建 URL 对象，指定请求路径
                    URL url = new URL("http://localhost:8080/process/" + id);
                    // 打开连接
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    // 设置请求方法为 GET
                    conn.setRequestMethod("GET");

                    // 获取响应代码
                    int responseCode = conn.getResponseCode();
                    // 打印响应代码
                    System.out.println("Response Code for request " + id + ": " + responseCode);

                } catch (Exception e) {
                    // 打印异常信息
                    e.printStackTrace();
                }
            });
        }

        // 释放 latch，启动所有任务
        latch.countDown();
        // 关闭线程池
        executor.shutdown();
    }
}

注：该类用于模拟批隔离，策略限制了同时处理的并发调用数量，确保系统部分组件的问题不会导致整个系统的瘫痪。

13. 总结

      通过Resilience4j+Redis实现超时检测，限速访问，以及重试，还有熔断回退和批隔离等简单的案例模拟，仅供学习交流使用。

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1958591.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CSRF Token 原理

CSRF Token 原理

CSRF 攻击 CSRF 攻击成功的关键是&#xff0c;恶意网站让浏览器自动发起一个请求&#xff0c;这个请求会自动携带 cookie &#xff0c;正常网站拿到 cookie 后会认为这是正常用户&#xff0c;就允许请求。 防范 如果在请求中加一个字段&#xff08;CSRF Token&#xff09;&am…
阅读更多...
C++笔记之指针基础

C++笔记之指针基础

函数重载：（C++特性） 定义： C++允许函数重名，但是参数列表要有区分 在相同的作用域定义同名的函数，但是它们的参数要有所区分，这样的多个函数构成重载关系 objdump -d test.exe >log.txt 将test.exe反汇编并将结果重定向到log.txt 文件中 ，然后在 log.txt中找到定…
阅读更多...
学习网络安全 为什么Linux首择Kali Linux? 以及如何正确的使用Kali Linux

学习网络安全 为什么Linux首择Kali Linux? 以及如何正确的使用Kali Linux

1.什么是kali linux&#xff1f; Kali Linux是一款基于Debian的Linux发行版&#xff0c;主要用于网络安全测试和渗透测试。它由全球顶尖的安全专家和黑客社区维护开发&#xff0c;提供了丰富的工具和资源&#xff0c;用于测试安全性、漏洞利用和渗透测试。此外&#xff0c;Kal…
阅读更多...
MySQL 性能调优

MySQL 性能调优

文章目录 一. MySQL调优金字塔1. 架构调优2. MySQL调优3. 硬件和OS调优4. 小结 二. 查询性能调优三. 慢查询1. 概念2. 优化数据访问3. 请求了不需要数据&#xff0c;怎么做4. 是否在扫描额外的记录5. 慢查询相关配置 & 日志位置6. 小结 四. 查询优化器五. 实现调优手段 一.…
阅读更多...
24、Python之面向对象：责任与自由，私有属性真的有必要吗

24、Python之面向对象：责任与自由，私有属性真的有必要吗

引言 前面我们进一步介绍了类定义中属性的使用&#xff0c;今天我们对中关于属性私有化的话题稍微展开聊一下&#xff0c;顺便稍微理解一下Python设计的相关理念。 访问级别 在其他编程语言中&#xff0c;比如Java&#xff0c;关于类中的属性和方法通过关键字定义明确的访问级…
阅读更多...
1、仓颉工程基础操作 cjpm

1、仓颉工程基础操作 cjpm

文章目录 1. 仓颉工程创建方式2. cjpm2.1 init 初始化工程2.2 run 运行工程 1. 仓颉工程创建方式 使用 cangjie studio 通过cangjie studio 创建 使用vscode插件 通过 VSCode 命令面板创建仓颉工程通过可视化界面创建仓颉工程 cjpm 注&#xff1a;具体使用参考官方文档&#…
阅读更多...
探索分布式光伏运维系统的组成 需要几步呢？

探索分布式光伏运维系统的组成 需要几步呢？

前言 随着光伏发电的不断发展&#xff0c;对于光伏发电监控系统的需求也日益迫切&#xff0c;“互联网”时代&#xff0c;“互联网”的理念已经转化为科技生产的动力&#xff0c;促进了产业的升级发展&#xff0c;本文结合“互联网”技术提出了一种针对分散光伏发电站运行数据…
阅读更多...
浅谈Devops

浅谈Devops

1.什么是Devops DevopsDev&#xff08;Development&#xff09;Ops&#xff08;Operation&#xff09; DevOps&#xff08;Development和Operations的混合词&#xff09;是一种重视“软件开发人员&#xff08;Dev&#xff09;”和“IT运维技术人员&#xff08;Ops&#xff09;”…
阅读更多...
asp.net mvc 三层架构开发商城系统需要前台页面代完善

asp.net mvc 三层架构开发商城系统需要前台页面代完善

一般会后端开发&#xff0c;都不太想写前台界面&#xff0c;这套系统做完本来想开源&#xff0c;需要前台界面&#xff0c;后台已开发&#xff0c;有需求的朋友&#xff0c;可以开发个前端界面完善一下&#xff0c;有的话可以私聊发给我啊
阅读更多...
The Llama 3 Herd of Models 第6部分推理部分全文

The Llama 3 Herd of Models 第6部分推理部分全文

第1,2,3部分 介绍，概览和预训练 第4部分 后训练 第5部分 结果 6 Inference 推理 我们研究了两种主要技术来提高Llama 3405b模型的推理效率:(1)管道并行化和(2)FP8量化。我们已经公开发布了FP8量化的实现。 6.1 Pipeline Parallelism 管道并行 当使用BF16数字表示模型参数时…
阅读更多...
VirtualBox创建共享磁盘

VirtualBox创建共享磁盘

VirtualBox创建共享磁盘 目录 VirtualBox创建共享磁盘1、划分共享磁盘1.1、【管理】->【工具】->【虚拟介质管理】1.2、【创建】->【VDI&#xff08;VirtualBox 磁盘映像&#xff09;】->【下一步】1.3、【预先分配全部空间】->【下一步】1.4、【分配大小】->…
阅读更多...
5、springboot3 vue3开发平台-后端- satoken 整合

5、springboot3 vue3开发平台-后端- satoken 整合

文章目录 1. 为什么使用sa-token2. 依赖导入jichu2.1 基础依赖引入2.2 redis整合2.3 redis 配置&#xff0c; 使redis能支持中文存储 3. 配置4. 配置使用4.1 权限加载接口实现&#xff0c; 登录实现4.2 配置全局过滤器4.3 登录异常处理 5. 登录测试6. 用户session的获取 1. 为什…
阅读更多...
MySQL索引与存储引擎、事物

MySQL索引与存储引擎、事物

数据库索引 是一个排序的列表&#xff0c;存储着索引值和这个值所对应的物理地址 无须对整个表进行扫描&#xff0c;通过物理地址就可以找到所需数据 是表中一列或者若干列值排序的方法 需要额外的磁盘空间 类型 普通索引 最基本的索引类型&#xff0c;没有唯一性之类的限制 创…
阅读更多...
图不连通怎么办？

图不连通怎么办？

目录 1.问题 2.连通的相关概念 3.解决方案 C语言示例实现&#xff1a; 1.问题 无论是图的深度还是广度遍历都是从图的某一条边往下走&#xff0c;那么被孤立的结点怎么被遍历到呢&#xff1f; 2.连通的相关概念 连通&#xff1a;如果从V到W存在一条&#xff08;无向&#…
阅读更多...
3D魔方游戏制作lua迷你世界

3D魔方游戏制作lua迷你世界

--3D魔方 --星空露珠工作室 --核心脚本来自负负 --1:xy 2:yx 3:xz 4:zx 5:yz 6:zy --4000,0-3 3995-0,3 local trn{ {{5,2},{3,1},{1,2},{1,3},{4,0},{2,2}}, {{3,0},{5,3},{1,3},{1,2},{2,3},{4,1}}, {{4,2},{2,1},{1,1},{1,0},{3,3},{5,1}}, {{2,0},{4,3},{1,0},{1,1},{5,0},…
阅读更多...
Web3.js 4.x版本事件监听详解：从HTTP到WebSocket的迁移

Web3.js 4.x版本事件监听详解：从HTTP到WebSocket的迁移

项目场景 在一个使用以太坊区块链技术的项目中&#xff0c;需要监听智能合约的事件&#xff0c;以便在事件触发时能够及时响应。项目中使用了web3.js库的4.x版本&#xff0c;节点使用Geth启动&#xff0c;并通过HTTP与节点进行通信。 问题描述 合约DataStorage.sol文件已经定…
阅读更多...
华为项目管理工具集

华为项目管理工具集

华为项目管理10大模板是一套被广泛认可和使用的项目管理工具集&#xff0c;它包含了在项目管理过程中常用的各种表格和文档模板。这些模板旨在帮助项目经理更有效地规划、执行和监控项目&#xff0c;确保项目的成功交付。 虽然具体的模板内容可能会有所不同&#xff0c;但根据…
阅读更多...
51 单片机的Keil5软件

51 单片机的Keil5软件

1. KEIL C51 软件获取 博主网盘下载&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1YBfrRh2L7SIehS5xLQkAow?pwd4211 提取码&#xff1a;4211 也可以在 KEIL 的官网上下载&#xff1a;http:// https://www.keil.com/download/product/ 打开界面如下图所示&#xff1…
阅读更多...
机器学习（二十三）：决策树和决策树学习过程

机器学习（二十三）：决策树和决策树学习过程

一、决策树 下面是数据集&#xff0c;输入特征是耳朵形状、脸形状、是否有胡子&#xff0c;输出结果是是否为猫 下图是决策树&#xff0c;根据耳朵形状、脸形状、是否有胡子这几个特征&#xff0c;建立决策树&#xff0c;从根节点一步步预测结果。 上图中&#xff0c;每一个椭…
阅读更多...
[硬件]—电感传感器

[硬件]—电感传感器

电感传感器 1.概述 工作基础&#xff1a;电磁感应&#xff0c;即利用线圈自感或互感的改变来实现非电量测量。工作原理&#xff1a; 被测物理量&#xff08;非电量&#xff1a;位移、振动、流量&#xff09;&#xff1b;线圈自感系数L/互感系数M&#xff1b;电压或电流&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023