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

Editor to share with you how to achieve a simple aop example of springboot, I hope you will learn something after reading this article, let's discuss it together!

Brief introduction

AOP (Aspect-Oriented Programming: aspect-oriented programming)

Aop can encapsulate some tedious, repetitive and irrelevant business logic and deal with it uniformly in one place, which is often used for logging, transaction management, permission control and so on. Aop can enhance a certain method, a certain method, or the whole class without changing the original code logic, which effectively reduces the code coupling and improves the expansibility of the project.

After ok's nonsense, let's get down to business, how to achieve an aop.

To implement aop, first of all, you need to know what you are doing with aop. Let's take journaling today as an example. Because this is the most commonly used, generally for important database operations, we need to record the operator, when, what has been done, and how to implement it. (if you want to know what is done, you have to know which method and which parameters are advanced operations. Let's simply implement an aop)

Let's new a section first.

@ Aspect@Componentpublic class LogAspect {@ Pointcut ("execution (* com.example.mydemos.controller..* (..)") Public void controllerMenthod () {} @ Before ("controllerPointcut ()") public void beforeExecute () {System.out.println ("before...");} @ After ("controllerPointcut ()") public void afterExecute () {System.out.println ("after...");}} about comments

@ Aspect: tell spring that this is a section

@ Component: leave the aspects to spring to manage

@ Pointcut: pointcut, the straightforward point is to specify where you need to cut in, and then the straightforward point is the target method you want to enhance. Here you need to understand the execution expression, where you can specify the methods you need to cut in. You can specify a single method, all the methods of the entire class, some methods of the class, all the methods of all classes under the package, and so on.

@ Before: what needs to be done before the target method is executed

@ After: what needs to be done after the target method is executed

There are also several common notes:

@ Around (you can freely specify the enhanced logic before and after the execution of the target method. You need to manually call the proceed method of ProceedingJoinPoint to execute the target method. If not, the target method will not be executed. If the target method has a return value, you need to return it manually.)

AfterReturning (make enhancements after the normal execution of the target method, use it if you need to get the return value of the method)

@ AfterThrowing (executed when an exception is thrown during the execution of the target method)

Timing of execution:

When you cut into the target method, you first weave Around, then you weave Before. When you exit the target method, you weave Around first, then AfterReturning, and finally After.

Give me a test, controller.

It's just an ordinary controller.

@ RestControllerpublic class HiController {@ GetMapping ("/ hi") public String sayHello () {System.out.println ("hi, good morning~"); return "hi bro ~";}}

My controller is placed under the Pointcut corresponding com.example.mydemos.controller package, so all methods of all classes under this package will be enhanced

Hypothesize before verification

In accordance with the above demo

When I visit "/ hi", I first execute the @ Before corresponding method and output "before..." , then execute the sayHello method in HiController, output "hi, good morning~", and return "hi bro ~". Finally, execute the @ After corresponding method to output "after..."

Verify:

The project runs to visit "/ hi"

Console

Verification successful ~

One of the most basic aop implementation is complete, and then do some advanced operations

Get target method parameters

Another test, controller.

@ RestControllerpublic class HelloController {@ GetMapping ("/ hello/ {title} / {content}") public String sayHello (@ PathVariable ("title") String title, @ PathVariable ("content") String content) {System.out.println (title + ":" + content); return "hello ya~";}}

Now we have two controller, by the way, we can test whether the execution rule is in effect. My rule is that all the methods under com.example.mydemos.controller are enhanced.

HelloController's sayHello method has two parameters, title and content, let's see if we can get it.

JoinPoint is required to obtain the target method parameters, which can be obtained in @ Before and @ After after testing.

@ Before ("controllerPointcut ()") public void beforeExecute (JoinPoint joinPoint) {Object [] args = joinPoint.getArgs (); List list = Arrays.asList (args); System.out.println ("Target method parameters in before"); list.forEach (System.out::println); System.out.println ("before...") } @ After ("controllerPointcut ()") public void afterExecute (JoinPoint joinPoint) {Object [] args = joinPoint.getArgs (); List list = Arrays.asList (args); System.out.println ("Target method parameters in after"); list.forEach (System.out::println); System.out.println ("after...");}

JoinPoint.getArgs () returns an array of object, which is your target method parameter

test

Result

Get the target method name

All methods that conform to the rules will be enhanced, so how do I know which method is currently being executed?

@ Before ("controllerPointcut ()") public void beforeExecute (JoinPoint joinPoint) {String name = joinPoint.getSignature () .getName (); System.out.println ("method name in before:" + name); System.out.println ("before...");} @ After ("controllerPointcut ()") public void afterExecute (JoinPoint joinPoint) {String name = joinPoint.getSignature () .getName () System.out.println (method name in "after:" + name); System.out.println ("after...");}

JoinPoint.getSignature (). GetName () returns the method name

Get the return value of the target method

This requires @ Around or @ AfterReturning.

@ Around@Around ("controllerPointcut ()") public Object aruondExecute (ProceedingJoinPoint joinPoint) throws Throwable {System.out.println ("around before..."); String name = joinPoint.getSignature (). GetName (); Object o = joinPoint.proceed (); System.out.println (the return value of "method" + name + "is" + o "); System.out.println (" around after... "); return o;}

Note that if you use around, you need to manually call ProceedingJoinPoint.proceed to execute the target method, and if the target method has a return value, you need to manually return

Visit "/ hi"

2. @ AfterReturning@AfterReturning (value = "controllerPointcut ()", returning = "result") public void AfterReturningExecute (JoinPoint joinPoint, Object result) {System.out.println ("AfterReturning..."); String name = joinPoint.getSignature (). GetName (); System.out.println (the return value of "method" + name + "is" + result ");}

If you use AfterReturning, you need to add a parameter returning, which is used to receive the return value, and the parameter in the AfterReturning annotation should be the same as that in AfterReturningExecute, otherwise it will not be recognized.

Visit "/ hi"

After reading this article, I believe you have a certain understanding of "how to achieve a simple aop example of springboot". If you want to know more about it, you are welcome to follow the industry information channel. Thank you for reading!

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.