Serialisation en Java

Objectif:
Les objectifs de la réunion étaient les suivants:
 Comprendre les principes de base de la serialisation en Java.
 Examiner les avantages et les inconvénients de la serialisation en Java.
 Discuter des meilleures pratiques à suivre pour utiliser la serialisation en Java efficacement.
Concept de serialisation en java :
La serialisation en Java est un mécanisme qui permet de convertir un objet Java en une séquence d'octets, afin de pouvoir le stocker dans un
fichier, le transmettre sur un réseau ou le sauvegarder dans une base de données. La sérialisation est un processus récursif qui permet de
sérialiser des objets complexes qui contiennent des références à d'autres objets. Lorsqu'un objet est sérialisé, tous les objets référencés par
cet objet sont également sérialisés, ce qui peut conduire à une séquence d'octets très importante.
La désérialisation est le processus inverse, qui permet de restaurer un objet Java à partir d'une séquence d'octets. Lorsqu'un objet est
désérialisé, tous les objets référencés par cet objet sont également désérialisés, ce qui permet de restaurer la structure de l'objet d'origine.
Applications :

class Employee implements Serializable {

    private String matricule;
    private String nom;
    private String prenom;
    private double salaire;
    public Employee(String matricule, String nom, String prenom, double salaire) {
        this.matricule = matricule;
        this.nom = nom;
        this.prenom = prenom;
        this.salaire = salaire;
    }}
Ce code définit une classe Employee qui implémente l'interface Serializable en Java. Cela signifie que les instances de cette classe peuvent
être sérialisées et désérialisées pour être stockées ou transférées.

public class SaveEmployees{

    public static void main(String[] args) {
        Employee e = new Employee("700","bensalem","Mohamed",1500);
        try{ File f = new File("employees.ser");
            FileOutputStream of = new FileOutputStream(f);
            ObjectOutputStream objf = new ObjectOutputStream(of);
            objf.writeObject(e);
            objf.close();
        } catch (Exception o) {}
    }}
La classe SaveEmployees est un programme Java qui crée un objet Employee et le sérialise dans un fichier. La méthode main commence
par créer un objet Employee avec des valeurs spécifiées pour ses champs. Ensuite, un fichier File est créé avec le nom "employees.ser". Un
flux de sortie de fichier FileOutputStream est créé pour écrire les données dans le fichier. Un flux d'objet ObjectOutputStream est créé à
partir du flux de sortie de fichier, et l'objet Employee est écrit dans le flux d'objet en utilisant sa méthode writeObject(). Enfin, le flux d'objet
est fermé en utilisant la méthode close(). Si une exception est levée pendant ce processus, elle est attrapée et ignorée.

public class CatEmployee {

    public static void main(String[] args) {
        String filename = args[0];
        try {
            FileInputStream fis = new FileInputStream(filename);
            ObjectInputStream ois = new ObjectInputStream(fis);
            List<Employee> employees = new ArrayList<Employee>();
            employees=(List<Employee>)ois.readObject();
            int i=0;
            while (i<employees.size()) {
                    Employee employee = employees.get(i);
                    System.out.println("Matricule: " + employee.getMatricule());
                    System.out.println("Nom: " + employee.getNom());
                    System.out.println("Prenom: " + employee.getPrenom());
                    System.out.println("Salaire: " + employee.getSalaire());
                    System.out.println("----------------------");
                    i++;
            }
            ois.close();
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }}}
Ce code est un programme Java qui lit le contenu d'un fichier binaire contenant des objets de la classe Employee. Le nom du fichier est
passé en argument en ligne de commande. Le programme utilise un FileInputStream pour lire le contenu du fichier, puis un
ObjectInputStream pour désérialiser les objets de la classe Employee. Les objets sont stockés dans une liste de type ArrayList<Employee>.
Ensuite, le programme affiche les informations de chaque employé stocké dans la liste. Le programme utilise une boucle while pour
parcourir chaque élément de la liste, puis affiche les propriétés de chaque employé en appelant les méthodes getters de la classe Employee.
Si une exception est levée lors de l'exécution du programme, le message d'erreur est affiché.
public class ConvertToText {
    public static void main(String[] args) {
        String inputFilename = args[0];
        String outputFilename = args[1];
        try {
            FileInputStream fis = new FileInputStream(inputFilename);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Employee employee = (Employee) ois.readObject();
            ois.close();
            FileWriter fw = new FileWriter(outputFilename);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write("Matricule:" + employee.getMatricule()+' ');
            bw.write("Nom:" + employee.getNom()+' ');
            bw.write("Prenom:" + employee.getPrenom()+' ');
            bw.write("Salaire:" + employee.getSalaire()+' ');
            bw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }}}
