Tutoriel pour le développement d'un client Swing avancé : menus, filtres, enregistrements, services Web REST…

package com.icauda.tp.chien.ihm;

import static java.awt.BorderLayout.CENTER;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.swing.AbstractAction;
import javax.swing.ButtonGroup;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

import org.apache.log4j.Logger;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.general.DefaultPieDataset;

import com.icauda.tp.chien.domain.Chien;
import com.icauda.tp.chien.domain.RaceDeChien;
import com.icauda.tp.chien.domain.Sexe;

public class ChienJFrame8 extends JFrame {

    /**
     * serialVersionUID
     */
    private static final long serialVersionUID = -638731145561555723L;

    private static final Logger LOGGER = Logger.getLogger(ChienJFrame8.class);

    private JTable tableau;
    private ModeleDynamique2 modele;

    private JDialog ratioMaleFemaleJdialog;
    private JDialog poidsJdialog;
    private JDialog poids2Jdialog;

    // Menus
    private JMenuItem menuModifier;
    private JMenuItem menuSupprimer;

    public ChienJFrame8() {
        super();
        setTitle("Liste des chiens (v8)");
        setPreferredSize(new Dimension(500, 400));
        setDefaultCloseOperation(EXIT_ON_CLOSE);

        // tableau
        ajoutDuTableau();

        // Menu
        ajoutDuMenu();

        pack();
    }

    private void ajoutDuMenu() {
        final JMenuBar menuBar = new JMenuBar();

        // Menu Fichier
        final JMenu menuFichier = new JMenu("Fichier");
        menuBar.add(menuFichier);

        // Sous-menus
        final JMenuItem menuOuvrir = new JMenuItem(new OuvrirAction("Ouvrir"));
        menuFichier.add(menuOuvrir);
        final JMenuItem menuSauver = new JMenuItem(new SauverAction("Sauver"));
        menuFichier.add(menuSauver);
        menuFichier.addSeparator();
        final JMenuItem menuQuitter = new JMenuItem(new QuitterAction("Quitter"));
        menuFichier.add(menuQuitter);

        // Menu Edition
        final JMenu menuEdition = new JMenu("Edition");
        menuBar.add(menuEdition);
        final JMenuItem menuAjouter = new JMenuItem(new AjouterLigneAction());
        menuEdition.add(menuAjouter);
        menuModifier = new JMenuItem(new ModifierLigneAction());
        menuEdition.add(menuModifier);
        menuSupprimer = new JMenuItem(new SupprimerLigneAction());
        menuEdition.add(menuSupprimer);
        activerOuDesactiverMenuEdition();

        // Menu Affichage
        final JMenu menuAffichage = new JMenu("Affichage");
        menuBar.add(menuAffichage);

        // Genres
        final JRadioButtonMenuItem menuMale = new JRadioButtonMenuItem(new MaleAction("M"));
        menuAffichage.add(menuMale);
        final JRadioButtonMenuItem menuFemale = new JRadioButtonMenuItem(new FemaleAction("F"));
        menuAffichage.add(menuFemale);
        final JRadioButtonMenuItem menuMaleAndFemale = new JRadioButtonMenuItem(new MaleAndFemaleAction("M & F"));
        menuAffichage.add(menuMaleAndFemale);

        // Group des genres
        final ButtonGroup groupGenre = new ButtonGroup();
        groupGenre.add(menuMale);
        groupGenre.add(menuFemale);
        groupGenre.add(menuMaleAndFemale);
        menuMaleAndFemale.setSelected(true);

        // Menu Graphe
        final JMenu menuGraphe = new JMenu("Graphe");
        menuBar.add(menuGraphe);
        final JMenuItem menuCamember = new JMenuItem(new CamembertMaleFemaleAction());
        menuGraphe.add(menuCamember);
        menuGraphe.addSeparator();
        final JMenuItem menuPoids = new JMenuItem(new PoidsAction());
        menuGraphe.add(menuPoids);
        final JMenuItem menuPoids2 = new JMenuItem(new Poids2Action());
        menuGraphe.add(menuPoids2);

        // Menu ?
        final JMenu menuPointInterrogration = new JMenu("?");
        menuBar.add(menuPointInterrogration);
        final JMenuItem menuPreferences = new JMenuItem(new PreferencesAction("Préférences"));
        menuPointInterrogration.add(menuPreferences);
        final JMenuItem menuAPropos = new JMenuItem(new PreferencesAction("A propos"));
        menuPointInterrogration.add(menuAPropos);

        // Ajout a la fenetre
        setJMenuBar(menuBar);
    }

