SpringAOP 常见应用场景

文章目录

  • SpringAOP
    • 1 概念
    • 2 常见应用场景
    • 3 AOP的几种通知类型分别有什么常见的应用场景
    • 4 AOP实现 性能监控
      • 4.1 首先，定义一个切面类，用于实现性能监控逻辑：
      • 4.2 定义自定义注解
      • 4.3 注解修饰监控的方法
    • 5 AOP实现 API调用统计
      • 5.1 定义切面类，用于实现API调用统计逻辑
    • 6 AOP实现 缓存
      • 6.1 定义缓存注解
      • 6.2 实现缓存切面
      • 6.3 应用缓存注解
    • 7 AOP实现自定义滑动窗口限流
      • 7.1 定义缓存注解
      • 7.2 滑动窗口限流器
      • 7.3 AOP切面实现
      • 7.4 应用限流注解

SpringAOP

1 概念

Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架中的一个模块，它提供了面向切面编程的支持。AOP允许开发者将横切关注点（如日志记录、权限检查、性能监控等）从业务逻辑中分离出来，通过这种方式，可以使代码更加模块化，易于维护和管理。

核心概念：

  1. 切面（Aspect）：切面是跨越多个对象的行为或关注点的模块化。例如，事务管理就是企业级应用中的一个关注点，它需要跨越多个对象进行管理。
  2. 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如方法的调用或者异常的抛出。在Spring AOP中，连接点总是方法的执行。
  3. 切入点（Pointcut）：定义了切面应该在哪些连接点上执行的规则。可以通过表达式来匹配哪些方法需要被切面所影响。
  4. 通知（Advice）：在切面识别到某个连接点后要执行的动作。有多种类型的通知，包括前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）。
  5. 织入（Weaving）：将切面应用到目标对象上，从而创建代理对象的过程。这个过程可以在编译时、类加载时或运行时完成。Spring AOP采用的是运行时织入。

2 常见应用场景

Spring AOP（面向切面编程）的常见应用场景广泛，主要用于将那些遍布于应用各处的横切关注点（Cross-cutting Concerns）进行集中管理和代码复用。以下是一些典型的Spring AOP应用场景：

  1. 日志记录（Logging）：在方法调用前后记录日志信息，用于跟踪方法执行情况、性能监控或调试。
  2. 权限检查（Security/Authorization）：在方法执行前验证用户是否有权限执行该操作，比如角色检查或资源访问控制。
  3. 事务管理（Transaction Management）：自动管理数据库事务的开启、提交或回滚，保证数据的一致性。
  4. 异常处理（Exception Handling）：集中处理特定类型的异常，比如记录异常信息或执行特定的恢复操作。
  5. 性能监控（Performance Monitoring）：监控方法执行时间，帮助识别和优化性能瓶颈。
  6. 缓存（Caching）：自动缓存方法的返回结果，减少不必要的数据库查询或其他耗时操作。
  7. 参数校验和转换（Parameter Validation and Conversion）：在方法调用前对参数进行校验或转换，确保符合业务逻辑要求。
  8. API调用统计（API Call Tracking）：记录API的调用次数、频率等，用于分析和优化。
  9. SLF4J、Logback、Log4j等日志框架集成：通过AOP可以在不修改业务代码的情况下，灵活地切换或增强日志框架的功能。
  10. 自定义注解的处理：使用AOP拦截带有特定自定义注解的方法，实现特定逻辑，如标记某个方法需要审计、限流等。

这些场景体现了AOP的核心价值，即通过将横切关注点与核心业务逻辑分离，提高代码的可维护性和可读性，同时降低了模块间的耦合度。

aop的几种通知类型分别有什么常见的应用场景

3 AOP的几种通知类型分别有什么常见的应用场景