La classe ConvertToText est un programme Java qui prend en entrée un fichier contenant un objet Employee sérialisé et crée un fichier
texte avec les données de cet objet. La méthode main commence par récupérer les noms de fichiers d'entrée et de sortie à partir des
arguments de ligne de commande. Ensuite, un flux d'entrée de fichier FileInputStream est créé pour lire les données du fichier d'entrée. Un
flux d'objet ObjectInputStream est créé à partir du flux d'entrée de fichier, et l'objet Employee est lu à partir du flux d'objet en utilisant sa
méthode readObject(). Enfin, les champs de l'objet Employee sont écrits dans un fichier texte en utilisant la classe FileWriter et la classe
BufferedWriter. Si une exception est levée pendant ce processus, elle est attrapée et imprimée en utilisant la méthode printStackTrace().

public class ConvertToText2

We add 2 things :String separator=args[0] and +separator in every line of output.
Ce code est très similaire au code précédent, mais il y a une différence notable: il prend un paramètre supplémentaire appelé separator,
qui est utilisé pour spécifier le séparateur entre les différents champs dans le fichier texte de sortie. Ce paramètre est stocké dans la variable
separator et est utilisé pour ajouter le séparateur approprié entre chaque champ lors de l'écriture des données de l'employé dans le fichier
texte.

public class ConvertTextFileToObjFile{

    public static void main(String[] args) {
        String inputFilename = args[0];
        String outputFilename = args[1];
        try {
            BufferedReader reader = new BufferedReader(new FileReader(inputFilename));
            String line = reader.readLine();
            String[] tokens = line.split(" ");
            String matricule = tokens[0].substring(tokens[0].indexOf(':') + 1);
            String nom = tokens[1].substring(tokens[1].indexOf(':') + 1);
            String prenom = tokens[2].substring(tokens[2].indexOf(':') + 1);
            double salaire = Double.parseDouble(tokens[3].substring(tokens[3].indexOf(':') + 1));
            reader.close();
            Employee employee = new Employee(matricule, nom, prenom, salaire);
            FileOutputStream fos = new FileOutputStream(outputFilename);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(employee);
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }}}
 Le code prend en entrée un nom de fichier texte contenant les informations d'un employé, les lit et les stocke dans un objet de la classe
Employee. Ensuite, il utilise un objet ObjectOutputStream pour écrire l'objet Employee sérialisé dans un fichier de sortie. Ce fichier peut être
facilement lu par d'autres programmes Java pour obtenir les informations de l'employé.
public class AddEmployee {
    public static void main(String[] args) {
        try {
            File f = new File(args[0]);
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois = new ObjectInputStream(fis);
            List<Employee> employees = new ArrayList<Employee>();
            employees.add((Employee)ois.readObject());
            ois.close();
            Employee newEmployee = new Employee(args[1], args[2], args[3],
Double.parseDouble(args[4]));
            employees.add(newEmployee);
            FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(employees);
            oos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }}}
 Ce code Java permet d'ajouter un nouvel employé à une liste d'employés stockée dans un fichier. Les informations de l'employé sont
passées en arguments lors de l'exécution du programme. Le programme commence par ouvrir le fichier de données existant en lecture. Il lit
ensuite la liste des employés à partir du fichier et ajoute l'employé nouvellement créé à la fin de la liste. Ensuite, il ferme le fichier de lecture
et ouvre le fichier en écriture. Il écrit la liste des employés mise à jour dans le fichier. S'il y a des erreurs, il les imprime à la console.

public class RemoveEmployee {

