spring aop实现的2种方式，以及自定义注解

AOP（Aspect Oriented Programming）面向切面编程，通过预编译方式和运行期动态代理实现程序功能的横向多模块统一控制的一种技术。
AOP是OOP的补充，是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP可以分为静态织入与动态织入，静态织入即在编译前将需织入内容写入目标模块中，这样成本非常高。动态织入则不需要改变目标模块。Spring框架实现了AOP，使用注解配置完成AOP比使用XML配置要更加方便与直观。

1、采用注解方式实现spring aop

（1）我们以吃饭为例子，吃饭前要洗手，吃完饭要擦嘴来实现spring aop的例子。
（2）添加相关依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.danni</groupId>
  <artifactId>SpringAopDemo</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.11.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency>
  </dependencies>
</project>

（3）定义基本方法

package com.danni.bean;

public class Eat {
    public void eat(){
        System.out.println("吃饭。");
    }
}

（4）定义切面方法

package com.danni.bean;

@Aspect
public class EatHelper {
    //第一个*表示返回类型，*表示是任意值
    //第二个*表示任意类
    //eat表示指的是eat方法
    @Pointcut("execution(* *.eat())")
    public void eatPointcut(){

    }

    @Before("eatPointcut()")
    public void beforeEat(){
        System.out.println("饭前洗手。");
    }

    @After("eatPointcut()")
    public void afterEat(){
        System.out.println("饭后擦嘴。");
    }

}

（5）配置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-4.3.xsd
                        http://www.springframework.org/schema/aop 
                        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <bean id="eat" class="com.danni.bean.Eat"></bean>

    <bean id="eatHelper" class="com.danni.bean.EatHelper"></bean>

</beans>

（6）编写测试类

package com.danni.aoptest;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.danni.bean.Eat;

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        Eat eat = (Eat) context.getBean("eat");

        eat.eat();
    }

}

---

2、采用在xml中配置的方式实现spring aop

前三步都是一样的不改变，改变的是下面的内容
（4）定义切面方法

package com.danni.bean;

public class EatHelper {
    public void beforeEat(){
        System.out.println("饭前洗手。");
    }

    public void afterEat(){
        System.out.println("饭后擦嘴。");
    }

}

（5）配置applicationContext.xml文件，添加aop的注解

<?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-4.3.xsd
                        http://www.springframework.org/schema/aop 
                        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <bean id="eat" class="com.danni.bean.Eat"></bean>

    <bean id="eatHelper" class="com.danni.bean.EatHelper"></bean>

    <aop:config>
        <aop:aspect ref="eatHelper">
            <aop:before method="beforeEat" pointcut="execution(* *.eat(..))"/>
            <aop:before method="afterEat" pointcut="execution(* *.eat(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

运行控制类，可以看到控制台输出：

饭前洗手。
饭后擦嘴。
吃饭。

---

3、spring aop中@Around @Before @After三个注解的区别？

@Before是在所拦截方法执行之前执行一段逻辑。
@After 是在所拦截方法执行之后执行一段逻辑。
@Around是可以同时在所拦截方法的前后执行一段逻辑。

修改EatHelper类，在其中加入@Around注解即可看到效果：

@Aspect
public class EatHelper {

    //第一个*表示方法的返回值类型，*表示任意值
    //com.danni.bean.*.eat()：*表示com.danni.bean这个包下面的所有类，eat()表示指的是eat()方法
    @Pointcut("execution(* com.danni.bean.*.eat())")
    public void logPointcut(){

    }

    @Around(value = "logPointcut()")
    public void aroundEat(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("around注解下的吃饭前");
        pjp.proceed();
        System.out.println("around注解下的吃饭后");
    }

    @Before(value = "logPointcut()")
    public void beforeEat(){
        System.out.println("before注解下的饭前洗手。");
    }

    @After(value = "logPointcut()")
    public void afterEat(){
        System.out.println("after注解下的饭后擦嘴。");
    }

}

控制台输出：

around注解下的吃饭前
before注解下的饭前洗手。
吃饭。
around注解下的吃饭后
after注解下的饭后擦嘴。

---

4、自定义注解

Retention(保留)注解说明，这种类型的注解会被保留到那个阶段.，有三个值：
1、RetentionPolicy.SOURCE —— 这种类型的Annotations只在源代码级别保留,编译时就会被忽略。
2、RetentionPolicy.CLASS —— 这种类型的Annotations编译时被保留,在class文件中存在,但JVM将会忽略。
3、RetentionPolicy.RUNTIME —— 这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。

@Target注解：用于设定注解使用范围

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。

自定义注解格式：public @interface 注解名 {定义体}

注解方法不能带有参数；
注解方法返回值类型限定为：基本类型、String、Enums、Annotation或者是这些类型的数组；
注解方法可以有默认值；