Como evitar o código Java nos arquivos JSP?

Eu sou novo no Java EE e sei que algo como as três linhas a seguir

<%= x+1 %>
<%= request.getParameter("name") %>
<%! counter++; %>

é uma maneira antiga de codificação e, na versão 2 do JSP, existe um método para evitar o código Java nos arquivos JSP. Alguém pode me dizer as linhas alternativas JSP 2, e como essa técnica é chamada?

O uso de scriptlets (essas <% %>coisas) no JSP é realmente altamente desencorajado desde o nascimento de taglibs (como JSTL ) e EL ( Expression Language , essas ${}coisas) em 2001.

As principais desvantagens dos scriptlets são:

1. Reutilização: você não pode reutilizar scripts.
2. Substituição: você não pode tornar os scriptlets abstratos.
3. Capacidade OO: você não pode usar herança / composição.
4. Depuração: se o scriptlet lança uma exceção até a metade, tudo o que você obtém é uma página em branco.
5. Testabilidade: os scriptlets não podem ser testados por unidade.
6. Manutenção: por saldo, é necessário mais tempo para manter a lógica de código mesclada / confusa / duplicada.

O próprio Sun Oracle também recomenda nas convenções de codificação JSP evitar o uso de scriptlets sempre que a mesma funcionalidade for possível pelas classes (tag). Aqui estão várias citações de relevância:

Na Especificação JSP 1.2, é altamente recomendável que a JSTL (JSP Standard Tag Library) seja usada em seu aplicativo da web para ajudar reduzir a necessidade de scriptlets JSP em suas páginas. As páginas que usam JSTL são, em geral, mais fáceis de ler e manter.

...

Sempre que possível, evite scripts JSP sempre que as bibliotecas de tags fornecerem funcionalidade equivalente. Isso facilita a leitura e a manutenção das páginas, ajuda a separar a lógica de negócios da lógica de apresentação e facilita a evolução das páginas para páginas no estilo JSP 2.0 (a JSP 2.0 Specification suporta, mas não enfatiza o uso de scriptlets).

...

No espírito de adotar o padrão de design do MVC (Model-View-Controller) para reduzir o acoplamento entre a camada de apresentação da lógica de negócios, os scriptlets JSP não devem ser usados para escrever a lógica de negócios. Em vez disso, os scriptlets JSP são usados, se necessário, para transformar dados (também chamados de "objetos de valor") retornados do processamento das solicitações do cliente em um formato adequado para o cliente. Mesmo assim, isso seria melhor com um servlet do controlador frontal ou uma tag personalizada.

Como substituir scriptslet depende inteiramente do único objetivo do código / lógica. Com mais freqüência, esse código deve ser colocado em uma classe Java totalmente válida:

• Se você deseja chamar o mesmo código Java em todas as solicitações, menos ou mais, independentemente da página solicitada, por exemplo, verificando se um usuário está logado, implemente um filtro e escreva o código de acordo com o doFilter()método. Por exemplo:

  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
      if (((HttpServletRequest) request).getSession().getAttribute("user") == null) {
          ((HttpServletResponse) response).sendRedirect("login"); // Not logged in, redirect to login page.
      } else {
          chain.doFilter(request, response); // Logged in, just continue request.
      }
  }

  Quando mapeado em uma <url-pattern>cobertura apropriada das páginas JSP de interesse, você não precisa copiar novamente o mesmo trecho de código nas páginas JSP gerais.

  ---

• Se você deseja chamar algum código Java para pré - processar uma solicitação, por exemplo, pré-carregando alguma lista de um banco de dados para exibir em alguma tabela, se necessário com base em alguns parâmetros de consulta, implemente um servlet e escreva o código de acordo com o doGet()método. Por exemplo:

  protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      try {
          List<Product> products = productService.list(); // Obtain all products.
          request.setAttribute("products", products); // Store products in request scope.
          request.getRequestDispatcher("/WEB-INF/products.jsp").forward(request, response); // Forward to JSP page to display them in a HTML table.
      } catch (SQLException e) {
          throw new ServletException("Retrieving products failed!", e);
      }
  }

  Dessa forma, lidar com exceções é mais fácil. O banco de dados não é acessado no meio da renderização JSP, mas muito antes da exibição do JSP. Você ainda tem a possibilidade de alterar a resposta sempre que o acesso ao banco de dados lança uma exceção. No exemplo acima, a página de erro padrão 500 será exibida e você poderá personalizar de qualquer maneira com um <error-page>in web.xml.

  ---