    private void ajoutDuTableau() {
        modele = new ModeleDynamique2();
        tableau = new JTable(modele);
        getContentPane().add(new JScrollPane(tableau), CENTER);

        tableau.setDefaultRenderer(Sexe.class, new SexeCellRenderer());
        tableau.setDefaultRenderer(RaceDeChien.class, new RaceCellRenderer());

        tableau.getColumnModel().getColumn(4).setCellRenderer(new ListeCouleursCellRenderer());

        tableau.setAutoCreateRowSorter(true);

        final TableRowSorter<TableModel> sorter = new TableRowSorter<TableModel>(tableau.getModel());
        tableau.setRowSorter(sorter);

        // colonne Nom non triable
        sorter.setSortable(0, false);
        // Tri sur le nb de lettres
        sorter.setComparator(1, new StringSizeComparator());

        // Ajout d'un ecouteur
        final ListSelectionModel listSelectionModel = tableau.getSelectionModel();
        listSelectionModel.addListSelectionListener(new TableauListSelectionListener());

    }

    // Menu Fichier
    private class OuvrirAction extends AbstractAction {
        public OuvrirAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            // TODO
        }
    }

    private class SauverAction extends AbstractAction {
        public SauverAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            LOGGER.info("Sauverr");

            modele.sauver();
        }
    }

    private class QuitterAction extends AbstractAction {
        public QuitterAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            LOGGER.info("Au revoir");
            System.exit(0);
        }
    }

    // Menu Affichage
    private class MaleAction extends AbstractAction {
        public MaleAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            modele.rechercheAvecFiltreSurSexe(Sexe.MALE);
        }
    }

    private class FemaleAction extends AbstractAction {
        public FemaleAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            modele.rechercheAvecFiltreSurSexe(Sexe.FEMALE);
        }
    }

    private class MaleAndFemaleAction extends AbstractAction {
        public MaleAndFemaleAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            modele.rechercheAvecFiltreSurSexe(null);
        }
    }

    private class AjouterLigneAction extends AbstractAction {

        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = 7183768497443802311L;

        private AjouterLigneAction() {
            super("Ajouter");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("Click sur le bouton ajouter");

            final AjouterModifierChienActionHandler handler = new AjouterModifierChienActionHandler(modele);
            AjouterModifierChienJDialog popup = new AjouterModifierChienJDialog(handler);

            popup.setVisible(true);

            // final Chien idefix = new SimpleChien("Idefix", "Idefix", MALE,
            // LABRADOR, new String[] { "blanc" }, 25.0);
            // modele.ajouterChien(idefix);
        }
    }

    private class ModifierLigneAction extends AbstractAction {

        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = 7183768497443802311L;

        private ModifierLigneAction() {
            super("Modifier");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("Click sur le bouton modifier");

            final int[] selection = tableau.getSelectedRows();

            if (selection == null || selection.length != 1) {
                // TODO erreur
            }
            final Chien chien = modele.getChienAt(selection[0]);

            final AjouterModifierChienActionHandler handler = new AjouterModifierChienActionHandler(modele);
            AjouterModifierChienJDialog popup = new AjouterModifierChienJDialog(handler, chien);

            popup.setVisible(true);
        }
    }

    private class SupprimerLigneAction extends AbstractAction {

        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = -5556554884674073716L;

        private SupprimerLigneAction() {
            super("Supprimer");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            final int[] selection = tableau.getSelectedRows();
            for (int i = selection.length - 1; i >= 0; i--) {
                modele.supprimerChien(selection[i]);
            }
        }
    }

    private class CamembertMaleFemaleAction extends AbstractAction {

        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = 4515460004284651581L;

        private CamembertMaleFemaleAction() {
            super("Camembert M/F");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("cliv clic");

            final List<Chien> chiens = modele.getChiens();
            int nbMale = 0;
            for (Chien chien : chiens) {
                if (chien.getSexe() == Sexe.MALE) {
                    nbMale++;
                }
            }
            final int nbFemele = chiens.size() - nbMale;

            ratioMaleFemaleJdialog = new JDialog();
            ratioMaleFemaleJdialog.setTitle("Ratio H/F");

            final DefaultPieDataset pieDataset = new DefaultPieDataset();

            pieDataset.setValue("Female", nbFemele);
            pieDataset.setValue("Male", nbMale);

            final JFreeChart pieChart = ChartFactory.createPieChart("Ratio M/F", pieDataset, true, false, false);
            final ChartPanel cPanel = new ChartPanel(pieChart);

            ratioMaleFemaleJdialog.getContentPane().add(cPanel, CENTER);

            ratioMaleFemaleJdialog.pack();
            ratioMaleFemaleJdialog.setVisible(true);

        }
    }

    private class PoidsAction extends AbstractAction {

        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = -2621678352128531798L;

        private PoidsAction() {
            super("Poids");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("cliv clic");

            String[] trancheNames = { "0-5", "6-10", "11-15", "16-20", "21-25", "26-30", "31+" };

            Map<String, Integer> map = new HashMap<String, Integer>();
            for (String trancheName : trancheNames) {
                map.put(trancheName, 0);
            }

            final List<Chien> chiens = modele.getChiens();

            for (Chien chien : chiens) {

                String tranche = "0-5";
                if (6 <= chien.getPoids()) {
                    tranche = "6-10";
                }
                if (11 <= chien.getPoids()) {
                    tranche = "11-15";
                }
                if (16 <= chien.getPoids()) {
                    tranche = "16-20";
                }
                if (21 <= chien.getPoids()) {
                    tranche = "21-25";
                }
                if (26 <= chien.getPoids()) {
                    tranche = "26-30";
                }
                if (31 <= chien.getPoids()) {
                    tranche = "31+";
                }

                Integer value = map.get(tranche);
                value++;
                map.put(tranche, value);
            }

            poidsJdialog = new JDialog();
            poidsJdialog.setTitle("Poids");

            final DefaultCategoryDataset dataset = new DefaultCategoryDataset();

            for (String tranche : trancheNames) {
                final Integer nb = map.get(tranche);
                dataset.addValue(nb, "Poids", tranche);
            }

            final JFreeChart barChart = ChartFactory.createBarChart("Poids", "Tranches", "Nombre", /**/
                    dataset, PlotOrientation.VERTICAL, true, true, false);

            final ChartPanel cPanel = new ChartPanel(barChart);

            poidsJdialog.getContentPane().add(cPanel, CENTER);

            poidsJdialog.pack();
            poidsJdialog.setVisible(true);
        }
    }

    private class Poids2Action extends AbstractAction {

        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = -2621678352128531798L;

        private Poids2Action() {
            super("Poids M/F");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("cliv clic");

            String[] trancheNames = { "0-5", "6-10", "11-15", "16-20", "21-25", "26-30", "31+" };

            Map<String, Integer> maleMap = new HashMap<String, Integer>();
            Map<String, Integer> femaleMap = new HashMap<String, Integer>();
            for (String trancheName : trancheNames) {
                maleMap.put(trancheName, 0);
                femaleMap.put(trancheName, 0);
            }

            final List<Chien> chiens = modele.getChiens();

            for (Chien chien : chiens) {

                String tranche = "0-5";
                if (6 <= chien.getPoids()) {
                    tranche = "6-10";
                }
                if (11 <= chien.getPoids()) {
                    tranche = "11-15";
                }
                if (16 <= chien.getPoids()) {
                    tranche = "16-20";
                }
                if (21 <= chien.getPoids()) {
                    tranche = "21-25";
                }
                if (26 <= chien.getPoids()) {
                    tranche = "26-30";
                }
                if (31 <= chien.getPoids()) {
                    tranche = "31+";
                }

                final Map<String, Integer> map = (chien.getSexe() == Sexe.MALE) ? maleMap : femaleMap;

                Integer value = map.get(tranche);
                value++;
                map.put(tranche, value);
            }

            poids2Jdialog = new JDialog();
            poids2Jdialog.setTitle("Poids M/F");

            final DefaultCategoryDataset dataset = new DefaultCategoryDataset();

            for (String tranche : trancheNames) {
                final Integer nb = maleMap.get(tranche);
                dataset.addValue(nb, "Male", tranche);
            }

            for (String tranche : trancheNames) {
                final Integer nb = femaleMap.get(tranche);
                dataset.addValue(nb, "Female", tranche);
            }

            final JFreeChart barChart = ChartFactory.createBarChart("Poids", "Tranches", "Nombre", /**/
                    dataset, PlotOrientation.VERTICAL, true, true, false);

            final ChartPanel cPanel = new ChartPanel(barChart);

            poids2Jdialog.getContentPane().add(cPanel, CENTER);

            poids2Jdialog.pack();
            poids2Jdialog.setVisible(true);
        }
    }

    private class PreferencesAction extends AbstractAction {
        public PreferencesAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            // TODO
        }
    }

    private class AProposAction extends AbstractAction {
        public AProposAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            // TODO
        }
    }

    private class TableauListSelectionListener implements ListSelectionListener {

        @Override
        public void valueChanged(final ListSelectionEvent event) {
            if (event.getValueIsAdjusting()) {
                return;
            }
            // System.out.println(event);

            activerOuDesactiverMenuEdition();
        }

    }

    private void activerOuDesactiverMenuEdition() {
        final int[] selection = tableau.getSelectedRows();

        // On veut activer le menu supprimer s'il y a au moins une ligne
        // selectionne.
        final boolean isSelection = selection != null && selection.length != 0;
        menuSupprimer.setEnabled(isSelection);

        // On ne veut modifier que s'il y a une seule ligne selectionnee.
        final boolean isUnEtSeulementUnSelection = isSelection && selection.length == 1;
        menuModifier.setEnabled(isUnEtSeulementUnSelection);
    }
}

