Come evitare il codice Java nei file JSP?

Sono nuovo di Java EE e so che qualcosa come le seguenti tre linee

   

è un modo di codificare della vecchia scuola e nella versione 2 di JSP esiste un metodo per evitare il codice Java nei file JSP. Qualcuno può dirmi le linee JSP 2 alternative e quale tecnica viene chiamata?

L’utilizzo di scriptlet (quelle < % %> %% < % %> cose) in JSP è in effetti altamente scoraggiato dalla nascita di taglibs (come JSTL ) ed EL ( Expression Language , quelle ${} cose) nel lontano 2001.

I principali svantaggi degli scriptlet sono:

  1. Riusabilità: non è ansible riutilizzare gli scriptlet.
  2. Sostituibilità: non è ansible rendere astratti gli scriptlet.
  3. OO-abilità: non puoi fare uso dell’eredità / composizione.
  4. Debugability: se lo scriptlet lancia un’eccezione a metà, si ottiene solo una pagina vuota.
  5. Testabilità: gli scriptlet non sono testabili da unità.
  6. Manutenibilità: per saldo è necessario più tempo per mantenere la logica di codice mista / ingombra / duplicata.

Sun Oracle stessa raccomanda anche nelle convenzioni di codifica JSP di evitare l’uso di scriptlet ogni volta che la stessa funzionalità è ansible per le classi (tag). Qui ci sono diverse citazioni di rilevanza:

Dalla specifica JSP 1.2, si consiglia vivamente di utilizzare la libreria di tag standard JSP (JSTL) nell’applicazione Web per ridurre la necessità di scriptlet JSP nelle pagine. Le pagine che utilizzano JSTL sono, in generale, più facili da leggere e gestire.

Ove ansible, evitare gli scriptlet JSP ogni volta che le librerie di tag forniscono funzionalità equivalenti. Ciò semplifica la lettura e la manutenzione delle pagine, aiuta a separare la logica di business dalla logica di presentazione e renderà le pagine più facili da evolvere in pagine in stile JSP 2.0 (le specifiche JSP 2.0 supportano ma deumidificano l’uso di scriptlet).

Nello spirito dell’adozione del modello di progettazione model-view-controller (MVC) per ridurre l’accoppiamento tra il livello di presentazione dalla business logic, gli scriptlet JSP non dovrebbero essere utilizzati per scrivere la logica di business. Piuttosto, gli script script JSP vengono utilizzati se necessario per trasformare i dati (detti anche “oggetti valore”) restituiti dall’elaborazione delle richieste del client in un formato adatto per il client. Anche in questo caso, sarebbe meglio farlo con un servlet del front controller o un tag personalizzato.


