一、反射
反射其实就是对字节码进行操作，构造函数对应Constructor类，成员变量对应Field类，成员方法对应Method类，其实这些类有一个特性，那就是通过字节码获取的。
1.1、反射解析
1、获取字节码的三种方式：
- 类名.class 例如:System.class
- 对象.class 例如:new Date().getClass()
- Class.forName("类名"),例如:Class.forName("java.util.Date");
String str = "abc";
Class cls1 = str.getClass();//通过调用getClass方法获取字节码。
Class cls2 = String.class;//通过类名.class获取字节码。
Class cls3 = Class.forName("完整类名");//通过Class.forName()获取字节码,会出现异常。
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true
总结:获取字节码的三种方式,主要用第三种。可以将"java.util.Date"看成一个变量。
2、反射获取构造函数
Constructor类：
a) 得到某个类所有的构造方法。
Constructor[] cons = Class.forName("java.lang.String").getConstructors();
b) 得到某一个构造方法:
Constructor constructor = Class.forName("java.lang.String").getConstructors(StringBuffer.class);
c) 创建实例对象:
通常方式:
String str = new String(new StringBuffer("abc"));
反射方式:
Constrctor cons = String.class.getConstructor(StringBuffer.class);
String str = (String)cons.newInstance(new StringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象
String.class.getConstructor("可变参数列表");//StringBuffer.class,int.class.....
常用方法：
- getConstructor(字节码...)://获取类中public修饰构造函数，获取时需要指定参数列表来确定具体哪一个.注意它是可变参数列表。
- getDeclaredConstructor(字节码...)://获取类中public或private修饰的构造函数,获取时需要指定参数列表来确定具体哪一个.注意它是可变参数列表。
- getConstructors()://获取类中所有被public修饰的构造函数，返回的是Constructor类型的数组。
- getDeclaredConstructors()://获取类中所有被public以及private修饰的构造函数，返回值是Constructor类型的数组。
使用详解:
1.Contructor类中的newInstance()的返回值是Object类型，参数列表对应getConstruct()方法的参数列表锁指定的类型。
Constructor cons = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
String str = (String)cons.newInstance(new StringBuffer("abc"));
类型转换是因为编译时所指定的，运行时却不知道，所以我们必须再次指定，也可以简单的理解newInstance()返回的是Object类型。
注意:Class类中也有newInstance()方法，其实只是Constructor类的省略写法，省去了获取字节码的过程，它只能访问无参的构造函数。
3、成员变量的反射
Field类:Field类代表某个类中的一个成员变量。
- getField(String name)://获取类中public修饰的且变量名和参数列表相同的成员变量。
- getDeclaredField(String name)://获取类中public或者private修饰的且变量名和参数列表相同的成员变量。
- getFields()://获取类中所有被public修饰的成员变量,返回值是Field类型的数组。
- getDeclaredFields()://获取类中所有被public以及private修饰的成员变量，返回值是Field类型的数组。
使用详解:
(1) get和set方法:
Object get(Object obj)://返回指定对象上此 Field 表示的字段的值。根据返回值注意类型转换。 void set(Object obj, Object value)://将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 拓展:这系列方法还有很多，比如:getInt()、getBoolean()、setInt()、setBoolean().....等等
(2) Class<?> getType():返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
例:field.getType == String.class
注:这里判断用==,当然也可以用equals,只是==的话语意上才正确。
实例演示：
class ReflectPoint {
private int x;
public int y;
ReflectPoint(int x,int y){
this.x = x;
this.y = y;
}
}
//主函数
ReflectPoint rep = new ReflectPoint(3,5);
//Field不是对象身上的变量，而是类上，要用它去取对象身上的值。
//获取public修饰的成员变量。
Field fieldY = rep.getClass().getField("y");
System.out.println(fieldY.get(rep));
//获取被private修饰的成员变量(暴力反射)
Field fieldX = rep.getClass().getDeclaredField("x");
fieldX.setAccessible(true);//设置为可以访问
System.out.println(fieldX.get(rep));
/*
我的写法:
ReflectPoint rep = new ReflectPoint(3,5);
Class cls = rep.getClass();
Field fieldY = cls.getField("y");
//暴力反射
Field fieldX = cls.getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(rep)+"::"+fieldY.get(rep));
练习:将一个类中所有String类型的成员变量的值中的a改成b。
(接上面,具体参考反射源码示例)
//获取类中所有的String类型成员变量，并将‘a‘改成‘b‘。
public static void changeValue(Object obj) throws Exception{
Field[] fields = obj.getClass().getFields();
//迭代器
for(Field field : fields){
if(field.getType() == String.class){
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace(‘a‘,‘b‘);
//替换后再将新值存进去
field.set(obj,newValue);
}
}
}
4、成员方法的反射
Method类:Method代表某个类中的一个成员方法。
Mehod charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);
调用方法:
1)通常方式:
String str = "abc";
System.out.println(str.charAt());
(2)反射方式:
String str = "abc";
Mehod Me = Class.forName("java.lang.String").getMethod("charAt",int.class);
System.out.println(Me.invoke(str,1));
//注:getMethod(name,type.class):第一个参数是方法名，第二个参数是数据类型的字节码。
//invoke(Object obj,参数):第一个参数为对象，第二个参数为getMethod方法中所对应的方法名的参数。(charAt的参数)
如果传递给Method对的invoke()方法的第一个参数为null,说明该Method的对象对应的是一个静态方法。
常用方法:
- getMethod(String name,字节码...)://获取类中被public修饰的方法，获取时需要指定方法名(name)，以及字节码是该方法名的参数列表类型的字节码。
- getDeclaredMethod(String name,字节码...)://获取类中被public或者private修饰的方法，获取时需要指定方法名(name)，以及字节码是该方法名的参数列表类型的字节码。
- getMethods()://获取类中被public修饰的所有方法,返回值是Method类型的数组。
- getDeclaredMethods()://获取类中被public以及private修饰的所有方法，返回值是Method类型的数组
使用详解:
invoke(Object obj, Object... args):
(1) 它的返回值是Object类型，所以调用传值过程中注意类型转换。
(2) 它第一个参数对应被反射的类的引用(对象),如果被反射获取的方法是静态的，则参数值为null。
(3) 它第二个参数是可变参数列表，对应被反射获取的方法的参数列表，如果为无参方法，则invoke第二个参数值为0的数组或者null。
(4) 它具备了所有被反射的成员的方法的功能，可以破坏方法的限制，主要指定该方法所在类的对象，以及方法名。
5、数组的反射:
- 具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
- 代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
- 基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
- Arrays.asList()方法处理int[]和String[]时的差异。
- Array工具类用于完成对数组的反射操作。
反射的方式操作数组。
public static void printObject(Object obj){
//获取数组的字节码
Class cls = obj.getClass();
//判断是否是数组
if(cls.isArray()){
//是数组的话我们取其长度并打印
int len = Array.getLength(obj);
for(int x=0;x<len;x++){
System.out.ptintln(Array.get(obj,x));
}
}else{
//不是数组直接打印值
System.out.println(obj);
}
}
总结:数组的反射操作是通过数组的字节码和Array工具类结合来判断长度和获取元素。
6、反射总结
a) 总结一:
1.getFields()和getMethods()依次获得权限为public的成员变量和方法，将包含从父类(接口)中继承到的成员变量和方法；
2.而通过方法getDeclaredFields()和getDeclaredMethods()只是获得本类中定义的所有成员变量和方法,包括private修饰的。
3.getField以及getMethod和getFields()和getMethods()也是一样,带s的返回的是数组，不带s的可以在参数列表中指定具体某一个。
b) 总结二:
1.Constructor、Filed、以及Method类都有一个父类AccessibleObject,从中继承了一系列的方法，比如:setAccessible(boolean flag)。
2.setAccessible(boolean flag)方法主要是在访问被private修饰的构造函数、成员变量以及成员方法的时候，必须指定setAccessible(true)。
3.setAccessible(true)并不是将访问权限改成了public,而是取消java的权限控制检查。所以即使是public方法，其属性默认也是false。
了解:getFiled和getMethod以及带s的都是通过递归去查找公共成员变量或者方法，成员变量先接口再父类，成员方法先父类后接口。
带Declared的能访问一个类中所有的方法，不论是公开还是私有。
二、动态代理
动态代理:用来修改已经具有的对象的方法,控制方法是否执行,或在方法执行之前和执行之后做一些额外的操作
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h);
loader -- 类加载器
interfaces -- 指定代理对象实现哪些接口,通常代理对象要和被代理对象实现相同的接口,从而保证和被代理者具有相同的方法
InvocationHandler
-- 处理器对象,当调用代理对象的任何方法时,都会导致此对象中的invoke方法执行,在这个方法中可以编写是否允许方法执行,
以及在方法执行之前和之后做那些额外的操作
其中有一个比较重要的方法：
{
Object invoke (Object proxy, Method method, Object[] args)
proxy -- 代理者对象
method -- 当前调用到的方法
args -- 方法的参数
返回值 -- 就是这个方法要返回什么
}
1、使用动态代理
a) 我们首先创建一个Person类，并实现接口IAction，接口中有两个方法sing和dance。
public class Person implements IAction {
public void singe() {
System.out.println("唱歌");
}
public void dance() {
System.out.println("跳舞");
}
}
interface IAction {
public void singe();
public void dance();
}
b) 接下来我们创建Person的代理类PersonProxy
public class PersonProxy {
private Person person = new Person();
public Object newPersonProxy(){
IAction iAction = (IAction) Proxy.newProxyInstance(person.getClass().getClassLoader(),
person.getClass().getInterfaces(), new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 当返回代理对象，调用代理对象的任何方法都会走invoke里面的逻辑
System.out.println("----------------------");
return null;
}
});
return iAction;
}
}
c) 然后我们创建TestDynamicProxy类来测试下,运行可以看出-----被打印出来，并且调用任意方法都会走invoke的逻辑。
public class TestDynamicProxy {
public static void main(String[] args){
PersonProxy personProxy = new PersonProxy();
IAction iAction = (IAction) personProxy.newPersonProxy();
iAction.dance();
}
}
d) 再次处理下invoke中的逻辑，完善代理类的操作
public class PersonProxy {
private Person person = new Person();
public Object newPersonProxy(){
IAction iAction = (IAction) Proxy.newProxyInstance(person.getClass().getClassLoader(),
person.getClass().getInterfaces(), new InvocationHandler() {
// 当返回代理对象，调用代理对象的任何方法都会走invoke里面的逻辑
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 调用真实的person去执行行为操作
if(method.getName().equals("dance")){
// 第一个参数为代理对象，第二个参数是方法的参数列表,如果不想让程序继续执行，则直接retuen
return method.invoke(person, args);
}else if (method.getName().equals("sing")) {
return method.invoke(person, args);
}else{
System.out.println("该方法暂时未开通");
return null;
}
}
});
return iAction;
}
}
e) 接下来，我们对方法进行改造，比如加入点歌的操作，并且还带返回值，以表达观众的热情
public class Person implements IAction {
public String sing(String name) {
System.out.println("唱歌");
return "歌唱完了，谢谢！";
}
public String dance(String name) {
System.out.println("跳舞");
return "跳舞完了，谢谢";
}
}
interface IAction {
public String sing(String name);
public String dance(String name);
}
f) 可以看到运行没有问题，其实传递的参数会封装在invoke的args参数列表中，它是一个Object类型的可变数组，我们可以在invoke中打印查看args列表
public class TestDynamicProxy {
public static void main(String[] args){
PersonProxy personProxy = new PersonProxy();
IAction iAction = (IAction) personProxy.newPersonProxy();
String dance = iAction.dance("爵士舞");
String sing = iAction.sing("黑色毛衣");
System.out.println(dance);
System.out.println(sing);
}
}
g) 之后，假如唱歌和跳舞需要一些特殊的要求，比如要钱或者掌声等等，那么我们可以在invoke中处理这个逻辑
public class PersonProxy {
private Person person = new Person();
public Object newPersonProxy(){
IAction iAction = (IAction) Proxy.newProxyInstance(person.getClass().getClassLoader(),
person.getClass().getInterfaces(), new InvocationHandler() {
// 当返回代理对象，调用代理对象的任何方法都会走invoke里面的逻辑
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 调用真实的person去执行行为操作
if(method.getName().equals("dance")){
// 第一个参数为代理对象，第二个参数是方法的参数列表,如果不想让程序继续执行，则直接retuen
System.out.println(args[0]);
System.out.println("跳舞需要三千块钱");
return method.invoke(person, args);
}else if (method.getName().equals("sing")) {
System.out.println(args[0]);
System.out.println("唱歌需要二千块钱");
return method.invoke(person, args);
}else{
System.out.println("该方法暂时未开通");
return null;
}
}
});
return iAction;
}
}
总结：动态代理最大的作用是通过反射在不改变源代码的情况下，对方法进行增强操作。
2、动态代理原理
动态代理其实是在运行时，通过反射获取到字节码，在运行时期的内存中创建被代理类的实例对象，并返回。
动态代理中最重要的方法就是newProxyInstance()方法了，我们可以看下它的源码：
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
.....
Class<?> cl = getProxyClass0(loader, intfs);
try {
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (Exception e) {
}
}
通过源码我们可以看出，首先拿到被代理类的字节码，通过反射获取到构造函数，然后创建出被代理对象的实例并返回给代理对象。
简而言之，动态代理其实就是被代理类的实例构建出该类的另一个实例，这个另外的实例就是所谓的代理对象。
不过日常开发中，动态代理很少使用，一般主要用于方法增强和框架开发等，不过方法增强的方式有很多，不一定
非要使用动态代理，比如使用继承和装饰者模式，但是动态代理有一个优点，它可以不改变源代码来实现功能加强。