Votre question

Pourriez-vous m'aider à résoudre mon problème de lecteur de flux en Java?

Tags :
  • Java
  • Html
  • Programmation
Dernière réponse : dans Programmation
30 Octobre 2012 21:45:30

Pour l'école, je dois créer un lecteur de flux, voici l'énnoncé:
L’application :
• ne comportera pas d’interface graphique;
• prendra comme paramètre d’entrée un fichier contenant
la liste des flux ainsi que la fréquence souhaitée de
rafraîchissement pour chacun des flux;
• générera:
◦ un fichier HTML (cf. exemple Illustration 4)par
flux reprenant les informations fournies par le
flux,
◦ un fichier HTML général listant les différents flux
surveillés; un lien vers la page HTML du flux
correspondant permettra d’accéder à celle-ci (cf.
exemple Illustration 3).
Illustration 3
Le fichier HTML propre à chaque flux RSS reprendra les
informations principales concernant le flux (titre,
dernière mise à jour,…), et les informations principales
des chaque information (auteur, titre, dates, lien, media,
…).
La mise à jour (rafraîchissement) des pages HTML de chaque
flux se fera suivant le délai contenu dans le fichier de
configuration (par exemple toutes les 5 minutes).

L’application contiendra les classes suivantes:
• une classe « principale » dont le rôle se bornera à:
◦ lire le fichier de configuration;
◦ lancer le traitement de chacun des flux;
◦ lancer la création de la page HTML de résumé;
• une classe «flux» de type «Thread» qui:
o lira le fichier XML référencé par l’URL du flux;
o lancera le traitement du canal contenu dans le
flux;
o créera le fichier HTML lié au flux;
• une classe «canal» qui structurera les informations
propres au canal, et lancera la structuration des
différents items; cette classe est celle qui doit
modéliser et contenir toute l'information contenue
dans le fichier flux original;
• une classe «item» qui s’occupera de structurer les
informations concernant un item;
-Projet de développement 2012-2013 page 5/ 8 -
• une ou plusieurs classes de création des fichiers
HTML; ces classes travailleront sur base des
informations fournies par la classe principale, la
classe «canal» ou encore la classe «item» suivant le
cas.

Je suis bloqué, je suis à la phase de création d'un fichier sur le disque dur que je ne parviens pas à réaliser, je dois dans mon main, permettre d'enregistrer sur le disque dur chaque flux présent dans mon fichier texte que j'ai appelé "listeflux", qui contient les url des flux suivants.: http://www.lesoir.be/actualite/le_fil_info/rss.xml
http://feeds2.feedburner.com/ForumDesOranges
http://www.siteduzero.com/Templates/xml/news_fr.xml
http://www.developpez.com/index/rss
http://rss.feedsportal.com/c/629/f/502234/index.rss.

Voici mes classes:
la classe main:
  1. package cydown;
  2.  
  3. import java.io.*;
  4.  
  5.  
  6. public class Main {
  7.  
  8.  
  9. public static void main(String[] listeflux) {
  10. // TODO code application logic here
  11. Cydown cydown = new Cydown(listeflux[0]); // a la place de args metttre "listeflux"
  12.  
  13.  
  14. }
  15. }


