Template JSP

Meskipun alat pengembangan Web berkembang pesat, mereka masih tertinggal di belakang sebagian besar perangkat antarmuka pengguna grafis (GUI) seperti Swing atau VisualWorks Smalltalk. Misalnya, perangkat GUI tradisional menyediakan pengelola tata letak, dalam satu bentuk atau lainnya, yang memungkinkan algoritme tata letak dienkapsulasi dan digunakan kembali. Artikel ini membahas mekanisme template untuk Halaman JavaServer (JSP) yang, seperti pengelola tata letak, merangkum tata letak sehingga dapat digunakan kembali dan bukan direplikasi.

Karena tata letak mengalami banyak perubahan selama pengembangan, penting untuk merangkum fungsionalitas tersebut sehingga dapat dimodifikasi dengan dampak minimal pada aplikasi lainnya. Faktanya, manajer tata letak mendemonstrasikan contoh salah satu prinsip desain berorientasi objek: merangkum konsep yang bervariasi, yang juga merupakan tema fundamental untuk banyak pola desain.

JSP tidak memberikan dukungan langsung untuk enkapsulasi tata letak, sehingga Halaman Web dengan format yang identik biasanya mereplikasi kode tata letak; misalnya, Gambar 1 menunjukkan halaman Web yang berisi bagian header, footer, sidebar, dan konten utama.

Tata letak halaman yang ditunjukkan pada Gambar 1 diimplementasikan dengan tag tabel HTML:

Contoh 1. Menyertakan konten

Template JSP  
   
<% @ include file = "sidebar.html"%>
<% @ include file = "header.html"%>
<% @ include file = "introduksi.html"%>
<% @ include file = "footer.html"%>

Dalam contoh yang tercantum di atas, konten disertakan dengan includedirektif JSP , yang memungkinkan konten halaman bervariasi - dengan mengubah file yang disertakan - tanpa mengubah halaman itu sendiri. Namun, karena tata letak memiliki kode keras, perubahan tata letak memerlukan modifikasi pada halaman. Jika Situs Web memiliki banyak halaman dengan format yang identik, yang umum terjadi, bahkan perubahan tata letak yang sederhana memerlukan modifikasi pada semua halaman.

Untuk meminimalkan dampak perubahan layout, kita membutuhkan mekanisme untuk memasukkan layout selain konten; dengan begitu, tata letak dan konten dapat bervariasi tanpa mengubah file yang menggunakannya. Mekanisme itu adalah template JSP.

Menggunakan template

Template adalah file JSP yang menyertakan konten berparameter. Template dibahas dalam artikel ini diimplementasikan dengan satu set tag kustom: template:get, template:put, dan template:insert. The template:gettag mengakses konten parameter, seperti digambarkan dalam Contoh 2.a, yang menghasilkan Halaman Web dengan format yang ditunjukkan pada Gambar 1.

Contoh 2.a. Sebuah template

< template: get name = "title" />
   
< template: get name = "header" />

Contoh 2.a hampir identik dengan Contoh 1, kecuali kita menggunakan template:getsebagai pengganti includedirektif. Mari kita periksa cara template:getkerjanya.

template:getmengambil kacang Java dengan nama yang ditentukan dari ruang lingkup permintaan. Kacang berisi URI (Uniform Resource Identifier) ​​dari komponen Web yang disertakan oleh template:get. Misalnya, dalam template yang terdaftar di Contoh 2.a, template:getmemperoleh URI - header.html- dari kacang bernama headerdalam lingkup permintaan. Selanjutnya, template:gettermasuk header.html.

template:putmenempatkan kacang dalam ruang lingkup permintaan yang kemudian diambil oleh template:get. Template disertakan dengan template:insert. Contoh 2.b mengilustrasikan penggunaan tag putdan insert:

Contoh 2.b. Menggunakan template dari Contoh 2.a

   
    masukkan template = "/ articleTemplate.jsp">
    
     letakkan name = "title" content = "Template" direct = "true" />
     
      letakkan name = "header" content = "/ header.html" />
      
       letakkan name = "sidebar" content = "/ sidebar.jsp" />
       
        letakkan name = "content" content = "/ introduksi.html" />
        
         letakkan name = "footer" content = "/ footer.html" />
        
       
      
     
    
   

The insertmenspesifikasikan start tag template untuk dimasukkan, dalam hal ini template yang tercantum dalam Contoh 2.a. Setiap puttag menyimpan kacang dalam ruang lingkup permintaan dan inserttag akhir menyertakan templatnya. Template selanjutnya mengakses kacang seperti dijelaskan di atas.

Sebuah directatribut dapat ditentukan untuk template:put; jika directdisetel ke true, konten yang terkait dengan tag tidak disertakan oleh template:get, tetapi dicetak langsung ke outvariabel implisit . Dalam Contoh 2.b, misalnya, konten judul - JSP Templates - digunakan untuk judul jendela.

