Écrire un fichier HTML en utilisant Java
Je veux que mon application Java écrive du code HTML dans un fichier. En ce moment, je code en dur des balises HTML en utilisant la classe java.io.BufferedWriter. Par exemple:
BufferedWriter bw = new BufferedWriter(new FileWriter(file));
bw.write("<html><head><title>New Page</title></head><body><p>This is Body</p></body></html>");
bw.close();
Existe-t-il un moyen plus simple de le faire, car je dois créer des tables et cela devient très gênant?
10 answers
Si vous voulez le faire vous-même, sans utiliser de bibliothèque externe, je pense qu'un moyen propre serait de créer un "modèle.html" fichier avec tout le contenu statique, comme par exemple:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>$title</title>
</head>
<body>$body
</body>
</html>
Mettre une balise comme tag tag pour tout contenu dynamique, puis faire quelque chose comme ceci:
File htmlTemplateFile = new File("path/template.html");
String htmlString = FileUtils.readFileToString(htmlTemplateFile);
String title = "New Page";
String body = "This is Body";
htmlString = htmlString.replace("$title", title);
htmlString = htmlString.replace("$body", body);
File newHtmlFile = new File("path/new.html");
FileUtils.writeStringToFile(newHtmlFile, htmlString);
Remarque: J'ai utilisé org.apache.commons.io.FileUtils pour plus de simplicité.
Il y a quelques mois, j'ai eu le même problème et chaque bibliothèque que j'ai trouvée fournit trop de fonctionnalités et de complexité pour mon objectif final. Je finis donc par développer ma propre bibliothèque - HtmlFlow - qui fournit une API très simple et intuitive qui me permet d'écrire du HTML dans un style fluide. Vérifiez-le ici: https://github.com/fmcarvalho/HtmlFlow (il prend également en charge liaison dynamique aux éléments HTML)
Voici un exemple de liaison les propriétés d'un Task objet dans les éléments HTML. Considérons un Task classe Java avec trois propriétés: Title, Description et un Priority, puis nous pouvons produire un document HTML d'une Task objet de la manière suivante:
import htmlflow.HtmlView;
import model.Priority;
import model.Task;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
public class App {
private static HtmlView<Task> taskDetailsView(){
HtmlView<Task> taskView = new HtmlView<>();
taskView
.head()
.title("Task Details")
.linkCss("https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css");
taskView
.body().classAttr("container")
.heading(1, "Task Details")
.hr()
.div()
.text("Title: ").text(Task::getTitle)
.br()
.text("Description: ").text(Task::getDescription)
.br()
.text("Priority: ").text(Task::getPriority);
return taskView;
}
public static void main(String [] args) throws IOException{
HtmlView<Task> taskView = taskDetailsView();
Task task = new Task("Special dinner", "Have dinner with someone!", Priority.Normal);
try(PrintStream out = new PrintStream(new FileOutputStream("Task.html"))){
taskView.setPrintStream(out).write(task);
Desktop.getDesktop().browse(URI.create("Task.html"));
}
}
}
Vitesse est un bon candidat pour écrire ce genre de choses.
Il vous permet de garder votre code html et de génération de données aussi séparés que possible.
Je vous recommande fortement d'utiliser un langage de template très simple tel que Freemarker
Vous pouvez utiliser jsoup ou wffweb (HTML5) en fonction.
Exemple de code pour jsoup: -
Document doc = Jsoup.parse("<html></html>");
doc.body().addClass("body-styles-cls");
doc.body().appendElement("div");
System.out.println(doc.toString());
Imprime
<html>
<head></head>
<body class=" body-styles-cls">
<div></div>
</body>
</html>
Exemple de code pour wffweb: -
Html html = new Html(null) {{
new Head(this);
new Body(this,
new ClassAttribute("body-styles-cls"));
}};
Body body = TagRepository.findOneTagAssignableToTag(Body.class, html);
body.appendChild(new Div(null));
System.out.println(html.toHtmlString());
//directly writes to file
html.toOutputStream(new FileOutputStream("/home/user/filepath/filename.html"), "UTF-8");
Imprime (en format minifié): -
<html>
<head></head>
<body class="body-styles-cls">
<div></div>
</body>
</html>
Cela dépend vraiment du type de fichier HTML que vous créez.
Pour de telles tâches, j'utilise pour créer un objet, le sérialiser en XML, puis le transformer avec XSL. Les avantages de cette approche sont:
- La séparation stricte entre le code source et le modèle HTML,
- La possibilité d'éditer du HTML sans avoir à recompiler l'application,
- La possibilité de servir différents HTML dans différents cas basés sur le même XML, ou même de servir XML directement en cas de besoin (pour un plus de la désérialisation par exemple),
- La plus courte quantité de code à écrire.
Les inconvénients sont:
- Vous devez connaître XSLT et savoir comment l'implémenter en Java.
- Vous devez écrire XSLT (et c'est une torture pour de nombreux développeurs).
- Lors de la transformation de XML en HTML avec XSLT, certaines parties peuvent être délicates. Quelques exemples:
<textarea/>tags (qui rendent la page inutilisable), déclaration XML (qui peut causer des problèmes avec IE), espaces (avec<pre></pre>tags etc.), En entités HTML ( ), etc. - Les performances seront réduites, car la sérialisation en XML gaspille beaucoup de ressources CPU et la transformation XSL est également très coûteuse.
Maintenant, si votre HTML est très court ou très répétitif ou si le HTML a une structure volatile qui change dynamiquement, cette approche ne doit pas être prise en compte. D'autre part, si vous servez des fichiers HTML qui ont tous une structure similaire et vous souhaitez réduire la quantité de code Java et utiliser des modèles, cette approche peut travail.
Si vous êtes prêt à utiliser Groovy, le MarkupBuilder est très pratique pour ce genre de chose, mais je ne sais pas que Java a quelque chose comme ça.
Http://groovy.codehaus.org/Creating+XML+aide+Groovy's+MarkupBuilder
Si cela devient un travail répétitif; je pense que vous shud faites de la réutilisation de code ! pourquoi ne pas simplement écrire des fonctions qui "écrivent" de petits blocs de construction de HTML. l'idée? voir, par exemple. vous pouvez avoir une fonction à laquelle vous pouvez passer une chaîne et elle la mettrait automatiquement dans une balise de paragraphe et la présenterait. Bien sûr, vous devrez également écrire une sorte d'analyseur de base pour ce faire (comment la fonction saurait-elle où attacher le paragraphe!). je ne pense pas que vous êtes un débutant .. donc, je ne suis pas l'élaboration d' ... dites-moi si vous ne comprenez pas..
Les modèles et autres méthodes basés sur la création préliminaire du document en mémoire sont susceptibles d'imposer certaines limites à la taille du document résultant.
Pendant ce temps, une approche d'écriture à la volée très simple et fiable pour la création de HTML simple existe, basée sur un gestionnaire SAX et un transformateur XSLT par défaut, ce dernier ayant une capacité intrinsèque de sortie HTML:
String encoding = "UTF-8";
FileOutputStream fos = new FileOutputStream("myfile.html");
OutputStreamWriter writer = new OutputStreamWriter(fos, encoding);
StreamResult streamResult = new StreamResult(writer);
SAXTransformerFactory saxFactory =
(SAXTransformerFactory) TransformerFactory.newInstance();
TransformerHandler tHandler = saxFactory.newTransformerHandler();
tHandler.setResult(streamResult);
Transformer transformer = tHandler.getTransformer();
transformer.setOutputProperty(OutputKeys.METHOD, "html");
transformer.setOutputProperty(OutputKeys.ENCODING, encoding);
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
writer.write("<!DOCTYPE html>\n");
writer.flush();
tHandler.startDocument();
tHandler.startElement("", "", "html", new AttributesImpl());
tHandler.startElement("", "", "head", new AttributesImpl());
tHandler.startElement("", "", "title", new AttributesImpl());
tHandler.characters("Hello".toCharArray(), 0, 5);
tHandler.endElement("", "", "title");
tHandler.endElement("", "", "head");
tHandler.startElement("", "", "body", new AttributesImpl());
tHandler.startElement("", "", "p", new AttributesImpl());
tHandler.characters("5 > 3".toCharArray(), 0, 5); // note '>' character
tHandler.endElement("", "", "p");
tHandler.endElement("", "", "body");
tHandler.endElement("", "", "html");
tHandler.endDocument();
writer.close();
Notez que XSLT transformer vous libérera du fardeau d'échapper à des caractères spéciaux comme >, car il en prend soin par lui-même.
Et il est facile d'envelopper des méthodes de SAXOPHONE comme startElement() et characters() à quelque chose de plus pratique à son goût...
J'ai aussi eu du mal à trouver quelque chose de simple pour satisfaire mes besoins alors j'ai décidé d'écrire ma propre bibliothèque (avec licence MIT). Il est principalement basé sur le modèle composite et constructeur.
Un exemple déclaratif de base est:
import static com.github.manliogit.javatags.lang.HtmlHelper.*;
html5(attr("lang -> en"),
head(
meta(attr("http-equiv -> Content-Type", "content -> text/html; charset=UTF-8")),
title("title"),
link(attr("href -> xxx.css", "rel -> stylesheet"))
)
).render();
Un exemple courant est:
ul()
.add(li("item 1"))
.add(li("item 2"))
.add(li("item 3"))
Vous pouvez cocher plus d'exemples ici
J'ai également créé un on line converter pour transformer chaque extrait html (du modèle bootstrap complexe au simple extrait simple) sur le voler (c'est à dire html> javatags)