SpringBoot가 AOP를 사용하여 글로벌 인터페이스 방문 횟수를 계산하는 방법

AOP란 무엇입니까

AOP(Aspect Oriented 프로그래밍)는 관점 지향 프로그래밍이라고도 알려져 있으며 런타임 중에 사전 컴파일 및 동적 프록시를 통해 프로그램 기능을 구현하는 전통적이고 유지 관리되는 기술입니다.

AOP의 역할과 장점

기능 : 프로그램 실행 중 소스코드 수정 없이 특정 메소드의 기능적 향상이 이루어짐

장점 : 중복코드 감소, 개발 효율성 향상, 유지보수 용이

Common Dynamic 프록시 기술

jdk 프록시: 인터페이스 기반 동적 프록시 기술

cglib 프록시: 상위 클래스 기반 동적 프록시 기술

AOP 관련 개념

• List item- Target(대상 객체): The 프록시의 대상 개체

• Proxy(프록시): AOP에 의해 클래스가 짜여지고 강화된 후 결과 프록시 클래스가 생성됩니다

• Joinpoint(연결 지점): 연결 지점은 가로채는 지점을 나타냅니다. . Spring에서는 메소드 유형 연결 포인트만 지원하기 때문에 이러한 포인트는 메소드를 참조합니다(향상될 수 있는 메소드를 연결 포인트라고 함)

• PointCut(pointcut): Pointcut은 우리가 수행하려는 Joinpoint를 나타냅니다. 차단 정의

• Advice(notification/enhancement): 통지는 Joinpoint를 가로채고 나서 해야 할 일이 통지된다는 것을 의미합니다.

• Aspect(Aspect): 진입점과 통지의 조합입니다.

• Weaving(weaving) ) 입력) : 대상 객체에 개선 사항을 적용하여 새로운 프록시 객체를 생성하는 과정입니다. Spring은 동적 프록시 위빙을 사용하고, AspectJ는 컴파일러 위빙과 클래스 로더 위빙을 사용합니다.

implementation

여기에서는 주석 기반 AOP 개발을 사용합니다.

개발 단계

의존성 추가

		<!--引入AOP依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--AOP-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.12</version>
        </dependency>

대상 인터페이스 및 대상 클래스 생성(내부에 컷 포인트 포함)

Aspect 클래스 생성(내부에 향상 메소드 포함)

대상 클래스 및 Aspect 클래스의 객체 생성 권한은 Spirng에 맡기세요

애스펙트 클래스에서 위빙 관계를 구성하려면 주석을 사용하세요.

구성 파일에서 구성 요소 검색 및 AOP 자동 프록시를 활성화하세요.

제 프로젝트는 SpringBoot 웹 프로젝트이므로 여기에서 주석만 활성화하세요.

다음 코드는 사용된 원자 계산 클래스입니다.

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicCounter {
    private static final AtomicCounter atomicCounter = new AtomicCounter();
    /**
     * 单例，不允许外界主动实例化
     */
    private AtomicCounter() {
    }
    public static AtomicCounter getInstance() {
        return atomicCounter;
    }
    private static AtomicInteger counter = new AtomicInteger();
    public int getValue() {
        return counter.get();
    }
    public int increase() {
        return counter.incrementAndGet();
    }
    public int decrease() {
        return counter.decrementAndGet();
    }
    // 清零
    public void toZero(){
        counter.set(0);
    }
}

다음 코드는 전역 인터페이스 모니터링을 구현한 코드입니다.

프로젝트 내 캐싱은 간단히 Redis를 사용하는데, Redis와 관련된 모든 작업을 볼 수 있습니다.

@Before를 사용하여 사전 알림을 구성하세요. 포인트컷 메소드 이전에 향상된 메소드가 실행되도록 지정합니다.

@@AfterReturning을 사용하여 게시물 알림을 구성하세요. 포인트컷 메소드 이후에 향상된 메소드가 실행되도록 지정합니다.

@@AfterThrowing을 사용하여 예외 발생 알림을 구성하세요. 예외가 발생할 때 향상된 메서드가 실행되도록 지정합니다.

