最爱Java

一.  捕获对构造函数的调用
    使用Call(Signature)写入点，它带有额外的new关键字作为签名的一部分。使用与构造函数有关的call(Signature)切入点的语法如下：
    pointcut <pointcut name>(<any values to be picked up>): call(<optional modifier> <class>.new(<parameter types>));

    在用于捕获对构造函数的调用时，call(Signature)切入点具有3个关键特征：
    1.在把一个类实例化成一个对象时，具有new关键字的call(Signature)切入点会捕获连接点。
    2.通过使用around()形式的通知，call(Signature)写入点可以在Java的正常继承规则的限制下重写返回对象的类型。
    3.编译器不会检查指定的Signature是否对应于实际的构造函数。

package com.aspectj;

public aspect CallNewRecipe {
    /**//*
     * Specifies calling advice when any constructor is called
     * that meets the following signature rules:
     * 
     * Class Name:MyClass
     * Method Name:new (This is a keyword indicating the constructor call)
     * Method Parameters: int , String
     */
    pointcut myClassConstructorWithIntAndStringPointcut() : call(MyClass.new(int , String));
    
    //Advice declaration
    before() : myClassConstructorWithIntAndStringPointcut() {
        System.out.println("---------- Aspect Advice Logic ----------");
        System.out.println("In the advice picked by myClassConstructorWithIntAndOthersPointcut()");
        System.out.println("The current type of object under construction is:");
        System.out.println(thisJoinPoint.getThis());
        System.out.println("Signature: " + thisJoinPoint.getSignature());
        System.out.println("Source Line: " + thisJoinPoint.getSourceLocation());
        System.out.println("-----------------------------------------");
    }
}

二. 在执行构造函数时捕获它
    使用execution(Signature)切入点，它带有额外的new关键字作为签名的一部分。使用与构造函数有关的execution(Signature)切入点的语法如下：
    pointcut <pointcut name>(<any values to be picked up>):execution(<optional modifier> <class>.new<parameter types>));

    在用于捕获构造函数的执行时，execution(Signature)切入点具有3个关键特征：
    1.在执行类的构造函数时，具有new关键字的execution(Signature)切入点会触发连接点。
    2.不能在调用类的构造函数之前那一刻触发连接点。这会阻止重写返回的对象。
    3.可以使用around()通知来重写构造函数方法的实现，当不能重写正在构造的对象的类型。

package com.aspectj;

public aspect ExecutionNewRecipe {
    /**//*
     * Specifies calling advice when any constructor executes
     * that meets the following signature rules:
     * 
     * Class Name:MyClass
     * Method Name:new (This is a keyword indicating the constructor call)
     * Method Parameters: int , String
     */
    pointcut myClassConstructorWithIntAndStringPointcut() : execution(MyClass.new(int,String));
    
    //Advice declaration
    before() : myClassConstructorWithIntAndStringPointcut() {
        System.out.println("---------- Aspect Advice Logic ----------");
        System.out.println("In the advice picked by myClassConstructorWithIntAndOthersPointcut()");
        System.out.println("The current type of object under construction is:");
        System.out.println(thisJoinPoint.getThis().getClass());
        System.out.println("Signature: " + thisJoinPoint.getSignature());
        System.out.println("Source Line: " + thisJoinPoint.getSourceLocation());
        System.out.println("-----------------------------------------");        
    }
}

三. 捕获何时初始化对象
    使用initialization(Signature)切入点。initialization(Signature)切入点的语法如下：
    pointcut <pointcut name>(<any values to be picked up>):initialization(<optional modifier> <class>.new<parameter types>));

    initialization(Signature)切入点具有5个关键特征：
    1.initialization(Signature)切入点必须包含new关键字。
    2.initialization(Signature)切入点捕获连接点发生在任何超类的初始化之后，以及从构造函数方法返回之前。
    3.Signature必须解析成特定类的构造函数，而不是一个简单的方法。
    4.initialization(Signature)切入点提供了编译时的检查，用于检查构造函数是否正在被引用。
    5.由于AspectJ编译器中的编译器限制，当与around()通知关联时，不能使用initialization(Signature)切入点。

package com.aspectj;


