Excel导出工具-POI

<dependencies>
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>3.9</version>
</dependency>

<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
<version>3.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-nop -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-nop</artifactId>
<version>1.7.25</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.21</version>
</dependency>

<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.41</version>
</dependency>

</dependencies>

package com.h.util.excel;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;

import java.util.List;
import java.util.Map;

/**
* 导出Excel文档工具类
*/
public class ExcelUtil {

public static Workbook getSXSSFWorkBook() {
return new SXSSFWorkbook();
}

public static Workbook getHSSFWorkbook() {
return new HSSFWorkbook();
}

public static Workbook createWorkBook(String sheetName, List<Map<String, Object>> list, String[] keys, String columnNames[]) {
// 创建excel工作簿
SXSSFWorkbook wb = new SXSSFWorkbook();
return createWorkBook(wb, sheetName, list, keys, columnNames);
}

/**
* 创建excel文档,数据导出为单个工作表sheet
*
* @param sheetName   工作表名
* @param list        数据
* @param keys        list中map的key数组集合
* @param columnNames excel的列名
*/
public static Workbook createWorkBook(Workbook wb, String sheetName, List<Map<String, Object>> list, String[] keys, String columnNames[]) {
// 创建第一个sheet（页），并命名
Sheet sheet = wb.createSheet(sheetName);
// 手动设置列宽。第一个参数表示要为第几列设；，第二个参数表示列的宽度，n为列高的像素数。
for (int i = 0; i < keys.length; i++) {
sheet.setColumnWidth((short) i, (short) (35.7 * 150));
}

// 创建两种单元格格式
CellStyle cs = wb.createCellStyle();
CellStyle cs2 = wb.createCellStyle();

// 创建第一种字体样式（用于列名）
Font f = wb.createFont();
f.setFontHeightInPoints((short) 10);
f.setColor(IndexedColors.BLACK.getIndex());
f.setBoldweight(Font.BOLDWEIGHT_BOLD);

// 创建第二种字体样式（用于值）
Font f2 = wb.createFont();
f2.setFontHeightInPoints((short) 10);
f2.setColor(IndexedColors.BLACK.getIndex());

// 设置第一种单元格的样式（用于列名）
cs.setFont(f);
cs.setBorderLeft(CellStyle.BORDER_THIN);
cs.setBorderRight(CellStyle.BORDER_THIN);
cs.setBorderTop(CellStyle.BORDER_THIN);
cs.setBorderBottom(CellStyle.BORDER_THIN);
cs.setAlignment(CellStyle.ALIGN_CENTER);

// 设置第二种单元格的样式（用于值）
cs2.setFont(f2);
cs2.setBorderLeft(CellStyle.BORDER_THIN);
cs2.setBorderRight(CellStyle.BORDER_THIN);
cs2.setBorderTop(CellStyle.BORDER_THIN);
cs2.setBorderBottom(CellStyle.BORDER_THIN);
cs2.setAlignment(CellStyle.ALIGN_CENTER);

// 创建第一行
Row row = sheet.createRow((short) 0);
//设置列名
for (int i = 0; i < columnNames.length; i++) {
Cell cell = row.createCell(i);
cell.setCellValue(columnNames[i]);
cell.setCellStyle(cs);
}
//设置每行每列的值
Row row1 = null;
Map<String, Object> rowMap = null;
for (int i = 1; i < list.size(); i++) {
// Row 行,Cell 方格 , Row 和 Cell 都是从0开始计数的
// 创建一行，在页sheet上
row1 = sheet.createRow(i);
rowMap = list.get(i);
// 在row行上创建一个方格
for (short j = 0; j < keys.length; j++) {
Cell cell = row1.createCell(j);
cell.setCellValue(rowMap.get(keys[j]) == null ? " " : rowMap.get(keys[j]).toString());
cell.setCellStyle(cs2);
}
}
return wb;
}

/**
* 创建excel文档,数据导出为多张工作表sheet
* @param sheetNames  工作表的名字集合
* @param list        数据,集合中的每个元素代表一张sheet的数据集合
* @param keys        list中map的key数组集合
* @param columnNames excel的列名
*/
public static Workbook createFWorkBooks(Workbook wb, List<String> sheetNames, List<List<Map<String, Object>>> list, List<String[]> keys, List<String[]> columnNames) {
// 创建第一个sheet（页），并命名
if (sheetNames != null) {
int size = sheetNames.size();
if (list == null || keys == null || columnNames == null
|| list.size() != size || keys.size() != size || columnNames.size() != size) {
return null;
}

for (int i = 0; i < size; i++) {
createWorkBook(wb, shee
1adab
tNames.get(i), list.get(i), keys.get(i), columnNames.get(i));
}
}
return wb;
}
}

