zoukankan      html  css  js  c++  java

  • java代码将excel文件中的内容列表转换成JS文件输出

    思路分析

    我们想要把excel文件中的内容转为其他形式的文件输出，肯定需要分两步走：

    　　1.把excel文件中的内容读出来；

    　　2.将内容写到新的文件中。

    举例

    一张excel表中有一个表格：

    我们需要将表格中的内容写到JS文件中输出：

    文件名为expressData.js

    地址的经纬度我们就调用百度接口获得。

     新建一个springboot工程

    因为使用springboot方便，快捷，所以我们就用springboot来演示，如果还没用过springboot的，并且不知道springboot怎么用的也没关系，你只需要注重代码就行，把这些代码放到以SSM为架构的项目中也是一样的。这里的文件，我们一个一个说。

    pom.xml

     1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3   <modelVersion>4.0.0</modelVersion>
 4   <groupId>com.cetc.excelToJS</groupId>
 5   <artifactId>cetc_excelToJS</artifactId>
 6   <version>0.0.1-SNAPSHOT</version>
 7   <packaging>jar</packaging>
 8   
 9   <name>cetc_excelToJS</name>
10   <url>http://maven.apache.org</url>
11   
12   
13   <parent>
14         <groupId>org.springframework.boot</groupId>
15         <artifactId>spring-boot-starter-parent</artifactId>
16         <version>1.5.9.RELEASE</version>
17     </parent>
18 
19   <properties>
20     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
21     <java.version>1.8</java.version>
22   </properties>
23 
24   <dependencies>
25            <dependency>
26             <groupId>org.springframework.boot</groupId>
27             <artifactId>spring-boot-starter-web</artifactId>
28         </dependency>
29         <dependency>
30             <groupId>org.springframework.boot</groupId>
31             <artifactId>spring-boot-starter-tomcat</artifactId>
32 <!--             <scope>provided</scope> -->
33         </dependency>
34         <!-- 用于监控spring boot 端点 -->
35         <dependency>
36             <groupId>org.springframework.boot</groupId>
37             <artifactId>spring-boot-starter-actuator</artifactId>
38         </dependency>
39         <dependency>
40             <groupId>org.springframework.boot</groupId>
41             <artifactId>spring-boot-devtools</artifactId>
42             <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->
43         </dependency>
44         
45         <!-- 引入poi，解析workbook视图 -->
46        <dependency>
47            <groupId>org.apache.poi</groupId>
48            <artifactId>poi</artifactId>
49            <version>3.16</version>
50        </dependency>
51        <dependency>
52            <groupId>org.apache.poi</groupId>
53            <artifactId>poi-ooxml</artifactId>
54            <version>3.14</version>
55        </dependency>
56        <!-- 处理excel和上面功能是一样的-->
57        <dependency>
58            <groupId>net.sourceforge.jexcelapi</groupId>
59            <artifactId>jxl</artifactId>
60            <version>2.6.10</version>
61        </dependency>
62         
63   </dependencies>
64   
65 <!--   添加spring-boot 的maven插件 -->
66     <build>
67         <plugins>
68             <plugin>
69                 <groupId>org.springframework.boot</groupId>
70                 <artifactId>spring-boot-maven-plugin</artifactId>
71             </plugin>
72         </plugins>
73     </build>
74   
75   
76 </project>

    如果你用ssm写的话，在pom.xml文件中添加

     1  <!-- 引入poi，解析workbook视图 -->
 2        <dependency>
 3            <groupId>org.apache.poi</groupId>
 4            <artifactId>poi</artifactId>
 5            <version>3.16</version>
 6        </dependency>
 7        <dependency>
 8            <groupId>org.apache.poi</groupId>
 9            <artifactId>poi-ooxml</artifactId>
10            <version>3.14</version>
11        </dependency>
12        <!-- 处理excel和上面功能是一样的-->
13        <dependency>
14            <groupId>net.sourceforge.jexcelapi</groupId>
15            <artifactId>jxl</artifactId>
16            <version>2.6.10</version>
17        </dependency>

    application.yml

    这里我们用不到任何配置，所以这个文件我们就放个空的就行了。

    Util包

    ReadExcel.java

    首先，当然是要读到excel中的内容撒。

     1 package com.cetc.excelToJS.util;
 2 import java.io.File;
 3 
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.util.ArrayList;
 9 import java.util.List;
