Commit Inicial

.gitignore

@@ -0,0 +1,7 @@
+/.classpath
+/.project
+/.settings/org.eclipse.jdt.core.prefs
+/.settings/org.eclipse.m2e.core.prefs
+/.settings/org.eclipse.wst.common.component
+/.settings/org.eclipse.wst.common.project.facet.core.xml
+/.settings/org.eclipse.wst.validation.prefs

pom.xml

@@ -0,0 +1,32 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>br.com.rjconsultores</groupId>
+	<artifactId>Auditador</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	
+	<build>
+		<sourceDirectory>src/main/java</sourceDirectory>
+		<testSourceDirectory>src/test/java</testSourceDirectory>
+		<plugins>
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.3</version>
+				<configuration>
+					<source>1.6</source>
+					<target>1.6</target>
+				</configuration>
+			</plugin>
+		</plugins>
+		<finalName>${project.artifactId}</finalName>
+	</build>
+	
+	<dependencies>
+		<dependency>
+			<groupId>commons-lang</groupId>
+			<artifactId>commons-lang</artifactId>
+			<version>2.2</version>
+		</dependency>
+	</dependencies>	
+</project>

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarAtributo.java

@@ -0,0 +1,28 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Anotação utilizada para atributos.
+ * 
+ * @author wilian
+ *
+ */
+@Target(ElementType.FIELD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarAtributo {
+	
+	/**
+	 * Caso seja necessário colocar um nome amigável para o atributo, senão for informado o padrão será o nome do atributo da classe.
+	 */
+	String nome() default "";
+	
+	/**
+	 * Em caso de um atributo do tipo "DATE", informar o formato da data, valor padrão: "dd/MM/yyyy HH:mm"
+	 */
+	String pattern() default "dd/MM/yyyy HH:mm";
+
+}

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarClasse.java

@@ -0,0 +1,35 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import br.com.rjconsultores.auditador.enums.TipoExtracaoDados;
+
+/**
+ * Anotação responsável por indicar que a classe será auditada.
+ * 
+ * @author wilian
+ *
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarClasse {
+	
+	/**
+	 * Caso seja necessário colocar um nome amigável para a classe, senão for informado o padrão será o nome da classe.
+	 */
+	String nome();
+	
+	/**
+	 * Atributo para indicar qual tela que o objeto será auditado.
+	 */
+	String tela();
+	
+	/**
+	 * Define se as informações serão extraídas pelo atributo ou metodo.
+	 * @return
+	 */
+	TipoExtracaoDados tipoExtracaoDados() default TipoExtracaoDados.ATRIBUTO;
+}

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarEntidade.java

@@ -0,0 +1,20 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Anotação responsável que indicará que o atributo é uma entidade e seus atributos deverão ser auditados individualmente.
+ * 
+ * @author wilian
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarEntidade {
+	
+	/**
+	 * Caso seja necessário colocar um nome amigável para o atributo, senão for informado o padrão será o nome do atributo da classe.
+	 */
+	String nome() default "";
+
+}

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarID.java

@@ -0,0 +1,18 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Anotação responsável para indicar qual o atributo que representa a chave primária da classe.
+ * 
+ * @author wilian
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarID {
+	
+	String nome() default "";
+	String pattern() default "";
+
+}

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarIDComposta.java

@@ -0,0 +1,15 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Anotação responsável para indicar qual o atributo que representa a chave primária composta da classe.
+ * 
+ * @author wilian
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarIDComposta {
+	
+}

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarLista.java

@@ -0,0 +1,26 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Anotação responsável para auditar o campos que são listas.
+ * 
+ * @author wilian
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarLista {
+
+	/**
+	 * Caso seja necessário colocar um nome amigável para o atributo, senão for informado o padrão será o nome do atributo da classe.
+	 */
+	String nome() default "";
+	
+	/**
+	 * Indica que os atributos da lista são entidades e precisam ser auditados individualmente. O padrão é comparar apenas se os itens da lista foram removidos ou adicionados.
+	 * @return
+	 */
+	boolean auditarEntidades() default false;
+
+}

src/main/java/br/com/rjconsultores/auditador/annotations/AuditarMetodo.java

@@ -0,0 +1,28 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Anotação utilizada para methodos.
+ * 
+ * @author wilian
+ *
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuditarMetodo {
+	
+	/**
+	 * Caso seja necessário colocar um nome amigável para o atributo, senão for informado o padrão será o nome do atributo da classe.
+	 */
+	String nome() default "";
+	
+	/**
+	 * Em caso de um atributo do tipo "DATE", informar o formato da data, valor padrão: "dd/MM/yyyy HH:mm"
+	 */
+	String pattern() default "dd/MM/yyyy HH:mm";
+
+}

src/main/java/br/com/rjconsultores/auditador/annotations/NaoAuditar.java

@@ -0,0 +1,15 @@
+package br.com.rjconsultores.auditador.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Anotação responsável para indicar que o atributo não deverá ser auditado, por padrão todos os atributos da classe são auditados.
+ * 
+ * @author wilian
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface NaoAuditar {
+
+}

src/main/java/br/com/rjconsultores/auditador/auditadores/Auditador.java

