package zeh.myspring.spring2annotation.code02annotationaop.aspect;

import com.alibaba.fastjson.JSONObject;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

// 通过AspectJ注解方式配置的Aspect切面类
// 注解方式不用实现指定的Advice通知接口,注解方式不用在springContext.xml中配置切入点Pointcut和通知Advice
@Component
// 注解方式标注为一个组件，将自动实例化该切面类的bean对象。
@Aspect
// 注解方式标注此类为Aspect切面类。
public class UseAnnotationAspect {
    // 目标方法前通知的切面
    // 目标方法执行之前执行下面的切面方法
    // 下述切面中的方法只要被指定的注解标注了， 就确认了切入点Pointcut和通知Advice
    // 下面的方法名称可以任意命名
    // execution()表达式是切面编程中用来定义切入点Pointcut的，execution()表达式的语法很灵活。
    @Before("execution(* zeh.myspring.spring2annotation.code02annotationaop.service.AopUseAnnotationServiceImpl.withAop()) ")
    public Object beforeMethod(JoinPoint jp) throws Throwable {
        System.out.println("====>进入Before方法前切面");
        System.out.println("@Before：执行目标方法之前的切面方法....");
        System.out.println("@Before：目标方法为--" + jp.getSignature().getName());
        System.out.println("====>结束Before方法前切面");
        return jp;
    }

    // --目标方法正常执行完毕后执行下面的切面方法
    // 下面的方法名称可以任意命名
    @AfterReturning(value = "execution(* zeh.myspring.spring2annotation.code02annotationaop.service.AopUseAnnotationServiceImpl.withAop()) ", returning = "result")
    public Object afterReturningMethod(JoinPoint jp, Object result)
            throws Throwable {
        System.out.println("====>进入AfterReturning方法后切面，目标方法正常执行完毕");
        System.out.println("@AfterReturning：目标方法正常执行完毕后的切面方法....");
        System.out.println("@AfterReturning：目标方法为--"
                + jp.getSignature().getName() + ";目标方法的返回结果 --" + result);
        System.out.println("====>结束AfterReturning方法后切面，目标方法正常执行完毕");
        return jp;
    }

    // 目标方法执行完毕后执行下面的切面方法,不管目标方法是否出现异常
    // 下面的方法名称可以任意命名
    @After("execution(* zeh.myspring.spring2annotation.code02annotationaop.service.AopUseAnnotationServiceImpl.withAop()) ")
    public Object afterMethod(JoinPoint jp) throws Throwable {
        System.out.println("====>进入After方法后切面");
        System.out.println("@After：目标方法执行完毕后执行下面的切面方法,不管目标方法是否出现异常后的切面方法....");
        System.out.println("@After：目标方法为--" + jp.getSignature().getName());
        System.out.println("====>结束After方法后切面");
        return jp;
    }

    // 目标方法出现异常后执行下面的切面方法
    // 下面的方法名称可以任意命名
    @AfterThrowing(value = "execution(* zeh.myspring.spring2annotation.code02annotationaop.service.AopUseAnnotationServiceImpl.withAop()) ", throwing = "e")
    public Object afterThorwingMethod(JoinPoint jp, Exception e)
            throws Throwable {
        System.out.println("====>进入AfterThrowing异常切面");
        System.out.println("@AfterThrowing：目标方法正常执行完毕后的切面方法....");
        System.out.println("@AfterThrowing：目标方法为--"
                + jp.getSignature().getName() + ";目标方法的异常信息--" + e);
        System.out.println("====>结束AfterThrowing异常切面");
        return jp;
    }

    // 环绕目标方法的通知的切面
    // 下面的方法名称可以任意命名
    // ProceedingJoinPoint类只支持@Around注解这个Advice
    // @Around注解是环绕注解，可以统一方法前的Pointcut、方法后Pointcut和异常Pointcut。因为ProceedingJoinPoint类可以直接确定何时执行目标方法。
    @Around("execution(* zeh.myspring.spring2annotation.code02annotationaop.service.AopUseAnnotationServiceImpl.withAop()) ")
    public Object around(ProceedingJoinPoint jp) throws Throwable {
        String methodName = jp.getSignature().getName();// 通过jp对象获取当前目标方法的名称，该名称就是@Around()注解中配置的目标方法名称；

        // 目标方法执行结果
        JSONObject result = null;
        try {
            System.out.println("====>进入Around环绕切面");
            System.out.println("@Around：目标方法执行前的切面方法....，目标方法名称：" + methodName);
            /* 执行目标方法 */
            System.out.println("@Around：开始执行目标方法....");
            result = (JSONObject) jp.proceed();
            System.out.println("@Around：目标方法执行结束....");
            System.out.println("@Around：目标方法正常执行完毕后的切面方法....，目标方法名称："
                    + methodName);
        } catch (Exception e) {
            System.out.println("@Around：目标方法出现异常时的切面方法....，目标方法名称："
                    + methodName);
        }
        System.out.println("@Around：目标方法执行完毕后的切面方法，不管是否出现异常....，目标方法名称："
                + methodName);
        System.out.println("====>结束Around环绕切面");

        JSONObject logObject = new JSONObject();
        logObject.put("requestLog", "我是业务响应的日志");
        result.put("logResult", logObject);
        return result;
    }

}

package zeh.myspring.spring2annotation.code02annotationaop.service;

import com.alibaba.fastjson.JSONObject;

// aop业务接口
public interface IAopUseAnnotationService {

    JSONObject withAop() throws Exception;

    String withOutAop() throws Exception;
}

package zeh.myspring.spring2annotation.code02annotationaop.service;

import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Component;

// aop业务接口的实现
// 将service的实现类交给IOC容器管理，Ioc容器将采用反射自动实例化该实例
@Component("aopUseAnnotation")
public class AopUseAnnotationServiceImpl implements IAopUseAnnotationService {
    @Override
    public JSONObject withAop() throws Exception {
        System.out.println("withAop方法执行...");
        JSONObject result = new JSONObject();
        result.put("result", "我是withAop()方法，我被绑定了切面，所以我是目标方法");
        return result;
    }

    @Override
    public String withOutAop() throws Exception {
        System.out.println("withOutAop方法执行...");
        return "我是withOutAop()方法，我没有被绑定切面，所以我不是目标方法";
    }
}

package zeh.myspring.spring2annotation.code02annotationaop;

import com.alibaba.fastjson.JSONObject;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import zeh.myspring.spring2annotation.code02annotationaop.service.IAopUseAnnotationService;

// 使用注解的方式实现aop
// 之前通过传统的bean xml方式实现aop，比较繁琐，现在使用注解的方式实现。
public class RunAopByAnnotationJunit {

    @Test
    public void testAopByAnnotation() {
        String beanXml = "springannotation/code02-applicationContext-annotation-aop.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(beanXml);
        // 获取bean对象，此时的bean对象是代理对象
        IAopUseAnnotationService service = applicationContext.getBean("aopUseAnnotation", IAopUseAnnotationService.class);
        System.out.println(String.format("bean class is %s", service.getClass()));
        try {
            JSONObject result1 = service.withAop();// 执行配置了切面注解的目标方法
            String result2 = service.withOutAop();// 执行没有配置切面注解的目标方法
            System.out.println("最终响应结果result1:" + result1.toString());
            System.out.println("最终响应结果result2:" + result2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}