Spring（五）AOP的两种简单实现

最新推荐文章于 2022-04-08 11:46:02 发布

卫门口黄大爷

最新推荐文章于 2022-04-08 11:46:02 发布

阅读量177

点赞数

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

本文链接：https://blog.csdn.net/weixin_44962371/article/details/107023709

版权

spring 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Spring-AOP

1. AOP相关术语

连接点（Joinpoint）：业务层接口里的方法全是连接点。
切入点（Pointcut）：被AOP增强的方法。（所有切入点都是连接点，连接点不一定是切入点）
通知/增强（Advice）：指拦截到Joinpoint之后所要做的事情（五种通知）
目标对象（Target）：被代理对象（accountService）
织入（Weaving）：指把增强应用到目标对象来创建新的代理对象的过程
代理（Proxy）： Proxy.newProxyInstance出来的对象
切面（Aspect）：配置增强和执行切入点方法的过程

public IAccountService getAccountService() {
            return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					......
}

在这里插入图片描述

2. 基于XML配置的AOP简单实现

2.1 接口和实现类：

/**
 * 账户的业务层接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
    void saveAccount();
    /**
     * 模拟更新账户
     * @param i
     */
    void updateAccount(int i);
    /**
     * 删除账户
     * @return
     */
    int  deleteAccount();
}

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    @Override
    public void saveAccount() {System.out.println("执行了保存");}
    @Override
    public void updateAccount(int i) {System.out.println("执行了更新"+i);}
    @Override
    public int deleteAccount() {System.out.println("执行了删除");
    return 0;
    }
}

2.2 日志类

public class Logger {
    /**
     * 前置通知
     */
    public  void beforePrintLog(){ System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。"); }
    /**
     * 后置通知
     */
    public  void afterReturnPrintLog(){System.out.println("后置通知Logger类中的afterReturnPrintLog方法开始记录日志了。。。");}
    /**
     * 异常通知
     */
    public  void afterThrowingPrintLog(){System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");}
    /**
     * 最终通知
     */
    public  void afterPrintLog(){System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");}
}

2.3 bean.xml配置

spring中基于XML的AOP配置步骤
    1、把通知Bean也交给spring来管理
    2、使用aop:config标签表明开始AOP的配置
    3、使用aop:aspect标签表明配置切面
            id属性：是给切面提供一个唯一标识
            ref属性：是指定通知类bean的Id。
    4、在aop:aspect标签的内部使用对应标签来配置通知的类型
           我们现在示例是让printLog方法在切入点方法执行之前执行：所以是前置通知
           aop:before：表示配置前置通知
                method属性：用于指定Logger类中哪个方法是前置通知
                pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
        切入点表达式的写法：
            关键字：execution(表达式)
            表达式：
                访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
            标准的表达式写法：
                public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
            访问修饰符可以省略
                void com.itheima.service.impl.AccountServiceImpl.saveAccount()
            返回值可以使用通配符，表示任意返回值
                * com.itheima.service.impl.AccountServiceImpl.saveAccount()
            包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                * *.*.*.*.AccountServiceImpl.saveAccount())
            包名可以使用..表示当前包及其子包
                * *..AccountServiceImpl.saveAccount()
            类名和方法名都可以使用*来实现通配
                * *..*.*()
            参数列表：
                可以直接写数据类型：
                    基本类型直接写名称         int
                    引用类型写包名.类名的方式   java.lang.String
                可以使用通配符表示任意类型，但是必须有参数
                可以使用..表示有无参数均可，有参数可以是任意类型
            全通配写法：
                * *..*.*(..)

<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
	<!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.java.service.impl.AccountServiceImpl"></bean>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.java.utils.Logger"></bean>

    <aop:config>
        <aop:aspect id="logAdvice" ref="logger" >
            <!--前置通知-->
            <aop:before method="beforePrintLog" pointcut="execution(* com.java.service.impl.*.*(..))"></aop:before>
            <!--后置通知-->
            <aop:after-returning method="afterReturnPrintLog" pointcut="execution(* com.java.service.impl.*.*(..))"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut="execution(* com.java.service.impl.*.*(..))"></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="afterPrintLog" pointcut="execution(* com.java.service.impl.*.*(..))"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

简单配置下（切入点表达式重复了很多次，一般是用下面那种方式）

2.4 测试类

public class AOPtest {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        IAccountService as = (IAccountService)ac.getBean("accountService");

        as.saveAccount();
    }
}
//输出：
前置通知Logger类中的beforePrintLog方法开始记录日志了。。。
执行了保存
后置通知Logger类中的afterReturnPrintLog方法开始记录日志了。。。
最终通知Logger类中的afterPrintLog方法开始记录日志了。。。

注意

实际开发中切入点表达式的通常写法：

切到业务层实现类下的所有方法: com.itheima.service.impl..(…)

切入点通用配置（<aop:pointcut ></aop:pointcut>标签）：（更常用）

配置切入点表达式 expression属性用于指定表达式内容
此标签写在aop:aspect标签内部只能当前切面使用
它还可以写在aop:aspect外面，此时就变成了所有切面可用

