一、从JAVA构建对象内存分配谈起
我们来解释一下上面的图,在现代操作系统中,都是以进程为单位向操作系统申请内存资源,而且一般而言进程间的资源都是相互独立的。当进程申请到内存空间后,会有两种常见的使用模式:栈和堆。栈是线程专用,也就是说一个线程一个栈空间,它往往比较小,如果调用过度,容易造成溢出。堆是浩瀚无垠的,大量的线程共享数据,一般我们都是用指针指向。上图为我们解释了我们书写JAVA程序:Student stu = new Student(); 的时候内存中发生了哪些事情。
第一步:当JAVA中出现了类名(如Student),JAVA虚拟机会利用类加载器去检查这个类的Class对象是否已经加载,如果未加载,那么默认的类加载器就会根据类名查找.class文件,进行字节码的加载,同时也会检查文件有没有被破坏,这是java的安全防范措施。
第二步:创建引用变量Student stu,并将其放入栈空间。
第三步:创建裸对象,也就是new Student,从这里我们可以看出,一个类在内存中只有一份代码,不同的对象共用同一份代码,对象之间的差异完全是由对象属性的不同造成的,因此,我们判断一个对象占用内存空间大小,重点是去看这个对象身上携带了多少的属性。对象身上的属性除了类自身定义的属性外,还包含了几个隐式属性:this(指向自己)、super(指向父亲)和代码指针(指向代码区)。
第四步:调用构造函数Student()进行数据初始化。
总结:我们书写JAVA代码:Student stu = new Student(); 的时候,一共发生了四件事情:①Student,即加载字节码;②Student stu,创建引用变量并让入栈空间;③new Student,创建裸对象;④Student(),调用构造函数Student();
二、JAVA的类加载器
上文有提到说,当JAVA中出现一个类名时,类加载器就会把硬盘上的.class文件加载到内存,也就是我们常说的字节码加载。那么类加载器是何方神圣?竟有如此本事?其实类加载器也是JAVA类,JAVA的虚拟机中可以安装多个类加载器,系统默认有三个类加载器,分别负责加载特定位置的类,它们分别是:BootStrap、ExtClassLoader、AppClassLoader。其中ExtClassLoader、AppClassLoader自身也要被类加载器加载,那么显然BootStrap不是一个普通的JAVA类,它是JAVA虚拟机自带的,是用C++语言写的一串二进制代码。我们来做一个小测试:
public class ClassLoader {
public static void main(String[] args) {
System.out.println(ClassLoader.class.getClassLoader().getClass().getName());//sun.misc.Launcher$AppClassLoader
System.out.println(String.class.getClassLoader().getClass().getName());//空指针异常
}
}
显然,我们可以看出ClassLoader的类加载器是AppClassLoader,而String的类加载器是BootStrap,因为BootStrap是C++写的二进制,所以我们用getClass()无法获取其JAVA类名。其实这三个类加载器存在着父子关系,即ExtClassLoader是BootStrap的孩子,APPClassLoader是ExtClassLoader的孩子。BootStrap主要负责加载JRE/lib/rt.jar文件(多为JAVA自带的类,比如String、hashSet等),ExtClassLoader主要负责加载JRE/lib/ext/*.jar下的文件,而AppClassLoader主要负责加载CLASSPATH指定目录下的所有jar和目录,这就是为什么我们要把自己写的类放在CLASSPATH下,目的就是为了让APPClassLoader能顺利加载到。当然我们也可以强制指定我们写的类输出到JRE/lib/ext/下,让ExtClassLoade去加载它。当然我们也可以自己写一个类加载器,它实际上是AppClassLoader的孩子,需要继承ClassLoader,这里我们不做详细讲解。
三、Class对象
我们都知道每一个类都描述了一种事物的共性,比如Student类,抽象出了学生,里面可以包括学生的姓名、性别等属性以及吃饭、睡觉、写作业等方法。那么是否还有一个类,这个类描述了JAVA类的共性呢?答案是有的!那就是Class对象。Class对象中就包含了类的共性信息,比如类名、所属的包名、有哪些属性、有哪些方法等。其实Class对象得到的就是类的字节码信息!在JAVA中,提供了三种可以获得字节码信息的方式:
(1)类名.class 如:String.class; 凡是一个java类,都会有字节码信息,因此可适用于所有JAVA类
(2)对象.getClass() 如:String str=new String(""); str.getClass(); 效果与(1)是一样的,只不过使用(1)的时候内存中还没有该类的字节码,需要动态加载。而用该方法,是通过对象来获取,表明内存中已经存在该类的字节码。
(3)Class.forName(类的全名) 如:Class.forName("java.lang.String"); 该方法多用于反射,因为我们有的时候只有在程序运行的时候,根据配置文件等信息才知道需要加载哪个类,那么就不能用前两种做法了。该方法如果无法根据提供的类的全名找到相应的类,会抛出ClassNotFoundException异常。
说明:一份类只有一份字节码。但是int.class 与 Integer.class的字节码不同,因为它们属于两种数据类型。int[].class 与 int.class的字节码也不同。我们先简单的看一下Class对象的几个常见方法:
public class ClassLoader {
public static void main(String[] args) throws Exception {
String str = new String();
System.out.println(str.getClass().getName());// java.lang.String,获取类全名
System.out.println(str.getClass().isPrimitive());// false,是否是基本类型
System.out.println(int.class.isPrimitive());// true
System.out.println(str.getClass().isArray());// false,是否是数组
System.out.println(int[].class.isArray());// true
System.out.println(int.class == Integer.TYPE); // true,类字面常量:基本类型的.class等价于对应的类的.TYPE
System.out.println(int.class == Integer.class); // false
}
}
铺垫了那么久,我们来看看什么叫反射。反射就是"把JAVA类的各种成分映射成相应的JAVA类”,比如说我们用Constructor类去描述类的构造函数,用Field类去描述类的属性。这样,反射就为框架打下了坚实的基础。我们可以利用反射机制实现框架。比如说,Hibernate框架的编写者,他在写框架的时候肯定无法预料未来的人会写哪些类,那么Hibernate需要具备程序运行时动态地去new出类的实例并进行相应调用的能力。即究竟需要new出哪个类,是程序运行时才知道的。所以可以说,反射就是为框架服务的,如果不使用框架,反射只是徒有虚名。接下来,我们来看一下如何将”
JAVA类的各种成分映射成相应的JAVA类“。
假设我们有这么一个类(JAVABEAN):
public class Person {
public String name; //姓名(为了方便演示,将其写成public类型)
private String age; //年龄
private String sex; //性别
public Person() {
}
public Person(String name, String age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
我们现在通过反射机制去获取这个类的一些类型信息。
public class PersonTest {
public static void main(String[] args) throws Exception {
// 得到构造函数
Constructor c = String.class.getConstructor(StringBuffer.class); //得到构造函数,需要传入构造函数参数的class数组
String str = (String) c.newInstance(new StringBuffer("a123")); //根据构造函数创建实例
System.out.println(str); //a123
// 得到字段(访问public属性)
Person p1 = new Person("2", "3", "4");
Field f1 = p1.getClass().getField("name");
System.out.println(f1);//public java.lang.String edu.fjnu.reflect.Person.name 得到字段的信息
f1.set(p1, "999"); //设置字段
System.out.println(f1.get(p1)); //999 ,获取属性值
// 暴力反射(设置并访问私有属性)
Person p2 = new Person("21", "31", "41");
Field f2 = p2.getClass().getDeclaredField("age");
f2.setAccessible(true); // 强制将其变为可用(因为原来是私有的)
System.out.println(f2); //private java.lang.String edu.fjnu.reflect.Person.age
f2.set(p2, "666");
System.out.println(f2.get(p2)); //666
// 得到方法
Person p3 = new Person("aa", "bb", "cc");
Method method1 = Person.class.getMethod("setName", String.class);
method1.invoke(p3, "hello"); //调用set方法,并传入hello参数进行设置
Method method2 = Person.class.getMethod("getName");
System.out.println(method2.invoke(p3)); //hello,调用get方法
}
}
为了巩固知识,我特地将实例化对象和调用函数抽象出来,写成了通用方法,供大家参考使用。
/**
*
* @param path
* :类的全路径
* @param args
* :构造函数参数的Class数组
* @param init
* :构造函数的传递参数
* @return
* @throws Exception
*/
public static Object getInstance(String path, Class[] args, Object[] init) throws Exception {
return Class.forName(path).getConstructor(args).newInstance(init);
}
/**
*
* @param path
* :类的全路径
* @param obj
* :实例化对象
* @param method
* :方法名
* @param args1
* :方法参数的Class数组
* @param args2
* :传递的参数
* @return
* @throws Exception
*/
public static Object invokeMethod(String path, Object obj, String method,Class[] args1, Object[] args2) throws Exception {
<span style="white-space:pre"> </span>Method md = Class.forName(path).getMethod(method, args1);
return md.invoke(obj, args2);
}
再结合配置文件,写了一个小小的自动调用程序的代码。配置文件和调用代码如下:
<?xml version="1.0" encoding="UTF-8"?>
<root path="edu.fjnu.reflect.Letter">
<!-- 构造函数的class和参数配置 -->
<constructor>
<classes>
<class>java.lang.String</class>
</classes>
<parameters>
<parameter>ApplE45</parameter>
</parameters>
</constructor>
<!-- 调用方法的参数配置 -->
<method name="toUpperCase">
<classes>
<class>java.lang.String</class>
</classes>
<parameters>
<parameter>panye</parameter>
</parameters>
</method>>
</root>
import java.io.File;
import java.lang.reflect.Method;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
public class AutoInvoke {
public static void main(String[] args) {
try {
// 定义流模式读取xml文件
SAXReader reader = new SAXReader();
// 读取xml文件
Document doc = reader.read(new File("autoinvoke.xml"));
// 读取类名
String className = doc.getRootElement().attributeValue("path");
// 读取构造函数class
Class[] constructorClass = null;
List<Node> list = doc
.selectNodes("//root/constructor/classes/class");
if (list.size() > 0) {
constructorClass = new Class[list.size()];
for (int i = 0; i < list.size(); i++) {
constructorClass[i] = getClass(list.get(i).getText());
}
}
// 读取构造函数参数
Object[] constructorParams = null;
list = doc.selectNodes("//root/constructor/parameters/parameter");
if (list.size() > 0) {
constructorParams = new Object[list.size()];
for (int i = 0; i < list.size(); i++) {
constructorParams[i] = list.get(i).getText();
}
}
// 读取方法名
String methodName = doc.selectSingleNode("//root/method").valueOf(
"@name");
// 读取方法参数class
Class[] methodClass = null;
list = doc.selectNodes("//root/method/classes/class");
if (list.size() > 0) {
methodClass = new Class[list.size()];
for (int i = 0; i < list.size(); i++) {
methodClass[i] = getClass(list.get(i).getText());
}
}
// 读取方法参数
Object[] methodParam = null;
list = doc.selectNodes("//root/method/parameters/parameter");
if (list.size() > 0) {
methodParam = new Object[list.size()];
for (int i = 0; i < list.size(); i++) {
methodParam[i] = list.get(i).getText();
}
}
// 根据类名和构造参数获取实例
Object obj = getInstance(className, constructorClass,
constructorParams);
// 调用实例方法获取方法返回值
Object getReturn = invokeMethod(className, obj, methodName,
methodClass, methodParam);
// 输出返回值
if (getReturn != null) {
System.out.println(getReturn);
} else {
System.out.println("no");
}
} catch (Exception e) {
e.getStackTrace();
}
}
public static Class getClass(String str) throws Exception {
return Class.forName(str);
}
/**
*
* @param path
* :类的全路径
* @param args
* :构造函数参数的Class数组
* @param init
* :构造函数的传递参数
* @return
* @throws Exception
*/
public static Object getInstance(String path, Class[] args, Object[] init)
throws Exception {
return Class.forName(path).getConstructor(args).newInstance(init);
}
/**
*
* @param path
* :类的全路径
* @param obj
* :实例化对象
* @param method
* :方法名
* @param args1
* :方法参数的Class数组
* @param args2
* :传递的参数
* @return
* @throws Exception
*/
public static Object invokeMethod(String path, Object obj, String method,
Class[] args1, Object[] args2) throws Exception {
Method md = Class.forName(path).getMethod(method, args1);
return md.invoke(obj, args2);
}
}
四、内省
说到内省,我们得先说说javabean,javabean要求所有的属性都应该是私有的,并提供get/set的公共方法(如果是booolean类型的把get改成is),并且要提供一个无参的构造方法。比如下面的例子就是一个javabean。
public class Cat { // javabean写法
private String name;
private int age;
private boolean male;
private Date birthday = new Date();
public Cat() {
}
public Cat(String name, int age, boolean male) { //这不是一个javabean必须具备的,但是我们经常写上一个带全参的构造函数,方便对象初始化
this.name = name;
this.age = age;
this.male = male;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isMale() {
return male;
}
public void setMale(boolean male) {
this.male = male;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
这样严格格式的书写要求,相信阅读过前文的人一定能猜得出来,一定是为反射准备的。再来说说内省,内省其实就是根据属性名用反射的方式去调用get/set方法。这里先介绍一个PropertyDescriptor类,它可以可以方便的获得属性名对应的方法(当然我们可以利用前面的知识自己去写,但是既然人家都给我们写好了,当然直接用好了),我们来看下如何使用
PropertyDescriptor类来实现内省。
// 创建对象
Cat cat1 = new Cat("tom", 12, true);
// 填写属性名
String propertyName = "age";
// PropertyDescriptor类可以方便的获得propertyName对应的方法(getAge与setAge)
PropertyDescriptor pd = new PropertyDescriptor(propertyName,cat1.getClass());
// 调用set方法
pd.getWriteMethod().invoke(cat1, 24);
// 调用get方法
Object obj = pd.getReadMethod().invoke(cat1, null);
// 输出age值
System.out.println(obj); //24
同样的,我们将get 和 set写成通用的方法。
/**
* 通用版的javabean set内省
*
* @param obj
* :实例
* @param propertyName
* :属性值
* @param val
* :(数组) 传递的参数
* @throws Exception
*/
public static void set(Object obj, String propertyName, Object... val) throws Exception {
PropertyDescriptor pd = new PropertyDescriptor(propertyName,obj.getClass());
// 调用set方法
pd.getWriteMethod().invoke(obj, val);
}
/**
* 通用版的javabean get内省
*
* @param obj
* :实例
* @param propertyName
* :属性名
*
* @return get值
* @throws Exception
*/
public static Object get(Object obj, String propertyName) throws Exception {
PropertyDescriptor pd = new PropertyDescriptor(propertyName,obj.getClass());
// 调用get方法
return pd.getReadMethod().invoke(obj, null);
}
调用举例如下:
// 通用版的set/get方法
Cat cat2 = new Cat("tim", 23, false);
set(cat2, "age", 56);
System.out.println(get(cat2, "age")); //56
由于这个操作在项目中需要经常进行,apache基金会为我们提供了简便操作,那就是BeanUtils,我们常在web应用程序中使用它。使用它需要在工程中导入commons-beanutils.jar和commons-logging-1.1.jar。BeanUtils的使用方法如下:
Cat cat4 = new Cat("lily", 45, true);
System.out.println(BeanUtils.getProperty(cat4, "male")); //true
BeanUtils.setProperty(cat4, "male", "false"); // 注意:这里的参数统一用string类型。因为网页传递的参数全都是string的
System.out.println(BeanUtils.getProperty(cat4, "male"));
还有一个叫PropertyUtils的类,它能完成的功能与BeanUtils差不多,我们也稍微浏览下它的使用:
// PropertyUtils版
Cat cat5 = new Cat("lily1", 65, true);
System.out.println(PropertyUtils.getProperty(cat5, "name"));
BeanUtils.setProperty(cat4, "male", false); // 与BeanUtils的区别在于数据类型要用原来的
System.out.println(PropertyUtils.getProperty(cat4, "male"));
我们还可以利用BeanUtils或者PropertyUtils进行级联操作,比如我要设置Date类型的hours,可以进行如下调用:
// BeanUtils版(可以级联操作)
BeanUtils.setProperty(cat4, "birthday.hours", "13");// 对Date类型的hours进行set方法调用(级联调用)
System.out.println(BeanUtils.getProperty(cat4, "birthday.hours"));
// PropertyUtils版(可以级联操作)
BeanUtils.setProperty(cat5, "birthday.hours", 14); // 注意:这里的参数要和hours的保持一致
System.out.println(PropertyUtils.getProperty(cat5, "birthday.hours"));
以上就是我对JAVA反射机制的一些认识和理解,欢迎围观吐槽!