Produire un PDF à partir d'un byte[]

Version imprimable

20/12/2011, 16h48
ruza01

Produire un PDF à partir d'un byte[]

Bonjour,

Je souhaite produire un PDF à partir d'un byte[].

Le byte[] est récupéré à partir d'un composant sur lequel je n'ai pas la main. Ce composant est un éditeur de texte avec mise en forme et tout.

J'ai tenté de passer par iText. La conversion est correcte mais je passe par un fichier HTML intermédiaire et je n'ai pas exactement la même mise en page (souci au niveau du surlignage).

J'ai regardé du coté de FOP mais je ne crois pas que la solution soit la bonne dans mon cas. En fait la conversion byte[] > XML/XSL > PDF n'est pas super évidente je trouve.

Donc pour l'instant je ne vois pas comment réaliser cette conversion byte[] > PDF.

Quelqu'un aurait-il une idée ?

Merci pour votre participation.
20/12/2011, 20h39
thelvin

Mais... Il contient quoi le byte[] ? C'est quelles données et en quel format ?

Le byte[] comprend ce que que l'utilisateur aura saisi dans l’éditeur avec la mise forme (police, couleur, ...).

Le contenu est sous forme HTML
Exemple :
Code:

1 2 3 4 5 Bonjour test mise en forme <hr /> <div style="text-align: center">Toto et le reste du monde</div>

De retour :)
J'ai vu que l'article a été vu/lu un bon nombre de fois donc c'est que je ne dois pas être le seul dans ce cas...
Alors pour mon souci du moment je crois avoir trouvé une solution sur le net
voici le code source

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
import java.io.FileInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.ByteArrayOutputStream;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
 
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
 
import org.w3c.tidy.Tidy;
import org.w3c.dom.Document;
 
import org.xml.sax.InputSource;
 
import org.apache.fop.apps.Driver;
import org.apache.fop.messaging.MessageHandler;
import org.apache.fop.tools.DocumentInputSource;
 
import org.apache.avalon.framework.logger.ConsoleLogger;
import org.apache.avalon.framework.logger.Logger;
 
/*
 *  Class that converts HTML to PDF using
 *  the DOM interfaces of JTidy, Xalan, and FOP.
 *
 *  @author N. Afshartous
 * 
 */
