SpringAop实战

已于 2024-05-21 18:21:03 修改
阅读量608 收藏 6
点赞数 5
文章标签： java 开发语言 aop
于 2024-05-18 16:45:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58706693/article/details/139027151
版权

AOP实战

日志切面

@MyLog 注解 属性 desc 使用了SpEl表达式，主要是用来获取形参值，编写动态日志

  1. 定义枚举类
@Getter
public enum LogCodeEnum {

    SELECT("查询"),
    INSERT("添加"),
    UPDATE("修改"),
    DELETE("删除"),
    OTHER("其他");
    String Code;

    LogCodeEnum(String code) {
        Code = code;
    }
}
  1. 定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    LogCodeEnum type() default LogCodeEnum.OTHER;

    /**
     * 日志的描述信息，支持SpEL表达式
     *
     * @return
     */
    String desc() default "";
}
  1. 编写切面类
@Component
@Aspect
@Slf4j
public class LogAspect {

    @Pointcut("@annotation(com.shi.annotation.MyLog)")
    public void pointCut() {
    }

    @Around("pointCut()")
    public Object handle(ProceedingJoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String requestURI = request.getRequestURI();
        System.out.println(methodSignature);
        Object[] args = joinPoint.getArgs();
        MyLog annotation = method.getAnnotation(MyLog.class);
        String logDesc = parseSpEL(joinPoint);
        long begin = System.currentTimeMillis();
        Object res = null;
        try {
            res = joinPoint.proceed(args);
        } catch (Throwable e) {
            throw new RuntimeException();
        }
        long end = System.currentTimeMillis();
        // 可以定义entity 持久化到数据库
        log.info("日志类型：{}\t日志描述：{}\t请求URI：{}\t方法签名：{}\t请求参数列表：{}\t请求用时(ms)：{}", annotation.type().getCode(), logDesc, requestURI, methodSignature, args, end - begin);
        return res;
    }

    /**
     * 解析 @MyLog 注解中的 desc属性
     */
    private String parseSpEL(ProceedingJoinPoint joinPoint) {
        ExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext();
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        MyLog annotation = method.getAnnotation(MyLog.class);
        if (annotation.desc() == null || "".equals(annotation.desc().trim())) {
            return "";
        }
        Object[] args = joinPoint.getArgs();
        Parameter[] parameters = method.getParameters();
        // 向SpEL上下文注入参数信息
        for (int i = 0; i < parameters.length; i++) {
            context.setVariable(parameters[i].getName(), args[i]);
        }
        // 使用解析器，在上下文中解析目标表达式
        Object value = parser.parseExpression(annotation.desc()).getValue(context);
        if (value == null) {
            return "";
        }
        return value.toString();
    }

}
  1. 实战测试
    /**
     * 通过主键查询单条数据
     *
     * @return 单条数据
     */
    @MyLog(type = LogCodeEnum.SELECT)
    @GetMapping("/all")
    public Result queryAll() {
        return Result.ok(this.emp1Service.queryAll());
    }
	/**
     * 删除数据
     *
     * @param id 主键
     * @return 删除是否成功
     */
    @MyLog(type = LogCodeEnum.DELETE, desc = "'通过【id='+#id+'】删除'")
    @DeleteMapping("/{id}")
    public Result removeById(@PathVariable("id") Integer id) {
        return Result.ok(this.emp1Service.removeById(id));
    }

测试结果

日志类型：删除	日志描述：通过【id=5】删除	请求URI：/emp1/5	方法签名：Result com.shi.controller.Emp1Controller.removeById(Integer)	请求参数列表：[5]	请求用时(ms)：234

缓存切面