package com.h.util.excel;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
* @author wanghong
* @desc
* @date: 2017/12/18  9:54
* @Copyright (c) 2017, DaChen All Rights Reserved.
*/
public class ExportHelper {

private static final Logger logger = LoggerFactory.getLogger(ExportHelper.class);

/**
* 导出数据到Excel,直接在浏览器端下载为Excel
* @param response
* @param fileName
* @param columnNames
* @param keys
* @param list
* @throws IOException
*/
public static void writeDataToExcel(HttpServletResponse response, String fileName,String sheetName, String[] columnNames,
String[] keys, List<Map<String, Object>> list) throws IOException {
ByteArrayOutputStream os = new ByteArrayOutputStream();
ExcelUtil.createWorkBook(sheetName,list, keys, columnNames).write(os);
byte[] content  = os.toByteArray();
InputStream is = new ByteArrayInputStream(content);

// 设置response参数，可以打开下载页面
response.reset();
response.setContentType("application/vnd.ms-excel;charset=utf-8");
response.setHeader("Content-Disposition",
"attachment;filename=" + new String((fileName + ".xlsx").getBytes(), "iso-8859-1"));
ServletOutputStream out = response.getOutputStream();
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(is);
bos = new BufferedOutputStream(out);
byte[] buff = new byte[2048];
int bytesRead;
while (-1 != (bytesRead = bis.read(buff, 0, buff.length))) {
bos.write(buff, 0, bytesRead);
}
} catch (IOException e) {
logger.error(e.getMessage(), e);
throw e;
} finally {
if (bis != null) {
try {
bis.close();
}catch (IOException e){
logger.error(e.getMessage(), e);
}
}
if (bos != null) {
try {
bos.close();
}catch (IOException e){
logger.error(e.getMessage(), e);
}
}
}
}

/**
* 将List<T>转换为Excel行记录
* @param list
* @return
* @throws Exception
*/
public static List<Map<String, Object>> createExcelRecord(List<?> list) throws Exception {
List<Map<String, Object>> listmap = new ArrayList<>(list.size());
for (Object obj : list) {
listmap.add(MapConvertUtil.beanToMap(obj));
}
return listmap;
}
}

package com.h.util.excel;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

/**
* @author wanghong
* @desc
* @date: 2017/12/6  10:38
* @Copyright (c) 2017, DaChen All Rights Reserved.
*/
public class MapConvertUtil {

/**
* Bean -> Map(若存在父类,无法转换从父类中继承的属性)
* @param o
* @return
* @throws Exception
*/
public static Map<String, Object> beanToMap(Object o) throws Exception{
Field[] fields = o.getClass().getDeclaredFields();
Map<String, Object> map = new HashMap<>(fields.length);
for (Field field : fields) {
field.setAccessible(true);
map.put(field.getName(), field.get(o));
}
return map;
}

public static <T> T mapToBean(Map<String,Object> map,Class<T> cls) throws Exception{
T t = null;
if (!map.isEmpty()) {
t = cls.newInstance();
for (Map.Entry entry:map.entrySet()){
Field[] fields = cls.getDeclaredFields();
for (Field field : fields) {
int mod = field.getModifiers();
if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
continue;
}
if (field.getName().equals(entry.getKey())) {
field.setAccessible(true);
field.set(t, entry.getValue());
}
}
}
}
return t;
}

}

