反射和代理机制是JDK5.0提供的java新特性，反射的出现打破了java一些常规的规则，如，私有变量不可访问。
先看一下，Java 反射机制主要提供了以下功能：
•在运行时判断任意一个对象所属的类。
•在运行时构造任意一个类的对象。
•在运行时判断任意一个类所具有的成员变量和方法。
•在运行时调用任意一个对象的方法
在这里先看一下sun为我们提供了那些反射机制中的类：
java.lang.Class;
java.lang.reflect.Constructor;
java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Modifier;
java.lang.reflect.Array类：提供了动态创建数组，以及访问数组的元素的静态方法
Class类是Reflection API 中的核心类，它有以下方法
–getName()：获得类的完整名字。
–getFields()：获得类的public类型的属性。
–getDeclaredFields()：获得类的所有属性。
–getMethods()：获得类的public类型的方法。
–getDeclaredMethods()：获得类的所有方法。
-getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes参数指定方法的参数类型。
-getConstructors()：获得类的public类型的构造方法。
•getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。
•newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。
•（2）通过默认构造方法创建一个新对象：
•Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
•以上代码先调用Class类的getConstructor()方法获得一个Constructor 对象，它代表默认的构造方法，然后调用Constructor对象的newInstance()方法构造一个实例。
（4）Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，再将其返回
（5）Java中，无论生成某个类的多少个对象，这些对象都会对应于同一个Class对象。 要想使用反射，首先需要获得待处理类或对象所对应的Class对象。
获取某个类或某个对象所对应的Class对象的常用的3种方式：
a) 使用Class类的静态方法forName：Class.forName(“java.lang.String”);
b) 使用类的.class语法：String.class;
c) 使用对象的getClass()方法：String s = “aa”; Class<?> clazz = s.getClass();
下面写一个程序来用一下这些API吧：
- //获得MethodInvoke类对应的一个clas对象
- Class<?> MethodInvok=MethodInvoke.class;
- //获得一个MethodInvoke类对应的对象实例
- Object MethodInvo=MethodInvok.newInstance();
- //获得MethodInvo对象对应的add方法对应的一个对象实例
- 1）：Method method=MethodInvok.getMethod("add", int.class,int.class);
- //调用MethodInvo对象对应的add方法对应的一个对象(MethodInvo)实例所代表的方法，并获得结果
- 2）Object result= method.invoke(MethodInvo, 1,2);
- System.out.println(result);
- System.out.println("--------------------------------------");
- Method method1=MethodInvok.getMethod("print",String.class);
- Object Result1=method1.invoke(MethodInvo, "tom");
- System.out.println(Result1);
注：1）处的int.class,int.class可以写为new Class[]{int.class,int.class}
原因在于getMethod方法的第二个参数是一个可变参数。
2）处的1,2可以写为new int【】{1,2}，原因如1）；
4.若想通过类的不带参数的构造方法来生成对象，我们有两种方式：
a) 先获得Class对象，然后通过该Class对象的newInstance()方法直接生成即可：
Class<?> classType = String.class;
Object obj = classType.newInstance();
b) 先获得Class对象，然后通过该对象获得对应的Constructor对象，再通过该Constructor对象的newInstance()方法生成：
Class<?> classType = Customer.class;
Constructor cons = classType.getConstructor(new Class[]{});
Object obj = cons.newInstance(new Object[]{});
4. 若想通过类的带参数的构造方法生成对象，只能使用下面这一种方式：
Class<?> classType = Customer.class;
Constructor cons = classType.getConstructor(new Class[]{String.class, int.class});
Object obj = cons.newInstance(new Object[]{“hello”, 3});
java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法
一维数组的简单创建，设值，取值
Object array = Array.newInstance(classType, 10);
Array.set(array, 5, "hello");
String str = (String)Array.get(array, 5);
二维数组的简单创建，设值，取值
- //创建一个设值数组维度的数组
- int[] dims = new int[] { 5, 10, 15 };
- //利用Array.newInstance创建一个数组对象，第一个参数指定数组的类型，第
- 二个参数设值数组的维度，下面是创建一个长宽高为：5,10,15的三维数组
- Object array = Array.newInstance(Integer.TYPE, dims);
- //获取整个类
- Class c = Class.forName("java.lang.Integer");
- //获取所有的属性?
- Field[] fs = c.getDeclaredFields();
- //定义可变长的字符串，用来存储属性
- StringBuffer sb = new StringBuffer();
- //通过追加的方法，将每个属性拼接到此字符串中
- //最外边的public定义
- sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");
- //里边的每一个属性
- for(Field field:fs){
- sb.append("\t");//空格
- sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等
- sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字
- sb.append(field.getName()+";\n");//属性的名字+回车
- }
- sb.append("}");
- System.out.println(sb);
b，获取特定的属性，对比着传统的方法来学习
- public static void main(String[] args) throws Exception{
- <span style="white-space:pre"> </span>//以前的方式：
- /*
- User u = new User();
- u.age = 12; //set
- System.out.println(u.age); //get
- */
- //获取类
- Class c = Class.forName("User");
- //获取id属性
- Field idF = c.getDeclaredField("id");
- //实例化这个类赋给o
- Object o = c.newInstance();
- //打破封装
- idF.setAccessible(true); //使用反射机制可以打破封装性，导致了java对象的属性不安全。
- //给o对象的id属性赋值"110"
- idF.set(o, "110"); //set
- //get
- System.out.println(idF.get(o));
- }
接下来让我们取得其他类的全部属性吧，最后我讲这些整理在一起，也就是通过class取得一个类的全部框架
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
class
hello {
public
static
void
main(String[] args) {
Class<?> demo =
null
;
try
{
demo = Class.forName(
"Reflect.Person"
);
}
catch
(Exception e) {
e.printStackTrace();
}
System.out.println(
"===============本类属性========================"
);
// 取得本类的全部属性
Field[] field = demo.getDeclaredFields();
for
(
int
i =
0
; i < field.length; i++) {
// 权限修饰符
int
mo = field[i].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = field[i].getType();
System.out.println(priv +
" "
+ type.getName() +
" "
+ field[i].getName() +
";"
);
}
System.out.println(
"===============实现的接口或者父类的属性========================"
);
// 取得实现的接口或者父类的属性
Field[] filed1 = demo.getFields();
for
(
int
j =
0
; j < filed1.length; j++) {
// 权限修饰符
int
mo = filed1[j].getModifiers();
String priv = Modifier.toString(mo);
// 属性类型
Class<?> type = filed1[j].getType();
System.out.println(priv +
" "
+ type.getName() +
" "
+ filed1[j].getName() +
";"
);
}
}
}
|
其实还可以通过反射调用其他类中的方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class
hello {
public
static
void
main(String[] args) {
Class<?> demo =
null
;
try
{
demo = Class.forName(
"Reflect.Person"
);
}
catch
(Exception e) {
e.printStackTrace();
}
try
{
//调用Person类中的sayChina方法
Method method=demo.getMethod(
"sayChina"
);
method.invoke(demo.newInstance());
//调用Person的sayHello方法
method=demo.getMethod(
"sayHello"
, String.
class
,
int
.
class
);
method.invoke(demo.newInstance(),
"Rollen"
,
20
);
}
catch
(Exception e) {
e.printStackTrace();
}
}
}
|
代理
动态代理
【案例】首先来看看如何获得类加载器：
|
1
2
3
4
5
6
7
8
9
|
class
test{
}
class
hello{
public
static
void
main(String[] args) {
test t=
new
test();
System.out.println(
"类加载器 "
+t.getClass().getClassLoader().getClass().getName());
}
}
|
【程序输出】：
类加载器 sun.misc.Launcher$AppClassLoader
其实在java中有三种类类加载器。
1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类
3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。
Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽象方法在代理类中动态实现。
(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：
Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。
所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作
package
Reflect;
import
java.lang.reflect.*;
//定义项目接口
interface
Subject {
public
String say(String name,
int
age);
}
// 定义真实项目
class
RealSubject
implements
Subject {
@Override
public
String say(String name,
int
age) {
return
name +
" "
+ age;
}
}
class
MyInvocationHandler
implements
InvocationHandler {
private
Object obj =
null
;
public
Object bind(Object obj) {
this
.obj = obj;
return
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
.getClass().getInterfaces(),
this
);
}
@Override
public
Object invoke(Object proxy, Method method, Object[] args)
throws
Throwable {
Object temp = method.invoke(
this
.obj, args);
return
temp;
}
}
class
hello {
public
static
void
main(String[] args) {
MyInvocationHandler demo =
new
MyInvocationHandler();
Subject sub = (Subject) demo.bind(
new
RealSubject());
String info = sub.say(
"Rollen"
,
20
);
System.out.println(info);
}
}
|
类的生命周期
在一个类编译完成之后，下一步就需要开始使用类，如果要使用一个类，肯定离不开JVM。在程序执行中JVM通过装载，链接，初始化这3个步骤完成。
类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。 但是同一个类只会被类装载器装载以前
链接就是把二进制数据组装为可以运行的状态。
链接分为校验，准备，解析这3个阶段
校验一般用来确认此二进制文件是否适合当前的JVM（版本），
准备就是为静态成员分配内存空间，。并设置默认值
解析指的是转换常量池中的代码作为直接引用的过程，直到所有的符号引用都可以被运行程序使用（建立完整的对应关系）
完成之后，类型也就完成了初始化，初始化之后类的对象就可以正常使用了，直到一个对象不再使用之后，将被垃圾回收。释放空间。
当没有任何引用指向Class对象时就会被卸载，结束类的生命周期
将反射用于工厂模式
package
Reflect;
interface
fruit{
public
abstract
void
eat();
}
class
Apple
implements
fruit{
public
void
eat(){
System.out.println(
"Apple"
);
}
}
class
Orange
implements
fruit{
public
void
eat(){
System.out.println(
"Orange"
);
}
}
class
Factory{
public
static
fruit getInstance(String ClassName){
fruit f=
null
;
try
{
f=(fruit)Class.forName(ClassName).newInstance();
}
catch
(Exception e) {
e.printStackTrace();
}
return
f;
}
}
class
hello{
public
static
void
main(String[] a){
fruit f=Factory.getInstance(
"Reflect.Apple"
);
if
(f!=
null
){
f.eat();
}
}
}
|
现在就算我们添加任意多个子类的时候，工厂类就不需要修改。
上面的爱吗虽然可以通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过属性文件的形式配置所需要的子类。
下面我们来看看： 结合属性文件的工厂模式
首先创建一个fruit.properties的资源文件，
内容为：
|
1
2
|
apple=Reflect.Apple
orange=Reflect.Orange
|
package
Reflect;
import
java.io.*;
import
java.util.*;
interface
fruit{
public
abstract
void
eat();
}
class
Apple
implements
fruit{
public
void
eat(){
System.out.println(
"Apple"
);
}
}
class
Orange
implements
fruit{
public
void
eat(){
System.out.println(
"Orange"
);
}
}
//操作属性文件类
class
init{
public
static
Properties getPro()
throws
FileNotFoundException, IOException{
Properties pro=
new
Properties();
File f=
new
File(
"fruit.properties"
);
if
(f.exists()){
pro.load(
new
FileInputStream(f));
}
else
{
pro.setProperty(
"apple"
,
"Reflect.Apple"
);
pro.setProperty(
"orange"
,
"Reflect.Orange"
);
pro.store(
new
FileOutputStream(f),
"FRUIT CLASS"
);
}
return
pro;
}
}
class
Factory{
public
static
fruit getInstance(String ClassName){
fruit f=
null
;
try
{
f=(fruit)Class.forName(ClassName).newInstance();
}
catch
(Exception e) {
e.printStackTrace();
}
return
f;
}
}
class
hello{
public
static
void
main(String[] a)
throws
FileNotFoundException, IOException{
Properties pro=init.getPro();
fruit f=Factory.getInstance(pro.getProperty(
"apple"
));
if
(f!=
null
){
f.eat();
}
}
}
如果打印代理的Class，会发现其是MainClass.$Proxy0类型
$Proxy0 extends java.lang.reflect.Proxy implements com.tom.proxy.dynamic.BusinessProcessor
{
java.lang.reflect.Method m4;
java.lang.reflect.Method m2;
java.lang.reflect.Method m0;
java.lang.reflect.Method m3;
java.lang.reflect.Method m1;
void eat();
int hashCode();
boolean equals(java.lang.Object);
java.lang.String toString();
}
很明显，Proxy.newProxyInstance方法会做如下几件事：
1，根据传入的第二个参数interfaces动态生成一个类，实现interfaces中的接口，该例中即BusinessProcessor接口的processBusiness方法。并且继承了Proxy类，重写了hashcode,toString,equals等三个方法。具体实现可参看 ProxyGenerator.generateProxyClass(...); 该例中生成了$Proxy0类
2，通过传入的第一个参数classloder将刚生成的类加载到jvm中。即将$Proxy0类load
3，利用第三个参数，调用$Proxy0的$Proxy0(InvocationHandler)构造函数 创建$Proxy0的对象，并且用interfaces参数遍历其所有接口的方法，并生成Method对象初始化对象的几个Method成员变量
4，将$Proxy0的实例返回给客户端。
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);
m3 = Class.forName("com.ml.test.Manager").getMethod("modify",
new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);
} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}
@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
.booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final void modify() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}
1788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
