personal website

Corso JSP - Le direttive

corso-jsp-le-direttive

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - Le direttive

Le direttive permettono di definire la struttura di tutto il documento JSP. Indicano gli aspetti principali del servlet in cui sarà convertito il file JSP. Sono processati al momento della conversione in servlet: a compile-time, cioè a tempo di compilazione. Le direttive esistenti sono: page, include e taglib.
Introdotte dal simbolo @ possono contenere diversi attributi, in alcuni casi concatenabili come per la direttiva import.

direttiva page

<%@ page attributi %>  dove attributi sono coppie:  nome="valore"
Esempio:
<%@   page language=”Java” import="java.sql.*,java.util.*" session="true" buffer="10kb" %>
Esiste una lista di attributi che possono essere usati, ne elenco alcuni:
import ="package.class"
Lista di package o classes, separati da virgola, che saranno importati per essere utilizzati nel codice java.
session ="true | false"
specifica se la pagina fa parte di una sessione HTTP. Se si inizializza a true, è disponibile l'oggetto implicito sessione.
buffer ="dimensionekb"
specifica la dimensione di un buffer di uscita di tipo stream, per il client.
errorPage="url"
specifica una pagina JSP che sarà processata nel caso si verifichi un errore.
isErrorPage="true|false"
Indica che la pagina è una pagina di errore JSP e può mostrare a video l'output dell'errore verificatosi. Per default è settata false.
contentType = "MIME-Type"
oppure
contentType = "MIME-Type; charset = Character-Set"
Il valore MIME di default è text/html

direttiva include

Indica al motore JSP di includere  il contenuto del file corrispondente, inserendolo al posto della direttiva nella pagina JSP.
Il contenuto del file incluso è analizzato al momento della traduzione del file JSP e si include una copia del file stesso nel servlet generato.
Una volta incluso, se si modifica il file non sarà ricompilato nel servlet.
Il tipo di file da includere può essere un
file html (statico)
file jsp  (dinamico)
Sintassi:    <%@ include file="nome del file" %>

esempio

<html> <head> <title> pagina di prova Direttive  </title> </head> <body> <h1> pagina di prova Direttive inclusione  </h1>       <%@ include file="/hello_world.html" %>       <%@ include file=”/login.jsp” %> </body> </html>

direttiva taglib

Permette estendere i marcatori di JSP con etichette o marcatori generati dall'utente (etichette personalizzate).

Sintassi

<%@ taglib uri="taglibraryURI" prefix="tagPrefix" %>

Esempi librerie standard

 
4305

Corso JSP - Le variabili

corso-jsp-le-variabili

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - Le variabili

Le variabili  in Java devono essere definite e tipizzate, i tipi principali sono (utilizzati negli esempi) poi ci sono Per l'elenco completo delle variabili e dei tipi primitivi fare riferimento alla documentazione di Java. Esempi di uso delle variabili nelle Java Server Pages:

Copia codice

<%-- Document : variabili Created on : 3-giu-2013, 11.19.17 Author : mauro --%> <%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <h1>variabile stringa</h1>
<%
 String stVar = "Questa è una stringa!";
 %>
variabile stringa: <%=stVar%> <h1>variabile intera</h1>
<%
 int iVar=25;
 %>
variabile intera: <%=iVar%> <h1>variabile float</h1>

<% float fVar=123.456f; %>

variabile float: <%=fVar%> <h1>variabile booleana</h1>

