Info-System

Servlet generating an Excel file

For those, who are in a hurry, code of the servlet is at the end of the article. In my online forms composer I wanted to add a nice functionality - export of collected data to excel file. Everything has gone smoothly, but… There is always a “but”. Everything was ok on my development machine (Windows), but failed to work on my production server, which runs on linux (Gentoo to be precise).

When I tried to download a generated xls file, it was always empty. I got really frustrated, because JBoss logged no error in CONSOLE output. I investigated several leads:

DynamicJasper (I used to get dynamic columns set), errors related to closing, flushing outputstreams, not setting response length, etc. Unfortunately nothing was wrong with them.

I was really down because for about two days I haven’t moved an inch forward. Suddenly I realized that standard FILE log4j logger configured in JBoss shows a bit different things than standard CONSOLE logger, so I examined it my second server log and there it was:

net.sf.jasperreports.engine.util.JRFontNotFoundException: Font 'Arial' is not available to the JVM. See the Javadoc for more details.
      at net.sf.jasperreports.engine.util.JRFontUtil.checkAwtFont(JRFontUtil.java:339)
      at net.sf.jasperreports.engine.util.JRStyledText.getAwtAttributedString(JRStyledText.java:226)
      at net.sf.jasperreports.engine.fill.TextMeasurer.measure(TextMeasurer.java:362)
      at net.sf.jasperreports.engine.fill.JRFillTextElement.chopTextElement(JRFillTextElement.java:1129)

It turned out that Gentoo does not have popular fonts. Shame boyz! To sooth my pain gentoo guys made instalation really easy. Typing “emerge corefonts” in shell has done the job.

It was a painful lesson, but now I know that I should pay more attention to configuration of production server logger. As I write it now, it sounds so obvious.

