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