JAVA反射

获取class对象引用的三种方式

• Object类中的getClass()方法，object.getClass();

• 通过对象静态属性 .class来获取对应的Class对象（类字面常量）

• Class.forName(“”)

import cn.easycode.mycode.po.Student;
public class Solution {
	public static void main(String[] args) {
		Student stu = new Student();
		Class<?> stuClass1 = stu.getClass();
		Class<?> stuClass2 = Student.class;
		try {
			Class<?> stuClass3 = Class.forName("cn.easycode.mycode.po.Student");
			System.out.println(stuClass1.getName());
			System.out.println(stuClass2.getName());
			System.out.println(stuClass3.getName());
		} catch (ClassNotFoundException e) {
			System.out.println("ClassNotFoundException");
		}
	}
}

创建对象的五种方式

使用new关键字

Student student = new Student();

使用Class类的newInstance方法

Class<?> studentClass = Class.forName("cn.easycode.mycode.po.Student");
Student student = (Student) studentClass.newInstance();

使用Constructor类的newInstance方法

Class<?> studentClass = Class.forName("cn.easycode.mycode.po.Student");
Student student = (Student) studentClass.getConstructor(String.class,int.class).newInstance("张三",20);

使用clone方法

@Data
public class Student implements Serializable,Cloneable{
	private static final long serialVersionUID = -1377794110170113031L;
	
	private int age;
	private String name;
	private String grade;
	private String school;
	private String schoolClass;
	
	public Student() {}
	
	public Student(String name,int age) {
		this.age = age;
		this.name = name;
	}

	@Override
	public Student clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return (Student)super.clone();
	}
}

