Publicado em: 12/07/2011 16:02:48

O framework que desenvolvi foi baseado num design pattern chamado Specification">http://martinfowler.com/apsupp/spec.pdf"">Specification criado por Martin">http://martinfowler.com/"">Martin Fowler.

O framework consiste de uma classe utilitária chamada Rule e uma interface chamada Specification.

Para definir uma regra de negócio, voce implementa a interface Specification. Com sua implementação pronta, você cria uma instância de Rule passando a sua regra de negócio (implementação de Specification) como parametro.

Veja o exemplo para entender como utilizar a classe Rule e a interface Specification para aplicar regras de negócio numa classe hipotetica Pessoa.

Uma Pessoa tem os seguintes atributos: nome, idade e sexo.
Para validar uma Pessoa, foram definidas as seguintes regras:
- O nome não pode ser null e deve começar com uma letra maiúscula e ter uma ou mais letras minúsculas;
- A idade não pode ser negativa;
- O sexo só pode ser 'M' ou 'F'.

Primeiro definimos a classe Pessoa conforme abaixo:

class Pessoa { String nome; int idade; char sexo; Pessoa(String nome, int idade, char sexo) { this.nome = nome; this.idade = idade; this.sexo = sexo; } }


Agora criamos três especificações distintas para as regras que validam nome, idade e sexo da Pessoa.

// Especificação da regra que valida o nome de uma Pessoa class Nome implements Specification<Pessoa, String> { public boolean isSatisfiedBy(Pessoa pessoa, Collection<String> detalhes) { String nome = pessoa.nome; if (nome == null) { detalhes.add("Nome não pode ser null"); return false; } if (!nome.matches("[A-Z]{1}[a-z]+")) { detalhes.add("Nome precisa começar com letra maiuscula e ter pelo menos duas letras"); return false; } return true; } }

// Especificação da regra que valida a idade de Pessoa class Idade implements Specification<Pessoa, String> { public boolean isSatisfiedBy(Pessoa pessoa, Collection<String> detalhes) { if (pessoa.idade < 0) { detalhes.add("Idade não pode ser negativa"); return false; } return true; } }

// Especificação da regra que valida o sexo de uma Pessoa class Sexo implements Specification<Pessoa, String> { public boolean isSatisfiedBy(Pessoa pessoa, Collection<String> detalhes) { switch (pessoa.sexo) { case 'M': case 'F': return true; default: detalhes.add("Sexo só pode ser 'M' ou 'F'"); return false; } } }


Agora ja temos a classe Pessoa e as especificações das regras para nome, idade e sexo criadas.
Podemos então utilizar a classe Rule para validar instancias de Pessoa de diversas formas, por exemplo:

// instanciamos as regras a partir das especificações Rule<Pessoa, String> regraDoNome = Rule.from(new Nome()); Rule<Pessoa, String> regraDaIdade = Rule.from(new Idade()); Rule<Pessoa, String> regraDoSexo = Rule.from(new Sexo()); // criamos uma pessoa com nome, idade e sexo validos Pessoa pessoa = new Pessoa("Ricardo", 29, 'M'); if (regraDoNome.and(regraDaIdade) .and(regraDoSexo) .isSatisfiedBy(pessoa)) { // o nome, idade e sexo da pessoa atendem as regras } // criamos uma pessoa com nome invalido, mas idade e sexo validos pessoa = new Pessoa("RicArdO", 29, 'M'); Rule<Pessoa, String> regraDoNomeIdadeSexo = regraDoNome.and(regraDaIdade) .and(regraDoSexo); if (regraDoNomeIdadeSexo.not().isSatisfiedBy(pessoa)) { // apresentamos os detalhes for (String detalhe : regraDoNomeIdadeSexo.getDetails()) { System.out.println(detalhe); } }




Abaixo estão os dois fontes que compões o FrameWork