• Se você deseja chamar algum código Java para pós - processar uma solicitação, por exemplo, processar uma submissão de formulário, implemente um servlet e escreva o código de acordo com o doPost()método. Por exemplo:

  protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      String username = request.getParameter("username");
      String password = request.getParameter("password");
      User user = userService.find(username, password);
  
      if (user != null) {
          request.getSession().setAttribute("user", user); // Login user.
          response.sendRedirect("home"); // Redirect to home page.
      } else {
          request.setAttribute("message", "Unknown username/password. Please retry."); // Store error message in request scope.
          request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response); // Forward to JSP page to redisplay login form with error.
      }
  }

  Desta forma, lidar com diferentes destinos página de resultados é mais fácil: reexibir o formulário com erros de validação no caso de um erro (neste exemplo em particular, você pode exibi-la novamente usando ${message}em EL ), ou apenas tomar para a página de destino desejado em caso de sucesso.

  ---

• Se você desejar chamar algum código Java para controlar o plano de execução e / ou o destino da solicitação e da resposta, implemente um servlet de acordo com o Front Controller Pattern do MVC . Por exemplo:

  protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      try {
          Action action = ActionFactory.getAction(request);
          String view = action.execute(request, response);
  
          if (view.equals(request.getPathInfo().substring(1)) {
              request.getRequestDispatcher("/WEB-INF/" + view + ".jsp").forward(request, response);
          } else {
              response.sendRedirect(view);
          }
      } catch (Exception e) {
          throw new ServletException("Executing action failed.", e);
      }
  }

  Ou apenas adote uma estrutura MVC como JSF , Spring MVC , Wicket , etc, para que você acabe com apenas uma página JSP / Facelets e uma classe JavaBean sem a necessidade de um servlet personalizado.

  ---

• Se você deseja chamar algum código Java para controlar o fluxo dentro de uma página JSP, precisará pegar um taglib de controle de fluxo (existente) como o núcleo JSTL . Por exemplo, exibindo List<Product>em uma tabela:

  <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  ...
  <table>
      <c:forEach items="${products}" var="product">
          <tr>
              <td>${product.name}</td>
              <td>${product.description}</td>
              <td>${product.price}</td>
          </tr>
      </c:forEach>
  </table>

  Com tags no estilo XML que se encaixam perfeitamente em todo esse HTML, o código é melhor legível (e, portanto, melhor de manter) do que um monte de scriptlets com várias chaves de abertura e fechamento ( "Onde diabos essa chave de fechamento pertence?" ). Uma ajuda fácil é configurar seu aplicativo da web para gerar uma exceção sempre que scriptslet ainda forem usados, adicionando a seguinte parte a web.xml:

  <jsp-config>
      <jsp-property-group>
          <url-pattern>*.jsp</url-pattern>
          <scripting-invalid>true</scripting-invalid>
      </jsp-property-group>
  </jsp-config>

  No Facelets , o sucessor do JSP, que faz parte do JSF da estrutura MVC fornecida pelo Java EE , já não é possível usar scripts . Dessa forma, você é automaticamente forçado a fazer as coisas "do jeito certo".

  ---

• Se você desejar chamar algum código Java para acessar e exibir dados de "back-end" dentro de uma página JSP, precisará usar EL (Expression Language), essas ${}coisas. Por exemplo, exibindo novamente os valores de entrada enviados:

  <input type="text" name="foo" value="${param.foo}" />

  O ${param.foo}exibe o resultado de request.getParameter("foo").

  ---