AOP（面向切面编程）的通知类型是实现切面功能的关键组成部分，每种类型对应着不同的应用场景。以下是Spring AOP五种通知类型及其常见应用场景：

  1. 前置通知（Before advice）
    • 应用场景：在目标方法执行前执行某些操作，如记录方法调用日志、验证权限、参数校验等。例如，在方法开始前记录操作日志，或检查用户是否已经登录。
  2. 后置通知（After returning advice）
    • 应用场景：在目标方法正常执行完毕后执行，通常用于清理资源、记录方法返回值或日志。例如，记录方法执行成功的信息或操作结果，以及进行一些资源清理工作。
  3. 异常通知（After throwing advice）
    • 应用场景：在目标方法抛出异常后执行，用于异常处理，如记录异常日志、发送错误报告、执行异常补偿措施等。例如，捕获并记录业务异常，或者向管理员发送异常报警邮件。
  4. 最终通知（After (finally) advice）
    • 应用场景：无论目标方法是否正常结束（包括正常返回或抛出异常），都会执行的代码块，常用于释放资源、关闭文件或数据库连接等。例如，确保数据库连接关闭，或执行必要的清理操作。
  5. 环绕通知（Around advice）
    • 应用场景：最灵活的通知类型，可以在方法调用前后执行自定义操作，甚至可以选择是否执行目标方法，适用于需要完全控制方法调用流程的场景，如性能监控、事务管理、日志记录与时间度量等。例如，环绕一个方法调用，测量其执行时间的同时控制事务的开启与提交或回滚。

通过这些通知类型，AOP能够有效地将横切关注点（如日志、安全、事务等）从核心业务逻辑中分离出来，提高代码的模块化程度和可维护性。

4 AOP实现 性能监控

在Spring AOP中，实现性能监控的一种常见方法是通过环绕通知（Around Advice）来测量方法的执行时间。环绕通知可以在方法调用前后执行自定义逻辑，非常适合用来监控性能。下面是一个简单的例子，展示如何使用Spring AOP来监控方法的执行时间：

4.1 首先，定义一个切面类，用于实现性能监控逻辑：

这里，我们定义了一个带有@Around注解的环绕通知方法，它会拦截所有标有自定义注解@PerformanceMonitor的方法。PerformanceMonitor是我们自定义的一个注解，用于标记需要监控的方法，并可配置额外的监控阈值。

package com.example.demo.aspect;

import com.example.demo.annotation.PerformanceMonitor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * PerformanceMonitorAspect : 性能监控切面
 *
 * @author zyw
 * @create 2024-06-06  13:18
 */

@Aspect
@Component
@Slf4j
public class PerformanceMonitorAspect {

    /**
     * 切面方法 Around环绕通知方法
     *
     * @param joinPoint
     * @param performanceMonitor
     * @return
     * @throws Throwable
     */
    @Around("@annotation(performanceMonitor)")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint, PerformanceMonitor performanceMonitor) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            // 执行方法
            Object result = joinPoint.proceed();
            return result;
        } finally {
            long elapsedTime = System.currentTimeMillis() - start;
            // 记录方法执行时间
            log.info("方法: {} 执行了 {} ms", joinPoint.getSignature().getName(), elapsedTime);
            if (performanceMonitor.logIfGreaterThan() > 0 && elapsedTime > performanceMonitor.logIfGreaterThan()) {
                log.warn("性能警告:方法 {} 执行时间超过{}ms.", joinPoint.getSignature().getName(), performanceMonitor.logIfGreaterThan());
            }
        }
    }

}

4.2 定义自定义注解

package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

/**
 * PerformanceMonitor : 性能监控注解
 *
 * @author zyw
 * @create 2024-06-06  13:19
 */

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface PerformanceMonitor {
    // 默认不设置警告阈值
    long logIfGreaterThan() default 0;
}

4.3 注解修饰监控的方法

这样，每次调用performSomeTask方法时，都会自动记录其执行时间，并在超过设定阈值时输出警告信息，帮助识别和优化性能瓶颈。

