AOP_面向切面编程初步理解
让咱们先设想一个场景，你正在编写一个我的项目，在开发过程中的多个模块都有某段反复的代码，于是你抉择将其形象成一个办法，而后在须要的中央调用这个办法，当须要批改这段代码时只须要批改这个办法就行。有一天，你的Boss给了新的需要，须要再形象出一个办法，而后再在各个须要这个办法的模块调用这个办法，这可能就让你头疼了，须要批改大量的代码，于是会想，能不能不批改源代码为零碎业务增加某种性能呢？侥幸的是，AOP能够很好的解决这个问题。
简略介绍
AOP:保障开发者不批改源代码的前提下，去为零碎中的业务组件增加某种通用性能,实质是由AOP框架批改业务组件的多个办法的源代码，咱们将其分为两类:
动态AOP
AOP 框架在编译阶段对程序源代码进行批改，生成了动态的 AOP 代理类（生成的*.class文件曾经被改掉了，须要应用特定的编译器），比方 AspectJ。
动静AOP：
AOP 框架在运行阶段对动静生成代理对象（在内存中以 JDK 动静代理，或 CGlib 动静地生成 AOP 代理类），如 SpringAOP。
具体阐明
Spring 的告诉类型
名称--标签-- 阐明
前置告诉--@Before--用于配置前置告诉。指定加强的办法在切入点办法之前执行
后置告诉--@AfterReturning--用于配置后置告诉。指定加强的办法在切入点办法之后执行
盘绕告诉--@Around--用于配置盘绕告诉。指定加强的办法在切入点办法之前和之后都执行
异样告诉--@AfterThrowing--用于配置异样抛出告诉。指定加强的办法在出现异常时执行
最终告诉--@After--用于配置最终告诉。无论加强形式执行是否有异样都会执行
切面类注解--@Aspect--标注该以后类是一个切面类
断点注解--@Pointcut--应用一个返回值为 void 、办法体为空的办法来命名切入点
实战演练
导入依赖包
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.5</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.5</version> </dependency> <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency> <!-- https://mvnrepository.com/artifact/aopalliance/aopalliance --> <dependency> <groupId>aopalliance</groupId> <artifactId>aopalliance</artifactId> <version>1.0</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency></dependencies>创立一个加强类以及其接口
加强类接口:
public interface VisitService {
//用于实现前置告诉，后置告诉，异样告诉，最终告诉void visit(String str) throws Exception;//用于实现盘绕告诉void around();}
加强类：
public class VisitServiceImpl implements VisitService {
//前置，后置，最终，异样告诉的加强类public void visit(String str) throws Exception{ System.out.println(str); if(!str.equalsIgnoreCase("agree")){ throw new Exception("非法拜访"); }}//盘绕告诉的加强类public void around() { System.out.println("盘绕告诉");}}
创立一个切面类
@Component("VisitAspect")
@Aspect //标注以后myAspect是一个切面类
public class VisitAspect_anno {
// 定义切入点表达式// 应用一个返回值为 void 、办法体为空的办法来命名切入点@Pointcut("execution(* Spring_AOP.service.impl.VisitServiceImpl.visit(..))")private void v1() {}//前置告诉@Before("v1()")public void visitBefore(JoinPoint joinPoint) { System.out.println("口令：");}@After("v1()")//最终告诉，无论是否报错，都执行public void visitAfter(JoinPoint joinPoint) { System.out.println("输出实现");}@AfterReturning("v1()")//后置告诉报错不执行public void visitSuccess(JoinPoint joinPoint) { System.out.println("申请胜利，欢送");}@AfterThrowing(value = "v1()",throwing = "ex")//异样告诉，报错后执行public void visitThrow(JoinPoint joinPoint, Throwable ex) { System.out.println("申请失败，回绝");}@Around("execution(* Spring_AOP.service.impl.VisitServiceImpl.around())")//盘绕告诉，如果报错只执行前一句public Object visitAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("-------盘绕-------"); Object obj = proceedingJoinPoint.proceed(); System.out.println("------------------"); return obj;}}
配置xml文件
<!-- 基于注解的申明式 AspectJ --><context:component-scan base-package="Spring_AOP" /><!-- 启动基于注解的申明式 AspectJ 反对一 --><aop:aspectj-autoproxy></aop:aspectj-autoproxy>创立一个测试类
public class visitTest {
@Testpublic void VisitTest(){ ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext_AOP.xml"); VisitService visitService = app.getBean(VisitService.class); try { visitService.visit("agree"); } catch (Exception e) { e.printStackTrace(); } try { visitService.visit("ok"); } catch (Exception e) { e.printStackTrace(); } visitService.around();}}
测试运行
口令：
agree
申请胜利，欢送
输出实现
口令：
ok
申请失败，回绝
输出实现
-------盘绕-------
盘绕告诉
-------盘绕-------
总结
应用结构注入能够更不便的实现AOP模式，然而同样与设置注入相比各有千秋。
以上就是以注解实现SpringAOP框架结构注入的实现。