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; }