Come sostituire scriptlet dipende interamente dal solo scopo del codice / logica. Molto spesso questo codice deve essere inserito in una class Java completa:

  • Se si desidera richiamare lo stesso codice Java su ogni richiesta, meno o più indipendentemente dalla pagina richiesta, ad esempio controllando se un utente è loggato, quindi implementare un filtro e scrivere il codice di conseguenza nel metodo doFilter() . Per esempio:

     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 mappato su un appropriato che copre le pagine JSP di interesse, non è necessario copypastare lo stesso pezzo di codice su tutte le pagine JSP.


  • Se si desidera invocare un codice Java per elaborare una richiesta, ad es. Caricare un elenco da un database per visualizzarlo in alcune tabelle, se necessario sulla base di alcuni parametri di query, quindi implementare un servlet e scrivere il codice di conseguenza nel metodo doGet() . Per esempio:

     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { List 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); } } 

    In questo modo affrontare le eccezioni è più facile. Il DB non è accessibile nel mezzo del rendering JSP, ma molto prima che il JSP sia stato visualizzato. Hai ancora la possibilità di modificare la risposta ogni volta che l’accesso al DB genera un’eccezione. Nell’esempio sopra, verrà visualizzata la pagina di errore predefinita 500, che è comunque ansible personalizzare mediante in web.xml .


  • Se si desidera invocare un codice Java per postprocedere una richiesta, ad esempio l’elaborazione di un invio di modulo, quindi implementare un servlet e scrivere il codice di conseguenza nel metodo doPost() . Per esempio:

     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. } } 

    In questo modo affrontare le diverse destinazioni delle pagine dei risultati è più semplice: rivisualizzare il modulo con errori di validazione in caso di errore (in questo esempio è ansible visualizzarlo usando ${message} in EL ) o semplicemente portarlo alla pagina di destinazione desiderata nel caso di successo.


  • Se si desidera richiamare un codice Java per controllare il piano di esecuzione e / o la destinazione della richiesta e la risposta, implementare un servlet in base al Pattern del controller anteriore di MVC . Per esempio:

     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); } } 

    O semplicemente adottare un framework MVC come JSF , Spring MVC , Wicket , ecc in modo da finire con solo una pagina JSP / Facelets e una class Javabean senza la necessità di un servlet personalizzato.


  • Se si desidera invocare un codice Java per controllare il stream all’interno di una pagina JSP, è necessario prendere un taglib (esistente) di controllo del stream come il core JSTL . Ad es. Visualizzazione List in una tabella:

     < %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> ...  
    ${product.name} ${product.description} ${product.price}

    Con tag di stile XML che si adattano bene a tutto questo HTML, il codice è meglio leggibile (e quindi meglio conservabile) di un gruppo di scriptlet con varie parentesi di apertura e chiusura ( “A che diamine appartiene questa parentesi di chiusura?” ). Un semplice aiuto è configurare la tua applicazione web per generare un’eccezione ogni volta che gli scriptlet sono ancora usati aggiungendo il seguente brano a web.xml :

       *.jsp true   

    In Facelets , il successore di JSP, che fa parte di Java EE, ha fornito il framework JSF MVC, non è già ansible utilizzare gli scriptlet . In questo modo sei costretto automaticamente a fare le cose “nel modo giusto”.


  • Se si desidera invocare un codice Java per accedere e visualizzare i dati “back-end” all’interno di una pagina JSP, è necessario utilizzare EL (Expression Language), quelle ${} cose. Ad esempio, rivisualizzando i valori di input presentati:

      

    ${param.foo} mostra il risultato di request.getParameter("foo") .


  • Se si desidera richiamare del codice Java di utilità direttamente nella pagina JSP (in genere metodi public static ), è necessario definirli come funzioni EL. C’è una funzione standard taglib in JSTL, ma puoi anche creare facilmente le funzioni da solo . Ecco un esempio di come JSTL fn:escapeXml è utile per prevenire gli attacchi XSS .

     < %@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %> ...  

    Si noti che la sensibilità XSS non è in alcun modo specificamente correlata a Java / JSP / JSTL / EL / qualsiasi, questo problema deve essere preso in considerazione in ogni applicazione web sviluppata. Il problema degli scriptlet è che non fornisce alcun metodo di prevenzione integrata, almeno non utilizzando l’API Java standard. Il successore di JSP Facelets ha già implicito l’escape dell’HTML, quindi non devi preoccuparti dei buchi XSS in Facelets.

Guarda anche:

  • Qual è la differenza tra JSP, Servlet e JSF?
  • Come funzionano Servlet, ServletContext, HttpSession e HttpServletRequest / Response?
  • Esempio di MVC di base con JSP, Servlet e JDBC
  • Modelli di progettazione in applicazioni Web Java
  • Funzionalità nascoste di JSP / Servlet

Come protezione: Disabilita gli scriptlet per sempre

Come un’altra domanda sta discutendo, puoi sempre disabilitare gli scriptlet nel tuo descrittore web.xml .

Lo farei sempre per impedire a qualsiasi sviluppatore di aggiungere scriptlet, specialmente nelle grandi aziende in cui prima o poi perderete la panoramica. Le impostazioni web.xml questo aspetto:

   *.jsp true   

JSTL offre tag per condizionali, loop, set, gets, ecc. Ad esempio:

  ...  

JSTL funziona con gli attributi di richiesta – sono spesso impostati nella richiesta da un servlet, che inoltra al JSP.

Non sono sicuro se ottengo questo corretto.

Dovresti leggere qualcosa su MVC. Spring MVC & Struts 2 sono le due soluzioni più comuni.

È ansible utilizzare i tag JSTL insieme alle espressioni EL per evitare di mescolare codice 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" %>       // and so on   

