Android APT从入门到实战

一叶飘舟

已于 2023-11-30 14:37:13 修改

阅读量1.6k

点赞数 3

CC 4.0 BY-SA版权

文章标签： android python 前端

于 2023-11-30 14:13:39 首次发布

原文链接：https://juejin.cn/post/6997690572819398669

APT是什么?有什么用?

APT(Annotation Processing Tool)即注解处理器，在编译的时候可以处理注解然后搞一些事情，也可以在编译时生成一些文件之类的。ButterKnife和EventBus都使用了APT技术，如果不会APT技术就很难看懂这两个框架的源码。

使用过程中可能会遇到的问题：

Android 中使用 ServiceLoader、AutoService 摔坑记录 - 灰信网（软件开发博客聚合）

实现效果

我们来实现一个简单的功能，只要在任何类的成员变量上添加一个 @Print注解，就可以动态生成一个方法，然后把成员变量的变量名输出：

动态生成的类大概长这样:

整理思路

首先我们需要创建两个JavaLibrary
一个用来定义注解，一个用来扫描注解
获取到添加注解的成员变量名
动态生成类和方法用IO生成文件

实战
创建一个空项目

创建两个JavaLibrary

注解的Lib: apt-annotation
扫描注解的Lib: apt-processor

创建完之后

apt-processor工程的build.gradle文件如下：

apply plugin: 'java-library'

java {
    sourceCompatibility = JavaVersion.VERSION_1_7
    targetCompatibility = JavaVersion.VERSION_1_7
}

dependencies {
    implementation files ('/Library/Java/JavaVirtualMachines/jdk1.8.0_131.jdk/Contents/Home/jre/lib/rt.jar')
    //自动注册，动态生成 META-INF/...文件
    implementation 'com.google.auto.service:auto-service:1.0'
    annotationProcessor 'com.google.auto.service:auto-service:1.0'
    //依赖apt-annotation
    implementation project(path: ':apt-annotation')
}

当你的java library不能找到javax开头的类时，手动引入rt.jar ：

implementation files ('/Library/Java/JavaVirtualMachines/jdk1.8.0_131.jdk/Contents/Home/jre/lib/rt.jar')

注意：jdk 11删除了jre，即使生成了jre目录，下面也没有rt.jar文件，尽量不要在jdk 11下面折腾

app模块依赖两个Library

implementation project(path: ':apt-annotation') 
annotationProcessor project(path: ':apt-processor')

注解Lib中创建一个注解类

如果还不会自定义注解的同学，可以先去看我之前写的一篇Java自定义注解入门到实战

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface Print {

}

扫描注解的Lib添加依赖

dependencies {
    //自动注册，动态生成 META-INF/...文件
    implementation 'com.google.auto.service:auto-service:1.0-rc6'
    annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'
    //依赖apt-annotation
    implementation project(path: ':apt-annotation')
}

创建扫描注解的类

重写init方法，输出Hello,APT

注意: 这里是JavaLib，所以不能使用Log打印，这里可以使用Java的println()或注解处理器给我们提供的方法，建议使用注解处理器给我们提供的

见证奇迹

现在我们已经完成了APT的基本配置，现在我们可以build一下项目了，成败在此一举

踩坑指南

如果你已经成功输出了文本，说明APT已经配置好，可以继续下一步了
如果你失败了：

如果继承的时候找不到AbstractProcessor类，那你 创建的肯定不是JavaLibrary，你可以删掉重新创建
如果点击编译没反应，你可以试试先 clear一下项目再重新编译
如果都不行，就去检查一下前面流程的 依赖是否都配置正确

继续完成功能

现在我们可以继续完成上面要实现的功能了，我们需要先来实现几个方法

/**
 * 要扫描扫描的注解，可以添加多个
 */
@Override
public Set<String> getSupportedAnnotationTypes() {
    HashSet<String> hashSet = new HashSet<>();
    hashSet.add(Print.class.getCanonicalName());
    return hashSet;
}

