/* $Id: DigesterLoader.java 992084 2010-09-02 19:52:17Z simonetripodi $
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.digester.annotations;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.Rule;
import org.apache.commons.digester.RuleSet;
import org.apache.commons.digester.annotations.handlers.DefaultLoaderHandler;
import org.apache.commons.digester.annotations.internal.RuleSetCache;
import org.apache.commons.digester.annotations.reflect.MethodArgument;
import org.apache.commons.digester.annotations.spi.AnnotationRuleProviderFactory;
import org.apache.commons.digester.annotations.spi.DigesterLoaderHandlerFactory;
import org.apache.commons.digester.annotations.utils.AnnotationUtils;
/**
* This class manages the creation of Digester instances analyzing target classes
* annotated with digester annotations.
*
* @since 2.1
*/
public final class DigesterLoader {
/**
* In-memory LRU cache that stores already analyzed classes and relative
* {@link RuleSet}.
*/
private final RuleSetCache cachedRuleSet = new RuleSetCache();
private final AnnotationRuleProviderFactory annotationRuleProviderFactory;
private final DigesterLoaderHandlerFactory digesterLoaderHandlerFactory;
/**
* Creates a new {@link DigesterLoader} instance.
*
* @param annotationRuleProviderFactory
* @param digesterLoaderHandlerFactory
*/
protected DigesterLoader(AnnotationRuleProviderFactory annotationRuleProviderFactory,
DigesterLoaderHandlerFactory digesterLoaderHandlerFactory) {
this.annotationRuleProviderFactory = annotationRuleProviderFactory;
this.digesterLoaderHandlerFactory = digesterLoaderHandlerFactory;
}
protected AnnotationRuleProviderFactory getAnnotationRuleProviderFactory() {
return annotationRuleProviderFactory;
}
protected DigesterLoaderHandlerFactory getDigesterLoaderHandlerFactory() {
return digesterLoaderHandlerFactory;
}
/**
* Creates a new digester which rules are defined by analyzing the digester
* annotations in the target class.
*
* @param target the class has to be analyzed.
* @return a new Digester instance.
*/
public Digester createDigester(final Class<?> target) {
Digester digester = new Digester();
digester.setClassLoader(target.getClassLoader());
addRules(target, digester);
return digester;
}
/**
* Add rules to an already created Digester instance, analyzing the digester
* annotations in the target class.
*
* @param target the class has to be analyzed.
* @param digester the Digester instance reference.
*/
public void addRules(final Class<?> target, final Digester digester) {
RuleSet ruleSet = getRuleSet(target);
ruleSet.addRuleInstances(digester);
}
/**
* Builds a new {@link RuleSet} analyzing the digester annotations in the
* target class.
*
* It avoids iterate the annotations analysis for already analyzed classes,
* using an in-memory LRU cache.
*
* @param target the class has to be analyzed.
* @return a new {@link RuleSet}.
*/
public RuleSet getRuleSet(final Class<?> target) {
if (this.cachedRuleSet.containsKey(target)) {
return this.cachedRuleSet.get(target);
}
FromAnnotationsRuleSet ruleSet = new FromAnnotationsRuleSet(this);
addRulesTo(target, ruleSet);
this.cachedRuleSet.put(target, ruleSet);
return ruleSet;
}
/**
* Analyzes the target class and adds the {@link AnnotationRuleProvider}s to
* the existing {@link FromAnnotationsRuleSet}.
*
* @param target the class has to be analyzed.
* @param ruleSet the RuleSet where adding the providers.
*/
public void addRulesTo(final Class<?> target, FromAnnotationsRuleSet ruleSet) {
if (target == Object.class
|| target.isInterface()
|| ruleSet.mapsClass(target)) {
return;
}
if (this.cachedRuleSet.containsKey(target)) {
ruleSet.addRulesProviderFrom(this.cachedRuleSet.get(target));
ruleSet.addMappedClass(target);
return;
}
// current analyzed class
handle(target, ruleSet);
// class fields
for (Field field : target.getDeclaredFields()) {
handle(field, ruleSet);
}
// class methods
for (Method method : target.getDeclaredMethods()) {
handle(method, ruleSet);
// method args
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Class<?>[] parameterTypes = method.getParameterTypes();
for (int i = 0; i < parameterTypes.length; i++) {
handle(new MethodArgument(i, parameterTypes[i], parameterAnnotations[i]), ruleSet);
}
}
ruleSet.addMappedClass(target);
addRulesTo(target.getSuperclass(), ruleSet);
}
/**
* Executes an analysis for each annotation present in the element.
*
* @param element the current element under analysis.
* @param ruleSet the ruleSet where add providers.
*/
private void handle(AnnotatedElement element, FromAnnotationsRuleSet ruleSet) {
for (Annotation annotation : element.getAnnotations()) {
handle(annotation, element, ruleSet);
}
}
/**
* Handles the current visited element and related annotation, invoking the
* right handler putting the rule provider in the rule set.
*
* @param annotation the current visited annotation.
* @param element the current visited element.
*/
@SuppressWarnings("unchecked")
private <A extends Annotation, E extends AnnotatedElement, R extends Rule> void handle(A annotation,
E element,
FromAnnotationsRuleSet ruleSet) {
Class<?> annotationType = annotation.annotationType();
// check if it is one of the @*.List annotation
if (annotationType.isAnnotationPresent(DigesterRuleList.class)) {
Annotation[] annotations = AnnotationUtils.getAnnotationsArrayValue(annotation);
if (annotations != null && annotations.length > 0) {
// if it is an annotations array, process them
for (Annotation ptr : annotations) {
handle(ptr, element, ruleSet);
}
}
} else if (annotationType.isAnnotationPresent(DigesterRule.class)) {
DigesterRule digesterRule = annotationType.getAnnotation(DigesterRule.class);
if (DefaultLoaderHandler.class == digesterRule.handledBy()) {
Class<? extends AnnotationRuleProvider<A, E, R>> providerType =
(Class<? extends AnnotationRuleProvider<A, E, R>>) digesterRule.providedBy();
ruleSet.addRuleProvider(AnnotationUtils.getAnnotationPattern(annotation),
providerType,
annotation,
element);
} else {
Class<? extends DigesterLoaderHandler<Annotation, AnnotatedElement>> handlerType =
(Class<? extends DigesterLoaderHandler<Annotation, AnnotatedElement>>) digesterRule.handledBy();
DigesterLoaderHandler<Annotation, AnnotatedElement> handler =
this.digesterLoaderHandlerFactory.newInstance(handlerType);
// run!
handler.handle(annotation, element, ruleSet);
}
}
}
}