• Se você desejar chamar algum código Java utilitário diretamente na página JSP (normalmente public staticmétodos), será necessário defini-los como funções EL. Há um taglib de funções padrão no JSTL, mas você também pode criar funções facilmente . Aqui está um exemplo de como o JSTL fn:escapeXmlé útil para evitar ataques XSS .

  <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
  ...
  <input type="text" name="foo" value="${fn:escapeXml(param.foo)}" />

  Observe que a sensibilidade do XSS não está de forma alguma especificamente relacionada a Java / JSP / JSTL / EL / qualquer que seja, esse problema precisa ser levado em consideração em todos os aplicativos da Web que você desenvolver. O problema dos scriptlets é que ele não fornece meios de prevenção interna, pelo menos não usando a API Java padrão. O Facelets sucessor do JSP já possui escape HTML implícito, portanto você não precisa se preocupar com os buracos XSS no Facelets.

Veja também:

• Qual é a diferença entre JSP, Servlet e JSF?
• Como funcionam Servlet, ServletContext, HttpSession e HttpServletRequest / Response?
• Exemplo básico de MVC com JSP, Servlet e JDBC
• Padrões de design em aplicativos da web Java
• Recursos ocultos do JSP / Servlet

Como salvaguarda: desative scripts para sempre

Como outra pergunta está sendo discutida, você pode e sempre deve desativar os scriptlets no web.xmldescritor do aplicativo da web.

Eu sempre faria isso para impedir que qualquer desenvolvedor adicionasse scriptlets, especialmente em empresas maiores, nas quais você perderá a visão geral mais cedo ou mais tarde. oweb.xml configurações são assim:

<jsp-config>
  <jsp-property-group>
    <url-pattern>*.jsp</url-pattern>
     <scripting-invalid>true</scripting-invalid>
  </jsp-property-group>
</jsp-config>

O JSTL oferece tags para condicionais, loops, sets, gets, etc. Por exemplo:

<c:if test="${someAttribute == 'something'}">
   ...
</c:if>

JSTL trabalha com atributos de solicitação - eles são configurados com mais freqüência na solicitação por um Servlet, que encaminha para o JSP.

Não tenho certeza se estou certo.

Você deve ler algo sobre o MVC. Spring MVC & Struts 2 são as duas soluções mais comuns.

Você pode usar tags JSTL junto com expressões EL para evitar a mistura de código Java e HTML:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<html>
    <head>
    </head>
    <body>

        <c:out value="${x + 1}" />
        <c:out value="${param.name}" />
        // and so on

    </body>
</html>

Também existem estruturas baseadas em componentes, como o Wicket, que geram muito do HTML para você. As tags que terminam no HTML são extremamente básicas e praticamente não há lógica misturada. O resultado são páginas HTML quase vazias, com elementos HTML típicos. A desvantagem é que há muitos componentes na API do Wicket para aprender e algumas coisas podem ser difíceis de alcançar sob essas restrições.

No padrão MVC Architectural, JSPs representam a camada View. A incorporação de código java em JSPs é considerada uma má prática. Você pode usar JSTL , FreeMarker , a velocidade com JSP como "modelo de motor". O provedor de dados para essas tags depende das estruturas com as quais você está lidando. Struts 2e webworkcomo implementação do MVC Pattern, o OGNL usa "técnica muito interessante para expor as propriedades do Beans ao JSP".

A experiência mostrou que os JSPs têm algumas deficiências, sendo uma delas difícil de evitar misturar a marcação com o código real.

Se puder, considere usar uma tecnologia especializada para o que você precisa fazer. No Java EE 6, há o JSF 2.0, que fornece muitos recursos interessantes, incluindo a colagem de beans Java junto com as páginas JSF através da #{bean.method(argument)}abordagem.

se você simplesmente deseja evitar as desvantagens da codificação Java no JSP, pode fazê-lo mesmo com scriplets. Basta seguir alguma disciplina para ter Java mínimo em JSP e quase nenhum cálculo e lógica na página JSP.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%//instantiate a JSP controller
MyController clr = new MyController(request, response);

