ASPECTJ annotation configuration for Spring AOP instances

http://blog.csdn.net/xiaoxian8023/article/details/17285809

The XML configuration of the spring AOP instance is explained in the previous blog post, which explains how to configure Spring AOP by ASPECTJ annotations today.

The JDK proxy, interface and implementation class code are still used, please refer to the previous blog post. The main is to share the aspect class:

[Java]View Plaincopy

2. Package COM.TGB.AOP;
6. Import Org.aspectj.lang.JoinPoint;
8. Import Org.aspectj.lang.ProceedingJoinPoint;
10. Import Org.aspectj.lang.annotation.After;
12. Import org.aspectj.lang.annotation.AfterReturning;
14. Import org.aspectj.lang.annotation.AfterThrowing;
16. Import Org.aspectj.lang.annotation.Around;
18. Import Org.aspectj.lang.annotation.Aspect;
20. Import Org.aspectj.lang.annotation.Before;
22. Import org.aspectj.lang.annotation.DeclareParents;
24. Import Org.aspectj.lang.annotation.Pointcut;
28. /**
30. * Test after,before,around,throwing,returning Advice.
32. * @author Admin
34. *
36. */
38. @Aspect
40. Public class Aspcejadvice {
44. /** 
46. * Pointcut
48. * The name of the definition pointcut,pointcut is Aspectjmethod (), this method has no return value and parameter
50. * The method is an identity, not a call
52. */
54. @Pointcut ("Execution (* find* (..))")
56. private void Aspectjmethod () {};
60. /**  
62. * Before
64. * Execution before core business execution, cannot prevent the call of core business.
66. * @param joinpoint
68. */
70. @Before ("Aspectjmethod ()")
72. public void Beforeadvice (Joinpoint joinpoint) {
74. System.out.println ("-----beforeadvice (). Invoke-----");
76. System.out.println ("Do some security judgments and so on before executing the core business logic");
78. System.out.println ("Can get what you need through Joinpoint");
80. System.out.println ("-----End of Beforeadvice ()------");
82. }
86. /**  
88. * After
90. * After the core business logic exits (including normal execution end and abnormal exit), perform this advice
92. * @param joinpoint
94. */
96. @After (value = "Aspectjmethod ()")
98. public void Afteradvice (Joinpoint joinpoint) {
100. System.out.println ("-----afteradvice (). Invoke-----");
102. System.out.println ("Do some logging operations and so on after executing the core business logic");
104. System.out.println ("Can get what you need through Joinpoint");
106. System.out.println ("-----End of Afteradvice ()------");
108. }
112. /**  
114. * Around
116. * Manual control calls the core business logic, as well as pre-and post-call processing,
118. *
120. * Note: When the core business throws an exception, exit immediately and turn to Afteradvice
122. * Finish Afteradvice, then go to Throwingadvice
124. * @param PJP
126. * @return
128. * @throws Throwable
130. */
132. @Around (value = "Aspectjmethod ()")
134. Public Object Aroundadvice (proceedingjoinpoint pjp) throws Throwable {
136. System.out.println ("-----aroundadvice (). Invoke-----");
138. System.out.println ("Things like before advice can be done here");
142. //Call Core Logic
144. Object RetVal = Pjp.proceed ();
146. System.out.println ("Things like after advice" can be done here);
148. System.out.println ("-----End of Aroundadvice ()------");
150. return retVal;
152. }
156. /**  
158. * afterreturning
160. * Core business logic call after normal exit, regardless of whether there is a return value, after normal exit, do this advice
162. * @param joinpoint
164. */
166. @AfterReturning (value = "Aspectjmethod ()", returning = "RetVal")
168. public void Afterreturningadvice (Joinpoint joinpoint, String retVal) {
170. System.out.println ("-----afterreturningadvice (). Invoke-----");
172. System.out.println ("Return Value:" + retVal);
174. System.out.println ("The return value can be further processed here");
176. System.out.println ("Can get what you need through Joinpoint");
178. System.out.println ("-----End of Afterreturningadvice ()------");
180. }
184. /** 
186. * Core business logic call after exception exit, execute this advice, handle error message
188. *
190. * Note: Execution sequence after around advice
192. * @param joinpoint
194. * @param ex
196. */
198. @AfterThrowing (value = "Aspectjmethod ()", throwing = "ex")
200. public void Afterthrowingadvice (Joinpoint joinpoint, Exception ex) {
202. System.out.println ("-----afterthrowingadvice (). Invoke-----");
204. SYSTEM.OUT.PRINTLN ("error message:" +ex.getmessage ());
206. System.out.println ("Here is intended to perform core business logic errors, catch exceptions, and can do some logging operations, etc.");
208. System.out.println ("Can get what you need through Joinpoint");
210. System.out.println ("-----End of Afterthrowingadvice ()------");
212. }
214. }

