/// <summary> /// Parse the specified XmlElement and register the resulting /// ObjectDefinitions with the <see cref="P:Spring.Objects.Factory.Xml.ParserContext.Registry"/> IObjectDefinitionRegistry /// embedded in the supplied <see cref="T:Spring.Objects.Factory.Xml.ParserContext"/> /// </summary> /// <remarks> /// <p>This method is never invoked if the parser is namespace aware /// and was called to process the root node. /// </p> /// </remarks> /// <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> public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext) { IObjectDefinitionFactory factory = parserContext.ReaderContext.ObjectDefinitionFactory; AssertUtils.ArgumentNotNull(factory, "factory"); RegisterTypeConverters(); string id = element.GetAttribute(ObjectNames.MongoId); string defaultId = StringUtils.HasText(id) ? id : ObjectNames.MongoDatabaseFactoryDefaultId; string url = element.GetAttribute(ObjectNames.MongoDatabaseFactoryUrl); string mongoRef = element.GetAttribute(ObjectNames.MongoDatabaseFactoryMongoRef); string dbname = element.GetAttribute(ObjectNames.MongoDatabaseFactoryDbname); ObjectDefinitionBuilder dbFactoryBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(SimpleMongoDatabaseFactory)); IObjectDefinition userCredentials = GetUserCredentialsObjectDefinition(element); ParseAttribute(element, dbFactoryBuilder, SimpleMongoDatabaseFactory.WriteConcernProperty, ObjectNames.MongoDatabaseFactoryWriteConcern); if (StringUtils.HasText(url)) { if (StringUtils.HasText(mongoRef) || StringUtils.HasText(dbname) || userCredentials != null) { parserContext.ReaderContext.ReportException(element, ObjectNames.DbFactory, "Configure either url or details individually!"); } dbFactoryBuilder.AddConstructorArg(GetMongoUrl(url)); parserContext.Registry.RegisterObjectDefinition(defaultId, dbFactoryBuilder.ObjectDefinition); return(null); } if (StringUtils.HasText(mongoRef)) { dbFactoryBuilder.AddConstructorArgReference(mongoRef); } else { dbFactoryBuilder.AddConstructorArg(RegisterMongoObjectDefinition(element)); } dbname = StringUtils.HasText(dbname) ? dbname : ObjectNames.MongoDatabaseFactoryDefaultDatabaseName; dbFactoryBuilder.AddConstructorArg(dbname); if (userCredentials != null) { dbFactoryBuilder.AddConstructorArg(userCredentials); } parserContext.Registry.RegisterObjectDefinition(defaultId, dbFactoryBuilder.ObjectDefinition); return(null); }
/// <summary> /// Parse the supplied XmlElement and populate the supplied ObjectDefinitionBuilder as required. /// </summary> /// <param name="xml">The obejct representation in XML.</param> /// <param name="builder">The builder used to build the object definition in Spring.</param> protected override void DoParse(XmlElement xml, ObjectDefinitionBuilder builder) { // all behaviours with config being parsed have @respondsTo string respondsTo = xml.GetAttribute("responds-to"); builder.AddConstructorArg(respondsTo); // all view behaviours have @content-type string contentType = xml.GetAttribute("content-type"); builder.AddConstructorArg(contentType); }
/// <summary>Adds the constructor arg boolean value if attribute defined.</summary> /// <param name="builder">The builder.</param> /// <param name="element">The element.</param> /// <param name="attributeName">Name of the attribute.</param> /// <param name="defaultValue">if set to <c>true</c> [default value].</param> public static void AddConstructorArgBooleanValueIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName, bool defaultValue) { var value = element.GetAttribute(attributeName); if (!string.IsNullOrWhiteSpace(value)) { builder.AddConstructorArg(new TypedStringValue(value)); } else { builder.AddConstructorArg(defaultValue); } }
/** * Parse an "interval-trigger" element */ private static string ParseIntervalTrigger(XmlElement element, ParserContext parserContext) { string interval = element.GetAttribute("interval"); if (!StringUtils.HasText(interval)) { parserContext.ReaderContext.ReportException(element, element.Name, "the 'interval' attribute is required for an <interval-trigger/>"); } //TimeUnit timeUnit = TimeUnit.valueOf(element.getAttribute("time-unit")); ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".IntervalTrigger"); //TODO MLP handle parsing of time-unit correctly, now hardcode use of 'seconds' via Spring.Core.TypeConversion.TimeSpanConverter string timeUnit = element.GetAttribute("time-unit"); switch (timeUnit) { case "SECONDS": interval = interval + "s"; break; case "MILLISECONDS": interval = interval + "ms"; break; } builder.AddConstructorArg(interval); //builder.addConstructorArgValue(timeUnit); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "initial-delay"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "fixed-rate"); return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition)); }
protected override AbstractObjectDefinition ParseConsumer(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".LoggingHandler"); builder.AddConstructorArg(element.GetAttribute("level")); return(builder.ObjectDefinition); }
protected override void ParseTransformer(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { ManagedDictionary headers = new ManagedDictionary(); XmlAttributeCollection attributes = element.Attributes; for (int i = 0; i < attributes.Count; i++) { XmlNode node = attributes.Item(i); String name = node.LocalName; if (IsEligibleHeaderName(name)) { name = Conventions.AttributeNameToPropertyName(name); object value; if (ReferenceAttributesContains(name)) { value = new RuntimeObjectReference(node.Value); } else { value = node.Value; } if (_prefix != null) { name = _prefix + name; } headers.Add(name, value); } } PostProcessHeaders(element, headers, parserContext); builder.AddConstructorArg(headers); builder.AddPropertyValue("overwrite", ShouldOverwrite(element)); }
/** * Register an error channel in the given ObjectDefinitionRegistry if not yet present. * The bean name for which this is checking is defined by the constant * {@link IntegrationContextUtils#ERROR_CHANNEL_BEAN_NAME}. */ private void RegisterErrorChannelIfNecessary(IObjectDefinitionRegistry registry) { if (!registry.ContainsObjectDefinition(IntegrationContextUtils.ErrorChannelObjectName)) { if (logger.IsInfoEnabled) { logger.Info("No bean named '" + IntegrationContextUtils.ErrorChannelObjectName + "' has been explicitly defined. Therefore, a default PublishSubscribeChannel will be created."); } RootObjectDefinition errorChannelDef = new RootObjectDefinition(); errorChannelDef.ObjectTypeName = IntegrationNamespaceUtils.BASE_PACKAGE + ".Channel.PublishSubscribeChannel"; ObjectDefinitionHolder errorChannelHolder = new ObjectDefinitionHolder(errorChannelDef, IntegrationContextUtils.ErrorChannelObjectName); ObjectDefinitionReaderUtils.RegisterObjectDefinition(errorChannelHolder, registry); ObjectDefinitionBuilder loggingHandlerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".LoggingHandler"); string loggingHandlerObjectName = ObjectDefinitionReaderUtils.GenerateObjectName(loggingHandlerBuilder.ObjectDefinition, registry); loggingHandlerBuilder.AddConstructorArg("ERROR"); ObjectDefinitionHolder loggingHandlerHolder = new ObjectDefinitionHolder(loggingHandlerBuilder.ObjectDefinition, loggingHandlerObjectName); ObjectDefinitionReaderUtils.RegisterObjectDefinition(loggingHandlerHolder, registry); ObjectDefinitionBuilder loggingEndpointBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.ENDPOINT_PACKAGE + ".EventDrivenConsumer"); loggingEndpointBuilder.AddConstructorArgReference(IntegrationContextUtils.ErrorChannelObjectName); loggingEndpointBuilder.AddConstructorArgReference(loggingHandlerObjectName); string loggingEndpointObjectName = ObjectDefinitionReaderUtils.GenerateObjectName(loggingEndpointBuilder.ObjectDefinition, registry); ObjectDefinitionHolder loggingEndpointHolder = new ObjectDefinitionHolder(loggingEndpointBuilder.ObjectDefinition, loggingEndpointObjectName); ObjectDefinitionReaderUtils.RegisterObjectDefinition(loggingEndpointHolder, registry); } }
private static IApplicationContext CreateContextProgrammaticallyWithAutoWire() { InitializeCommonLogging(); GenericApplicationContext ctx = new GenericApplicationContext(); IObjectDefinitionFactory objectDefinitionFactory = new DefaultObjectDefinitionFactory(); //Create MovieLister and dependency on ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory, typeof(MovieLister)); builder.AddPropertyReference("MovieFinder", "BogusNameOfDependency") .SetAutowireMode(AutoWiringMode.ByType); ctx.RegisterObjectDefinition("MyMovieLister", builder.ObjectDefinition); builder = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory, typeof(ColonDelimitedMovieFinder)); builder.AddConstructorArg("movies.txt") .SetAutowireMode(AutoWiringMode.ByType); ctx.RegisterObjectDefinition("AnotherMovieFinder", builder.ObjectDefinition); ctx.Refresh(); return(ctx); }
private IObjectDefinition GetMongoUrl(string url) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(MongoUrl)); builder.AddConstructorArg(url); return(builder.ObjectDefinition); }
private static string CreateCompletionStrategyAdapter(string refatr, string method, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.AGGREGATOR_PACKAGE + ".CompletionStrategyAdapter"); builder.AddConstructorArgReference(refatr); builder.AddConstructorArg(method); return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition)); }
private static void ParseQueueCapacity(ObjectDefinitionBuilder builder, XmlElement queueElement) { string capacity = queueElement.GetAttribute("capacity"); if (StringUtils.HasText(capacity)) { builder.AddConstructorArg(Convert.ToUInt32(capacity)); } }
private IObjectDefinition GetUserCredentialsObjectDefinition(XmlElement element) { string username = element.GetAttribute(ObjectNames.MongoDatabaseFactoryUsername); string password = element.GetAttribute(ObjectNames.MongoDatabaseFactoryPassword); if (!StringUtils.HasText(username) && !StringUtils.HasText(password)) { return(null); } ObjectDefinitionBuilder userCredentialsBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(MongoCredentials)); userCredentialsBuilder.AddConstructorArg(StringUtils.HasText(username) ? username : null); userCredentialsBuilder.AddConstructorArg(StringUtils.HasText(password) ? password : null); userCredentialsBuilder.RawObjectDefinition.Source = element; return(userCredentialsBuilder.ObjectDefinition); }
/// <summary>The do parse.</summary> /// <param name="element">The element.</param> /// <param name="parserContext">The parser context.</param> /// <param name="builder">The builder.</param> protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { var exchangeName = element.GetAttribute("name"); builder.AddConstructorArg(new TypedStringValue(exchangeName)); this.ParseBindings(element, parserContext, builder, exchangeName); NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, DURABLE_ATTRIBUTE, true); NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, AUTO_DELETE_ATTRIBUTE, false); var argumentsElement = element.SelectChildElementByTagName(ARGUMENTS_ELEMENT); if (argumentsElement != null) { var parser = new ObjectDefinitionParserHelper(parserContext); var map = parser.ParseMapElementToTypedDictionary(argumentsElement, builder.RawObjectDefinition); builder.AddConstructorArg(map); } }
private object ParseKeyInterest(ParserContext parserContext, XmlElement subElement) { ObjectDefinitionBuilder keyInterestBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(KeyInterest)); ParseCommonInterestAttr(subElement, keyInterestBuilder); Object key = ParsingUtils.ParseRefOrNestedObjectDeclaration(parserContext, subElement, keyInterestBuilder, "key-ref"); keyInterestBuilder.AddConstructorArg(key); return(keyInterestBuilder.ObjectDefinition); }
/// <summary>Adds the constructor arg value if attribute defined.</summary> /// <param name="builder">The builder.</param> /// <param name="element">The element.</param> /// <param name="attributeName">Name of the attribute.</param> /// <returns><c>true</c> if [is attribute defined] [the specified element]; otherwise, <c>false</c>.</returns> public static bool AddConstructorArgValueIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName) { var value = element.GetAttribute(attributeName); if (!string.IsNullOrWhiteSpace(value)) { builder.AddConstructorArg(new TypedStringValue(value)); return(true); } return(false); }
/** * Parse a "cron-trigger" element */ private static string ParseCronTrigger(XmlElement element, ParserContext parserContext) { string cronExpression = element.GetAttribute("expression"); if (!StringUtils.HasText(cronExpression)) { parserContext.ReaderContext.ReportException(element, element.Name, "the 'expression' attribute is required for a <cron-trigger/>"); } ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".CronTrigger"); builder.AddConstructorArg(cronExpression); return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition)); }
protected override string ParseSource(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(NmsDestinationPollingSource)); string nmsTemplate = element.GetAttribute(NmsAdapterParserUtils.NMS_TEMPLATE_ATTRIBUTE); string destination = element.GetAttribute(NmsAdapterParserUtils.DESTINATION_ATTRIBUTE); string destinationName = element.GetAttribute(NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE); string headerMapper = element.GetAttribute(NmsAdapterParserUtils.HEADER_MAPPER_ATTRIBUTE); if (StringUtils.HasText(nmsTemplate)) { if (element.HasAttribute(NmsAdapterParserUtils.CONNECTION_FACTORY_ATTRIBUTE) || element.HasAttribute(NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE) || element.HasAttribute(NmsAdapterParserUtils.DESTINATION_ATTRIBUTE)) { throw new ObjectCreationException( "When providing '" + NmsAdapterParserUtils.NMS_TEMPLATE_ATTRIBUTE + "', none of '" + NmsAdapterParserUtils.CONNECTION_FACTORY_ATTRIBUTE + "', '" + NmsAdapterParserUtils.DESTINATION_ATTRIBUTE + "', or '" + NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE + "' should be provided."); } builder.AddConstructorArgReference(nmsTemplate); } else if (StringUtils.HasText(destination) || StringUtils.HasText(destinationName)) { builder.AddConstructorArgReference(NmsAdapterParserUtils.DetermineConnectionFactoryBeanName(element, parserContext)); if (StringUtils.HasText(destination)) { builder.AddConstructorArgReference(destination); } else if (StringUtils.HasText(destinationName)) { builder.AddConstructorArg(destinationName); } } else { throw new ObjectCreationException("either a '" + NmsAdapterParserUtils.NMS_TEMPLATE_ATTRIBUTE + "' or one of '" + NmsAdapterParserUtils.DESTINATION_ATTRIBUTE + "' or '" + NmsAdapterParserUtils.DESTINATION_NAME_ATTRIBUTE + "' attributes must be provided for a polling NMS adapter"); } if (StringUtils.HasText(headerMapper)) { builder.AddPropertyReference(NmsAdapterParserUtils.HEADER_MAPPER_PROPERTY, headerMapper); } IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "extract-payload"); IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "destination-resolver"); return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition)); }
protected override AbstractObjectDefinition ParseConsumer(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder invokerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".MethodInvokingMessageHandler"); invokerBuilder.AddConstructorArgReference(element.GetAttribute("ref")); invokerBuilder.AddConstructorArg(element.GetAttribute("method")); string order = element.GetAttribute("order"); if (StringUtils.HasText(order)) { invokerBuilder.AddPropertyValue("order", order); } return(invokerBuilder.ObjectDefinition); }
/// <summary>Adds the constructor arg parent ref if attribute defined.</summary> /// <param name="builder">The builder.</param> /// <param name="element">The element.</param> /// <param name="attributeName">Name of the attribute.</param> /// <returns><c>true</c> if [is attribute defined] [the specified element]; otherwise, <c>false</c>.</returns> public static bool AddConstructorArgParentRefIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName) { var value = element.GetAttribute(attributeName); if (!string.IsNullOrWhiteSpace(value)) { var child = ObjectDefinitionBuilder.GenericObjectDefinition(); child.RawObjectDefinition.ParentName = value; builder.AddConstructorArg(child.ObjectDefinition); return(true); } return(false); }
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(GetGatewayClassName(element)); string url = ParseUrl(element, parserContext); builder.AddConstructorArg(url); string replyChannel = element.GetAttribute("reply-channel"); if (StringUtils.HasText(replyChannel)) { builder.AddPropertyReference("replyChannel", replyChannel); } PostProcessGateway(builder, element, parserContext); return(builder); }
public static bool AddConstructorArgValueIfElementDefined(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder, string childElementName) { var childElement = element.GetSingleChildElement(childElementName); if (childElement != null) { var parser = NamespaceParserRegistry.GetParser(childElement.NamespaceURI); var inlineConnection = parser.ParseElement(childElement, parserContext); builder.AddConstructorArg(inlineConnection); return(true); } return(false); }
public static void RegisterSingleton(this IConfigurableApplicationContext context, Type type, string name, params object[] constructorArguments) { ObjectDefinitionBuilder definitionBuilder = ObjectDefinitionBuilder.RootObjectDefinition(new DefaultObjectDefinitionFactory(), type) .SetAutowireMode(AutoWiringMode.AutoDetect) .SetSingleton(true); if (constructorArguments != null && constructorArguments.Length > 0) { foreach (object argument in constructorArguments) { definitionBuilder.AddConstructorArg(argument); } } context.ObjectFactory.RegisterObjectDefinition(name, definitionBuilder.ObjectDefinition); }
/// <summary> /// Parse the supplied XmlElement and populate the supplied ObjectDefinitionBuilder as required. /// </summary> /// <remarks> /// The default implementation delegates to the /// <code> /// DoParse /// </code> /// version without /// ParameterContext argument. /// </remarks> /// <param name="element">The element.</param><param name="parserContext">The parser context.</param><param name="builder">The builder used to define the /// <code> /// IObjectDefinition /// </code> /// .</param> protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { if (element.HasAttribute(ConnectionStringAttribute)) { if (element.Attributes.Cast <XmlAttribute>().Any(a => a.Name != ConnectionStringAttribute && a.Name != "id")) { parserContext.ReaderContext.ReportFatalException(element, "If the connectionString attribute is used, then other connection attributes should not be specified"); } else { NamespaceUtils.AddConstructorArgValueIfAttributeDefined(builder, element, ConnectionStringAttribute); return; } } //if connectionString attribute was not specified than servers should be specified. if (!element.HasAttribute(Endpoints)) { parserContext.ReaderContext.ReportFatalException(element, "Either the connection string containing the endpoints or the Endpoints attribute is required."); } //to rely on the out-of-the-box ability provided by ConfiguratioOptions.Parse(connectionString) method, //we'll now read all of the attributes and form a connection string. var connectionString = new StringBuilder(); connectionString.Append(element.GetAttribute(Endpoints)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(AbortOnConnectFail)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(AllowAdmin)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(ChannelPrefix)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(ConnectRetry)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(ConnectTimeout)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(ConfigChannel)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(DefaultDatabase)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(KeepAlive)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(Password)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(Proxy)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(ResolveDns)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(Ssl)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(SslHost)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(SyncTimeout)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(TieBreaker)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(Version)); connectionString.Append(element.ToKeyValuePairAttributeStringIfDefined(WriteBufferSize)); builder.AddConstructorArg(new TypedStringValue(connectionString.ToString())); }
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".ServiceActivatingHandler"); string refAttribute = element.GetAttribute(RefAttribute); if (!StringUtils.HasText(refAttribute)) { parserContext.ReaderContext.ReportException(element, "ref", "The '" + RefAttribute + "' attribute is required."); } builder.AddConstructorArgReference(refAttribute); if (StringUtils.HasText(element.GetAttribute(MethodAttribute))) { string method = element.GetAttribute(MethodAttribute); builder.AddConstructorArg(method); } return(builder); }
/// <summary>The do parse.</summary> /// <param name="element">The element.</param> /// <param name="parserContext">The parser context.</param> /// <param name="builder">The builder.</param> protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder) { if (!NamespaceUtils.IsAttributeDefined(element, "name") && !NamespaceUtils.IsAttributeDefined(element, ID_ATTRIBUTE)) { parserContext.ReaderContext.ReportFatalException(element, "Queue must have either id or name (or both)"); } NamespaceUtils.AddConstructorArgValueIfAttributeDefined(builder, element, "name"); if (!NamespaceUtils.IsAttributeDefined(element, "name")) { if (this.AttributeHasIllegalOverride(element, DURABLE_ATTRIBUTE, "false") || this.AttributeHasIllegalOverride(element, EXCLUSIVE_ATTRIBUTE, "true") || this.AttributeHasIllegalOverride(element, AUTO_DELETE_ATTRIBUTE, "true")) { parserContext.ReaderContext.ReportFatalException(element, "Anonymous queue cannot specify durable='true', exclusive='false' or auto-delete='false'"); return; } } else { NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, DURABLE_ATTRIBUTE, false); NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, EXCLUSIVE_ATTRIBUTE, false); NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, AUTO_DELETE_ATTRIBUTE, false); } var queueArguments = element.GetAttribute(ARGUMENTS); var argumentsElement = element.SelectChildElementByTagName(ARGUMENTS); if (argumentsElement != null) { var parser = new ObjectDefinitionParserHelper(parserContext); if (!string.IsNullOrWhiteSpace(queueArguments)) { parserContext.ReaderContext.ReportFatalException(element, "Queue may have either a queue-attributes attribute or element, but not both"); } var map = parser.ParseMapElement(argumentsElement, builder.RawObjectDefinition); builder.AddConstructorArg(map); } if (!string.IsNullOrWhiteSpace(queueArguments)) { builder.AddConstructorArgReference(queueArguments); } }
private static IApplicationContext CreateContextMixXmlAndProgrammatic() { GenericApplicationContext ctx = new GenericApplicationContext(); IObjectDefinitionReader objectDefinitionReader = new XmlObjectDefinitionReader(ctx); objectDefinitionReader.LoadObjectDefinitions("assembly://Spring.IocQuickStart.MovieFinder/Spring.IocQuickStart.MovieFinder/AppContextContribution.xml"); IObjectDefinitionFactory objectDefinitionFactory = new DefaultObjectDefinitionFactory(); ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory, typeof(ColonDelimitedMovieFinder)); builder.AddConstructorArg("movies.txt"); ctx.RegisterObjectDefinition("AnotherMovieFinder", builder.ObjectDefinition); ctx.Refresh(); return(ctx); }
private static string ParseSelector(XmlElement element, ParserContext parserContext) { string refAttribute = element.GetAttribute("ref"); if (!StringUtils.HasText(refAttribute)) { parserContext.ReaderContext.ReportException(element, "filter", "The 'ref' attribute is required."); } string method = element.GetAttribute("method"); if (!StringUtils.HasText(method)) { return(refAttribute); } ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.FILTER_PACKAGE + ".MethodInvokingSelector"); builder.AddConstructorArgReference(refAttribute); builder.AddConstructorArg(method); return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition)); }
protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext) { ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.AGGREGATOR_PACKAGE + ".MethodInvokingAggregator"); string refatr = element.GetAttribute(RefAttribute); if (!StringUtils.HasText(refatr)) { parserContext.ReaderContext.ReportException(element, element.Name, "The '" + RefAttribute + "' attribute is required."); } builder.AddConstructorArgReference(refatr); if (StringUtils.HasText(element.GetAttribute(MethodAttribute))) { string method = element.GetAttribute(MethodAttribute); builder.AddConstructorArg(method); } IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, DiscardChannelAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, SendTimeoutAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, SendPartialResultOnTimeoutAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, ReaperIntervalAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, TrackedCorrelationIdCapacityAttribute); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "auto-startup"); IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, TimeoutAttribute); string completionStrategyRef = element.GetAttribute(CompletionStrategyRefAttribute); string completionStrategyMethod = element.GetAttribute(CompletionStrategyMethodAttribute); if (StringUtils.HasText(completionStrategyRef)) { if (StringUtils.HasText(completionStrategyMethod)) { string adapterBeanName = CreateCompletionStrategyAdapter( completionStrategyRef, completionStrategyMethod, parserContext); builder.AddPropertyReference(CompletionStrategyProperty, adapterBeanName); } else { builder.AddPropertyReference(CompletionStrategyProperty, completionStrategyRef); } } return(builder); }
/// <summary> /// Register a TaskScheduler in the given <see cref="IObjectDefinitionFactory"/> if not yet present. /// The object name for which this is checking is defined by the constant <see cref="IntegrationContextUtils.TaskSchedulerObjectName"/> /// </summary> /// <param name="registry">the <see cref="IObjectDefinitionFactory"/></param> private void RegisterTaskSchedulerIfNecessary(IObjectDefinitionRegistry registry) { if (!registry.ContainsObjectDefinition(IntegrationContextUtils.TaskSchedulerObjectName)) { if (logger.IsInfoEnabled) { logger.Info("No object named '" + IntegrationContextUtils.TaskSchedulerObjectName + "' has been explicitly defined. Therefore, a default SimpleTaskScheduler will be created."); } IExecutor taskExecutor = IntegrationContextUtils.CreateThreadPoolTaskExecutor(2, 100, 0, "task-scheduler-"); ObjectDefinitionBuilder schedulerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".SimpleTaskScheduler"); schedulerBuilder.AddConstructorArg(taskExecutor); ObjectDefinitionBuilder errorHandlerBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".MessagePublishingErrorHandler"); errorHandlerBuilder.AddPropertyReference("defaultErrorChannel", IntegrationContextUtils.ErrorChannelObjectName); string errorHandlerBeanName = ObjectDefinitionReaderUtils.GenerateObjectName(errorHandlerBuilder.ObjectDefinition, registry); ObjectDefinitionHolder errorHandlerHolder = new ObjectDefinitionHolder(errorHandlerBuilder.ObjectDefinition, errorHandlerBeanName); ObjectDefinitionReaderUtils.RegisterObjectDefinition(errorHandlerHolder, registry); schedulerBuilder.AddPropertyReference("errorHandler", errorHandlerBeanName); ObjectDefinitionHolder schedulerHolder = new ObjectDefinitionHolder(schedulerBuilder.ObjectDefinition, IntegrationContextUtils.TaskSchedulerObjectName); ObjectDefinitionReaderUtils.RegisterObjectDefinition(schedulerHolder, registry); } }
/// <summary> /// Parse the supplied XmlElement and populate the supplied ObjectDefinitionBuilder as required. /// </summary> /// <param name="xml">The object representation in XML.</param> /// <param name="builder">The builder used to build the object definition in Spring.</param> protected override void DoParse(XmlElement xml, ObjectDefinitionBuilder builder) { if (xml == null) { throw new ArgumentNullException("xml", "The object description provided is null."); } if (xml.OwnerDocument == null) { throw new ArgumentException("The xml provided to parse must have an owning document to obtain namespace information from."); } // all behaviours with config being parsed have @respondsTo string respondsTo = xml.GetAttribute("responds-to"); builder.AddConstructorArg(respondsTo); // now we're going to read any config defined within our behaviour identified // by its namespace "Inversion.Process.Behaviour" HashSet <IConfigurationElement> elements = new HashSet <IConfigurationElement>(); XmlNamespaceManager ns = new XmlNamespaceManager(xml.OwnerDocument.NameTable); ns.AddNamespace("inv", "Inversion.Process.Behaviour"); XmlNodeList frames = xml.SelectNodes("inv:*", ns); // do we have any config then? if (frames != null && frames.Count > 0) { int ordinal = 0; // we're going to read the config into tuples // of frame, slot, name, value foreach (XmlElement frameElement in frames) { string frame = frameElement.Name; // process any frame attributes as <frame slot="name" /> foreach (XmlAttribute pair in frameElement.Attributes) { string slot = pair.Name; string name = pair.Value; IConfigurationElement element = new Configuration.Element(ordinal, frame, slot, name, String.Empty); elements.Add(element); ordinal++; } foreach (XmlElement slotElement in frameElement.ChildNodes) { string slot = slotElement.Name; int start = elements.Count; // read children of slot as <name>value</name> foreach (XmlElement pair in slotElement.ChildNodes) { string name = pair.Name; string value = pair.InnerText; IConfigurationElement element = new Configuration.Element(ordinal, frame, slot, name, value); elements.Add(element); ordinal++; } // read attributes of slot as name="value" foreach (XmlAttribute pair in slotElement.Attributes) { string name = pair.Name; string value = pair.Value; IConfigurationElement element = new Configuration.Element(ordinal, frame, slot, name, value); elements.Add(element); ordinal++; } if (elements.Count == start) // the slot had no name/value pairs { IConfigurationElement element = new Configuration.Element(ordinal, frame, slot, String.Empty, String.Empty); elements.Add(element); ordinal++; } } } builder.AddConstructorArg(elements); } }