Ci sono anche framework basati su componenti come Wicket che generano molto del codice HTML per te. I tag che finiscono nell’HTML sono estremamente semplici e non c’è praticamente nessuna logica in cui si mischino. Il risultato sono pagine HTML quasi vuote come i tipici elementi HTML. Il rovescio della medaglia è che ci sono molti componenti nell’API di Wicket da imparare e alcune cose possono essere difficili da ottenere sotto questi vincoli.

Nel pattern MVC Architectural, i JSP rappresentano il livello View. Incorporare il codice java in JSP è considerato una ctriggers pratica. Puoi usare JSTL , freeMarker , velocity con JSP come “template engine”. Il fornitore di dati per tali tag dipende dai framework con cui si ha a che fare. Struts 2 e webwork come implementazione per MVC Pattern utilizzano OGNL “tecnica molto interessante per esporre le proprietà dei bean a JSP”.

L’esperienza ha dimostrato che le JSP hanno alcune imperfezioni, una delle quali è difficile evitare di mescolare il markup con il codice reale.

Se è ansible, quindi prendere in considerazione l’utilizzo di una tecnologia specializzata per ciò che è necessario fare. In Java EE 6 c’è JSF 2.0, che offre molte funzioni interessanti, tra cui l’incollaggio dei bean Java insieme alle pagine JSF attraverso l’approccio #{bean.method(argument)} .

Wicket è anche un’alternativa che separa completamente java da html, quindi un designer e un programmatore possono lavorare insieme e su diversi set di codice con poca comprensione l’uno dell’altro.

Guarda Wicket.

se vuoi semplicemente evitare gli inconvenienti della codifica Java in JSP, puoi farlo anche con gli scriplet. Basta seguire un po ‘di disciplina per avere Java minimo in JSP e quasi nessun calcolo e logica nella pagina 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();%>     

< %= showMe %>

< % for(String str : clr.listOfStrings()) { %>

< %= str %>< % } %> // and so on

Impara a personalizzare e scrivere i tuoi tag utilizzando JSTL

Nota che EL è EviL (eccezioni di runtime, refactoring)
Wicket potrebbe anche essere malvagio (prestazioni, faticoso per piccole app o semplice livello di vista)

Esempio da java2s ,

Questo deve essere aggiunto al web.xml dell’applicazione web

  /java2s /WEB-INF/java2s.tld  

crea File: java2s.tld nel / 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">   1.0 1.2 Java2s Simple Tags   bodyContentTag com.java2s.BodyContentTag JSP  howMany    

compila il seguente codice in WEB-INF \ classs \ 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; } } 

Avvia il server e carica bodyContent.jsp nel browser

 < %@ taglib uri="/java2s" prefix="java2s" %>   A custom tag: body content   This page uses a custom tag manipulates its body content.Here is its output: 
  1. java2s.com

Hai sollevato una buona domanda e anche se hai delle buone risposte, ti suggerirei di sbarazzarti di JSP. È una tecnologia obsoleta che alla fine morirà. Utilizza un approccio moderno, come i motori di template. Avrai una netta separazione dei livelli di business e di presentazione e certamente nessun codice Java nei modelli, quindi puoi generare modelli direttamente dal software di editing di presentazioni web, nella maggior parte dei casi sfruttando WYSIWYG.

E certamente stare lontano dai filtri e pre e post processing, altrimenti potresti affrontare difficoltà di supporto / debug perché non sai sempre dove la variabile ottiene il valore.

per evitare il codice java nei file JSP, java ora fornisce librerie di tag come JSTL anche java ha messo a punto JSF in cui puoi scrivere tutte le strutture di programmazione sotto forma di tag

Non importa quanto tu cerchi di evitare, quando lavori con altri sviluppatori, alcuni di loro continueranno a preferire scriptlet e quindi inseriranno il codice malvagio nel progetto. Pertanto, impostare il progetto al primo segno è molto importante se si vuole veramente ridurre il codice dello scriptlet. Ci sono diverse tecniche per superare questo (compresi diversi framework che altri menzionati). Tuttavia, se si preferisce il modo JSP puro, utilizzare il file di tag JSTL. La cosa bella di questo è che puoi anche impostare le pagine master per il tuo progetto, in modo che le altre pagine possano ereditare le pagine master

Crea una pagina principale chiamata base.tag sotto il tuo WEB-INF / tag con il seguente contenuto

 < %@tag description="Overall Page template" pageEncoding="UTF-8"%> < %@attribute name="title" fragment="true" %>    <jsp:invoke fragment="title"></jsp:invoke>     

