Framework de injeção de dependência revolucionário! Confiram!

Você deve estar se perguntando pow!!! Uma versão novo do spring, nem tava sabendo, mas num é nada disso, esta aqui hoje de bobeira em casa, aproveitando feriado prolongado e pensei! Vou construir um framework, primeiro pensei, construir um concorrente do hibernate, quem sabe domino o mundo com isso! Mas só de pensar no trabalho já me cansei, não ia conseguir concluir hoje!!! Ai pensei, injeção de dependência é legal, ta na moda, os programadores não querem mais manter o forte acoplamento!! Então vamos lá, vejam como usar.

import br.com.frameork.annotations.Dependencia;

/**
 * 
 * Computador um objeto que contem varios acoplamentos!
 * porem os computadores no mundo real seus acoplamentos
 * são plugaveis
 * 
 * para injetar a dependencia em um acoplamento é somente usar
 * a annotação @Dependencia
 *
 */
public class Computador {
	
	@Dependencia
	private Mouse mouse;

	@Dependencia
	private Teclado teclado;
	
	public void setMouse(Mouse mouse) {
		this.mouse = mouse;
	}

	public Mouse getMouse() {
		return mouse;
	}
	
	public void ligar() {
		System.out.println("opa! Iniciando o computador!!!");
		getMouse().testar();
		getTeclado().testar();
	}

	public void setTeclado(Teclado teclado) {
		this.teclado = teclado;
	}

	public Teclado getTeclado() {
		return teclado;
	}
	
}

Classes dos acoplamentos

public class Mouse {

	protected void testar() {
		System.out.println("mouse funfando!!!");
	}

}


public class Teclado {
	
	protected void testar() {
		System.out.println("teclado funfando!!!");
	}
	
}

Agora vamos ligar o computador!!! rsrsrs

 public static void main(String[] args) {
		Computador computador = (Computador)Injetar.dependencias(Computador.class);
		computador.ligar();
 }

Saida no console: Bazinga!!! Sem NullPointException e sem acoplamento direto

opa! Iniciando o computador!!!
mouse funfando!!!
teclado funfando!!!

Onde está a revolução? hehehe

To zuando cara… é bacana sim… mostra que vc tá entendendo da bagaça… eheheh

Na próxima versão… faça assim… (desafio)

Em alguma classe, coloque um método com um @StartApplication

Só pode haver 1 único método na aplicação com essa anotation…

Aí no seu main… vc faz apenas:

Injection.start();

O framework realiza a injeção de dependencia… e chama o método com o @StartApplication

pow mano que massa!! vou fazer sim e posto pra galera ver!! é trankilo fazer isso!! Mas me tira uma duvida outros frameworks fazem isso que você sugerio???

Fazem… ehehhe

Na minha assinatura… tem um por exemplo…

kkkk Que massa nem tinha visto!! Dei uma olhada no site do teu framework!! parabems exelente iniciativa! Essa ideia do framework é só zueira, não tenho tempo de me dedicar nesses projetos,porem quando puder vou ajudar em algum projeto opem!!.., Hoje que estava de bobeira e comecei a estudar um pouco sobre spring a ler algumas coisa a baixei uma apostila, acho que ela estava meio desatualizada, porque usava xml ao inves de annotations!! Ae resolvi brincar e fazer a injeção de uma forma menos complicada… hehehe é isso ae, parabems pelo projeto

:lol:

Heheh… mas começa é assim mesmo… tá no caminho!

Salve galera! Como hoje estava de bobeira fiz uma nova implementação no Framework “Ainda não tem nome alguem sugere algum???”! Sugestão de rogelgarcia: [quote]
Na próxima versão… faça assim… (desafio)

Em alguma classe, coloque um método com um @StartApplication

Só pode haver 1 único método na aplicação com essa anotation…

Aí no seu main… vc faz apenas:

Injection.start();
[/quote]

Pessoal olhem como ficou a versão 0.0.0.0.0.0.0.0.0.0,1.

package br.tete.classe;

public class Mouse {
	
	public void testar() {
		System.out.println("Algum tipo de mouse");
	}
	
}
package br.tete.classe;

import br.com.etex.annotations.Dependencia;

/**
 * 
 * Computador um objeto que contem varios acoplamentos!
 * porem os computadores no mundo real seus acoplamentos
 * são plugaveis
 * 
 * para injetar a dependencia em um acoplamento é somente usar
 * a annotação @Dependencia
 *
 */
public class Computador {
	
	
	private Mouse mouse;

	@Dependencia
	public void setMouse(Mouse mouse) {
		this.mouse = mouse;
	}
	
	public Mouse getMouse() {
		return mouse;
	}
	
	public void testar() {
		System.out.println("ligar computador");
		getMouse().testar();
	}
}

