Example usage for org.springframework.aop.framework AopProxyUtils completeProxiedInterfaces

Introduction

In this page you can find the example usage for org.springframework.aop.framework AopProxyUtils completeProxiedInterfaces.

Prototype

public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) 

Source Link

Document

Determine the complete set of interfaces to proxy for the given AOP configuration.

Usage

From source file:org.springframework.aop.framework.Cglib2AopProxy.java

public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating CGLIB2 proxy: target source is " + this.advised.getTargetSource());
    }/* w  w  w  . jav a2 s .  co  m*/

    Enhancer enhancer = createEnhancer();
    try {
        Class rootClass = this.advised.getTargetSource().getTargetClass();
        Class proxySuperClass = (AopUtils.isCglibProxyClass(rootClass)) ? rootClass.getSuperclass() : rootClass;

        // Create proxy in specific ClassLoader, if given.
        if (classLoader != null) {
            enhancer.setClassLoader(classLoader);
        }

        // Validate the class, writing log messages as necessary.
        validateClassIfNecessary(proxySuperClass);

        enhancer.setSuperclass(proxySuperClass);

        enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised));
        enhancer.setStrategy(new UndeclaredThrowableStrategy(UndeclaredThrowableException.class));
        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));

        Callback[] callbacks = getCallbacks(rootClass);
        enhancer.setCallbacks(callbacks);

        if (CglibUtils.canSkipConstructorInterception()) {
            enhancer.setInterceptDuringConstruction(false);
        }

        Class[] types = new Class[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        enhancer.setCallbackTypes(types);

        // Generate the proxy class and create a proxy instance.
        Object proxy;
        if (this.constructorArgs != null) {
            proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
        } else {
            proxy = enhancer.create();
        }

        return proxy;
    } catch (CodeGenerationException ex) {
        throw new AopConfigException(
                "Couldn't generate CGLIB subclass of class [" + this.advised.getTargetSource().getTargetClass()
                        + "]: "
                        + "Common causes of this problem include using a final class or a non-visible class",
                ex);
    } catch (IllegalArgumentException ex) {
        throw new AopConfigException(
                "Couldn't generate CGLIB subclass of class [" + this.advised.getTargetSource().getTargetClass()
                        + "]: "
                        + "Common causes of this problem include using a final class or a non-visible class",
                ex);
    } catch (Exception ex) {
        // TargetSource.getTarget() failed
        throw new AopConfigException("Unexpected AOP exception", ex);
    }
}

---

From source file:org.springframework.aop.framework.CglibAopProxy.java

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
    }/*www .  j a va  2 s. c o  m*/

    try {
        Class<?> rootClass = this.advised.getTargetClass();
        Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

        Class<?> proxySuperClass = rootClass;
        if (ClassUtils.isCglibProxyClass(rootClass)) {
            proxySuperClass = rootClass.getSuperclass();
            Class<?>[] additionalInterfaces = rootClass.getInterfaces();
            for (Class<?> additionalInterface : additionalInterfaces) {
                this.advised.addInterface(additionalInterface);
            }
        }

        // Validate the class, writing log messages as necessary.
        validateClassIfNecessary(proxySuperClass, classLoader);

        // Configure CGLIB Enhancer...
        Enhancer enhancer = createEnhancer();
        if (classLoader != null) {
            enhancer.setClassLoader(classLoader);
            if (classLoader instanceof SmartClassLoader
                    && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
            }
        }
        enhancer.setSuperclass(proxySuperClass);
        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

        Callback[] callbacks = getCallbacks(rootClass);
        Class<?>[] types = new Class<?>[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        // fixedInterceptorMap only populated at this point, after getCallbacks call above
        enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(),
                this.fixedInterceptorMap, this.fixedInterceptorOffset));
        enhancer.setCallbackTypes(types);

        // Generate the proxy class and create a proxy instance.
        return createProxyClassAndInstance(enhancer, callbacks);
    } catch (CodeGenerationException | IllegalArgumentException ex) {
        throw new AopConfigException(
                "Could not generate CGLIB subclass of class [" + this.advised.getTargetClass() + "]: "
                        + "Common causes of this problem include using a final class or a non-visible class",
                ex);
    } catch (Throwable ex) {
        // TargetSource.getTarget() failed
        throw new AopConfigException("Unexpected AOP exception", ex);
    }
}

---

From source file:org.springframework.aop.framework.OptimizedJdkDynamicAopProxy.java

/**
 * Creates a new Proxy object for the given object, proxying
 * the given interface. Uses the given class loader.
 *///from   ww w.ja v  a  2  s  .c  o m
public Object getProxy(ClassLoader cl) {
    logger.debug("Creating JDK dynamic proxy");
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
    return Proxy.newProxyInstance(cl, proxiedInterfaces, this);
}

---