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()