Spring(二）面向切面编程AOP

　　这篇博客写的比较累赘，好多相同的程序写了好几遍，主要是为了是自己养成这样的一个编程思路，其中应该不乏错误之处，以后好好学，慢慢改吧。——————jgp

1 AOP介绍

　　1.1什么是AOP

　　面向切面编程（Aspect Oriented Programing）：通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

　　AOP采取横向抽取机制，取代了传统纵向继承体系的重复性代码，主要体现在事务处理、日志管理、权限控制、异常处理等方面，使开发人员在编写业务逻辑时可以专心于核心业务，提高了代码的可重用性可维护性。

　　目前最流行的AOP框架有两个，分别是Spring AOP和AspectJ。

　　传统纵向继承：编写一个类，继承该类，重写该类中的这种需要增强的方法，这样确实可以达到我们的目的，但是一旦需要修改的方法所属的类不是一个类，那么就需要在多写很多子类，增加很多方法，编程量就是一个很大的问题，并且后期要修改，工作量也很大。

　　

　　横向抽取机制：将要增强所用到的代码提取到一个类中，然后对需要增强的方法通过代理类去将其增强即可。

　　

　　1.2 AOP实现原理

　　aop底层将采用代理机制进行实现。

　　接口 + 实现类 ：spring采用 jdk 的动态代理Proxy。

　　实现类：spring 采用 cglib字节码增强。

　　1.3 AOP术语

　　1.target(目标)：需要被代理的类。例如：UserService

　　2.Joinpoint(连接点)：所谓连接点是指那些可能被拦截到的方法。例如：所有的方法

　　3.PointCut (切入点)：已经被增强的连接点。例如：addUser()

　　4.advice(通知/增强)：增强代码。例如：after、before

　　5. Weaving(织入)：是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.

　　6.proxy(代理)：生成的代理对象

　　7. Aspect(切面): 是切入点pointcut和通知advice的结合

2 手动方式实现代理

　　2.1 JDK动态代理

　　JDK动态代理，是对“装饰者”设计模式 简化。使用前提：必须有接口和实现类      不用写配置文件

　　1.目标类：接口 + 实现类

　　2.切面类：MyAspect，用于存通知

　　3.工厂类：编写工厂生成代理

　　4.测试

　　

　　2.1.1 导入jar包

　　

　　2.1.2 接口和实现类

　　　　UserDao.java

public interface UserDao {
    public void save();
    public void find();
}

 　　　　UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save添加用户");
    }
    @Override
    public void find() {
        System.out.println("find查询用户");
    }
}

　　2.1.3 切面类

　　　　MyAspect.java

public class MyAspect {
    public void myBefore(){
        System.out.println("方法执行前");
    }
    public void myAfter(){
        System.out.println("方法执行后");
    }
}

 　　2.1.4 工厂类

public class MyBeanFactory {
    public static UserDao getBean(){
        //1.目标类
        final UserDao userDao= new UserDaoImpl();
        //2.切面类
        final MyAspect myAspect = new MyAspect();
        /* 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
         *     Proxy.newProxyInstance
         *         参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
         *             一般情况：当前类.class.getClassLoader();
         *                     目标类实例.getClass().get...
         *         参数2：Class[] interfaces 代理类需要实现的所有接口
         *             方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
         *             方式2：new Class[]{UserService.class}   
         *             例如：jdbc 驱动  --> DriverManager  获得接口 Connection
         *         参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
         *             提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
         *                 参数31：Object proxy ：代理对象
         *                 参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
         *                     执行方法名：method.getName()
         *                     执行方法：method.invoke(对象，实际参数)
         *                 参数33：Object[] args :方法实际参数 
         */
        return (UserDao) Proxy.newProxyInstance(
                MyBeanFactory.class.getClassLoader(), 
                new Class[]{UserDao.class}, 
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        //前执行
                        myAspect.myBefore();
                        //执行目标类的方法
                        Object obj = method.invoke(userDao, args);
                        //后方法执行
                        myAspect.myAfter();
                        return obj;
                    }
                });
    }
}

 　　2.1.5 测试类

