反射机制"/>
Java高级编程——Java反射机制
Java高级编程——Java反射机制
目录
Java高级编程——Java反射机制
一、Java反射机制概述
1.Java Reflection
2.补充：动态语言 vs 静态语言
3.Java反射机制研究及应用
4.反射相关的主要API
二、理解Class类并获取Class实例
1.Class 类
2. Class类的常用方法
3.反射的应用举例
4.获取Class类的实例 (四种方法)
5.哪些类型可以有Class对象？
上代码
三、类的加载与ClassLoader的理解
1.了解：类的加载过程
2.了解：什么时候会发生类初始化？
3.了解：ClassLoader
上代码
四、创建运行时类的对象
1.有了Class对象，能做什么？
上代码
五、获取运行时类的完整结构
1.通过反射获取运行时类的完整结构
2.小 结
上代码
六、调用运行时类的指定结构
1.调用指定方法
2.调用指定属性
3.关于setAccessible方法的使用
上代码
七、反射的应用：动态代理
1.代理设计模式的原理
2.Java动态代理相关API
3.动态代理步骤
4.动态代理与AOP（Aspect Orient Programming)
代码演示
静态代理
动态代理
一、Java反射机制概述
1.Java Reflection
2.补充：动态语言 vs 静态语言
框架 =反射 + 注解 + 设计模式
3.Java反射机制研究及应用
4.反射相关的主要API
二、理解Class类并获取Class实例
1.Class 类
2. Class类的常用方法
3.反射的应用举例
4.获取Class类的实例 (四种方法)
5.哪些类型可以有Class对象？
上代码
package com.tyl.java;import org.junit.Test;import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java* @Project：workidea* @Filename: ReflectionTest* @create 2023-06-19 21:08***/
public class ReflectionTest {// 反射之前，对于Person的操作@Testpublic void test1(){// 1.创建Person类的对象Person p1 = new Person("tyl", 20);// 2.通过对象，调用其内部的属性、方法p1.age = 10;System.out.println(p1.toString());p1.show();// 在Person类外部，不可以通过Person类的对象调用其内部私有结构。// 比如：name、showNation() 以及私有的构造器}// 反射之后，对于Person的操作@Testpublic void test2() throws Exception {Class clazz = Person.class;// 1.通过反射，创建Person类的对象Constructor cons = clazz.getConstructor(String.class, int.class);Object obj = cons.newInstance("tyl", 22);Person p = (Person) obj;System.out.println(p.toString());// 2.通过反射，调用对象指定的属性、方法// 调用属性Field age = clazz.getDeclaredField("age");age.set(p,10);System.out.println(p.toString());// 调用方法Method show = clazz.getDeclaredMethod("show");show.invoke(p);System.out.println("************************************************");// 通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性// 调用私有的构造器Constructor cons1 = clazz.getDeclaredConstructor(String.class);cons1.setAccessible(true);Object p1 = cons1.newInstance("wc");Person p2 = (Person) p1;System.out.println(p2);// 调用私有的属性Field name = clazz.getDeclaredField("name");name.setAccessible(true);name.set(p2,"xxxx");System.out.println(p2);// 调用私有的方法Method showNation = clazz.getDeclaredMethod("showNation", String.class);showNation.setAccessible(true);String nation = (String) showNation.invoke(p2, "china");System.out.println(nation);}// 疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？// 建议：直接new的方式。// 什么时候会使用：反射的方式。反射的特征：动态性// 疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？// 不矛盾/*关于java.Lang.CLass类的理解1.类的加载过程：程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。2.换句话说，CLass的实例就对应着一个运行时类。3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。*///获取Class的实例的方式 （前三种方式需要掌握）@Testpublic void test3() throws ClassNotFoundException {// 方式一：调用运行时类的属性：.cLassClass<Person> clazz1 = Person.class;System.out.println(clazz1);// 方式二：通过运行时类的对象，调用getCLass（）Person p1 = new Person();Class clazz2 = p1.getClass();System.out.println(clazz2);// 方式三：调用CLass的静态方法：forName(String cLassPath). 常用Class clazz3 = Class.forName("com.tyl.java.Person");
// Class clazz3 = Class.forName("java.lang.String");System.out.println(clazz3);System.out.println(clazz1 == clazz2); // trueSystem.out.println(clazz1 == clazz3); // true// 方式四：使用类的加载器：CLassLoaderClassLoader classLoader = ReflectionTest.class.getClassLoader();Class clazz4 = classLoader.loadClass("com.tyl.java.Person");System.out.println(clazz4);System.out.println(clazz1 == clazz4); // true}// 万事万物皆对象？对象, XXX, FiLe, URL, 反射，前端、数据库操作// CLass实例可以是哪些结构的说明：@Testpublic void test4(){Class c1 = Object.class;Class c2 = Comparable.class;Class c3 = String[].class;Class c4 = int[][].class;Class c5 = ElementType.class;Class c6 = Override.class;Class c7 = int.class;Class c8 = void.class;Class c9 = Class.class;int[] a = new int[10];int[] b = new int[100];Class c10 = a.getClass();Class c11 = b.getClass();// 只要数组的元素类型与维度一样，就是同一个ClassSystem.out.println(c10 == c11);}}
三、类的加载与ClassLoader的理解
1.了解：类的加载过程
2.了解：什么时候会发生类初始化？
3.了解：ClassLoader
上代码
package com.tyl.java;import org.junit.Test;import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java* @Project：workidea* @Filename: ClassLoaderTest* @create 2023-06-20 18:10** 了解类的加载器*/
public class ClassLoaderTest {@Testpublic void test1(){// 对于自定义类，使用系统类加载器进行加载ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();System.out.println(classLoader);// 调用系统类加载器的getParent（）:获取扩展类加载器ClassLoader classLoader1 = classLoader.getParent();System.out.println(classLoader1);// 调用扩展类加载器的getParent（）：无法获取引导类加载器// 引导类加载器主要负责加载java的核心类库，无法加载自定义类的。ClassLoader classLoader2 = classLoader1.getParent();System.out.println(classLoader2);ClassLoader classLoader3 = String.class.getClassLoader();System.out.println(classLoader3);}/*Properties: 用来读取配置文件。*/@Testpublic void test2() throws IOException {Properties pros = new Properties();// 此时的文件默认在当前的nodule下// 读取配置文件的方式一
// FileInputStream fis = new FileInputStream("jdbc1.properties");FileInputStream fis = new FileInputStream("src\\jdbc1.properties");pros.load(fis);// 读取配置文件的方式二：使用CLassLoader// 配置文件默认识别为：当前nodule的src下
// ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
// InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
// pros.load(is);String user = pros.getProperty("user");String password = pros.getProperty("password");System.out.println("user =" + user + ", password = " + password);}}
四、创建运行时类的对象
1.有了Class对象，能做什么？
上代码
package com.tyl.java;import org.junit.Test;import java.util.Random;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java* @Project：workidea* @Filename: NewInstanceTest* @create 2023-06-20 18:33** 通过反射创建对应的运行时类的对象*/
public class NewInstanceTest {@Testpublic void test1() throws InstantiationException, IllegalAccessException {Class<Person> clazz = Person.class;/*newInstance（）:调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。要想此方法正常的创建运行时类的对象，要求：1.运行时类必须提供空参的构造器2.空参的构造器的访问权限得够。通常，设置为public在javabean中要求提供一个public的空参构造器。原因：1.便于通过反射，创建运行时类的对象2.便于子类继承此运行时类时，默认调用super（）时，保证父类有此构造器*/Person obj = clazz.newInstance();System.out.println(obj);}// 体会反射的动态性@Testpublic void test2(){for (int i = 0; i < 100; i++) {int num = new Random().nextInt(3);String classPath = "";switch (num){case 0:classPath = "java.util.Date";break;case 1:classPath = "java.lang.Object";break;case 2:classPath = "com.tyl.java.Person";break;}Object obj = null;try {obj = getInstance(classPath);System.out.println(obj);} catch (InstantiationException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}}/*创建一个指定类的对象。cLassPath:指定类的全类名*/public Object getInstance(String classPath) throws InstantiationException, IllegalAccessException, ClassNotFoundException {Class clazz = Class.forName(classPath);return clazz.newInstance();}}
五、获取运行时类的完整结构
1.通过反射获取运行时类的完整结构
2.小 结
1.在实际的操作中，取得类的信息的操作代码，并不会经常开发。
2.一定要熟悉java.lang.reflect包的作用，反射机制。
3.如何取得属性、方法、构造器的名称，修饰符等。
上代码
package com.tyl.java2;import com.tyl.java1.Person;
import org.junit.Test;import java.lang.reflect.Field;
import java.lang.reflect.Modifier;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java2* @Project：workidea* @Filename: FiledTest* @create 2023-06-20 19:47*/
public class FiledTest {@Testpublic void test1(){Class<Person> clazz = Person.class;//获取属性结构//getFields（）:获取当前运行时类及其父类中声明为public访问权限的属性Field[] fields = clazz.getFields();for(Field f : fields){System.out.println(f);}System.out.println();//getDecLaredFields（）:获取当前运行时类中声明的所有属性。（不包含父类中声明的属性)Field[] declaredFields = clazz.getDeclaredFields();for(Field f : declaredFields){System.out.println(f);}}// 权限修饰符 数据类型 变量名@Testpublic void test2(){Class<Person> clazz = Person.class;Field[] declaredFields = clazz.getDeclaredFields();for(Field f : declaredFields){// 1.权限修饰弑int modifiers = f.getModifiers();System.out.print(Modifier.toString(modifiers) + "\t");// 2.数据类型Class<?> type = f.getType();System.out.print(type.getName() + "\t");// 3.变量名String name = f.getName();System.out.print(name);System.out.println();}}
}
package com.tyl.java2;import com.tyl.java1.Person;
import org.junit.Test;import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java2* @Project：workidea* @Filename: MethodTest* @create 2023-06-20 20:32** 获取运行时类的方法结构*/
public class MethodTest {@Testpublic void test1(){Class<Person> clazz = Person.class;// getMethods（）:获取当前运行时类及其所有父类中声明为public权限的方法Method[] methods = clazz.getMethods();for(Method m : methods){System.out.println(m);}System.out.println("*********************************");// getDecLaredMethods（）:获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）Method[] declaredMethods = clazz.getDeclaredMethods();for(Method m : declaredMethods){System.out.println(m);}}/*@XXXx权限修饰符 返回值类型 方法名(参数类型虹形参名1，···) throws XxxException{}*/@Testpublic void test2(){Class<Person> clazz = Person.class;Method[] declaredMethods = clazz.getDeclaredMethods();for(Method m : declaredMethods){// 1.获取方法声明的注解Annotation[] annotations = m.getAnnotations();for(Annotation a : annotations){System.out.println(a);}// 2.权限修饰符System.out.print(Modifier.toString(m.getModifiers()) + "\t");// 3.返回值类型System.out.print(m.getReturnType().getName() + "\t");// 4.方法名String name = m.getName();System.out.print(name);System.out.print("(");// 5.形参列表Class[] parameterTypes = m.getParameterTypes();if(!(parameterTypes == null && parameterTypes.length == 0)){for (int i = 0; i < parameterTypes.length; i++) {if(i == parameterTypes.length - 1 ){System.out.print(parameterTypes[i].getName() + " args_ " + i);break;}System.out.print(parameterTypes[i].getName() + " args_ " + i + ",");}}System.out.print(")");// 6.抛出异常Class[] exceptionTypes = m.getExceptionTypes();if(exceptionTypes.length > 0){for (int i = 0; i < exceptionTypes.length; i++) {if(!(exceptionTypes == null && exceptionTypes.length == 0)){System.out.print("throws: ");System.out.print(exceptionTypes[i].getName());break;}System.out.print(exceptionTypes[i].getName() + ",");}}System.out.println();}}}
package com.tyl.java2;import com.tyl.java1.Person;
import org.junit.Test;import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java2* @Project：workidea* @Filename: OtherTest* @create 2023-06-20 21:26*/
public class OtherTest {/*获取构造器结构*/@Testpublic void test1(){Class<Person> clazz = Person.class;// getConstructors（）:获取当前运行时类中声明为public的构造器Constructor[] constructors = clazz.getConstructors();for(Constructor c : constructors){System.out.println(c);}System.out.println();// getDecLaredConstructors（）:获取当前运行时类中声明的所有的构造器Constructor[] declaredConstructors = clazz.getDeclaredConstructors();for(Constructor c : declaredConstructors){System.out.println(c);}}/*茯取运行时类的父类*/@Testpublic void test2(){Class<Person> clazz = Person.class;Class superclass = clazz.getSuperclass();System.out.println(superclass);}/*茯取运行时类带泛型的父类*/@Testpublic void test3(){Class<Person> clazz = Person.class;Type genericSuperclass = clazz.getGenericSuperclass();System.out.println(genericSuperclass);}/*茯取运行时类带泛型的父类的泛型代码： 逻辑性代码 vs 功能性代码*/@Testpublic void test4(){Class<Person> clazz = Person.class;Type genericSuperclass = clazz.getGenericSuperclass();ParameterizedType paramType = (ParameterizedType) genericSuperclass;// 获取泛型类型Type[] actualTypeArguments = paramType.getActualTypeArguments();
// System.out.println(actualTypeArguments[0].getTypeName());System.out.println(((Class)actualTypeArguments[0]).getName());}/*获取运行时类实现的接口*/@Testpublic void test5(){Class<Person> clazz = Person.class;Class[] interfaces = clazz.getInterfaces();for(Class c : interfaces){System.out.println(c);}System.out.println("************************");// 获取运行时类的父类实现的接口Class[] interfaces1 = clazz.getSuperclass().getInterfaces();for(Class c : interfaces1){System.out.println(c);}}/*获取运行时类所在的包*/@Testpublic void test6(){Class<Person> clazz = Person.class;Package aPackage = clazz.getPackage();System.out.println(aPackage);}/*获取运行时类声明的注解*/@Testpublic void test7(){Class<Person> clazz = Person.class;Annotation[] annotations = clazz.getAnnotations();for(Annotation a : annotations){System.out.println(a);}}}六、调用运行时类的指定结构
1.调用指定方法
2.调用指定属性
3.关于setAccessible方法的使用
上代码
package com.tyl.java2;import com.tyl.java1.Person;
import org.junit.Test;import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java2* @Project：workidea* @Filename: ReflectionTest* @create 2023-06-25 16:00** 调用运行时类中指定的结构：属性、方法、构造器*/
public class ReflectionTest {/*不需要掌握*/@Testpublic void test1() throws Exception {Class clazz = Person.class;//创建运行时类的对象Person p = (Person) clazz.newInstance();//获取指定的属性 要求运行时类中属性明为public// 通常不用Field id = clazz.getField("id");/*设置当前属性的值set（）:参数1：指明设置哪个对象的属性 参数2：将此属性值设置为多少*/id.set(p,1001);/*获取当前属性的值get（）:参数1：获取哪个对象的当前属性值*/int pid = (int) id.get(p);System.out.println(pid);}/*如何操作运行时类中的指定的属性·需要掌握*/@Testpublic void test2() throws Exception {Class clazz = Person.class;// 创建运行时类的对象Person p = (Person) clazz.newInstance();// 1.getDecLaredField(string fieldName):获取运行时类中指定变量名的属性Field name = clazz.getDeclaredField("name");// 2.保证当前属性是可访问的name.setAccessible(true);// 3.获取、设置指定对象的此属性值name.set(p,"tyl");System.out.println(name.get(p));}/*如何操作运行时类中的指定的方法~~需要掌握*/@Testpublic void test3() throws Exception {Class clazz = Person.class;// 创建运行时类的对象Person p = (Person) clazz.newInstance();/*1.获取指定的某个方法getDecLaredMethod（）:参数1：指明获取的方法的名称 参数2：指明获取的方法的形参列表*/Method show = clazz.getDeclaredMethod("show", String.class);// 2. 保证当前属性是可访问的show.setAccessible(true);/*3.调用方法的invoke（）:参数1：方法的调用者 参数2：给方法形参赋值的实参invoke（）的返回值即为对应类中调用的方法的返回值。*/Object returnValue = show.invoke(p, "China");System.out.println(returnValue);System.out.println("****************如何调用静态方法*******************");// private static void showDescMethod showDesc = clazz.getDeclaredMethod("showDesc");showDesc.setAccessible(true);//如果调用的运行时类中的方法没有返回值，则此invoke（）返回nuLL
// Object returnVal = showDesc.invoke(Person.class);Object returnVal = showDesc.invoke(null);System.out.println(returnVal); // null}/*如何调用运行时类中的指定的构造器*/@Testpublic void test4() throws Exception {Class clazz = Person.class;// private Person(String name)/*1.获取指定的构造器getDecLaredConstructor（）:参数：指明构造器的参数列表*/Constructor constructor = clazz.getDeclaredConstructor(String.class);// 2. 保证当前属性是可访问的constructor.setAccessible(true);// 3. 调用此构造器创建运行时类的对象Person per = (Person) constructor.newInstance("tyl");System.out.println(per);}}
七、反射的应用：动态代理
1.代理设计模式的原理
2.Java动态代理相关API
3.动态代理步骤
4.动态代理与AOP（Aspect Orient Programming)
代码演示
静态代理
package com.tyl.java;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java* @Project：workidea* @Filename: StaticProxyTest* @create 2023-06-25 22:31** 静态代理举例* 特点：代理类和被代理类在编译期间，就确定下来了。*/interface ClothFactory {void produceCloth();
}// 代理类
class ProxyClothFactory implements ClothFactory{private ClothFactory factory;public ProxyClothFactory(ClothFactory factory){this.factory = factory;}@Overridepublic void produceCloth() {System.out.println("代理工厂做准备！！！");factory.produceCloth();System.out.println("代理工厂后续工作！！！");}}// 被代理类
class NikeClothFactory implements ClothFactory{@Overridepublic void produceCloth() {System.out.println("Nike生产运动鞋！！！");}
}public class StaticProxyTest {public static void main(String[] args) {// 创建被代理类的对象NikeClothFactory nike = new NikeClothFactory();// 创建代理类的对象ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);proxyClothFactory.produceCloth();}}动态代理
package com.tyl.java;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author tyl 邮箱：tyl202061@gmail* @Package：com.tyl.java* @Project：workidea* @Filename: ProxyTest* @create 2023-06-25 22:35** 动态代理的举例*/interface Human{String getBelief();void eat(String food);}// 被代理类
class SuperMan implements Human{@Overridepublic String getBelief() {return "I believe I can fly!";}@Overridepublic void eat(String food) {System.out.println("我喜欢吃:" + food);}
}class HuamUtil{public void method1(){System.out.println("*****************通用方法一************************");}public void method2(){System.out.println("*****************通用方法二************************");}
}/*
要想实现动态代理，需要解决的问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。*/
class ProxyFactory{// 调用此方法，返回一个代理类的对象 解决问题一public static Object getProxyInstance(Object obj){ // obj: 被代理类的对象MyInvocationHandler handler = new MyInvocationHandler();handler.bind(obj);return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);}
}class MyInvocationHandler implements InvocationHandler{private Object obj; // 需要使用被代理类的对象进行赋值public void bind(Object obj){this.obj = obj;}// 当我们通过代理类的对象，调用方法和时，就会自动的调用如下的方法：invoke（）// 将被代理类要执行的方法和的功能就声明在invoke（）中@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {HuamUtil huamUtil = new HuamUtil();huamUtil.method1();// method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法// obj:被代理类的对象Object returnValue = method.invoke(obj, args);huamUtil.method2();// 上述方法的返回值就作为当前类中的invoke（）的返回值。return returnValue;}
}public class ProxyTest {public static void main(String[] args) {SuperMan superMan = new SuperMan();// proxyInstance:代理类的对象Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);// 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法String belief = proxyInstance.getBelief();System.out.println(belief);proxyInstance.eat("麻辣烫");System.out.println("****************************");NikeClothFactory nikeClothFactory = new NikeClothFactory();ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);proxyClothFactory.produceCloth();}}
框架 =反射 + 注解 + 设计模式
虽然理解的不够全面，透彻，但是在以后的框架学习中一定会有更深的理解！！！
更多推荐
Java高级编程——Java反射机制
发布评论