学习目标：
1.学习java反射基本概念 2.Java的类加载机制
3.通过反射了解泛型本质 4.POI组件通过反射导出excel实战Demo
java反射基本概念
java在运行的状态中，对于任何一个类，我们都可以知道它的方法与属性。对于任何一个对象，能够对它的方法和
属性进行调用。这种动态获取对象信息，调用对象方法成为反射机制。
Class类：代表类的实体，在运行的Java应用程序中表示类和接口
Field类：代表类的成员变量
Method类：代表类的方法
Constructor类：代表类的构造方法
demo
public class reflexdemo {
// 获取类字节码方法有三种：
public static void main(String [] args) throws ClassNotFoundException {
// 我们创建一个实例对象stu
// Student该类为java.lang.Class类的实例对象（官方文档详解）
// 任何一个类都是Class的实例对象，Student实例对象有三种表达方式
Student stu = new Student();
// 第一种，实际告诉我们任何一个类都有一个隐含的静态成员变量class
Class s1 = Student.class;
// 第二种，该类的对象通过getclass方法获取
Class s2 = stu.getClass();
// 通过类的全路径名获取Class对象
Class c3 = Class.forName("com.sun.Student");
}
}
java 动态加载类
java程序在编译时刻加载类称为静态加载类，运行时刻加载类称为动态加载类。new 实例对象为静态加载类，在编
译时刻需要加载所有可能使用到的类，功能性的类都使用动态加载。
1.创建一个接口。
public interface OfficeAble {
public void start();
}
2.创建Word类实现标准接口，进行标准化。
public class Word implements OfficeAble {
public void start() {
System.out.println("word....start");
}
}2.创建Excel类实现标准接口，进行标准化。
public class Excel implements OfficeAble {
public void start() {
System.out.println("Excel....start");
}
}
3.创建一个动态加载类，Class.forName类的类类型，动态加载类。
class OfficeBetter
{
public static void main(String [] args)
{
try{
//Class.forName类的类类型，动态加载类。
Class c = Class.forName(args[0]);
//通过类类型，创建该类对象
OfficeAble oa = (OfficeAble)c.newInstance();
oa.start();
}catch(Exception e){
e.printStackTrace();
}
}
//args是使用命令行的参数列表，java指定的程序名 参数 args[0]即 参数列表的 第一个参数 <...code...>
//工作以后，业务中用得多，假设现在A单位用户只需要excel2003与word2003这两个类，你在主程序中只有一个类调用，很简单，
//但B单位用户要求用word2017与excel2017，新增的两个类大部分功能和03版的差不多，但细节方面还有些不同，这时候动态加载就起大作用了，
//你只用在你主程序调用代码那里传不同的参数就可以，减少了因代码未修改完全导致业务出来问题等低级
}4.创建一个Office类，调用Word类和Excel类。
class Office
{
public static void main(String [] args)
{
//new 创建对象为静态加载类，在编译时刻就需要加载所有可能要使用到的类
//如果直接使用Word类，未定义编译会报错。
//在运行过程中不可能所有的类全使用，则需要通过动态加载类解决问题
if("Word".equals(args[0]))
{
Word w = new Word();
w.start();
}
if("Excel".equals(args[0]))
{
Excel e = new Excel();
e.start();
}
}
}new创建的对象都为静态加载类，在编译时刻就需要加载所有使用到的类，可以使用动态加载类机制，先让让Word类实现一个标准接口A。我们写一个动态类加载模板。传入参数取到其类类型。利用类类型创建该类实例对象，强转的时候转化类型为Word类实现的接口A。
void关键字 也有自己的类类型
public Method[] getMethods()：返回某个类的所有公用（public）方法包括其继承类的公用方法，当然也包括它所实现接口的方法。
public Method[] getDeclaredMethods()：对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。当然也包括它所实现接口的方法。
我们要想得到类的信息，首先获取到该类的类类型。
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassUtil {
/**
* 打印类的信息，包括类的成员函数、成员变量(只获取成员函数)
* @param obj 该对象所属类的信息
*/
public static void printClassMethodMessage(Object obj){
//要获取类的信息 首先要获取类的类类型
Class c = obj.getClass();//传递的是哪个子类的对象 c就是该子类的类类型
//获取类的名称
System.out.println("类的名称是:"+c.getName());
/*
* Method类，方法对象
* 一个成员方法就是一个Method对象
* getMethods()方法获取的是所有的public的函数，包括父类继承而来的
* getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
*/
Method[] ms = c.getMethods();//c.getDeclaredMethods()
for(int i = 0; i < ms.length;i++){
//得到方法的返回值类型的类类型
Class returnType = ms[i].getReturnType();
System.out.print(returnType.getName()+" ");
//得到方法的名称
System.out.print(ms[i].getName()+"(");
//获取参数类型--->得到的是参数列表的类型的类类型
Class[] paramTypes = ms[i].getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
/**
* 获取成员变量的信息
* @param obj
*/
public static void printFieldMessage(Object obj) {
Class c = obj.getClass();
/*
* 成员变量也是对象
* java.lang.reflect.Field
* Field类封装了关于成员变量的操作
* getFields()方法获取的是所有的public的成员变量的信息
* getDeclaredFields获取的是该类自己声明的成员变量的信息
*/
//Field[] fs = c.getFields();
Field[] fs = c.getDeclaredFields();
for (Field field : fs) {
//得到成员变量的类型的类类型
Class fieldType = field.getType();
String typeName = fieldType.getName();
//得到成员变量的名称
String fieldName = field.getName();
System.out.println(typeName+" "+fieldName);
}
}
/**
* 打印对象的构造函数的信息
* @param obj
*/
public static void printConMessage(Object obj){
Class c = obj.getClass();
/*
* 构造函数也是对象
* java.lang. Constructor中封装了构造函数的信息
* getConstructors获取所有的public的构造函数
* getDeclaredConstructors得到所有的构造函数
*/
//Constructor[] cs = c.getConstructors();
Constructor[] cs = c.getDeclaredConstructors();
for (Constructor constructor : cs) {
System.out.print(constructor.getName()+"(");
//获取构造函数的参数列表--->得到的是参数列表的类类型
Class[] paramTypes = constructor.getParameterTypes();
for (Class class1 : paramTypes) {
System.out.print(class1.getName()+",");
}
System.out.println(")");
}
}
}方法的反射demo
决定一个方法的因素为方法的名称与方法的参数。getMethod参数列表因为是（。。。）可变参数，则可变参数可以传入
(参数类型.class)或者直接传入一个数组。
class OfficeBetter
{
public static void main(String [] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
Student stu = new Student();
Class student = stu.getClass();
Method student1 = student.getMethod("start", new Class[]{int.class,int.class});
Method student2 = student.getMethod("print", int.class,int.class);
//方法如果没有返回值返回null,有返回值返回具体的返回值
Object o1 = student1.invoke(stu,new Object[]{10,20});
Object o2 = student2.invoke(stu, 10,20);
}
}首先拿到一个类的类类型，利用该类的类类型来获取方法（注意名称和参数列表，因为是。。。则可以传入数组或者具体类型.class）。拿到这个Method方法后,利用方法.invoke("该类的对象名称"，参数列表)；
通过反射了解集合泛型的本质
反射的操作都是编译后的操作，而java中集合的泛型，是防止错误输入，只在编译阶段有效，绕过编译阶段无效。我们可以创建一个ArrayList<String> 对象，使用add方法添加数字会报错。所以我们拿到ArrayList<String> 对象的类类型，通过类类型拿到add方法，利用方法.invoke(对象，参数)绕过编译操作就绕过了泛型。实例如下：
public class MethodDemo4 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
ArrayList<String> list1 = new ArrayList<String>();
list1.add("hello");
//list1.add(20);错误的
Class c1 = list.getClass();
Class c2 = list1.getClass();
System.out.println(c1 == c2);
//反射的操作都是编译之后的操作
/*
* c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
* Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
* 绕过编译就无效了
* 验证：我们可以通过方法的反射来操作，绕过编译
*/
try {
Method m = c2.getMethod("add", Object.class);
m.invoke(list1, 20);//绕过编译操作就绕过了泛型
System.out.println(list1.size());
System.out.println(list1);
/*for (String string : list1) {
System.out.println(string);
}*///现在不能这样遍历
} catch (Exception e) {
e.printStackTrace();
}
}
}POI组件通过反射导出excel实战Demo
在工作中，导出excel表格，如果我们利用实体类携带数据，则通过迭代器迭代，获取每一条数据，针对每条数据通过反射获取其所有的方法，取到该方法携带的值，放入POL组件中。
/**
* 利用开源组件POI3.0.2动态导出EXCEL文档
*
* @param <T>
* 应用泛型，代表任意一个符合javabean风格的类
* 注意这里为了简单起见，boolean型的属性xxx的get器方式为getXxx(),而不是isXxx()
* byte[]表jpg格式的图片数据
*/
public class ExportExcelUtil<T> {
public void exportExcelFile(Map<String, Object> map, String[] headers, Collection<T> dataset, OutputStream out,
String pattern) {
exportExcelFile("供应商评分模板", map, headers, dataset, out, pattern);
}
/**
* 这是一个通用的方法，利用了JAVA的反射机制，可以将放置在JAVA集合中并且符号一定条件的数据以EXCEL 的形式输出到指定IO设备上
*
* @param title
* 表格标题名
* @param headers
* 表格属性列名数组
* @param dataset
* 需要显示的数据集合,集合中一定要放置符合javaBean风格的类的对象。此方法支持的
* javaBean属性的数据类型有基本数据类型及String,Date,byte[](图片数据)
* @param out
* 与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
* @param pattern
* 如果有时间数据，设定输出格式。默认为"yyyy-MM-dd"
*/
@SuppressWarnings({ "deprecation" })
public void exportExcelFile(String title, Map<String, Object> map, String[] headers, Collection<T> dataset,
OutputStream out, String pattern) {
// 声明一个工作薄
HSSFWorkbook workbook = new HSSFWorkbook();
// 生成一个表格
HSSFSheet sheet = workbook.createSheet(title);
// 设置表格默认列宽度为15个字节
sheet.setDefaultColumnWidth((short) 40);
sheet.setDefaultRowHeight((short) 6);
// sheet.setColumnWidth(1,(short) 30);
// sheet.setColumnWidth(2,(short) 30);
// sheet.setColumnWidth(3,(short) 50);
// sheet.setColumnWidth(4,(short) 30);
// sheet.setColumnWidth(5,(short) 30);
// 生成一个样式
HSSFCellStyle style = workbook.createCellStyle();
// 设置这些样式
style.setFillForegroundColor(HSSFColor.GREY_40_PERCENT.index);
style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
style.setBorderBottom(HSSFCellStyle.BORDER_THIN);
style.setBorderLeft(HSSFCellStyle.BORDER_THIN);
style.setBorderRight(HSSFCellStyle.BORDER_THIN);
style.setBorderTop(HSSFCellStyle.BORDER_THIN);
style.setAlignment(HSSFCellStyle.ALIGN_CENTER);
// 生成一个字体
HSSFFont font = workbook.createFont();
font.setColor(HSSFColor.BLACK.index);
font.setFontHeightInPoints((short) 10);
font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
// 把字体应用到当前的样式
style.setFont(font);
// 生成并设置另一个样式
HSSFCellStyle style2 = workbook.createCellStyle();
style2.setFillForegroundColor(HSSFColor.GREY_25_PERCENT.index);
style2.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
style2.setBorderBottom(HSSFCellStyle.BORDER_THIN);
style2.setBorderLeft(HSSFCellStyle.BORDER_THIN);
style2.setBorderRight(HSSFCellStyle.BORDER_THIN);
style2.setBorderTop(HSSFCellStyle.BORDER_THIN);
style2.setAlignment(HSSFCellStyle.ALIGN_CENTER);
style2.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
// 生成另一个字体
HSSFFont font2 = workbook.createFont();
font2.setBoldweight(HSSFFont.BOLDWEIGHT_NORMAL);
font2.setColor(HSSFColor.BLACK.index);
// 把字体应用到当前的样式
style2.setFont(font2);
// 声明一个画图的顶级管理器
HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
// 定义注释的大小和位置,详见文档
HSSFComment comment = patriarch.createComment(new HSSFClientAnchor(0, 0, 0, 0, (short) 4, 2, (short) 6, 5));
// 设置注释内容
comment.setString(new HSSFRichTextString("定标明细!"));
// 设置注释作者，当鼠标移动到单元格上是可以在状态栏中看到该内容.
// comment.setAuthor("韩松");
// 产生查询条件
HSSFRow row = sheet.createRow(0);
// 产生表格标题行
style.setFillForegroundColor(HSSFColor.GREY_40_PERCENT.index);
row = sheet.createRow(0);
settext(headers, style, row);
// 遍历集合数据，产生数据行
Iterator<T> it = dataset.iterator();
int index = 0;
while (it.hasNext()) {
index++;
row = sheet.createRow(index);
T t = (T) it.next();
// 利用反射，根据javabean属性的先后顺序，动态调用getXxx()方法得到属性值 从1开始 因为第0个是序列化id
Field[] fields = t.getClass().getDeclaredFields();
for (short i = 1; i < fields.length; i++) {
HSSFCell cell = row.createCell(i);
cell.setCellStyle(style2);
Field field = fields[i];
String fieldName = field.getName();
String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
setcell(pattern, workbook, sheet, patriarch, row, index, t, i, cell, getMethodName);
}
}
try {
workbook.write(out);
} catch (IOException e) {
e.printStackTrace();
}
}
private void settext(String[] headers, HSSFCellStyle style, HSSFRow row) {
for (short i = 0; i < headers.length; i++) {
HSSFCell cell = row.createCell(i);
cell.setCellStyle(style);
HSSFRichTextString text = new HSSFRichTextString(headers[i]);
cell.setCellValue(text);
}
}
private void setcell(String pattern, HSSFWorkbook workbook, HSSFSheet sheet, HSSFPatriarch patriarch, HSSFRow row, int index, T t, short i, HSSFCell cell, String getMethodName) {
try {
Class<?> tCls = t.getClass();
Method getMethod = tCls.getMethod(getMethodName, new Class[] {});
Object value = getMethod.invoke(t, new Object[] {});
// 判断值的类型后进行强制类型转换
String textValue = null;
if (value instanceof Boolean) {
boolean bValue = (Boolean) value;
textValue = "1";
if (!bValue) {
textValue = "0";
}
} else if (value instanceof Date) {
Date date = (Date) value;
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
textValue = sdf.format(date);
} else if (value instanceof byte[]) {
// 有图片时，设置行高为60px;
row.setHeightInPoints(60);
// 设置图片所在列宽度为80px,注意这里单位的一个换算
sheet.setColumnWidth(i, (short) (35.7 * 80));
// sheet.autoSizeColumn(i);
byte[] bsValue = (byte[]) value;
HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 1023, 255, (short) 6, index, (short) 6,
index);
anchor.setAnchorType(2);
patriarch.createPicture(anchor, workbook.addPicture(bsValue, HSSFWorkbook.PICTURE_TYPE_JPEG));
} else {
// 其它数据类型都当作字符串简单处理
if (value == null) {
value = "";
}
textValue = value.toString();
}
// 如果不是图片数据，就利用正则表达式判断textValue是否全部由数字组成
if (textValue != null) {
Pattern p = Pattern.compile("^//d+(//.//d+)?$");
Matcher matcher = p.matcher(textValue);
if (matcher.matches()) {
// 是数字当作double处理
cell.setCellValue(Double.parseDouble(textValue));
} else {
HSSFRichTextString richString = new HSSFRichTextString(textValue);
HSSFFont font3 = workbook.createFont();
font3.setColor(HSSFColor.BLACK.index);
richString.applyFont(font3);
cell.setCellValue(richString);
}
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} finally {
// 清理资源
}
}
}
}
您提的问题，就是对小编一次知识的回顾。
777
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
