public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
if (_configurationHandler != null)
{
_configurationHandler(factory);
}
}
public void SetUp()
{
IObjectFactory grandparent = new XmlObjectFactory(new ReadOnlyXmlTestResource("root.xml", GetType()));
IObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("middle.xml", GetType()), grandparent);
IConfigurableListableObjectFactory child = new XmlObjectFactory(new ReadOnlyXmlTestResource("leaf.xml", GetType()), parent);
_factory = child;
}
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
IList<string> objectDefinitionNames = factory.GetObjectDefinitionNames();
if (Logger.IsInfoEnabled)
Logger.Info("Iniciando proceso para establecer el alcance de los services y controllers");
foreach (string objectDefinitionName in objectDefinitionNames)
{
IObjectDefinition objectDefinition = factory.GetObjectDefinition(objectDefinitionName);
if (objectDefinition is ScannedGenericObjectDefinition)
{
var componentAttribute =
Attribute.GetCustomAttribute(objectDefinition.ObjectType, typeof (ComponentAttribute), true) as
ComponentAttribute;
if ( (componentAttribute is ControllerAttribute) || (WcfServices && componentAttribute is ServiceAttribute) )
{
if (Logger.IsInfoEnabled)
Logger.InfoFormat("Estableciendo alcance para la definición {0}", objectDefinitionName);
objectDefinition.Scope = "prototype";
}
}
}
}
private static bool IsLazyInit(IConfigurableListableObjectFactory configurableObjectFactory, string name)
{
if (configurableObjectFactory == null)
{
return false;
}
return configurableObjectFactory.GetObjectDefinition(name).IsLazyInit;
}
/// <summary>
/// Registers any type aliases. The supplied
/// <paramref name="factory"/> is not used since type aliases
/// are registered with a global <see cref="TypeRegistry"/>
/// </summary>
/// <param name="factory">
/// The object factory.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public override void PostProcessObjectFactory(
IConfigurableListableObjectFactory factory)
{
if (types != null)
{
foreach (DictionaryEntry entry in types)
{
string alias = entry.Key.ToString();
Type type = ResolveRequiredType(entry.Value, "value", "custom type alias");
TypeRegistry.RegisterType(alias, type);
}
}
}
public void MalformedOverrideKey()
{
IConfigurableListableObjectFactory objectFactory = A.Fake <IConfigurableListableObjectFactory>();
IConfigurableListableObjectFactory fac = objectFactory;
PropertyOverrideConfigurer cfg = new PropertyOverrideConfigurer();
NameValueCollection defaultProperties = new NameValueCollection();
defaultProperties.Add("malformedKey", "Rick Evans");
cfg.Properties = defaultProperties;
Assert.Throws <FatalObjectException>(() => cfg.PostProcessObjectFactory(fac));
}
/// <summary>
/// Registers custom IResource implementations. The supplied
/// <paramref name="factory"/> is not used since IResourse implementations
/// are registered with a global <see cref="Spring.Core.IO.ResourceHandlerRegistry"/>
/// </summary>
/// <param name="factory">
/// The object factory.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public override void PostProcessObjectFactory(
IConfigurableListableObjectFactory factory)
{
if (resourceHandlers != null)
{
foreach (DictionaryEntry entry in resourceHandlers)
{
string protocolName = entry.Key.ToString();
Type type = ResolveRequiredType(entry.Value, "value", "custom IResource implementation");
ResourceHandlerRegistry.RegisterResourceHandler(protocolName, type);
}
}
}
protected override void InitializeServiceLocator()
{
IConfigurableApplicationContext context = new StaticApplicationContext();
objectFactory = context.ObjectFactory;
var sl = new SpringServiceLocatorAdapter(objectFactory);
objectFactory.RegisterInstance <IServiceLocator>(sl);
ServiceLocator.SetLocatorProvider(() => sl);
objectFactory.Register <IInvoiceTotalCalculator, SumAndTaxTotalCalculator>();
objectFactory.RegisterPrototype <IInvoice, Invoice>();
}
/// <summary>
/// Registers any custom converters with the supplied
/// <paramref name="factory"/>.
/// </summary>
/// <param name="factory">
/// The object factory to register the converters with.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public override void PostProcessObjectFactory(
IConfigurableListableObjectFactory factory)
{
if (_customConverters != null)
{
foreach (DictionaryEntry entry in _customConverters)
{
Type requiredType = ResolveRequiredType(entry.Key, "key", "custom type converter");
TypeConverter converter = ResolveConverter(entry.Value);
factory.RegisterCustomConverter(requiredType, converter);
}
}
}
public void DoesNotChokeOnBadResourceLocationIfIgnoreBadResourcesFlagSetToTrue()
{
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.IgnoreResourceNotFound = true;
IResource mockResource = A.Fake <IResource>();
A.CallTo(() => mockResource.Exists).Returns(false);
cfg.Location = mockResource;
cfg.ConfigSections = new string[] { "" };
IConfigurableListableObjectFactory mockFactory = A.Fake <IConfigurableListableObjectFactory>();
A.CallTo(() => mockFactory.GetObjectDefinitionNames(false)).Returns(new string[] {});
cfg.PostProcessObjectFactory(mockFactory);
}
public void PostProcessObjectFactory(IConfigurableListableObjectFactory objectFactory)
{
IObjectDefinitionRegistry registry = objectFactory as IObjectDefinitionRegistry;
if (registry != null)
{
RegisterNullChannel(registry);
RegisterErrorChannelIfNecessary(registry);
RegisterTaskSchedulerIfNecessary(registry);
}
else if (logger.IsWarnEnabled)
{
logger.Warn("ObjectFactory is not a ObjectDefinitionRegistry. The default '"
+ IntegrationContextUtils.ErrorChannelObjectName + "' and '"
+ IntegrationContextUtils.TaskSchedulerObjectName + "' cannot be configured.");
}
}
/// <summary>
/// Postprocesses the object factory.
/// </summary>
/// <param name="objectFactory">The object factory.</param>
public void PostProcessObjectFactory(IConfigurableListableObjectFactory objectFactory)
{
if (_postProcessObjectFactoryCalled)
{
throw new InvalidOperationException(
"PostProcessObjectFactory already called for this post-processor");
}
_postProcessObjectFactoryCalled = true;
if (!_postProcessObjectDefinitionRegistryCalled)
{
// ObjectDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigObjectDefinitions lazily at this point then.
ProcessConfigObjectDefinitions((IObjectDefinitionRegistry)objectFactory);
}
EnhanceConfigurationClasses(objectFactory);
}
/// <summary>
/// Inject dependencies into 'this' instance (that is, this test instance).
/// </summary>
/// <remarks>
/// <p>The default implementation populates protected variables if the
/// <see cref="PopulateProtectedVariables"/> property is set, else
/// uses autowiring if autowiring is switched on (which it is by default).</p>
/// <p>You can certainly override this method if you want to totally control
/// how dependencies are injected into 'this' instance.</p>
/// </remarks>
protected virtual void InjectDependencies()
{
if (PopulateProtectedVariables)
{
if (managedVariableNames == null)
{
InitManagedVariableNames();
}
InjectProtectedVariables();
}
else if (AutowireMode != AutoWiringMode.No)
{
IConfigurableListableObjectFactory factory = applicationContext.ObjectFactory;
((AbstractObjectFactory)factory).IgnoreDependencyType(typeof(AutoWiringMode));
factory.AutowireObjectProperties(this, AutowireMode, DependencyCheck);
}
}
public void ObjectNamesIncludingAncestorsPreserveOrderOfRegistration()
{
MockRepository mocks = new MockRepository();
IConfigurableListableObjectFactory of = (IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory));
IConfigurableListableObjectFactory ofParent = (IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory));
Expect.Call(of.GetObjectNamesForType(typeof(object))).Return(new string[] { "objA", "objB", "objC" });
Expect.Call(((IHierarchicalObjectFactory)of).ParentObjectFactory).Return(ofParent);
Expect.Call(ofParent.GetObjectNamesForType(typeof(object))).Return(new string[] { "obj2A", "objB", "obj2C" });
mocks.ReplayAll();
string[] names = ObjectFactoryUtils.ObjectNamesIncludingAncestors(of);
Assert.AreEqual(5, names.Length);
Assert.AreEqual(new string[] { "objA", "objB", "objC", "obj2A", "obj2C" }, names);
mocks.VerifyAll();
}
public void MissingObjectDefinitionDoesntRaiseFatalException()
{
const string valueTo_NOT_BeOveridden = "Jenny Lewis";
TestObject foo = new TestObject(valueTo_NOT_BeOveridden, 30);
IConfigurableListableObjectFactory objectFactory = A.Fake <IConfigurableListableObjectFactory>();
A.CallTo(() => objectFactory.GetObjectDefinition("rubbish")).Returns(null);
IConfigurableListableObjectFactory fac = objectFactory;
PropertyOverrideConfigurer cfg = new PropertyOverrideConfigurer();
NameValueCollection defaultProperties = new NameValueCollection();
defaultProperties.Add("rubbish.Name", "Rick Evans");
cfg.Properties = defaultProperties;
cfg.PostProcessObjectFactory(fac);
Assert.AreEqual(valueTo_NOT_BeOveridden, foo.Name, "Property value was overridden, but a rubbish objectName root was supplied.");
}
private void AutodetectBeans(Func <Type, string, bool> shouldExportCallback)
{
IConfigurableListableObjectFactory configurableObjectFactory = _objectFactory as IConfigurableListableObjectFactory;
foreach (string name in _objectFactory.GetObjectNamesForType(typeof(object), false, false))
{
Type beanType = _objectFactory.GetType(name);
if (shouldExportCallback(beanType, name))
{
bool lazyInit = IsLazyInit(configurableObjectFactory, name);
object instance = !lazyInit ? _objectFactory[name] : null;
if (!_beans.Contains(name) &&
(instance == null || !BeansContainsInstance(instance)))
{
_beans[name] = !lazyInit ? instance : name;
}
}
}
}
public void DoesNotChokeOnBadResourceLocationIfIgnoreBadResourcesFlagSetToTrue()
{
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.IgnoreResourceNotFound = true;
IResource mockResource = (IResource)mocks.CreateMock(typeof(IResource));
Expect.Call(mockResource.Exists).Return(false);
cfg.Location = mockResource;
cfg.ConfigSections = new string[] { "" };
IConfigurableListableObjectFactory mockFactory = (IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory));
Expect.Call(mockFactory.GetObjectDefinitionNames()).Return(new string[] {});
mocks.ReplayAll();
cfg.PostProcessObjectFactory(mockFactory);
mocks.VerifyAll();
}
public static void RegisterDefaultConversationAop(this IConfigurableListableObjectFactory confObjFactory)
{
var metaInfoStore = new ReflectionConversationalMetaInfoSource();
confObjFactory.RegisterInstance(metaInfoStore);
// register advisor definition
var pc =
ObjectDefinitionBuilder.RootObjectDefinition(ObjectDefinitionFactory,
typeof(ConversationInterceptor))
.SetAutowireMode(AutoWiringMode.AutoDetect)
.SetSingleton(false);
confObjFactory.RegisterObjectDefinition("PersistentConversationalInterceptor", pc.ObjectDefinition);
var postProcessor = new ConversationalAttributeAutoProxyCreator(metaInfoStore)
{
ObjectFactory = confObjFactory,
InterceptorNames = new[] { "PersistentConversationalInterceptor" }
};
confObjFactory.AddObjectPostProcessor(postProcessor);
}
/// <summary>
/// Apply the given properties to the supplied
/// <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>.
/// </summary>
/// <param name="factory">
/// The <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>
/// used by the application context.
/// </param>
/// <param name="props">The properties to apply.</param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If an error occured.
/// </exception>
protected override void ProcessProperties(IConfigurableListableObjectFactory factory, NameValueCollection props)
{
PlaceholderResolveHandlerAdapter resolveAdapter = new PlaceholderResolveHandlerAdapter(this, props);
ObjectDefinitionVisitor visitor = new ObjectDefinitionVisitor(new ObjectDefinitionVisitor.ResolveHandler(resolveAdapter.ParseAndResolveVariables));
string[] objectDefinitionNames = factory.GetObjectDefinitionNames();
for (int i = 0; i < objectDefinitionNames.Length; ++i)
{
string name = objectDefinitionNames[i];
IObjectDefinition definition = factory.GetObjectDefinition(name);
try
{
visitor.VisitObjectDefinition(definition);
}
catch (ObjectDefinitionStoreException ex)
{
throw new ObjectDefinitionStoreException(
definition.ResourceDescription, name, ex.Message);
}
}
}
public void MalformedOverrideKey()
{
IConfigurableListableObjectFactory objectFactory = mocks.StrictMock <IConfigurableListableObjectFactory>();
IConfigurableListableObjectFactory fac = objectFactory;
PropertyOverrideConfigurer cfg = new PropertyOverrideConfigurer();
NameValueCollection defaultProperties = new NameValueCollection();
defaultProperties.Add("malformedKey", "Rick Evans");
cfg.Properties = defaultProperties;
mocks.ReplayAll();
try
{
cfg.PostProcessObjectFactory(fac);
Assert.Fail("Should have had a FatalObjectException at this point because of a malformed key.");
}
catch (FatalObjectException)
{
}
mocks.VerifyAll();
}
public void ObjectNamesForTypeIncludingAncestorsPrototypesAndFactoryObjectsPreserveOrderOfRegistration()
{
MockRepository mocks = new MockRepository();
IConfigurableListableObjectFactory of = (IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory));
IConfigurableListableObjectFactory ofParent = (IConfigurableListableObjectFactory)mocks.DynamicMock(typeof(IConfigurableListableObjectFactory));
Type EXPECTEDTYPE = typeof(ITestObject);
Expect.Call(of.GetObjectNamesForType(EXPECTEDTYPE, false, false)).Return(new string[] { "objA", "objB", "objC" });
Expect.Call(((IHierarchicalObjectFactory)of).ParentObjectFactory).Return(ofParent);
Expect.Call(ofParent.GetObjectNamesForType(EXPECTEDTYPE, false, false)).Return(new string[] { "obj2A", "objB", "obj2C" });
mocks.ReplayAll();
IList <string> names = ObjectFactoryUtils.ObjectNamesForTypeIncludingAncestors(of, EXPECTEDTYPE, false, false);
Assert.AreEqual(5, names.Count);
Assert.AreEqual(new string[] { "objA", "objB", "objC", "obj2A", "obj2C" }, names);
mocks.VerifyAll();
}
public void MissingObjectDefinitionDoesntRaiseFatalException()
{
const string valueTo_NOT_BeOveridden = "Jenny Lewis";
TestObject foo = new TestObject(valueTo_NOT_BeOveridden, 30);
IConfigurableListableObjectFactory objectFactory =
(IConfigurableListableObjectFactory)mocks.CreateMock(typeof(IConfigurableListableObjectFactory));
Expect.Call(objectFactory.GetObjectDefinition("rubbish")).Return(null);
IConfigurableListableObjectFactory fac = (IConfigurableListableObjectFactory)objectFactory;
PropertyOverrideConfigurer cfg = new PropertyOverrideConfigurer();
NameValueCollection defaultProperties = new NameValueCollection();
defaultProperties.Add("rubbish.Name", "Rick Evans");
cfg.Properties = defaultProperties;
mocks.ReplayAll();
cfg.PostProcessObjectFactory(fac);
Assert.AreEqual(valueTo_NOT_BeOveridden, foo.Name,
"Property value was overridden, but a rubbish objectName root was supplied.");
mocks.VerifyAll();
}
private static void RegisterObject(string objectName, object obj, IObjectFactory objectFactory)
{
AssertUtils.ArgumentNotNull(objectName, "object name must not be null");
IConfigurableListableObjectFactory configurableListableObjectFactory = null;
if (objectFactory is IConfigurableListableObjectFactory)
{
configurableListableObjectFactory = (IConfigurableListableObjectFactory)objectFactory;
}
else if (objectFactory is GenericApplicationContext)
{
configurableListableObjectFactory = ((GenericApplicationContext)objectFactory).ObjectFactory;
}
if (obj is IObjectNameAware)
{
((IObjectNameAware)obj).ObjectName = objectName;
}
if (obj is IObjectFactoryAware)
{
((IObjectFactoryAware)obj).ObjectFactory = objectFactory;
}
if (obj is IInitializingObject)
{
try
{
((IInitializingObject)obj).AfterPropertiesSet();
}
catch (Exception ex)
{
throw new FatalObjectException("failed to register bean with test context", ex);
}
}
if (configurableListableObjectFactory == null)
{
throw new ArgumentException("configurableListableObjectFactory must not be null");
}
configurableListableObjectFactory.RegisterSingleton(objectName, obj);
}
/// <summary>
/// Modify the application context's internal object factory after its
/// standard initialization.
/// </summary>
/// <param name="factory">
/// The object factory used by the application context.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
/// <seealso cref="Spring.Objects.Factory.Config.IObjectFactoryPostProcessor.PostProcessObjectFactory(IConfigurableListableObjectFactory)"/>
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
try
{
NameValueCollection properties = new NameValueCollection();
InitializeWithDefaultProperties(properties);
LoadProperties(properties);
ProcessProperties(factory, properties);
}
catch (Exception ex)
{
if (typeof(ObjectsException).IsInstanceOfType(ex))
{
throw;
}
else
{
throw new ObjectsException(
"Errored while postprocessing an object factory.", ex);
}
}
}
/// <summary>
/// Apply the property replacement using the specified <see cref="IVariableSource"/>s for all
/// object in the supplied
/// <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>.
/// </summary>
/// <param name="factory">
/// The <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>
/// used by the application context.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If an error occured.
/// </exception>
protected virtual void ProcessProperties(IConfigurableListableObjectFactory factory)
{
CompositeVariableSource compositeVariableSource = new CompositeVariableSource(variableSourceList);
TextProcessor tp = new TextProcessor(this, compositeVariableSource);
ObjectDefinitionVisitor visitor = new ObjectDefinitionVisitor(new ObjectDefinitionVisitor.ResolveHandler(tp.ParseAndResolveVariables));
string[] objectDefinitionNames = factory.GetObjectDefinitionNames();
for (int i = 0; i < objectDefinitionNames.Length; ++i)
{
string name = objectDefinitionNames[i];
IObjectDefinition definition = factory.GetObjectDefinition(name);
try
{
visitor.VisitObjectDefinition(definition);
}
catch (ObjectDefinitionStoreException ex)
{
throw new ObjectDefinitionStoreException(
definition.ResourceDescription, name, ex.Message);
}
}
}
public void WithIgnoreUnresolvablePlaceholder()
{
const string defName = "foo";
const string placeholder = "${name}";
TestObject foo = new TestObject(placeholder, 30);
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("name", placeholder);
RootObjectDefinition def = new RootObjectDefinition(typeof(TestObject), pvs);
IConfigurableListableObjectFactory mock = A.Fake <IConfigurableListableObjectFactory>();
A.CallTo(() => mock.GetObjectDefinitionNames(false)).Returns(new string [] { defName });
A.CallTo(() => mock.GetObjectDefinition(defName, false)).Returns(def);
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.IgnoreUnresolvablePlaceholders = true;
cfg.PostProcessObjectFactory(mock);
Assert.AreEqual(placeholder, foo.Name);
A.CallTo(() => mock.AddEmbeddedValueResolver(null)).WithAnyArguments().MustHaveHappened();
}
public void WithIgnoreUnresolvablePlaceholder()
{
const string defName = "foo";
const string placeholder = "${name}";
TestObject foo = new TestObject(placeholder, 30);
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("name", placeholder);
RootObjectDefinition def = new RootObjectDefinition(typeof(TestObject), pvs);
IConfigurableListableObjectFactory mock = (IConfigurableListableObjectFactory)mocks.CreateMock(typeof(IConfigurableListableObjectFactory));
Expect.Call(mock.GetObjectDefinitionNames()).Return(new string [] { defName });
Expect.Call(mock.GetObjectDefinition(defName)).Return(def);
mocks.ReplayAll();
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.IgnoreUnresolvablePlaceholders = true;
cfg.PostProcessObjectFactory(mock);
Assert.AreEqual(placeholder, foo.Name);
mocks.VerifyAll();
}
/// <summary>
/// Modify the application context's internal object factory after its
/// standard initialization.
/// </summary>
/// <param name="factory">The object factory used by the application context.</param>
/// <remarks>
/// <p>
/// All object definitions will have been loaded, but no objects will have
/// been instantiated yet. This allows for overriding or adding properties
/// even to eager-initializing objects.
/// </p>
/// </remarks>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public void PostProcessObjectFactory( IConfigurableListableObjectFactory factory )
{
if (CollectionUtils.IsEmpty(variableSourceList))
{
throw new ArgumentException("No VariableSources configured");
}
ICollection filtered = CollectionUtils.FindValuesOfType(this.variableSourceList, typeof (IVariableSource));
if (filtered.Count != this.variableSourceList.Count)
{
throw new ArgumentException("'VariableSources' must contain IVariableSource elements only", "VariableSources");
}
try
{
ProcessProperties( factory );
}
catch (Exception ex)
{
if (typeof( ObjectsException ).IsInstanceOfType( ex ))
{
throw;
}
else
{
throw new ObjectsException(
"Errored while postprocessing an object factory.", ex );
}
}
}
/// <summary>
/// Registers well-known <see cref="IObjectPostProcessor"/>s and
/// preregisters well-known dependencies using <see cref="IConfigurableListableObjectFactory.RegisterResolvableDependency"/>
/// </summary>
/// <param name="objectFactory">the raw object factory as returned from <see cref="RefreshObjectFactory"/></param>
private void PrepareObjectFactory(IConfigurableListableObjectFactory objectFactory)
{
EnsureKnownObjectPostProcessors(objectFactory);
objectFactory.IgnoreDependencyType(typeof(IResourceLoader));
objectFactory.IgnoreDependencyType(typeof(IApplicationContext));
objectFactory.RegisterResolvableDependency(typeof(IObjectFactory), objectFactory);
objectFactory.RegisterResolvableDependency(typeof(IResourceLoader), this);
objectFactory.RegisterResolvableDependency(typeof(IApplicationEventPublisher), this);
objectFactory.RegisterResolvableDependency(typeof(IApplicationContext), this);
objectFactory.RegisterResolvableDependency(typeof(IEventRegistry), this);
}
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
Called = true;
}
public void SetUp()
{
mocks = new MockRepository();
factory = mocks.StrictMock <IConfigurableListableObjectFactory>();
}
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
SPRNET1231FactoryObject testFactory = (SPRNET1231FactoryObject)factory.GetObject("testFactory");
Assert.AreEqual(0, testFactory.count);
}
/// <summary>
/// An new <see cref="IConfigurableListableObjectFactory"/> was set. Initialize this creator instance
/// according to the specified object factory.
/// </summary>
/// <param name="objectFactory"></param>
protected virtual void InitObjectFactory(IConfigurableListableObjectFactory objectFactory)
{
_advisorRetrievalHelper = CreateAdvisorRetrievalHelper(objectFactory);
}
private void EnhanceConfigurationClasses(IConfigurableListableObjectFactory objectFactory)
{
ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer(objectFactory);
IList<string> objectNames = objectFactory.GetObjectDefinitionNames();
foreach (string name in objectNames)
{
IObjectDefinition objDef = objectFactory.GetObjectDefinition(name);
if (((AbstractObjectDefinition)objDef).HasObjectType)
{
if (Attribute.GetCustomAttribute(objDef.ObjectType, typeof(ConfigurationAttribute)) != null)
{
//TODO check type of object isn't infrastructure type.
Type configClass = objDef.ObjectType;
Type enhancedClass = enhancer.Enhance(configClass);
Logger.Debug(m => m("Replacing object definition '{0}' existing class '{1}' with enhanced class", name, configClass.FullName));
((IConfigurableObjectDefinition)objDef).ObjectType = enhancedClass;
}
}
}
}
/// <summary>
/// DO NOT USE - this is subject to change!
/// </summary>
/// <param name="appRelativeVirtualPath"></param>
/// <param name="objectFactory"></param>
/// <returns>
/// This method requires registrars to follow the convention of registering web object definitions using their
/// application relative urls (~/mypath/mypage.aspx).
/// </returns>
/// <remarks>
/// Resolve an object definition by url.
/// </remarks>
protected internal static NamedObjectDefinition FindWebObjectDefinition(string appRelativeVirtualPath, IConfigurableListableObjectFactory objectFactory)
{
ILog Log = LogManager.GetLogger(typeof(AbstractHandlerFactory));
bool isDebug = Log.IsDebugEnabled;
// lookup definition using app-relative url
if (isDebug)
Log.Debug(string.Format("GetHandler():looking up definition for app-relative url '{0}'", appRelativeVirtualPath));
string objectDefinitionName = appRelativeVirtualPath;
IObjectDefinition pageDefinition = objectFactory.GetObjectDefinition(appRelativeVirtualPath, true);
if (pageDefinition == null)
{
// try using pagename+extension and pagename only
string pageExtension = Path.GetExtension(appRelativeVirtualPath);
string pageName = WebUtils.GetPageName(appRelativeVirtualPath);
// only looks in the specified object factory -- it will *not* search parent contexts
pageDefinition = objectFactory.GetObjectDefinition(pageName + pageExtension, false);
if (pageDefinition == null)
{
pageDefinition = objectFactory.GetObjectDefinition(pageName, false);
if (pageDefinition != null)
objectDefinitionName = pageName;
}
else
{
objectDefinitionName = pageName + pageExtension;
}
if (pageDefinition != null)
{
if (isDebug)
Log.Debug(string.Format("GetHandler():found definition for page-name '{0}'", objectDefinitionName));
}
else
{
if (isDebug)
Log.Debug(string.Format("GetHandler():no definition found for page-name '{0}'", pageName));
}
}
else
{
if (isDebug)
Log.Debug(string.Format("GetHandler():found definition for page-url '{0}'", appRelativeVirtualPath));
}
return (pageDefinition == null) ? (NamedObjectDefinition)null : new NamedObjectDefinition(objectDefinitionName, pageDefinition);
}
/// <summary>
/// Initializes a new instance of the <see cref="SpringObjectMethodInterceptor"/> class.
/// </summary>
/// <param name="configurableListableObjectFactory">The configurable listable object factory.</param>
public SpringObjectMethodInterceptor(IConfigurableListableObjectFactory configurableListableObjectFactory)
{
_configurableListableObjectFactory = configurableListableObjectFactory;
}
/// <summary>
/// An new <see cref="IConfigurableListableObjectFactory"/> was set. Initialize this creator instance
/// according to the specified object factory.
/// </summary>
/// <param name="objectFactory"></param>
protected virtual void InitObjectFactory(IConfigurableListableObjectFactory objectFactory)
{
_advisorRetrievalHelper = CreateAdvisorRetrievalHelper(objectFactory);
}
private Type GenerateProxyType(string objectName, IConfigurableListableObjectFactory objectFactory)
{
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.ProxyTargetAttributes = true;
proxyFactory.Interfaces = Type.EmptyTypes;
proxyFactory.TargetSource = new ObjectFactoryTargetSource(objectName, objectFactory);
SpringObjectMethodInterceptor methodInterceptor = new SpringObjectMethodInterceptor(objectFactory);
proxyFactory.AddAdvice(methodInterceptor);
//TODO check type of object isn't infrastructure type.
InheritanceAopProxyTypeBuilder iaptb = new InheritanceAopProxyTypeBuilder(proxyFactory);
//iaptb.ProxyDeclaredMembersOnly = true; // make configurable.
return iaptb.BuildProxyType();
}
/// <summary>
/// Instantiate and invoke all registered
/// <see cref="Spring.Objects.Factory.Config.IObjectFactoryPostProcessor"/>
/// objects, respecting any explicit ordering.
/// </summary>
/// <remarks>
/// <note type="caution">
/// <b>Must</b> be called before singleton instantiation.
/// </note>
/// </remarks>
/// <exception cref="ObjectsException">In the case of errors.</exception>
private void InvokeObjectFactoryPostProcessors(IConfigurableListableObjectFactory objectFactory)
{
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
ArrayList processedObjects = new ArrayList();
if (objectFactory is IObjectDefinitionRegistry)
{
IObjectDefinitionRegistry registry = (IObjectDefinitionRegistry)objectFactory;
ArrayList regularPostProcessors = new ArrayList();
ArrayList registryPostProcessors = new ArrayList();
foreach (IObjectFactoryPostProcessor factoryProcessor in ObjectFactoryPostProcessors)
{
if (factoryProcessor is IObjectDefinitionRegistryPostProcessor)
{
((IObjectDefinitionRegistryPostProcessor)factoryProcessor).PostProcessObjectDefinitionRegistry(registry);
registryPostProcessors.Add(factoryProcessor);
}
else
{
regularPostProcessors.Add(factoryProcessor);
}
}
IDictionary objectMap = objectFactory.GetObjectsOfType(typeof(IObjectDefinitionRegistryPostProcessor), true, false);
ArrayList registryPostProcessorObjects = new ArrayList(objectMap.Values);
registryPostProcessorObjects.Sort(new OrderComparator());
foreach (System.Object processor in registryPostProcessorObjects)
{
((IObjectDefinitionRegistryPostProcessor)processor).PostProcessObjectDefinitionRegistry(registry);
}
InvokeObjectFactoryPostProcessors(registryPostProcessors, objectFactory);
InvokeObjectFactoryPostProcessors(registryPostProcessorObjects, objectFactory);
InvokeObjectFactoryPostProcessors(regularPostProcessors, objectFactory);
// processedObjects.Add(objectMap.Keys);
foreach (DictionaryEntry entry in objectMap)
{
processedObjects.Add(entry.Key);
}
}
else
{
foreach (IObjectFactoryPostProcessor factoryProcessor in ObjectFactoryPostProcessors)
{
// Invoke factory processors registered with the context instance.
factoryProcessor.PostProcessObjectFactory(objectFactory);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
ArrayList factoryProcessorNames = new ArrayList();
string[] names = GetObjectNamesForType(typeof(IObjectFactoryPostProcessor), true, false);
foreach (string name in names)
{
factoryProcessorNames.Add(name);
}
// Separate between ObjectFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
ArrayList priorityOrderedFactoryProcessors = new ArrayList();
ArrayList orderedFactoryProcessorsNames = new ArrayList();
ArrayList nonOrderedFactoryProcessorNames = new ArrayList();
for (int i = 0; i < factoryProcessorNames.Count; ++i)
{
string processorName = (string)factoryProcessorNames[i];
if (processedObjects.Contains(processorName))
{
//skip -- already processed in first phase above
Debug.WriteLine("");
}
else if (IsTypeMatch(processorName, typeof(IPriorityOrdered)))
{
priorityOrderedFactoryProcessors.Add(ObjectFactory.GetObject(processorName, typeof(IObjectFactoryPostProcessor)));
}
else if (IsTypeMatch(processorName, typeof(IOrdered)))
{
orderedFactoryProcessorsNames.Add(processorName);
}
else
{
nonOrderedFactoryProcessorNames.Add(processorName);
}
}
// First, invoke the IObjectFactoryPostProcessors that implement IPriorityOrdered.
InvokePriorityOrderedObjectFactoryPostProcessors(factoryProcessorNames, priorityOrderedFactoryProcessors);
// Second, invoke those IObjectFactoryPostProcessors that implement IOrdered...
ArrayList orderedFactoryProcessors = new ArrayList();
foreach (string orderedFactoryProcessorsName in orderedFactoryProcessorsNames)
{
orderedFactoryProcessors.Add(ObjectFactory.GetObject(orderedFactoryProcessorsName,
typeof(IObjectFactoryPostProcessor)));
}
orderedFactoryProcessors.Sort(new OrderComparator());
InvokeObjectFactoryPostProcessors(orderedFactoryProcessors, ObjectFactory);
// and then the unordered ones...
ArrayList nonOrderedPostProcessors = new ArrayList();
foreach (string nonOrderedFactoryProcessorName in nonOrderedFactoryProcessorNames)
{
nonOrderedPostProcessors.Add(ObjectFactory.GetObject(nonOrderedFactoryProcessorName,
typeof(IObjectFactoryPostProcessor)));
}
InvokeObjectFactoryPostProcessors(nonOrderedPostProcessors, ObjectFactory);
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug(string.Format(
CultureInfo.InvariantCulture,
"processed {0} IFactoryObjectPostProcessors defined in application context [{1}].",
factoryProcessorNames.Count,
Name));
}
#endregion
}
/// <summary>
/// Modify the application context's internal object factory after its
/// standard initialization.
/// </summary>
/// <param name="factory">The object factory used by the application context.</param>
/// <remarks>
/// <p>
/// All object definitions will have been loaded, but no objects will have
/// been instantiated yet. This allows for overriding or adding properties
/// even to eager-initializing objects.
/// </p>
/// </remarks>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public abstract void PostProcessObjectFactory(
IConfigurableListableObjectFactory factory);
public void SetUp()
{
factoryMock = new DynamicMock(typeof(IConfigurableListableObjectFactory));
factory = (IConfigurableListableObjectFactory)factoryMock.Object;
host = NewApplicationHost(AppDomain.CurrentDomain, factory);
}
private void RegisterObjectPostProcessors(IConfigurableListableObjectFactory objectFactory)
{
RefreshObjectPostProcessorChecker(objectFactory);
IDictionary dict = GetObjectsOfType(typeof(IObjectPostProcessor), true, false);
ArrayList objectProcessors = new ArrayList(dict.Values);
// objectProcessors.Sort(new OrderComparator());
foreach (IObjectPostProcessor objectPostProcessor in objectProcessors)
{
ObjectFactory.AddObjectPostProcessor(objectPostProcessor);
}
if (log.IsDebugEnabled)
{
log.Debug(string.Format(
CultureInfo.InvariantCulture,
"processed {0} IObjectPostProcessors defined in application context [{1}].",
objectProcessors.Count,
Name));
}
}
public void SetUp()
{
factory = A.Fake <IConfigurableListableObjectFactory>();
}
public void Reset(IConfigurableListableObjectFactory objectFactory, int objectPostProcessorTargetCount)
{
_objectFactory = objectFactory;
_objectPostProcessorTargetCount = objectPostProcessorTargetCount;
}
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
Called = true;
}
public void SetUp()
{
mocks = new MockRepository();
factory = (IConfigurableListableObjectFactory)
mocks.CreateMock(typeof(IConfigurableListableObjectFactory));
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectFactoryTargetSource"/> class.
/// </summary>
/// <param name="objectName">Name of the object.</param>
/// <param name="objectFactory">The object factory.</param>
public ObjectFactoryTargetSource(string objectName, IConfigurableListableObjectFactory objectFactory)
{
_objectName = objectName;
_objectFactory = objectFactory;
}
/// <summary>
/// Apply the property replacement using the specified <see cref="IVariableSource"/>s for all
/// object in the supplied
/// <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>.
/// </summary>
/// <param name="factory">
/// The <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>
/// used by the application context.
/// </param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If an error occured.
/// </exception>
protected virtual void ProcessProperties( IConfigurableListableObjectFactory factory )
{
CompositeVariableSource compositeVariableSource = new CompositeVariableSource(variableSourceList);
TextProcessor tp = new TextProcessor(this, compositeVariableSource);
ObjectDefinitionVisitor visitor = new ObjectDefinitionVisitor(new ObjectDefinitionVisitor.ResolveHandler(tp.ParseAndResolveVariables));
IList<string> objectDefinitionNames = factory.GetObjectDefinitionNames(includeAncestors);
for (int i = 0; i < objectDefinitionNames.Count; ++i)
{
string name = objectDefinitionNames[i];
IObjectDefinition definition = factory.GetObjectDefinition( name, includeAncestors );
if (definition == null)
continue;
try
{
visitor.VisitObjectDefinition( definition );
}
catch (ObjectDefinitionStoreException ex)
{
throw new ObjectDefinitionStoreException(
definition.ResourceDescription, name, ex.Message );
}
}
}
/// <summary>
/// Ensures, that predefined ObjectPostProcessors are registered with this ObjectFactory
/// </summary>
/// <param name="objectFactory"></param>
protected void EnsureKnownObjectPostProcessors(IConfigurableListableObjectFactory objectFactory)
{
// index 0 contains the ObjectPostProcessorChecker that is handled separately!
for (int i = 1; i < _defaultObjectPostProcessors.Count; i++)
{
objectFactory.AddObjectPostProcessor((IObjectPostProcessor)this._defaultObjectPostProcessors[i]);
}
}
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
Assert.AreEqual(ObjectProcessingState.PostProcessObjectFactory, CurrentState);
CurrentState++;
}
/// <summary>
/// Modify the application context's internal object factory after its standard
/// initialization.
/// </summary>
/// <remarks>
/// <p>
/// All object definitions will have been loaded, but no objects
/// will have been instantiated yet. This allows for the registration
/// of special
/// <see cref="Spring.Objects.Factory.Config.IObjectPostProcessor"/>s
/// in certain
/// <see cref="Spring.Context.IApplicationContext"/> implementations.
/// </p>
/// </remarks>
/// <param name="objectFactory">
/// The object factory used by the application context.
/// </param>
/// <exception cref="ObjectsException">
/// In the case of errors.
/// </exception>.
protected virtual void PostProcessObjectFactory(
IConfigurableListableObjectFactory objectFactory)
{
}
/// <summary>
/// Modify the application context's internal object factory after its
/// standard initialization.
/// </summary>
/// <param name="factory">
/// The object factory used by the application context.
/// </param>
/// <seealso cref="Spring.Objects.Factory.Config.IObjectFactoryPostProcessor.PostProcessObjectFactory(IConfigurableListableObjectFactory)"/>
public void PostProcessObjectFactory(IConfigurableListableObjectFactory factory)
{
string filename = null;
if (UseConfigFile)
{
filename = (Filename == null)
? AppDomain.CurrentDomain.SetupInformation.ConfigurationFile
: Filename.File.FullName;
}
#if NET_2_0
RemotingConfiguration.Configure(filename, EnsureSecurity);
#else
RemotingConfiguration.Configure(filename);
#endif
#region Instrumentation
if (log.IsDebugEnabled)
{
if (filename == null)
{
log.Debug("Default remoting infrastructure loaded.");
}
else
{
log.Debug(String.Format("Remoting infrastructure configured using file '{0}'.", filename));
}
}
#endregion
}
private void InvokeObjectFactoryPostProcessors(IList objectFactoryPostProcessors, IConfigurableListableObjectFactory objectFactory)
{
foreach (IObjectFactoryPostProcessor processor in objectFactoryPostProcessors)
{
processor.PostProcessObjectFactory(objectFactory);
}
}
/// <summary>
/// Apply the given properties to the supplied
/// <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>.
/// </summary>
/// <param name="factory">
/// The <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>
/// used by the application context.
/// </param>
/// <param name="props">The properties to apply.</param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If an error occured.
/// </exception>
protected override void ProcessProperties(
IConfigurableListableObjectFactory factory, NameValueCollection props)
{
foreach (string key in props.AllKeys)
{
ProcessKey(factory, key, props[key]);
}
}
/// <summary>
/// Resets the well-known ObjectPostProcessorChecker that logs an info
/// message when an object is created during IObjectPostProcessor
/// instantiation, i.e. when an object is not eligible for being
/// processed by all IObjectPostProcessors.
/// </summary>
private void RefreshObjectPostProcessorChecker(IConfigurableListableObjectFactory objectFactory)
{
int registeredObjectPostProcessorCount = GetObjectNamesForType(typeof(IObjectPostProcessor), true, false).Length;
int objectPostProcessorCount = ObjectFactory.ObjectPostProcessorCount + 1
+ registeredObjectPostProcessorCount;
((ObjectPostProcessorChecker)_defaultObjectPostProcessors[0]).Reset(objectFactory, objectPostProcessorCount);
}
/// <summary>
/// Process the given key as 'name.property' entry.
/// </summary>
/// <param name="factory">
/// The object factory containing the object definitions that are to be
/// processed.
/// </param>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If an error occurs.
/// </exception>
/// <exception cref="Spring.Objects.FatalObjectException">
/// If the property was not well formed (i.e. not in the format "name.property").
/// </exception>
protected virtual void ProcessKey(
IConfigurableListableObjectFactory factory, string key, string value)
{
int dotIndex = key.IndexOf('.');
if (dotIndex == -1)
{
throw new FatalObjectException(
string.Format(CultureInfo.InvariantCulture,
"Invalid key '{0}': expected 'objectName.property' form.", key));
}
string name = key.Substring(0, dotIndex);
string objectProperty = key.Substring(dotIndex + 1);
IObjectDefinition definition = factory.GetObjectDefinition(name);
if(definition != null)
{
PropertyValue pv = definition.PropertyValues.GetPropertyValue(objectProperty);
if (pv != null && pv.Value is RuntimeObjectReference)
{
definition.PropertyValues.Add(objectProperty, new RuntimeObjectReference(value));
}
else if (pv != null && pv.Value is ExpressionHolder)
{
definition.PropertyValues.Add(objectProperty, new ExpressionHolder(value));
}
else
{
definition.PropertyValues.Add(objectProperty, value);
}
}
else
{
#region Instrumentation
if (_logger.IsWarnEnabled)
{
_logger.Warn(string.Format(CultureInfo.InvariantCulture,
"Cannot find object '{0}' when overriding properties; check configuration.", name));
}
#endregion
}
#region Instrumentation
if (_logger.IsDebugEnabled)
{
_logger.Debug(string.Format(CultureInfo.InvariantCulture,
"Property '{0}' set to '{1}'.", key, value));
}
#endregion
}
/// <summary>
/// Apply the given properties to the supplied
/// <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>.
/// </summary>
/// <param name="factory">
/// The <see cref="Spring.Objects.Factory.Config.IConfigurableListableObjectFactory"/>
/// used by the application context.
/// </param>
/// <param name="props">The properties to apply.</param>
/// <exception cref="Spring.Objects.ObjectsException">
/// If an error occured.
/// </exception>
protected override void ProcessProperties(IConfigurableListableObjectFactory factory, NameValueCollection props)
{
PlaceholderResolveHandlerAdapter resolveAdapter = new PlaceholderResolveHandlerAdapter(this, props);
ObjectDefinitionVisitor visitor = new ObjectDefinitionVisitor(resolveAdapter.ParseAndResolveVariables);
IList<string> objectDefinitionNames = factory.GetObjectDefinitionNames();
for (int i = 0; i < objectDefinitionNames.Count; ++i)
{
string name = objectDefinitionNames[i];
IObjectDefinition definition = factory.GetObjectDefinition(name);
try
{
visitor.VisitObjectDefinition(definition);
}
catch (ObjectDefinitionStoreException ex)
{
throw new ObjectDefinitionStoreException(
definition.ResourceDescription, name, ex.Message);
}
}
factory.AddEmbeddedValueResolver(resolveAdapter);
}
/// <summary>
/// Postprocesses the object factory.
/// </summary>
/// <param name="objectFactory">The object factory.</param>
public void PostProcessObjectFactory(IConfigurableListableObjectFactory objectFactory)
{
if (_postProcessObjectFactoryCalled)
{
throw new InvalidOperationException(
"PostProcessObjectFactory already called for this post-processor");
}
_postProcessObjectFactoryCalled = true;
if (!_postProcessObjectDefinitionRegistryCalled)
{
// ObjectDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigObjectDefinitions lazily at this point then.
ProcessConfigObjectDefinitions((IObjectDefinitionRegistry)objectFactory);
}
EnhanceConfigurationClasses(objectFactory);
}
public void SetUp()
{
mocks = new MockRepository();
factory = mocks.StrictMock<IConfigurableListableObjectFactory>();
}
private void EnhanceConfigurationClasses(IConfigurableListableObjectFactory objectFactory)
{
string[] objectNames = objectFactory.GetObjectDefinitionNames();
foreach (string t in objectNames)
{
IObjectDefinition objDef = objectFactory.GetObjectDefinition(t);
if (((AbstractObjectDefinition)objDef).HasObjectType)
{
if (Attribute.GetCustomAttribute(objDef.ObjectType, typeof(ConfigurationAttribute)) != null)
{
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.ProxyTargetAttributes = true;
proxyFactory.Interfaces = Type.EmptyTypes;
proxyFactory.TargetSource = new ObjectFactoryTargetSource(t, objectFactory);
SpringObjectMethodInterceptor methodInterceptor = new SpringObjectMethodInterceptor(objectFactory);
proxyFactory.AddAdvice(methodInterceptor);
//TODO check type of object isn't infrastructure type.
InheritanceAopProxyTypeBuilder iaptb = new InheritanceAopProxyTypeBuilder(proxyFactory);
//iaptb.ProxyDeclaredMembersOnly = true; // make configurable.
((IConfigurableObjectDefinition)objDef).ObjectType = iaptb.BuildProxyType();
objDef.ConstructorArgumentValues.AddIndexedArgumentValue(objDef.ConstructorArgumentValues.ArgumentCount, proxyFactory);
}
}
}
}