public void ParsesObjectAttributes()
{
DefaultListableObjectFactory of = new DefaultListableObjectFactory();
XmlObjectDefinitionReader reader = new XmlObjectDefinitionReader(of);
reader.LoadObjectDefinitions(new StringResource(
@"<?xml version='1.0' encoding='UTF-8' ?>
<objects xmlns='http://www.springframework.net'>
<object id='test1' type='Spring.Objects.TestObject, Spring.Core.Tests' singleton='false' abstract='true' />
<object id='test2' type='Spring.Objects.TestObject, Spring.Core.Tests' singleton='true' abstract='false' lazy-init='true'
autowire='no' dependency-check='simple'
depends-on='test1'
init-method='init'
destroy-method='destroy'
/>
</objects>
"));
AbstractObjectDefinition od1 = (AbstractObjectDefinition)of.GetObjectDefinition("test1");
Assert.IsFalse(od1.IsSingleton);
Assert.IsTrue(od1.IsAbstract);
Assert.IsFalse(od1.IsLazyInit);
AbstractObjectDefinition od2 = (AbstractObjectDefinition)of.GetObjectDefinition("test2");
Assert.IsTrue(od2.IsSingleton);
Assert.IsFalse(od2.IsAbstract);
Assert.IsTrue(od2.IsLazyInit);
Assert.AreEqual(AutoWiringMode.No, od2.AutowireMode);
Assert.AreEqual("init", od2.InitMethodName);
Assert.AreEqual("destroy", od2.DestroyMethodName);
Assert.AreEqual(1, od2.DependsOn.Count);
Assert.AreEqual("test1", od2.DependsOn[0]);
Assert.AreEqual(DependencyCheckingMode.Simple, od2.DependencyCheck);
}
/// <summary>
/// Checks the class to see if it is a candidate to be a <see cref="ConfigurationAttribute"/> source.
/// </summary>
/// <param name="objectDefinition">The object definition.</param>
/// <returns></returns>
public static bool CheckConfigurationClassCandidate(IObjectDefinition objectDefinition)
{
Type objectType = null;
if (objectDefinition is AbstractObjectDefinition)
{
AbstractObjectDefinition definition = (AbstractObjectDefinition)objectDefinition;
if (definition.HasObjectType)
{
objectType = definition.ObjectType;
}
else
{
if (definition.ObjectTypeName != null && !definition.IsAbstract)
{
objectType = TypeResolutionUtils.ResolveType(definition.ObjectTypeName);
}
}
if (objectType != null)
{
if (Attribute.GetCustomAttribute(objectType, typeof(ConfigurationAttribute)) != null)
{
return(true);
}
if (Attribute.GetCustomAttribute(objectType, typeof(ComponentAttribute)) != null ||
HasAttributeOnMethods(objectType, typeof(ObjectDefAttribute)))
{
return(true);
}
}
}
return(false);
}
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
string id = base.ResolveId(element, definition, parserContext);
if (element.GetAttribute("default").Equals("true"))
{
if (parserContext.Registry.GetObjectDefinition(IntegrationContextUtils.DefaultPollerMetadataObjectName) != null)
{
parserContext.ReaderContext.ReportException(element, element.Name, "Only one default <poller/> element is allowed per context.");
}
if (StringUtils.HasText(id))
{
parserContext.Registry.RegisterAlias(id, IntegrationContextUtils.DefaultPollerMetadataObjectName);
}
else
{
id = IntegrationContextUtils.DefaultPollerMetadataObjectName;
}
}
else if (!StringUtils.HasText(id))
{
parserContext.ReaderContext.ReportException(element, element.Name, "The 'id' attribute is required for a top-level poller element unless it is the default poller.");
}
return(id);
}
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
builder.AddPropertyReference(TxNamespaceUtils.TRANSACTION_MANAGER_PROPERTY,
GetAttributeValue(element, TxNamespaceUtils.TRANSACTION_MANAGER_ATTRIBUTE));
XmlNodeList txAttributes = element.SelectNodes("*[local-name()='attributes' and namespace-uri()='" + element.NamespaceURI + "']");
if (txAttributes.Count > 1)
{
parserContext.ReaderContext.ReportException(element, "tx advice", "Element <attributes> is allowed at most once inside element <advice>");
}
else if (txAttributes.Count == 1)
{
//using xml defined source
XmlElement attributeSourceElement = txAttributes[0] as XmlElement;
AbstractObjectDefinition attributeSourceDefinition =
ParseAttributeSource(attributeSourceElement, parserContext);
builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, attributeSourceDefinition);
}
else
{
//Assume attibutes source
ObjectDefinitionBuilder txAttributeSourceBuilder =
parserContext.ParserHelper.CreateRootObjectDefinitionBuilder(typeof(AttributesTransactionAttributeSource));
builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE,
txAttributeSourceBuilder.ObjectDefinition);
}
}
/// <summary>
/// Parse the specified XmlElement and register the resulting
/// ObjectDefinitions with the <see cref="ParserContext.Registry"/> IObjectDefinitionRegistry
/// embedded in the supplied <see cref="ParserContext"/>
/// </summary>
/// <param name="element">The element to be parsed.</param>
/// <param name="parserContext">TThe object encapsulating the current state of the parsing process.
/// Provides access to a IObjectDefinitionRegistry</param>
/// <returns>The primary object definition.</returns>
/// <remarks>
/// <p>
/// This method is never invoked if the parser is namespace aware
/// and was called to process the root node.
/// </p>
/// </remarks>
public virtual IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
{
AbstractObjectDefinition definition = ParseInternal(element, parserContext);
if (!parserContext.IsNested)
{
string id = null;
try
{
id = ResolveId(element, definition, parserContext);
if (!StringUtils.HasText(id))
{
parserContext.ReaderContext.ReportException(element, "null",
"Id is required for element '" + element.LocalName + "' when used as a top-level tag", null);
}
ObjectDefinitionHolder holder = new ObjectDefinitionHolder(definition, id);
RegisterObjectDefinition(holder, parserContext.Registry);
}
catch (ObjectDefinitionStoreException ex)
{
parserContext.ReaderContext.ReportException(element, id, ex.Message);
return(null);
}
}
return(definition);
}
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
String name = base.ResolveId(element, definition, parserContext);
if (!StringUtils.HasText(name))
{
name = "gemfire-pool";
}
return(name);
}
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
string id = base.ResolveId(element, definition, parserContext);
if (!StringUtils.HasText(id))
{
id = element.GetAttribute("name");
}
if (!StringUtils.HasText(id))
{
id = parserContext.ReaderContext.GenerateObjectName(definition);
}
return(id);
}
/// <summary>
/// Spring ObjectDefinition을 가져오거나 생성합니다.
/// </summary>
/// <param name="ctx"></param>
/// <param name="info"></param>
/// <returns></returns>
private static IObjectDefinition GetOrCreateObjectDefinition(AbstractApplicationContext ctx, AutowireTargetPropertyInfo info)
{
if (ctx.IsObjectNameInUse(info.ObjectInfo.Id))
{
return(ctx.GetObjectDefinition(info.ObjectInfo.Id));
}
else
{
AbstractObjectDefinition objectDefinition = fac.CreateObjectDefinition(info.ObjectInfo.Type, null, AppDomain.CurrentDomain);
objectDefinition.IsSingleton = info.ObjectInfo.Singleton;
ctx.ObjectFactory.RegisterObjectDefinition(info.ObjectInfo.Id, objectDefinition);
return(ctx.GetObjectDefinition(info.ObjectInfo.Id));
}
}
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
string id = element.GetAttribute("id");
if (!element.HasAttribute("channel"))
{
// the created channel will get the 'id', so the adapter's object name includes a suffix
id = id + ".adapter";
}
else if (!StringUtils.HasText(id))
{
id = parserContext.ReaderContext.GenerateObjectName(definition);
}
return(id);
}
/// <summary>
/// Resolves the ID for the supplied <see cref="IObjectDefinition"/>.
/// </summary>
/// <remarks>
/// When using <see cref="ShouldGenerateId"/> generation, a name is generated automatically.
/// Otherwise, the ID is extracted from the "id" attribute, potentially with a
/// <see cref="ShouldGenerateIdAsFallback"/> fallback to a generated id.
/// </remarks>
/// <param name="element">The element that the object definition has been built from.</param>
/// <param name="definition">The object definition to be registered.</param>
/// <param name="parserContext">The the object encapsulating the current state of the parsing process;
/// provides access to a <see cref="IObjectDefinitionRegistry"/> </param>
/// <returns>the resolved id</returns>
/// <exception cref="ObjectDefinitionStoreException">
/// if no unique name could be generated for the given object definition
/// </exception>
protected virtual string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
if (ShouldGenerateId)
{
return(parserContext.ReaderContext.GenerateObjectName(definition));
}
else
{
string id = GetAttributeValue(element, ID_ATTRIBUTE);
if (!StringUtils.HasText(id) && ShouldGenerateIdAsFallback)
{
id = parserContext.ReaderContext.GenerateObjectName(definition);
}
return(id);
}
}
/// <summary>
/// Override this method to control the registration process and return the bean name.
/// If parsing a bean definition whose name can be auto-generated, consider using
/// {@link #parseConsumer(Element, ParserContext)} instead.
/// </summary>
/// <param name="element"></param>
/// <param name="parserContext"></param>
/// <returns></returns>
protected virtual string ParseAndRegisterConsumer(XmlElement element, ParserContext parserContext)
{
AbstractObjectDefinition definition = ParseConsumer(element, parserContext);
if (definition == null)
{
parserContext.ReaderContext.ReportException(element, element.Name, "Consumer parsing must return a ObjectDefinition.");
}
string order = element.GetAttribute("order");
if (StringUtils.HasText(order) && definition != null)
{
definition.PropertyValues.Add("order", order);
}
return(parserContext.ReaderContext.RegisterWithGeneratedName(definition));
}
public override IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
{
AbstractObjectDefinition definition = this.ParseInternal(element, parserContext);
if (!parserContext.IsNested)
{
string id = null;
try
{
id = this.ResolveId(element, definition, parserContext);
if (!StringUtils.HasText(id))
{
parserContext.ReaderContext.ReportException(element, "null",
"Id is required for element '" + element.LocalName + "' when used as a top-level tag", null);
}
string[] name = new string[0];
if (NamespaceUtils.IsAttributeDefined(element, "name"))
{
name = new[] { GetAttributeValue(element, "name") };
}
ObjectDefinitionHolder holder;
if (name.Length == 0)
{
holder = new ObjectDefinitionHolder(definition, id);
}
else
{
holder = new ObjectDefinitionHolder(definition, id, name);
}
this.RegisterObjectDefinition(holder, parserContext.Registry);
}
catch (ObjectDefinitionStoreException ex)
{
parserContext.ReaderContext.ReportException(element, id, ex.Message);
return(null);
}
}
return(definition);
}
/// <summary>
/// Parses the supplied advisor element and registers the resulting <see cref="IAdvisor"/>
/// </summary>
/// <param name="advisorElement">The advisor element.</param>
/// <param name="parserContext">The parser context.</param>
private void ParseAdvisor(XmlElement advisorElement, ParserContext parserContext)
{
AbstractObjectDefinition advisorDef = CreateAdvisorObjectDefinition(advisorElement, parserContext);
string id = advisorElement.GetAttribute(ID);
string pointcutObjectName = ParsePointcutProperty(advisorElement, parserContext);
advisorDef.PropertyValues.Add(POINTCUT_REF, new RuntimeObjectReference(pointcutObjectName));
string advisorObjectName = id;
if (StringUtils.HasText(advisorObjectName))
{
parserContext.Registry.RegisterObjectDefinition(advisorObjectName, advisorDef);
}
else
{
parserContext.ReaderContext.RegisterWithGeneratedName(advisorDef);
}
}
private static object ParsePropertySubElement(XmlElement childElement,
AbstractObjectDefinition rawObjectDefinition,
ParserContext parserContext)
{
string localName = childElement.LocalName;
if ("object".Equals(localName))
{
ObjectDefinitionHolder holder = parserContext.ParserHelper.ParseObjectDefinitionElement(childElement);
return(holder);
}
if ("ref".Equals(localName))
{
string reference = childElement.GetAttribute("object");
return(new RuntimeObjectReference(reference));
}
parserContext.ReaderContext.ReportException(childElement, localName, "unsupported element");
return(null);
}
protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder handlerBuilder = ParseHandler(element, parserContext);
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(handlerBuilder, element, "output-channel");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(handlerBuilder, element, "order");
AbstractObjectDefinition handlerBeanDefinition = handlerBuilder.ObjectDefinition;
string inputChannelAttributeName = InputChannelAttributeName;
if (!element.HasAttribute(inputChannelAttributeName))
{
if (!parserContext.IsNested)
{
parserContext.ReaderContext.ReportException(element, element.Name, "The '" + inputChannelAttributeName
+ "' attribute is required for top-level endpoint elements.");
}
return(handlerBeanDefinition);
}
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CONFIG_PACKAGE + ".ConsumerEndpointFactoryObject");
string handlerBeanName = parserContext.ReaderContext.RegisterWithGeneratedName(handlerBeanDefinition);
builder.AddConstructorArgReference(handlerBeanName);
string inputChannelName = element.GetAttribute(inputChannelAttributeName);
if (!parserContext.Registry.ContainsObjectDefinition(inputChannelName))
{
ObjectDefinitionBuilder channelDef = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".DirectChannel");
ObjectDefinitionHolder holder = new ObjectDefinitionHolder(channelDef.ObjectDefinition, inputChannelName);
ObjectDefinitionReaderUtils.RegisterObjectDefinition(holder, parserContext.Registry);
}
builder.AddPropertyValue("inputChannelName", inputChannelName);
XmlElement pollerElement = DomUtils.GetChildElementByTagName(element, "poller");
if (pollerElement != null)
{
IntegrationNamespaceUtils.ConfigurePollerMetadata(pollerElement, builder, parserContext);
}
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "auto-startup");
return(builder.ObjectDefinition);
}
public void CanApplyConstructorArgsToAbstractType()
{
IResource resource = new ReadOnlyXmlTestResource("ctor-args.xml", GetType());
XmlObjectFactory xof = new XmlObjectFactory(resource);
TestObject rod = (TestObject)xof.GetObject("rod");
Assert.AreEqual(1, rod.Age);
RootObjectDefinition def = (RootObjectDefinition)xof.GetObjectDefinition("rod");
ConstructorResolver resolver = new ConstructorResolver(xof, xof, new SimpleInstantiationStrategy(),
new ObjectDefinitionValueResolver(xof));
ConstructorInstantiationInfo ci = resolver.GetConstructorInstantiationInfo("rod", def, null, null);
AbstractObjectDefinition objDef = (AbstractObjectDefinition)xof.GetObjectDefinition("foo");
objDef.IsAbstract = false;
TestObject foo = (TestObject)xof.GetObject("foo");
Assert.AreEqual(2, foo.Age);
}
private bool IndicatesPubSub(AbstractObjectDefinition configDef)
{
return((bool)configDef.PropertyValues.GetPropertyValue("PubSubDomain").Value);
}
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
return(IntegrationNamespaceUtils.CONFIG_ANNOTATION_PACKAGE + ".InternalMessagingAnnotationPostProcessor");
}
protected override string ResolveId(XmlElement element, AbstractObjectDefinition definition, ParserContext parserContext)
{
// TODO return AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME;
return(AbstractApplicationContext.EventRegistryObjectName); //.APPLICATION_EVENT_MULTICASTER_BEAN_NAME;
}