package com.h.util.excel;

import com.alibaba.fastjson.JSONObject;

public class JSONMessage extends JSONObject {

public static final Object EMPTY_OBJECT = new Object();
public static final int COMMON_ERROR = 100;//标准错误
public static final int TOKEN_INVALID = 1030102;//token不存在
public static final int TOKEN_ERROR = 100001;//token错误
public static final int PARAM_ERROR = 100200;//token参数错误
public static final int GUEST_TOKEN_ERROP = 1030104;//游客令牌错误
public static final int IDENTITY_ERROR = 100300;//身份标识错误
public static final int Failure = 0;//失败
public static final int Success = 1;//成功
private static final long serialVersionUID = 1L;

public JSONMessage() {
}

public JSONMessage(int resultCode, String resultMsg) {
setResultCode(resultCode);
setResultMsg(resultMsg);
}

public JSONMessage(int resultCode, String resultMsg, String detailMsg) {
setResultCode(resultCode);
setResultMsg(resultMsg);
setDetailMsg(detailMsg);
}

public JSONMessage(int resultCode, String resultMsg, Object data) {
setResultCode(resultCode);
setResultMsg(resultMsg);
setData(data);
}

public JSONMessage(String groupCode, String serviceCode, String nodeCode,
String resultMsg) {
setResultCode(new StringBuffer().append(groupCode).append(serviceCode)
.append(nodeCode).toString());
setResultMsg(resultMsg);
}

public static JSONMessage success(String resultMsg) {
return new JSONMessage(Success, resultMsg);
}

public static JSONMessage success() {
return success(null, null);
}

public static JSONMessage success(Object data) {
return success(null, data);
}

public static JSONMessage success(String resultMsg, Object data) {
return new JSONMessage(Success, resultMsg, data);
}

public static JSONMessage failure(String resultMsg) {
return new JSONMessage(Failure, resultMsg);
}

public static JSONMessage error(Exception e) {
return new JSONMessage(1020101, "服务器繁忙，请稍后再试！", e.getMessage());
}

public Object getResultCode() {
return get("resultCode");
}

public void setResultCode(Object resultCode) {
put("resultCode", resultCode);
}

public String getResultMsg() {
return getString("resultMsg");
}

public void setResultMsg(String resultMsg) {
put("resultMsg", resultMsg);
}

public String getDetailMsg() {
return getString("detailMsg");
}

public void setDetailMsg(String detailMsg) {
put("detailMsg", detailMsg);
}

public Object getData() {
return get("data");
}

public void setData(Object data) {
put("data", data);
}

}

package com.dachen.export.controller;

import com.dachen.export.entity.health.DoctorExcelVO;
import com.dachen.export.service.UserExcelService;
import com.dachen.export.util.ExportHelper;
import com.dachen.export.util.JSONMessage;
import com.dachen.util.TimeUtil;
import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;

