Spring AOP笔记

最新推荐文章于 2024-06-18 20:07:10 发布
最新推荐文章于 2024-06-18 20:07:10 发布
阅读量323 收藏
点赞数
分类专栏： SpringBoot

学习地址：慕课网

AOP

面向切面编程是一种编程范式，用来解决特定问题，是OOP的补充

使用初衷

这里写图片描述
这里写图片描述

AOP使用场景

这里写图片描述

1-权限案例对比

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

普通方法拦截

校验权限的一个例子

@Service
public class ProductService {

    @Autowired
    AuthService authService;

    public void insert(Product product){
        authService.checkAccess();//代码有侵入
        System.out.println("insert product");
    }

    public void delete(Long id){
        authService.checkAccess();
        System.out.println("delete product");
    }
}

AOP拦截方式

定义一个在方法上的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AdminOnly {
}

在目标方法上加入注解

    @AdminOnly
    public void insert(Product product){
        //authService.checkAccess();代码有侵入
        System.out.println("insert product");
    }
    @AdminOnly
    public void delete(Long id){
        //authService.checkAccess();
        System.out.println("delete product");
    }

声明一个AOP，配置拦截规则

@Aspect
@Component
public class SecurityAspect {
    @Autowired
    AuthService authService;

    @Pointcut("@annotation(AdminOnly)")
    public void adminOnly(){

    }

    @Before("adminOnly()")//方法之前执行
    public void check(){
        authService.checkAccess();
    }
}

相对于普通方法，AOP的方式减少了重复代码，降低了代码耦合，更低的代码侵入性。

2-SpringAOP使用详解

这里写图片描述

@Aspect表示类是一个切面类
@Pointcut表示切面的作用范围
Advice表示作用的时间点，before、after

这里写图片描述

designators匹配的方式
wildcards匹配的通配符

* 匹配任意数量的字符
+匹配制定类及其子类
..一般用于匹配任意数的子包或参数

operators运算符

这里写图片描述

execution类型

@Aspect
@Component
public class ExecutionAspectConfig {

    //@Pointcut("execution(public * com.imooc.aopdemo.service.*Service.*(..))") 不拦截子包
    //@Pointcut("execution(public * com.imooc.aopdemo.service..*Service.*(..))")

    //@Pointcut("execution(public void com.imooc.aopdemo.service..*Service.*(..))") //匹配返回值为void的方法
    //@Pointcut("execution(public * com.imooc.aopdemo.service..*Service.*(Long))") //匹配第一个参数为Long的方法
    //@Pointcut("execution(public * com.imooc.aopdemo.service..*Service.*())") //匹配没有参数的方法
    @Pointcut("execution(public * com.imooc.aopdemo.service..*Service.*(..) throws IllegalAccessException)") //匹配抛出异常的方法
    public void matchCondition(){

    }

    @Before("matchCondition()")
    public void before(){
        System.out.println("");
        System.out.println("***before***");
    }
}

within类型

@Aspect
@Component
public class PkgTypeAspectConfig {
  //@Pointcut("within(com.imooc.aopdemo.service.ProductService)")匹配类里的所有方法
    @Pointcut("within(com.imooc.aopdemo.service..*)")//匹配ProductService类里头的所有方法
    public void matchType(){}

    @Before("matchType()")
    public void before(){
        System.out.println("");
        System.out.println("***before***");
    }
}

对象匹配

arget与this的区别：
this能够拦截AOP的introduction定义的方法，而target不行（因为intrduction定义的方法是经过AOP代理过后动态添加的）
这里写图片描述

参数匹配

这里写图片描述

注解匹配

这里写图片描述

@Aspect
@Component
public class AnnoAspectConfig {

    //@Pointcut("@annotation(com.imooc.aopdemo.anno.AdminOnly)")
    //@Pointcut("@within(com.imooc.aopdemo.anno.NeedSecured) && within(com.imooc.aopdemo..*)")
    //@Pointcut("@target(com.imooc.aopdemo.anno.NeedSecured) && within(com.imooc.aopdemo..*)")
    @Pointcut("@args(com.imooc.aopdemo.anno.NeedSecured) && within(com.imooc.aopdemo..*)")
    public void matchCondition(){

    }
    @Before("matchCondition()")
    public void before(){
        System.out.println("");
        System.out.println("***before***");
    }
}

advice注解

这里写图片描述

@Aspect
@Component
public class AdviceConfig {
    @Pointcut("@annotation(com.imooc.aopdemo.anno.AdminOnly)")
    public void matchAnno(){}

    @Pointcut("execution(* *..find*(Long,..))")
    public void matchLongArg(){}

    @Pointcut("execution(* *..*(..)throws IllegalAccessException)")
    public void matchException(){}

