private void DoGetObjectsOfType(Type type, bool includeFactoryObjects, bool includePrototypes, IDictionary collector)
{
bool isFactoryType = (type != null && typeof(IFactoryObject).IsAssignableFrom(type));
foreach (string name in objects.Keys)
{
object instance = objects[name];
if (instance is IFactoryObject && includeFactoryObjects)
{
IFactoryObject factory = (IFactoryObject)instance;
Type objectType = factory.ObjectType;
if ((objectType == null && factory.IsSingleton) ||
((factory.IsSingleton || includePrototypes) &&
objectType != null && type.IsAssignableFrom(objectType)))
{
object createdObject = GetObject(name);
if (type.IsInstanceOfType(createdObject))
{
collector[name] = createdObject;
}
}
}
else if (type.IsAssignableFrom(instance.GetType()))
{
if (isFactoryType)
{
collector[ObjectFactoryUtils.BuildFactoryObjectName(name)] = instance;
}
else
{
collector[name] = instance;
}
}
}
}
/// <summary>
/// Determines whether the specified object qualifies as an autowire candidate,
/// to be injected into other beans which declare a dependency of matching type.
/// This method checks ancestor factories as well.
/// </summary>
/// <param name="objectName">Name of the object to check.</param>
/// <param name="descriptor">The descriptor of the dependency to resolve.</param>
/// <returns>
/// <c>true</c> if the object should be considered as an autowire candidate; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="NoSuchObjectDefinitionException">if there is no object with the given name.</exception>
public bool IsAutowireCandidate(string objectName, DependencyDescriptor descriptor)
{
//Consider FactoryObjects as autowiring candidates.
bool isFactoryObject = (descriptor != null && descriptor.DependencyType != null &&
typeof(IFactoryObject).IsAssignableFrom(descriptor.DependencyType));
if (isFactoryObject)
{
objectName = ObjectFactoryUtils.TransformedObjectName(objectName);
}
if (!ContainsObjectDefinition(objectName))
{
if (ContainsSingleton(objectName))
{
return(true);
}
else if (ParentObjectFactory is IConfigurableListableObjectFactory)
{
// No object definition found in this factory -> delegate to parent
return
(((IConfigurableListableObjectFactory)ParentObjectFactory).IsAutowireCandidate(objectName, descriptor));
}
}
return(IsAutowireCandidate(objectName, GetMergedObjectDefinition(objectName, true), descriptor));
}
/// <summary> Add all global interceptors and pointcuts.</summary>
private void AddGlobalAdvisor(IListableObjectFactory objectFactory, string prefix)
{
var globalAspectNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvisors));
var globalAdvisorNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvisor));
var globalInterceptorNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IInterceptor));
List <object> objects = new List <object>();
Dictionary <object, string> names = new Dictionary <object, string>();
for (int i = 0; i < globalAspectNames.Count; i++)
{
string name = globalAspectNames[i];
if (name.StartsWith(prefix))
{
IAdvisors advisors = (IAdvisors)objectFactory.GetObject(name);
foreach (object advisor in advisors.Advisors)
{
// exclude introduction advisors from interceptor list
if (!(advisor is IIntroductionAdvisor))
{
objects.Add(advisor);
names[advisor] = name;
}
}
}
}
for (int i = 0; i < globalAdvisorNames.Count; i++)
{
string name = globalAdvisorNames[i];
if (name.StartsWith(prefix))
{
object obj = objectFactory.GetObject(name);
// exclude introduction advisors from interceptor list
if (!(obj is IIntroductionAdvisor))
{
objects.Add(obj);
names[obj] = name;
}
}
}
for (int i = 0; i < globalInterceptorNames.Count; i++)
{
string name = globalInterceptorNames[i];
if (name.StartsWith(prefix))
{
object obj = objectFactory.GetObject(name);
objects.Add(obj);
names[obj] = name;
}
}
objects.Sort(OrderComparator.Instance);
foreach (object obj in objects)
{
string name = names[obj];
AddAdvisorOnChainCreation(obj, name);
}
}
private IDictionary FindAutowireCandidates(string objectName, Type requiredType, DependencyDescriptor descriptor)
{
string[] candidateNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.Eager);
#if NET_1_0 || NET_1_1
IDictionary result = new Hashtable();
#else
IDictionary result = new OrderedDictionary(candidateNames.Length);
#endif
foreach (DictionaryEntry entry in resolvableDependencies)
{
Type autoWiringType = (Type)entry.Key;
if (autoWiringType.IsAssignableFrom(requiredType))
{
object autowiringValue = this.resolvableDependencies[autoWiringType];
if (requiredType.IsInstanceOfType(autowiringValue))
{
result.Add(ObjectUtils.IdentityToString(autowiringValue), autowiringValue);
break;
}
}
}
for (int i = 0; i < candidateNames.Length; i++)
{
string candidateName = candidateNames[i];
if (!candidateName.Equals(objectName) && IsAutowireCandidate(candidateName, descriptor))
{
result.Add(candidateName, GetObject(candidateName));
}
}
return(result);
}
/// <summary> Add all global interceptors and pointcuts.</summary>
private void AddGlobalAdvisor(IListableObjectFactory objectFactory, string prefix)
{
string[] globalAspectNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvisors));
string[] globalAdvisorNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvisor));
string[] globalInterceptorNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IInterceptor));
ArrayList objects = new ArrayList();
Hashtable names = new Hashtable();
for (int i = 0; i < globalAspectNames.Length; i++)
{
string name = globalAspectNames[i];
if (name.StartsWith(prefix))
{
IAdvisors advisors = (IAdvisors)objectFactory.GetObject(name);
foreach (object advisor in advisors.Advisors)
{
// exclude introduction advisors from interceptor list
if (!(advisor is IIntroductionAdvisor))
{
objects.Add(advisor);
names[advisor] = name;
}
}
}
}
for (int i = 0; i < globalAdvisorNames.Length; i++)
{
string name = globalAdvisorNames[i];
if (name.StartsWith(prefix))
{
object obj = objectFactory.GetObject(name);
// exclude introduction advisors from interceptor list
if (!(obj is IIntroductionAdvisor))
{
objects.Add(obj);
names[obj] = name;
}
}
}
for (int i = 0; i < globalInterceptorNames.Length; i++)
{
string name = globalInterceptorNames[i];
if (name.StartsWith(prefix))
{
object obj = objectFactory.GetObject(name);
objects.Add(obj);
names[obj] = name;
}
}
((ArrayList)objects).Sort(new OrderComparator());
foreach (object obj in objects)
{
string name = (string)names[obj];
AddAdvisorOnChainCreation(obj, name);
}
}
/// <summary>
/// Determine the type of the object with the given name.
/// </summary>
/// <remarks>
/// <p>
/// More specifically, checks the type of object that
/// <see cref="Spring.Objects.Factory.IObjectFactory.GetObject(string)"/> would return.
/// For an <see cref="Spring.Objects.Factory.IFactoryObject"/>, returns the type
/// of object that the <see cref="Spring.Objects.Factory.IFactoryObject"/> creates.
/// </p>
/// </remarks>
/// <param name="name">The name of the object to query.</param>
/// <returns>
/// The <see cref="System.Type"/> of the object or <see langword="null"/> if
/// not determinable.
/// </returns>
public Type GetType(string name)
{
string objectName = ObjectFactoryUtils.TransformedObjectName(name);
object instance = objects[objectName];
if (instance == null)
{
throw new NoSuchObjectDefinitionException(name, GrabDefinedObjectsString());
}
if (instance is IFactoryObject && !ObjectFactoryUtils.IsFactoryDereference(name))
{
return(((IFactoryObject)instance).ObjectType);
}
return(instance.GetType());
}
/// <summary>
/// Gets the names of advisor candidates
/// </summary>
/// <param name="targetType">the type of the object to be advised</param>
/// <param name="targetName">the name of the object to be advised</param>
/// <returns>a non-null string array of advisor candidate names</returns>
protected virtual IList <string> GetAdvisorCandidateNames(Type targetType, string targetName)
{
if (_cachedObjectNames == null)
{
lock (this)
{
if (_cachedObjectNames == null)
{
List <string> candidateNameList = new List <string>();
IList <string> advisorCandidateNames = ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(_objectFactory, typeof(IAdvisor), true, false);
candidateNameList.AddRange(advisorCandidateNames);
IList <string> advisorsCandidateNames = ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(_objectFactory, typeof(IAdvisors), true, false);
candidateNameList.AddRange(advisorsCandidateNames);
_cachedObjectNames = candidateNameList;
}
}
}
return(_cachedObjectNames);
}
/// <summary>
/// Gets the names of advisor candidates
/// </summary>
/// <param name="targetType">the type of the object to be advised</param>
/// <param name="targetName">the name of the object to be advised</param>
/// <returns>a non-null string array of advisor candidate names</returns>
protected virtual string[] GetAdvisorCandidateNames(Type targetType, string targetName)
{
if (_cachedObjectNames == null)
{
lock (this)
{
if (_cachedObjectNames == null)
{
ArrayList candidateNameList = new ArrayList();
string[] advisorCandidateNames = ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(_objectFactory, typeof(IAdvisor), true, false);
candidateNameList.AddRange(advisorCandidateNames);
string[] advisorsCandidateNames = ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(_objectFactory, typeof(IAdvisors), true, false);
candidateNameList.AddRange(advisorsCandidateNames);
_cachedObjectNames = (string[])candidateNameList.ToArray(typeof(string));
}
}
}
return(_cachedObjectNames);
}
/// <summary>
/// Detects the petsistence exception translators in the given object factory.
/// </summary>
/// <param name="objectFactory">The object factory for obtaining all IPersistenceExceptionTranslators.</param>
/// <returns>A chained IPersistenceExceptionTranslator, combining all PersistenceExceptionTranslators found in the factory
/// </returns>
/// <seealso cref="ChainedPersistenceExceptionTranslator"/>
protected IPersistenceExceptionTranslator DetectPersistenceExceptionTranslators(IListableObjectFactory objectFactory)
{
// Find all translators, being careful not to activate FactoryObjects.
IDictionary <string, object> pets =
ObjectFactoryUtils.ObjectsOfTypeIncludingAncestors(objectFactory,
typeof(IPersistenceExceptionTranslator), false,
false);
if (pets.Count == 0)
{
throw new InvalidOperationException("No persistence exception translators found in container. Cannot perform exception translation.");
}
ChainedPersistenceExceptionTranslator cpet = new ChainedPersistenceExceptionTranslator();
foreach (KeyValuePair <string, object> pet in pets)
{
cpet.AddTranslator((IPersistenceExceptionTranslator)pet.Value);
}
return(cpet);
}
/// <summary> Add all global introductions.</summary>
private void AddGlobalIntroduction(IListableObjectFactory objectFactory, string prefix)
{
IList <string> globalAspectNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvisors));
IList <string> globalAdvisorNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvisor));
IList <string> globalIntroductionNames =
ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(objectFactory, typeof(IAdvice));
ArrayList objects = new ArrayList();
Dictionary <object, string> names = new Dictionary <object, string>();
for (int i = 0; i < globalAspectNames.Count; i++)
{
string name = globalAspectNames[i];
if (name.StartsWith(prefix))
{
IAdvisors advisors = (IAdvisors)objectFactory.GetObject(name);
foreach (object advisor in advisors.Advisors)
{
// only include introduction advisors
if (advisor is IIntroductionAdvisor)
{
objects.Add(advisor);
names[advisor] = name;
}
}
}
}
for (int i = 0; i < globalAdvisorNames.Count; i++)
{
string name = globalAdvisorNames[i];
if (name.StartsWith(prefix))
{
object obj = objectFactory.GetObject(name);
// only include introduction advisors
if (obj is IIntroductionAdvisor)
{
objects.Add(obj);
names[obj] = name;
}
}
}
for (int i = 0; i < globalIntroductionNames.Count; i++)
{
string name = globalIntroductionNames[i];
if (name.StartsWith(prefix))
{
object obj = objectFactory.GetObject(name);
// exclude other advice types
if (!(obj is IInterceptor || obj is IBeforeAdvice || obj is IAfterReturningAdvice))
{
objects.Add(obj);
names[obj] = name;
}
}
}
objects.Sort(new OrderComparator());
foreach (object obj in objects)
{
string name = names[obj];
AddIntroductionOnChainCreation(obj, name);
}
}
/// <summary>
/// Return the object instances that match the given object
/// <see cref="System.Type"/> (including subclasses).
/// </summary>
/// <param name="type">
/// The <see cref="System.Type"/> (class or interface) to match.
/// </param>
/// <param name="includeNonSingletons">
/// Whether to include prototype objects too or just singletons (also applies to
/// <see cref="Spring.Objects.Factory.IFactoryObject"/>s).
/// </param>
/// <param name="allowEagerInit">
/// Whether to include <see cref="Spring.Objects.Factory.IFactoryObject"/>s too
/// or just normal objects.
/// </param>
/// <returns>
/// An <see cref="System.Collections.IDictionary"/> of the matching objects,
/// containing the object names as keys and the corresponding object instances
/// as values.
/// </returns>
/// <exception cref="Spring.Objects.ObjectsException">
/// If any of the objects could not be created.
/// </exception>
/// <seealso cref="Spring.Objects.Factory.IListableObjectFactory.GetObjectsOfType(Type, bool, bool)"/>
protected IList DoGetObjectNamesForType(Type type, bool includeNonSingletons, bool allowEagerInit)
{
IList result = new ArrayList();
string[] objectNames = GetObjectDefinitionNames();
foreach (string s in objectNames)
{
string objectName = s;
if (!IsAlias(objectName))
{
try
{
RootObjectDefinition mod = GetMergedObjectDefinition(objectName, false);
// Only check object definition if it is complete
if (!mod.IsAbstract &&
(allowEagerInit || (mod.HasObjectType || !mod.IsLazyInit /*|| this.AllowEagerTypeLoading*/) &&
!RequiresEagerInitForType(mod.FactoryObjectName)))
{
bool isFactoryObject = IsFactoryObject(objectName, mod);
bool matchFound =
(allowEagerInit || !isFactoryObject || ContainsSingleton(objectName)) &&
(includeNonSingletons || IsSingleton(objectName)) && IsTypeMatch(objectName, type);
if (!matchFound && isFactoryObject)
{
// in case of a FactoryObject, try to match FactoryObject instance itself next
objectName = ObjectFactoryUtils.BuildFactoryObjectName(objectName);
matchFound = (includeNonSingletons || mod.IsSingleton) && IsTypeMatch(objectName, type);
}
if (matchFound)
{
result.Add(objectName);
}
}
}
catch (CannotLoadObjectTypeException ex)
{
if (allowEagerInit)
{
throw;
}
// Probably contains a placeholder; lets ignore it for type matching purposes.
if (log.IsDebugEnabled)
{
log.Debug("Ignoring object class loading failure for object '" + objectName + "'", ex);
}
}
catch (ObjectDefinitionStoreException ex)
{
if (allowEagerInit)
{
throw;
}
// Probably contains a placeholder; lets ignore it for type matching purposes.
if (log.IsDebugEnabled)
{
log.Debug("Ignoring unresolvable metadata in object definition '" + objectName + "'", ex);
}
}
}
}
// check singletons too, to catch manually registered singletons...
string[] singletonNames = GetSingletonNames();
foreach (string s in singletonNames)
{
string objectName = s;
// only check if manually registered...
if (!ContainsObjectDefinition(objectName))
{
// in the case of an IFactoryObject, match the object created by the IFactoryObject...
if (IsFactoryObject(objectName))
{
if ((includeNonSingletons || IsSingleton(objectName)) && IsTypeMatch(objectName, type))
{
result.Add(objectName);
continue;
}
objectName = ObjectFactoryUtils.BuildFactoryObjectName(objectName);
}
if (IsTypeMatch(objectName, type))
{
result.Add(objectName);
}
}
}
return(result);
}
/// <summary>
/// Ensure that all non-lazy-init singletons are instantiated, also
/// considering <see cref="Spring.Objects.Factory.IFactoryObject"/>s.
/// </summary>
/// <exception cref="Spring.Objects.ObjectsException">
/// If one of the singleton objects could not be created.
/// </exception>
/// <seealso cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory.PreInstantiateSingletons"/>
public void PreInstantiateSingletons()
{
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug("Pre-instantiating singletons in factory [" + this + "]");
}
#endregion
try
{
int definitionCount = objectDefinitionNames.Count;
for (int i = 0; i < definitionCount; i++)
{
string name = (string)objectDefinitionNames[i];
if (!ContainsSingleton(name) && ContainsObjectDefinition(name))
{
RootObjectDefinition definition
= GetMergedObjectDefinition(name, false);
if (!definition.IsAbstract &&
definition.IsSingleton &&
!definition.IsLazyInit)
{
Type objectType = ResolveObjectType(definition, name);
if (objectType != null &&
typeof(IFactoryObject).IsAssignableFrom(definition.ObjectType))
{
IFactoryObject factoryObject = (IFactoryObject)GetObject(
ObjectFactoryUtils.
BuildFactoryObjectName(name));
if (factoryObject.IsSingleton)
{
GetObject(name);
}
}
else
{
GetObject(name);
}
}
}
}
}
catch (ObjectsException)
{
// destroy already created singletons to avoid dangling resources...
try
{
Dispose();
}
catch (Exception ex)
{
log.Error(
"PreInstantiateSingletons failed but couldn't destroy any already-created singletons.",
ex);
}
throw;
}
}
/// <summary>
/// Find object instances that match the <paramref name="requiredType"/>.
/// </summary>
/// <remarks>
/// <p>
/// Called by autowiring. If a subclass cannot obtain information about object
/// names by <see cref="System.Type"/>, a corresponding exception should be thrown.
/// </p>
/// </remarks>
/// <param name="requiredType">
/// The type of the objects to look up.
/// </param>
/// <returns>
/// An <see cref="System.Collections.IDictionary"/> of object names and object
/// instances that match the <paramref name="requiredType"/>, or
/// <see langword="null"/> if none is found.
/// </returns>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
protected override IDictionary FindMatchingObjects(Type requiredType)
{
return(ObjectFactoryUtils.ObjectsOfTypeIncludingAncestors(
this, requiredType, true, true));
}