package com.icauda.tp.chien.ihm;

import org.apache.log4j.Logger;

import com.icauda.tp.chien.domain.Chien;

public class AjouterModifierChienActionHandler implements ActionHandler {

    private static final Logger LOGGER = Logger.getLogger(AjouterModifierChienActionHandler.class);

    private ModeleDynamique2 modele;

    public AjouterModifierChienActionHandler(ModeleDynamique2 modele) {
        this.modele = modele;
    }

    @Override
    public void process(final Action action) throws ChienException {
        LOGGER.debug("process");
        process(action, null);
    }

    @Override
    public void process(final Action action, final Chien chien) throws ChienException {
        LOGGER.debug("process");

        switch (action) {
        case ANNULER:
            annuler();
            break;

        case MODIFIER:
            modifier(chien);
            break;

        case CREER:
            ajouter(chien);
            break;

        case SUPPRIMER:
            supprimer(chien);
            break;

        default:
            throw new IllegalArgumentException("L'action demandee n'est pas disponible");
        }

    }

    private void ajouter(final Chien chien) throws ChienException {
        LOGGER.debug("Ajouter");

        if (!valider(chien)) {
            // TODO lancer une exception...
        }

        // On a acces au modele et on peut donc demander l'ajout.
        modele.ajouterChien(chien);
    }