    @Pointcut("execution(String com.*..*(..))")
    public void matchReturn(){}

    @Pointcut("execution(* com.*..*(..))")
    public void matchAll(){}

//    @Around("matchReturn()")
//    public void around(ProceedingJoinPoint joinPoint){
//        try{
//            Object res = joinPoint.proceed(joinPoint.getArgs());
//            System.out.println("==========return data:"+res);
//        } catch (Throwable throwable) {
//            throwable.printStackTrace();
//        } finally {
//            System.out.println("===========finally================");
//        }
//    }

//    @Before("matchLongArg() && args(ww,..)")
//    public void before(long ww){
//        System.out.println("==========the data:"+ww);
//    }

    @AfterThrowing("matchException()")
    public void after(){
        System.out.println("=========after========");
    }
}

3-SpringAOP实现原理

代理模式（静态代理）

接口

public interface Subject {
    void request();

}

目标对象

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("real subject excute request");

    }
}

代理对象

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("before");
        try {
            realSubject.request();
        } catch (Exception e) {
            System.out.println("ex:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after");
        }
    }
}

客户端调用

public class Client {
    public static void main(String args[]){
        Subject subject = new Proxy(new RealSubject());//通过构造器强行注入
        subject.request();
    }
}

jdk代理

这里写图片描述

/**
 * jdk动态代理
 *
 */
public class JdkProxySubject implements InvocationHandler {

    private RealSubject realSubject;

    public JdkProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = null;
        try {
            result = method.invoke(realSubject,args);

        } catch (Exception e) {
            System.out.println("ex:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after");
        }
        return result;
    }
}
public class Client {
    public static void main(String args[]){
        Subject subject = (Subject) Proxy.newProxyInstance(Client.class.getClassLoader()
        ,new Class[]{Subject.class},new JdkProxySubject(new RealSubject()));
        subject.request();
    }
}

接口增加方法，静态代理需要实现其接口，而动态代理不需要改动代码。

public interface Subject {
    void request();
    void hello();
}

cglib代理

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;
public class DemoMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before in cglib");
        Object result = null;
        try {
            result = methodProxy.invokeSuper(o,objects);
        }catch (Exception e){
            System.out.println("ex:"+e.getMessage());
            throw e;
        }finally {
            System.out.println("after in cglib");
        }
        return result;
    }
}
public class Client {
    public static void main(String args[]){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(new DemoMethodInterceptor());
        Subject subject = (Subject) enhancer.create();
        subject.hello();
    }
}

这里写图片描述

AOP如何链式调用

这里写图片描述

public abstract class Handler {

    private Handler sucessor;

    public void execute(){
        //链式调用
        handleProcess();
        if(sucessor != null){
            sucessor.execute();
        }
    }

    protected abstract void handleProcess();

    public Handler getSucessor() {
        return sucessor;
    }

    public void setSucessor(Handler sucessor) {
        this.sucessor = sucessor;
    }

}
public class Client {
    static class  HandlerA extends Handler{

        @Override
        protected void handleProcess() {
            System.out.println("handler by a");
        }
    }
    static class  HandlerB extends Handler{

        @Override
        protected void handleProcess() {
            System.out.println("handler by b");
        }
    }
    static class  HandlerC extends Handler{

        @Override
        protected void handleProcess() {
            System.out.println("handler by c");
        }
    }
    public static void main(String args[]){
        Handler handlerA = new HandlerA();
        Handler handlerB = new HandlerB();
        Handler handlerC = new HandlerC();

        handlerA.setSucessor(handlerB);
        handlerB.setSucessor(handlerC);
        handlerA.execute();
    }
}

第二种方式：

public class Chain {
    private List<ChainHandler> handlers;

    private int index = 0;

    public Chain(List<ChainHandler> handlers) {
        this.handlers = handlers;
    }
    public void proceed(){
        if(index >= handlers.size()){
            return ;
        }
        handlers.get(index++).execute(this);
    }
}
public abstract class ChainHandler {

    public void execute(Chain chain){
        handleProcess();
        chain.proceed();//执行表下一个Chain
    }
    protected abstract void handleProcess();
}

public class ChainClient {

    static class ChainHandlerA extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handle by chain a ");
        }
    }
    static class ChainHandlerB extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handle by chain b ");
        }
    }
    static class ChainHandlerC extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handle by chain c ");
        }
    }
    static class ChainHandlerD extends ChainHandler{
        @Override
        protected void handleProcess() {
            System.out.println("handle by chain d ");
        }
    }
    public static void main(String args[]){
        List<ChainHandler> handlers = Arrays.asList(
                new ChainHandlerA(),new ChainHandlerB(),
                new ChainHandlerC(),new ChainHandlerD()
        );
        Chain chain = new Chain(handlers);
        chain.proceed();
    }

}