<% boolean checkBoolean=false; if(checkBoolean==true) { out.print("La condizione è vera"); } else { out.print("La condizione è falsa");//stamperà la condizione è falsa } %>

</body> </html>
4296

Corso JSP - Le espressioni

corso-jsp-le-espressioni

JSP: le espressioni 

Notazione abbreviata che invia il valore di una espressione Java al client.
L’espressione si traduce nella chiamata al metodo println dell'oggetto out nel metodo _jspService(), ad ogni richiesta, l’espressione è valutata e il risultato si converte a String e si visualizza

Sintassi

<%=   espressione Java da valutare %>

Esempio

stinga di testo + variabile jsp

<%=  “questa espressione mostra il valore di un contatore“ + contatore %>

Esempio

In questa pagina JSP l'espressione consiste nel creare un oggetto e chiamare uno dei suoi metodi. Il risultato è una stringa che si mostra al client.  

Copia il codice

<html> <head> <title> Pagina esempio di Espressioni </title> </head> <body> <h1> pagina Esempio di Espressioni </h1> Torino, <%= new Date().toString() %> </body> </html>
4248

Corso JSP - In breve

corso-jsp-introduzione

Corso JSP - In breve

pagina JSP -> Servlet

  • La pagina JSP si converte in un servlet (il servlet o la servlet? leggi qui la discussione funny )
  • La conversione la realizza il motore o contenitore JSP (tomcat, glassfish, ...), la prima volta che si sollecita la pagina JSP
  • Questo servlet generato processa qualsiasi richiesta per questa pagina JSP
  • Se si modifica il codice della pagina JSP, allora si rigenera e ricompila automaticamente il servlet e si ricarica la volta successiva

oggetti impliciti

JSP utilizza gli oggetti impliciti (built-in)
  • Gli oggetti impliciti sono oggetti istanziati automaticamente dall’ambiente JSP, non dobbiamo preoccuparci di importarli e istanziarli.
  • Per utilizzarli è sufficiente usare la sintassi nomeOggetto.nomeMetodo
questi oggetti sono disponibili per l’uso in pagine JSP e sono:
  • out: per scrivere codice HTML nella risposta (System.out di Java)
  • session: dati specifici della sessione utente corrente
  • request: richiesta HTTP ricevuta e i suoi attributi, header, cookie, parametri, etc.
  • page: la pagina e le sue proprietà.
  • config: dati di configurazione
  • response: risposta HTTP e le sue proprietà.
  • application: dati condivisi da tutte le pagine della web application
  • exception: eventuali eccezioni lanciate dal server; utile per pagine di errore
  • pageContext: dati di contesto per l’esecuzione della pagina
Gli oggetti impliciti possono essere
  • oggetti legati alla servlet relativa alla pagina JSP
  • oggetti legati all’input e all’output della pagina JSP
  • oggetti che forniscono informazioni sul contesto in cui la JSP viene eseguita
  • oggetti risultanti da eventuali errori
Ambito
Definisce dove e per quanto tempo saranno accessibili gli oggetti: oggetti impliciti, JavaBeans, ...
  • di pagina: l'oggetto è accessibile dal servlet che rappresenta la pagina
  • di richiesta:  l'oggetto viene creato e poi distrutto  dopo l'uso
  • di sessione: l'oggetto è accessibile durante tutta la sessione
  • di applicazione: l'oggetto è accessibile dal servlet che rappresenta la pagina
Ciclo di vita di una pagina JSP
La pagina viene salvata in una cartella pubblica del server web
alla prima richiesta ricevuta dal Web server la pagina JSP è automaticamente:
  • tradotta in un sorgente Java chiamato Servlet
  • compilata come programma Java
  • caricata in memoria ed eseguita
successivamente la pagina JSP (la servlet) viene solo eseguita.
In fase di debug il web server verifica se la pagina JSP è più recente del servlet corrispondente.
Rispetto ad altre tecnologie server side come PHP o ASP, questa è una differenza vantaggiosa in termini di velocità di risposta: dopo la prima esecuzione, il codice risulterà già compilato e disponibile immediatamente. Con PHP e ASP il webserver interpreterà il codice ad ogni richiesta prima di servire la pagina di risposta.

Elementi di una pagina JSP

  • codice HTML
  • marcatori JSP
    • direttive al server
    • elementi di scripting
    • azioni standard
      • <jsp:include>
      • <jsp:forward>
      • <jsp:param>
      • <jsp:useBean>
      • <jsp:setProperty>
      • <jsp:getProperty>
      • <jsp:plugin>
    • azioni personalizzate - custom tags (vedi sotto tag libraries)

Costrutti del linguaggio

Supporta i costrutti e la sintassi standard di Java, ecco alcuni esempi:
esempi disponibili:

JDBC e interazione con database

Le Tag Libraries

 Uso avanzato

Post su JSP

[su_post post_id="4311"]

Edizione del corso

 

4246

Corso JSP - argomenti

corso-jsp-argomenti

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - argomenti delle lezioni

Primo approccio a JSP
->Esercizio: installazione ed esecuzione della prima pagina JSP
  1. Installazione dell' SDK di Java e di Tomcat configurazione dell’IDE e prima pagina Hello world con JSP
  2. Esplorazione dell’ambiente di sviluppo, creazione, modifica pagine JSP, passaggio dei dati tra pagine
  3. Oggetti impliciti, oggetti principali, uso di Request, Out, etc.
  4. Inclusione di file, primo utilizzo delle direttive.
  5. Tipi di tag JSP: dichiarazioni, espressioni, scriptlet, direttive.
  6. Compile-time e Request-time
 

Elementi fondamentali di JSP - Sintassi e caratteristiche degli oggetti principali: scriptlet, azioni standard, servlet

-> Esercizio esempi di utilizzo degli elementi fondamentali
  1. Ciclo di vita di una pagina Jsp, Scriptlet: usare i costrutti del linguaggio JAVA nelle JSP
  2. Cookie e gestione delle sessioni – Impostare una procedura di login da riutilizzare
  3. Teoria ed esercizi sulle standard actions - jsp:forward
  4. Standard action JavaBeans: estendere le funzionalità della web application, separare la logica dell'app;
  5. Standard action: come usare le altre azioni standard
  6. Lavorare con le date in JSP.
-> Esercizio utilizzo di JavaBeans

Lavorare con i database

  1. Correzione in aula dell'esercitazione e individuazione best practices.
  2. Approfondimento ed esercizi con i JavaBeans. Introduzione database con JSP.
  3. Uso di JDBC nelle JSP. Creazione database, accesso alla base dati.
  4. Esercizi sulla base dati, applicazione CRUD in JSP.
  5. Progetto ed implementazione di un'applicazione web complessa con JSP: creare un sito web per acquisti on line, sviluppo di un carrello della spesa.
  6. Lettura e scrittura di file, utilizzo database nell'applicazione web. Hibernate, JSTL, servlet e MySql. MVC pattern. Persistenza in JSP.
Elementi Avanzati di una pagina JSP
-> Esercizio uso di Etichette personalizzate
  1. Esercitazione guidata Hibernate e JSTL. Le TagLibraries.
  2. Esercitazione guidata JSTL: core, xml, fmt, sql, functions.
  3. JSP2 - JSF - EL expression language. Panoramica framework principali JSP.
  4. Esercitazione guidata Java Server Faces

4240

Corso JSP - jsp:forward

corso-jsp-forward

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - jsp:forward

L'azione forward, come intuibile, serve per trasferire l'utente da una pagina jsp ad un'altra. Come l'azione jsp:include è possibile utlizzare forward con o senza parametri. In quest'ultimo caso occorre terminare l'istruzione inserendo / prima della parentesi angolare di chiusura tag :
<jsp:forward page="URL" />
Nel caso si vogliano utilizare dei parametri, invece, utilizzeremo il tag di chiusura del blocco di codice </jsp:forward> :
<jsp:forward page="URL" > 
<jsp:param name="ParamName1" value="ParamValue1" /> 
<jsp:param name="ParamName2" value="ParamValue2" /> 
</jsp:forward>

Esempio di codice (incluso in tomcat 7)

per trovarne altri, dopo l'indirizzo del server (es. localhost:8080) scrivi /examples/jsp/
<html>
<%
   double freeMem = Runtime.getRuntime().freeMemory();
   double totlMem = Runtime.getRuntime().totalMemory();
   double percent = freeMem/totlMem;
   if (percent < 0.5) {
%>

<jsp:forward page="one.jsp"/>

<% } else { %>

<jsp:forward page="two.html"/>

<% } %>

</html>

4228

Corso JSP - Le dichiarazioni

corso-jsp-dichiarazioni

JSP: usare le dichiarazioni <%! ... %>

(e le espressioni <%= ... %> )

  Racchiuse tra i tag <%! ... %>, contengono codice Java e sono utilizzate per definire metodi e proprietà della classe generata. Le dichiarazioni sono esterne al servlet, a differenza degli scriptlet. Queste variabili o metodi dichiarati diventeranno variabili di istanza della classe servlet generata. Questo significa che saranno globali a tutto il servlet generato per la pagina. Può servire per definire dei metodi da usarsi con il servlet, dichiarare attibuti (variabili di oggetto) del servlet.
Sintassi
<%! Dichiarazione %> esempio

Copia e completa il codice

<%@page contentType="text/html" pageEncoding="utf-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>JSP Page</title> </head> <body> <h1>Corso JSP - Le dichiarazioni: crea una funzione per stampare 5 numeri random</h1> <h2>NB: non ci sono i controlli per ordinare i numeri e verificare l'assenza di duplicati, prova a completare il codice usando gli array</h2>

<%! private String lottoGame() { return ("<h2>" + (int)Math.floor(Math.random() * 90 +1 )+ "</h2>"); } %>

<%= lottoGame() %>

<%= lottoGame() %>

<%= lottoGame() %>

<%= lottoGame() %>

<%= lottoGame() %>

</body> </html>
4224

Corso JSP - Sessioni: salvare l'input di un form html

corso-jsp-sessioni

file index.jsp

pagina con form per l'invio dei dati

<%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <h1>Prima pagina con form per l'invio dei dati</h1> <h2><a href="index.jsp">home</a></h2> <form method="post" action="saveName.jsp"> Come ti chiami? <br/><input type="text" name="nomeUtente" value="<%= session.getAttribute( "userName" ) %>" /> <br/> <input type="submit" value="registra"/> </form> </body> </html>

file saveName.jsp

In questa pagina memorizzo il nome in una variabile di sessione JSP

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<% String name = request.getParameter( "nomeUtente" ); session.setAttribute( "userName", name );  %>

<!DOCTYPE html>
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <h1>In questa pagina memorizzo il nome in una variabile di sessione!</h1> <a href="showName.jsp">Continua</a> </body> </html>

file showName.jsp

In questa pagina richiamo la variabile di sessione JSP

<%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body>

<h1>In questa pagina richiamo la variabile di sessione <i>userName</i></h1> <h2>Benvenuto <u><%= session.getAttribute( "userName" ) %></u></h2> <h2><a href="index.jsp">Torna alla home page</a></h2>

</body> </html>
4204

Corso JSP - Condizione If Else

corso-jsp-if-else

<%-- Document : if_else Created on : 14-mag-2013, 16.38.00 Author : mauro --%> <%@ page import="java.util.*, java.text.*" %> <%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <h1>Condizione if else</h1>

<%

int goal_toro = 3, goal_juve = 2;

String prima = null; if (goal_toro > goal_juve) { vince = "toro"; } else { vince = "juve"; }

out.println("Vince: "+vince);

out.println("<h2>Torino - Juventus 3-2 (27-3-1983)</h2>"); %>

<h1>Condizione if else e gioco della moneta</h1>

<%

if (Math.random() < 0.5) {%> <h1>Testa!</h1> <% } else {%> <h1 style="color:red;">Croce!</h1> <% }

%>

</body> </html>
4201

Corso JSP - Ciclo DO WHILE

corso-jsp-ciclo-do-while

Ciclo DO WHILE con JSP

 (il ciclo viene eseguito almeno una volta)

<%-- Document : CicloDOWhile Created on : 28-mag-2013, 16.43.59 Author : mauro --%> <%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Corso JSP</title> </head> <body> <h1>Corso JSP - Uso del ciclo DO WHILE</h1> <h2>Uso dell'oggetto implicito OUT per stampare il valore a video</h2> <table > <tr> <td></td> <td>numero</td> <td>aggiungo +1 al numero base </td> <td>moltiplico *2 il numero base </td> </tr>

<% int i=0; do{ out.print("<tr><td>numero</td><td>"+i+"</td>"+"<td>"+(i+1)+"</td>"+"<td>"+(i*2)+"</td></tr>"); i++; } while(i<=10); %>

</body> </html>
4196

Corso JSP - Ciclo WHILE

corso-jsp-ciclo-while

<%-- Document : CicloWhile Created on : 28-mag-2013, 16.43.59 Author : mauro --%> <%@page contentType="text/html" pageEncoding="UTF-8"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <h1>Uso del ciclo WHILE</h1> <h2>Uso dell'oggetto implicito OUT per stampare il valore a video</h2> <table > <tr> <td></td> <td>numero</td> <td>aggiungo +1 al numero base </td> <td>moltiplico *2 il numero base </td> </tr> <% int i=0; while(i<=10) { out.print("<tr><td>numero</td><td>"+i+"</td>"+"<td>"+(i+1)+"</td>"+"<td>"+(i*2)+"</td></tr>" ); i++; } %> </body> </html>
4192

Corso JSP - Ciclo for ed espressioni

corso-jsp-ciclo-for

<%-- Document : CicloFor Created on : 6-mag-2013, 12.29.49 Author : mauro --%>   <html> <head> <style> table td { border:1px solid #ccc; } </style> </head> <body> <h1>Uso del ciclo for</h1> <h2>Uso delle espressioni per stampare il valore a video</h2> <table > <tr> <td></td> <td>numero</td> <td>aggiungo +1 al numero base </td> <td>moltiplico *2 il numero base </td> </tr> <% for ( int i = 0; i < 10; i++ ) { %> <tr> <td>numero</td> <td><%= i %></td> <td><%= i+1 %></td> <td><%= i*2 %></td> </tr> <% } %> </table> </body> </html>
4188

Corso JSP - Array di tipo stringa - metodo 2

corso-jsp-array-di-tipo-stringa-metodo-2

<%@ page contentType="text/html; charset=utf-8" language="java" %>

<% String[] stArray=new String[4]; stArray[0]="cane"; stArray[1]="gatto"; stArray[2]="topo"; stArray[3]="papero"; %>

<html> <body> <h1>Array di tipo stringa, un modo per definirli e popolarli</h1> <br/>     <%     int i=0;     for(i=0; i<stArray.length; i++)     {       out.print("Animale "+ i + ": " + stArray[i] + "<br/>");     }     %>
4181

Corso JSP - Array di tipo List

corso-jsp-array-list

<%-- Document : array Created on : 6-mag-2013, 19.19.53 Author : mauro --%> <%@ page import="java.util.ArrayList" language="java" %> <% ArrayList al=new ArrayList(); al.add("mela"); al.add("pera"); al.add("banana"); al.add("fragola"); %> <html> <body> <body> <h1>Array di tipo Vettore, devo importare java.util.ArrayList</h1> <br/> <% int i=0; for(i=0;i<al.size();i++) { out.print("Frutta: "+al.get(i)+"<br/>"); } %> </body> </html>  
4179

Corso JSP - Array di tipo vettore + esempio ciclo for

corso-jsp-array-di-tipo-kvettor-esempio-ciclo-for

<%-- Document : array Created on : 6-mag-2013, 19.19.53 Author : mauro --%> <%@ page import="java.util.Vector" language="java" %> <% Vector vc=new Vector(); vc.add("bianco"); vc.add("rosso"); vc.add("verde"); vc.add("blu"); %> <html> <body> <h1>Array di tipo vettore, devo importare java.util.Vector</h1> <br/> <% int i=0; for(i=0;i<vc.size();i++) { out.print("Vettore: "+vc.get(i)+"<br/>"); } %> </body> </html>

4175

Corso JSP - Funzione contatore accessi + esempio uso dichiarazioni e espressioni

corso-jsp-dichiarazioni-espressioni

Corso JSP - Funzione contatore accessi + esempio uso dichiarazioni e espressioni <%-- Document : contatore Created on : 7-mag-2013, 15.47.29 Author : mauro --%> <%@page contentType="text/html" pageEncoding="utf-8" language="java"%> <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>JSP Page</title> </head> <body> <%! int conta = 0; %> <%! public void contatore() { conta ++; } %> Questa pagina è stata caricata <%= conta %> volte. <% contatore(); %> </body> </html>
4172

Corso JSP - Array di tipo intero + esempio ciclo for

corso_jsp_array_intero_ciclo_for

<%-- Document : array Created on : 6-mag-2013, 19.19.53 Author : mauro --%> <%@ page contentType="text/html; charset=utf-8" language="java" %> <% int[] intArray={23,45,13,54,78}; %> <html> <body> <h1>Array di tipo intero</h1> <br/> <% int i=0; for(i=0;i<intArray.length;i++) { out.print("Numero: "+intArray[i]+"<br/>"); } %> </body> </html>
4164

Corso JSP - Array di tipo stringa e uso dell'oggetto implicito out

corso-jsp-array-stringa-0

<%-- Document : array Created on : 6-mag-2013, 19.19.53 Author : mauro --%> <%@ page contentType="text/html; charset=iso-8859-1" language="java" %> <% String[] stArray={"yamaha","honda","suzuki","kawasaki"}; %> <html> <body> <h1>Array di tipo stringa e uso dell'oggetto implicito out</h1> <br/> <% int i=0; for(i=0;i<stArray.length;i++) { out.print(i+" Moto: "+stArray[i]+"<br/>"); } %> </body> </html>
4533

Corso JSP - Esempio JSTL Core

corso-jsp-esempio-jstl-core

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - JSTL e EL

JSP Standard Tag Library e Expression Language
<%-- 
    Document   : core
    Created on : 26-giu-2013, 15.16.15
    Author     : mauro
--%>
<!-- collega la taglib e assegna il prefisso, in questo caso usa la lettera c -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<html>
<head>
<title>Esempi core</title>
</head>
<body>
    <h1>Esempio con tag: out</h1>
<!-- la lettera del prefisso permette di accedere agli oggetti ed ai metodi definiti nella taglib vedi gli esempi -->
<c:out value="${'<body> , %'}"/>

    <h1>Esempio con tag: set</h1>
<c:set var="prodotto" scope="session" value="${2000*2}"/>
<c:out value="${prodotto}"/>
    <h1>Esempio con tag: remove</h1>
<c:remove var="prodotto"/>
<c:out value="${prodotto}"/>

    <h1>Esempio con tag: catch e if</h1>
<c:catch var ="catchException">
   <% int x = 10/0;%>
</c:catch>

<c:if test = "${catchException != null}">
   <p>The exception is : ${catchException} <br />
   There is an exception: ${catchException.message}</p>
</c:if>
    <h1>Esempio con tag: choose</h1>

    <c:set var="prodotto" scope="session" value="${5000+500+50+5}"/>

<c:choose>
    <c:when test="${prodotto <= 0}">
       Il valore del prodotto è minore di 0.
    </c:when>
    <c:when test="${prodotto > 1000}">
       Il valore del prodotto è maggiore di 1000.
    </c:when>
    <c:otherwise>
        <c:out value="${prodotto}"/>
    </c:otherwise>
</c:choose>   

<h2>Esempio con import: importa il sorgente di una pagina web con JSTL</h2>
<%--<c:import var="data" url="http://www.bogliaccino.it"/>--%>
<h2>stampa il codice importato</h2>
<%--<c:out value="${data}"/>--%>

</body>
</html>

4539

Corso JSP - Esempio JSTL Functions

corso-jsp-esempio-jstl-functions

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - JSTL

<%-- 
    Document   : newjspfucntions
    Created on : 26-giu-2013, 16.27.22
    Author     : mauro
--%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
<h2>la funzione replace fn:replace()</h2>
<c:set var="stringa1" value="Questa è la prima stringa."/>
<c:out value="${stringa1}"/>
<c:set var="stringa2" value="${fn:replace(stringa1, 
                                'prima', 'seconda')}" />

