java注解及应用场景AOP切面

有关注解推荐文章：秒懂，Java 注解 （Annotation）你可以这样学
讲的通俗易懂，很容易理解！下面是我的应用场景springAop切面，很方便。
注解

package com.yt.anno;

import java.lang.annotation.*;

@Documented //记录javadoc
@Target(ElementType.METHOD) //运用到的地方
@Retention(RetentionPolicy.RUNTIME) //注解的生命周期
public @interface LogProcessor {
}

下面是切面

package com.yt.aop;


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.Bean;

/**
 * @ClassName LogAspect
 * @author zyt
 * Create Date: 2019/10/24 11:37
 * Description: 切面
 */


@Aspect
public class LogAspect {

//    @Pointcut("execution(public int com.yt.bean.Cat.eat())")
//    public void pointCut(){
//    }

    @Pointcut("@annotation(com.yt.anno.LogProcessor)")
    public void pointCut(){
    }

    @Before(value = "pointCut()")
    public void logStart(){
        System.out.println("方法之前开始运行：：：：：");
    }

    @After("pointCut()")
    public void logEnd(){
        System.out.println("方法之后开始运行：：：：：");
    }

    @AfterReturning("pointCut()")
    public void logRetrun(){
        System.out.println("方法返回时运行：：：：");
    }

    @AfterThrowing("pointCut()")
    public void logThrow(){
        System.out.println("方法出现异常运行：：：");
    }

    @Around("pointCut()")
    public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("方法环绕增强前：：：：");
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("方法环绕增强后：：：：");
        return proceed;
    }
}

连接点

package com.yt.bean;

import com.yt.anno.LogProcessor;

/**
 * @ClassName Cat
 * @author zyt
 * Create Date: 2019/10/24 11:33
 * Description: 连接点
 */
public class Cat {

    @LogProcessor
    public int eat(int num){
        System.out.println("毛毛要吃饭了。。");
        return num;
    }
}

Spring实体类

/**
 * @ClassName MainConfig
 * @author zyt
 * Create Date: 2019/10/24 11:31
 * Description: 配置类
 */
@Configuration
@EnableAspectJAutoProxy
public class MainConfig {

     @Bean
     public  Cat cat(){
         return new Cat();
     }

     @Bean
     public LogAspect logAspect(){
         return new LogAspect();
     }

}

测试用例

package com.yt;

import static org.junit.Assert.assertTrue;

import com.yt.bean.Cat;
import com.yt.config.MainConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * Unit test for simple App.
 */
public class AppTest 
{
    /**
     * Rigorous Test :-)
     */
    @Test
    public void DemoTest(){
        AnnotationConfigApplicationContext anno = new  
        			AnnotationConfigApplicationContext(MainConfig.class);
        Cat bean = anno.getBean(Cat.class);
        bean.eat(1);
    }
}

返回结果

方法环绕增强前：：：：
方法之前开始运行：：：：：
毛毛要吃饭了。。
方法环绕增强后：：：：
方法之后开始运行：：：：：
方法返回时运行：：：：