前置通知(前置增强)- before()执行方法前通知
返回通知(返回增强)- afterReturn方法正常结束返回后的通知
异常抛出通知(异常抛出增强)- afetrThrow()
最终通知- after无论方法是否发生异常，均会执行该通知。
环绕通知– around包围一个连接点(join point)的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

切面

切入点与通知的结合，决定了切面的定义，切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么，切面则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切面则是横切关注点抽象。

目标对象

被代理的对象

织入

将切面应用到目标对象并生成代理对象的这个过程即为织入

引入

在不修改原有应用程序代码的情况下，在程序运行期为类动态添加方法或者字段的过程称为引入

谈谈你对AOP的理解？

Aop是面向切面编程，Aop关注的不再是程序代码中某个类，某些方法，而是层与层之间的一种切入
应用于日志记录，性能统计，安全控制，事务处理等方面，实现公共功能性的重复使用。
作用：降低模块与模块之间的耦合度，提高业务代码的聚合度,提高了代码的复用性,可以在不影响原有的功能基础上添加新的功能
动态代理（JDK与CGLIB）实现AOP

SpringAOP的实现

依赖引用

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
</dependency>

spring.xml配置

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd

注解实现

1.定义切面设置通知

package com.lsf.aspect;



import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 定义切面
 *  定义 切入点 与 通知 的结合
 *
 */

@Component  //将该类交给IOC实例化
@Aspect   //声明此类为切面类
public class LogCut 

/**
 * 定义切入点
 *      通过Pointcut定义规则
 *      @Pointcut("execution(* com.lsf.service.*.*(..))")   com.lsf.service下所有方法
 *      例：
 *      1，拦截所有方法
 *      @Pointcut("execution(* *(..))")
 *
 *      2,拦截所有公共的set方法方法
 *      @Pointcut("execution(public set*(..))")
 *
 *
 *  *
 *  *
  */
    @Pointcut("execution(* com.lsf.service.*.*(..))")
    public void cut()

    
    /**
     * 前置通知，引用在切入点
     *  在目标方法调用前
     */


    @Before(value = "cut()")
    public void before()
        System.out.println("这是一个前面通知");

    

    /**
     * 返回通知，引用在切入点
     *  在目标方法无异常返回时输出
     */
    @AfterReturning(value = "cut()")
    public void afterReturn()
        System.out.println("返回通知");
    

    /**
     * 最终通知，引用在切入点
     *  在目标方法是否异常 ，都输出
     */
    @After(value = "cut()")
    public void after()
        System.out.println("最终通知");
    

    /**
     * 异常通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */
    @AfterThrowing(value = "cut()",throwing = "e")
    public void afterThrow(Exception e)
        System.out.println("异常通知：异常原因：  ");
    

    /**
     * 环绕通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */
    @Around(value = "cut()")
    public Object around()
        System.out.println("前置通知");
        Object result = null;
        try 
            System.out.println("返回通知");

        catch (Exception e)
        e.printStackTrace();
            System.out.println("异常通知");
        catch (Throwable throwable)
            throwable.printStackTrace();
        finally 
            System.out.println("最终通知");
        
       
        return result;

2.开启aop

  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3.测试

package com.lsf;


import com.lsf.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Starter 

    public static void main(String[] args) 

        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();

xml实现

1.写切面类

package com.lsf.aspect;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 定义切面
 *  定义 切入点 与 通知 的结合
 *
 */

@Component  //将该类交给IOC实例化
@Aspect   //声明此类为切面类
public class LogCutxml 

    /**
     * 定义切入点
     */

    public void cut()

    
    /**
     * 前置通知，引用在切入点
     *  在目标方法调用前
     */



    public void before()
        System.out.println("这是一个前面通知");

    

    /**
     * 返回通知，引用在切入点
     *  在目标方法无异常返回时输出
     */

    public void afterReturn()
        System.out.println("返回通知");
    

    /**
     * 最终通知，引用在切入点
     *  在目标方法是否异常 ，都输出
     */

    public void after()
        System.out.println("最终通知");
    

    /**
     * 异常通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */

    public void afterThrow(Exception e)
        System.out.println("异常通知：异常原因：  ");
    

    /**
     * 环绕通知，引用在切入点
     *  在目标方法发生异常时 ，都输出
     */

    public Object around()
        System.out.println("前置通知");
        Object result = null;
        try 
            System.out.println("返回通知");

        catch (Exception e)
        e.printStackTrace();
            System.out.println("异常通知");
        catch (Throwable throwable)
            throwable.printStackTrace();
        finally 
            System.out.println("最终通知");
        

        return result;

2.配置aop相关配置

 <!--aop相关配置-->
        <aop:config>
                <!--  aop切面-->
                <aop:aspect ref="logCutxml">
                        <!--定义aop切入点-->
                        <aop:pointcut id="cut" expression="execution(* com.lsf.service..*.*(..))"/><!--配置前置通知指定前置通知方法名︰并引用切入点定义-->
                        <aop:before method="before" pointcut-ref="cut" />
                        <!--配置返回通知指定返回通知方法名并引用切入点定义-->
                        <aop:after-returning method="afterReturn" pointcut-ref="cut"/><!--配置异常通知指定异常通知方法名并引用切入点定义-->
                        <aop:after-throwing method="afterThrow" throwing="e" pointcut-ref="cut" />
                        <!-- 配置最终通知指定最终通知方法名并引用切入点定义-->
                        <aop:after method="after" pointcut-ref="cut" />
                        <!--配置指定环绕通知方法名并引用切入点定义-->
                        <aop:around method="around" pointcut-ref="cut"/>
        </aop:aspect>
</aop:config>

3.测试

package com.lsf;


import com.lsf.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Starter 

    public static void main(String[] args) 

        ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) ac.getBean("userService");
        userService.test();