JSP

Úvod

nevýhoda servletov
- nepohodlný zápis HTML kódu v prípade jeho väčšieho množstva (neprehľadné, veľké množstvá out.println(...))
- slabé oddelenie užívateľského rozhrania od výkonného kódu -- grafik/návrhár stránky musí ovládať Javu.
vývoj smeroval k JSP
- formát štandardného HTML kódu
- možno vkladať kód Javy (cez výrazy, scriptlets, deklarácie a direktívy)
- plus rozšírenie o niektoré špeciálne tagy
JSP sú serverom automaticky transformované na servlet a kompilované

Elementy JSP stránok

štandardný HTML kód
```
      <b><i>Ahoj svet!</i></b>
    
```
výrazy (expressions)
```
      <%= new java.util.Date() %>
    
```
- sú vyhodnotené ako reťazec a vložené do stránky.
- príklad: vytvorí objekt Date() a vypíše ho ako reťazec (pomocou jeho metódy toString()
  do stránky vloží text Sun Oct 12 13:26.10 EST 2003
scriptlets

      <%
        MyObject o = new MyObject();
        o.doSomething();
      %>

možnosť vložiť ľubovoľný kód Javy (nie však celé metódy, ani triedy)

deklarácie

      <%!
        private int pocet = 0;
        public void pracuj() {
          System.out.println("Pracujem...");
        }
      %>

možnosť vložiť deklaráciu dátových členov, či metód

direktívy

      <%@ page import="java.util.Vector" %> //analógia k deklarácii import
      <%@ page contentType="text/html; charset=windows-1250" %> // analógia k response.setContentType(..)

špecifikácia niektorých možností stránky

Preddefinované premenné

Vo výrazoch (<%= ... %>) a scriptletoch (<% ... %>) sú preddefinované nasledovné premenné:

request -- inštancia triedy HttpServletRequest -- reprezentuje požiadavku
response -- inštancia triedy HttpServletResponse -- reprezentuje odpoveď užívateľovi
out -- inštancia triedy PrintWriter -- pomocou nej môžeme zapisovať do stránky
session -- inštancia triedy HttpSession, ak sú používané sessions.

Príklad stránky a jej transformácie na servlet

    <%@ page contentType=
      "text/html; charset=windows-1250" %>

    <%!
      public static int accessCount = 0;
    %>

    <%
      accessCount++;
    %>
    <html>
    <body>
    <h1>Informácie o požiadavke</h1>
    Názov servera:
    <%= request.getServerName() %> <br>
    Port:
    <%= request.getServerPort() %> <br>
    Vaša adresa:
    <%= request.getRemoteAddr() %> <br>
    Názov vášho počítača:
    <%= request.getRemoteHost() %> <br>
    Používate prehliadač
    <% out.print(request.getHeader("User-Agent")); %>
    <hr>
    Táto stránka bola od poslednej zmeny navštívená
    <%= accessCount %>-krát.
    </body>
    </html>

package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import org.apache.jasper.runtime.*;

public class sample_jsp extends HttpJspBase {

  public static int accessCount = 0;

  private static java.util.Vector _jspx_includes;

  public java.util.List getIncludes() {
    return _jspx_includes;
  }

  public void _jspService(HttpServletRequest request,
    HttpServletResponse response)

        throws java.io.IOException, ServletException {

    JspFactory _jspxFactory = null;
    javax.servlet.jsp.PageContext pageContext = null;
    HttpSession session = null;
    ServletContext application = null;
    ServletConfig config = null;
    JspWriter out = null;
    Object page = this;
    JspWriter _jspx_out = null;


    try {
      _jspxFactory = JspFactory.getDefaultFactory();
      response.setContentType("text/html; charset=windows-1250");
      pageContext = _jspxFactory.getPageContext(this,
        request, response, null, true, 8192, true);
      application = pageContext.getServletContext();
      config = pageContext.getServletConfig();
      session = pageContext.getSession();
      out = pageContext.getOut();
      _jspx_out = out;

      out.write("\r\n\r\n");
      out.write("\r\n\r\n");

      accessCount++;

      out.write("\r\n");
      out.write("<html>\r\n");
      out.write("<body>\r\n");
      out.write("<h1>Informácie o požiadavke");
      out.write("</h1>\r\nNázov servera: ");
      out.print( request.getServerName() );
      out.write(" ");
      out.write("<br>\r\nPort: ");
      out.print( request.getServerPort() );
      out.write(" ");
      out.write("<br>\r\nVaša adresa: ");
      out.print( request.getRemoteAddr() );
      out.write(" ");
      out.write("<br>\r\nNázov vášho počítača: ");
      out.print( request.getRemoteHost() );
      out.write(" ");
      out.write("<br>\r\nPoužívate prehliadč ");

      out.print(request.getHeader("User-Agent"));

      out.write("\r\n");
      out.write("<hr>\r\nTáto stránka bola od poslednej
        zmeny navštívená ");
      out.print( accessCount );
      out.write("-krát.\r\n");
      out.write("</body>\r\n");
      out.write("</html>\r\n");
    } catch (Throwable t) {
      out = _jspx_out;
      if (out != null && out.getBufferSize() != 0)
        out.clearBuffer();
      if (pageContext != null) pageContext.handlePageException(t);
    } finally {
      if (_jspxFactory != null)
        _jspxFactory.releasePageContext(pageContext);
    }
  }
}

Presmerovanie (forwarding) a vkladanie (include)

Presmerovanie

Presmerovanie v JSP Presmerovanie v servletoch

Vložením JSP tagu:

<jsp:forward page="relatívna URL" />

Získaním objektu RequestDispatcher pre cieľovú adresu URL, zavolaním jeho metódy forward.
```
          getServletContext()
            .getRequestDispatcher("/forward-URL")
            .forward(req, resp);
        
```
- cieľová adresa forward-URL musí začínať znakom / a je relatívna vzhľadom na koreň kontextu.
- presmerovanie je zariadené samotným serverom, z pohľadu užívateľa sa URL servletu, ktorý presmerováva, nemení.
Zavolaním metódy objektu HttpServletResponse:
```
          resp.sendRedirect("forward-URL");
        
```
- server oznámi prehliadaču novú adresu; prehliadač -- musí zariadiť prevzatie presmerovaného dokumentu.

Vkladanie -- include

Include v JSP Include v servletoch

Vložením JSP direktívy:
```
<%@ include file="relatívna URL" %>
```
- vkladaný zdroj je vložený v čase prekladu JSP do servletu.
- ak sa vkladaný zdroj zmení, NIE JE stránka aktualizovaná
Vložením JSP tagu:
```
<jsp:include page="relatívna URL" flush="true" />
```
- vkladaný zdroj je vkladaný dynamicky

Získaním objektu RequestDispatcher pre cieľovú adresu URL, zavolaním jeho metódy include.

        getServletContext()
          .getRequestDispatcher("/include-URL")
          .include(req, resp);

cieľová adresa include-URL musí začínať znakom / a je relatívna vzhľadom na koreň kontextu.
presmerovanie je zariadené samotným serverom

Sessions

HTTP je bezstavový protokol -- je ťažké udržiavať špecifické informácie o klientovi
príklad: pohyb v autentifikovanej zóne. Server musí vedieť, či bol užívateľ autentifikovaný na pohyb v istej časti informačného systému. Po úspešnej autentifikácii sa vložia do sessionu parametre s hodnotami
```
    uzivatel=durkomocik
    datumPrihlasenia=12.10.2003
    autentifikovany=true
  
```
realizácia:
- cookies -- server si prostredníctvom užívateľa uloží na jeho počítači malý súbor -- cookie -- s požadovanými údajmi
- prepisovanie URL -- pri pristupovaní na stránky sa ku každej URL adrese pripíše špeciálny parameter session ID.
```
        http://www.server.com/goto.jsp?JSESSIONID=AFIPZVVIPMVV
      
```
  V tejto adrese je session id hodnota AFIPZVVIPMVV.
JSP automaticky zvolí spôsob realizácie -- ak má užívateľ cookies zakázané, zvolí prepisovanie URL.

Sessions v servletoch a JSP

Session je realizovaný pomocou objektu HttpSession. Do sessionu možno vkladať ľubovoľný objekt.

Sessions v JSP	Sessions v servletoch
Vložením JSP direktívy: <%@ page session="true" %>	`HttpServletRequest` obsahuje metódu `getRequest(..)` vracajúcu session asociovanú s touto stránkou. Ak je parameter metódy `true`, v prípade, že session k tomuto requestu neexistuje, bude vytvorený nový objekt `HttpSession`. Ak je parameter `false` a session neexistuje, vráti sa `null`. HttpSession session = req.getSession(true);

vkladanie objektov do sessionu:

session.putValue(String parameterName, Object value)

čítanie objektov z sessionu:
```
MojObjekt o = (MojObjekt) session.getValue("nazovparametra")
```
Ak neexistuje nazovparametra, vráti sa null.
odstraňovanie objektov
```
session.removeValue("názovParametra")
```
vyhlásenie session za vypršanú, uvoľnenie všetkých objektov
```
session.invalidate()
```