Como escolher o melhor framework Java para web

Dr. AndersonV. de Araújo
about.me/andvicoso

A intenção aqui não é definir qual é o
MELHOR framework MVC para Java web
É dar opções!
Falar um pouco de cada e mostrar exemplos
em código
Foco no Controller
Matt Raible
Compara frameworks desde 2004
Links para algumas comparações dele no final

Servlets 3.X
JSF 2.X
Struts2
Spring MVC
VRaptor
Play!

Podemos fazer os mapeamentos (Servlets e
Filtros) usando anotações!
UHUUU!
Controller
Deve estender de HttpServlet
Deve ser mapeado a uma URL (XML ou anotações)

Pontos positivos:
Padrão Java EE
Bastante difundido (1.0 em 1997)
Bom para o aprendizado de conceitos básicos:
▪ Request, response, session, parameter, filter, ...
Pontos negativos:
Pegar parâmetros da requisição
Validação
Mensagens/Internacionalização
Etc (muita coisa ruim aqui)

@WebServlet(urlPatterns = { "/view/user/add.do" })
public class AddUserServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest pReq, HttpServletResponse pResp)
throws ServletException, IOException {
String name = pReq.getParameter("name");
String phone = pReq.getParameter("phone");
boolean valid = StringUtils.isNotBlank(name) &&
StringUtils.isNotBlank(phone);
if (valid) {
User user = new User();
user.setName(name);
user.setPhone(phone);
UserDao dao = new UserDaoJPA();//Poderia ser injetada!
dao.create(user);
}
pResp.sendRedirect(valid ? "list.do" : "add.do");
}
}

Component-based framework
Controller:
Todos devem ser anotados com @ManagedBean para
serem visíveis na view
Deve ser anotado com uma anotação de escopo na
qual o bean vai estar disponível
▪ @NoneScoped, @RequestScoped, @ViewScoped,
@SessionScoped, @ApplicationScoped e @CustomScope
Os métodos do managed bean são acessíveis na view
(xhtml) através das tags do JSF

Pontos positivos:
Padrão Java EE
Bastante difundido (1.0 em 2004)
Alta empregabilidade (ainda)
Várias bibliotecas de componentes disponíveis
Facilidade no uso de componentes ricos e “Ajax”
Pontos negativos:
Sopa de tags no jsps
▪ Pode ser ruim para designers
Muito acoplamento entreView e Controller
Chato de testar
“Aprende” menos CSS, HTML e JS
FacesContext.getCurrentInstance().getExternalContext()

