org.jboss.weld.bean.proxy

Class ProxyFactory<T>

java.lang.Object

org.jboss.weld.bean.proxy.ProxyFactory<T>

All Implemented Interfaces:

PrivilegedAction<T>

Direct Known Subclasses:

ClientProxyFactory, DecoratorProxyFactory, EnterpriseProxyFactory, InterceptedSubclassFactory

public class ProxyFactory<T>
extends Object
implements PrivilegedAction<T>

Main factory to produce proxy classes and instances for Weld beans. This implementation creates proxies which forward non-static method invocations to a BeanInstance. All proxies implement the Proxy interface.

Author:

David Allen, Stuart Douglas, Marius Bogoevici, Ales Justin

Field Summary

Fields

Modifier and Type	Field and Description
static String	CONSTRUCTED_FLAG_NAME
protected static BytecodeMethodResolver	DEFAULT_METHOD_RESOLVER
static String	DEFAULT_PROXY_PACKAGE
protected static String	INIT_METHOD_NAME
protected static String	LBEAN_IDENTIFIER
protected static String	LJAVA_LANG_BYTE
protected static String	LJAVA_LANG_CLASS
protected static String	LJAVA_LANG_OBJECT
protected static String	LJAVA_LANG_REFLECT_METHOD
protected static String	LJAVA_LANG_STRING
protected static String	LJAVA_LANG_THREAD_LOCAL
protected static String	METHOD_HANDLER_FIELD_NAME
static String	PROXY_SUFFIX

Constructor Summary

Constructors

Constructor and Description
ProxyFactory(String contextId, Class<?> proxiedBeanType, Set<? extends Type> typeClosure, Bean<?> bean) created a new proxy factory from a bean instance.
ProxyFactory(String contextId, Class<?> proxiedBeanType, Set<? extends Type> typeClosure, Bean<?> bean, boolean forceSuperClass)
ProxyFactory(String contextId, Class<?> proxiedBeanType, Set<? extends Type> typeClosure, String proxyName, Bean<?> bean) Creates a new proxy factory when the name of the proxy class is already known, such as during de-serialization
ProxyFactory(String contextId, Class<?> proxiedBeanType, Set<? extends Type> typeClosure, String proxyName, Bean<?> bean, boolean forceSuperClass)

Method Summary

Modifier and Type	Method and Description
protected void	addAdditionalInterfaces(Set<Class<?>> interfaces) Sub classes may override to specify additional interfaces the proxy should implement
protected void	addConstructedGuardToMethodBody(ClassMethod classMethod) Adds the following code to a delegating method: if(!this.constructed) return super.thisMethod() This means that the proxy will not start to delegate to the underlying bean instance until after the constructor has finished.
protected void	addConstructors(ClassFile proxyClassType, List<DeferredBytecode> initialValueBytecode) Adds a constructor for the proxy for each constructor declared by the base bean type.
protected void	addFields(ClassFile proxyClassType, List<DeferredBytecode> initialValueBytecode)
void	addInterface(Class<?> newInterface) Adds an additional interface that the proxy should implement.
void	addInterfacesFromTypeClosure(Set<? extends Type> typeClosure, Class<?> proxiedBeanType)
protected void	addMethods(ClassFile proxyClassType, ClassMethod staticConstructor)
protected void	addMethodsFromClass(ClassFile proxyClassType, ClassMethod staticConstructor)
protected void	addSerializationSupport(ClassFile proxyClassType) Adds special serialization code.
protected void	addSpecialMethods(ClassFile proxyClassType, ClassMethod staticConstructor) Adds methods requiring special implementations rather than just delegation.
T	create(BeanInstance beanInstance) Method to create a new proxy that wraps the bean instance.
protected void	createForwardingMethodBody(ClassMethod classMethod, MethodInformation method, ClassMethod staticConstructor)
protected void	createInterceptorBody(ClassMethod classMethod, MethodInformation method, ClassMethod staticConstructor) Creates the given method on the proxy class where the implementation forwards the call directly to the method handler.
protected void	createSpecialMethodBody(ClassMethod proxyClassType, MethodInformation method, ClassMethod staticConstructor)
protected void	generateEqualsMethod(ClassFile proxyClassType) Generate the body of the proxies equals method.
protected void	generateGetMethodHandlerBody(ClassMethod method)
protected void	generateHashCodeMethod(ClassFile proxyClassType) Generate the body of the proxies hashCode method.
protected void	generateSetMethodHandlerBody(ClassMethod method)
Set<Class<?>>	getAdditionalInterfaces()
protected String	getBaseProxyName() Returns the package and base name for the proxy class.
Bean<?>	getBean()
Class<?>	getBeanType()
protected Class<T>	getCachedProxyClass(String proxyClassName)
String	getContextId()
protected void	getMethodHandlerField(ClassFile file, CodeAttribute b)
protected Class<? extends MethodHandler>	getMethodHandlerType()
Class<T>	getProxyClass() Produces or returns the existing proxy class.
protected String	getProxyNameSuffix() Returns a suffix to append to the name of the proxy class.
protected void	invokeMethodHandler(ClassMethod classMethod, MethodInformation method, boolean addReturnInstruction, BytecodeMethodResolver bytecodeMethodResolver, ClassMethod staticConstructor) calls methodHandler.invoke for a given method
protected boolean	isCreatingProxy()
static boolean	isProxy(Object proxySuspect) Convenience method to determine if an object is a proxy generated by this factory or any derived factory.
static ClassLoader	resolveClassLoaderForBeanProxy(String contextId, Class<?> proxiedType, Proxies.TypeInfo typeInfo) Figures out the correct class loader to use for a proxy for a given bean
T	run()
static <T> void	setBeanInstance(String contextId, T proxy, BeanInstance beanInstance, Bean<?> bean) Convenience method to set the underlying bean instance for a proxy.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

