Spring AOP

A list,

Spring AOP provides a comprehensive AOP solution. Spring seamlessly integrates Spring AOP and IOC with AspectJ to meet all of AOP’s usage requirements in a consistent Spring-based application architecture.

SpringBoot integrates Spring-AOP

Add the dependent

Maven dependencies are added as follows <! <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <! > <dependency> <groupId>org.springframework.boot</groupId> <artifactId> spring-boot-starter-AOP </artifactId> </dependency>Copy the code

Note: No additional configuration is required after the introduction of AOP dependencies is complete. The spring. Aop. auto attribute is enabled by default, meaning that @enableAspectJAutoProxy has been added by default whenever AOP dependencies are introduced. You do not need to add @EnableAspectJAutoProxy to the program main class to enable this.

Write aspect code

The Aspect class uses the @aspect annotation and must add @Component to inject the Aspect class into IOC container management

@Aspect @Component @Slf4j public class TestLog { @Pointcut("execution(* com.yuntian.example.controller.*.*(..) @param jp */ @before ("testLog()") public void doBefore(JoinPoint JP) {/ /... Log.info (" Before method execution :............." ); } @param jp */ @after ("testLog()") public void doAfter(JoinPoint JP) {//... Log.info (" After method execution :............." ); @afterreturning ("testLog()") public void doAfterReturning(JoinPoint jp) {// . Log.info (" Return notification after method execution :............." ); * @param jp * @param e */ @afterthrowing (value="testLog()",throwing="e") public void doAfterThrowing(JoinPoint jp,Exception e) { // ... Log.info (" Exception after method execution :............." ); }}Copy the code

Business code

package com.yuntian.example.controller; import com.yuntian.example.base.Result; import com.yuntian.example.entity.dto.OrderDTO; import com.yuntian.example.entity.vo.OrderVO; import com.yuntian.example.service.OrderService; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; /** * @author yuntian. * @date Created in 18:13 2019/8/7 * @description */ @RestController @RequestMapping("order") public class OrderController { @Resource private OrderService orderService; @PostMapping("/createOrder") public Result createOrder(OrderDTO dto){ OrderVO orderVO= orderService.createOrder(dto); Result<OrderVO> result=new Result<>(); result.setData(orderVO); result.setCode(99); return result; }}Copy the code

The results of

You can see faceted classes that implement logic without intruding into the business code.

Write aspect code, using surround notification

@Aspect @Component @Slf4j public class TestLogAround { @Pointcut("execution(* com.yuntian.example.controller.*.*(..) )") public void testLogAround() {} /** * use the surround notification * @param PJP * @return */ @around ("testLogAround()") public Object doAround(ProceedingJoinPoint pjp){ Object obj=null; Try {log.info(" pre-notification: before execution "); obj=pjp.proceed(); Log.info (" Return notification: after execution "); } catch(Throwable e){log.info(" Exception notification:........ !" ); } return obj; }}Copy the code

The results of

Write aspect code with custom annotations

@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) public @interface MTransaction { @AliasFor("transactionManager") String value() default ""; @AliasFor("value") String transactionManager() default ""; int timeout() default -1; boolean readOnly() default false; Class<? extends Throwable>[] rollbackFor() default {}; String[] rollbackForClassName() default {}; Class<? extends Throwable>[] noRollbackFor() default {}; String[] noRollbackForClassName() default {}; } @Component @Slf4j @Aspect public class TransactionAspect { The @pointcut (" @ the annotation (com) yuntian. Example. The annotation. MTransaction) ") public void transactionAspect () {} / * * * * use around the notice * @param PJP * @return */ @around ("transactionAspect()") public Object doAround(ProceedingJoinPoint PJP) MethodSignature methodSignature = (MethodSignature) pjp.getSignature(); Method method = methodSignature.getMethod(); Object[] args= pjp.getArgs(); Object obj = null; Try {log.info(" Pre-notification: start transaction...") ); MTransaction transaction = method.getAnnotation(MTransaction.class); if (transaction ! = null) {log.info(" transaction: "+ transaction. Value ()); } log.info(" argument: "+ json.tojsonString (args)); obj = pjp.proceed(); Log.info (" Return notification: close transaction..." ); } catch (Throwable e) {log.info(" exception notification: transaction rollback..." ); } return obj; }}Copy the code

The results of

Two, section introduction

Tangent expression

Pointcuts are methods of all classes in the scope

@Pointcut("execution(* com.yuntian.example.controller.*.*(..) )"Copy the code

Pointcuts are annotated methods

 @Pointcut("@annotation(com.yuntian.example.annotation.MTransaction)")
Copy the code

AspectJ indicator

JoinPoint usage

Iv. Reference materials

Blog.csdn.net/XU906722/ar…