Vivendo e Aprendendo

Experiência prática na administração de Banco de Dados

Indo um pouco além …

by Gilberto C. Andrade on 23 Março 2009

Tagged as: Java,

Estou aprendendo um pouco sobre programação orientada a objeto em java e com o pouco que li resolvi implementar uma pequena api que abstrai as regras de acesso e recuperação de dados − acesso a banco de dados. Gosto muito dessa (OrBroker) api de persistência com isso elaborei um contrato que acho o mínimo necessário para o acesso a dados, o qual poderá utilizar a api OrBroker - espero não somente essa api, mas outras (desacoplamento).

IService: Interface (contrato) geral para uso com o mescanimo de persistência OrBroker. Estabelece assinaturas de métodos essenciais para operações de acesso a banco de dados.
Assinaturas:

   public Collection<T> getAll();
   public boolean find(T entity);
   public void insert(T entity);
   public void update(T entity);
   public void delete(T entity);
   public Collection<T> findByNamedQuery(String queryName);
   public Collection<T> findLike(String likeColumn, String likeValue);

Vocês podem notar o uso do inglês para nomear classes, metodos e até atributos. Acho isso um vício ou uma maneira de reduzir os nomes, pois em português ficam enormes. Outra coisa, alguns podem comentar que o nome certo seria sufixar ou prefixar tal interface com o termo DAO, para expressar um padrão de projeto muito conhecido e utilizado para, também, abstrair essas atividades de banco de dados. Acontece que essa minha pequena implementação não exigirá tamanha desacoplagem e acho também que um programa que grava e ler dados, não faz somente isso, faz isso e um pouco mais - regras de negócio. Assim, optei por, inicialmente, colocar as assinaturas necessárias ao acesso a dados e deixar para uma outra interface acrescentar as assinaturas de contrato específicas:

public interface ICategoriaService extends IService<categoria, integer> {
	public Categoria find(Integer primaryKey);
	public void Classificar();
	}

Na implementação ocorre um fato interessante quando a entidade sendo trabalhada não exigir contratos além dos já fornecidos. Notei essa característica quando da implementação dos métodos por uma classe a ser utilizada como base de implementação, ou seja, as classes mais específicas − a exemplo da ICategoriaService − herdarão dessa classe base e implementarão seus contratos específicos. Um exemplo de uso dessa classe base:

public class CategoriaBaseServiceTest {
	private BaseService<categoria, integer> cS = new BaseService<categoria,integer>(Categoria.class,Constants.ORBROKER_INVENTARIO);	
	
	@Test
	public void testGetAll() {
	Collection<categoria> result = cS.getAll();
		System.out.println(result);
		assertFalse(result.isEmpty());
	}
}

Então ficou da seguinte maneira essa pequena api:
</>

Interface	Implementação
IService ----------> BaseService
:                     :
:                     :
ICategoriaService -> CategoriaService	
comments powered by Disqus