<p>Stringa modificata: ${stringa2}</p>
<h2>la funzione split e la funzione join fn:split() fn:join()</h2>
<c:set var="stringa1" value="Questa è la prima stringa."/>
<c:set var="stringa2" value="${fn:split(stringa1, ' ')}" />
<c:set var="stringa3" value="${fn:join(stringa2, '|')}" />

<p>Stringa (3) : ${stringa3}</p>

<c:set var="stringa4" value="${fn:split(stringa3, '|')}" />
<c:set var="stringa5" value="${fn:join(stringa4, ' ')}" />

<p>Stringa (5) : ${stringa5}</p>
    </body>
</html>

4523

Corso JSP - Esempio Java Server Faces

corso-jsp-java-server-faces

"Programmazione web server-side con JSP" - corso IFTS - ITIS Pininfarina (TO) - Corso JSP - 

Corso JSP - Java Server Faces

Hello world JSF con Netbeans 7.3
  1. Crea un nuovo progetto Java Web - > Web Application
  2. Assegna un nome al progetto e salvalo sul disco
  3. Scegli un server web
  4. Scegli il framework Java Server Faces
  5. Clicca su 'Fine'
In Source Packages aggiungi un nuovo package (p.es login ), all'interno del package aggiungi una classe java (p. es accesso.java) Incolla il codice seguente
package login;