Here is the code of the Servlet:

            import java.io.ByteArrayOutputStream;
            import java.io.IOException;
            import java.text.SimpleDateFormat;
            import java.util.ArrayList;
            import java.util.Date;
            import java.util.HashMap;
            import java.util.List;
            import java.util.Locale;
            import java.util.Map;
         
            import javax.servlet.ServletException;
            import javax.servlet.ServletOutputStream;
            import javax.servlet.http.HttpServlet;
            import javax.servlet.http.HttpServletRequest;
            import javax.servlet.http.HttpServletResponse;
            
            import net.sf.jasperreports.engine.JRDataSource;
            import net.sf.jasperreports.engine.JRException;
            import net.sf.jasperreports.engine.JRExporterParameter;
            import net.sf.jasperreports.engine.JasperPrint;
            import net.sf.jasperreports.engine.data.JRMapCollectionDataSource;
            import net.sf.jasperreports.engine.export.JRXlsExporter;
            import net.sf.jasperreports.engine.export.JRXlsExporterParameter;
            import net.sf.jasperreports.engine.util.JRProperties;
            import net.sf.jasperreports.engine.util.JRStyledText;
            
            import org.apache.log4j.Logger;
            import org.jboss.seam.Component;
            import org.jboss.seam.log.Log;
            
            import ar.com.fdvs.dj.core.DynamicJasperHelper;
            import ar.com.fdvs.dj.core.layout.ListLayoutManager;
            import ar.com.fdvs.dj.domain.DynamicReport;
            import ar.com.fdvs.dj.domain.builders.ColumnBuilderException;
            import ar.com.fdvs.dj.domain.builders.FastReportBuilder;
            
            import com.infosystem.forms.entity.Field;
            import com.infosystem.forms.entity.Submit;
            import com.infosystem.forms.forms.FieldUtils;
            import com.infosystem.utility.HTMLCleaner;
            
            public class CSVExportServletDEmo extends HttpServlet {
            
                private ExportDao exportDao = new ExportDao();
            
                private List<Field> fields;
                private ServletOutputStream outputStream;
                private Logger log = Logger.getLogger(CSVExportServletDEmo.class);
            
                public void doGet(HttpServletRequest request, HttpServletResponse response)
                        throws ServletException, IOException {
                    prepareFields(request, response);
                    try {
                        if (exportDao.isFormResultsAllowedForPublic()) {
                            setResponseProperties(response);
                            createResponse(response);
                        }
                    } catch (Exception e) {
                       logger.error(e);
                    } finally {
                        outputStream.flush();
                        outputStream.close();
                    }
                }
            
                private void prepareFields(HttpServletRequest request,
                        HttpServletResponse response) throws IOException {
                    response.reset();
                    exportDao = new ExportDao();
                    setFormId(request.getParameter("formId"));
                    setChosenField(request.getParameter("chosenFields"));
                    outputStream = response.getOutputStream();
                }
            
                private void setResponseProperties(HttpServletResponse response) {
                    response.setContentType("application/vnd.ms-excel");
                    response.setHeader("Content-Disposition", "inline; filename="
                            + getFileName());
                }
            
                public void createResponse(HttpServletResponse response) throws IOException {
                    DynamicReport dr;
                    try {
                        dr = prepareReport();
                        JRDataSource ds = loadData();
                        ByteArrayOutputStream stream = loadReportAndExport(dr, ds);
                        stream.flush();
                        stream.close();
                        byte[] bytes = stream.toByteArray();
                        response.setContentLength(bytes.length);
                        log.error(bytes.length);
                        outputStream.write(bytes, 0, bytes.length);
                    } catch (JRException e) {
                        log.error(e.getMessage(), e);
                    } catch (ColumnBuilderException e) {
                        log.error(e.getMessage(), e);
                    } catch (ClassNotFoundException e) {
                        log.error(e.getMessage(), e);
                    }
                }
            
                public DynamicReport prepareReport() throws ColumnBuilderException,
                        IOException, ClassNotFoundException {
                    FastReportBuilder drb = new FastReportBuilder();
                    drb.setResourceBundle("forms");
                    drb = createColumns(drb);
                    drb.setTitle(exportDao.getFormTitle())
                            .setPrintBackgroundOnOddRows(true).setIgnorePagination(true);
                    return drb.build();
                }
            
                public JRDataSource loadData() throws JRException {
                    List<Map<String, String>> rows = new ArrayList<Map<String, String>>();
            
                    return new JRMapCollectionDataSource(rows);
                }
            
                private ByteArrayOutputStream loadReportAndExport(DynamicReport dr,
                        JRDataSource ds) throws JRException {
                    JasperPrint jasperPrint = DynamicJasperHelper.generateJasperPrint(dr,
                            new ListLayoutManager(), ds);
                    ByteArrayOutputStream xlsReport = new ByteArrayOutputStream();
                    JRXlsExporter exporter = new JRXlsExporter();
                    exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                    exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, xlsReport);
                    exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET,
                            Boolean.FALSE);
                    exporter.setParameter(JRXlsExporterParameter.IS_DETECT_CELL_TYPE,
                            Boolean.TRUE);
                    exporter.setParameter(JRXlsExporterParameter.IS_WHITE_PAGE_BACKGROUND,
                            Boolean.FALSE);
                    exporter.setParameter(JRXlsExporterParameter.IS_IGNORE_GRAPHICS,
                            Boolean.FALSE);
                    exporter.exportReport();
                    return xlsReport;
                }
            
                private FastReportBuilder createColumns(FastReportBuilder drb)
                        throws IOException, ColumnBuilderException, ClassNotFoundException {
                    fields = exportDao.getFields();
                    for (Field field : fields) {
                        drb = drb.addColumn(HTMLCleaner.getStringWithoutTags(field
                                .getDescription()), String.valueOf(field.getId()),
                                String.class, 100);
                    }
                    return drb;
                }
            
                public Log getLogger() {
                    return (Log) Component.getInstance(Log.class);
                }
            
                public String getFileName() {
                    return exportDao.getFormName() + "_" + new Date()
                            + ".xls";
                }
            
                public ExportDao getExportDao() {
                    return exportDao;
                }
            
            }