Sample Application - Spring Batch - page 341

for (Entry<Pattern, LineTokenizer> entry : patternTokenizers.entrySet()) {
Matcher matcher = entry.getKey().matcher(input);
if(matcher.find()) {
tokenizer = entry.getValue();
break;
}
}
if(tokenizer != null) {
return tokenizer;
} else {
throw new ParseException("Unable to locate a tokenizer for " + input);
}
}
public void afterPropertiesSet() throws Exception {
patternTokenizers = new HashMap<Pattern, LineTokenizer>();
patternMappers = new HashMap<LineTokenizer, FieldSetMapper<Object>>();
for (Map.Entry<String, LineTokenizer> entry : tokenizers.entrySet()) {
Pattern pattern = Pattern.compile(entry.getKey());
patternTokenizers.put(pattern, entry.getValue());
patternMappers.put(entry.getValue(), mappers.get(entry.getKey()));
}
}
public void setLineTokenizers(Map<String, LineTokenizer> lineTokenizers) {
this.tokenizers = lineTokenizers;
}
public void setFieldSetMappers(Map<String, FieldSetMapper<Object>> fieldSetMappers) {
this.mappers = fieldSetMappers;
}
}
RegularExpressionLineMapper is a basic implementation of the LineMapper interface. It implements
the one required method, mapLine , to convert a String read in from a flat file to an object. The mapLine
method begins by obtaining a LineTokenizer implementation based on the String the method received
as input (more on that in a bit). It then uses that LineTokenizer implementation to parse the String into
a FieldSet. With the String divided into its individual fields, the appropriate FieldSetMapper is retrieved,
and the fields are mapped into a new instance of the object required. The new object is then returned.
To determine which LineTokenizer to use, you do two things. First, the afterPropertiesSet method
(from the InitializerBean interface) creates two Map s. The first consists of regular expression keys to
LineTokenizer values. The second consists of LineTokenizer keys to FieldSetMapper values. These two
Map s are used in delegating to the appropriate implementations. You use these maps by looping through
the keys of the patternTokenizers Map , applying each regular expression to the String you're trying to
parse. When you find a regular expression that matches, you use the associated LineTokenizer to parse
the String . The LineTokenizer from the previous step allows you to get the correct FieldSetMapper from
the patternMappers Map and map the FieldSet to the correct object. If for some reason a LineTokenizer or