import com.example.demo.annotation.PerformanceMonitor;    

    @Override
    @PerformanceMonitor(logIfGreaterThan = 100) // 如果执行时间超过100ms，则记录警告日志
    public void performSomeTask(Integer num) {
        if (num == 1){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

在这里插入图片描述

5 AOP实现 API调用统计

5.1 定义切面类，用于实现API调用统计逻辑

在这个切面中，我们使用了ConcurrentHashMap和AtomicLong来安全地记录每个API方法的调用次数，确保在高并发环境下也能正确统计。

package com.example.demo.aspect;

import com.example.demo.annotation.PerformanceMonitor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * PerformanceMonitorAspect : 性能监控切面
 *
 * @author zyw
 * @create 2024-06-06  13:18
 */

@Aspect
@Component
@Slf4j
public class PerformanceMonitorAspect {

    private ConcurrentHashMap<String, AtomicLong> callCountMap = new ConcurrentHashMap<>();
    /**
     * 切面方法 Around环绕通知方法
     *
     * @param joinPoint
     * @param performanceMonitor
     * @return
     * @throws Throwable
     */
    @Around("@annotation(performanceMonitor)")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint, PerformanceMonitor performanceMonitor) throws Throwable {
        long start = System.currentTimeMillis();
        try {
            String methodName = joinPoint.getSignature().getName();
            long count = callCountMap.computeIfAbsent(methodName, k -> new AtomicLong()).incrementAndGet();
            // 执行方法
            Object result = joinPoint.proceed();
            // 可以在这里添加更复杂的统计逻辑，比如记录到数据库、发送到监控系统等
            // 这里简单打印调用次数
            log.info("方法: {} 调用次数: {}", methodName, count);
            return result;
        } finally {
            long elapsedTime = System.currentTimeMillis() - start;
            // 记录方法执行时间
            log.info("方法: {} 执行了 {} ms", joinPoint.getSignature().getName(), elapsedTime);
            if (performanceMonitor.logIfGreaterThan() > 0 && elapsedTime > performanceMonitor.logIfGreaterThan()) {
                log.warn("性能警告:方法 {} 执行时间超过{}ms.", joinPoint.getSignature().getName(), performanceMonitor.logIfGreaterThan());
            }
        }
    }

}

现在，每当/api/data这个API被调用时，ApiCallStatsAspect就会自动增加调用计数，并打印调用次数。你可以根据需要进一步扩展此逻辑，比如定期将统计数据发送到监控系统、数据库等，以便进行更深入的分析和优化。

在这里插入图片描述

6 AOP实现 缓存

6.1 定义缓存注解

首先，你需要定义一个自定义注解，用于标记需要缓存的方法。

package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Cacheable : AOP缓存注解
 *
 * @author zyw
 * @create 2024-06-06  16:16
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Cacheable {
    // 缓存的键，可以根据方法参数生成
    String key();
    // 缓存过期时间，默认永不过期
    long ttl() default 0;
}

6.2 实现缓存切面

接下来，创建一个切面来拦截带有@Cacheable注解的方法，并实现缓存逻辑。

package com.example.demo.aspect;

import com.example.demo.annotation.Cacheable;
import com.example.demo.uitls.RedisUtil;
import jakarta.annotation.Resource;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;


/**
 * CacheAspect :
 *
 * @author zyw
 * @create 2024-06-06  16:17
 */

@Aspect
@Component
public class CacheAspect {

    @Resource
    private RedisUtil redisUtil;

    @Around("@annotation(cacheable)")
    public Object cacheable(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
        String cacheKey = generateCacheKey(joinPoint, cacheable.key());
        Object result = redisUtil.get(cacheKey);

        if (result == null) {
            // 缓存中没有，执行方法并缓存结果
            result = joinPoint.proceed();
            if (cacheable.ttl() > 0) {
                redisUtil.set(cacheKey, result, cacheable.ttl());
            } else {
                redisUtil.set(cacheKey, result);
            }
        }

        return result;
    }

    private String generateCacheKey(ProceedingJoinPoint joinPoint, String keyExpression) {
        // 根据方法名、参数等生成缓存键，这里简化处理，实际可能需要更复杂的逻辑
        StringBuilder keyBuilder = new StringBuilder(keyExpression);
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            keyBuilder.append(":").append(arg.toString());
        }
        return keyBuilder.toString();
    }

}