Situs web yang berisi beberapa halaman dengan format yang sama memiliki satu template, seperti yang tercantum di Contoh 2.a, dan banyak halaman JSP, seperti Contoh 2.b, yang menggunakan template tersebut. Jika format diubah, perubahan dibatasi pada template.

Manfaat lain dari template dan termasuk konten secara umum adalah desain modular. Misalnya, file JSP yang tercantum dalam Contoh 2.b pada akhirnya disertakan header.html, yang tercantum dalam Contoh 2.c.

Contoh 2.c. header.html

   

Karena header.htmltermasuk konten, tidak harus direplikasi di antara halaman yang menampilkan header. Selain itu, meskipun header.htmlmerupakan file HTML, file ini tidak berisi pembukaan tag HTML biasa seperti atau karena tag tersebut ditentukan oleh template. Artinya, karena template menyertakan header.html, tag tersebut tidak boleh diulang dalam header.html.

Catatan: JSP menyediakan dua cara untuk memasukkan konten: secara statis, dengan includedirektif, dan secara dinamis, dengan includetindakan. The includedirektif meliputi sumber halaman target pada waktu kompilasi dan setara dengan C #includeatau Jawa import. The includeaksi termasuk respon target yang dihasilkan pada saat runtime.

Like the JSP include action, templates include content dynamically. So, although the JSP pages in Example 1 and Example 2.b are functionally identical, the former statically includes content, whereas the latter dynamically includes it.

Optional content

All template content is optional, which makes a single template useful to more Webpages. For example, Figure 2.a and Figure 2.b show two pages -- login and inventory -- that use the same template. Both pages have a header, footer, and main content. The inventory page has an edit panel (which the login page lacks) for making inventory changes.

Below, you'll find the template shared by the login and inventory pages:

 ... 
   
name='editPanel'/>
...

The inventory page uses the template listed above and specifies content for the edit panel:

   ... 
    ...  

In contrast, the login page does not specify content for the edit panel:


  

Because the login page does not specify content for the edit panel, it's not included.

Role-based content

Web applications often discriminate content based on a user's role. For example, the same JSP template, which includes the edit panel only when the user's role is curator, produces the two pages shown in Figures 3.a and 3.b.

The template used in Figures 3.a and 3.b uses template:get's role attribute:

 ... 
   
     ... 
     ... 
    
role='curator'/>
...

The get tag includes content only if the user's role matches the role attribute. Let's look at how the tag handler for template:get uses the role attribute:

public class GetTag extends TagSupport { private String name = null, role = null; ... public void setRole(String role) { this.role = role; } ... public int doStartTag() throws JspException { ... if(param != null) { if(roleIsValid()) { // include or print content ... } } ... } private boolean roleIsValid()  } 

Implementing templates

The templates discussed in this article are implemented with three custom tags:

  • template:insert
  • template:put
  • template:get

The insert tag includes a template, but before it does, put tags store information -- a name, URI, and Boolean value specifying whether content should be included or printed directly -- about the content the template includes. template:get, which includes (or prints) the specified content, subsequently accesses the information.

template:put stores beans in request scope but not directly because if two templates use the same content names, a nested template could overwrite the enclosing template's content.

To ensure that each template has access only to its own information, template:insert maintains a stack of hashtables. Each insert start tag creates a hashtable and pushes it on the stack. The enclosed put tags create beans and store them in the newly created hashtable. Subsequently, get tags in the included template access the beans in the hashtable. Figure 4 shows how the stack is maintained for nested templates.

Each template in Figure 4 accesses the correct footer; footer.html for template_1.jsp and footer_2.html for template_2.jsp. If the beans were stored directly in request scope, step 5 in Figure 4 would overwrite the footer bean specified in step 2.

Template tag implementations

The remainder of this article examines the implementation of the three template tags: insert, put, and get. We begin with sequence diagrams, starting with Figure 5. It illustrates the sequence of events for the insert and put tags when a template is used.

If a template stack does not already exist, the insert start tag creates one and places it in request scope. A hashtable is subsequently created and pushed on the stack.

Setiap puttag awal membuat PageParameterkacang, disimpan dalam hashtable yang dibuat oleh inserttag yang melampirkan .

endTag sisipan menyertakan template. Template menggunakan gettag untuk mengakses kacang yang dibuat oleh puttag. Setelah template diproses, hashtable yang dibuat oleh inserttag awal dikeluarkan dari tumpukan.

Gambar 6 menunjukkan diagram sekuens untuk template:get.

Daftar tag template

Penerapan penangan tag untuk tag kerangka terbukti langsung. Contoh 3.a mendaftar InsertTagkelas - penangan tag untuk template:insert.

Contoh 3.a. InsertTag.java