JSP nedir? JavaServer Sayfalarına Giriş

JavaServer Pages (JSP), Java web uygulamalarınız için dinamik, veriye dayalı sayfalar yazmanıza olanak tanıyan standart bir Java teknolojisidir. JSP, Java Servlet spesifikasyonu üzerine inşa edilmiştir. İki teknoloji, özellikle eski Java web uygulamalarında tipik olarak birlikte çalışır. Kodlama perspektifinden bakıldığında, aralarındaki en bariz fark, sunucu uygulamalarında Java kodu yazmanız ve ardından istemci tarafı işaretlemeyi (HTML gibi) bu koda yerleştirirken, JSP ile istemci tarafı komut dosyası veya işaretlemeyle başlayıp ardından yerleştirmenizdir. Sayfanızı Java arka ucuna bağlamak için JSP etiketleri.

JSP, MVC (model-görünüm-denetleyici) web uygulamaları oluşturmak için bir Java spesifikasyonu olan JSF (JavaServer Faces) ile de yakından ilgilidir. JSP, Eclipse Mojarra, MyFaces ve PrimeFaces gibi Java web çerçeveleri için standart olan JSF'den nispeten daha basit ve daha eski bir teknolojidir. JSP'nin eski JSF uygulamaları için ön uç olarak kullanıldığını görmek alışılmadık bir durum olmasa da, Facelets, modern JSF uygulamaları için tercih edilen görünüm teknolojisidir.

JSP, dinamik web sayfaları oluşturmak için ilk tercihiniz olmasa da, temel bir Java web teknolojisidir. JSP sayfaları nispeten hızlıdır ve oluşturulması kolaydır ve Tomcat gibi bir servlet kapsayıcısındaki Java sunucuları ile sorunsuz bir şekilde etkileşirler. Daha eski Java web uygulamalarında JSP ile karşılaşacaksınız ve zaman zaman basit, dinamik Java web sayfaları oluşturmak için yararlı bulabilirsiniz. Bir Java geliştiricisi olarak, en azından JSP'ye aşina olmalısınız.

Bu makale, JSP Standart Etiket Kitaplığı (JSTL) dahil olmak üzere JavaServer Sayfalarına hızlı bir giriş olacaktır. Örnekler size basit bir HTML sayfasının nasıl yazılacağını, bir Java sunucu uygulamasına bağlanmak için JSP etiketlerinin nasıl yerleştirileceğini ve sayfayı bir sunucu uygulaması kapsayıcısında çalıştırmayı gösterir.

Java sunucu uygulamaları ve JavaSunucusu Yüzleri hakkında daha fazla bilgi edinmek için bu serideki önceki makalelere bakın.

Jakarta EE'de JSP

Java EE 8'in piyasaya sürülmesinin ardından Oracle, Java Enterprise Edition'ın (Java EE) yönetimini Eclipse Foundation'a taşıdı. Gelecekte, Java kurumsal platformu Jakarta EE olarak yeniden markalandı. Java Servlet ve JSF belirtimlerinin yanı sıra JSP, Jakarta EE'de sürekli destek ve yükseltmeler için dahil edilen Java web teknolojilerinden biridir.

JSP sayfaları yazma

Basit bir JSP sayfası (.jsp), JSP etiketleriyle gömülü HTML işaretlemesinden oluşur. Dosya sunucuda işlendiğinde, HTML bir web sayfası olan uygulama görünümü olarak işlenir. Gömülü JSP etiketleri, sunucu tarafındaki kodu ve verileri çağırmak için kullanılacaktır. Şekil 1'deki diyagram, HTML, JSP ve web uygulama sunucusu arasındaki etkileşimi göstermektedir.

Matthew Tyson

Liste 1, basit bir JSP sayfasını gösterir.

Liste 1. Basit bir JSP sayfası

${2 * 2} should equal 4

Liste 1'de, İfade Dili (EL) kullanılarak Java sunucusuna yazılan bir talimat olan JSP ifadesi içeren bir HTML bloğu görüyorsunuz . İfadesi "olarak ${2 * 2}", " ${}" HTML içine kodunu interpolating için JSP sözdizimi. Yürütüldüğünde, JSP, ifadenin içinde ne varsa çalıştırmanın sonuçlarını verecektir. Bu durumda çıktı 4 numara olacaktır.

Servlet kapsayıcısında JSP