@Component
@Aspect
public class GlobalActuator {
    private static final Logger log = LoggerFactory.getLogger(GlobalActuator.class);
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    ThreadLocal<Long> startTime = new ThreadLocal<>();
    ConcurrentHashMap<Object, Object> countMap = new ConcurrentHashMap<Object, Object>();
    /**
     * 匹配控制层层通知 这里监控controller下的所有接口
     */
    @Pointcut("execution(* com.sf.controller.*Controller.*(..))")
    private void controllerPt() {
    }
    /**
     * 在接口原有的方法执行前，将会首先执行此处的代码
     */
    @Before("com.sf.actuator.GlobalActuator.controllerPt()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        //获取传入目标方法的参数
        Object[] args = joinPoint.getArgs();
    }
    /**
     * 只有正常返回才会执行此方法
     * 如果程序执行失败，则不执行此方法
     */
    @AfterReturning(returning = "returnVal", pointcut = "com.sf.actuator.GlobalActuator.controllerPt()")
    public void doAfterReturning(JoinPoint joinPoint, Object returnVal) throws Throwable {
        Signature signature = joinPoint.getSignature();
        String declaringName = signature.getDeclaringTypeName();
        String methodName = signature.getName();
        String mapKey = declaringName + methodName;
        // 执行成功则计数加一
        int increase = AtomicCounter.getInstance().increase();
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        synchronized (this) {
        //在项目启动时，需要在Redis中读取原有的接口请求次数
            if (countMap.size() == 0) {
                JSONObject jsonObject = RedisUtils.objFromRedis(StringConst.INTERFACE_ACTUATOR);
                if (jsonObject != null) {
                    Set<String> strings = jsonObject.keySet();
                    for (String string : strings) {
                        Object o = jsonObject.get(string);
                        countMap.putIfAbsent(string, o);
                    }
                }
            }
        }
        // 如果此次访问的接口不在countMap，放入countMap
        countMap.putIfAbsent(mapKey, 0);
        countMap.compute(mapKey, (key, value) -> (Integer) value + 1);
        synchronized (this) {
            // 内存计数达到30 更新redis
            if (increase == 30) {
                RedisUtils.objToRedis(StringConst.INTERFACE_ACTUATOR, countMap, Constants.AVA_REDIS_TIMEOUT);
                //删除过期时间
                stringRedisTemplate.persist(StringConst.INTERFACE_ACTUATOR);
                //计数器置为0
                AtomicCounter.getInstance().toZero();
            }
        }
        //log.info("方法执行次数:" + mapKey + "------>" + countMap.get(mapKey));
        //log.info("URI:[{}], 耗费时间:[{}] ms", request.getRequestURI(), System.currentTimeMillis() - startTime.get());
    }
    /**
     * 当接口报错时执行此方法
     */
    @AfterThrowing(pointcut = "com.sf.actuator.GlobalActuator.controllerPt()")
    public void doAfterThrowing(JoinPoint joinPoint) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        log.info("接口访问失败，URI:[{}], 耗费时间:[{}] ms", request.getRequestURI(), System.currentTimeMillis() - startTime.get());
    }
}

컨트롤러 레이어 코드는 여기에 제공됩니다.

    @GetMapping("/interface/{intCount}")
    @ApiOperation(value = "查找接口成功访问次数（默认倒序）")
    public Result<List<InterfaceDto>> findInterfaceCount(
            @ApiParam(name = "intCount", value = "需要的接口数") @PathVariable Integer intCount
    ) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        JSONObject jsonObject = RedisUtils.objFromRedis(StringConst.INTERFACE_ACTUATOR);
        if (jsonObject != null) {
            Set<String> strings = jsonObject.keySet();
            for (String string : strings) {
                Integer o = (Integer) jsonObject.get(string);
                hashMap.putIfAbsent(string, o);
            }
        }
        //根据value倒序
        Map<String, Integer> sortedMap = hashMap.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
        //返回列表
        List<InterfaceDto> resultList = new ArrayList<>();
        //排序后中的map中所有的key
        Object[] objects = sortedMap.keySet().toArray();
        for (int i = 0; i < intCount; i++) {
            InterfaceDto interfaceDto = new InterfaceDto();
            interfaceDto.setName((String) objects[i]);
            interfaceDto.setCount(sortedMap.get((String) objects[i]));
            resultList.add(interfaceDto);
        }
        return Result.success(resultList);
    }

프로젝트가 일정 기간 실행된 후 Redis에서 인터페이스에 대한 요청 수를 확인할 수 있습니다.

웹의 최종 렌더링은 다음과 같습니다.

위 내용은 SpringBoot가 AOP를 사용하여 글로벌 인터페이스 방문 횟수를 계산하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!