1. 引入AspectJ
2. 简单使用Aspect注解
3. AspectJ基础知识
4. 例子
5. execution()
6. @annotation()
7. args()与@args()
8. within()
9. target()
10. @within()和@target()
11. 引介增强用法
12. this()

引入AspectJ

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjtools -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjtools</artifactId>
    <version>1.9.4</version>
</dependency>

简单使用Aspect注解

public interface MyInterFace {
    void m1();

    void m2();

    void m3(String name);
}

public class MyImplClass implements MyInterFace {
    public void m1() {
        System.out.println("m1方法执行");
    }

    public void m2() {
        System.out.println("m2方法执行");
    }

    public void m3(String name) {
        System.out.println("m3方法执行, 参数是" + name);
    }
}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectAdvisor {

    @Before("execution(* m1(..))")
    public void enhance() {
        System.out.println("m1方法前的增强");
    }

    public static void main(String[] args) {
        MyImplClass myImplClass = new MyImplClass();
        myImplClass.m1();
        myImplClass.m2();
    }
}

public static void main(String[] args) {
    MyImplClass target = new MyImplClass();

    AspectJProxyFactory factory = new AspectJProxyFactory();

    factory.setTarget(target);
    factory.addAspect(AspectAdvisor.class);

    MyImplClass proxy = (MyImplClass) factory.getProxy();

    proxy.m1();
    proxy.m2();
}

AspectJ基础知识

1. execution(), 参数是一个方法模式匹配串, 最后会按照匹配方法来确定具体的方法.
2. @annotation, 参数是一个注解类的名称, 匹配所有使用了这个注解类的方法
3. args(), 参数是一个类, 如果这个类和目标类的方法的参数相同, 就匹配上了.
4. @args(), 参数是一个类, 这个玩意是匹配目标类的方法的参数是不是经过指定的类的注解, 如果是就匹配上了.
5. within(), 参数是一个类名的模式匹配串, 会匹配到类之后, 对个类下边所有的连接点生效. 注意仅匹配类, 匹配到类之后, 类下边所有方法自动生效.
6. target(), 参数是一个类名, 这个是匹配一批类, 比如参数是一个接口的话, 这个接口及其所有实现类的所有连接点都匹配成功.
7. @within(), 参数是一个注解类名, 被注解类注解的类会得到增强.
8. @target(), 参数是一个注解类名, 被注解类注解的类会得到增强, 经过我试验, 这个和@within()的作用一样, 需要哪个类就给哪个类加注解.
9. this(), 参数是一个类名, 生成的代理类匹配于参数类的话, 被代理的目标类的所有连接点都匹配改切点, 有点抽象. 这个实际上可以逆向的去给一些类加上增强.

1. *, 匹配任意字符, 但只能匹配一个元素
2. .., 分两种情况: 匹配多个元素的时候需要和*搭配使用, 表示匹配任意类; 使用在参数的场合可以表示任意多个参数.
3. +, 表示按照类型匹配+之前的类型, 比如com.car.benz+, 表示匹配benz及其所有继承或者扩展的类.

1. @Before, 前置增强, value成员用于定义切点, argNames用于在运行时指定标注了增强方法的参数名称, 多个参数名用逗号分割, 有了argNames, 增强方法就可以获取参数了.
2. @AfterReturning, 后置增强, value成员用于定义切点, argNames和上边一样. pointcut表示切点, 如果设置pointcut会覆盖value. returning成员可以把目标对象方法的返回值绑定给增强的方法.
3. @Around, 环绕增强, value成员用于定义切点, argNames和上边一样.
4. @AfterThrowing, 异常增强, value成员用于定义切点, argNames和上边一样. pointcut和上边一样. throwing用于让增强方法可以获取异常对象
5. @After, 究极增强, 就是不管被增强的方法出了异常还是执行完成, 都会执行这个增强. value成员用于定义切点, argNames和上边一样.
6. @DeclareParents, 引介增强, value成员用于定义切点, defaultImpl成员是一个想要添加进来的接口的实现类, 后边专门看.

例子

public interface Waiter {

    void greetTo(String clientName);

    void serveTo(String clientName);
}

public class NaiveWaiter implements Waiter{

    @Override
    public void greetTo(String clientName) {
        System.out.println("NaiveWaiter的greetTo方法, 向" + clientName + "问好");
    }

    @Override
    public void serveTo(String clientName) {
        System.out.println("NaiveWaiter的serveTo方法, 向" + clientName + "提供服务");
    }

