SpringAOP学习手记

最新推荐文章于 2024-06-17 08:38:35 发布

烤鲅鱼

最新推荐文章于 2024-06-17 08:38:35 发布

阅读量123

点赞数

分类专栏： spring 文章标签： spring java

本文链接：https://blog.csdn.net/qq_34674558/article/details/106342634

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章背景

近日学习慕课网课程Spring入门篇，我看完Spring AOP该章。由于Spring入门篇课程内容录制比较早。录制者是使用的Eclipse编写，但是没有用maven导入jar包。本文从视频内容入手，加入pom.xml文件课方便导入jar。本人为想使用IDEA学习课程的小伙伴提供一篇参考文章，希望各位小伙伴快速入门Spring。

项目结构

在这里插入图片描述

标签应用

<aop:config> 作用：用于声明开始aop的配置
<aop:before>

作用：用于配置前置通知
属性：
    method：指定通知中方法的名称。
    pointct：定义切入点表达式
    pointcut-ref：指定切入点表达式的引用

<aop:after>

作用：用于配置最终通知
属性：
    method：指定通知中方法的名称。
    pointct：定义切入点表达式

<aop:after-throwing>

作用：用于配置后置通知，出现异常不调用
属性：
    method：指定通知中方法的名称。
    pointct：定义切入点表达式
    pointcut-ref：指定切入点表达式的引用

<aop:pointcut>

作用： 用于配置切入点表达式
属性：
    value：相当于XML中的types-matching，待引入增强作用的类的表达式， 支持通配符
   defaultImpl：引入增强的具体实现

<aop:pointcut>
作用：对现有类增加新的方法
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识。

来自于：
https://blog.csdn.net/Kato_op/article/details/80247423
https://www.jianshu.com/p/f7238613c877

实现代码

pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.geronimo.bundles</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.6.8_2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.geronimo.bundles</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8_2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-dao</artifactId>
            <version>2.0.8</version>
        </dependency>
    </dependencies>

spring-aop-schema-advisors.xml

<?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:context="http://www.springframework.org/schema/context"
       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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.spring
    .aop.schema"></context:component-scan>

    <aop:config>
        <aop:aspect id="concurrentOperationRetry" ref="concurrentOperationExecutor">
            <aop:pointcut id="idempotentOperation"
                          expression="execution(* com.spring.aop.schema.advisors.service.*.*(..)) " />
            <aop:around pointcut-ref="idempotentOperation" method="doConcurrentOperation" />

        </aop:aspect>
    </aop:config>

    <bean id="concurrentOperationExecutor" class="com.spring.aop.schema.advisors.ConcurrentOperationExecutor">
        <property name="maxRetries" value="3" />
        <property name="order" value="100" />
    </bean>
</beans>

spring-aop-schema-advice.xml

<?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-4.0.xsd">
    <bean id="aspect" class="com.spring.aop.schema.advice.Aspect"></bean>
    <bean id="aspectBiz" class="com.spring.aop.schema.advice.biz.AspectBiz"></bean>

    <aop:config>
        <aop:aspect id="aspectAOP" ref="aspect">
            <aop:pointcut expression="execution(* com.spring.aop.schema.advice.biz.*Biz.*(..))" id="pointCut"/>
            <aop:before method="before" pointcut-ref="pointCut"/>
            <aop:after method="afterReturning" pointcut-ref="pointCut"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointCut"/>
            <aop:after method="after" pointcut-ref="pointCut"/>
            <aop:around method="around" pointcut-ref="pointCut"/>

            <aop:around method="aroundInit"
                        pointcut="execution(* com.spring.aop.schema.advice.biz.AspectBiz.init(String,int)) and args(bizName,times)"/>
            <aop:declare-parents types-matching="com.spring.aop.schema.advice.biz.*(+)"
                                 implement-interface="com.spring.aop.schema.advice.Fit"
                                 default-impl="com.spring.aop.schema.advice.FitImpl"/>
        </aop:aspect>
    </aop:config>
