一文看懂java中的反射

最新推荐文章于 2023-09-11 21:29:12 发布

程序人生tt

最新推荐文章于 2023-09-11 21:29:12 发布

阅读量158

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/qq_43169491/article/details/105449834

版权

java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Class - 字节码文件面向对象的类
类的加载概述
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
加载
就是指将class文件读入内存，并为之创建一个Class对象。(字节码文件)
任何类被使用时系统都会建立一个Class对象。
连接
验证 : 是否有正确的内部结构，并和其他类协调一致
准备 : 负责为类的静态成员分配内存，并设置默认初始化值
解析：把类中的符号引用转换为直接引用
初始化就是类的初始化步骤

类在什么时候加载？（也就是类的加载时机）
创建类的实例
访问类的静态变量，或者为静态变量赋值。
使用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

类加载器的概述
负责将.class文件加载到内在中，并为之生成对应的Class对象。
类加载器的分类
Bootstrap ClassLoader 根类加载器
Extension ClassLoader 扩展类加载器
Sysetm ClassLoader 系统类加载器
类加载器的作用
Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录
Sysetm ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath 环境变量所指定的jar包和类路径
关于类的加载器，我现在还没啥研究，可能明年才会学习虚拟机。毕竟学习是一个循序渐进的过程。记住水到渠成，我真的很喜欢的一个成语。

反射的定义：反射技术就是把Java类中的各种成分映射成相应的java类，通过反射技术，一个类的成员都可以得到相应反射类的一个实例对象，通过调用Class类的方法可以得到这些实例对象。通过Class类的反射技术，能够较好地提高程序的灵活性和复用性。

获取字节码文件的方式：

1、Object类的getClass方法（）（利用对象调用这个方法来实现）
2、静态属性class（运用对象.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取对应的基本数据类型的Class实例）
3、class类中静态方法forName() (里面传入的是类的全限定名：指的是包名加类名)
代码实例：


public class TestPerson {
	
	public static void main(String[] args) {
		
		//1、Object类的getClass方法（）
		Class<? extends Person> cl = new Person().getClass();
		System.out.println(cl);
		
		
		System.out.println("-------------------------------");
		//2、静态属性class
		Class<Person> cl1 = Person.class;
		System.out.println(cl1);
		System.out.println("-------------------------------");
		//3、class类中静态方法forName()
		try {
			Class<?> cl3 = Class.forName("com.yaorange.entity.User");
			System.out.println(cl3);
		} catch (ClassNotFoundException e) {
			
			e.printStackTrace();
		}
	}
}

下面分别对java类（成员字段、成员方法、构造函数）中的成分进行操作：

研究字节码文件中的构造函数

注意这只能是公有的方法：
在这里插入图片描述
这可以是私有的构造方法：
这里有个知识点很重要：在反射中如果要操作私有的修饰属性或者方法必须取消java中的访问检查

