Apa itu JSP? Pengenalan kepada JavaServer Pages

JavaServer Pages (JSP) adalah teknologi standar Java yang memungkinkan anda menulis halaman yang dinamis dan didorong oleh data untuk aplikasi web Java anda. JSP dibina di atas spesifikasi Java Servlet. Kedua-dua teknologi biasanya berfungsi bersama, terutama dalam aplikasi web Java yang lebih lama. Dari perspektif pengekodan, perbezaan yang paling jelas antara mereka adalah dengan servlet anda menulis kod Java dan kemudian menanamkan markup sisi klien (seperti HTML) ke dalam kod itu, sedangkan dengan JSP anda mulakan dengan skrip atau markup sisi klien, kemudian sematkan Tag JSP untuk menghubungkan halaman anda ke backend Java.

JSP juga berkait rapat dengan JSF (JavaServer Faces), spesifikasi Java untuk membangun aplikasi web MVC (model-view-controller). JSP adalah teknologi yang lebih sederhana dan lebih tua daripada JSF, yang merupakan standard untuk kerangka web Java seperti Eclipse Mojarra, MyFaces, dan PrimeFaces. Walaupun tidak jarang melihat JSP digunakan sebagai frontend untuk aplikasi JSF yang lebih tua, Facelets adalah teknologi pandangan pilihan untuk pelaksanaan JSF moden.

Walaupun JSP mungkin bukan pilihan pertama anda untuk membina laman web dinamik, ini adalah teknologi web inti Java. Halaman JSP agak cepat dan mudah dibina, dan mereka berinteraksi dengan lancar dengan servlet Java dalam wadah servlet seperti Tomcat. Anda akan menemui JSP dalam aplikasi web Java yang lebih lama, dan dari semasa ke semasa anda mungkin berguna untuk membina halaman web Java yang sederhana dan dinamik. Sebagai pemaju Java, sekurang-kurangnya anda harus mengenali JSP.

Artikel ini akan menjadi pengenalan pantas ke JavaServer Pages, termasuk JSP Standard Tag Library (JSTL). Contoh menunjukkan kepada anda cara menulis halaman HTML sederhana, menanamkan tag JSP untuk menyambung ke servlet Java, dan menjalankan halaman dalam wadah servlet.

Lihat artikel sebelumnya dalam siri ini untuk mempelajari lebih lanjut mengenai servlet Java dan JavaServer Faces.

JSP di Jakarta EE

Setelah peluncuran Java EE 8, Oracle memindahkan kepemimpinan Java Enterprise Edition (Java EE) ke Eclipse Foundation. Ke depan, platform perusahaan Java telah dijenamakan semula sebagai Jakarta EE. Bersama dengan spesifikasi Java Servlet dan JSF, JSP adalah salah satu teknologi web Java yang disertakan untuk sokongan dan peningkatan berterusan di Jakarta EE.

Menulis halaman JSP

Halaman JSP ringkas (.jsp) terdiri daripada markup HTML yang disertakan dengan tag JSP. Apabila fail diproses di pelayan, HTML diberikan sebagai tampilan aplikasi, halaman web. Tag JSP tertanam akan digunakan untuk memanggil kod dan data sisi pelayan. Gambar rajah dalam Rajah 1 menunjukkan interaksi antara HTML, JSP, dan pelayan aplikasi web.

Matthew Tyson

Penyenaraian 1 menunjukkan halaman JSP yang mudah.

Penyenaraian 1. Halaman JSP yang mudah

${2 * 2} should equal 4

Dalam Penyenaraian 1, anda melihat sekumpulan HTML yang menyertakan ekspresi JSP , yang merupakan arahan kepada pelayan Java yang ditulis menggunakan Bahasa Ekspresi (EL). Dalam ungkapan " ${2 * 2}", the " ${}" adalah sintaks JSP untuk interpolating code ke dalam HTML. Apabila dijalankan, JSP akan mengeluarkan hasil pelaksanaan apa sahaja yang ada di dalam ekspresi. Dalam kes ini, output akan menjadi nombor 4.

JSP dalam bekas servlet

