一、什么是反射
百度百科的解释：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
简而言之：在运行时可以动态的获取任意一个类或者对象（包括基本数据类型）的属性和方法。
二、什么是Class对象
jvm将.class文件装载到内存中后，会在堆内存中同时生成一个Class对象，这个Class对象是唯一的。即：通过同一个类获取的Class都是一样的，并且Class对象是jvm虚拟机创建的，如下：输出的结果为true。
package com.baohuajie.cn;
public class ReflectDemo1 {
public static void main(String[] args) {
/*
Class 类的实例表示正在运行的 Java 应用程序中的类和接口。
枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，
所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型
（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。
*/
int a=10;
Integer aObj=new Integer(a);
int b=12;
Integer bObj=new Integer(b);
Class<? extends Integer> aClass = aObj.getClass();
Class<? extends Integer> bClass = bObj.getClass();
System.out.println(aClass==bClass);//true
int[] arrayA=new int[10];
int[] arrayB=new int[10];
int[][] arrayC=new int[10][];
Class<? extends int[]> arrayAClass = arrayA.getClass();
Class<? extends int[]> arrayBClass = arrayB.getClass();
Class<?> arrayCClass = arrayC.getClass();
System.out.println(arrayAClass==arrayBClass);//true
System.out.println(arrayAClass==arrayCClass);//false
Student s1=new Student();
Student s2=new Student();
System.out.println(s1.getClass()==s2.getClass());//true
}
}
class Student {
private String name;
public Student() {
}
public Student(String name) {
this.name = name;
}
}
Class对象是.class文件在内存中的一种存在方式，.class文件是在硬盘中的一种存在形式。
获取到Class对象之后就可以得到类的方法、属性，反射也可以理解为通过.class文件得到类，并将类中的信息解析成各种对象，如：方法对象Method、属性对象Field等等。
jdk中对CLass的解释如下：
jdk中defineClass函数的源码如下：
/**
* 将一个 byte 数组转换为 Class 类的实例。必须分析 Class，然后才能使用它。
此方法将默认的 ProtectionDomain 分配给新定义的类。调用 Policy.getPolicy().getPermissions(new CodeSource(null, null)) 时，ProtectionDomain 被有效授予所返回的相同权限集。默认域在第一次调用 defineClass 时创建，并在后续调用时被重用。
要将特定的 ProtectionDomain 分配给类，需要使用 defineClass 方法，该方法将 ProtectionDomain 用作其参数之一。
参数：
name - 所需要的类的二进制名称，如果不知道此名称，则该参数为 null
b - 组成类数据的字节。off 与 off+len-1 之间的字节应该具有《Java Virtual Machine Specification》定义的有效类文件的格式。
off - 类数据的 b 中的起始偏移量
len - 类数据的长度
返回：
从指定类数据中创建的 Class 对象。
*/
protected final Class<?> defineClass(String name, byte[] b, int off, int len,
ProtectionDomain protectionDomain)
throws ClassFormatError
{
protectionDomain = preDefineClass(name, protectionDomain);
Class c = null;
String source = defineClassSourceLocation(protectionDomain);
try {
c = defineClass1(name, b, off, len, protectionDomain, source);
} catch (ClassFormatError cfe) {
c = defineTransformedClass(name, b, off, len, protectionDomain, cfe,
source);
}
postDefineClass(c, protectionDomain);
return c;
}三、如何获取Class对象
Student student=new Student();
//第一种方式
Class<? extends Student> studentClass = student.getClass();
//第二种方式
Class<Student> studentClass1 = Student.class;
//第三种方式
try {
Class<?> studentClass2 = Class.forName("com.baohuajie.cn.Student");
System.out.println(studentClass==studentClass1);//true
System.out.println(studentClass2==studentClass1);//true
} catch (ClassNotFoundException e) {
e.printStackTrace();
}四、java中反射如何使用
package com.baohuajie.cn;
import java.lang.reflect.*;
import java.util.List;
public class ReflectDemo2 {
public static void main(String[] args) {
/**
* 通过反射可以获取以下信息：参数：https://www.cnblogs.com/qifengshi/p/6267511.html
*
Class对象
构造器
变量
方法
私有变量与私有方法
注解
泛型
数组
*/
Class personClazz=null;
try {
//===========================构造器==========================================================
personClazz=Class.forName("com.baohuajie.cn.Person");
//getConstructors():获取public类型构造函数（只包括public类型的）
Constructor[] constructors = personClazz.getConstructors();
System.out.println("===============获取public类型构造函数（只包括public类型的）==================");
for(Constructor c:constructors){
System.out.println(c);
}
//getDeclaredConstructors()：获取所有类型构造函数
Constructor[] declaredConstructors = personClazz.getDeclaredConstructors();
System.out.println("===============获取所有类型构造函数==================");
for(Constructor c:declaredConstructors){
System.out.println(c);
}
//获取指定参数类型的public型构造函数=
Constructor constructor = personClazz.getConstructor(Integer.TYPE);
Constructor constructor1 = personClazz.getConstructor(String.class, Integer.TYPE, String.class);
System.out.println("===============获取指定参数类型的public型构造函数==================");
System.out.println(constructor);
System.out.println(constructor1);
System.out.println("===============通过构造方法创建实例==================");
constructor1.newInstance("Baohuajie",20,"河南省");
//注：使用Constructor constructor = personClazz.getConstructor(Integer.class);时会报异常
//获取指定参数类型的所有型构造函数
Constructor declaredConstructor = personClazz.getDeclaredConstructor(String.class, Integer.TYPE, String.class);
System.out.println("===============获取指定参数类型的所有型构造函数===================");
System.out.println(declaredConstructor);
//获取public类型的方法
Method[] methods = personClazz.getMethods();
System.out.println("===============获取public类型的方法===================");
for (Method method:methods){
System.out.println(method);
}
//===========================方法==========================================================
//获取所有类型的方法
Method[] declaredMethods = personClazz.getDeclaredMethods();
System.out.println("===============获取所有类型的方法===================");
for (Method method:declaredMethods){
System.out.println(method);
}
//获取指定方法名和参数类型的方法
Class<?>[] paramType=new Class<?>[]{String.class,Integer.TYPE};
Method publicMethod = personClazz.getMethod("publicMethod",paramType);
System.out.println("===============获取指定方法名和参数类型的方法===================");
System.out.println(publicMethod);
//调用方法
System.out.println("===============调用方法===================");
publicMethod.invoke(personClazz.newInstance(),"包华杰",new Integer(20));
//获取无参方法
System.out.println("===============获取无参方法==================");
Method getAdress = personClazz.getDeclaredMethod("getAdress", new Class<?>[]{});
System.out.println(getAdress);
//===========================字段==========================================================
//获取字段,注：name是私有字段
Field name = personClazz.getDeclaredField("name");
System.out.println("===============获取字段==================");
System.out.println(name);
name.setAccessible(true);//对私有字段进行反射
Object obj = personClazz.getDeclaredConstructor().newInstance();
name.set(obj,"小强");
Person person = (Person) obj;
System.out.println(person.getName());
//===========================泛型 ==========================================================
//间接的利用反射得到泛型信息
/**
*
1、反射得到返回类型为泛型类的方法
2、调用getGenericReturnType得到方法返回类型中的参数化类型
3、判断该type对象能不能向下转型为ParameterizedType
4、转型成功，调用getActualTypeArguments得到参数化类型的数组，因为有的泛型类，不只只有一个参数化类型如Map<K，V>
5、取出数组中的每一个的值，转型为Class对象输出。
*/
System.out.println("===============泛型：返回类型==================");
Method lists = personClazz.getMethod("getLists",null);
Type genericReturnType = lists.getGenericReturnType();
if(genericReturnType instanceof ParameterizedType){
ParameterizedType parameterizedType = ((ParameterizedType) genericReturnType);
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
for (Type type:actualTypeArguments){
System.out.println("类型："+(Class) type);
}
}
System.out.println("===============泛型：参数类型==================");
Method setLists = personClazz.getMethod("setLists", List.class);
Type[] genericParameterTypes = setLists.getGenericParameterTypes();
for(Type type:genericParameterTypes){
if(type instanceof ParameterizedType){
ParameterizedType parameterizedType = ((ParameterizedType) type);
Type[] types = parameterizedType.getActualTypeArguments();
for (Type t:types){
System.out.println(t);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Person {
private String name;
private int age;
public String adress;
public List<String> lists;
public List<String> getLists() {
return lists;
}
public void setLists(List<String> lists) {
this.lists = lists;
}
Person() {
System.out.println("public 无参构造方法"+name+age+adress);
}
private Person(String name) {
this.name = name;
System.out.println("private 有参构造方法name");
}
public Person(int age) {
this.age = age;
}
public Person(String name, int age, String adress) {
this.name = name;
this.age = age;
this.adress = adress;
System.out.println("public 有参构造方法age"+name+age+adress);
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getAdress() {
return adress;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setAdress(String adress) {
this.adress = adress;
}
private void privateMethod(){
System.out.println("私有无参方法");
}
public void publicMethod(){
System.out.println("共有无参方法");
}
private void privateMethod(String name,int age){
System.out.println("私有有参方法");
}
public void publicMethod(String name,int age){
System.out.println("共有有参方法"+name+age);
}
}
五、反射的应用
1、在jdbc中的应用
public class ConnectionJDBC {
/**
* @param args
*/
//驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中
public static final String DBDRIVER = "com.mysql.jdbc.Driver";
//连接地址是由各个数据库生产商单独提供的，所以需要单独记住
public static final String DBURL = "jdbc:mysql://localhost:3306/test";
//连接数据库的用户名
public static final String DBUSER = "root";
//连接数据库的密码
public static final String DBPASS = "";
public static void main(String[] args) throws Exception {
Connection con = null; //表示数据库的连接对象
Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序 ,反射机制的体现
con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、连接数据库
System.out.println(con);
con.close(); // 3、关闭数据库
}
2、在spring中的应用
Spring 通过 XML 配置模式装载 Bean 的过程：
(1)将程序内所有 XML 或 Properties 配置文件加载入内存中
(2)Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息
(3)使用反射机制，根据这个字符串获得某个类的Class实例
(4)动态配置实例的属性
Spring这样做的好处是：
(1)不用每一次都要在代码里面去new或者做其他的事情
(2)以后要改的话直接改配置文件，代码维护起来就很方便了
(3)有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现
public class BeanFactory {
private Map<String, Object> beanMap = new HashMap<String, Object>();
/**
* bean工厂的初始化.
* @param xml xml配置文件
*/
public void init(String xml) {
try {
//读取指定的配置文件
SAXReader reader = new SAXReader();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
//从class目录下获取指定的xml文件
InputStream ins = classLoader.getResourceAsStream(xml);
Document doc = reader.read(ins);
Element root = doc.getRootElement();
Element foo;
//遍历bean
for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
foo = (Element) i.next();
//获取bean的属性id和class
Attribute id = foo.attribute("id");
Attribute cls = foo.attribute("class");
//利用Java反射机制，通过class的名称获取Class对象
Class bean = Class.forName(cls.getText());
//获取对应class的信息
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
//获取其属性描述
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
//设置值的方法
Method mSet = null;
//创建一个对象
Object obj = bean.newInstance();
//遍历该bean的property属性
for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
Element foo2 = (Element) ite.next();
//获取该property的name属性
Attribute name = foo2.attribute("name");
String value = null;
//获取该property的子元素value的值
for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
Element node = (Element) ite1.next();
value = node.getText();
break;
}
for (int k = 0; k < pd.length; k++) {
if (pd[k].getName().equalsIgnoreCase(name.getText())) {
mSet = pd[k].getWriteMethod();
//利用Java的反射极致调用对象的某个set方法，并将值设置进去
mSet.invoke(obj, value);
}
}
}
//将对象放入beanMap中，其中key为id值，value为对象
beanMap.put(id.getText(), obj);
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
//other codes
}3、反射在注解中的应用
参考：https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html
https://my.oschina.net/itgaowei/blog/1600525
六、反射的优缺点
静态编译：在编译时确定类型，绑定对象
动态编译：运行时确定类型，绑定对象
优点：行期类型的判断，动态类加载：提高代码灵活度，降低耦合
缺点：性能瓶颈，反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多
1742
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
