org.atmosphere.inject

Class InjectableObjectFactory

java.lang.Object

org.atmosphere.inject.InjectableObjectFactory

All Implemented Interfaces:

AtmosphereObjectFactory<Injectable<?>>, AtmosphereConfigAware

public class InjectableObjectFactory
extends Object
implements AtmosphereObjectFactory<Injectable<?>>

Support injection of Atmosphere's Internal object using AtmosphereConfig,AtmosphereFramework,org.atmosphere.cpr.BroadcasterFactory, {@link org.atmosphere.cpr.AtmosphereResourceFactory } ,{@link org.atmosphere.cpr.DefaultMetaBroadcaster } and {@link org.atmosphere.cpr.AtmosphereResourceSessionFactory } and classes implementing the {@link Injectable} defined inside META_INF/services/org.atmosphere.inject.Inject

Author:

Jeanfrancois Arcand

Field Summary

Fields

Modifier and Type	Field and Description
protected static org.slf4j.Logger	logger

Constructor Summary

Constructors

Constructor and Description
InjectableObjectFactory()

Method Summary

Modifier and Type	Method and Description
AtmosphereObjectFactory	allowInjectionOf(Injectable<?> injectable) Pass information to the underlying Dependency Injection Implementation
AtmosphereObjectFactory	allowInjectionOf(Injectable<?> injectable, boolean first)
<U> void	applyMethods(U instance, Class<U> defaultType) Execute InjectIntrospector.introspectMethod(java.lang.reflect.Method, java.lang.Object)
void	configure(AtmosphereConfig config) Configure an AtmosphereFramework object.
protected <T,U extends T> void	fieldInjectionException(Field field, U instance, Class<T> clazz, Exception ex)
<U> U	getInjectable(Class<U> u) Use this method to retrieve available Injectable.
<T> T	inject(T instance) Apply Injectable and InjectIntrospector to a class already constructed.
<U> void	injectFields(Set<Field> fields, U instance, AtmosphereFramework framework, LinkedList<Injectable<?>> injectable)
<U> void	injectInjectable(U instance, Class<? extends U> defaultType, AtmosphereFramework framework)
protected void	injectionFailed()
InjectableObjectFactory	listener(InjectionListener i)
protected <T,U extends T> void	methodInjectionException(Method m, U instance, Class<T> clazz, Exception ex)
boolean	needRequestScoped(Class defaultType)
<T,U extends T> U	newClassInstance(Class<T> classType, Class<U> defaultType) Delegate the creation of Object to the underlying object provider like Spring, Guice, etc.
protected <T,U extends T> void	nullFieldInjectionFor(Field field, U instance, Class<T> clazz)
protected <T,U extends T> void	postFieldInjection(Field field, U instance, Class<T> clazz)
protected <T,U extends T> void	postMethodInjection(Method method, U instance, Class<T> clazz)
protected <T,U extends T> void	preFieldInjection(Field field, U instance, Class<T> clazz)
protected <T,U extends T> void	preMethodInjection(Method method, U instance, Class<T> clazz)
void	requestScoped(Object instance, Class defaultType)
void	requestScoped(Object instance, Class defaultType, AtmosphereResource r)
protected void	retryInjection(AtmosphereFramework framework)
String	toString()

Methods inherited from class java.lang.Object

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

Field Detail

logger

protected static final org.slf4j.Logger logger

Constructor Detail

InjectableObjectFactory

public InjectableObjectFactory()

Method Detail

configure

public void configure(AtmosphereConfig config)

Description copied from interface: AtmosphereConfigAware

Configure an AtmosphereFramework object.

Specified by:

configure in interface AtmosphereConfigAware

Parameters:

config - AtmosphereConfig

retryInjection

protected void retryInjection(AtmosphereFramework framework)

newClassInstance

public <T,U extends T> U newClassInstance(Class<T> classType,
                                          Class<U> defaultType)
                                   throws InstantiationException,
                                          IllegalAccessException

Description copied from interface: AtmosphereObjectFactory

