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.
September 29th, 2010 at 12:09 pm
Ola Rafael,
É possÃvel utilizar Entitis do JPA como beans do jsf? ( eu li que não é possÃvel/recomendávelem uma aplicação onde se utilize apenas JSF, Richfaces e JPA (meu caso) por isso nunca tentei, mas, o Jboss Seam permite fazer isso sem problemas, certo? ).
Agora eu criei uma classe que copia automaticamente os dados dos meus entitis pros Back beans e visse versa. Utilizei para isso a API reflection . Apesar de ter funcionado perfeitamente isso não é recomendável né?
September 30th, 2010 at 10:13 am
Oscar,
É possÃvel sim, basta declarar a entidade (ou qualquer classe) como managed bean no faces-config.xml. Eu não vejo problemas nisso, contudo até hoje não tive essa necessidade.
Eu não entendi seu último paragrafo. Qual a finalidade de criar uma classe para copiar as propriedades de uma entidade para o managed bean? Você poderia simplesmente utilizar a entidade dentro do managed bean.
Um abraço.
October 1st, 2010 at 7:22 am
Olá Rafael, estou com um problema ao tentar usar seu método de controle de regras de visualização.
Usando JSF “puro” ele não reconhece ‘mostrarSeCondicao’ em
rendered=”#{Bean.mostrarSeCondicao}”
como um método, mas sim como um atributo. Como você faz para que esse método seja executado corretamente? Usa alguma ferramenta adicional ao seu JSF?
Abraço!
October 1st, 2010 at 10:04 am
Vinicius,
Poderia mostrar a implementação do método “#{bean.mostrarSeCondicao}”?
December 4th, 2010 at 9:51 am
O lá Rafael,
Tenho uma classe cliente que tem um relacionamento com a classe telefone e um cliente pode ter vários telefones, ou seja, uma lista de telefones.
Não estou conseguindo passar esses telefone da view para o controller. Como devo receber estes dados na view? E como faço para o controller receber esses dados e salvar no banco.
Estou usando hibernate.
December 6th, 2010 at 11:07 am
Erika,
Esse tipo de questionamento pode te trazer a várias respostas e soluções dependendo do cenário.
Logo, se possÃvel, seria interessante você se juntar ao grupo #javasf (http://groups.google.com/group/javasf) e levantar este questionamento na lista. Com certeza você terá um excelente feedback dos membros.
Um abraço.
December 22nd, 2010 at 5:01 am
[...] lendo: http://www.rponte.com.br/2009/08/27/managed-beans-nao-complique-simplifique/ Tag: jsf • managed beans Click here to cancel reply. Name [...]
January 25th, 2011 at 9:15 pm
[...] somente seus componentes de tela e assim fica fácil para um design trabalhar com o visual, um bom artigo sobre isso é do Rafael Pontes referência em JSF, então vamos [...]
February 1st, 2011 at 9:33 am
Como vai Rafael?
Estou com um problemão aqui. (segue código)
na página com a pesquisa
no método do Bean
public String produtoViewLink(Produto produtoAux){
this.produto = produtoAux;
return “produtoView”;
}
na view de retorno
#{produtoBB.produto.nome}
caso eu remova a action do h:commandLink action=”produtoBB.produtoViewLink(item)”, funciona perfeitamente.
E segue o erro:
SEVERE: Erro…javax.servlet.ServletException: /pesquisa.xhtml @73,126 action=”#{produtoBB.produtoViewLink(item)}” Error Parsing: #{produtoBB.produtoViewLink(item)}
e LOG
SEVERE: Servlet.service() for servlet Faces Servlet threw exception
org.apache.el.parser.ParseException: Encountered ” “(” “( “” at line 1, column 28.
Was expecting one of:
“}” …
“.” …
“[” …
Ele chora alguma coisa na EL, qual devo usar?
Não queria ter que recorrer ao uso de biding com escopo de session. Sei que é feio, errado, no entanto é que venho fazendo. Espero que por enquanto.
Outra dúvida: é possÃvel usar biding nos dataTable e recuperar o valor da linha clicada usando beans com escopo de request?
Rafael, Só você para estas questões, Obrigado!
February 1st, 2011 at 9:41 am
Pesquisando sobre o erro que citei encontrei vários fóruns dizendo que não é possÃvel passar parâmetros por EL. Pelo seu post, Rafael, isso não é verdade. Pode nos ajudar.
Um dos fóruns que citei
http://www.guj.com.br/java/220736-duvida-basica-com-jsf
February 1st, 2011 at 10:05 am
Pesquisando um pouco mais, e sempre devia começar pelo seu site. Encontrei a solução para o primeiro problema em um de seus posts.
das EL
http://www.rponte.com.br/2008/10/23/estendendo-jsf-el-com-jboss-el/
February 1st, 2011 at 10:12 am
No entanto, infelizmente como Corinthiano e agora tentando ser programador, sei bem disso. Tanho outro:
A action não é executada dentro da dataTable (segue código sem a notação , para que possa aparecer no post
View
h:dataTable value=”#{pesquisaBB.produtos}” var=”item” id=”pesquisaDataTable” styleClass=”ui-datatable” headerClass=”textAlignLeft”
h:column
h:form id=”itemView2″
h:commandLink value=”#{item.nome}” action=”#{produtoBB.produtoViewLink(item)}”/
/h:form
/h:column
/h:dataTable
Bean
public String produtoViewLink(Produto produtoAux){
System.out.println(”Passei por aqui!”);
this.produto = produtoAux;
return “produtoView”;
}
Coloquei inclusive um System para testar e nada, inclusive elevei o contexto dos Beans para session e nada. O Server nada executa.
February 1st, 2011 at 10:15 am
Olá Fabiano,
Como você mesmo já descobriu como resolver o seu primeiro problema (existe uma link de referência também nesse post, rss), então vou pular sua dúvida, ok?
Segunda dúvida: sim, você pode recuperar o valor da linha clicada mesmo o seu managed bean estando em request. 1) Uma maneira simples é utilizando algum componente que estenda o escopo conversacional, um escopo maior que request e menor que session, como t:saveState do Tomahawk ou a4j:keepAlive do Richfaces. 2) A maneira complicadinha é garantir que sempre que a dataTable avaliar a EL que representa a lista de objetos o managed bean retorne a mesma lista (mesmo que tenha que ir buscar de novo no banco).
Este post do BalusC tem algumas dicas,
http://balusc.blogspot.com/2006/06/using-datatables.html
Espero que tenha te ajudado.
Um abraço.
February 3rd, 2011 at 8:26 am
Rafael, ajudou muito. Obrigado!
Você sabe dizer se a primefaces tem um componente com esta caracterÃstica das t:saveState e a4j:keepAlive?
February 14th, 2011 at 8:30 am
Olá a todos, Estou usando a biblioteca primefaces e queria saber se esta tem algum contexto maior que request e menor que session.
April 11th, 2011 at 6:29 pm
Boa noite Rafael.
Estou com um problema, espero que vc possa me ajudar. Tenho duas páginas JSF, um para listar os clientes outro para edita-los também tenho três managed bean dois deles com o escopo request e um com o esposo session, uso os de request receber dados e passar para o de session e ele deve acessar os métodos do meu sessionBean porém quando tento acessar não consigo pegar a seção. Será que pode me ajudar ?
Desde já obrigado.
June 20th, 2011 at 11:34 am
“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” - Disse tudo e mais um pouco…
August 26th, 2011 at 3:11 pm
Para otimizar e alavancar o uso de conceito JSF-2, utilize-o SEMPRE em conjunto com o JBoss-Seam!!!! Ele resolve problemas de Beans mantidos, transação, etc…. Integra de forma eficaz e graciosa toda arquitetura q elvouve JSF, com alta curva de produtividade.
September 10th, 2011 at 12:58 pm
Depois que li este post, minha mente abriu, muito bom mesmo parabens…
October 12th, 2011 at 10:33 am
Bom galera, minha duvida é a seguinte, estou precisando passar valores entre beans. Por exemplo, o usuário faz login no sistema, um atribuito grava o usuário logado, com isso em outros beans preciso saber o usuário que está logado no sistema. Como faço isso no JSF 2.0 ? Grato pela ajuda.
February 3rd, 2012 at 6:31 pm
I’d need to verify with you here. Which isn’t something I often do! I take pleasure in reading a post that may possibly make folks believe. In addition, thanks for permitting me to comment! 506961
February 4th, 2012 at 4:16 am
Greetings! Quick question that’s completely off topic. Do you know how to make your site mobile friendly? My weblog looks weird when viewing from my iphone. I’m trying to find a template or plugin that might be able to fix this problem. If you have any recommendations, please share. Appreciate it! 341240
February 4th, 2012 at 4:45 am
Hey! Great stuff, please keep us posted when you post something like that! 326346