/**
 * 编译版本，固定写法就可以
 */
@Override
public SourceVersion getSupportedSourceVersion() {
    return processingEnv.getSourceVersion();
}

定义注解

我们先在MianActivity中添加两个成员变量并使用我们定义的注解

定义注解

真正解析注解的地方是在process方法，我们先试试能不能拿到被注解的变量名

/**
 * 扫描注解回调
 */
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    //拿到所有添加Print注解的成员变量
    Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Print.class);
    for (Element element : elements) {
        //拿到成员变量名
        Name simpleName = element.getSimpleName();
        //输出成员变量名
        processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,simpleName);
    }
    return false;
}

编译试一下

生成类

既然能拿到被注解的变量名，后面就简单了，我们只需要用字符串拼出来一个工具类，然后用IO流写到本地就ok了

@Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(Print.class);
        try {
            JavaFileObject fileObject = processingEnv.getFiler().createSourceFile("PrintUtil");
            Writer writer = fileObject.openWriter();
            writer.write("package com.baidu.netesay;\n");
            writer.write("\n");
            writer.write("public class PrintUtil{\n");
            for (Element e: elements) {
                Name simpleName = e.getSimpleName();
                //processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,simpleName);
                writer.write("    //输出"+simpleName+"\n");
                writer.write("   public static void print$$"+simpleName+"() {\n");
                writer.write("        System.out.println(\"Hello "+simpleName+ "\");\n   }\n\n");

            }
            writer.write("}");
            writer.flush();
            writer.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

        return false;
    }

查看效果

现在点击一下编译，然后我们可以看到app模块下的build文件已经有我们生成的类了

调用方法

现在我们回到MainActivity，就可以直接调用这个动态生成的类了

实战结束

结束了吗...好像是结束了，但是上面拼接类的方法感觉一不小心就会写错，有没有更好的方法呢，我们先来看看EventBus的源码是怎么生成的:

看到大佬也是这样拼接的，这我就放心了🤡，我们再看一下ButterKnife的源码是怎么生成的:

ButterKnife的源码竟然不是用字符串拼接的!!! 隐约看到TypeSpec.classBuilder，这是啥玩意？不过身为资深的程序猿这点问题我们还是可以很容易的找到答案的

JavaPoet

经过一个小时的百度，大概研究了一下JavaPoet，这玩意好像可以帮我们以面向对象的思维来生成类，这样我们就不用手动拼接字符串的方式来生成类了，那我们来优化一下上面的代码:

先添加依赖
implementation 'com.squareup:javapoet:1.13.0'

/**
 * 扫描注解回调
 */
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    //拿到所有添加Print注解的成员变量
    Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Print.class);

    //生成类
    TypeSpec.Builder classBuilder = TypeSpec
            .classBuilder("PrintUtil")
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL);

    for (Element element : elements) {
        //拿到成员变量名
        Name simpleName = element.getSimpleName();
        //生成方法
        MethodSpec method = MethodSpec.methodBuilder("print$$"+simpleName)
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .returns(void.class)
                .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
                .build();
        classBuilder.addMethod(method);
    }
    //包
    JavaFile javaFile = JavaFile
            .builder("com.lkx.helloapt", classBuilder.build())
            .build();
    try {
        javaFile.writeTo(processingEnv.getFiler());
    } catch (IOException e) {
        e.printStackTrace();
    }
    return false;
}

编译一下

总结

APT可以在编译器扫描注解帮我们提前生成类
JavaPoet可以帮我们优雅的生成类，再也不用拼接了
APT最主要的功能就是可以替代反射的一些功能，避免降低性能
APT只会在编译时影响一点点速度，在运行期不会，而反射刚好相反

java注解的详细使用（APT、插桩、反射）

一、APT，编译时注解处理器

1、概述：

