Internazionalizzazione con Java Server Faces

In questi giorni mi sto dando allo studio delle Java Server Faces (JSF) e mi sono subito imbattuto in un problema: l'internazionalizzazione.

Volendo evitare modalità "classiche" tipo cookie o salvare i testi direttamente dentro un classe, possiamo procedere in questo modo.

Nel mio package ho creato un sotto package con dentro i file di properties: com.mf.language.

I file di properties devono avere questa nomenclatura: nome_lingua.properties, tranne quello di default.

Io ne ho due:

• messages.properties (italiano)
• messages_en.properties (inglese)

I file di properties lavorano con il concetto di chiave:valore:

ciao=CIAO!

Poi dovete scrivere l'equivalente per la altre lingue nei file appositi.

A questo punto creiamo, se non esiste già, il file di configurazione faces-config.xml dentro a WEB-INF, con questo dentro:

<?xml version='1.0' encoding='UTF-8'?>
<faces-config version="2.2"
              xmlns="http://xmlns.jcp.org/xml/ns/javaee"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd">
    <application>
        <locale-config>
            <default-locale>it</default-locale>
            <supported-locale>en</supported-locale>
        </locale-config>
        <resource-bundle>
            <base-name>com_mf.language.messages</base-name>
            <var>msg</var>
        </resource-bundle>
    </application>
</faces-config>

In pratica gli diciamo dove sono i file delle lingue, e ne impostiamo una di default.

Registrazione Servlet in una web app Java

Le Servlet sono dei componenti fondamentali in una applicazione web scritta in Java.

L'unica cosa che bisogna ricordarsi è di registrarle; per farlo abbiamo due modi.

Il primo, quello classico, è usare il file web.xml; in genere gli IDE richiedono se registrare una Servlet nel web.xml o meno (o almeno Netbeans lo fa).

Coumunque è sempre possibile farlo a mano con questa sintassi:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <servlet>
        <servlet-name>SimpleServlet</servlet-name>
        <servlet-class>com_mf.SimpleServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SimpleServlet</servlet-name>
        <url-pattern>/SimpleServlet</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
</web-app>

Nelle ultimissime versioni, però, non è più obbligatorio usare questo file; è possibile registrarle direttamente da codice usando una semplice riga.

Gestire le sessioni con le Servlet

Gestire le sessioni con le Servlet è abbastanza semplice.

Prendiamo uno scenario del genere:

-form di login

-se l'utente esiste viene creato un oggetto User

-l'oggetto viene passato alla Servlet che crea una sessione

Quindi partendo da un form del genere:

<table>
<form action="ServletLogin" method="post">
<tbody>
<tr>
<td>User:</td>
<td><input type="text" id="focus" name="username" value="" /></td>
</tr>
<tr>
<td>Password:</td>
<td><input type="password" name="password" value="" /></td>
</tr>
<tr>
<td><input type="submit" value="Submit" name="submit" /></td>
</tr>
</form>
</table>

Questo form richiama la ServletLogin in POST:

public class ServletLogin extends HttpServlet {

private DBManager db = DBManager.getInstance(); // CLASSE PER LA CONNESSIONE

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
boolean success = false;
HttpSession session = request.getSession(true);
if (session.getAttribute("user") == null) {
try {
User user = db.login(request.getParameter("username").trim(), request.getParameter("password").trim());
String userCreato = user.getName().toString();
int userCreatoId = user.getId();
session.setAttribute("user_id", userCreatoId);
session.setAttribute("user_name", userCreato);
success = true;
if (success) {
response.sendRedirect("index.jsp");
} else {
response.sendRedirect("error.jsp?err=Atenticazione fallita");
}
} catch (ClassNotFoundException ex) {
response.sendRedirect("error.jsp?err=" + ex.getMessage());
} catch (SQLException ex) {
response.sendRedirect("error.jsp?err=" + ex.getMessage());
} catch (NoSuchAlgorithmException ex) {
response.sendRedirect("error.jsp?err=" + ex.getMessage());
}
}
}

}

Istanzia un oggetto HttpSession con il quale prendiamo la sessione corrente.

Passare dati da una JTable a un JFrame

Lo scenario è questo: abbiamo dei dati su un db che visualiziamo tramite JTable; quando vogliamo modificare un record lo selezioniamo e passiamo i valro a un JFrame che si occuperà di fare questo.

Come fare?

La cosa non è molto difficile.

Dopo aver aggiunto un JButton apposito dobbiamo creare un evento.

Io l'ho fatto fare a NetBeans (sono un pò pigro ).

JFrame full screen

Per rendere un JFrame a schermo intero ci sono diversi modi.

Qui vi spiego due modi per avviare un JFrame massimizzato e uno per renderlo a schermo intero.

Cominciamo proprio da quest'ultimo:

import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import javax.swing.JFrame;

public class DrawPanel extends JFrame {

    public DrawPanel() {
        super("Draw panel");
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        GraphicsDevice cc = ge.getDefaultScreenDevice();
        setVisible(true);
        cc.setFullScreenWindow(this);
    }
}

Nel costruttore del nostro JFrame creiamo un oggetto di classe GraphicsEnvironment il metodo getLocalGraphicsEnvironment().

Sull'oggetto creato richiamiamo il metodo getDefaultScreenDevice() che altro non fa che identificare lo schermo in uso.

Infine setFullScreenWindow mette la finestra in full size (come si evince dallo stesso nome del metodo).