Cara SpringBoot menggunakan AOP untuk mengira bilangan lawatan antara muka global

Apakah itu AOP

AOP (Aspect Oriented Programming), juga dikenali sebagai pengaturcaraan berorientasikan aspek, ialah teknologi tradisional dan diselenggara yang melaksanakan fungsi program melalui pra-penyusunan dan proksi dinamik semasa masa jalan.

Fungsi dan kelebihan AOP

Fungsi: Semasa menjalankan program, peningkatan fungsi dibuat kepada kaedah tertentu tanpa mengubah suai kod sumber

Kelebihan: Kurangkan kod pendua , meningkatkan kecekapan pembangunan dan memudahkan penyelenggaraan

Teknologi proksi dinamik biasa

proksi jdk: teknologi proksi dinamik berasaskan antara muka

Proksi cglib: Teknologi proksi dinamik berdasarkan kelas induk

Konsep berkaitan AOP

• Item senarai- Sasaran (objek sasaran): proksi Objek sasaran

• Proksi (proksi): Selepas kelas digabungkan ke dalam peningkatan oleh AOP, kelas proksi hasil

• Joinpoint (titik sambungan) dijana ): Titik sambungan ialah titik yang dipintas. Dalam Spring, titik ini merujuk kepada kaedah, kerana Spring hanya menyokong titik sambungan jenis kaedah (kaedah yang boleh dipertingkatkan dipanggil titik sambungan)

• PointCut (pointcut): pointcut Ia merujuk kepada definisi Joinpoints mana yang ingin kita pintas

• Nasihat (pemberitahuan/peningkatan): Pemberitahuan bermaksud apa yang perlu dilakukan selepas memintas Joinpoint adalah untuk memberitahu

• Aspek (aspek): Ia ialah gabungan potongan titik dan pemberitahuan

• Anyaman (tenunan): proses menggunakan penambahan pada objek sasaran untuk mencipta objek proksi baharu. Spring menggunakan tenunan proksi dinamik, manakala AspectJ menggunakan tenunan pengkompil dan tenunan pemuat kelas

pelaksanaan

Saya menggunakan pembangunan AOP berasaskan anotasi di sini.

Langkah pembangunan

Tambah kebergantungan

		<!--引入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>

Buat antara muka sasaran dan kelas sasaran (dengan titik potong secara dalaman)

Buat kelas aspek (dengan kaedah yang dipertingkatkan secara dalaman)

Serahkan hak penciptaan objek kelas sasaran dan kelas aspek kepada Spirng

Gunakan anotasi untuk mengkonfigurasi hubungan tenunan dalam kelas aspek

Dayakan pengimbasan komponen dan AOP dalam fail konfigurasi Proksi automatik

Oleh kerana projek saya ialah projek Web SpringBoot, hanya dayakan anotasi di sini.

Kod berikut ialah kelas pengiraan atom yang digunakan.

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

Kod berikut ialah pemantauan antara muka global yang dilaksanakan.

Saya hanya menggunakan Redis untuk caching dalam projek, dan anda boleh melihat semua operasi berkaitan Redis.

Gunakan @Sebelum untuk mengkonfigurasi prapemberitahuan. Menentukan bahawa kaedah yang dipertingkatkan dilaksanakan sebelum kaedah potong mata.

Gunakan @ @AfterReturning untuk mengkonfigurasi pemberitahuan siaran. Menentukan bahawa kaedah yang dipertingkatkan dilaksanakan selepas kaedah potong mata.

Gunakan @ @AfterThrowing untuk mengkonfigurasi pemberitahuan lontaran pengecualian. Menentukan bahawa kaedah yang dipertingkatkan dilaksanakan apabila pengecualian berlaku.

@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());
    }
}

Kod lapisan Pengawal diberikan di sini.

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

Selepas projek berjalan untuk satu tempoh masa, anda boleh melihat bilangan permintaan untuk antara muka dalam Redis.

Pemarahan akhir Web adalah seperti berikut:

Atas ialah kandungan terperinci Cara SpringBoot menggunakan AOP untuk mengira bilangan lawatan antara muka global. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!