Apa itu JSP? Pengantar Halaman JavaServer

JavaServer Pages (JSP) adalah teknologi standar Java yang memungkinkan Anda menulis halaman dinamis berdasarkan data untuk aplikasi web Java Anda. JSP dibangun di atas spesifikasi Java Servlet. Kedua teknologi tersebut biasanya bekerja bersama, terutama dalam aplikasi web Java yang lebih lama. Dari perspektif pengkodean, perbedaan paling jelas di antara mereka adalah bahwa dengan servlet Anda menulis kode Java dan kemudian menanamkan markup sisi klien (seperti HTML) ke dalam kode itu, sedangkan dengan JSP Anda mulai dengan skrip atau markup sisi klien, lalu menyematkan Tag JSP untuk menghubungkan halaman Anda ke backend Java.

JSP juga terkait erat dengan JSF (JavaServer Faces), spesifikasi Java untuk membangun aplikasi web MVC (model-view-controller). JSP adalah teknologi yang relatif lebih sederhana dan lebih tua daripada JSF, yang merupakan standar untuk kerangka kerja web Java seperti Eclipse Mojarra, MyFaces, dan PrimeFaces. Meskipun tidak jarang melihat JSP digunakan sebagai frontend untuk aplikasi JSF lama, Facelet adalah teknologi tampilan yang lebih disukai untuk implementasi JSF modern.

Meskipun JSP mungkin bukan pilihan pertama Anda untuk membangun halaman web dinamis, ini adalah teknologi web Java inti. Halaman JSP relatif cepat dan mudah dibuat, dan mereka berinteraksi secara mulus dengan servlet Java dalam wadah servlet seperti Tomcat. Anda akan menemukan JSP di aplikasi web Java yang lebih lama, dan dari waktu ke waktu Anda mungkin merasa berguna untuk membangun halaman web Java yang sederhana dan dinamis. Sebagai pengembang Java, Anda setidaknya harus terbiasa dengan JSP.

Artikel ini akan menjadi pengantar singkat untuk Halaman JavaServer, termasuk JSP Standard Tag Library (JSTL). Contoh menunjukkan kepada Anda bagaimana menulis halaman HTML sederhana, menanamkan tag JSP untuk menghubungkan ke servlet Java, dan menjalankan halaman dalam wadah servlet.

Lihat artikel sebelumnya dalam seri ini untuk mempelajari lebih lanjut tentang servlet Java dan Wajah JavaServer.

JSP di Jakarta EE

Setelah Java EE 8 dirilis, Oracle memindahkan pengelolaan Java Enterprise Edition (Java EE) ke Eclipse Foundation. Ke depannya, platform perusahaan Java telah diubah namanya menjadi Jakarta EE. Bersama dengan spesifikasi Java Servlet dan JSF, JSP adalah salah satu teknologi web Java yang disertakan untuk dukungan dan peningkatan berkelanjutan di Jakarta EE.

Menulis halaman JSP

Halaman JSP sederhana (.jsp) terdiri dari markup HTML yang disematkan dengan tag JSP. Saat file diproses di server, HTML ditampilkan sebagai tampilan aplikasi, halaman web. Tag JSP tertanam akan digunakan untuk memanggil kode dan data sisi server. Diagram pada Gambar 1 menunjukkan interaksi antara HTML, JSP, dan server aplikasi web.

Matthew Tyson

Kode 1 menunjukkan halaman JSP sederhana.

Daftar 1. Halaman JSP sederhana

${2 * 2} should equal 4

Dalam Kode 1, Anda melihat blok HTML yang menyertakan ekspresi JSP , yang merupakan instruksi ke server Java yang ditulis menggunakan Expression Language (EL). Dalam ekspresi " ${2 * 2}", " ${}" adalah sintaks JSP untuk menginterpolasi kode ke dalam HTML. Saat dijalankan, JSP akan menampilkan hasil eksekusi apa pun yang ada di dalam ekspresi. Dalam hal ini, outputnya adalah angka 4.

JSP dalam wadah servlet

