ta batizado o framework agora é jShot gostei do nome!!
[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.[/quote]
Criar o schema de configuração relolucionario ta phoda… eu ainda prefiro as anotações, mas como tu disse nem tudo vai poder ser via annotations…
Alguem tem ideia de um layout de arquivo revolucionário ???
Gelera essa é a estrutura do meu framework para IoC - injeção de dependencia, é algo muito simples, estou postando para o pessoal aprender um pouco mais sobre reflexão em java
package br.com.etex.annotations.injection;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Dependencia {
Class<?> classe() default Class.class;
boolean injetar() default true;
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Start {
public boolean start() default true;
}public interface Injetar {
public void start();
public Object getNovaInstancia();
}package br.com.etex;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import br.com.etex.annotations.injection.Dependencia;
import br.com.etex.annotations.injection.Start;
import br.com.etex.exceptions.VariosStartException;
import br.com.etex.interfaces.Injetar;
public class InjecaoDependencia implements Injetar {
private Object instancia;
public InjecaoDependencia(Class<?> classe) {
injetarDependencias(classe);
}
/**
* Verifica se é um methodo set
*
* @param classe
*/
private boolean isSetMethodo(String nome) {
if (nome.substring(0, 3).equals("set")) {
return true;
} else {
return false;
}
}
/**
*
* @param atributo
* atributo que será injetado a dependencia
* @return String nome do methodo set do atributo exp : setAtributo
*/
private String nomeMethodo(Field atributo) {
return "set" + atributo.getName().substring(0, 1).toUpperCase()
+ atributo.getName().substring(1, atributo.getName().length());
}
private Object getInstancia(Object objeto, Method method)
throws InstantiationException, IllegalAccessException {
Object instancia = null;
for (Field field : objeto.getClass().getDeclaredFields()) {
if (nomeMethodo(field).equals(method.getName())) {
instancia = field.getType().newInstance();
break;
}
}
return instancia;
}
@Override
public Object getNovaInstancia() {
return getInstancia();
}
/**
*
* @param classe
* Classe qual deve ser criada uma nova instancia
* com suas dependencias ja injetadas
* @return Object
* retorna uma instancia com classe ja injetada
*/
private Object injetarDependencias(Class<?> classe) {
Object objeto = null;
Dependencia dependencia = null;
try {
objeto = classe.newInstance();
for (Method method : objeto.getClass().getDeclaredMethods()) {
for (Annotation annotation : method.getDeclaredAnnotations()) {
if (annotation instanceof Dependencia) {
dependencia = (Dependencia) annotation;
if (dependencia.injetar()) {
Class<?> tipoClasse = null;
Object objetoAtributo = null;
if (dependencia.classe() == Class.class) {
if (isSetMethodo(method.getName())) {
if (getInstancia(objeto, method) != null) {
method.invoke(objeto,
new Object[] { getInstancia(
objeto, method) });
}
}
} else {
tipoClasse = dependencia.classe();
objetoAtributo = tipoClasse.newInstance();
if (isSetMethodo(method.getName())) {
method.invoke(objeto,
new Object[] { objetoAtributo });
}
}
}
}
}
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
setInstancia(objeto);
return objeto;
}
/**
* verifica se existe varias annotações @start
* se tiver mais que uma gera a exception
* {@link VariosStartException}
*/
private void validaStartAnnotation() {
int qtd = 0;
for (Method method : getInstancia().getClass().getDeclaredMethods()) {
for (Annotation annotation : method.getDeclaredAnnotations()) {
if (annotation instanceof Start) {
qtd++;
}
}
}
if(qtd > 1) {
try {
throw new VariosStartException();
} catch (VariosStartException e) {
e.printStackTrace();
}
}
}
/**
* inicia um methodo que esta anatado
* com start para ser iniciado altomaticamento
*/
public void start() {
Start start = null;
validaStartAnnotation();
for (Method method : getInstancia().getClass().getDeclaredMethods()) {
for (Annotation annotation : method.getDeclaredAnnotations()) {
if (annotation instanceof Start) {
start = (Start) annotation;
if (start.start()) {
try {
method.invoke(getInstancia(), new Object[] {});
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
}
}
private void setInstancia(Object instancia) {
this.instancia = instancia;
}
private Object getInstancia() {
return instancia;
}
}
É isso ae galera esse é o revolucionário framework de injeção de controle, ta ae os fontes para copiar, colar, melhorar… etc… bla bla blaa…
Se alguem tiver alguma duvida sobre alguma coisa pode perguntar
Achei muito interessante o código mas quando tento usar o eclipse apresenta o seguinte erro: “The annotation @Dependencia is disallowed for this location”.
Corrige os pacotes
provavelmente você não esta usando mesma estrutura de pacotes que eu usei.
Depois de 7 anos as pessoas comecam a abandonar XML e Annotations. A moda agora é configuracão programática, DSL, etc.
Parabéns pelo framework. Continue desenvolvendo ele. No mínimo vc vai aprender bastante.
Dá uma olhada também no MentaContainer, que é um framework de IoC, DI e AutoWiring completo que compete com Guice, Pico e Spring. E totalmente baseado em configuracão programática.
[quote=saoj][quote]
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.
[/quote]
Depois de 7 anos as pessoas comecam a abandonar XML e Annotations. A moda agora é configuracão programática, DSL, etc.
Parabéns pelo framework. Continue desenvolvendo ele. No mínimo vc vai aprender bastante.
Dá uma olhada também no MentaContainer, que é um framework de IoC, DI e AutoWiring completo que compete com Guice, Pico e Spring. E totalmente baseado em configuracão programática.
http://mentacontainer.soliveirajr.com/posts/list/5.page
[/quote]
saoj. Esse framework foi apenas uma brincadeira que eu fiz, para que de forma simplificada as pessoas possam entender um pouco como funciona internamente os frameworks de IoC…
Não sei se é isso o problema, veja como deixei a estrutura:
br.com.etex
----InjecaoDependencia
br.com.etex.annotations.injection
----Dependencia
----Injetar
----Start
Galera essa bagaça ta começando a ficar séria mas está show de bola. haha