Package org.springframework.beans.factory.config

# Class YamlProcessor

java.lang.Object
org.springframework.beans.factory.config.YamlProcessor

Direct Known Subclasses:
  `YamlMapFactoryBean`, `YamlPropertiesFactoryBean`

public abstract class YamlProcessor extends Object
Base class for YAML factories.

Requires SnakeYAML 2.0 or higher, as of Spring Framework 6.1.

Since:
  4.1
Author:
  Dave Syer, Juergen Hoeller, Sam Brannen, Brian Clozel

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static interface`
`YamlProcessor.DocumentMatcher`
Strategy interface used to test if properties match.
`static interface`
`YamlProcessor.MatchCallback`
Callback interface used to process the YAML parsing results.
`static enum`
`YamlProcessor.MatchStatus`
Status returned from `YamlProcessor.DocumentMatcher.matches(java.util.Properties)`.
`static enum`
`YamlProcessor.ResolutionMethod`
Method to use for resolving resources.

## Constructor Summary

Constructors
Constructor
Description
`YamlProcessor()`

## Method Summary

Modifier and Type
Method
Description
`protected org.yaml.snakeyaml.Yaml`
`createYaml()`
Create the `Yaml` instance to use.
`protected final Map<String,Object>`
`getFlattenedMap(Map<String,Object> source)`
Return a flattened version of the given map, recursively following any nested Map or Collection values.
`protected void`
`process(YamlProcessor.MatchCallback callback)`
Provide an opportunity for subclasses to process the Yaml parsed from the supplied resources.
`void`
`setDocumentMatchers(YamlProcessor.DocumentMatcher... matchers)`
A map of document matchers allowing callers to selectively use only some of the documents in a YAML resource.
`void`
`setMatchDefault(boolean matchDefault)`
Flag indicating that a document for which all the `document matchers` abstain will nevertheless match.
`void`
`setResolutionMethod(YamlProcessor.ResolutionMethod resolutionMethod)`
Method to use for resolving resources.
`void`
`setResources(org.springframework.core.io.Resource... resources)`
Set locations of YAML `resources` to be loaded.
`void`
`setSupportedTypes(Class<?>... supportedTypes)`
Set the supported types that can be loaded from YAML documents.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### YamlProcessor

public YamlProcessor()

## Method Details

### setDocumentMatchers

public void setDocumentMatchers(YamlProcessor.DocumentMatcher... matchers)
A map of document matchers allowing callers to selectively use only some of the documents in a YAML resource. In YAML documents are separated by `---` lines, and each document is converted to properties before the match is made. For example,

     environment: dev
     url: https://dev.bar.com
     name: Developer Setup
     ---
     environment: prod
     url:https://foo.bar.com
     name: My Cool App

when mapped with

     setDocumentMatchers(properties ->
         ("prod".equals(properties.getProperty("environment")) ? MatchStatus.FOUND : MatchStatus.NOT_FOUND));

would end up as

     environment=prod
     url=https://foo.bar.com
     name=My Cool App

### setMatchDefault

public void setMatchDefault(boolean matchDefault)
Flag indicating that a document for which all the `document matchers` abstain will nevertheless match. Default is `true`.

### setResolutionMethod

public void setResolutionMethod(YamlProcessor.ResolutionMethod resolutionMethod)
Method to use for resolving resources. Each resource will be converted to a Map, so this property is used to decide which map entries to keep in the final output from this factory. Default is `YamlProcessor.ResolutionMethod.OVERRIDE`.

### setResources

public void setResources(org.springframework.core.io.Resource... resources)
Set locations of YAML `resources` to be loaded.

See Also:
  - `YamlProcessor.ResolutionMethod`

### setSupportedTypes

public void setSupportedTypes(Class<?>... supportedTypes)
Set the supported types that can be loaded from YAML documents.

If no supported types are configured, only Java standard classes (as defined in `SafeConstructor`) encountered in YAML documents will be supported. If an unsupported type is encountered, a `ComposerException` will be thrown when the corresponding YAML node is processed.

Parameters:
  `supportedTypes` - the supported types, or an empty array to clear the supported types
Since:
  5.1.16
See Also:
  - `createYaml()`

### process

protected void process(YamlProcessor.MatchCallback callback)
Provide an opportunity for subclasses to process the Yaml parsed from the supplied resources. Each resource is parsed in turn and the documents inside checked against the `matchers`. If a document matches it is passed into the callback, along with its representation as Properties. Depending on the `setResolutionMethod(ResolutionMethod)` not all the documents will be parsed.

Parameters:
  `callback` - a callback to delegate to once matching documents are found
See Also:
  - `createYaml()`

### createYaml

protected org.yaml.snakeyaml.Yaml createYaml()
Create the `Yaml` instance to use.

The default implementation sets the "allowDuplicateKeys" flag to `false`, enabling built-in duplicate key handling.

If custom supported types have been configured, the default implementation creates a `Yaml` instance that filters out unsupported types encountered in YAML documents. If an unsupported type is encountered, a `ComposerException` will be thrown when the node is processed.

See Also:
  - `LoaderOptions.setAllowDuplicateKeys(boolean)`

### getFlattenedMap

protected final Map<String,Object> getFlattenedMap(Map<String,Object> source)
Return a flattened version of the given map, recursively following any nested Map or Collection values. Entries from the resulting map retain the same order as the source. When called with the Map from a `YamlProcessor.MatchCallback` the result will contain the same values as the `YamlProcessor.MatchCallback` Properties.

Parameters:
  `source` - the source map
Returns:
  a flattened map
Since:
  4.1.3