Halaman JSP harus ditempatkan di dalam wadah servlet Java. Untuk menerapkan aplikasi web Java berdasarkan JSP dan servlet, Anda akan mengemas file .jsp, kode Java, dan metadata aplikasi dalam file .war, yang merupakan file .zip sederhana dengan struktur konvensional untuk aplikasi web.

Setelah Anda memuat JSP ke dalam wadah servlet Anda, itu akan dikompilasi menjadi servlet. JSP dan servlet Java memiliki karakteristik serupa, termasuk kemampuan untuk mengakses dan merespons objek permintaan. Apache Tomcat 9x adalah implementasi referensi untuk spesifikasi Servlet 4.0 dan JSP 2.3. (Perhatikan bahwa pembaruan antara JSP 2.2 dan 2.3 relatif kecil.)

Penampung servlet vs. server aplikasi

Di dunia Java, wadah servlet , juga dikenal sebagai server web, adalah seperti versi lite (bir) dari server aplikasi. Sebuah wadah servlet menangani interaksi permintaan-dan-respon dan memungkinkan interaksi tersebut untuk berinteraksi dengan subset dari kapabilitas perusahaan Java untuk aplikasi web. Server aplikasi Java menyertakan wadah servlet sebagai bagian dari tumpukan perusahaan Java lengkap, termasuk EJB, JPA, JMS, dan lainnya.

Aplikasi contoh untuk JSP

Kami akan menggunakan aplikasi contoh di Tomcat untuk membantu Anda memulai dengan Halaman JavaServer. Jika Anda belum menginstal Tomcat, telusuri halaman download Tomcat dan pilih instalasi Tomcat untuk sistem operasi Anda. Pada tulisan ini, Tomcat 9 adalah rilis terbaru, kompatibel dengan Servlet 4.0 dan JSP 2.3.

Anda dapat menginstal Tomcat sebagai layanan Windows, atau menjalankannya dari baris perintah dengan /bin/catalina.sh startatau /bin/catalina.bat. Either way, mulai Tomcat, lalu pergi ke localhost:8080untuk melihat halaman selamat datang Tomcat yang ditunjukkan pada Gambar 2.

Matthew Tyson

Objek Implisit di Tomcat

Di halaman selamat datang Tomcat, klik tautan Contoh , lalu klik Contoh JSP .

Selanjutnya, buka aplikasi web Implicit Objects Execute . Gambar 3 menunjukkan keluaran untuk aplikasi ini. Luangkan waktu sebentar untuk mempelajari hasil ini.

Matthew Tyson

Parameter permintaan

Objek implisit adalah objek bawaan yang dapat diakses melalui halaman JSP. Sebagai pengembang halaman web, Anda akan menggunakan objek-objek ini untuk membuat akses ke hal-hal seperti parameter permintaan , yang merupakan data yang dikirim dari browser saat mengeluarkan permintaan HTTP. Pertimbangkan URL browser untuk Objek Implisit:

 //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar 

Parameternya adalah ?foo=bar, dan Anda dapat melihatnya tercermin dalam output di halaman web, di mana tabel menunjukkan "EL Expression" dan nilainya adalah "bar." Untuk mengujinya, ubah URL ke //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , tekan Enter , dan Anda akan melihat perubahan tercermin dalam output.

Contoh ini adalah pengantar yang sangat sederhana untuk menggunakan tag JSP untuk mengakses parameter permintaan sisi server. Dalam hal ini, halaman JSP menggunakan objek built-in (implisit) yang dipanggil paramuntuk mengakses parameter permintaan aplikasi web. The paramobjek tersedia di dalam sintaks ekspresi JSP yang Anda lihat di Listing 1.

Dalam contoh itu, kami menggunakan ekspresi untuk melakukan beberapa matematika:, ${2 * 2}keluaran yang mana 4.

Dalam contoh ini, ekspresi digunakan untuk mengakses objek dan lapangan pada objek yang: ${param.foo}.

JSP dalam aplikasi web