    public void smile(String clientName, int times) {
        System.out.println("NaiveWaiter的smile方法, 向" + clientName + "笑了" + times + "次");
    }
}

public class NaughtyWaiter implements Waiter {

    @Override
    public void greetTo(String clientName) {
        System.out.println("NaughtyWaiter的greetTo方法, 向" + clientName + "问好");
    }

    @Override
    public void serveTo(String clientName) {
        System.out.println("NaughtyWaiter的serveTo方法, 向" + clientName + "提供服务");
    }

    public void joke(String clientName, int times) {
        System.out.println("NaughtyWaiter的joke方法, 向" + clientName + "开玩笑" + times + "次");
    }
}

public class CuteNaiveWaiter extends NaiveWaiter {
}

public interface Seller {
    int sell(String goods, String clientName);
}

public class SmartSeller implements Seller {

    @Override
    public int sell(String goods, String clientName) {
        System.out.println("SmartSeller的sell方法在向" + clientName + "销售" + goods + "");
        return 10;
    }

    protected int showGoods(String goods) {
        System.out.println("SmartSeller的showGoods方法展示" + goods);
        return 10;
    }
}

public class WaiterManager {

    public void addWaiter(Waiter waiter) {
        System.out.println("添加了一个Waiter");
    }

    public void addNaiveWaiter(NaiveWaiter naiveWaiter) {
        System.out.println("添加了一个naiveWaiter");
    }
}

//@target()表达式需要注解是运行时才可以
@Retention(RetentionPolicy.RUNTIME)
public @interface Mark {
    String value() default "saner";
}

public static void main(String[] args) {
    NaiveWaiter naiveWaiter = new NaiveWaiter();
    NaughtyWaiter naughtyWaiter = new NaughtyWaiter();
    SmartSeller smartSeller = new SmartSeller();
    CuteNaiveWaiter cuteNaiveWaiter = new CuteNaiveWaiter();
    WaiterManager waiterManager = new WaiterManager();


    AspectJProxyFactory factory1 = new AspectJProxyFactory();
    factory1.setTarget(naiveWaiter);
    factory1.addAspect(AspectAdvisor.class);
    NaiveWaiter naiveWaiterProxy = factory1.getProxy();

    AspectJProxyFactory factory2 = new AspectJProxyFactory();
    factory2.setTarget(naughtyWaiter);
    factory2.addAspect(AspectAdvisor.class);
    NaughtyWaiter naughtyWaiterProxy = factory2.getProxy();

    AspectJProxyFactory factory3 = new AspectJProxyFactory();
    factory3.setTarget(smartSeller);
    factory3.addAspect(AspectAdvisor.class);
    SmartSeller smartSellerProxy = factory3.getProxy();

    AspectJProxyFactory factory4 = new AspectJProxyFactory();
    factory4.setTarget(cuteNaiveWaiter);
    factory4.addAspect(AspectAdvisor.class);
    CuteNaiveWaiter cuteNaiveWaiterProxy = factory4.getProxy();

    AspectJProxyFactory factory5 = new AspectJProxyFactory();
    factory5.setTarget(waiterManager);
    factory5.addAspect(AspectAdvisor.class);
    WaiterManager waiterManagerProxy = factory5.getProxy();

    System.out.println("------------------------------------------");
    naiveWaiterProxy.greetTo("owl");
    naiveWaiterProxy.smile("owl", 5);
    System.out.println("------------------------------------------");
    naughtyWaiterProxy.greetTo("owl");
    naughtyWaiterProxy.joke("owl", 6);
    System.out.println("------------------------------------------");
    smartSellerProxy.sell("lego", "owl");
    smartSellerProxy.showGoods("lego");
    System.out.println("------------------------------------------");
    cuteNaiveWaiterProxy.serveTo("owl");
    System.out.println("------------------------------------------");
    waiterManagerProxy.addNaiveWaiter(naiveWaiter);
    waiterManagerProxy.addWaiter(naiveWaiter);
}

execution()

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectAdvisor {

    @Before(*************)
    public void enhance() {
        System.out.println("我是增强");
    }
}

<修饰符> <返回类型> <方法名>(<参数模式>) <异常模式>