//process action if any
clr.process(request);

//process page forwaring if necessary

//do all variable assignment here
String showMe = clr.getShowMe();%>

<html>
    <head>
    </head>
    <body>
        <form name="frm1">
            <p><%= showMe %>
            <p><% for(String str : clr.listOfStrings()) { %>
            <p><%= str %><% } %>

            // and so on   
        </form>
    </body>
</html>

Aprenda a personalizar e escrever suas próprias tags usando JSTL

Observe que EL é EviL (exceções de tempo de execução, refatoração) O
wicket também pode ser ruim (desempenho, trabalhoso para aplicativos pequenos ou camada de visualização simples)

Exemplo de java2s ,

Isso deve ser adicionado ao web.xml do aplicativo Web

<taglib>
    <taglib-uri>/java2s</taglib-uri>
    <taglib-location>/WEB-INF/java2s.tld</taglib-location>
</taglib>

crie File: java2s.tld no / WEB-INF /

<!DOCTYPE taglib
  PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">

<!-- a tab library descriptor -->
<taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor">
    <tlib-version>1.0</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>Java2s Simple Tags</short-name>

    <!-- this tag manipulates its body content by converting it to upper case
    -->
    <tag>
        <name>bodyContentTag</name>
        <tag-class>com.java2s.BodyContentTag</tag-class>
        <body-content>JSP</body-content>
        <attribute>
          <name>howMany</name>
        </attribute>
    </tag>
</taglib>

compile o seguinte código em WEB-INF \ classes \ com \ java2s

package com.java2s;

import java.io.IOException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyContent;
import javax.servlet.jsp.tagext.BodyTagSupport;

public class BodyContentTag extends BodyTagSupport{
    private int iterations, howMany;

    public void setHowMany(int i){
        this.howMany = i;
    }

    public void setBodyContent(BodyContent bc){
        super.setBodyContent(bc);
        System.out.println("BodyContent = '" + bc.getString() + "'");
    }

    public int doAfterBody(){
        try{    
            BodyContent bodyContent = super.getBodyContent();
            String bodyString  = bodyContent.getString();
            JspWriter out = bodyContent.getEnclosingWriter();

            if ( iterations % 2 == 0 ) 
                out.print(bodyString.toLowerCase());
            else
                out.print(bodyString.toUpperCase());

            iterations++;
            bodyContent.clear(); // empty buffer for next evaluation
        }
        catch (IOException e) {
            System.out.println("Error in BodyContentTag.doAfterBody()" + e.getMessage());
            e.printStackTrace();
        } // end of catch

        int retValue = SKIP_BODY;

        if ( iterations < howMany ) 
            retValue = EVAL_BODY_AGAIN;

        return retValue;
    }
}

Inicie o servidor e carregue o bodyContent.jsp no navegador

<%@ taglib uri="/java2s" prefix="java2s" %>
<html>
    <head>
        <title>A custom tag: body content</title>
    </head>
    <body>
        This page uses a custom tag manipulates its body content.Here is its output:
        <ol>
            <java2s:bodyContentTag howMany="3">
            <li>java2s.com</li>
            </java2s:bodyContentTag>
        </ol>
    </body>
</html>

O Wicket também é uma alternativa que separa completamente o java do html, para que um designer e programador possam trabalhar juntos e em diferentes conjuntos de códigos com pouco entendimento um do outro.

Veja o Wicket.

Você levantou uma boa pergunta e, embora tenha boas respostas, sugiro que você se livre do JSP. É uma tecnologia ultrapassada que acabará por morrer. Use uma abordagem moderna, como mecanismos de modelo. Você terá uma separação muito clara das camadas de negócios e de apresentação, e certamente nenhum código Java nos modelos, para poder gerar modelos diretamente a partir do software de edição de apresentações na Web, na maioria dos casos utilizando o WYSIWYG.