什么是apt：
APT，就是Annotation Processing Tool的简称，就是可以在代码编译期间对注解进行处理，并且生成Java文件，减少手动的代码输入。注解我们平时用到的比较多的可能会是运行时注解，比如大名鼎鼎的retrofit就是用运行时注解，通过动态代理来生成网络请求。编译时注解平时开发中可能会涉及的比较少，但并不是说不常用，比如我们经常用的轮子Dagger2, ButterKnife, EventBus3 都在用，所以要紧跟潮流来看看APT技术的来龙去脉。

编译时注解：
也有人叫它代码生成，其实他们还是有些区别的，在编译时对注解做处理，通过注解，获取必要信息，在项目中生成代码，运行时调用，和直接运行手写代码没有任何区别。而更准确的叫法：APT - Annotation Processing Tool

大概原理：
Java API 已经提供了扫描源码并解析注解的框架，开发者可以通过继承 AbstractProcessor 类来实现自己的注解解析逻辑。APT 的原理就是在注解了某些代码元素（如字段、函数、类等）后，在编译时编译器会检查 AbstractProcessor 的子类，并且自动调用其 process() 方法，然后将添加了指定注解的所有代码元素作为参数传递给该方法，开发者再根据注解元素在编译期输出对应的 Java 代码。

APT在代码编译期解析注解，并且生成新的 Java 文件，减少手动的代码输入。

APT是一个命令行工具，它对源代码文件进行检测找出其中的annotation后，使用AbstractProcessor来处理annotation。

JavaPoet + Auto Service + java APT完成对编译时注解的处理。

2、Android studio中使用APT过程:

(1) 创建android过程SelfAnnotationProcessor
(2) 给工程添加java module:名称 apt：主要用于处理运行时注解的解析工作;给工程添加java module:名称 anno：主要用于定义运行时注解;
(3) 在app module的build.gradle添加依赖
annotationProcessorproject(":apt")
implementationproject(’:anno’)

在apt module的build.gradle添加依赖

implementation project(‘:anno’)
implementation’com.squareup:javapoet:1.11.1’
implementation’com.google.auto.service:auto-service:1.0-rc2’

(4) 在 anno module下定义注解:

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD,ElementType.TYPE)
public @interface BindView {
    int value();
}

(5) 在app module的MainActivity中使用自定义注解 BindSelfView

@BindView(1)
public class MainActivity extends Activity{
    @BindView(R.id.textView1)
    TextView textView1;
    @BindView(R.id.textView2)
    TextView textView1;
    protected void onCreate(Bundle savedInstanceState){
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
    }
    @BindView(2)
    class ViewHolder{
    }
}

(6) 在apt module下定义自定义注解处理器(代码过长)

@AutoService(Processor.class)
@SupportedAnnotationTypes("com.example.sjh.anno.BindSelfView")
public class MyAnnoProcessor extends AbstractProcessor{

添加了 @AutoService(Processor.class)

那么就会在当前工程apt的META-INF下生成配置文件, 内容为注册的注解处理器

在init方法中进行工具类对象的获取:

@Override
public synchronized void init(ProcessingEnvironment processingEnvironment){
     System.out.printlin("MyAnnoProcessor init is invoke.processingEnvironment"+processingEnvironment);
     super.init(processingEnvironment);
     mFiler=processingEnvironment.getFiler();
     elementsUtils=processingEnvironment.getElementUtils();
}

在核心方法process里面对被注解元素进行分析，并生成目标文件;

整个过程中用到TypeSpec，MethodSpec，JavaFile等对象

TypeSpec.Builder tb = TypeSpec.classBuilder( name: "MainActivity. _BindView" ).
            addModifiers (Modifier . PUBLIC, Modifier .FINAL)
            . addField(String.class, name: "textView", Modifier . PRIVATE)
            .addJavadoc(sb. tostring());
            
MethodSpec .Builder mb = MethodSpec . methodBuilder( name: "onCreate").returns(TypeName. VOID).
            addModifiers(Modifier.PUBLIC)
            .addParameter(String.class,"savedInstanceState");




Set<? extends Element> eleSet = roundEnvi ronment. getElementsAnnot at edWith(BindSeIfView.class);



Iterstorc? extends Element) t . eleSet.iterator();
while (it.haslext()) (
     Element ele=it.next();
     if(ele instanceof TypeElement) {
          Annotation anne=ele.getannotation(BindSelfView.class);
          BindSelfView view=(BindSelfView)anno;
          String desc="eleName:"+ele.getSimpleName().toString()+",annoNmae:"+anno.annotationType().getClass().getSimpleName()+",annoValue:"+view.value()+",kind:"+ele.getKind();
            
            CodeBlock cb=CodeBlock.builder()
               .addStatement(""+desc);
               .build();
            mb.addCode(cb);  
     }
}