package br.com.staroski.rules; import java.util.Collection; /** * Interface que representa a especificação de uma regra para determinado tipo de dado.<BR> * A especificação pode fornecer detalhes sobre o motivo de um objeto atende-la ou não.<BR> * O critério pra avaliar se um objeto atende ou não a uma especificação é realizado através da implementação do método * {@link #isSatisfiedBy(Object, Collection)}.<BR> * <BR> * <I><B>Dica: </B> Consulte a documentação da classe {@link Rule} para mais detalhes.</I> * * @author Ricardo Artur Staroski * @param <O> Tipo de dado do objeto que pode ou não atender a especificação desta interface. * @param <D> Tipo de dado da lista de detalhes que pode conter informações sobre o motivo de um objeto atender, ou não, a especificação desta * interface. */ public interface Specification<O, D> { /** * Verifica se o objeto informado atende, ou não, a especificação desta interface. * * @param object O objeto a ser verificado. * @param details Coleção que pode conter os detalhes sobre o motivo de um objeto atender, ou não, a esta especificação. * @return <code>true</code> se o objeto atender a especificação e <code>false</code> caso contrário. */ public boolean isSatisfiedBy(O object, Collection<D> details); }

package br.com.staroski.rules; import java.util.Collection; import java.util.Collections; import java.util.LinkedList; import java.util.List; /** * Esta classe é reponsável por criar regras a partir de simples especificações.<BR> * <BR> * <I> Para obter instancias desta classe, utilize o método {@link #from(Specification)}.</I><BR> * <BR> * Através de uma instância de {@link Rule}, é possivel montar expressões complexas associando outras {@link Specification}s ou {@link Rule}s através * dos seguintes métodos:<BR> * - {@link #and(Specification)}<BR> * - {@link #andNot(Specification)}<BR> * - {@link #or(Specification)}<BR> * - {@link #orNot(Specification)}<BR> * - {@link #not()} <BR> * Outra característica interessante desta classe é o método {@link #getDetails()} que obtém detalhes do motivo de um objeto atender, ou não, * dependendo da situação, a especificação da regra.<BR> * <BR> * <B><I>Veja o exemplo para entender como utiliza-la:</I></B><BR> * <BR> * Uma <tt>Pessoa</tt> tem os seguintes atributos: <tt>nome</tt>, <tt>idade</tt> e <tt>sexo</tt>.<BR> * Para validar uma <tt>Pessoa</tt>, foram definidas as seguintes regras:<BR> * - O nome não pode ser <code>null</code> e deve começar com uma letra maiúscula e ter uma ou mais letras minúsculas;<BR> * - A idade não pode ser negativa;<BR> * - O sexo só pode ser <code>'M'</code> ou <code>'F'</code>.<BR> * <BR> * <B>Primeiro definimos a classe <tt>Pessoa</tt> conforme abaixo:</B> * * <PRE> * class Pessoa { * * String nome; * int idade; * char sexo; * * Pessoa(String nome, int idade, char sexo) { * this.nome = nome; * this.idade = idade; * this.sexo = sexo; * } * } * </PRE> * * <B>Agora criamos três especificações distintas para as regras que validam <tt>nome</tt>, <tt>idade</tt> e <tt>sexo</tt> da <tt>Pessoa</tt>.</B> * * <PRE> * // Especificação da regra que valida o nome de uma Pessoa * class Nome implements Specification<Pessoa, String> { * * public boolean isSatisfiedBy(Pessoa pessoa, Collection<String> detalhes) { * String nome = pessoa.nome; * if (nome == null) { * detalhes.add("Nome não pode ser null"<img src="http://javafree.uol.com.br/forum/images/smiles/icon_wink.gif">; * return false; * } * if (!nome.matches("[A-Z]{1}[a-z]+"<img src="http://javafree.uol.com.br/forum/images/smiles/icon_wink.gif">) { * detalhes.add("Nome precisa começar com letra maiuscula e ter pelo menos duas letras"<img src="http://javafree.uol.com.br/forum/images/smiles/icon_wink.gif">; * return false; * } * return true; * } * } * </PRE> * * <PRE> * // Especificação da regra que valida a idade de Pessoa * class Idade implements Specification<Pessoa, String> { * * public boolean isSatisfiedBy(Pessoa pessoa, Collection<String> detalhes) { * if (pessoa.idade < 0) { * detalhes.add("Idade não pode ser negativa"<img src="http://javafree.uol.com.br/forum/images/smiles/icon_wink.gif">; * return false; * } * return true; * } * } * </PRE> * * <PRE> * // Especificação da regra que valida o sexo de uma Pessoa * class Sexo implements Specification<Pessoa, String> { * * public boolean isSatisfiedBy(Pessoa pessoa, Collection<String> detalhes) { * switch (pessoa.sexo) { * case 'M': * case 'F': * return true; * default: * detalhes.add("Sexo só pode ser 'M' ou 'F'"<img src="http://javafree.uol.com.br/forum/images/smiles/icon_wink.gif">; * return false; * } * } * } * </PRE> * * <B>Agora ja temos a classe <tt>Pessoa</tt> e as especificações das regras para <tt>nome</tt>, <tt>idade</tt> e <tt>sexo</tt> criadas.<BR> * Podemos então utilizar a classe {@link Rule} para validar instancias de <tt>Pessoa</tt> de diversas formas, por exemplo:</B> * * <PRE> * // instanciamos as regras a partir das especificações * Rule<Pessoa, String> nome = Rule.from(new Nome()); * Rule<Pessoa, String> idade = Rule.from(new Idade()); * Rule<Pessoa, String> sexo = Rule.from(new Sexo()); * * // criamos uma pessoa com nome, idade e sexo validos * Pessoa pessoa = new Pessoa("Ricardo", 29, 'M'); * if (nome.and(idade) * .and(sexo) * .isSatisfiedBy(pessoa)) { * // o nome, idade e sexo da pessoa atendem as regras * } * * // criamos uma pessoa com nome invalido, mas idade e sexo validos * pessoa = new Pessoa("RicArdO", 29, 'M'); * Rule<Pessoa, String> regra = nome.and(idade) * .and(sexo); * if (regra.not().isSatisfiedBy(pessoa)) { * // apresentamos os detalhes * for (String detalhe : regra.getDetails()) { * System.out.println(detalhe); * } * } * </PRE> * * @author Ricardo Artur Staroski * @param <O> Tipo de dado do objeto que pode ou não atender as regras. * @param <D> Tipo de dado da lista de detalhes caso o objeto não atenda as regras. */ public abstract class Rule<O, D> implements Specification<O, D> { /** * Regra interna que realiza a operação <B>E</B> entre duas especificações. * * @param <X> Tipo de dado do objeto que pode ou não atender as regras. * @param <Y> Tipo de dado da lista de detalhes caso o objeto não atenda as regras. */ private static final class And<X, Y> extends Rule<X, Y> { /** * A primeira especificação desta regra. */ private final Specification<X, Y> spec1; /** * A segunda especificação desta regra. */ private final Specification<X, Y> spec2; /** * Cria uma nova regra. * * @param spec1 A primeira especificação desta regra. * @param spec2 A segunda especificação desta regra. */ protected And(final Specification<X, Y> spec1, final Specification<X, Y> spec2) { this.spec1 = spec1; this.spec2 = spec2; } /** * {@inheritDoc} */ @Override public boolean isSatisfiedBy(final X object, final Collection<Y> details) { // precisa ser '&' ao invés de '&&' de forma a preencher os detalhes das duas especificações return spec1.isSatisfiedBy(object, details) & spec2.isSatisfiedBy(object, details); } } /** * Especialização de {@link LinkedList} que não aceita duplicatas. * * @param <X> Tipo de dado da lista. */ @SuppressWarnings("serial") private static final class Details<X> extends LinkedList<X> { /** * {@inheritDoc} */ @Override public void add(final int index, final X element) { if (!contains(element)) { super.add(index, element); } } /** * {@inheritDoc} */ @Override public boolean add(final X e) { if (!contains(e)) { return super.add(e); } return false; } /** * {@inheritDoc} */ @Override public boolean addAll(final Collection<? extends X> c) { return super.addAll(getNotContained(c)); } /** * {@inheritDoc} */ @Override public boolean addAll(final int index, final Collection<? extends X> c) { return super.addAll(index, getNotContained(c)); } /** * Dado uma coleção, obtém os elementos desta coleção que não inclusos na lista atual. * * @param c Um coleção qualquer * @return Os elementos da coleção que não estão inclusos na lista atual. */ private Collection<X> getNotContained(final Collection<? extends X> c) { final List<X> elements = new LinkedList<X>(); for (final X e : c) { if (!contains(e)) { elements.add(e); } } return elements; } } /** * Regra interna que realiza criada a partir de uma especificação qualquer. * * @param <X> Tipo de dado do objeto que pode ou não atender as regras. * @param <Y> Tipo de dado da lista de detalhes caso o objeto não atenda as regras. */ private static final class Is<X, Y> extends Rule<X, Y> { /** * A especificação desta regra. */ private final Specification<X, Y> spec; /** * Cria uma nova regra. * * @param spec A especificação desta regra. */ protected Is(final Specification<X, Y> spec) { this.spec = spec; } /** * {@inheritDoc} */ @Override public boolean isSatisfiedBy(final X object, final Collection<Y> details) { return spec.isSatisfiedBy(object, details); } } /** * Regra interna que realiza a operação <B>NÃO</B> de uma especificação qualquer. * * @param <X> Tipo de dado do objeto que pode ou não atender as regras. * @param <Y> Tipo de dado da lista de detalhes caso o objeto não atenda as regras. */ private static final class Not<X, Y> extends Rule<X, Y> { /** * A especificação desta regra. */ private final Specification<X, Y> spec; /** * Cria uma nova regra. * * @param spec A primeira especificação desta regra. */ protected Not(final Specification<X, Y> spec) { this.spec = spec; } /** * {@inheritDoc} */ @Override public boolean isSatisfiedBy(final X object, final Collection<Y> details) { return !spec.isSatisfiedBy(object, details); } } /** * Regra interna que realiza a operação <B>OU</B> entre duas especificações. * * @param <X> Tipo de dado do objeto que pode ou não atender as regras. * @param <Y> Tipo de dado da lista de detalhes caso o objeto não atenda as regras. */ private static final class Or<X, Y> extends Rule<X, Y> { /** * A primeira especificação desta regra. */ private final Specification<X, Y> spec1; /** * A segunda especificação desta regra. */ private final Specification<X, Y> spec2; /** * Cria uma nova regra. * * @param spec1 A primeira especificação desta regra. * @param spec2 A segunda especificação desta regra. */ protected Or(final Specification<X, Y> spec1, final Specification<X, Y> spec2) { this.spec1 = spec1; this.spec2 = spec2; } /** * {@inheritDoc} */ @Override public boolean isSatisfiedBy(final X object, final Collection<Y> details) { // precisa ser '|' ao invés de '||' de forma a preencher os detalhes das duas especificações return spec1.isSatisfiedBy(object, details) | spec2.isSatisfiedBy(object, details); } } /** * Obtém uma regra a partir de uma simples especificação, ou seja, informa-se uma implementação de {@link Specification} correspondente a regra * desejada e obtém-se uma implementação de {@link Rule}. * * @param <X> Tipo de dado do objeto que pode ou não atender as regras. * @param <Y> Tipo de dado da lista de detalhes caso o objeto não atenda as regras. * @param spec A {@link Specification} da qual será criada uma {@link Rule}. * @return A {@link Rule} que encapsula a {@link Specification} informada. */ public static final <X, Y> Rule<X, Y> from(final Specification<X, Y> spec) { return new Is<X, Y>(spec); } /** * Detalhes do motivo de um objeto nao atender a esta regra. */ private Details<D> details; /** * Construtor privado, só é acessivel pelas <I>inner classes</I> {@link Is}, {@link Not}, {@link And} e {@link Or}. */ private Rule() { details = new Details<D>(); } /** * Cria uma nova regra que somente atenderá a um objeto qualquer se a especificação desta regra <B>E</B> a especificação informada também * atenderem ao mesmo objeto.<BR> * <BR> * A operação <I>AND</I> possui o comportamento abaixo: * * <PRE> * objetoAtende = objetoAtendeRegra1 & objetoAtendeRegra2 * </PRE> * * @param spec A {@link Specification} a ser adicionada a esta regra. * @return Uma {@link Rule} que atende a um objeto se a especificação da regra atual e a especificação informada também atenderem a este objeto. */ public final Rule<O, D> and(final Specification<O, D> spec) { return new And<O, D>(this, spec); } /** * Cria uma nova regra que somente atenderá a um objeto qualquer se a especificação desta regra atender <B>E</B> a especificação informada * <B>NÃO</B> atender ao mesmo objeto.<BR> * <BR> * A operação <I>AND NOT</I> possui o comportamento abaixo: * * <PRE> * objetoAtende = objetoAtendeRegra1 & !objetoAtendeRegra2 * </PRE> * * @param spec A {@link Specification} a ser adicionada a esta regra. * @return Uma {@link Rule} que atende a um objeto se a especificação da regra atual atender e a especificação informada não atender a este * objeto. */ public final Rule<O, D> andNot(final Specification<O, D> spec) { return new And<O, D>(this, new Is<O, D>(spec).not()); } /** * Obtém os detalhes caso um objeto não atenda a esta regra.<BR> * <BR> * <B>Observação:</B> Uma regra somente é populada com detalhes durante a execução do método {@link #isSatisfiedBy(Object)}. Caso seja invocado o * método {@link #isSatisfiedBy(Object, Collection)}, os detalhes estarão na própria coleção passada como parâmetro. * * @return Uma coleção vazia caso o objeto atenda a esta regra ou uma coleção contendo contendo os detalhes do motivo de ele não atender a regra. */ public final List<D> getDetails() { return Collections.unmodifiableList(details); } /** * Verifica se o objeto informado atende, ou não, a especificação desta regra.<BR> * <BR> * <B>Observação:</B> Após a execução deste método, caso o objeto informado não atenda a regra, os detalhes poderão ser obtidos através do método * {@link #getDetails()}. * * @param object O objeto a ser verificado. * @return <code>true</code> se o objeto atender a especificação e <code>false</code> caso contrário. */ public final boolean isSatisfiedBy(final O object) { details = new Details<D>(); return isSatisfiedBy(object, details); } /** * {@inheritDoc}<BR> * <BR> * <B>Observação:</B> Este método somente manipula a coleção passada por parâmetro, não alterando o retorno do método {@link #getDetails()}, de * forma que, após a execução dele, os detalhes estarão contidos no próprio parametro. */ public abstract boolean isSatisfiedBy(O object, Collection<D> details); /** * Cria uma nova regra que somente atenderá a um objeto qualquer se a especificação desta regra <B>NÃO</B> atender ao mesmo objeto.<BR> * <BR> * A operação <I>NOT</I> possui o comportamento abaixo: * * <PRE> * objetoAtende = !objetoAtendeRegra * </PRE> * * @return Uma {@link Rule} que atende a um objeto se a especificação da regra atual não atender a este objeto. */ public final Rule<O, D> not() { return new Not<O, D>(this); } /** * Cria uma nova regra que somente atenderá a um objeto qualquer se a especificação desta regra <B>OU</B> a especificação informada também * atenderem ao mesmo objeto.<BR> * <BR> * A operação <I>OR</I> possui o comportamento abaixo: * * <PRE> * objetoAtende = objetoAtendeRegra1 | objetoAtendeRegra2 * </PRE> * * @param spec A {@link Specification} a ser adicionada a esta regra. * @return Uma {@link Rule} que atende a um objeto se a especificação da regra atual ou a especificação informada também atenderem a este objeto. */ public final Rule<O, D> or(final Specification<O, D> spec) { return new Or<O, D>(this, spec); } /** * Cria uma nova regra que somente atenderá a um objeto qualquer se a especificação desta regra atender <B>OU</B> a especificação informada * <B>NÃO</B> * atender ao mesmo objeto. <BR> * <BR> * A operação <I>OR NOT</I> possui o comportamento abaixo: * * <PRE> * objetoAtende = objetoAtendeRegra1 | !objetoAtendeRegra2 * </PRE> * * @param spec A {@link Specification} a ser adicionada a esta regra. * @return Uma {@link Rule} que atende a um objeto se a especificação da regra atual atender ou a especificação informada não atender a este * objeto. */ public final Rule<O, D> orNot(final Specification<O, D> spec) { return new Or<O, D>(this, new Is<O, D>(spec).not()); } }
_________________
Ricardo Artur Staroski, OCP-JP
Blumenau - SC