Spring的AOP

/**
 * 账户的业务层接口
 * 这是一个新建的类
 */
public interface AccountService {
    /**
     * 模拟保存账户
     */
     void saveAccount();

    /**
     * 模拟更新账户
     * @param i
     */
     void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
     int deleteAccount();
}

public class AccountServiceImpl implements AccountService {

    public void saveAccount() {
        System.out.println("执行了保存操作");
    }

    public void updateAccount(int i) {
        System.out.println("执行了更新操作"+i);
    }

    public int deleteAccount() {
        System.out.println("执行了删除操作");
        return 0;
    }

public class Logger {
    /**
     * 用于打印日志 让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public void printLog(){
        System.out.println("Logger类中的printLog方法开始记录日志了。。。");
    }
}

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">
  <!--配置spring的ioc把service对象配置进来 -->
  <bean id="accountService" class="com.rpf.service.impl.AccountServiceImpl"></bean>

    <!--spring中基于xml的AOP配置步骤
     1. 把通知bean也交给spring来管理
     2. 使用aop:config标签表明开始AOP配置
     3. 使用aop:aspect标签表明开始切面
             id:给切面提供唯一标志
             ref:是指定通知类bean的id
     4. 在aop:aspect标签的内部使用对应的标签来配置通知的类型
               我们现在示例是让sprintLog方法在切入点方法执行之前执行 所以是前置通知
               aop：before 表示配置前置通知
                 method属性：用于指定Logger类中哪个方法是前置通知
                 pointcut属性：用于指定切入点表达式，该表达式含义指的是对业务层中哪些方法增强
                 切入点表达式的写法 ：
                  关键字 execution(表达式)
                  表达式的写法 访问修饰符 返回值 包名.包名.包名...类名.方法名（参数列表）
                  标准表达式写法
                  public void com.rpf.service.impl.AccountServiceImpl.saveAccount()
                  访问修饰符可以省略
                  返回值可以使用通配符 表示任意返回值
                  包名可以使用通配符表示任意包 ，但有几级包就要写几个*. 例 四级包 *.*.*.*
                  包名可以使用..表示当前包及其子包
                  类名和方法名都可以使用*来实现通配
                  * *..*.*()
                  参数可以直接写数据类型
                    基本类型直接写名称             int 直接写int
                    引用类型直接写包名.类名的方式  例 String需要写 java.lang.string
                    类型可以使用通配符表示任意类型，但必须有参数
                    可以用..表示有无参数均可 有参数可以是任意类型
                  全通配写法：
                  * * ..*.*(..)
                  实际开发中切入点表示的通常写法
                   切到业务层实现类下的所有方法
                   * com.rpf.service.impl.*.*(..)
    -->
    <!--配置logger类-->
    <bean id="logger" class="com.rpf.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知类型且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.rpf.service.impl.*.*(..))"></aop:before>
        </aop:aspect>

    </aop:config>
</beans>

  ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        AccountService as=(AccountService)ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();
        as.updateAccount(1);
        as.deleteAccount();

@Service("accountService")
public class AccountServiceImpl implements AccountService {

@Component("logger")
@Aspect//表示当前是一个切面类
public class Logger {
   @Pointcut("execution(* com.rpf.service.impl.*.*(..))")
    private void pt1(){}
    /**
     * 前置通知
     */
   // @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
   // @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }

    /**
     * 异常通知
     */
   // @AfterThrowing("pt1()")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
  //  @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

    /**
     * 环绕通知
     * 问题 当我们配置了环绕通知之后 切入点方法没有执行 而通知方法执行了
     * 分析 通过对比动态代理中的环绕通知代码 发现动态代理中的环绕通知有明确的切入点方法调用
     * 而我们的代码中没有
     * 解决spring框架为我们提供了一个接口 ProceedingJoinPoint 该接口有一个方法proceed() 此方法相当于明确调用切入点方法
     * 该接口可以做为环绕通知的方法参数 在程序执行时 spring会为我们提供该接口的实现类供我们使用
     * spring中的环绕通知
     * 它是spring为我们提供的一种方式 一种可以在代码中手动控制增强方法何时执行的方式
      */
    @Around("pt1()")
    public Object  aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue=null;
        try{
            Object[] args =pjp.getArgs();//得到方法啊运行所需的参数
            System.out.println("环绕通知Logger类中的aroundPringLog方法开始记录日志了。。。");
            rtValue=pjp.proceed();//明确调用切入点方法
            System.out.println("环绕通知Logger类中的aroundPringLog方法开始记录日志了。。。");
            return rtValue;
        }catch (Throwable t){//必须写Throwable
            System.out.println("环绕通知Logger类中的aroundPringLog方法开始记录日志了。。。");
                   throw new RuntimeException(t);
        }finally {
            System.out.println("环绕通知Logger类中的aroundPringLog方法开始记录日志了。。。");
        }


    }

    <!--配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.rpf"></context:component-scan>


    <!--配置AOP的注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

        //1.获取容器
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        AccountService as=(AccountService)ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();