6.3 应用缓存注解

最后，在你想要缓存其返回结果的方法上使用@Cacheable注解。

package com.example.demo.service.impl;

import com.example.demo.annotation.Cacheable;
import com.example.demo.annotation.PerformanceMonitor;
import com.example.demo.entity.SysUser;
import com.example.demo.service.SysUserService;
import com.example.demo.service.TestService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import java.util.List;

/**
 * TestServiceImpl :
 *
 * @author zyw
 * @create 2023-12-18  15:15
 */
@Service
public class TestServiceImpl implements TestService {

    @Resource
    private SysUserService sysUserService;

    @Override
    @Cacheable(key = "UserListCacheKey", ttl = 60) // 缓存1分钟
    public List<SysUser> getUserList() {
        return sysUserService.list();
    }
}

可用于结果固定，频繁需要获取的数据集，首次查询时走数据库，后缓存有效期内再次获取都从redis中取

在这里插入图片描述
在这里插入图片描述

7 AOP实现自定义滑动窗口限流

要实现AOP结合滑动窗口算法来实现自定义规则的限流，我们可以在原有的基础上进一步扩展，以支持更灵活的配置和更复杂的规则。以下是一个基于Spring AOP和滑动窗口算法的简单示例，包括自定义注解来设置限流规则，以及如何在切面中应用这些规则。

7.1 定义缓存注解

首先，定义一个自定义注解来标记需要限流的方法，并允许传入限流的具体规则

package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * SlidingWindowRateLimiter : 滑动窗口限流注解
 *
 * @author zyw
 * @create 2024-06-06  17:20
 */

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface WindowRateLimit {
    // 允许的最大请求数
    int limit();
    // 窗口时间长度，单位毫秒
    long timeWindowMilliseconds();
}

7.2 滑动窗口限流器

接下来，实现滑动窗口限流器，这里简化处理，直接使用内存实现，实际应用中可能需要基于Redis等持久化存储以适应分布式场景:

package com.example.demo.uitls;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.LinkedList;

/**
 * SlidingWindowRateLimiter : 滑动窗口限流算法
 *
 * @author zyw
 * @create 2024-06-07  15:16
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class SlidingWindowRateLimiter implements Serializable {
    /**
     * 请求队列
     */
    private LinkedList<Long> requests = new LinkedList<>();
    /**
     * 最大请求数
     */
    private int maxRequests;
    /**
     * 窗口大小
     */
    private long windowSizeInMilliseconds;

    public SlidingWindowRateLimiter(int maxRequests, long windowSizeInMilliseconds) {
        this.maxRequests = maxRequests;
        this.windowSizeInMilliseconds = windowSizeInMilliseconds;
    }

    /**
     * 判断是否允许请求
     * @return
     */
    public synchronized boolean allowRequest() {
        // 获取当前时间
        long currentTime = System.currentTimeMillis();

        // 清除窗口之外的旧请求
        while (!requests.isEmpty() && currentTime - requests.peekFirst() > windowSizeInMilliseconds) {
            requests.removeFirst();
        }

        // 如果当前窗口请求未达到上限，则允许请求并记录
        if (requests.size() < maxRequests) {
            requests.addLast(currentTime);
            return true;
        } else {
            // 达到限流阈值，拒绝请求
            return false;
        }
    }
}

7.3 AOP切面实现

最后，创建AOP切面来应用限流逻辑：

package com.example.demo.aspect;

