Java ProxyFactory.setFilter方法代码示例

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
public static Class getProxyFactory(
		Class persistentClass,
		Class[] interfaces) throws HibernateException {
	// note: interfaces is assumed to already contain HibernateProxy.class

	try {
		ProxyFactory factory = new ProxyFactory();
		factory.setSuperclass( interfaces.length == 1 ? persistentClass : null );
		factory.setInterfaces( interfaces );
		factory.setFilter( FINALIZE_FILTER );
		return factory.createClass();
	}
	catch ( Throwable t ) {
		LOG.error(LOG.javassistEnhancementFailed(persistentClass.getName()), t);
		throw new HibernateException(LOG.javassistEnhancementFailed(persistentClass.getName()), t);
	}
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
public static Class getProxyFactory(
		Class persistentClass,
        Class[] interfaces) throws HibernateException {
	// note: interfaces is assumed to already contain HibernateProxy.class

	try {
		ProxyFactory factory = new ProxyFactory();
		factory.setSuperclass( interfaces.length == 1 ? persistentClass : null );
		factory.setInterfaces( interfaces );
		factory.setFilter( FINALIZE_FILTER );
		return factory.createClass();
	}
	catch ( Throwable t ) {
		LogFactory.getLog( BasicLazyInitializer.class ).error(
				"Javassist Enhancement failed: "
				+ persistentClass.getName(), t
		);
		throw new HibernateException(
				"Javassist Enhancement failed: "
				+ persistentClass.getName(), t
		);
	}
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
/**
 * Constructs a partial instance of abstract type {@code cls}, passing {@code args} into its
 * constructor.
 *
 * <p>The returned object will throw an {@link UnsupportedOperationException} from any
 * unimplemented methods.
 */
public static <T> T of(Class<T> cls, Object... args) {
  checkIsValidPartial(cls);
  try {
    Constructor<?> constructor = cls.getDeclaredConstructors()[0];
    ProxyFactory factory = new ProxyFactory();
    factory.setSuperclass(cls);
    factory.setFilter(new MethodFilter() {
      @Override public boolean isHandled(Method m) {
        return Modifier.isAbstract(m.getModifiers());
      }
    });
    @SuppressWarnings("unchecked")
    T partial = (T) factory.create(
        constructor.getParameterTypes(), args, new ThrowingMethodHandler());
    return partial;
  } catch (Exception e) {
    throw new RuntimeException("Failed to instantiate " + cls, e);
  }
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
/**
 * Get an instance of a rest proxy instance for the service class.
 *
 * @param serviceClass
 *            the service class.
 * @return the proxy implementation that invokes the remote service.
 * @throws Exception
 */
@SuppressWarnings("unchecked")
public <T> T getInstance(@NonNull final Class<T> serviceClass) throws Exception {
    final ProxyFactory factory = new ProxyFactory();
    if (serviceClass.isInterface()) {
        factory.setInterfaces(new Class[] { serviceClass });
    } else {
        factory.setSuperclass(serviceClass);
    }
    factory.setFilter(new MethodFilter() {
        @Override
        public boolean isHandled(final Method method) {
            return Modifier.isPublic(method.getModifiers());
        }
    });

    final Class<?> klass = factory.createClass();
    final Object instance = objenesis.getInstantiatorOf(klass).newInstance();
    ((ProxyObject) instance).setHandler(new RestMethodInvocationHandler(baseUri,
            clientProvider, interfaceAnalyzer.analyze(serviceClass), responseToThrowableMapper,
            builderFilter));
    return (T) instance;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <T> Class<T> createTheProxy(Class<?> mainClass) {
	ProxyFactory f = new ProxyFactory();
	f.setSuperclass(mainClass);
	f.setInterfaces(new Class[] {NoSqlProxy.class});
	f.setFilter(new MethodFilter() {
		public boolean isHandled(Method m) {
			// ignore finalize()
			if(m.getName().equals("finalize"))
				return false;
			else if(m.getName().equals("equals"))
				return false;
			else if(m.getName().equals("hashCode"))
				return false;
			return true;
		}
	});
	Class<T> clazz = f.createClass();
	testInstanceCreation(clazz);
	
	return clazz;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
private static PyObjectValueProxyClass getProxyClass(PyObject pyObject) throws Exception {
    String proxyClassName = pyObject.getClass() + PROXY_CLASS_SUFFIX;
    PyObjectValueProxyClass proxyClass = proxyClasses.get(proxyClassName);
    if (proxyClass == null) {
        writeLock.lock();
        try {
            proxyClass = proxyClasses.get(proxyClassName);
            if (proxyClass == null) {
                ProxyFactory factory = new ProxyFactory();
                factory.setSuperclass(pyObject.getClass());
                factory.setInterfaces(new Class[]{PyObjectValue.class});
                factory.setFilter(new PyObjectValueMethodFilter());
                factory.setUseWriteReplace(false);
                proxyClasses.putIfAbsent(proxyClassName, createProxyClass(factory.createClass(), pyObject));
                proxyClass = proxyClasses.get(proxyClassName);
            }
        } finally {
            writeLock.unlock();
        }
    }
    return proxyClass;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
/**
 * Performs a benchmark for a trivial class creation using javassist proxies.
 *
 * @return The created instance, in order to avoid JIT removal.
 */
@Benchmark
public Class<?> benchmarkJavassist() {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setUseCache(false);
    ProxyFactory.classLoaderProvider = new ProxyFactory.ClassLoaderProvider() {
        @Override
        public ClassLoader get(ProxyFactory proxyFactory) {
            return newClassLoader();
        }
    };
    proxyFactory.setSuperclass(baseClass);
    proxyFactory.setFilter(new MethodFilter() {
        public boolean isHandled(Method method) {
            return false;
        }
    });
    return proxyFactory.createClass();
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
@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;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
public static HibernateProxy getProxy(
		final String entityName,
		final Class persistentClass,
		final Class[] interfaces,
		final Method getIdentifierMethod,
		final Method setIdentifierMethod,
		CompositeType 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,
				ReflectHelper.overridesEquals(persistentClass)
		);
		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();
		( ( Proxy ) proxy ).setHandler( instance );
		instance.constructed = true;
		return proxy;
	}
	catch ( Throwable t ) {
		LOG.error(LOG.javassistEnhancementFailed(entityName), t);
		throw new HibernateException(LOG.javassistEnhancementFailed(entityName), t);
	}
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
@Test
public void testJavassistProxy() throws IllegalAccessException, InstantiationException {
    ProxyFactory f = new ProxyFactory();
    f.setSuperclass(User.class);
    f.setFilter(m -> !m.getName().equals("finalize"));
    Class proxyClass = f.createClass();
    assertTrue(ClassUtils.isProxy(proxyClass));
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
private static <T> T createProxyInstance(Class<T> entityType, MethodHandler methodHandler) {
	ProxyFactory factory = new ProxyFactory();
	factory.setSuperclass(entityType);
	factory.setFilter(FILTER_INSTANCE);
	
	Class<?> clazz = factory.createClass();
	T proxy = instantiateClass(clazz);
	((Proxy) proxy).setHandler(methodHandler);
	return proxy;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
private static ProxyFactory createJavassistProxyFactory(Class<?> persistentClass, Class<?>[] interfaces) {
    ProxyFactory factory = new ProxyFactory();
    factory.setSuperclass(persistentClass);
    factory.setInterfaces(interfaces);
    factory.setFilter(METHOD_FILTERS);
    factory.setUseCache(true);
    if (WRITE_CLASSES_DIRECTORY != null) {
        factory.writeDirectory = WRITE_CLASSES_DIRECTORY;
    }
    return factory;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
private static ProxyFactory createProxyFactory(Class<?> persistentClass, Class<?>[] interfaces) {
    ProxyFactory factory = new ProxyFactory();
    factory.setSuperclass(persistentClass);
    factory.setInterfaces(interfaces);
    factory.setFilter(METHOD_FILTERS);
    factory.setUseCache(true);
    if (WRITE_CLASSES_DIRECTORY != null) {
        factory.writeDirectory = WRITE_CLASSES_DIRECTORY;
    }
    return factory;
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
protected <E> E createInternal(final Class<E> klass) {
	
	try {
	
   		ProxyFactory factory = new ProxyFactory();
   		factory.setSuperclass(klass);
   		
   		factory.setFilter(new MethodFilter() {
   
   			@Override
               public boolean isHandled(Method m) {
   				return getPropName(m) != null;
   			}
   		});
   		
   		MethodHandler handler = new MethodHandler() {
   	        
   			@Override
   	        public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
   				
   				return DefaultProxy.this.invoke(self, thisMethod, args);
   	        }
   	    };
   	    
   	    return (E) factory.create(new Class[0], new Object[0], handler);
   	    
	} catch(Exception e) {
		throw new BeanException(e);
	}
}
 

import javassist.util.proxy.ProxyFactory; //导入方法依赖的package包/类
private void checkForCreateListTypeType(Configuration conf, final Class<?> propertyType) throws NoSuchMethodException,
		IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
	if (!listTypeProxyCreatedSet.contains(propertyType)) {
		ProxyFactory factory = new ProxyFactory();
		factory.setSuperclass(ListTypeUserType.class);
		factory.setFilter(new MethodFilter() {

			@Override
			public boolean isHandled(Method method) {
				return Modifier.isAbstract(method.getModifiers());
			}
		});
		MethodHandler handler = new MethodHandler() {

			@Override
			public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
				if (thisMethod.getName().equals("returnedClass") && args.length == 0) {
					LOG.debug("Handling method returnedClass() of type ListTypeUserType", thisMethod);
					return propertyType;
				} else {
					throw new UnsupportedOperationException();
				}
			}

		};
		Object type = factory.create(new Class<?>[0], new Object[0], handler);
		conf.registerTypeOverride((UserType) type, new String[] { propertyType.getSimpleName(), propertyType.getName() });
		listTypeProxyCreatedSet.add(propertyType);
	}
}