Su questa pagina mater, ho creato un frammento chiamato “titolo”, in modo che nella pagina figlio potessi inserire altri codici in questo punto della pagina principale. Inoltre, il tag verrà sostituito dal contenuto della pagina figlio

Crea una pagina figlio (child.jsp) nella cartella WebContent:

 < %@ taglib prefix="t" tagdir="/WEB-INF/tags" %>      [Put your content of the child here]   

viene utilizzato per specificare la pagina principale che si desidera utilizzare (che è base.tag in questo momento). Tutto il contenuto all’interno del tag qui sostituirà nella tua pagina principale. La tua pagina figlio può anche includere qualsiasi tag lib e puoi usarla normalmente come le altre menzionate. Tuttavia, se si utilizza un codice scriptlet qui ( < %= request.getParameter("name") %> …) e si tenta di eseguire questa pagina, si otterrà una JasperException because Scripting elements ( <%!, <jsp:declaration, <%=, <jsp:expression, <%, <jsp:scriptlet ) are disallowed here . Pertanto, non c’è modo che altre persone possano includere il codice malvagio nel file jsp

Chiamando questa pagina dal tuo controller:

Puoi facilmente chiamare il file child.jsp dal tuo controller. Anche questo funziona bene con la struttura dei montanti

Utilizza le JSTL Tag libraries in JSP, che funzioneranno perfettamente.

Basta usare il tag JSTL e l’espressione EL.

Se qualcuno è davvero contrario alla programmazione in più lingue di uno , suggerisco GWT, in teoria puoi evitare tutti gli elementi JS e HTML, perché Google Toolkit trasforma tutti i client e i codici condivisi in JS, non avrai problemi con loro, quindi hai un servizio web senza codifica in altre lingue. Anche tu puoi usare alcuni CSS predefiniti da qualche parte dato da estensioni (smartGWT o Vaadin). Non hai bisogno di imparare dozzine di annotazioni.

Ovviamente, se lo desideri, puoi inserirti nelle profondità del codice e iniettare JS e arricchire la tua pagina HTML, ma in realtà puoi evitarlo se vuoi, e il risultato sarà buono come è stato scritto in qualsiasi altro framework. Dico che vale la pena provare e il GWT di base è ben documentato.

E naturalmente molti altri programmatori hanno descritto o consigliato diverse altre soluzioni. GWT è per le persone che davvero non vogliono avere a che fare con la web part o per minimizzarla.

Un’ottima idea dal mondo Python sono i linguaggi degli attributi Template ; TAL è stato introdotto da Zope (quindi conosciuto come “Zope Page Templates”, ZPT) ed è uno standard, con implementazioni in PHP, XSLT e Java (ho usato le incarnazioni Python / Zope e PHP). In questa class di linguaggi di template, uno sopra l’esempio potrebbe assomigliare a questo:

 
Example product A nice description 1.23

Il codice sembra HTML ordinario (o XHTML) più alcuni attributi speciali in uno spazio dei nomi XML; può essere visualizzato con un browser e ottimizzato in modo sicuro da un designer. C’è il supporto per le macro e anche per i18n:

 

Our special offers

Example product A nice description 1.23

Se sono disponibili traduzioni del contenuto, vengono utilizzate.

Non so molto sull’implementazione di Java , però.

L’utilizzo di scriptlet in JSP non è una buona pratica.

Invece, puoi usare:

  1. Tag JSTL
  2. Espressioni EL
  3. Tag personalizzati: puoi definire i tuoi tag da utilizzare.

Per favore riferisci a:

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

Tecnicamente, JSP sono tutti convertiti in servlet durante il runtime . JSP è stato inizialmente creato allo scopo di disaccoppiare la logica di business e la logica di progettazione, seguendo lo schema MVC. Quindi JSP sono tecnicamente tutti i codici java durante il runtime. Ma per rispondere alla domanda, le librerie di tag vengono solitamente utilizzate per applicare la logica (rimozione dei codici Java) alle pagine JSP.

