Shulou(Shulou.com)06/02 Report--

This article mainly explains "how to use Aop in SpringBean". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to use Aop in SpringBean.

SpringAOP what is Aop programming

Aop is aspect-oriented programming, and the application scenarios before and after the method are: log printing, transaction implementation, security, and so on.

Because AOP can solve the problem of code redundancy in our program.

AOP of Spring

Advance notice

Post notification

Surround notification

Run Notification

Exception notification

The underlying principle of Aop programming

Dynamic agent technology

Implementation of InvocationHandler bottom layer using reflection Technology based on Jdk

Implementation of bytecode technology based on CGLIB

Start Aop org.springframework spring-context 5.0.5.RELEASE org.aspectj aspectjweaver 1.8.13 based on annotations

Log AOP

@ Aspect// definition facet class @ Component// injection spring container @ EnableAspectJAutoProxy// opens AOPpublic class LogAop {/ / definition pointcut, indicating the entry @ Pointcut ("execution (* com.xuyu.service..*.* (..)") that begins to be intercepted. Public void logAop () {} @ Before ("logAop ()") public void doBefor () {System.out.println ("pre-notification. Intercept before calling a method");} @ After ("logAop ()") public void doAfter () {System.out.println ("post notification. Intercept after the method is called");}}

Config

Configuration@ComponentScan (basePackages = {"com.xuyu.service", "com.xuyu.aop"}) public class MyConfig {}

Service

@ Componentpublic class OrderService {public void addOrder () {System.out.println ("execute target method....");}}

Startup class

Public class App {public static void main (String [] args) {AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext (MyConfig.class); OrderService orderService = applicationContext.getBean ("orderService", OrderService.class); orderService.addOrder ();}}

Execution result

Advance notice. Intercept before calling a method

Execute the target method.

Post notice. Intercept after calling a method

Let's start analyzing the source code.

So we can directly use the @ Import annotation to inject the AspectJAutoProxyRegistrar class into the IOC container

@ Import (AspectJAutoProxyRegistrar.class)

It's equivalent to this comment.

@ EnableAspectJAutoProxy// turn on AOP

Five complete notices

@ Aspect// definition facet class @ Component// injection spring container @ EnableAspectJAutoProxy// opens AOPpublic class LogAop {/ / definition pointcut, indicating the entry @ Pointcut ("execution (* com.xuyu.service..*.* (..)") that begins to be intercepted. Public void logAop () {} @ Before ("logAop ()") public void doBefore () {System.out.println ("advance notice. Intercept ");} @ After (" logAop () ") public void doAfter () {System.out.println (" post notification. Intercept ");} @ AfterReturning (" logAop () ") public void around (JoinPoint joinpoint) throws Throwable {String name = joinpoint.getSignature () .getName (); System.out.println (" return notification.... "+ name);} @ AfterThrowing (" logAop () ") public void afterThrowing (JoinPoint joinPoint) {System.out.println (" exception notification.... ") } @ Around ("logAop ()") public void doAround (ProceedingJoinPoint joinPoint) throws Throwable {System.out.println ("surround notification, processed before target method"); joinPoint.proceed (); / execute target method System.out.println ("surround notification, process after target method....");}}

Print the result

Surround the notification and process it before the target method.

Advance notice. Intercept before calling a method

Target method execution.

Surround the notification and process it after the target method.

Post notice. Intercept after calling a method

Return to the notification. AddOrder

Implementation of manual transactions in springBoot

Manual begin commit rollback

@ Componentpublic class TransactionalUtils {/ / TransactionAspectSupport currentTransactionStatus () .setRollbackOnly (); / * get the current transaction manager * / @ Autowired private DataSourceTransactionManager dataSourceTransactionManager; public TransactionStatus begin () {TransactionStatus transaction = dataSourceTransactionManager.getTransaction (new DefaultTransactionAttribute ()); System.out.println ("get current transaction >"); return transaction } / * commit transaction * / public void commit (TransactionStatus transactionStatus) {System.out.println ("commit current transaction >"); dataSourceTransactionManager.commit (transactionStatus);} public void rollback (TransactionStatus transactionStatus) {System.out.println ("Roll back current transaction >"); dataSourceTransactionManager.rollback (transactionStatus);} @ Servicepublic class OrderService {@ Autowired private OrderInfoMapper orderInfoMapper @ Autowired private TransactionalUtils transactionalUtils; public int addOrderInfo (int j) {TransactionStatus begin = transactionalUtils.begin (); try {int I = orderInfoMapper.addOrderInfo (); int result = 1 / j; transactionalUtils.commit (begin);} catch (Exception e) {e.printStackTrace (); transactionalUtils.rollback (begin);} return 1 }

Manual begin commit rollback code is redundant, so we use AOP to ReFactor manual transactions

Using SpringAop to implement refactoring and declarative transactions

@ Aspect@Component@Scope ("prototype") / / there will be problems with a single case. Here, set to multiple public class TransactionalAop {/ / Aspect definition pointcut class @ Autowired private TransactionalUtils transactionalUtils; / * * @ Pointcut definition pointcut * / @ Pointcut ("execution (* com.mayikt.service..*.* (..)") Public void transactionalAop () {} @ Around ("transactionalAop ()") public Object around (ProceedingJoinPoint joinPoint) throws Throwable {/ / get the method name String methodName = joinPoint.getSignature () .getName (); / / get the target object Class classTarget = joinPoint.getTarget () .getClass (); / / get the target object type Class [] par = ((MethodSignature) joinPoint.getSignature ()) .getParameterTypes () / / get the target object method Method objMethod = classTarget.getMethod (methodName, par); / / determine whether the target method has custom transaction annotations ExtTransactional extTransactional = objMethod.getDeclaredAnnotation (ExtTransactional.class); if (extTransactional = = null) {return joinPoint.proceed (); / / execute the target method} TransactionStatus begin = transactionalUtils.begin () Try {System.out.println ("> execute before surround notification. >"); Object proceed = joinPoint.proceed (); / / execute target scheme System.out.println ("> execute after surround notification. >"); transactionalUtils.commit (begin); return proceed } catch (Exception e) {/ / Target method rolls back the current transaction transactionalUtils.rollback (begin); return 0;}} @ Target ({ElementType.METHOD, ElementType.TYPE}) @ Retention (RetentionPolicy.RUNTIME) @ Documentedpublic @ interface ExtTransactional {} @ ExtTransactionalpublic int addOrderInfo (int j) {int I = orderInfoMapper.addOrderInfo (); return I } Note: if the service layer throws an exception, it is best to use TransactionAspectSupport.currentTransactionStatus (). SetRollbackOnly (); at this point, I believe you have a deeper understanding of "the use of Aop in SpringBean", you might as well do it in practice! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.