Sources JavaConsultez toutes les sources

Nombre d'auteurs : 29, nombre de sources : 134, création le 13 avril 2013 

 
OuvrirSommaireFlux, fichiers et réseauxNet et réseaux

Cette méthode à placer dans l'applet va envoyer un tableau (qui est un objet) contenant des arguments de requete SQL à une servlet qui renvoie un autre tableau de données contenant le résultat de la requête.

 
Sélectionnez
public String[][] recupAllData(){ 
       String[] tabData= new String[3]; 
       tabData[0]=argument1; 
       tabData[1]=argument2; 
       tabData[2]=argument3; 
       try{ 
   //connexion à la servlet 
            URL urlServlet=new URL("http://monServeur/monSite/servlet/getData"); 
          URLConnection connexion=urlServlet.openConnection(); 
            connexion.setDoOutput(true); 
         //sortie des données vers la servlet 
            ObjectOutputStream sortieObjet= new ObjectOutputStream(connexion.getOutputStream()); 
            sortieObjet.writeObject(tabData); 
         //retour de données en provenance de la servlet 
            ObjectInputStream entreeObjet= new ObjectInputStream(connexion.getInputStream()); 
            return (String[][])entreeObjet.readObject(); 
       }catch(Exception e){ 
          zoneMessage.reEcris(msgErr2); 
            System.out.println(e.toString()); 
            return null; 
       } 
     } 

à mettre dans la servlet :
attention les déclarations de variables ne sont pas présentées

 
Sélectionnez
public void doPost(HttpServletRequest requete,HttpServletResponse reponse){ 
          
      try{ 

           
           sortieObjet= new ObjectOutputStream(reponse.getOutputStream()); 
          entreeObjet= new ObjectInputStream(requete.getInputStream()); 
          String[][] monTableauResultat; 
          /*************************récupération des données de l'applet */
          lesDonnees=(String[])entreeObjet.readObject(); 

         /*************************on pose la question à la base de données */                
          requeteSql= "SELECT nom, prenom, mail from maTable "+
                            " where arg1='"+lesDonnes[0]+"' "+
                           " and arg2='"+lesDonnes[1]+"' and arg3='"+lesDonnes[2]+"' ";       
    
/** on pose la question à la base de données 
je vous montre pas le bout de code qui pond la réponse 
*/

                     
          /******************************renvoi du tableau de résultat */
          sortieObjet.writeObject(monTableauResultat); 
             
      }catch(Exception e){ 
         System.out.println(" ERR >> getData :"+e); 
      } 
   } 
Créé le 6 août 2004  par blaz

cette classe permet de se connecter à un serveur IRC.

Créé le 24 août 2004  par cameleon2002

Téléchargez le zip

Java est le client et C++ est le serveur.
Java envoie la chaine "Edit" a C++ qui l'imprime.
Cette idée de socket entre Java et C++ est une alternative à JNI pour le natif.

Client Java
Sélectionnez

