Médiaforma

All posts tagged java

Les fichiers au format JSON (JavaScript Object Notation) permettent de représenter des informations structurées.

Par exemple :

{
  "Employés": [
  { "Prénom":"John" , "Nom":"Doe" },
  { "Prénom":"Anna" , "Nom":"Smith" },
  { "Prénom":"Peter" , "Nom":"Jones" }
  ]
}

 

Ce qui équivaut à :

<Employés Prénom="John" Nom="Doe">
<Employés Prénom="Anna" Nom="Smith">
<Employés Prénom="Peter" Nom="Jones">

 

Pour accéder à des données JSON, vous utiliserez la fonction $.getJSON() :

$.getJSON(URL,function(données){
  // Une ou plusieurs instructions pour traiter les données lues
});

 

 

 

Saisissez ces données dans NotePad++ et sauvegardez-les dans le fichier employes.json :

{
  "Prenom":"John",
  "Nom":"Doe",
  "Age":"25"
}

 

 

Nous allons accéder à ce fichier en jQuery et exploiter les données qui le composent. Voici le résultat attendu :

 

 

Et voici le fichier HTML5/jQuery utilisé :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Lecture et parsing d'un fichier JSON</title>
    <style>
      #zone {
        width: 300px;
        height: 315px;
        border-style: solid;
        border-width: 3px;
        border-color: black;
      }
    </style>
  </head>
  <body>
    <script src="jquery.js"></script>
    <h2>Lecture et parsing du fichier employes.json</h2>
    <button id="lecture">Lancer la lecture</button>
    <div id="zone"></div>
    <script>
      $(function() {
        $('#lecture').on('click', function(){
          $.getJSON('employes.json',function(data){
            $('#zone').append('Prénom : ' + data.Prenom + '<br>');
            $('#zone').append('Nom : ' + data.Nom + '<br>');
            $('#zone').append('Age : ' + data.Age + '<br>');
          });
        });
      });
    </script>
  </body>
</html>

 

L’extraction (aussi appelée parsing) des données se fait dans la fonction callback :

$.getJSON('employes.json',function(data){
  $('#zone').append('Prénom : ' + data.Prenom + '<br>');
  $('#zone').append('Nom : ' + data.Nom + '<br>');
  $('#zone').append('Age : ' + data.Age + '<br>');
});

 

La structure du fichier JSON pris en exemple est ultra simple. Pour accéder à ses différentes composantes, on utilise le paramètre de la fonction callback, suffixé par le nom des différents champs à accéder :

data.Prenom
data.Nom
data.Age

 

Exercice :

Créez le fichier employes2.json :

[
  { "Prenom":"John" , "Nom":"Doe", "Age":"25" },
  { "Prenom":"Anna" , "Nom":"Smith", "Age":"34" },
  { "Prenom":"Peter" , "Nom":"Jones", "Age":"17" }
]

 

Modifiez le code jQuery pour afficher toutes les données de ce fichier JSON. Pour cela, vous parcourrez les données retournées par la fonction $.getJSON() en utilisant la fonction $.each() dont voici la syntaxe :

$.each(données à examiner, function(index, données extraites){
  // Instructions pour examiner les données extraites
});

 

 

Solution :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Lecture et parsing d'un fichier JSON</title>
    <style>
      #zone {
        width: 300px;
        height: 315px;
        border-style: solid;
        border-width: 3px;
        border-color: black;
      }
    </style>
  </head>
  <body>
    <script src="jquery.js"></script>
    <h2>Lecture et parsing du fichier employes.json</h2>
    <button id="lecture">Lancer la lecture</button>
    <div id="zone"></div>
    <script>
      $(function() {
        $('#lecture').on('click', function(){
          $.getJSON('employes2.json',function(data){
            $.each(data,function(index,d){
              $('#zone').append('Prénom : ' + d.Prenom + '<br>');
              $('#zone').append('Nom : ' + d.Nom + '<br>');
              $('#zone').append('Age : ' + d.Age + '<br><br>');
            });
          });
        });
      });
    </script>
  </body>
</html>

 

La fonction callback de $.getJSON() obtient la totalité des données du fichier JSON. La boucle $.each() porte sur les données extraites par $.getJSON(). Sa fonction callback va s’intéresser individuellement à chaque enregistrements, ici représentés par la lettre “d” :