Pada halaman Objek Implisit, klik panah kembali, diikuti dengan tautan Sumber . Ini akan mengarahkan Anda ke kode JSP untuk aplikasi web Implicit Objects, yang ditunjukkan pada Listing 2.

Kode 2. Kode JSP untuk aplikasi web Implicit Objects

     JSP 2.0 Expression Language - Implicit Objects   
    
This example illustrates some of the implicit objects available in the Expression Language. The following implicit objects are available (not all illustrated here):
  • pageContext - the PageContext object
  • pageScope - a Map that maps page-scoped attribute names to their values
  • requestScope - a Map that maps request-scoped attribute names to their values
  • sessionScope - a Map that maps session-scoped attribute names to their values
  • applicationScope - a Map that maps application-scoped attribute names to their values
  • param - a Map that maps parameter names to a single String parameter value
  • paramValues - a Map that maps parameter names to a String[] of all values for that parameter
  • header - a Map that maps header names to a single String header value
  • headerValues - a Map that maps header names to a String[] of all values for that header
  • initParam - a Map that maps context initialization parameter names to their String parameter value
  • cookie - a Map that maps cookie names to a single Cookie object.
Change Parameter foo =

EL Expression Result
\${param.foo} ${fn:escapeXml(param["foo"])}
\${param["foo"]} ${fn:escapeXml(param["foo"])}
\${header["host"]} ${fn:escapeXml(header["host"])}
\${header["accept"]} ${fn:escapeXml(header["accept"])}
\${header["user-agent"]} ${fn:escapeXml(header["user-agent"])}

JSP functions

If you're familiar with HTML, then Listing 2 should look pretty familiar. You have the expected HTML elements, followed by the ${ } JSP expression syntax introduced in Listing 1. But notice the value for param.foo: ${fn:escapeXml(param["foo"])} . The "fn:escapeXML()" is a JSP function.

A JSP function encapsulates a chunk of reusable functionality. In this case, the functionality is to escape XML. JSP offers a variety of functions, and you can also create functions yourself. To use a function, you import its library into your JSP page, then call the function.

In Listing 2, the escapeXML function is included with the line:

The syntax is pretty clear: it imports the required functions and assigns them a prefix (in this case "fn") that can be used in all following expressions.

The JSP Standard Tag Library (JSTL)

The import line in Listing 2 calls taglib, which is short for tag library, or (in this case) JSP Standard Tag Library (JSTL). Tag libraries define reusable bits of functionality for JSP. JSTL is the standard tag library, containing a collection of taglibs that ship with every servlet and JSP implementation, including Tomcat.

The "functions" library is just one of the taglibs included with JSTL. Another common taglib is the core library, which you import by calling:

Like "fn", the "c" designation is conventional, and you will see it across most JSP pages.

Securing JSP pages

An example tag from the core library is


    

which outputs the tag with the XML already escaped. This function is important because outputting content directly to a web page via ${variable} opens the door to script injection attacks. This simple function is used to protect web pages from such attacks.

The core library also includes various tags for iteration and flow control (like IF/ELSE handling).

JSTL tag classifications

There are five sets of tags included in JSTL, each designed for a specific area of web application functionality:

  • JSTL core: Dealing with logic and execution flow; conventional tag: "c"
  • JSTL formatting: Dealing with formatting (like dates) and internationalization; conventional tag: "fmt".
  • JSTL SQL: Dealing with querying SQL databases (this is usually discouraged in the view layer); conventional tag: "sql".
  • JSTL XML: Dealing with working with XML documents; conventional tag: "x".
  • JSTL functions: Dealing primarily with String manipulations; conventional tag: "fn".

Calling taglibs in JSP pages

Now that you've got a handle on JSP basics, let's make a change to the example application. To start, locate the Implicit Object app in your Tomcat installation. The path is: apache-tomcat-8.5.33/webapps/examples/jsp/jsp2/el.

Open this file and locate the functions include:

just below this line, add a new line:

Hit Return and add another new line:

Now reload the page at //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar.

Anda harus melihat pembaruan Anda tercermin dalam output.