import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;

/**
*
* @author mauro
*/

@ManagedBean
@RequestScoped
public class accesso {
public String login;

public String getLogin() {
return login;
}

public void setLogin(String login) {
this.login = login;
}

public accesso() {
}
}
Il file index.xhtml contiene il form per l'invio del nome utente, incolla il codice all'interno dei tag h:body
    
<h:form>

<h2>login</h2>
Login: <h:inputText id="login" size="30" required="true" requiredMessage="inserisci nome utente" value="#{accesso.login}" />

<h:/form>
Iinfine crea il file login.xhtml che visualizza il testo inviato. Attenzione! Anche questo codice dovrà compreso all'interno dei tag h:form, così come il campo input per l'invio del testo.
    
<h:form>

Benvenuto: <h:outputText value="#{accesso.login}" />
            <h:commandLink value="torna alla home" action="index"/>

<h:/form>

4502

Corso JSP - Operazioni sul filesystem - scrivi e leggi file

corso-jsp-operazioni-sul-filesystem-scrivi-e-leggi

Scrivi su file

Usare la direttiva page per importare il package input-output import="java.io.*"
 <%@ page import="java.io.*" %>
Poi definisci una stringa di testo e il percorso del file <% String stringa = "scrivimi sul file"; String nome_file = "/percorso/assoluto/file_scritto.txt"; %> Infine con un try-catch scrivi il file usando l'oggetto Printwriter.
<%
try {   
    PrintWriter scrivi = new PrintWriter(new FileOutputStream(nome_file));
    scrivi.println(stringa);
    scrivi.close();
} catch(IOException e) {
   out.println(e.getMessage());
}
%>