import com.example.demo.annotation.WindowRateLimit;
import com.example.demo.config.redis.RedisKeyEnum;
import com.example.demo.uitls.RedisUtil;
import com.example.demo.uitls.SlidingWindowRateLimiter;
import jakarta.annotation.Resource;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * RateLimiterAspect :
 *
 * @author zyw
 * @create 2024-06-06  17:21
 */

@Aspect
@Component
public class SlidingWindowRateLimiterAspect {

    @Resource
    private RedisUtil redisUtil;

    @Around("@annotation(rateLimit)")
    public Object applyRateLimit(ProceedingJoinPoint joinPoint, WindowRateLimit rateLimit) throws Throwable {
        // 获取调用的方法名
        String methodName = joinPoint.getSignature().getName();
        // 获取方法对应的缓存滑动窗口限流器KEY
        String key = RedisKeyEnum.WINDOW_CURRENT_LIMITING.getKey() + methodName;
        // 从缓存中获取滑动窗口限流器
        SlidingWindowRateLimiter rateLimiter = redisUtil.getCacheObject(key);
        // 如果滑动窗口限流器不存在，则创建一个新限流器
        if (rateLimiter == null) {
            rateLimiter = new SlidingWindowRateLimiter(rateLimit.limit(), rateLimit.timeWindowMilliseconds());
        }
        // 如果滑动窗口限流器存在，则判断是否允许请求
        if (!rateLimiter.allowRequest()) {
            throw new RuntimeException("Too many requests, please try again later.");
        }
        // 如果允许请求，则更新滑动窗口限流器
        redisUtil.setCacheObject(key, rateLimiter);
        // 允许执行方法
        return joinPoint.proceed(); 
    }

}

7.4 应用限流注解

在需要做限流的方法上加上注解，在注解参数中设定 允许的最大请求数 和 窗口时间长度(单位毫秒)

package com.example.demo.service.impl;

import com.example.demo.annotation.WindowRateLimit;
import com.example.demo.service.TestService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

/**
 * TestServiceImpl :
 *
 * @author zyw
 * @create 2023-12-18  15:15
 */
@Service
public class TestServiceImpl implements TestService {

    @Override
    @WindowRateLimit(limit = 5, timeWindowMilliseconds = 60L*1000) // 每最多允许5次请求
    public String getContent() {
        return "Hello Word";
    }
}

首次请求时，初始化滑动窗口限流器，记录第一次请求的时间戳

在这里插入图片描述

窗口期内，记录了五次请求的时间戳后，已达到我们在注解中设置的窗口期最大请求量

在这里插入图片描述

此时接口限流

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

连续状态方程的离散化例子

连续状态方程的离散化例子

连续状态方程的离散化 在控制系统中，连续状态方程的离散化是一个重要的步骤，用于将连续时间系统转换为离散时间系统，以便在数字控制器中实现。这通常涉及将连续时间的微分方程转换为离散时间的差分方程。常用的离散化方法 前向欧拉法（Forward Euler）简单易实现，但精度较…
阅读更多...
在Anaconda中安装keras-contrib库

在Anaconda中安装keras-contrib库

文章目录 1. 有git2. 无git2.1 步骤12.2 步骤22.3 步骤3 1. 有git 如果环境里有git&#xff0c;直接运行以下命令&#xff1a; pip install githttps://www.github.com/farizrahman4u/keras-contrib.git2. 无git 2.1 步骤1 打开网址&#xff1a;https://github.com/keras-tea…
阅读更多...
刷代码随想录有感（97）：动态规划——斐波那契数列

刷代码随想录有感（97）：动态规划——斐波那契数列

题干&#xff1a; 代码&#xff1a; class Solution { public:int fib(int n) {if(n < 1)return n;vector<int> dp(n 1);dp[0] 0;dp[1] 1;for(int i 2; i < n; i){dp[i] dp[i - 1] dp[i - 2];}return dp[n];} }; 动态规划五部曲&#xff1a; 1.dp数组的定…
阅读更多...
【数据结构】二叉树专题

【数据结构】二叉树专题

