package com.wanju.project001.zonghe.common.controller;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.wanju.project001.zonghe.handler.EIEntity;
import com.wanju.project001.zonghe.handler.ScanPojoHandler;
@Controller
@RequestMapping("/extro")
public class ExtroFuncIndexExportImportController {
@Autowired
ScanPojoHandler scanPojoHandler;
@RequestMapping("/init")
public ModelAndView index(HttpServletRequest request,
HttpServletResponse response) {
ModelAndView view = new ModelAndView("/extro/extro");
return view;
}
@RequestMapping("/import")
public ModelAndView importFile(HttpServletRequest request,
HttpServletResponse response) {
String path = request.getParameterMap().get("filepath")[0];
if (null != path && !"".equals(path)) {
}
return null;
}
@RequestMapping("/export")
public ModelAndView export(HttpServletRequest request,
HttpServletResponse response) {
ModelAndView view = new ModelAndView("/extro/test");
String tabname = request.getParameterMap().get("tabname")[0];
System.out.println("comon");
if ("user".equals(tabname)) {
// 第一步,创建一个webbook,对应一个Excel文件
HSSFWorkbook wb = new HSSFWorkbook();
// 第二步,在webbook中添加一个sheet,对应Excel文件中的sheet
HSSFSheet sheet = wb.createSheet("学生表一");
// 第三步,在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制short
HSSFRow row = sheet.createRow((int) 0);
// 第四步,创建单元格,并设置值表头 设置表头居中
HSSFCellStyle style = wb.createCellStyle();
style.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 创建一个居中格式
HSSFCell cell = row.createCell((short) 0);
cell.setCellValue("id");
cell.setCellStyle(style);
cell = row.createCell((short) 1);
cell.setCellValue("name");
cell.setCellStyle(style);
cell = row.createCell((short) 2);
cell.setCellValue("password");
cell.setCellStyle(style);
// 第五步,写入实体数据 实际应用中这些数据从数据库得到,
for (int i = 0; i < users.length; i++) {
row = sheet.createRow((int) i + 1);
row.createCell((short) 0).setCellValue(users[i].getId());
row.createCell((short) 1).setCellValue(users[i].getName());
row.createCell((short) 2).setCellValue(users[i].getPassword());
}
// 第六步,将文件存到指定位置
try {
FileOutputStream fout = new FileOutputStream("D:/students.xls");
wb.write(fout);
fout.close();
} catch (Exception e) {
e.printStackTrace();
}
PrintWriter writer;
try {
writer = response.getWriter();
writer.println("数据已经导入完毕,导入了" + users.length + "条数据");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
@RequestMapping("/exportreflect")
public ModelAndView exportReflect(HttpServletRequest request,
HttpServletResponse response) {
ModelAndView view = new ModelAndView("/extro/test");
String tabname = request.getParameterMap().get("tabname")[0];
System.out.println("comon");
Set<Class<?>> sets= scanPojoHandler.execute();
if ("user".equals(tabname)) {
// 第一步,创建一个webbook,对应一个Excel文件
HSSFWorkbook wb = new HSSFWorkbook();
// 第二步,在webbook中添加一个sheet,对应Excel文件中的sheet
HSSFSheet sheet = wb.createSheet("学生表一");
// 第三步,在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制short
HSSFRow row = sheet.createRow((int) 0);
// 第四步,创建单元格,并设置值表头 设置表头居中
HSSFCellStyle style = wb.createCellStyle();
style.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 创建一个居中格式
// 第五步,写入实体数据 实际应用中这些数据从数据库得到,
for (int i = 0; i < users.length; i++) {
HSSFCell cell = row.createCell(0);
if (i == 0) {
addCellForTitle(
row,
users[i],
"com.wanju.project001.zonghe.common.controller.User",
style);
}
row = sheet.createRow((int) i + 1);
if (users[i] instanceof User)
addCell(row, users[i],
"com.wanju.project001.zonghe.common.controller.User");
else {
System.out.println("判断其他类型");
}
}
// 第六步,将文件存到指定位置
try {
FileOutputStream fout = new FileOutputStream(
"D:/studentsreflect.xls");
wb.write(fout);
fout.close();
} catch (Exception e) {
e.printStackTrace();
}
PrintWriter writer;
try {
writer = response.getWriter();
writer.println("数据已经导入完毕,导入了" + users.length + "条数据");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
@RequestMapping("/exportreflectanno")
public ModelAndView exportReflectanno(HttpServletRequest request,
HttpServletResponse response) {
ModelAndView view = new ModelAndView("/extro/test");
String tabname = request.getParameterMap().get("tabname")[0];
System.out.println("comon");
// Set<Class<?>> sets= scanPojoHandler.execute();
Set<Class> sets= scanPojoHandler.executeFix();
if ("user".equals(tabname)) {
// 第一步,创建一个webbook,对应一个Excel文件
HSSFWorkbook wb = new HSSFWorkbook();
// 第二步,在webbook中添加一个sheet,对应Excel文件中的sheet
HSSFSheet sheet = wb.createSheet("学生表一");
// 第三步,在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制short
HSSFRow row = sheet.createRow((int) 0);
// 第四步,创建单元格,并设置值表头 设置表头居中
HSSFCellStyle style = wb.createCellStyle();
style.setAlignment(HSSFCellStyle.ALIGN_CENTER); // 创建一个居中格式
// 第五步,写入实体数据 实际应用中这些数据从数据库得到,
for (int i = 0; i < users.length; i++) {
HSSFCell cell = row.createCell(0);
if (i == 0) {
for (Iterator iterator = sets.iterator(); iterator
.hasNext();) {
Class class1 = (Class) iterator.next();
Object obj = null;
try {
obj = class1.newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// if(users[i]instanceof class1.newInstance().getClass()){
if(users[i].getClass().isInstance(obj)){
System.out.println("flg"+class1.getPackage()+class1.getName());
addCellForTitle(
row,
users[i],
class1.getName(),
style);
}
}
}
row = sheet.createRow((int) i + 1);
if (users[i] instanceof User)
addCell(row, users[i],
"com.wanju.project001.zonghe.common.controller.User");
else {
System.out.println("判断其他类型");
}
}
// 第六步,将文件存到指定位置
try {
FileOutputStream fout = new FileOutputStream(
"D:/studentsreflect.xls");
wb.write(fout);
fout.close();
} catch (Exception e) {
e.printStackTrace();
}
PrintWriter writer;
try {
writer = response.getWriter();
writer.println("数据已经导入完毕,导入了" + users.length + "条数据");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return null;
}
public static final User[] users = { new User(1, "33", "991"),
new User(2, "34", "992"), new User(3, "35", "993") };
public void addCellForTitle(HSSFRow row, Object object, String objectPath,
HSSFCellStyle style) {
Class class1;
try {
class1 = Class.forName(objectPath);
// Object object = class1.newInstance();
// Method[] methods = class1.getMethods();
Field[] fields = class1.getDeclaredFields();
class1.getFields();
for (int i = 0; i < fields.length; i++) {
HSSFCell cell = row.createCell(i);
cell.setCellStyle(style);
System.out.println(fields[i].getName());
cell.setCellValue(fields[i].getName().toString());
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void addCell(HSSFRow row, Object object, String objectPath) {
Class class1;
try {
class1 = Class.forName(objectPath);
// Object object = class1.newInstance();
Method[] methods = class1.getMethods();
for (int i = 0; i < methods.length; i++) {
if (methods[i].getName().contains("get")
&& !methods[i].getName().equals("getClass")) {
Object result = methods[i].invoke(object);
row.createCell(i).setCellValue(result.toString());
}
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
@EIEntity
class User {
private int id;
private String name;
private String password;
public User() {
// TODO Auto-generated constructor stub
}
public User(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
package com.wanju.project001.zonghe.handler;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class ScanPojoHandler {
private String basePojoPackage;
public Set<Class<?>> execute() {
System.out.println("basePojoPackage" + basePojoPackage);
return getClasses(basePojoPackage);
}
public Set<Class> executeFix() {
System.out.println("basePojoPackage" + basePojoPackage);
return getClassesFix(basePojoPackage);
}
public String getBasePojoPackage() {
return basePojoPackage;
}
public void setBasePojoPackage(String basePojoPackage) {
this.basePojoPackage = basePojoPackage;
}
public static Set<Class<?>> getClasses(String pack) {
// 第一个class类的集合
Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageName = pack;
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader()
.getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
System.err.println("file类型的扫描");
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName, filePath,
recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
System.err.println("jar类型的扫描");
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection())
.getJarFile();
// 从此jar包 得到一个枚举类
Enumeration<JarEntry> entries = jar.entries();
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx)
.replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class")
&& !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(
packageName.length() + 1,
name.length() - 6);
try {
// 添加到classes
classes.add(Class
.forName(packageName + '.'
+ className));
} catch (ClassNotFoundException e) {
// log
// .error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
// log.error("在扫描用户定义视图时从jar包获取文件出错");
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
public static Set<Class> getClassesFix(String pack) {
// 第一个class类的集合
Set<Class> classes = new LinkedHashSet<Class>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageName = pack;
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader()
.getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
System.err.println("file类型的扫描");
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFileFix(packageName, filePath,
recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
System.err.println("jar类型的扫描");
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection())
.getJarFile();
// 从此jar包 得到一个枚举类
Enumeration<JarEntry> entries = jar.entries();
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx)
.replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class")
&& !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(
packageName.length() + 1,
name.length() - 6);
try {
// 添加到classes
classes.add(Class
.forName(packageName + '.'
+ className));
} catch (ClassNotFoundException e) {
// log
// .error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
// log.error("在扫描用户定义视图时从jar包获取文件出错");
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public static void findAndAddClassesInPackageByFile(String packageName,
String packagePath, final boolean recursive, Set<Class<?>> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
// log.warn("用户定义包名 " + packageName + " 下没有任何文件");
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return (recursive && file.isDirectory())
|| (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(
packageName + "." + file.getName(),
file.getAbsolutePath(), recursive, classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0,
file.getName().length() - 6);
try {
// 添加到集合中去
// classes.add(Class.forName(packageName + '.' +
// className));
// 经过回复同学的提醒,这里用forName有一些不好,会触发static方法,没有使用classLoader的load干净
classes.add(Thread.currentThread().getContextClassLoader()
.loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
// log.error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
public static void findAndAddClassesInPackageByFileFix(String packageName,
String packagePath, final boolean recursive, Set<Class> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
// log.warn("用户定义包名 " + packageName + " 下没有任何文件");
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return (recursive && file.isDirectory())
|| (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFileFix(
packageName + "." + file.getName(),
file.getAbsolutePath(), recursive, classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0,
file.getName().length() - 6);
try {
// 添加到集合中去
// classes.add(Class.forName(packageName + '.' +
// className));
// 经过回复同学的提醒,这里用forName有一些不好,会触发static方法,没有使用classLoader的load干净
Class clz = Thread.currentThread().getContextClassLoader()
.loadClass(packageName + '.' + className);
EIEntity iEiEntity = (EIEntity) clz
.getAnnotation(EIEntity.class);
if (iEiEntity != null) {
classes.add(Thread.currentThread()
.getContextClassLoader()
.loadClass(packageName + '.' + className));
} else {
System.out.println("非pojo类");
}
} catch (ClassNotFoundException e) {
// log.error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
}