public class TestJDK {
    @Test
    public void demo(){
        UserDao userDao = MyBeanFactory.getBean();
        userDao.save();
        userDao.find();
    }
}

　　测试结果：

　　

　　2.2 CGLIB字节码增强

　　没有接口，只有实现类。

　　采用字节码增强框架cglib，它的底层通过使用一个小而快的字节码处理框架ASM（Java字节码操控框架）来转换字节码，为一个类创建子类，然后对子类进行增强，解决无接口代理问题。

　　自己导包（了解）：

　　

              核心：hibernate-distribution-3.6.10.Finallibytecodecglibcglib-2.2.jar

              依赖：struts-2.3.15.3appsstruts2-blankWEB-INFlibasm-3.3.jar

　　　　Spring的核心包中已经整合以上两个jar包，所以开发中不需要另外导入ASM的jar包了

　　

　　

　　2.2.1 导入jar包

　　

　　2.2.2 目标类

public class BookDao {
    public void delete(){
        System.out.println("delete删除图书");
    }
    public void update(){
        System.out.println("update修改图书");
    }
}

　　2.2.3 切面类

public class MyAspect {
    public void myBefore(){
        System.out.println("方法执行前");
    }
    public void myAfter(){
        System.out.println("方法执行后");
    }
}

 　　2.2.4 工厂类

public class MyBeanFactory {
    public static BookDao getBean(){
        //1.目标类
        final BookDao bookDao= new BookDao();
        //2.切面类
        final MyAspect myAspect = new MyAspect();
        // 3.代理类 ，采用cglib，底层创建目标类的子类
            //3.1 核心类
            Enhancer enhancer = new Enhancer();
            //3.2 确定父类
            enhancer.setSuperclass(bookDao.getClass());
            /* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
             *     intercept() 等效 jdk  invoke()
             *         参数1、参数2、参数3：以invoke一样
             *         参数4：methodProxy 方法的代理
             */
            enhancer.setCallback(new MethodInterceptor(){
                @Override
                public Object intercept(Object proxy, Method method,
                        Object[] args, MethodProxy methodProxy) throws Throwable {
                    myAspect.myBefore();
                    Object obj = method.invoke(bookDao, args);
                    myAspect.myAfter();
                    return obj;
                }
            });
            //3.4 创建代理
        BookDao proxyBookDao = (BookDao) enhancer.create();
        return proxyBookDao;
    }
}

　　2.2.5 测试类

public class TestCGLIB {
    @Test
    public void demo(){
        BookDao bookDao = MyBeanFactory.getBean();
        bookDao.delete();
        bookDao.update();
    }
}

 　　测试结果：

　　

3 Spring编写代理：半自动方式

　　3.1 Spring通知类型

　　Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

　　前置通知 org.springframework.aop.MethodBeforeAdvice 　　  在目标方法执行前实施增强

　　后置通知 org.springframework.aop.AfterReturningAdvice　　  在目标方法执行后实施增强

　　环绕通知 org.aopalliance.intercept.MethodInterceptor　　　　在目标方法执行前后实施增强

　　异常抛出通知 org.springframework.aop.ThrowsAdvice　　　   在方法抛出异常后实施增强

　　引介通知 org.springframework.aop.IntroductionInterceptor　　在目标类中添加一些新的方法和属性，必须手动执行目标方法

try{
   //前置通知
   //执行目标方法
   //后置通知
} catch(){
   //抛出异常通知
}

　　3.2 实现AOP代理

　　让spring 创建代理对象，从spring容器中手动的获取代理对象。就是不用自己编写工厂类了，让Spring中的工厂来生成。

　　基本方法：使用org.springframework.aop.framework.ProxyFactoryBean，这个类为对应的切入点和通知提供了完整的控制能力，生成指定的内容。

　　

　　3.2.1 导入jar包

　　4核心+1依赖+AOP联盟（规范）+spring-aop （实现）  

　　

　　3.2.2 接口和实现类

　　UserDao.java

public interface UserDao {
    public void save();
    public void find();
}