/**
* @author wanghong
* @desc
* @date: 2017/12/18  10:01
* @Copyright (c) 2017, DaChen All Rights Reserved.
*/
@RequestMapping("/export")
@RestController
public class ExportController {
private final static Logger logger = LoggerFactory.getLogger(ExportController.class);

@Autowired
private UserExcelService userExcelService;

/**
* 导出医生数据(按注册时间范围导出)
* @param response
* @param startTime
* @param endTime
*/
@RequestMapping(value = "/exportDoctor/{startTime}/{endTime}", method = RequestMethod.GET)
public JSONMessage exportDoctor(HttpServletResponse response, @PathVariable String startTime, @PathVariable  String endTime) {
logger.info("/exportPhoneMeeting:入参startTime=" + startTime + ",endTime=" + endTime);
try {
long start = TimeUtil.stringToLong(startTime, "yyyy-MM-dd");
long end = TimeUtil.stringToLong(endTime, "yyyy-MM-dd");
if (start > end){
return JSONMessage.failure("开始时间不能大于结束时间!");
}
List<DoctorExcelVO> doctorExcelVOList = userExcelService.getDoctorByRegisterTime(start, end);
if (CollectionUtils.isEmpty(doctorExcelVOList)){
return JSONMessage.failure("没有查询到数据");
}

List<Map<String,Object>> list = userExcelService.listToMap(doctorExcelVOList);

String fileName = "医生数据";
String[] columnNames = {"审核状态","账号身份","科室","职称","姓名","手机号","邀请人姓名","注册来源","注册时间","提交审核时间","审核通过时间","最后登陆时间","医疗机构名称","医院id","省","市","区","用户OPENID","邀请人OPENID","已加入的圈子"};
String[] keys = {"status","userLevel","departments","title","username","telephone","inviterName","source","registerTime","submitTime","checkTime","lastLoginTime","hospital","hospitalId","province","city","country","openId","inviterOpenId","circleNames"};

ExportHelper.writeData(response,fileName,columnNames,keys,list);
} catch (Exception e) {
logger.error(e.getMessage(), e);
return JSONMessage.error(e);
}

return JSONMessage.success();
}

}

package com.dachen.export.service;