Delegate the creation of Object to the underlying object provider like Spring, Guice, etc. When creating a class, it is important to check if the class can be configured via its implementation of the AtmosphereConfigAware. AtmosphereConfigAware.configure(AtmosphereConfig) should be called in that case.

Specified by:

newClassInstance in interface AtmosphereObjectFactory<Injectable<?>>

Parameters:

classType - The class' type to be created

defaultType - a class to be created @return an instance of T

Throws:

InstantiationException

IllegalAccessException

inject

public <T> T inject(T instance)
             throws InstantiationException,
                    IllegalAccessException

Apply Injectable and InjectIntrospector to a class already constructed.

Parameters:

instance - the instance to inject to.

Returns:

Throws:

InstantiationException

IllegalAccessException

applyMethods

public <U> void applyMethods(U instance,
                             Class<U> defaultType)
                      throws IllegalAccessException

Execute InjectIntrospector.introspectMethod(java.lang.reflect.Method, java.lang.Object)

Type Parameters:

U -

Parameters:

instance - the requested object.

defaultType - the type of the requested object

Throws:

IllegalAccessException

injectInjectable

public <U> void injectInjectable(U instance,
                                 Class<? extends U> defaultType,
                                 AtmosphereFramework framework)
                          throws IllegalAccessException

Type Parameters:

U -

Parameters:

instance - the requested object.

defaultType - the type of the requested object

framework - the AtmosphereFramework

Throws:

IllegalAccessException

injectFields

public <U> void injectFields(Set<Field> fields,
                             U instance,
                             AtmosphereFramework framework,
                             LinkedList<Injectable<?>> injectable)
                      throws IllegalAccessException

Throws:

IllegalAccessException

allowInjectionOf

public AtmosphereObjectFactory allowInjectionOf(Injectable<?> injectable)

Description copied from interface: AtmosphereObjectFactory

Pass information to the underlying Dependency Injection Implementation

Specified by:

allowInjectionOf in interface AtmosphereObjectFactory<Injectable<?>>

Parameters:

injectable - an Z

Returns:

this

allowInjectionOf

public AtmosphereObjectFactory allowInjectionOf(Injectable<?> injectable,
                                                boolean first)

toString

public String toString()

Overrides:

toString in class Object

getInjectable

public <U> U getInjectable(Class<U> u)

Use this method to retrieve available Injectable. This method is for application that inject their own Injectable and needs already constructed classes.

Type Parameters:

U - the type

Parameters:

u - the class

Returns:

the class if exists, null if not

requestScoped

public void requestScoped(Object instance,
                          Class defaultType,
                          AtmosphereResource r)
                   throws IllegalAccessException

Throws:

IllegalAccessException

requestScoped

public void requestScoped(Object instance,
                          Class defaultType)
                   throws IllegalAccessException

Throws:

IllegalAccessException

needRequestScoped

public boolean needRequestScoped(Class defaultType)
                          throws IllegalAccessException

Throws:

IllegalAccessException

listener

public InjectableObjectFactory listener(InjectionListener i)

injectionFailed

protected void injectionFailed()

nullFieldInjectionFor

protected <T,U extends T> void nullFieldInjectionFor(Field field,
                                                     U instance,
                                                     Class<T> clazz)

fieldInjectionException

protected <T,U extends T> void fieldInjectionException(Field field,
                                                       U instance,
                                                       Class<T> clazz,
                                                       Exception ex)

methodInjectionException

protected <T,U extends T> void methodInjectionException(Method m,
                                                        U instance,
                                                        Class<T> clazz,
                                                        Exception ex)

preFieldInjection

protected <T,U extends T> void preFieldInjection(Field field,
                                                 U instance,
                                                 Class<T> clazz)

postFieldInjection

protected <T,U extends T> void postFieldInjection(Field field,
                                                  U instance,
                                                  Class<T> clazz)

preMethodInjection

protected <T,U extends T> void preMethodInjection(Method method,
                                                  U instance,
                                                  Class<T> clazz)

postMethodInjection

protected <T,U extends T> void postMethodInjection(Method method,
                                                   U instance,
                                                   Class<T> clazz)