In Application-config.xml, you only need to configure the business logic bean and the aspect bean, and enable aspect annotations:

2. <? XML version= "1.0" encoding="UTF-8"?>
6. <beans xmlns="Http://www.springframework.org/schema/beans"
8. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
10. xmlns:aop="HTTP://WWW.SPRINGFRAMEWORK.ORG/SCHEMA/AOP"
12. xmlns:tx="Http://www.springframework.org/schema/tx"
14. xsi:schemalocation= "Http://www.springframework.org/schema/beans Http://www.springframework.org/schema/beans /spring-beans-2.0.xsd
16. HTTP://WWW.SPRINGFRAMEWORK.ORG/SCHEMA/AOP http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
18. Http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd ">
22. <!--enable ASPECTJ support for annotation-
24. <aop:aspectj-autoproxy/>
28. <Bean id= "usermanager" class="Com.tgb.aop.UserManagerImpl"/>
30. <Bean id= "aspcejhandler" class="Com.tgb.aop.AspceJAdvice"/>
34. </Beans>

The order in which the Aroundadvice, Beforeadvice, Afteradvice, Returningadvice are executed is determined by the order of the annotations. But sometimes the order is changed, and the result is not changed, possibly because of the cache. I had this problem a few days ago, but I tested it again today and found that the order of execution was consistent with the order of the annotations.

Both XML and Annotation annotations can be configured as configuration items to manage Spring AOP, so what are the pros and cons of each?

First, talk about XML. XML is almost always used as a configuration item in Web applications, such as the framework Struts, Spring, Hibernate, and so on, which are used as configurations. XML is so popular because many of its advantages are irreplaceable in the configuration of other technologies:

• The biggest advantage of XML as an Extensible Markup language is that developers can tailor the applicable markup to the software to make the code more understandable.
• The use of XML configuration can make the software more extensible. Spring, for example, configures dependencies between classes in XML to maximize the scalability of the application.
• Proven validation mechanism to ensure program correctness. Using a Schema or DTD, you can validate the correctness of the XML and avoid an illegal configuration that results in an application error.
• Modify the configuration without changing the existing program.

Although there are so many advantages, but after all, there is no omnipotent thing, XML has its own shortcomings.

• Support for parsing tools or class libraries is required.
• Parsing XML is bound to affect application performance and consume system resources.
• Too many profiles cause management to become difficult.
• The compilation period cannot validate the correctness of its configuration items, or the error can only be run during runtime.
• The IDE cannot verify the correctness of the configuration items.
• It becomes difficult to find fault. Often the configuration of a hand mistakenly leads to inexplicable errors.
• Developers have to maintain code and configuration files at the same time, and development inefficiencies become inefficient.
• There are unspoken rules between the configuration item and the code. Change either party may affect the other party.

Let's look at the advantages of Annotation.

• Save in the class file to reduce maintenance costs.
• No tooling support, no parsing required.
• Compile time to verify correctness, error checking becomes easy.
• Improve development efficiency.

The same Annotation is not omnipotent, it also has a lot of shortcomings.

• To modify a configuration item, you have to modify the Java file to recompile the packaged app.
• The configuration item is encoded in a Java file, which is poor extensibility.

Summary: No one thing is omnipotent, the same XML and Java Annotation have their own advantages and disadvantages. By contrast, careful readers may have found that their strengths and weaknesses are complementary. The strength of XML is not Annotation, and Annotation's advantage is the lack of XML. This is why the current popular XML + Annotation configuration. Balance is the kingly way!

ASPECTJ annotation configuration for Spring AOP instances