    private void modifier(final Chien chien) throws ChienException {
        LOGGER.debug("Modifier");

        if (!valider(chien)) {
            // TODO lancer une exception...
        }

        modele.modifierChien(chien);
    }

    private void annuler() {
        LOGGER.debug("Annuler");
        // Ici rien a faire
    }

    private void supprimer(final Chien chien) {
        LOGGER.debug("Supprimer");
        throw new UnsupportedOperationException("Cette fonction n est pas encore disponible");
    }

    /**
     * Valide que les attributs du chien sont bien renseignes.
     */
    private boolean valider(final Chien chien) {

        return true;
    }
}

package com.icauda.tp.chien.ihm;

import static java.awt.BorderLayout.CENTER;
import static java.awt.BorderLayout.SOUTH;
import static javax.swing.SwingConstants.RIGHT;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.util.List;

import javax.swing.AbstractAction;
import javax.swing.DefaultListCellRenderer;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JPanel;
import javax.swing.JTextField;

import org.apache.log4j.Logger;

import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.icauda.tp.chien.domain.Chien;
import com.icauda.tp.chien.domain.RaceDeChien;
import com.icauda.tp.chien.domain.Sexe;
import com.icauda.tp.chien.domain.SimpleChien;

public class AjouterModifierChienJDialog extends JDialog {

    private static final Logger LOGGER = Logger.getLogger(AjouterModifierChienJDialog.class);
    private ActionHandler actionHandler;

    private JTextField nom = new JTextField(15);
    private JTextField nomComplet = new JTextField(15);
    private JComboBox sexe = new JComboBox();
    private JComboBox race = new JComboBox();
    // private JComboBox jour = new JComboBox();
    // private JComboBox mois = new JComboBox();
    // private JComboBox annee = new JComboBox();
    private JTextField couleurs = new JTextField(15);
    private JTextField poids = new JTextField(15);

    private JButton ajouterButton = new JButton(new AjouterAction("Ajouter"));
    private JButton modifierButton = new JButton(new ModifierAction("Modifier"));
    private JButton annulerButton = new JButton(new AnnulerAction("Annuler"));

    private static final int widthLabel = 100;
    private static final int widthChamp = 200;
    // private static final int widthChampMultiple = 60;
    private static final int heightLigne = 20;

    private static final int espace = 5;

    private int y = 0;

    private JPanel formPanel = new JPanel(null);
    private JPanel buttonPanel = new JPanel();

    private Chien chien;

    public AjouterModifierChienJDialog(final ActionHandler actionHandler) {
        this(actionHandler, null);

    }

    public AjouterModifierChienJDialog(final ActionHandler actionHandler, final Chien chien) {
        super();

        this.actionHandler = actionHandler;
        this.chien = chien;

        if (chien == null) {
            setTitle("Ajouter un chien");
        } else {
            setTitle("Modifier un chien");
        }

        // La taille est calculee a l'aide du panel (cf. addFormulaire).
        // setPreferredSize(new Dimension(400, 250));
        setModal(true);

        // Formulaire
        addFormulaire();
        preremplirFormulaire();

        // Boutons
        addBoutons();

        pack();

    }

    private void addBoutons() {
        if (chien == null) {
            buttonPanel.add(ajouterButton);
        } else {
            buttonPanel.add(modifierButton);
        }
        buttonPanel.add(annulerButton);
        add(buttonPanel, SOUTH);
    }