Halaman JSP mesti disebarkan di dalam wadah servlet Java. Untuk menggunakan aplikasi web Java berdasarkan JSP dan servlet, Anda akan mengemas fail .jsp, kod Java, dan metadata aplikasi dalam fail .war, yang merupakan file .zip sederhana dengan struktur konvensional untuk aplikasi web.

Setelah anda memasukkan JSP ke dalam servlet container anda, ia akan dikompilasi menjadi servlet. JSP dan servlet Java mempunyai ciri yang serupa, termasuk kemampuan untuk mengakses dan menanggapi objek permintaan. Apache Tomcat 9x adalah implementasi rujukan untuk spesifikasi Servlet 4.0 dan JSP 2.3. (Perhatikan bahawa kemas kini antara JSP 2.2 dan 2.3 agak kecil.)

Bekas servlet berbanding pelayan aplikasi

Di dunia Java, wadah servlet , juga dikenal sebagai pelayan web, seperti versi pelayan aplikasi lite (bir). Wadah servlet menangani interaksi permintaan dan tindak balas dan membolehkan interaksi tersebut berinteraksi dengan subset kemampuan perusahaan Java untuk aplikasi web. Pelayan aplikasi Java merangkumi wadah servlet sebagai sebahagian daripada timbunan perusahaan Java penuh, termasuk EJB, JPA, JMS, dan banyak lagi.

Contoh aplikasi untuk JSP

Kami akan menggunakan aplikasi contoh di Tomcat untuk memulakan anda dengan JavaServer Pages. Sekiranya anda belum memasang Tomcat, semak ke halaman muat turun Tomcat dan pilih pemasangan Tomcat untuk sistem operasi anda. Pada penulisan ini, Tomcat 9 adalah keluaran terkini, serasi dengan Servlet 4.0 dan JSP 2.3.

Anda boleh memasang Tomcat sebagai perkhidmatan Windows, atau menjalankannya dari baris arahan dengan /bin/catalina.sh startatau /bin/catalina.bat. Walau apa pun, mulakan Tomcat, kemudian pergi localhost:8080untuk melihat halaman selamat datang Tomcat seperti yang ditunjukkan dalam Gambar 2.

Matthew Tyson

Objek Tersirat di Tomcat

Di halaman selamat datang Tomcat, klik pautan Contoh , kemudian klik Contoh JSP .

Seterusnya, buka aplikasi web Implicit Object Execute . Rajah 3 menunjukkan output untuk aplikasi ini. Luangkan masa sebentar untuk mengkaji output ini.

Matthew Tyson

Parameter permintaan

Objek tersirat adalah objek bawaan yang dapat diakses melalui halaman JSP. Sebagai pembangun laman web, Anda akan menggunakan objek ini untuk membuat akses ke hal-hal seperti parameter permintaan , yang merupakan data yang dikirim dari penyemak imbas ketika mengeluarkan permintaan HTTP. Pertimbangkan URL penyemak imbas untuk Objek Tersirat:

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

Paramennya ?foo=bar, dan anda dapat melihatnya tercermin dalam output di laman web, di mana jadual 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 yang ditunjukkan dalam output.

Contoh ini adalah pengenalan yang sangat mudah untuk menggunakan tag JSP untuk mengakses parameter permintaan sisi pelayan. Dalam hal ini, halaman JSP menggunakan objek bawaan (tersirat) yang dipanggil paramuntuk mengakses parameter permintaan aplikasi web. The paramobjek boleh didapati di dalam ungkapan sintaks JSP yang telah kaulihat pada Penyenaraian 1.

Dalam contoh itu, kami menggunakan ungkapan untuk melakukan beberapa matematik:, ${2 * 2}output yang mana 4.

Dalam contoh ini, ungkapan yang digunakan untuk mengakses objek dan bidang yang di objek itu: ${param.foo}.

JSP dalam aplikasi web

Pada halaman Objek Tersirat, klik anak panah belakang, diikuti dengan pautan Sumber . Ini akan membawa anda ke kod JSP untuk aplikasi web Objek Tersirat, yang ditunjukkan dalam Penyenaraian 2.

Penyenaraian 2. Kod JSP untuk aplikasi web Objek Tersirat

     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 mesti melihat kemas kini anda tercermin dalam output.