10 
11 import org.springframework.stereotype.Component;
12 
13 import jxl.Sheet;
14 import jxl.Workbook;
15 import jxl.read.biff.BiffException;
16 
17 @Component
18 public class ReadExcel {
19    public static void main(String[] args) {
20        ReadExcel obj = new ReadExcel();
21        File file = new File("D:/1234.xls");
22        List excelList = obj.readExcel(file);
23        System.out.println("list中的数据打印出来");
24        for (int i = 0; i < excelList.size(); i++) {
25            List list = (List) excelList.get(i);
26            for (int j = 0; j < list.size(); j++) {
27                System.out.print(list.get(j));
28            }
29            System.out.println();
30        }
31 
32    }
33    
34    public List<List> getContent(String path) {
35        ReadExcel obj = new ReadExcel();
36        File file = new File(path);
37        List<List> excelList = obj.readExcel(file);
38        return excelList;
39        
40    }
41    
42    // 去读Excel的方法readExcel，该方法的入口参数为一个File对象
43    public List readExcel(File file) {
44        try {
45            // 创建输入流，读取Excel
46            InputStream is = new FileInputStream(file.getAbsolutePath());
47            // jxl提供的Workbook类
48            Workbook wb = Workbook.getWorkbook(is);
49            // Excel的页签数量
50            int sheet_size = wb.getNumberOfSheets();
51            for (int index = 0; index < sheet_size; index++) {
52                List<List> outerList=new ArrayList<List>();
53                // 每个页签创建一个Sheet对象
54                Sheet sheet = wb.getSheet(index);
55                // sheet.getRows()返回该页的总行数
56                for (int i = 0; i < sheet.getRows(); i++) {
57                    List innerList=new ArrayList();
58                    // sheet.getColumns()返回该页的总列数
59                    for (int j = 0; j < sheet.getColumns(); j++) {
60                        String cellinfo = sheet.getCell(j, i).getContents();
61                        if(cellinfo.isEmpty()){
62                            continue;
63                        }
64                        innerList.add(cellinfo);
65                        System.out.print(cellinfo);
66                    }
67                    outerList.add(i, innerList);
68                    System.out.println();
69                }
70                return outerList;
71            }
72        } catch (FileNotFoundException e) {
73            e.printStackTrace();
74        } catch (BiffException e) {
75            e.printStackTrace();
76        } catch (IOException e) {
77            e.printStackTrace();
78        }
79        return null;
80    }
81 }
    点击展开

    两个方法：

    1.getContent(String path)   返回类型<List<List>>

    　　很明显，Controller来调用我，给我一个excel文件的路径，我返回给你文件中的内容，以List<List>的形式。外面这个list是一行一个对象（也就是小list），里面这个list就是一行内容有多个字段，每个字段就是一个对象。

    2.readExcel(File file) 返回类型<List<List>>

    　　这是getContent 方法调用的，返回<List<List>>给getContent，就是所有事情都替它干了。注释也很清楚，不用多说了。

    TargetInformation.java

    这是一个实体类，我们读出了excel文件中的内容，根据需求，我们还要根据地址，查出经纬度，对不对。那我们是不是还要给每个小list对象中加两个值，lng和lat。你可以这样干，但是我是喜欢用对象来处理的，可能有点多余，但你可以不这么干。

     1 package com.cetc.excelToJS.pojo;
 2 
 3 public class TargetInformation {
 4     private String lng;
 5     private String lat;
 6     private String name;
 7     private String address;
 8     
 9     public TargetInformation(String lng,String lat,String name,String address) {
10         this.lng = lng;
11         this.lat = lat;
12         this.name = name;
13         this.address = address;
14     }
15     
16     public String getLng() {
17         return lng;
18     }
19     public void setLng(String lng) {
20         this.lng = lng;
21     }
22     public String getLat() {
23         return lat;
24     }
25     public void setLat(String lat) {
26         this.lat = lat;
27     }
28     public String getName() {
29         return name;
30     }
31     public void setName(String name) {
32         this.name = name;
33     }
34     public String getAddress() {
35         return address;
36     }
37     public void setAddress(String address) {
38         this.address = address;
39     }
40     
41     
42 }
    点击展开

    GetLatAndLngByBaidu.java

    百度根据地址查询经纬度的方法类，不用说了。有个注意点就是，你传的地址一定要是准确的，存在的。比如：你输入的地址在百度地图上都找不到，或者输入地址点击查询，地图上出来好多个标记，那接口哪知道是哪一个啊？所以，这两种情况是一定会报错的。

     1 package com.cetc.excelToJS.util;
 2 import java.io.BufferedReader;
 3 import java.io.IOException;
 4 import java.io.InputStreamReader;
 5 import java.io.UnsupportedEncodingException;
 6 import java.net.MalformedURLException;
 7 import java.net.URL;
 8 import java.net.URLConnection;
 9 