　　UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save添加用户");
    }
    @Override
    public void find() {
        System.out.println("find查询用户");
    }
}

　　3.2.3 切面类

public class MyAspect implements MethodInterceptor{
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("方法执行之前");
        Object obj = mi.proceed();
        System.out.println("方法执行之后");
        return obj;
    }    
}

　　　　注意：我们自己定义的切面类要继承Spring通知类型中的某一个。

　　3.2.4 Spring配置

　　applicationContext.xml（在开发中，一般放在src目录下。在自己写测试程序的时候，为了方便有时候会放到包里）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                              http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 1 创建目标类 -->
    <bean id="userDao" class="com.tcxpz.spring_chapter03.proxy_factory_bean.UserDaoImpl"></bean>
    <!-- 2 创建切面类 -->
    <bean id="myAspect" class="com.tcxpz.spring_chapter03.proxy_factory_bean.MyAspect"></bean>
    <!-- 3 创建代理类 
        * 使用FactoryBean，底层调用 getObject() 返回特殊bean
        * ProxyFactoryBean 用于创建代理工厂bean，生成特殊代理对象
            optimize :强制使用cglib
                <property name="optimize" value="true"></property>
        底层机制
            如果目标类有接口，采用jdk动态代理
            如果没有接口，采用cglib 字节码增强
            如果声明 optimize = true ，无论是否有接口，都采用cglib
    -->
    <bean id="proxyUserDao" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 3.1 代理实现的接口 -->
        <property name="interfaces" value="com.tcxpz.spring_chapter03.proxy_factory_bean.UserDao"></property>
        <!-- 3.2 目标 -->
        <property name="target" ref="userDao"></property>
        <!-- 3.3 用通知增强目标 -->
        <property name="interceptorNames" value="myAspect"></property>
    </bean>    
</beans>

 　　3.2.5 测试类

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save添加用户");
    }
    @Override
    public void find() {
        System.out.println("find查询用户");
    }
}

　　测试结果：

　　

3 Spring AOP编程：全自动

　　3.1 简介

　　上面的半自动方式，测试程序从Spring容器中获得的是代理类对象，如果没有进行代理类的配置，程序就会报错。

　　

　　而如果我们的需求变成这样的呢？

　　如果在配置文件中配置了代理类，我们就获得被增强后的代理类对象，

　　如果在配置文件中没有配置代理类，我们就获得没有被增强的目标对象，

　　这样的程序会更加灵活。

　　

　　3.2 AOP编程

　　3.2.1 导入jar包

　　通过AspectJ切入点表达式确定目标类，在上面7个jar包的基础上再增加一个jar包

       spring-framework-3.0.2.RELEASE-dependenciesorg.aspectjcom.springsource.org.aspectj.weaver1.6.8.RELEASE

 　　

　　3.2.2 接口和实现类

　　UserDao.java

public interface UserDao {
    public void save();
    public void find();
}

　　UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save添加用户");
    }
    @Override
    public void find() {
        System.out.println("find查询用户");
    }
}

　　3.2.3 切面类

public class MyAspect implements MethodInterceptor{
    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("方法执行之前");
        Object obj = mi.proceed();
        System.out.println("方法执行之后");
        return obj;
    }    
}

　　3.2.4 Spring配置

　　这里首先要导入命名空间，可以在这里找到：spring-framework-3.2.0.RELEASEdocsspring-framework-referencehtmlxsd-config.html

　　

　　

　　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">
    <!-- 1 创建目标类 -->
    <bean id="userDao" class="com.tcxpz.spring_chapter04.aop_auto.UserDaoImpl"></bean>
    <!-- 2 创建切面类 -->
    <bean id="myAspect" class="com.tcxpz.spring_chapter04.aop_auto.MyAspect"></bean>
    <!-- 3 aop编程 
        3.1 导入命名空间
        3.2 使用 <aop:config>进行配置
                proxy-target-class="true" 声明时使用cglib代理
            <aop:pointcut> 切入点 ，从目标对象获得具体方法
            <aop:advisor> 特殊的切面，只有一个通知 和 一个切入点
                advice-ref 通知引用
                pointcut-ref 切入点引用
        3.3 切入点表达式
            execution(* com.itheima.c_spring_aop.*.*(..))
            选择方法         返回值任意   包             类名任意   方法名任意   参数任意
    -->
    <aop:config proxy-target-class="true">
        <aop:pointcut expression="execution(* com.tcxpz.spring_chapter04.aop_auto.*.*(..))" id="myPointCut"/>
        <aop:advisor advice-ref="myAspect" pointcut-ref="myPointCut"/>
    </aop:config>
