public static javassist.util.proxy.ProxyFactory buildJavassistProxyFactory( final Class persistentClass, final Class[] interfaces) { javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory() { @Override protected ClassLoader getClassLoader() { return persistentClass.getClassLoader(); } }; factory.setSuperclass( interfaces.length == 1 ? persistentClass : null ); factory.setInterfaces( interfaces ); factory.setFilter( EXCLUDE_FILTER ); return factory; }
Object readResolve() throws ObjectStreamException { try { int n = interfaces.length; Class[] infs = new Class[n]; for (int i = 0; i < n; i++) infs[i] = loadClass(interfaces[i]); ProxyFactory f = new ProxyFactory(); f.setSuperclass(loadClass(superClass)); f.setInterfaces(infs); Proxy proxy = (Proxy)f.createClass(filterSignature).newInstance(); proxy.setHandler(handler); return proxy; } catch (ClassNotFoundException e) { throw new java.io.InvalidClassException(e.getMessage()); } catch (InstantiationException e2) { throw new java.io.InvalidObjectException(e2.getMessage()); } catch (IllegalAccessException e3) { throw new java.io.InvalidClassException(e3.getMessage()); } } }
f.setInterfaces(infs); Proxy proxy = (Proxy)f.createClass(filterSignature).getConstructor().newInstance(); proxy.setHandler(handler);
public BasicProxyFactoryImpl(Class superClass, Class[] interfaces) { if ( superClass == null && ( interfaces == null || interfaces.length < 1 ) ) { throw new AssertionFailure( "attempting to build proxy without any superclass or interfaces" ); } final javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory(); factory.setFilter( FINALIZE_FILTER ); if ( superClass != null ) { factory.setSuperclass( superClass ); } if ( interfaces != null && interfaces.length > 0 ) { factory.setInterfaces( interfaces ); } proxyClass = factory.createClass(); }
protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException { boolean isProxy = readBoolean(); if (isProxy) { String name = (String)readObject(); Class superClass = loader.loadClass(name); int length = readInt(); Class[] interfaces = new Class[length]; for (int i = 0; i < length; i++) { name = (String)readObject(); interfaces[i] = loader.loadClass(name); } length = readInt(); byte[] signature = new byte[length]; read(signature); ProxyFactory factory = new ProxyFactory(); // we must always use the cache and never use writeReplace when using // ProxyObjectOutputStream and ProxyObjectInputStream factory.setUseCache(true); factory.setUseWriteReplace(false); factory.setSuperclass(superClass); factory.setInterfaces(interfaces); Class proxyClass = factory.createClass(signature); return ObjectStreamClass.lookup(proxyClass); } else { return super.readClassDescriptor(); } }
@Override protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException { boolean isProxy = readBoolean(); if (isProxy) { String name = (String)readObject(); Class<?> superClass = loader.loadClass(name); int length = readInt(); Class<?>[] interfaces = new Class[length]; for (int i = 0; i < length; i++) { name = (String)readObject(); interfaces[i] = loader.loadClass(name); } length = readInt(); byte[] signature = new byte[length]; read(signature); ProxyFactory factory = new ProxyFactory(); // we must always use the cache and never use writeReplace when using // ProxyObjectOutputStream and ProxyObjectInputStream factory.setUseCache(true); factory.setUseWriteReplace(false); factory.setSuperclass(superClass); factory.setInterfaces(interfaces); Class<?> proxyClass = factory.createClass(signature); return ObjectStreamClass.lookup(proxyClass); } return super.readClassDescriptor(); }
private ClassFile make() throws CannotCompileException { ClassFile cf = new ClassFile(false, classname, superName); cf.setAccessFlags(AccessFlag.PUBLIC); setInterfaces(cf, interfaces, hasGetHandler ? Proxy.class : ProxyObject.class); ConstPool pool = cf.getConstPool();
private ClassFile make() throws CannotCompileException { ClassFile cf = new ClassFile(false, classname, superName); cf.setAccessFlags(AccessFlag.PUBLIC); setInterfaces(cf, interfaces, hasGetHandler ? Proxy.class : ProxyObject.class); ConstPool pool = cf.getConstPool();
public GuiceDynamicProxyProvider(final GuiceRegistry registry, Class<?> interfaceType) { this.registry = registry; this.clazz = interfaceType; proxyFactory.setInterfaces(new Class[]{clazz}); }
@Override public <T> T proxify(Class<T> type, MethodInvocation<? super T> handler) { final ProxyFactory factory = new ProxyFactory(); factory.setFilter(IGNORE_BRIDGE_AND_OBJECT_METHODS); Class<?> rawType = extractRawType(type); if (type.isInterface()) { factory.setInterfaces(new Class[] { rawType }); } else { factory.setSuperclass(rawType); } Object instance = createInstance(type, handler, factory); logger.debug("a proxy for {} was created as {}", type, instance.getClass()); return (T) instance; }
public static <T> Class<T> createProxyClass(Class<T> proxyClass) { ProxyFactory proxyFactory = new ProxyFactory(); if (proxyClass != null) { proxyFactory.setSuperclass(proxyClass); } proxyFactory.setInterfaces(new Class<?>[]{LifecycleMixin.class, TargetInstanceProxy.class}); Class<T> clazz = proxyFactory.createClass(); return clazz; }
private javassist.util.proxy.ProxyFactory buildJavassistProxyFactory() { final javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory() { @Override protected ClassLoader getClassLoader() { return persistentClass.getClassLoader(); } }; factory.setSuperclass(interfaces.length == 1 ? persistentClass : null); factory.setInterfaces(getInterfacesIncludingV2HibernateProxy(interfaces)); factory.setFilter(FINALIZE_FILTER); return factory; }
private static ProxyFactory createProxyFactory(Class<?> persistentClass, Class<?>[] interfaces) { ProxyFactory factory = new ProxyFactory(); factory.setSuperclass(interfaces.length == 1 ? persistentClass : null); factory.setInterfaces(interfaces); factory.setFilter(METHOD_FILTERS); if (WRITE_CLASSES_DIRECTORY != null) { factory.writeDirectory = WRITE_CLASSES_DIRECTORY; } return factory; }
private ProviderFactory createProviderFactoryProxy( Class factoryClass ) { ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setSuperclass( factoryClass ); proxyFactory.setInterfaces( new Class[]{ProviderFactory.class} ); try { return (ProviderFactory) proxyFactory.create( new Class[]{}, new Object[]{}, getProviderFactoryMethodHandler() ); } catch( Exception exception ) { throw new RuntimeException( "failed to create proxy", exception ); } }
private Class<?> proxyClass(Class<?> mockedType, Class<?>... ancilliaryTypes) { final ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setFilter(new MethodFilter() { @Override public boolean isHandled(final Method m) { // ignore finalize() and als bridge methods return !m.getName().equals("finalize") || m.isBridge(); } }); proxyFactory.setSuperclass(mockedType); proxyFactory.setInterfaces(ancilliaryTypes); return proxyFactory.createClass(); }
public static <T> Class<T> createProxyClassWithHandler(Class<T> proxyClass, MethodHandler methodHandler) { ProxyFactory proxyFactory = new ProxyFactory(); if (proxyClass != null) { proxyFactory.setSuperclass(proxyClass); } proxyFactory.setInterfaces(new Class<?>[]{LifecycleMixin.class, TargetInstanceProxy.class}); proxyFactory.setHandler(methodHandler); Class<T> clazz = proxyFactory.createClass(); return clazz; } }
public Object createProxy() { ProxyFactory factory = new ProxyFactory(); factory.setSuperclass(clazz); factory.setInterfaces(interfaces); try { return factory.create(new Class[0], new Object[0], new JavassistInvocationHandler(methodInterceptors)); } catch (Exception e) { throw new MirrorException("Proxy could not be created", e); } } }
public BasicProxyFactoryImpl(Class superClass, Class[] interfaces) { if ( superClass == null && ( interfaces == null || interfaces.length < 1 ) ) { throw new AssertionFailure( "attempting to build proxy without any superclass or interfaces" ); } javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory(); factory.setFilter( FINALIZE_FILTER ); if ( superClass != null ) { factory.setSuperclass( superClass ); } if ( interfaces != null && interfaces.length > 0 ) { factory.setInterfaces( interfaces ); } proxyClass = factory.createClass(); }
public BasicProxyFactoryImpl(Class superClass, Class[] interfaces) { if ( superClass == null && ( interfaces == null || interfaces.length < 1 ) ) { throw new AssertionFailure( "attempting to build proxy without any superclass or interfaces" ); } javassist.util.proxy.ProxyFactory factory = new javassist.util.proxy.ProxyFactory(); factory.setFilter( FINALIZE_FILTER ); if ( superClass != null ) { factory.setSuperclass( superClass ); } if ( interfaces != null && interfaces.length > 0 ) { factory.setInterfaces( interfaces ); } proxyClass = factory.createClass(); }
public static <T> Class<T> createProxyClassWithHandler(ClassMetadata<T> proxyClass, MethodHandler methodHandler) { ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setUseWriteReplace(false); if (proxyClass != null) { proxyFactory.setSuperclass(proxyClass.getJavaClass()); } proxyFactory.setInterfaces(new Class<?>[]{LifecycleMixin.class, TargetInstanceProxy.class}); proxyFactory.setHandler(methodHandler); Class<T> clazz = proxyFactory.createClass(); return clazz; }