java 的反射机制

2021-10-11 21:05:49

一：介绍

1.大纲

　　允许程序在执行期间，调用反射API取得任何类的内部信息，并且可以直接操作任何对象的内部属性和方法。

　　学习反射，需要掌握的知识点：

　　　　*实例化class类

　　　　*获取类的完整结构

　　　　*通过反射调用类的属性和方法

　　　　*动态代理

2.涉及到的一些API

　　java.lang.Class 类

　　java.lang.reflect.Field　　　　属性

　　java.lang.reflect.Method　　　方法

　　java.lang.reflect.Constructor　构造器

二：简单反射的小示例（可以直接看后面的内容）

1.新建要反射的类Person

　　这个要被反射的类中不含有父类，接口，注解等额外的部分，只是一个特别简单的可以被用来反射的类，用来做演示。

 package demo2;

 public class Person1 {

     //这里为了说明反射，权限为public

     public String name;

     //这里为了说明反射，做对比，权限为private

     private int age;

     public Person1() {

         super();

     }

     public Person1(String name) {

         super();

         this.name = name;

     }

     public Person1(int age) {

         super();

         this.age = age;

     }

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public int getAge() {

         return age;

     }

     public void setAge(int age) {

         this.age = age;

     }

     @Override

     public String toString() {

         return "Person1 [name=" + name + ", age=" + age + "]";

     }

     //两个普通的方法

     //不带参数的函数

     public void show(){

         System.out.println("this is person class");

     }

     //带参数的函数

     public void diaplay(String nation){

         System.out.println("contry is "+nation);

     }

 }

2.反射的测试

　　这个部分包括建立反射源

　　通过反射设置属性

　　通过反射调用方法函数

 package demo2;

 import java.lang.reflect.Field;

 import java.lang.reflect.Method;

 public class Test1 {

     public static void main(String[] args)throws Exception {

         reflectMethod();

     }

     public static void reflectMethod()throws Exception{

         //产生对应的类

         Class clazz=Person1.class;

         Person1 p=(Person1)clazz.newInstance();

         System.out.println(p);

         System.out.println("-------------------------");

         //设置public权限的属性

         Field f=clazz.getField("name");

         f.set(p, "zhangsan");

         System.out.println(p);

         System.out.println("-------------------------");

         //设置private权限的属性

         Field f1=clazz.getDeclaredField("age");

         f1.setAccessible(true);//增加访问权限

         f1.set(p, 90);

         System.out.println(p);

         System.out.println("-------------------------");

         //调用不带参数的函数方法

         Method m=clazz.getMethod("show");

         m.invoke(p);

         System.out.println("-------------------------");

         //调用带参数的函数方法

         Method m1=clazz.getMethod("diaplay",String.class);

         m1.invoke(p, "China");

     }

 }

3.运行结果

-----------------------------------------------------------------------------------------------#反射重点#---------------------------------------------------------------------------------------------------

三：实现Class类的四种实现方式（所有反射的基础源头---class类的获取）

1.介绍四种方式获取要反射类的class文件

　　*用运行时类本身的.class获取

　　*通过运行时类的对象的获取

　　*以class的静态方法获取

　　*通过类的加载器获取

2.程序

 package demo2;

 import org.junit.Test;

 public class Test2 {

     @Test

     public void classMethod() throws ClassNotFoundException{

         //通过类的class文件

         Class c1=Person1.class;

         System.out.println(c1);

         //通过运行时类的对象获取class文件

         Person1 p=new Person1();

         Class c2=p.getClass();

         System.out.println(c2);

         //通过class的静态方法

         String name="demo2.Person1";

         Class c3=Class.forName(name);

         System.out.println(c3);

         //通过类的加载器获得class

         ClassLoader classLoader=this.getClass().getClassLoader();

         Class c4=classLoader.loadClass(name);

         System.out.println(c4);

     }

 }

3.运行结果

　　结果看到：四种方式都可以获得class类。

