A algum tempo atraz falei de configurar o spring via código java, como a ideia usada no Mentaway, acabei achando algumas coisas não tão fáceis de fazer quanto eu achava que seriam, e como ninguem mais se interessou no projeto (que nem cheguei a publicar em lugar nenhum pra falar a verdade), acabei abandonando a ideia.
Trabalho a algum tempo ja com o Spring framework, ele ja me salvou a vida em alguns clientes diversas vezes, só que sempre achei um saco de configurar tudo em XML, pq não é nem só o XML do Spring, tem o XML do Hibernate, o web.xml, o do Spring, …
Agora com o JDK 1.5, as annotations facilitam bastante a vida, são necessárias muito menos anotações do que código XML para configurar a mesma coisa, e também é a ultima moda utilizar elas para substituir os meta dados em XML por meta dados na propria classe 
Então até este momento, depois de umas 8 horas de trabalho, brincando com o spring, annotations, etc, tenho uma pequena biblioteca que facilita bastante a programação usando o Spring Framework (e até um pouco o uso de JSF, mas ainda não trabalhei muito nesta parte)
Instalação:
copiar o jar para o WEB-INF/lib
editar o web.xml para colocar o seguinte:
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>TO - Novo Site</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext.xml</param-value>
</context-param>
<context-param>
<param-name>contextClass</param-name>
<param-value>
br.com.techoffice.spring.web.TOAnnotationXmlWebApplicationContext
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<filter>
<filter-name>requestContext</filter-name>
<filter-class>
org.springframework.web.filter.RequestContextFilter
</filter-class>
</filter>
<filter>
<filter-name>extensionsFilter</filter-name>
<filter-class>
org.apache.myfaces.component.html.util.ExtensionsFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>requestContext</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>extensionsFilter</filter-name>
<url-pattern>*.jsf</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>INCLUDE</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>ERROR</dispatcher>
</filter-mapping>
<filter-mapping>
<filter-name>extensionsFilter</filter-name>
<url-pattern>/faces/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>INCLUDE</dispatcher>
<dispatcher>FORWARD</dispatcher>
<dispatcher>ERROR</dispatcher>
</filter-mapping>
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.to</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>*.jsf</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
Verifiquem que a unica coisa que não é padrão JSF/Spring MVC são as poucas linhas em negrito
um dispatcher-servlet.xml praticamente em branco, só pra evitar o erro do spring (ainda to trabalhando nisto)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
default-autowire="byName">
</beans>
Criar dentro do diretório de contes da aplicação um arquivo com o nome de to.properties, que pode estar até em branco.
Pronto, não sera mais necessário mexer em XML na aplicação, a não ser que se deseje
A partir dai, se "registra" um bean no spring assim:
package br.com.techoffice.site.dao.impl;
import br.com.techoffice.site.dao.CurriculoDao;
import br.com.techoffice.site.data.Curriculo;
import br.com.techoffice.spring.annotation.Bean;
@Bean(name="curriculoDao")
public class CurriculoDaoImpl extends TOBaseHibernateDao<Curriculo, String> implements CurriculoDao {
public CurriculoDaoImpl() {
super(Curriculo.class);
}
}
prontinho, a engine vai encontrar ele e este vai ser registrado no contexto, como se fosse colocado no XML, tah, mas e dai o que melhorou até agora?
bom, até o momento só o fato de estar tudo em um só lugar.
o Autowire continua funcionando normalmente, ou seja, neste caso ai, este bean precisa de um sessionFactory do hibernate, e este sera fornecido para ele automaticamente.
tah, mas e se eu quiser trabalhar com o Spring MVC?
@Bean(name = "emailSender", singleton = false)
@UrlMapping("/enviaemail.to")
public class EmailSender implements Controller {
private MailUtility mailUtility;
private EmailDao emailDao;
@SuppressWarnings("unchecked")
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//…
return new ModelAndView("contatos");
}
public void setMailUtility(MailUtility mailUtility) {
this.mailUtility = mailUtility;
}
public void setEmailDao(EmailDao emailDao) {
this.emailDao = emailDao;
}
}
Registrei o bean no spring framework, utilizando o @Bean, e configurei a URL dele usando @UrlMapping.
lógico, isto não é a abolição do XML, eu não iria querer configurar via anotações de onde vem o meu data source, ou servidor de e-mails por exemplo, isto eu posso continuar configurando via properties ou XML do spring como eu sempre fiz, e configurar isto dependendo do ambiente de deployment (teste/produção/…)
A ideia disto é simplesmente evitar que se escreva XML para o que não é "configuração" é apenas meta dado da aplicação mesmo .
Até o momento, ja fiz funcionar/inventei, as seguintes anotações:
- @Bean - Correspondente a <bean> do spring
- autoWire (NO, BY_NAME, BY_TYPE, INHERITED)
- dependencyCheck
- destroyMethod
- factoryMethod
- initMethod
- lazy
- name
- scope (APPLICATION, REQUEST, SESSION)
- singleton
@UrlMapping - define o mapeamento do controller
@UrlMappings - permite colocar diversos mapeamentos para o mesmo controller
@WebService - expõem o bean como um web service, utilizando o XFire, por enquanto é preciso especificar o nome do serviço a ser exposto (acho que vou deixar o nome do bean como default) e a interface que deve ser exposta, vou mudar esta anotação para a da JSR que especifica exatamente isto
@Property
@ConstructorArgs
Por enquanto é isto que foi feito para spring+annotations.
Para o JSF foi só colocar um faces-config.xml dentro do diretório META-INF para este ser localizado automagicamente, onde esta configurado o VariableResolver do spring, e um navigation handler costumizado, que faz com que o JSF seja mais aderente a "Padrão sobre configuração" ou seja a minha aplicação JSF consiste de:
uma classe
@Bean(name = "test", scope = Scope.REQUEST, initMethod = "init")
public class TestObject {
private static final Log logger = LogFactory.getLog(TestObject.class.getName());
public String action() {
return "teste1";
}
public String nome() {
return "teste2";
}
public void init() {
logger.debug("init");
}
}
nenhuma alteração em arquivo XML nenhum
uma página JSF que vai chamar algum metodo deste Bean, por exemplo:
<%@ page contentType="text/html;charset=windows-1252"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>
<%@ taglib uri="http://myfaces.apache.org/tomahawk" prefix="t"%>
<html>
<body>
<f:view>
<h:form>
<h:commandButton action="#{test.action}">
<h:outputText value="Teste" />
</h:commandButton>
<h:commandButton action="#{test.nome}">
<h:outputText value="Teste1" />
</h:commandButton>
</h:form>
</f:view>
</body>
</html>
e considerando que o nome do bean é "test", quando um metodo dele retornar, por exemplo, "teste1", o navigationHandler que eu implementei, vai renderizar o arquivo "/test/teste1.jsp"
ou seja o nome do bean é o nome da pasta, e o nome do bean é o nome da pasta, e o resultado do metodo o nome da view do resultado desejada
continua funcionando o comportamento padrão do JSF para o caso de retornar uma string em branco ele fica na mesma página
mas por enquanto era isto, acho que vou enviar o código que implementei até agora para o pessoal do spring para ver o que eles acham
se alguem tiver alguma sugestão ela sera bem vinda
Se você gostou deste post, lembre-se de assinar o RSS feed do blog, para ser notificado de novos posts!
!["]("img/box-6x6.gif)