10 import org.springframework.stereotype.Component;
11  
12 /** 
13 * 获取经纬度
14 * 
15 * @author Sunny 
16 * 密钥:lAGGc3PbOv0KeGTWcp6xOtDbkt6Kuld5
17 */ 
18 @Component
19 public class GetLatAndLngByBaidu { 
20 /** 
21 * @param addr 
22 * 查询的地址 
23 * @return 
24 * @throws IOException 
25 */ 
26     public Object[] getCoordinate(String addr) throws IOException {
27         String lng = null;//经度
28         String lat = null;//纬度
29         String address = null; 
30         try { 
31             address = java.net.URLEncoder.encode(addr, "UTF-8"); 
32         }catch (UnsupportedEncodingException e1) { 
33             e1.printStackTrace(); 
34         } 
35 //        String key = "f247cdb592eb43ebac6ccd27f796e2d2"; 
36         String key  = "lAGGc3PbOv0KeGTWcp6xOtDbkt6Kuld5";
37         String url = String .format("http://api.map.baidu.com/geocoder?address=%s&output=json&key=%s", address, key); 
38         URL myURL = null; 
39         URLConnection httpsConn = null; 
40         try { 
41             myURL = new URL(url); 
42         } catch (MalformedURLException e) { 
43             e.printStackTrace(); 
44         } 
45         InputStreamReader insr = null;
46         BufferedReader br = null;
47         try { 
48             httpsConn = (URLConnection) myURL.openConnection();// 不使用代理 
49             if (httpsConn != null) { 
50                 insr = new InputStreamReader( httpsConn.getInputStream(), "UTF-8"); 
51                 br = new BufferedReader(insr); 
52                 String data = null; 
53                 int count = 1;
54                 while((data= br.readLine())!=null){ 
55                     if(count==5){
56                         lng = (String)data.subSequence(data.indexOf(":")+1, data.indexOf(","));//经度
57                         count++;
58                     }else if(count==6){
59                         lat = data.substring(data.indexOf(":")+1);//纬度
60                         count++;
61                     }else{
62                         count++;
63                     }
64                 } 
65             } 
66         } catch (IOException e) { 
67             e.printStackTrace(); 
68         } finally {
69             if(insr!=null){
70                 insr.close();
71             }
72             if(br!=null){
73                 br.close();
74             }
75         }
76         return new Object[]{lng,lat}; 
77     } 
78  
79  
80     public static void main(String[] args) throws IOException {
81         GetLatAndLngByBaidu getLatAndLngByBaidu = new GetLatAndLngByBaidu();
82         Object[] o = getLatAndLngByBaidu.getCoordinate("无锡市新吴区旺庄路156号宝龙城市广场f2");
83         System.out.println(o[0]);//经度
84         System.out.println(o[1]);//纬度
85     }
86 }
    点击展开

    TargetContent.java

    好了，我们现在地址有了，接口也有了。那就查吧，并且查出来封装成对象，把这些对象放到一个新的list中。以备将来所用！

     1 package com.cetc.excelToJS.util;
 2 
 3 import java.io.IOException;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 import javax.annotation.Resource;
 8 
 9 import org.springframework.stereotype.Component;
