注册 登录
> 编程技术

使用jasperReport实现动态表头

系统 1616 0

最近在我公司drp(运营分销系统)开发中,需要大量报表,由于本人有过jasperReport的开发经验,所以选用了它,jr确实不错,开源,可扩展性很好,缺点就是免费的文档很少,更可气的是,代码中的doc少的可怜,基本上没有参考价值.

       由于我们的产品是用于服装行业的,在服装行业有一个尺码组,非常的麻烦,在制作含有尺码组的报表时,表头的各种尺码不能写死,要从数据库查询出来.但是,一般的报表工具都是不支持表头动态化的(我理解,报表嘛,是呈现给特定人物如老板看的特定内容,表头应该是设计好的,不会经常性的更改),jasperReport也是一样,并不直接支持,细究它的实现过程,我们还是可以扩展从而解决这个问题的.

      先看jasperReport的流程图.

           从上图可看到,jrxml文件要通过JRXmlLoader解析为一个JasperDesign的对象,从源码中可以看出,此对象用java类去描述了报表的整个设计,比如,columnHeader,detail,columnFooter等等.然后由JasperCompileManager编译为一个JasperReport对象,其实,如果你用ireport(jasperReport报表的可视化设计器)制作报表,你完全可以不必理会怎样生成jaserReport对象.ireport对此有很好的支持.

       了解了以上过程,我们可以看出,如果要动态的加入设计元素,只能在JasperDesign对象中下手.加入需要的动态元素,我的需求是在columnHeader中加入一个尺码组的表头,代码实现如下.

java 代码
  1. package  com.webstone.drp.report.common.dynamicHeader;   
  2.   
  3. import  java.io.File;   
  4. import  java.lang.reflect.InvocationTargetException;   
  5. import  java.util.Iterator;   
  6. import  org.apache.commons.beanutils.BeanUtils;   
  7. import  net.sf.jasperreports.engine.JRException;   
  8. import  net.sf.jasperreports.engine.JasperCompileManager;   
  9. import  net.sf.jasperreports.engine.JasperReport;   
  10. import  net.sf.jasperreports.engine.design.JRDesignBand;   
  11. import  net.sf.jasperreports.engine.design.JRDesignStaticText;   
  12. import  net.sf.jasperreports.engine.design.JasperDesign;   
  13. import  net.sf.jasperreports.engine.xml.JRXmlLoader;   
  14.   
  15. /**  
  16.  * @author yaer  
  17.  */   
  18. @SuppressWarnings ( "unchecked" )   
  19. public   class  ReportDesignProcess {   
  20.      private   static   final  String flagTextKey =  "customFlagText" ;   
  21.   
  22.      public   static  JasperReport getJasperReport(String xmlFilePath,   
  23.             String[][] sizeGroup)  throws  JRException {   
  24.         JasperDesign design = getJasperDesign(xmlFilePath);   
  25.         JRDesignBand columnHeader = (JRDesignBand) design.getColumnHeader();   
  26.   
  27.         reSetColumnHeaderHeight(columnHeader, sizeGroup);   
  28.         reSetshapeAndPosition(columnHeader, sizeGroup);   
  29.         addElementToColumnHeader(columnHeader, sizeGroup);   
  30.          return  JasperCompileManager.compileReport(design);   
  31.     }   
  32.      private   static  JasperDesign getJasperDesign(String filePath)   
  33.              throws  JRException {   
  34.          return  JRXmlLoader.load( new  File(filePath));   
  35.     }   
  36.      private   static   void  reSetColumnHeaderHeight(JRDesignBand columnHeader,   
  37.             String[][] sizeGroup) {   
  38.         columnHeader.setHeight(columnHeader.getHeight() * sizeGroup.length);   
  39.     }   
  40.      private   static  JRDesignStaticText getFlagTextInDesign(   
  41.             JRDesignBand columnHeader) {   
  42.          return  (JRDesignStaticText) columnHeader.getElementByKey(flagTextKey);   
  43.     }   
  44.      private   static   void  reSetshapeAndPosition(JRDesignBand columnHeader,   
  45.             String[][] sizeGroup) {   
  46.         JRDesignStaticText flagText = getFlagTextInDesign(columnHeader);   
  47.         Iterator<jrdesignstatictext></jrdesignstatictext> children = columnHeader.getChildren()   
  48.                 .iterator();   
  49.         JRDesignStaticText element;   
  50.          while  (children.hasNext()) {   
  51.             element = children.next();   
  52.              if  (element.getX() > flagText.getX()) {   
  53.                 element.setX(flagText.getX() + flagText.getWidth()   
  54.                         * sizeGroup[ 0 ].length);   
  55.             }   
  56.              if  (!flagTextKey.equals(element.getKey())) {   
  57.                 element.setHeight(element.getHeight() * sizeGroup.length);   
  58.             }   
  59.         }   
  60.     }   
  61.      private   static   void  addElementToColumnHeader(JRDesignBand columnHeader,   
  62.             String[][] sizeGroup) {   
  63.         JRDesignStaticText flagText = getFlagTextInDesign(columnHeader);   
  64.         columnHeader.removeElement(flagText);   
  65.          for  ( int  i =  0 ; i < sizeGroup.length; i++) {   
  66.              for  ( int  j =  0 ; j < sizeGroup[i].length; j++) {   
  67.                  try  {   
  68.                     JRDesignStaticText newElement = (JRDesignStaticText) BeanUtils   
  69.                             .cloneBean(flagText);   
  70.                     newElement.setText(sizeGroup[i][j]);   
  71.                     newElement.setX(flagText.getX() + flagText.getWidth() * j);   
  72.                     newElement.setY(flagText.getY() + flagText.getHeight() * i);   
  73.                     columnHeader.addElement(newElement);   
  74.                 }  catch  (IllegalAccessException e) {   
  75.                     e.printStackTrace();   
  76.                 }  catch  (InstantiationException e) {   
  77.                     e.printStackTrace();   
  78.                 }  catch  (InvocationTargetException e) {   
  79.                     e.printStackTrace();   
  80.                 }  catch  (NoSuchMethodException e) {   
  81.                     e.printStackTrace();   
  82.                 }   
  83.             }   
  84.         }   
  85.     }   
  86. }  

      很遗憾，没有写注解，原因是我看了一本书叫<<测试驱动开发>>,里面有一句话"意图导向编程",意思是说，用手段比如容易理解，贴切的类名，方法名，属性达到让读者轻易理解代码．从而少写注解，让代码更简捷．如果大家不大明白以上代码的意思，那就是我写的不够好，还要继续努力．