public class Html2Pdf {
 
 
    public static void main(String[] args) {
//args[0] = fichier html de base
//args[1] = fichier xsl
	// open file
	if (args.length != 2) {
	    System.out.println("Usage: Html2Pdf htmlFile styleSheet");
	    System.exit(1);
	}
 
	FileInputStream input = null;
	String htmlFileName = args[0];
 
	try {
 
		input = new FileInputStream(htmlFileName);
 
	}
	catch (java.io.FileNotFoundException e) {
		System.out.println("File not found: " + htmlFileName);
	}
 
        Tidy tidy = new Tidy();
	Document xmlDoc = tidy.parseDOM(input, null);
 
	Document foDoc = xml2FO(xmlDoc, args[1]);
 
	String pdfFileName = htmlFileName.substring(0, htmlFileName.indexOf(".")) + ".pdf";
	try {
	    OutputStream pdf = new FileOutputStream(new File(pdfFileName));
	    pdf.write(fo2PDF(foDoc));
	}
	catch (java.io.FileNotFoundException e) {
	    System.out.println("Error creating PDF: " + pdfFileName);
	}
	catch (java.io.IOException e) {
	    System.out.println("Error writing PDF: " + pdfFileName);
	}
 
 
    }
 
 
    /*
     *  Applies stylesheet to input.
     *
     *  @param xml  The xml input Document
     *  
     *  @param stylesheet Name of the stylesheet
     *
     *  @return Document  Result of the transform
     */
    private static Document xml2FO(Document xml, String styleSheet) {
 
	DOMSource xmlDomSource = new DOMSource(xml);
      	DOMResult domResult = new DOMResult();
 
	Transformer transformer = getTransformer(styleSheet);
 
	if (transformer == null) {
	    System.out.println("Error creating transformer for " + styleSheet);
	    System.exit(1);
	}
	try {
	    transformer.transform(xmlDomSource, domResult);
	}
	catch (javax.xml.transform.TransformerException e) {
	    return null;
	}
	return (Document) domResult.getNode();
 
    }
 
 
    /*
     *  Apply FOP to XSL-FO input
     *
     *  @param foDocument  The XSL-FO input
     *  
     *  @return byte[]  PDF result
     */
    private static byte[] fo2PDF(Document foDocument) {
 
        DocumentInputSource fopInputSource = new DocumentInputSource(
                                                         foDocument);
 
        try {
 
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            Logger log = new ConsoleLogger(ConsoleLogger.LEVEL_WARN);
 
            Driver driver = new Driver(fopInputSource, out);
            driver.setLogger(log);
            driver.setRenderer(Driver.RENDER_PDF);
            driver.run();
 
            return out.toByteArray();
 
        } catch (Exception ex) {
            return null;
        }
    }
 
 
    /*
     *  Create and return a Transformer for the specified stylesheet.
     *  
     *  Based on the DOM2DOM.java example in the Xalan distribution.
     */
    private static Transformer getTransformer(String styleSheet) {
 
	try {
 
	    TransformerFactory tFactory = TransformerFactory.newInstance();
 
	    DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
 
	    dFactory.setNamespaceAware(true);
 
	    DocumentBuilder dBuilder = dFactory.newDocumentBuilder();
	    Document xslDoc = dBuilder.parse(styleSheet);
	    DOMSource xslDomSource = new DOMSource(xslDoc);
 
	    return tFactory.newTransformer(xslDomSource);
 
	}
	catch (javax.xml.transform.TransformerException e) {
	    e.printStackTrace();
	    return null;
	}
	catch (java.io.IOException e) {
	    e.printStackTrace();
	    return null;
	}
	catch (javax.xml.parsers.ParserConfigurationException e) {
	    e.printStackTrace();
	    return null;
	}
	catch (org.xml.sax.SAXException e) {	
	    e.printStackTrace();
	    return null;
	}
 
    }
 
}

30/12/2011, 15h22
thelvin

Citation:

Envoyé par ruza01

J'ai vu que l'article a été vu/lu un bon nombre de fois donc c'est que je ne dois pas être le seul dans ce cas...

Je vois pas le rapport. Les gens qui viennent te lire viennent juste voir s'ils peuvent t'aider. S'ils étaient dans la même situation que toi, ils parleraient de ce qu'ils ont déjà regardé, et de leur propre situation.

Citation:

Envoyé par ruza01

Alors pour mon souci du moment je crois avoir trouvé une solution sur le net

J'aurais effectivement vu quelque chose comme ça.
Reste à trouver une stylesheet XSLT qui transforme XHTML en XSL-FO, mais je vois que l'article que tu as trouvé en cite une. Peut-être qu'elle convient.

Bonjour juste pour apporter une précision...
Je ne suis pas arrivé à faire fonctionner l'exemple que j'ai trouvé dans un premier temps.
J'ai dû découper ma classe java pour qu'elle interprète bien toute les phases et créé des fichiers intermédiares.
Point important également l'exemple trouvé est fait pour fonctionner avec fop 0.20 (Driver). J'ai donc modifié pour intégrer fop1 (plus de Driver).
phase1 html to xml avec jtidy
phase2 xml to fo (méthode de fop)
phase3 fo to pdf (méthode de fop)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Properties;
 
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
 
import org.apache.fop.apps.FOPException;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.Fop;
import org.apache.fop.apps.FopFactory;
import org.apache.fop.apps.FormattingResults;
import org.apache.fop.apps.MimeConstants;
import org.apache.fop.apps.PageSequenceResults;
import org.w3c.tidy.Tidy;
 
public class TestFopHMTLtoPDF {
 
	private static FopFactory fopFactory = FopFactory.newInstance();
 