PROXY_SUFFIX

public static final String PROXY_SUFFIX

See Also:

Constant Field Values

DEFAULT_PROXY_PACKAGE

public static final String DEFAULT_PROXY_PACKAGE

See Also:

Constant Field Values

CONSTRUCTED_FLAG_NAME

public static final String CONSTRUCTED_FLAG_NAME

See Also:

Constant Field Values

DEFAULT_METHOD_RESOLVER

protected static final BytecodeMethodResolver DEFAULT_METHOD_RESOLVER

LJAVA_LANG_REFLECT_METHOD

protected static final String LJAVA_LANG_REFLECT_METHOD

See Also:

Constant Field Values

LJAVA_LANG_BYTE

protected static final String LJAVA_LANG_BYTE

See Also:

Constant Field Values

LJAVA_LANG_CLASS

protected static final String LJAVA_LANG_CLASS

See Also:

Constant Field Values

LJAVA_LANG_OBJECT

protected static final String LJAVA_LANG_OBJECT

See Also:

Constant Field Values

LBEAN_IDENTIFIER

protected static final String LBEAN_IDENTIFIER

See Also:

Constant Field Values

LJAVA_LANG_STRING

protected static final String LJAVA_LANG_STRING

See Also:

Constant Field Values

LJAVA_LANG_THREAD_LOCAL

protected static final String LJAVA_LANG_THREAD_LOCAL

See Also:

Constant Field Values

INIT_METHOD_NAME

protected static final String INIT_METHOD_NAME

See Also:

Constant Field Values

METHOD_HANDLER_FIELD_NAME

protected static final String METHOD_HANDLER_FIELD_NAME

See Also:

Constant Field Values

Constructor Detail

ProxyFactory

public ProxyFactory(String contextId,
                    Class<?> proxiedBeanType,
                    Set<? extends Type> typeClosure,
                    Bean<?> bean)

created a new proxy factory from a bean instance. The proxy name is generated from the bean id

ProxyFactory

public ProxyFactory(String contextId,
                    Class<?> proxiedBeanType,
                    Set<? extends Type> typeClosure,
                    Bean<?> bean,
                    boolean forceSuperClass)

ProxyFactory

public ProxyFactory(String contextId,
                    Class<?> proxiedBeanType,
                    Set<? extends Type> typeClosure,
                    String proxyName,
                    Bean<?> bean)

Creates a new proxy factory when the name of the proxy class is already known, such as during de-serialization

Parameters:

proxiedBeanType - the super-class for this proxy class

typeClosure - the bean types of the bean

proxyName - the name of the proxy class

ProxyFactory

public ProxyFactory(String contextId,
                    Class<?> proxiedBeanType,
                    Set<? extends Type> typeClosure,
                    String proxyName,
                    Bean<?> bean,
                    boolean forceSuperClass)

Method Detail

addInterfacesFromTypeClosure

public void addInterfacesFromTypeClosure(Set<? extends Type> typeClosure,
                                         Class<?> proxiedBeanType)

isCreatingProxy

protected boolean isCreatingProxy()

addInterface

public void addInterface(Class<?> newInterface)

Adds an additional interface that the proxy should implement. The default implementation will be to forward invocations to the bean instance.

Parameters:

newInterface - an interface

create

public T create(BeanInstance beanInstance)

Method to create a new proxy that wraps the bean instance.

Parameters:

beanInstance - the bean instance

Returns:

a new proxy object

run

public T run()

Specified by:

run in interface PrivilegedAction<T>

getProxyClass

public Class<T> getProxyClass()

Produces or returns the existing proxy class. The operation is thread-safe.

Returns:

always the class of the proxy

getCachedProxyClass

protected Class<T> getCachedProxyClass(String proxyClassName)

getBaseProxyName

protected String getBaseProxyName()

Returns the package and base name for the proxy class.

Returns:

base name without suffixes

isProxy

public static boolean isProxy(Object proxySuspect)