</beans>

　　3.2.5 测试类

public class TestAOP {
    @Test
    public void demo(){
        String xmlPath = "applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.save();
        userDao.find();
    }
}

 　　测试结果：

　　

　　当我们直接只把代理类的配置注释掉之后，并没有报错，测试结果如下，说明程序从Spring容器中直接取到了目标对象，而不是代理对象。

　　

4 AspectJ【掌握】

　　4.1 简介

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

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

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

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

　　主要用途：自定义开发

　　4.2 切入点表达式（重要）

　　1.execution()  用于描述方法 【掌握】

　　语法：execution(修饰符  返回值  包.类.方法名(参数) throws异常)

　　　　修饰符，一般省略

　　　　　　public　　公共方法

　　　　　　  *　　　  任意

　　　　返回值，不能省略

　　　　　　void　  　返回没有值

　　　　　　String　　返回值字符串

　　　　　　* 　　　　任意

　　　　　包，[可以省略]

　　　　　　com.tcxpz.crm固定包

　　　　　　com.tcxpz.crm.*.servicecrm包下面子包任意 （例如：com.tcxpz.crm.staff.service）

　　　　　　com.tcxpz.crm..crm包下面的所有子包（含自己）

　　　　　　com.tcxpz.crm.*.service..crm包下面任意子包，固定目录service，service目录任意包

　　　　   类，[可以省略]

　　　　　　UserServiceImpl　　 指定类

　　　　　　*Impl　　　　　　　 以Impl结尾

　　　　　　User* 　　　　　　   以User开头

　　　　　　　*　　　　　　　　 任意

　　　　方法名，不能省略

　　　　　　addUser　　　　　　固定方法

　　　　　　add*　　　　　　　  以add开头

　　　　　　*Do　　　　　　　　以Do结尾

　　　　　　*　　　　　　　　　 任意

　　2.within:匹配包或子包中的方法(了解)

       　　within(com.tcxpz.aop..*)

　　3.this:匹配实现接口的代理对象中的方法(了解)

       　　this(com.tcxpz.aop.user.UserDAO)

　　4.target:匹配实现接口的目标对象中的方法(了解)

       　　target(com.tcxpz.aop.user.UserDAO)

　　5.args:匹配参数格式符合标准的方法(了解)

       　　args(int,int)

　　6.bean(id)  对指定的bean所有的方法(了解)

      　　 bean('userServiceId')

　　4.3 AspectJ通知类型

　　在上面半自动或者自动方式中，aop联盟定义通知类型是一些接口，我们自己写的切面类必须实现，从而确定方法名称。

　　而aspectj 的通知类型只定义类型名称。我们自己写的切面类不需继承接口，而且方法名称任意。

　　　　before:前置通知(应用：各种校验)

              　　在方法执行前执行，如果通知抛出异常，阻止方法运行

       　　afterReturning:后置通知(应用：常规数据处理)

              　　方法正常返回后执行，如果方法中抛出异常，通知无法执行

              　　必须在方法执行后才执行，所以可以获得方法的返回值。

       　　around:环绕通知(应用：十分强大，可以做任何事情)

              　　方法执行前后分别执行，可以阻止方法的执行

              　　必须手动执行目标方法

       　　afterThrowing:抛出异常通知(应用：包装异常信息)

              　　方法抛出异常后执行，如果方法没有抛出异常，无法执行

       　　after:最终通知(应用：清理现场)

              　　方法执行完毕后执行，无论方法中是否出现异常

　　　　

　　看一下源码就很好理解了

　　

　　

　　