tb.addMethod(mb.build());
JavaFile jf=JavaFile.builder( packageName: "com. example.sjh.selfannotationprocessor",tb.build())
            .build();
try {
      jf . writeTo(mFller);
} catch (IOException e) {
      e.printStackTrace();
}
return true;

其中用到了javapoet的提供的API

(7) 然后执行build(rebuild)操作，就可以在 app module下看到生成的目标文件
github demo地址//这是一个单纯编译时注解的demo

二、插桩，编译后处理筛选

什么是插桩?

插桩就是将一段代码插入或者替换原本的代码。字节码插桩顾名思义就是在我们编写的源码编译成字节码（Class）后，在Android下生成dex之前修改Class文件，修改或者增强原有代码逻辑的操作。

字节码操作框架

QQ空间使用了 Javaassist 来进行字节码插桩，除了 Javaassist 之外还有一个应用更为广泛的 ASM 框架同样也是字节码操作框架，Instant Run包括 AspectJ 就是借助 ASM来实现各自的功能。

字节码操作框架的作用在于生成或者修改Class文件，因此在Android中字节码框架本身是不需要打包进入APK的，只有其生成/修改之后的Class才需要打包进入APK中。它的工作时机为Android打包流程中的生成Class之后，打包dex之前。

Android打包流程图：

通过上图可知，只要在图中红色箭头处拦截（生成class文件之后，dex文件之前），就可以拿到当前应用程序中所有的.class文件，再去借助ASM之类的库，就可以遍历这些.class文件中所有方法，再根据一定的条件找到需要的目标方法，最后进行修改并保存，就可以插入指定代码。

ASM

ASM是一个字节码操作库，它可以直接修改已经存在的class文件或者生成class文件。ASM提供了一些便捷的功能来操作字节码内容。与其它字节码操作框架（比如：AspectJ等）相比，ASM更偏向于底层，它是直接操作字节码的，在设计上相对更小、更快，所以在性能上更好，而且几乎可以任意修改字节码。

三、反射，运动时动态获取注解信息

1.概述：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

反射就是把java类中的各种成分映射成一个个的Java对象

例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。

Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

2、查看Class类在java中的api详解

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

3、反射的使用（这里使用Student类做演示）

先写一个Student类。

1、获取Class对象的三种方式

1.1 Object ——> getClass();
1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
1.3 通过Class类的静态方法：forName（String className）(常用)

package fanshe;
/**
 * 获取Class对象的三种方式
 * 1 Object ——> getClass();
 * 2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
 * 3 通过Class类的静态方法：forName（String  className）(常用)
 *
 */
public class Fanshe {
	public static void main(String[] args) {
		//第一种方式获取Class对象  
		Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
		Class stuClass = stu1.getClass();//获取Class对象
		System.out.println(stuClass.getName());
		
		//第二种方式获取Class对象
		Class stuClass2 = Student.class;
		System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
		
		//第三种方式获取Class对象
		try {
			Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
	}
}

注意：在运行期间，一个类，只有一个Class对象产生。
三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。

2、通过反射获取构造方法并使用

package fanshe;
 
public class Student {
	
	//---------------构造方法-------------------
	//（默认的构造方法）
	Student(String str){
		System.out.println("(默认)的构造方法 s = " + str);
	}
	
