spring框架—AOP编程的两种实现方式

spring框架—AOP编程的两种实现方式，一种是以注解的方式，另一种是在spring.xml文件中配置的方式。
springnAop编程实现有两个工具，如下
1.代理的使用，JDK自带的Proxy代理工具以及sping框架的cglib代理方式
spring框架会根据代理对象的不同来自动选择使用哪一种代理方式：代理对象如果有实现的接口就用JDK的Proxy代理方式，代理对象如果没有接口则使用cglib来实现代理
代理的使用在Spring框架的AOP编程中应用，即面向切面的开发方式
使用场景：当你要权限拦截某个服务，且软件运维监测时候，目标类有实现接口则使用JDK代理，如果目标类没有实现任何接口，则使用cglib的代理方式。
2.代码实现spring框架，核心jar包spring.jar ,切面的开发方式应用jar包：aspectjrt.jar,aspectjweaver.jar,cglib-nodep.jar或者cglib.jar 
注意你的jar包版本是否和jdk匹配，我的是JDK1.7---aspectjrt-1.7.4.jar,aspectjweaver1.7.4.jar
如果你使用注解则需要jar包：common-annotations.jar
你还需要日志包：commons-logging.jar
使用spring cglibAop开发时，实现形式也有两种：
一：注解形式
首先创建一个切面类，使用注解

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

	@Pointcut("execution(* SpringFrame.ImplService.*.doSomething(..))")//要拦截的类方法
	public void anyMethod(){}
	
	@Before("anyMethod()")
	public void doCheckBefore(){
		System.out.println("前置通知");
	}
	@After("anyMethod()")
	public void doCheckAfter(){
		System.out.println("定义最终通知");
	}
	@Around("anyMethod()")//这个拦截如果成功，则被拦截的方法就不能执行了
	public Object around(ProceedingJoinPoint joinPoint){
		System.out.println("环绕通知");
		Object result = null;
		try {
				result = joinPoint.proceed();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return result;
	}
	@AfterReturning(pointcut = "anyMethod()")
	public void doAfterReturnAdvice(){
		System.out.println("定义后置通知");
	}
	@AfterThrowing(pointcut = "anyMethod()",throwing = "ex")
	public void doAfterThrowing(Exception ex){
		System.out.println("定义例外通知");
	}
}

然后再引用库jar包AOP开发就完成了；

二.使用xml配置文件的方式进行AOP开发

在spring配置文件中配置：

	<bean id = "xmlaspect" class="SpringFrame.aspectprogramming.Aspect.XmlAspect"/><!-- 创建切面拦截器，及拦截时要执行的代码类对象 -->
	<aop:config>
		<aop:aspect id="myxmlaspect" ref="xmlaspect">
			<aop:pointcut  id="mycut" expression="execution(* SpringFrame.aspectprogramming.ImplService.*.xmlAspectT(..))"/>
			<aop:around method="around" pointcut-ref="mycut"/>
			<aop:before method="before" pointcut-ref="mycut"/>
			<aop:after  method="after"  pointcut-ref="mycut"/>
			<aop:after-returning method="afterreturning" pointcut-ref="mycut"/>
			<aop:after-throwing  method="afterThrowing" pointcut-ref="mycut"/>
		</aop:aspect>
	</aop:config>
	

配置xml之前先在项目中创建拦截器执行类XmlAspect

import org.aspectj.lang.ProceedingJoinPoint;

public class XmlAspect {

	public void anyMethod(){}
	
	public Object around(ProceedingJoinPoint joinPoint){
		System.out.println("定义环绕通知");
		Object object = null;
		try {
			object = joinPoint.proceed();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return object;
	}
	
	public void before(){
		System.out.println("定义前置通知");
	}
	public void after(){
		System.out.println("定义最终通知");
	}
	public void afterThrowing(){
		System.out.println("定义例外通知");
	}
	public void afterreturning(){
		System.out.println("定义后置通知");
	}
}

这样就完成了对spring的切面编程了，AOP是spring框架中的核心模块，如有问题请大家多多指教。