JSP sayfalarının bir Java servlet kapsayıcısı içinde konuşlandırılması gerekir. JSP ve servlet tabanlı bir Java web uygulamasını dağıtmak için, .jsp dosyalarınızı, Java kodunuzu ve uygulama meta verilerinizi, web uygulamaları için geleneksel bir yapıya sahip basit bir .zip dosyası olan bir .war dosyasında paketleyeceksiniz.

JSP'yi sunucu uygulaması kapsayıcınıza yükledikten sonra, bir sunucu uygulamasında derlenecektir. JSP'ler ve Java sunucu uygulamaları, istek nesnelerine erişme ve bunlara yanıt verme yeteneği dahil benzer özellikleri paylaşır. Apache Tomcat 9x, Servlet 4.0 ve JSP 2.3 spesifikasyonları için referans uygulamasıdır. (JSP 2.2 ve 2.3 arasındaki güncellemelerin nispeten küçük olduğunu unutmayın.)

Servlet kapsayıcısı ve uygulama sunucusu karşılaştırması

Java dünyasında, web sunucusu olarak da bilinen bir servlet konteyneri , bir uygulama sunucusunun lite (bira) versiyonu gibidir. Servlet konteyneri, istek ve yanıt etkileşimlerini yönetir ve bu etkileşimlerin, web uygulamaları için Java kurumsal yeteneklerinin bir alt kümesiyle arabirim oluşturmasına olanak tanır. Bir Java uygulama sunucusu, EJB, JPA, JMS ve daha fazlası dahil olmak üzere eksiksiz Java kurumsal yığınının bir parçası olarak servlet konteynerini içerir.

JSP için örnek uygulama

JavaServer Pages kullanmaya başlamanız için Tomcat'te örnek bir uygulama kullanacağız. Tomcat'i önceden kurmadıysanız, Tomcat indirme sayfasına gidin ve işletim sisteminiz için Tomcat kurulumunu seçin. Bu yazı itibariyle Tomcat 9, Servlet 4.0 ve JSP 2.3 ile uyumlu güncel sürümdür.

Bir Windows hizmeti olarak Tomcat yükleyebilir veya komut satırından çalıştırabilirsiniz /bin/catalina.sh startveya /bin/catalina.bat. Her iki durumda da Tomcat'i başlatın, ardından localhost:8080Şekil 2'de gösterilen Tomcat karşılama sayfasını görmek için gidin .

Matthew Tyson

Tomcat'te Örtük Nesneler

Tomcat karşılama sayfasında, Örnekler bağlantısını ve ardından JSP Örnekleri'ni tıklayın .

Ardından, Implicit Objects Execute web uygulamasını açın. Şekil 3, bu uygulama için çıktıyı göstermektedir. Bu çıktıyı incelemek için bir dakikanızı ayırın.

Matthew Tyson

İstek parametreleri

Örtük nesneler , bir JSP sayfası aracılığıyla erişilebilen yerleşik nesnelerdir. Bir web sayfası geliştiricisi olarak, bir HTTP isteği yayınlarken tarayıcıdan gönderilen veriler olan istek parametreleri gibi şeylere erişim oluşturmak için bu nesneleri kullanacaksınız . Örtük Nesneler için tarayıcı URL'sini göz önünde bulundurun:

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

Param ?foo=bar, ve web sayfasındaki çıktıda yansıtıldığını görebilirsiniz, burada tablo "EL İfadesi" ni gösterir ve değer "bar" dır. Şuna test etmek için, URL'yi değiştirmek //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , vurmak girin ve çıktıda yansıyan değişiklik göreceksiniz.

Bu örnek, sunucu tarafı istek parametrelerine erişmek için JSP etiketlerinin kullanımına çok basit bir giriş niteliğindedir. Bu durumda JSP sayfası param, web uygulamasının istek parametrelerine erişmek için çağrılan yerleşik (örtük) nesneyi kullanır . paramNesne Liste 1'de gördüğünü JSP ifade söz dizimi içinde de kullanılabilir.

Bu örnekte, biraz matematik yapmak için bir ifade kullandık:, ${2 * 2}hangi çıktı 4.

Bu örnekte, ekspresyon bu nesne ile ilgili bir nesne ve bir alan erişmek için kullanılır: ${param.foo}.

Bir web uygulamasında JSP

Örtülü Nesneler sayfasında, geri okunu ve ardından Kaynak bağlantısını tıklayın. Bu sizi Liste 2'de gösterilen Örtük Nesneler web uygulaması için JSP koduna yönlendirecektir.

Liste 2. Örtük Nesneler web uygulaması için JSP kodu

     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.

Güncellemelerinizin çıktıya yansıdığını görmelisiniz.