	//无参构造方法
	public Student(){
		System.out.println("调用了公有、无参构造方法执行了。。。");
	}
	
	//有一个参数的构造方法
	public Student(char name){
		System.out.println("姓名：" + name);
	}
	
	//有多个参数的构造方法
	public Student(String name ,int age){
		System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。
	}
	
	//受保护的构造方法
	protected Student(boolean n){
		System.out.println("受保护的构造方法 n = " + n);
	}
	
	//私有构造方法
	private Student(int age){
		System.out.println("私有的构造方法   年龄："+ age);
	}
 
}

共有6个构造方法；

package fanshe;
 
import java.lang.reflect.Constructor;
 
 
/*
 * 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
 * 
 * 1.获取构造方法：
 * 		1).批量的方法：
 * 			public Constructor[] getConstructors()：所有"公有的"构造方法
            public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
     
 * 		2).获取单个的方法，并调用：
 * 			public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：
 * 			public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
 * 		
 * 			调用构造方法：
 * 			Constructor-->newInstance(Object... initargs)
 */
public class Constructors {
 
	public static void main(String[] args) throws Exception {
		//1.加载Class对象
		Class clazz = Class.forName("fanshe.Student");
		
		
		//2.获取所有公有构造方法
		System.out.println("**********************所有公有构造方法*********************************");
		Constructor[] conArray = clazz.getConstructors();
		for(Constructor c : conArray){
			System.out.println(c);
		}
		
		
		System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");
		conArray = clazz.getDeclaredConstructors();
		for(Constructor c : conArray){
			System.out.println(c);
		}
		
		System.out.println("*****************获取公有、无参的构造方法*******************************");
		Constructor con = clazz.getConstructor(null);
		//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型
		//2>、返回的是描述这个无参构造函数的类对象。
	
		System.out.println("con = " + con);
		//调用构造方法
		Object obj = con.newInstance();
	//	System.out.println("obj = " + obj);
	//	Student stu = (Student)obj;
		
		System.out.println("******************获取私有构造方法，并调用*******************************");
		con = clazz.getDeclaredConstructor(char.class);
		System.out.println(con);
		//调用构造方法
		con.setAccessible(true);//暴力访问(忽略掉访问修饰符)
		obj = con.newInstance('男');
	}
	
}

所有公有构造方法***********
public fanshe.Student(java.lang.String,int)
public fanshe.Student(char)
public fanshe.Student()
所有的构造方法(包括：私有、受保护、默认、公有)***
private fanshe.Student(int)
protected fanshe.Student(boolean)
public fanshe.Student(java.lang.String,int)
public fanshe.Student(char)
public fanshe.Student()
fanshe.Student(java.lang.String)
获取公有、无参的构造方法**************
con = public fanshe.Student()
调用了公有、无参构造方法执行了。。。
获取私有构造方法，并调用*************
public fanshe.Student(char)
姓名：男

调用方法：

1.获取构造方法：
1).批量的方法：
public Constructor[] getConstructors()：所有"公有的"构造方法
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)

2).获取单个的方法，并调用：
public Constructor getConstructor(Class… parameterTypes):获取单个的"公有的"构造方法：
public Constructor getDeclaredConstructor(Class… parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；

调用构造方法：
Constructor–>newInstance(Object… initargs)

2、 newInstance是 Constructor类的方法（管理构造函数的类）
api的解释为：
newInstance(Object… initargs)
使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
它的返回值是T类型，所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用

3、获取成员变量并调用

package fanshe.field;
 
public class Student {
	public Student(){
		
	}
	//**********字段*************//
	public String name;
	protected int age;
	char sex;
	private String phoneNum;
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex
				+ ", phoneNum=" + phoneNum + "]";
	}
	
	
}