public class Solution {
	public static void main(String[] args) {
		try {
			Class<?> studentClass = Class.forName("cn.easycode.mycode.po.Student");
			Student student = (Student) studentClass.getConstructor(String.class, int.class).newInstance("张三", 20);
			Student clone = student.clone();
			System.out.println(clone);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

Student(age=20, name=张三, grade=null, school=null, schoolClass=null)

#####　使用反序列化

	@Test
	public void run() {
		try {
			serializeObject();
			Student student = (Student)deserializeObject();
			System.out.println("反序列化对象:" + student.toString());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
	}
//具体可参考本文对象的序列化和反序列化章节

Class类的方法

java.lang.reflect类

java.lang.reflect.AccessibleObject

简介

java.lang.reflect.AccessibleObject 类是Field，Method和Constructor对象的基类.它提供了将反射对象标记为在使用时禁止默认Java语言访问控制检查的功能.当使用Fields，Methods或Constructors设置或获取字段，调用方法或创建和初始化类的新实例时，将执行对公共，默认(包)访问，受保护和私有成员的访问检查.在反射对象中设置可访问标志允许具有足够权限的复杂应用程序(例如Java对象序列化或其他持久性机制)以通常被禁止的方式操作对象.

类方法

java.lang.reflect.Field

简介

java.lang.reflect.Field 类提供有关类或接口的单个字段的信息和动态访问.反射字段可以是类(静态)字段或实例字段.字段允许在获取或设置访问操作期间进行扩展转换，但如果发生缩小转换，则抛出IllegalArgumentException.

类方法

java.lang.reflect.Method

简介

java.lang.reflect.Method 类提供有关类或接口上单个方法的信息和访问权限.反射的方法可以是类方法或实例方法(包括抽象方法).方法允许在将实际参数与基础方法的形式参数进行匹配时进行扩展转换，但如果发生缩小转换，则会抛出IllegalArgumentException.

类方法

java.lang.reflect.Constructor

简介

java.lang.reflect.Constructor 类提供有关类的单个构造函数的信息和访问权限.构造函数允许在将实际参数与newInstance()与底层构造函数的形式参数匹配时进行扩展转换，但如果发生缩小转换，则抛出IllegalArgumentException.

类方法

java.lang.reflect.Array

简介

java.lang.reflect.Array 类提供动态创建和访问Java数组的静态方法.数组允许在get或set操作期间进行扩展转换，但如果发生收缩转换，则抛出IllegalArgumentException.

类方法

java.lang.reflect.Modifier

简介

java.lang.reflect.Modifier 类提供静态方法和常量来解码类和成员访问修饰符.修饰符集表示为具有表示不同修饰符的不同位位置的整数.表示修饰符的常量值取自Java虚拟机规范的4.1,4.4,4.5和4.7节中的表.

Fields

• static int FINAL : 表示最终修饰符的int值.
• static int INTERFACE : 表示接口修饰符的int值.
• static int NATIVE : 表示本机修饰符的int值.
• static int PRIVATE : 表示私有修饰符的int值.
• static int PROTECTED : 表示受保护修饰符的int值.
• static int PUBLIC : 表示公共修饰符的int值.
• static int STATIC : 表示静态修饰符的int值.
• static int STRICT : 表示strictfp修饰符的int值.
• static int SYNCHRONIZED : 表示同步修饰符的int值.
• static int TRANSIENT : 表示瞬态修饰符的int值.
• static int VOLATILE : 表示volatile修饰符的int值.

类方法

java.lang.reflect.Proxy

简介

java.lang.reflect.Proxy 类提供了用于创建动态代理类和实例的静态方法，它也是所有类的超类由这些方法创建的动态代理类.

类方法

java.lang.reflect接口

简介

java.lang.reflect接口包含用于获取有关类和对象的反射信息的接口.

接口摘要

java.lang.reflect异常

简介

java.lang.reflect Exceptions 包含在反射操作期间可能发生的异常.

异常摘要

java.lang.reflect错误

简介

java.lang.reflect错误包含反射操作期间可能发生的错误.

错误摘要

动态代理

被代理类和接口

//接口
public interface ProxyInterface {
	int add();
	void show();
}
//实现
public class ProxyInterfaceImpl implements ProxyInterface {
    private static int count = 1;
    
	public int add() {
		// TODO Auto-generated method stub
		System.out.println("add ProxyInterfaceImpl");
		return count++;
	}
	
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("show ProxyInterfaceImpl");
	}
}

JDK动态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {
	private Object target;

	public Object bind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(this.target.getClass().getClassLoader(), this.target.getClass().getInterfaces(),this);
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("doSomething before");
		Object result  = method.invoke(target, args);
		System.out.println("doSomething after");
		return result;
	}
}

cglib动态代理

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.Enhancer;
import java.lang.reflect.Method;


public class ProxyMethodInterceptor implements MethodInterceptor {
	// 业务类对象，供代理方法中进行真正的业务方法调用
	private Object target;

	// 相当于JDK动态代理中的绑定
	public Object bind(Object target) {
		// 给业务对象赋值
		this.target = target;
		// 创建加强器，用来创建动态代理类
		Enhancer enhancer = new Enhancer();
		// 为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
		enhancer.setSuperclass(this.target.getClass());
		// 设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
		enhancer.setCallback(this);
		// 创建动态代理类对象并返回
		return enhancer.create();
	}

	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("预处理——————");
		// 调用业务类（父类中）的方法
		Object result = proxy.invokeSuper(obj, args);
		System.out.println("调用后操作——————");
		return result;
	}
}

调用和结果

import cn.easycode.mycode.interfaces.ProxyInterface;
import cn.easycode.mycode.po.ProxyInterfaceImpl;
import cn.easycode.mycode.po.ProxyInvocationHandler;
import cn.easycode.mycode.po.ProxyMethodInterceptor;

public class Solution {
	public static void main(String[] args) {
		ProxyInterfaceImpl target = new ProxyInterfaceImpl();
		System.out.println("JDK动态代理 --开始");
		ProxyInvocationHandler handler = new ProxyInvocationHandler();
		ProxyInterface jdkProxy = (ProxyInterface)handler.bind(target);
		int result1 = jdkProxy.add();
		System.out.println("jdkProxy add方法调用结果:" + result1);
		System.out.println("JDK动态代理 --结束");
		
		System.out.println("-----------------------------------");
		
		System.out.println("CGLIB动态代理--开始");
		ProxyMethodInterceptor interceptor = new ProxyMethodInterceptor();
		ProxyInterface cglibProxy = (ProxyInterface)interceptor.bind(target);
		int result2 = cglibProxy.add();
		System.out.println("cglibProxy add方法调用结果:" +result2);
		System.out.println("CGLIB动态代理--结束");
	}
}


JDK动态代理 --开始
doSomething before
add ProxyInterfaceImpl
doSomething after
jdkProxy add方法调用结果:1
JDK动态代理 --结束
-----------------------------------
CGLIB动态代理--开始
预处理——————
add ProxyInterfaceImpl
调用后操作——————
cglibProxy add方法调用结果:2
CGLIB动态代理--结束

对象序列化和反序列化

//序列化对象
@Data
public class Student implements Serializable{
	private static final long serialVersionUID = -1377794110170113031L;
	
	private int age;
	private String name;
	private String grade;
	private String school;
	private String schoolClass;
}

//序列化和反序列化
public class SerializableSolution {
	private static final String objectFile = "D:\Object\student.txt";
	//序列化对象
	public void serializeObject() throws FileNotFoundException, IOException {
		Student student = new Student();
		student.setName("张三");
		student.setSchool("清华大学");
		student.setAge(20);
		File file = new File(objectFile);
		if (!FileUtil.exist(file)) {
			// 创建文件目录
			FileUtil.mkParentDirs(file);
			// 创建文件
			file.createNewFile();
		}
		ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
		out.writeObject(student);
		out.close();
	}
	//反序列化对象
	public Object deserializeObject() throws FileNotFoundException, IOException, ClassNotFoundException {
		File file = new File(objectFile);
		if (!FileUtil.exist(file)) {
			System.out.println("文件不存在");
			return null;
		}
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
		Object obj = in.readObject();
		in.close();
		return obj;
	}
	
	@Test
	public void run() {
		try {
			serializeObject();
			Student student = (Student)deserializeObject();
			System.out.println("反序列化对象:" + student.toString());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
	}
}

反序列化对象:Student(age=20, name=张三, grade=null, school=清华大学, schoolClass=null)

最后

以上就是生动冷风为你收集整理的深入浅出系列之JAVA反射（java.lang.reflect及Class类详解）JAVA反射的全部内容，希望文章能够帮你解决深入浅出系列之JAVA反射（java.lang.reflect及Class类详解）JAVA反射所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。