四：类的加载器（解释一下上面方式四中类的加载器，次要内容）

1.介绍

2.程序验证

 package demo2;

 import org.junit.Test;

 public class Test3 {

     @Test

     public void show(){

         //systemClassLoader

         ClassLoader c1=ClassLoader.getSystemClassLoader();

         System.out.println(c1);

         //ExterSionClassLoader

         ClassLoader c2=c1.getParent();

         System.out.println(c2);

         //null(这一个类加载器不会被获取)

         ClassLoader c3=c2.getParent();

         System.out.println(c3);

     }

 }

3.运行结果

4.在方式四种使用的是哪一个加载器（程序验证）

 package demo2;

 import org.junit.Test;

 public class Test4 {

     @Test

     public void method(){

         String name="demo2.Person1";

         ClassLoader classLoader=this.getClass().getClassLoader();

         System.out.println(classLoader);

     }

 }

5.运行结果

五：创建运行时类对象（class文件的基础上）

1.要求

　　要反射的类中有空参的构造器（最好是这样）

　　构造器的权限为public

2.程序实现解释

 package demo2;

 public class Test5 {

     public static void main(String[] args)throws Exception {

         Class c=Person1.class;

         Object obj=c.newInstance();

         Person1 p=(Person1)obj;

         System.out.println(p);

     }

 }

3.运行结果

六：重新构建复杂的即将被反射的类

1.构建复杂的类对象

　　包含:

　　　　*父类

　　　　*多接口

　　　　*注解

　　　　*内部类

　　　　*异常

首先是父类：

 package com.at.java;

 public class Creature<T>{

     public double weight;

     public void breath(){

         System.out.println("呼吸");

     }

 }

自定义接口：

 package com.at.java;

 import java.io.Serializable;

 public interface MyInterface extends Serializable{

 }

自定义注解：

 package com.at.java;

 import static java.lang.annotation.ElementType.CONSTRUCTOR;

 import static java.lang.annotation.ElementType.FIELD;

 import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

 import static java.lang.annotation.ElementType.METHOD;

 import static java.lang.annotation.ElementType.PARAMETER;

 import static java.lang.annotation.ElementType.TYPE;

 import java.lang.annotation.Retention;

 import java.lang.annotation.RetentionPolicy;

 import java.lang.annotation.Target;

 @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})

 @Retention(RetentionPolicy.RUNTIME)

 public @interface MyAnnotation {

     String value();

 }

反射的类：

 package com.at.java;

 @MyAnnotation(value = "atguigu")

 public class Person extends Creature<String> implements Comparable,MyInterface{

     public String name;

     private int age;

     int id;

     public Person() {

         super();

     }

     public Person(String name) {

         super();

         this.name = name;

     }

     private Person(String name, int age) {

         super();

         this.name = name;

         this.age = age;

     }

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public int getAge() {

         return age;

     }

     public void setAge(int age) {

         this.age = age;

     }

     public int getId() {

         return id;

     }

     public void setId(int id) {

         this.id = id;

     }

     @MyAnnotation(value = "abc123")

     public void show(){

         System.out.println("this is person");

     }

     private Integer display(String nation,Integer i) throws Exception{

         System.out.println("国籍：" + nation);

         return i;

     }

     @Override

     public String toString() {

         return "Person [name=" + name + ", age=" + age + "]";

     }

     @Override

     public int compareTo(Object o) {

         // TODO Auto-generated method stub

         return 0;

     }

     public static void info(){

         System.out.println("信息");

     }

     class Bird{

     }

 }

七：获取以及调用类的属性

　　包括：

　　　　*所有属性的获取

　　　　*指定属性的调用

1.获取对应类运行时的属性

　　包括两种;

　　　　*getFields():只能获取到运行时类中及其父类中声明为public的属性