package fanshe.field;
import java.lang.reflect.Field;
/*
 * 获取成员变量并调用：
 * 
 * 1.批量的
 * 		1).Field[] getFields():获取所有的"公有字段"
 * 		2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
 * 2.获取单个的：
 * 		1).public Field getField(String fieldName):获取某个"公有的"字段；
 * 		2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
 * 
 * 	 设置字段的值：
 * 		Field --> public void set(Object obj,Object value):
 * 					参数说明：
 * 					1.obj:要设置的字段所在的对象；
 * 					2.value:要为字段设置的值；
 * 
 */
public class Fields {
 
		public static void main(String[] args) throws Exception {
			//1.获取Class对象
			Class stuClass = Class.forName("fanshe.field.Student");
			//2.获取字段
			System.out.println("************获取所有公有的字段********************");
			Field[] fieldArray = stuClass.getFields();
			for(Field f : fieldArray){
				System.out.println(f);
			}
			System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
			fieldArray = stuClass.getDeclaredFields();
			for(Field f : fieldArray){
				System.out.println(f);
			}
			System.out.println("*************获取公有字段**并调用***********************************");
			Field f = stuClass.getField("name");
			System.out.println(f);
			//获取一个对象
			Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();
			//为字段设置值
			f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
			//验证
			Student stu = (Student)obj;
			System.out.println("验证姓名：" + stu.name);
			
			
			System.out.println("**************获取私有字段****并调用********************************");
			f = stuClass.getDeclaredField("phoneNum");
			System.out.println(f);
			f.setAccessible(true);//暴力反射，解除私有限定
			f.set(obj, "18888889999");
			System.out.println("验证电话：" + stu);
			
		}
	}

