JAVA Reflection 反射机制
- 面试题：Java中创建对象大概有这几种方式？
- 静态语言 / 动态语言
- 什么是反射机制？
- 反射机制的原理
- 反射的优缺点
- 反射的用途
- JAVA中基本数据类型的Class是什么？
- 反射机制常用的API
- 反射机制获取类的方法
- 通过反射获取运行时类的完整结构
- 获取Class对象后能做什么?
- 创建类的对象
- 通过反射调用对象的方法
- 通过反射操作属性
- 反射操作泛型
- 反射操作注解
面试题：Java中创建对象大概有这几种方式？
思考：在讲反射之前，先思考一个问题，java中如何创建一个对象，有哪几种方式?
答：
- 使用new关键字：这是我们最常见的也是最简单的创建对象的方式，需要使用构造器。
语法格式：类名 对象名 = new 类名()；
//1、使用关键字new创建对象（没有参数调用无参构造、传入参数调用带参构造）
Girlfriend girlfriend01 = new Girlfriend();
Girlfriend girlfriend02 = new Girlfriend("y", 18);- 使用object类的clone方法：需要实现Cloneable接口，重写object类的clone方法。无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。
语法格式：类名 对象名 = (类名)已创建好的类对象名.clone();
Girlfriend girlfriendClone = (Girlfriend) girlfriend03.clone();- 使用反序列化：通过 ObjectInputStream 的 readObject()方法反序列化类，当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象。为了反序列化一个对象，我们需要让我们的类实现Serializable接口。在反序列化时，JVM创建对象并不会调用任何构造函数。
通过反序列化生成对象的过程主要由以下几个步骤：
1、创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2、 通过对象输入流的readObject()方法读取对象。
Girlfriend clone = ObjectUtils.clone(girlfriend04);序列化工具类：
public class ObjectUtils {
public static <T extends Serializable> T clone(Girlfriend obj) {
T cloneObj = null;
try {
//写入字节流
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream obs = new ObjectOutputStream(out);
obs.writeObject(obj);
obs.close();
//分配内存，写入原始对象，生成新对象
ByteArrayInputStream bis = new ByteArrayInputStream(out.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
//返回新生成的对象
cloneObj = (T) ois.readObject();
bis.close();
out.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return cloneObj;
}
}上边是Java中常见的创建对象的三种方式，其实除了上边的三种还有另外一种方式，就是接下来我们要讨论的 “反射”。使用反射机制创建对象，用Class类或Constructor类的newInstance()方法。
语法格式：
java.lang.Class Class 类对象名称=java.lang.Class.forName(要实例化的类全称);
类名 对象名=(类名)Class类对象名称.newInstance();
当使用Class类里的newInstance()方法，调用的是无参构造方法。
当使用 java.lang.reflect.Constructor 类里的 newInstance() 方法，调用的是有参构造方法。
//使用反射机制创建对象，使用Class的newInstance()调用默认的无参构造
Girlfriend girlfriend03 = Girlfriend.class.newInstance();
//反射机制2，调用带参
Class<?> p1 = Class.forName("com.yky.Girlfriend");
Constructor<?> constructor = p1.getConstructor(String.class, Integer.class);
Girlfriend girlfriend04 = (Girlfriend) constructor.newInstance("k", 18);
System.out.println(girlfriend04);静态语言 / 动态语言
动态语言:
➢是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
➢主要动态语言: Object-C、 C#、 JavaScript、 PHP、 Python等。
静态语言：
➢与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
注意：
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一 定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性上编程的时候更加灵活!
什么是反射机制？
Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。
反射机制的原理
我们可能听过，Java编写的程序，一次编译，到处运行。这也是Java程序为什么是无关平台的所在，原因在于，java的源代码会被编译成.class文件字节码，只要装有Java虚拟机JVM的地方（Java提供了各种不同平台上的虚拟机制。）.class文件才可以在运行加载。其流程如下：
- 第一步：由Java编译器进行源代码编译，得到相应类的字节码.class文件。
- 第二步：生成class文件之后，通过ClassLoader类加载器加载进内存，Java字节码由JVM执行解释给目标计算机。
- 第三步，目标计算机将结果呈现给我们计算机用户；因此，Java并不是编译机制，而是解释机制.class文件才可以在不同平台上运行加载。
Java的反射机制，操作的就是这个.class文件，首先加载相应类的字节码（运行编译器idea的时候，.class文件的字节码会加载到内存中），随后解剖（反射 reflect）出字节码中的构造函数、方法以及变量（字段）。
反射的优缺点
优点：
在运行时获得类的各种内容，进行反编译，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。
缺点：
- 反射会消耗一定的系统资源，因此，如果不需要动态地创建一个对象，那么就不需要用反射；
- 反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题。
反射的用途
1、反编译：.class文件 --> .java文件；
2、通过反射机制访问java对象的属性，方法，构造方法等；
3、当我们在使用IDE,比如Ecplise时，当我们输入一个对象或者类，并想调用他的属性和方法是，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射；
4、反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。
5、例如，在使用Strut2框架的开发过程中，我们一般会在struts.xml里去配置Action，比如
<action name="login" class="org.ScZyhSoft.test.action.SimpleLoginAction" method="execute">
<result>/shop/shop-index.jsp</result>
<result name="error">login.jsp</result>
</action>比如我们请求login.action时，那么StrutsPrepareAndExecuteFilter就会去解析struts.xml文件，从action中查找出name为login的Action，并根据class属性创建SimpleLoginAction实例，并用Invoke方法来调用execute方法，这个过程离不开反射。配置文件与Action建立了一种映射关系，当View层发出请求时，请求会被StrutsPrepareAndExecuteFilter拦截，然后StrutsPrepareAndExecuteFilter会去动态地创建Action实例。
比如，加载数据库驱动的，用到的也是反射。
Class.forName("com.mysql.jdbc.Driver"); // 动态加载mysql驱动JAVA中基本数据类型的Class是什么？
import java.lang.annotation.ElementType;
//所有类型的Class
public class test2 {
public static void main(String[] args) {
Class c1 = Object.class; //类
Class c2 = Comparable.class; //接口
Class c3 = String[].class; //一维数组
Class c4 = int[][].class; //二维数组
Class c5 = Override.class; //注解
Class c6 = ElementType.class; //枚举
Class c7 = Integer .class; //基本数据类型
Class c8 = void.class; //void
Class c9 = Class.class; //Class
System. out. println(c1);
System. out. println(c2);
System. out. println(c3);
System. out. println(c4);
System. out. println(c5);
System. out. println(c6);
System. out. println(c7);
System. out. println(c8);
System. out. println(c9);
//只要元素类型与维度一样，就是同一个Class.
int[] a = new int[10] ;
int[] b = new int [100] ;
System.out.println(a. getClass().hashCode()) ;
System.out.println(b. getClass().hashCode()) ;
}
}运行结果：
反射机制常用的API
Java.lang.Class;
Java.lang.reflect.Constructor;
Java.lang.reflect.Field;
Java.lang.reflect.Method;
Java.lang.reflect.Modifier;
反射机制获取类的方法
java文件经过编译后生成一个或多个字节码文件(.class文件)，当我们对.class文件解释运行时。相当于将某个字节码文件加载到内存，此过程就称为类的加载。加载到内存中的类，就称为运行时类，此运行时类也就是Class的一个实例。
//通过反射获取类的方式
public class test1 {
public static void main(String[] args) throws ClassNotFoundException{
User user = new user1();
System.out.println("这个角色是："+user.getName());
//方式1：通过对象获得
Class class1 = user.getClass();
System.out.println(class1.hashCode());
//方式2：使用forName获取
Class class2 = Class.forName("testReflection.user1");
System.out.println(class2.hashCode());
//方式3:通过类名.class获得
Class class3 = user1.class;
System.out.println(class3.hashCode());
//方式4：基本内置类型的包装类都有一个type属性（该方法有局限性）
Class class4 = Integer.TYPE;
System.out.println(class4);
//获取class1的父类类型
Class class5 = class1.getSuperclass();
System.out.println(class5);
}
}
//实体类
class User {
private String name;
private int id;
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" + "name='" + name + '\'' + ", id=" + id + ", age=" + age + '}';
}
}
class user1 extends User {
public user1() {
this.setName("甲");
this.setId(001);
this.setAge(18);
}
}
class user2 extends User {
public user2() {
this.setName("乙");
this.setId(002);
this.setAge(28);
}
}运行结果：
Class对象提供了如下常用方法：
通过反射获取运行时类的完整结构
public class test08 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName ("testReflection.User") ;
//获得类的名字
System.out.println(c1.getName()); //获得包名 +类名.
System.out.println(c1 . getSimpleName()); //获得类名
System.out.println("==============================");
// 获得类的属性
Field[] fields = c1.getFields();//只能找到public修饰的属性
for (Field field : fields) {
System. out . println(field);
}
System.out.println("==============================");
fields = c1.getDeclaredFields();//获取全部的属性
for (Field field : fields) {
System. out . println(field);
}
System.out.println("==============================");
//获得指定属性的值
Field name = c1. getDeclaredField("name") ;
System.out.println(name) ;
System.out.println("============================");
//获得类的方法
Method[] methods = c1. getMethods(); // 获得本类及其父类的全部public方法
for (Method method : methods) {
System.out.println("正常的:" + method);
}
System.out.println("============================");
methods = c1. getDeclaredMethods(); // 获得本类的所有方法
for (Method method : methods) {
System.out.println("getDeclaredMethods : "+method) ;
}
System.out.println("============================");
//获得指定方法
// 为什么要添加参数？因为JAVA中的重载，如果方法名一样没有添加参数就会出错
Method getName = c1. getMethod("getName",null) ;
Method setName = c1. getMethod("setName",String.class);
System.out.println(getName);
System.out.println(setName) ;
System.out.println("============================");
//获得指定的构造器
Constructor[] constructors = c1. getConstructors();
for (Constructor constructor : constructors) {
System.out.println("public修饰："+constructor);
}
System.out.println("============================");
constructors = c1. getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println("全部：" + constructor);
}
System.out.println("============================");
//获得指定的构造器
Constructor declaredConstructor = c1. getDeclaredConstructor(String.class, int.class, int.class);
System.out.println("指定构造器:"+declaredConstructor);
}
}获取Class对象后能做什么?
创建类的对象
方式一：调用Class对象的newInstance()方法。
➢1) 类必须有一个无参数的构造器。
➢2) 类的构造器的访问权限需要足够。
public class test09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
//获得Class对象
Class c1 = Class.forName ("testReflection.User");
//构造一个对象
User user = (User)c1. newInstance(); // 本质是调用了类的无参构造器
System. out. println(user);
}
}运行结果：
试操作，如果我们把User类里面的无参构造器删除后，在运行代码，会报错~~
思考：难道没有无参的构造器就不能创建对象了吗?
不然，其实只要在操作的时候明确的调用User类中的构造器,并将参数传递进去之后，就可以实例化操作。
方式二:
- （1) 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器；
- （2) 向构造器的形参中传递一个对象数组进去， 里面包含了构造器中所需的各个参数；
- （3) 通过Constructor实例化对象。
public class test09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//获得Class对象
Class c1 = Class.forName ("testReflection.User");
//通过构造器创建对象
Constructor constructor = c1.getDeclaredConstructor(String. class, int.class, int.class);
User user2 = (User)constructor.newInstance("SKY",001,18);
System.out.println(user2);
}
}运行结果：
通过反射调用对象的方法
public class test09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//获得Class对象
Class c1 = Class.forName ("testReflection.User");
//通过反射调用普通方法
User user3 = (User)c1 . newInstance();
//通过反射获取一个方法
Method setName = c1. getDeclaredMethod( "setName", String.class) ;
//invoke :激活的意思,(对象，“方法的值")
setName.invoke (user3, "AAA") ;
System.out.println(user3. getName());
}
}运行结果：
调用指定的方法：Object invoke(Object obj, Object args[])
- Object 对应原方法的返回值，若原方法无返回值，此时返回null;
- 若原方法若为静态方法,此时形参Object obj可为null;
- 若原方法形参列表为空，则Object[] args为null;
- 若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
通过反射操作属性
public class test09 {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//获得Class对象
Class c1 = Class.forName ("testReflection.User");
//通过反射操作属性
User user4 = (User)c1.newInstance();
Field name = c1. getDeclaredField( "name") ;
//在User类中，name属性是private修饰，不能直接操作私有属性
//我们需要关闭程序的安全检测，将属性或者方法的setAccessible(true)，设置成公有性质.
name.setAccessible(true);
name.set(user4,"BBB") ;
System.out.println(user4.getName());
}
}运行结果：
setAccessible介绍：
- Method和Field、Constructor对象都有setAccessible()方法。setAccessible作用是启动和禁用访问安全检查的开关。
- 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。参数值为false则指示反射的对象应该实施Java语言访问检查
- 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问
反射操作泛型
Java采用泛型擦除的机制来引入泛型, Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除。
为了通过反射操作这些类型, Java新增了ParameterizedType , GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。
- ParameterizedType :表示一种参数化类型,比如Collection< String>；
- GenericArrayType :表示一种元素类型是参数化类型或者类型变量的数组类型；
- TypeVariable : 是各种类型变量的公共父接口；
- WildcardType :代表一种通配符类型表达式。
//通过反射获取泛型
public class test11 {
public void test01 (Map<String,User> map, List<User> list){
System. out. println("test01");
}
public Map<String,User> test02(){
System. out . println("test02");
return null;
}
public static void main(String[] args) throws NoSuchMethodException {
//首先，获取方法，通过该方法获取泛型的参数化类型
Method method = test11.class.getMethod("test01", Map.class, List.class) ;
Type[] genericParameterTypes = method.getGenericParameterTypes() ;
for (Type genericParameterType : genericParameterTypes){
System.out.println("test01泛型参数类型："+ genericParameterType);
//判断是不是一个参数化类型，是，就进行强转成参数化类型
if (genericParameterType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments){
System.out.println("test01泛型参数信息："+actualTypeArgument);
}
}
}
method = test11.class.getMethod("test02", null);
Type genericParameterType = method.getGenericReturnType();
if (genericParameterType instanceof ParameterizedType){
Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments){
System.out.println("test02泛型参数信息："+actualTypeArgument);
}
}
}
}运行结果：
反射操作注解
//反射操作注解
public class test12 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("testReflection.Student2");
//通过反射获取注解
Annotation[] annotations = c1.getAnnotations();
for (Annotation annotation : annotations){
System.out.println(annotation);
}
System.out.println("===========================================");
//获得注解的value值
TableSky tableSky = (TableSky)c1.getAnnotation(TableSky.class);
String value = tableSky.value();
System.out.println(value);
System.out.println("===========================================");
//获得类指定的注解
Field field = c1.getDeclaredField("id");
FieldSky annotation =field.getAnnotation(FieldSky.class);
System.out.println(annotation.columnName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableSky("db_SKY")
class Student2{
@FieldSky(columnName = "db_id",type="int",length=10)
private int id;
@FieldSky(columnName = "db_age",type="int",length=10)
private int age;
@FieldSky(columnName = "db_name",type="varchar",length=5)
private String name;
public Student2() {
}
public Student2(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student2{" + "id=" + id + ", age=" + age + ", name='" + name + '\'' + '}';
}
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableSky{
String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldSky{
String columnName();
String type();
int length();
}运行结果：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