@ManagedBean
@ViewScoped //Poderia ser outro escopo
public class UserController implements Serializable {
private UserDao dao;
private User user;
@PostConstruct
public void init() {
user = new User();
dao = new UserDaoJPA();//Poderia ser injetada!
}
public String add() {
dao.create(user);
user = new User();
return "list";
}
//getters e setters omitidos

<html xmlns=http://www.w3.org/1999/xhtml
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<h:head><title>Cadastro de usuários</title></h:head>
<h:body>
<h1>Cadastro de Usuário</h1><br />
<h:messages />
<h:form>
<h:panelGrid columns="2">
<h:outputText value="Nome" />
<h:inputText value="#{userController.user.name}" />
<h:outputText value="Telefone" />
<h:inputText value="#{userController.user.phone}" />
<h:outputText value="Login" />
<h:inputText value="#{userController.user.login}" />
<h:outputText value="Password" />
<h:inputSecret value="#{userController.user.password}" />
<h:commandButton action="#{userController.add}" value="Cadastrar"/>
</h:panelGrid>
</h:form>
</h:body>
</html>

Action-based framework
Junção do Struts com oWebWork
Configuração:
Antigamente tinha muita em XML
Atualmente boa parte pode ser feita usando anotações
Convention Plugin (CP) facilita muito a vida
Convention over configuration (coding by convention)
Controller:
Convention Plugin:
▪ Deve conter um pacote com um dos nomes: struts, struts2, action ou
actions. Nele devem estar as actions
▪ Os paths são definidos por pacotes na hierarquia
As actions devem ser anotadas com @Action(“url”)
Os resultados (retornos) são definidos com @Result
Em geral, estendem de ActionSupport

Pontos positivos:
Bastante difundido (1.0 – 2000, 2.0 - 2007)
Alta empregabilidade (ainda)
Vários plugins: Bootstrap, Convention, JQuery, ...
▪ Com tags de componentes (pode ser um ponto negativo)
Interceptor
Pontos negativos:
Pode ter sopa de tags no jsps
Documentação muito espalhada e mal organizada
▪ Fácil confundir com a versão 1 em uma “googlada”
Pode ter muito XML na configuração, além do properties

@Results({ @Result(name = "success",
type = "redirectAction", params = {"actionName", "list”}),
@Result(name = "input", location = "add.jsp") })
public class AddUserAction extends ActionSupport {
private User user = new User();
@Action("add")
return INPUT;
}
@Action("put")
public String put() {
UserDao dao = new UserDaoJPA();//Poderia ser injetada!
dao.create(user);
return SUCCESS;
}
//getters e setters omitidos
}

Action-based framework
As características do Spring podem ser
utilizadas independentemente (DI, Aspects, ...)
Webservices RESTful podem ser criados através
de anotações.
Controller:
Classe deve ser anotada com @Controller
Método de ação deve ser anotado com
@RequestMapping(“url")
Parâmetros com @RequestParam

Pontos positivos:
Fácil aprendizado
Não precisa de getters e setters como Struts2 e JSF
Fácil aprendizado
▪ Forma de redirecionamento, REST, validação , e
internacionalização são bem fáceis
Comunidade crescendo rapidamente
Pontos negativos:
Pode ter muito XML na configuração
▪ Configuração com anotações ainda muito incipiente
Requer experiência pra configurar inicialmente

@Controller
public class UserController {
@Inject
private UserDao dao;//injetado
@RequestMapping(value = "/user/put", method =
RequestMethod.POST)
public String put(@ModelAttribute User user) {
dao.create(user);
return “redirect:/user/list”;
}
@RequestMapping(value = “/user/add")
return “user/add";
}
}

Caelum
Cursos e apostilas
Brasileiro!
Nasceu em 2003 no IME-USP
Convention over Configuration
Controller:
Deve ser anotado com @Resource e o nome da classe
deve terminar com Controller
Ex.: FuncionarioController.
O path de acesso fica “/funcionario/{nomeDoMetodo}”
O método pode ser anotado com @Path para alterar

Pontos Positivos:
Documentação em português!
Fácil aprendizado
▪ Forma de redirecionamento, REST, validação , injeção de
dependências e internacionalização são bem fáceis
Não precisa de getters e setters como o Struts2 e JSF
Interceptor
Pontos Negativos:
Baixa utilização fora do Brasil
Comunidade pequena
Baixa empregabilidade

@Resource
public class UserController {
private UserDao dao;
private Result result;
private Validator validator;
public UserController(UserDao dao, Result result, Validator validator) {
this.dao = dao;
this.result = result;
this.validator = validator;
}
@Get
public void add() {}
@Post
public void put(User user) {
validator.checking(getValidations(user, false));
validator.onErrorUsePageOf(UserController.class).add();
dao.create(user);
result.redirectTo(this).list();
}
private Validations getValidations(final User user, final boolean isEdit) {
return new Validations() {{
that(StringUtils.isNotBlank(user.getName()), "error", "name.empty");
that(StringUtils.isNotBlank(user.getPhone()), "error", "phone.empty");
}};
}}

Servlets** JSF Struts 2 Spring MVC
Livros (Amazon.com) 1,104 334 690 149
Linked in Skills 144k (-7) 77k (-5%) 161k (-10%) 494k***
(+5%)
Índice de pesquisa do
Google EUA (jun13)
5 34 11 14
* vraptor - É zero ou não foi possível pesquisar.
** Difícil de mensurar, pode ser utilizado em conjunto com outras tecnologias.
*** Foi possível a pesquisa apenas por Spring.

Importância dos
frameworks pelos
desenvolvedores
-InfoQ (EUA, Jun13)

Ordem
Matt`s
Weighted
TheServerSide
Java Symposium
The Rich Web
Experience
(RWX) 2010
Devoxx
2010
1 Grails Grails Grails GWT
2 Play GWT GWT Rails
3 Spring MVC Rails Rails Spring MVC
4 Rails / Vaadin Spring MVC Spring MVC Grails
5 GWT Vaadin Tapestry / Vaadin Wicket / Struts 2

Que tipo de aplicação que você está
construindo?
Projeto Comunitário?
Manutenção
CaracterísticasTécnicas

Não acredite piamente em blogs e artigos
Tente você mesmo!
Acredite desenvolvedores, não evangelistas
Aqueles que têm experiência com o framework e
tenham usado em produção
Cuidado com os interesses corporativos
Os livros são um bom sinal!
Sempre!

Frameworks têm pontos fracos – a sua
aplicação é/possui um deles?
Escolha 2-3 frameworks para o seu tipo de
aplicação ... e protótipo!
Se a prototipagem for dolorosa, mude!
Depois de prototipar, pare e compare os
frameworks

Não tenha medo de:
Experimentar novos frameworks
Usar frameworks antigos
Manter o seu framework existente

Não existe MELHOR framework;
É ótimo ter competição!
Os desenvolvedores deveriam saber mais de
um framework
Você deve tentar um framework antes de ficar
falando mal dele
Fazer uma boa pesquisa pode economizar
tempo e dinheiro no futuro

Matt Raible
Comparative table;
Esta apresentação no slideshare;
http://www.slideshare.net/andvicoso/como-
escolher-o-framework-java-para-web
http://github.com/andvicoso
http://andvicoso.blogspot.com

Como escolher o melhor framework Java para web

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Como escolher o melhor framework Java para web

Similar to Como escolher o melhor framework Java para web (20)

Como escolher o melhor framework Java para web