I. Dependencies between methods
As we said in the Spring overview, coupling in programs generally involves coupling between classes, and coupling between methods. We reduce the dependencies between classes through the Ioc container provided by Spring. Today we look at dependencies between methods, using a simulated business code case to analyze problems in the program. Procedure is as follows
Persistence layer interface
public interface AccountMapper {
// Query all methods
List<Account> selectAll(a);
// find the account by id
Account selectById(Integer id);
// Update the account
int update(Account account);
}
Copy the codeBusiness layer implementation code
package com.zxwin.service.impl;
@Service("accountService")
public class AccountServiceImplOld implements AccountService {
private AccountMapper accountMapper;
// The utility class for transaction management is closed, and the implementation class is not given
private TransactionManage transactionManage;
@Autowired
public void setTransactionManage(TransactionManage transactionManage) {
this.transactionManage = transactionManage;
}
@Autowired
public void setAccountMapper(AccountMapper accountMapper) {
this.accountMapper = accountMapper;
}
@Override
public List<Account> findAllAccount(a) {
List<Account> accounts = null;
// Start the transaction
transactionManage.beginTransaction();
try {
accounts = accountMapper.selectAll();
// Commit the transaction
transactionManage.commit();
} catch (SQLException e) {
e.printStackTrace();
// Rollback if an exception occurs
transactionManage.rollback();
}finally {
// The operation to release resources
transactionManage.release();
}
return accounts;
}
// Transfer operation
@Override
public void transfer(Integer sourceId, Integer targetId, double money) {
transactionManage.beginTransaction();
try {
Account source = accountMapper.selectById(sourceId);
Account target = accountMapper.selectById(targetId);
source.setMoney(source.getMoney()-money);
target.setMoney(target.getMoney()+money);
accountMapper.update(source);
accountMapper.update(target);
transactionManage.commit();
} catch (SQLException e) {
e.printStackTrace();
transactionManage.rollback();
}finally{ transactionManage.release(); }}}Copy the codeThrough the above example, we can find that each method in the business code needs to control transactions through the TransactionManage class, which causes a lot of redundancy in the code and reduces our development efficiency. To make matters worse, if methods in the TransactionManage class are modified (such as parameters) we need to change the code in the entire business layer. This is the dependency that exists between methods.
To reduce this dependency, Spring provides our solution, AOP (aspect oriented programming). Before we get to AOP, we can modify the above example code using the techniques we already know.
The problem with the business in the above example is that there is a lot of duplicate transaction control code and the transaction control code is fixed. We can enhance business classes through dynamic proxy techniques, so that business classes only need to perform normal business operations, and transactional operations are enhanced through proxy classes. Let’s take a look at the dynamic proxy application.
Encapsulating classes for dynamic proxy implementations
@Component
public class ServiceAop {
// The proxy class needs to hold a reference to the proxy class
private AccountService accountService;
private TransactionManage transactionManage;
@Autowired
public void setAccountService(AccountService accountService) {
this.accountService = accountService;
}
@Autowired
public void setTransactionManage(TransactionManage transactionManage) {
this.transactionManage = transactionManage;
}
// Get the enhanced business proxy class
@Bean("accountServiceProxy")
public AccountService getAccountService(a){
// Use the third tool class to implement the dynamic proxy method through the subclass
return (AccountService) Enhancer.create(accountService.getClass(),
new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object result = null;
// Enhancements: enable transactions
transactionManage.beginTransaction();
try {
// Execute the proxied method
result = method.invoke(accountService,args);
// Enhancements: Commit transactions
transactionManage.commit();
} catch (Exception e) {
e.printStackTrace();
// Enhancements: rollback transactions
transactionManage.rollback();
}finally {
// Enhancement: Release resources
transactionManage.release();
}
returnresult; }}); }}Copy the codeThe business layer code only needs to implement the business function
@Service("accountService")
public class AccountServiceImpl implements AccountService {
private AccountMapper accountMapper;
private TransactionManage transactionManage;
@Autowired
public void setTransactionManage(TransactionManage transactionManage) {
this.transactionManage = transactionManage;
}
@Autowired
public void setAccountMapper(AccountMapper accountMapper) {
this.accountMapper = accountMapper;
}
@Override
public List<Account> findAllAccount(a) {
List<Account> accounts = null;
accountMapper.selectAll();
return accounts;
}
@Override
public void transfer(Integer sourceId, Integer targetId, double money) {
Account source = null;
Account target = null; source = accountMapper.selectById(sourceId); target = accountMapper.selectById(targetId); source.setMoney(source.getMoney()-money); target.setMoney(target.getMoney()+money); accountMapper.update(source); accountMapper.update(target); transactionManage.commit(); }}Copy the codeThis allows us to separate the business function from the transaction function through dynamic proxy, and even if the transaction function code changes we only need to change it in the enhancement section.
This is the solution to method dependency, and the above example is very helpful in understanding AOP technology in Spring.
Second, AOP concept
AOP(Aspect Oriented Programming) is a technology that realizes unified maintenance of program through precompilation and dynamic proxy at run time. Using AOP, each part of logic business can be separated, so as to reduce the degree of coupling between each part of logic business and improve the reusability of program. Improve development efficiency.
The purpose of AOP is to implement enhancements to existing functionality without modifying the source code while the program is running;
The advantages of AOP include reduced duplication of code; Improve development efficiency; Maintenance is convenient
The implementation of AOP relies on dynamic proxies, so we must first have some understanding of dynamic proxies, in order to better learn AOP
Terminology in AOP
JoinPoint: Join points are the points that are intercepted, which in Spring are methods (Spring only supports join points of method types). That is, all methods in the proxied object
Pointcut: Pointcut is the definition of which JoinPoints we want to intercept. Methods that need to be enhanced
Advice: Advice is what you do when you are intercepted in JoinPoint. Types of notifications: pre-notification, post-notification, exception notification, final notification, surround notification
Introduction: A special notification allows you to dynamically add methods or fields to a class at run time without modifying the code
Target: The Target object of the agent
Proxy: The resulting Proxy class when a class is woven and enhanced by AOP
Weaving is the process of applying enhancements to target objects to create new proxy objects
Aspect: Is a combination of a pointcut and an introduction
Iv. Classification of notices
Notifications are simply operations enhanced by proxied object methods
There are five main types of notification mentioned in the term above. What does each type of notification mean? Let’s look at the first four.
We know that AOP uses dynamic proxy techniques to implement enhancements to existing functionality while the program is running without modifying the program. Let’s look at an example
// This code implements enhancements in the dynamic proxy
InvocationHandler h = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try{
System.out.println("Advance notice");
// Execute the pointcut method
result = method.invoke(arithmetic, args);
System.out.println("Post notification");
}catch (Exception e){
e.printStackTrace();
System.out.println("Exception notification");
}finally {
System.out.println("Final notice");
}
returnresult; }};Copy the codeThe above example explicitly gives the location of the four types of notification
Pre-notification is the action that takes place before a pointcut method; A post-advice is an action that is executed after the pointcut method has normally executed; Exception notification is an action performed after an exception occurs in a pointcut method; The final notification is executed whether the pointcut method executes correctly or not.
Surround notifications are a way that Spring gives us to manually control when notifications are executed in our code. More on that later.
Five, learning springAOP to clear things
The development phase
Programmers write the core business code
Extract common code and make it into notifications (at the end of development)
In a configuration file, the relationship between declared pointcuts and advice is the aspect
Operation phase
The Spring framework monitors the implementation of the pointcut method. Once the pointcut method is monitored to be executed, the proxy mechanism is used to dynamically create the proxy object of the target object, and the corresponding function of the notification is woven into the corresponding position of the proxy object according to the notification category to complete the complete code logic
Six, AOP case
We simulate the usual development of log printing requirements, the first requirements of Serivce layer work through AOP to achieve log printing function
Dependencies to import
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>SpringTest</artifactId>
<version>1.0 the SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.13. RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.8. RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
<! Parsing pointcut expressions -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
</dependencies>
</project>
Copy the codeLet’s start by looking at the business layer code and custom notification classes (classes use methods to implement enhancements to methods in the business layer)
package com.zxwin.service.impl;
// Simulate business layer code
public class UserServiceImpl implements UserService {
@Override
public int updateUser(a) {
System.out.println("Update method executed");
return 0;
}
@Override
public void save(a) {
System.out.println("Save method executed");
}
@Override
public void delete(int i) {
System.out.println("Delete method executed"); }}Copy the codepackage com.zxwin.advice;
// Define the notification class
public class Logger {
// The notification method
public void printLog(a){
System.out.println("Logger started printing logs."); }}Copy the codeLet’s look at the specific configuration of AOP
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
<! --> < span style = "box-sizing: border-box! Important;
<bean id="userService" class="com.zxwin.service.imple.UserServiceImpl"/>
<! -- Give the notification class to Spring management -->
<bean id="logger" class="com.zxwin.advice.Logger"/>
<! -- Configure AOP 1- use the tag < AOP :config> to start configuring AOP 2- use the tag < AOP :config> under the tag < AOP :config> to start configuring the aspect ID property to uniquely identify the aspect ref property used to execute the notification bean 3- Under the tag < AOP :aspect> use tags of different advice types such as < AOP :before> to start configuring the advice method property to identify which method in the advice class to execute the advice. The pointcut property identifies pointcuts (which methods in the business class need to be enhanced by the advice) The value of pointcut requires a pointcut expression format: the access modifier method returns the package name of the value. Package name Package name Class name Method name (parameter) -->
<aop:config>
<aop:aspect id="loggerAdvice" ref="logger">
<aop:before method="printLog" pointcut="execution( public void com.zxwin.service.imple.UserServiceImpl.save())"/>
</aop:aspect>
</aop:config>
</beans>
Copy the codeThe test class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class TestAOP {
@Autowired
private UserService userService;
@Test
public void testLoggerAdvice(a){ userService.save(); }}Copy the codeThe execution result
Logger starts printing logs and executes the save method
You can see that the print log method is executed before the save() method, indicating that our AOP is configured correctly.
We can also write pointcut expressions as wildcards in the configuration above, as follows
-
Access modifiers can be omitted, and the expression of equivalent to the above execution (void com. Zxwin. Service. Imple. UserServiceImpl. The save ())
-
The method’s return value can use wildcards said any return value type, and amend the expression to execution (* com. Zxwin. Service. Imple. UserServiceImpl. The save ())
-
Package names can use wildcards to represent any package. Note that there are several levels of package that require several *
* *.*.*.*.UserServiceImpl.save()
Copy the codePackage names can also be used as.. Represents any package and subpackage, and can be rewritten as
* *.. UserServiceImpl.save()Copy the code- Both class and method names can also be represented with wildcards
* *.. *. * ()Copy the codeThis writing matches the two methods updateUser() and save() in the UserServiceImpl class.
-
The list of parameters
-
You can write the type name directly
- Primitive types can be written directly to the type name
- Reference types need to be written to the full class name
-
You can also use the wildcard * to indicate any type
* *.. UserServiceImpl.*(*) // Matches the delete(int I) methodCopy the code -
Can use.. Indicates whether the parameter is valid or not
* *.. UserServiceImpl.*(*) // All three methods will be matchedCopy the code
-
Through the above expression writing learning, we can write the expression * *.. *. * (..) This expression is an all-wildcard character that matches all methods of the current project and is not recommended.
Our usage principle is to match all methods * com.zxwin.service.impl.*.*(..).
7. Configure other types of notification
In the AOP example above, we only configured pre-notification. We know that there are five types of notification in SpringAOP: pre-notification, post-notification, exception notification, final notification, and surround notification. We will then complete the other notifications based on the above example
Notification class modification
public class Logger {
// Pre-notification
public void beforeLog(a){
System.out.println("Pre-notification beforeLog");
}
// post notification
public void afterReturningLog(a){
System.out.println("AfterReturningLog");
}
// Exception notification
public void afterThrowingLog(a){
System.out.println("Exception Notification afterThrowingLog");
}
// Final notification
public void afterLog(a){
System.out.println("Final notification afterLog"); }}Copy the codeModify section configuration
<aop:config>
<aop:aspect id="loggerAdvice" ref="logger">
<! Configure pointcut expressions that can only be called on the current aspect when placed in the < AOP :aspect> tag. This tag can also be configured under the < AOP :config> tag and can be used by all facets -->
<aop:pointcut id="servicePointcut" expression="execution( * com.zxwin.service.impl.*.*(..) )"/>
<! -- Pre-notification -->
<aop:before method="beforeLog" pointcut-ref="servicePointcut"/>
<! -- Post-notification -->
<aop:after-returning method="afterReturningLog" pointcut-ref="servicePointcut"/>
<! -- Exception notification -->
<aop:after-throwing method="afterThrowingLog" pointcut-ref="servicePointcut"/>
<! -- Final notice -->
<aop:after method="afterLog" pointcut-ref="servicePointcut"/>
</aop:aspect>
</aop:config>
Copy the codeThe test class
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class TestAOP {
@Autowired
private UserService userService;
@Test
public void testLoggerAdvice(a) { userService.save(); }}Copy the codeBeforeLog After the save method is executed afterReturningLog Final notification afterLog
8. Surround notification
Circular notifications in Spring are a way that Spring gives us to manually control when notifications are executed in our code.
Let’s take a look at spring’s configuration for surround notification
<aop:config>
<aop:aspect id="loggerAdvice" ref="logger">
<! Configure pointcut expressions that can only be called on the current aspect when placed in the < AOP :aspect> tag. This tag can also be configured under the < AOP :config> tag and can be used by all facets -->
<aop:pointcut id="servicePointcut" expression="execution( * com.zxwin.service.impl.*.*(..) )"/>
<! -- Surround notification -->
<aop:around method="aroundLog" pointcut-ref="servicePointcut"/>
</aop:aspect>
</aop:config>
Copy the codeWe mentioned above that surround notification is actually a way that Spring gives us to manually control notification execution in our code
public class Logger {
// Pre-notification
public void beforeLog(a){
System.out.println("Pre-notification beforeLog");
}
// post notification
public void afterReturningLog(a){
System.out.println("AfterReturningLog");
}
// Exception notification
public void afterThrowingLog(a){
System.out.println("Exception Notification afterThrowingLog");
}
// Final notification
public void afterLog(a){
System.out.println("Final notification afterLog");
}
Spring provides us with the ProceedingJoinPoint interface, which calls the proceed() method of the interface, which quite explicitly calls the pointcut method. Complete the wrap notification */ around the proceed() method
public void aroundLog(ProceedingJoinPoint pjp){
try {
beforeLog();
pjp.proceed(pjp.getArgs());
afterReturningLog();
} catch (Throwable throwable) {
afterThrowingLog();
throwable.printStackTrace();
}finally{ afterLog(); }}}Copy the codeAOP annotation configuration
<! Add @enableAspectJAutoProxy annotations to the config class if you use a pure annotation configuration.
<aop:aspectj-autoproxy/>
Copy the code@Aspect // Identifies the class as a facet class
@Component("logger")
public class Logger {
// Section expression
@Pointcut("execution(* com.zxwin.service.impl.*.*(..) )"
public void pointcut(a){}
// Pre-notification
@Before("pointcut()")
public void beforeLog(a){
System.out.println("Pre-notification beforeLog");
}
// post notification
@AfterReturning("pointcut()")
public void afterReturningLog(a){
System.out.println("AfterReturningLog");
}
// Exception notification
@AfterThrowing("pointcut()")
public void afterThrowingLog(a){
System.out.println("Exception Notification afterThrowingLog");
}
// Final notification
@After("pointcut()")
public void afterLog(a){
System.out.println("Final notification afterLog");
}
// @around ("pointcut()") does exactly what the other four do
public void aroundLog(ProceedingJoinPoint pjp){
try {
beforeLog();
pjp.proceed(pjp.getArgs());
afterReturningLog();
} catch (Throwable throwable) {
afterThrowingLog();
throwable.printStackTrace();
}finally{ afterLog(); }}}Copy the codeNote: Configuring the other four notifications when using annotation configuration can cause problems with the order of invocation. Surround notification configured with annotations works fine.