Dite as regras na sua aplicação:
Web MVC com IoC e Reflection

Essa palestra foi apresentada como Tutorial no Conexão Java 2005. O conteúdo abaixo contém mais explicações que os slides exibidos, assim todos podem acompanhar melhor. Os códigos também estão disponíveis em links. (no final da página estão todos os códigos juntos)

Sérgio L. Lopes Jr. (sergio arroba caelum.com.br)

Caelum - www.caelum.com.br

IoC: Setter Injection

• Mas como as coisas chegam magicamente para a Action?
• 1° tipo de IoC: Setter Injection
  • Action tem setters pra tudo que ela precisar
  • Controlador chama esse setter passando o parâmetro esperado!
• Exemplo para o Inversor:
  • Método setNome(String nome) na classe Inversor
  • O controlador se encarrega de fazer:
    inversor.setNome(request.getParameter("nome"));
• Tiramos os request.getParameter() da Action
• Criamos, nas Actions, campos e seus setters para cada parâmetro
• Agora falta fazer a mágica acontecer no controlador... Mais Reflection!

Setter Injection

paraCada (metodo nos metodosDaAction) {
   se (é um setter) {
      procura um parametro com esse nome;
      chama o setter passando o valor do parametro;
   }
}
	

for (Method method : action.getClass().getMethods()) {
	String m = method.getName(); 
	if (m.startsWith("set")) {
		String p = request.getParameter(m.substring(3,4).toLowerCase() + m.substring(4));
		if (p != null) {
			method.invoke(action, p);
		}
	}
}
	

Independentes!

• Nossas Actions não dependem mais do Request ou do Response!
• Podemos tirar o request e o response do método execute()
  • Refatorar: No Eclipse: Refactor -> Change Method Signature
• Código da Action aqui

Muita independência?

• Mas, e se precisamos...
  • ...fazer aquela mega-super-ultra feature que precisa muito do Request?
  • ...da Sessão do usuário para gravar uma informação?
• Solução: mais mágica! Mais IoC! Mais Reflection!

IoC: Constructor Injection

• 2° tipo de IoC: Contructor Injection
• A Action tem um construtor que recebe o tipo de argumento necessário
• O controlador chama esse construtor passando exatamente o que a Action precisa
• Exemplo para o Inversor:
  • Construtor Inversor(HttpServletRequest request){ ... } na classe Inversor
  • O controlador magicamente faz:
    Action a = new Inversor(request);

Diferentes injeções

• Diferença entre setter injection (SI) e constructor injection (CI):
  • SI: setter chamado é resolvido em função do nome do campo
  • CI: parâmetros passados ao construtor são resolvidos em função do tipo
• Constructor Injection é mais recomendado porque é atômico. Todas as dependências são injetadas de uma vez e somente na instanciação. Com Setter Injection podemos esquecer alguma dependência e não é atômico.

Constructor Injection: Exemplo

public class Login implements Action {
  private HttpServletRequest request;
  private String nome;
  public Login(HttpServletRequest r) {
    request = r;
  }
  public void execute() {
    this.request.getSession().
	setAttribute("usuario", this.nome);
  }
  //setter para o campo nome
}
	

• Criamos essa classe e colocamos no controller.properties
• Criamos login.jsp

Constructor Injection: Implementando

construtor := o construtor da Action;
paraCada (parametro nos parametrosDoConstrutor) {
  acha um objeto que satisfaça o tipo do parametro;
}
chama o construtor passando os objetos encontrados;
	

• Principal questão: onde achar um objeto que satisfaça aquele tipo?
• Resposta: criamos um contexto onde o controlador procura objetos (um simples mapa)

Constructor Injection: O contexto

• Mapa onde salvamos objetos que podem ser usados em constructor injection
• Colocar um objeto nesse contexto significa que eles estão disponíveis para as Actions que os solicitarem

• Map context = new HashMap();
  context.put(HttpServletRequest.class, request);
  context.put(HttpServletResponse.class, response);
  		

• Novo criaAction() usando IoC:
  

  private Action criaAction(String pagina, Map context) throws Exception {
  	Class action = Class.forName(properties.getProperty(pagina + ".action"));
  	Constructor[] constructors = action.getConstructors();
  	if (constructors.length == 0)
  		return (Action) action.newInstance();
  		
  	Constructor constructor = constructors[0];
  	Class[] types = constructor.getParameterTypes();
  		
  	Object[] parameters = new Object[types.length];
  	int i = 0;
  		
  	for (Class type: types) {
  		parameters[i++] = context.get(type);
  	}
  	
  	return (Action) constructor.newInstance(parameters);
  }
  		

Código final:

• Controller
• Inversor
• Somadora
• Action
• MagicRequest
• Login
• controller.properties
• inversor.jsp
• somadora.jsp
• login.jsp
• topo.jsp
• rodape.jsp

Como está o framework?

• Separamos tudo em camadas
  • A visualização está nos JSPs
  • O controlador é totalmente reaproveitável
• As ações estão em classes separadas
  • São totalmente independentes da Web (ou qualquer outro contexto)
  • Mas, se precisamos de algo específico, conseguimos também
• Tudo configurado num .properties muito simples
• Está muito bem encaminhado; agora é só melhorar...

Sugestões: Algumas melhorias no nosso framework

• Tirar o parâmetro "pagina"
• Não usar a interface Action!
  • Podemos configurar qual método chamar
  • Ou marcar o método com uma Anotação
• Setter Injection que converte automaticamente para outros tipos
• Constructor Injection mais inteligente (instanciando objetos também)
  • PicoContainer (www.picocontainer.org)
• Há mais 2 "tipos de Reflection": nos campos (Fields) e anotações (Annotations)

Sugestões: Alguns links legais

• PicoContainer: Legal ler as introduções deles onde explicam o que é IoC. É um framework para auxiliar no trabalho com IoC.
• Inversion of Control Containers and the Dependency Injection pattern: Artigo de IoC do Martin Fowler (excelente!)
• The Reflection API: Tutorial de Reflection da Sun
• VRaptor: framework Web que roda por trás do GUJ. Boa parte das idéias da palestra estão no vRaptor também.
• Why extends is evil: artigo do JavaWorld que fala porque herança deve ser evitada sempre.
• GUJ: Grupo de Usuários Java, do qual participo e sou Moderador
• Caelum: Empresa onde trabalho, com pessoal muito bom. Tem cursos de Java ótimos.
• Conexão Java: Evento onde esta palestra foi dada. É organizado pelo CUJ, Portal Java e Anhembi Morumbi.
• Meu Blog e Site