JSP'ye Giriş (JavaServer Pages)
JSP (JavaServer Pages), HTML içine dinamik Java verisi gömmenin klasik yoludur. Servlet'le saf Java içinden HTML yazmak (out.write("<h1>...")) zahmetlidir; JSP bunu tersine çevirir: bir HTML sayfası yazarsın, içine öz…
JSP'ye Giriş (JavaServer Pages)
JSP (JavaServer Pages), HTML içine dinamik Java verisi gömmenin klasik yoludur. Servlet'le saf
Java içinden HTML yazmak (out.write("<h1>...")) zahmetlidir; JSP bunu tersine çevirir: bir HTML
sayfası yazarsın, içine özel etiketlerle dinamik kısımları gömersin. JSP, sunum (view) katmanının
ilk Java teknolojisidir.
Not: Gerçek JSP bir sunucu konteyneri (Tomcat) gerektirir; portal headless olduğu için JSP'nin temel fikrini (şablon + model → HTML) kendi mini render mantığımızla taklit ediyoruz. Gerçek JSP kodu aşağıdadır.
JSP nasıl çalışır?
Bir JSP sayfası aslında bir servlet'e dönüştürülür: konteyner, ilk istekte .jsp dosyasını bir
Java servlet sınıfına çevirir (translation), derler ve çalıştırır. Yani JSP, "ters yazılmış bir
servlet"tir — çoğunluğu HTML, araya gömülü dinamik kısımlar.
Sayfa sunucuda işlenir ve sonuç düz HTML olarak tarayıcıya gider; tarayıcı hiçbir zaman JSP etiketlerini görmez.
Expression Language (EL): ${...}
Dinamik veriyi HTML'e gömmenin modern JSP yolu EL'dir: ${ad} gibi ifadeler sunucuda modelden
doldurulur:
<h1>Merhaba, ${ad}!</h1> <p>Sepette ${adet} ürün, toplam ${tutar} TL.</p>
Örnek 1 (./Ornek1.java) bu doldurma mantığını taklit eder: ${anahtar} ifadelerini bir model
Map'inden değerlerle değiştirir.
JSTL: döngü ve koşul
Saf HTML statiktir; dinamik listeler ve koşullar için JSP, JSTL etiket kütüphanesini kullanır:
<table> <c:forEach items="${urunler}" var="u"> <tr><td>${u.ad}</td><td>${u.fiyat} TL</td></tr> </c:forEach> </table>
<c:forEach>: döngü (liste → satırlar)<c:if>/<c:choose>: koşullu gösterim<c:out>: güvenli (XSS'e karşı kaçışlı) yazdırma
Örnek 2 (./Ornek2.java) bir ürün listesini HTML tablo satırlarına çeviren c:forEach mantığını
Stream ile taklit eder.
Gerçek JSP + Servlet akışı
Tipik MVC akışı: Servlet (controller) veriyi hazırlar, isteği JSP'ye (view) yönlendirir; JSP HTML üretir:
// Servlet (controller) @WebServlet("/urunler") public class UrunServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ... { req.setAttribute("urunler", urunServisi.hepsi()); // modeli koy req.getRequestDispatcher("/urunler.jsp").forward(req, resp); // JSP'ye yönlendir } }
<!-- urunler.jsp (view) --> <%@ taglib prefix="c" uri="jakarta.tags.core" %> <html><body> <table> <c:forEach items="${urunler}" var="u"> <tr><td>${u.ad}</td><td>${u.fiyat}</td></tr> </c:forEach> </table> </body></html>
Eski özellik — scriptlet: Erken JSP'lerde
<% Java kodu %>(scriptlet) ile sayfaya doğrudan Java gömülürdü. Bu, HTML ile mantığı karıştırdığı için artık önerilmez; yerine EL + JSTL kullanılır.
JSP bugün: modern alternatifler
JSP güçlüdür ama günümüzde yeni projelerde azalmıştır. Yaygın alternatifler:
- Thymeleaf: Spring Boot'un önerdiği modern şablon motoru (doğal HTML, tasarımcı dostu).
- REST API + JS frontend: Backend JSON döner, arayüzü React/Vue/Angular çizer — bu eğitim portalının mimarisi (Spring Boot API + React).
Yine de "sunucuda şablon + model → HTML" fikri evrenseldir ve her şablon motorunda aynıdır.
Özet
JSP'nin HTML içine dinamik veri gömen, servlet'e dönüştürülen bir sunum teknolojisi olduğunu;
EL (${...}) ile model doldurmayı (Örnek 1) ve JSTL (c:forEach) ile döngü/koşulu (Örnek 2)
öğrendik; gerçek Servlet+JSP MVC akışını, scriptlet'in neden terk edildiğini ve modern
alternatifleri (Thymeleaf, REST+JS) gördük. Bununla framework tanıtımları bölümü (AWT/Swing/
Servlet/JSP) tamamlandı.
▶ Kod Örnekleri(2)
Ornek1
çalıştırılabilir1// Ornek1: JSP'nin "EL" (Expression Language) mantığı — ${...} yer tutucularını modelden doldurma.
2// (Gerçek JSP bir konteyner gerektirir; burada JSP'nin temel fikrini taklit ediyoruz. Gerçek JSP README'de.)
3// Çalıştırma: java Ornek1.java
4import java.util.Map;
5import java.util.regex.Matcher;
6import java.util.regex.Pattern;
7
8public class Ornek1 {
9
10 // JSP EL'in basit taklidi: şablondaki ${anahtar} ifadelerini model değerleriyle değiştirir.
11 static String render(String sablon, Map<String, Object> model) {
12 Matcher m = Pattern.compile("\\$\\{(\\w+)\\}").matcher(sablon);
13 StringBuilder sb = new StringBuilder();
14 while (m.find()) {
15 Object deger = model.getOrDefault(m.group(1), "");
16 m.appendReplacement(sb, Matcher.quoteReplacement(String.valueOf(deger)));
17 }
18 m.appendTail(sb);
19 return sb.toString();
20 }
21
22 public static void main(String[] args) {
23 // JSP sayfasının gövdesi gibi bir HTML şablonu (içinde ${} ifadeleri):
24 String sablon = """
25 <html>
26 <body>
27 <h1>Merhaba, ${ad}!</h1>
28 <p>Sepetinizde ${adet} ürün var, toplam ${tutar} TL.</p>
29 </body>
30 </html>""";
31
32 // Sunucu tarafında model (gerçekte controller/servlet doldurur):
33 Map<String, Object> model = Map.of("ad", "Ada", "adet", 3, "tutar", 1250.0);
34
35 String html = render(sablon, model);
36 System.out.println("Üretilen HTML:\n" + html);
37
38 System.out.println("""
39
40 --- JSP ve Expression Language (EL) ---
41 JSP, HTML içine dinamik veri gömmenin yoludur: ${ad} gibi ifadeler SUNUCUDA modelden doldurulur.
42 Sonuç düz HTML olarak tarayıcıya gider; tarayıcı ${} görmez, dolu halini görür.
43 Bu örnek o doldurma mantığını taklit eder; gerçek JSP'de bunu konteyner otomatik yapar.""");
44 }
45}Ornek2
çalıştırılabilir1// Ornek2: JSP'nin "JSTL c:forEach" döngü mantığı — bir listeyi HTML tablo satırlarına çevirme.
2// Çalıştırma: java Ornek2.java
3import java.util.List;
4import java.util.stream.Collectors;
5
6public class Ornek2 {
7
8 record Urun(String ad, double fiyat, int stok) {}
9
10 public static void main(String[] args) {
11 List<Urun> urunler = List.of(
12 new Urun("Klavye", 450, 12),
13 new Urun("Mouse", 250, 40),
14 new Urun("Monitör", 3200, 5));
15
16 // JSTL <c:forEach items="${urunler}" var="u"> ... </c:forEach> mantığının taklidi:
17 // her ürün için bir <tr> satırı üret.
18 String satirlar = urunler.stream()
19 .map(u -> " <tr><td>%s</td><td>%.2f TL</td><td>%d</td></tr>"
20 .formatted(u.ad(), u.fiyat(), u.stok()))
21 .collect(Collectors.joining("\n"));
22
23 String html = """
24 <table>
25 <thead><tr><th>Ürün</th><th>Fiyat</th><th>Stok</th></tr></thead>
26 <tbody>
27 %s
28 </tbody>
29 </table>""".formatted(satirlar);
30
31 System.out.println("Üretilen tablo:\n" + html);
32
33 System.out.println("""
34
35 --- JSP + JSTL (döngü/koşul) ---
36 Saf HTML statiktir; dinamik listeleri göstermek için JSP, JSTL etiketlerini kullanır:
37 <c:forEach> (döngü), <c:if>/<c:choose> (koşul), <c:out> (güvenli yazdırma).
38 Sunucu, listeyi dolaşıp her eleman için HTML üretir; tarayıcıya hazır tablo gider.
39 Bu örnek o üretimi Stream ile taklit eder. Modern projelerde JSP yerine genelde
40 Thymeleaf veya bir REST API + JS frontend (bu portal gibi) tercih edilir.""");
41 }
42}