O que é Jasper, beanName e outras dúvidas [RESOLVIDO]

Bem, não sou muito experiente em Java para web pois entrei nesse undo há pouco tempo, mas posso esclarecer algumas coisas, ou talvez todas.

Jasper, traduzindo ao pé da letra, significa jaspe, um tipo de pedra, um mineral. Num sei qual a relação que tentam fazer utilizando a palavra jasper, talvez algo relacionado com mineração de informações do jsp para convertê-lo em servlet como vc disse… Creio que num seja algo q vc deva se preocupar.

A “engine” que traduz os JSPs em Servlets e gerencia todo esse tipo de coisa é o container de servlets, por exemplo o Tomcat, que provavelmente vc está utilizando. Sendo assim os “Jaspers” do container devem ser como falei a pouco entidades que ajudam na tradução/conversão

Estudando a ação useBean do JSP, percebi um atributo que, no livro dos Deitel, diz assim:

beans Name O nome de um JavaBean que pode ser utilizado com o método instantiate da classe java.beans.Beans para carregar um JavaBean na memória.

Só que eu não entendi! Pq/para que carregar um bean na memória? Outro bean?

O useBean vai instanciar um novo objeto da classe especificada. Se vc especificar essa classe usando o parâmetro beanName, o container vai instanciar seu bean usando o método instantitate da classe java.beans.Beans que vc tem que extender na classe q vc ta usando.

A classe q vc está utilizando deve extender a classe java.beans.Beans e implementar o método instantiate que seria responsável por inicializar os campos da classe… (se fiz alguma confusão aqui, me corrijam por favor!)

O carregar na memória que é mencionado quer dizer, nesse contexto, criar uma nova instância daquela classe.

Claro que podem! Os escopos da aplicação podem ser acessados pelo objeto request, do tipo HttpServletRequest, dos métodos que vc precisa implementar (sobrescrever) na sua classe que extende HttpServlet.

Vamos supor, vc tem o método doGet, ele tem como parâmetro um HttpServletRequest e um HttpServletResponse num é? Através do request, utilizando seus métodos, vc pode acessar os escopos, da uma olhada na documentação.

Por exemplo, para acessar a sessão:

request.getSession().getAttribute( “algumaCoisaQVcSetouNaSessão” );

Isso retorna um Object, q vc precisa realizar um cast para trabalhar no objeto q vc quer.

Espero não ter sido muito confuso

Falow!

Cara, muito obrigado pelas explicações. Apenas mantive algumas dúvidas quanto ao manejamento de objetos/propriedades entre JSP’s e Servlets.

Pq tp, eu até já havia pensando no request.getSession().

Acontece que, neste caso, poderei, ainda, acessar SOMENTE os beans de escopo session, não é? Como eu faço para acessar os de escopo request, no caso de eu, por exemplo, processar algo parcialmente em uma JSP, e querer passar o restante do processamento para um servlet?

Kra, para manipulação de dados dos diversos escopos dentro de um srevlet vc deve usar:

// obtém um parâmetro do request (dados de formulário)
        // retorna uma String
        request.getParameter( "nome do parâmetro" );
        
        // obtém algum atributo que você configurou no request
        // retorna um Object
        request.getAttribute( "nome do atributo" );
        // configura atributo no request
        request.setAttribute( "nome do atributo", conteúdo ); 
        
        // obtém a sessão, e se esta ainda não foi criada, cria uma
        HttpSession sessao = request.getSession();
        
        // obtém atributo da sessão
        sessao.getAttribute( "nome do atributo" );
        // configura atributo na sessão
        sessao.setAttribute( "nome do atributo", conteúdo ); 
        
        // obtém o contexto (escopo da aplicação)
        ServletContext contexto = sessao.getServletContext();
        
        // obtém atributo da aplicação
        contexto.getAttribute( "nome do atributo" );
        // configura atributo na aplicação
        contexto.setAttribute( "nome do atributo", conteúdo );

Não se esqueça que existem muitos outros métodos no request, sessão e contexto. Da uma olhada na documentação q vc vai ver. Se vc tiver usando o netbeans ou eclipse eles vão mostrar tudo o que tem.
Existem ainda também mais dois escopos, o de página, que vc vai acessar nos jsps (são as variáveis que existem apenas no servlet da jsp) e o escopo de tag, que são variáveis q somente podem ser acessadas dentro de tags, por exemplo o varStatus da tag forEach da JSTL.

Para a manipulação dos escopos dentro de um jsp existem os objetos implícitos do jsp e também existem os objetos implícitos da expression language, dá uma pesquisa sobre isso. Esses objetos implícitos são refer~encias aos objetos que existem no servlet .

Dá uma olhada
Objetos implícitos do jsp
request
session
application
pageContext

Objetos implícitos da expression language
pageScope
requestScope
sessionScope
applicationScope
pageContext

Esses objetos implícitos não são todos... Existem mais alguns...

Dá uma pesquisada para que serve cada um e como utilizar e também nos outros que existem.

Falow!

E ae cara… po, vlw ae pelo help…

Mas é o seguinte… eu to ligado nesse negócio dos escopos e tudo o mais… a minha dúvida era principalmente em: “intercalar e intercambiar objetos entre JSP’s e servlets numa mesma sessão”.

