Résumé : Cet article présente deux méthodes permettant à JavaBean d'implémenter plusieurs téléchargements de fichiers, en utilisant respectivement le protocole http et le protocole ftp. Tout d'abord, il décrit le format de base du transfert de plusieurs fichiers via le protocole HTTP et le processus détaillé de téléchargement. Ensuite, il présente brièvement l'utilisation de la classe ftpclient pour implémenter le téléchargement FTP et compare enfin les deux méthodes.
Mots-clés : JavaBean, http, ftp, ftpclient
JavaBean est un composant logiciel basé sur Java. JSP fournit une prise en charge complète pour l'intégration des composants JavaBean dans les applications Web. Cette prise en charge réduit non seulement le temps de développement (vous pouvez utiliser directement des composants existants qui ont été testés et approuvés, évitant ainsi un développement répété), mais apporte également plus d'évolutivité aux applications JSP.
La fonction de téléchargement de fichiers est très courante dans le modèle de développement basé sur B/S. Par rapport à d'autres outils de développement, la prise en charge de JSP pour le téléchargement de fichiers n'est pas parfaite. Elle ne nécessite pas de composants comme ASP, ni ne fournit directement de prise en charge pour le téléchargement de fichiers comme PHP. La manière dont JSP implémente le téléchargement de fichiers est la suivante : utiliser la méthode getInputStream() de la classe ServletRequest pour obtenir un flux de données envoyé par le client au serveur, puis traiter ce flux de données pour analyser et obtenir les différents paramètres et paramètres passés à le serveur pendant le téléchargement des données, puis stockez-y les données du fichier sous forme de fichier ou insérez-les dans une base de données. Habituellement, les pages JSP ne gèrent pas la fonction de téléchargement de fichiers, mais placent ces fonctions dans des servlets ou des JavaBeans pour les implémenter. Des exemples d'utilisation de Servlet pour effectuer des téléchargements de fichiers sont présentés dans certains livres liés à JSP. Ici, je vais vous présenter comment utiliser JeanBean pour effectuer des téléchargements de fichiers. Il existe deux manières de télécharger des fichiers dans JSP, à savoir le protocole HTTP et le protocole FTP. Il existe de grandes différences dans les principes de transmission entre les deux. Ce qui suit donnera une brève introduction à leur implémentation basée sur le code source. Je pense que les lecteurs y gagneront quelque chose. Le programme suivant a été débogué et réussi. Environnement de débogage : serveur Windows 2000+Apache +tomcat4.0, environnement de débogage JavaBean : JDK1.4+Editplus.
L'utilisation de JavaBean dans JSP pour implémenter la fonction de téléchargement de fichiers basée sur le Web nécessite généralement la combinaison de trois types de fichiers. Ces trois fichiers sont respectivement le fichier de page HTML qui fournit l'interface, le fichier JSP qui termine l'appel pour implémenter la fonction de téléchargement de JavaBean et le fichier de classe Java qui implémente JavaBean. Ci-dessous, je me concentrerai sur la partie JavaBean qui utilise le protocole HTTP et le protocole FTP pour implémenter la fonction de téléchargement de fichiers.
1 Utilisez le protocole HTTP pour télécharger plusieurs fichiers.
Dans le passé, les formulaires HTML ne pouvaient pas télécharger de fichiers, ce qui limitait quelque peu les fonctions de certaines pages Web. La spécification RFC1867 (c'est-à-dire le téléchargement de fichiers basé sur un formulaire en HTML) étend le formulaire et ajoute un élément de formulaire . En utilisant cet élément, le navigateur générera automatiquement une zone de saisie et un bouton. La zone de saisie permet à l'utilisateur de renseigner le nom du fichier local et le nom du chemin, et le bouton permet au navigateur d'ouvrir une zone de sélection de fichier pour que l'utilisateur puisse le faire. sélectionnez un fichier. L'implémentation spécifique du formulaire est la suivante :
Lorsque vous choisissez de coller le fichier, saisissez directement le chemin absolu du fichier local. La valeur de l'attribut d'action du formulaire est *.jsp, ce qui signifie que la requête (y compris le fichier téléchargé) sera envoyée au Fichier *..jsp. Dans ce processus, le téléchargement de fichiers via HTTP est réellement implémenté. Le téléchargement de fichiers du client vers le serveur est pris en charge par la Common Gateway Interface (CGI) du protocole HTTP. Cette méthode de téléchargement nécessite que le navigateur et le serveur WEB prennent en charge Rfc1867. JavaBean obtient un flux de données envoyé par le client au serveur via la méthode getInputStream() de la classe ServletRequest, analyse le format de fichier téléchargé et génère plusieurs fichiers vers le fichier cible côté serveur dans l'ordre en fonction des résultats de l'analyse. La fonction de JavaBeande dans cet exemple est spécifiquement implémentée par la classe testUpload. Le framework de la classe TestUpload est le suivant :
classe publique testUpload
{
public testUpload(){……}
public final void initialize (configuration ServletConfig) lance ServletException
{ m_application = config.getServletContext();
public void upload() lance testUploadException, IOException, ServletException
{…………}
privé vide getDataSection(){………}
vide privé getDataHeader(){………}
sauvegarde int publique (String destPathName)
lance SmartUploadException, IOException, ServletException
{…………}
…
}
Initialisez l'environnement d'exécution du servlet via la méthode initialize(). Utilisez la méthode upload() pour obtenir le flux d'entrée, analyser le format du fichier téléchargé et attribuer les attributs de chaque fichier téléchargé à plusieurs instances de classe File pour le traitement. Ces instances de classe File sont gérées par la classe Files. La classe File appelle sa méthode save () en fonction des attributs de chaque fichier pour afficher successivement plusieurs fichiers vers le fichier cible côté serveur. La méthode upload() est la clé, utilisée pour analyser le format des fichiers transmis par le protocole http1.1. Après test, nous obtenons le format du fichier du flux de transport, ce qui est utile pour comprendre la méthode upload(). Par exemple, téléchargez le fichier Mes documentstt.txt. Le format est le suivant :
//Séparateur de fichiers
--------------------------7d226137250336
//En-tête des informations sur le fichier
Disposition du contenu : form-data ; nom="FILE1" ; nom de fichier="C:Documents and SettingsAdministrator.TIMBER-4O6B0ZZ0Mes documentstt.sql"
Type de contenu : texte/plain
//Contenu du fichier source
créer des informations sur la table (
image de contenu nulle);
//Délimiteur du fichier suivant
--------------------------7d226137250336
Contenu-Disposition : formulaire-données ; nom="FILE2" ;
Type de contenu : application/flux d'octets
--------------------------------7d226137250336
À partir des fichiers ci-dessus, nous pouvons voir que lors du téléchargement de plusieurs fichiers, le protocole HTTP Tous sont placés dans le flux d'entrée et distingués par certains délimiteurs. En fait, la méthode upload() consiste à analyser le fichier ci-dessus et à déterminer le contenu du délimiteur, le format du contenu de chaque fichier, le nom de chemin complet du fichier ainsi que le début et la fin des données réelles du fichier. Une chose à noter ici est que le délimiteur est aléatoire, il s'agit de tous les caractères avant le premier caractère de retour chariot du fichier de flux de transport.
Le processus d'implémentation de la méthode Upload() est le suivant : envoyez d'abord le fichier de flux d'entrée dans le tableau d'octets m_binArray, qui est implémenté via le code suivant.
m_totalBytes=1024 ; totalRead=0 ;
pour(; totalRead < m_totalBytes; totalRead += readBytes)
essayer
{ m_request.getInputStream();
readBytes = m_request.getInputStream().read(m_binArray, totalRead, m_totalBytes - totalRead);
}catch(Exception e){ throw new SmartUploadException("Impossible de télécharger.");}
La méthode de lecture multi-octets dans la boucle est utilisée ici. La boucle ci-dessus lit en continu les données jusqu'à ce que le tableau soit rempli. Si un fichier peut être entièrement récupéré, tous les octets du fichier peuvent également être récupérés. Mais comme la vitesse du réseau est généralement beaucoup plus lente que celle du processeur, il est facile pour le programme d'effacer le tampon réseau avant que toutes les données n'arrivent. En fait, la méthode de lecture multioctet renverra 0 lors de la tentative de lecture de données à partir d'un tampon réseau temporairement vide mais ouvert, ce qui signifie qu'aucune donnée n'existe mais que le flux réseau n'a pas été fermé. Dans ce cas, la méthode mono-octet empêchera l'exécution du programme en cours d'exécution, donc le comportement de la méthode multi-octets est meilleur que celui de la méthode read() mono-octet. Ensuite, le tableau d'octets m_binArray sera analysé. Recherchez d'abord le délimiteur ; utilisez la méthode getDataHeader() pour renvoyer la valeur de l'en-tête des informations du fichier, à partir de laquelle le nom de chemin complet du fichier source, l'extension du fichier source et le format du contenu du fichier source sont déterminés, utilisez getDataSection() ; méthode pour renvoyer les données du contenu du fichier et les enregistrer. Les positions de début et de fin des données du fichier dans le tableau d'octets. Générez ensuite une instance de classe File et placez le nom de chemin complet du fichier, l'extension du fichier source, le format du contenu du fichier source et les positions de début et de fin des données de contenu du fichier dans les attributs de l'instance de classe File. Recherchez le délimiteur suivant et continuez à répéter le processus ci-dessus jusqu'à ce que l'analyse soit terminée.
2 Utilisez le protocole FTP pour télécharger plusieurs fichiers.
Le protocole FTP est un protocole utilisé pour transférer des fichiers sur Internet. Il stipule les normes de transfert mutuel de fichiers sur Internet. L'implémentation de cette fonction en Java se fait à l'aide de la classe FtpClient. Processus de mise en œuvre spécifique : établissez d'abord une connexion avec le serveur FTP ; initialisez la méthode de transmission de fichiers, y compris ASCII et BINARY ; envoyez le fichier dans le flux d'entrée de fichier FileInputStream ; les données sont écrites dans le flux de sortie TelnetOutputStream (utilisez la méthode write pour écrire les données sur une liaison réseau). De cette manière, un fichier portant le même nom que le fichier source est copié sur le serveur. Dans cet exemple, le JavaBean termine le processus de téléchargement de fichiers via trois méthodes : connectServer(), upload() et closeConnect(). L'implémentation principale est la suivante :
classe publique ftpUpload
{ Nom de fichier de chaîne ; Nom de fichier de chaîne1 ; FTPClient ftpClient ;
public void connectServer (serveur de chaîne, utilisateur de chaîne, mot de passe de chaîne, chemin de chaîne)
{
//server : adresse IP du serveur FTP ; user : nom d'utilisateur pour se connecter au serveur FTP
//password : le mot de passe du nom d'utilisateur pour se connecter au serveur FTP path : le chemin sur le serveur FTP ;
essayez{ ftpClient=new FtpClient();
ftpClient.openServer(serveur);
ftpClient.login(utilisateur, mot de passe);
System.out.println("Connexion réussie !");
if (path.length()!=0) ftpClient.cd(path);
ftpClient.binary(); }catch (IOException ex) {System.out.println(ex);}
}
public void closeConnect()
{essayer{ ftpClient.closeServer();
}catch (IOException ex) {System.out.println(ex);}
}
téléchargement public vide()
{ filename1=findFileName(filename);
//Analysez le nom du fichier à partir du nom de fichier et utilisez-le comme nom du fichier cible. La méthode spécifique n'est pas donnée.
essayer {
TelnetOutputStream os=ftpClient.put(filename1);
java.io.File file_in=new java.io.File(nom de fichier);
FileInputStream est=nouveau FileInputStream(file_in);
octet[] octets=nouvel octet[1024];
int c;
while ((c=is.read(bytes))!=-1){ os.write(bytes,0,c });
est.close(); os.close();
} catch (IOException ex) {System.out.println(ex);}
}
}
connectServer() remplit la fonction d'établissement d'une connexion avec le serveur FTP, utilise la méthode openServer(string server) de FtpClient pour ouvrir le serveur FTP distant, puis utilise la méthode login(user, password) de FtpClient pour se connecter au serveur. Il existe deux manières de se connecter au serveur FTP distant : l'une consiste à se connecter en tant qu'utilisateur enregistré et l'autre consiste à se connecter de manière anonyme. Le premier nécessite que l'utilisateur s'inscrive d'abord en tant que client du serveur. Le serveur donnera à l'utilisateur un compte de connexion et un mot de passe, et se connectera au serveur en fonction du compte et du mot de passe. Ce dernier oblige les utilisateurs à utiliser les noms d'utilisateur spéciaux « ennuyeux » et « invité » sans s'inscrire pour avoir un accès restreint aux fichiers publics sur des hôtes distants. De nombreux systèmes exigent désormais que les utilisateurs utilisent leur adresse e-mail comme mot de passe. Pour des raisons de sécurité, la plupart des hôtes FTP anonymes autorisent généralement les utilisateurs distants à télécharger des fichiers, mais pas à les télécharger. Cela dépend des paramètres du serveur FTP. Les utilisateurs peuvent choisir d'utiliser deux méthodes en fonction des conditions réelles. Après vous être connecté, utilisez la méthode binaire() de FtpClient pour initialiser le mode de transmission en mode octet. upload() complète la fonction de téléchargement de fichiers. Créez le flux d'entrée de fichier FileInputStream du fichier source, écrivez le flux d'entrée dans le tableau d'octets et utilisez la méthode d'écriture de TelnetOutputStream pour écrire les données du tableau d'octets sur une liaison réseau. Puisque TelnetOutputStream ouvre un fichier sur le serveur FTP, les données sont écrites dans le fichier cible, complétant ainsi le téléchargement du fichier. closeConnect() nécessite une déconnexion du serveur.
Ce qui précède ne concerne que le processus de téléchargement d'un seul fichier. S'il existe plusieurs fichiers, ce processus de téléchargement peut être appelé plusieurs fois. À partir des deux méthodes ci-dessus, nous pouvons voir que l’utilisation du protocole FTP pour télécharger plusieurs fichiers est relativement simple et facile à mettre en œuvre. L'utilisation du protocole FTP pour télécharger des fichiers est généralement un programme côté client, et les paramètres de sécurité côté serveur seront plus compliqués ; tandis que l'utilisation du protocole HTTP pour télécharger des fichiers est une application côté serveur, et les paramètres de sécurité seront relativement simples ; . Et grâce à des tests, il a été constaté que la méthode de téléchargement FTP est des dizaines, voire des centaines de fois, plus rapide que la méthode de téléchargement HTTP lors de la transmission de fichiers volumineux, mais elle est légèrement plus lente que la méthode de téléchargement HTTP lors de la transmission de fichiers de taille inférieure à 1 Mo. Par conséquent, les deux méthodes de transmission présentent leurs propres avantages. Il est conseillé aux lecteurs d’agir en fonction de leurs propres circonstances. Si vous avez des questions ou avez besoin du code source d'autres pièces, veuillez me contacter !