一、概述
反射,就是通过class文件对象,去使用该文件中的成员变量,构造方法,成员方法。
要想这样使用,首先你必须得到class文件对象,其实也就是得到Class类的对象。
Class类:
成员变量 Field
构造方法 Constructor
成员方法 Method
获取class文件对象的方式:
1)Object类的getClass()方法
2)数据类型的静态属性class
3)Class类中的静态方法
public static Class forName(String className)
开发时一般使用Class类中的静态方法获取class文件,因为可以通过把字符串配置到配置文件中灵活的创建不同的类。
二、详解
1.通过反射获取构造方法并使用
获取构造方法的对象
public Constructor[] getConstructors():所有公共构造方法
public Constructor[] getDeclaredConstructors():所有构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes):获取单个构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes):获取单个构造方法(含私有)
参数表示的是:要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
获取构造方法对象后,通过方法:T newInstance(Object... initargs) 创建对象。
注意:
在访问私有构造方法时不能直接访问,要设置一下访问权限
方法:void setAccessible(boolean flag) true表示可以直接访问
简单案例
public class ReflectDemo3 { public static void main(String[] args) throws Exception { // 获取字节码文件对象 Class c = Class.forName("cn.itcast_01.Person"); // 获取私有构造方法对象 // NoSuchMethodException:每个这个方法异常 // 原因是一开始我们使用的方法只能获取公共的,下面这种方式就可以了。 Constructor con = c.getDeclaredConstructor(String.class); // 用该私有构造方法创建对象 // IllegalAccessException:非法的访问异常。 // 暴力访问 con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。 Object obj = con.newInstance("abc"); System.out.println(obj); } }
2.通过反射获取成员变量并使用
获取成员变量的对象
Field[] fields = c.getFields();获取所有的公共成员变量
Field[] fields = c.getDeclaredFields();获取所有的成员变量
Field field = c.getDeclaredField(String name);获取单个成员变量(可以为私有)
获取成员变量对象后, 通过方法: void set(Object obj, Object value) 直接对 对象里的成员变量的值进行修改。
注意:在访问私有构造方法时不能直接访问,要设置一下访问权限方法:void setAccessible(boolean flag) true表示可以直接访问
简单案例import java.lang.reflect.Constructor; import java.lang.reflect.Field; /* * 通过反射获取成员变量并使用 */ public class ReflectDemo { public static void main(String[] args) throws Exception { // 获取字节码文件对象 Class c = Class.forName("cn.itcast_01.Person"); // 获取所有的成员变量 // Field[] fields = c.getFields(); // Field[] fields = c.getDeclaredFields(); // for (Field field : fields) { // System.out.println(field); // } /* * Person p = new Person(); p.address = "北京"; System.out.println(p); */ // 通过无参构造方法创建对象 Constructor con = c.getConstructor(); Object obj = con.newInstance(); System.out.println(obj); // 获取单个的成员变量 // 获取address并对其赋值 Field addressField = c.getField("address"); // public void set(Object obj,Object value) // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京" System.out.println(obj); // 获取name并对其赋值 // NoSuchFieldException Field nameField = c.getDeclaredField("name"); // IllegalAccessException nameField.setAccessible(true); nameField.set(obj, "林青霞"); System.out.println(obj); // 获取age并对其赋值 Field ageField = c.getDeclaredField("age"); ageField.setAccessible(true); ageField.set(obj, 27); System.out.println(obj); } }
3.通过反射获取成员方法并使用
获取成员方法的对象
Method[] methods = c.getMethods(); 获取自己的包括父亲的公共方法Method[] methods = c.getDeclaredMethods(); 获取自己的所有的方法
public Method getMethod(String name,Class<?>... parameterTypes); 获取 单个 方法public Method getDeclaredMethod(String name,Class<?>... parameterTypes);获取单个方法(可以为私有)
获取成员方法对象后,调用方法:public Object invoke(Object obj,Object... args)
返回值是Object接收,第一个参数表示对象是谁,第二参数表示调用该方法的实际参数
实现方法的执行
注意:在访问私有构造方法时不能直接访问,要设置一下访问权限方法:void setAccessible(boolean flag) true表示可以直接访问
简单案例
import java.lang.reflect.Constructor; import java.lang.reflect.Method; public class ReflectDemo { public static void main(String[] args) throws Exception { // 获取字节码文件对象 Class c = Class.forName("cn.itcast_01.Person"); // 获取所有的方法 // Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法 // Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法 // for (Method method : methods) { // System.out.println(method); // } Constructor con = c.getConstructor(); Object obj = con.newInstance(); /* * Person p = new Person(); p.show(); */ // 获取单个方法并使用 // public void show() // public Method getMethod(String name,Class<?>... parameterTypes) // 第一个参数表示的方法名,第二个参数表示的是方法的参数的class类型 Method m1 = c.getMethod("show"); // obj.m1(); // 错误 // public Object invoke(Object obj,Object... args) // m1.invoke(obj); // 调用obj对象的m1方法 System.out.println("----------"); // public void method(String s) Method m2 = c.getMethod("method", String.class); m2.invoke(obj, "hello"); System.out.println("----------"); // public String getString(String s, int i) Method m3 = c.getMethod("getString", String.class, int.class); Object objString = m3.invoke(obj, "hello", 100); System.out.println(objString); // String s = (String)m3.invoke(obj, "hello",100); // System.out.println(s); System.out.println("----------"); // private void function() Method m4 = c.getDeclaredMethod("function"); m4.setAccessible(true); m4.invoke(obj); } }
4.动态代理
1)代理概述
代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。
动态代理:在程序运行时,运用反射机制动态创建而成。
2)动态代理的实现:Proxy与InvocationHandler
A:新建Proxy对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
B:新建对象需要获取ClassLoader,interfaces,InvocationHandler
通过class.getClassLoader()获得ClassLoader
通过class.getInterfaces()获得getInterfaces
InvocationHandler需要自己建立:
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class MyInvocationHandler implements InvocationHandler { private Object target; // 目标对象 public MyInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("权限校验"); Object result = method.invoke(target, args); System.out.println("日志记录"); return result; // 返回的是代理对象 } }
C:对象新建完成后运行被代理的方法即可
3)案例
public class StudentDaoImpl implements StudentDao { @Override public void login() { System.out.println("登录功能"); } @Override public void regist() { System.out.println("注册功能"); } }
public class UserDaoImpl implements UserDao { @Override public void add() { System.out.println("添加功能"); } @Override public void delete() { System.out.println("删除功能"); } @Override public void update() { System.out.println("修改功能"); } @Override public void find() { System.out.println("查找功能"); } }
import java.lang.reflect.Proxy; public class Test { public static void main(String[] args) { UserDao ud = new UserDaoImpl(); ud.add(); ud.delete(); ud.update(); ud.find(); System.out.println("-----------"); // 我们要创建一个动态代理对象 // Proxy类中有一个方法可以创建动态代理对象 // public static Object newProxyInstance(ClassLoader loader,Class<?>[] // interfaces,InvocationHandler h) // 我准备对ud对象做一个代理对象 MyInvocationHandler handler = new MyInvocationHandler(ud); UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass() .getClassLoader(), ud.getClass().getInterfaces(), handler); proxy.add(); proxy.delete(); proxy.update(); proxy.find(); System.out.println("-----------"); StudentDao sd = new StudentDaoImpl(); MyInvocationHandler handler2 = new MyInvocationHandler(sd); StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass() .getClassLoader(), sd.getClass().getInterfaces(), handler2); proxy2.login(); proxy2.regist(); } }
5.案例
给定ArrayList<Integer>的一个对象,在这个集合中添加一个字符串数据
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.ArrayList; /* * 给定ArrayList<Integer>的一个对象,在这个集合中添加一个字符串数据 */ public class ArrayListDemo { public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // 创建集合对象 ArrayList<Integer> array = new ArrayList<Integer>(); // array.add("hello"); // array.add(10); Class c = array.getClass(); // 集合ArrayList的class文件对象 Method m = c.getMethod("add", Object.class); m.invoke(array, "hello"); // 调用array的add方法,传入的值是hello m.invoke(array, "world"); m.invoke(array, "java"); System.out.println(array); } }