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; }
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(); }
/** * Constructs a Latke bean. * * @param beanManager the specified bean manager * @param name the specified bean name * @param beanClass the specified bean class * @param types the specified bean types * @param stereotypes the specified stereo types */ public Bean(final BeanManager beanManager, final String name, final Class<T> beanClass, final Set<Type> types, final Set<Class<? extends Annotation>> stereotypes) { this.beanManager = beanManager; this.name = name; this.beanClass = beanClass; this.types = types; this.stereotypes = stereotypes; this.configurator = beanManager.getConfigurator(); javassistMethodHandler = new JavassistMethodHandler(beanManager); final ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setSuperclass(beanClass); proxyFactory.setFilter(javassistMethodHandler.getMethodFilter()); proxyClass = (Class<T>) proxyFactory.createClass(); annotatedType = new AnnotatedTypeImpl<T>(beanClass); fieldInjectionPoints = new HashSet<>(); initFieldInjectionPoints(); }
/** * 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); } }
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; }
public static <T> T getProxy(Class<T> proxyClass, MethodHandler handler) throws InstantiationException, IllegalAccessException { // 设置需要创建子类的父类 proxyFactory.setSuperclass(proxyClass); proxyFactory.setFilter(new MethodFilter() { public boolean isHandled(Method m) { // ignore finalize() return !m.getName().equals("finalize"); } }); // 通过字节码技术动态创建子类实例 Class<?> realClass = proxyFactory.createClass(); Object proxy = realClass.newInstance(); ((Proxy) proxy).setHandler(handler); return (T) proxy; }
@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; }
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 Entity proxifyEntity(final Entity entity) { if (entity == null) { return null; } final ProxyFactory factory = new ProxyFactory(); factory.setSuperclass(entity.getClass()); factory.setFilter(new AllMethodFilter()); try { return (Entity) factory.create(new Class<?>[0], new Object[0], new LazyMethodHandler(entity, lazyLoader)); } catch (final Exception e) { throw new RuntimeException("Error when proxifying object", e); } }
private Entity proxifyEntity(final Entity entity) { if (entity == null) { return null; } final ProxyFactory factory = new ProxyFactory(); factory.setSuperclass(entity.getClass()); factory.setFilter(new AllMethodFilter()); try { return (Entity) factory.create(new Class<?>[0], new Object[0], new LazyMethodHandler(entity, lazyLoader)); } catch (final Exception e) { throw new RuntimeException("Error when proxifying object", e); } }
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(); }
private static Counters.Counter proxyCounter(Counter c) { ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setSuperclass(Counters.Counter.class); proxyFactory.setFilter(CCMethodHandler.FILTER); CCMethodHandler handler = new CCMethodHandler(c); try { return (Counters.Counter) proxyFactory.create(new Class[0], new Object[0], handler); } catch (Exception e) { throw new CrunchRuntimeException(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 FailureLog( "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 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" ); } 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(); }
private static <T> T createProxyInstance(Class<T> entityType, MethodHandlerChain handlerChain) { ProxyFactory factory = new ProxyFactory(); if (ProxyFactory.isProxyClass(entityType)) { factory.setInterfaces(getNonProxyInterfaces(entityType)); factory.setSuperclass(entityType.getSuperclass()); } else { factory.setSuperclass(entityType); } factory.setFilter(handlerChain); Class<?> clazz = factory.createClass(); T proxy = instantiateClass(clazz); ((Proxy) proxy).setHandler(handlerChain); return proxy; }
private static <T> T createProxyInstance(Class<T> entityType, MethodHandlerChain handlerChain) { ProxyFactory factory = new ProxyFactory(); if (ProxyFactory.isProxyClass(entityType)) { factory.setInterfaces(getNonProxyInterfaces(entityType)); factory.setSuperclass(entityType.getSuperclass()); } else { factory.setSuperclass(entityType); } factory.setFilter(handlerChain); Class<?> clazz = factory.createClass(); T proxy = instantiateClass(clazz); ((Proxy) proxy).setHandler(handlerChain); return proxy; }