前言 本篇博客我们来看一些二叉树的经典题型&#xff0c;也是对上篇博客的补充 &#x1f493; 个人主页&#xff1a;小张同学zkf ⏩ 文章专栏&#xff1a;数据结构 若有问题 评论区见&#x1f4dd; &#x1f389;欢迎大家点赞&#x1f44d;收藏⭐文章 ​ 目录 1.单值二叉树 …
阅读更多...
鲜为人知的英伟达创始人：早早退出，身价不如黄仁勋零头

鲜为人知的英伟达创始人：早早退出，身价不如黄仁勋零头

内容提要 普里姆因为婚姻纠纷等个人生活的干扰无法专注在工作上&#xff0c;在成立公司的10年后&#xff0c;也就是2003年宣布退休离开英伟达&#xff0c;并在2006年出售剩余的所有英伟达股份&#xff0c;过上不与外界联系、离群索居的生活&#xff0c;在家中鼓捣着如何“拯救…
阅读更多...
数据结构【堆排序】

数据结构【堆排序】

前言 在上一篇文章主要讲解了二叉树的基本概念和堆的概念以及接口的实现&#xff08;点此处跳转&#xff09; 我们简回顾下堆的基本概念&#xff1a; 1.堆分为大堆和小堆 大堆&#xff1a;父亲结点比左右孩子都大&#xff0c;根结点是最大的小堆&#xff1a;父亲结点比左右孩…
阅读更多...
Redis系列-4 Redis集群介绍

Redis系列-4 Redis集群介绍

Redis集群 Redis提供了持久化能力&#xff0c;保证了重启不会丢失数据&#xff1b;但Redis重启至完全恢复期间&#xff0c;缓存不可用。另外&#xff0c;对于高并发场景下&#xff0c;单点Redis服务器的性能不能满足吞吐量要求&#xff0c;需要进行横向扩展。此时&#xff0c;…
阅读更多...
Java基础_Stream流

Java基础_Stream流