public aspect InitializationRecipe {
    /**//*
     * Specifies calling advice when any object
     * initializes using a constructor
     * that meets the following signature rules:
     * 
     * Class Name:MyClass
     * Method Name:new (This is a keyword indicating the constructor call)
     * Method Parameters: int and any others
     */
    pointcut myClassObjectInitializationWithIntAndStringPointcut() : execution(MyClass.new(int,*));
    
    //Advice declaration
    before() : myClassObjectInitializationWithIntAndStringPointcut() {
        System.out.println("---------- Aspect Advice Logic ----------");
        System.out.println("In the advice picked by myClassObjectInitializationWithIntAndStringPointcut()");
        System.out.println("The current type of object under construction is:");
        System.out.println(thisJoinPoint.getThis().getClass());
        System.out.println("Signature: " + thisJoinPoint.getSignature());
        System.out.println("Source Line: " + thisJoinPoint.getSourceLocation());
        System.out.println("-----------------------------------------");        
    }
}

四. 捕获何时将要初始化一个对象
    使用preinitialization(Signature)切入点。preinitialization(Signature)切入点的语法如下：
    pointcut <pointcut name>(<any values to be picked up>):preinitialization(<optional modifier> <class>.new<parameter types>));

    preinitialization(Signature)切入点具有5个关键特征：
    1.preinitialization(Signature)切入点必须包含new关键字。
    2.preinitialization(Signature)切入点捕获连接点发生在进入捕获构造函数之后，以及调用任何超类构造函数之前。
    3.Signature必须解析成一个构造函数。
    4.preinitialization(Signature)切入点提供了编译时的检查，用于检查构造函数是否正在被引用。
    5.由于AspectJ编译器中的编译器限制，当与around()通知关联时，不能使用preinitialization(Signature)切入点。

package com.aspectj;

public aspect PreInitializationRecipe {
    /**//*
     * Specifies calling advice just before an object initializes
     * using a constructor that meets the following signature rules:
     * 
     * Class Name:MyClass
     * Method Name:new (This is a keyword indicating the constructor call)
     * Method Parameters: an int followed by a String
     */
    pointcut myClassIntStringObjectPreInitializationPointcut() : preinitialization(MyClass.new(int,String));
    
    //Advice declaration
    before(int number , String name) : myClassIntStringObjectPreInitializationPointcut() && args(number , name) {
        System.out.println("---------- Aspect Advice Logic ----------");
        System.out.println("In the advice picked by anyMyClassObjectInitializationPointcut()");
        System.out.println("The current type of object under construction is:");
        System.out.println(thisJoinPoint.getThis());
        System.out.println("The values passed in where: " + number + " , " + name);
        System.out.println("Signature: " + thisJoinPoint.getSignature());
        System.out.println("Source Line: " + thisJoinPoint.getSourceLocation());
        System.out.println("-----------------------------------------");        
    }
}

五. 捕获何时初始化类
    使用staticinitialization(TypePattern)写入点。staticinitialization(TypePattern)写入点的语法如下：
    pointcut <pointcout name>(<any values to be picked up>) : staticinitialization(<class>);

    staticinitialization(TypePattern)切入点具有两个关键特征：
    1.对可供staticinitialization(TypePattern)切入点所选通知使用的环境有一些限制。没有父对象触发静态初始化；因此，没有this引用。也不涉及实例对象，因此，没有目标引用。
    2.TypePattern可以包含通配符，用于选择一系列不同的类。

package com.aspectj;

public aspect StaticinitializationRecipe {
    /**//*
     * Specifies calling advice when a class is initialized
     * that meets the following type pattern rules:
     * 
     * Class Name:MyClass
     */
    pointcut myClassStaticInitializationPointcut() : staticinitialization(MyClass);
    
    //Advice declaration
    before() : myClassStaticInitializationPointcut() {
        System.out.println("---------- Aspect Advice Logic ----------");
        System.out.println("In the advice picked by myClassStaticInitializationPointcut()");
        System.out.println("Join Point Kind: ");
        System.out.println(thisJoinPoint.getStaticPart().getKind());
        System.out.println("Signature: " + thisJoinPoint.getSignature());
        System.out.println("Source Line: " + thisJoinPoint.getSourceLocation());
        System.out.println("-----------------------------------------");        
    }
}