文章目录
一. java反射机制
1.1 概述
我记得之前涉及到Class类的地方是进程同步，好像是将类名.class作为同步监视器
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
程序不仅可以获得类的内部信息，还可以直接操作类的属性和方法
编译型语言：需通过编译器（compiler）将源代码编译成机器码，之后才能执行的语言C、C++
解释性语言：程序不需要编译，相比编译型语言省了道工序，解释性语言在运行程序的时候才逐行翻译JavaScript、Python
动态语言：一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是
其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构 JavaScript、Python
静态语言：与动态语言相对应的，运行时结构不可变的语言就是静态语言Java、C、C++
编程语言的分类
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
这个代码示例采用的思路很好，通过比较使用反射前后的变化来说明反射机制的作用
//反射之前，对于Person的操作
@Test
public void test1() {
//1.创建Person类的对象
Person p1 = new Person("Tom", 12);
//2.通过对象，调用其内部的属性、方法
p1.age = 10;
System.out.println(p1.toString());
p1.show();
//在Person类外部，不可以通过Person类的对象调用其内部私有结构。
//比如：name、showNation()以及私有的构造器
}
//反射之后，对于Person的操作
@Test
public void test2() throws Exception{
Class clazz = Person.class;
//1.通过反射，创建Person类的对象
Constructor cons = clazz.getConstructor(String.class,int.class);
Object obj = cons.newInstance("Tom", 12);
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);
Person p1 = (Person) cons1.newInstance("Jerry");
System.out.println(p1);
//调用私有的属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"HanMeimei");
System.out.println(p1);
//调用私有的方法
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
showNation.setAccessible(true);
String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
System.out.println(nation);
}
在最开始学习面向对象就知道，类有五个成员，属性方法构造器内部类代码块。这些属于不同的类的共性。因此设计一个叫做Class的类，从上面来看至少有三个类的成员也被设计为了类，然后将他们的对象作为Class这个类的成员。这三个成员分别是构造器类Constructor，属性类Field，方法类Method。
在这里插入代码片
1.1.1 通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个?
A：绝大多数通过new的方式。反射有非常非常实际的应用场景，如果在编译的时候不知道要创建哪个类的对象，就需要使用反射机制。比如说，网站的注册和登录。后台服务器一直运行，注册的指令过来就造一个注册的对象，登录的指令过来就造一个登录的对象。在编译期间，我们并不知道应该造哪个对象。很神奇啊。
1.1.2 反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术?
A：不矛盾。应该说他们都是为了便于进行开发任务所进行的一种抽象，形成两种抽象的目的是不同的
1.2 理解Class类并获取Class实例
1.2.1 java.lang.Class类
程序编译以后，会生成一个或多个.class字节码文件
接着使用java.exe对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存，这一步叫类的加载
加载到内存中的类，称为运行时类，这个运行时类，就作为Class类的一个实例。相当于加载某个类的时候，这个内存结构也可以被Class引用所指向，所以才有Class c = Person.class; 体现的也就是类也是对象，写在了等号右边
这也就意味着Class引用指向的是同一个内存地址
换句话说，Class的实例就对应着一个运行时类。
加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
1.2.2 获取Class类的实例的四种方式
有四种方式：
//获取Class的实例的方式（前三种方式需要掌握）
@Test
public void test3() throws ClassNotFoundException {
//方式一：调用运行时类的属性：.class
Class clazz1 = Person.class;
System.out.println(clazz1);
//方式二：通过运行时类的对象,调用getClass()。这个方法在Object类方法中声明
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
//方式三：调用Class的静态方法：forName(String classPath).必须说明这个类的具体位置，在那个包下面
Class clazz3 = Class.forName("com.atguigu.java.Person");
// clazz3 = Class.forName("java.lang.String");
System.out.println(clazz3);
System.out.println(clazz1 == clazz2);
System.out.println(clazz1 == clazz3);
//方式四：使用类的加载器：ClassLoader (了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");
System.out.println(clazz4);
System.out.println(clazz1 == clazz4);
}
1.2.3 Class实例对应的结构
呢些类型可以有Class对象：
(1) class:
外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
(2) interface:接口
(3）[]:数组
(4) enum:枚举
(5) annotation:注解@interface
(6) primitive type:基本数据类型
( 7) void：比如说public static void main()
第三条提到了数组，那么对于初始化为不同长度的一维数组，他们的Class对象是否相等呢？
A：只要数组的元素类型与维度一样，就是同一个cLass
1.3 类的加载与ClassLoader的理解
1.3.1 类的加载过程
1.3.2 ClassLoader类加载器
ClassLoader也是一个类：ClassLoader cl = ClassLoaderTest.class.getClassLoader();
类加载的作用:
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存:标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间。不过JvM垃圾回收机制可以回收这些Class对象
1.3.2.1 类加载器的分类
1.3.2.2 使用ClassLoader类（加载器）加载配置文件
Properties类：集合中Map接口的实现类，键值都是String类型的
说道property，从意思上，和field一样，都有属性性质的意思。但是，
（1）field一般是不暴露给外部的，只用作类或对象的内部数据储存只用；而property是需要暴露给外部的，用于控制类或对象的行为的参数；
（2）field一般没有对应的set/get方法，但property必有对应的set/get方法，以便反射时获取或修改property的值。
配置文件可以就是一个.txt文本文件，里边以键值对的形式写入数据，比如user=1234
加载配置文件有两种方式：
（1）使用IO流将配置文件加载到Map接口的实现类Properties类
Properties pros = new Properties();
//此时的文件默认在当前的module下。
//读取配置文件的方式一：
FileInputStream fis = new FileInputStream("jdbc.properties");
FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
pros.load(fis);
使用FileInputStream输入字节流读取文件的话，相对路径的起始位置是在工程
一般来说，工程下面有文件，文件夹，这当中有一个src文件夹。src下面就是一堆package，也可以是文件。如果将package命名为com.atguigu.java那么相当于src里面有个文件夹叫com，com里边有文件夹叫做atguigu，atguigu里面有文件夹叫java
（2）使用ClassLoader（类加载器）类
区别就在于输入流的创建方式，不是用new的方式，而是调用ClassLoader类对象的getResourceAsStream()方法，返回一个字节输入流的实例
//读取配置文件的方式二：使用ClassLoader
//配置文件默认识别为：当前module的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);
文件一般来说是放在src下边，因为项目部署到tomcat服务器之后配置文件就缺失了（？？？）
1.4 创建运行时类的对象（通过反射）
newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
要想此方法正常的创建运行时类的对象，要求：
1.运行时类必须提供空参的构造器
2.空参的构造器的访问权限得够。通常，设置为public。
调用newInstance方法创建对象，在编译期间是没有造对象的，是到程序运行期间才去创建了对象。直觉上好像和我直接new没啥区别啊？？？？？？？？？？？？？？？？？
JavaBean 是一种JAVA语言写成的可重用组件,它是一个类
在javabean中要求提供一个public的空参构造器。原因：
1.便于通过反射，创建运行时类的对象
2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
@Test
public void test1() throws IllegalAccessException, InstantiationException {
Class<Person> clazz = Person.class;
Person obj = clazz.newInstance();
System.out.println(obj);
}
1.4.1 体会反射的动态性
调用newInstance方法创建对象，在编译期间是没有造对象的，是到程序运行期间才去创建了对象。直觉上好像和我直接new没啥区别啊？？？？？？？？？？？？？？？？？
在反射这块，有非常重要的两个步骤：
（1）创建Class类对象，由四种方式，其中三种和运行时类有关，还有一种是调用Class类的静态方法forName(运行时类的位置),严格来说是四种都有关。之所以存在这种绑定，是因为从底层来说Class类对象就和某个运行时类密不可分。Class类也是一个泛型类
（2）创建运行时类对象，Class引用调用newInstance方法
//体会反射的动态性
@Test
public void test2(){
for(int i = 0;i < 100;i++){
int num = new Random().nextInt(3);//0,1,2
String classPath = "";
switch(num){
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.atguigu.java.Person";
break;
}
try {
Object obj = getInstance(classPath);
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/*
创建一个指定类的对象。
classPath:指定类的全类名
*/
public Object getInstance(String classPath) throws Exception {
Class clazz = Class.forName(classPath);
return clazz.newInstance();
}
首先封装了一个方法，用于创建运行时类的对象。创建运行时类的对象之前，需要先对Class类进行实例化，调用forName方法需要一个字符串参数，指明运行时类的位置
为什么在switch-case中去确定这个字符串参数，而不是直接创建不同的Class类对象？？？
A：我直接去尝试了。答案是可以的，这只是写法上的不同。两种方法都会有一些冗余的代码
Object obj = getInstance(num);这是比较典型的多态
@Test
public void test() throws Exception{
for(int i = 0;i< 10;i++){
int num = new Random().nextInt(3);
Object obj = getInstance(num);
System.out.println(obj);
}
}
public Object getInstance(int num) throws Exception{
Class clazz = null;
switch(num){
case 0:
{
clazz = Class.forName("java.util.Date");
break;
}
case 1:
{
clazz = Class.forName("java.lang.Object");
break;
}
case 2:
{
clazz = Class.forName("com.atguigu.java.Person");
break;
}
}
return clazz.newInstance();
}
要注意，在switch-case中Class cla是一个局部变量，在外部是访问不到的。那么可以再switch-case外部先造一个Class cla引用，然后在Switch-case中赋值
1.4.1.1 为什么不直接在switch-case结构中创建不同类型的对象呢？？非要先进行Class类的实例化？？？？？
A:语法上来说没有任何问题，代码上也没有增加。这里还没有看出任何的优势。
前面使用反射来做，始终还是要写出所有的运行时类的地址
这里呢，就是直接完成具体的类的实例化
Object o = null;
switch(num){
case 0:
{
o = new Date();
break;
}
case 1:
{
o = new Object();
break;
}
case 2:
{
o = new Person();
break;
}
}
return o;
为什么上面的例子看起来反射没有用？？？？
A：因为我的评判标准是代码量是否有减少。一方面，我不用反射实现，代码量是差不多的；另一方面，如果我增加类的数量，不管用不用反射，都得增加case的数量。综上看来，我觉得反射就没作用
如果是这样一个场景，不知道具体实例化的是哪一个类，但知道有多少潜在的类，那你不可避免的就需要把每一种情况考虑到。那反射确实就没什么作用
如果是这样一种场景，为了模块化编程，我们甚至将类的实例化这一操作都模块化，就像上面这个例子也是将类的实例化封装到方法中。并且，我们明确知道要实例化的是哪一个类。如果不使用反射，就会是这样：
public static X create1(String name){
if (name.equals("A")) {
return new A();
} else if(name.equals("B")){
return new B();
}
return null;
}
这些类之间也不存在继承关系，只要增加类的数量，那么也必须增加代码
但要是使用反射机制，
public static X create2(String name){
Class<?> class = Class.forName(name);
X x = (X) class.newInstance();
return x;
}
Class类引用可以指向任何一个类加载到方法区中的结构，这个引用可以作为方法区中运行时类的数据的访问入口。这样就不用单独去对每一个类new对象了。但要注意前提，如果不知道实例化哪一个类，比如说要经过一个映射关系才能知道实例化的是哪一个类，那么还是得每种情况都写出来，用不用反射都是一样的
这种感觉有点像多态，父类的引用可以指向子类的实例，虽然不能访问子类特有的结构，但多态的出现并非是为了用父类引用访问子类特有的结构，而是为了访问子类重写的方法（比较具体的说法）
1.4.2 反思总结
就我至此的理解，我还没有感受到反射的作用，至少以上的开发还没有必须用反射不可的地步
当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理
1.5 获取运行时类的完整结构
提供了大量的getXxxx方法以帮助我们获取运行时类的各种结构，包括Field、Method、Constructor、Superclass、Interface、Annotation
1.5.1 获取属性结构
public class FieldTest {
@Test
public void test1(){
Class 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);
}
}
//获取属性的 权限修饰符 数据类型 变量名
@Test
public void test2(){
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
//1.权限修饰符
int modifier = f.getModifiers();//将权限修饰符映射到了整型数据上
System.out.print(Modifier.toString(modifier) + "\t");
//2.数据类型
Class type = f.getType();
System.out.print(type.getName() + "\t");
//3.变量名
String fName = f.getName();
System.out.print(fName);
System.out.println();
}
}
}
要注意，反射并不能拿到一个类的所有属性，要么获取包括继承而来的声明为public的属性，要么获取自己声明的所有属性
（1）getFields():获取当前运行时类及其父类中声明为public访问权限的属性
（2）getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
declare表示声明，宣布
属性的权限修饰符，数据类型，变量名分别对应modifier，type，name
要注意，返回的是什么。调用getModifiers方法，返回的是int，并不是Modifier对象；调用getType方法，返回的是Class对象，还得调用getName方法，才能取出里边的字符串；调用getName方法，返回的是String对象，这就可以直接打印了
1.5.2 获取方法结构
和获取属性类似，有getMethods(), getDeclaredMethods()
要注意，反射并不能拿到一个类的所有方法，要么获取包括继承而来的声明为public的方法，要么获取自己声明的所有方法
方法的内部结构也可以获取，包括注解，权限修饰符，返回值类型，方法名，参数类型，形参名，异常类型，他们对应的是Annotations，Modifiers，ReturnType，Name，ParameterTypes，Parameters，ExceptionTypes
getAnnotations方法，返回Annotation数组
getModifiers方法，返回int，调用toString方法映射一下
getReturnType方法，返回Class对象，调用getName方法
getName方法，返回String对象，直接打印
getParameterTypes方法，返回Class数组，调用getName方法
getParameters方法，返回Parameter数组，调用getName方法
getExceptionTypes方法，返回Class数组，调用getName方法
/*
@Xxxx
权限修饰符 返回值类型 方法名(参数类型1 形参名1,...) throws XxxException{}
*/
@Test
public void test2(){
Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
//1.获取方法声明的注解
Annotation[] annos = m.getAnnotations();
for(Annotation a : annos){
System.out.println(a);
}
//2.权限修饰符
System.out.print(Modifier.toString(m.getModifiers()) + "\t");
//3.返回值类型
System.out.print(m.getReturnType().getName() + "\t");
//4.方法名
System.out.print(m.getName());
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){
System.out.print("throws ");
for(int i = 0;i < exceptionTypes.length;i++){
if(i == exceptionTypes.length - 1){
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.print(exceptionTypes[i].getName() + ",");
}
}
System.out.println();
}
}
1.5.2.1 获取方法形参名
上面的代码没有获取到真实的方法形参名
jdk8之前，我们使用注解的方式获取方法形参名；jdk8支持javac -parameters命令开启参数以获取方法形参名
获取方法形参名
法一：注解元数据标明参数名
目前许多框架使用的方法，如，SpringMVC的参数绑定，MyBatis的参数映射
//自定义@param注解
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Param {
String value();
}
//声明参数名
public void foo(@Param("name") String name, @Param("count") int count){
System.out.println("name:=" + name + ",count=" + count);
}
//获取
Method foo = ParameterDemo.class.getMethod("foo", String.class, int.class);
Annotation[][] parameterAnnotations = foo.getParameterAnnotations();
for (Annotation[] parameterAnnotation : parameterAnnotations) {
for (Annotation annotation : parameterAnnotation) {
if(annotation instanceof Param){
System.out.println(((Param) annotation).value());
}
}
}
//获取结果
name
count
法二：JDK8反射
public void foo(String name, int count){
System.out.println("name:=" + name + ",count=" + count);
}
//通过反射获取
Method foo = ParameterDemo.class.getMethod("foo", String.class, int.class);
Parameter[] parameters = foo.getParameters();
for (Parameter parameter : parameters) {
System.out.println(parameter.getName());
}
//获取结果
name
count
但只有条件，需要在javac编译时开启-parameters参数，而为了兼容性该参数默认是不开启的。所以编译的时候需要使用新的命令：javac -parameters
如果是在IDE环境下，可以设置javac命令
如果是Maven工程的话，可以这样配置，但这个文件是pom还是setting不清楚
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>8</source>
<target>8</target>
<compilerArgs>
<compilerArg>-parameters</compilerArg>
</compilerArgs>
</configuration>
</plugin>
1.5.2.2 获取注解成员变量的值（JVM运行时生成的类$Proxyxxx）
学注解的时候我就特别想知道到底怎么获取注解的值，不知道我浑身难受啊
前面我们调用getAnnotations方法获取了方法的所有注解，注意返回的是一个Annotation数组，Annotation是一个接口，它是不能实例化的，这意味着这里用了多态，实际上应该是接口实现类的对象
其实可以把注解看做是一个被final修饰、继承Annotation的interface
注解的实例化
这个实现类在哪里呢？？？百度之后，是JVM在运行时生成的，名称一般遵循$Proxyxxx的形式
既然实现类不对外暴露，那不知道应该不影响理解和使用
从Annotation数组中取出一个实例，先强转为MyAnnotation类型，然后就可以使用点运算符访问他的成员变量value()
我在最开始写的时候一直访问不到成员变量，我是这么写的
System.out.println((MyAnnotation) a.value());
我估计这是优先级造成的，点运算符的优先级高于强转，加了括号之后就正常了
System.out.println(((MyAnnotation) a).value());
1.5.3 获取构造器
同样两个方法，
getConstructors():获取当前运行时类中声明为public的构造器
getDeclaredConstructors():获取当前运行时类中声明的所有构造器
至于说权限修饰符这些，和上面的获取方法内部结构一样
1.5.4 获取运行时类的父类
父类对应的是Superclass
调用getSuperclass()，返回Class对象
1.5.5 获取运行时类的父类的泛型（JDBC用到了）
带泛型的父类对应的是GenericSuperclass
调用getGenericSuperclass(),返回Type接口实现类对象
public void test3(){
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);
}
1.5.6 获取运行时类带泛型的父类的泛型
就是拿到一个字符串，你看前面，不管是获取父类，还是获取带泛型的父类，返回的都是一个对象
Type是一个接口，实现类就是Class类
ParameterizedType也是一个接口，他继承了Type接口，实现类还是被隐藏了
调用getActualTypeArguments()，获取真实类型参数，也就是泛型，返回的是一个Type数组
所以最后可以吧Type数组中的元素强转为Class类型，然后调用getName方法
public void test4(){
Class 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());
}
1.5.7 获取运行时类的接口，包，注解
接口对应Interface
包对应Package
注解对应Annotations
调用getInterfaces(),返回Class数组，调用getName
调用getPackage(),返回Package对象
调用getAnnotations()，返回Annotation数组
1.6 调用运行时类的指定结构
调用指定结构，你都指定了，就说明你得先知道这个结构是哪一个，我们用字符串来标识不同的结构
1.6.1 调用指定属性
获取属性和获取指定属性在代码层面用单复数来区分
获取属性调用getFields()
获取指定属性调用getField()
同时呢，获取指定属性的范围和上面获取属性的结论一样：
getField方法，获取运行时类及其父类中声明为public的指定属性
getDeclaredField方法，获取运行时类中声明的指定属性
这两个方法都需要传入一个字符串，说明要访问的属性的属性名
get,set属性的时候还需要指明是哪一个对象
public void testField() 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);
}
1.6.1.1 操作声明为非public权限的指定属性
底层规定，默认情况下不能操作非public权限的属性
需要让属性调用setAccessible()方法设置为可操作
同样存在权限问题，声明为非public权限的指定方法不能在反射中被调用，先调用setAccessible方法
public void testField1() 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,"Tom");
System.out.println(name.get(p));
}
1.6.2 调用指定方法
两个get方法都需要传入几个参数：
（1）String类型的方法名
（2）避免重载，传入每个形参的类型的Class对象
比如getMethod(“show”, String.class)
获取到的方法调用invoke方法实现对自己的调用，invoke方法需要传入几个参数：
（1）指明是哪一个对象
（2）传入实参
方法可能有返回值，invoke方法额返回值即为调用invoke的那个方法的返回值
public void testMethod() 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,"CHN"); //String nation = p.show("CHN");
System.out.println(returnValue);
System.out.println("*************如何调用静态方法*****************");
// private static void showDesc()
Method showDesc = clazz.getDeclaredMethod("showDesc");
showDesc.setAccessible(true);
//如果调用的运行时类中的方法没有返回值，则此invoke()返回null
// Object returnVal = showDesc.invoke(null);
Object returnVal = showDesc.invoke(Person.class);
System.out.println(returnVal);//null
}
1.6.2.1 静态方法
非静态方法调用invoke要传对象，那静态传什么呢？？
静态方法一般是类去调用，那就传运行时类的Class对象，比如Person.class
但其实对象也可以调静态方法，所以invoke传入对象也行
再简单一点，写null也行
1.6.3 调用指定构造器
参考调用指定方法
就调用构造器不同，不是调用invoke方法，而是调用newInstance方法
Person per = (Person) constructor.newInstance("Tom");
System.out.println(per);
1.7 反射的应用：动态代理
Spring两大核心：IOC容器（依赖注入），AOP（动态代理）
1.7.1 代理模式（中介）
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上
这不就有点像javaweb那个中央控制器吗，所有的请求都会先到中央控制器，由中央控制器决定调用哪一个控制器来处理请求
又根据代理创建的时间分为静态和动态代理。前者是在编译期就确定代理，后者是在运行时才确定代理
静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能
代理类和被代理类要实现同一套接口，这样实际上就是代理类的方法实现了对被代理类中同名方法的封装
1.7.2 动态代理概述
中央代理类根据被代理类的信息，创建对应的代理类
这确实很像中央控制器和控制器的关系。但是又不准确，代理类和被代理类要实现同一套接口啊。回想起来，反而是控制器和业务层之间的关系更像是代理和被代理，中央控制器充当中央代理类
1.7.3 静态代理示例
可以看到，大量使用多态，代码中的引用全是接口类型的，只能说我还不太适应
我觉得不适应的点在于，后面根本就不知道引用指向的实例到底是什么类型了，总觉得不踏实
代理要能封装被代理类的方法，代理内部就得有被代理类的对象。这部份封装到了代理的构造器中
使用的时候，先实例化被代理类，再实例化代理类，把被代理类的实例传入代理类的构造器
interface ClothFactory{
void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory){
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}
//被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产一批运动服");
}
}
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory nike = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
proxyClothFactory.produceCloth();
}
}
1.7.4 动态代理示例（确实比静态难理解）
不管是动态代理还是静态代理，我们希望呈现的效果都是是由代理类对象调用方法x，而在方法x的方法体调用的是被代理类中的同名方法方法x
因此，测试的代码应该是下面所示。从大的框架上看静态代理和动态代理差不多，但是底层的实现差别很大
//动态代理
//被代理类对象
SuperMan superMan = new SuperMan();
//proxyInstance:代理类的对象
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
//当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
String belief = proxyInstance.getBelief();
//静态代理
//创建被代理类的对象
ClothFactory nike = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
proxyClothFactory.produceCloth();
先造好接口和被代理类
然后就有两个问题：
（1）如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
（2）当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法
1.7.4.1 区别
这里先说说实现上有什么区别，这个差别主要体现在代理类上
（1）代理类不再实现接口
（2）代理类只负责获取一个代理类对象，通过一个静态方法实现
（3）上面的静态方法主要又是通过java.lang.reflect.Proxy类的静态方法newProxyInstance来实现
（4）newProxyInstance方法需要获取被代理类的类加载器，接口，以及一个InvocationHandler实现类对象
（5）上面的InvocationHandler实现类中实现invoke方法，这个invoke方法就是静态代理中代理类的方法x，由这个invoke方法实现对被代理类中同名方法x的调用
（6）上面的InvocationHandler实现类的invoke方法需要的3个参数不需要我们手动传入实参，而是在代理类对象调用自己的方法时就为invoke方法提供了实参，proxyInstance.getBelief()提供了代理类对象，方法，以及方法中的参数列表，而invoke方法需要的就是Object proxy, Method method, Object[] args
（7）上面的InvocationHandler实现类的invoke方法需要使用反射调用被代理类中的方法，因此还需要被代理类对象，于是在InvocationHandler实现类中增加一个bind方法获取被代理类对象
（8）最难以理解的一条就是，当代理类对象去调用方法的时候，实际上是InvocationHandler实现类的对象去调用了自己的invoke方法
大致说明一下执行的流程：
（1）先造一个被代理类对象
（2）调用代理类的静态方法，以被代理类对象为参数
（3）静态方法方法体内部造一个InvocationHandler实现类对象
（4）InvocationHandler实现类对象调用bind方法，以被代理类对象为参数
（5）调用java.lang.reflect.Proxy类的静态方法newProxyInstance，返回一个代理类对象（其实是Object类对象）
（6）将代理类对象强转为接口类型
（7）代理类对象调用接口中的方法
（8）InvocationHandler实现类对象调用invoke方法
最重要的就是java.lang.reflect.Proxy类的静态方法newProxyInstance，我们不知道它是怎么执行的，执行了那些命令
1.7.4.2 newProxyInstance方法的返回值类型（JVM运行时生成的类&Proxyxxx）
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
其中Human是接口，superMan是被代理类
这段代码让我一直想不明白，为什么newProxyInstance方法的返回值可以被强转为接口类型Human？？？？？
我知道newProxyInstance方法的声明返回的是Object实例，我也知道实际返回的一定不是Object实例，Object又不是Human接口的实现类，怎么可能强转呢
于是，我打印了newProxyInstance方法返回值的类型
System.out.println(ProxyFactory.getProxyInstance(superMan).getClass().getName());
然后我就看到了一个熟悉的类，com.atguigu.java.$Proxy0
我在查getAnnotations方法的返回值类型的时候也遇到了，这个方法声明的时候返回的是Annotation数组，但是Annotation是接口，所以一定有一个实现类。这个实现类是在JVM运行时生成的，名称是$Proxyxxx的形式。然后呢，这个类里边有一个handler，他的实际类型是AnnotationInvocationHandler
于是，我猜com.atguigu.java.$Proxy0类应该是实现了Human接口，所以说才能强转为Human类型。com.atguigu.java.$Proxy0里边应该也有handler，不仅实现了Human接口，还实现了Human接口中的方法，当然方法体里边就是handler去调自己的invoke方法
1.7.4.3 调度的依据就是根据被代理类对象的类型，来创建对应的代理类对象
这个时候再回顾这句话感触就比较深了，创建不同的代理类对象实际上是java.lang.reflect.Proxy类的静态方法newProxyInstance来完成的
之所以可以创建不同的代理类对象，是因为传入newProxyInstance方法的参数不同
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
可以说，实现动态代理最核心的一点是使用了java.lang.reflect.Proxy类的静态方法newProxyInstance，其他的结构都是围绕着newProxyInstance方法来构建的
1.7.4.4 Proxy类
引入一个java.lang.reflect包下的Proxy类
Proxy类提供了一个静态方法，顾名思义是new一个代理实例
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
这个方法返回一个Object对象，但是呢极大可能是一个多态
InvocationHandler实例的作用是 当Proxy对象调用自己的方法时，自动就会调用InvocationHandler实现类的invoke方法
1.7.4.5 InvocationHandler接口
引入一个java.lang.reflect包下的InvocationHandler接口
可以看到这个接口声明了一个invoke方法，虽然java.lang.reflect.Method类中也有一个invoke方法，但这两者还是不一样
//来自java.lang.reflect.InvocationHandler接口
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
//来自java.lang.reflect.Method类
public Object invoke(Object obj, Object... args)
1.7.4.6 代理类
引入一个代理类来负责代理类的调度，调度的依据就是根据被代理类对象的类型，来创建对应的代理类对象
InvocationHandler实例的作用是 当Proxy对象调用自己的方法时，自动就会调用InvocationHandler实现类的invoke方法
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);
}
}
1.7.4.7 实现InvocationHandler接口
实现InvocationHandler接口的目的在于：当我们通过代理类的对象，调用方法a时，就会自动的调用这里的invoke()
之所以要有invoke方法，是因为 当Proxy对象调用自己的方法时，自动就会调用InvocationHandler实现类的invoke方法
class MyInvocationHandler implements InvocationHandler{
private Object obj;//需要使用被代理类的对象进行赋值
public void bind(Object obj){
this.obj = obj;
}
//当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
//obj:被代理类的对象
Object returnValue = method.invoke(obj,args);
//上述方法的返回值就作为当前类中的invoke()的返回值。
return returnValue;
}
}
1.7.4.8 Handler句柄
终究还是让我遇上了句柄这个翻译怪，从没见过这么抽象的翻译
本意肯定是一个类似管理者的东西，确保有才能的人知道在何时何地如何去展示
在计算机领域，就是确保资源合适的调度和利用。在操作系统或某些程序和程序语言中，句柄本身可以理解成像指针的一个东西，它指向某些资源（可以是函数，内存等等）
invocation是invoke的名词形式，也可以翻译为调用。也就是说InvocationHandler接口就是定义管理调用的规范
1.8 动态代理与AOP
注解那块讲过一次AOP，当时的理解是AOP就相当于把代码段隐藏到了切面，不会影响业务程序。但这个理解很粗浅，也不涉及具体的实现
实际上AOP就是用动态代理实现的
考虑这样一个需求：
程序中的三个代码段用到了同一段程序，我最多就是把重复的代码封装到一个方法中，提高复用率。但是这会带来耦合的问题，你这三个代码段需要显式地调用这个方法，如果要调用另外一个方法，就得重新编译
最理想的效果是：代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用方法A
1.8.1 被封装的操作不在被代理类的方法中
比如说被代理类有一个方法A，被封装的操作被封装在工具类的方法B中，如果不是在方法A的方法体内部调用方法B，那么很简单，就在InvocationHandler接口的实现类的invoke函数里边写逻辑即可
1.8.2 在被代理类的方法中调用被封装的操作
这种情况则要麻烦许多，被代理类的方法A内部要执行工具类的方法B，同时又不能显式地调用方法B，那就得用反射，得在方法A的内部加入获取工具类中指定方法的反射代码
我最开始写的代码只能实现获取无参的指定方法，后面修改了.properties配置文件的内容，终于可以实现获取任意指定方法
获取指定方法并实现对这个方法的调用需要我们提供以下几个结构：
（1）方法名，比如说字符串show
（2）参数类型的Class实例，比如说String.class
（3）工具类对象
（4）实参
通过之前的学习我们知道，要获取一个指定的方法，其代码为
class Util{public void show(String a, Integer b){}}
Class clazz = Util.class;
Method m = clazz.getDeclaredMethod("show", String.class,Integer.class)
字符串"show"我打算直接放在配置文件中，为了获取类的Class对象，我先在配置文件中以字符串的形式记录类的位置，比如
method1=util3
//使用空格隔开，为了之后调用String类的静态方法split()
fieldType1=java.lang.String java.lang.Integer java.lang.Double
然后调用Class类的静态方法forName()获得对应的Class对象
Class clazz = Class.forName("java.lang.String");
这样一来我们就能得到指定方法，下面代码中的字符串部分我们都是在配置文件中获取到的
Method m = clazz.getDeclaredMethod("show", Class.forName("java.lang.String"),Class.forName("java.lang.Integer"))
最后就可以准备好实参数组，调用前面获取到的指定方法
public void show(){
System.out.println("i can run");
try {
//为后面调用工具类中的指定方法做准备
CarUtil carUtil = new CarUtil();
//获取工具类的Class对象，为后面获取工具类中的指定方法做准备
Class clazz = CarUtil.class;
//读取配置文件
InputStream is = ClassLoader.getSystemClassLoader().getSystemResourceAsStream("Benz.properties");
Properties properties = new Properties();
properties.load(is);
//获取指定方法的所有参数的类型对应的Class对象
//要考虑到方法没有参数的情况，此时Properties调用getProperty方法就什么都拿不到
Class[] classes = null;
if(!(properties.getProperty("fieldType1").length() == 0)) {
//调用split方法，以空格为分隔符切分字符串，比如"java.lang.String java.lang.Integer java.lang.Double"
String[] fieldTpye = properties.getProperty("fieldType1").split(" ");
//如果方法有参数，我们才实例化Class数组
classes = new Class[fieldTpye.length];
//通过循环获取方法的所有参数的类型对应的Class对象
for (int i = 0; i < fieldTpye.length; i++) {
classes[i] = Class.forName(fieldTpye[i]);
}
}
//获取指定方法
Method method = clazz.getDeclaredMethod(properties.getProperty("method1"), classes);
//获取实参数组这里我们是直接给定实参，但在实际应用中，实参由这一块反射代码之前的代码提供
Object[] actualParameter = {"我爱你", 10, 3.1415926};
//调用前面获取到的指定方法
method.invoke(carUtil,actualParameter);
} catch (Exception e) {
throw new RuntimeException("show方法中配置文件错误");
}
要在被代理类中的
1.9 JVM运行时生成的类
getAnnotations方法：JVM生成Annotation接口的实现类$Proxyxxx
newProxyInstance方法：JVM生成自定义接口的实现类$Proxyxxx
感觉要跟接口有关才会让JVM在运行时生成类，像getMethod方法，因为Method是类，所以直接就返回Method实例
java注解
前言
之前学习注解的时候我都是直接跳过了，感觉上没什么用
但是学习了java web之后，我发现注解有实际的应用，而在框架，注解的使用则更为深入，可以说，框架和注解是分不开的关系
我在百度的时候，有一位经验丰富的程序员有这样一段论述：
注解从一定程度上分担了xml配置的一些任务（配套的标准如：JPA）。甚至可以在项目中用纯注解来配置
几乎所有的主流框架（除了struts1）都有自己的一套注解。追溯注解的源头，我个人认为，注解的前身就是我们看到的注释文档。标准的注释文档中有包括@author等的标注
我们可以用注解配置对象。这个是xml文件无法做到的。而注解配置对象，不再需要程序员手动编写大量重复的配置代码，代码多了，也容易出错
比如说java web中配置servlet
使用注解之前，需要在web.xml配置文件中配置servlet和servlet mapping标签
以servlet-name为纽带将servlet-class和url映射起来
<servlet>
<servlet-name>Demo01Servlet</servlet-name>
<servlet-class>com.atguigu.servlets.Demo01Servlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Demo01Servlet</servlet-name>
<url-pattern>/demo01</url-pattern>
</servlet-mapping>
使用注解之后，我们直接在servlet上面加上注解
@WebServlet("/demo01")
public class Demo01Servlet extends ViewBaseServlet {
因为注解的易配置性和强灵活性，还有对代码的执行并不产生影响。注解得到了广泛的应用。现在，新的项目开发都开始倾向于注解这种新的开发方式，在开发的效率和纠错性上面。他已经远远优于xml配置
概述
从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是
Annotation(注解)
注解可以在编译, 类加载, 运行时被读取, 并执行相应的处理
注解相当于在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署
Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明。在java web中，只看到了注解修饰servlet类
在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等
框架 = 注解 + 反射 + 设计模式
应用程序的切面（AOP）
切面这个词涉及到另一个概念AOP，aspects oriented programming，面向切面编程
程序的切面？？？非常抽象
可以这样讲：程序是命令的集合。平时我们练习的时候，我们可以在程序中的任何位置增加命令，比如说加个打印啊，测试运行时长啊
但是，如果这个程序是业务程序，我们是不能随意增加命令的，这会导致业务逻辑被污染，写过的都知道业务逻辑被污染的后果。这个时候我们希望这些与业务逻辑无关的命令不要出现在业务程序中，这些命令会被执行，但在业务程序里边你看不到他们
此时，为了描述这些与业务逻辑无关的命令的位置，产生了一个术语，切面，把与业务逻辑无关的命令逻辑上的位置叫做切面
业务程序中的两条命令中间看起来没有其他命令了，我们以为切开他们什么都没有，但是内有乾坤，切开之后他是一个面，这个面隐藏着一些命令
AOP，把增加的命令隐藏到切面当中
可以这样对比一下，这两段代码结构上差不多，但执行结果一样吗？
public void testAopDemo1() {
AopDemo aopDemo = new AopDemo();
aopDemo.eat();
aopDemo.work();
aopDemo.sleep();
}
public void testAopDemo2() {
IAopDemo aopDemo = (IAopDemo) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{IAopDemo.class}, new AopDemoHandle());
aopDemo.eat();
aopDemo.work();
aopDemo.sleep();
}
示例
示例一：生成文档相关的注解
示例二：在编译时进行格式检查(JDK内置的三个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告
示例三：跟踪代码依赖性，实现替代配置文件功能。也就是在servlet类那个地方加的@WebServlet(“/fruit.do”)注解
前面也说了，注解在编译, 类加载, 运行时被读取, 并执行相应的处理。像@override注解，他就是在编译的时候就进行检查，检查修饰的方法是否是重写的父类的方法
@deprecated，强烈反对
自定义注解
public @interface MyAnnotation {
String value();
}
这个@interface和接口那个interface关键字没有任何关系
自动继承了java.lang.annotation.Annotation接口，也就是说注解可以继承接口？？反直觉
比较反直觉的是注解的成员变量，以无参数方法的形式来声明String value();这看着太奇葩了，方法名可以作为实参传递这我知道，但是String value();这种形式确实很反直觉
方法名和返回值定义了该成员的名字和类型，value()定义了成员变量名，String[]定义了成员变量的类型。这被称之为配置参数
类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组
到这里我们就已经可以使用上面的自定义注解去修饰类了
@MyAnnotation(value="hello")
class Person{}
使用注解的时候对成员变量赋值。只是说这种语法确实很反直觉
我们还可以指定value的默认值
public @interface MyAnnotation {
String value() default "hello";
}
注解可以没有成员变量，比如说@override注解，那么这个注解只起一个标识作用
@WebServlet注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WebServlet {
String name() default "";
String[] value() default {};
String[] urlPatterns() default {};
int loadOnStartup() default -1;
WebInitParam[] initParams() default {};
boolean asyncSupported() default false;
String smallIcon() default "";
String largeIcon() default "";
String description() default "";
String displayName() default "";
}
注解的作用
前面我们给value赋值了，那总不是无缘无故去赋值吧
从之后java web中使用注解的经验来看，注解中的赋值就是给他修饰的结构加了一个标识，标识是要拿来对比的，因此需要外部传入一个参数，用这个参数和标识对比，如果比对成功，就说明要调用注解修饰的结构
这就像是if这种结构
字符串的作用（反射）
在java web中我有一个印象深刻的场景，就是当时要根据不同的情况选择调用不同的方法
这个不同的情况是用一个字符串来实现，根据字符串的值选择不同的方法。这个字符串是从外部传入的
采用switch case来实现这个需求，case的一系列值就很像标识，外部传入的字符串和这些标识作比较，比对成功，就调用对应的方法
switch case结构的缺点也很明显，有多少个方法，我们就得加同样数量的case标识，这显然会使代码十分臃肿
回顾switch case结构，我们的case标识并不是乱写的，他往往和对应的方法名一样，比如有一个add方法，那标识就是字符串add
但是方法名你能取到吗？？把方法名以字符串的形式取出来？？？
反射机制做得到。利用反射机制将类中的所有方法名以字符串的形式取出来，我们就不需要手动去写这些标识。然后，让外部传入的字符串和标识去比对
反射的一大作用就是把类名，属性名，方法名都以字符串的形式取出来，满足了视情况使用类，属性，方法的需求
自定义注解必须配上注解的信息处理流程(使用反射)才有意义
使用反射获取注解中携带的信息：
Class clazz = Student.class;
Annotation[] annotations = clazz.getAnnotations();
for(int i = 0;i < annotations.length;i++){
System.out.println(annotations[i]);
}
打印：@com.atguigu.java.MyAnnotation(value=“ji”)
看起来并没有取出里边的信息，因为这里是Annotation实例调用了Object类中的toString方法
现在还得从Annotation实例中把信息取出来，他只有一个属性String value()，但是.value()编译都过不了
我们的注解是：@MyAnnotation(value=“ji”)
交互
仔细想想，交互要传递信息，而绝大多数情况，这个信息绝大多数情况就是以字符串的形式存在，这就倒逼我们必须围绕这一点来编写程序
比如说java web，前端点一下，请求中就带着字符串，根据这个字符串，我们会选择调用什么结构来处理请求
JDK中的四种元注解
元注解，meta annotation，用来修饰注解的注解
Retention：保持，维持
Target
Documented：记录，记载
Inherited：继承
自定义注解一般会用Retention注解指定注解的生命周期，用Target注解指定注解可以修饰的结构
@Retention注解
用于指定该 Annotation 的生命周期, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用@Rentention 时必须为该 value 成员变量指定值:
RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释
RetentionPolicy.CLASS:在class文件中有效（即class保留） ， 当运行 Java 程序时, JVM 不会保留注解。 这是默认值
RetentionPolicy.RUNTIME:在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会保留注释。程序可以通过反射获取该注释
Retention声明，那么Retention注解的使用应该是@Retention(value=“”),并不是，而是@Retention(value=Retention.SOURCE),或者省略为@Retention(Retention.SOURCE)
public @interface Retention {
RetentionPolicy value();
}
RetentionPolicy是一个枚举类
public enum RetentionPolicy {
SOURCE,
CLASS,
RUNTIME
}
@Target注解
用于指定被修饰的 Annotation 能用于
修饰哪些程序元素
Target 也包含一个名为 value 的成员变量，ElementType和前面的RetentionPolicy一样，都是枚举类
public @interface Target {
ElementType[] value();
}
public enum ElementType {
TYPE,
FIELD,
METHOD,
PARAMETER,
CONSTRUCTOR,
LOCAL_VARIABLE,
ANNOTATION_TYPE,
PACKAGE,
TYPE_PARAMETER,
TYPE_USE
}
@Documented注解
指定被该元 Annotation 修饰的 Annotation 类将被javadoc 工具提取成文档。默认情况下，javadoc是不包括注解的
定义为Documented的注解必须设置Retention值为RUNTIME
@Inherited注解
被它修饰的 Annotation 将具有继承性。如果某个类使用了被
@Inherited 修饰的 Annotation, 则其子类将自动具有该注解
元数据
比如说String name = “hello”，“hello”就是数据，String和name都是元数据
元数据，修饰数据的数据
我们会在JDBC部分遇到，当我们从结果集中取数据的时候，要先拿元数据
JDK8中的注解新特性
可重复注解
有这样一个需求，传递两个注解信息，
直接这样写肯定是不行的
@MyAnnotation(value="hi")
@MyAnnotation("abc")
class Person{}
在支持可重复注解之前
需要用另外一个注解来包裹注解
public @interface MyAnnotations{
MyAnnotation[] value();
}
public @interface MyAnnotation {
String value() default "hello";
}
@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
注意区分这种写法：
public @interface MyAnnotation{
String[] value();
}
@MyAnnotation({"hi","world"})
支持可重复注解以后
引入一个新的元注解@Repeatable
public @interface Repeatable {
Class<? extends Annotation> value();
}
@Repeatable(MyAnnotations.class)//将内外层注解关联起来
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {
String value() default "hello";
}
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
MyAnnotation[] value();
}
//经过前面的配置，就支持直接这样重叠了
@MyAnnotation(value="hi")
@MyAnnotation("abc")
class Person{}
注意，外层的注解和内层的注解要保持和Retention，Target，Inherited一致
类型注解
在Java 8之前，注解只能是在声明的地方所使用，Java8开始，注解可以应用在任何地方
在Target注解的ElementType枚举类里边有TYPE_PARAMETER,TYPE_USE
TYPE_PARAMETER
表示该注解能写在类型变量的声明语句中（如：泛型声明）
class Generic<@MyAnnotation T>{}
TYPE_USE
表示该注解能写在使用类型的任何语句中
异常类型的前边，基本数据类型的前边，引用数据类型的前边
class Generic<@MyAnnotation T>{
public void show() throws @MyAnnotation RuntimeException{
ArrayList<@MyAnnotation String> list = new ArrayList<>();
int num = (@MyAnnotation int) 10L;
}
}
2021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
