一、从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
}
}假设我们有这么一个类（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;
}
}
// 创建对象
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
/**
* 通用版的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
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版
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版(可以级联操作)
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"));
293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