</beans>

切面类Aspect

package com.spring.aop.schema.advice;

//切面类
public class Aspect {
    public void before(){
        System.out.println("Aspect before.");
    }

    public void afterReturning(){
        System.out.println("afterReturning.");
    }

    public void afterThrowing(){
        System.out.println("afterThrowing.");
    }

    public void after(){
        System.out.println("after.");
    }
}

切面业务类AspectBiz

package com.spring.aop.schema.advice;

//切面业务类
public class AspectBiz {

    public void biz(){
        System.out.println("AspectBiz biz.");
        throw new RuntimeException();
    }
}

Fit.java

public interface Fit {
    void filter();
}

FitImpl.java

package com.spring.aop.schema.advice;

public class FitImpl implements Fit {
    @Override
    public void filter() {
        System.out.println("FitImpl filter.");
    }
}

ConcurrentOperationExecutor.java

package com.spring.aop.schema.advisors;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.core.Ordered;
import org.springframework.dao.PessimisticLockingFailureException;

public class ConcurrentOperationExecutor implements Ordered {

    private static final int DEFAULT_MAX_RETRIES=2;

    private int maxRetries=DEFAULT_MAX_RETRIES;

    private int order=1;

    public void setMaxRetries(int maxRetries){
        this.maxRetries=maxRetries;
    }

    @Override
    public int getOrder() {
        return this.order;
    }

    public void setOrder(int order){
        this.order=order;
    }

    public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable{
        int numAttempts=0;
        PessimisticLockingFailureException lockFailureException;
        do{
            numAttempts++;
            System.out.println("Try times :"+numAttempts);
            try {
                return pjp.proceed();
            } catch (PessimisticLockingFailureException ex) {
                lockFailureException=ex;
            }
        }while(numAttempts<=this.maxRetries);
        System.out.println("Try error "+numAttempts);
        throw lockFailureException;

    }
}

InvokeService.java

package com.spring.aop.schema.advisors.service;

import org.springframework.dao.PessimisticLockingFailureException;
import org.springframework.stereotype.Service;

@Service("invokeService")
public class InvokeService {

    public void invoke(){
        System.out.println("InvokeService...");
    }

    public void  invokeException(){
        throw new PessimisticLockingFailureException("");
    }
}

测试类 testAOP

package com.spring.aop.schema.advice.test;


import com.spring.aop.schema.advice.Fit;
import com.spring.aop.schema.advice.biz.AspectBiz;
import com.spring.aop.schema.advisors.service.InvokeService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class testAOP {
    @Test
    public void TestAOPSchemaAdvice(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-aop-schema-advice.xml");
        AspectBiz biz= (AspectBiz) context.getBean("aspectBiz");
        biz.biz();
    }

    @Test
    public void testInit(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-aop-schema-advice.xml");
        AspectBiz aspectBiz= (AspectBiz) context.getBean("aspectBiz");
        aspectBiz.init("service",3);
    }

    @Test
    public void testFit(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-aop-schema-advice.xml");
        Fit fit= (Fit) context.getBean("aspectBiz");
        fit.filter();
    }

    @Test
    public void testSave(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring-aop-schema-advisors");
        InvokeService service= (InvokeService) context.getBean("invokeService");
        System.out.println();
        service.invokeException();
    }
}

烤鲅鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringAOP学习手记

文章背景近日学习慕课网课程Spring入门篇，我正好看到Spring AOP该章中Advice应用(上)。由于Spring入门篇课程内容录制比较早。录制者是使用的Eclipse编写，但是没有用maven导入jar包。本文从视频内容入手，加入pom.xml文件课方便导入jar。本人为想使用IDEA学习课程的小伙伴提供一篇参考文章，希望各位小伙伴快速入门Spring。项目结构实现代码pom.xml <dependencies> <dependency>
复制链接

扫一扫