Java 类org.aspectj.lang.reflect.AjTypeSystem 实例源码

项目：lams 文件：AbstractAspectJAdvisorFactory.java

@Override
public void validate(Class<?> aspectClass) throws AopConfigException {
    // If the parent has the annotation and isn't abstract it's an error
    if (aspectClass.getSuperclass().getAnnotation(Aspect.class) != null &&
            !Modifier.isAbstract(aspectClass.getSuperclass().getModifiers())) {
        throw new AopConfigException("[" + aspectClass.getName() + "] cannot extend concrete aspect [" +
                aspectClass.getSuperclass().getName() + "]");
    }

    AjType<?> ajType = AjTypeSystem.getAjType(aspectClass);
    if (!ajType.isAspect()) {
        throw new NotAnAtAspectException(aspectClass);
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOWBELOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflowbelow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
}

项目：spring4-understanding 文件：AbstractAspectJAdvisorFactory.java

@Override
public void validate(Class<?> aspectClass) throws AopConfigException {
    // If the parent has the annotation and isn't abstract it's an error
    if (aspectClass.getSuperclass().getAnnotation(Aspect.class) != null &&
            !Modifier.isAbstract(aspectClass.getSuperclass().getModifiers())) {
        throw new AopConfigException("[" + aspectClass.getName() + "] cannot extend concrete aspect [" +
                aspectClass.getSuperclass().getName() + "]");
    }

    AjType<?> ajType = AjTypeSystem.getAjType(aspectClass);
    if (!ajType.isAspect()) {
        throw new NotAnAtAspectException(aspectClass);
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOWBELOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflowbelow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
}

项目：spring 文件：AbstractAspectJAdvisorFactory.java

@Override
public void validate(Class<?> aspectClass) throws AopConfigException {
    // If the parent has the annotation and isn't abstract it's an error
    if (aspectClass.getSuperclass().getAnnotation(Aspect.class) != null &&
            !Modifier.isAbstract(aspectClass.getSuperclass().getModifiers())) {
        throw new AopConfigException("[" + aspectClass.getName() + "] cannot extend concrete aspect [" +
                aspectClass.getSuperclass().getName() + "]");
    }

    AjType<?> ajType = AjTypeSystem.getAjType(aspectClass);
    if (!ajType.isAspect()) {
        throw new NotAnAtAspectException(aspectClass);
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOWBELOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflowbelow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
}

项目：class-guard 文件：AbstractAspectJAdvisorFactory.java

public void validate(Class<?> aspectClass) throws AopConfigException {
    // If the parent has the annotation and isn't abstract it's an error
    if (aspectClass.getSuperclass().getAnnotation(Aspect.class) != null &&
            !Modifier.isAbstract(aspectClass.getSuperclass().getModifiers())) {
        throw new AopConfigException("[" + aspectClass.getName() + "] cannot extend concrete aspect [" +
                aspectClass.getSuperclass().getName() + "]");
    }

    AjType<?> ajType = AjTypeSystem.getAjType(aspectClass);
    if (!ajType.isAspect()) {
        throw new NotAnAtAspectException(aspectClass);
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
    if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOWBELOW) {
        throw new AopConfigException(aspectClass.getName() + " uses percflowbelow instantiation model: " +
                "This is not supported in Spring AOP.");
    }
}

项目：lams 文件：AspectMetadata.java

/**
 * Create a new AspectMetadata instance for the given aspect class.
 * @param aspectClass the aspect class
 * @param aspectName the name of the aspect
 */
public AspectMetadata(Class<?> aspectClass, String aspectName) {
    this.aspectName = aspectName;

    Class<?> currClass = aspectClass;
    AjType<?> ajType = null;
    while (!currClass.equals(Object.class)) {
        AjType<?> ajTypeToCheck = AjTypeSystem.getAjType(currClass);
        if (ajTypeToCheck.isAspect()) {
            ajType = ajTypeToCheck;
            break;
        }
        currClass = currClass.getSuperclass();
    }
    if (ajType == null) {
        throw new IllegalArgumentException("Class '" + aspectClass.getName() + "' is not an @AspectJ aspect");
    }
    this.ajType = ajType;
    if (this.ajType.getDeclarePrecedence().length > 0) {
        throw new IllegalArgumentException("DeclarePrecendence not presently supported in Spring AOP");
    }

    switch (this.ajType.getPerClause().getKind()) {
        case SINGLETON :
            this.perClausePointcut = Pointcut.TRUE;
            return;
        case PERTARGET : case PERTHIS :
            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
            ajexp.setLocation("@Aspect annotation on " + aspectClass.getName());
            ajexp.setExpression(findPerClause(aspectClass));
            this.perClausePointcut = ajexp;
            return;
        case PERTYPEWITHIN :
            // Works with a type pattern
            this.perClausePointcut = new ComposablePointcut(new TypePatternClassFilter(findPerClause(aspectClass)));
            return;
        default :
            throw new AopConfigException(
                    "PerClause " + ajType.getPerClause().getKind() + " not supported by Spring AOP for " + aspectClass);
    }
}

项目：spring4-understanding 文件：AspectMetadata.java

/**
 * Create a new AspectMetadata instance for the given aspect class.
 * @param aspectClass the aspect class
 * @param aspectName the name of the aspect
 */
public AspectMetadata(Class<?> aspectClass, String aspectName) {
    this.aspectName = aspectName;

    Class<?> currClass = aspectClass;
    AjType<?> ajType = null;
    while (currClass != Object.class) {
        AjType<?> ajTypeToCheck = AjTypeSystem.getAjType(currClass);
        if (ajTypeToCheck.isAspect()) {
            ajType = ajTypeToCheck;
            break;
        }
        currClass = currClass.getSuperclass();
    }
    if (ajType == null) {
        throw new IllegalArgumentException("Class '" + aspectClass.getName() + "' is not an @AspectJ aspect");
    }
    this.ajType = ajType;
    if (this.ajType.getDeclarePrecedence().length > 0) {
        throw new IllegalArgumentException("DeclarePrecendence not presently supported in Spring AOP");
    }

    switch (this.ajType.getPerClause().getKind()) {
        case SINGLETON :
            this.perClausePointcut = Pointcut.TRUE;
            return;
        case PERTARGET : case PERTHIS :
            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
            ajexp.setLocation("@Aspect annotation on " + aspectClass.getName());
            ajexp.setExpression(findPerClause(aspectClass));
            this.perClausePointcut = ajexp;
            return;
        case PERTYPEWITHIN :
            // Works with a type pattern
            this.perClausePointcut = new ComposablePointcut(new TypePatternClassFilter(findPerClause(aspectClass)));
            return;
        default :
            throw new AopConfigException(
                    "PerClause " + ajType.getPerClause().getKind() + " not supported by Spring AOP for " + aspectClass);
    }
}

项目：spring 文件：AspectMetadata.java

/**
 * Create a new AspectMetadata instance for the given aspect class.
 * @param aspectClass the aspect class
 * @param aspectName the name of the aspect
 */
public AspectMetadata(Class<?> aspectClass, String aspectName) {
    this.aspectName = aspectName;

    Class<?> currClass = aspectClass;
    AjType<?> ajType = null;
    while (currClass != Object.class) {
        AjType<?> ajTypeToCheck = AjTypeSystem.getAjType(currClass);
        if (ajTypeToCheck.isAspect()) {
            ajType = ajTypeToCheck;
            break;
        }
        currClass = currClass.getSuperclass();
    }
    if (ajType == null) {
        throw new IllegalArgumentException("Class '" + aspectClass.getName() + "' is not an @AspectJ aspect");
    }
    if (ajType.getDeclarePrecedence().length > 0) {
        throw new IllegalArgumentException("DeclarePrecendence not presently supported in Spring AOP");
    }
    this.aspectClass = ajType.getJavaClass();
    this.ajType = ajType;

    switch (this.ajType.getPerClause().getKind()) {
        case SINGLETON :
            this.perClausePointcut = Pointcut.TRUE;
            return;
        case PERTARGET : case PERTHIS :
            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
            ajexp.setLocation("@Aspect annotation on " + aspectClass.getName());
            ajexp.setExpression(findPerClause(aspectClass));
            this.perClausePointcut = ajexp;
            return;
        case PERTYPEWITHIN :
            // Works with a type pattern
            this.perClausePointcut = new ComposablePointcut(new TypePatternClassFilter(findPerClause(aspectClass)));
            return;
        default :
            throw new AopConfigException(
                    "PerClause " + ajType.getPerClause().getKind() + " not supported by Spring AOP for " + aspectClass);
    }
}

项目：spring 文件：AspectMetadata.java

private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
    inputStream.defaultReadObject();
    this.ajType = AjTypeSystem.getAjType(this.aspectClass);
}

项目：pinenut 文件：AjTypeSystemTest.java

public static void main(String[] args) {
    AjType ajType = AjTypeSystem.getAjType(AspectJ4Logging.class);
    System.out.println(ajType.isArray());
}

项目：class-guard 文件：AspectMetadata.java

/**
 * Create a new AspectMetadata instance for the given aspect class.
 * @param aspectClass the aspect class
 * @param aspectName the name of the aspect
 */
public AspectMetadata(Class<?> aspectClass, String aspectName) {
    this.aspectName = aspectName;

    Class<?> currClass = aspectClass;
    AjType ajType = null;
    while (!currClass.equals(Object.class)) {
        AjType ajTypeToCheck = AjTypeSystem.getAjType(currClass);
        if (ajTypeToCheck.isAspect()) {
            ajType = ajTypeToCheck;
            break;
        }
        currClass = currClass.getSuperclass();
    }
    if (ajType == null) {
        throw new IllegalArgumentException("Class '" + aspectClass.getName() + "' is not an @AspectJ aspect");
    }
    this.ajType = ajType;
    if (this.ajType.getDeclarePrecedence().length > 0) {
        throw new IllegalArgumentException("DeclarePrecendence not presently supported in Spring AOP");
    }

    switch (this.ajType.getPerClause().getKind()) {
        case SINGLETON :
            this.perClausePointcut = Pointcut.TRUE;
            return;
        case PERTARGET : case PERTHIS :
            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
            ajexp.setLocation("@Aspect annotation on " + aspectClass.getName());
            ajexp.setExpression(findPerClause(aspectClass));
            this.perClausePointcut = ajexp;
            return;
        case PERTYPEWITHIN :
            // Works with a type pattern
            this.perClausePointcut = new ComposablePointcut(new TypePatternClassFilter(findPerClause(aspectClass)));
            return;
        default :
            throw new AopConfigException(
                    "PerClause " + ajType.getPerClause().getKind() + " not supported by Spring AOP for " + aspectClass);
    }
}