try {

             InetAddress addresse = InetAddress.getLocalHost();
            
            
             Socket socket = new Socket(addresse, 6001);
             System.out.println("SOCKET = " + socket);
            
                    
             OutputStream os = socket.getOutputStream();
             System.out.println("JAVA ecriture du buf");
             os.write("Edit".getBytes());

             System.out.println(" JAVA fin ecriture du buf");
            
                   
 catch (IOException exc) {
            System.err.println(exc.getMessage());
             }
Serveur C++
Sélectionnez

/*liste des imports*/
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <iostream.h>
#include <unistd.h>
#define SADDR struct sockaddr * 

// ...

struct sockaddr_in sa;
      int s, i, n = sizeof(sa);
      if ((s=socket(AF_INET,SOCK_STREAM,0)) < 0) throw(3);//make socket
     sa.sin_family = AF_INET;                             // set type
     sa.sin_addr.s_addr = INADDR_ANY;             // set wildcard
     sa.sin_port = htons(6001);                           // set port
          if ( bind(s, (struct sockaddr*)&sa, n) < 0 ) throw(3);         // bind address
          if(listen(s,1)<0)
       {
                  throw(3);
       }

int connected_fd;
        int rlen = sizeof(sa);

        if( (connected_fd=accept(s,(struct sockaddr*)&sa,&rlen))<0){
               throw(3);
       }

      
      printf("C++ la valeur du connected est %i \n",connected_fd);
      
       char buf[512];
        
                 int nbrecv = recv(connected_fd,buf,512,0);
         if(nbrecv <0){perror("recv");}
         //cont = (nbrecv > 0);
                 
         cout << "C++ Message: " << buf << endl; 
                  close(connected_fd);
Créé le 21 janvier 2005  par parisjohn

Possibilité d'ajouter des destinataires, copie et copie cachée, de vérifier si une adresse est valide.
On peut appeler les fonctions avec un tableau de String en paramètre, ou avec une String toute seule.
Une string peut contenir plusieurs adresses mails séparées par un espace, une virgule ou un point virgule.

Notes :

  • - une fonction spéciale à la fin permet de transformer un pseudo en mail.
  • - un tout petit peu de config au début, le serveur smtp et l'adresse no-reply

Exemple :

 
Sélectionnez

//Envoi un message provenant de no-reply@societe.fr au webmaster,
//à mail@exemple et no.spam
Mail m = new Mail();
m.setTo("webmaster, mail@exemple.com;no.spam@thank.you");
m.setSujet("test");
m.setMessage("Ceci est un test");
m.send();
 
Sélectionnez

/*
 * Created on 10 nov. 2004
 */
package xxxx.util;

import java.util.Properties;

import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
 * Classe pour simplifier les envois de mails
 * @author SMAC
 */
public class Mail {
   /** Type texte brut */
   static public final int TEXT = 0;
   /** Type text/html */
   static public final int HTML = 1;
   
   /** Adresse "no-reply" par défaut de l'entreprise */
   private static final String NOREPLY = "noreply@societe.fr";
   /** Adresse du serveur SMTP de l'entreprise */
   private static final String SMTPHOST = "smtp.societe.fr";
   
   private Properties props;
   private Session session;
   private MimeMessage mm;
   private int mimetype;
   /**
    * Si on n'appelle pas setFrom, met automatiquement noreply@societe.fr
    */
   private boolean noreply = true;
   
   /**
    * Créateur d'un mail.
    */
   public Mail() {
      //Par défaut en texte brut
      mimetype = TEXT;
      
      //Get system properties
      props = System.getProperties();
      //Setup mail server
      props.put("mail.smtp.host", SMTPHOST);
      //Get session
      session = Session.getDefaultInstance(props, null);
      //Define message
      mm = new MimeMessage(session);
   }
      
   //############################################################
   //Ajout d'expéditeur et destinataires
   //############################################################
   
   /**
    * Ajoute un expéditeur
    * @param expediteur
    * @throws Exception
    */
   public void setFrom(String expediteur) throws Exception {
      if (expediteur.trim().length() > 0) {
         mm.setFrom(checkMail(expediteur));
         noreply = false;
      }
   }
   
   /**
    * Ajoute un destinataire
    * @param destinataire
    * @throws Exception
    */
   public void setTo(String destinataire) throws Exception {
      if (destinataire.trim().length() > 0) {
         if (plusieursMails(destinataire))
            setTo(decoupe(destinataire));
         else {
            mm.addRecipient(Message.RecipientType.TO, checkMail(destinataire));
         }
      }
   }
   /**
    * Ajoute plusieurs destinataires
    * @param dest
    * @throws Exception
    */
   public void setTo(String[] dest) throws Exception {
      for (int i=0; i<dest.length; i++)
         setTo(dest[i]);
   }
   
   /**
    * Ajoute un destinataire en copie
    * @param cc
    * @throws Exception
    */
   public void setCC(String cc) throws Exception {
      if (cc.trim().length() > 0) {
         if (plusieursMails(cc))
            setCC(decoupe(cc));
         else {
            mm.addRecipient(Message.RecipientType.CC, checkMail(cc));
         }
      }
   }
   /**
    * Ajoute plusieurs destinataires en copie
    * @param cc
    * @throws Exception
    */
   public void setCC(String[] cc) throws Exception {
      for (int i=0; i < cc.length; i++)
         setCC(cc[i]);
   }
   
   /**
    * Ajoute un destinataire en copie cachée.
    * @param bcc
    * @throws Exception
    */
   public void setCopieCachee(String bcc) throws Exception {
      if (bcc.trim().length() > 0) {
         if (plusieursMails(bcc))
            setCopieCachee(decoupe(bcc));
         else {
            mm.addRecipient(Message.RecipientType.BCC, checkMail(bcc));
         }
      }
   }
   /**
    * Ajoute plusieurs destinataires en copie cachée.
    * @param bcc
    * @throws Exception
    */
   public void setCopieCachee(String[] bcc) throws Exception {
      for (int i=0; i < bcc.length; i++)
         setCopieCachee(bcc[i]);
   }
   
   //############################################################
   //Champs avec destinataires multiples
   //############################################################

   /**
    * Teste si y'a plusieurs mails dans la chaîne, séparés par un espace, une virgule ou un point-virgule
    * @param mails
    * @return
    */
   static public boolean plusieursMails(String mails) {
      return ((mails.indexOf(' ') + mails.indexOf(',') + mails.indexOf(';')) > -1);
   }
   /**
    * Découpe la chaîne contenant plusieurs mails en String[]
    * @return
    */
   static public String[] decoupe(String mails) {
      return mails.split(" |,|;");
   }
   
   //############################################################
   //Sujet et message
   //############################################################

   /**
    * Ajoute le sujet
    * @param sujet
    * @throws Exception
    */
   public void setSujet(String sujet) throws Exception {
      mm.setSubject(sujet);
   }
   
   /**
    * Choisir entre le type texte brut ({@link Mail#TEXT}) ou HTML ({@link Mail#HTML}).
    * @param mime
    * @throws Exception
    */
   public void setMimeType(int mime) throws Exception {
      mimetype = mime;
   }
   
   /**
    * Ajoute le message
    * @param message
    * @throws Exception
    */
   public void setMessage(String message) throws Exception {
      if (mimetype == HTML)
         mm.setContent(message, "text/html");
      else mm.setText(message);
   }
   
   //############################################################
   //Envoi
   //############################################################
   
   /**
    * Envoie le mail
    * @throws Exception
    */
   public void send() throws Exception {
      if (noreply)
         setFrom(NOREPLY);
      Transport.send(mm);
   }
   
   //############################################################
   //Vérifications de la validité d'adresse e-mails
   //(fonctions pour l'extérieur : jsp ou WebServices...)
   //############################################################
   /**
    * Vérifie si l'adresse passée en paramètre est valide. Si elle ne contient pas
    * de @, vérifie si elle correspond bien à un pseudo (voir nameToMail).
    * @param mail
    */
   static public void isValide(String mail) throws Exception {
      if (plusieursMails(mail))
         areValide(decoupe(mail));
      else
         Mail.checkMail(mail);
   }
   /**
    * Vérifie si les adresses passées en paramètres sont valides. Si elles ne contient pas
    * de @, vérifie si elles correspondent à des pseudos (voir nameToMail).
    * <p>Vérifie chacune des adresse, et renvoie une exception global, contenant plusieurs
    * messages d'erreur si plusieurs adresses sont fausses, chaque message étant séparé
    * par un \n.
    * @param mails
    * @throws Exception
    */
   static public void areValide(String[] mails) throws Exception {
      String msg = "";
      for (int i=0; i<mails.length; i++) {
         try {
            isValide(mails[i]);
         } catch (Exception e) {
            msg += ((msg.length()>0)?"\n":"") + e.getMessage();
         }
      }
      if (msg.length() > 0) {
         throw new Exception(msg);
      }
   }
   
   //############################################################
   //Fonctions private,
   //statiques pour être appelés par les public isValide et areValide
   //############################################################

   /**
    * Vérifie la validité d'une adresse e-mail, et renvoie sous forme d'InternetAdress
    * ou une exception en cas d'erreur.
    * @param mail
    * @throws Exception
    */
   static private InternetAddress checkMail(String mail) throws Exception {
      //Pas de @, c'est peut-être un pseudonyme ?...
      if (mail.indexOf('@') == -1) {
         return new InternetAddress(nameToMail(mail));
      }
      else {
         //le parse d'InternetAddress ne renvoie pas d'erreur sur adresse@mail
         //alors on fait un test simple pour savoir si y'a un point, après l'@
         //adresse@mail.fr est OK, adresse@mail renvoie une exception.
         if (mail.lastIndexOf('.') < mail.indexOf('@')) {
            throw new Exception("Adresse email \""+mail+"\" invalide");
         }
         else {
            return new InternetAddress(mail);
         }
      }
   }
   
   /**
    * Ici votre fonction perso, qui transforme des noms génériques en adresses e-mail.
    * <p>Par exemple : webmaster -> webmaster@societe.fr
    * @param name
    * @throws Exception si le pseudo est inconnu.
    */
   static private String nameToMail(String name) throws Exception {
      //L'exemple du mail au webmaster, si on met juste "webmaster" sans mettre
      //@societe.fr, cette fonction transforme.
      if (name.equalsIgnoreCase("webmaster"))
         return "webmaster@societe.fr";
      //else if....
      //else if....
      //else c'est une erreur
      else
         throw new Exception("Nom \""+name+"\" inconnu");
   }
}
Créé le 15 janvier 2005  par iubito

Voici un serveur proxy (pour ceux qui ne savent pas ce que c'est : un serveur proxy sert de station de connexion entre un client et un serveur. Les requêtes du client sont redirigées par le proxy au serveur effectif et les réponses de celui-ci transitent également par le proxy avant d'arriver au client) que vous pourrez améliorer afin de contrôler et d'enregistrer les connexions, assister un pare-feu, fournir un accès Internet ou à certains serveurs par mot de passe, effectuer des statistiques, filtrage des adresses pour interdire l'accès à certains sites, ... les idées ne manque pas !
Je vous laisse le soin de configurer votre navigateur HTTP sur le proxy.

Enjoy it !

Créé le 15 janvier 2005  par Julien CHABLE

Téléchargez le zip

La classe Network permet d'établir une connexion TCP/IP entre deux ordinateurs, leurs permettant ainsi de s'échanger des messages sans se soucier des aspects réseau. Le programme TestNetwork est un exemple permettant de mieux comprendre son fonctionnement.

Créé le 15 février 2005  par Michel Deriaz

Téléchargez le zip

Source permettant d'effectuer des téléchargements sur internet via les deux protocoles FTP et HTTP,avec possibilité du réglage de la vitesse du téléchargement.

Créé le 11 juin 2005  par karami mohamed

Téléchargez le zip

Tous les codes sources fournis gratuitement ici sont soumis à la licence GNU LGPL traduite en français ici. Par contre, la page de présentation constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2004-2005 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.