spring(AOP详解)

最新推荐文章于 2022-08-27 01:23:50 发布
最新推荐文章于 2022-08-27 01:23:50 发布
阅读量1k 收藏 1
点赞数
分类专栏： 框架 文章标签： aop spring proxy aop详解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45860268/article/details/107011285
版权

1. 动态代理

1.1 动态代理的特点

  • 字节码随用随创建，随用随加载。
  • 它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
  • 装饰者模式就是静态代理的一种体现。

1.2 动态代理常用的两种方式

基于接口的动态代理 使用JDK 官方的 Proxy 类创建代理对象

此处我们使用的是一个演员的例子：在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪人来找了。

public interface IActor {
    /**
    * 基本演出
    * @param money
    */
    public void basicAct(float money);
    /**
    * 危险演出
    * @param money
    */
    public void dangerAct(float money);
}

/**
* 一个演员
*/
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
    public void basicAct(float money){
        System.out.println("拿到钱，开始基本的表演："+money);
    }
    public void dangerAct(float money){
        System.out.println("拿到钱，开始危险的表演："+money);
    }
}

public class Client {
    public static void main(String[] args) {
        //一个剧组找演员：
        final Actor actor = new Actor();//直接
        /**
        * 代理：
        * 间接。
        * 获取代理对象：
        * 要求：
        * 被代理类最少实现一个接口
        * 创建的方式
        * Proxy.newProxyInstance(三个参数)
        * 参数含义：
        * ClassLoader：和被代理对象使用相同的类加载器。
        * Interfaces：和被代理对象具有相同的行为。实现相同的接口。
        * InvocationHandler：如何代理。
        *
        策略模式：使用场景是：
        *
        数据有了，目的明确。
        *
        如何达成目标，就是策略。
        *
        */
        IActor proxyActor = (IActor) Proxy.newProxyInstance(
            actor.getClass().getClassLoader(),
            actor.getClass().getInterfaces(),
            new InvocationHandler() {
                /**
                * 执行被代理对象的任何方法，都会经过该方法。
                * 此方法有拦截的功能。
                *
                * 参数：
                * proxy：代理对象的引用。不一定每次都用得到
                * method：当前执行的方法对象
                * args：执行方法所需的参数
                * 返回值：
                * 当前执行方法的返回值
                */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                    String name = method.getName();
                    Float money = (Float) args[0];
                    Object rtValue = null;
                    //每个经纪公司对不同演出收费不一样，此处开始判断
                    if("basicAct".equals(name)){
                        //基本演出，没有 2000 不演
                        if(money > 2000){
                            //看上去剧组是给了 8000，实际到演员手里只有 4000
                            //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                            rtValue = method.invoke(actor, money/2);
                        }
                    }
                    if("dangerAct".equals(name)){
                        //危险演出,没有 5000 不演
                        if(money > 5000){
                            //看上去剧组是给了 50000，实际到演员手里只有 25000
                            //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
                            rtValue = method.invoke(actor, money/2);
                        }
                    }
                    return rtValue;
                }
            });
        //没有经纪公司的时候，直接找演员。
        //
        actor.basicAct(1000f);
        //
        actor.dangerAct(5000f);
        //剧组无法直接联系演员，而是由经纪公司找的演员
        proxyActor.basicAct(8000f);
        proxyActor.dangerAct(50000f);
    }
}

基于子类的动态代理 使用 CGLib 的 Enhancer 类创建代理对象

还是那个演员的例子，只不过不让他实现接口。

/**
* 一个演员
*/
public class Actor{//没有实现任何接口
    public void basicAct(float money){
        System.out.println("拿到钱，开始基本的表演："+money);
    }
    public void dangerAct(float money){
        System.out.println("拿到钱，开始危险的表演："+money);
    }
}

