javassist.util.proxy.ProxyObject Java Examples

@Override
@SuppressWarnings("unchecked")
public <T> T createProxy(final Class<?> targetClass, final List<IProxy> proxies) {
    ProxyFactory factory = new ProxyFactory();
    factory.setSuperclass(targetClass);
    Class<?> clazz = factory.createClass();
    try {
        Object targetObj = clazz.newInstance();
        ((ProxyObject) targetObj).setHandler(new MethodHandler() {
            @Override
            public Object invoke(final Object self, Method thisMethod, final Method proceed, final Object[] args) throws Throwable {
                return new AbstractProxyChain(JavassistProxyFactory.this, targetClass, self, thisMethod, args, proxies) {
                    @Override
                    protected Object doInvoke() throws Throwable {
                        return proceed.invoke(getTargetObject(), getMethodParams());
                    }
                }.doProxyChain();
            }
        });
        return (T) targetObj;
    } catch (Exception e) {
        throw new Error(e);
    }
}
 

@Test
public void testIsProxyObjectType() throws Exception
{
   Assert.assertTrue(Proxies.isProxyType(new ProxyObject()
   {
      @Override
      public void setHandler(MethodHandler mi)
      {
      }

      @Override
      public MethodHandler getHandler()
      {
         return null;
      }
   }.getClass()));
}
 

@SuppressWarnings("rawtypes")
public static <T> T create(final Object obj, final ProxyCallback onSuccess, final ProxyCallback onException) throws Exception {
	ProxyFactory factory = new ProxyFactory();
	Class<T> origClass = (Class<T>) obj.getClass();
	factory.setSuperclass(origClass);
	Class clazz = factory.createClass();
	MethodHandler handler = new MethodHandler() {

		@Override
		public Object invoke(Object self, Method overridden, Method forwarder,
				Object[] args) throws Throwable {
			try {
				Object returnVal = overridden.invoke(obj, args);
				if (null != onSuccess) onSuccess.execute();
				return returnVal;
			} catch (Throwable tr) {
				if (null != onException) onException.execute();
				throw tr;
			}
		}
	};
	Object instance = clazz.newInstance();
	((ProxyObject) instance).setHandler(handler);
	return (T) instance;
}
 

void setSuperclass(Class<?> classToIntercept) {
    if (ProxyObject.class.isAssignableFrom(classToIntercept)) { // Because it's not possible to proxy a proxy class because of setHandler duplicate exception.
        factory.setSuperclass(classToIntercept.getSuperclass());
    } else {
        factory.setSuperclass(classToIntercept);
    }
}
 

private static Class<?>[] makeAValidInterfaceArray(Class<?>... interfaces) {
    // makes a ordered set of the interfaces. (removes duplicates)
    Set<Class<?>> set = new LinkedHashSet<Class<?>>(Arrays.asList(interfaces));
    set.remove(InterceptableProxy.class); // remove is exists
    set.add(InterceptableProxy.class); // needed by this library.
    set.remove(ProxyObject.class); // not allowed by javassit.
    set.remove(ProxyObject.class); // not allowed by javassit.
    return set.toArray(new Class<?>[set.size()]);
}
 

private Class<?> getClazz( Object object )
{
    Class<?> clazz = object.getClass();

    while ( ProxyObject.class.isAssignableFrom( clazz ) )
    {
        clazz = clazz.getSuperclass();
    }

    return clazz;
}
 

public Object getProxy() {
	try {
		ProxyObject proxy = ( ProxyObject ) proxyClass.newInstance();
		proxy.setHandler( new PassThroughHandler( proxy, proxyClass.getName() ) );
		return proxy;
	}
	catch ( Throwable t ) {
		throw new HibernateException( "Unable to instantiated proxy instance" );
	}
}
 

@Override
public Object instantiatePartial(SpearalContext context, Class<?> cls, Property[] partialProperties)
	throws InstantiationException, IllegalAccessException {
	
	if (Proxy.isProxyClass(cls))
		return ProxyInstantiator.instantiatePartial(context, cls, partialProperties);
	
	Class<?> proxyClass = proxyClassesCache.getOrPutIfAbsent(context, cls);
	ProxyObject proxyObject = (ProxyObject)proxyClass.newInstance();
	proxyObject.setHandler(new PartialObjectProxyHandler(context, cls, partialProperties));
	return proxyObject;
}
 

public static boolean isProxyType(Class<?> type)
{
   if (type != null)
   {
      if (type.getName().contains("$$EnhancerByCGLIB$$")
               || type.getName().contains("_jvst")
               || type.getName().contains("$Proxy$_$$_WeldClientProxy")
               || Proxy.class.isAssignableFrom(type)
               || ProxyObject.class.isAssignableFrom(type))
      {
         return true;
      }
   }
   return false;
}
 

private <T> T createProxyWithObjenesis() {
    Object obj = ObjenesisHelper.newInstance(factory.createClass());
    ((ProxyObject) obj).setHandler(new JavassistInterceptorMethodHandler());
    return (T) obj;
}
 

public static HibernateProxy getProxy(
		final String entityName,
        final Class persistentClass,
        final Class[] interfaces,
        final Method getIdentifierMethod,
        final Method setIdentifierMethod,
        AbstractComponentType componentIdType,
        final Serializable id,
        final SessionImplementor session) throws HibernateException {
	// note: interface is assumed to already contain HibernateProxy.class
	try {
		final JavassistLazyInitializer instance = new JavassistLazyInitializer(
				entityName,
		        persistentClass,
		        interfaces,
		        id,
		        getIdentifierMethod,
		        setIdentifierMethod,
		        componentIdType,
		        session
		);
		ProxyFactory factory = new ProxyFactory();
		factory.setSuperclass( interfaces.length == 1 ? persistentClass : null );
		factory.setInterfaces( interfaces );
		factory.setFilter( FINALIZE_FILTER );
		Class cl = factory.createClass();
		final HibernateProxy proxy = ( HibernateProxy ) cl.newInstance();
		( ( ProxyObject ) proxy ).setHandler( instance );
		instance.constructed = true;
		return proxy;
	}
	catch ( Throwable t ) {
		LogFactory.getLog( BasicLazyInitializer.class ).error(
				"Javassist Enhancement failed: " + entityName, t
		);
		throw new HibernateException(
				"Javassist Enhancement failed: "
				+ entityName, t
		);
	}
}