Cet exemple partage le code spécifique du client d'implémentation Java pour envoyer des fichiers au serveur pour votre référence. Le contenu spécifique est le suivant
Code source du serveur:
Importer java.io.bufferedReader; Importer java.io.file; import java.io.filenotfoundException; Importer java.io.fileOutputStream; Importer java.io.ioException; Importer java.io.inputStreamReader; import java.net.serversocket; import java.net.socket; / ** * Nom de fichier: ServerReceive.java * Fonction d'implémentation: En tant que serveur, recevez des fichiers envoyés par le client * * Processus d'implémentation spécifique: * 1. Établissez SockeTerver et attendez que le client se connecte * 2. Lorsqu'il existe une connexion client, selon l'accord entre les deux parties. 4. Recevoir les paquets de données dans une boucle et écrire les paquets de données dans le fichier * 5. Lorsque la durée des données reçues est égale à la durée du fichier envoyé par le fichier à l'avance, cela signifie que le fichier a été reçu et que le fichier est fermé * 6. Le travail de réception du fichier est terminé * * * * et la sortie de fichiers peut être placée par elle-même en fonction de votre propre programme] * * * Auteur: Xiaoqiu * Temps de création: 2014-08-19 * * * / public class ServerReceive {public static void main (String [] args) {/ ** manche de communication pour établir une connexion avec le serveur * / Serversocket ss = null; Socket s = null; / ** Définissez des objets de fichier et des objets de flux de sortie de fichier créés localement après réception * / fichier file = null; FileoutputStream fos = null; / ** Définissez les flux d'entrée et utilisez l'entrée de socket pour saisir le paquet * / inputStream est = null; / ** Définissez les tableaux d'octets pour servir de paquets de stockage pour les paquets * / octet [] tampon = nouveau octet [4096 * 5]; / ** Stand String utilisé pour recevoir des demandes d'envoi de fichiers * / String comm = null; / ** Définissez la communication SOCEKT et attendez que le serveur se connecte * / try {ss = new SERVERSocket (4004); S = ss.accept (); } catch (ioException e) {e.printStackTrace (); } / ** Lisez les informations de la convention envoyées par une ligne de clients * / try {inputStreamReader ISR = new inputStreamReader (s.getInputStream ()); BufferedReader br = new BufferedReader (ISR); Comm = br.readline (); } catch (ioException e) {System.out.println ("Le serveur se déconnecte du client"); } / ** Démarrer l'analyse de la commande de demande envoyée par le client * / int index = Comm.Indexof ("/ #"); / ** Discutez si le protocole est le protocole pour l'envoi de fichiers * / String xieyi = Comm.SubString (0, index); if (! xieyi.equals ("111")) {System.out.println ("Le code de protocole reçu par le serveur est incorrect"); retour; } / ** analyser le nom et la taille du fichier * / comm = Comm.Substring (index + 2); index = Comm.Indexof ("/ #"); String filename = Comm.SubString (0, index) .trim (); String FileSize = Comm.SubString (index + 2) .trim (); / ** Créez un fichier vide pour recevoir le fichier * / file = nouveau fichier (nom de fichier); if (! file.exists ()) {try {file.createenewfile (); } catch (ioException e) {System.out.println ("La création de fichiers côté serveur a échoué"); }} else {/ ** Vous pouvez également vous demander s'il faut écraser * / system.out.println ("Le même fichier existe déjà dans ce chemin, écraser"); } / ** [Ce qui précède est la partie préparée du serveur écrit dans le code client] * / / ** * Le code de clé pour le serveur pour recevoir le fichier * / try {/ ** enveloppez le fichier dans l'objet Stream de sortie du fichier * / fos = new FileOutputStream (fichier); long file_size = long.parselong (Filesize); is = s.getInputStream (); / ** La taille est la longueur de chaque paquet reçu * / int size = 0; / ** Count est utilisé pour enregistrer la longueur du fichier reçu * / le nombre long = 0; / ** recevoir des paquets en utilisant while Loop * / while (count <file_size) {/ ** Lisez un paquet dans le flux d'entrée * / size = is.read (tampon); / ** Écrivez le paquet que vous venez de lire dans le fichier local * / fos.write (tampon, 0, taille); fos.flush (); / ** la longueur du fichier reçu + taille * / count + = taille; System.out.println ("Le serveur a reçu le paquet, la taille est" + taille); }} catch (filenotfoundException e) {System.out.println ("Le serveur n'a pas écrit le fichier"); } catch (ioException e) {System.out.println ("Server: Client Disconnect"); } Enfin {/ ** * Fermez le fichier ouvert * Si nécessaire, vous pouvez également fermer la connexion de socket ici * * / try {if (fos! = null) fos.close (); } catch (ioException e) {e.printStackTrace (); } // catch (ioException e)} // enfin} // public static void main (String [] args)} // public class serverreceiveCode source du client:
Importer java.io.file; import java.io.fileInputStream; import java.io.filenotfoundException; Importer java.io.ioException; import java.io.outputStream; import java.io.printstream; import java.net.socket; / ** * * Nom de fichier: Clientsend.java * Fonction d'implémentation: Envoyez un fichier au serveur en tant que client * * Processus d'implémentation spécifique: * 1. Établissez une connexion avec le serveur, IP: 127.0.0.1, port: 4004 * 2. est uniquement utilisé pour démontrer le transfert de fichiers entre le client et le serveur. * Il n'y a pas de commande de protocole de fichier avant chaque paquet de données * La transmission de protocole spécifique et l'étape d'utilisation sortante du fichier peuvent être placées en fonction de votre propre programme] * * * Auteur: Novice * Temps de création: 2014-08-19 * * * / classe publique ClientsDend {public static void main (String [] args) {/ ** Handle de communication pour établir une connexion avec le serveur * / socket s = null; / ** Définissez l'objet de fichier, c'est-à-dire le fichier à envoyer * Si vous utilisez un chemin absolu, n'oubliez pas d'utiliser la différence entre '/' et '/' ** Pour des différences spécifiques, veuillez leader Query par vous-même * * / fichier sendFile = nouveau fichier ("api.chm"); / ** Définissez le flux d'entrée de fichier pour ouvrir et lire le fichier à envoyer * / fileInputStream fis = null; / ** Définissez le tableau d'octets à utiliser comme paquet de stockage du paquet de données * / octet [] tampon = nouveau octet [4096 * 5]; / ** Définissez le flux de sortie et utilisez OutputStream de Socket pour sortir le paquet * / outputStream os = null; / ** Vérifiez si le fichier à envoyer existe * / if (! SendFile.exists ()) {System.out.println ("Client: le fichier à envoyer n'existe pas"); retour; } / ** Créez une connexion avec le serveur * / try {s = new socket ("127.0.0.1", 4004); } catch (ioException e) {System.out.println ("Non connecté au serveur"); } / ** Initialiser l'objet FIS avec un objet de fichier * afin que la taille du fichier puisse être extraite * * / try {fis = new FileInputStream (sendFile); } catch (filenotfoundException e1) {e1.printStackTrace (); } / ** Envoyez d'abord des informations sur le fichier sur le serveur pour faciliter le serveur pour recevoir des préparations connexes * pour des préparations spécifiques, veuillez vérifier le code du serveur. * * Le contenu envoyé comprend: le code du protocole d'envoi de fichiers (voici 111) / # Nom de fichier (avec nom de suffixe) / # taille de fichier * * / try {printStream ps = new printStream (s.getOutputStream ()); ps.println ("111 / #" + sendFile.getName () + "/ #" + fis.available ()); ps.flush (); } catch (ioException e) {System.out.println ("Interruption de connexion du serveur"); } / ** * Dormez ici pendant 2 secondes, en attendant que le serveur prépare le travail pertinent * également pour s'assurer que les lecteurs du réseau * peuvent choisir d'ajouter ce code * * / try {Thread.Sleep (2000); } catch (InterruptedException e1) {e1.printStackTrace (); } / ** Une fois les travaux de préparation précédents terminés * Ce qui suit est le code de clé pour le transfert de fichiers * * / try {/ ** Obtenez le sort de sortie de la prise pour y écrire un paquet * / os = s.getOutputStream (); / ** La taille est utilisée pour enregistrer la taille de chaque fichier lecture * / int size = 0; / ** Lisez le fichier en utilisant While Loop jusqu'à ce que la lecture du fichier soit terminée * / while ((size = fis.read (tampon))! = -1) {System.out.println ("Le client envoie le paquet, la taille est" + taille); / ** Écrivez le paquet que vous venez de lire dans le flux de sortie * / os.write (tampon, 0, taille); / ** actualiser * / os.flush (); }} catch (filenotfoundException e) {System.out.println ("Erreur de fichier de lecture client"); } catch (ioException e) {System.out.println ("Erreur de fichier de sortie client"); } Enfin {/ ** * Fermez le fichier ouvert * Si nécessaire, vous pouvez également fermer la connexion de socket ici * * / try {if (fis! = null) fis.close (); } catch (ioException e) {System.out.println ("Erreur de clôture du fichier client"); } // Catch (ioException e)} // enfin} // public static void main (String [] args)} // public CLASSYDENDCe qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.