　　　　*getDeclaredFields():获取运行时类本身声明的所有的属性

 package com.at.java;

 import java.lang.reflect.Field;

 public class Test1 {

     public static void main(String[] args){

         get1();

         System.out.println("###################");

         get2();

     }

     /**

      * getFields():只能获取到运行时类中及其父类中声明为public的属性

      */

     public static void get1(){

         Class clazz=Person.class;

         Field[] f=clazz.getFields();

         for(int i=0;i<f.length;i++){

             System.out.println(f[i].getName());

         }

     }

     /**

      * getDeclaredFields():获取运行时类本身声明的所有的属性

      */

     public static void get2(){

         Class clazz=Person.class;

         Field[] f=clazz.getDeclaredFields();

         for(Field ff:f){

             System.out.println(ff.getName());

         }

     }

 }

2.运行结果

　　使用###进行将两种方式进行隔离。

3.获取对应类运行时的属性的各个部分的内容

　　主要包括：

　　　　*权限

　　　　*变量名

 package com.at.java;

 import java.lang.reflect.Field;

 import java.lang.reflect.Modifier;

 public class Test2 {

     public static void main(String[] args) {

         get2();

     }

     /**

      * getDeclaredFields():获取运行时类本身声明的所有的属性的各个部分

      */

     public static void get2(){

         Class clazz=Person.class;

         Field[] f=clazz.getDeclaredFields();

         for(Field ff:f){

             //属性权限

             int num=ff.getModifiers();

             String str=Modifier.toString(num);

             System.out.print(str+"\t");

             //属性类型

             Class type=ff.getType();

             System.out.print(type.getName()+"\t");

             //属性变量名

             System.out.println(ff.getName());

         }

     }

 }

4.运行结果

5.调用设置指定属性

　　注意点事权限问题

 package com.at.java;

 import java.lang.reflect.Field;

 public class Test6 {

     public static void main(String[] args)throws Exception {

         Class clazz=Person.class;

         /**

          * 属性权限为public

          */

         Field name = clazz.getField("name");

         Person p = (Person)clazz.newInstance();

         //将运行时类的指定的属性赋值

         name.set(p,"Jerry");

         System.out.println(p);

         //将运行时类的指定的属性赋值后再取出

         System.out.println("name="+name.get(p));

         System.out.println("########################");

         /**

          * 属性权限为private

          */

         Field age = clazz.getDeclaredField("age");

         age.setAccessible(true);//由于属性权限修饰符的限制，需要在操作前使得此属性可被操作。

         age.set(p,10);

         System.out.println(p);

         System.out.println("#######################");

         /**

          * 属性的权限为默认default

          * 这个set时不需要setAccessible(true)。

          */

         Field id = clazz.getDeclaredField("id");

         id.set(p,3);

         System.out.println(p);

     }

 }

6.运行结果

八：获取与调用对应类运行时的方法

　　包括两种：

　　　　*获取所有方法

　　　　*调用指定方法

1.获取对应类运行时的方法

　　包括两种：

　　　　*getMethods():获取运行时类及其父类中所有的声明为public的方法

　　　　*getDeclaredMethods():获取运行时类本身声明的所有的方法

 package com.at.java;

 import java.lang.reflect.Method;

 public class Test3 {

     public static void main(String[] args) {

         get1();

         System.out.println("#############");

         get2();

     }

     /**

      * getMethods():获取运行时类及其父类中所有的声明为public的方法

      */

     public static void get1(){

         Class clazz=Person.class;

         Method[] m=clazz.getMethods();

         for(Method mm: m){

             System.out.println(mm.getName());

         }

     }

     /**

      * getDeclaredMethods():获取运行时类本身声明的所有的方法

      */

     public static void get2(){

         Class clazz=Person.class;

         Method[] m=clazz.getDeclaredMethods();

         for(Method mm:m){

             System.out.println(mm.getName());

         }

     }

 }

2.运行结果

3.获取对应类运行时的方法的各个部分

　　包括：

　　　　*注解

　　　　*权限