我的这个缓存切面有哪些优势？
实现了解耦合 可以通过配置文件修改属性
缓存空值：解决了缓存穿透
通过互斥锁：解决了缓存击穿
设置随机的过期时间：解决了缓存雪崩
通过使用SpEl表达式，灵活的实现key的删除，redis的模糊表达式。
@MyCacheEvict注解 likeKeys支持数组形式。
为什么使用数组形式呢？
比如：
我们有一个emp表，缓存中目前存的key如下：
emp:all
emp:Id:1
emp:Id:2
emp:Id:3
现在我们想要删除emp:Id:1
那么哪些缓存会受到影响呢？emp:all 和emp:Id:1会受到影响，所以需要删除这些key。
怎么实现呢？下面注解就可以实现
@MyCacheEvict(likeKeys = {“‘emp:all’”, “‘emp:Id:’+#Id”})

话不多说，开始上手

  1. 定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCacheable {

    /**
     * 缓存 key
     * 支持SpEl表达式
     *
     * @return
     */
    String key();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCacheEvict {
    /**
     * 模糊删除
     * 支持SpEl表达式
     *
     * @return
     */
    String[] likeKeys();
}
  1. 编写切面
@Aspect
@Component
public class CacheableAspect {

    private static final Random RANDOM = new Random();
    /**
     * 默认10秒
     */
    @Value("${cache.lock-ttl:10000}")
    private Integer lock_ttl;
    /**
     * 默认30分钟
     */
    @Value("${cache.object-ttl:1800000}")
    private Integer cache_ttl;
    /**
     * 空值缓存过期时间10秒
     */
    @Value("${cache.null-ttl:10000}")
    private Integer null_ttl;

    @Value("${cache.lock-key-prefix:lock}")
    private String lockKey_prefix;
    /**
     * 全限定类名
     * 确保这个类中有 data属性，因为在重建缓存函数中用到了
     */
    @Value("${cache.result.type:com.shi.common.Result}")
    private String cacheResultType;

    /**
     * 统一返回结果集中，data的属性名
     * 这里默认使用的data，你可以根据需要修改
     */
    @Value("${cache.result.data.name:data}")
    private String dataName;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Pointcut("@annotation(com.shi.annotation.MyCacheable)")
    public void pointCut() {
    }


    @Around("pointCut()")
    public Object handle(ProceedingJoinPoint joinPoint) {
        String key = parseSpEl(joinPoint);
        String cacheStr = stringRedisTemplate.opsForValue().get(key);
        // 检查缓存中是否存在
        if (cacheStr != null) {
            try {
                Class<?> clazz = Class.forName(cacheResultType);
                return JSONUtil.toBean(cacheStr, clazz);
            } catch (ClassNotFoundException e) {
                throw new RuntimeException();
            }
        }
        String lockKey = lockKey_prefix + ":" + key;
        // 重建缓存
        return buildCache(lockKey, key, joinPoint);
    }

    /**
     * 通过互斥锁重建缓存
     *
     * @param lockKey
     * @param key
     * @param joinPoint
     * @return
     */
    private Object buildCache(String lockKey, String key, ProceedingJoinPoint joinPoint) {
        // 获取互斥锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "1", Duration.ofMillis(lock_ttl));
        Object res = null;
        if (Boolean.TRUE.equals(success)) {
            try {
                Class<?> clazz = Class.forName(cacheResultType);
                Field field = clazz.getDeclaredField(dataName);
                field.setAccessible(true);
                res = joinPoint.proceed();
                if (ObjectUtil.isEmpty(field.get(res))) {
                    stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(res), Duration.ofMillis(null_ttl));
                    stringRedisTemplate.delete(lockKey);
                    return res;
                }
                stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(res), Duration.ofMillis(getRandomTTL()));
                stringRedisTemplate.delete(lockKey);
                return res;
            } catch (Throwable e) {
                throw new RuntimeException();
            }
        } else {
            try {
                Thread.sleep(50);
                handle(joinPoint);
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
        }
        return null;
    }

    /**
     * 获取缓存的随机过期时间
     *
     * @return
     */
    private Integer getRandomTTL() {
        // 1000*60*10
        // 在原来缓存时间的基础上，随机加上 0-10分钟
        return cache_ttl + RANDOM.nextInt(600000);
    }

    /**
     * 解析注解 @MyCacheable中属性key的SpEl
     *
     * @param joinPoint
     * @return
     */
    private String parseSpEl(ProceedingJoinPoint joinPoint) {
        ExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext();
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        MyCacheable annotation = method.getAnnotation(MyCacheable.class);
        Object[] args = joinPoint.getArgs();
        Parameter[] parameters = method.getParameters();
        // 向SpEL上下文注入参数信息
        for (int i = 0; i < parameters.length; i++) {
            context.setVariable(parameters[i].getName(), args[i]);
        }
        // 使用解析器，在上下文中解析目标表达式
        Object value = parser.parseExpression(annotation.key()).getValue(context);
        if (value == null) {
            return "";
        }
        return value.toString();
    }
}

@Aspect
@Component
public class CacheEvictAspect {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Pointcut("@annotation(com.shi.annotation.MyCacheEvict)")
    public void pointCut() {
    }

    @AfterReturning("pointCut()")
    public void handle(JoinPoint joinPoint) {
        Set<String> set = parseSpEl(joinPoint);
        Set<String> allKeys = new HashSet<>();
        for (String n : set) {
            Set<String> keys = stringRedisTemplate.keys(n);
            if (keys != null && !keys.isEmpty()) {
                allKeys.addAll(keys);
            }
        }
        stringRedisTemplate.delete(allKeys);
    }

    /**
     * 解析注解 @MyCacheEvict中属性keys的SpEl
     *
     * @param joinPoint
     * @return
     */
    private Set<String> parseSpEl(JoinPoint joinPoint) {
        ExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext();
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        MyCacheEvict annotation = method.getAnnotation(MyCacheEvict.class);
        Object[] args = joinPoint.getArgs();
        Parameter[] parameters = method.getParameters();
        // 向SpEL上下文注入参数信息
        for (int i = 0; i < parameters.length; i++) {
            context.setVariable(parameters[i].getName(), args[i]);
        }
        // 使用解析器，在上下文中解析目标表达式
        Set<String> set = new HashSet<>();
        for (String key : annotation.likeKeys()) {
            set.add(JSONUtil.toJsonStr(parser.parseExpression(key).getValue(context)));
        }
        return set;
    }
}
  1. 实战测试
    @MyCacheable(key = "'emp:all'")
    @GetMapping("/all")
    public Result queryAll() {
        return Result.ok(this.emp1Service.queryAll());
    }
	
	@GetMapping("/{id}")
    @MyCacheable(key = "'emp:id:'+#id")
    public Result queryById(@PathVariable("id") Integer id) {
        return Result.ok(this.emp1Service.queryById(id));
    }

	@DeleteMapping("/{id}")
    @MyCacheEvict(likeKeys = {"'emp:all'","'emp:id:'+#id"})
    public Result removeById(@PathVariable("id") Integer id) {
        return Result.ok(this.emp1Service.removeById(id));
    }

权限切面

  1. 编写枚举类
@Getter
public enum PermCodeEnum {
    NO_NEED_PERM("no:need:auth", "不需要任何权限"),
    EMP_SELECT("emp:select", "emp表的查询权限"),
    EMP_DELETE("emp:delete", "emp表的删除权限"),
    EMP_UPDATE("emp:update", "emp表的修改权限");

    private String code;
    private String desc;

    PermCodeEnum(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }
}
  1. 编写注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAuth {

    /**
     * 是否需要认证
     *
     * @return
     */
    boolean requireAuth() default true;

    /**
     * 需要的权限，默认不需要任何权限就能访问（只要登陆过）
     *
     * @return
     */

    PermCodeEnum hasPerm() default PermCodeEnum.NO_NEED_PERM;
}
  1. 编写切面
@Aspect
@Component
@Order(-1)
public class AuthAspect {

    /**
     * 将常量放到 常量类中管理，因为在其他地方也需要用到
     */
    private static final String SESSION_LOGIN_USER_KEY = "session_login_user_key";

    @Pointcut("@annotation(com.shi.annotation.MyAuth)")
    public void pointCut() {
    }

    @Before("pointCut()")
    public void handle(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        MyAuth annotation = method.getAnnotation(MyAuth.class);
        // 不需要认证
        if (!annotation.requireAuth()) {
            return;
        }
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        // 检查是否登录
        checkLogin(session);
        // 不需要任何权限
        if (annotation.hasPerm() == PermCodeEnum.NO_NEED_PERM) {
            return;
        }
        checkPerm(session, annotation);
    }

    /**
     * 检查是否登录
     * 扩展：如果使用的token，请修改代码逻辑
     *
     * @param session
     */
    private void checkLogin(HttpSession session) {
        Object attribute = session.getAttribute(SESSION_LOGIN_USER_KEY);
        if (attribute == null) {
            throw new BusinessException(ResultCodeEnum.NO_LOGIN);
        }
    }

    private void checkPerm(HttpSession session, MyAuth annotation) {
        Object attribute = session.getAttribute(SESSION_LOGIN_USER_KEY);
        String code = annotation.hasPerm().getCode();
        // 将 attribute 强转为 session中的用户对象
        // 判断session对象中的 权限码中是否包含 要求的权限，不包含直接抛出异常
    }
}
  1. 实战测试
    没有加该注解的就不需要登录验证
	@MyAuth(hasPerm = PermCodeEnum.EMP_DELETE)
    public Result removeById(@PathVariable("id") Integer id) {
        return Result.ok(this.emp1Service.removeById(id));
    }

切面限流

滑动窗口限流

  1. 定义注解
/**
 * 限流规则
 */
public @interface RateLimitRule {
    /**
     * 时间窗口, 单位秒
     *
     * @return
     */
    int time() default 60;

    /**
     * 允许请求数
     *
     * @return
     */
    int count() default 100;
}

/**
 * 限流器
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 支持重复注解
@Repeatable(value = RateLimiters.class)
public @interface RateLimiter {

    /**
     * 限流键前缀
     *
     * @return
     */
    String key() default "rate_limit:";

    /**
     * 限流规则
     *
     * @return
     */
    RateLimitRule[] rules() default {};

    /**
     * 限流类型
     *
     * @return
     */
    LimitType type() default LimitType.DEFAULT;
}

/**
 * 限流器容器
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimiters {
    RateLimiter[] value();
}
  1. 定义切面
@Component
@Aspect
@Order(2)
public class RateLimiterAspect {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private DefaultRedisScript<Long> limitScript;

    {
        limitScript = new DefaultRedisScript<>("""
                local flag = 1
                for i = 1, #KEYS do
                    local window_start = tonumber(ARGV[1]) - tonumber(ARGV[(i - 1) * 2 + 2])
                    print(tonumber(ARGV[(i - 1) * 2 + 2]))
                    redis.call('ZREMRANGEBYSCORE', KEYS[i], 0, window_start)
                    local current_requests = tonumber(redis.call('ZCARD', KEYS[i]))
                    if current_requests < tonumber(ARGV[(i - 1) * 2 + 3]) then
                    else
                        flag = 0
                    end
                end
                if flag == 1 then
                    for i = 1, #KEYS do
                        print('add')
                        print(KEYS[i], tonumber(ARGV[1]), ARGV[1])
                        redis.call('ZADD', KEYS[i], tonumber(ARGV[1]), ARGV[1])
                        redis.call('pexpire', KEYS[i], tonumber(ARGV[(i - 1) * 2 + 2]))
                    end
                end
                return flag
                """, Long.class);
    }

    private static String getIpAddr(HttpServletRequest request) {
        String ipAddress;
        try {
            ipAddress = request.getHeader("x-forwarded-for");
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getRemoteAddr();
                if (ipAddress.equals("127.0.0.1")) {
                    // 根据网卡取本机配置的IP
                    try {
                        ipAddress = InetAddress.getLocalHost().getHostAddress();
                    } catch (BusinessException e) {
                        throw new RuntimeException();
                    }
                }
            }
            // 通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
            if (ipAddress != null) {
                if (ipAddress.contains(",")) {
                    return ipAddress.split(",")[0];
                } else {
                    return ipAddress;
                }
            } else {
                return "";
            }
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    // 定义切点，需要把RateLimiter和RateLimiters同时加进来，否则多重注解不生效
    @Pointcut("@annotation(com.shi.annotation.limit.RateLimiter)")
    public void rateLimiter() {
    }

    @Pointcut("@annotation(com.shi.annotation.limit.RateLimiters)")
    public void rateLimiters() {
    }

    // 定义切点之前的操作
    @Before("rateLimiter() || rateLimiters()")
    public void doBefore(JoinPoint point) {
        try {
            // 从切点获取方法签名
            MethodSignature signature = (MethodSignature) point.getSignature();
            // 获取方法
            Method method = signature.getMethod();
            String name = point.getTarget().getClass().getName() + "." + signature.getName();
            // 获取日志注解
            RateLimiter rateLimiter = method.getAnnotation(RateLimiter.class);
            RateLimiters rateLimiters = method.getAnnotation(RateLimiters.class);

            List<RateLimiter> limiters = new ArrayList<>();
            if (rateLimiter != null) {
                limiters.add(rateLimiter);
            }

            if (rateLimiters != null) {
                limiters.addAll(Arrays.asList(rateLimiters.value()));
            }

            if (!allowRequest(limiters, name)) {
                throw new RuntimeException("访问过于频繁，请稍候再试");
            }

        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException("服务器限流异常，请稍候再试");
        }
    }

    /**
     * 是否允许请求
     *
     * @param rateLimiters 限流注解
     * @param name         方法全名
     * @return 是否放行
     */
    private boolean allowRequest(List<RateLimiter> rateLimiters, String name) {
        List<String> keys = getKeys(rateLimiters, name);
        String[] args = getArgs(rateLimiters);
        Long res = stringRedisTemplate.execute(limitScript, keys, args);
        System.out.println(res);
        return res != null && res == 1L;
    }

    /**
     * 获取限流的键
     *
     * @param rateLimiters 限流注解
     * @param name         方法全名
     * @return
     */
    private List<String> getKeys(List<RateLimiter> rateLimiters, String name) {
        List<String> keys = new ArrayList<>();

        for (RateLimiter rateLimiter : rateLimiters) {
            String key = rateLimiter.key();
            RateLimitRule[] rules = rateLimiter.rules();
            LimitType type = rateLimiter.type();

            StringBuilder sb = new StringBuilder();
            sb.append(key).append(name);

            if (LimitType.IP == type) {
                String ipAddr = getIpAddr(((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest());
                sb.append("_").append(ipAddr);
            } else if (LimitType.USER == type) {
                // 获取用户id,自己实现
                Long userId = 1L;
                sb.append("_").append(userId);
            }
            for (RateLimitRule rule : rules) {
                int time = rule.time() * 1000;
                int count = rule.count();
                StringBuilder builder = new StringBuilder(sb);
                builder.append("_").append(time).append("_").append(count);
                keys.add(builder.toString());
            }
        }
        return keys;
    }

    /**
     * 获取需要的参数
     *
     * @param rateLimiters 限流注解
     * @return
     */
    private String[] getArgs(List<RateLimiter> rateLimiters) {
        List<String> args = new ArrayList<>();
        args.add(String.valueOf(System.currentTimeMillis()));
        for (RateLimiter rateLimiter : rateLimiters) {
            RateLimitRule[] rules = rateLimiter.rules();
            for (RateLimitRule rule : rules) {
                int time = rule.time() * 1000;
                int count = rule.count();
                args.add(String.valueOf(time));
                args.add(String.valueOf(count));
            }
        }
        return args.toArray(new String[]{});
    }


}
  1. 限流测试
	/**
     * 对于接口，1分钟可以接收1000个请求
     * 对于一个ip，1分钟可以接收10个请求
     *
     * @return
     */
	@RateLimiter(rules = {@RateLimitRule(time = 60, count = 1000)})
    @RateLimiter(rules = {@RateLimitRule(time = 60, count = 10)}, type = LimitType.IP)
    @GetMapping("/test")
    public Result test() {
        return Result.ok("hello");
    }

Gitee源码地址

https://gitee.com/shi-fangqing/aspect-demo

勿语&
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring AOP项目实战
技术分享
07-12 898
本文主要介绍了Spring AOP的基础知识以及在项目中实际使用场景以及代码实现
Spring AOP实战 记录日志 下载可以直接使用
01-05
也欢迎对AOP实战用法感兴趣的同学们加入。 使用场景及目标： 在生产环境中，通过巧妙的AOP机制，实现对日志的细致记录和处理。我们的目标是提高日志记录的效率和规范性，为监控和故障排查提供更为轻松便捷的工具。 ...
SpringAOP实战和理论
weixin_45956631的博客
07-21 231
Spring AOP概述Spring AOP概述
Spring AOP 实战案例
Emine
08-17 815
文章目录定义service定义切面模拟正常访问模拟异常访问 定义service package com.demo.test.aop; import com.demo.test.entity.User; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind
SpringAOP实战
MemoForward的博客
09-02 821
AOP(Aspect Oriented Programming)面向切面编程，是OOP面向对象编程的升级，AOP是基于OOP的。
Spring AOP实战
风雪夜归人的博客
09-11 424
项目中如何应用spring aop编程
Spring实战 | Spring AOP
qq_34193201的博客
10-17 114
Spring AOP（面向切面编程）是Spring框架中的一个关键特性之一。它提供了一种在应用程序中以非侵入式方式实现横切关注点的方法。AOP通过在应用程序中定义切面（Aspect）和连接点（Join Point）来实现，切面定义了横切关注点的行为，而连接点则表示在应用程序中可以插入切面的位置。使用Spring AOP，您可以将横切关注点（如日志记录、性能监视、事务管理等）与业务逻辑相分离，以提高应用程序的可维护性和灵活性。
Spring AOP 实战之异常处理
cdtpf的专栏
01-18 514
要用上Spring AOP，需要依赖以下两个包，Spring AOP是框架，它本身是基于java的代理和cligbl来实现的。@SpringJunitConfig是在单元测试的时候来注入测试需要的类。@Aspect用来注释这个类是AOP需要运行的类。实现业务的接口和实现类，这里用简单业务描述。
Java spring Aop实战
zhurui19940321的博客
07-26 297
只能在service实现类加。不符合业务逻辑，加入事物。Spring 配置文件。Mybatis配置文件。重新测试方法2和方法3。数据库不不会更新数据。
深入浅出Spring AOP：面向切面编程的实战与解析
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-30 1万+
Spring AOP（面向切面编程）作为Spring框架的核心特性之一，提供了强大的横切关注点处理能力，使得开发者能够更好地解耦系统架构，将非功能性需求（如日志记录、事务管理、权限控制等）从主业务逻辑中抽离出来，实现模块化的交叉关注点处理。本文将带你逐步探索Spring AOP的关键技术要点及其实战应用。
Spring AOP定义Before增加实战案例详解
08-25
主要介绍了Spring AOP定义Before增加,结合实例形式详细分析了Spring面向切面AOP定义Before增加相关定义与使用技巧,需要的朋友可以参考下
SpringAOP+RabbitMQ+WebSocket实战详解
08-26
主要介绍了SpringAOP+RabbitMQ+WebSocket实战详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring AOP配置实例
05-14
Spring AOP配置的实例，最基本的Spring AOP配置
Spring AOP精讲
05-08
Spring AOP精讲 AOP概念 让我们从定义一些重要的AOP概念开始。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 351
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 505
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 576
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 625
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
springaop和aspectj实战
08-04
在《Spring 实战》一书中，第四章《面向切面编程的Spring》可能没有很清楚地解释Spring AOP和AspectJ的区别和关系，这可能导致你对它们的理解不够清晰。但是你提到找到了一篇关于Spring AOP (AspectJ)的文章，它可能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值