E certamente fique longe de filtros e pré e pós-processamento, caso contrário, você poderá lidar com dificuldades de suporte / depuração, pois nem sempre sabe onde a variável obtém o valor.

para evitar o código java nos arquivos JSP, o java agora fornece bibliotecas de tags como o JSTL e o java criou o JSF no qual você pode escrever todas as estruturas de programação na forma de tags

Não importa o quanto tente evitar, quando você trabalha com outros desenvolvedores, alguns deles ainda preferem scriptlet e, em seguida, inserem o código incorreto no projeto. Portanto, a configuração do projeto no primeiro sinal é muito importante se você realmente deseja reduzir o código do scriptlet. Existem várias técnicas para superar isso (incluindo várias estruturas mencionadas anteriormente). No entanto, se você preferir a maneira JSP pura, use o arquivo de tag JSTL. O bom disso é que você também pode configurar páginas mestras para o seu projeto, para que as outras páginas possam herdar as páginas mestras.

Crie uma página mestre chamada base.tag em suas tags WEB-INF / com o seguinte conteúdo

<%@tag description="Overall Page template" pageEncoding="UTF-8"%>

<%@attribute name="title" fragment="true" %>

<html>
  <head>
    <title>  
       <jsp:invoke fragment="title"></jsp:invoke>
    </title>

  </head>
  <body>
    <div id="page-header">
       ....
    </div>
    <div id="page-body">
      <jsp:doBody/>
    </div>
    <div id="page-footer">
      .....
    </div>
  </body>
</html>

Nesta página de material, criei um fragmento chamado "title", para que na página filha pudesse inserir mais códigos nesse local da página mestre. Além disso, a tag <jsp:doBody/>será substituída pelo conteúdo da página filha

Crie a página filho (child.jsp) na sua pasta WebContent:

<%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>

<t:base>
    <jsp:attribute name="title"> 
        <bean:message key="hello.world" />
    </jsp:attribute>

    <jsp:body>
    [Put your content of the child here]
    </jsp:body>   
</t:base>

<t:base>é usado para especificar a página mestre que você deseja usar (que é base.tag no momento). Todo o conteúdo dentro da tag <jsp:body>aqui substituirá o <jsp:doBody/>da sua página mestre. Sua página filha também pode incluir qualquer tag lib e você pode usá-la normalmente como a outra mencionada. No entanto, se você usar qualquer código de scriptlet aqui ( <%= request.getParameter("name") %>...) e tentar executar esta página, receberá um JasperException because Scripting elements ( <%!, <jsp:declaration, <%=, <jsp:expression, <%, <jsp:scriptlet ) are disallowed here. Portanto, não há como outras pessoas incluírem o código incorreto no arquivo jsp

Chamando esta página do seu controlador:

Você pode facilmente chamar o arquivo child.jsp do seu controlador. Isso também funciona bem com o framework struts

Use JSTL Tag librariesno JSP, que funcionará perfeitamente.

Basta usar a tag JSTL e a expressão EL.

Se alguém é realmente contra a programação em mais de um idioma , sugiro o GWT. Teoricamente, você pode evitar todos os elementos JS e HTML, porque o Google Toolkit transforma todo o cliente e o código compartilhado em JS, e você não terá problemas com eles. você tem um serviço da web sem codificar em nenhum outro idioma. Mesmo você pode usar algum CSS padrão de algum lugar, pois é fornecido por extensões (smartGWT ou Vaadin). Você não precisa aprender dezenas de anotações.

Obviamente, se você quiser, poderá invadir as profundezas do código e injetar JS e enriquecer sua página HTML, mas, na verdade, você pode evitá-la se quiser, e o resultado será bom, como foi escrito em outras estruturas. Eu digo que vale a pena tentar, e o GWT básico está bem documentado.

E, é claro, muitos colegas programadores descrevem ou recomendam várias outras soluções. O GWT é para pessoas que realmente não querem lidar com a Web Part ou minimizá-la.