　　4.4 基于XML的声明式AspectJ

　　通过在XML文件中进行配置，来定义切面、切入点及声明通知。

　　　4.4.1 导入jar包

　　4个核心包+依赖包+aop联盟规范+spring aop 实现+aspect 规范+spring aspect 实现

　　

　　4.4.2 接口和实现类

　　UserDao.java

public interface UserDao {
    public void save();
    public void find();
}

　　UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save添加用户");
    }
    @Override
    public void find() {
        System.out.println("find查询用户");
    }
}

　　4.4.3 切面类

　　MyAspect.java

public class MyAspect {
    //前置通知
    public void myBefore(JoinPoint joinPoint){
        System.out.print("前置通知,");
        System.out.print("目标:"+joinPoint.getTarget());
        System.out.println(",方法名称:"+joinPoint.getSignature().getName());
    }
    //后置通知
    public void myAfterReturning(JoinPoint joinPoint,Object returnVal){
        System.out.print("后置通知,");
        System.out.print("方法名称:"+joinPoint.getSignature().getName());
        System.out.println(",返回值:"+returnVal);
    }
    //环绕通知
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕开始");
        //手动执行目标方法
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("环绕结束");
        return obj;
    }
    
    //抛出异常通知
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("异常通知"+e.getMessage());
    }
    
    //最终通知
    public void myAfter(){
        System.out.println("最终通知");
    }
}

　　在切面类中，分别定义了几种不同的通知类型和相应方法。

　　JoinPoint连接点作为参数传递，可以通过该参数获得目标对象的类名、目标方法名和目标方法参数等；

　　需要注意的是，环绕通知必须接受一个类型为ProceedingJoinPoint的参数，返回值必须是Object类型，且必须抛出异常；

　　异常通知中可以传入Throwable类型的参数，用来输出异常信息。

　　4.4.4 Spring配置文件

　　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">
    <!-- 1 目标类 -->
    <bean id="userDao" class="com.tcxpz.spring_pro5.aspectj_xml.UserDaoImpl"></bean>
    <!-- 2 切面 -->
    <bean id="myAspect" class="com.tcxpz.spring_pro5.aspectj_xml.MyAspect"></bean>
    <!-- 3 aop编程 -->
    <aop:config>
        <aop:aspect ref="myAspect">
                <!-- 3.1 配置切入点，通知最后增强哪些方法 -->
            <aop:pointcut expression="execution(* com.tcxpz.spring_pro5.aspectj_xml.*.*(..))" id="myPointCut" />
                <!-- 3.2 关联通知Advice和切入点pointCut -->
                <!-- #1前置通知 -->
            <aop:before method="myBefore" pointcut-ref="myPointCut" />
                <!-- #2后置通知,在方法返回之后执行，就可以获得返回值 returning属性：用于设置后置通知的第二个参数的名称,类型是Object -->
            <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="returnVal" />
                <!-- #3环绕通知 -->
            <aop:around method="myAround" pointcut-ref="myPointCut" />
                <!-- #4 抛出通知：用于处理程序发生异常，就可以接收当前方法产生的异常 -->
                <!-- * 注意：如果程序没有异常，将不会执行增强 -->
                <!-- * throwing属性：用于设置通知第二个参数的名称，类型Throwable -->
            <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e" />
                <!-- #5最终通知：无论程序发生任何事情，都将执行 -->
            <aop:after method="myAfter" pointcut-ref="myPointCut" />
        </aop:aspect>
    </aop:config>
</beans>

　　4.4.5 测试类

　　TestXML.java

public class TestXML {
    @Test    
    public void demo(){
        String xmlPath="applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.save();
        userDao.find();
    }
}

　　测试结果：

　　

　　当我们在UserDaoImpl.java中模拟出现异常时

　　

　　测试结果是这样的

　　

　　上面的结果说明程序从Spring容器中得到了代理对象，

　　如果我们注释掉aop编程部分，程序也不会报错，只是得到的是目标对象，没有增强内容

　　

　　4.5 基于Annotation的声明式AspectJ

