导入（若依框架）

用户界面，以导入用户数据为例

模板
发起请求
页面发起导入请求： 在导入对话框中，点击 <点击上传>按钮，选择导入文件，点击确认，发起导入请求
http://localhost/dev-api/system/user/importData?updateSupport=false

后台导入的入口方法

@Log(title = "用户管理", businessType = BusinessType.IMPORT)
    @PreAuthorize("@ss.hasPermi('system:user:import')")
    @PostMapping("/importData")
    public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception
    {
        ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class);
        // 核心代码
        List<SysUser> userList = util.importExcel(file.getInputStream());
        LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
        String operName = loginUser.getUsername();
        String message = userService.importUser(userList, updateSupport, operName);
        return AjaxResult.success(message);
    }

进入com.ruoyi.common.utils.poi.ExcelUtil#importExcel(java.io.InputStream)方法

    public List<T> importExcel(InputStream is) throws Exception
    {
        return importExcel(StringUtils.EMPTY, is);
    }

进入com.ruoyi.common.utils.poi.ExcelUtil#importExcel(java.lang.String, java.io.InputStream)方法。

这个方法是导入的核心逻辑。返回List ，后续可以根据这个集合，进行插入数据库操作。

  /**
     * 对excel表单指定表格索引名转换成list
     * 
     * @param sheetName 表格索引名
     * @param is 输入流
     * @return 转换后集合
     */
    public List<T> importExcel(String sheetName, InputStream is) throws Exception
    {
        // 声明操作为导入
        this.type = Type.IMPORT;
        // 从InputStream中，读入excel中的数据，封装到wb中。
        this.wb = WorkbookFactory.create(is);
        List<T> list = new ArrayList<T>();
        Sheet sheet = null;
        if (StringUtils.isNotEmpty(sheetName))
        {
            // 如果指定sheet名,则取指定sheet中的内容.
            sheet = wb.getSheet(sheetName);
        }
        else
        {
            // 如果传入的sheet名不存在则默认指向第1个sheet.
            sheet = wb.getSheetAt(0);
        }

        if (sheet == null)
        {
            throw new IOException("文件sheet不存在");
        }
		// 获取sheet页中的行数
        int rows = sheet.getPhysicalNumberOfRows();

        if (rows > 0)
        {
            // 定义一个map用于存放excel列的序号和field.
            Map<String, Integer> cellMap = new HashMap<String, Integer>();
            // 获取表头
            Row heard = sheet.getRow(0);
            // 遍历表头，heard.getPhysicalNumberOfCells() 获取表头的个数
            for (int i = 0; i < heard.getPhysicalNumberOfCells(); i++)
            {
                Cell cell = heard.getCell(i);
                if (StringUtils.isNotNull(cell))
                {
                    // 获取表头单元格中的值
                    String value = this.getCellValue(heard, i).toString();
                    // 将表头的单元格的名称和序号存入到cellMap中。
                    cellMap.put(value, i);
                }
                else
                {
                    cellMap.put(null, i);
                }
            }
            // 有数据时才处理 得到类的所有field.
            Field[] allFields = clazz.getDeclaredFields();
            // 定义一个map用于存放列的序号和field.
            Map<Integer, Field> fieldsMap = new HashMap<Integer, Field>();
            // 遍历字段数组
            for (int col = 0; col < allFields.length; col++)
            {
                Field field = allFields[col];
                // 获取注解Excel
                Excel attr = field.getAnnotation(Excel.class);
                // 根据注解判断该feild是否是声明的导入字段。
                if (attr != null && (attr.type() == Type.ALL || attr.type() == type))
                {
                    // 设置类的私有字段属性可访问.为了后续的反射赋值
                    field.setAccessible(true);
                    // 获取表头名称列的序号
                    Integer column = cellMap.get(attr.name());
                    if (column != null)
                    {
                        // execl表头的序号，和filed映射关系。核心的map。
                        fieldsMap.put(column, field);
                    }
                }
            }
            // 从第1行遍历Execl。 （第0行是表头）
            for (int i = 1; i < rows; i++)
            {
                // 从第2行开始取数据,默认第一行是表头.
                Row row = sheet.getRow(i);
                T entity = null;
                for (Map.Entry<Integer, Field> entry : fieldsMap.entrySet())
                {
                    // 根据列号获取单元格的值。
                    Object val = this.getCellValue(row, entry.getKey());

                    // 如果不存在实例则新建.
                    entity = (entity == null ? clazz.newInstance() : entity);
                    // 从map中得到对应列的field.
                    Field field = fieldsMap.get(entry.getKey());
                    // 取得类型,并根据对象类型设置值.
                    Class<?> fieldType = field.getType();
                    // 判断类型
                    if (String.class == fieldType)
                    {
                        // 转为string类型
                        String s = Convert.toStr(val);
                        if (StringUtils.endsWith(s, ".0"))
                        {
                            val = StringUtils.substringBefore(s, ".0");
                        }
                        else
                        {
                            String dateFormat = field.getAnnotation(Excel.class).dateFormat();
                            if (StringUtils.isNotEmpty(dateFormat))
                            {
                                val = DateUtils.parseDateToStr(dateFormat, (Date) val);
                            }
                            else
                            {
                                val = Convert.toStr(val);
                            }
                        }
                    }
                    else if ((Integer.TYPE == fieldType || Integer.class == fieldType) && StringUtils.isNumeric(Convert.toStr(val)))
                    {
                        val = Convert.toInt(val);
                    }
                    else if (Long.TYPE == fieldType || Long.class == fieldType)
                    {
                        val = Convert.toLong(val);
                    }
                    else if (Double.TYPE == fieldType || Double.class == fieldType)
                    {
                        val = Convert.toDouble(val);
                    }
                    else if (Float.TYPE == fieldType || Float.class == fieldType)
                    {
                        val = Convert.toFloat(val);
                    }
                    else if (BigDecimal.class == fieldType)
                    {
                        val = Convert.toBigDecimal(val);
                    }
                    else if (Date.class == fieldType)
                    {
                        if (val instanceof String)
                        {
                            val = DateUtils.parseDate(val);
                        }
                        else if (val instanceof Double)
                        {
                            val = DateUtil.getJavaDate((Double) val);
                        }
                    }
                    else if (Boolean.TYPE == fieldType || Boolean.class == fieldType)
                    {
                        val = Convert.toBool(val, false);
                    }
                    if (StringUtils.isNotNull(fieldType))
                    {
                        Excel attr = field.getAnnotation(Excel.class);
                        String propertyName = field.getName();
                        if (StringUtils.isNotEmpty(attr.targetAttr()))
                        {
                            propertyName = field.getName() + "." + attr.targetAttr();
                        }
                        else if (StringUtils.isNotEmpty(attr.readConverterExp()))
                        {
                            val = reverseByExp(Convert.toStr(val), attr.readConverterExp(), attr.separator());
                        }
                        else if (StringUtils.isNotEmpty(attr.dictType()))
                        {
                            val = reverseDictByExp(Convert.toStr(val), attr.dictType(), attr.separator());
                        }
                        // 反射个属性赋值。
                        ReflectUtils.invokeSetter(entity, propertyName, val);
                    }
                }
                // 将实体对象加入到容器中。
                list.add(entity);
            }
        }
        return list;
    }

导入的思路

核心点：表头的字段和 java实体类字段的映射。若依采用的是表头列的序号和java实体类的映射。（为了提高效率）

1. 通过导入的表格可以得到表头的序号和名称。
   Map<String, Integer> cellMap =
   {
   ​ “用户序号” : 0,
   ​ “部门编号” : 1,
   “用户名称” : 2
   ​ …
   }

2. 通过反射获取java实体类所有Filed对象，通过注解@Excel,筛选支持导入的字段，并从字段注解中获取表格中的对应的名称。结合cellMap封装成。 （Excel注解中默认支持导入导出，name属性值的是excel中表头的名称）
   Map<Integer, Field> fieldsMap=
   {
   0 : filed0,
   1 : filed1,
   ​ 2 : filed2
   ​ …
   }

3. 遍历读入的execl数据，通过每一行中，每一个单元格的序号，在fieldsMap中找到对应的filed对象，进行反射赋值。

4. 赋值过程中，根据filed字段的类型，进行单元格数据的处理。

5. 每一行数据对应一个java实体对象，将每一个实体对象保存到集合中。

6. 遍历集合，执行数据库插入操作。