    private void addFormulaire() {
        // Noms
        ajouter("Nom :", nom);
        ajouter("Nom complet :", nomComplet);

        // Sexes
        sexe.addItem(Sexe.MALE);
        sexe.addItem(Sexe.FEMALE);
        sexe.setRenderer(new DefaultListCellRenderer() {
            @Override
            public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
                final Sexe sexe = (Sexe) value;
                setText((sexe == Sexe.MALE) ? "Male" : "Female");
                return this;
            }

        });
        ajouter("Sexe :", sexe);

        // Races
        for (RaceDeChien raceDeChien : RaceDeChien.values()) {
            race.addItem(raceDeChien);
        }
        race.setRenderer(new DefaultListCellRenderer() {
            @Override
            public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
                final RaceDeChien raceDeChien = (RaceDeChien) value;
                setText(raceDeChien.getLabel());
                return this;
            }
        });
        ajouter("Race :", race);

        // Couleurs, poids
        ajouter("Couleurs :", couleurs);
        ajouter("Poids :", poids);

        // Si on avait voulu mettre des champs pour la date de naissance, on
        // aurait pu faire comment suit :
        // for(int i = 1; i <= 31;i++) {
        // jour.addItem(i);
        // }
        //
        // // Date de naissance
        // for (int i = 1; i <= 31; i++) {
        // jour.addItem(i);
        // }
        // for (int i = 1; i <= 12; i++) {
        // mois.addItem(i);
        // }
        // for (int i = 2013; 1970 < i; i--) {
        // annee.addItem(i);
        // }
        // ajouter("Naissance :", jour, mois, annee);

        // Taille du panel
        formPanel.setPreferredSize(new Dimension(3 * espace + widthLabel + widthChamp, y + espace));

        // Ajout de tout le formulaire au centre
        add(formPanel, CENTER);
    }

    private void preremplirFormulaire() {
        if (chien == null) {
            return;
        }

        nom.setText(chien.getNom());
        nomComplet.setText(chien.getNomComplet());
        poids.setText(chien.getPoids().toString());
        couleurs.setText(Joiner.on(", ").join(chien.getCouleurs()));

        sexe.setSelectedItem(chien.getSexe());
        race.setSelectedItem(chien.getRace());
    }

    private void ajouter(final String label, final JComponent champ) {
        y += espace;

        final JLabel l = new JLabel(label);
        l.setBounds(espace, y, widthLabel, heightLigne);
        l.setHorizontalAlignment(RIGHT);

        champ.setBounds(2 * espace + widthLabel, y, widthChamp, heightLigne);

        y += heightLigne;

        formPanel.add(l);
        formPanel.add(champ);
    }

    // private void ajouter(final String label, final JComponent champ1, final
    // JComponent champ2, final JComponent champ3) {
    // y += espace;
    //
    // final JLabel l = new JLabel(label);
    // l.setBounds(espace, y, widthLabel, heightLigne);
    // l.setHorizontalAlignment(RIGHT);
    //
    // int x = 2 * espace + widthLabel;
    // champ1.setBounds(x, y, widthChampMultiple, heightLigne);
    //
    // x += espace + widthChampMultiple;
    // champ2.setBounds(x, y, widthChampMultiple, heightLigne);
    //
    // x += espace + widthChampMultiple;
    // champ3.setBounds(x, y, widthChampMultiple, heightLigne);
    //
    // y += heightLigne;
    //
    // formPanel.add(l);
    // formPanel.add(champ1);
    // formPanel.add(champ2);
    // formPanel.add(champ3);
    // }

    private class AjouterAction extends AbstractAction {
        public AjouterAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent event) {
            LOGGER.debug("Ajouter");

            final SimpleChien nouveauChien = new SimpleChien();
            remplirChien(nouveauChien);

            try {
                actionHandler.process(Action.CREER, nouveauChien);
            } catch (ChienException exception) {
                // TODO
            }

            // Fermeture de la fenetre
            AjouterModifierChienJDialog.this.closePopup();
        }
    }

    private class ModifierAction extends AbstractAction {
        public ModifierAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("Modifier");

            if (!(chien instanceof SimpleChien)) {
                // TODO erreur
            }

            remplirChien((SimpleChien) chien);

            try {
                actionHandler.process(Action.MODIFIER, chien);
            } catch (ChienException exception) {
                // TODO
            }

            // Fermeture de la fenetre
            AjouterModifierChienJDialog.this.closePopup();
        }
    }

    private void remplirChien(final SimpleChien chien) {

        chien.setNom(nom.getText());
        chien.setNomComplet(nomComplet.getText());

        try {
            final List<String> couleurList = Lists.newArrayList( //
                    Splitter.on(",")//
                            .trimResults()//
                            .omitEmptyStrings()//
                            .split(couleurs.getText()));
            chien.setCouleurs(couleurList);
        } catch (Exception e) {
            // TODO
        }

        try {
            String temp = poids.getText();
            // Ne pas oublier que les chiffres utilisent des points et non des
            // virgules
            temp = temp.replace(',', '.');
            // Suppression des espaces
            temp = temp.replaceAll(" ", "");

            if (temp.isEmpty()) {
                // TODO erreur
            }

            chien.setPoids(Double.valueOf(temp));

        } catch (NullPointerException e) {
            // TODO si temp est null

        } catch (NumberFormatException e) {
            // TODO Si temp n'est pas un chiffre correct
        }

        chien.setRace((RaceDeChien) race.getSelectedItem());
        chien.setSexe((Sexe) sexe.getSelectedItem());

    }

    private class AnnulerAction extends AbstractAction {
        public AnnulerAction(String texte) {
            super(texte);
        }

        public void actionPerformed(ActionEvent e) {
            LOGGER.debug("Annuler");
            // Ici pas besoin d'appeler le handler.
            AjouterModifierChienJDialog.this.closePopup();
        }
    }

    private void closePopup() {
        // Vidage des champs...
        // ici pas besoin

        // Fermeture de la fenetre.
        dispose();
    }
}