1. public * *(..), 匹配所有类的所有public方法. 此时有了public, 则还需要一个 * 表示所有的返回类型. 之后的 *(..) 被解释为所有类的所有方法.
2. * *To(..), 匹配所有类的所有以To结尾的方法.
3. * cc.conyli.aspect.NaiveWaiter.*To(..), 匹配NaiveWaiter的所有以To结尾的方法. 这里有个有趣的现象是cuteNaiveWaiterProxy也会触发这个切面, 这是因为CuteNaiveWaiter里没有实现这个方法,所以调用的是父类的方法.
4. * cc.conyli.aspect.CuteNaiveWaiter.*To(..), 匹配CuteNaiveWaiter的所有以To结尾的方法. 但实际上执行的时候, 不会有任何增强效果, 这是因为CuteNaiveWaiter里没有实现这个方法, 实际调用的是父类的方法, 等于这个切点表达式没有匹配成功任何一个方法.
5. * cc.conyli.aspect.Waiter.*(..), 匹配所有Waiter接口里的所有方法, 不是这个接口里的方法不会匹配成功. 可以看到, NaughtyWaiter自己扩展的方法不符合这个条件.
6. * cc.conyli.aspect.Waiter+.*(..), 匹配所有Waiter衍生类的所有方法. 可以看到, 即使NaughtyWaiter自己扩展的方法, 也符合这个条件.
7. * cc.Waiter+.*(..), 匹配所有Waiter衍生类的所有方法. 可以看到, 即使NaughtyWaiter自己扩展的方法, 也符合这个条件.
8. * cc.conyli..*(..), 出现..*,表示cc.conyli之下的所有包的所有方法, 会递归下去, 不仅仅是第一层.
9. * cc.conyli..*To(..), cc.conyli之下的所有包的以To结尾的方法, 也会递归匹配到底.
10. * cc..*.g*(..)), cc之下的所有包的以g开头的方法, 也会递归匹配到底. 看过上边三个例子, 需要注意的是, 要把..*和前边的包一起来理解, 即表达式是

        cc..*.g*(..)
    

    橙色部分指的是cc及其内部所有递归到底的类, 然后一个点表示分隔符, 之后是蓝色的方法表达式, 表示g开头的方法. 这样就不容易出错.
11. * cc.conyli..*.*(String, int), cc.conyli之下的所有包内只有两个参数, 并且第一个参数是String, 第二个参数是int的方法, 对应smile和joke两个方法. 参数的类如果是java.lang下边, 不用加全类名, 否则要加全类名.
12. * cc.conyli..*.*(String, *), cc.conyli之下的所有包内只有两个参数, 并且第一个参数是String, 第二个参数是任意类型的方法, 这里就对应smile和joke和sell三个方法了, 因为这三个方法第二个参数有不同, 但第一个参数全都是String.
13. * cc.conyli..*.*(String, ..), cc.conyli之下的所有包内至少第一个参数是String的方法, 后边的参数可以没有, 也可以是任意类型和数量, 这就对应了更多的方法了, 除了WaiterManager的方法, 剩下的方法全都可以匹配.
14. * cc.conyli..*.*(cc.conyli.aspect.Waiter+, ..), cc.conyli之下的所有包内至少第一个参数是Waiter及其后继类的方法, 这个就能匹配上WaiterManager的两个方法.

@annotation()

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectAdvisor {

    @Before("@annotation(cc.conyli.aspect.Mark)")
    public void enhance() {
        System.out.println("我是增强");
    }
}

args()与@args()

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectAdvisor {

    @Before("@args(cc.conyli.aspect.Mark)")
    public void enhance() {
        System.out.println("我是增强");
    }
}

//没有被增强
waiterManagerProxy.addNaiveWaiter(naiveWaiter);

//增强了
waiterManagerProxy.addWaiter(naiveWaiter);

within()

1. within(cc.conyli..*), 再次强调, ..*要用在匹配类的字符串上. 这表示cc.conyli下边的递归的包中的所有类的所有方法.
2. within(cc.conyli.aspect.Waiter), 这是精确匹配, 仅仅匹配Waiter类, 但是由于接口本身没法直接实例化, 所以不会有任何方法得到增强.
3. within(cc.conyli.aspect.Waiter+), Waiter类及其实现类的全部方法, 也包括实现类自己扩展出来的方法.

target()

1. target(cc.conyli.aspect.NaiveWaiter), 匹配NaiveWaiter及其子类, 也就说NaiveWaiter和CuteNaiveWaiter中的所有方法都匹配
2. target(cc.conyli.aspect.NaiveWaiter+), 因为本身就是匹配所有子类和实现类了, 所以加上了+, 效果和没有加是一样的.
3. target(cc.conyli.aspect..*), 不能使用通配符*, 用了会报错.

@within()和@target()

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AspectAdvisor {

    @Before("@target(cc.conyli.aspect.Mark)")
    public void enhance() {
        System.out.println("我是增强");
    }
}