$.getJSON('employes2.json',function(data){
  $.each(data,function(index,d){

 

Pour extraire les données d’un enregistrement, il suffit de passer par “d” et de le suffixer par le nom des champs concernés : Prenom, Nom et Age :

$('#zone').append('Prénom : ' + d.Prenom + '<br>');
$('#zone').append('Nom : ' + d.Nom + '<br>');
$('#zone').append('Age : ' + d.Age + '<br><br>');

 

Voici le résultat :

 

 


Affichez le contenu du fichier texte d’URL http://lem.korp.free.fr/ReadMe.txt en utilisant les méthodes des classes URL et URLConnection.

Solution

import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class FichierTexte {

    public static void main(String[] args) {
      URL uneURL=null;
      try {
        uneURL = new URL("https://lem.korp.free.fr/ReadMe.txt");
        URLConnection connexion = uneURL.openConnection();
        InputStream flux = connexion.getInputStream();
        int longueur = connexion.getContentLength();
        System.out.println("longueur=" + longueur);
        for(int i=1;i<longueur;i++)
          System.out.print((char)flux.read());
        flux.close(); 
      } 
      catch(Exception e) {
          System.out.println(e);
      }
    }

}

Ecrivez quelques lignes de Java pour extraire le protocole, le hôte, le port et le chemin des URL suivantes :

http://www.provider.com:80/fichiers/unfichier.pdf

ftp://pierre:legrandPierre56@ftpperso.free.fr:21/fichiers

Solution

import java.net.*;
public class manipulationURL {
    public static void decode(String s){
        URL uneURL=null;
        try{
            uneURL = new URL(s);
        }
        catch(MalformedURLException mal){
          System.out.println(mal);
        }
        System.out.println("Analyse de l'URL " + s);
        System.out.println("getProtocol() -> " + uneURL.getProtocol());
        System.out.println("getHost() -> " + uneURL.getHost());
        System.out.println("getPort() -> " + uneURL.getPort());
        System.out.println("getFile() -> " + uneURL.getFile());
        System.out.println("getUserInfo() -> " + uneURL.getUserInfo());

        System.out.println();
    }

    public static void main(String[] args) {
      decode("http://www.provider.com:80/fichiers/unfichier.pdf");
      decode("ftp://pierre:legrandPierre56@ftpperso.free.fr:21/fichiers");
    }
}

Voici le résultat :

 

 


Les éléments accessibles sur Internet ou sur l’Intranet d’une entreprise sont représentés par leur URL (Uniform Resource Locator). La syntaxe utilisée dans l’URL est fonction du protocole utilisé :

Protocole URL
http http://serveur:port/chemin?param1&param2&param3
ftp ftp://utilisateur:motDePasse@serveur:port/chemin
mail mailto:email
fichier local file://serveur/chemin

 

Pour accéder à un élément par son URL en Java, vous utiliserez les classes URL et URLConnection. Voici quelques-unes des méthodes utilisables :

Classe Méthode Objet de cette méthode
URL getProtocol() Partie protocole de l’URL
URL getHost() Partie hôte de l’URL
URL getPort() Port utilisé dans l’URL
URL getFile() chemin complet de l’URL
URL getUserInfo() Nom de l’utilisateur de l’URL, ou null si inexistant
URLConnection openConnection() Ouverture d’une connexion vers une URL
URLConnection openStream() Ouverture d’un flux de données en entrée
URLConnection getContentLength() Longueur du flux de données

La classe InetAddress permet d’obtenir toutes les informations attachées à une adresse IP. Voici les méthodes utilisables :

Méthode Utilité
InetAddress getByName(String) Retourne l’adresse internet associée au nom d’hôte fourni
InetAddress[] getAllByName(String) Retourne un tableau des adresses internet associées au nom d’hôte fourni
InetAddress getLocalHost() Retourne l’adresse internet de la machine locale
byte[] getAddress() Retourne un tableau contenant les quatre octets de l’adresse internet
String getHostAddress() Retourne l’adresse internet sous la forme d’une chaîne de caractères
String getHostName() Retourne le nom du serveur

 

Voici un exemple de code qui utilise les méthodes de la classe InetAddress :

import java.net.*;
public class InetAdresse {

   public static void main(String[] args) {
    try {
      InetAddress adrLocale = InetAddress.getLocalHost();
      System.out.println("Adresse IP locale = "+adrLocale.getHostAddress());
      InetAddress adrServeur = InetAddress.getByName("www.microsoft.com");
      System.out.println("Adresse IP de Microsoft = "+adrServeur.getHostAddress());
      InetAddress[] adrServeurs = InetAddress.getAllByName("www.google.com");
      System.out.println("Les adresses IP de Google : ");
      for (InetAddress s:adrServeurs)
          System.out.println("     "+s.getHostAddress());
    } catch (Exception e) {
        e.printStackTrace();
    }
  }
}

Voici le résultat :

 

 


Cette section va vous montrer comment échanger des flux de données sur la couche TCP/IP.

Quelques notions de base

Java propose plusieurs classes et interfaces destinées à faciliter l’utilisation du réseau via les sockets. Ces classes et interfaces sont regroupées dans le package java.net. Les échanges client/serveur se font en utilisant le protocole réseau IP et le protocole de transport TCP ou UDP :

  • Le protocole IP (Internet Protocol) permet d’échanger des paquets d’octets. Ce protocole ne garantit pas que les paquets arrivent jusqu’à leur destinataire. Cette opération peut se faire par un autre protocole tel que TCP.
  • Les protocoles TCP (Transmission Control Protocol) et UDP (User Datagram Protocol) permettent la communication entre deux applications sur des machines distantes.

Les sockets sont implémentés sur tous les systèmes qui utilisent TCP/IP. Ils correspondent à des points de communication par lesquels des informations peuvent être émises par un thread.

Les communications se font sur un port de la machine, identifié par un entier compris entre 1 et 65535.

Les adresses Internet permettent d’identifier de façon unique une machine sur un réseau en utilisant quatre octets séparés par un point. Par exemple : 123.186.12.45

Pour faciliter la compréhension de ces adresses, on utilise un serveur DNS (Domain Name Server) qui associe un nom à chaque adresse IP.


Les servlets sont des classes Java qui gèrent les requêtes http et implémentent l’interface javax.servlet.Servlet. Généralement, les développeurs d’applications Web écrivent des servlets qui étendent la classe abstraite javax.servlet.http.HttpServlet. Cette classe implémente l’interface Servlet et est spécialement conçue pour gérer les requêtes http.

Voici une servlet Hello World. Lorsqu’elle sera invoquée, elle se contentera d’afficher « Hello World » dans le navigateur. Tapez les instructions suivantes dans votre éditeur de code et sauvegardez le fichier sous le nom HelloWorld.java dans votre dossier de travail :

// Importation des bibliothèques Java nécessaires
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

// Extension de la classe HttpServlet
public class HelloWorld extends HttpServlet {

  private String message;

  public void init() throws ServletException {
      // Initialisation de la servlet
      message = "Hello World";
      // Ici, vous pourriez par exemple extraire des données
      // depuis une base de données pour créer la réponse http
  }

  public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      // Définition du type de la réponse
      response.setContentType("text/html");

      // Actions à effectuer dans la servlet
      PrintWriter out = response.getWriter();
      out.println("<h1>" + message + "</h1>");
  }

  public void destroy() {
      // Dans cette servlet, il n'y a rien à faire ici
  }
}

Examinons ce code.

Les premières lignes importent les bibliothèques Java nécessaires à l’exécution d’une servlet.

Pour qu’une classe Java soit une servlet, elle doit :

1) étendre la classe HttpServlet :

 public class HelloWorld extends HttpServlet

2) surcharger la classe doGet ou la classe doPost (selon si les données sont passées par une requête GET ou POST).
 public void doGet(HttpServletRequest request, HttpServletResponse response)

La méthode init() est exécutée une fois, au démarrage de la servlet. Ici, elle initialise le private String message :

public void init() throws ServletException {
message = "Hello World";

Dans cet exemple, nous surchargeons la méthode doGet().

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

Ici :

  • request permet de lire les en-têtes http (les cookies) et les données entrées par l’utilisateur (ici, aucune donnée n’est transmise par GET).
  • response définit la réponse HTTP, c’est-à-dire :
    • le status http (200,404, etc.),
    • l’en-tête (content-type, cookies, etc.),
    • les données à retourner au client, à travers l’objet PrinterWriter.

 

Remarque

Toutes les servlets ont un squelette identique. Seuls changent :

  • le contenu de la méthode init() ;
  • la ou les classes surchargées : doGet() ou/et doPost() ;
  • les traitement effectués dans les classes doGet() et/ou doPost().

 

Autre remarque :

Vous pourriez retourner un code HTML complet au client en remplaçant l’instruction suivante :

out.println("<h1>" + message + "</h1>");

Par ces instructions :

out.println("<HTML>");
out.println("<HEAD><TITLE>Ma première servlet</TITLE></HEAD>");
out.println("<BODY>");
out.println("Hello World");
out.println("</BODY>");
out.println("</HTML>");
out.close();

 

Compilez la classe HelloWorld.java. Pour cela, ouvrez une Invite de commande dans le dossier où se trouve HelloWorld.java et lancez cette commande :

javac -cp %CLASSPATH%;"c:\Program Files\Apache Software Foundation\Tomcat 8.0\lib\servlet-api.jar" HelloWorld.java

Si tout se passe bien, vous devriez obtenir le fichier HelloWorld.class. Les serlvets se trouvent par défaut dans le dossier c:\Program Files\Apache Software Foundation\Tomcat 8.0\webapps\ROOT\WEB-INF\classes\.

Copiez HelloWorld dans ce dossier.

 

Pour que la servlet soit accessible, vous devez lui associer une URL.

Ouvrez le fichier web.xml dans votre éditeur de code (ce fichier se trouve dans c:\Program Files\Apache Software Foundation\Tomcat 8.0\webapps\ROOT\WEB-INF\) et complétez-le avec les instructions en gras :

 

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app 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-app_3_1.xsd"
version="3.1"
metadata-complete="true">

<display-name>Welcome to Tomcat</display-name>
<description>
Welcome to Tomcat
</description>

  <servlet>
    <servlet-name>HelloWorld</servlet-name>
    <servlet-class>HelloWorld</servlet-class>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>HelloWorld</servlet-name>
    <url-pattern>/HelloWorld</url-pattern>
  </servlet-mapping>

</web-app>

Le bloc <servlet></servlet> définit le nom et la classe de la servlet.

Le bloc <servlet-mapping></servlet-mapping> définit l’URL associée à la servlet. Ici /HelloWorld.

 

Il ne vous reste plus qu’à naviguer vers l’URL http://localhost:8080/HelloWorld pour lancer la servlet et obtenir un Hello World en retour :