Vamos ao Main

package br.main;

import br.com.etex.Injetar;
import br.tete.classe.Computador;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		Injetar injetar = new Injetar(Computador.class);
		Computador computador = (Computador)injetar.getDependencias();
		computador.testar();
		
	}

}

Como esse é um super framework, podemos trabalhar com tipos polimórficos… olhem só

package br.tete.classe;

public class MouseOptico extends Mouse {
	
	@Override
	public void testar() {
		System.out.println("opa! Esse mouse é de luzinha");
	}
	
}
package br.tete.classe;

import br.com.etex.annotations.Dependencia;

public class Computador {
	
	
	private Mouse mouse;

	/**
	 * olhem só que maravilha!! em nosso computador
	 * podemos plugar um mouse optico tambem
	 * @param mouse
	 */
	@Dependencia(classe=MouseOptico.class)
	public void setMouse(Mouse mouse) {
		this.mouse = mouse;
	}
	
	public Mouse getMouse() {
		return mouse;
	}
	
	public void testar() {
		System.out.println("ligar computador");
		getMouse().testar();
	}
	
}

Agora vamos a sugestão do nosso amigo!

package br.tete.classe;

import br.com.etex.annotations.Dependencia;
import br.com.etex.annotations.Start;

public class Computador {
	
	
	private Mouse mouse;

	@Dependencia(classe=MouseOptico.class)
	public void setMouse(Mouse mouse) {
		this.mouse = mouse;
	}
	
	public Mouse getMouse() {
		return mouse;
	}
	
	/*
	 * Com a anotação start no méthodo podemos inverter
	 * o controle da execução deixando para o framework
	 */
	@Start
	public void testar() {
		System.out.println("ligar computador");
		getMouse().testar();
	}
	
}

vamos ao Main

package br.main;

import br.com.etex.Injetar;
import br.tete.classe.Computador;

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		Injetar injetar = new Injetar(Computador.class);
		injetar.start();
		
	}

}

É isso ai galera! Mais uma novidade no Framework! Alguém tem mais alguma sugestão para torna-lo ele cada vez melhor???

Essa anotação:

No método setMouse não é muito interessante pois você está acoplando a classe Computador a classe MouseOptico. É quase a mesma coisa de fazer setMouseOptico(…).

Que modificações você pode fazer para que isso não ocorra?

Não acho isso um problema e sim uma solução!! Pois em um mundo real o objetos são plugaveis! E com isso eu posso plugar qualquer tipo de mouse que for covariante de Mouse!!! MouseOptico, MouseBolinha…

uma ideia que tive agora, em tempo de execução trocar os acoplamentos!

Injetar.plugar(MouseBolinha.class);

Exatamente porque você poderá plugar outros tipos de mouse que isso pode ser um problema.

Você fixou na sua classe computador que é para injetar um mouse optico.

Sim! Poso plugar qualquer tipo que seja covariante de mouse! ou seja posso plugar um mouse Optico ou bolinha! Realmente não vejo problema nisso

@Dependencia(classe=MouseOptico.class) public void setMouse(Mouse mouse) { this.mouse = mouse; }

Só Injeta MouseOptico… por causa da anotação. O mouse foi forçado a ser um MouseOptico.

Muito legal!
Um ótimo jeito de entender profundamente um framework é criando um concorrente :slight_smile:

[quote=rogelgarcia]@Dependencia(classe=MouseOptico.class) public void setMouse(Mouse mouse) { this.mouse = mouse; }Só Injeta MouseOptico… por causa da anotação. O mouse foi forçado a ser um MouseOptico.[/quote]
Esse é o único probleminha que eu tinha observado, o suporte a injeção sem que a classe usuária precise determinar qual implementação usar.
É quase o mesmo que fazer private Mouse mouse = new MouseOptico().

hum!!! Saquei o que vc kiz dizer agora

Vou resolver esse problema tirando da minha anotação a propiedade classe… ae só vai poder injetar tipos definidos e não polimorficos…

alguma outra ideia para o framework??

Sugestões:
[list]jShot;[/list][list]Shot;[/list][list]iShot.[/list]
Fica aí a dica.
:smiley:

[quote=bobboyms]Vou resolver esse problema tirando da minha anotação a propiedade classe… ae só vai poder injetar tipos definidos e não polimorficos…
alguma outra ideia para o framework??[/quote]
Aí perde um pouco da graça, e parte importante da funcionalidade de um container de injeção de dependencia.
Tente criar um esquema de configuração revolucionário (para combinar com o framework revolucionário rs) que guarde essas informações em algum lugar externo às classes do sistema - para que o framework fique o menos intrusivo possível - mas sem a chatice dos XMLs do spring.