反射
提到反射就不得不说类加载的过程,在Java代码运行的过程中,并不是只有new对象一种方式;
类加载
类加载的过程
作用:将.class文件加载到虚拟机中的过程;
类加载的时机:
- 创建类的实例(对象)
- 调用类的类方法
- 访问类或者接口的类变量,或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
过程:
如图示从左到右,以及每步做的工作;
类加载器的分类
我们也可以进行继承加载器,建立自己的类加载器,是系统类加载器的子类,但是用途不大;
package invoke;
import java.io.InputStream;
public class MyClassLoder extends ClassLoader {
public MyClassLoder(ClassLoader parent) {
super(parent);
}
public MyClassLoder() {
}
@Override
public InputStream getResourceAsStream(String name) {
return super.getResourceAsStream(name);
}
}
package invoke;
public class ClassLoderTest {
public static void main(String[] args) {
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();// 系统类加载器
ClassLoader parent = systemClassLoader.getParent();//平台类加载器
ClassLoader parent1 = parent.getParent();//启动类加载器
//ClassLoader parent2 = parent1.getParent();//空指针异常
System.out.println(systemClassLoader);
System.out.println(parent);
System.out.println(parent1);
//System.out.println(parent2);
MyClassLoder myClassLoder = new MyClassLoder();
ClassLoader parent2 = myClassLoder.getParent(); // 系统类加载器
System.out.println(parent2);
}
}
类加载的双亲委派模型
前置:
类加载过程时,虚拟机肯定要保证加载进来的类是唯一的,那么怎么保证呢?
双亲委派:
如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行,如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器,如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式
简单来说:类加载器收到一个类加载请求,他会先去找自己的父类加载器去执行,父类加载器执行无法加载,子类才会尝试去加载;
test.properties
xingming=xiaoming
nianling=23
package invoke;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class ClassLoderTest02 {
public static void main(String[] args) throws IOException {
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
InputStream resourceAsStream = systemClassLoader.getResourceAsStream("test.properties");
Properties properties = new Properties();
properties.load(resourceAsStream);
System.out.println(properties);// {nianling=23, xingming=xiaoming}
resourceAsStream.close();
}
}
针对初学者,在这里会发现文件和代码联系起来了,是不是很好玩,不过具体的可以看流的具体讲解,这里不展开了;
反射的概念
反射机制:
反射是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;
对于任意一个对象,都能够调用它的任意属性和方法;
这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
获取class类对象的三种方式
- 类名.class属性
- 对象名.getClass()方法
- Class.forName(全类名)方法
常用API
大类 | 方法名 | 作用 |
构造方法 | Constructor<?>[] getConstructors() | 返回所有公共构造方法对象的数组 |
构造方法 | Constructor<?>[] getDeclaredConstructors() | 返回所有构造方法对象的数组 |
构造方法 | Constructor getConstructor(Class<?>… parameterTypes) | 返回单个公共构造方法对象 |
构造方法 | Constructor getDeclaredConstructor(Class<?>… parameterTypes) | 返回单个构造方法对象 |
反射创建对象 | T newInstance(Object…initargs) | 根据指定的构造方法创建对象 |
暴力反射 | setAccessible(boolean flag) | 设置为true,表示取消访问检查 |
获取方法 | Method[] getMethods() | 返回所有公共成员方法对象的数组,包括继承的 |
获取方法 | Method[] getDeclaredMethods() | 返回所有成员方法对象的数组,不包括继承的 |
获取方法 | Method getMethod(String name, Class<?>… parameterTypes) | 返回单个公共成员方法对象 |
获取方法 | Method getDeclaredMethod(String name, Class<?>… parameterTypes) | 返回单个成员方法对象 |
反射运行方法 | Object invoke(Object obj, Object… args) | 运行方法 |
测试
package invoke;
public class Student {
private String name;
private Integer age;
public Student() {
System.out.println("空构造方法执行");
}
public Student(String name, Integer age) {
System.out.println("全参构造方法执行");
this.name = name;
this.age = age;
}
public String getName() {
System.out.println("获取name");
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
System.out.println("获取age");
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public void methodTest(){
System.out.println("测试反射执行");
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package invoke;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class InvokeTest {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
method01();
}
private static void method01() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class<?> aClass = Class.forName("invoke.Student");
Student student = (Student)aClass.newInstance();//空构造方法执行
Method getName = aClass.getMethod("getName");//获取name
Method getMethod = aClass.getMethod("methodTest");//测试反射执行
getName.invoke(student);
getMethod.invoke(student);
Method[] declaredMethods = aClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod);
}
}
}
动态代理
动态代理主要是在不改类代码的情况下,对实现某一接口的类的某些方法增强
接口
package dongtaidaili;
public interface PeopleInterface {
void eat(String food);
void play(String name);
}
实现类
package dongtaidaili;
public class People implements PeopleInterface{
private String name;
private String food;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
public void eat(String food) {
System.out.println("吃"+food);
}
public void play(String name) {
System.out.println("玩"+name);
}
}
测试方法
package dongtaidaili;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Demo01 {
public static void main(String[] args) {
final People people = new People();
people.eat("奶酪");//吃奶酪
people.play("散步");//玩散步
PeopleInterface peoProxy = (PeopleInterface)Proxy.newProxyInstance(People.class.getClassLoader(),
new Class[]{PeopleInterface.class},
/*
* * @param proxy 代理对象,这个位置的代理对象是给系统使用
* @param method 目标方法的封装对象
* @param args 调用目标方法传递的实参
* @return 表示目标方法的返回值,一定要在该方法内部,把调用目标方法获得的返回值return出去,否则外界无法获取该值
*/
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if("play".equals(method.getName())){
System.out.println("太极");
return null;
}else {
return method.invoke(people,args);
}
}
});
peoProxy.eat("花生");//吃花生
peoProxy.play("跆拳道");// 太极
}
}
带出参的返回
上面的接口和类出参为String 不在写了
package dongtaidaili;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Demo01 {
public static void main(String[] args) {
final People people = new People();
//people.eat("奶酪");//吃奶酪
//people.play("散步");//玩散步
PeopleInterface peoProxy = (PeopleInterface) Proxy.newProxyInstance(People.class.getClassLoader(),
new Class[]{PeopleInterface.class},
/*
* * @param proxy 代理对象,这个位置的代理对象是给系统使用
* @param method 目标方法的封装对象
* @param args 调用目标方法传递的实参
* @return 表示目标方法的返回值,一定要在该方法内部,把调用目标方法获得的返回值return出去,否则外界无法获取该值
*/
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
if ("play".equals(method.getName())) {
System.out.println(args[0]);// 吃花生 比如加入参日志
System.out.println("太极");
result = method.invoke(people, args);
System.out.println(result); // 跆拳道 比如出参日志
}
else {
result = method.invoke(people, args);
}
} catch (
Exception e) {
e.printStackTrace();
}
return result;
}
});
String invokeValue = peoProxy.eat("花生");//吃花生
System.out.println("---------------------------------------");
String resultValue = peoProxy.play("跆拳道");// 太极
//System.out.println("普通return" + invokeValue);
System.out.println(resultValue);
}
}
cglib代理
cglib代理是对没有实现接口的类的某些方法增强
类
package cglib;
public class Student {
private String name;
private String school;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String name(String name){
System.out.println(name);
return name;
}
}
cglib增强
package cglib;
import org.easymock.cglib.proxy.Enhancer;
import org.easymock.cglib.proxy.MethodInterceptor;
import org.easymock.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class StudentCglibProxy {
public static Student createStudentCglibProxy(Class clazz){
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
// 回调方法
enhancer.setCallback(new MethodInterceptor() {
/**
*
* @param proxyObject 代理对象
* @param targetMethod 目标方法
* @param args 目标方法调用时传递的实参
* @param methodProxy 代理方法(增强后的方法)
* @return 目标方法的返回值
* @throws Throwable
*/
public Object intercept(Object proxyObject, Method targetMethod, Object[] args, MethodProxy methodProxy) throws Throwable {
//通过调用父类的方法实现对原始方法的调用
// 用错了,可以会掉子类对象的代理方法(递归,没有出口)
Object ret = methodProxy.invokeSuper(proxyObject, args);
//后置增强内容,与JDKProxy区别:JDKProxy仅对接口方法做增强,cglib对所有方法做增强,包括Object类中的方法
if(targetMethod.getName().equals("name")) {
System.out.println("小明同学");
}
return ret;
}
});
//使用Enhancer对象创建对应的对象
return (Student) enhancer.create();
}
}
test
package cglib;
public class Test10 {
public static void main(String[] args) {
Student studentCglibProxy = StudentCglibProxy.createStudentCglibProxy(Student.class);
String name = studentCglibProxy.name("小红");
System.out.println(name);
}
}