代码实例：

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class TestUser {
	
	public static void main(String[] args) {
		
		/*
		 * 研究User字节码文件中的构造函数
		 */
		Class<User> clzz = User.class;
		
		
		Constructor<?>[] cs = clzz.getConstructors();
		for (Constructor<?> constructor : cs) {
			System.out.println(constructor);
		}
		
		System.out.println("--------------------------");
		//获取指定的构造器   传入的是对应的字节码文件类型
		try {
			Constructor<User> c = clzz.getConstructor(String.class,int.class);
			
			System.out.println(c);
			
			//调用该字节码文件 对指定的对象中的属性赋值
			User u = c.newInstance("小明",23);
			System.out.println(u);
			
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		
		
		//获取私有的构造方法
		try {
			Constructor<User> c2 = clzz.getDeclaredConstructor(String.class);
			System.out.println(c2);
			//在反射中如果要操作私有的 修饰属性 或者方法 必须 取消java中的访问检查
			c2.setAccessible(true);
			User u2 = c2.newInstance("老王");
			System.out.println(u2);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		
		
		
		
	}

}

研究字节码文件中的方法

公有的：
在这里插入图片描述
私有的：

代码实例：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestUser_2 {
	
	public static void main(String[] args) {
		
		Class<User> clzz = User.class;
		
		//有参数写参数，没参数写null或者不写
		try {
			Method m1 = clzz.getMethod("show",null);
			//创建字节码文件的实例
			User obj = clzz.newInstance();
			
			m1.invoke(obj, null);
			
			/*
			 * 有参数的私有方法调用
			 */
			Method m2 = clzz.getDeclaredMethod("setUsers", String.class,int.class);
			m2.setAccessible(true);
			Object invoke = m2.invoke(obj, "大桥",15);
			System.out.println(invoke);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}

}

研究字节码文件中的成员字段

私有的：
在这里插入图片描述
公有的：

代码实例：

import java.lang.reflect.Field;

public class TestUser_1 {
	public static void main(String[] args) {
		/*
		 * 反射操作字段
		 * 这个和构造函数比较类似
		 */
		Class<User> clzz = User.class;
		
		Field[] fis = clzz.getDeclaredFields();
		for (Field field : fis) {
			//得到所有字段的名称
			System.out.println(field.getName());
			
		}
		
		System.out.println("---------------------------------------");
		//得到指定字段的名称
		try {
			Field f1 = clzz.getDeclaredField("uname");
			//给字段赋值
			//set(object obj,Object value)
			//这个创建类的实例一定调用的是类的无参构造函数
			User obj = clzz.newInstance();
			f1.setAccessible(true);
			f1.set(obj, "小红");
			System.out.println(obj);
			
			
			
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		
		
	}
	

}

反射的应用：

代码实例：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
 * 通过反射越过泛型检查
 */

public class Case_1 {
	
	public static void main(String[] args) {
		ArrayList<Integer> arrayList = new ArrayList<>();
		
		arrayList.add(12);
		//通过反射将字符串 放入 整型集合中
		
		//通过反射调用方法
		//其ArrayList的字节码文件
		try {
			Class<ArrayList> forName = (Class<ArrayList>)Class.forName("java.util.ArrayList");
			
			//获取反射要调用的方法
			Method m = forName.getDeclaredMethod("add", Object.class);
			
			//调用反射方法
			m.invoke(arrayList, "小明");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		
		for(int i=0;i<arrayList.size();i++) {
			System.out.println(arrayList.get(i));
		}
		
		
	}
	
	
}

代理模式：

静态代理：
动态代理：
在这里插入图片描述
给里面的功能添加一些额外的能力，比如记录什么时候进入方法，什么时候结束方法。

静态代理实例代码：

/*
 * 服务接口
 */
public interface ServiceInter {
	
	void service();
}

/*
 * 目标类
 */
public class TargetServie  implements ServiceInter{

	@Override
	public void service() {
		
		System.out.println("执行业务逻辑");
	}

}

/*
 * 代理类
 */
public class ProxyService implements ServiceInter{
	
	//保存目标类的引用
	
	private ServiceInter targetService;
	
	public ProxyService(ServiceInter targetService) {
		super();
		this.targetService = targetService;
	}

	@Override
	public void service() {
		logBefore();
		targetService.service();
		logAfter();
		
	}
	
	public void logBefore() {
		
		System.out.println("记录进入方法的时间");
	}
	
	public void logAfter() {
		System.out.println("出去的时间");
	}
	

}


public class Test {
	
	public static void main(String[] args) {
		ProxyService servie = new ProxyService(new TargetServie());
		servie.service();
	}
}

运行结果：
在这里插入图片描述
**

动态代理概述

**
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
举例：春季回家买票让人代买
动态代理：在程序运行过程中产生的这个对象
而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
在Java中java.lang.reflect包下提供了一个Proxy类和一个 InvocationHandler接口，
通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
最终会调用InvocationHandler的方法
InvocationHandler Object invoke(Object proxy,Method method,Object[] args)
案例演示: 动态代理的实现

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理类
public class Case_1 {
	
	public static void main(String[] args) {
		
		/*
		 * 创建代理类的实例
		 */
		TargetServie obj = new TargetServie();
		ServiceInter proService = (ServiceInter)Proxy.newProxyInstance(Case_1.class.getClassLoader(), new Class[]{ServiceInter.class}, new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				
				logBefore();
				//调用目标类的方法
				Object invoke = method.invoke(obj, args);
				logAfter();
				return invoke;
			}
			
			public void logBefore() {
				
				System.out.println("记录进入方法的时间");
			}
			
			public void logAfter() {
				System.out.println("出去的时间");
			}
			
		});
		
		//调用代理类的方法
		proService.service();
		
		System.out.println("--------------------");
		
		proService.add();
	}
}

运行结果：
在这里插入图片描述
到这里反射及其应用就讲到这里了。
书山有路勤为径，学海无涯苦做舟。

程序人生tt

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
一文看懂java中的反射

Class - 字节码文件面向对象的类类的加载概述当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。加载就是指将class文件读入内存，并为之创建一个Class对象。(字节码文件)任何类被使用时系统都会建立一个Class对象。连接验证 : 是否有正确的内部结构，并和其他类协调一致准备 : 负责为类的静态成员分配内存，并设...
复制链接

扫一扫

专栏目录