SpringAOP - 注解方式实现


简述


xml配置方式实现AOP → xml实现

 AOP: 
 	- 面向切面编程,
 	- AOP是一种编程范式,Spring将AOP思想引入到框架中,
 	- 使用AOP可以对某个模块的功能进行增强,
 	- SpringAOP底层使用的是动态代理来实现,
 	- 利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率,
 	- AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码
  • 学习AOP的原因:

在OOP中要实现一个功能的增强,可以继承类或实现一个接口来完成,这样就会使得代码的耦合度增强;
AOP思想通过无缝切入来实现,无需继承类或实现接口,从而达到解耦。
可以在不修改源代码的前提下,对程序功能进行增强!(解耦合,强功能)


AOP的术语


  • 通知的类型:
@Before				-- 前置通知(在目标类的方法执行之前执行)
@AfterReturing		-- 后置通知(在目标类的方法正常执行后的通知, 程序出现异常, 则不会执行)
@After				-- 最终通知(在目标类的方法执行之后执行,如果程序出现了异常,最终通知也会执行)
@Around				-- 环绕通知(在目标类方法的执行前后执行)
@AfterThrowing		-- 异常抛出通知(在目标类方法执行出现异常时, 才会调用该通知)
  • 相关术语
Joinpoint(连接点)	-- 连接点是指那些被拦截到的点。在spring中,目标类的所有方法都可当做是一个连接点
Pointcut(切入点)		-- 切入点是指我们要对哪些Joinpoint进行拦截的定义
Advice(通知/增强)	-- 通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介)	-- 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field
Target(目标对象)		-- 代理的目标对象
Weaving(织入)		-- 是指把增强应用到目标对象来创建新的代理对象的过程
Proxy(代理)		-- 一个类通过AOP织入增强后,就会产生一个结果代理类
Aspect(切面)			-- 是切入点与通知的结合

注解方式实现Spring AOP


使用 Maven 来完成

  • 完整构建图
    在这里插入图片描述
  • pom.xml
<!-- 导入4个依赖 -->
<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-webmvc</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aspects</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-test</artifactId>
		<version>5.1.5.RELEASE</version>
	</dependency>

	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
	</dependency>
</dependencies>
  • 导入依赖后的jar包
    在这里插入图片描述
  • MyService 接口
package com.zlk.service;

public interface MyService {

    public void before();
    
    public void after();
    
    public void around();
    
    public void afterReturning();
    
    public void afterThrowing();
}
  • MyServiceImpl 类,被拦截类 (MyService 接口的实现类)
package com.zlk.service.impl;

import org.springframework.stereotype.Service;

import com.zlk.service.MyService;

@Service("myService")  // 等价于==> <bean id="myService" class="com.zlk.service.impl.MyServiceImpl"></bean>
public class MyServiceImpl implements MyService {

    @Override
    public void before() {
        System.out.println("before message");
    }

    @Override
    public void after() {
//        int a = 10 / 0;
        System.out.println("after message");
    }

    @Override
    public void around() {
        System.out.println("around message");
    }

    @Override
    public void afterReturning() {
//        int a = 10 / 0;
        System.out.println("afterReturning message");
    }

    @Override
    public void afterThrowing() {
//        int a = 10 / 0;
        System.out.println("afterThrowing message");
    }
}
  • MyAop 切面类
package com.zlk.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect		// 使用 @Aspect 来声明切面类,注解方式才需要加
@Component  // 让切面类成为Spring管理的Bean,等价于 ==>  <bean id="myAop" class="com.zlk.aop.MyAop"></bean>
public class MyAop {
    
    // 切入点
    @Pointcut("execution(* *..*.before(..))")
    public void anyMethod() { }

    // 测试 @Pointcut
    // 前置通知
    // 在目标类的方法执行之前执行
    @Before("anyMethod()")
    public void beforeAdvice() {
        System.out.println("前置通知!");
    }
    
    // 最终通知
    // 在目标类的方法执行之后执行,如果程序出现了异常,最终通知也会执行
    @After("execution(* *..*.after(..))")
    public void afterAdvice() {
        System.out.println("最终通知!");
    }
    
    // 后置通知
    // 方法正常执行后的通知, 程序出现异常, 则不会执行
    @AfterReturning("execution(* *..*.afterReturning(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知!");
    }
    
    // 环绕通知
    // 在目标类方法的执行前后执行
    @Around("execution(* *..*.around(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) {
        System.out.println("环绕通知 - 前");
        
        try {
            joinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        
        System.out.println("环绕通知 - 后");
    }
    
    // 异常抛出通知
    // 在目标类方法执行出现异常时, 才会调用该通知
    @AfterThrowing("execution(* *..*.afterThrowing(..))")
    public void afterThrowingAdvice() {
        System.out.println("异常抛出通知");
    }
}
  • applicationContext.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">

	<!-- 开启自动代理, 注解方式才需要开启 -->
	<aop:aspectj-autoproxy />
	
	<context:component-scan base-package="com.zlk" />
	
</beans>
  • MyTest 测试类
package com.zlk.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.zlk.service.MyService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class MyTest {

    @Resource(name = "myService")
    private MyService myService;

    @Test
    public void run1() {
        // 测试前置通知
//        myService.before();

        // 测试最终通知
        myService.after();

        // 测试后置通知
//        myService.afterReturning();

        // 测试环绕通知
//        myService.around();

        // 测试异常抛出通知
//        myService.afterThrowing();
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值