Discussion :

[RomG7]

Bonjour à tous,

J'ai effectué beaucoup de recherche sur le pattern MVC en java et je ne trouve aucun exemple sur la conception d'une telle architecture avec l'utilisation des bases de données.

J'ai compris que le contrôleur reçoit l'action utilisateur de la vue et appelle le modèle qui à son tour va avertir la vue des changements.
Je ne comprends pas pourquoi c'est le modèle qui informe la vue des changements. Je trouverai plus normal que le contrôleur interroge le modèle et qui rafraîchisse la vue en fonction.

J'ai essayé de développer moi même une telle architecture que je propose au plus curieux d'entre vous pour avoir un avis.

Le Modèle de la table Client:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class ClientModel {
	private int idClient;
	private String nomClient;
 
	public ClientModel(int idClient, String nomClient) {
		this.idClient = idClient;
		this.nomClient = nomClient;
	}
 
	// GETTERS AND SETTERS
	public int getIdClient() {
		return idClient;
	}
 
	public String getNomClient() {
		return nomClient;
	}
}

Le Modèle pour la connexion à la table Client:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public class ClientConnex {
	private Connection conn = null;
	private Statement stmt = null;
 
	public ClientConnex() throws SQLException, Exception {
		//Chargement du driver specifique au sgbd
		Class.forName("com.mysql.jdbc.Driver"); 
		this.conn = DriverManager.getConnection("jdbc:mysql://localhost/db_maBase", "root", "root");
 
		this.stmt = this.conn.createStatement();
		conn.setAutoCommit(false);
	}
 
	public Vector<ClientModel> vClient(String search) throws SQLException {
		Vector<ClientModel> vData = new Vector<ClientModel>();
		String requete = "SELECT id_client, nom_client FROM tbl_client WHERE (nom_client LIKE ?);";
 
		PreparedStatement pre = this.conn.getConn().prepareStatement(requete);
		search = "%" + search.trim() + "%";
		pre.setString(1, search);
 
		ResultSet res = pre.executeQuery(); 
		while (res.next()) {
			ClientModel client = new ClientModel(res.getInt(2), res.getString(3));
			vData.addElement(client);
		}
 
		res.close();
		pre.close();
		return vData;
	}
}

La vue représentant la fenêtre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
public class View extends JFrame {
	private Controller controller;
	private JToolBar barreOutil;
 
	public View(Controller controller) {
		super();
 
		assert controller != null;
		this.controller = controller;
		initialize();
	}
 
	private void initialize() {
		JButton btnClient = new JButton("Liste Client");
		btnClient.addActionListener(new BtnClientListener());
 
		// Création de la barre d'outils
		this.barreOutil = new JToolBar("Outils");
		this.barreOutil.setFloatable(false);
		this.barreOutil.add(btnClient);
 
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setPreferredSize(new Dimension(1024, 768));
		JFrame.setDefaultLookAndFeelDecorated(true);
		this.pack();
		this.setExtendedState(MAXIMIZED_BOTH);
		this.setLocationRelativeTo(null);
 
		this.getContentPane().add(barreOutil, BorderLayout.PAGE_START);
		this.setVisible(true);
	}
 
 
	// EVENEMENT
	class BtnClientListener implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			getContentPane().removeAll();
			getContentPane().add(barreOutil, BorderLayout.PAGE_START);
			controller.displayClient();
		}
	}
}

La ou les vues représentant le panneau de la fenêtre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
public class ViewClient extends JPanel {
	private final ControllerClient controllerClient;
 
	private static final String[] columnNames = {"Identifiant", "Nom"};
	private final DefaultTableModel model;
        private final JTable table;
 