　　此类只有一个方法,根据传来的报表文件路径和一个二维数组式的尺码组生成一个jaserReport的对象.有三个关键方法.重新设置columnHeader的height;重新设置静态内容的形状和大小,添加新的元素到columnHeader中,其实，这儿有一个不太容易理的东西：类中有一个flagTextKey的属性，它是标识报表设计中动态内容的一个样板元素，为什么要这个样板元素了，因为用它承载动态内容的样式，要比在用代码实现方便的多．请看BeanUtils.coloneBean()方法,实际上是克隆样板元素对象．

        这个类设计的太具体于应用，应该写成一个抽象方法，让子类来具体实现加入动态元素的过程，我相信大家的需求和我不太一样．由于时间关系，我没有仔细考究．毕竟这只是一个参考实现．

　　最后，在用于ireport画报表时就要注意了，一呈不变的元素该怎么画就怎么画，但样板元素的位置一定要放好．动态内容起始的位置和样式就靠它来定义，大多数时候，它是一个标签．只不过它的"key"属性和上面类的"flagTextKey"要保持一致．

　　这个话题就到这儿了，我这儿还有一个我包装的工具类，我们公司的同事都认为对开发报表有帮助．

java 代码
  1. package  com.webstone.drp.report.common;   
  2.   
  3. import  java.util.ArrayList;   
  4. import  java.util.Collection;   
  5. import  java.util.HashMap;   
  6. import  java.util.Map;   
  7. import  javax.servlet.http.HttpServletRequest;   
  8. import  javax.servlet.http.HttpSession;   
  9. import  javax.faces.context.FacesContext;   
  10. import  org.apache.commons.lang.ArrayUtils;   
  11. import  com.webstone.drp.report.common.dataSource.JRArrayCollectionDataSource;   
  12. import  com.webstone.drp.report.common.dynamicHeader.ReportDesignProcess;   
  13. import  net.sf.jasperreports.engine.JRException;   
  14. import  net.sf.jasperreports.engine.JasperFillManager;   
  15. import  net.sf.jasperreports.engine.JasperPrint;   
  16. import  net.sf.jasperreports.engine.JasperReport;   
  17. import  net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;   
  18. import  net.sf.jasperreports.engine.JRDataSource;   
  19. import  net.sf.jasperreports.engine.util.JRLoader;   
  20.   
  21. /**  
  22.  * 使用jasperReport做报表时的工具支持类.有两个用途,生成jasperPrint对象,和设置导出时的session  
  23.  *   
  24.  * @author yaer  
  25.  * @date 2006-8-26   
  26.  * @modify date 2006-12-8  
  27.  */   
  28. public   class  ReportUtils {   
  29.      public   static   final  String XLS =  "xls" ; // 导出为xls文件;   
  30.      public   static   final  String PDF =  "pdf" ; // 导出为pdf文件;   
  31.      private   static   final  String JASPER =  "jasper" ; // 编译过后的报表文件;   
  32.      private   static   final  String JRXML =  "jrxml" ; // 原始的报表文件(xml格式);   
  33.      private  HttpServletRequest request;   
  34.      private  HttpSession session;   
  35.      private  String rootPath; // 报表文件路径   
  36.   
  37.      /**  
  38.      * 在jsf环境下时构造些工具类对象  
  39.      *   
  40.      * @param context  
  41.      *            jsf的上下文对象  
  42.      */   
  43.   
  44.      public  ReportUtils(FacesContext context) {   
  45.         request = (HttpServletRequest) context.getExternalContext()   
  46.                 .getRequest();   
  47.         session = (HttpSession) context.getExternalContext().getSession( true );   
  48.          this .createRootPath(request); // 生成报表文件的绝对路径   
  49.     }   
  50.      /**  
  51.      * 在其它web环境下构造此工具类对象  
  52.      *   
  53.      * @param req  
  54.      *            request请求对象  
  55.      */   
  56.      public  ReportUtils(HttpServletRequest req) {   
  57.          this .request = req;   
  58.          this .session = req.getSession();   
  59.          this .createRootPath(request); // 生成报表文件的绝对路径   
  60.     }   
  61.      /**  
  62.      * 获得报表文件的绝对路径  
  63.      *   
  64.      * @return rootPath  
  65.      */   
  66.      public  String getRootPath() {   
  67.          return  rootPath;   
  68.     }   
  69.      /**  
  70.      * 获得JasperPrint对象; jasperPrint对象在jasperReport中是填充了报表数据后的一个实体,打印,导出,显示都要使用它.  
  71.      * 此方法含有java5.0支持的'可变参数'特性.params其实质是一个对象数组.在调用些方法时要注意它可能的参数顺序.  
  72.      * 此方法参数描述:  
  73.      * 1、最多只有四个参数。  
  74.      * 2、固定参数filePath表示报表文件的路径,为了支持drp系统中动态尺码组做表头的特性, filePath包括两类:  
  75.      *    编译过后的文件扩展名为'.jasper'和未编译的原始xml文件'.jrxml';  
  76.      *    若报表中有动态尺码组作表头，则filePath为扩展名是'.jrxml'的文件。  
  77.      *    若报表中不涉及动态尺码组,则filePath为扩展名是'.jasper'的文件。  
  78.      * 3、可变参数params的完整列表是(注意顺序):Object obj/Collection dataSource,String seprator,String[][] sizeGroup.  
  79.      *    这三个参数中,有一个例外,Object obj/Collection dataSource必须有一个，此参数表示填充报表的数据,可以是一个Collection式的集合,  
  80.      *    也可以是一个model对象(有且只有一个Collection的属性);  
  81.      *    String seprator表示分隔符,如果数据源是一个Array的集合,则需此参数。String[][]sizeGroup表款尺码组的二维数组。  
  82.      *   
  83.      * @param filePath  
  84.      * @param params  
  85.      * @return jasperPrint  
  86.      */   
  87.      public  JasperPrint getJasperPrint(String filePath, Object... params) {   
  88.         JasperReport jasperReport =  null ;   
  89.          try  {   
  90.              if  (JASPER.equals(filePath.substring(filePath.indexOf( "." ) +  1 ,   
  91.                     filePath.length()))) { // jasper式文件的处理   
  92.                 jasperReport = getReportTemplate(filePath);   
  93.             }   
  94.              if  (JRXML.equals(filePath.substring(filePath.indexOf( "." ) +  1 ,   
  95.                     filePath.length()))) { // jrxml式文件的处理   
  96.                 jasperReport = ReportDesignProcess.getJasperReport(filePath,   
  97.                         (String[][]) params[params.length -  1 ]); // 重新设置表头,编译   
  98.                 params = ArrayUtils.remove(params, params.length -  1 ); // 删除参数中的sizeGroup   
  99.             }   
  100.              return  fillReport(jasperReport, params);   
  101.         }  catch  (JRException e) {   
  102.             e.printStackTrace();   
  103.         }   
  104.          return   null ;   
  105.     }   
  106.      /**  
  107.      * 获得JasperPrint对象;自定义填充报表时的parameter和dataSource. 参数说明和动态表头的用法参考上一方法  
  108.      * @param filePath  
  109.      * @param parameter  
  110.      * @param dataSource  
  111.      * @param sizeGroup  
  112.      * @return  
  113.      */   
  114.      public  JasperPrint getJasperPrint(String filePath, Map parameter,   
  115.             JRDataSource dataSource, Object... sizeGroup) {   
  116.         JasperReport jasperReport =  null ;   
  117.          try  {   
  118.              if  (sizeGroup.length ==  0 ) {   
  119.                 jasperReport = getReportTemplate(filePath);   
  120.             }   
  121.              if  (sizeGroup.length ==  1 ) {   
  122.                 jasperReport = ReportDesignProcess.getJasperReport(filePath,   
  123.                         (String[][]) sizeGroup[sizeGroup.length -  1 ]); // 重新设置表头,编译   
  124.             }   
  125.              return  JasperFillManager.fillReport(jasperReport, parameter,   
  126.                     dataSource);   
  127.         }  catch  (JRException e) {   
  128.             e.printStackTrace();   
  129.         }   
  130.          return   null ;   
  131.     }   
  132.      public   void  setAttrToPage(JasperPrint jasperPrint, String report_fileName,   
  133.             String report_type) {   
  134.         session.setAttribute( "REPORT_JASPERPRINT" , jasperPrint);   
  135.         session.setAttribute( "REPORT_FILENAME" , report_fileName);   
  136.         session.setAttribute( "REPORT_TYPE" , report_type);   
  137.     }   
  138.      private  JasperPrint fillReport(JasperReport jasperReport, Object[] params)   
  139.              throws  JRException {   
  140.         Map parameters =  null ;   
  141.         JRDataSource ds =  null ;   
  142.          if  (params.length ==  0 ) {   
  143.              return   null ;   
  144.         }   
  145.          if  (params.length ==  1  && params[ 0 ].getClass() == ArrayList. class ) { //其实质是要判断是否是集合   
  146.             ds =  new  JRBeanCollectionDataSource((Collection) params[ 0 ]);   
  147.         }   
  148.          if  (params.length ==  1  && params[ 0 ].getClass() != ArrayList. class ) {   
  149.             ClassAnalysis ca =  new  ClassAnalysis(params[ 0 ]);   
  150.             parameters = ca.getFields();   
  151.             ds =  new  JRBeanCollectionDataSource(ca.getSet());   
  152.         }   
  153.          if  (params.length ==  2  && params[ 0 ].getClass() == ArrayList. class ) {   
  154.             ds =  new  JRArrayCollectionDataSource((Collection) params[ 0 ],   
  155.                     params[ 1 ].toString());   
  156.         }   
  157.          if  (params.length ==  2  && params[ 0 ].getClass() != ArrayList. class ) {   
  158.             ClassAnalysis ca =  new  ClassAnalysis(params[ 0 ]);   
  159.             parameters = ca.getFields();   
  160.             ds =  new  JRArrayCollectionDataSource(ca.getSet(), params[ 1 ]   
  161.                     .toString());   
  162.         }   
  163.          return  JasperFillManager.fillReport(jasperReport,   
  164.                 parameters ==  null  ?  new  HashMap() : parameters, ds);   
  165.     }   
  166.      private   void  createRootPath(HttpServletRequest request) {   
  167.         rootPath = request.getSession().getServletContext().getRealPath( "/" )   
  168.                 +  "WEB-INF\\classes\\com\\webstone\\drp\\report\\jaser\\" ;   
  169.     }   
  170.      private  JasperReport getReportTemplate(String jasperPath)   
  171.              throws  JRException {   
  172.          return  (JasperReport) JRLoader.loadObject(rootPath + jasperPath);   
  173.     }   
  174. }   
　　　此类用于生成填充后报表对象jasperPrint.

使用jasperReport实现动态表头


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索：z360901061

微信扫一扫加我为好友

QQ号联系： 360901061

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧，狠狠点击下面给点支持吧，站长非常感激您！手机微信长按不能支付解决办法：请将微信支付二维码保存到相册，切换到微信，然后点击微信右上角扫一扫功能，选择支付二维码完成支付。

【本文对您有帮助就好】元

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧，站长会非常 感谢您的哦！！！

发表我的评论
最新评论 总共0条评论