　　　　*返回类型

　　　　*方法名

　　　　*参数列表

　　　　*异常类型

 package com.at.java;

 import java.lang.annotation.Annotation;

 import java.lang.reflect.Method;

 import java.lang.reflect.Modifier;

 public class Test4 {

     public static void main(String[] args) {

         get2();

     }

     /**

      * 注解 权限修饰符 返回值类型 方法名 形参列表 异常

      */

     public static void get2(){

         Class clazz = Person.class;

         Method[] m2 = clazz.getDeclaredMethods();

         for(Method m : m2){

             //1.注解

             Annotation[] ann = m.getAnnotations();

             for(Annotation a : ann){

                 System.out.println(a);

             }

             //2.权限修饰符

             String str = Modifier.toString(m.getModifiers());

             System.out.print(str + " ");

             //3.返回值类型

             Class returnType = m.getReturnType();

             System.out.print(returnType.getName() + " ");

             //4.方法名

             System.out.print(m.getName() + " ");

             //5.形参列表

             System.out.print("(");

             Class[] params = m.getParameterTypes();

             for(int i = 0;i < params.length;i++){

                 System.out.print(params[i].getName() + " args-" + i + " ");

             }

             System.out.print(")");

             //6.异常类型

             Class[] exps = m.getExceptionTypes();

             if(exps.length != 0){

                 System.out.print("throws ");

             }

             for(int i = 0;i < exps.length;i++){

                 System.out.print(exps[i].getName() + " ");

             }

             System.out.println();

         }

     }

 }

4.运行结果

5.调用指定方法

 package com.at.java;

 import java.lang.reflect.Method;

 public class Test7 {

     public static void main(String[] args) throws Exception{

         Class clazz = Person.class;

         Person p = (Person)clazz.newInstance();

         /**

          * public

          */

         Method m1 = clazz.getMethod("show");

         Object returnVal = m1.invoke(p);

         System.out.println(returnVal);    //因为返回值为void，所以打印为null

         Method m2 = clazz.getMethod("toString");

         Object returnVal1 = m2.invoke(p); //因为返回值为string，所以这样调用不会有什么现象

         System.out.println(returnVal1);   //没有现象，所以打印就是打印返回值

         /**

          * private

          * 同时，这是带参数的函数

          */

         Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);

         m4.setAccessible(true);

         Object value = m4.invoke(p,"CHN",10);

         System.out.println(value);

         /**

          * static 方法，单独提出来

          */

         Method m3 = clazz.getMethod("info");

         m3.invoke(Person.class);

     }

 }

6.运行结果

九：获取构造器

　　包括：

　　　　*所有的构造器

　　　　*调用指定的构造器

1.获取所有的构造器

 package com.at.java;

 import java.lang.reflect.Constructor;

 public class Test8 {

     public static void main(String[] args) throws Exception{

         String className = "com.at.java.Person";

         Class clazz = Class.forName(className);

         /**

          * 获取所有的构造器

          */

         Constructor[] cons = clazz.getDeclaredConstructors();

         for(Constructor c : cons){

             System.out.println(c);

         }

     }

 }

2.运行结果

3.调用指定的构造器

 package com.at.java;

 import java.lang.reflect.Constructor;

 public class Test9 {

     public static void main(String[] args)throws Exception{

         String className = "com.at.java.Person";

         Class clazz = Class.forName(className);

         /**

          * 调用String，int的构造器

          */

         Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);

         cons.setAccessible(true);

         Person p = (Person)cons.newInstance("罗伟",20);

         System.out.println(p);

     }

 }

4.运行结果

十：获取其他的内容（父类，接口，注解，包，）