la classe downloader:

  1. package cydown;
  2.  
  3.  
  4. import java.io.*;
  5. import java.util.*;
  6. import java.net.*;
  7.  
  8. class Downloader extends Thread // création du thread
  9. {
  10. URL url;
  11. String path;
  12. Channel parser;
  13. public Downloader(URL url, String path)
  14. {
  15. this.url= url;
  16. this.path= path;
  17. this.start();
  18. }
  19. public void run()
  20. {
  21. URLConnection connection= null;
  22. DataInputStream input= null;
  23. FileOutputStream output= null;
  24. System.out.println("Start with URL: " + url.toString());
  25. // Récupération de l'URLConnection
  26. // et du flux de lecture.
  27. try {
  28. connection= url.openConnection();
  29. input= new DataInputStream(connection.getInputStream());
  30. }
  31. catch(IOException ioe)
  32. {
  33. System.out.println("L'URL" + url.toExternalForm() + "n'est pas atteignable");
  34. }
  35. // Création du flux de sortie.
  36. try {
  37. output= new FileOutputStream(path);
  38. }
  39. catch(IOException ioe)
  40. {
  41. System.out.println("Impossible d'écrire le fichier" + url.getFile()+ ".");
  42. // On sort de la méthode si on ne peut ouvrir en écriture le fichier de sortie
  43. return;
  44. }
  45. // Lecture du fichier distant pointé par l'URL
  46. // Récupération de la taille du fichier
  47. int fileSize= connection.getContentLength();
  48. if(fileSize > 0)
  49. {
  50. try
  51. {
  52. // Création d'un tableau de bytes à la taille du fichier
  53. byte[]fileContent = new byte[fileSize];
  54. // Lecture complète du fichier! Hum, hum!
  55. input.readFully(fileContent);
  56. // Ecriture complète du fichier
  57. output.write(fileContent);
  58. }
  59. catch(IOException ioe){
  60. System.out.println("Impossible de lire le fichier" + url.getFile() + ".");
  61. }
  62. }// fin if
  63. else
  64. {
  65. // Méthode alternative de lecture: byte par byte : - [
  66. // Essayeralors par stream buffer...
  67. int lecteur=0;
  68. do{
  69. try{
  70. lecteur= input.read();
  71. if(lecteur != -1)
  72. output.write(lecteur);
  73. }
  74. catch(IOException ioe) {}
  75. }
  76. while(lecteur !=-1 );
  77.  
  78. } // fin else
  79. try{
  80. input.close();
  81. output.close();
  82. } catch(IOException ioe) {}
  83. System.out.println("Done with URL:" + url.toString());
  84. parser = new Channel(path);
  85. } // fin run
  86. } // classe downloader
  87.  
  88.  
  89.  
  90.  
  91. // url connection: un objet qui va permettre d'aller chercher le fichier

la classe cydown:


  1. package cydown;
  2.  
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.util.Scanner;
  6. import java.util.logging.Level;
  7. import java.util.logging.Logger;
  8. import java.io.*;
  9. import java.util.*;
  10. import java.net.*;
  11. import java.io.FileNotFoundException;
  12. import java.io.IOException;
  13. import java.util.logging.Level;
  14. import java.util.logging.Logger;
  15.  
  16.  
  17. public class Cydown
  18.  
  19. {
  20. //permet de manipuler la description du fichier(chemin d'accès, nom, voir si le fichier existe, etc...),
  21. //c'est un pointeur vers le fichier (voir eteks.com)
  22.  
  23.  
  24. File myFile;
  25. URL url ;
  26. // variable de type URL: construire une URL (peut générer une exception), passer un string, juste une description
  27. // de l'URL
  28. // variable qui permet de lire le fichier= flux, l'intérêt des flux est de permettre de se connecter
  29. // à beaucoup de choses(notamment un fichier)
  30. String fileNotFoundMsg= " Le fichier d'URL est introuvable." ;
  31. String lecteur ;
  32. // permet de lire le fichier texte ligne par ligne
  33. String workingpath ;
  34. // on stocke les processus, on doit mettre une référence
  35. Vector downloaders; // 5 traites stockées dans un vecteur
  36. StringTokenizer tokenizer; // pour découper une chaîne de caractères en morceaux
  37. int nTokens;
  38.  
  39.  
  40.  
  41. public Cydown(String fileNameURLs)
  42. {
  43.  
  44. // Initialisation du vecteur de Threads
  45. downloaders= new Vector();
  46. myFile= new File(fileNameURLs);
  47.  
  48.  
  49. // crée juste une description du fichier
  50.  
  51.  
  52. if(! myFile.exists())
  53. {
  54. System.out.println(fileNotFoundMsg);
  55. System.out.print(myFile);
  56. return ;
  57. }
  58. // on vérifie que le fichier existe, on sait que le fichier existe et ou il se trouve
  59.  
  60. //Création de l'accès au fichier d'URLs.
  61. // le flux fileReader: ne permet pas de lire une ligne de fichier texte tandis que
  62. // le flux BufferedReader: permet de lire une ligne de fichier texte
  63. // si on veut l'utiliser, il faut d'abord le construire: BufferedReader(FileReader).readline()
  64. try{
  65. fileIn= new BufferedReader(new FileReader(myFile.getAbsolutePath()));
  66. }
  67. {System.out.println(fileNotFoundMsg);
  68. System.out.print(myFile);
  69. }
  70.  
  71. //Recherche du chemin d'accès au répertoire du fichier.
  72. workingpath = myFile.getParent() + "\\";
  73. // Début de la boucle de lecture des lignes du fichier d'URLs
  74.  
  75.  
  76. // mettre creation de thread et appel de downloader voir après
  77.  
  78.  
  79.  
  80. do
  81. {
  82. try
  83. {lecteur = fileIn.readLine();}
  84. catch(IOException ioe)
  85. {System.out.println("Problème lors de la lecture du fichier"); }
  86. //Traitement de l'URL lue dans le fichier
  87. if(lecteur != null)
  88. {
  89. try
  90. {
  91. //constitution de l'objet URL.
  92. url= new URL(lecteur);
  93. // Utilisation de tokens pour retrouver le nom du fichier dans l'URL.
  94. tokenizer= new StringTokenizer(lecteur, "/");
  95. nTokens= tokenizer.countTokens();
  96. //token: chaque élément coupé séquentiellement, on découpe, on demande le nom du token, voir boucle
  97. for(int i= 1 ; i< nTokens; i++) tokenizer.nextToken();
  98. String fileNameURL= tokenizer.nextToken();
  99. // création de l'objet donwloader.
  100. downloaders.addElement( new Downloader(url, workingpath + fileNameURL));
  101. }
  102. {System.out.println("L'URL : " + lecteur + "est incorrecte.");}
  103. }
  104.  
  105. } while (lecteur != null);
  106.  
  107. // On sort de la boucle quand il n'y a plus rien à lire dans le fichier d'URLs
  108. } // fin du constructeur
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115. }