10 
11 import com.cetc.excelToJS.pojo.TargetInformation;
12 
13 @Component
14 public class TargetContent {
15     @Resource
16     private GetLatAndLngByBaidu getLatAndLngByBaidu;
17     
18     public List getTargerList(List<List> excelList) throws IOException {
19         List<TargetInformation> resultList= new ArrayList<TargetInformation>();
20         for(int i = 1;i<excelList.size();i++) {
21             List<String> contentList = (List<String>) excelList.get(i);
22             // --------------------------------------------------------
23             // --------------这里看一下该条记录的内容先-------------------
24             for(int j=0;j<contentList.size();j++) {
25                 System.out.println(contentList.get(j));
26             }
27             // --------------------------------------------------------
28             // 找出该条记录的地址，调用百度接口，获得经纬度
29             Object[] ouject = getLatAndLngByBaidu.getCoordinate(contentList.get(1));
30             // 将经纬度封装到对象中存入resultList中
31             TargetInformation targetInformation = new TargetInformation(ouject[0].toString(),
32                     ouject[1].toString(),
33                     contentList.get(0),
34                     contentList.get(1));
35             resultList.add(targetInformation);
36         
37         }
38         return resultList;
39     }
40 }
    点击展开

    WriteJS.java

    获得需要写入的对象集合，那我们就写JS文件呗。

      1 package com.cetc.excelToJS.util;
  2 
  3 
  4 import java.io.BufferedReader;  
  5 import java.io.File;  
  6 import java.io.FileInputStream;  
  7 import java.io.FileOutputStream;  
  8 import java.io.IOException;  
  9 import java.io.InputStreamReader;  
 10 import java.io.PrintWriter;
 11 import java.util.List;
 12 
 13 import org.springframework.stereotype.Component;
 14 
 15 import com.cetc.excelToJS.pojo.TargetInformation;  
 16 @Component
 17 public class WriteJS {  
 18     // 这里是创建的路径
 19     private static String path = "D:/";  
 20     private static String filenameTemp;  
 21   
 22 //    public static void main(String[] args) throws IOException {
 23 //        WriteJS.creatJSFile("你好");  
 24 //        WriteJS.writeJSFile("你好");
 25 //        WriteJS.writeJSFile("    罗大爷1");
 26 //    }  
 27     public String doWrite(List<TargetInformation> resultList)  {
 28         try {
 29         // 创建一个名为expressData 的js文件
 30         this.creatJSFile("expressData");
 31         // 先开个头
 32         this.writeJSFile("var expPointArr = [");
 33         
 34         for(int i=0;i<resultList.size()-1;i++) {
 35             TargetInformation targetInformation = resultList.get(i);
 36             // {"lng":118.752696,"lat":32.22832,"name":"盘城揽投部","address":"新华路121号"},
 37             String information = "{"lng":"+targetInformation.getLng()
 38                                 +","lat":"+targetInformation.getLat()
 39                                 +","name":""+targetInformation.getName()
 40                                 +"","address":""+targetInformation.getAddress()
 41                                 +""},";
 42             this.writeJSFile("    "+information);
 43         }
 44         // 这里添加最后一条，因为最后一一条后面没逗号
 45         TargetInformation targetInformation_last = resultList.get(resultList.size()-1);
 46         String information_last = "{"lng":"+targetInformation_last.getLng()
 47                             +","lat":"+targetInformation_last.getLat()
 48                             +","name":""+targetInformation_last.getName()
 49                             +"","address":""+targetInformation_last.getAddress()
 50                             +""}";
 51         this.writeJSFile("    "+information_last);
 52         // 这里结束
 53         this.writeJSFile("];");
 54         
 55         return "success";
 56         }catch (Exception e) {
 57             return "failure";
 58         }
 59     }
 60       
 61       
 62     /** 
 63      * 创建文件 
 64      *  
 65      * @throws IOException 
 66      */  
 67     public  boolean creatJSFile(String name) throws IOException {  
 68         boolean flag = false;  
 69         filenameTemp = path + name + ".js";  
 70         File filename = new File(filenameTemp);  
 71         if (!filename.exists()) {
 72             filename.createNewFile();  
 73             flag = true;  
 74         }
 75         return flag;  
 76     } 
 77     
 78   
 79     /** 
 80      * 写文件 
 81      *  
 82      * @param newStr 
 83      *            新内容 
 84      * @throws IOException 
 85      */  
 86     public  boolean writeJSFile(String newStr) throws IOException {  
 87         // 先读取原有文件内容，然后进行写入操作  
 88         boolean flag = false;  
 89         String filein = newStr + "
";  
 90         String temp = "";  
 91   
 92         FileInputStream fis = null;  
 93         InputStreamReader isr = null;  
 94         BufferedReader br = null;  
 95   
 96         FileOutputStream fos = null;  
 97         PrintWriter pw = null;  
 98         try {  
 99             // 文件路径  
100             File file = new File(filenameTemp);  
101             // 将文件读入输入流  
102             fis = new FileInputStream(file);  
103             isr = new InputStreamReader(fis);  
104             br = new BufferedReader(isr);  
105             StringBuffer buf = new StringBuffer();  
106   
107             // 保存该文件原有的内容  
108             for (int j = 1; (temp = br.readLine()) != null; j++) {  
109                 buf = buf.append(temp);  
110                 // System.getProperty("line.separator")  
111                 // 行与行之间的分隔符 相当于“
”  
112                 buf = buf.append(System.getProperty("line.separator"));  
113             }  
114             buf.append(filein);  
115   
116             fos = new FileOutputStream(file);  
117             pw = new PrintWriter(fos);  
118             pw.write(buf.toString().toCharArray());  
119             pw.flush();  
120             flag = true;  
121         } catch (IOException e1) {  
122             // TODO 自动生成 catch 块  
123             throw e1;  
124         } finally {  
125             if (pw != null) {  
126                 pw.close();  
127             }  
128             if (fos != null) {  
129                 fos.close();  
130             }  
131             if (br != null) {  
132                 br.close();  
133             }  
134             if (isr != null) {  
135                 isr.close();  
136             }  
137             if (fis != null) {  
138                 fis.close();  
139             }  
140         }  
141         return flag;  
142     }  
143   
144 }
    点击展开

    代码很好明白。有两个静态属性说一下：

    private static String path = "D:/";
    private static String filenameTemp;

    第一个：path是即将要生成的JS文件要放的位置。你可以改。

    第二个：filenameTemp 是JS的文件名，我是让Controller传的。

    createExcel.java

    这是一个创建excel的工具类，这里可以忽略。有兴趣的下代码去。

    IndexController.java

     1 package com.cetc.excelToJS.controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.HashMap;
 5 import java.util.List;
 6 import java.util.Map;
 7 
 8 import javax.annotation.Resource;
 9 import javax.servlet.http.HttpServletResponse;