1.程序

 package com.at.java;

 import java.lang.annotation.Annotation;

 import java.lang.reflect.ParameterizedType;

 import java.lang.reflect.Type;

 import org.junit.Test;

 public class Test10 {

     //6.获取注解

         @Test

         public void test6(){

             Class clazz = Person.class;

             Annotation[] anns = clazz.getAnnotations();

             for(Annotation a : anns){

                 System.out.println(a);

             }

         }

         //5.获取所在的包

         @Test

         public void test5(){

             Class clazz = Person.class;

             Package pack = clazz.getPackage();

             System.out.println(pack);

         }

         //4.获取实现的接口

         @Test

         public void test4(){

             Class clazz = Person.class;

             Class[] interfaces = clazz.getInterfaces();

             for(Class i : interfaces){

                 System.out.println(i);

             }

         }

         //3*.获取父类的泛型

         @Test

         public void test3(){

             Class clazz = Person.class;

             Type type1 = clazz.getGenericSuperclass();

             ParameterizedType param = (ParameterizedType)type1;

             Type[] ars = param.getActualTypeArguments();

             System.out.println(((Class)ars[0]).getName());

         }

         //2.获取带泛型的父类

         @Test

         public void test2(){

             Class clazz = Person.class;

             Type type1 = clazz.getGenericSuperclass();

             System.out.println(type1);

         }

         //1.获取运行时类的父类

         @Test

         public void test1(){

             Class clazz = Person.class;

             Class superClass = clazz.getSuperclass();

             System.out.println(superClass);

         }

 }

2.运行结果

十一：动态代理

1.静态代理

 /**

  * 静态代理模式

  */

 package com.at.java1;

 //接口

 interface ClothFactory{

     void productCloth();

 }

 //被代理类

 class NikeClothFactory implements ClothFactory{

     @Override

     public void productCloth() {

         System.out.println("Nike");

     }

     public void productCloth2() {

         System.out.println("Nike2");

     }

 }

 //代理类

 class ProxyFactory implements ClothFactory{

     //引用

     ClothFactory cf;

     public ProxyFactory(ClothFactory cf){  //创建代理类的对象时，实际传入一个被代理类的对象

         this.cf = cf;

     }

     @Override

     public void productCloth() {

         System.out.println("一共$1000");

         cf.productCloth();                 //实际在代理类中执行的还是被代理类的方法

     }

 }

 public class TestClothProduct {

     public static void main(String[] args) {

         NikeClothFactory nike = new NikeClothFactory();

         ProxyFactory proxy = new ProxyFactory(nike);     //将被代理类传入代理类中

         proxy.productCloth();

     }

 }

2.运行结果

3.动态代理

 /**

  * 动态代理

  */

 package com.at.java1;

 import java.lang.reflect.InvocationHandler;

 import java.lang.reflect.Method;

 import java.lang.reflect.Proxy;

 //接口

 interface Subject {

     void action();

 }

 //被代理类

 class RealSubject implements Subject {

     public void action() {

         System.out.println("我是被代理类，记得要执行我哦！");

     }

 }

 //代理类

 //动态代理都要实现接口InvocationHandler

 class MyInvocationHandler implements InvocationHandler {

     Object obj;

     //①给被代理的对象实例化②返回一个代理类的对象

     public Object blind(Object obj) {

         this.obj = obj;

         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj

                 .getClass().getInterfaces(), this);

     }

     //当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用

     @Override

     public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {

         Object returnVal = method.invoke(obj, args);

         return returnVal;

     }

 }

 public class TestProxy {

     public static void main(String[] args) {

         RealSubject real = new RealSubject();

         MyInvocationHandler handler = new MyInvocationHandler();

         //动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象。

         Object obj = handler.blind(real);

         Subject sub = (Subject)obj;

         sub.action();

     }

 }

4.运行结果

十二：动态代理与静态代理的区别

　　2017.12.21，今天查看了一下他们之间的区别，在这篇文章中解释的挺好的，就没有重新整理，直接粘贴一下链接。

　　http://blog.csdn.net/hejingyuan6/article/details/36203505。

　　在这篇文章中，这一段比我上面的程序写的更好理解：

码农公寓

相关文章