JAVA注解与反射
一:注解（java.Annotation）
1、注解入门：
1、什么是注解
1）、annotation是从jdk5开始引入的技术
2）、作用：不是程序本身，可以对程序作出解释；可以被其他程序（如：编译器等）读取（通过反射读取）
3）、格式：以“@注释名”在代码中存在，还可以添加一些参数
4）、使用场景：可以附加在package、class、method、filed等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对元数据的访问
2、内置注解
1）、@Overried：重写超类的方法
2）、@Deprecate: 定义在java.lang.Deprecate中，此注释可以修饰方法、属性、类，表示不建议程序员使用这样的元素，通常是因为它很危险或者有更好的选择；
3）、@SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息。这个注释需要添加参数才能正常使用，这些参数已经定义好了；
@SuppressWarnings("all"); @SuppressWarnings("unchecked"); @SuppressWarnings(value={"unchecked","deprecation"}); 等
3、元注解
1）、作用：负责注解其他注解，java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型做说明；
2）、这些类型和他们所支持的类在java.lang.annotation包中可以找到（@Target,@Retention,@Documented,@Inherited）:
a)、@Target ：用于描述注解的使用范围（即：被描述对的注解可以用在什么地方）；
b)、@Retntion：表示需要在什么级别保存该注释信息，用于描述注解的生命周期
c)、@Document：说明该注解将被包含在javadoc中
d)、@Inherited：说明子类可以继承父类中的该注解
4、自定义注解
使用@interface自定义注解的时候，自动继承了java.lang.annotation.Annotation接口
1）、@interface用来声明一个注解，格式：public @interface 注解名{定义内容}；
2）、其中每一个方法实际上都是声明了一个配置参数；
3）、方法的名称就是参数的名称；
4）、返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）；
5）、可以使用defaule来声明参数的默认值；
6）、如果只有一个参数成员，一般参数名称为value；
7）、注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值。
/**
* @auto xxx
* @since 2020/06/05
* @dec 测试元注解；自定义注解
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
@MyAnnotation1
public class YuanzhujieTest {
//@MyAnnotation：注解在下面定义了只能定义在方法上
@MyAnnotation
// @MyAnnotation1:可以定义在方法上和类上
@MyAnnotation1
public void test(){}
@MyAnnotation2(age=10)
public void test1(){}
}
//定义一个注解
/**
* @Targe：用于描述注解使用的范围;
* ElementType：是一个枚举：METHOD:代表这个注解能使用在方法上；
* @Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期
* RetentionPolicy是一个枚举：
* SOURCE：表示这个注解在源码的时候有效
* CLASS： 表示这个注解在class的时候有效
* RUNTIME：表示这个自定义注解在运行时有作用
* RUNTIME>CLASS>SORUCE: 在runtime中有效的时候在class和source中一定有效
* @Document：表示是否将注解生成在javadoc中
* @Inherited：表示子类可以继承父类的注解
*/
@Documented
@Inherited
@Target(value = ElementType.METHOD)
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation{
}
/**
* Target的value是一个数组，可以放多个参数类型
* ElementType：TYPE:代表这个注解可以定义在类上
*/
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@interface MyAnnotation1{
}
/**
* 自定义注解
*/
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
//注解的参数: 格式： 参数类型 + 参数名();
//default "" :name这个参数默认为"";如果参数没有默认值，我们就必须要给注解赋值的
String name() default "";
int age();
int id() default -1;//如果默认值为-1，就代表不存在
String[] schools() default {"北大","清华"};
}二、反射（java.Reflection）
1、java发射机制概述
Reflection(发射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性以及方法。
Class c = Class.forName("java.lang.String")加载完类之后，在堆内存的方法区中就产生了一个Class类型的对像（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对像看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
java反射机制提供的功能：
1）、在运行时判断任意一个对象所属的类
2）、在运行时构造任意一个类的对象
3）、在运行时判断任意一个类所具有的成员变量和方法
4）、在运行时获取泛型信息
5）、在运行时调用任意一个对象的成员变量和方法
6）、在运行时处理注解
7）、生产动态代理等
Java反射的优点和缺点
优点：可以实现动态创建对象和编译，体现出很大的灵活性
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
@Test
public void test() throws ClassNotFoundException {
//通过反射获取类的class对象
Class cla = Class.forName("com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser");
System.out.println(cla);
log.debug("获取WellLoginUser对象："+cla);
Class cla1 = Class.forName("com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser");
//判断一个类在内存中只有一个Class对象：判断cla和cla1的hashCode是否相同，相同代表是同一个对象
//一个类加载后，类的整个结构都会被封装在class对象中
System.out.println(cla.hashCode());
System.out.println(cla1.hashCode());
}
}class com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser
1871259950
18712599502、理解Class类并获取Class实例
Class类
在Object类中定义了一下的方法，此方法被所有子类继承
public final Class getClass()上面方法的返回值的类型是一个Class类，此类是Java反射的源头，实际上所有反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称
1）、Class本身也是一个类
2）、Class对象只能由系统创建对象
3）、一个加载的类在JVM中只会有一个Class实例
4）、一个Class对象对应的是一个加载到JVM中的一个.class文件
5）、每个类的实例都会记得自己是由哪个Class实例所生产
6）、通过Class可以完整的得到一个类中的所有被加载的结构
7）、Class类是Reflection的根源，针对任何想动态加载，运行的类，唯有先获取相应的Class对象
Class类的常用方法
获取Class类的实例
1）、若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
Class cla = WellLoginUser.class;2）、已知某个类的实例，调用该实例的getClass()方法获取Class对象
Class cla = WellLoginUser.getClass();3）、已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
Class cla = Class.forName("com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser");4）、内置基本数据类型可以直接用类名.Type
5）、还可以利用ClassLoder
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
//测试Class类的创建方式
@Test
public void test01() throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是："+person.name);
//方式一：通过对象获得
Class cl1 = person.getClass();
//方法二：forname获得
Class cl2 = Class.forName("com.example.springBoot_mybatisPlus.Student");
//方式三：通过类名.class获得
Class cl3 = Student.class;
//判断两种获取class对象的hashCode值是否相同
System.out.println(cl1.hashCode());
System.out.println(cl2.hashCode());
System.out.println(cl3.hashCode());
//方法四：基本内置类型的包装类都有一个Type属性
Class cl4 = Integer.TYPE;
System.out.println(cl4);
//获得父类类型
Class cl5 = cl3.getSuperclass();
System.out.println(cl5);
//只有元素类型与维度一样，就是同一个Class
Person person1 = new Student();
System.out.println(person.getClass().hashCode());
System.out.println(person1.getClass().hashCode());
}
}
class Person{
public String name;
public Person(){};
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
'}';
}
}
class Student extends Person{
public Student(){
this.name = "学生";
}
}
class Teacher extends Person{
public Teacher(){
this.name = "老师";
}
}这个人是：学生
1972628089
1972628089
1972628089
int
class com.example.springBoot_mybatisPlus.Person
1268786037
1268786037哪些类型可以有Class对象
1）、class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类。
2）、interface：接口
3）、[]：数组
4）、enum：枚举
5）、annotation：注解@interface
6）、primitive type ：基本数据类型
7）、void
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.lang.annotation.ElementType;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
//所有类型的class
@Test
public void test02(){
//类
Class c1 = Object.class;
//Comparable是一个接口
Class c2 = Comparable.class;
//一维数组
Class c3 = String[].class;
//二维数组
Class c4 = int[][].class;
//注解类型
Class c5 = Override.class;
//枚举
Class c6 = ElementType.class;
//基本数据类型
Class c7 = Integer.class;
//void
Class c8 = void.class;
//Class
Class c9 = Class.class;
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
System.out.println(c5);
System.out.println(c6);
System.out.println(c7);
System.out.println(c8);
System.out.println(c9);
//数组长度不一样的话，如果是同一类型的数组，是否是同一个class对象
int[] a = new int[10];
int[] b = new int[100];
//输出结果是两个class对象的hashCode值相同，所以同一个类型只有一个class对象
//只有元素类型与维度一样，就是同一个Class
System.out.println(a.getClass().hashCode());
System.out.println(b.getClass().hashCode());
}
}class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[I
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class
226170135
2261701353、类的加载与ClassLoader
Java内存分析
类的加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过下面三个步骤对该类进行初始化：
1）、加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。
2）、链接：将Java类的二进制代码合并到JVM的运行状态之中的过程：
a）、验证：确保加载的类信息符合JVM规范，没有安全方面的问题
b）、准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
c）、解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
3）、初始化：
a）、执行类构造器
b）、当初始化一个类的时候如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
c）、虚拟机会保证一个类的
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.lang.annotation.ElementType;
/**
* @author xxx
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
//类的加载过程
@Test
public void test03(){
A a = new A();
System.out.println(A.m);
/**
* 加载过程
* 1、首先加载到内存，会生成一个class对象
* 2、链接，链接结束后 m=0
* 3、初始化
* (){
* System.out.println("A类静态代码块初始化");
* m = 300;
* m = 100;
* }
* 4、初始化结束，输出的值为m=100.
*/
}
}
class A{
static {
System.out.println("A类静态代码块初始化");
m = 300;
}
static int m = 100;
public A(){
System.out.println("A类的无参构造初始化");
}
} A类静态代码块初始化
A类的无参构造初始化
100什么时候会发生类的初始化
1、类的主动引用（一定会发生类的初始化）
1）、当虚拟机启动，先初始化main方法所在的类
2）、new一个类的对象
3）、调用类的静态成员（除final常量）和静态方法
4）、使用java.lang.reflect包的方法对类进行反射调用
5）、当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类
2、类的被动引用（不会发生类初始化）
1）、当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
2）、通过数组定义类的引用，不会触发此类的初始化
3）、引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.lang.annotation.ElementType;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
//测试类什么时候会初始化
@Test
public void test04() throws ClassNotFoundException {
//1、主动引用
//new一个类的对象
Son son = new Son();
System.out.println("=============================");
}
@Test
public void test05() throws ClassNotFoundException {
//1、主动引用
//反射也会产生主动引用
Class.forName("com.example.springBoot_mybatisPlus.Son");
System.out.println("=============================");
//2、被动引用：不会产生类的引用的方法
//当通过子类引用父类的静态变量，不会导致子类初始化。
System.out.println(Son.b);
System.out.println("=============================");
//通过数组定义类的引用，不会触发此类的初始化
System.out.println("通过数组定义类的引用，不会触发此类的初始化");
Son[] array = new Son[5];
System.out.println("=============================");
//引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
System.out.println("引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）");
System.out.println(Son.a);
}
}
class Father{
static int b = 2;
static {
System.out.println("父类被加载");
}
}
class Son extends Father{
static {
System.out.println("子类被加载");
m = 300;
}
static int m =100;
static final int a =1;//定义一个常量
}//test04的执行结果
父类被加载
子类被加载
=============================//test05的执行结果
父类被加载
子类被加载
=============================
2
=============================
通过数组定义类的引用，不会触发此类的初始化
=============================
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
1类加载器的作用
1）、类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
2）、类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些class对象。
类加载器作用是把类（class）装载进内存。JVM规范定义了如下类型的类加载器：
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.lang.annotation.ElementType;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
@Test
public void test06() throws ClassNotFoundException {
//获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
//获取系统类加载器的父类加载器-->扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
//获取扩展类加载器的父类加载器-->根加载器（是有c/c++编写的）
ClassLoader parent1 = parent.getParent();
//由于根加载器是由c/c++编写的，该加载器无法直接获取，所以输出的应该为null
System.out.println(parent1);
//测试当前类是由哪个加载器加载的
ClassLoader classLoader = Class.forName("com.example.springBoot_mybatisPlus.fansheTest").getClassLoader();
System.out.println(classLoader);
//测试JDK内置类是由哪个加载器加载的
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classLoader);
//如何获的系统类加载器可以加载的路径
System.getProperty("java.class.path");
//双亲委派机制：自己定义的一个类，首先会在系统加载器中查找有没有这个类，如果没有，就去
//扩展类加载器中找，如果没有的话就去根加载器中找，无论在哪个加载器中找到和你自定义的类相同的类，那么你自定义的类就无法发挥作用
//作用：多重检测，保证安全性
}
}sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@6659c656
null
sun.misc.Launcher$AppClassLoader@18b4aac2
null
4、创建运行时类的对象
获取运行时类的完整结构
通过反射获取运行时类的完整结构：Field（字段）、Method（方法）、Constructor（构造器）、Superclass（父类）、Interface（接口）、Annotation（注解）。。。
package com.example.springBoot_mybatisPlus;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
//获得类的信息
@Test
public void test07() throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
//获取类的class对象
Class cl = Class.forName("com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser");
//获得类的名称：获得包名 + 类名
System.out.println("==获得类的名称：获得包名 + 类名===========================================");
System.out.println(cl.getName());
//获得类的简单名称：获得类名
System.out.println("==获得类的简单名称：获得类名===========================================");
System.out.println(cl.getSimpleName());
//获得类的属性
System.out.println("==获得类public的属性===========================================");
Field[] fields = cl.getFields(); //只能找到public属性
Arrays.asList(fields).stream().forEach(z -> System.out.println(z));
System.out.println("==获得类的全部属性===========================================");
fields = cl.getDeclaredFields(); //找到全部的属性
Arrays.asList(fields).stream().forEach(z -> System.out.println(z));
//获得指定属性的值
System.out.println("==获得指定属性的值===========================================");
System.out.println(cl.getDeclaredField("status"));
//获得类的方法
//获得本类及其父类的全部public方法
System.out.println("==获得本类及其父类的全部public方法：getMethods===========================================");
Method[] methods = cl.getMethods();
Arrays.asList(methods).stream().forEach(method -> System.out.println("正常的："+method));
//获取本类的所有方法
System.out.println("==获取本类的所有方法：getDeclaredMethods===========================================");
methods = cl.getDeclaredMethods();
Arrays.asList(methods).stream().forEach(method -> System.out.println("getDeclaredMethods："+method));
//获得类的指定方法（如果指定方法由参数，则需要指定参数）
System.out.println("==获得类的指定方法===========================================");
Method setName = cl.getMethod("setUserName", String.class);
Method getName = cl.getMethod("getUserName",null);
System.out.println(setName);
System.out.println(getName);
//获得构造器
System.out.println("==获得构造器:getConstructors===========================================");
Constructor[] constructors = cl.getConstructors();//获得public
Arrays.asList(constructors).stream().forEach(constructor -> System.out.println(constructor));
System.out.println("==获得构造器:getDeclaredConstructors===========================================");
constructors = cl.getDeclaredConstructors();//获得全部构造器
Arrays.asList(constructors).stream().forEach(constructor -> System.out.println(constructor));
}
}==获得类的名称：获得包名 + 类名===========================================
com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser
==获得类的简单名称：获得类名===========================================
WellLoginUser
==获得类public的属性===========================================
==获得类的全部属性===========================================
private static final long com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.serialVersionUID
private java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.id
private java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.userName
private java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.password
private java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.sex
private java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.email
private java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.phone
private java.time.LocalDate com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.createTime
private java.time.LocalDate com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.updateTime
private java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.status
==获得指定属性的值===========================================
private java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.status
==获得本类及其父类的全部public方法：getMethods===========================================
正常的：public boolean com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.equals(java.lang.Object)
正常的：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.toString()
正常的：public int com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.hashCode()
正常的：public java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getId()
正常的：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getPassword()
正常的：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getUserName()
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setUserName(java.lang.String)
正常的：public static com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser$WellLoginUserBuilder com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.builder()
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setId(java.lang.Integer)
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setStatus(java.lang.Integer)
正常的：public java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getStatus()
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setPassword(java.lang.String)
正常的：public java.time.LocalDate com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getCreateTime()
正常的：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getEmail()
正常的：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getSex()
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setCreateTime(java.time.LocalDate)
正常的：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getPhone()
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setSex(java.lang.String)
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setEmail(java.lang.String)
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setPhone(java.lang.String)
正常的：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setUpdateTime(java.time.LocalDate)
正常的：public java.time.LocalDate com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getUpdateTime()
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.update(com.baomidou.mybatisplus.core.conditions.Wrapper)
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.delete(com.baomidou.mybatisplus.core.conditions.Wrapper)
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.insert()
正常的：public com.baomidou.mybatisplus.extension.toolkit.SqlRunner com.baomidou.mybatisplus.extension.activerecord.Model.sql()
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.deleteById(java.io.Serializable)
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.deleteById()
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.updateById()
正常的：public com.baomidou.mybatisplus.core.metadata.IPage com.baomidou.mybatisplus.extension.activerecord.Model.selectPage(com.baomidou.mybatisplus.core.metadata.IPage,com.baomidou.mybatisplus.core.conditions.Wrapper)
正常的：public java.util.List com.baomidou.mybatisplus.extension.activerecord.Model.selectList(com.baomidou.mybatisplus.core.conditions.Wrapper)
正常的：public com.baomidou.mybatisplus.extension.activerecord.Model com.baomidou.mybatisplus.extension.activerecord.Model.selectById()
正常的：public com.baomidou.mybatisplus.extension.activerecord.Model com.baomidou.mybatisplus.extension.activerecord.Model.selectById(java.io.Serializable)
正常的：public com.baomidou.mybatisplus.extension.activerecord.Model com.baomidou.mybatisplus.extension.activerecord.Model.selectOne(com.baomidou.mybatisplus.core.conditions.Wrapper)
正常的：public java.lang.Integer com.baomidou.mybatisplus.extension.activerecord.Model.selectCount(com.baomidou.mybatisplus.core.conditions.Wrapper)
正常的：public boolean com.baomidou.mybatisplus.extension.activerecord.Model.insertOrUpdate()
正常的：public java.util.List com.baomidou.mybatisplus.extension.activerecord.Model.selectAll()
正常的：public final void java.lang.Object.wait() throws java.lang.InterruptedException
正常的：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 native java.lang.Class java.lang.Object.getClass()
正常的：public final native void java.lang.Object.notify()
正常的：public final native void java.lang.Object.notifyAll()
==获取本类的所有方法：getDeclaredMethods===========================================
getDeclaredMethods：public boolean com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.equals(java.lang.Object)
getDeclaredMethods：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.toString()
getDeclaredMethods：public int com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.hashCode()
getDeclaredMethods：public java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getId()
getDeclaredMethods：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getPassword()
getDeclaredMethods：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getUserName()
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setUserName(java.lang.String)
getDeclaredMethods：public static com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser$WellLoginUserBuilder com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.builder()
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setId(java.lang.Integer)
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setStatus(java.lang.Integer)
getDeclaredMethods：public java.lang.Integer com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getStatus()
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setPassword(java.lang.String)
getDeclaredMethods：protected boolean com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.canEqual(java.lang.Object)
getDeclaredMethods：public java.time.LocalDate com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getCreateTime()
getDeclaredMethods：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getEmail()
getDeclaredMethods：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getSex()
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setCreateTime(java.time.LocalDate)
getDeclaredMethods：public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getPhone()
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setSex(java.lang.String)
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setEmail(java.lang.String)
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setPhone(java.lang.String)
getDeclaredMethods：public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setUpdateTime(java.time.LocalDate)
getDeclaredMethods：public java.time.LocalDate com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getUpdateTime()
==获得类的指定方法===========================================
public com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.setUserName(java.lang.String)
public java.lang.String com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser.getUserName()
==获得构造器:getConstructors===========================================
==获得构造器:getDeclaredConstructors===========================================
com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser(java.lang.Integer,java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.lang.String,java.time.LocalDate,java.time.LocalDate,java.lang.Integer)
class对象的作用：
1）、通过class类的getDeclaredConstructor(Class ... parameterTypes)取得本类的指定形参类型的构造器
2）、像构造器的形参传递一个对象数组进去，里面包含了构造器所需的各个参数
3）、通过Construtor实例化对象
4）、调用指定的方法：通过反射调用类中的方法。通过Class类的getMethod(String name,Class ... parameterTypes)方法取得一个Method对象，并设置此方法操作时需要的参数类型；之后使用Object invoke(Object obj,Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
Object invoke(Object obj,Object[] args)：
a）、Object对应原方法的返回值，若原方法无返回值，此时返回null
b）、若原方法为静态方法，此时形参Object obj可为null
c）、若原方法形参列表为空，则Object[] args为null
d）、若原方法声明为private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
setAccessible：
1）、Method、Field、Constructor对象都有setAccessible()方法
2）、setAccessible作用是启动和禁用访问安全检查的开关
3）、参数值为true则指示反射的对象在使用时应该取消java语言访问检查
a）、提高反射的效率，如果代码中必须使用反射，则该句代码需要频繁的被调用，那么请设置为true
b）、使得原本无法访问的私有成员也可以访问
4）、参数值为false则指示反射的对象应该实施Java语言访问检查。
package com.example.springBoot_mybatisPlus;
import com.example.springBoot_mybatisPlus.modul.dual.entity.WellLoginUser;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.Date;
/**
* @author hfq
* @date 2020/06/06
* @desc 测试反射
*/
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class fansheTest {
//测试性能
@Test
public void test08() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
test09(); //普通凡是调用
System.out.println("==========================");
test10(); //反射方式调用
System.out.println("==========================");
test11(); //反射方式+关闭检查
}
//普通调用
private void test09() {
WellLoginUser user = new WellLoginUser();
//开始时间
long startTime = System.currentTimeMillis();
for(int i = 0 ;i < 1000000000;i++){
user.getUserName();
}
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("普通方式执行10亿次："+(endTime-startTime)+"ms");
}
//反射调用
private void test10() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
WellLoginUser user = new WellLoginUser();
Class cl = user.getClass();
//获得方法
Method getUserName = cl.getDeclaredMethod("getUserName", null);
//开始时间
long startTime = System.currentTimeMillis();
for(int i = 0 ;i < 1000000000;i++){
getUserName.invoke(user,null);
}
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("反射调用执行10亿次："+(endTime-startTime)+"ms");
}
//反射调用关闭检测
private void test11() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
WellLoginUser user = new WellLoginUser();
Class cl = user.getClass();
//获得方法
Method getUserName = cl.getDeclaredMethod("getUserName", null);
getUserName.setAccessible(true);
//开始时间
long startTime = System.currentTimeMillis();
for(int i = 0 ;i < 1000000000;i++){
getUserName.invoke(user,null);
}
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("反射调用关闭检测方式执行10亿次："+(endTime-startTime)+"ms");
}
}普通方式执行10亿次：93ms
==========================
反射调用执行10亿次：3678ms
==========================
反射调用关闭检测方式执行10亿次：3408ms