private IObjectDefinition RegisterMongoObjectDefinition(XmlElement element)
{
var mongoBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(MongoFactoryObject));
string host = element.GetAttribute(ObjectNames.MongoDatabaseFactoryHost);
if (!StringUtils.HasText(host))
{
host = ObjectNames.MongoDatabaseFactoryDefaultHostname;
}
string port = element.GetAttribute(ObjectNames.MongoDatabaseFactoryPort);
if (!StringUtils.HasText(port))
{
port = ObjectNames.MongoDatabaseFactoryDefaultPort;
}
string url = string.Format("mongodb://{0}:{1}", host, port);
mongoBuilder.AddPropertyValue(MongoFactoryObject.UrlProperty, url);
mongoBuilder.RawObjectDefinition.Source = element;
return(mongoBuilder.ObjectDefinition);
}
/// <summary>
/// Creates object definition using <c>objectBuildAction</c>.
/// </summary>
/// <typeparam name="TObject">Type of defined object.</typeparam>
/// <param name="objectBuildAction">Action used to configure object.</param>
/// <returns>Definition.</returns>
public static IDefinition <TObject> Object <TObject>(Action <IInstantiationBuildStage <TObject> > objectBuildAction)
{
var builder = new ObjectDefinitionBuilder <TObject>(null);
objectBuildAction(builder);
return(new Definition <TObject>(builder.Definition));
}
public string Parse(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_INTERCEPTOR_PACKAGE + ".WireTap");
string targetRef = element.GetAttribute("channel");
if (!StringUtils.HasText(targetRef))
{
parserContext.ReaderContext.ReportException(element, "wire-tap", "The 'channel' attribute is required.");
}
builder.AddConstructorArgReference(targetRef);
string selectorRef = element.GetAttribute("selector");
if (StringUtils.HasText(selectorRef))
{
builder.AddConstructorArgReference(selectorRef);
}
// TODO check timeout
string timeout = element.GetAttribute("timeout");
if (StringUtils.HasText(timeout))
{
builder.AddPropertyValue("timeout", TimeSpan.Parse(timeout));
}
return(parserContext.ReaderContext.RegisterWithGeneratedName(builder.ObjectDefinition));
}
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);
}
}
internal static bool SetCollectionPropertyIfElementDefined(XmlElement element, ParserContext parserContext,
ObjectDefinitionBuilder builder, string propertyName, string parentPropertyName, string parentId)
{
var propertyElement = element.GetSingleChildElement(propertyName.ToCamelCase());
if (propertyElement != null)
{
var managedList = new ManagedList();
foreach (XmlNode node in propertyElement)
{
var parser = NamespaceParserRegistry.GetParser(node.NamespaceURI);
var objectDefinition = parser.ParseElement((XmlElement)node, parserContext);
if (!string.IsNullOrEmpty(parentPropertyName))
{
//if the child object has a parent Property specified then set it as well for bi-directional relationships to work seamlessly.
objectDefinition.PropertyValues.Add(parentPropertyName, new RuntimeObjectReference(parentId));
}
managedList.Add(objectDefinition);
}
builder.AddPropertyValue(propertyName, managedList);
return(true);
}
return(false);
}
public void Configure(ObjectDefinitionBuilder builder)
{
foreach (var key in properties.Keys)
{
builder.AddPropertyValue(key, properties[key]);
}
}
protected override void DoParse(XmlElement element, ObjectDefinitionBuilder builder)
{
base.DoParse(element, builder);
ParseSimpleProperties(element, builder);
XmlNodeList subElements = element.ChildNodes;
ManagedList locators = new ManagedList(subElements.Count);
ManagedList servers = new ManagedList(subElements.Count);
for (int i = 0; i < subElements.Count; i++)
{
XmlNode subElement = subElements.Item(i);
if (subElement != null && subElement.NodeType == XmlNodeType.Element)
{
if ("locator".Equals(subElement.LocalName))
{
locators.Add(ParseLocator((XmlElement)subElement));
}
if ("server".Equals(subElement.LocalName))
{
servers.Add(ParseServer((XmlElement)subElement));
}
}
}
if (locators.Count > 0)
{
builder.AddPropertyValue("Locators", locators);
}
if (servers.Count > 0)
{
builder.AddPropertyValue("Servers", servers);
}
}
public void Configure(ObjectDefinitionBuilder builder)
{
foreach (var keyValue in properties)
{
builder.AddPropertyValue(keyValue.Key, keyValue.Value);
}
}
/// <summary>
/// Registers object definition with specified <c>id</c> for <c>T</c> type.
/// </summary>
/// <typeparam name="T">Type of configured object.</typeparam>
/// <param name="id">Object id.</param>
/// <returns>Next build stage.</returns>
public IScopeBuildStage <T> RegisterNamed <T>(string id)
{
var builder = new ObjectDefinitionBuilder <T>(id);
RegisterObjectDefinition(id, builder.Definition);
return(builder);
}
public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
{
IObjectDefinitionFactory factory = parserContext.ReaderContext.ObjectDefinitionFactory;
AssertUtils.ArgumentNotNull(factory, "factory");
string id = element.GetAttribute(ObjectNames.MongoConventionProfileId);
string defaultId = StringUtils.HasText(id) ? id : ObjectNames.MongoConventionProfileDefaultId;
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(ConventionProfileFactory));
SetConvention(element, builder, ObjectNames.ConventionProfileDefaultValue, ConventionProfileFactory.DefaultValueConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileElementName, ConventionProfileFactory.ElementNameConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileExtraElementsMember, ConventionProfileFactory.ExtraElementsMemberConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileIdGenerator, ConventionProfileFactory.IdGeneratorConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileIdMember, ConventionProfileFactory.IdMemberConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreExtraElements, ConventionProfileFactory.IgnoreExtraElementsConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreIfDefault, ConventionProfileFactory.IgnoreIfDefaultConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreIfNull, ConventionProfileFactory.IgnoreIfNullConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileMemberFinder, ConventionProfileFactory.MemberFinderConventionProperty);
SetConvention(element, builder, ObjectNames.ConventionProfileSerializationOptions, ConventionProfileFactory.SerializationOptionsConventionProperty);
parserContext.Registry.RegisterObjectDefinition(defaultId, builder.ObjectDefinition);
return(null);
}
public void ObjectDefinitionReplacementTest()
{
var appContext = (AbstractApplicationContext)applicationContext;
var objectDefinitionName = _dummyCalculator.GetType().FullName;
var originalObjectDefinition = appContext.GetObjectDefinition(objectDefinitionName);
var surrogateObjectDefinition = ObjectDefinitionBuilder.GenericObjectDefinition(
typeof(SurrogateFactoryObject))
.AddPropertyValue("TargetObjectType", typeof(ICalculator))
.ObjectDefinition;
appContext.ReplaceObjectDefinition(objectDefinitionName, surrogateObjectDefinition);
var surrogateObject = appContext.GetObject(objectDefinitionName);
Assert.AreNotSame(surrogateObject.GetType(), _dummyCalculator.GetType());
//Replace
appContext.ReplaceObjectDefinition(objectDefinitionName, originalObjectDefinition);
var originalObject = appContext.GetObject(objectDefinitionName);
Assert.AreNotSame(surrogateObject, originalObject);
Assert.AreSame(_dummyCalculator.GetType(), originalObject.GetType());
}
public void Configure(ObjectDefinitionBuilder builder)
{
foreach (var keyValue in properties)
{
builder.AddPropertyValue(keyValue.Key, keyValue.Value);
}
}
private void ParseTypeFilters(XmlElement element, ObjectDefinitionBuilder builder)
{
var includeTypeFilters = new List <ITypeFilter>();
var excludeTypeFilters = new List <ITypeFilter>();
foreach (XmlNode node in element.ChildNodes)
{
if (node.Name.Contains(ObjectNames.IncludeFilterElement))
{
var typeFilter = CreateTypeFilter(node);
if (typeFilter != null)
{
includeTypeFilters.Add(typeFilter);
}
}
else if (node.Name.Contains(ObjectNames.ExcludeFilterElement))
{
var typeFilter = CreateTypeFilter(node);
if (typeFilter != null)
{
excludeTypeFilters.Add(typeFilter);
}
}
}
builder.AddPropertyValue(ConventionProfileFactory.IncludeFiltersProperty, includeTypeFilters);
builder.AddPropertyValue(ConventionProfileFactory.ExcludeFiltersProperty, excludeTypeFilters);
}
/**
* 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 ParseInternal(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder metadataBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.SCHEDULING_PACKAGE + ".PollerMetadata");
if (element.HasAttribute("ref"))
{
parserContext.ReaderContext.ReportException(element, element.Name, "the 'ref' attribute must not be present on a 'poller' element submitted to the parser");
}
ConfigureTrigger(element, metadataBuilder, parserContext);
IntegrationNamespaceUtils.SetValueIfAttributeDefined(metadataBuilder, element, "max-messages-per-poll");
XmlElement adviceChainElement = DomUtils.GetChildElementByTagName(element, "advice-chain");
if (adviceChainElement != null)
{
ConfigureAdviceChain(adviceChainElement, metadataBuilder, parserContext);
}
XmlElement txElement = DomUtils.GetChildElementByTagName(element, "transactional");
if (txElement != null)
{
ConfigureTransactionAttributes(txElement, metadataBuilder);
}
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(metadataBuilder, element, "task-executor");
return(metadataBuilder.ObjectDefinition);
}
private void ParseSelectorChain(ObjectDefinitionBuilder builder, XmlElement element, ParserContext parserContext)
{
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "voting-strategy");
ManagedList selectors = new ManagedList();
selectors.ElementTypeName = typeof(IMessageSelector).FullName;
XmlNodeList childNodes = element.ChildNodes;
for (int i = 0; i < childNodes.Count; i++)
{
XmlNode child = childNodes.Item(i);
if (child.NodeType == XmlNodeType.Element)
{
string nodeName = child.LocalName;
if ("selector".Equals(nodeName))
{
string refatr = ((XmlElement)child).GetAttribute("ref");
selectors.Add(new RuntimeObjectReference(refatr));
}
else if ("selector-chain".Equals(nodeName))
{
ObjectDefinitionBuilder nestedBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(GetObjectTypeName(null));
ParseSelectorChain(nestedBuilder, (XmlElement)child, parserContext);
string nestedBeanName = parserContext.ReaderContext.RegisterWithGeneratedName(nestedBuilder.ObjectDefinition);
selectors.Add(new RuntimeObjectReference(nestedBeanName));
}
}
}
builder.AddPropertyValue("selectors", selectors);
}
protected override ObjectDefinitionBuilder BuildObjectDefinition(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder;
XmlElement queueElement;
if ((queueElement = DomUtils.GetChildElementByTagName(element, "queue")) != null)
{
builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".QueueChannel");
ParseQueueCapacity(builder, queueElement);
}
else if ((queueElement = DomUtils.GetChildElementByTagName(element, "priority-queue")) != null)
{
builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".PriorityChannel");
ParseQueueCapacity(builder, queueElement);
string comparatorRef = queueElement.GetAttribute("comparator");
if (StringUtils.HasText(comparatorRef))
{
builder.AddConstructorArgReference(comparatorRef);
}
}
else if (DomUtils.GetChildElementByTagName(element, "rendezvous-queue") != null)
{
builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".RendezvousChannel");
}
else
{
builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".DirectChannel");
}
return(builder);
}
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);
}
protected override AbstractObjectDefinition ParseConsumer(XmlElement element, ParserContext parserContext)
{
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.HANDLER_PACKAGE + ".LoggingHandler");
builder.AddConstructorArg(element.GetAttribute("level"));
return(builder.ObjectDefinition);
}
void Init()
{
if (initialized)
{
return;
}
lock (componentProperties)
{
foreach (var t in componentProperties.Keys)
{
var builder = ObjectDefinitionBuilder.RootObjectDefinition(factory, t)
.SetAutowireMode(AutoWiringMode.AutoDetect)
.SetSingleton(typeHandleLookup[t] == DependencyLifecycle.SingleInstance);
componentProperties[t].Configure(builder);
IObjectDefinition def = builder.ObjectDefinition;
context.RegisterObjectDefinition(t.FullName, def);
}
}
initialized = true;
context.Refresh();
}
/// <summary>
/// Registers the specified implementation type.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="implementationType">Type of the implementation.</param>
public void Register <TService>(Type implementationType)
where TService : class
{
var b = SetLifetime(ObjectDefinitionBuilder.RootObjectDefinition(_factory, implementationType));
_container.RegisterObjectDefinition(SpringServiceLocator.GetName(implementationType), b.ObjectDefinition);
}
/// <summary>
/// Registers the specified implementation type.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <param name="implementationType">Type of the implementation.</param>
/// <param name="name">The name.</param>
public void Register <TService>(Type implementationType, string name)
where TService : class
{
var b = ObjectDefinitionBuilder.RootObjectDefinition(_factory, implementationType);
_container.RegisterObjectDefinition(name, b.ObjectDefinition);
}
private static void RegisterPrototype <TImplementation>(IConfigurableListableObjectFactory confObjFactory)
{
ObjectDefinitionBuilder odb = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory, typeof(TImplementation))
.SetSingleton(false).SetAutowireMode(AutoWiringMode.AutoDetect);
confObjFactory.RegisterObjectDefinition(typeof(TImplementation).FullName, odb.ObjectDefinition);
}
/**
* 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);
}
}
/// <summary>
/// Registers object definition with specified <c>id</c> for <c>T</c> type.
/// </summary>
/// <typeparam name="T">Type of configured object.</typeparam>
/// <param name="ctx">Context for the registration</param>
/// <param name="id">Object id.</param>
/// <returns>Next build stage.</returns>
public static IScopeBuildStage <T> RegisterNamed <T>(this IConfigurableApplicationContext ctx, string id)
{
var builder = new ObjectDefinitionBuilder <T>(id);
ctx.ObjectFactory.RegisterObjectDefinition(id, builder.Definition);
return(builder);
}
private static void Register <TSerivice, TImplementation>(IConfigurableListableObjectFactory confObjFactory)
{
ObjectDefinitionBuilder odb = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory, typeof(TImplementation)).
SetAutowireMode(AutoWiringMode.Constructor);
confObjFactory.RegisterObjectDefinition(typeof(TSerivice).FullName, odb.ObjectDefinition);
}
protected static void PostProcess(ObjectDefinitionBuilder builder, XmlElement element)
{
foreach (string attributeName in _referenceAttributes)
{
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, attributeName);
}
}
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
base.DoParse(element, builder);
//TODO investigate setting of scope on client cache
//builder.AddPropertyValue("Scope", "some value");
//TODO check if .NET client has any 'data policy' settings.
ParsingUtils.SetPropertyValue(element, builder, "name", "name");
ParsingUtils.SetPropertyValue(element, builder, "pool-name", "poolName");
String cacheRef = element.GetAttribute("cache-ref");
// add cache reference (fallback to default if nothing is specified)
builder.AddPropertyReference("cache", (StringUtils.HasText(cacheRef) ? cacheRef : "gemfire-cache"));
// client region attributes
String regionAttributesRef = element.GetAttribute("attributes-ref");
if (StringUtils.HasText(regionAttributesRef))
{
ObjectDefinitionBuilder attrBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(RegionAttributesFactoryObject));
builder.AddPropertyReference("attributes", regionAttributesRef);
}
ManagedList interests = new ManagedList();
XmlNodeList subElements = element.ChildNodes;
for (int i = 0; i < subElements.Count; i++)
{
XmlNode subElement = subElements.Item(i);
if (subElement.NodeType == XmlNodeType.Element)
{
string name = subElement.LocalName;
if ("cache-listener".Equals(name))
{
builder.AddPropertyValue("cacheListeners", ParseCacheListener(parserContext, (XmlElement)subElement, builder));
}
else if ("regex-interest".Equals(name))
{
interests.Add(ParseRegexInterest(parserContext, (XmlElement)subElement));
}
else if ("key-interest".Equals(name))
{
interests.Add(ParseKeyInterest(parserContext, (XmlElement)subElement));
}
else if ("all-keys-interest".Equals(name))
{
interests.Add(ParseAllKeysInterest(parserContext, (XmlElement)subElement));
}
}
}
if (subElements.Count > 0)
{
builder.AddPropertyValue("interests", interests);
}
}
private object ParseAllKeysInterest(ParserContext parserContext, XmlElement subElement)
{
ObjectDefinitionBuilder keyInterestBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(AllKeysInterest));
ParseCommonInterestAttr(subElement, keyInterestBuilder);
return(keyInterestBuilder.ObjectDefinition);
}
public void Configure(ObjectDefinitionBuilder builder)
{
foreach (var key in properties.Keys)
{
builder.AddPropertyValue(key, properties[key]);
}
}
private string ParseMessageListenerContainer(XmlElement element, ParserContext parserContext)
{
if (element.HasAttribute("container"))
{
foreach (string containerAttribute in containerAttributes)
{
if (element.HasAttribute(containerAttribute))
{
parserContext.ReaderContext.ReportException(element, containerAttribute,
"The '" + containerAttribute +
"' attribute should not be provided when specifying a 'container' reference.");
}
}
return(element.GetAttribute("container"));
}
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(SimpleMessageListenerContainer));
string destinationAttribute = this.expectReply ? "request-destination" : "destination";
string destinationNameAttribute = this.expectReply ? "request-destination-name" : "destination-name";
string destination = element.GetAttribute(destinationAttribute);
string destinationName = element.GetAttribute(destinationNameAttribute);
if (!(StringUtils.HasText(destination) ^ StringUtils.HasText(destinationName)))
{
parserContext.ReaderContext.ReportException(element, "destination or destination-name",
"Exactly one of '" + destinationAttribute + "' or '" + destinationNameAttribute + "' is required.");
}
builder.AddPropertyReference(NmsAdapterParserUtils.CONNECTION_FACTORY_PROPERTY,
NmsAdapterParserUtils.DetermineConnectionFactoryBeanName(element, parserContext));
if (StringUtils.HasText(destination))
{
builder.AddPropertyReference("destination", destination);
}
else
{
builder.AddPropertyValue("destinationName", destinationName);
}
AcknowledgementMode acknowledgementMode = NmsAdapterParserUtils.ParseAcknowledgementMode(element, parserContext);
if (acknowledgementMode.Equals(AcknowledgementMode.Transactional))
{
builder.AddPropertyValue("sessionTransacted", true);
}
else
{
builder.AddPropertyValue("sessionAcknowledgeMode", acknowledgementMode);
}
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "destination-resolver");
IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "transaction-manager");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "pub-sub-domain");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "concurrent-consumers");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "max-concurrent-consumers");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "max-messages-per-task");
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "idle-task-execution-limit");
builder.AddPropertyValue("autoStartup", false);
return(parserContext.ReaderContext.RegisterWithGeneratedName(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));
}