public class Client {
    /**
    * 基于子类的动态代理
    * 要求：
    *
    被代理对象不能是最终类
    * 用到的类：
    *
    Enhancer
    * 用到的方法：
    *
    create(Class, Callback)
    * 方法的参数：
    *
    Class：被代理对象的字节码
    *
    Callback：如何代理
    * @param args
    */
    public static void main(String[] args) {
        final Actor actor = new Actor();
        Actor cglibActor = (Actor) Enhancer.create(actor.getClass(), new MethodInterceptor() {
            /**
            * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
            方法进行增强。
            *
            * 参数：
            * 前三个和基于接口的动态代理是一样的。
            * MethodProxy：当前执行方法的代理对象。
            * 返回值：
            * 当前执行方法的返回值
            */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args,
                                    MethodProxy methodProxy) throws Throwable {
                String name = method.getName();
                Float money = (Float) args[0];
                Object rtValue = null;
                if("basicAct".equals(name)){
                    //基本演出
                    if(money > 2000){
                        rtValue = method.invoke(actor, money/2);
                    }
                }
                if("dangerAct".equals(name)){
                    //危险演出
                    if(money > 5000){
                        rtValue = method.invoke(actor, money/2);
                    }
                }
                return rtValue;
            }
        });
        cglibActor.basicAct(10000);
        cglibActor.dangerAct(100000);
    }
}

2. Spring 中的 AOP

2.1 Spring 中 AOP 的细节

spring 的 aop，就是通过配置的方式实现代理的功能。

  • Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
  • Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
  • Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
  • Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
  • Target(目标对象):代理的目标对象。
  • Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
  • Proxy（代理）:一个类被 AOP 织入增强后，就产生一个结果代理类。
  • Aspect(切面):是切入点和通知（引介）的结合。

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

2.2 基于 XML 的 AOP 配置

环境搭建

创建 spring 的配置文件并导入约束

此处要导入 aop 的约束

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans                   
       		http://www.springframework.org/schema/beans/spring-beans.xsd
        	http://www.springframework.org/schema/aop
        	http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

配置 spring 的 ioc

!-- 配置 service -->
<bean id="accountService" class="org.woster.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>
<!-- 配置 dao -->
<bean id="accountDao" class="org.woster.dao.impl.AccountDaoImpl">
    <property name="dbAssit" ref="dbAssit"></property>
</bean>
<!-- 配置数据库操作对象 -->
<bean id="dbAssit" class="org.woster.dbassit.DBAssit">
    <property name="dataSource" ref="dataSource"></property>
    <!-- 指定 connection 和线程绑定 -->
    <property name="useCurrentConnection" value="true"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql:///test"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>

抽取公共代码制作成通知