　　与传统的AOP编程方式相比，基于XML的生命是AspectJ便捷得多，但是它的缺点是要在Spring文件配置大量的消息。

　　为了解决这个问题，AspectJ框架为AOP提供了一套Annotation注解，用以取代Spring配置文件中为实现AOP功能的臃肿的代码。

　　　　@Aspect：用于定义一个切面
　　　　@Before：用于定义前置通知，相当于BeforeAdvice。

　　　　@AfterReturning：用于定义后置通知，相当于AfterReturningAdvice。

　　　　@Arround：用于定义环绕通知，相当于MethodInterdeptor。

　　　　@AfterThrowing：用于定义抛出通知，相当于ThrowAdvice。

　　　　@After：用于定义最终final通知，不管是否异常，该通知都会执行。

　　　　@DeclareParents：用于定义引介通知，相当于IntroductionInterceptor（不要求掌握）

　　 使用注解的话，很简单，就是把xml方式用注解给替代，其中也就做6件事

　　　　1、使用将切面类配置给spring，相当于<bean id="" class="切面类全限定类名">             @Component

　　　　2、将切面类申明为切面  　　　　@Aspect

　　　　3、申明目标类切入点范围  　　　　 

　　　　　　(1).方法必须private，没有返回值，没有参数

　　　　　　(2).之后使用将其当成方法调用。例如：@After("myPointcut()")　

　　　　4、编写相应的通知

　　　　　　

　　　　5、将目标类配置给spring       @Repository("userDao")

　　　　　　

　　　　6、必须在xml中扫描注解和启用aop

　　　　　　

　　　　　　附上UserDao.java、UserDaoImpl.java、MyAspect.java和applicationContext.xml文件，方便以后复现实验结果

　　　　　　UserDao.java

public interface UserDao {
    public void save();
    public void find();
}

　　　　　　UserDaoImpl.java

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save添加用户");
    }
    @Override
    public void find() {
        System.out.println("find查询用户");
    }
}

 　　　　　　MyAspect.java

@Component
@Aspect
public class MyAspect {
    @Pointcut("execution(* com.tcxpz.spring_pro6.aspectj_anno.*.*(..))")
    private void myPointCut(){}
    //前置通知
    @Before("myPointCut()")
    public void myBefore(JoinPoint joinPoint){
        System.out.print("前置通知,");
        System.out.print("目标:"+joinPoint.getTarget());
        System.out.println(",方法名称:"+joinPoint.getSignature().getName());
    }
    //后置通知
    @AfterReturning(value="myPointCut()",returning="returnVal")
    public void myAfterReturning(JoinPoint joinPoint,Object returnVal){
        System.out.print("后置通知,");
        System.out.print("方法名称:"+joinPoint.getSignature().getName());
        System.out.println(",返回值:"+returnVal);
    }
    //环绕通知
    @Around("myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕开始");
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("环绕结束");
        return obj;
    }
    //抛出异常通知
    @AfterThrowing(value="myPointCut()",throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println("异常通知"+e.getMessage());
    }
    //最终通知
    @After("myPointCut()")
    public void myAfter(){
        System.out.println("最终通知");
    }
}

　　　　　　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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
                            http://www.springframework.org/schema/context
                              http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 扫描包，使注解生效 -->
    <context:component-scan base-package="com.tcxpz.spring_pro6.aspectj_anno"></context:component-scan>                    
    <!-- 使切面开启自动代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

 　　　　7、测试

　　　　　　TestAnnotation.java

public class TestAnnotation {
    @Test    
    public void demo(){
        String xmlPath="applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.save();
        userDao.find();
    }
}

 　　　　测试结果：

　　　　

　　　　当出现异常和在配置文件中关闭自动代理时，测试的结果与基于xml方式相同，说明我们可以很方便地在配置文件中决定是否使用代理对象。

 总结：

　　其实章节最重要的就是aop编程全自动方式和AspectJ框架方式了，要重点掌握。其他的手动和半自动方式，了解他们随需求变化而变化的过程就行。
看第一遍的时候一头雾水，其实自己动手试一试，理清他们之间的相同点和不同点，就很好理解了。