Vou afirmar algumas coisas que compreendi, e você me corrija se estiver errado:

• escopo page: todos os beans criados com “scope=‘page’” são acessiveis só e somente só durante a execução de uma mesma página

• escopo session: os beans criados com “scope=‘session’” são acessíveis:
  pelo JSP: pelo próprio id do bean
  pelo servlet: ? como que acessa? pelo getAttribute()?

• escopo application: beans instanciados por “scope=‘application’” são acessíveis:
  pelo JSP: pelo próprio id do bean
  pelo servlet: ? como ?

• escopo request: beans instanciados com “scope=‘request’” são acessíveis:
  pelo JSP: pelo próprio id do bean
  pelo servlet: ? como ?

Da outra forma eu entendi:
Eu posso usar os métodos getAttribute() e setAttribute() tanto no JSP quanto no servlet, isso recupera e armazena objetos, respectivamente, em variáveis de escopo [scope] que eu defino, até aí tudo bem.

Mas a minha dúvida é como eu posso, em um servlet, recuperar um bean criado pelo useBean em uma JSP, sendo que o escopo é qualquer um exceto “page”.

• simplificando -
  Em uma página JSP executo esse código:

<jsp:useBean id="dataCenter" scope="request" class="com.projectalpha.DataCenter"/>

<jsp:forward page="/dataCenterProccess"/>

No código do servlet dataCenterProccess, de que forma eu posso acessar o bean do dataCenter, uma vez que ele tenha sido instanciado com escopo request, eu devo ser capaz de acessá-lo não?

Entrando na conversa agora…

O que eu entendo é o seguinte:

Temos um bean …ClasseX
Ele possui getters e setters que terão os mesmos nomes tanto na classe como na página…

Na página vc instancia esse bean para receber e colocar dados dependendo do que se trata a página, formulário ou tabela dinâmica…

No teu servlet vc irá chamar o objeto que foi instanciado pela página, possivelmente como uma collection, uma List…

Quando vc chamar esse objeto vc irá fazer um cast e assim terá uma instancia da sua “ClasseX”, a qual poderá manipular da maneira que quiser de acordo com a regra do teu negócio, com os getters e setters…

Caso vc utilize um framework boa parte do trabalho fica por conta dele…

Bem, caso eu tenha dito algo que não confere, por favor me corrijam…

hugohasth, obrigado pela participação. Tp, tu entendeste o que eu quero fazer, mas a questão é como fazer. Veja o meu post anterior ao teu. vlw

Estas afirmações agora serão baseadas no que eu vejo acontecer em minhas aplicações que utilizam-se do STRUTS para o pattern MVC…

Qualquer bean é acessado pela servlet através dos métodos tanto do HttpServletRequest como HttpSession…

HttpSession session = request.getSession();
ClasseX clazz = (ClasseX) session.getAttribute("id do bean");

ou

ClasseX clazz = (ClassX) request.getAttribute;
String nome = clazz.getNome();
nome = "mudarNome";
request.setParameter("nomeId", nome);

Tudo isso dentro do método doGet da servlet que vc criar…

É mais ou menos assim que os frameworks funcionam, com alguma inversão de controle, reflection e injeção de dependência…

E amais uma vez, para reforçar, me corrijam se estiver incorreto o que eu disse… Pois falei baseado no que programo, não pesquisei a fundo sobre o assunto!

Valeu…

Galera, até que enfim consegui descobrir o que eu queria.

A questão principal era a seguinte:

Em uma JSP, eu posso usar Beans com os seguintes escopos: page, request, session e application

O que me chamava a atenção/curiosidade era COMO um servlet poderia acessar diferentes objetos desses escopos, quais os métodos e objetos usados para isso.

Então consegui:

Se eu usar esse código na JSP:

<jsp:useBean id="dataCenter" scope="request" class="ym.util.DataCenter"/>

Poderei então capturar no servlet da seguinte maneira:

DataCenter dc = (DataCenter) request.getAttribute("dataCenter");

Nota: perceba que, dentro do servlet eu estou acessando o método getAttribute() diretamente do objeto request, isso quer dizer que estou acessando atributos instanciados com escopo “request”.

Se eu usar esse código na JSP:

<jsp:useBean id="dataCenter" scope="session" class="ym.util.DataCenter"/>

Poderei então capturar no servlet da seguinte maneira:

DataCenter dc = (DataCenter) request.getSession().getAttribute("dataCenter");

Nota: perceba que, dentro do servlet eu estou acessando o método getAttribute() NÃO diretamente do objeto request, mas sim da Session que me é retornada através do método getSession() do objeto request, isso quer dizer que estou acessando atributos instanciados com escopo “session”.

Se eu usar esse código na JSP:

<jsp:useBean id="dataCenter" scope="application" class="ym.util.DataCenter"/>

Poderei então capturar no servlet da seguinte maneira:

DataCenter dc = (DataCenter) getServletContext().getAttribute("dataCenter");

Nota: perceba que, dentro do servlet eu estou acessando o método getAttribute() NÃO diretamente do objeto request nem da Session, mas sim do contexto-geral do Servlet.

Espero que agora tenha ficado clara qual era a minha dúvida: “como, programaticamente, acessar objetos de diferentes escopos instanciados em JSP’s dentro de Servlets.”