获取所有公有的字段********
public java.lang.String fanshe.field.Student.name
获取所有的字段(包括私有、受保护、默认的)********
public java.lang.String fanshe.field.Student.name
protected int fanshe.field.Student.age
char fanshe.field.Student.sex
private java.lang.String fanshe.field.Student.phoneNum
获取公有字段并调用********************
public java.lang.String fanshe.field.Student.name
验证姓名：刘德华
获取私有字段****并调用******************
private java.lang.String fanshe.field.Student.phoneNum
验证电话：Student [name=刘德华, age=0, sex=

由此可见
调用字段时：需要传递两个参数：第一个参数：要传入设置的对象，第二个参数：要传入实参

4、获取成员方法并调用

package fanshe.method;
 
public class Student {
	//**************成员方法***************//
	public void show1(String s){
		System.out.println("调用了：公有的，String参数的show1(): s = " + s);
	}
	protected void show2(){
		System.out.println("调用了：受保护的，无参的show2()");
	}
	void show3(){
		System.out.println("调用了：默认的，无参的show3()");
	}
	private String show4(int age){
		System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
		return "abcd";
	}
}

package fanshe.method;
 
import java.lang.reflect.Method;
 
/*
 * 获取成员方法并调用：
 * 
 * 1.批量的：
 * 		public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
 * 		public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
 * 2.获取单个的：
 * 		public Method getMethod(String name,Class<?>... parameterTypes):
 * 					参数：
 * 						name : 方法名；
 * 						Class ... : 形参的Class类型对象
 * 		public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
 * 
 * 	 调用方法：
 * 		Method --> public Object invoke(Object obj,Object... args):
 * 					参数说明：
 * 					obj : 要调用方法的对象；
 * 					args:调用方式时所传递的实参；
):
 */
public class MethodClass {
 
	public static void main(String[] args) throws Exception {
		//1.获取Class对象
		Class stuClass = Class.forName("fanshe.method.Student");
		//2.获取所有公有方法
		System.out.println("***************获取所有的”公有“方法*******************");
		stuClass.getMethods();
		Method[] methodArray = stuClass.getMethods();
		for(Method m : methodArray){
			System.out.println(m);
		}
		System.out.println("***************获取所有的方法，包括私有的*******************");
		methodArray = stuClass.getDeclaredMethods();
		for(Method m : methodArray){
			System.out.println(m);
		}
		System.out.println("***************获取公有的show1()方法*******************");
		Method m = stuClass.getMethod("show1", String.class);
		System.out.println(m);
		//实例化一个Student对象
		Object obj = stuClass.getConstructor().newInstance();
		m.invoke(obj, "刘德华");
		
		System.out.println("***************获取私有的show4()方法******************");
		m = stuClass.getDeclaredMethod("show4", int.class);
		System.out.println(m);
		m.setAccessible(true);//解除私有限定
		Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参
		System.out.println("返回值：" + result);
		
		
	}
}

获取所有的”公有“方法****
public void fanshe.method.Student.show1(java.lang.String)
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public java.lang.String java.lang.Object.toString()
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
获取所有的方法，包括私有的****
public void fanshe.method.Student.show1(java.lang.String)
private java.lang.String fanshe.method.Student.show4(int)
protected void fanshe.method.Student.show2()
void fanshe.method.Student.show3()
获取公有的show1()方法****
public void fanshe.method.Student.show1(java.lang.String)
调用了：公有的，String参数的show1(): s = 刘德华
获取私有的show4()方法***
private java.lang.String fanshe.method.Student.show4(int)
调用了，私有的，并且有返回值的，int参数的show4(): age = 20
返回值：abcd

其实这里的成员方法：在模型中有属性一词，就是那些setter（）方法和getter()方法。还有字段组成，这些内容在内省中详解

5、反射main方法

package fanshe.main;
 
public class Student {
 
	public static void main(String[] args) {
		System.out.println("main方法执行了。。。");
	}
}

package fanshe.main;
 
import java.lang.reflect.Method;
 
/**
 * 获取Student类的main方法、不要与当前的main方法搞混了
 */
public class Main {
	
	public static void main(String[] args) {
		try {
			//1、获取Student对象的字节码
			Class clazz = Class.forName("fanshe.main.Student");
			
			//2、获取main方法
			 Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，
			//3、调用main方法
			// methodMain.invoke(null, new String[]{"a","b","c"});
			 //第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数
			 //这里拆的时候将  new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。
			 methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一
			// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		
	}
}

main方法执行了。。。

6、反射方法的其它使用之—通过反射运行配置文件内容

public class Student {
    public void show(){
        System.out.println("is show()");
    }
}

配置文件以txt文件为例子（pro.txt）：

className = cn.fanshe.Student
methodName = show

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;
 
/*
 * 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改
 * 我们只需要将新类发送给客户端，并修改配置文件即可
 */
public class Demo {
	public static void main(String[] args) throws Exception {
		//通过反射获取Class对象
		Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
		//2获取show()方法
		Method m = stuClass.getMethod(getValue("methodName"));//show
		//3.调用show()方法
		m.invoke(stuClass.getConstructor().newInstance());
		
	}
	
	//此方法接收一个key，在配置文件中获取相应的value
	public static String getValue(String key) throws IOException{
		Properties pro = new Properties();//获取配置文件的对象
		FileReader in = new FileReader("pro.txt");//获取输入流
		pro.load(in);//将流加载到配置文件对象中
		in.close();
		return pro.getProperty(key);//返回根据key获取的value值
	}
}

is show()

需求：
当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动

7、反射方法的其它使用之—通过反射越过泛型检查
泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的

import java.lang.reflect.Method;
import java.util.ArrayList;
 
/*
 * 通过反射越过泛型检查
 * 
 * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
 */
public class Demo {
	public static void main(String[] args) throws Exception{
		ArrayList<String> strList = new ArrayList<>();
		strList.add("aaa");
		strList.add("bbb");
		
	//	strList.add(100);
		//获取ArrayList的Class对象，反向的调用add()方法，添加数据
		Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
		//获取add()方法
		Method m = listClass.getMethod("add", Object.class);
		//调用add()方法
		m.invoke(strList, 100);
		
		//遍历集合
		for(Object obj : strList){
			System.out.println(obj);
		}
	}
}