Managed Beans. Não complique, simplifique.
Já é sabido de todos que JSF é um framework web MVC com uma filosofia voltada a component-based. E não diferentemente dos bons frameworks action-based existentes hoje em dia, o JSF também se utiliza de POJOs como parte do controller.
Sim, eu estou falando dos, já muito conhecidos, managed beans. Eles são os responsáveis por intermediar a comunicação entre nossas páginas e o nosso modelo. Até aí tudo bem, não existe qualquer mistério, basta entender um pouco sobre MVC que isso torna-se óbvio.
Se você observar, quando está trabalhando com JSF, notará que cerca de 50-70% do seu esforço é dedicado na implementaçao do managed bean. E que as futuras alterações e correções de bugs estão intimamente ligados a ele. Implementar corretamente um managed bean pode evitar muita dor de cabeça e facilitar na manutenção da aplicação.
Mas você já se perguntou como e qual seria a melhor forma de implementá-los? Não que exista apenas uma única maneira de escreve-los, longe disso, mas em contra partida existem inúmeras maneiras de torna-los realmente ruins.
Escrever um managed bean de forma porca incorreta pode dificultar e muito sua vida e da sua equipe. Falta de legibilidade, dificuldade para escrever testes de unidade e principalmente medo de alterar o código são apenas alguns dos possíveis problemas.
Agora pare e imagine a vida do próximo desenvolvedor que deverá manter tal código. É, não parece algo divertido.
Managed Beans mais responsáveis
A principal responsabilidade de um managed bean é intermediar a comunicação entre as páginas (componentes do JSF) e nosso modelo. Escutar eventos, processa-los e delegar para a camada de negócios são apenas algumas de suas responsabilidades.
Talvez devido a experiência com frameworks action-based muitos desenvolvedores acabam subutilizando os managed beans e sobrecarregando as páginas com lógicas e dados desnecessários. Os managed beans e as páginas usam a abusam do modelo “pull” durante a renderização e (re)construção da árvore de componentes, isto é, basicamente as páginas é quem decidem (através de EL) quais os dados e lógica necessária para que possam ser processadas.
Graças a este modelo nós conseguimos retirar toda lógica de renderização da página e colocando-a onde jamais deveria ter saído, no managed bean. Esta lógica estará localizada nos métodos públicos do managed bean que serão acessados através de EL pela página.
Não importa se a lógica é simples ou complexa, é quase que mandatório que ela esteja localizada no seu managed bean. Então bizarrices lógicas de apresentação nas páginas, que não são difíceis de se encontrar por aí, como esta deveriam ser evitadas:
<h:panelGrid id="pnl" rendered="#{loginBean.usuario.admin == 1 or loginBean.permissao('exibir_painel_de_usuarios')}" />
...
</h:panelGrid>
Reparem que a lógica de apresentação está, representada através de EL, na página. Se você teve a infelicidade de encontrar códigos assim então há grandes possibilidades de você também encontrar regras de negócio nas páginas, o que é muito pior que encontra-las no controller.
E olha que este foi apenas um exemplo simples e ligeiramente legível, já encontrei códigos mais complicados que este de dificil leitura e horrível de dar manutenção.
O problema disso é se houver a necessidade de mudar a regra (o que muitas vezes ocorre), mas e se ela estiver duplicada por dezenas de páginas, como você faria? Como testa-la? Pense um pouco sobre isso.
Imaginem um código um pouco pior que este (com 3 ou 4 condicionais), mas dentro de um componente de iteração (como h:dataTable ou ui:repeat). É, você nem vai querer imaginar.
A regra de visualização acima deveria está encapsulada no managed bean, a página não deveria conhecer a regra, mas apenas quem a conhece. Então pensando nisso nós poderíamos alterar nosso código para algo melhor, algo como isto:
<h:panelGrid id="pnl" rendered="#{loginBean.permitidoExibirPainelDeUsuariosLogados}" />
...
</h:panelGrid>
O componente não conhece a regra, mas sabe exatamente a quem perguntar. O código está bem mais legível pois revela sua intenção. Agora está bem mais fácil mudar a regra (pois temos apenas um único ponto de manutenção) e principalmente testa-la através de testes automatizados.
Um managed bean deveria ao máximo tentar esconder a complexidade das páginas através de métodos que revelem a devida intenção, ou seja, a nomenclatura dos métodos é realmente importante e você deveria dar importância a legibilidade do seu código.
Comunicação entre managed beans
O que eu tenho para falar, de longe, se iguala ao que pode ser encontrado no excelente conteúdo sobre comunicação no JSF neste post no blog do BalusC, além de que para mim ele aborda 99% sobre como managed beans podem se comunicar.
O que pretendo falar está mais relacionado em como manter uma conversa (troca de mensagens) saudável entre managed beans. Em como explicitar os parâmetros esperados e como passar parâmetros de um managed bean para outro de maneira coerente.
A comunicacão entre managed beans não difere da troca de mensagens entre componentes de software na orientação a objetos. Cada componente (managed bean) conhece a interface pública do outro componente para que eles possam trocar mensagens.
Sendo, ter esta interface pública bem definida pode facilitar muito a “conversa” entre os managed beans, facilitar os testes, evitar problemas inesperados, diminuir o acoplamento, aumentar a coesão e assegurar contratos e invariantes do componente.
Nada mais claro que um exemplo para assimilar a idéia:
<h:dataTable var="item" value="#{compraBean.itensNoCarrinho}">
<h:column>
<h:commandLink value="detalhe" action="#{itemBean.exibirDetalhesDoItem}">
<f:setPropertyActionListener value="#{item}" target="#{itemBean.itemSelecionado}" />
</h:commandLink>
</h:column>
</h:dataTable>
O código acima não tem nada de errado ou anormal, nada do que não estejamos acostumados a ver quase todos os dias. Se repararem há um pequeno “dialogo” entre dois managed beans - compraBean e itemBean - que estão trocando informações.
O problema não está na comunicação em si, pois isso teria que acontecer de um jeito ou de outro, mas sim em como eles se comunicam. O managed bean compraBean conhece detalhes de como o itemBean se comporta, ou seja, ele sabe mais do que o necessário.
Um maneira de melhorar isso seria ter uma interface pública bem definida no itemBean. Algo semelhante ao código abaixo:
<h:dataTable var="item" value="#{compraBean.itensNoCarrinho}">
<h:column>
<h:commandLink value="detalhe" action="#{itemBean.exibirDetalhesDoItem(item)}" />
</h:column>
</h:dataTable>
Além de todos os benefícios (baixo acoplamento, alta coesão etc) citados acima, nós ganharíamos de cara maior legibilidade no código, o que é algo realmente importante quando a comunicação foge do trivial.
Vale ressaltar que independente da comunicação ocorrer na página (por meio da JBoss-EL) ou diretamente dentro do managed bean, essa abordagem poderia -e até deveria- ser utilizada. Para o segundo caso, frameworks como JBoss Seam ou Spring ajudam a injetar as dependências de maneira simples através de anotações.
Um ou vários managed beans?
Não tenho uma opinião realmente formada quanto a isso, ainda não. Já pensei várias vezes sobre o assunto, e sempre me pego vislumbrando cenários nada comuns. Que no caso os considero como casos excepcionais.
Desde 2006 eu trabalho com JSF, ministro cursos e treinamentos e presto consultoria para algumas empresas. E posso dizer que somente três vezes eu precisei ter mais de um managed bean para resolver uma tarefa. Dentre todas eu tenho a ligeira impressão que segui o caminho errado mais complicado, e que se tivesse pensado mais um pouco eu poderia ter evitado tais soluções.
Managed beans são componentes, em sua grande maioria, intimamente ligados a(s) página(s) e que deveriam ter apenas o estritamente necessário para representar a GUI. Dificilmente você terá um managed bean genérico (CRUD não conta) que poderia funcionar em todo lugar. Você precisa fazer um esforço hercúleo para conseguir isso, e as vezes parece que não vale a pena.
A idéia de um managed bean ter dados (entrada pelo usuário e estados) e comportamentos (eventos e regras ligadas a apresentação) juntos segue o princípio básico da OOP, o que torna o trabalho mais simples e coeso. Tentar ir contra isso (ao estilo ActionForm e Action do Struts) pode te trazer muita dor de cabeça a médio-longo prazo.
Neste post do Neil Griffin, um dos autores do primeiro livro de JSF2.0, ele sugere alguns “rótulos” para os diversos tipos de managed beans que podem haver numa aplicação, e ainda por cima ele incita que seria uma boa prática trabalhar com vários managed beans por questões de SoC, baixo acomplamento etc.
De fato, devido ao modelo “pull” podemos ter managed beans atuando como componentes menores, mais reutilizáveis e mais orientados a objetos. Ter componentes (managed beans ou não) de granularidade fina colaborando para construção da página é algo bastante comum, e eu mesmo me utilizo muito disso. Mas não são destes tipos de componentes que falo, muito menos o Neil.
Eu, particularmente, não concordo com quase nada no post do Neil. Para mim ele se utilizou de argumentos isolados e vagos para defender sua idéia. Managed beans por sua natureza deveriam ser simples, contudo a abordagem do Neil, definifitivamente, vai contra tudo isso. Eu a considero um overkill, e ela torna qualquer aplicação web difícil de manter.
Bem, se dois ou mais managed beans relacionados -delimitados a um contexto- estão servindo para você e sua equipe, ótimo. Continue assim, não tem porque mudar. O framework (JSF) te permite isso, contudo eu tenho sérias dúvidas se essa abordagem vale a pena.
Conclusão
Este post estava em draft faz um bocado de tempo, mas a falta de tempo e a coragem não me permitiam finaliza-lo. Felizmente resolvi tira-lo do baú e posta-lo.
Tudo que comentei aqui está mais ligado a minha experiência e o que aprendi durante estes anos como desenvolvedor (e conversando com outros profissionais) do que eu pude encontrar em livros de JSF sobre o assunto. Existem muitos livros bons, assim como artigos em blogs e sites especializados sobre o assunto, mas nada melhor que a experiência do dia a dia para nos mostrar caminhos mais adequados de como solucionar determinados problemas.
Por mais longo que o post tenha ficado, eu ainda sinto que falta complementa-lo em alguns aspectos e pontos. Pois o que falei acima acaba te levando a aderir outras soluções não menos importantes, mas que já foram bastante citadas neste blog e discutidas em listas de discussão.
Entre os três tópicos abordados aqui eu ainda tenho algumas dúvidas quanto ao último, principalmente depois desta resposta do @edburns a minha pergunta no Twitter. Hoje minha opinião está mais para o lado “um managed bean é suficiente” por não ter encontrado respostas que me convencessem do contrário.
Enfim, como disse antes, se vários managed beans intrinsecamente relacionados estão resolvendo teu problema por algum motivo, ótimo! Continue assim. Se você tiver um tempinho e puder comentar sobre tua decisão eu ficaria grato.
Tags: backingbean, boas.praticas, comunicacao.jsf, controller, Java, java.server.faces, JavaServer Faces, jboss el, jboss.el, jboss.seam, JEE, JSF, jsf.communication, managedbean, mvc, pull, pull.mvc, Seam, Spring, web
August 27th, 2009 at 9:07 am
Apesar de não ter larga experiência com JSF como você, Rafael, eu acho que managed beans devem ser especificos por funcionalidade, por exemplo, pois se você tiver apenas “O MANAGED BEAN”, então alguém terá que ser responsável por fazer esse trabalho de controle.
Apesar de gostar de trabalhar com algumas soluções genéricas, eu não acho que vale a pena deixar todo o controle por conta de alguém que conhece o que implementou e como será a manutenção disto?
Lembre-se que as vezes é bom ter um único ponto de implementação, mas nem sempre é obrigatório, pois como você tem um único managed bean, então qualquer alteração deverá ser pensada, para que não resulte em um fracasso em uma outra funcionalidade.
Essa é a minha opinião e espero ter ajudado.
August 27th, 2009 at 9:30 am
Muito bom Rafael,
eu também tinha essa dúvida, após um projeto que participei com o Regis (SERPRO), isso ficou mais claro pelo que o Regis falava. Para mim hoje poucas coisas (ou nenhuma) justifcam o uso de mais de um managed bean por página, um managed bean pertence a uma única página e a página a seu managed bean.
August 27th, 2009 at 10:15 am
Tenho uma aplicação de BI onde existe uma consulta que se pode fazer vários detalhamentos… basicamente ela vai descendo o nível pra ir especificando a informação. Ex: Consulta de Classificação (tipo um Ranking) da pontuação é detalhada para a consulta de indicadores (pontos pra cada indicador que geraram a pontuação final), depois detalhando para os eventos (cada indicador tem vários eventos que juntos geram a pontuação do indicador) indo por fim aos dados de produção (apenas registros que com uma lógica aplicada, geraram os pontos dos eventos).
Bom para fazer tudo isso eu uso 4 Managed Beans, sendo 1 pra cada nível de consulta.
Hoje dentro dos 3 primeiros MBs eu tenho um método que chama o próximo MB da hierarquia, setando os parametros para detalhar.
Teria uma prática melhor de se fazer isso ?
Se usasse apenas um facilitaria, pois estaria tudo ali e evitaria ficar chamando outros MBs, mas seria certo ?
August 27th, 2009 at 10:15 am
Rafael, acha que é válido criar managed-beans mais que o necessário apenas para tentar deixar sua estrutura mais organizada?
Ótimo post, tente não ficar tanto tempo sem postar hehehe
Abraços,
August 27th, 2009 at 11:02 am
Parabéns pelo post!
Muitas coisas que fazemos acabam sendo feitas por herança de experiências anteriores a capacidade deve haver espaço para auto-crítica, fugindo da mesmice: “Sempre fiz assim e deu certo!” pensar em novas soluções nos leva a evolução.
esse post me fez refletir muito sobre o assunto…
August 27th, 2009 at 11:30 am
Minha dica para simplificar o JSF: NUNCA USE JSF!
August 27th, 2009 at 7:48 pm
Pensando de um outro ponto de vista, mas vejam bem, não estou afirmando.
E se um managed-bean pertencesse apenas a uma determinada entidade (modelo), não seria o mais correto.
Visto que uma página pode utilizar informações de mais de um managed-bean.
August 28th, 2009 at 5:28 am
Sempre nos salvando com seus posts.
Parabéns Rafael
September 5th, 2009 at 9:00 am
Belo artigo Ponte,
Eu que estou agora voltando no tempo e trabalhando action-based, entendi bem melhor como trabalhar com MB.
September 29th, 2009 at 8:22 am
Eu fiquei com uma dúvida, quando voce diz apenas “um” managedbean? Voce quer dizer apenas um por pagina? Ou por aplicação? Ou ainda quem sabe por regra de negocio/funcionalidade??
November 4th, 2009 at 9:18 am
Ah, se todos que conheço pensassem em seus managedBeans como objetos que realmente possuem estado.
Vejo os managedBeans muito ‘orientado a funções’ apenas por acessarem diretamente as páginas (visão).
Leitura obrigatória, esse post.
Parabéns.
November 7th, 2009 at 8:36 am
Pessoal, é simples: Para cada arquivo [*.jsf, *.jsp, *.xhtml], devemos ter um - e apenas um - managed bean. O que acontece: cada página tem seu comportamento, e este comportamento é definido por um managed bean. Ele existe para não poluirmos nossa página com EL’s, tags cheias de comportamento. Caso tenhamos que manter estado da tela, quem sabe sobre o estado é a instância do managed bean. É ele o responsável por manter um escopo de conversação. Por isso, cada recurso web deveria estar associado a um único managed bean. Não faz sentido, e fica poluído, termos diversos managed beans associados a um recurso. Em um projeto grande perdemos o controle (e eu já vi isso várias vezes). A definição de como trabalhar com managed beans também depende das necessidades e de outras definições arquiteturais. Particularmente, eu não aceito o uso de ’scope’ session em managed beans. Isso é algo raro de acontecer. O problema é que o JSF 1 não provê maneira simples de manter estado de managed beans com escopo de requisição no servidor. A solução acaba sendo recorrer a componentes de bibliotecas alternativas: (t:saveState, a4j:keepAlive, …). Porém, ambos se comportam de forma diferente, e a maioria dos desenvolvedores que fazem uso deles, não sabem como realmente funcionam. Vou parar por aqui, mas tem muito mais pontos a se considerar.
November 8th, 2009 at 7:41 am
Olá Felipe,
Não há uma regra sobre quantos managed beans devemos implementar para resolver um problema. Como disse no post, hoje em dia eu ainda tenho minhas dúvidas sobre a necessidade de termos mais que um managed bean por tarefa/funcionalidade/UC. Mas ainda não descarto que em certos cenários isso pode fazer sentido.
Ter um managed bean responsável pela navegação faz sentido quando nos utilizamos de uma abordagem com grande uso de AJAX e baseada em “navegação orientada a estados”. O que é comumente visto em sistema coorporativos (mesmo achando que JSF não seja o ideal fora dessa realidade).
JSF é um framework literalmente “core”. Ele foi concebido para ser estendido, o seu uso isolado beira a INUTILIDADE. Trabalhar com JSF sem frameworks e componentes auxiliares para estende-lo ou flexibiliza-lo é inviável no mundo real. Eu tenho um post em draft sobre o assunto, em breve, se a coragem e o tempo permitir, eu devo estar postando algo.
November 9th, 2009 at 6:37 am
Ótimo Rafael,
Realmente o uso isolado de JSF é inútil. Porém, sua extensão requer cuidados. A empresa onde trabalho hoje foi cobaia de experimentos do querido Urubatan na criação do Spring Annotations, framework já removido de todas aplicações da empresa atualmente. Uma boa configuração com o Spring atual, facelets, e [Richfaces, Tomahawk] atende diversas necessidades. Pro cliente que quiser pagar, temos o renovado ADF. Mas reinventar a roda não vale a pena. Eu, particularmente, acredito que apenas o NavigationHandler exige uma implementação na versão 1 do JSF.
Aguardo seu post.