Spring aop學習

 

    AOP主要實現的目的是針對業務處理過程當中的切面進行提取，它所面對的是處理過程當中的某個步驟或階段，以得到邏輯過程當中各部分之間低耦合的隔離效果。

    在軟件中，有些行爲對於大多應用都是通用的-----日誌，安全和事務管理等。

    分佈於應用中多處的功能被稱爲橫切關注點，這些橫切關注點從概念上與應用的業務邏輯相分離，每每是嵌入到應用的業務邏輯中，這些橫切關注點與業務邏輯 相分離正是面向切面編程 AOP所須要解決的。

1 aop術語

描述切面術語有通知，切點，鏈接點。

橫切性關注點

對哪些方法進行攔截，攔截該方法後怎麼處理，這些關注就稱之爲橫切面關注點。

Aspect（切面）

指橫切性的關注點的抽象即爲切面，它與類類似，只是二者的關注點不同，類是對物體特徵的抽象，而切面是對橫切性關注點的抽象。

Joinpoint（鏈接點）

鏈接點是切面插入應用程序的地方，該點能被方法調用，並且也會被拋出意外。鏈接點是應用程序提供給切面插入的地方，能夠添加新的方法。

Pointcut(切點)

pointcut能夠控制你把哪些advice應用於jointpoint上去，一般你使用pointcuts經過正則表達式來把明顯的名字和模式進行匹配應用。決定了那個jointpoint會得到通知。

Advice（通知）

所謂通知就是指切入點攔截到Jointpoint（鏈接點）以後要作的事情。通知分爲前置通知（@Before）、後置通知（@AfterReturning）、異常通知（@AfterThrowing）、最終通知（@After）和環繞通知（@Around）。

Target（目標對象）

代理的目標對象。

Weave(織入)

指將aspects應用到target對象並致使proxy對象建立的過程稱爲織入。

Introduction(引入)

在不修改類代碼的前提下，introduction能夠在運行期爲類動態的添加一些方法或Field（字段）。

2 aop編程方式

xml配置切面

<aop:config>
    <aop:aspect  ref="RestartJobAspect ">
         <aop:after—returning  pointcut="execution(* cn.com.sncfc.batch.EdaccSifEndpoint.startEdacc(..))" 
 method="afterJobAspect" />
    </aop:aspect>
</aop:config

註解切面

@Component
@Aspect
public class RestartJobAspect {
  
	@AfterReturning("execution(* cn.com.sncfc.batch.runner.EdaccSifEndpoint.startEdacc(..))")
	public void afterJobAspect() {
		System.out.println("---------------------------------afterJobAspect()");
	}
}

1.RestartJobAspect 爲切面

2.startEdacc（）方法爲切點

3.afterJobAspect（）方法至關於鏈接點方法

4.@AfterReturning爲通知

以上代碼意思是在執行startEdacc（）後執行afterJobAspect（）方法。

3動態代理

jdk1.5中提供，利用反射。實現InvocationHandler接口。

a.業務接口

package Invocation;

public interface Dog {
	
	void run();
	void info();
	
}

b.代理對象

package Invocation;

public class DogUtil implements Dog {

	@Override
	public void run() {
		System.out.println("---------------------------------run()");

	}

	@Override
	public void info() {
		// TODO Auto-generated method stub
		System.out.println("----------------------------------info()");
	}

}

c.代理類

package Invocation;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class InvocationHandlerTest implements InvocationHandler {

	
	private Object target;
	
	public void setTarget(Object target){
		
		this.target = target;
		
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		
		Object result = method.invoke(target, args);
		return result;
				
	}

}

d.工廠類

package Invocation;


public class InvokeFeatory {

	public static Object Proxy(Object target) throws IllegalArgumentException, InstantiationException, IllegalAccessException{
		
		InvocationHandlerTest handle = new InvocationHandlerTest();
		
		handle.setTarget(target);
		
		return  java.lang.reflect.Proxy.newProxyInstance(target.getClass().getClassLoader(),
				 target.getClass().getInterfaces(), handle);
	}
	
}

b.測試類

package Invocation;

public class Test {
	
	
	
	public static void main(String[] args) throws IllegalArgumentException, InstantiationException, IllegalAccessException {
		
		Dog target  = new DogUtil();
		
		Dog dog = (Dog) InvokeFeatory.Proxy(target);
		
		dog.info();
		dog.run();
	}
}

 

輸出結果會是：

----------------------------------info() ---------------------------------run()