Java基础_Stream流 Stream流的简单使用Stream流的获取Stream流的中间方法Stream流的终结方法综合练习数字过滤字符串过滤并收集自定义对象过滤并收集 来源Gitee地址 Stream流的简单使用 public class StreamDemo01 {public static void main(String[] args) {/*** 创建集合添加…
阅读更多...
【C++ | 拷贝赋值运算符函数】一文了解C++的 拷贝赋值运算符函数

【C++ | 拷贝赋值运算符函数】一文了解C++的 拷贝赋值运算符函数

&#x1f601;博客主页&#x1f601;&#xff1a;&#x1f680;https://blog.csdn.net/wkd_007&#x1f680; &#x1f911;博客内容&#x1f911;&#xff1a;&#x1f36d;嵌入式开发、Linux、C语言、C、数据结构、音视频&#x1f36d; ⏰发布时间⏰&#xff1a;2024-06-09 1…
阅读更多...
API接口测试工具：jmeter的安装、汉化、Jmeter桌面快捷图标和基本使用

API接口测试工具：jmeter的安装、汉化、Jmeter桌面快捷图标和基本使用

文章目录 测试工具&#xff1a;JmeterJmeter安装和配置Jmeter汉化设置中文语言&#xff1a;永久方式设置中文语言&#xff1a;临时方式 设置Jmeter桌面快捷图标jmeter基本用法Jmeter无法保存测试问题解决 测试工具&#xff1a;Jmeter Jmeter依赖于JDK&#xff0c;所以必须确保…
阅读更多...
kafka集成flink api编写教程

kafka集成flink api编写教程

1.引入依赖&#xff08;pox.xml&#xff09; <dependencies><dependency><groupId>org.apache.flink</groupId><artifactId>flink-java</artifactId><version>1.13.6</version></dependency><dependency><gro…
阅读更多...
C# WPF入门学习主线篇（十六）—— Grid布局容器

C# WPF入门学习主线篇（十六）—— Grid布局容器

C# WPF入门学习主线篇&#xff08;十六&#xff09;—— Grid布局容器 欢迎来到C# WPF入门学习系列的第十六篇。在前几篇文章中&#xff0c;我们已经探讨了 Canvas、StackPanel、WrapPanel 和 DockPanel 布局容器及其使用方法。本篇博客将介绍另一种功能强大且灵活的布局容器—…
阅读更多...
MT76X8 RF定频使用方法

MT76X8 RF定频使用方法

一、从下面网址下载QA软件包&#xff0c;然后在WIN系统下安装QA环境。https://download.csdn.net/download/zhouwu_linux/89408573?spm1001.2014.3001.5503 在WINDOWS 7系统下先安装WinPcap_4_1_3.exe。 二、硬件连接。 模块上电&#xff0c;PC机 的IP配置成为10.10.18.100&a…
阅读更多...
GraphQL（6）：认证与中间件

GraphQL（6）：认证与中间件

下面用简单来讲述GraphQL的认证示例 1 实现代码 在代码中添加过滤器&#xff1a; 完整代码如下&#xff1a; const express require(express); const {buildSchema} require(graphql); const grapqlHTTP require(express-graphql).graphqlHTTP; // 定义schema&#xff0c;…
阅读更多...
Wireshark TS | 应用传输丢包问题

Wireshark TS | 应用传输丢包问题

问题背景 仍然是来自于朋友分享的一个案例&#xff0c;实际案例不难&#xff0c;原因也就是互联网线路丢包产生的重传问题。但从一开始只看到数据包截图的判断结果&#xff0c;和最后拿到实际数据包的分析结果&#xff0c;却不是一个结论&#xff0c;方向有点跑偏&#xff0c;…
阅读更多...
微服务第一轮

微服务第一轮

课程文档 目录 一、业务流程 1、登录 Controller中的接口&#xff1a; Service中的实现impl&#xff1a; Service中的实现impl所继承的接口IService&#xff08;各种方法&#xff09;&#xff1a; VO&#xff1a; DTO&#xff1a; 2、搜索商品 ​Controller中的接口&a…
阅读更多...
牛客热题：最长公共子串

牛客热题：最长公共子串

&#x1f4df;作者主页&#xff1a;慢热的陕西人 &#x1f334;专栏链接&#xff1a;力扣刷题日记 &#x1f4e3;欢迎各位大佬&#x1f44d;点赞&#x1f525;关注&#x1f693;收藏&#xff0c;&#x1f349;留言 文章目录 牛客热题&#xff1a;最长公共子串题目链接方法一&am…
阅读更多...
【Redis学习笔记05】Jedis客户端（中）

【Redis学习笔记05】Jedis客户端（中）

Jedis客户端 1. 命令 1.1 String类型 1.1.1 常见命令 SET命令 语法&#xff1a;SET key value [EX seconds | PX milliseconds] [NX|XX] 说明&#xff1a;将string类型的value值设置到指定key中&#xff0c;如果之前该key存在&#xff0c;则会覆盖原先的值&#xff0c;原先…
阅读更多...
Java--可变参数

Java--可变参数

1.JDK1.5开始&#xff0c;Java支持同类型的可变参数给一个方法 2.在方法声明之前&#xff0c;在指定参数类型后加一个省略号&#xff08;...&#xff09; 3.一个方法只能指定一个可变参数&#xff0c;它必须是方法的最后一个参数&#xff0c;任何普通的参数必须在它之前声明 …
阅读更多...
Java----抽象类和接口

Java----抽象类和接口

欢迎大家来这次博客-----抽象类和接口。 1.抽象类 1.1 抽象类概念 在Java中我们都是通过类来描述对象&#xff0c;但反过来并不是所有的类都是用来描述对象的。当一个类中没有足够的信息来描述一个具体对象&#xff0c;我们就将该类称为抽象类。 如上图中的Shape类&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023