Normalização de Banco de Dados

A aplicação da normalização pode evitar alguns  problemas no banco de dados, tais como:

• grupos repetitivos de dados;
• redundâncias de dados desnecessárias;
• perdas acidentais de informação;
• dificuldade na representação de fatos da realidade observada;

A normalização de banco de dados  é uma técnica que permite evitar  inconsistências no banco como por exemplo informações com duplicidade, dependências funcionais mal resolvidas, etc.

(1FN) Primeira Forma Normal: tabelas sem grupos de repetição.

1º Problema: redundância e inconsistência

2º Problema: aumento desnecessário do volume de dados.

Exemplo: Tem-se uma tabela cliente no qual temos os campos id, nome e cidade.

Pode-se perceber que existem repetições nas cidades, a cidade de São Paulo por exemplo está escrito de duas formas diferentes, mas fazem referência à mesma cidade, o mesmo acontece com a cidade de Belo Horizonte, ou seja, numa pesquisa por clientes da cidade de São Paulo por exemplo, tem-se como resultado neste caso apenas um cliente, quando na verdade existem dois cliente desta cidade.

Pode-se resolver isto da seguinte maneira:

Criamos uma tabela cidade e a tabela cliente tera uma chave estrangeira da tabela cidade:

Tabela cidade:

Neste caso, ainda fizemos uma tabela para o estado usando a mesma norma:

OBS: Para que na tabela cidade não exsita duas cidades com o mesmo nome em um mesmo estado, é necessário que se faça uma Unique Key para o nome e o id_uf

(2FN) Segunda Forma Normal: Quando PK composta, cada atributo que não for PK deve depender de todas as chaves:

Por exemplo uma tabela pedido, cujo a chave  primária composta  é formado pelo id do cliente e o id do produto:

Veja que temos também uma atributo cor, porém este campo faz referência apenas ao produto, então de acordo com norma a tabela mostrada acima está incorreta, o atributo cor deve estar na tabela produto e não na tabela pedido:

(3FN) Terceira Forma Normal: Todos os campos que não forem PK devem sempre depender da chave primária, é o mesmo que 2FN, porém esta faz referencia à chave primária simples.

Por exemplo uma tabela funcionário:

Na tabela acima nos temos o id do funcionário, o nome do funcionário, a sua categoria e o piso salarial da categoria do funcionário, perceba que o piso salarial faz referência a categoria e não ao funcionário, então de acordo com a 3FN o correto seria o seguinte:

Fazemos uma tabela categoria e nesta sim colocamos o piso salarial, pois este faz referência à categoria, e na tabela funcionário coloca-se uma chave estrangeira referenciando a tabela categoria!

Referência: Aula de Banco de Dados – Univás – Profº: Artur

Injeção de Dependência com Spring

Injeção de dependência nada mais é que quando um componente não instancia suas dependências mas sim o ambiente as fornece automaticamente. Vamos demonstrar isso com e sem o Spring:

Primeiro temos uma classe Monitor que será usada para interação com o usuário. Ela apenas escreve uma mensagem no console:

public class Monitor {

	public void exibeMensagem(String mensagem) {
		//Exibe mesagens para o usuário

		System.out.println("[MONITOR]" + mensagem);
	}
}

Agora teremos uma classe Teclado que será usada para ler algo que o usuario digitar:

public class Teclado {

	public String ler() {
		//Lè texto do usuário

		String texto = null;
		System.out.println("[TECLADO]>");
		try {
			texto = new BufferedReader(
new InputStreamReader(System.in)).readLine();
		} catch (IOException e) {
			System.out.println("Erro lendo teclado");
			e.printStackTrace();
		}
		return texto;
	}
}

Depois teremos a classe Impressora que apenas imprime o texto que a classe Teclado leu.

public class Impressora {

	public void imprimirTexto(String texto) {
		//Nossa impressora apenas escreve na tela
		//o texto digitado pelo usuario

		System.out.println("[IMPRESSORA]" + texto);
	}
}

E agora iremos montar o computador!!! Nesta classe temos referencias de todas as classe que compoe o computador, a classe Teclado, Monitor e Teclado. Perceba que não iremos instanciar nenhuma das dependências aqui.

Não podemos esquecer os metodos setter, pois é ele será usado para injetar as dependências tanto com o Spring quanto sem ele. Esta classe possui també, um método para ligarmos o nosso computador, que chamará o monitor para exibir uma mensagem ao usuário, o teclado para ler a mensagem e a impressora para imprimir:

public class Computador{

	private Teclado _teclado = null;
	private Monitor _monitor = null;
	private Impressora _impressora = null;

	public void setImpressora(Impressora impressora){
		_impressora = impressora;
	}

	public void setMonitor(Monitor monitor){
		_monitor = monitor;
	}

	public void setTeclado(Teclado teclado){
		_teclado = teclado;
	}

	public void ligar(){
		_monitor.exibeMensagem("Digite texo para impressão:");
		String texto = _teclado.ler();
		_impressora.imprimirTexto(texto);
		_monitor.exibeMensagem("Texto impresso!");
	}
}

Primeiro vamos criar uma classe para inicializar nossas depêndencias. Veja que criamos um objeto computador e configuramos cada dependência e depois ligamos o computador.

public class IniciaComputadorSemSpring {

	public static void main(String[] args) {

		Computador computador = new Computador();
		computador.setImpressora(new Impressora());
		computador.setTeclado(new Teclado());
		computador.setMonitor(new Monitor());
		computador.ligar();
	}
}

Agora iremos fazer o mesmo trabalho acima usando o Spring:

cria-se então o arquivo applicationContext.xml, este arquivo deve ficar no src do seu projeto. Cria-se um bean para a classe computador e passamos como propriedade para ele três outros beans que referenciam cada um respectivamente as classes Impressora, Teclado e Monitor.

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

	<bean id="computadorBean" class="teste.computador.Computador">
<property name="impressora" ref="impressoraBean" />
<property name="teclado" ref="tecladoBean" />
<property name="monitor" ref="monitorBean" />
	</bean>

	<bean id="impressoraBean" class="teste.computador.Impressora" />

	<bean id="tecladoBean" class="teste.computador.Teclado" />

	<bean id="monitorBean" class="teste.computador.Monitor" />

</beans>

Agora criaremos a classe com outro método main para a inicialização com o Spring, aqui carregamos nosso applicationContext.xml e criamos um objeto Computador inicializando-o com o computadorBean declarado no applicationContext.xml

<pre>public class IniciaUsandoSpring {

	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
		Computador computador = (Computador) applicationContext.getBean("computadorBean");
		computador.ligar();
	}
}

Referência Bibliográfica:  Apostila Spring – Phillip Calçado “Shoes”