package com.icauda.tp.chien.dao.csv;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.util.HashMap;
import java.util.List;

import org.apache.log4j.Logger;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import com.icauda.tp.chien.domain.Chien;
import com.icauda.tp.chien.domain.SimpleChien;

import fr.ybonnel.csvengine.CsvEngine;
import fr.ybonnel.csvengine.factory.AbstractCsvReader;
import fr.ybonnel.csvengine.factory.DefaultCsvManagerFactory;
import fr.ybonnel.csvengine.factory.OpenCsvReader;
import fr.ybonnel.csvengine.model.Error;
import fr.ybonnel.csvengine.model.Result;

public class EngineCsvChienDao extends AbstractCsvChienDao {

    // ################################################
    // ################# Attributs ####################
    // ################################################
    private static final Logger LOGGER = Logger.getLogger(EngineCsvChienDao.class);

    // ################################################
    // ############## Methodes diverses ###############
    // ################################################

    private void setEngineFactory(final CsvEngine engine) {
        engine.setFactory(new DefaultCsvManagerFactory() {
            @Override
            public AbstractCsvReader createReaderCsv(Reader reader, char separator) {
                return new OpenCsvReader(reader, separator) {
                    @Override
                    public String[] readLine() throws IOException {
                        String[] nextLine = super.readLine();
                        if (isLineAComment(nextLine)) {
                            nextLine = readLine();
                        }
                        return nextLine;
                    }

                    private boolean isLineAComment(String[] line) {
                        return line != null && line.length > 0 && line[0].startsWith("#");
                    }
                };
            }
        });

    }

    @SuppressWarnings("unchecked")
    @Override
    protected void reloadChiens() {
        LOGGER.debug("reloadChiens");

        try {
            final CsvEngine engine = new CsvEngine(SimpleChien.class);
            setEngineFactory(engine);

            final FileInputStream fis = new FileInputStream(file);

            final Result<SimpleChien> resultat = engine.parseInputStream(fis, SimpleChien.class);

            final List<? extends Chien> dogs = resultat.getObjects();
            chiens = (List<Chien>) dogs;
            chienMapByNom = new HashMap<String, Chien>(chiens.size());
            for (Chien chien : chiens) {
                LOGGER.debug("[chien] " + chien);
                chienMapByNom.put(chien.getNom(), chien);
            }

            List<Error> errors = resultat.getErrors();
            LOGGER.debug(errors);

            entetes = engine.getColumnNames(SimpleChien.class);

            LOGGER.debug("[entetes] " + entetes);

        } catch (Exception e) {
            LOGGER.error("Une erreur s'est produite...", e);
        }
    }

    @Override
    public void sauver(final List<Chien> chiens, final File file) {
        final List<SimpleChien> simpleChiens = Lists.transform(chiens, new Function<Chien, SimpleChien>() {
            public SimpleChien apply(final Chien chien) {
                return (SimpleChien) chien;
            }
        });

        doSauver(simpleChiens, file);

    }