import com.dachen.auth2.dao.Auth2DAO;
import com.dachen.auth2.entity.Auth2User;
import com.dachen.drugorg.dao.IDrugOrgDao;
import com.dachen.drugorg.entity.CompanyUser;
import com.dachen.export.dao.UserExcelDao;
import com.dachen.export.entity.health.DoctorExcelVO;
import com.dachen.health.entity.UserEnum;
import com.dachen.qora.ServiceException;
import com.dachen.util.TimeUtil;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
* @author wanghong
* @desc
* @date: 2017/12/18  16:10
* @Copyright (c) 2017, DaChen All Rights Reserved.
*/
@Service
public class UserExcelService {
@Autowired
private UserExcelDao userExcelDao;

@Autowired
private IDrugOrgDao drugOrgDao;

@Autowired
private Auth2DAO auth2DAO;

@Autowired
private CircleExcelService circleExcelService;

/**
* 根据注册时间(创建时间)查询医生数据
* @param startTime 注册开始时间
* @param endTime  注册结束时间
* @return
*/
public List<DoctorExcelVO> getDoctorByRegisterTime(long startTime, long endTime) {
if (Objects.isNull(startTime) || Objects.isNull(endTime)){
throw new ServiceException("开始或结束时间不能为空!");
}
List<DoctorExcelVO> doctors = userExcelDao.getDoctorByRegisterTime(startTime, endTime);
doctors = warpOpenId(doctors);
doctors = warpInviterOpenId(doctors);
doctors = wrapCircleNames(doctors);
return doctors;
}

private List<DoctorExcelVO> wrapCircleNames(List<DoctorExcelVO> doctors) {
List<String> doctorStringIds = new ArrayList<>(doctors.parallelStream().map(DoctorExcelVO::getUserId).collect(Collectors.toSet()));
int querySize = doctorStringIds.size();
//进行分页查询
int index = 0;
int perSize = 100;
Map<String, Object> circleNameMap = new HashMap<>();
Map<String, Object> tempMap = null;
List<String> subUserIds = null;
while (querySize > index){
int last = Math.min(querySize,index + perSize);
subUserIds = doctorStringIds.subList(index, last);
tempMap = circleExcelService.getCircleNameByUserIds(subUserIds);
if (!tempMap.isEmpty()){
circleNameMap.putAll(tempMap);
}
index += perSize;
}

if (!circleNameMap.isEmpty()){
for (DoctorExcelVO doctor:doctors){
for (Map.Entry<String,Object> entry:circleNameMap.entrySet()){
String key = entry.getKey();
Map<String,Object> value = (Map<String,Object>)entry.getValue();
if (Objects.equals(doctor.getUserId(),key)){
List<String> circleNameList = (List<String>)value.get("circle");
doctor.setCircleNames(CollectionUtils.isEmpty(circleNameList) ? "":String.join(",",circleNameList));
}
}
}
}

return doctors;
}

private List<DoctorExcelVO> warpOpenId(List<DoctorExcelVO> doctors) {
List<String> doctorIds = doctors.parallelStream().map(DoctorExcelVO::getUserId).collect(Collectors.toList());
List<Integer> integers = doctorIds.stream().map(Integer::parseInt).collect(Collectors.toList());
List<Auth2User> auth2Users = auth2DAO.findByIds(integers);
Map<Integer, Auth2User> map = auth2Users.parallelStream().collect(Collectors.toMap(Auth2User::getUserId, a->a));
Auth2User auth2User = null;
for (DoctorExcelVO doctor : doctors) {
auth2User = map.get(Integer.valueOf(doctor.getUserId()));
if (Objects.nonNull(auth2User)) {
doctor.setOpenId(auth2User.getOpenId());
}
}

return doctors;
}

private List<DoctorExcelVO> warpInviterOpenId(List<DoctorExcelVO> doctors) {
List<String> inviterDoctorIds = new ArrayList<>();
List<String> inviterDrugIds = new ArrayList<>();
if(!CollectionUtils.isEmpty(doctors)){
for(DoctorExcelVO doctor : doctors){
if(Objects.equals(doctor.getSourceType(), UserEnum.Source.drugOrg.getIndex())&&Objects.nonNull(doctor.getInviterId())){
inviterDrugIds.add(doctor.getInviterId());
}
if(Objects.equals(doctor.getSourceType(), UserEnum.Source.doctorCircle.getIndex())&&Objects.nonNull(doctor.getInviterId())){
inviterDoctorIds.add(doctor.getInviterId());
}
}
}
List<Integer> integerDoctors = inviterDoctorIds.stream().map(Integer::parseInt).collect(Collectors.toList());
//获取医生
Map<String, DoctorExcelVO> doctorUsersMap = findDoctorByIds(integerDoctors);
List<Integer> integerDrugs = inviterDrugIds.stream().map(Integer::parseInt).collect(Collectors.toList());
List<CompanyUser> drugUsers = drugOrgDao.findByIds(integerDrugs);
Map<Integer, CompanyUser> drugUsersmap = drugUsers.parallelStream().collect(Collectors.toMap(CompanyUser::getUserId, a->a));
CompanyUser companyUser = null;
DoctorExcelVO user = null;
if(!CollectionUtils.isEmpty(doctors)){
for (DoctorExcelVO doctor : doctors) {
if(Objects.equals(doctor.getSourceType(), UserEnum.Source.drugOrg.getIndex())&&Objects.nonNull(doctor.getInviterId())){
companyUser = drugUsersmap.get(Integer.parseInt(doctor.getInviterId()));
if(Objects.nonNull(companyUser)){
doctor.setInviterOpenId(companyUser.getOpenId());
doctor.setInviterName(companyUser.getName());
}
}

if(Objects.equals(doctor.getSourceType(), UserEnum.Source.doctorCircle.getIndex())&&Objects.nonNull(doctor.getInviterId())){
user = doctorUsersMap.get(doctor.getInviterId());
if(Objects.nonNull(user)){
doctor.setInviterOpenId(user.getOpenId());
doctor.setInviterName(user.getUsername());
}
}
}
}
return doctors;
}

private Map<String,DoctorExcelVO> findDoctorByIds(List<Integer> ids) {
List<DoctorExcelVO> doctors = userExcelDao.findDoctorByIds(ids);
Map<String,DoctorExcelVO> map = doctors.parallelStream().collect(Collectors.toMap(DoctorExcelVO::getUserId, d -> d));
return map;
}

public List<Map<String,Object>> listToMap(List<DoctorExcelVO> doctorExcelVOList) {
List<Map<String,Object>> result = new ArrayList<>(doctorExcelVOList.size());
Map<String, Object> sheet = new HashMap<String, Object>();
sheet.put("sheetName", "sheet1");
result.add(sheet);
Map<String,Object> map = null;
for (DoctorExcelVO doctor:doctorExcelVOList){
map = new HashMap<>();
map.put("status",doctor.getStatus());
map.put("userLevel",doctor.getUserLevel());
map.put("departments",doctor.getDepartments());
map.put("title",doctor.getTitle());
map.put("username",doctor.getUsername());
map.put("telephone",doctor.getTelephone());
map.put("inviterName",doctor.getInviterName());
map.put("source",doctor.getSource());
if (Objects.nonNull(doctor.getRegisterTime())) {
map.put("registerTime", TimeUtil.df3.format(doctor.getRegisterTime()));
}
if (Objects.nonNull(doctor.getSubmitTime())){
map.put("submitTime",TimeUtil.df3.format(doctor.getSubmitTime()));
}
if (Objects.nonNull(doctor.getCheckTime())){
map.put("checkTime",TimeUtil.df3.format(doctor.getCheckTime()));
}
if (Objects.nonNull(doctor.getLastLoginTime())){
map.put("lastLoginTime",TimeUtil.df3.format(doctor.getLastLoginTime()));
}
map.put("hospital",doctor.getHospital());
map.put("hospitalId",doctor.getHospitalId());
map.put("province",doctor.getProvince());
map.put("city",doctor.getCity());
map.put("country",doctor.getCountry());
map.put("openId",doctor.getOpenId());
map.put("inviterOpenId",doctor.getInviterOpenId());
map.put("circleNames",doctor.getCircleNames());
result.add(map);
}
return result;
}
}

