本篇文章为你整理了Spring（十四）：SpringAOP及AOP的三种实现方法（spring aop的两种实现方式）的详细内容，包含有spring aop实例讲解 spring aop的两种实现方式 spring aop三种实现方式 spring实现aop的几种方式 Spring（十四）：SpringAOP及AOP的三种实现方法，希望能帮助你了解 Spring（十四）：SpringAOP及AOP的三种实现方法。
一、什么是AOP
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
二、AOP的一些概念
1.Aspect（切面）：切面是通知和切入点的结合。
2.Join point（连接点）：与切入点匹配的执行点，例如执行方法或处理异常。在SpringAOP 中，连接点始终表示方法执行。
3.Advice（通知）：在切面中需要完成的工作。
4.Pointcut（切入点）:切入通知执行的位置。
5.Target（目标）：被通知的对象。
6.proxy（代理）：向目标对象应用通知之后创建的对象。
7.Introduction（引入）：向现有类添加新的方法或属性。
8.Weaving（织入）：将各个方面与其他应用程序类型或对象链接起来，以创建通知的对象。
三、AOP的三种实现方法
首先我们需要导入依赖：
dependency
groupId org.aspectj /groupId
artifactId aspectjweaver /artifactId
version 1.9.9.1 /version
/dependency
1.通过SpringAPI接口进行实现
SpringAOP有五种通知方式，也有对应的接口：
Before：前置通知，在目标方法调用前通知，对应接口：MethodBeforeAdvice；
After：后置通知，在目标方法返回或异常后通知，对应接口：AfterReturningAdvice；
AfterReturning：后置返回通知，在目标方法返回后通知，对应接口：AfterReturningAdvice；
AfterThrowing：异常通知，在目标方法抛出异常后通知，对应接口：ThrowsAdvice；
Around：环绕通知：通知方法会将目标方法包裹起来，对应接口：MethodInterceptor；
我们下面以具体的例子来展示：
（1）定义一个接口
package com.jms.service;
public interface UserService {
void create();
void read();
void update();
void delete();
}
（2）接口的实现类
package com.jms.service;
public class UserServiceImpl implements UserService{
@Override
public void create() {
System.out.println("建立了一个用户信息");
@Override
public void read() {
System.out.println("读取了一个用户信息");
@Override
public void update() {
System.out.println("更新了一个用户信息");
@Override
public void delete() {
System.out.println("删除了了一个用户信息");
}
（3）建立两个类分别继承前置通知和后置返回通知的接口
package com.jms.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class beforeLog implements MethodBeforeAdvice {
@Override
//method：要执行目标对象的方法
//args：参数
//target：目标对象
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("[Debug]" + target.getClass().getName() + "的" + method.getName() + "执行...");
}
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("[Debug]" + target.getClass().getName() + "的" + method.getName() + "执行完成，返回了" + returnValue);
}
（4）xml配置文件
注册bean，并且配置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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd"
bean id="userService" /
bean id="beforeLog" /
bean id="afterLog" /
!--方法一：使用SpringAPI接口--
!--aop配置--
aop:config
!--pointcut：切入点
expression：表达式
aop:pointcut id="pointcut" expression="execution(* com.jms.service.UserServiceImpl.*(..))"/
!--执行环绕增加--
aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/
aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/
/aop:config
public void test1() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserServiceImpl userService = applicationContext.getBean("userService", UserServiceImpl.class)这样执行会报错
因为动态代理代理的是接口，所以必须获取接口
UserService userService = applicationContext.getBean("userService", UserService.class);
userService.create();
}
测试结果如下：
2.自定义类、自定义切面实现
接口以及实现类都与上面相同
（1）自定义切面类
package com.jms.diy;
public class diyAspect {
public void before() {
System.out.println("[Debug]方法执行...");
public void after() {
System.out.println("[Debug]方法执行完成");
}
切面类中自定义通知方法
（2）xml配置文件
注入切面类的Bean，配置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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd"
bean id="userService" /
!--方法二：自定义类，自定义切面--
bean id="diyAspect" /
aop:config
!--自定义切面--
aop:aspect ref="diyAspect"
!--切入点--
aop:pointcut id="pointcut1" expression="execution(* com.jms.service.UserServiceImpl.*(..))"/
aop:after method="after" pointcut-ref="pointcut1"/
aop:before method="before" pointcut-ref="pointcut1"/
/aop:aspect
/aop:config
（3）测试如下
3.通过注解实现
这种实现其实是第二种的注解方式
（1）自定义切面类
package com.jms.diy;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class annotationAspect {
@Before("execution(* com.jms.service.UserServiceImpl.*(..))")
public void before() {
System.out.println("[Debug]方法前置增强");
@After("execution(* com.jms.service.UserServiceImpl.*(..))")
public void after() {
System.out.println("[Debug]方法后置增强");
}
（2）此处还是采用xml配置，也可以采用java类配置
?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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd"
bean id="userService" /
!--方法三：注解--
!--增加注解支持--
context:annotation-config/
context:component-scan base-package="com.jms"/
aop:aspectj-autoproxy/
/beans
（3）测试
（本文仅作个人学习记录用，如有纰漏敬请指正）
以上就是Spring（十四）：SpringAOP及AOP的三种实现方法（spring aop的两种实现方式）的详细内容，想要了解更多 Spring（十四）：SpringAOP及AOP的三种实现方法的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。