Discussion :

[t.n.b.g]

bonjours tout le monde

je suis entraint de devellopper en java deux application client serveur qui communuque entre elles de telle facons elle permet le transfert des fichier du serveur au client , l'application est presque fini mais je veux ajouter au client un plus qui se caracterise en fait la permission de supprimer un des fichier fourni par le serveur a condition que personne des autres clients n'est entraint de telecharger ce fichier .est ce qu'il y a une methode connu pour realiser ca ?

merci

[dinobogan]

Quel est le protocole de communication que tu utilises ? Un fait maison ou un existant ?
Tu utilises une API "publique" ou du code 100% maison ?
Ton problème est tellement général qu'on ne va pas se bousculer pour te répondre
Donne plus d'infos !

[t.n.b.g]

En fait j'utilise le protocol TCP/IP,et jai utilisé des API "publique".

[dinobogan]

En fait j'utilise le protocol TCP/IP,et jai utilisé des API "publique".

Ok, on avance.
Et pour avoir le nom de cette API, je suppose que je fais :

BouleDeCristal.getInstance().repondre( "quel est le nom de l'API ?" );

[Vespasien]

Ce n'est pas au client de supprimer le fichier mais au serveur. Le client propose au serveur de supprimer. Le serveur considère la demande et l'exécute selon les contraintes imposées.

Logiquement, les clients ne peuvent savoir combien de personnes sont connectées au serveur et ce n'est pas a eux de gérer les transactions.

[t.n.b.g]

excelente reponse dinobogan vous avez raison

[t.n.b.g]

bon Vespasien,il y a du logique dans ton raisonnement je suis d'accord avec toi, la j'ai fait la class de suppression

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
 //les import pour que cela fonctionne
  import java.io.File;
 
 //classe principale qui etend et implements ce dont elle a besoin pour fonctionner
 public class Suppression extends Thread implements Runnable {
 // constructeur qui recoit un File en parametre
 public Suppression(File Finit) {
 // on recupere le parametre
         this.Finit = Finit;
 // on l'affiche pour le fun ;)
       System.out.println("fichier initiale :" + Finit.getName());
 }
 
 public void run() {
 // on verifie si c'est un repertoire .....
         if (Finit.isDirectory()) {
 // si s'en est un on liste son contenu
         listing = Finit.listFiles();
 // si il n'a pas de contenu ...
         if (listing.length == 0) {
 // ...on supprime le repertoire
         Finit.delete();
 // on previen l'utilisateur
         System.out.println("suppession finni");
 }
 // sinon tant qu'il y a des sou repertoire ....
 
 while (listing.length > 0) {
 // poiur chaque sous repertoire ...
            for (int i = 0; i < listing.length; i++) {
 // ...on verifie si c'est des fichier ...
            if (listing[i].isFile()) {
 // ... si ca en est on les supprime
            boolean b = listing[i].delete();
 // on verifie si tout c'est bien passe
            System.out.println("suppession de :" + listing[i] + ":"+ b);
 }
 // si c'est un repertoire on demare une methode...
 else{
 // on demare la methode
 dlRep(listing[i]);
 }
 
 }
 // on met a jour listing ...
 listing = Finit.listFiles();
 // ... on verifie si il reste des sous repertoire
 if (listing.length == 0) {
 // si yen a pas on supprime le repertoire de depart
 Finit.delete();
 System.out.println("suppession finni");
 break; // on quite le Thread
 }
 }
 // .....c'est pas un repertoire donc on le supprime directement
 } else if (Finit.isFile())
 Finit.delete();
 
 this.interrupt(); // on quitte le thread
 }
 
 // debut de la methode
 private void dlRep(File ToDel) {
 // on list le repertoire donner en parametre
 File[] listing2 = ToDel.listFiles();
 // si il est vide on le supprime
 if (listing2.length == 0)
 // on le supprime
 ToDel.delete();
 // et pour chaque objet File liste on ...
 for (int i = 0; i < listing2.length; i++) {
 // ...verifie si c'est un fichier
 if (listing2[i].isFile()) {
 // on le supprime et on verifie que c'est bon
 boolean b = listing2[i].delete();
 System.out.println("suppession de :" + listing2[i] + ":" + b);
 }
 // sinon c'est un repertoire
 else {
 // on applique de nouveau la methode sur le repertoire
 dlRep(listing2[i]);
 }
 }
 }
 
 // variable
 public File[] listing;
 
 public File Finit;
 }