package com.dachen.export.dao;

import com.dachen.export.entity.health.DoctorExcelVO;
import com.dachen.export.entity.health.UserEnum;
import com.dachen.util.MongodbUtil;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.QueryOperators;
import org.mongodb.morphia.AdvancedDatastore;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.util.*;

/**
* @author wanghong
* @desc
* @date: 2017/12/18  11:32
* @Copyright (c) 2017, DaChen All Rights Reserved.
*/
@Repository
public class UserExcelDao {
@Resource(name = "healthDataSource")
protected AdvancedDatastore dsForRW;

/**
* 根据注册时间(创建时间)查询医生数据
* @param startTime 注册开始时间
* @param endTime  注册结束时间
* @return
*/
public List<DoctorExcelVO> getDoctorByRegisterTime(long startTime, long endTime) {
List<DoctorExcelVO> doctors = new ArrayList<>();

DBObject query = new BasicDBObject();
query.put("userType",3);//userType=3,表示医生
DBObject object = new BasicDBObject(QueryOperators.GTE, startTime);
object.put(QueryOperators.LTE, endTime);
query.put("createTime", object);

DBCursor cursor = dsForRW.getDB().getCollection("user").find(query);
while (cursor.hasNext()){
DBObject obj = cursor.next();
DoctorExcelVO doctor = new DoctorExcelVO();
doctor.setUserId(MongodbUtil.getString(obj,"_id"));
Integer status = MongodbUtil.getInteger(obj, "status");
doctor.setStatus(UserEnum.UserStatus.getEnum(status).getTitle());
doctor.setUsername(MongodbUtil.getString(obj,"name"));
doctor.setTelephone(MongodbUtil.getString(obj,"telephone"));
DBObject doctorObject = (DBObject) obj.get("doctor");
if (Objects.nonNull(doctorObject)) {
doctor.setDepartments(MongodbUtil.getString(doctorObject,"departments"));
doctor.setTitle(MongodbUtil.getString(doctorObject,"title"));
DBObject checkobj = (DBObject) doctorObject.get("check");
if (Objects.nonNull(checkobj)){
doctor.setCheckTime(MongodbUtil.getLong(checkobj,"checkTime"));
}
doctor.setHospital(MongodbUtil.getString(doctorObject,"hospital"));
doctor.setHospitalId(MongodbUtil.getString(doctorObject,"hospitalId"));
doctor.setProvince(MongodbUtil.getString(doctorObject,"province"));
doctor.setCity(MongodbUtil.getString(doctorObject,"city"));
doctor.setCountry(MongodbUtil.getString(doctorObject,"country"));
}
Integer userLevel = MongodbUtil.getInteger(obj, "userLevel");
doctor.setUserLevel(UserEnum.UserLevel.getName(userLevel));
Object sourceObject = obj.get("source");
if (Objects.nonNull(sourceObject)) {
DBObject dbSourceObject = (DBObject) sourceObject;
doctor.setInviterId(MongodbUtil.getString(dbSourceObject, "inviterId"));
Integer sourceType = MongodbUtil.getInteger(dbSourceObject, "sourceType");
if (Objects.nonNull(sourceType)){
doctor.setSourceType(sourceType);
doctor.setSource(Objects.isNull(  com.dachen.health.entity.UserEnum.Source.getEnum(sourceType)) ? "":  com.dachen.health.entity.UserEnum.Source.getEnum(sourceType).getSource());
}
}
doctor.setRegisterTime(MongodbUtil.getLong(obj,"createTime"));
doctor.setSubmitTime(MongodbUtil.getLong(obj,"submitTime"));
doctor.setLastLoginTime(MongodbUtil.getLong(obj,"lastLoginTime"));

doctors.add(doctor);
}

return doctors;
}

public List<DoctorExcelVO> findDoctorByIds(List<Integer> ids) {
List<DoctorExcelVO> doctors = new ArrayList<>(ids.size());

if (org.apache.commons.collections.CollectionUtils.isEmpty(ids)){
return doctors;
}

Set<Integer> set = new HashSet<>(ids);
DBObject query = new BasicDBObject();
DBObject userIdObjects = new BasicDBObject();
userIdObjects.put("$in", set);
query.put("_id", userIdObjects);
DBCursor cursor = dsForRW.getDB().getCollection("user").find(query);

while (cursor.hasNext()) {

DBObject obj = cursor.next();
DoctorExcelVO doctor = new DoctorExcelVO();
doctor.setUserId(MongodbUtil.getString(obj, "_id"));
doctor.setUsername(MongodbUtil.getString(obj, "name"));
Object doctorObject = obj.get("doctor");
if (Objects.isNull(doctorObject)) {
continue;
}

Object sourceObject = obj.get("source");
if (Objects.nonNull(sourceObject)) {
DBObject dbSourceObject = (DBObject) sourceObject;
doctor.setInviterId(MongodbUtil.getString(dbSourceObject, "inviterId"));
doctor.setSourceType(MongodbUtil.getInteger(dbSourceObject, "sourceType"));
}
doctors.add(doctor);
}
return doctors;
}

}

