自行导入poi3.9的jar包

  1. package com.cpic.caf.template.home.util;
  2. import java.io.BufferedOutputStream;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. import java.lang.reflect.Field;
  8. import java.lang.reflect.InvocationTargetException;
  9. import java.lang.reflect.Method;
  10. import java.text.SimpleDateFormat;
  11. import java.util.Collection;
  12. import java.util.Date;
  13. import java.util.Iterator;
  14. import java.util.List;
  15. import java.util.Map;
  16. import java.util.Set;
  17. import java.util.regex.Matcher;
  18. import java.util.regex.Pattern;
  20. import javax.servlet.http.HttpServletResponse;
  22. import org.apache.poi.hssf.usermodel.HSSFCell;
  23. import org.apache.poi.hssf.usermodel.HSSFCellStyle;
  24. import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
  25. import org.apache.poi.hssf.usermodel.HSSFComment;
  26. import org.apache.poi.hssf.usermodel.HSSFFont;
  27. import org.apache.poi.hssf.usermodel.HSSFPatriarch;
  28. import org.apache.poi.hssf.usermodel.HSSFRichTextString;
  29. import org.apache.poi.hssf.usermodel.HSSFRow;
  30. import org.apache.poi.hssf.usermodel.HSSFSheet;
  31. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  32. import org.apache.poi.hssf.util.HSSFColor;
  34. /**
  35.  * 
  36.  * @author librag
  37.  * @version v1.0
  38.  * @param <T>
  39.  *  应用泛型，代表任意一个符合javabean风格的类
  40.  *  注意这里为了简单起见，boolean型的属性xxx的get器方式为getXxx(),而不是isXxx()
  41.  *  byte[]表jpg格式的图片数据
  42.  */
  43. public class ExportExcel<T>{
  44. 	
  45. 	public static final String Map = "Map";
  46. 	public static final String List = "List";
  47. 	
  48. 	private  int List_Size = 0;
  49. 	
  50. /*	
  51. 	public ExportExcel(int List_Size) {
  52. 		this.List_Size = List_Size;
  53. 	}
  54. 	
  55. 	
  56. 	public ExportExcel() {
  57. 		
  58. 	}*/
  59. 	
  60. 	/**
  61.      * @param title
  62.      *            表格标题名
  63.      * @param headers
  64.      *            表格属性列名数组
  65.      * @param dataset 允许的类型(实体类,List<List<Object>>,List<Map<String,Object>>)
  66.      *            需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
  67.      *            javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
  68.      * @param out
  69.      *            与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
  70.      * @param pattern
  71.      *            如果有时间数据，设定输出格式。默认为"yyy-MM-dd"
  72.     
  73. 	Controller示例
  74. 	
  75. 	
  76. 			//引用浏览器引擎下载
  77. 			//使用本工具类创建对象
  78. 	 		ExportExcel<对象> ex = new ExportExcel<对象>();
  79. 	        
  80. 	        //创建列
  81. 	        String[] headers =
  82. 	        { "主键", "从业者ID", "案例是作品集还是婚礼案例", "案例类型", "标题","案例地址","描述","置顶","删除状态","访问量","收藏量"};
  83. 	        
  84. 	        //创建值列
  85. 	    	List<对象> dataset = Service.方法名();
  86. 	    	
  87. 	    	//调用工具类对象
  88.             ex.exportExcel(headers,dataset,response);
  89.            
  90.             //提示
  91.             System.out.println("excel导出成功！");
  92.             
  93.             
  94.     Controller示例2
  95. 	
  96. 	
  97. 	
  98. 			//直接下载到本地磁盘
  99. 			//使用本工具类创建对象
  100. 	 		ExportExcel<Map<String, Object>> ex = new ExportExcel<对象>();
  101. 	        
  102. 	        //创建列
  103. 	        String[] headers =
  104. 	        { "主键", "从业者ID", "案例是作品集还是婚礼案例", "案例类型", "标题","案例地址","描述","置顶","删除状态","访问量","收藏量"};
  105. 	        
  106. 	         //创建值列
  107. 	    	List<Map<String, Object>> dataset = Service.方法名();
  108. 	    	
  109. 	    	//调用工具类对象
  110.             ex.exportExcel(headers,dataset,"E:\\文件夹名\\文件夹名");
  111.            
  112.             //提示
  113.             System.out.println("excel导出成功！");
  114.         
  115.         
  116.         
  117.         
  118.      */
  119. 	
  120. 	
  121. 	
  122. 	/**
  123. 	 * 方法重载同时指向一个unchecked
  124. 	 * @param dataset Value列
  125. 	 * @param response 必须
  126. 	 * @param path  (当传入指定path时 方法会使用IO流下载到指定地址(文件夹) || 反之 会引用浏览器的下载引擎)
  127. 	 */
  128.     public void exportExcel(Collection<T> dataset,String path){
  129.         exportExcel("EXCEL文档", null, dataset, "yyyy-MM-dd",path);
  130.     }
  131.     public void exportExcel(String[] headers, Collection<T> dataset,String path) {
  132.         exportExcel("EXCEL文档", headers, dataset, "yyyy-MM-dd",path);
  133.     }
  134.     public void exportExcel(String[] headers, Collection<T> dataset, String pattern,String path){
  135.         exportExcel("EXCEL文档", headers, dataset, pattern,path);
  136.     }
  137.     public void exportExcel(Collection<T> dataset,HttpServletResponse response){
  138.         exportExcel("EXCEL文档", null, dataset, "yyyy-MM-dd",response);
  139.     }
  140.     public void exportExcel(String[] headers, Collection<T> dataset,HttpServletResponse response) {
  141.         exportExcel("EXCEL文档", headers, dataset, "yyyy-MM-dd",response);
  142.     }
  143.     public void exportExcel(String[] headers, Collection<T> dataset, String pattern,HttpServletResponse response){
  144.         exportExcel("EXCEL文档", headers, dataset, pattern,response);
  145.     }
  146.     
  147.     public void exportExcel(String[] headers, List<List<Object>> dataset,HttpServletResponse response) {
  148.         exportExcel("EXCEL文档", headers, dataset, "yyyy-MM-dd",response);
  149.     }
  150.     
  151.     public void MapExportExcel(String[] headers, List<Map<String, Object>> dataset,HttpServletResponse response) {
  152.         exportExcel("EXCEL文档", headers, dataset, "yyyy-MM-dd",response,"Map");
  153.     }
  154.     
  156.     /**
  157.      * 这是一个通用的方法，利用了JAVA的反射机制，可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
  158.      * 
  159.      * @param title 表格标题名
  160.      * @param headers 表格属性列名数组
  161.      * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
  162.      * javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
  163.      * @param pattern 如果有时间数据，设定输出格式。默认为"yyy-MM-dd"
  164.      */
  165.     @SuppressWarnings("unchecked")
  166.     public void exportExcel(String title, String[] headers,Collection<T> dataset, String pattern,String path){
  167.     	
  168.     	
  169.         // 声明一个工作薄
  170.         HSSFWorkbook workbook = new HSSFWorkbook();
  171.         // 生成一个表格
  172.         HSSFSheet sheet = workbook.createSheet(title);
  173.         // 设置表格默认列宽度为15个字节
  174.         sheet.setDefaultColumnWidth((short) 15);
  175.         // 生成一个样式
  176.         HSSFCellStyle style = workbook.createCellStyle();
  177.         // 设置这些样式
  178.         style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
  179.         style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  180.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  181.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  182.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  183.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  184.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  185.         // 生成一个字体
  186.         HSSFFont font = workbook.createFont();
  187.         font.setColor(HSSFColor.VIOLET.index);
  188.         font.setFontHeightInPoints((short) 12);
  189.         font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
  190.         // 把字体应用到当前的样式
  191.         style.setFont(font);
  192.         // 生成并设置另一个样式
  193.         HSSFCellStyle style2 = workbook.createCellStyle();
  194.         style2.setFillForegroundColor(HSSFColor.LIGHT_YELLOW.index);
  195.         style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  196.         style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  197.         style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  198.         style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
  199.         style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
  200.         style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  201.         style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  202.         // 生成另一个字体
  203.         HSSFFont font2 = workbook.createFont();
  204.         font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  205.         // 把字体应用到当前的样式
  206.         style2.setFont(font2);
  208.         // 声明一个画图的顶级管理器
  209.         HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
  210.         // 定义注释的大小和位置,详见文档
  211.         HSSFComment comment = patriarch.createComment(new HSSFClientAnchor(0,
  212.                 0, 0, 0, (short) 4, 2, (short) 6, 5));
  213.         // 设置注释内容
  214.         comment.setString(new HSSFRichTextString("可以在POI中添加注释！"));
  215.         // 设置注释作者，当鼠标移动到单元格上是可以在状态栏中看到该内容.
  216.         comment.setAuthor("leno");
  218.         // 产生表格标题行
  219.         HSSFRow row = sheet.createRow(0);
  220.         for (short i = 0; i < headers.length; i++)
  221.         {
  222.             HSSFCell cell = row.createCell(i);
  223.             cell.setCellStyle(style);
  224.             HSSFRichTextString text = new HSSFRichTextString(headers[i]);
  225.             cell.setCellValue(text);
  226.         }
  227.         
  228.         
  229.         try
  230.         {
  231.         
  233. 	        // 遍历集合数据，产生数据行
  234. 	        Iterator<T> it = dataset.iterator();
  235. 	        int index = 0;
  236. 	        while (it.hasNext())
  237. 	        {
  238. 	            index++;
  239. 	            row = sheet.createRow(index);
  240. 	            T t = (T) it.next();
  241. 	            // 利用反射，根据javabean属性的先后顺序，动态调用getXxx()方法得到属性值
  242. 	            Field[] fields = t.getClass().getDeclaredFields();
  243. 	            for (short i = 0; i < fields.length; i++)
  244. 	            {
  245. 	                HSSFCell cell = row.createCell(i);
  246. 	                cell.setCellStyle(style2);
  247. 	                Field field = fields[i];
  248. 	                String fieldName = field.getName();
  249. 	                String getMethodName = "get"
  250. 	                        + fieldName.substring(0, 1).toUpperCase()
  251. 	                        + fieldName.substring(1);
  252. 	              
  253. 	                    Class tCls = t.getClass();
  254. 	                    Method getMethod = tCls.getMethod(getMethodName,
  255. 	                            new Class[]
  256. 	                            {});
  257. 	                    Object value = getMethod.invoke(t, new Object[]
  258. 	                    {});
  259. 	                    // 判断值的类型后进行强制类型转换
  260. 	                    String textValue = null;
  261. 	               /*      if (value instanceof Integer) {
  262. 	                     int intValue = (Integer) value;
  263. 	                     cell.setCellValue(intValue);
  264. 	                     } else if (value instanceof Float) {
  265. 	                     float fValue = (Float) value;
  266. 	                     textValue = new HSSFRichTextString(
  267. 	                     String.valueOf(fValue));
  268. 	                     cell.setCellValue(textValue);
  269. 	                     } else if (value instanceof Double) {
  270. 	                     double dValue = (Double) value;
  271. 	                     textValue = new HSSFRichTextString(
  272. 	                     String.valueOf(dValue));
  273. 	                     cell.setCellValue(textValue);
  274. 	                     } else if (value instanceof Long) {
  275. 	                     long longValue = (Long) value;
  276. 	                     cell.setCellValue(longValue);
  277. 	                     }*/
  278. 	                    if (value instanceof Boolean)
  279. 	                    {
  280. 	                        boolean bValue = (Boolean) value;
  281. 	                        textValue = "男";
  282. 	                        if (!bValue)
  283. 	                        {
  284. 	                            textValue = "女";
  285. 	                        }
  286. 	                    }
  287. 	                    else if (value instanceof Date)
  288. 	                    {
  289. 	                        Date date = (Date) value;
  290. 	                        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  291. 	                        textValue = sdf.format(date);
  292. 	                    }
  293. 	                    else if (value instanceof byte[])
  294. 	                    {
  295. 	                        // 有图片时，设置行高为60px;
  296. 	                        row.setHeightInPoints(60);
  297. 	                        // 设置图片所在列宽度为80px,注意这里单位的一个换算
  298. 	                        sheet.setColumnWidth(i, (short) (35.7 * 80));
  299. 	                        // sheet.autoSizeColumn(i);
  300. 	                        byte[] bsValue = (byte[]) value;
  301. 	                        HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0,
  302. 	                                1023, 255, (short) 6, index, (short) 6, index);
  303. 	                        anchor.setAnchorType(2);
  304. 	                        patriarch.createPicture(anchor, workbook.addPicture(
  305. 	                                bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
  306. 	                    }
  307. 	                    else
  308. 	                    {
  309. 	                        // 其它数据类型都当作字符串简单处理
  310. 	                        textValue = value.toString();
  311. 	                    }
  312. 	                    // 如果不是图片数据，就利用正则表达式判断textValue是否全部由数字组成
  313. 	                    if (textValue != null)
  314. 	                    {
  315. 	                        Pattern p = Pattern.compile("^//d+(//.//d+)?$");
  316. 	                        Matcher matcher = p.matcher(textValue);
  317. 	                        if (matcher.matches())
  318. 	                        {
  319. 	                            // 是数字当作double处理
  320. 	                            cell.setCellValue(Double.parseDouble(textValue));
  321. 	                        }
  322. 	                        else
  323. 	                        {
  324. 	                            HSSFRichTextString richString = new HSSFRichTextString(
  325. 	                                    textValue);
  326. 	                            HSSFFont font3 = workbook.createFont();
  327. 	                            font3.setColor(HSSFColor.BLUE.index);
  328. 	                            richString.applyFont(font3);
  329. 	                            cell.setCellValue(richString);
  330. 	                        }
  331. 	                    }
  332. 	               
  333. 	            }
  334. 	        }
  335.         
  336.         }catch (SecurityException e){
  337.             e.printStackTrace();
  338.         }catch (NoSuchMethodException e){
  339.             e.printStackTrace();
  340.         }catch (IllegalArgumentException e){
  341.             e.printStackTrace();
  342.         }catch (IllegalAccessException e){
  343.             e.printStackTrace();
  344.         }catch (InvocationTargetException e){
  345.             e.printStackTrace();
  346.         }finally{
  347.             // 清理资源
  348.         }
  349.         
  350.         //生成文件流
  351.         IOExcle(workbook,path);
  352.     	
  353.     }
  354.     
  355.     
  356.     
  357.     
  358.     /**
  359.      * (网络传输)
  360.      * 这是一个通用的方法，利用了JAVA的反射机制，可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
  361.      * @param title 表格标题名
  362.      * @param headers 表格属性列名数组
  363.      * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
  364.      * javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
  365.      * @param pattern 如果有时间数据，设定输出格式。默认为"yyy-MM-dd"
  366.      */
  367.     @SuppressWarnings("unchecked")
  368.     public void exportExcel(String title, String[] headers,Collection<T> dataset, String pattern,HttpServletResponse response){
  369.     	
  370.     	response.reset(); // 清除buffer缓存
  371.         // 指定下载的文件名
  372.         response.setHeader("Content-Disposition", "attachment;filename=contacts" + getDateTimeName() + ".xls");
  373.         response.setContentType("application/vnd.ms-excel;charset=UTF-8");
  374.         response.setHeader("Pragma", "no-cache");
  375.         response.setHeader("Cache-Control", "no-cache");
  376.         response.setDateHeader("Expires", 0);
  377.     	
  378.         // 声明一个工作薄
  379.         HSSFWorkbook workbook = new HSSFWorkbook();
  380.         // 生成一个表格
  381.         HSSFSheet sheet = workbook.createSheet(title);
  382.         // 设置表格默认列宽度为15个字节
  383.         sheet.setDefaultColumnWidth((short) 15);
  384.         // 生成一个样式
  385.         HSSFCellStyle style = workbook.createCellStyle();
  386.         // 设置这些样式
  387.         style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
  388.         style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  389.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  390.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  391.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  392.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  393.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  394.         // 生成一个字体
  395.         HSSFFont font = workbook.createFont();
  396.         font.setColor(HSSFColor.VIOLET.index);
  397.         font.setFontHeightInPoints((short) 12);
  398.         font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
  399.         // 把字体应用到当前的样式
  400.         style.setFont(font);
  401.         // 生成并设置另一个样式
  402.         HSSFCellStyle style2 = workbook.createCellStyle();
  403.         style2.setFillForegroundColor(HSSFColor.LIGHT_YELLOW.index);
  404.         style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  405.         style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  406.         style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  407.         style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
  408.         style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
  409.         style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  410.         style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  411.         // 生成另一个字体
  412.         HSSFFont font2 = workbook.createFont();
  413.         font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  414.         // 把字体应用到当前的样式
  415.         style2.setFont(font2);
  417.         // 声明一个画图的顶级管理器
  418.         HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
  419.         // 定义注释的大小和位置,详见文档
  420.         HSSFComment comment = patriarch.createComment(new HSSFClientAnchor(0,
  421.                 0, 0, 0, (short) 4, 2, (short) 6, 5));
  422.         // 设置注释内容
  423.         comment.setString(new HSSFRichTextString("可以在POI中添加注释！"));
  424.         // 设置注释作者，当鼠标移动到单元格上是可以在状态栏中看到该内容.
  425.         comment.setAuthor("leno");
  427.         
  428.         // 产生表格标题行
  429.         HSSFRow row = sheet.createRow(0);
  430.         for (short i = 0; i < headers.length; i++)
  431.         {
  432.             HSSFCell cell = row.createCell(i);
  433.             cell.setCellStyle(style);
  434.             HSSFRichTextString text = new HSSFRichTextString(headers[i]);
  435.             cell.setCellValue(text);
  436.         }
  438.         
  439.         try
  440.         {
  441. 	        // 遍历集合数据，产生数据行
  442. 	        Iterator<T> it = dataset.iterator();
  443. 	        int index = 0;
  444. 	        
  445. 	        while (it.hasNext()){
  446. 	        	
  447. 	            index++;
  448. 	            row = sheet.createRow(index);
  449. 	            T t = (T) it.next();
  450. 	            // 利用反射，根据javabean属性的先后顺序，动态调用getXxx()方法得到属性值
  451. 	            Field[] fields = t.getClass().getDeclaredFields();
  452. 	            for (short i = 0; i < fields.length; i++)
  453. 	            {
  454. 	                HSSFCell cell = row.createCell(i);
  455. 	                cell.setCellStyle(style2);
  456. 	                Field field = fields[i];
  457. 	                String fieldName = field.getName();
  458. 	                String getMethodName = "get"
  459. 	                        + fieldName.substring(0, 1).toUpperCase()
  460. 	                        + fieldName.substring(1);
  461. 	               
  462. 	                    Class tCls = t.getClass();
  463. 	                    Method getMethod = tCls.getMethod(getMethodName,
  464. 	                            new Class[]
  465. 	                            {});
  466. 	                    Object value = getMethod.invoke(t, new Object[]
  467. 	                    {});
  468. 	                    // 判断值的类型后进行强制类型转换
  469. 	                    String textValue = null;
  470. 	
  471. 	                    if (value instanceof Boolean)
  472. 	                    {
  473. 	                        boolean bValue = (Boolean) value;
  474. 	                        textValue = "男";
  475. 	                        if (!bValue)
  476. 	                        {
  477. 	                            textValue = "女";
  478. 	                        }
  479. 	                    }
  480. 	                    else if (value instanceof Date)
  481. 	                    {
  482. 	                        Date date = (Date) value;
  483. 	                        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  484. 	                        textValue = sdf.format(date);
  485. 	                    }
  486. 	                    else if (value instanceof byte[])
  487. 	                    {
  488. 	                        // 有图片时，设置行高为60px;
  489. 	                        row.setHeightInPoints(60);
  490. 	                        // 设置图片所在列宽度为80px,注意这里单位的一个换算
  491. 	                        sheet.setColumnWidth(i, (short) (35.7 * 80));
  492. 	                        // sheet.autoSizeColumn(i);
  493. 	                        byte[] bsValue = (byte[]) value;
  494. 	                        HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0,
  495. 	                                1023, 255, (short) 6, index, (short) 6, index);
  496. 	                        anchor.setAnchorType(2);
  497. 	                        patriarch.createPicture(anchor, workbook.addPicture(
  498. 	                                bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
  499. 	                    }
  500. 	                    else
  501. 	                    {
  502. 	                        // 其它数据类型都当作字符串简单处理
  503. 	                        textValue = value.toString();
  504. 	                    }
  505. 	                    // 如果不是图片数据，就利用正则表达式判断textValue是否全部由数字组成
  506. 	                    if (textValue != null)
  507. 	                    {
  508. 	                        Pattern p = Pattern.compile("^//d+(//.//d+)?$");
  509. 	                        Matcher matcher = p.matcher(textValue);
  510. 	                        if (matcher.matches())
  511. 	                        {
  512. 	                            // 是数字当作double处理
  513. 	                            cell.setCellValue(Double.parseDouble(textValue));
  514. 	                        }
  515. 	                        else
  516. 	                        {
  517. 	                            HSSFRichTextString richString = new HSSFRichTextString(
  518. 	                                    textValue);
  519. 	                            HSSFFont font3 = workbook.createFont();
  520. 	                            font3.setColor(HSSFColor.BLUE.index);
  521. 	                            richString.applyFont(font3);
  522. 	                            cell.setCellValue(richString);
  523. 	                        }
  524. 	                    }
  525. 	               
  526. 	            }
  527. 	            
  528. 	            
  529. 	        }//while
  530.         
  531.         
  532.         }catch (SecurityException e){
  533.             e.printStackTrace();
  534.         }catch (NoSuchMethodException e){
  535.             e.printStackTrace();
  536.         }catch(IllegalArgumentException e) {
  537.             e.printStackTrace();
  538.         }catch (IllegalAccessException e){
  539.             e.printStackTrace();
  540.         }catch (InvocationTargetException e){
  541.             e.printStackTrace();
  542.         }finally{
  543.             // 清理资源
  544.         }
  545.         
  546.         
  547.         
  548.         //生成文件流
  549.         HTTPExcle(workbook,response);
  550.        
  551.     }
  552.     
  553.     
  554.     
  555.     
  556.     
  557.     
  558.     
  560.     /**
  561.      * (网络传输)集合
  562.      * 这是一个通用的方法，利用了JAVA的反射机制，可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
  563.      * @param title 表格标题名
  564.      * @param headers 表格属性列名数组
  565.      * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
  566.      * javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
  567.      * @param pattern 如果有时间数据，设定输出格式。默认为"yyy-MM-dd"
  568.      */
  569.     @SuppressWarnings("unchecked")
  570.     public void exportExcel(String title, String[] headers,List<List<Object>> dataset, String pattern,HttpServletResponse response){
  571.     	
  572.     	response.reset(); // 清除buffer缓存
  573.         // 指定下载的文件名
  574.         response.setHeader("Content-Disposition", "attachment;filename=contacts" + getDateTimeName() + ".xls");
  575.         response.setContentType("application/vnd.ms-excel;charset=UTF-8");
  576.         response.setHeader("Pragma", "no-cache");
  577.         response.setHeader("Cache-Control", "no-cache");
  578.         response.setDateHeader("Expires", 0);
  579.     	
  580.         // 声明一个工作薄
  581.         HSSFWorkbook workbook = new HSSFWorkbook();
  582.         // 生成一个表格
  583.         HSSFSheet sheet = workbook.createSheet(title);
  584.         // 设置表格默认列宽度为15个字节
  585.         sheet.setDefaultColumnWidth((short) 15);
  586.         // 生成一个样式
  587.         HSSFCellStyle style = workbook.createCellStyle();
  588.         // 设置这些样式
  589.         style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
  590.         style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  591.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  592.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  593.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  594.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  595.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  596.         // 生成一个字体
  597.         HSSFFont font = workbook.createFont();
  598.         font.setColor(HSSFColor.VIOLET.index);
  599.         font.setFontHeightInPoints((short) 12);
  600.         font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
  601.         // 把字体应用到当前的样式
  602.         style.setFont(font);
  603.         // 生成并设置另一个样式
  604.         HSSFCellStyle style2 = workbook.createCellStyle();
  605.         style2.setFillForegroundColor(HSSFColor.LIGHT_YELLOW.index);
  606.         style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  607.         style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  608.         style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  609.         style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
  610.         style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
  611.         style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  612.         style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  613.         // 生成另一个字体
  614.         HSSFFont font2 = workbook.createFont();
  615.         font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  616.         // 把字体应用到当前的样式
  617.         style2.setFont(font2);
  619.         // 声明一个画图的顶级管理器
  620.         HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
  621.         // 定义注释的大小和位置,详见文档
  622.         HSSFComment comment = patriarch.createComment(new HSSFClientAnchor(0,
  623.                 0, 0, 0, (short) 4, 2, (short) 6, 5));
  624.         // 设置注释内容
  625.         comment.setString(new HSSFRichTextString("可以在POI中添加注释！"));
  626.         // 设置注释作者，当鼠标移动到单元格上是可以在状态栏中看到该内容.
  627.         comment.setAuthor("leno");
  629.         
  630.         // 产生表格标题行
  631.         HSSFRow row = sheet.createRow(0);
  632.         for (short i = 0; i < headers.length; i++)
  633.         {
  634.             HSSFCell cell = row.createCell(i);
  635.             cell.setCellStyle(style);
  636.             HSSFRichTextString text = new HSSFRichTextString(headers[i]);
  637.             cell.setCellValue(text);
  638.         }
  640.         
  641.         
  642.         try {
  643.     	  
  644. 	    	for (int i = 0; i < dataset.size(); i++) {
  645. 	    		//创建外层集合行
  646. 	    		HSSFRow createRow = sheet.createRow(i+1);
  647. 	    		for (int j = 0; j < dataset.get(i).size(); j++) {
  648. 	    			createRow.createCell(j).setCellValue(dataset.get(i).get(j).toString());;
  649. 				}
  650. 			}
  651. 	    	
  652.         }catch (Exception e){
  653.             e.printStackTrace();
  654.         }finally{
  655.             // 清理资源
  656.         }
  657.         
  658.         
  659.         
  660.         //生成文件流
  661.         HTTPExcle(workbook,response);
  662.        
  663.     }
  664.     
  665.     
  666.     
  667.     
  668.     /**
  669.      * (网络传输)集合Map
  670.      * 这是一个通用的方法，利用了JAVA的反射机制，可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
  671.      * @param title 表格标题名
  672.      * @param headers 表格属性列名数组
  673.      * @param dataset 需要显示的数据集合,集合中一定要放置符合javabean风格的类的对象。此方法支持的
  674.      * javabean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
  675.      * @param pattern 如果有时间数据，设定输出格式。默认为"yyy-MM-dd"
  676.      */
  677.     @SuppressWarnings("unchecked")
  678.     public void exportExcel(String title, String[] headers,List<Map<String, Object>> dataset, String pattern,HttpServletResponse response,String name){
  679.     	
  680.     	response.reset(); // 清除buffer缓存
  681.         // 指定下载的文件名
  682.         response.setHeader("Content-Disposition", "attachment;filename=contacts" + getDateTimeName() + ".xls");
  683.         response.setContentType("application/vnd.ms-excel;charset=UTF-8");
  684.         response.setHeader("Pragma", "no-cache");
  685.         response.setHeader("Cache-Control", "no-cache");
  686.         response.setDateHeader("Expires", 0);
  687.     	
  688.         // 声明一个工作薄
  689.         HSSFWorkbook workbook = new HSSFWorkbook();
  690.         // 生成一个表格
  691.         HSSFSheet sheet = workbook.createSheet(title);
  692.         // 设置表格默认列宽度为15个字节
  693.         sheet.setDefaultColumnWidth((short) 15);
  694.         // 生成一个样式
  695.         HSSFCellStyle style = workbook.createCellStyle();
  696.         // 设置这些样式
  697.         style.setFillForegroundColor(HSSFColor.SKY_BLUE.index);
  698.         style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  699.         style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  700.         style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  701.         style.setBorderRight(HSSFCellStyle.BORDER_THIN);
  702.         style.setBorderTop(HSSFCellStyle.BORDER_THIN);
  703.         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  704.         // 生成一个字体
  705.         HSSFFont font = workbook.createFont();
  706.         font.setColor(HSSFColor.VIOLET.index);
  707.         font.setFontHeightInPoints((short) 12);
  708.         font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
  709.         // 把字体应用到当前的样式
  710.         style.setFont(font);
  711.         // 生成并设置另一个样式
  712.         HSSFCellStyle style2 = workbook.createCellStyle();
  713.         style2.setFillForegroundColor(HSSFColor.LIGHT_YELLOW.index);
  714.         style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
  715.         style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
  716.         style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
  717.         style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
  718.         style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
  719.         style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  720.         style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  721.         // 生成另一个字体
  722.         HSSFFont font2 = workbook.createFont();
  723.         font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
  724.         // 把字体应用到当前的样式
  725.         style2.setFont(font2);
  727.         // 声明一个画图的顶级管理器
  728.         HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
  729.         // 定义注释的大小和位置,详见文档
  730.         HSSFComment comment = patriarch.createComment(new HSSFClientAnchor(0,
  731.                 0, 0, 0, (short) 4, 2, (short) 6, 5));
  732.         // 设置注释内容
  733.         comment.setString(new HSSFRichTextString("可以在POI中添加注释！"));
  734.         // 设置注释作者，当鼠标移动到单元格上是可以在状态栏中看到该内容.
  735.         comment.setAuthor("leno");
  737.         
  738.         // 产生表格标题行
  739.         HSSFRow row = sheet.createRow(0);
  740.         for (short i = 0; i < headers.length; i++)
  741.         {
  742.             HSSFCell cell = row.createCell(i);
  743.             cell.setCellStyle(style);
  744.             HSSFRichTextString text = new HSSFRichTextString(headers[i]);
  745.             cell.setCellValue(text);
  746.         }
  748.         
  749.         
  750.         try {
  751.         	dataset = nullToEmpty(dataset);
  752. 	    	for (int i = 0; i < dataset.size(); i++) {
  753. 	    		//创建外层集合行
  754. 	    		HSSFRow createRow = sheet.createRow((i+1));
  755. 	    		 //第一種  
  756. 	            Set<String> set = dataset.get(i).keySet(); //取出所有的key值
  757. 	            Iterator<String> it = set.iterator();
  758. 	            
  759. 	            int j = 0;
  760. 	            while(it.hasNext()) {
  761. 	            /*	String str = null;
  762. 	            	if(it.next()!=null&&dataset.get(i)!=null&&dataset.get(i).get(it.next())!=null) {
  763. 	            		System.out.println("----------------------------");
  764. 	            		System.out.println(it.next());
  765. 	            		System.out.println(dataset.get(i).get(it.next()));
  766. 	            		str = dataset.get(i).get(it.next()).toString();
  767. 	            		
  768. 	            		
  769. 	            	}*/
  770. 	            	Object value = dataset.get(i).get(it.next());
  771. 	            	String textValue = null;
  772. 	            	if (value instanceof Boolean){
  773.                         boolean bValue = (Boolean) value;
  774.                         textValue = "男";
  775.                         if (!bValue)
  776.                         {
  777.                             textValue = "女";
  778.                         }
  779.                     }else if (value instanceof Date){
  780.                         Date date = (Date) value;
  781.                         SimpleDateFormat sdf = new SimpleDateFormat(pattern);
  782.                         textValue = sdf.format(date);
  783.                     }else if (value instanceof byte[]){
  784.                         // 有图片时，设置行高为60px;
  785.                         row.setHeightInPoints(60);
  786.                         // 设置图片所在列宽度为80px,注意这里单位的一个换算
  787.                         sheet.setColumnWidth(i, (short) (35.7 * 80));
  788.                         // sheet.autoSizeColumn(i);
  789.                         byte[] bsValue = (byte[]) value;
  790.                         HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0,
  791.                                 1023, 255, (short) 6, (i+1), (short) 6, (i+1));
  792.                         anchor.setAnchorType(2);
  793.                         patriarch.createPicture(anchor, workbook.addPicture(
  794.                                 bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
  795.                     }else{
  796.                         // 其它数据类型都当作字符串简单处理
  797.                         textValue = value.toString();
  798.                     }
  799. 	            	
  800. 	            	
  801. 	            	/*if(str!=null) {
  802. 	            		
  803. 	            	}else {
  804. 	            		createRow.createCell(j).setCellValue("");//取出元素
  805. 	            	}
  806. 	            	*/
  807. 	            	
  808. 	            	 // 如果不是图片数据，就利用正则表达式判断textValue是否全部由数字组成
  809.                     if (textValue != null)
  810.                     {
  811.                         Pattern p = Pattern.compile("^//d+(//.//d+)?$");
  812.                         Matcher matcher = p.matcher(textValue);
  813.                         if (matcher.matches())
  814.                         {
  815.                             // 是数字当作double处理
  816.                             createRow.createCell(j).setCellValue(Double.parseDouble(textValue));//取出元素
  817.                         }
  818.                         else
  819.                         {
  820.                             HSSFRichTextString richString = new HSSFRichTextString(
  821.                                     textValue);
  822.                             HSSFFont font3 = workbook.createFont();
  823.                             font3.setColor(HSSFColor.BLACK.index);
  824.                             richString.applyFont(font3);
  825.                             createRow.createCell(j).setCellValue(richString);
  826.                         }
  827.                     }
  828. 	            	
  829. 	            	
  830. 	            	
  831. 	            	j++;
  832. 	            }//判断是否有下一个
  833. 			}
  834. 	    	
  835.         }catch (Exception e){
  836.             e.printStackTrace();
  837.         }finally{
  838.             // 清理资源
  839.         }
  840.         
  841.         
  842.         
  843.         //生成文件流
  844.         HTTPExcle(workbook,response);
  845.        
  846.     }
  847.     
  848.     
  849.     
  850.     
  851.     /************************************************************(工具方法)***************************************************************/
  852.     
  853.     
  854.     
  855.     public static void IOExcle(HSSFWorkbook workbook,String path) {
  856.     	
  857.     	OutputStream out = null;
  858. 		try {
  859. 			out = new FileOutputStream(path.replaceAll("\\\\", "/")+getDateTimeName()+".xls");
  860. 			 workbook.write(out);
  861. 		} catch (FileNotFoundException e) {
  862. 			// TODO Auto-generated catch block
  863. 			e.printStackTrace();
  864. 		} catch (IOException e) {
  865. 			// TODO Auto-generated catch block
  866. 			e.printStackTrace();
  867. 		}finally{
  868. 			 try {
  869. 				out.close();
  870. 			} catch (IOException e) {
  871. 				// TODO Auto-generated catch block
  872. 				e.printStackTrace();
  873. 			}
  874. 		};
  875.     	
  876.     }
  877.     
  878.     public static void HTTPExcle(HSSFWorkbook workbook,HttpServletResponse response) {
  879.     	
  880.     	 OutputStream output;
  881.          try {
  882.              output = response.getOutputStream();
  883.              BufferedOutputStream bufferedOutPut = new BufferedOutputStream(output);
  884.              bufferedOutPut.flush();
  885.              workbook.write(bufferedOutPut);
  886.              bufferedOutPut.close();
  887.          } catch (Exception e) {
  888.              e.printStackTrace();
  889.          }
  890.     	
  891.     }
  892.   
  893.     
  894.     
  895.     public static String  getDateTimeName() {
  896.     	SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
  897.     	String format = sdf.format(new Date());
  898.     	return format;
  899.     }
  902.     /** 
  903.     * <p>方法名：nullToEmpty</p>
  904.     * <p>功能描述：map的value如果是null处理成空字符串</p>
  905.     */
  906.     public static List<Map<String, Object>> nullToEmpty(List<Map<String, Object>> list) {
  907. 	    if(list !=null && !list.isEmpty()) {
  908. 		    for(Map<String, Object> map : list) {
  909. 			    Set<String> set = map.keySet();
  910. 				    if(set != null && !set.isEmpty()) {
  911. 					    for(String key : set) {
  912. 						    if(map.get(key) == null) {
  913. 						    	map.put(key, "");
  914. 						    }
  915. 					    }
  916. 				    }
  917. 			    }
  918. 		    }
  919. 	    return list;
  920.     }
  921.     
  922.     
  923. }
  1. package com.cpic.caf.template.home.controller;
  3. import java.io.BufferedOutputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.OutputStream;
  8. import java.io.UnsupportedEncodingException;
  9. import java.math.BigInteger;
  10. import java.net.URLDecoder;
  11. import java.util.Date;
  12. import java.util.HashMap;
  13. import java.util.List;
  14. import java.util.Map;
  15. import java.util.Set;
  17. import javax.servlet.http.HttpServletRequest;
  18. import javax.servlet.http.HttpServletResponse;
  19. import javax.servlet.http.HttpSession;
  21. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  22. import org.slf4j.Logger;
  23. import org.slf4j.LoggerFactory;
  24. import org.springframework.beans.factory.annotation.Autowired;
  25. import org.springframework.stereotype.Controller;
  26. import org.springframework.ui.Model;
  27. import org.springframework.web.bind.annotation.RequestMapping;
  28. import org.springframework.web.bind.annotation.RequestMethod;
  29. import org.springframework.web.bind.annotation.RequestParam;
  30. import org.springframework.web.bind.annotation.ResponseBody;
  32. import com.cpic.caf.template.home.business.ProtocolAppoint;
  33. import com.cpic.caf.template.home.entity.OrderEO;
  34. import com.cpic.caf.template.home.entity.ProtocolParam;
  35. import com.cpic.caf.template.home.service.OrderService;
  36. import com.cpic.caf.template.home.util.CommonFunction;
  37. import com.cpic.caf.template.home.util.ExportExcel;
  38. import com.cpic.caf.template.home.util.HomeSQLUtil;
  39. import com.cpic.caf.template.home.util.OrderDSQLUtil;
  40. import com.cpic.caf.workers.hall.entity.WorkUserEO;
  41. import com.cpic.caf.workers.hall.entity.WorkersCaseuserEO;
  42. import com.cpic.caf.workers.hall.service.OmnipotentSqlService;
  43. import com.cpic.caf.workers.hall.service.WorkersCaseuserService;
  45. /**
  46.  * 订单
  47.  *
  48.  * Title: 喜事码头 Description: 例子 Copyright: Copyright (c) 2018
  49.  * Company:河南意莱享网络科技有限公司
  50.  * 
  51.  * @author changshenghui
  52.  * @version 1.1
  53.  * @Date 2018年6月12日
  54.  */
  55. @Controller
  56. public class OrderController {
  58. 	Logger logger = LoggerFactory.getLogger(OrderController.class);
  60. 	@Autowired
  61. 	OrderService orderService;
  63. 	@Autowired
  64. 	private	OmnipotentSqlService omnipotent;
  65. 	
  66. 	@Autowired
  67. 	private WorkersCaseuserService WorkUserEO;
  68. 	
  69. 	
  70. 	
  71. 	
  72. 	
  73. 	/**
  74. 	 * 获得订单信息列表（导出）
  75. 	 * 
  76. 	 * @param model
  77. 	 * @param request
  78. 	 * @param pageRequest
  79. 	 * @return
  80. 	 */
  81. 	@RequestMapping(value = "/getEclise", method = RequestMethod.GET, produces = "application/json")
  82. 	@ResponseBody
  83. 	public void getOrderInfoList(Model model,HttpServletRequest request,HttpSession session,HttpServletResponse response) {
  84. 			
  85. 	        ExportExcel<Map<String, Object>> ex = new ExportExcel<Map<String, Object>>();
  86. 	        
  87. 	        //创建列
  88. 	        String[] headers =
  89. 	        { "主键", "从业者ID", "案例是作品集还是婚礼案例", "案例类型", "标题","案例地址","描述","置顶","删除状态","访问量","收藏量",
  90. 	        "排序","剩余可上传数","婚礼发生时间","创建时间","修改时间"};
  91. 	        
  92. 	        //创建值列
  93. 	    	List<Map<String, Object>> dataset = omnipotent.findsqlByParam("SELECT * FROM  xsmt.ylx_workers_wuorder");
  94. 	    	
  95.             ex.MapExportExcel(headers,dataset,response);
  96.            
  97.             System.out.println("excel导出成功！");
  98.             
  99.          
  100. 		
  101. 	
  102. 	}
  103. 	
  104. 	
  105. 	
  106. 	
  107. 	
  108. 	
  109. 	/**
  110. 	 * 获得订单信息列表
  111. 	 * 
  112. 	 * @param model
  113. 	 * @param request
  114. 	 * @param pageRequest
  115. 	 * @return
  116. 	 */
  117. 	@RequestMapping(value = "/getOrderInfoList", method = RequestMethod.GET, produces = "application/json")
  118. 	@ResponseBody
  119. 	public Map<String, Object> getOrderInfoList(Model model,
  120. 												HttpServletRequest request,
  121. 												HttpSession session,
  122. 												@RequestParam(value="PageIndex",required=false)Integer PageIndex,
  123. 												@RequestParam(value="paramIndex",required=false)Integer paramIndex,
  124. 												@RequestParam(value="start",required=false)Integer start,
  125. 												@RequestParam(value="NO",required=false)String NO,
  126. 												@RequestParam(value="DateParam",required=false)String DateParam,
  127. 												@RequestParam(value="BIZ",required=false)String BIZ
  128. 												) {
  129. 		try {
  130. 			WorkUserEO attribute =(WorkUserEO) session.getAttribute("worker");//获取登录对象
  131. 			Integer WU_id = 1;
  132. 			String NO_ = "";
  133. 			String SQL = null;
  134. 			String SQLCount = null;
  135. 			
  136. 			if(attribute == null) {
  137. 				System.out.println("- 登录对象为空 -");
  138. 			}else {
  139. 				WU_id = attribute.getId();
  140. 			}
  141. 			if(NO!=null) {
  142. 				NO_ = NO;
  143. 			}
  144. 			logger.info("================================="+DateParam+"= 订单查询CYZid:"+WU_id+"  into  getOrderInfoList  ==========================================");
  145. 			Map<String, Object> map = new HashMap<String, Object>();
  146. 			
  147. 			switch (paramIndex) {
  148. 			case 1:
  149. 				//查询全部订单
  150. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,null,null,null,null,NO_,DateParam,BIZ);
  151. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,null,null,null,null,NO_,DateParam,BIZ);
  152. 				System.out.println("查询全部订单:"+SQL);
  153. 				break;
  154. 			case 2:
  155. 				//查询已支付
  156. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,1,null,null,null,NO_,DateParam,BIZ);
  157. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,1,null,null,null,NO_,DateParam,BIZ);
  158. 				System.out.println("查询已支付:"+SQL);
  159. 				break;
  160. 			case 3:
  161. 				//查询待处理
  162. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,null,5,null,null,NO_,DateParam,BIZ);
  163. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,null,5,null,null,NO_,DateParam,BIZ);
  164. 				System.out.println("查询待处理:"+SQL);
  165. 				break;
  166. 			case 4:
  167. 				//查询待已付款
  168. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,null,null,1,null,NO_,DateParam,BIZ);
  169. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,null,null,1,null,NO_,DateParam,BIZ);
  170. 				System.out.println("查询待已付款:"+SQL);
  171. 				break;
  172. 			case 5:
  173. 				//查询已完成
  174. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,null,6,null,null,NO_,DateParam,BIZ);
  175. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,null,6,null,null,NO_,DateParam,BIZ);
  176. 				System.out.println("查询已完成:"+SQL);
  177. 				break;
  178. 			case 6:
  179. 				//查询已取消
  180. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,null,null,null,1,NO_,DateParam,BIZ);
  181. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,null,null,null,1,NO_,DateParam,BIZ);
  182. 				System.out.println("查询已取消:"+SQL);
  183. 				break;
  184. 			default:
  185. 				//查询全部订单
  186. 				SQL = OrderDSQLUtil.getOrderListByParams(PageIndex,WU_id,null,null,null,null,NO_,DateParam,BIZ);
  187. 				SQLCount = OrderDSQLUtil.getOrderListByCount(PageIndex,WU_id,null,null,null,null,NO_,DateParam,BIZ);
  188. 				System.out.println("查询全部订单:"+SQL);
  189. 				break;
  190. 			}
  191. 			
  192. 			// 查询数据
  193. 			List<Map<String, Object>> findsqlByParam = omnipotent.findsqlByParam(SQL);
  194. 			if(start !=null){
  195. 				// 总条数
  196. 				List<Map<String, Object>> findsqlByCount = omnipotent.findsqlByParam(SQLCount);
  197. 				map.put("totalCount", findsqlByCount.get(0).get("count"));
  198. 			}
  199. 			map.put("resultList", findsqlByParam);
  200. 			return map;
  201. 		} catch (Exception e) {
  202. 			e.printStackTrace();
  203. 			return null;
  204. 		}
  205. 		
  206. 	}
  208. 	
  209. 	
  210. 	/**
  211. 	 * 增加订单信息
  212. 	 * 
  213. 	 * @param model
  214. 	 * @param request
  215. 	 * @param pageRequest
  216. 	 * @return
  217. 	 */
  218. 	@RequestMapping(value = "/jsonAddOrderInfo", method = RequestMethod.POST)
  219. 	@ResponseBody
  220. 	public ProtocolParam addOrderInfo(Model model, HttpServletRequest request,
  221. 			@RequestParam Map<String, Object> pageRequest) {
  222. 		logger.info("======================================== JsonAddOrderInfo==================================");
  223. 		// 获得要添加的字段
  224. 		try {
  225. 			String no = URLDecoder.decode((String) pageRequest.get("no"),
  226. 					"utf-8");// 订单编号
  227. 			String cust_name = URLDecoder.decode(
  228. 					(String) pageRequest.get("custname"), "utf-8");// 客户姓名
  229. 			// 创建实体对象
  230. 			OrderEO order = new OrderEO();
  231. 			// 订单编号
  232. 			if (no != null && !"".equals(no)) {
  233. 				order.setNo(CommonFunction.getRandomOrderNo());
  234. 			}
  235. 			// 客户名称
  236. 			if (cust_name != null && !"".equals(cust_name)) {
  237. 				order.setCust_name(cust_name);
  238. 			}
  239. 			// 生成流水号
  240. 			order.setTrade_no(CommonFunction.GetNewOrderNo(no));
  241. 			// 服务名称
  242. 			order.setService_name("中式");
  243. 			order.setCreation_time(new Date());
  244. 			// 调用方法
  245. 			String str = HomeSQLUtil.homeOrderAddSQL(order);
  246. 			int count = orderService.add(str);
  247. 			// orderService.addOrderInfo(order);
  248. 			if (count > 0) {
  249. 				return ProtocolAppoint.succeed("新增成功", null, null);
  250. 			}
  251. 			return null;
  252. 		} catch (UnsupportedEncodingException e) {
  253. 			return ProtocolAppoint.error("新增失败", null, null);
  254. 		}
  255. 	}
  257. 	/**
  258. 	 * 删除
  259. 	 * 
  260. 	 * @param pageRequest
  261. 	 * @return
  262. 	 */
  263. 	@RequestMapping(value = "/JsonDelOrderInfo", method = RequestMethod.POST)
  264. 	@ResponseBody
  265. 	public ProtocolParam delOrderInfo(
  266. 			@RequestParam Map<String, Object> pageRequest) {
  267. 		logger.info("=============================== JsonDelOrderInfo ===============================");
  268. 		try {
  269. 			int id = Integer.parseInt(URLDecoder.decode(
  270. 					(String) pageRequest.get("id"), "utf-8"));
  271. 			String sql = HomeSQLUtil.homeDelOrderInfo(id);
  272. 			int count = orderService.delete(sql);
  273. 			if (count > 0) {
  274. 				return ProtocolAppoint.merry(200, "成功", null, null);
  275. 			}
  276. 			return null;
  277. 		} catch (Exception e) {
  278. 			return ProtocolAppoint.error("失败", null, null);
  279. 		}
  280. 	}
  281. 	
  282. 	@RequestMapping(value="/ModifyOrderInfo",method=RequestMethod.POST)
  283. 	@ResponseBody
  284. 	public ProtocolParam modifyOrderInfo(@RequestParam Map<String, Object> pageRequest){
  285. 		logger.info("============================= ModifyOrderInfo =========================================");
  286. 		try {
  287. 			int id=Integer.parseInt(URLDecoder.decode(
  288. 					(String) pageRequest.get("id"), "utf-8"));
  289. 			OrderEO order=new OrderEO();
  290. 			order.setNo("NO201806201543");
  291. 			order.setCust_name("青青");
  292. 			order.setId(BigInteger.valueOf(id));
  293. 			String sql=HomeSQLUtil.homeModifyOrderInfo(order);
  294. 			int count =orderService.update(sql);
  295. 			if(count>0){
  296. 				return ProtocolAppoint.merry(200, "成功", null, null);
  297. 			}
  298. 			return null;
  299. 		} catch (Exception e) {
  300. 			return ProtocolAppoint.error("失败", null, null);
  301. 		}
  302. 	}
  303. }

版权声明：本文为chengxiaolong原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/chengxiaolong/p/10206339.html