Convenience method to determine if an object is a proxy generated by this factory or any derived factory.

Parameters:

proxySuspect - the object suspected of being a proxy

Returns:

true only if it is a proxy object

setBeanInstance

public static <T> void setBeanInstance(String contextId,
                                       T proxy,
                                       BeanInstance beanInstance,
                                       Bean<?> bean)

Convenience method to set the underlying bean instance for a proxy.

Parameters:

proxy - the proxy instance

beanInstance - the instance of the bean

getProxyNameSuffix

protected String getProxyNameSuffix()

Returns a suffix to append to the name of the proxy class. The name already consists of _$$_Weld, to which the suffix is added. This allows the creation of different types of proxies for the same class.

Returns:

a name suffix

addAdditionalInterfaces

protected void addAdditionalInterfaces(Set<Class<?>> interfaces)

Sub classes may override to specify additional interfaces the proxy should implement

addConstructors

protected void addConstructors(ClassFile proxyClassType,
                               List<DeferredBytecode> initialValueBytecode)

Adds a constructor for the proxy for each constructor declared by the base bean type.

Parameters:

proxyClassType - the Javassist class for the proxy

initialValueBytecode -

addFields

protected void addFields(ClassFile proxyClassType,
                         List<DeferredBytecode> initialValueBytecode)

getMethodHandlerType

protected Class<? extends MethodHandler> getMethodHandlerType()

addMethods

protected void addMethods(ClassFile proxyClassType,
                          ClassMethod staticConstructor)

addSerializationSupport

protected void addSerializationSupport(ClassFile proxyClassType)

Adds special serialization code. By default this is a nop

Parameters:

proxyClassType - the Javassist class for the proxy class

addMethodsFromClass

protected void addMethodsFromClass(ClassFile proxyClassType,
                                   ClassMethod staticConstructor)

generateHashCodeMethod

protected void generateHashCodeMethod(ClassFile proxyClassType)

Generate the body of the proxies hashCode method.

If this method returns null, the method will not be added, and the hashCode on the superclass will be used as per normal virtual method resolution rules

generateEqualsMethod

protected void generateEqualsMethod(ClassFile proxyClassType)

Generate the body of the proxies equals method.

If this method returns null, the method will not be added, and the hashCode on the superclass will be used as per normal virtual method resolution rules

Parameters:

proxyClassType - The class file

createSpecialMethodBody

protected void createSpecialMethodBody(ClassMethod proxyClassType,
                                       MethodInformation method,
                                       ClassMethod staticConstructor)

addConstructedGuardToMethodBody

protected void addConstructedGuardToMethodBody(ClassMethod classMethod)

Adds the following code to a delegating method:

if(!this.constructed) return super.thisMethod()

This means that the proxy will not start to delegate to the underlying bean instance until after the constructor has finished.

createForwardingMethodBody

protected void createForwardingMethodBody(ClassMethod classMethod,
                                          MethodInformation method,
                                          ClassMethod staticConstructor)

createInterceptorBody

protected void createInterceptorBody(ClassMethod classMethod,
                                     MethodInformation method,
                                     ClassMethod staticConstructor)

Creates the given method on the proxy class where the implementation forwards the call directly to the method handler.

the generated bytecode is equivalent to:

return (RetType) methodHandler.invoke(this,param1,param2);

Parameters:

classMethod - the class method

method - any JLR method

invokeMethodHandler

protected void invokeMethodHandler(ClassMethod classMethod,
                                   MethodInformation method,
                                   boolean addReturnInstruction,
                                   BytecodeMethodResolver bytecodeMethodResolver,
                                   ClassMethod staticConstructor)

calls methodHandler.invoke for a given method

Parameters:

method - The method information

addReturnInstruction - set to true you want to return the result of the method invocation

bytecodeMethodResolver - The resolver that returns the method to invoke

addSpecialMethods

protected void addSpecialMethods(ClassFile proxyClassType,
                                 ClassMethod staticConstructor)

Adds methods requiring special implementations rather than just delegation.

Parameters:

proxyClassType - the Javassist class description for the proxy type

generateSetMethodHandlerBody

protected void generateSetMethodHandlerBody(ClassMethod method)

generateGetMethodHandlerBody

protected void generateGetMethodHandlerBody(ClassMethod method)

getBeanType

public Class<?> getBeanType()

getAdditionalInterfaces

public Set<Class<?>> getAdditionalInterfaces()

getBean

public Bean<?> getBean()

getContextId

public String getContextId()

resolveClassLoaderForBeanProxy

public static ClassLoader resolveClassLoaderForBeanProxy(String contextId,
                                                         Class<?> proxiedType,
                                                         Proxies.TypeInfo typeInfo)

Figures out the correct class loader to use for a proxy for a given bean

getMethodHandlerField

protected void getMethodHandlerField(ClassFile file,
                                     CodeAttribute b)