Certo, sostituisci < %! counter++; %> < %! counter++; %> < %! counter++; %> da un’architettura produttore-consumatore di eventi, in cui viene notificato al livello aziendale la necessità di incrementare il contatore, reagisce di conseguenza e notifica i relatori in modo che aggiornino le viste. Sono coinvolte un certo numero di transazioni di database, poiché in futuro avremo bisogno di conoscere il nuovo e il vecchio valore del contatore, che l’ha incrementato e con quale scopo in mente. Ovviamente la serializzazione è coinvolta, poiché gli strati sono completamente disaccoppiati. Sarai in grado di incrementare il tuo contatore su RMI, IIOP, SOAP. Ma è richiesto solo HTML, che non implementare, poiché è un caso così banale. Il tuo nuovo objective è di raggiungere 250 incrementi al secondo sul tuo nuovo E7 shiny, 64 GB di RAM.

Ho più di 20 anni di programmazione, la maggior parte dei progetti falliscono prima del sestetto: riutilizzabilità sostituibilità OO-abilità debugabilità testabilità La manutenibilità è addirittura necessaria. Altri progetti, gestiti da persone che si preoccupavano solo di funzionalità, hanno avuto un grande successo. Inoltre, la struttura rigida dell’object, implementata troppo presto nel progetto, rende il codice incapace di adattarsi ai drastici cambiamenti nelle specifiche (anche agili).

Quindi considero come procrastinazione l’attività di definizione di “livelli” o strutture di dati ridondanti all’inizio del progetto o quando non specificamente richiesto.

Se usiamo le seguenti cose in un’applicazione web java, il codice java può essere eliminato dal foreground del JSP.

  1. Usa l’architettura MVC per l’applicazione web

  2. Usa i tag JSP

    un. Tag standard

    b. Tag personalizzati

  3. Linguaggio di espressione

Come evitare il codice Java nei file JSP?

È ansible utilizzare tag della libreria di tabs come JSTL oltre a Expression Language ( EL ). Ma EL non funziona bene con JSP. Quindi è probabilmente meglio abbandonare completamente JSP e usare Facelets .

Facelets è il primo linguaggio di dichiarazione delle pagine non JSP progettato per JSF (Java Server Faces) che ha fornito agli sviluppatori JSF un modello di programmazione più semplice e più potente rispetto a JSP. Risolve diversi problemi si verificano in JSP per lo sviluppo di applicazioni web.

inserisci la descrizione dell'immagine qui

JSP 2.0 ha una funzionalità chiamata “Tag Files” , è ansible scrivere tag senza codice java esterno e tld . Devi creare un file .tag e inserirlo nei WEB-INF\tags puoi persino creare una struttura di directory per impacchettare i tuoi tag.

Per esempio:

 /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"%>  

Use it like

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

Also you can read the tag body easly

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

Use it

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

The samples are very simple but you can do lots of complicated tasks here. Please consider you can use other tags (eg: JSTL which has controlling tags like if/forEcah/chosen text manipulation like format/contains/uppercase or even SQL tags select/update ), pass all kind parameters, for example Hashmap , access session , request , … in your tag file too.

Tag File are so easy developed as you did not need to restart the server when changing them, like jsp files. This make them easy for development.

Even if you use a framework like struts 2, which have lots of good tags, you may find that having your own tags can reduce your code a lot. You can pass your tag parameters to struts and this way customize your framework tag.

You can use tag not only to avoid java but also minimize your HTML codes. I myself try to review HTML codes and build tags a lot as soon as see code duplicates start in my pages.

(Even if you end up using the java in you jsp code, which I hope not, you can encapsulate that code in a tag)

Using Scriptlets is a very old way and Not recommended. If you want directly output something in your JSP pages just use Expression Language(EL) along with JSTL .

There are also other options such as using a templating engine such as Velocity, Freemarker, Thymeleaf etc. But using plain JSP with EL and JSTL serves my purpose most of the time and it also seems the simplest for a beginner.

Also, take note that it is not a best practice to do business logic in the view layer, you should perform your business logics in the Service layer, and pass the output result to your views through a Controller.

Nothing of that is used anymore my friend, my advice is to decouple the view(css, html, javascript, etc) from the server.

In my case I do my systems handling the view with Angular and any data needed is brought from the server using rest services.

Believe me, this will change the way you design

Use backbone , angular like javascript framework for UI design and fetch the data using rest api. This will remove the java dependency from UI completely.

As many answers says, use JSTL or create your own custom tags. Here is good explanation about creating custom tags

By using JSTL tags together with EL expression you can avoid this. Put the following things in your jsp page:

 < %@ 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" %>