Spring的AspectJ的AOP(*****)

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

AspectJ是一个基于Java语言的AOP框架

Spring2.0以后新增了对AspectJ切点表达式支持

@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP

AspectJ表达式:

* 语法:execution(表达式)

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

* execution(“* cn.itcast.spring3.demo1.dao.*(..)”) ---只检索当前包

* execution(“* cn.itcast.spring3.demo1.dao..*(..)”) ---检索包及当前包的子包.

* execution(* cn.itcast.dao.GenericDAO+.*(..)) ---检索GenericDAO及子类

AspectJ增强:

@Before 前置通知，相当于BeforeAdvice，

就在方法之前执行.没有办法阻止目标方法执行的.

@AfterReturning 后置通知，相当于AfterReturningAdvice

后置通知,获得方法返回值.

@Around 环绕通知，相当于MethodInterceptor

在可以方法之前和之后来执行的,而且可以阻止目标方法的执行.

@AfterThrowing抛出通知，相当于ThrowAdvice

@After 最终final通知，不管是否异常，该通知都会执行

@DeclareParents 引介通知，相当于IntroductionInterceptor (不要求掌握)

基于AspectJ有两种方式①基于注解②基于XML

引入jar包

需要下载jar包请点击我

第一种：基于注解

第一步:编写被增强的类:UserDao

public class UserDao {
	public void add(){
		System.out.println("添加用户");
	}
	public int update(){
		System.out.println("修改用户");
		return 1;
	}
	public void delete(){
		System.out.println("删除用户");
	}
	public void find(){
		System.out.println("查询用户");
		//int d = 1/ 0;
	}
}

第二步:使用AspectJ注解形式:

@Aspect
public class MyAspect {
	
	@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")
	public void before(JoinPoint joinPoint){
		System.out.println("前置增强...."+joinPoint);
	}
	
	@AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.update(..))",returning="returnVal")
	public void afterReturin(Object returnVal){
		System.out.println("后置增强....方法的返回值:"+returnVal);
	}
	
	@Around(value="MyAspect.myPointcut()")
	public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
		System.out.println("环绕前增强....");
		Object obj = proceedingJoinPoint.proceed();
		System.out.println("环绕后增强....");
		return obj;
	}
	
	@AfterThrowing(value="MyAspect.myPointcut()",throwing="e")
	public void afterThrowing(Throwable e){
		System.out.println("不好了 出异常了!!!"+e.getMessage());
	}
	
	@After("MyAspect.myPointcut()")
	public void after(){
		System.out.println("最终通知...");
	}
	
	@Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")//定义切点
	private void myPointcut(){}
}

第三步:创建applicationContext.xml

<?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"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!-- 自动生成代理  底层就是AnnotationAwareAspectJAutoProxyCreator -->
	<aop:aspectj-autoproxy />

	<bean id="userDao" class="cn.itcast.spring3.demo1.UserDao"></bean>

	<bean id="myAspect" class="cn.itcast.spring3.demo1.MyAspect"></bean>
</beans>

第四步：创建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 {

	@Autowired
	@Qualifier("userDao")
	private UserDao userDao;
	
	@Test
	public void demo1(){
		userDao.add();
		userDao.delete();
		userDao.update();
		userDao.find();
	}
}

第二种：基于XML方式

第一步:编写被增强的类:ProductDao

public class ProductDao {
	public int add(){
		System.out.println("添加商品...");
		int d = 10/0;
		return 100;
	}
	public void update(){
		System.out.println("修改商品...");
	}
	public void delete(){
		System.out.println("删除商品...");
	}
	public void find(){
		System.out.println("查询商品...");
	}
}

第二步:定义切面

public class MyAspectXML {
	
	public void before(){
		System.out.println("前置通知...");
	}
	
	public void afterReturing(Object returnVal){
		System.out.println("后置通知...返回值:"+returnVal);
	}
	
	public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
		System.out.println("环绕前增强....");
		Object result = proceedingJoinPoint.proceed();
		System.out.println("环绕后增强....");
		return result;
	}
	
	public void afterThrowing(Throwable e){
		System.out.println("异常通知..."+e.getMessage());
	}
	
	public void after(){
		System.out.println("最终通知....");
	}
}

第三步:配置applicationContext.xmll

<?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"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	<!-- 定义被增强的类 -->
	<bean id="productDao" class="cn.itcast.spring3.demo2.ProductDao"></bean>
	
	<!-- 定义切面 -->
	<bean id="myAspectXML" class="cn.itcast.spring3.demo2.MyAspectXML"></bean>
	
	<!-- 定义aop配置 -->
	<aop:config>
		<!-- 定义切点: -->
		<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>
		<aop:aspect ref="myAspectXML">
			<!-- 前置通知 -->
			<!-- <aop:before method="before" pointcut-ref="mypointcut"/> -->
			<!-- 后置通知 -->
			<!-- <aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/> -->
			<!-- 环绕通知 -->
			<!-- <aop:around method="around" pointcut-ref="mypointcut"/> -->
			<!-- 异常通知 -->
			<!-- <aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/> -->
			<!-- 最终通知 -->
			<aop:after method="after" pointcut-ref="mypointcut"/>
		</aop:aspect>
	</aop:config>
</beans>

第四步：编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class SpringTest2 {

	@Autowired
	@Qualifier("productDao")
	private ProductDao productDao;
	
	@Test
	public void demo1(){
		productDao.add();
		productDao.find();
		productDao.update();
		productDao.delete();
	}
}

两种方式根据项目需要选择其一就可以。

Spring的AspectJ的AOP(*****)

猜你喜欢