day39 09-Spring的AOP：基于AspectJ的通知类型

 AspectJ的六种通知的类型,最后一种不讲,只讲前五种.

 环绕通知是可以阻止目标方法执行的.

<?xml version="1.0" encoding="UTF-8"?>

<!-- 引AOP的约束了,Schema里面必须是带有AOP的. -->

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

package cn.itcast.spring3.demo1;

public class UserDao {

    public void add(){

        System.out.println("添加用户");

    }

    //public void update(){

    public int update(){

        System.out.println("修改用户");

        return 1;

    }

    public void delete(){

        System.out.println("删除用户");

    }

    public void find(){

        //int i = 1/0;

        System.out.println("查询用户");

    }

}

package cn.itcast.spring3.demo1;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

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

    }

}

package cn.itcast.spring3.demo1;

import org.aspectj.lang.JoinPoint;

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;

//我的切面类

/**

 * 切面类:就是切点与增强的结合

 * 切点就是哪些方法要使用什么增强

 * @author zhongzh

 *

 */

@Aspect //用来定义切面

public class MyAspect {

    //写增强的代码,假设现在做的是一个前置增强.

    @Before(value="execution(* cn.itcast.spring3.demo1.UserDao.add(..))") //前置增强的注解是Before 刚一写完Before就报错了,它里面肯定是有属性没写的.学过JDK的注解,如果只想使用它里面的value属性,value是可以不写的.

    //现在只对UserDao.add()应用前置增强.

    public void before(JoinPoint joinPoint){//JointPoint是可以用作增强的一个点.就是被增强的那个方法的描述.

        //System.out.println("前置增强......");

        System.out.println("前置增强......"+joinPoint);

    }

    @AfterReturning(value="execution(* cn.itcast.spring3.demo1.UserDao.update(..))",returning="returnVal")//这里也是要写切面表达式

    //public void afterReturn(){

    public void afterReturn(Object returnVal){

        System.out.println("后置增强....方法的返回值:"+returnVal);

    }

    @Around(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))")

    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

        System.out.println("环绕前增强.....");

        Object obj = proceedingJoinPoint.proceed();

        System.out.println("环绕后增强.....");

        return obj;//如果想要阻止目标方法的执行这里可以return null

    }

    @AfterThrowing(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))",throwing="e")

    public void afterThrowing(Throwable e){

        System.out.println("不好了 出异常了!!!!"+e.getMessage());

    }

    @After(value="execution(* cn.itcast.spring3.demo1.UserDao.find(..))") //最终通知 类似于try catch finally里面的那个finally

    public void after(){

        System.out.println("最终通知....");//最终通知它不管你什么情况下都会执行

    }

}