et la j'ai la class serveur

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
 
package modele;
 
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
import java.util.Vector;
 
import params.Messages;
import vue.InterfaceServeur;
import vue.MessageErreur;
 
/**
 * Cette classe est utilisee du cote serveur pour ecouter les connexions de clients
 
 */
public class Serveur extends Thread {
 
	private InterfaceServeur interf;
	private ServerSocket socketEcoute;
	private Vector connectes;
 
    /**
     * Construit un nouveau Serveur ecoutant sur le port 'port', 
     * en indiquant l'interfaceServeur correspondante
         * @param port Port d'ecoute du serveur
     * @param i Interface serveur
         */
	public Serveur(int port, InterfaceServeur i) {
		// Lien vers l'interface
		interf = i;
		// Initialisation du vecteur des connectes
		connectes = new Vector();
		// Creation d'une socket de connexion serveur
	    String msg;
		try{
			demarrer(port);
		    msg = Messages.get("Serveur.0");
		    msg = msg.replaceFirst("%s", ""+port);
			interf.addListing(1, msg);
		}
		catch(IOException e){
		    msg = Messages.get("Serveur.1");
		    msg = msg.replaceFirst("%s", ""+port);
			interf.addListing(1, msg);
			MessageErreur.show(Messages.get("err.2")+e, Messages.get("err.1"));
		}
		// Boucle d'attente de nouveaux clients
		this.start();
	}
 
 
	// METHODES
 
	/**
         * Demarre le serveur (maj la serverSocket)
         * @param port Port d'ecoute
         * @throws IOException
         */
	public void demarrer(int port) throws IOException{
		socketEcoute = new ServerSocket(port);
	}
 
	/**
         * Arrete le serveur
         */
	public void arreter(){
		try {
			socketEcoute.close();
			interf.addListing(1, Messages.get("Serveur.2"));
		} catch (IOException e) {
			MessageErreur.show(Messages.get("err.1"));
		}
	}
 
	/**
         * Boucle d'attente de nouveaux clients
         */
	@SuppressWarnings("unchecked")
	public void run(){
 
		try{
			interf.addListing(1, Messages.get("Serveur.3"));
			while (socketEcoute.isClosed()==false) {
				Socket socketClient = socketEcoute.accept();
				// Un client se connecte
				interf.addListing(1, Messages.get("Serveur.4"));
				// Creation d'un nouveau processus pour le nouveau client
				Thread c = new GestionClient(socketEcoute, socketClient, interf);
				// Enregistrement dans le vecteur de connectes
				Vector v = new Vector();
				v.add(new Date());      // Date
				v.add(socketClient);    // Socket
				v.add(c);               // Processus
				connectes.add(v);
			}
		}
		catch(Exception e){
	        MessageErreur.show(Messages.get("Serveur.2"));
		}
	}
 
 
	// ACCESSEURS
 
	/**
         * Definit l'interface serveur
         * @param i Interface serveur 
         */
	public void setInterf(InterfaceServeur i){
		this.interf = i;
	}
 
	/**
         * Retourne le vecteur des connectes
         * @return Vecteur des connectes
         */
	public Vector getConnectes(){
		return this.connectes;
	}
 
	/**
         * Retourne la socket d'ecoute
         * @return Socket d'ecoute
         */
	public ServerSocket getSocketEcoute(){
		return this.socketEcoute;
	}
 
}

donc ma question est-ce que je met la class suppression dans la class serveur pour donne la possibilité au client de supprimer un fichier qui se trouve dans le serveur ?