引介增强用法

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;

@Aspect
public class IntroSellerAspect {

    @DeclareParents(value = "cc.conyli.aspect.NaiveWaiter", defaultImpl = cc.conyli.aspect.SmartSeller.class)
    public Seller seller;
}

public static void main(String[] args) {
    NaiveWaiter naiveWaiter = new NaiveWaiter();

    AspectJProxyFactory factory1 = new AspectJProxyFactory();
    factory1.setTarget(naiveWaiter);
    factory1.addAspect(IntroSellerAspect.class);
    Seller naiveWaiterProxy = (Seller) factory1.getProxy();

    //转型成Seller, 实现的方法是SmartSeller中的实现
    naiveWaiterProxy.sell("owl", "owl");
    System.out.println("------------------------------------");

    Class[] in = naiveWaiterProxy.getClass().getInterfaces();
    Class[] in2 = naiveWaiterProxy.getClass().getClasses();
     for (Class c : in) {
        System.out.println(c.getName());
    }
     System.out.println("------------------------------------");
    for (Class c : in2) {
        System.out.println(c.getName());
    }
    System.out.println("------------------------------------");
    System.out.println(naiveWaiterProxy.getClass().getSuperclass().getName());
}

@Configuration
@ComponentScan
@EnableAspectJAutoProxy
public class Config {
}

package com.example.demo;

import com.example.demo.aop.Seller;
import com.example.demo.aop.Waiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Controller {

    private Waiter waiter;

    @Autowired
    public Controller(Waiter waiter) {
        this.waiter = waiter;
    }

    @GetMapping("/test")
    public String test() {
        waiter.greetTo("fdkjlkjl");

        Seller seller = (Seller) waiter;
        seller.sell("fsjlk", "dfslkj");

        Class[] in = waiter.getClass().getInterfaces();
        Class[] in2 = waiter.getClass().getClasses();
        for (Class c : in) {
            System.out.println(c.getName());
        }
        System.out.println("------------------------------------");
        for (Class c : in2) {
            System.out.println(c.getName());
        }
        System.out.println("------------------------------------");
        System.out.println(waiter.getClass().getSuperclass().getName());
        return "OK";
    }
}

NaiveWaiter的greetTo方法, 向fdkjlkjl问好
SmartSeller的sell方法在向dfslkj销售fsjlk
com.example.demo.aop.Seller
org.springframework.aop.SpringProxy
org.springframework.aop.framework.Advised
org.springframework.cglib.proxy.Factory
------------------------------------
------------------------------------
com.example.demo.aop.NaiveWaiter

this()

import com.example.demo.aop.Seller;
import com.example.demo.aop.Waiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Controller {

    private Waiter waiter;

    @Autowired
    public Controller(Waiter waiter) {
        this.waiter = waiter;
    }

    @GetMapping("/test")
    public String test() {
        System.out.println("-----------以Waiter类型调用方法-----------");
        waiter.greetTo("fdkjlkjl");
        System.out.println();
        System.out.println("-----------以Seller类型调用方法-----------");
        Seller seller = (Seller) waiter;
        seller.sell("fsjlk", "dfslkj");

        return "OK";
    }
}

@Aspect
@Component
public class IntroSellerAspect {

    @DeclareParents(value = "com.example.demo.aop.NaiveWaiter", defaultImpl =com.example.demo.aop.SmartSeller.class)
    public Seller seller;

    @Before("target(com.example.demo.aop.Waiter)")
    public void enhance1() {
        System.out.println("target(Waiter)的增强");
    }

    @Before("target(com.example.demo.aop.Seller)")
    public void enhance2() {
        System.out.println("target(Seller)的增强");
    }
}

-----------以Waiter类型调用方法-----------
target(Waiter)的增强
NaiveWaiter的greetTo方法, 向fdkjlkjl问好

-----------以Seller类型调用方法-----------
SmartSeller的sell方法在向dfslkj销售fsjlk

@Before("this(com.example.demo.aop.Waiter)")
public void enhance3() {
    System.out.println("this(Waiter)的增强");
}

@Before("this(com.example.demo.aop.Seller)")
public void enhance4() {
    System.out.println("this(Seller)的增强");
}

-----------以Waiter类型调用方法-----------
target(Waiter)的增强
this(Waiter)的增强
this(Seller)的增强
NaiveWaiter的greetTo方法, 向fdkjlkjl问好

-----------以Seller类型调用方法-----------
SmartSeller的sell方法在向dfslkj销售fsjlk