	public static void main(String[] args){
		try{
			File fichierHtml = new File("c:/temp/12.html");
			File fichierXml = new File("c:/temp/12Temp.xml");			
			File fichierXsl = new File("c:/temp/standardXslFo.xsl");
			File fichierFo = new File("c:/temp/12TempFo.fo");
			File fichierPdf = new File("c:/temp/12Temp.pdf");
			htmlToXml(fichierHtml.getAbsolutePath(),fichierXml.getAbsolutePath());
			System.out.println("xml ok");
			XmlToFo(fichierXml.getAbsolutePath(),fichierXsl.getAbsolutePath(), fichierFo.getAbsolutePath());
			System.out.println("fo ok");
			FoToPdf(fichierFo.getAbsolutePath(),fichierPdf.getAbsolutePath());
			System.out.println("pdf ok");
		//	fichierHtml.delete();
			fichierXml.delete();
			fichierFo.delete();
 
		}
		catch (Exception ex){
			System.out.println("===>Une erreur dans la méthode main s'est produite.\n");
			ex.printStackTrace();
		}
 
	}
 
	private static void htmlToXml(String fichierhtml,String fichierXml) throws IOException{
		FileInputStream input = null;
		FileOutputStream fos = null;
		try{
			input = new FileInputStream(fichierhtml);
			Tidy tidy = new Tidy();
			tidy.setNumEntities(true);
			tidy.setXmlOut(true);
			fos = new FileOutputStream(fichierXml);
			tidy.parse(input, fos);
		}
		catch(Exception ex){
			System.out.println("===>Erreur lors de la génération du fichier xml.\n");
			ex.printStackTrace();
		}
		finally{
			fos.close();
			input.close();
		}
 
	}
 
	private static void XmlToFo(String fichierXml,String fichierXsl, String fichierFo) throws IOException{
		OutputStream out = null;
		 try {
			 out= new java.io.FileOutputStream(fichierFo);
		        TransformerFactory factory = TransformerFactory.newInstance();
		        Transformer transformer = factory.newTransformer(new StreamSource(fichierXsl));
 
		        Source src = new StreamSource(fichierXml);
		        Result res = new StreamResult(out);
 
		        transformer.transform(src, res);
		 }
		 catch(FileNotFoundException ex){
				System.out.println("===>Erreur FileNotFoundException lors de la génération du fichier fo.\n");
				ex.printStackTrace();
		}		 
		catch(TransformerException ex){
			System.out.println("===>Erreur TransformerException lors de la génération du fichier fo.\n");
			ex.printStackTrace();
		}		
		 catch(Exception ex){
				System.out.println("===>Erreur Exception lors de la génération du fichier fo.\n");
				ex.printStackTrace();
			}
	    finally {
	        out.close();
	    }
 
	}
 
	private static void FoToPdf(String fichierFo, String fichierPdf) throws IOException, FOPException {
 
        OutputStream out = null;
 
        try {
            FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
            // configure foUserAgent as desired
 
            // Setup output stream.  Note: Using BufferedOutputStream
            // for performance reasons (helpful with FileOutputStreams).
            out = new FileOutputStream(fichierPdf);
            out = new BufferedOutputStream(out);
 
            // Construct fop with desired output format
            Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out);
 
            // Setup JAXP using identity transformer
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(); // identity transformer
 
            // Setup input stream
            Source src = new StreamSource(fichierFo);
 
            // Resulting SAX events (the generated FO) must be piped through to FOP
            Result res = new SAXResult(fop.getDefaultHandler());
 
            // Start XSLT transformation and FOP processing
            transformer.transform(src, res);
 
            // Result processing
            FormattingResults foResults = fop.getResults();
            java.util.List pageSequences = foResults.getPageSequences();
            for (java.util.Iterator it = pageSequences.iterator(); it.hasNext();) {
                PageSequenceResults pageSequenceResults = (PageSequenceResults)it.next();
                System.out.println("PageSequence "
                        + (String.valueOf(pageSequenceResults.getID()).length() > 0
                                ? pageSequenceResults.getID() : "<no id>")
                        + " generated " + pageSequenceResults.getPageCount() + " pages.");
            }
            System.out.println("Generated " + foResults.getPageCount() + " pages in total.");
 
        } catch (Exception ex) {
        	System.out.println("===>Erreur lors de la génération du fichier pdf.\n");
			ex.printStackTrace();
            System.exit(-1);
        } finally {
            out.close();
        }
    }
}

Le résultat est plutôt satisfaisant.
Je n'ai pas plus investigué pour le faire sans fichiers intermédiaires.
Peut être un prochain post...:D
Merci de votre participation.