Leggi file

Per leggere un file esistono molte possibilità, la scelta dipende essenzialmente dal contesto in cui il file si trova. Poiché in JSP si può fare tutto quello che si può fare con Java puoi usare il codice:
<%  BufferedReader lettore = new BufferedReader(new FileReader("/percorso/assoluto/file_scritto.txt"));  %>  <% String riga; %>  <% while ((riga = lettore.readLine()) != null) { %>  <%=riga %>  <% } %>
Se il file è raggiungibile dal web puoi usare le JSTL oppure ancora le inclusioni:
<c:import url="percorso/file_scritto.txt" />
<jsp:include page="percorso/file_scritto.txt" />

4157

Programmazione web server-side con JSP

programmazione-web-server-side-con-jsp

Corso IFTS Tecnico superiore per lo sviluppo software

Il modulo "Programmazione web server-side con JSP" fa parte del corso IFTS Tecnico superiore per lo sviluppo software, indirizzo Web Developer organizzato dall'istituto ITIS Pininfarina di Moncalieri, a.a. 2012-13.

obiettivo dell'unità formativa

L'unita' formativa si pone l'obiettivo di fornire gli strumenti e far acquisire le competenze necessarie per sviluppare autonomamente siti web dinamici utilizzando il linguaggio Java ed il server Tomcat.