la classe channel:

  1. package cydown;
  2.  
  3. import java.io.*;
  4. import org.jdom2.*;
  5. import org.jdom2.input.*;
  6. import org.jdom2.filter.*;
  7. import java.util.List;
  8. import java.util.Iterator;
  9. import org.jdom2.Element;
  10.  
  11. // Pour parser un fichier XML, il faut transformer le fichier XML en une arborescence JDOM
  12. // Parser: exploiter un fichier sous une forme brute affin d'en tirer les informations utile, on analyse
  13. // et traite l'information afin d'en dégager les informations importantes
  14.  
  15. public class Channel
  16. {
  17. // private: empêche de manipuler directement les variables d'instance, qui sont
  18. //généralement protégées par la mention "private" en écriture et en lecture
  19. private String Title;
  20. private String Link;
  21. private String Description;
  22.  
  23. Item i= new Item();
  24.  
  25.  
  26. static org.jdom2.Document document;
  27. static Element rss;
  28. Element elementChannel;
  29. List listElementItems,listItems;
  30.  
  31.  
  32.  
  33. public Channel(String Filepath)
  34. {
  35. //On crée une instance de SAXBuilder, on l'utilise pour parser le fichier, il est basé sur l'API SAX
  36.  
  37. SAXBuilder sxb = new SAXBuilder();
  38. try
  39. {
  40. //On crée un nouveau document JDOM avec en argument le fichier XML
  41. //Le parsing est alors terminé
  42.  
  43. document = sxb.build(new File(Filepath));
  44. }
  45. catch(Exception e){}
  46. // On initialise un nouvel élément racine avec l'élément racine du document
  47. rss = document.getRootElement();
  48. Element elementChannel= rss.getChild("channel");
  49. Title = elementChannel.getChild("title").getText();
  50. Link= elementChannel.getChild("link").getText();
  51. Description= elementChannel.getChild("description").getText();
  52. listElementItems = elementChannel.getChildren("item");
  53. // On crée un Iterator sur la liste d'items qu'on vient de créer
  54. Iterator i= listElementItems.iterator();
  55. while(i.hasNext())
  56. {
  57. //On crée l'élément courant à chaque tour de boucle afin de pouvoir utiliser les méthodes
  58. //propres aux éléments comme sélectionner tous les items
  59. Element courant=(Element)i.next();
  60. Item anItem = new Item(courant);
  61. listItems.add(anItem);
  62.  
  63. }
  64. }
  65.  
  66. Channel() {
  67. throw new UnsupportedOperationException("Not yet implemented");
  68. }
  69.  
  70.  
  71. public String getTitle()
  72. {
  73. return Title;
  74. }
  75.  
  76. public String getLink()
  77. {
  78. return Link;
  79. }
  80.  
  81. public String getDescription()
  82. {
  83. return Description;
  84. }
  85.  
  86.  
  87.  
  88. public void Settitle(String Title)
  89. {
  90. this.Title= Title;
  91. }
  92.  
  93. public void Setlink(String Link)
  94. {
  95. this.Link= Link;
  96. }
  97.  
  98. public void Setdescription(String Description)
  99. {
  100. this.Description= Description;
  101. }
  102.  
  103. }