@@ -0,0 +1,628 @@
+package br.com.rjconsultores.auditador.auditadores;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+import org.apache.commons.lang.StringUtils;
+
+import br.com.rjconsultores.auditador.annotations.AuditarAtributo;
+import br.com.rjconsultores.auditador.annotations.AuditarClasse;
+import br.com.rjconsultores.auditador.annotations.AuditarEntidade;
+import br.com.rjconsultores.auditador.annotations.AuditarID;
+import br.com.rjconsultores.auditador.annotations.AuditarIDComposta;
+import br.com.rjconsultores.auditador.annotations.AuditarLista;
+import br.com.rjconsultores.auditador.annotations.AuditarMetodo;
+import br.com.rjconsultores.auditador.annotations.NaoAuditar;
+import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao;
+import br.com.rjconsultores.auditador.enums.TipoExtracaoDados;
+import br.com.rjconsultores.auditador.exceptions.AuditadorException;
+import br.com.rjconsultores.auditador.interfaces.Auditavel;
+import br.com.rjconsultores.auditador.interfaces.AuditavelTelaAlternativa;
+import br.com.rjconsultores.auditador.model.AuditadorObjects;
+
+/**
+ * Classe responsável para listar as alterações do objeto.
+ * 
+ * @author wilian
+ *
+ */
+public class Auditador {
+	
+	AuditadorAtributo auditadorAtributo;
+	AuditadorEntidade auditadorEntidade;
+	AuditadorList auditadorList;
+	ExtrairAnotacao extrairAnotacao;
+	
+	private AuditadorObjects padrao;
+	private TipoExtracaoDados tipoExtracaoDados;
+	
+	private Auditador() {
+		super();
+	}
+	
+	public static Auditador getInstance( ) {
+		Auditador auditar = new Auditador();
+		auditar.auditadorAtributo = new AuditadorAtributo(auditar);
+		auditar.auditadorEntidade = new AuditadorEntidade(auditar);
+		auditar.auditadorList = new AuditadorList(auditar);
+		auditar.extrairAnotacao = new ExtrairAnotacao();
+		return auditar;
+	}
+	
+	/**
+	 * Responsável por auditar os registros.
+	 * 
+	 * @param original
+	 * @param novo
+	 * @param empresaId
+	 * @return
+	 */
+	public List<AuditadorObjects> auditar(Object original, Object novo) {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		try {
+			
+			if(isObjetosNulos(original, novo) || !iniciarObjetoPadrao(novo != null ? novo : original, original == null ? AuditadorTipoAlteracao.INCLUSAO : AuditadorTipoAlteracao.ALTERACAO)) {
+				return lsRetorno;
+			}
+			
+			AuditadorObjects objectNovo = auditarObjetoNovo(null, original, novo);
+			if(objectNovo != null) {
+				lsRetorno.add(objectNovo);
+				return lsRetorno;
+			}
+			
+			lsRetorno.addAll(auditarCampos(original, novo, padrao.getClasseAlterada()));
+			return lsRetorno;
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+	}
+	
+	/**
+	 * Responsável por auditar os registros filhos do objeto de referencia.
+	 * 
+	 * @param objetoReferencia
+	 * @param original
+	 * @param novo
+	 * @return
+	 */
+	public List<AuditadorObjects> auditar(Object objetoReferencia, Object original, Object novo) {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		try {
+			
+			if(!iniciarObjetoPadrao(objetoReferencia, AuditadorTipoAlteracao.ALTERACAO)) {
+				return lsRetorno;
+			}
+			
+			AuditadorObjects objectNovo = auditarObjetoNovo(null, original, novo);
+			if(objectNovo != null) {
+				lsRetorno.add(objectNovo);
+				return lsRetorno;
+			}
+			
+			lsRetorno.addAll(auditarCampos(original, novo, original != null ? original.getClass().getSimpleName() : novo.getClass().getSimpleName()));
+			return lsRetorno;
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+	}
+	
+	/**
+	 * Responsável por auditar a lista quando a alteração acontece exclusivamente nos atributos lista do objeto
+	 * 
+	 * @param objeto
+	 * @param nomeCampoListAuditar
+	 * @param original
+	 * @param novo
+	 * @return
+	 */
+	public List<AuditadorObjects> auditarList(Object objeto, String nomeCampoListAuditar, List<?> original, List<?> novo) {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		try {
+			if(!iniciarObjetoPadrao(objeto, AuditadorTipoAlteracao.ALTERACAO) || isObjetosNulos(original, novo)) {
+				return lsRetorno;
+			}
+			
+			Class<?> classe = objeto.getClass();
+			
+			List<AccessibleObject> camposAuditaveis = extrairCamposAuditaveis(classe);
+			for (AccessibleObject campo : camposAuditaveis) {
+				campo.setAccessible(true);
+				String nome = extrairDeclaredNomeCampo(campo);
+
+				if(!nome.equals(nomeCampoListAuditar)) {
+					continue;
+				}
+				
+				NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(campo);
+				if(naoAuditar != null) {
+					continue;
+				}
+				
+				List<Object> lsOriginal = new ArrayList<Object>();
+				if(original != null) {
+					lsOriginal.addAll(original);
+				}
+				
+				List<Object> lsNovo = new ArrayList<Object>();
+				if(novo != null) {
+					lsNovo.addAll(novo);
+				}
+				
+				AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo);
+				lsRetorno.addAll(auditadorList.auditarList(campo, auditarLista != null ? auditarLista.auditarEntidades() : false, lsOriginal, lsNovo));
+				
+				break;
+			}
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+		return lsRetorno;
+	}
+	
+	/**
+	 * Responsável por auditar quando o objeto é excluído.
+	 * 
+	 * @param objeto
+	 * @param empresaId 
+	 * @return
+	 */
+	public List<AuditadorObjects> auditarExclusao(Object objeto) {
+		try {
+			List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+			
+			if(isObjetosNulos(null, objeto) || !iniciarObjetoPadrao(objeto != null ? objeto : null, AuditadorTipoAlteracao.EXCLUSAO)) {
+				return lsRetorno;
+			}
+			
+			AuditadorObjects objetoExcluido = auditarObjetoExcluido(objeto);
+			if(objetoExcluido != null) {
+				lsRetorno.add(objetoExcluido);
+			}
+			
+			return lsRetorno;
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+	}
+	
+	/**
+	 * Responsável por auditar quando o objeto sofre uma alteração personalizada.
+	 * 
+	 * @param objeto
+	 * @param valorNovo
+	 * @param empresaId 
+	 * @return
+	 */
+	public List<AuditadorObjects> auditarPersonalizado(Object objeto, String valorNovo) {
+		try {
+			List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+			
+			if(isObjetosNulos(null, objeto) || !iniciarObjetoPadrao(objeto != null ? objeto : null, AuditadorTipoAlteracao.ALTERACAO)) {
+				return lsRetorno;
+			}
+			
+			AuditadorObjects objetoAuditado = auditarObjetoPersonalizado(objeto, AuditadorTipoAlteracao.ALTERACAO, valorNovo);
+			if(objetoAuditado != null) {
+				lsRetorno.add(objetoAuditado);
+			}
+			
+			return lsRetorno;
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+	}	
+	
+	protected AuditadorObjects auditarObjetoNovo(AccessibleObject campo, Object original, Object novo) throws CloneNotSupportedException {
+		if(original == null && novo != null) {
+			AuditadorObjects auditado = padrao.clonar();
+			auditado.setValorNovo(String.format("Registro Criado [%s]", extrairTextoInclusaoExclusao(novo)));
+			auditado.setCampoAlterado(extrairNomeCampo(campo));
+			return auditado;
+		}
+		return null;
+	}
+	
+	protected AuditadorObjects auditarObjetoPersonalizado(Object objeto, AuditadorTipoAlteracao tipoAlteracao, String valorNovo) throws CloneNotSupportedException {
+		if(objeto != null) {
+			AuditadorObjects auditado = padrao.clonar();
+			auditado.setTipoAlteracao(tipoAlteracao != null ? tipoAlteracao : AuditadorTipoAlteracao.ALTERACAO);
+			auditado.setValorNovo(String.format("%s [%s]", valorNovo, extrairTextoInclusaoExclusao(objeto)));
+			return auditado;
+		}
+		return null;
+	}
+	
+	protected AuditadorObjects auditarObjetoExcluido(Object objeto) throws CloneNotSupportedException {
+		return auditarObjetoPersonalizado(objeto, AuditadorTipoAlteracao.EXCLUSAO, "Registro excluido");
+	}
+	
+	protected AuditadorObjects auditarCampo(AccessibleObject campo, Object valorOriginal, Object valorNovo, String nomeClasse) throws CloneNotSupportedException {
+		if(isDiferente(valorOriginal, valorNovo)) {
+			String nomeCampo = extrairNomeCampo(campo);
+			AuditadorObjects auditado = padrao.clonar();
+			auditado.setTipoAlteracao(AuditadorTipoAlteracao.ALTERACAO);
+			auditado.setCampoAlterado(nomeCampo);
+			auditado.setValorAnterior(valorOriginal != null ? valorOriginal.toString() : null);
+			auditado.setValorNovo(valorNovo != null ? valorNovo.toString() : null);
+			auditado.setClasseAlterada(nomeClasse);
+			return auditado;
+		}
+		return null;
+	}
+
+	protected String extrairNomeClasse(Object original, Object novo) {
+		if(original != null) {
+			return original.getClass().getSimpleName();
+		}
+		if(novo != null) {
+			return novo.getClass().getSimpleName();
+		}
+		return null;
+	}
+	
+	protected String extrairNomeCampo(AccessibleObject campo) {
+		String nomeCampo = null;
+		if(campo != null) {
+			AuditarID auditarID = extrairAnotacao.extrairAuditarID(campo);
+			if(auditarID != null && StringUtils.isNotBlank(auditarID.nome())) {
+				nomeCampo = auditarID.nome();
+			}
+			AuditarAtributo auditarAtributo = extrairAnotacao.extrairAuditarAtributo(campo);
+			if(auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.nome())) {
+				nomeCampo = auditarAtributo.nome();
+			}
+			AuditarEntidade auditarEntidade = extrairAnotacao.extrairAuditarEntidade(campo);
+			if(auditarEntidade != null && StringUtils.isNotBlank(auditarEntidade.nome())) {
+				nomeCampo = auditarEntidade.nome();
+			}
+			AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo);
+			if(auditarLista != null && StringUtils.isNotBlank(auditarLista.nome())) {
+				nomeCampo = auditarLista.nome();
+			}
+			AuditarMetodo auditarMetodo = extrairAnotacao.extrairAuditarMetodo(campo);
+			if(auditarMetodo != null && StringUtils.isNotBlank(auditarMetodo.nome())) {
+				nomeCampo = auditarMetodo.nome();
+			}
+			
+			if(StringUtils.isBlank(nomeCampo)) {
+				nomeCampo = extrairDeclaredNomeCampo(campo);
+			}
+		}
+		return nomeCampo;
+	}
+
+	protected String extrairDeclaredNomeCampo(AccessibleObject campo) {
+		if(isExtrairDadosAtributo()) {
+			return ((Field) campo).getName();
+		} if(isExtrairDadosMetodo()) {
+			return ((Method) campo).getName();
+		}
+		return null;
+	}
+
+	protected boolean isDiferente(Object valorOriginal, Object valorNovo) {
+		if(valorOriginal == null && valorNovo == null) {
+			return false;
+		}
+		
+		if(valorOriginal != null && valorNovo == null) {
+			return true;
+		}
+		
+		if(valorOriginal == null && valorNovo != null) {
+			return true;
+		}
+		
+		return !valorOriginal.equals(valorNovo);
+	}
+
+	protected List<AuditadorObjects> auditarCampos(Object original, Object novo, String nomeClasse) throws IllegalArgumentException, IllegalAccessException {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		if(!isObjetosNulos(original, novo)) {
+			Class<?> classe = original != null ? original.getClass() : novo.getClass();
+			List<AccessibleObject> camposAuditaveis = extrairCamposAuditaveis(classe);
+			for (AccessibleObject campo : camposAuditaveis) {
+				AuditarEntidade auditarEntidade = extrairAnotacao.extrairAuditarEntidade(campo);
+				AuditarLista auditarLista = extrairAnotacao.extrairAuditarLista(campo);
+				
+				if(auditarEntidade != null) {
+					lsRetorno.addAll(auditadorEntidade.auditar(campo, original, novo, null));
+				} else if(auditarLista != null) {
+					lsRetorno.addAll(auditadorList.auditar(campo, original, novo, auditarLista.auditarEntidades()));
+				} else {
+					lsRetorno.addAll(auditadorAtributo.auditar(campo, original, novo, nomeClasse));
+				}
+			}
+		}
+		return lsRetorno;
+		
+	}
+
+	protected List<AccessibleObject> extrairCamposAuditaveis(Class<?> classe) {
+		List<AccessibleObject> campo = new ArrayList<AccessibleObject>();
+		if(isExtrairDadosAtributo()) {
+			campo = extrairFields(classe);
+		} else if(isExtrairDadosMetodo()) {
+			campo = extrairMethods(classe);
+		}
+		return campo;
+	}
+
+	protected List<AccessibleObject> extrairMethods(Class<?> classe) {
+		List<AccessibleObject> campos = new ArrayList<AccessibleObject>();
+		Method[] methods = classe.getDeclaredMethods();
+		for (Method method : methods) {
+			method.setAccessible(true);
+			
+			NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(method);
+			if(naoAuditar != null) {
+				continue;
+			}
+			
+			if(!method.getReturnType().equals(Void.TYPE) && method.getParameterTypes().length == 0  &&
+			   !isMethodIgnorado(method)) {
+				campos.add(method);
+			}
+		}
+		return campos;
+	}
+
+	private boolean isMethodIgnorado(Method method) {
+		return method.getName().equalsIgnoreCase("clone") ||
+			   method.getName().equalsIgnoreCase("clonar") ||
+			   method.getName().equalsIgnoreCase("getCloneObject") ||
+			   method.getName().equalsIgnoreCase("hashCode") ||
+			   method.getName().equalsIgnoreCase("equals");
+	}
+
+	protected List<AccessibleObject> extrairFields(Class<?> classe) {
+		List<AccessibleObject> campos = new ArrayList<AccessibleObject>();
+		Field[] fields = classe.getDeclaredFields();
+		for (Field field : fields) {
+			field.setAccessible(true);
+			
+			NaoAuditar naoAuditar = extrairAnotacao.extrairNaoAuditar(field);
+			if(naoAuditar != null) {
+				continue;
+			}
+			
+			campos.add(field);
+		}
+		return campos;
+	}
+
+	protected Object getValor(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException {
+		return getValor(campo, object, null);
+	}
+	
+	protected Object getValor(AccessibleObject campo, Object object, String pattern) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException {
+		if(campo == null || object == null) {
+			return null;
+		}
+		Object retorno = extrairValor(campo, object);
+		
+		Object atributo = null;
+		if (retorno instanceof Date) {
+			Date aux = (Date) retorno;
+
+			atributo = getStringDate(aux, pattern);
+		} else if (retorno instanceof Integer || retorno instanceof Long ) {
+			atributo = retorno.toString();
+		} else if (retorno instanceof Number) {
+			atributo = getValorFormatado(retorno.toString());
+		} else if(retorno instanceof String) {
+			atributo = StringUtils.isNotBlank(retorno.toString()) ? retorno.toString() : "nulo";
+		} else {
+			return retorno;
+		}
+		return atributo;
+		
+	}
+	
+	protected String getValorFormatado(String value) throws ParseException {
+		
+		if(value != null && StringUtils.isNotBlank(value)) {
+			NumberFormat nf = NumberFormat.getInstance(new Locale("pt", "br"));
+			BigDecimal valor =  new BigDecimal(nf.parse(value.replace(".", ",")).toString());
+			
+			return nf.format(valor.doubleValue());
+		}
+		
+		return null;
+	}
+	
+	protected String getStringDate(java.util.Date d, String pattern) {
+		if(StringUtils.isBlank(pattern)) {
+			pattern = "dd/MM/yyyy HH:mm";
+		}
+		
+		SimpleDateFormat sdf = new SimpleDateFormat(pattern);
+		if (d != null) {
+			return sdf.format(d);
+		}
+		return null;
+	}	
+	
+	@SuppressWarnings("unchecked")
+	protected List<Object> getValorList(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+		if(campo == null || object == null) {
+			return new ArrayList<Object>();
+		}
+		Object aux = extrairValor(campo, object);
+		
+		List<Object> retorno = new ArrayList<Object>();
+		if(aux != null && aux instanceof Collection) {
+			retorno.addAll((Collection<Object>) aux);
+		}
+		
+		return retorno;
+	}
+
+	protected boolean isObjetosNulos(Object original, Object novo) {
+		return novo == null && original == null;
+	}
+	
+	protected boolean isObjetoNovo(Object original, Object novo) {
+		return novo != null && original == null;
+	}
+
+	protected boolean iniciarObjetoPadrao(Object objeto, AuditadorTipoAlteracao tipoAlteracao) throws IllegalArgumentException, IllegalAccessException, SecurityException, NoSuchFieldException, ParseException, NoSuchMethodException, InvocationTargetException {
+		padrao = null;
+		Class<?> classe = objeto.getClass();
+		AuditarClasse auditarClasse = extrairAnotacao.extrair(classe);
+		if(auditarClasse != null) {
+			tipoExtracaoDados = auditarClasse.tipoExtracaoDados();
+			padrao = new AuditadorObjects();
+			padrao.setTipoAlteracao(tipoAlteracao);
+			padrao.setTela(getNomeTela(auditarClasse, objeto));
+			padrao.setIdAuditado(getIdEntidade(objeto));
+			padrao.setClassePrincipal(StringUtils.isNotBlank(auditarClasse.nome()) ? auditarClasse.nome() : classe.getSimpleName());
+			
+		}
+		return padrao != null;
+	}
+
+	protected String getNomeTela(AuditarClasse auditarClasse, Object objeto) {
+		if(objeto instanceof AuditavelTelaAlternativa) {
+			AuditavelTelaAlternativa aux = (AuditavelTelaAlternativa) objeto;
+			if(aux != null && StringUtils.isNotBlank(aux.getTelaAlternativa())) {
+				return aux.getTelaAlternativa();
+			}
+		}
+		return auditarClasse.tela();
+	}
+
+	protected String getIdEntidade(Object objeto) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException {
+		Object valor = null;
+		Class<?> classe = objeto.getClass();
+		List<AccessibleObject> camposAuditaveis = extrairCamposAuditaveis(classe);
+		for (AccessibleObject campo : camposAuditaveis) {
+			campo.setAccessible(true);
+			AuditarID auditarID = extrairAnotacao.extrairAuditarID(campo);
+			if(auditarID != null) {
+				valor = getValor(campo, objeto, auditarID.pattern());
+			}
+			
+			if(valor == null) {
+				AuditarIDComposta auditarIDComposta = extrairAnotacao.extrairAuditarIDComposta(campo);
+				if(auditarIDComposta != null) {
+					valor = getIdEntidadeComposta(campo, objeto);
+				}
+			}
+			
+		}
+		return valor != null ? valor.toString() : null;
+	}
+
+	protected Object getIdEntidadeComposta(AccessibleObject campo, Object objeto) throws IllegalArgumentException, IllegalAccessException, ParseException, InvocationTargetException {
+		StringBuilder sb = new StringBuilder();
+		if(campo != null && objeto != null) {
+			Object valorID = extrairValor(campo, objeto);
+			if(valorID != null) {
+				Class<?> classe = valorID.getClass();
+				List<AccessibleObject> camposAuditaveis = extrairCamposAuditaveis(classe);
+				for (AccessibleObject campoId : camposAuditaveis) {
+					campoId.setAccessible(true);
+					AuditarID auditarID = extrairAnotacao.extrairAuditarID(campoId);
+					if(auditarID != null) {
+						Object valor = getValor(campoId, valorID, auditarID.pattern());
+						if(valor != null) {
+							if(sb.length() > 0) {
+								sb.append("-");
+							}
+							sb.append(valor.toString());
+						}
+					}
+				}
+			}
+		}
+		return sb.length() > 0 ? sb.toString() : null;
+	}
+
+	protected AuditadorObjects getPadrao() {
+		try {
+			return padrao.clonar();
+		} catch (Exception e) {
+			throw new AuditadorException("Não foi possível clonar o objeto padrão", e);
+		}
+	}
+
+	protected String extrairTextoInclusaoExclusao(Object objeto) {
+		if(objeto instanceof Auditavel) {
+			Auditavel<?> auditavelAux = (Auditavel<?>) objeto;
+			return auditavelAux.getTextoInclusaoExclusao();
+		}
+		return "";
+	}
+	
+	protected Object extrairValor(AccessibleObject campo, Object object) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+		if(isExtrairDadosAtributo()) {
+			return ((Field) campo).get(object);
+		} else if(isExtrairDadosMetodo()) {
+			return ((Method) campo).invoke(object);
+		}
+		return null;
+	}
+	
+	protected boolean isExtrairDadosAtributo() {
+		return TipoExtracaoDados.ATRIBUTO.equals(tipoExtracaoDados);
+	}
+	
+	protected boolean isExtrairDadosMetodo() {
+		return TipoExtracaoDados.METODO.equals(tipoExtracaoDados);
+	}
+
+	protected String extrairPattern(AccessibleObject campoEntidade) {
+		String pattern = null;
+		if(isExtrairDadosAtributo()) {
+			AuditarAtributo auditarAtributo =  extrairAnotacao.extrairAuditarAtributo(campoEntidade);
+			if(auditarAtributo != null) {
+				pattern = auditarAtributo.pattern();
+			}
+		} else if(isExtrairDadosMetodo()) {
+			AuditarMetodo auditarMetodo =  extrairAnotacao.extrairAuditarMetodo(campoEntidade);
+			if(auditarMetodo != null) {
+				pattern = auditarMetodo.pattern();
+			}
+		}
+		return pattern;
+	}
+	
+	protected AccessibleObject extrairAccessibleObject(Object objeto, String nome) throws SecurityException, NoSuchFieldException, NoSuchMethodException {
+		if(objeto != null && StringUtils.isNotBlank(nome)) {
+			Class<?> classe = objeto.getClass();
+			if(isExtrairDadosAtributo()) {
+				Field field = classe.getDeclaredField(nome);
+				return field;
+			} else if(isExtrairDadosMetodo()) {
+				Method method = classe.getDeclaredMethod(nome);
+				return method;
+			}
+			
+		}
+		return null;
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorAtributo.java

@@ -0,0 +1,42 @@
+package br.com.rjconsultores.auditador.auditadores;
+
+import java.lang.reflect.AccessibleObject;
+import java.util.ArrayList;
+import java.util.List;
+
+import br.com.rjconsultores.auditador.exceptions.AuditadorException;
+import br.com.rjconsultores.auditador.model.AuditadorObjects;
+
+class AuditadorAtributo {
+	
+	protected Auditador auditador;
+
+	public AuditadorAtributo(Auditador auditar) {
+		super();
+		this.auditador = auditar;
+	}
+	
+	public List<AuditadorObjects> auditar(AccessibleObject campo, Object original, Object novo, String nomeClasse) {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		try {
+			
+			if(!auditador.isObjetosNulos(original, novo)) {
+				String pattern = auditador.extrairPattern(campo);
+				
+				Object valorOriginal = auditador.getValor(campo, original, pattern);
+				Object valorNovo = auditador.getValor(campo, novo, pattern);
+				AuditadorObjects auditado = auditador.auditarCampo(campo, valorOriginal, valorNovo, nomeClasse);
+				if(auditado != null) {
+					lsRetorno.add(auditado);
+				}
+			}
+			
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+		return lsRetorno;
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorEntidade.java

@@ -0,0 +1,76 @@
+package br.com.rjconsultores.auditador.auditadores;
+
+import java.lang.reflect.AccessibleObject;
+import java.util.ArrayList;
+import java.util.List;
+
+import br.com.rjconsultores.auditador.exceptions.AuditadorException;
+import br.com.rjconsultores.auditador.model.AuditadorObjects;
+
+class AuditadorEntidade {
+
+	protected Auditador auditador;
+
+	public AuditadorEntidade(Auditador auditar) {
+		super();
+		this.auditador = auditar;
+	}
+	
+	public List<AuditadorObjects> auditar(AccessibleObject campo, Object original, Object novo, String nomeClasse) {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		try {
+			Object valorOriginal = campo != null && original != null ? auditador.extrairValor(campo, original) : original;
+			Object valorNovo = campo != null && novo != null ? auditador.extrairValor(campo, novo) : novo;
+			
+			String localNomeClasse = nomeClasse != null ? nomeClasse : auditador.extrairNomeClasse(valorOriginal, valorNovo);
+			
+			AuditadorObjects objectNovo = auditador.auditarObjetoNovo(campo, valorOriginal, valorNovo);
+			if(objectNovo != null) {
+				lsRetorno.add(objectNovo);
+				return lsRetorno;
+			}
+			
+			if(!auditador.isObjetosNulos(valorOriginal, valorNovo)) {
+				Class<?> classe = valorOriginal != null ? valorOriginal.getClass() : valorNovo.getClass();
+				List<AccessibleObject> camposAuditaveis = auditador.extrairCamposAuditaveis(classe);
+				for (AccessibleObject campoEntidade : camposAuditaveis) {
+					String pattern = auditador.extrairPattern(campoEntidade);
+				
+					Object valorOriginalEntidade = auditador.getValor(campoEntidade, valorOriginal, pattern);
+					Object valorNovoEntidade = auditador.getValor(campoEntidade, valorNovo, pattern);
+					
+					AuditadorObjects auditado = auditador.auditarCampo(campoEntidade, valorOriginalEntidade, valorNovoEntidade, localNomeClasse);
+					if(auditado != null) {
+						lsRetorno.add(auditado);
+					}					
+				}
+//				Field[] campos = classe.getDeclaredFields();
+//				for (Field campoEntidade : campos) {
+//					campoEntidade.setAccessible(true);
+//					
+//					NaoAuditar naoAuditar = auditador.extrairAnotacao.extrairNaoAuditar(campoEntidade);
+//					if(naoAuditar != null) {
+//						continue;
+//					}				
+//					
+//					AuditarAtributo auditarAtributo =  auditador.extrairAnotacao.extrairAuditarAtributo(campoEntidade);
+//					String pattern = auditarAtributo != null && StringUtils.isNotBlank(auditarAtributo.pattern()) ? auditarAtributo.pattern() : null;
+//				
+//					Object valorOriginalEntidade = auditador.getValor(campoEntidade, valorOriginal, pattern);
+//					Object valorNovoEntidade = auditador.getValor(campoEntidade, valorNovo, pattern);
+//					
+//					AuditadorObjects auditado = auditador.auditarCampo(campoEntidade, valorOriginalEntidade, valorNovoEntidade, localNomeClasse);
+//					if(auditado != null) {
+//						lsRetorno.add(auditado);
+//					}
+//				}
+			}
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+		return lsRetorno;
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/auditadores/AuditadorList.java

@@ -0,0 +1,131 @@
+package br.com.rjconsultores.auditador.auditadores;
+
+import java.lang.reflect.AccessibleObject;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao;
+import br.com.rjconsultores.auditador.exceptions.AuditadorException;
+import br.com.rjconsultores.auditador.model.AuditadorObjects;
+
+class AuditadorList {
+
+	protected Auditador auditador;
+
+	public AuditadorList(Auditador auditar) {
+		super();
+		this.auditador = auditar;
+	}
+	
+	public List<AuditadorObjects> auditar(AccessibleObject campo, Object original, Object novo, boolean auditarEntidades) {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		try {
+			
+			List<Object> lsOriginal = auditador.getValorList(campo, original);
+			List<Object> lsNovo = auditador.getValorList(campo, novo);
+			
+			lsRetorno.addAll(auditarList(campo, auditarEntidades, lsOriginal, lsNovo));
+		} catch (Exception e) {
+			throw new AuditadorException(e.getMessage(), e);
+		} catch (Throwable e) {
+			throw new AuditadorException(e.getMessage(), e);
+		}
+		return lsRetorno;
+	}
+
+	public List<AuditadorObjects> auditarList(AccessibleObject campo, boolean auditarEntidades,
+			List<Object> lsOriginal, List<Object> lsNovo) throws CloneNotSupportedException {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		
+		List<Object> lsObjetosInseridos = new ArrayList<Object>(0);
+		List<Object> lsObjetosRemovidos = new ArrayList<Object>(0);
+		List<Object> lsObjetosMantidos = new ArrayList<Object>(0);
+		
+		if(lsNovo != null) {
+			lsObjetosInseridos.addAll(lsNovo);
+			if(lsOriginal != null) {
+				lsObjetosInseridos.removeAll(lsOriginal);
+			}
+			lsRetorno.addAll(auditarRegistros(campo, lsObjetosInseridos, true));
+			
+			if(auditarEntidades) {
+				lsObjetosMantidos.addAll(lsNovo);
+			}
+		}
+		
+		if(lsOriginal != null) {
+			lsObjetosRemovidos.addAll(lsOriginal);
+			if(lsNovo != null) {
+				lsObjetosRemovidos.removeAll(lsNovo);
+			}
+			lsRetorno.addAll(auditarRegistros(campo, lsObjetosRemovidos, false));
+			
+			if(auditarEntidades) {
+				lsObjetosMantidos.retainAll(lsOriginal);
+			}
+		}
+		
+		if(auditarEntidades) {
+			for (Object object : lsObjetosMantidos) {
+				Object originalEntidade = lsOriginal.get(lsOriginal.indexOf(object));
+				Object novoEntidade = lsNovo.get(lsNovo.indexOf(object));
+				String nomeClasse = auditador.extrairNomeClasse(originalEntidade, novoEntidade);
+				
+				lsRetorno.addAll(auditador.auditadorEntidade.auditar(null, originalEntidade, novoEntidade, nomeClasse));
+			}
+		}
+		return lsRetorno;
+	}
+
+	protected List<AuditadorObjects> auditarRegistros(AccessibleObject campo, List<Object> lsObjetosRemovidos, boolean inserido)
+			throws CloneNotSupportedException {
+		List<AuditadorObjects> lsRetorno = new ArrayList<AuditadorObjects>();
+		String nomeCampo = auditador.extrairNomeCampo(campo);
+		for (Object removido : lsObjetosRemovidos) {
+			AuditadorObjects objectInserido = null;
+
+			if(inserido) {
+				objectInserido = auditarObjetoInserido(nomeCampo, removido);
+			} else {
+				objectInserido = auditarObjetoRemovido(nomeCampo, removido);
+			}
+			
+			if(objectInserido != null) {
+				lsRetorno.add(objectInserido);
+			}
+		}
+		return lsRetorno;
+	}
+
+	protected boolean isObjetosList(Object objeto) {
+		return objeto != null && objeto instanceof Collection;
+	}
+	
+	protected AuditadorObjects auditarObjetoInserido(String nomeCampo, Object objeto) throws CloneNotSupportedException {
+		if(objeto != null) {
+			AuditadorObjects auditado = criarObjetoInseridoRemovido(nomeCampo, objeto);
+			auditado.setValorNovo(String.format("Registro inserido [%s]", auditador.extrairTextoInclusaoExclusao(objeto)));
+			return auditado;
+		}
+		return null;
+	}
+	
+	private AuditadorObjects criarObjetoInseridoRemovido(String nomeCampo, Object objeto) throws CloneNotSupportedException {
+		AuditadorObjects auditado = auditador.getPadrao().clonar();
+		auditado.setTipoAlteracao(AuditadorTipoAlteracao.ALTERACAO);
+		auditado.setCampoAlterado(nomeCampo);
+		auditado.setClasseAlterada(objeto.getClass().getSimpleName());
+		return auditado;
+	}
+	
+	protected AuditadorObjects auditarObjetoRemovido(String nomeCampo, Object objeto) throws CloneNotSupportedException {
+		if(objeto != null) {
+			AuditadorObjects auditado = criarObjetoInseridoRemovido(nomeCampo, objeto);
+			auditado.setValorNovo(String.format("Registro removido [%s]", auditador.extrairTextoInclusaoExclusao(objeto)));
+			return auditado;
+		}
+		return null;
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/auditadores/ExtrairAnotacao.java

@@ -0,0 +1,79 @@
+package br.com.rjconsultores.auditador.auditadores;
+
+import java.lang.reflect.AccessibleObject;
+
+import br.com.rjconsultores.auditador.annotations.AuditarAtributo;
+import br.com.rjconsultores.auditador.annotations.AuditarClasse;
+import br.com.rjconsultores.auditador.annotations.AuditarEntidade;
+import br.com.rjconsultores.auditador.annotations.AuditarID;
+import br.com.rjconsultores.auditador.annotations.AuditarIDComposta;
+import br.com.rjconsultores.auditador.annotations.AuditarLista;
+import br.com.rjconsultores.auditador.annotations.AuditarMetodo;
+import br.com.rjconsultores.auditador.annotations.NaoAuditar;
+
+class ExtrairAnotacao {
+	
+	protected AuditarClasse extrair(Class<?> classe) {
+		if(classe == null) {
+			return null;
+		}
+		return classe.getAnnotation(AuditarClasse.class);		
+	}
+	
+	protected AuditarAtributo extrairAuditarAtributo(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(AuditarAtributo.class);
+	}
+	
+	protected AuditarEntidade extrairAuditarEntidade(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(AuditarEntidade.class);
+	}
+	
+	protected AuditarID extrairAuditarID(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(AuditarID.class);
+	}
+	
+	protected AuditarIDComposta extrairAuditarIDComposta(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(AuditarIDComposta.class);
+	}
+	
+	protected AuditarLista extrairAuditarLista(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(AuditarLista.class);
+	}
+	
+	protected NaoAuditar extrairNaoAuditar(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(NaoAuditar.class);
+	}
+	
+	protected AuditarMetodo extrairAuditarMetodo(AccessibleObject campo) {
+		if(campo == null) {
+			return null;
+		}
+		campo.setAccessible(true);
+		return campo.getAnnotation(AuditarMetodo.class);
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/enums/AuditadorTipoAlteracao.java

@@ -0,0 +1,16 @@
+package br.com.rjconsultores.auditador.enums;
+
+import java.util.Arrays;
+import java.util.List;
+
+public enum AuditadorTipoAlteracao {
+	
+	INCLUSAO,
+	ALTERACAO,
+	EXCLUSAO;
+	
+	public static List<AuditadorTipoAlteracao> getList() {
+		return Arrays.asList(values());
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/enums/TipoExtracaoDados.java

@@ -0,0 +1,8 @@
+package br.com.rjconsultores.auditador.enums;
+
+public enum TipoExtracaoDados {
+	
+	ATRIBUTO,
+	METODO;
+
+}

src/main/java/br/com/rjconsultores/auditador/exceptions/AuditadorException.java

@@ -0,0 +1,11 @@
+package br.com.rjconsultores.auditador.exceptions;
+
+public class AuditadorException extends RuntimeException {
+
+	private static final long serialVersionUID = 1L;
+	
+	public AuditadorException(String message, Throwable throwable) {
+		super(message, throwable);
+	}
+
+}

src/main/java/br/com/rjconsultores/auditador/interfaces/Auditavel.java

@@ -0,0 +1,33 @@
+package br.com.rjconsultores.auditador.interfaces;
+
+/**
+ * Interface que deverá ser implementada quando o objeto for auditado, interface estende a interface Cloneable.
+ * 
+ * @author wilian
+ *
+ * @param <T>
+ */
+public interface Auditavel<T> extends Cloneable {
+	
+	/**
+	 * Método deverá ser implementado com o recurso de clonagem da Interface Cloneable. Executa o processo de clonagem do objeto para ser comparado com o alterado, executar esse método logo após recuperar o objeto do banco de dados.
+	 *  
+	 * @throws CloneNotSupportedException
+	 */
+	public void clonar() throws CloneNotSupportedException;
+	
+	/**
+	 * Após executar o método "clonar" retorna o objeto clonado.
+	 * 
+	 * @return
+	 * @throws CloneNotSupportedException
+	 */
+	public T getCloneObject() throws CloneNotSupportedException;
+	
+	/**
+	 * Método que descreve informações do objeto quando o registro é criado/incluído/excluído.
+	 * @return
+	 */
+	public String getTextoInclusaoExclusao();
+	
+}

src/main/java/br/com/rjconsultores/auditador/interfaces/AuditavelTelaAlternativa.java

@@ -0,0 +1,18 @@
+package br.com.rjconsultores.auditador.interfaces;
+
+/**
+ * Interface que permite informar uma tela alternativa para auditoria do objeto quando o mesmo é alterado em telas diferentes.
+ * 
+ * @author wilian
+ *
+ */
+public interface AuditavelTelaAlternativa {
+	
+	/**
+	 * Quando o objeto auditado implementar a interface, o valor do retorno desse método será priorizado.
+	 * 
+	 * @return
+	 */
+	public String getTelaAlternativa();
+
+}

src/main/java/br/com/rjconsultores/auditador/model/AuditadorObjects.java

@@ -0,0 +1,97 @@
+package br.com.rjconsultores.auditador.model;
+
+import br.com.rjconsultores.auditador.enums.AuditadorTipoAlteracao;
+
+public class AuditadorObjects implements Cloneable {
+
+	private String valorAnterior;
+	private String valorNovo;
+	private String campoAlterado;
+	private String classeAlterada;
+	private String classePrincipal;
+	private String tela;
+	private AuditadorTipoAlteracao tipoAlteracao;
+	private String idAuditado;
+
+	public String getValorAnterior() {
+		return valorAnterior;
+	}
+
+	public void setValorAnterior(String valorAnterior) {
+		this.valorAnterior = valorAnterior;
+	}
+
+	public String getValorNovo() {
+		return valorNovo;
+	}
+
+	public void setValorNovo(String valorNovo) {
+		this.valorNovo = valorNovo;
+	}
+
+	public String getCampoAlterado() {
+		return campoAlterado;
+	}
+
+	public void setCampoAlterado(String campoAlterado) {
+		this.campoAlterado = campoAlterado;
+	}
+
+	public String getClasseAlterada() {
+		return classeAlterada;
+	}
+
+	public void setClasseAlterada(String classeAlterada) {
+		this.classeAlterada = classeAlterada;
+	}
+
+	public String getClassePrincipal() {
+		return classePrincipal;
+	}
+
+	public void setClassePrincipal(String classePrincipal) {
+		this.classePrincipal = classePrincipal;
+	}
+
+	public String getTela() {
+		return tela;
+	}
+
+	public void setTela(String tela) {
+		this.tela = tela;
+	}
+
+	public AuditadorTipoAlteracao getTipoAlteracao() {
+		return tipoAlteracao;
+	}
+
+	public void setTipoAlteracao(AuditadorTipoAlteracao tipoAlteracao) {
+		this.tipoAlteracao = tipoAlteracao;
+	}
+
+	public String getIdAuditado() {
+		return idAuditado;
+	}
+
+	public void setIdAuditado(String idAuditado) {
+		this.idAuditado = idAuditado;
+	}
+
+	@Override
+	protected Object clone() throws CloneNotSupportedException {
+		return super.clone();
+	}
+	
+	public AuditadorObjects clonar() throws CloneNotSupportedException {
+		return (AuditadorObjects) this.clone();
+	}
+
+	@Override
+	public String toString() {
+		return "AuditadorObjects [valorAnterior=" + valorAnterior + ", valorNovo=" + valorNovo + ", campoAlterado="
+				+ campoAlterado + ", classeAlterada=" + classeAlterada + ", classePrincipal=" + classePrincipal
+				+ ", tela=" + tela + ", tipoAlteracao=" + tipoAlteracao + ", idAuditado="
+				+ idAuditado + "]";
+	}
+
+}

target/classes/META-INF/MANIFEST.MF

@@ -0,0 +1,5 @@
+Manifest-Version: 1.0
+Built-By: Fabio
+Build-Jdk: 11.0.11
+Created-By: Maven Integration for Eclipse
+

target/classes/META-INF/maven/br.com.rjconsultores/Auditador/pom.properties

@@ -0,0 +1,7 @@
+#Generated by Maven Integration for Eclipse
+#Fri Nov 26 15:44:47 GMT-03:00 2021
+m2e.projectLocation=E\:\\Desenvolvimento\\rjconsultores\\Auditador
+m2e.projectName=Auditador
+groupId=br.com.rjconsultores
+artifactId=Auditador
+version=0.0.1-SNAPSHOT

target/classes/META-INF/maven/br.com.rjconsultores/Auditador/pom.xml

@@ -0,0 +1,32 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>br.com.rjconsultores</groupId>
+	<artifactId>Auditador</artifactId>
+	<version>0.0.1-SNAPSHOT</version>
+	
+	<build>
+		<sourceDirectory>src/main/java</sourceDirectory>
+		<testSourceDirectory>src/test/java</testSourceDirectory>
+		<plugins>
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<version>3.3</version>
+				<configuration>
+					<source>1.6</source>
+					<target>1.6</target>
+				</configuration>
+			</plugin>
+		</plugins>
+		<finalName>${project.artifactId}</finalName>
+	</build>
+	
+	<dependencies>
+		<dependency>
+			<groupId>commons-lang</groupId>
+			<artifactId>commons-lang</artifactId>
+			<version>2.2</version>
+		</dependency>
+	</dependencies>	
+</project>

target/maven-archiver/pom.properties

@@ -0,0 +1,5 @@
+#Generated by Maven
+#Sat Jun 26 12:48:31 GMT-03:00 2021
+version=0.0.1-SNAPSHOT
+groupId=br.com.rjconsultores
+artifactId=Auditador

target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

@@ -0,0 +1,19 @@
+br\com\rjconsultores\auditador\auditadores\AuditadorAtributo.class
+br\com\rjconsultores\auditador\enums\AuditadorTipoAlteracao.class
+br\com\rjconsultores\auditador\annotations\AuditarEntidade.class
+br\com\rjconsultores\auditador\auditadores\Auditador.class
+br\com\rjconsultores\auditador\annotations\AuditarLista.class
+br\com\rjconsultores\auditador\annotations\AuditarMetodo.class
+br\com\rjconsultores\auditador\auditadores\AuditadorList.class
+br\com\rjconsultores\auditador\exceptions\AuditadorException.class
+br\com\rjconsultores\auditador\annotations\AuditarAtributo.class
+br\com\rjconsultores\auditador\auditadores\AuditadorEntidade.class
+br\com\rjconsultores\auditador\interfaces\AuditavelTelaAlternativa.class
+br\com\rjconsultores\auditador\interfaces\Auditavel.class
+br\com\rjconsultores\auditador\annotations\AuditarID.class
+br\com\rjconsultores\auditador\enums\TipoExtracaoDados.class
+br\com\rjconsultores\auditador\auditadores\ExtrairAnotacao.class
+br\com\rjconsultores\auditador\annotations\AuditarClasse.class
+br\com\rjconsultores\auditador\annotations\AuditarIDComposta.class
+br\com\rjconsultores\auditador\annotations\NaoAuditar.class
+br\com\rjconsultores\auditador\model\AuditadorObjects.class

target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

@@ -0,0 +1,19 @@
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\model\AuditadorObjects.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarEntidade.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\auditadores\Auditador.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\enums\TipoExtracaoDados.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarIDComposta.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarLista.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\auditadores\AuditadorEntidade.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\enums\AuditadorTipoAlteracao.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\auditadores\AuditadorAtributo.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarAtributo.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\interfaces\AuditavelTelaAlternativa.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\NaoAuditar.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\auditadores\ExtrairAnotacao.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\auditadores\AuditadorList.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\exceptions\AuditadorException.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarID.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarClasse.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\annotations\AuditarMetodo.java
+E:\Desenvolvimento\rjconsultores\Auditador\src\main\java\br\com\rjconsultores\auditador\interfaces\Auditavel.java