    private void doSauver(final List<SimpleChien> chiens, final File file) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Sauvegarde des " + chiens.size() + " chiens dans le fichier " + file.getName());
        }

        final CsvEngine engine = new CsvEngine(SimpleChien.class);

        try {
            engine.writeFile(new FileWriter(file), chiens, SimpleChien.class);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

package com.icauda.tp.chien.domain;

import org.codehaus.jackson.map.annotate.JsonDeserialize;

@JsonDeserialize(using = ChatDeserializer.class)
public class Chat {
    private String nom;
    private Sexe sexe;
    private String couleurs;
    private double poids;
    private double prix;

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Chat [nom=");
        builder.append(nom);
        builder.append(", sexe=");
        builder.append(sexe);
        builder.append(", couleurs=");
        builder.append(couleurs);
        builder.append(", poids=");
        builder.append(poids);
        builder.append(", prix=");
        builder.append(prix);
        builder.append("]");
        return builder.toString();
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((couleurs == null) ? 0 : couleurs.hashCode());
        result = prime * result + ((nom == null) ? 0 : nom.hashCode());
        long temp;
        temp = Double.doubleToLongBits(poids);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        temp = Double.doubleToLongBits(prix);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        result = prime * result + ((sexe == null) ? 0 : sexe.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Chat other = (Chat) obj;
        if (couleurs == null) {
            if (other.couleurs != null)
                return false;
        } else if (!couleurs.equals(other.couleurs))
            return false;
        if (nom == null) {
            if (other.nom != null)
                return false;
        } else if (!nom.equals(other.nom))
            return false;
        if (Double.doubleToLongBits(poids) != Double.doubleToLongBits(other.poids))
            return false;
        if (Double.doubleToLongBits(prix) != Double.doubleToLongBits(other.prix))
            return false;
        if (sexe != other.sexe)
            return false;
        return true;
    }

    // Getters et Setters

public class ResultChat {

    private String sexe;
    private String espece;
    private int nombre;
    private List<Chat> animaux;

    public ResultChat() {
    }

package com.icauda.tp.chien;

import java.io.IOException;

import javax.ws.rs.client.ClientBuilder;

import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

public class TesterWS {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("Un web service avec des chats...");

        final String url = "http://www.icauda.com/animal-mignon/selection.php";

        String responseEntity = ClientBuilder.newClient()//
                .target(url)//
                .queryParam("espece", "chat")//
                .queryParam("sexe", "m")//
                .request()//
                .get(String.class);

        System.out.println("responseEntity: " + responseEntity);

        final ObjectMapper mapper = new ObjectMapper();
        ResultChat myCat = null;
        try {
            myCat = mapper.readValue(responseEntity, ResultChat.class);
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println(myCat);
        if (myCat != null) {
            System.out.println(myCat.getAnimaux());
        }

        System.out.println("fin");
    }
}

package com.icauda.tp.chien.domain;

import java.io.IOException;

import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.ObjectCodec;
import org.codehaus.jackson.map.DeserializationContext;
import org.codehaus.jackson.map.JsonDeserializer;

public class ChatDeserializer extends JsonDeserializer<Chat> {

    public Chat deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {

        final ObjectCodec oc = jsonParser.getCodec();
        final JsonNode node = oc.readTree(jsonParser);

        final String nom = node.get("nom").getTextValue();
        final String sexe = node.get("sexe").getTextValue();
        final String couleurs = node.get("couleurs").getTextValue();
        final double poids = node.get("poids").getDoubleValue();
        final double prix = node.get("prix").getDoubleValue();

        final Chat chat = new Chat();
        chat.setNom(nom);
        chat.setSexe(Sexe.valueOfByLettre(sexe));
        chat.setCouleurs(couleurs);
        chat.setPoids(poids);
        chat.setPrix(prix);

        return chat;
    }
}

<?php

// Objets
class Chat {
    var $nom;
    var $sexe;
    var $poids;
    var $couleurs;
    var $prix;

    function __construct($aNom, $aSexe, $aPoids, $aCouleurs, $aPrix) {
        $this->nom = $aNom;
        $this->sexe = $aSexe;
        $this->poids = $aPoids;
        $this->couleurs = $aCouleurs;
        $this->prix = $aPrix;
    }
}

class Lapin {
    var $nom;
    var $sexe;
    var $tailleOreille;
    var $couleurs;
    var $prix;

    function __construct($aNom, $aSexe, $aTailleOreille, $aCouleurs, $aPrix) {
        $this->nom = $aNom;
        $this->sexe = $aSexe;
        $this->tailleOreille = $aPoids;
        $this->couleurs = $aCouleurs;
        $this->prix = $aPrix;
    }
}


class Souris {
    var $nom;
    var $sexe;
    var $tailleQueue;
    var $couleurs;
    var $couleursYeux;
    var $prix;

    function __construct($aNom, $aSexe, $aTailleQueue, $aCouleurs, $aCouleursYeux, $aPrix) {
        $this->nom = $aNom;
        $this->sexe = $aSexe;
        $this->tailleOreille = $aPoids;
        $this->couleurs = $aCouleurs;
        $this->couleursYeux = $aCouleursYeux;
        $this->prix = $aPrix;
    }
}


// Animaux
$animaux = array();

// Chats
$chats = array();
$chats[] = new Chat('Garfield', 'm', 12.5, 'noir, orange', 150);
$chats[] = new Chat('Lulu', 'f', 10.5, 'gris, noir', 150);
$chats[] = new Chat('Lulu', 'f', 5, 'gris, noir, blanc', 75);
$chats[] = new Chat('Minou', 'm', 8.5, 'noir', 150);
$chats[] = new Chat('Pupuce', 'f', 13.0, 'noir, jaune', 200);
$chats[] = new Chat('Scarlette', 'f', 8.2, 'blanc', 250);
$chats[] = new Chat('Boulette', 'f', 15.7, 'blanc', 250);
$chats[] = new Chat('Ronron', 'm', 8.0, 'noir', 250);
$chats[] = new Chat('Scarlette', 'f', 8.2, 'blanc', 250);
$chats[] = new Chat('Scarlette', 'f', 8.2, 'blanc', 250);
$animaux['chat'] = $chats;

// Lapins
$lapins = array();
$lapins[] = new Lapin('Bunny', 'm', 15, 'blanc', 25);
$lapins[] = new Lapin('Vincent', 'm', 14, 'noir', 25);
$lapins[] = new Lapin('Jessica', 'f', 15, 'rose', 25);
$lapins[] = new Lapin('Roger', 'm', 18, 'blanc, gris', 25);
$animaux['lapin'] = $lapins;

// Souris
$souris = array();
$souris[] = new Souris('Mickey', 'm', 10, 'noir', 'noir', 120);
$souris[] = new Souris('Mini', 'f', 10, 'noir, rose', 'noir', 120);
$souris[] = new Souris('Ratatouille', 'm', 7, 'gris', 'noir', 70);
$souris[] = new Souris('Speedy', 'm', 12, 'gris', 'rouge', 150);
$souris[] = new Souris('Bianca', 'f', 9, 'blanc', 'bleu', 150);
$souris[] = new Souris('Bernard', 'h', 10, 'gris', 'noir', 150);
$animaux['souris'] = $souris;

?>

<?php
// Content-type
header('Content-type: application/json');

// Parametres de la requete
function isParameterInRequest($key) {
    return array_key_exists($key, $_REQUEST);
}

function getFromRequest($key) {
    if(isParameterInRequest($key)) {
        return $_REQUEST[$key];
    } else {
        return null;
    }
}

// Objets
require_once('animaux.php');

// Objets de retour et erreur
class ErrorResult {
    var $message;

    function __construct($aMessage) {
        $this->message = $aMessage;
    }
}

class AnimalResult {
    var $sexe;
    var $espece;
    var $animaux;
    var $nombre;

    function __construct($aSexe, $aEspece, $aAnimaux, $aNombre) {
        $this->sexe = $aSexe;
        $this->espece = $aEspece;
        $this->animaux = $aAnimaux;
        $this->nombre = $aNombre;
    }
}



// Parametres de selection
$sexe = getFromRequest('sexe');
$espece = getFromRequest('espece');



// Choix de l'animal
if($espece == null || $espece == '') {
    $errorResult = new ErrorResult('Le site ne connait pas cette espece.');
    echo json_encode($errorResult);
    die();
}

if(!array_key_exists($espece, $animaux)) {
    $errorResult = new ErrorResult('Il faut preciser une espece.');
    echo json_encode($errorResult);
    die();
}

$tab1 = $animaux[$espece];



// Choix du sexe
if($sexe != null && $sexe != 'f' && $sexe != 'm') {
    $errorResult = new ErrorResult('Le sexe demande est incorrect.');
    echo json_encode($errorResult);
    die();
}

if($sexe == null || $sexe == '') {
    $tab2 = $tab1;
} else {
    $tab2 = array();
    foreach($tab1 as $item) {
        if($sexe == null || $sexe == '' || $sexe == $item->sexe) {
            $tab2[] = $item;
        }
    }
}

$animalResult = new AnimalResult($sexe, $espece, $tab2, count($tab2));

echo json_encode($animalResult);

?>

<?php
// Content-type
header('Content-type: application/json');

// Parametres de la requete
function isParameterInRequest($key) {
    return array_key_exists($key, $_REQUEST);
}

function getFromRequest($key) {
    if(isParameterInRequest($key)) {
        return $_REQUEST[$key];
    } else {
        return null;
    }
}

// Objets
require_once('animaux.php');

// Objets de retour et erreur
class EspeceResult {
    var $stock;

    function __construct($aStock) {
        $this->stock = $aStock;
    }
}


$tab = array();
foreach(array_keys($animaux) as $espece) {
    $tab[$espece] = count($animaux[$espece]);
}
$especeResult = new EspeceResult($tab);

echo json_encode($especeResult);

?>