et la classe item:

  1. package cydown;
  2. import org.jdom2.*;
  3. import org.jdom2.input.*;
  4. import org.jdom2.filter.*;
  5.  
  6. public class Item
  7. {
  8. private String Title;
  9. private String Link;
  10. private String Description;
  11. private String Author;
  12. private String Category;
  13. private String Comments;
  14. private String Enclosure;
  15. private String Guid;
  16. private String PubDate ;
  17. private String Source;
  18.  
  19. public Item (Element elementItem)
  20. {
  21. // On affiche les items de l'element Item
  22.  
  23.  
  24.  
  25. Title = getProperty(elementItem, "title");
  26. Link= getProperty(elementItem, "link");
  27. Description= getProperty(elementItem, "description");
  28. Author= getProperty(elementItem, "author");
  29. Category= getProperty(elementItem, "category");
  30. Comments= getProperty(elementItem,"comments");
  31. Enclosure= getProperty(elementItem,"enclosure");
  32. Guid= getProperty(elementItem,"guid");
  33. PubDate= getProperty(elementItem,"pubdate");
  34. Source= getProperty(elementItem,"source");
  35. }
  36.  
  37. Item() {
  38. throw new UnsupportedOperationException("Not yet implemented");
  39. }
  40.  
  41. private String getProperty(Element element, String SearchedProp)
  42. {
  43. Element property = element.getChild(SearchedProp);
  44. String returnValue="";
  45. if(property != null) returnValue= property.getText();
  46. return returnValue;
  47. }
  48. public String getTitle()
  49. {
  50. return Title;
  51. }
  52.  
  53. public String getLink()
  54. {
  55. return Link;
  56. }
  57.  
  58. public String getDescription()
  59. {
  60. return Description;
  61. }
  62.  
  63. public String getAuthor()
  64. {
  65. return Author;
  66. }
  67.  
  68. public String getCategory()
  69. {
  70. return Category;
  71. }
  72.  
  73. public String getComments()
  74. {
  75. return Comments;
  76. }
  77.  
  78. public String getEnclosure()
  79. {
  80. return Enclosure;
  81. }
  82.  
  83. public String getGuid()
  84. {
  85. return Guid;
  86. }
  87.  
  88. public String getPubDate()
  89. {
  90. return PubDate;
  91. }
  92.  
  93. public String getSource()
  94. {
  95. return Source;
  96. }
  97.  
  98.  
  99. public void Settitle(String Title)
  100. {
  101. this.Title= Title;
  102. }
  103.  
  104. public void SetLink(String Link)
  105. {
  106. this.Link= Link;
  107. }
  108.  
  109. public void SetDescription(String Description)
  110. {
  111. this.Description= Description;
  112. }
  113.  
  114. public void SetAuthor(String Author)
  115. {
  116. this.Author= Author;
  117. }
  118.  
  119. public void SetCategory(String Category)
  120. {
  121. this.Category= Category;
  122. }
  123.  
  124. public void SetComments(String Comments)
  125. {
  126. this.Comments= Comments;
  127. }
  128.  
  129. public void SetEnclosure(String Enclosure)
  130. {
  131. this.Enclosure= Enclosure;
  132. }
  133.  
  134. public void SetGuid(String Guid)
  135. {
  136. this.Guid= Guid;
  137. }
  138.  
  139. public void SetPubDate(String PubDate)
  140. {
  141. this.PubDate= PubDate;
  142. }
  143.  
  144. public void SetSource(String Source)
  145. {
  146. this.Source= Source;
  147. }
  148.  
  149. }

Si quelqu'un sait m'aider et m'aider pour la suite du projet, tout est décrit dans l'énnonce, contactez-moi: ******@hotmail.com.

Merci d'avance.



Autres pages sur : pourriez aider resoudre probleme lecteur flux java

a c 232 L Programmation
31 Octobre 2012 11:17:33

a édité ce message
a c 232 L Programmation
31 Octobre 2012 11:18:28

a édité ce message
31 Octobre 2012 12:51:09

a édité ce message
Tom's guide dans le monde
  • Allemagne
  • Italie
  • Irlande
  • Royaume Uni
  • Etats Unis
Suivre Tom's Guide
Inscrivez-vous à la Newsletter
  • ajouter à twitter
  • ajouter à facebook
  • ajouter un flux RSS