materiali del corso

Tutti i materiali sono disponibili sulla piattaforma Moodle dell'istituto nella sezione dedicata alla formazione a distanza, FAD al Pinin. Per i testi consigliati si faccia riferimento alla pagina Corso JSP - Bibliografia di questo sito. Per la prima parte del corso si fa riferimento all'ottima  Guida a JSP  di Giuseppe De Pietro, pubblicata sul sito "Porte Aperte sul Web", Comunità di pratica per l'accessibilità dei siti scolastici - USR Lombardia aggiornando la parte riguardante web server Tomcat e JDK alle ultime versioni disponibili. Un'altra risorsa disponibile liberamente in rete cui si fa riferimento per gli esempi ed i tutorial è tutorialspont.com

Che cos'è l'IFTS?

ifts logoIstruzione e Formazione Tecnica Superiore è un canale formativo integrato (realizzato in collaborazione tra Scuola, Università, Impresa, Agenzie Formative) per la formazione di Tecnici Specializzati, figure professionali a livello post-secondario, rispondenti alla domanda proveniente dal mondo del lavoro pubblico e privato, con particolare riguardo al sistema dei servizi, degli enti locali e dei settori produttivi interessati da innovazioni tecnologiche e dalla internazionalizzazione dei mercati secondo le priorità indicate dalla programmazione economica regionale. Tratto da Indire - leggi tutto  

 Argomenti del corso e programma delle lezioni

(macro-progettazione e micro-progettazione) Gli argomenti trattati nel corso JSP e il programma delle lezioni è disponibile sulla piattaforma FAD del Pininfarina e sommariamente descritto alla pagina Corso JSP - Argomenti in questo sito.