public class TransactionManager {
    //定义一个 DBAssit
    private DBAssit dbAssit ;
    public void setDbAssit(DBAssit dbAssit) {
        this.dbAssit = dbAssit;
    }
    //开启事务
    public void beginTransaction() {
        try {
            dbAssit.getCurrentConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //提交事务
    public void commit() {
        try {
            dbAssit.getCurrentConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //回滚事务
    public void rollback() {
        try {
            dbAssit.getCurrentConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //释放资源
    public void release() {
        try {
            dbAssit.releaseConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

配置步骤

第一步：把通知类用 bean 标签配置起来

<!-- 配置通知 -->
<bean id="txManager" class="org.woster.utils.TransactionManager">
    <property name="dbAssit" ref="dbAssit"></property>
</bean>

第二步：使用 aop:config 声明 aop 配置

aop:config:

作用：

  • 用于声明开始 aop 的配置
<aop:config>
    <!-- 配置的代码都写在此处 -->
</aop:config>

第三步：使用 aop:aspect 配置切面

aop:aspect:

作用：

  • 用于配置切面。

属性：

  • id：给切面提供一个唯一标识。
  • ref：引用配置好的通知类 bean 的 id。
<aop:aspect id="txAdvice" ref="txManager">
    <!--配置通知的类型要写在此处-->
</aop:aspect>

第四步：使用 aop:pointcut 配置切入点表达式

aop:pointcut：

作用：

  • 用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。

属性：

  • expression：用于定义切入点表达式。
  • id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression="execution(public void org.woster.service.impl.AccountServiceImpl.transfer(java.lang.String, java.lang.String,java.lang.Float)
                          )" id="pt1"/>

第五步：使用 aop:xxx 配置对应的通知类型

aop:before

作用：

  • 用于配置前置通知。指定增强的方法在切入点方法之前执行

属性：

  • method:用于指定通知类中的增强方法名称
  • ponitcut-ref：用于指定切入点的表达式的引用
  • poinitcut：用于指定切入点表达式

执行时间点：

  • 切入点方法执行之前执行

aop:after-returning

作用：

  • 用于配置后置通知

属性：

  • method：指定通知中方法的名称。
  • pointct：定义切入点表达式
  • pointcut-ref：指定切入点表达式的引用

执行时间点：

  • 切入点方法正常执行之后。它和异常通知只能有一个执行

aop:after-throwing

作用：

  • 用于配置异常通知

属性：

  • method：指定通知中方法的名称。
  • pointct：定义切入点表达式
  • pointcut-ref：指定切入点表达式的引用

执行时间点：

  • 切入点方法执行产生异常后执行。它和后置通知只能执行一个

aop:after

作用：

  • 用于配置最终通知

属性：

  • method：指定通知中方法的名称。
  • pointct：定义切入点表达式
  • pointcut-ref：指定切入点表达式的引用

执行时间点：

  • 无论切入点方法执行时是否有异常，它都会在其后面执行。

切入点表达式说明

execution:匹配方法的执行
	execution(表达式)
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
写法说明
	全匹配方式：
		public void org.woster.service.impl.AccountServiceImpl.saveAccount(org.woster.domain.Account)
	访问修饰符可以省略
		void org.woster.service.impl.AccountServiceImpl.saveAccount(org.woster.domain.Account)
	返回值可以使用*号，表示任意返回值
		* org.woster.service.impl.AccountServiceImpl.saveAccount(org.woster.domain.Account)
	包名可以使用*号，表示任意包，但是有几级包，需要写几个*
		* *.*.*.*.AccountServiceImpl.saveAccount(org.woster.domain.Account)
	使用..来表示当前包，及其子包
		* com..AccountServiceImpl.saveAccount(org.woster.domain.Account)
	类名可以使用*号，表示任意类
		* com..*.saveAccount(org.woster.domain.Account)
	方法名可以使用*号，表示任意方法
		* com..*.*( org.woster.domain.Account)
	参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
		* com..*.*(*)
	参数列表可以使用..表示有无参数均可，有参数可以是任意类型
		* com..*.*(..)
	全通配方式
		* *..*.*(..)

通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。execution(* org.woster.service.impl..(…))

环绕通知

配置方式

<aop:config>
    <aop:pointcut expression="execution(* org.woster.service.impl.*.*(..))" id="pt1"/>
    <aop:aspect id="txAdvice" ref="txManager">
        <!-- 配置环绕通知 -->
        <aop:around method="transactionAround" pointcut-ref="pt1"/>
    </aop:aspect>
</aop:config>

aop:around：

作用：

  • 用于配置环绕通知

属性：

  • method：指定通知中方法的名称。
  • pointct：定义切入点表达式
  • pointcut-ref：指定切入点表达式的引用

说明：

  • 它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

注意：

  • 通常情况下，环绕通知都是独立使用的
/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
    //定义返回值
    Object rtValue = null;
    try {
        //获取方法执行所需的参数
        Object[] args = pjp.getArgs();
        //前置通知：开启事务
        beginTransaction();
        //执行方法
        rtValue = pjp.proceed(args);
        //后置通知：提交事务
        commit();
    }catch(Throwable e) {
        //异常通知：回滚事务
        rollback();
        e.printStackTrace();
    }finally {
        //最终通知：释放资源
        release();
    }
    return rtValue;
}

2.3 基于注解的 AOP 配置

环境搭建

在配置文件中导入 context 的名称空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置数据库操作对象 -->
    <bean id="dbAssit" class="org.woster.dbassit.DBAssit">
        <property name="dataSource" ref="dataSource"></property>
        <!-- 指定 connection 和线程绑定 -->
        <property name="useCurrentConnection" value="true"></property>
    </bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
        <property name="user" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>
</beans>

把资源使用注解配置

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;
}

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
    @Autowired
    private DBAssit dbAssit ;
}

在配置文件中指定 spring 要扫描的包

<!-- 告知 spring，在创建容器时要扫描的包 -->
<context:component-scan base-package="org.woster"></context:component-scan>

配置步骤

第一步：把通知类也使用注解配置

@Component("txManager")
public class TransactionManager {
    //定义一个 DBAssit
    @Autowired
    private DBAssit dbAssit ;
}

第二步：在通知类上使用@Aspect 注解声明为切面

作用：

  • 把当前类声明为切面类。
@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {
    //定义一个 DBAssit
    @Autowired
    private DBAssit dbAssit ;
}

第三步：在增强的方法上使用注解配置通知

@Before

作用：

  • 把当前方法看成是前置通知。

属性：

  • value：用于指定切入点表达式，还可以指定切入点表达式的引用。
//开启事务
@Before("execution(* org.woster.service.impl.*.*(..))")
public void beginTransaction() {
    try {
        dbAssit.getCurrentConnection().setAutoCommit(false);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

@AfterReturning

作用：

  • 把当前方法看成是后置通知。

属性：

  • value：用于指定切入点表达式，还可以指定切入点表达式的引用
//提交事务
@AfterReturning("execution(* org.woster.service.impl.*.*(..))")
public void commit() {
    try {
        dbAssit.getCurrentConnection().commit();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

@AfterThrowing

作用：

  • 把当前方法看成是异常通知。

属性：

  • value：用于指定切入点表达式，还可以指定切入点表达式的引用
//回滚事务
@AfterThrowing("execution(* org.woster.service.impl.*.*(..))")
public void rollback() {
    try {
        dbAssit.getCurrentConnection().rollback();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

@After

作用：

  • 把当前方法看成是最终通知。

属性：

  • value：用于指定切入点表达式，还可以指定切入点表达式的引用
//释放资源
@After("execution(* org.woster.service.impl.*.*(..))")
public void release() {
    try {
        dbAssit.releaseConnection();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持

<!-- 开启 spring 对注解 AOP 的支持 -->
<aop:aspectj-autoproxy/>

环绕通知注解配置

@Around

作用：

  • 把当前方法看成是环绕通知。

属性：

  • value：用于指定切入点表达式，还可以指定切入点表达式的引用。
@Around("execution(* org.woster.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
    //定义返回值
    Object rtValue = null;
    try {
        //获取方法执行所需的参数
        Object[] args = pjp.getArgs();
        //前置通知：开启事务
        beginTransaction();
        //执行方法
        rtValue = pjp.proceed(args);
        //后置通知：提交事务
        commit();
    }catch(Throwable e) {
        //异常通知：回滚事务
        rollback();
        e.printStackTrace();
    }finally {
        //最终通知：释放资源
        release();
    }
    return rtValue;
}

切入点表达式注解

@Pointcut

作用：

  • 指定切入点表达式

属性：

  • value：指定表达式的内容
@Pointcut("execution(* org.woster.service.impl.*.*(..))")
private void pt1() {}
引用方式：
    /**
* 环绕通知
* @param pjp
* @return
*/
    @Around("pt1()")//注意：千万别忘了写括号
    public Object transactionAround(ProceedingJoinPoint pjp) {
    //定义返回值
    Object rtValue = null;
    try {
        //获取方法执行所需的参数
        Object[] args = pjp.getArgs();
        //前置通知：开启事务
        beginTransaction();
        //执行方法
        rtValue = pjp.proceed(args);
        //后置通知：提交事务
        commit();
    }catch(Throwable e) {
        //异常通知：回滚事务
        rollback();
        e.printStackTrace();
    }finally {
        //最终通知：释放资源
        release();
    }
    return rtValue;
}

不适用XML的配置方式

@Configuration
@ComponentScan(basePackages="org.woster")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}
限定私语
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP详解
Lzc的博客
06-16 3010
一、AOP 1.1、AOP介绍 1.1.1、什么是AOP？ 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从...
Spring AOP（面向切面）介绍以及示例（@Before @Around @After @AfterReturning @AfrerThrowing）
qq_37130607的博客
03-31 3822
1、什么是面向切面（AOP） 在使用面向切面之前我们要理解一下面向对象和面向切面这两个概念。 面向对象就是提取公共特征进行抽象化，比如，不管是男人还是女人，它们都有年龄、名字等属性，那么就可以把这些属性以及相同的方法（如get、set）抽取到父类中，是一种纵向的抽取。 面向切面，就是将一些逻辑通过横向切割的方式抽取到一个独立的模块，业务只需要关注自身的逻辑，在运行业务时，由程序将这些逻辑织入，是一种横向的抽取。比如假设数据库操作之前需要编写日志，这时可以对修改每个函数添加写日志操作，为了提升代码复用可以进
Spring中的AOP（五）——在Advice方法中获取目标方法的参数
weixin_33859504的博客
03-23 1299
为什么80%的码农都做不了架构师？>>> ...
Java练习（十）：Spring应用之AOP的@Before, @After操作（简单工程示例）
sulia1234567890的博客
09-18 8443
目录 1. 背景概念 1.1 定义 1.2 AOP的本质 1.3 AOP的实现 1.4各个名称的概念详解 2. 示例工程 2.1 maven的配置文件： pom.xml 2.2 bean配置文件： bean_aop.xml 2.3 接口和类的代码 2.3.1 接口：UserService 2.3.2实现接口的类：UserServiceImpl 2.3.3Before类：BeforeLog 2.3.4After类：AfterLog 2.4 测试类 1. 背景概念 1....
一篇文章彻底搞懂java AOP、@Before、@After、@AfterReturning、@AfterThrowing、@Around的使用、Spring AOP详解
qq_40585384的博客
08-27 1万+
Advice，确切地说它应该被理解为增强，前面也一直在强调方法的增强，那么接下来我们来看看在Spring AOP中是如何去实现方法的增强的。
（Spring笔记）AspectJ最终通知——@After切面开发+切入点表达式取别名
张松的博客
06-30 1172
AspectJ最终通知——@After切面开发+切入点表达式取别名
spring aop详解.docx
12-02
【Spring AOP详解】 Spring AOP，全称Spring Aspect-Oriented Programming，是Spring框架中的一个关键特性，用于实现面向切面编程。AOP的概念源于解决传统面向对象编程（OOP）中出现的问题，尤其是在大型复杂系统中...
java Spring AOP详解及简单实例
08-30
Java Spring AOP详解及简单实例 一、什么是AOP AOP（Aspect Oriented Programming）是面向切面编程，它不同于OOP（Object Oriented Programming）面向对象编程。AOP是将程序的运行看成一个流程切面，其中可以在切...
spring aop 的约束文件
09-10
spring aop的约束文件，在eclipse编译器上选择window-》preference-》进入页面，在左上方输入catalog
springAOP详解
12-03
spring aop详解，详细地讲述了spring中aop的实现，实现原理，实现过程。
Spring Aop详解
05-02
Spring 中的Aop面向切面编程详解，具体实例。
AspectJ 切面注解中五种通知注解：@Before、@After、@AfterReturning、@AfterThrowing、@Around
热门推荐
u010502101的博客
12-16 16万+
要在 Spring 中声明 AspectJ 切面, 只需要在 IOC 容器中将切面声明为 Bean 实例. 当在 Spring IOC 容器中初始化 AspectJ 切面之后, Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 Bean 创建代理。 在切面类中需要定义切面方法用于响应响应的目标方法，切面方法即为通知方法，通知方法需要用注解标识，AspectJ 支持 5 种类型的
在SpringAOP中如何获取方法的参数值（实体类）以及参数名
我是你妹她哥的博客
04-19 4万+
在前几篇的博客中，我利用AOP来做日志管理。感兴趣的同学可以去了解下（附上地址） https://blog.csdn.net/bicheng4769/article/details/79702778 实际产生的问题 在利用AOP管理日志的时候，遇到这样一个需求，需要将方法的参数、方法名记录下来。其实这样的需求很简单，我在前面那篇博客也讲过,就是利用java的反射机制获取。但是实际中会有这...
AOP使用重点（获取方法名、参数值、参数值类型、目标注解对象、目标方法所在类）
stubborn的博客
10-13 8041
1、引入pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2、创建一个自定义注解类CacheableTest @Retention(RetentionPolicy.RUNTIME) @Target(ElementTy
springAop @AfterReturning注解 获取返回值
weixin_34413103的博客
02-28 8110
@AfterReturning(returning="rvt", pointcut="@annotation(com.sinosoft.redis.cache.PutCache)") public Object AfterExec(JoinPoint joinPoint,Object rvt){ 　　rvt 这个就是方法返回值 } 转载于:https://www.cnblogs...
springboot 注解@Before和@After的用法
梦里蓝天
01-12 8137
首先，新建一个需要切面拦截的方法，再这个方法执行前以及执行后我们需要无耦合的添加一些提前后滞后的处理。 package com.fpga.java.api.impl; @Component @Service(timeout = 5000) public class FPGAComputeServiceImpl implements FPGAComputeService{ @Override public Map<String, String> send(int uid, String ch
框架概述
限定私语的博客
06-08 2412
1. 什么是框架 框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。 简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。 2. 框架要解决的问题 框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的软件企业
springaop详解
最新发布
08-11
Spring AOP（面向切面编程）是Spring框架中的一个模块，用于提供横切关注点（Cross-Cutting Concerns）的支持。横切关注点是与应用程序的核心业务逻辑无关的功能，例如日志记录、性能统计、事务管理等。 在Spring ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值