Checking if class is proxified with CDI 1.2

Question

In CDI 1.2 there is a way to check if a class instance is proxified? I need this because I need to get the name of original class, not the proxy name.

@Inject Bean bean;

public void sysout() {
    // will print something like com.Bean$$Weld9239823
    System.out.println(bean.getClass()); 

    // I don't know how to check if the bean instance if a proxy or real class instance
}

Using Weld classes I can do this job:

public void sysout() {
    // will print true because this is a proxy
    System.out.println(ProxyObject.class.isAssignableFrom(bean)); 

    // will print com.Bean
    System.out.println(((TargetInstanceProxy) bean).getTargetInstance());
}

In CDI 1.1 there is no method to do this. I search inside CDI 1.2 docs if a method was added about this, but I don't found anything.

So... I miss something and CDI 1.2 there is a method to get original class name and instance? Or if not, there is a plain to add this feature in near feature?

What is the use case for finding out the class of the bean? Considering that you're injecting `Bean bean` you already know that it implements `Bean` — John Ament, Aug 30 '14 at 19:26
Have you tried this solution? http://stackoverflow.com/a/7504552/2492784 — Sven, Sep 09 '14 at 19:38

score 2 · Answer 1 · answered Jun 05 '15 at 15:19

For Weld on WildFly do this:

public boolean isProxy(Object obj) {
    try{
        return Class.forName("org.jboss.weld.bean.proxy.ProxyObject").isInstance(obj);
    } catch (Exception e) {
        log.error("Unable to check if object is proxy", e);
    }
    return false;
}

To retrive actual object instead of proxy (I need to serialize it) I do this:

public Object getObject(Object obj) {
    Field f = null;
    boolean isAccessible = false;
    try {
        for(Field fi : Class.forName(handler).getDeclaredFields()) {
            if(fi.getName().equals(field)) {
                f = fi;
                isAccessible = f.isAccessible();
                f.setAccessible(true);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    if(f == null) {
        throw new RuntimeException(new NoSuchFieldException(String.format(
                "The required field '%s' not found in '%s'. " +
                        "May be the code is obsolete for running on this application server.",
                field, method)));
    } else {
        try{
            obj = f.get(getHandler(obj));
            for(Method m : Class.forName(instance).getMethods()) {
                if(m.getName().equals(value)) {
                    return m.invoke(obj);
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            f.setAccessible(isAccessible);
        }
        throw new NoSuchMethodError(String.format(
               "The required method '%s' not found in '%s'. " +
                       "May be the code is obsolete for running on this application server.",
                value, instance));
    }
}

Be aware, that it is the darkest magic as possible, have very poor performance and can break at any WildFly update, if they change classes, methods for fields in it.

score 0 · Answer 2 · answered Jan 05 '15 at 23:08

This is a terrible hack, but for Weld (and possibly other implementations) you can check if the class name contains "Proxy": possibleProxy.getClass().getSimpleName().contains("Proxy"). I use it only for logging purposes to get a cleaned up version of the wrapped class name:

/**
 * Get the actual simple name of the objects class that might be wrapped by
 * a proxy. A "simple" class name is not fully qualified (no package name).
 *
 * @param possibleProxy an object that might be a proxy to the actual
 * object.
 * @return the simple name of the actual object's class
 */
public static String getActualSimpleClassName(final Object possibleProxy) {
    final String outerClassName = possibleProxy.getClass().getSimpleName();
    final String innerClassName;
    if (outerClassName.contains("Proxy")) {
        innerClassName = outerClassName.substring(0, outerClassName.indexOf('$'));
    } else {
        innerClassName = outerClassName;
    }
    return innerClassName;
}

score 0 · Answer 3 · answered Jan 22 '15 at 19:51

you can make a method inside your proxied cdi bean like

public String getClassName() {
    return this.getClass().getName();
}

this is not the best solution, but a simple pragmatic way to get the class name through the proxy... the downside of this is that the method must be on every implementation...

Checking if class is proxified with CDI 1.2

3 Answers3