	private final JTextField txtSearchValue;
	private final JButton btnSearchValue;
 
 
	// CONSTRUCTEUR
	public ViewClient(ControllerClient controllerClient) {
		super();
 
		this.controllerClient = controllerClient;
 
		this.model = new DefaultTableModel(columnNames, null);
		this.table = new JTable(model);
		this.txtSearchValue = new JTextField();
		this.btnSearchValue = new JButton();
		this.btnSearchValue.addActionListener(new BtnSearchPatientListener());
 
		// création des panels
		JPanel panTop = new JPanel();
		panTop.setLayout(new FlowLayout(FlowLayout.RIGHT));
		panTop.add(txtSearchValue);
		panTop.add(btnSearchValue);
 
		JPanel panCenter = new JPanel();
		panCenter.setLayout(new BorderLayout());
		panCenter.add(new JScrollPane(this.table));
 
		// ajoute les panels sur la fenêtre
		this.setLayout(new BorderLayout());
		this.add(panTop, BorderLayout.NORTH);
		this.add(panCenter, BorderLayout.CENTER);
	}
 
	public void displayTableClient(Vector<TblClient> vClient) {	
		// supprime toutes les lignes au modèle de la table
		this.model.clearRow();
 
		// ajoute les nouvelles lignes au modèle de la table
		for (int i = 0; i < vClient.size(); i++) {
			TblClient client = vClient.elementAt(i);
			this.model.addRow(new Object[] {client.getIdClient(), client.getNomClient()});
		}			
	}
 
	// EVENEMENT
	class BtnSearchPatientListener implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			controllerClient.notifySearchClient(txtSearchValue.getText());
		}
	}
}

Le Controller de la frame

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class Controller {
	private View view;
 
	public Controller() {
		this.view = new View(this);
	}
 
	public void displayClient() {
		ControllerClient controllerClient = new ControllerClient(view);
		controllerClient.notifySearchClient("");
	}
}

Le Controller du panneau Client

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class ControllerClient {
	private final ViewClient viewClient;
 
	public ControllerClient(View view) {
		this.viewClient = new ViewClient(this);
		view.add(viewClient);
	}
 
	public void notifySearchClient(String value) {
		try {			
			// ouvre la connexion a la BD
			ClientConnex connex = new ClientConnex();
			Vector<ClientModel> vClient = connex.vClient(value);
 
			viewClient.displayTableClient(vClient);
		}
		catch (SQLException e) {
			System.out.println("erreur sql");
		}
		catch (Exception e) {
			System.out.println("erreur exception");
		}
	}
}

Le lanceur de l'application

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public class Main {
	public static void main(String[] args) {
		Controller controller = new Controller();
		controller.displayClient();
	}
}

Voila ce que j'ai pu mettre en place en fonction de tous ce que j'ai pu lire à droite et à gauche. Je ne sais pas si je me complique la vie, je voudrais vraiment être propre dans l'organisation de mon code.
Si vous connaissez un bon tutoriel ou un bon livre sur l'utilisation du pattern MVC en java avec utilisation d'une base de données, je suis preneur.

Merci d'avoir pris la peine d'arriver jusqu'ici, j'attends vos commentaires.

[Jimmy_]

Je ne comprends pas pourquoi c'est le modèle qui informe la vue des changements.

Non c'est pas ça. Le rôle du modèle est de construire un objet résultat, c'est le contrôleur qui synchronise la vue avec cet objet fournit par le modèle.
Si c'est ton modèle qui passe directement l'objet à la Vue, tu casses le pattern.

[exhortae]

Il faut distinguer 2 type de modèles :

- Le modèle passif, qui n'a aucune connaissance de la vue ni du controleur et c'est le controleur qui a la responsabilité d'effectuer des changements sur le modèle et de renvoyer à la vue le résultat de ces changements.

- Maintenant imagine qu'un composant extérieur à l'application change le modèle. Dans ce cas le controleur n'a aucune connaissance de ce changement (c'est le cas si le modèle est partagé entre plusieurs applications) et c'est alors au modèle de prévenir la vue qu'elle doit se mettre à jour (on peut utiliser le pattern observer pour ça). dans ce cas là on dis que le modèle est actif.

source : http://st-www.cs.illinois.edu/users/...-docs/mvc.html



Pour l'intégration ave une base de données je te conseille d'aller faire un tour du côté du pattern dao