    public static void main(String[] args) {
        String filename = args[0];
        String matriculeToRemove = args[1];
        try {
            // Read the current list of employees from the file
            FileInputStream fis = new FileInputStream(filename);
            ObjectInputStream ois = new ObjectInputStream(fis);
            ArrayList<Employee> employees = new ArrayList<Employee>();
            employees=(ArrayList<Employee>) ois.readObject();
            ois.close();
            // Remove the employee with the specified matricule
            Employee employeeToRemove = null;
            for (Employee employee : employees) {
                if (employee.getMatricule().equals(matriculeToRemove)) {
                    employeeToRemove = employee;
                    break;
                }
            }
                employees.remove(employeeToRemove);
            FileOutputStream fos = new FileOutputStream(filename);
            ObjectOutputStream oos = new ObjectOutputStream(fos);    
                oos.writeObject(employees);  
            oos.close();
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }}}
 Ce code permet de supprimer un employé d'une liste d'employés stockée dans un fichier en utilisant le numéro de matricule de
l'employé à supprimer en tant qu'argument d'entrée.Le programme commence par lire la liste actuelle d'employés à partir du fichier en
utilisant un objet FileInputStream et un ObjectInputStream. Ensuite, il parcourt la liste d'employés à la recherche de l'employé à supprimer
en comparant le numéro de matricule avec celui fourni en entrée. Une fois qu'il a trouvé l'employé à supprimer, il le supprime de la
liste.Enfin, le programme réécrit la liste mise à jour d'employés dans le fichier en utilisant un objet FileOutputStream et un
ObjectOutputStream.

public class ModifyEmployee {

    public static void main(String[] args) {
        String filename = args[0];
        String matriculeToModify = args[1];
        try {
            // Read the current list of employees from the file
            FileInputStream fis = new FileInputStream(filename);
            ObjectInputStream ois = new ObjectInputStream(fis);
            ArrayList<Employee> employees = new ArrayList<Employee>();
            employees = (ArrayList<Employee>) ois.readObject();
            ois.close();
            // Modify the employee with the specified matricule
            Employee employeeToModify = null;
            for (Employee employee : employees) {
                if (employee.getMatricule().equals(matriculeToModify)) {
                    employeeToModify = employee;
                    break;
                }}
            employeeToModify.setNom(args[2]);
            employeeToModify.setSalaire(parseDouble(args[4]));
            employeeToModify.setPrenom(args[3]);
            // Write the updated list of employees back to the file
            FileOutputStream fos = new FileOutputStream(filename);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(employees);
            oos.close();
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }}}
 Ce code permet de modifier les informations d'un employé existant dans un fichier enregistré en utilisant son matricule.Tout d'abord, les
arguments passés en ligne de commande sont récupérés. Le premier argument représente le nom du fichier contenant les informations des
employés, le deuxième argument représente le matricule de l'employé à modifier, le troisième argument représente le nouveau nom, le
quatrième argument représente le nouveau prénom et le cinquième argument représente le nouveau salaire.Ensuite, le code ouvre le
fichier d'employés, récupère la liste des employés, recherche l'employé à modifier en utilisant son matricule, modifie ses informations avec
les nouvelles valeurs, puis écrit la liste des employés mise à jour dans le fichier.Si une exception est levée à tout moment pendant le
processus, le programme affiche un message d'erreur.

Test et validation :

Conclusion :

La sérialisation est utile pour stocker des objets Java dans des fichiers ou des bases de données, et pour transférer des objets Java sur un
réseau. Cependant, la sérialisation peut également poser des problèmes de sécurité si les données sérialisées sont accessibles à des tiers.
Pour éviter ces problèmes de sécurité, il est recommandé de prendre des mesures appropriées pour sécuriser les données sérialisées, telles
que la validation de la source des données et la vérification de l'intégrité des données.
Voici quelques-unes des meilleures pratiques à suivre pour utiliser la serialization en Java efficacement :
1. Éviter la sérialisation .
2. Éviter la sérialisation de données sensibles .
3. Assurer la compatibilité entre les versions .
4. Utiliser la sérialisation personnalisée .
5. Vérifier les performances de la sérialisation .
En suivant ces meilleures pratiques, il est possible d'utiliser la serialization en Java de manière efficace et sécurisée.