Construindo Suas Próprias Condições de Filtragem
Na seção anterior vimos como BeforeElement e InsideElement funcionam. Com essas condições mais as opções básicas de StartElement e EndElement você pode fazer muitos tipos de filtragem. Mas suas imaginação pode sempre pensar em alguma forma de fitragem que será difícil ou impossível de fazer usando somente as anotações padrão. Para resolver essa questão, JColtrane permite ao usuário criar suas prórpias anotações com as condições que desejar. Dessa forma, veremos nessa seção os passos para construir a anotação e as condições construindo um exemplo que permite construir uma condição baseada no galho atual do processamento.
Step 1: Criando uma Anotação
A primeira coisa que você deve fazer é criar uma notação indicando as condições que você construirá. É recomendado o uso de um nome significativo. Como exemplo, criaremos a anotação UserAnnotation:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface UserAnnotation {
String currentBranch() ;
}
Na anotação você deve inserir os metadados que você necessitará quando construir suas condições. No nosso exemplo, precisaremos da String currentBrunch (galhoAtual).
Step 2: Criando Condições
Para criar sua própria condição, você deve implementar a interface Condition do pacote net.sf.jColtrane.conditions do JColtrane. Essa interface possui um método verify que retorna um booleano. Você deve fazê-lo retornar verdadeiro (true) quando sua condição for satisfeita e falso (false) quando não for. Em nosso exemplo, faremos ser possível para usuário escolher um galho corrente desejado baseado em uma expressão regular:
public class UserCondition implements Condition {
private Pattern pattern;
public UserCondition(String regularExpression,int elementDeep) {
pattern=Pattern.compile(regularExpression);
}
@Override
public boolean verify(ContextVariables contextVariables) {
return pattern.matcher(contextVariables.getCurrentBranch()).matches();
}
}
A ContextVariables é uma classe especial que te dá todas as informações sobre o processamento. A veremos em detalhes em Como Receber Parâmetros do JColtrane.
Step 3: Criando uma ConditionFactory
Você deve extender a classe abstrata ConditionFactory. Ela possui o método abstrato getConditions que retorna uma lista de Condition. O método recebe uma anotação como parâmetro, que poderá ser do tipo UserAnnotation que criamos no passo 1. Assim, nessa classe você recebe os metadados que necessita para construir suas condições. Note que para uma anotação criada podem existir várias condições ligadas. Assim, essa é a razão pela qual você precisa retornar uma lista de condições. Você pode lembrar da anotacão StartElement que você pode colocar uma opção para tag e para uri, assim, nesse caso, existem 2 condições ligadas. Em nosso exemplo fizemos só uma condição por questão de simplicidade. Vejamos:
public class UserConditionsFactory implements ConditionsFactory{
@Override
public List<Condition> getConditions(Annotation annotation) {
if(annotation instanceof UserAnnotation){
List<Condition> conditions=new LinkedList<Condition>();
UserAnnotation userAnnotation=(UserAnnotation) annotation;
conditions.add(new UserCondition(userAnnotation.currentBranch()));
return conditions;
}
return null;
}
}
Note que o método retorna null se a anotação não é do tipo desejado. Se você retornar null nesse método, JColtrane não levará em conta essa condição para executar o método.
Step 4: Indicando JColtrane a ConditionsFactory
Nesse último passo, você precisa dizer ao JColtrane onde encontrar a factory que você criou. Fazemos isso incluindo a linha marcada em UserAnnotation:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
@ConditionFactoryAnnotation(UserConditionsFactory.class)
public @interface UserAnnotation {
String currentBranch();
}
Depois desse último passo, você pode usar suas condição sempre que desejar:
public class UserAnnotatedClass {
@UserAnnotation(currentBanch="/.*/line.*")
@StartElement
public void executeUserTest(@CurrentBranch String currentBranch){
System.out.println(currentBranch);
System.out.println("executing test!!!!!");
}
}
Rodando o teste, baseado no documento XML visto da seção anterior, o sistema imprime:
/beanDescriptor/line/
executing test!!!!!
/beanDescriptor/line/property/
executing test!!!!!
/beanDescriptor/line/paragraphy/
executing test!!!!!
/beanDescriptor/line/paragraphy/phrase/
executing test!!!!!
/beanDescriptor/line/property2/
executing test!!!!!
NOTA: Assim como quando se usa BeforeElement, você precisa usar sua anotação em conjunto com StartElement ou EndElement. Se você usar somente sua anotação, JColtrane executará nada.
Após essa seção, você possui uma ferrameta poderosa para filtrar um elemento durante o processamento XML. Agora, para tornar possível fazer qualquer coisa durante o processamento, só está faltando saber como obter informações sobre o processamento. Vejamos isso em Como Receber Parâmetros do JColtrane.