	<aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.java.service.impl.*.*(..))"></aop:pointcut>
        <aop:aspect id="logAdvice" ref="logger" >
            <!--前置通知-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
            <!--后置通知-->
            <aop:after-returning method="afterReturnPrintLog" pointcut-ref="pt1"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
        </aop:aspect>
    </aop:config>

环绕通知

<aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.java.service.impl.*.*(..))"></aop:pointcut>
        <aop:aspect id="logAdvice" ref="logger" >
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

前面四种通知是通过配置的方式指定增强代码什么时候执行，而环绕通知是通过使用代码控制的方式增强什么时候执行（增强代码写在proceed（）方法的前面就是前置通知，catch里面就是异常通知…）。
ProceedingJoinPoint是Spring框架提供的一个接口，它有个proceed（）方法（此方法就相当于明确调用切入点方法），
该接口可以作为环绕通知的方法参数，在程序执行时，spring框架已经为我们提供该接口的实现类供我们使用（该接口的实现类框架自己写好了）。
getArgs()方法是获取切入点方法的参数，proceed()没有返回值可以不return。

	 public  Object aroundPringLog(ProceedingJoinPoint proceedingJoinPoint){
        Object rtValue = null;
        try {
            Object[] args = proceedingJoinPoint.getArgs();//得到方法执行所需的参数
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。");
            rtValue = proceedingJoinPoint.proceed(args);//明确调用业务层方法（切入点方法）
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。");
            return rtValue;
        } catch (Throwable throwable) {
            throw new RuntimeException(throwable);
        }finally {
        }
    }
//输出
Logger类中的aroundPringLog方法开始记录日志了。。。
执行了保存
Logger类中的aroundPringLog方法开始记录日志了。。。

2. 基于注解的AOP简单实现

2.1 bean.xml配置

比之前多了一个context约束
扫描包和开启注解AOP支持

	<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"
       xmlns:context="http://www.springframework.org/schema/context"
       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">

    <!--配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.java"></context:component-scan>

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

</beans>

2.2 切面类

@Aspect：切面类
@Pointcut：指定切入点表达式（引用时记得带上括号pt1()）

此处spring存在一个BUG：当用注解配置通知时会执行顺序会出问题（XML配置的不会），根据实际需要选择，一般开发中用环绕通知就可以避免

@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {

    @Pointcut("execution(* com.java.service.impl.*.*(..))")
    private void pt1(){}
    /**
     * 前置通知
     */
    @Before("pt1()")
    public  void beforePrintLog(){ System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。"); }
    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public  void afterReturnPrintLog(){
        System.out.println("后置通知Logger类中的afterReturnPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }
    /**
     * 最终通知
     */
    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
  	/**
     * 环绕通知
     */
    //@Around("pt1()")
    public  void aroundPringLog(ProceedingJoinPoint proceedingJoinPoint){
        Object rtValue = null;
        try {
            Object[] args = proceedingJoinPoint.getArgs();
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。");
            rtValue = proceedingJoinPoint.proceed(args);
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。");
        } catch (Throwable throwable) {
        	System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。");
            throw new RuntimeException(throwable);
        }finally {
        	System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。");
        }
    }  
//输出：
前置通知Logger类中的beforePrintLog方法开始记录日志了。。。
执行了保存
最终通知Logger类中的afterPrintLog方法开始记录日志了。。。
后置通知Logger类中的afterReturnPrintLog方法开始记录日志了。。。

2.3 配置类（替换bean.xml）

@EnableAspectJAutoProxy：开始AOP支持

@Configuration
@ComponentScan(basePackages = "com.java")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}

2.4 测试类

public class AOPtest {
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
//        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

        IAccountService as = (IAccountService)ac.getBean("accountService");

        as.saveAccount();
    }
}

卫门口黄大爷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring（五）AOP的两种简单实现

Spring-AOP1. AOP相关术语2. 基于XML配置的AOP2.1 接口和实现类：2.2 日志类2.3 bean.xml配置2.4 测试类1. AOP相关术语连接点（Joinpoint）：业务层接口里的方法全是连接点。切入点（Pointcut）：被AOP增强的方法。（所有切入点都是连接点）通知/增强（Advice）：指拦截到Joinpoint之后所要做的事情（五种通知）目标对象（Target）：被代理对象（accountService）织入（Weaving）：指把增强应用到目标
复制链接

扫一扫