Uma idéia interessante do mundo Python são as linguagens de atributo do modelo ; O TAL foi introduzido pelo Zope (também conhecido como "Zope Page Templates", ZPT) e é um padrão, com implementações em PHP, XSLT e Java também (usei as encarnações Python / Zope e PHP). Nesta classe de linguagens de modelos, um exemplo acima pode ser assim:

<table>
    <tr tal:repeat="product products">
        <td tal:content="product/name">Example product</td>
        <td tal:content="product/description">A nice description</td>
        <td tal:content="product/price">1.23</td>
    </tr>
</table>

O código se parece com HTML comum (ou XHTML), além de alguns atributos especiais em um espaço para nome XML; Ele pode ser visualizado em um navegador e ajustado com segurança por um designer. Há suporte para macros e também para i18n:

<h1 i18n:translate="">Our special offers</h1>
<table>
    <tr tal:repeat="product products">
        <td tal:content="product/name"
            i18n:translate="">Example product</td>
        <td tal:content="product/description"
            i18n:translate="">A nice description</td>
        <td tal:content="product/price">1.23</td>
    </tr>
</table>

Se traduções do conteúdo estiverem disponíveis, elas serão usadas.

Eu não sei muito sobre a implementação Java , no entanto.

Usar scripts em JSPs não é uma boa prática.

Em vez disso, você pode usar:

1. Tags JSTL
2. Expressões EL
3. Tags personalizadas - você pode definir suas próprias tags para usar.

Por favor, consulte:

1. http://docs.oracle.com/javaee/1.4/tutorial/doc/JSTL3.html
2. EL

Claro, substitua <%! counter++; %> por uma arquitetura produtor-consumidor de eventos, onde a camada de negócios é notificada sobre a necessidade de incrementar o contador, ela reage de acordo e notifica os apresentadores para que atualizem as visualizações. Diversas transações de banco de dados estão envolvidas, pois, no futuro, precisaremos conhecer o valor novo e antigo do contador, quem o incrementou e com que objetivo em mente. Obviamente, a serialização está envolvida, uma vez que as camadas são totalmente dissociadas. Você poderá incrementar seu contador em RMI, IIOP, SOAP. Mas apenas HTML é necessário, que você não implementa, pois é um caso tão mundano. Seu novo objetivo é atingir 250 incrementos por segundo em seu novo servidor brilhante E7 de 64 GB de RAM.

Tenho mais de 20 anos em programação, a maioria dos projetos falha antes do sexteto: Reutilização Substituibilidade Capacidade OO Capacidade Debuggability Testabilidade A manutenção é necessária. Outros projetos, executados por pessoas que se preocupavam apenas com a funcionalidade, foram extremamente bem-sucedidos. Além disso, a estrutura rígida de objetos, implementada muito cedo no projeto, torna o código incapaz de ser adaptado às mudanças drásticas nas especificações (também conhecido como ágil).

Portanto, considero como procrastinação a atividade de definição de "camadas" ou estruturas de dados redundantes no início do projeto ou quando não for especificamente necessário.  

Tecnicamente, o JSP é todo convertido em Servlets durante o tempo de execução . O JSP foi criado inicialmente com o objetivo de dissociar a lógica de negócios e a lógica de design, seguindo o padrão MVC. Portanto, JSP tecnicamente são todos os códigos Java durante o tempo de execução. Mas, para responder à pergunta, as bibliotecas de tags geralmente são usadas para aplicar lógica (remover códigos Java) às páginas JSP.

Se usarmos o seguinte em um aplicativo da web java, o código java poderá ser eliminado do primeiro plano do JSP.

1. Usar arquitetura MVC para aplicativo da web

2. Usar tags JSP

   uma. Tags padrão

   b. Tags personalizadas

3. Linguagem de Expressão

Como evitar o código Java nos arquivos JSP?

Você pode usar tags da biblioteca de guias como JSTL , além do Expression Language ( EL ). Mas o EL não funciona bem com o JSP. Portanto, é provavelmente melhor deixar o JSP completamente e usar o Facelets .

