前言
我们在工作中，会遇到项目在不同的环境运行，当我们需要将这个环境中的某些数据快速的移动到另一个环境，我们就可以通过导入导出json文件的方式实现。例如：我们将这个环境的数据库中用户信息导出为一份json格式文件，再直接将json文件复制到另一个环境导入到数据库，这样可以达到我们的目的。
下面我将使用springboot搭建用户数据信息的导入导出案例，实现了单用户和多用户数据库信息的导入导出功能。认真看完这篇文章，你一定能掌握导入导出json文件的核心
准备工作
需要maven依赖坐标：
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.29</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.13</version>
        </dependency>

数据库中的用户信息：

这些字段信息与Java中的UserEntity实体类一一对应


功能实现
准备好依赖和数据库信息之后，开始搭建用户导入导出具体框架：


导入导出单用户、多用户功能实现 UserUtil
package com.leige.test.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.leige.test.entity.UserEntity;
import com.leige.test.entity.UserEntityList;
import com.leige.test.model.ResultModel;
import com.leige.test.service.UserService;
import org.apache.commons.io.FileUtils;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.util.ObjectUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.util.List;
import java.util.UUID;

public class UserUtil {
    //导入用户
    public static ResultModel importUser(MultipartFile multipartFile, UserService userService) {
        ResultModel resultModel = new ResultModel();
        try {
            // 获取原始名字
            String fileName = multipartFile.getOriginalFilename();
            // 获取后缀名
            String suffixName = fileName.substring(fileName.lastIndexOf("."));
            //先将.json文件转为字符串类型
            File file = new File("/"+ fileName);
            //将MultipartFile类型转换为File类型
            FileUtils.copyInputStreamToFile(multipartFile.getInputStream(),file);
            String jsonString = FileUtils.readFileToString(file, "UTF-8");

            //如果是json或者txt文件
            if (".json".equals(suffixName) || ".txt".equals(suffixName)) {

                //再将json字符串转为实体类
                JSONObject jsonObject = JSONObject.parseObject(jsonString);

                UserEntity userEntity = JSONObject.toJavaObject(jsonObject, UserEntity.class);

                userEntity.setId(null);
                userEntity.setToken(UUID.randomUUID().toString());
                //调用创建用户的接口
                userService.addUser(userEntity);

            } else {
                resultModel.setStatusCode(0);
                resultModel.setStatusMes("请上传正确格式的.json或.txt文件！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultModel;
    }
    //批量导入用户
    public static ResultModel importUsers(MultipartFile multipartFile, UserService userService) {
        ResultModel resultModel = new ResultModel();
        try {
            // 获取原始名字
            String fileName = multipartFile.getOriginalFilename();
            // 获取后缀名
            String suffixName = fileName.substring(fileName.lastIndexOf("."));
            //先将.json文件转为字符串类型
            File file = new File("/"+ fileName);
            //将MultipartFile类型转换为File类型
            FileUtils.copyInputStreamToFile(multipartFile.getInputStream(),file);
            String jsonString = FileUtils.readFileToString(file, "UTF-8");

            //如果是json或者txt文件
            if (".json".equals(suffixName) || ".txt".equals(suffixName)) {

                //再将json字符串转为实体类
                JSONObject jsonObject = JSONObject.parseObject(jsonString);

                UserEntityList userEntityList = JSONObject.toJavaObject(jsonObject, UserEntityList.class);

                List<UserEntity> userEntities = userEntityList.getUserEntities();
                for (UserEntity userEntity : userEntities) {
                    userEntity.setId(null);
                    userEntity.setToken(UUID.randomUUID().toString());
                    //调用创建用户的接口
                    userService.addUser(userEntity);
                }
            } else {
                resultModel.setStatusCode(0);
                resultModel.setStatusMes("请上传正确格式的.json或.txt文件！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultModel;
    }
    //导出某个用户
    public static ResultModel exportUser(HttpServletResponse response, UserEntity userEntity, String fileName){
        ResultModel resultModel = new ResultModel();
        ObjectMapper objectMapper = new ObjectMapper();
        if (ObjectUtils.isEmpty(userEntity)){
            resultModel.setStatusCode(0);
            resultModel.setStatusMes("此用户id没有对应的用户");
            return resultModel;
        }else {
            try {
                String jsonString = objectMapper.writeValueAsString(userEntity);

                // 拼接文件完整路径// 生成json格式文件
                String fullPath = "/" + fileName;

                // 保证创建一个新文件
                File file = new File(fullPath);
                if (!file.getParentFile().exists()) { // 如果父目录不存在，创建父目录
                    file.getParentFile().mkdirs();
                }
                if (file.exists()) { // 如果已存在,删除旧文件
                    file.delete();
                }
                file.createNewFile();//创建新文件

                //将字符串格式化为json格式
                jsonString = jsonFormat(jsonString);
                // 将格式化后的字符串写入文件
                Writer write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
                write.write(jsonString);
                write.flush();
                write.close();

                FileInputStream fis = new FileInputStream(file);
                // 设置相关格式
                response.setContentType("application/force-download");
                // 设置下载后的文件名以及header
                response.setHeader("Content-Disposition", "attachment;filename="
                        .concat(String.valueOf(URLEncoder.encode(fileName, "UTF-8"))));
                response.setCharacterEncoding("utf-8");
                // 创建输出对象
                OutputStream os = response.getOutputStream();
                // 常规操作
                byte[] buf = new byte[1024];
                int len = 0;
                while((len = fis.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                fis.close();
                os.close();  //一定要记得关闭输出流，不然会继续写入返回实体模型
                return resultModel;
            } catch (Exception e) {
                resultModel.setStatusCode(0);
                resultModel.setStatusMes(e.getMessage());
                e.printStackTrace();
                return resultModel;
            }
        }
    }
    //导出所有用户
    public static ResultModel exportAllUser(HttpServletResponse response, UserEntityList userEntityList, String fileName){
        ResultModel resultModel = new ResultModel();
        ObjectMapper objectMapper = new ObjectMapper();
        if (ObjectUtils.isEmpty(userEntityList)){
            resultModel.setStatusCode(0);
            resultModel.setStatusMes("此用户id没有对应的用户");
            return resultModel;
        }else {
            try {
                String jsonString = objectMapper.writeValueAsString(userEntityList);

                // 拼接文件完整路径// 生成json格式文件
                String fullPath = "/" + fileName;

                // 保证创建一个新文件
                File file = new File(fullPath);
                if (!file.getParentFile().exists()) { // 如果父目录不存在，创建父目录
                    file.getParentFile().mkdirs();
                }
                if (file.exists()) { // 如果已存在,删除旧文件
                    file.delete();
                }
                file.createNewFile();//创建新文件

                //将字符串格式化为json格式
                jsonString = jsonFormat(jsonString);
                // 将格式化后的字符串写入文件
                Writer write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
                write.write(jsonString);
                write.flush();
                write.close();

                FileInputStream fis = new FileInputStream(file);
                // 设置相关格式
                response.setContentType("application/force-download");
                // 设置下载后的文件名以及header
                response.setHeader("Content-Disposition", "attachment;filename="
                        .concat(String.valueOf(URLEncoder.encode(fileName, "UTF-8"))));
                response.setCharacterEncoding("utf-8");
                // 创建输出对象
                OutputStream os = response.getOutputStream();
                // 常规操作
                byte[] buf = new byte[1024];
                int len = 0;
                while((len = fis.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                fis.close();
                os.close();     //一定要记得关闭输出流，不然会继续写入返回实体模型
                return resultModel;
            } catch (Exception e) {
                resultModel.setStatusCode(0);
                resultModel.setStatusMes(e.getMessage());
                e.printStackTrace();
                return resultModel;
            }
        }
    }
    //将字符串格式化为json格式的字符串
    public static String jsonFormat(String jsonString) {
        JSONObject object= JSONObject.parseObject(jsonString);
        jsonString = JSON.toJSONString(object, SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteDateUseDateFormat);
        return jsonString;
    }
}

1. 启动项目，浏览器输入访问 http://localhost:8888/export/users 导出所有已有用户json文件




打开json文件查看格式是否正确



2. 浏览器输入访问 http://localhost:8888/ 批量导入用户

导入 users.json 文件



输入地址，点击提交


查看数据库，发现增加的两条测试用户1,2成功！


导入导出单个用户这里就不测试了，更加简单，其他的关于springboot配置文件和实体类对应数据库信息也不详细说明了
如果这篇文章对你有用的话能否点个♥(ˆ◡ˆԅ)，谢谢宝贝❤

引入的jar maven坐标（pom.xml ）
	<dependency>
		<groupId>org.apache.poi</groupId>
		<artifactId>poi</artifactId>
		<version>3.15</version>
	</dependency>
	<dependency>
		<groupId>org.apache.poi</groupId>
		<artifactId>poi-ooxml-schemas</artifactId>
		<version>3.15</version>
	</dependency>
	<dependency>
		<groupId>org.apache.poi</groupId>
		<artifactId>poi-ooxml</artifactId>
		<version>3.15</version>
	</dependency>

实现
import com.synda.smp.log.entity.SyndaLog;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.util.List;


public interface LogService {
    XSSFWorkbook creatExcel(String fileName, List<SyndaLog> ids);
}

import com.synda.smp.log.entity.SyndaLog;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Service;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

@Service
public class LogServiceImpl implements LogService{


    @Override
    public XSSFWorkbook creatExcel(String fileName, List<SyndaLog> list) {
        XSSFWorkbook sheets = new XSSFWorkbook();
        //创建一张表
        Sheet sheet = sheets.createSheet(fileName);
        //创建表头,创建第一行，起始为0
        Row titleRow =sheet.createRow(0);
        Class<SyndaLog> logClass=SyndaLog.class;
        Field[] declaredFields = logClass.getDeclaredFields();
        List<String> methodNames=new ArrayList<>();
        int cells=0;
        for (int i=0;i<declaredFields.length;i++){
            cells++;
            titleRow.createCell(i).setCellValue(declaredFields[i].getName());
            methodNames.add("get"+declaredFields[i].getName().substring(0,1).toUpperCase()+declaredFields[i].getName().substring(1));
        }
        int cell = 1;
        for (SyndaLog syndaLog : list) {
            //从第二行开始保存数据
            Row row = sheet.createRow(cell);
            for (int i=0;i<methodNames.size();i++){
                Method method = null;
                Object invokeValue =null;
                try {
                    method = syndaLog.getClass().getMethod(methodNames.get(i));
                    invokeValue=method.invoke(syndaLog, new Object[0]);
                    String value=invokeValue.toString();
                    System.out.println(methodNames.get(i)+":"+value);
                    //将数据库的数据遍历出来
                    row.createCell(i).setCellValue(value);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            cell++;
        }
        return sheets;
    }
}


import com.synda.smp.log.repository.SyndaLogInterface;
import com.synda.smp.log.service.LogService;
import io.swagger.annotations.ApiParam;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedOutputStream;
import java.io.OutputStream;
import java.util.List;

import com.synda.smp.log.entity.SyndaLog;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  控制器
 * </p>
 *
 * @author gdc
 * @since 2020-07-14
 */

@RestController
@RequestMapping("/log")
public class SyndaLogController {
    @Autowired
    private LogService logService;
    @Resource
    private SyndaLogInterface repository;

    public void export(HttpServletResponse response,
                       @ApiParam(name = "ids", value = "需要导出的id集合", required = true)
                       @RequestParam(name = "ids")
                       String[] ids,
                       @ApiParam(name = "fileName", value = "导出文件名（无后缀）", required = true)
                       @RequestParam(name = "fileName")
                       String fileName){
        List<SyndaLog> syndaLogs = repository.findAllByIdInAndExportTagEquals(ids,0);
        String result=syndaLogs.size()>0?"result":null;
        Assert.notNull(result,"无数据导出");
        XSSFWorkbook sheets = logService.creatExcel(fileName,syndaLogs);
        this.setBrowser(response,sheets,fileName);
    }
    private  void setBrowser(HttpServletResponse response, XSSFWorkbook workbook, String fileName) {
        try {
            //清空response
            response.reset();
            //设置response的Header
            response.addHeader("Content-Disposition", "attachment;filename=" + fileName);
            OutputStream os = new BufferedOutputStream(response.getOutputStream());
            response.setContentType("application/vnd.ms-excel;charset=gb2312");
            //将excel写入到输出流中
            workbook.write(os);
            os.flush();
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

基于SSM的excel表格数据导入导出到数据库
SSM的坏境搭建暂不介绍
一、导入到数据库
1、首先在pom.xml文件中加入poi的maven坐标依赖
		<!--poi-->
		<dependency>
		  <groupId>org.apache.poi</groupId>
		  <artifactId>poi</artifactId>
		  <version>3.14</version>
		</dependency>
		<dependency>
		  <groupId>org.apache.poi</groupId>
		  <artifactId>poi-ooxml</artifactId>
		  <version>3.14</version>
		</dependency>

2、加入读文件和读出文件的工具类
package com.fg.utils;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.web.multipart.MultipartFile;

public class POIUtils {
    private final static String xls = "xls";
    private final static String xlsx = "xlsx";
    private final static String DATE_FORMAT = "yyyy/MM/dd";
    
    /**
     * 读入excel文件，解析后返回
     * @param file
     * @throws IOException
     */
    public static List<String[]> readExcel(MultipartFile file) throws IOException {
        //检查文件
        checkFile(file);
        //获得Workbook工作薄对象
        Workbook workbook = getWorkBook(file);
        //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回
        List<String[]> list = new ArrayList<String[]>();
        if(workbook != null){
            for(int sheetNum = 0;sheetNum < workbook.getNumberOfSheets();sheetNum++){
                //获得当前sheet工作表
                Sheet sheet = workbook.getSheetAt(sheetNum);
                if(sheet == null){
                    continue;
                }
                //获得当前sheet的开始行
                int firstRowNum  = sheet.getFirstRowNum();
                //获得当前sheet的结束行
                int lastRowNum = sheet.getLastRowNum();
                //循环除了第一行的所有行
                for(int rowNum = firstRowNum+1;rowNum <= lastRowNum;rowNum++){
                    //获得当前行
                    Row row = sheet.getRow(rowNum);
                    if(row == null){
                        continue;
                    }
                    //获得当前行的开始列
                    int firstCellNum = row.getFirstCellNum();
                    //获得当前行的列数
                    int lastCellNum = row.getPhysicalNumberOfCells();
                    String[] cells = new String[row.getPhysicalNumberOfCells()];
                    //循环当前行
                    for(int cellNum = firstCellNum; cellNum < lastCellNum;cellNum++){
                        Cell cell = row.getCell(cellNum);
                        cells[cellNum] = getCellValue(cell);
                    }
                    list.add(cells);
                }
            }
            workbook.close();
        }
        return list;
    }

    //校验文件是否合法
    public static void checkFile(MultipartFile file) throws IOException{
        //判断文件是否存在
        if(null == file){
            throw new FileNotFoundException("文件不存在！");
        }
        //获得文件名
        String fileName = file.getOriginalFilename();
        //判断文件是否是excel文件
        if(!fileName.endsWith(xls) && !fileName.endsWith(xlsx)){
            throw new IOException(fileName + "不是excel文件");
        }
    }
    
    public static Workbook getWorkBook(MultipartFile file) {
        //获得文件名
        String fileName = file.getOriginalFilename();
//        //System.out.println(fileName);
        //创建Workbook工作薄对象，表示整个excel
        Workbook workbook = null;
        try {
            //获取excel文件的io流
            InputStream is = file.getInputStream();
//            //System.out.println(is);
            //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象
            if(fileName.endsWith(xls)){
                //2003
                workbook = new HSSFWorkbook(is);
            }else if(fileName.endsWith(xlsx)){
                //2007
                workbook = new XSSFWorkbook(is);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return workbook;
    }
    
    public static String getCellValue(Cell cell){
        String cellValue = "";
        if(cell == null){
            return cellValue;
        }
        //如果当前单元格内容为日期类型，需要特殊处理
        String dataFormatString = cell.getCellStyle().getDataFormatString();
        if(dataFormatString.equals("m/d/yy")){
            cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());
            return cellValue;
        }
        //把数字当成String来读，避免出现1读成1.0的情况
        if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
            cell.setCellType(Cell.CELL_TYPE_STRING);
        }
        //判断数据的类型
        switch (cell.getCellType()){
            case Cell.CELL_TYPE_NUMERIC: //数字
                cellValue = String.valueOf(cell.getNumericCellValue());
                break;
            case Cell.CELL_TYPE_STRING: //字符串
                cellValue = String.valueOf(cell.getStringCellValue());
                break;
            case Cell.CELL_TYPE_BOOLEAN: //Boolean
                cellValue = String.valueOf(cell.getBooleanCellValue());
                break;
            case Cell.CELL_TYPE_FORMULA: //公式
                cellValue = String.valueOf(cell.getCellFormula());
                break;
            case Cell.CELL_TYPE_BLANK: //空值
                cellValue = "";
                break;
            case Cell.CELL_TYPE_ERROR: //故障
                cellValue = "非法字符";
                break;
            default:
                cellValue = "未知类型";
                break;
        }
        return cellValue;
    }
}


3、控制器类实现
    /**
	 * 读取excel文件
	 * @param excelFile
	 * @return
	 */
	@RequestMapping(value ="/read" , method = RequestMethod.POST) 
	public String  upload(@RequestParam(value ="excelFile",required= false) MultipartFile excelFile){			
		List<String[]> lists;
		try {
			lists = POIUtils.readExcel(excelFile);
//			//System.out.println(lists);
			// 把List<String[]> 数据转换成 List<OrderSetting>数据
	        List<User> user = new ArrayList<>();
	        for (String[] str : lists) {
	          //根据具体实体类添加字段
				User user1 = new User();
				user1.setId(str[0]);
				user1.setName(str[1]);
				user1.setAge(str[2]);
				user.add(user1);
			}
	        userInfoService.add(user);
	        return "success"; //返回成功视图
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			 return "shibai";//返回失败视图
		}	
	}

4、service层调用dao层循环进行数据的插入

5、dao层基于注解或者其他方式连接数据库，插入数据
二、从数据库里面导出数据
1、控制器类书写
/**
	 * 导出
	 * @param response
	 * @return
	 */
	@RequestMapping(value="/download_excel")    
	//获取url链接上的参数
	public @ResponseBody String dowm(HttpServletResponse response){
	     response.setContentType("application/binary;charset=UTF-8");
	              try{
	                  ServletOutputStream out=response.getOutputStream();
	                  try {
	                      //设置文件头：最后一个参数是设置下载文件名
	                      response.setHeader("Content-Disposition", "attachment;fileName=" + 
	                      URLEncoder.encode("学生信息表.xls", "UTF-8"));//生成表名
	                  } catch (UnsupportedEncodingException e1) {
	                      e1.printStackTrace();
	                  }
	                  String[] titles = { "用户id", "用户姓名", "用户年龄" }; 
	                  userInfoService.export(titles, out);      
	                  return "success";
	              } catch(Exception e){
	                  e.printStackTrace();
	                  return "导出信息失败";
	              }
	    }

2、service实现类的编写
/**
	 * 导出信息
	 * @param titles
	 * @param out
	 * @throws Exception
	 */
	@SuppressWarnings("resource")
	public void export(String[] titles, ServletOutputStream out) throws Exception{
		try{
	         // 第一步，创建一个workbook，对应一个Excel文件	      
			 HSSFWorkbook workbook = new HSSFWorkbook();
	         // 第二步，在webbook中添加一个sheet,对应Excel文件中的sheet
	         HSSFSheet hssfSheet = workbook.createSheet("sheet1");
	         // 第三步，在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制short     
	         HSSFRow row = hssfSheet.createRow(0);
	         // 第四步，创建单元格，并设置值表头 设置表头居中
	         HSSFCellStyle hssfCellStyle = workbook.createCellStyle();
	         //居中样式
	         hssfCellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
	         HSSFCell hssfCell = null;
	          for (int i = 0; i < titles.length; i++) {
	             hssfCell = row.createCell(i);//列索引从0开始
	             hssfCell.setCellValue(titles[i]);//列名1
	             hssfCell.setCellStyle(hssfCellStyle);//列居中显示                
	            }
	             ArrayList<User> list = userInfoDao.findAll();
	             for (int i = 0; i < list.size(); i++) {
	                  row = hssfSheet.createRow(i+1);                
	                  User user = list.get(i);
	                  // 第六步，创建单元格，并设置值
	                  String  id = null;
	                 if(user.getId() != null){
	                     id = user.getId();
	                 }
	                 row.createCell(0).setCellValue(id);
	                 String name = "";
	                 if(user.getName() != null){
	                     name = user.getName();
	                 }
	                 row.createCell(1).setCellValue(name);
	                 String age = "";            
	                 if(user.getAge()!= null){
	                     age = user.getAge();
	                 }
	                 row.createCell(2).setCellValue(age);  
	                }
	                 // 第七步，将文件输出到客户端浏览器
	              try {
	                 workbook.write(out);
	                 out.flush();
	                 out.close();   
	               }catch (Exception e) {
	                 e.printStackTrace();
	             }
	           }catch(Exception e){
	             e.printStackTrace();
	            throw new Exception("导出信息失败！");	        
	         }
	     }

以上代码是实现excel表格数据导入导出到数据库的主要代码，欢迎大家学习

全世界78707个主要城市信息MYSQL数据库，包含经纬度坐标值，已经导出成了SQL文件，因为比较大，有10M，所以这里单独导出来，供升级失败的同学手工导入，如图：



 

这个数据主要是用于天气预报插件的，天气预报插件，需要首先从这个库里面，查询城市的ID，在把ID传给接口，返回天气预报数据。

 

下载请到 ：http://blog.erdaicms.com