10 
11 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
12 import org.springframework.web.bind.annotation.GetMapping;
13 import org.springframework.web.bind.annotation.RestController;
14 
15 import com.cetc.excelToJS.pojo.TargetInformation;
16 import com.cetc.excelToJS.util.HandleFile;
17 import com.cetc.excelToJS.util.ReadExcel;
18 import com.cetc.excelToJS.util.TargetContent;
19 import com.cetc.excelToJS.util.WriteJS;
20 
21 @RestController
22 public class IndexController {
23     
24     @Resource
25     private ReadExcel readExcel;
26     @Resource
27     private WriteJS writeJS;
28     @Resource
29     private TargetContent targetContent;
30     
31     @GetMapping("/transfor")
32     public String transfor() {
33         try {
34         String path = "D:/expressData.xls";
35         List<List> excelList = readExcel.getContent(path);
36         List<TargetInformation> resultList = targetContent.getTargerList(excelList);
37         String message = writeJS.doWrite(resultList);
38         return message;
39         }catch (Exception e) {
40             return "操作失败";
41         }
42     }
43     
44     /**
45      * excel生成下载
46      * @param response
47      * @return
48      * @throws Exception
49      */
50     @GetMapping(value = "/createExcel")
51     public String createExcel(HttpServletResponse response) throws Exception{
52         Map<String,Object> excelMap = new HashMap<>();
53         //1.设置Excel表头
54         List<String> headerList = new ArrayList<>();
55         headerList.add("name");
56         headerList.add("address");
57         excelMap.put("header",headerList);
58  
59         //2.是否需要生成序号，序号从1开始(true-生成序号 false-不生成序)
60         boolean isSerial = false;
61         excelMap.put("isSerial",isSerial);
62  
63         //3.sheet名
64         String sheetName = "统计表";
65         excelMap.put("sheetName",sheetName);
66  
67  
68         //4.需要放入Excel中的数据
69         List<String> list = new ArrayList<>();
70         list.add("鼓楼投递部");
71         list.add("江苏省南京市玄武区韩家巷10-2号");
72         List<List<String>> data= new ArrayList<>();
73         data.add(list);
74  
75         excelMap.put("data",data);
76  
77         //Excel文件内容设置
78         HSSFWorkbook workbook = HandleFile.createExcel(excelMap);
79  
80         String fileName = "expressData.xls";
81  
82         //生成excel文件
83         HandleFile.buildExcelFile(fileName, workbook);
84  
85         //浏览器下载excel
86         HandleFile.buildExcelDocument(fileName,workbook,response);
87  
88         return "down excel";
89  
90     }
91 
92 }
    点击展开

    这个大家不一定一样，只是作为启动这个excel转JS文件功能的...引擎吧。

    只要看这个接口就行：

     1 @GetMapping("/transfor")
 2     public String transfor() {
 3         try {
 4         String path = "D:/expressData.xls";
 5         List<List> excelList = readExcel.getContent(path);
 6         List<TargetInformation> resultList = targetContent.getTargerList(excelList);
 7         String message = writeJS.doWrite(resultList);
 8         return message;
 9         }catch (Exception e) {
10             return "操作失败";
11         }
12     }

    它是去读D盘根目录下的expressData.xls文件的。然后生成对象list,然后写JS文件，执行完了你会发现D盘多了一个文件

    里面的内容嘛，我就不贴了，在上面。

    代码下载地址：https://gitee.com/fengyuduke/my_open_resources/blob/master/cetc_excelToJS.zip

    到这里本来想结束，但是这里有个问题，大家注意到没？

    我是到固定目录下面去找excel文件的，要是用起来肯定多有不便。更多时候我们都是前端上传文件的，然后后台代码来解析读取我们上传的这个文件。那这个时候怎么做？

    我们从上到下来修改：

    第一步：修改Controller中的接口方法

     1 @RequestMapping(value="transfor")
 2 public String transfor(@RequestParam(required = true) MultipartFile file) {
 3         try {
 4 //        String path = "D:/expressData.xls";
 5         List<List> excelList = readExcel.getContent(file);
 6         List<TargetInformation> resultList = targetContent.getTargerList(excelList);
 7         String message = writeJS.doWrite(resultList);
 8         return message ;
 9         }catch (Exception e) {
10             return "操作失败";
11         }
12     }

    我们接收前端传来的文件，然后把文件传给工具类。

    第二步：修改ReadExcel.java

      1 package com.project.ndmp.excelToJS;
  2 import java.io.FileNotFoundException;
  3 import java.io.IOException;
  4 import java.io.InputStream;
  5 import java.util.ArrayList;
  6 import java.util.List;
  7 
  8 import org.apache.commons.fileupload.disk.DiskFileItem;
  9 import org.springframework.stereotype.Component;
 10 import org.springframework.web.multipart.MultipartFile;
 11 import org.springframework.web.multipart.commons.CommonsMultipartFile;
 12 
 13 import jxl.Sheet;
 14 import jxl.Workbook;
 15 import jxl.read.biff.BiffException;
 16 
 17 @Component
 18 public class ReadExcel {
 19    public static void main(String[] args) {
 20 //       ReadExcel obj = new ReadExcel();
 21 //       // 此处为我创建Excel路径：E:/zhanhj/studysrc/jxl下
 22 //       File file = new File("D:/1234.xls");
 23 //       List excelList = obj.readExcel(file);
 24 //       System.out.println("list中的数据打印出来");
 25 //       for (int i = 0; i < excelList.size(); i++) {
 26 //           List list = (List) excelList.get(i);
 27 //           for (int j = 0; j < list.size(); j++) {
 28 //               System.out.print(list.get(j));
 29 //           }
 30 //           System.out.println();
 31 //       }
 32 
 33    }
 34    
 35    public List<List> getContent(MultipartFile mFile) {
 36        ReadExcel obj = new ReadExcel();
 37 //       CommonsMultipartFile cFile = (CommonsMultipartFile) mFile;
 38 //       DiskFileItem fileItem = (DiskFileItem) cFile.getFileItem();
 39 //       InputStream inputStream = fileItem.getInputStream();
 40 //       File file = new File(path);
 41        List<List> excelList = obj.readExcel(mFile);
 42        return excelList;
 43        
 44    }
 45    /**
 46     * 
 47     * @param mFile MultipartFile
 48     * @return
 49     */
 50    public List readExcel(MultipartFile mFile) {
 51        try {
 52            // -------------------------------------------------------------------
 53            /*
 54             * 从springmvc获取到的文件是MultipartFile类型的，有的时候不能直接用从这种类型获取
 55             * 到的inputstream操作一些事情，比如从中初始化poi的Workbook，这时候要怎么获取到File
 56             * 式的流呢？ 
 57                 有一个方法就是把读到的MultipartFile转存到本地，然后再从本地读取这个转存的这个临
 58                 时文件，从中获取文件流。这么写的话可以达到目的但是听起来就很繁琐对不对。
 59                 
 60                 下面这三步，就是通过转换的形式将MultipartFile类型的文件放到输入流里面
 61             */
 62            CommonsMultipartFile cFile = (CommonsMultipartFile) mFile;
 63            DiskFileItem fileItem = (DiskFileItem) cFile.getFileItem();
 64            InputStream is = fileItem.getInputStream();
 65            // --------------------------------------------------------------------
 66            /*
 67             *  创建输入流，读取Excel
 68             *  下面这一步不用了，这是文件在本地的情况，根据文件的绝对路径来将文件写到输入流中
 69             */
 70 //           InputStream is = new FileInputStream(file.getAbsolutePath());
 71            // jxl提供的Workbook类
 72            Workbook wb = Workbook.getWorkbook(is);
 73            // Excel的页签数量
 74            int sheet_size = wb.getNumberOfSheets();
 75            for (int index = 0; index < sheet_size; index++) {
 76                List<List> outerList=new ArrayList<List>();
 77                // 每个页签创建一个Sheet对象
 78                Sheet sheet = wb.getSheet(index);
 79                // sheet.getRows()返回该页的总行数
 80                for (int i = 0; i < sheet.getRows(); i++) {
 81                    List innerList=new ArrayList();
 82                    // sheet.getColumns()返回该页的总列数
 83                    for (int j = 0; j < sheet.getColumns(); j++) {
 84                        String cellinfo = sheet.getCell(j, i).getContents();
 85                        if(cellinfo.isEmpty()){
 86                            continue;
 87                        }
 88                        innerList.add(cellinfo);
 89                        System.out.print(cellinfo);
 90                    }
 91                    outerList.add(i, innerList);
 92                    System.out.println();
 93                }
 94                return outerList;
 95            }
 96        } catch (FileNotFoundException e) {
 97            e.printStackTrace();
 98        } catch (BiffException e) {
 99            e.printStackTrace();
100        } catch (IOException e) {
101            e.printStackTrace();
102        }
103        return null;
104    }
105 }
    点击展开

    这里最为关键的就是这三行代码

     CommonsMultipartFile cFile = (CommonsMultipartFile) mFile;
DiskFileItem fileItem = (DiskFileItem) cFile.getFileItem();
InputStream is = fileItem.getInputStream();

    这三行代码解决了怎么将MultipartFile类型的文件放到输入流里。这样我们后面的操作都不用变了。

    最后

    代码中没说的创建excel文件的接口和工具类也很实用。但是我想大家一般都是把模板放到项目里，然后提供下载地址即可，不一定需要代码创建啦！
  • 相关阅读:
    四大组件之BroadcastReceiver基础
    SQLiteOpenHelper与SQLiteDatabase的使用
    SharedPreferences实现保存用户名功能
    Fragment加载方式与数据通信
    ProgressBar、ProgessDialog用法解析
    GridView添加事件监听和常用属性解析
    ListView添加item的事件监听
    ArrayAdapter、SimpleAdapter简单用法
    MySQL入门笔记（二）
    MySQL入门笔记（一）
  • 原文地址：https://www.cnblogs.com/fengyuduke/p/10445907.html
Copyright © 2011-2022 走看看