Facelets é a primeira linguagem de declaração de página não JSP projetada para JSF (Java Server Faces) que forneceu um modelo de programação mais simples e mais poderoso aos desenvolvedores JSF do que o JSP. Ele resolve problemas diferentes que ocorrem no JSP para o desenvolvimento de aplicativos da web.

Fonte

O uso de Scriptlets é uma maneira muito antiga e não recomendada. Se você deseja produzir algo diretamente em suas páginas JSP, use o Expression Language (EL) junto com o JSTL .

Existem também outras opções, como o uso de um mecanismo de modelagem, como Velocity, Freemarker, Thymeleaf etc.

Além disso, observe que não é uma prática recomendada executar lógica de negócios na camada de visualização, você deve executar suas lógicas de negócios na camada Serviço e passar o resultado da saída para suas visualizações através de um Controlador.

Nada disso é mais usado meu amigo, meu conselho é desacoplar a visualização (css, html, javascript, etc) do servidor.

No meu caso, eu faço meus sistemas lidando com a visualização com Angular e todos os dados necessários são trazidos do servidor usando serviços de descanso.

Acredite, isso mudará a maneira como você cria

Use o backbone, estrutura de javascript angular como para o design da interface do usuário e busque os dados usando a API restante. Isso removerá completamente a dependência do java da interface do usuário.

O JSP 2.0 possui um recurso chamado "Arquivos de tags" , você pode escrever tags sem javacódigo externo e tld. Você precisa criar um .tagarquivo e colocá-lo emWEB-INF\tags Você pode até criar uma estrutura de diretórios para empacotar suas tags.

Por exemplo:

/WEB-INF/tags/html/label.tag

<%@tag description="Rensders a label with required css class" pageEncoding="UTF-8"%>
<%@attribute name="name" required="true" description="The label"%>

<label class="control-label control-default"  id="${name}Label">${name}</label>

Use-o como

<%@ taglib prefix="h" tagdir="/WEB-INF/tags/html"%>
<h:label  name="customer name" />

Além disso, você pode ler o corpo da tag facilmente

/WEB-INF/tags/html/bold.tag
<%@tag description="Bold tag" pageEncoding="UTF-8"%>
<b>
  <jsp:doBody/>
</b>

Use-o

<%@ taglib prefix="h" tagdir="/WEB-INF/tags/bold"%>
<h:bold>Make me bold</h:bold>

As amostras são muito simples, mas você pode executar muitas tarefas complicadas aqui. Por favor, considere que você pode usar outras tags (por exemplo: JSTLque controlam marcas como if/forEcah/chosenmanipulação de texto como format/contains/uppercaseou mesmo etiquetas de SQL select/update), passar todos os parâmetros tipo, por exemplo Hashmap, o acesso session, request... no seu arquivo de tag também.

O Tag File é tão fácil de desenvolver que você não precisa reiniciar o servidor ao alterá-lo, como arquivos JSP. Isso os torna fáceis para o desenvolvimento.

Mesmo se você usar uma estrutura como o Struts 2, que possui muitas boas tags, você pode achar que ter suas próprias tags pode reduzir muito o seu código. Você pode passar seus parâmetros de tag para struts e, dessa forma, personalizar sua tag de estrutura.

Você pode usar a tag não apenas para evitar java, mas também para minimizar seus códigos HTML. Eu mesmo tento revisar códigos HTML e criar muitas tags assim que as duplicatas de código começarem em minhas páginas.

(Mesmo se você acabar usando o java no seu código JSP, o que espero não, você pode encapsular esse código em uma tag)

Como muitas respostas dizem, use JSTL ou crie suas próprias tags personalizadas. Aqui está uma boa explicação sobre a criação de tags personalizadas

1. Faça seus valores e parâmetros dentro de suas classes de servlet
2. Busque esses valores e parâmetros em seu JSP usando JSTL / Taglib

O lado bom dessa abordagem é que seu código também é como código HTML!

Usando tags JSTL junto com a expressão EL, você pode evitar isso. Coloque o seguinte na sua página jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>