package com.dachen.export.entity.health;

/**
* @author wanghong
* @desc
* @date: 2017/12/18  14:13
* @Copyright (c) 2017, DaChen All Rights Reserved.
*/
public class DoctorExcelVO {
private String userId;

/**
* 医生审核状态
* @see UserEnum.UserStatus
*/
private String status;

private String username;// 用户名

private String telephone;//手机号

/** 所属科室 */
private String departments;

/** 职称 */
private String title;

private String userLevel;// 账号身份

private String inviterId;//邀请id

/**
*邀请人姓名
**/
private String inviterName;

/**
* 来源类型
**/
private Integer sourceType;

/**注册来源**/
private String source;

/**注册时间*/
private Long registerTime;

/**提交审核时间 */
private Long submitTime;

/**审核通过时间 */
private Long checkTime;

/**
* 最后一次登录的时间
**/
private Long lastLoginTime;

/**
* 医疗机构名称
*/
private String hospital;

/**
* 医院ID
*/
private String hospitalId;

/**
* 省
*/
private String province;

/**
* 市
*/
private String city;

/**
* 区
*/
private String country;

/**
* 用户openid
*/
private String openId;

/**
*邀请人openId
**/
private String inviterOpenId;

/**
* 已加入的圈子
*/
private String circleNames;

get/set...