2018.4.16

Please correct me for my own lack of understanding~

What is AOP?

The following examples refer to KenWang's blog~

AOP (Aspect Oriented Programming) - Aspect Oriented Programming

AOP and IoC are one of the two core ideas of Spring

It is also a supplement to traditional OOP (Object Oriented Programming)

In OOP, various vertical relationships in real life can be imitated by concepts such as inheritance and polymorphic encapsulation

But OOP doesn't work for mimicking horizontal relationships

What is a horizontal relationship?

Imagine a few real life examples:

1. When operating the ATM, we may perform the following operations:

Withdrawal: start - enter password - withdraw - end
Transfer: start - enter password - transfer - end
Balance: start - enter password - query - end

In this example we can see that if we take the withdrawal and transfer to query the balance as the core operation

Then the operation of entering the password is the " auxiliary operation " called by the core operation

This description does not mean that the importance of auxiliary operations is low, but relative to the core operations of each specialization

Secondary actions appear repetitive and irrelevant

2. The following operations may be required in a shopping system:

Provide transaction management for each order generated
When a user clicks or searches for a certain keyword, we want to count the click-through rate of this type of product
When users log in, log out, and change their passwords, we need to record the location and time of the operation.

All three operations in this example can be thought of as " auxiliaries " to the core business function

How do you understand this with "aspect" and "horizontal relationship"?

We can see that in the ATM example, we draw three straight lines for three unrelated businesses of withdrawal, transfer, and balance inquiry.

And these three services all require the support of the auxiliary function of entering a password

And this red line that cuts into the three black lines is the so-called " cut plane "

The intersection of the red and black lines can be called the " point of tangent "

Also established a " horizontal relationship "

In the idea of aspect-oriented programming AOP

Let core business functions and aspect functions be developed independently

And then weaving the two together is called AOP

Why use AOP?

Like IoC, another core idea of Spring, AOP is also committed to making the code more concise and clear, let us spend more time on the construction of the core code

If in the ATM example

Withdrawal, transfer and balance inquiry are three different services

Now all three services require the support of the "authentication" feature

So what to do?

Maybe you will think of adding a piece of authentication code to these three pieces of code

Maybe you think about writing a separate function and calling it when the three services start

But these methods will produce code duplication and coupling

In summary:

AOP can make business modules more concise and solve the problem of coupling between business logic and auxiliary modules

Getting started with AOP

Additional packages added:

Other Spring required packages are the same as before

We use such an example:

Now there is a login service we need to print the system time before and after login

We take login service as core business and print time as ancillary business

First build the project structure:

Write the Timeprint class in the aspect package:

package com.tzy.aspect;

public class Timeprint
{
	public void printTime ()
	{
		System.out.println("The current time is: "+System.currentTimeMillis());
	}
}

Write the Login class in the serve package:

package com.tzy.serive;

import java.util.Scanner;

public class Login
{
	public void log()
	{
		Scanner sc=new Scanner(System.in);
		System.out.println("Please enter user name:");
		String username=sc.next();
		System.out.println(username+"Login successful!");
	}
}

Write the test class:

package com.tzy.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.tzy.serive.Login;

public class testAOP
{
	public static void main(String args[])
	{
		ApplicationContext context=new ClassPathXmlApplicationContext
				(new String[]{"applicationContext.xml"});
		Login user1=(Login)context.getBean("login");
		user1.log();
	}
}

Now configure the applicationContext:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context      
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   <context:annotation-config/>
      
   <bean name="login" class="com.tzy.serive.Login" >
   </bean>
    <bean id="Timeprint" class="com.tzy.aspect.Timeprint">
   </bean>
   
   <aop:config>
   		<aop:aspect id="time" ref="Timeprint">
   				<aop:pointcut id="test1"
   				expression="execution(* com.tzy.serive.Login.*(..))"/>
   				<aop:before method="printTime" pointcut-ref="test1"/>
   				<aop:after method="printTime" pointcut-ref="test1"/>
   		</aop:aspect>
   </aop:config>
	
  </beans>

run:

Next, explain some of the problems in the configuration file

1. Please refer to the previous article for the assembly of the bean class

2.<aop:aspect>

Use the ref attribute directly when the aspect code is an auto-injected bean

Above we can see the injection to the Timerprint class:

3.<aop:pointcut>与execution

pointcut means to create a pointcut

execution is more complicated

Here first use execution(* *.*(..)) instead

The first occurrence of * means: matching any return type method can be changed to void int double to match a specific return type function

The second occurrence of * means: full class name

The third occurrence of * means: match any method name

The last occurrence of (..) means: match any type and number of parameters

4. <aop before> and others

We need to configure when to execute the aspect code, such as before or after the core business call

There are the following types:

after invokes the notification after the method completes regardless of whether it succeeded or not
after-returning is called after the method has successfully executed
after-throwing is called after a method throws an exception
around is called before and after
before calls the notification before the method call

5.method