Spring AOP注解

这里写图片描述

对单个数据库操作有事务控制，同一个方法内有多个数据库操作，不加事务注解，各自的事务不会相互影响；加上注解，会加上一个事务包含这些事务，对每个事务进行标记，当所有事务执行完之后，根据标记判断执行还是回滚

伍Wu哈Ha
关注
专栏目录
spring aop 学习笔记
05-27
NULL 博文链接：https://microjava.iteye.com/blog/525796
springAOP笔记
10-27
springAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOPspringAOP
SpringAOP笔记
i博客
10-10 193
百度定义： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 为什么学习AOP？ AOP可以进行权限校验、日志记录、事务管理、性能监测等。 ...
Spring AOP IOC源码笔记.pdf
05-08
本笔记将深入探讨这两个概念以及它们在Spring中的实现。 1. Spring框架简介： Spring作为一个轻量级的开源框架，旨在简化企业级应用的开发。它通过提供IOC容器，实现了对象的创建、管理和依赖注入，减轻了开发者对...
spring Aop笔记,和源码讲解
06-09
好的，关于Spring AOP的笔记和源码讲解，我可以给你简单介绍一下。 Spring AOP是Spring框架中的一个重要模块，提供了基于代理的AOP实现。AOP（Aspect Oriented Programming）面向切面编程，是一种编程思想，它通过...
Spring AOP源码笔记
03-11
【Spring AOP源码笔记】 Spring AOP是Spring框架的核心组件之一，它实现了面向切面编程（Aspect-Oriented Programming，简称AOP），允许开发者定义“切面”，这些切面可以封装横切关注点，如日志记录、事务管理等。...
spring aop 笔记
aajjw的博客
06-22 163
aop思想 面向切面编程：是代码复用的一种手段，是面向对象编程的补充。 做了什么事情：在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往是权限校验代码、⽇志代码、事务控制代码、性能监控代码。 AOP 相关术语 Target 目标类 Proxy 代理 Joinpoint 连接点 Pointcut 切点 Advice 增强 Advisor 切面 Wearing 织入 Introduction 引入 增强的类型 before advice 前置增强 after advice 后置增强 around
Spring之AOP(学习笔记)
Lazyafei's Blog
05-27 485
什么是AOP AOP的存在价值 AOP的原理剖析 AOP的关键概念 AOP的通俗理解     什么是AOP AOP的基本概念 (Aspect-Oriented Programming)面向切面编程 AOP将应用系统分为两个部分 核心业务逻辑和横向的通用逻辑  即所谓的Aspect  (如所有大中型应用都要涉及到的持久化的管理，事务管理，安全管理，日志管理，以及调试管理等
SpringAOP笔记【JavaEE】
孙宇航的博客
02-14 285
SpringAOP 一、AOP理解 AOP是一种思想，SpringAOP是一个框架，提供了一种对AOP思想的实现，他们的关系就像MVC和SpringMVC、IOC与DI类似。 AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方
Spring AOP 学习笔记
锦瑟年华,逐梦之人
08-06 1850
注：该篇文章会与我的个人博客同步更新。欢迎移步https://cqh-i.github.io/体验更好的阅读效果。 什么是AOP   全称面向切面编程(Aspect Oriented Programming), 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
Spring笔记--AOP
最新发布
Bbbcccccc的博客
06-18 293
AOP全称是Aspect Oriented Programming ，即面向切面编程。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对程序进行增强：权限校验,日志记录,性能监控,事务控制.
Spring AOP学习笔记
weixin_45797182的博客
03-20 137
AOP编程 学习aop之前我们可以先掌握动态代理的原理和作用。 动态代理 动态代理：我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。通俗来讲，遭我们需要用到一个对象的某个方法时，但是它的某些代码块或者全部代码都不需要时，此时我们就可以用到动态代理去实现自己所需要的编程需求或者是在原有的代码上追加代码。 - java...
spring-aop学习笔记
wendy_fly的专栏
02-20 619
一 基本概念 通知(Advice):切面的工作被称为通知。定义了切面是什么以及何时使用。spring切面可以应用5种类型的通知(Before、After、After-retrunning，After-throwing, Around)。 连接点(JointPoint)：是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应
SpringAOP笔记整理
qq_38762479的博客
05-14 419
我们都知道，想使用SpringAop需要做一些xml配置，其中很大一部分是基于标签的，这些标签并不是Spring原生，而是自定义注解。Spring中如果声明了自定义注解，那么就一定会在程序中的某个地方注册了对应的解析器。我们的分析也是由此开始。 我们全局搜索后发现了AopNamespaceHandler类，点进去看下： public class AopName...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值