所谓单元测试，就是针对最小的功能单元，编写测试代码对其进行正确性测试。
我们想想，咱们之前是怎么进行测试的呢？
比如说我们写了一个学生管理系统，有添加学生、修改学生、删除学生、查询学生等这些功能。要对这些功能这几个功能进行测试，我们是在main方法中编写代码来测试的。
但是在main方法中写测试代码有如下的几个问题，如下图所示：
为了测试更加方便，有一些第三方的公司或者组织提供了很好用的测试框架，给开发者使用。这里给同学们介绍一种Junit测试框架。
Junit是第三方公司开源出来的，用于对代码进行单元测试的工具（IDEA已经集成了junit框架）。相比于在main方法中测试有如下几个优点。
我们知道单元测试是什么之后，接下来带领同学们使用一下。由于Junit是第三方提供的，所以我们需要把jar包导入到我们的项目中，才能使用，具体步骤如下图所示：
接下来，我们就按照上面的步骤，来使用一下.
先准备一个类，假设写了一个StringUtil工具类，代码如下
publicclassStringUtil{publicstaticvoidprintNumber(Stringname){System.out.println("名字长度："+name.length());}}
接下来，写一个测试类，测试StringUtil工具类中的方法能否正常使用。
publicclassStringUtilTest{@TestpublicvoidtestPrintNumber(){StringUtil.printNumber("admin");StringUtil.printNumber(null);}}
写完代码之后，我们会发现测试方法左边，会有一个绿色的三角形按钮。点击这个按钮，就可以运行测试方法。
接下来，我们学习一个单元测试的断言机制。所谓断言：意思是程序员可以预测程序的运行结果，检查程序的运行结果是否与预期一致。
我们在StringUtil类中新增一个测试方法
publicstaticintgetMaxIndex(Stringdata){if(data==null){return-1;}returndata.length();}
接下来，我们在StringUtilTest类中写一个测试方法
publicclassStringUtilTest{@TestpublicvoidtestGetMaxIndex(){intindex1=StringUtil.getMaxIndex(null);System.out.println(index1);intindex2=StringUtil.getMaxIndex("admin");System.out.println(index2);//断言机制：预测index2的结果Assert.assertEquals("方法内部有Bug",4,index2);}}
运行测试方法，结果如下图所示，表示我们预期值与实际值不一致
同学们，刚才我们以及学习了@Test注解，可以用来标记一个方法为测试方法，测试才能启动执行。
除了@Test注解，还有一些其他的注解，我们要知道其他注解标记的方法什么时候执行，以及其他注解在什么场景下可以使用。
接下来，我们演示一下其他注解的使用。我们在StringUtilTest测试类中，再新增几个测试方法。代码如下
publicclassStringUtilTest{@Beforepublicvoidtest1(){System.out.println("-->test1Before执行了");}@BeforeClasspublicstaticvoidtest11(){System.out.println("-->test11BeforeClass执行了");}@Afterpublicvoidtest2(){System.out.println("-->test2After执行了");}@AfterClasspublicstaticvoidtest22(){System.out.println("-->test22AfterCalss执行了");}}
执行上面的测试类，结果如下图所示，观察执行结果特点如下
我们现在已经知道每一个注解的作用了，那他们有什么用呢？应用场景在哪里
我们来看一个例子，假设我想在每个测试方法中使用Socket对象，并且用完之后，需要把Socket关闭。代码就可以按照下面的结构来设计
publicclassStringUtilTest{privatestaticSocketsocket;@Beforepublicvoidtest1(){System.out.println("-->test1Before执行了");}@BeforeClasspublicstaticvoidtest11(){System.out.println("-->test11BeforeClass执行了");//初始化Socket对象socket=newSocket();}@Afterpublicvoidtest2(){System.out.println("-->test2After执行了");}@AfterCalsspublicstaticvoidtest22(){System.out.println("-->test22AfterCalss执行了");//关闭Socketsocket.close();}}
什么是反射。其实API文档中对反射有详细的说明，我们去了解一下。在java.lang.reflect包中对反射的解释如下图所示
翻译成人话就是：反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。
反射有啥用呢？其实反射是用来写框架用的，但是现阶段同学们对框架还没有太多感觉。为了方便理解，我给同学们看一个我们见过的例子：平时我们用IDEA开发程序时，用对象调用方法，IDEA会有代码提示，idea会将这个对象能调用的方法都给你列举出来，供你选择，如果下图所示
问题是IDEA怎么知道这个对象有这些方法可以调用呢原因是对象能调用的方法全都来自于类，IDEA通过反射技术就可以获取到类中有哪些方法，并且把方法的名称以提示框的形式显示出来，所以你能看到这些提示了。
为反射获取的是类的信息，那么反射的第一步首先获取到类才行。由于Java的设计原则是万物皆对象，获取到的类其实也是以对象的形式体现的，叫字节码对象，用Class类来表示。获取到字节码对象之后，再通过字节码对象就可以获取到类的组成成分了，这些组成成分其实也是对象，其中每一个成员变量用Field类的对象来表示、每一个成员方法用Method类的对象来表示，每一个构造器用Constructor类的对象来表示。
如下图所示：
反射的第一步：是将字节码加载到内存，我们需要获取到的字节码对象。
比如有一个Student类，获取Student类的字节码代码有三种写法。不管用哪一种方式，获取到的字节码对象其实是同一个。
publicclassTest01_Class{publicstaticvoidmain(String[]args)throwsClassNotFoundException{/*字节码文件对象获取三种方式*///1:根据类名.classClassc1=Student.class;System.out.println(c1);System.out.println(c1.getName());//获取全类名包名+类名System.out.println(c1.getSimpleName());//获取简单类名//2:根据类的全路径(包名+类名)获取Classc2=Class.forName("com.itheima.d2_reflect.Student");//c1c2是不是一个对象？类只加载一次！！System.out.println(c1==c2);//3:得到对象之后，通过对象的方法获取运行时类Studentstu=newStudent();Classc3=stu.getClass();System.out.println(c1==c3);}}
同学们，上一节我们已经可以获取到类的字节码对象了。接下来，我们学习一下通过字节码对象获取构造器，并使用构造器创建对象。
获取构造器，需要用到Class类提供的几个方法，如下图所示：
想要快速记住这个方法的区别，给同学们说一下这些方法的命名规律，按照规律来记就很方便了。
get:获取Declared:有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的Constructor:构造方法的意思后缀s:表示可以获取多个，没有后缀s只能获取一个话不多少，上代码。假设现在有一个Cat类，里面有几个构造方法，代码如下
publicclassCat{privateStringname;privateintage;publicCat(){}privateCat(Stringname,intage){}}
@TestpublicvoidtestGetConstructors(){//反射第一步获取字节码对象Classc=Cat.class;//获取所有的public修饰的构造器//Constructor[]constructors=c.getConstructors();//System.out.println(constructors.length);//for(Constructorconstructor:constructors){//System.out.println("构造器全称:"+constructor);//System.out.println("构造器名称:"+constructor.getName());//获取构造器的名字//System.out.println("参数个数:"+constructor.getParameterCount());//}//获取所有存在的构造器(无所谓修饰符)Constructor[]constructors=c.getDeclaredConstructors();System.out.println("总共:"+constructors.length+"个构造器");for(Constructorconstructor:constructors){System.out.println("构造器全称:"+constructor);System.out.println("构造器名称:"+constructor.getName());//获取构造器的名字System.out.println("参数个数:"+constructor.getParameterCount());System.out.println("==============================");}}
运行测试方法打印结果如下
打印结果如下
同学们，刚才上一节我们已经获取到了Cat类中的构造器。获取到构造器后，有什么作用呢？
其实构造器的作用：初始化对象并返回。
这里我们需要用到如下的两个方法，注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。
如下图所示，constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来
由于构造器是private修饰的，先需要调用setAccessible(true)表示禁止检查访问控制，然后再调用newInstance(实参列表)就可以执行构造器，完成对象的初始化了。
代码如下：为了看到构造器真的执行，故意在两个构造器中分别加了两个打印语句
代码的执行结果如下图所示：
同学们，上一节我们已经学习了获取类的构造方法并使用。接下来，我们再学习获取类的成员变量，并使用。
其实套路是一样的，在Class类中提供了获取成员变量的方法，如下图所示。
这些方法的记忆规则，如下
执行完上面的代码之后，我们可以看到控制台上打印输出了，每一个成员变量的名称和它的类型。
publicclassTest03_Field{@TestpublicvoidgetFields()throwsNoSuchFieldException,IllegalAccessException{//获取所有的属性//1:获取字节码对象Classc=Cat.class;//2:获取所有的成员属性Field[]fields=c.getDeclaredFields();//3：遍历得到每个成员属性的对象形式for(Fieldfield:fields){System.out.println("全称:"+field+"查小名:"+field.getName()+"属性的类型:"+field.getType());}System.out.println("=========================");//需求对某个对象的某个属性完成赋值取值Catcat=newCat();//给cat对象的name属性赋值"加菲猫"//给cat对象的age属性赋值3//通过反射方式找到指定的属性对象FieldfName=c.getDeclaredField("name");FieldfAge=c.getDeclaredField("age");//只要是在反射形式调用可以绕过权限检查fName.setAccessible(true);fAge.setAccessible(true);//完成赋值//fNamefAge属性的对象形式fName.set(cat,"加菲猫");fAge.set(cat,3);System.out.println(cat);//获取到指定对象的指定属性的值？cat.getName()cat.name//属性对象反向调用Stringname=(String)fName.get(cat);//cat.nameSystem.out.println(name);}}
在Filed类中提供给给成员变量赋值和获取值的方法，如下图所示。
再次强调一下设置值、获取值的方法时Filed类的需要用Filed类的对象来调用，而且不管是设置值、还是获取值，都需要依赖于该变量所属的对象。代码如下
执行代码，控制台会有如下的打印
各位同学，上面几节我们已经学习了反射获取构造方法、反射获取成员变量，还剩下最后一个就是反射获取成员方法并使用了。
在Java中反射包中，每一个成员方法用Method对象来表示，通过Class类提供的方法可以获取类中的成员方法对象。如下下图所示
接下来我们还是用代码演示一下：假设有一个Cat类，在Cat类中红有若干个成员方法
publicclassCat{privateStringname;privateintage;publicCat(){System.out.println("空参数构造方法执行了");}privateCat(Stringname,intage){System.out.println("有参数构造方法执行了");this.name=name;this.age=age;}privatevoidrun(){System.out.println("(>^ω^<)喵跑得贼快~~");}publicvoideat(){System.out.println("(>^ω^<)喵爱吃猫粮~");}privateStringeat(Stringname){return"(>^ω^<)喵爱吃:"+name;}publicvoidsetName(Stringname){this.name=name;}publicStringgetName(){returnname;}publicvoidsetAge(intage){this.age=age;}publicintgetAge(){returnage;}}
接下来，通过反射获取Cat类中所有的成员方法，每一个成员方法都是一个Method对象
packagecom.itheima.d2_reflect;importorg.junit.Test;importjava.lang.reflect.InvocationTargetException;importjava.lang.reflect.Method;publicclassTest04_Method{@TestpublicvoidtestGetMethod()throwsNoSuchMethodException,InvocationTargetException,IllegalAccessException{//1：获取字节码对象Classc=Cat.class;//2:获取所有的方法Method[]methods=c.getDeclaredMethods();//3:遍历for(Methodmethod:methods){System.out.println("全称:"+method+"简称:"+method.getName()+"返回值类型:"+method.getReturnType()+"参数个数:"+method.getParameterCount());}System.out.println("==============");//获取指定的方法//runMethodrun=c.getDeclaredMethod("run");//因为类中是这么区分方法的方法名和参数列表System.out.println("简称:"+run.getName()+"返回值类型:"+run.getReturnType()+"参数个数:"+run.getParameterCount());Methodeat=c.getDeclaredMethod("eat",String.class);//因为类中是这么区分方法的方法名和参数列表System.out.println("简称:"+eat.getName()+"返回值类型:"+eat.getReturnType()+"参数个数:"+eat.getParameterCount());}}
执行上面的代码，运行结果如下图所示：打印输出每一个成员方法的名称、参数格式、返回值类型
也能获取单个指定的成员方法，如下图所示
获取到成员方法之后，有什么作用呢？
在Method类中提供了方法，可以将方法自己执行起来。
下面我们演示一下，把run()方法和eat(Stringname)方法执行起来。看分割线之下的代码
打印结果如下图所示：run()方法执行后打印猫跑得贼快~~，返回null；eat()方法执行完，直接返回猫最爱吃:鱼儿
各位小伙伴，按照前面我们学习反射的套路，我们已经充分认识了什么是反射，以及反射的核心作用是用来获取类的各个组成部分并执行他们。但是由于同学们的经验有限，对于反射的具体应用场景还是很难感受到的（这个目前没有太好的办法，只能慢慢积累，等经验积累到一定程度，就会豁然开朗了）。
我们一直说反射使用来写框架的，接下来，我们就写一个简易的框架，简单窥探一下反射的应用。反射其实是非常强大的，这个案例也仅仅值小试牛刀。
需求是让我们写一个框架，能够将任意一个对象的属性名和属性值写到文件中去。不管这个对象有多少个属性，也不管这个对象的属性名是否相同。
分析一下该怎么做
1.先写好两个类，一个Student类和Teacher类2.写一个ObjectFrame类代表框本架在ObjectFrame类中定义一个saveObject(Objectobj)方法，用于将任意对象存到文件中去参数：Objectobj:就表示要存入文件中的对象3.编写方法内部的代码，往文件中存储对象的属性名和属性值1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。2)接着就通过反射获取类的成员变量信息了（变量名、变量值）3)把变量名和变量值写到文件中去写一个ObjectFrame表示自己设计的框架，代码如下图所示
使用自己设计的框架，往文件中写入Student对象的信息和Teacher对象的信息。
先准备好Student类和Teacher类
publicclassStudent{privateStringname;privateintage;privatecharsex;privatedoubleheight;privateStringhobby;}publicclassTeacher{privateStringname;privatedoublesalary;}创建一个测试类，在测试中类创建一个Student对象，创建一个Teacher对象，用ObjectFrame的方法把这两个对象所有的属性名和属性值写到文件中去。
publicclassTest5Frame{@Testpublicvoidsave()throwsException{Students1=newStudent("黑马吴彦祖",45,'男',185.3,"篮球，冰球，阅读");Teachers2=newTeacher("播妞",999.9);ObjectFrame.save(s1);ObjectFrame.save(s2);}}
打开data.txt文件，内容如下图所示，就说明我们这个框架的功能已经实现了
注解和反射一样，都是用来做框架的，我们这里学习注解的目的其实是为了以后学习框架或者做框架做铺垫的。
那注解该怎么学呢？和反射的学习套路一样，我们先充分的认识注解，掌握注解的定义和使用格式，然后再学习它的应用场景。
先来认识一下什么是注解？
Java注解是代码中的特殊标记，比如@Override、@Test等，作用是：让其他程序根据注解信息决定怎么执行该程序。
比如：Junit框架的@Test注解可以用在方法上，用来标记这个方法是测试方法，被@Test标记的方法能够被Junit框架执行。
再比如：@Override注解可以用在方法上，用来标记这个方法是重写方法，被@Override注解标记的方法能够被IDEA识别进行语法检查。
上面我们说的@Test注解、@Overide注解是别人定义好给我们用的，将来如果需要自己去开发框架，就需要我们自己定义注解。
接着我们学习自定义注解
自定义注解的格式如下图所示
比如：现在我们自定义一个MyTest注解
public@interfaceMyTest1{Stringaaa();booleanbbb()defaulttrue;//defaulttrue表示默认值为true,使用时可以不赋值。String[]ccc();}
定义好MyTest注解之后，我们可以使用MyTest注解在类上、方法上等位置做标记。注意使用注解时需要加@符号，如下
@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})publicclassAnnotationTest1{@MyTest1(aaa="铁扇公主",bbb=false,ccc={"Python","前端","Java"})publicvoidtest1(){}}
注意：注解的属性名如何是value的话，并且只有value没有默认值，使用注解时value名称可以省略。比如现在重新定义一个MyTest2注解
public@interfaceMyTest2{Stringvalue();Stringname()default"太上老君";//value可以省略属性前提其他的属性不用赋值}
定义好MyTest2注解后，再将@MyTest2标记在类上，此时value属性名可以省略，代码如下
@MyTest1(aaa="小黑子",ccc={"鸡你太美","打篮球rap"})publicclassAnnotationTest1{//Class@MyTest1(aaa="ikun",bbb=false,ccc="跳")@MyTest2("红孩儿")publicvoidtest1(){}//Method@MyTest2("铁扇公主")privateStringname;//Field对象}
到这里关于定义注解的格式、以及使用注解的格式就学习完了。
注解本质是什么呢？
想要搞清楚注解本质是什么东西，我们可以把注解的字节码进行反编译，使用XJad工具进行反编译。经过对MyTest1注解字节码反编译我们会发现：
各位小伙伴，刚才我们已经认识了注解以及注解的基本使用。接下来我们还需要学习几种特殊的注解，叫做元注解。
什么是元注解？
元注解是修饰注解的注解。这句话虽然有一点饶，但是非常准确。我们看一个例子
别一下@Target注解和@Retention注解有什么作用，如下图所示
如果我们定义MyTest3注解时，使用@Target注解属性值写成下面样子
到这里@Target元注解的使用就演示完毕了。
各位小伙伴，通过前面的学习我们能够自己定义注解，也能够把自己定义的注解标记在类上或者方法上等位置，但是总感觉有点别扭，给类、方法、变量等加上注解后，我们也没有干什么呀！！！
接下来，我们就要做点什么。我们可以通过反射技术把类上、方法上、变量上的注解对象获取出来，然后通过调用方法就可以获取注解上的属性值了。我们把获取类上、方法上、变量上等位置注解及注解属性值的过程称为解析注解。
解析注解套路如下
解析来看一个案例，来演示解析注解的代码编写
按照需求要求一步一步完成
①先定义一个MyTest4注解
②定义有一个类Demo
@MyTest4(value="杉木",aaa=1000,bbb={"喝水","晒太阳"})publicclassDemo{@MyTest4(value="熏悟空",bbb={"喝牛奶","吃香蕉"})publicvoidtest1(){}}
③写一个测试类AnnotationTest3解析Demo类上的MyTest4注解
各位同学，关于注解的定义、使用、解析注解就已经学习完了。接下来，我们再学习一下注解的应用场景，注解是用来写框架的，比如现在我们要模拟Junit写一个测试框架，要求有@MyTest注解的方法可以被框架执行，没有@MyTest注解的方法不能被框架执行。
第一步：先定义一个MyTest注解
@Target(ElementType.METHOD)@Retetion(RetetionPloicy.RUNTIME)public@interfaceMyTest{}第二步：写一个测试类AnnotationTest4，在类中定义几个被@MyTest注解标记的方法
publicclassAnnotationTest4{@MyTestpublicvoidtest1(){System.out.println("=====test1====");}@MyTestpublicvoidtest2(){System.out.println("=====test2====");}publicvoidtest3(){System.out.println("=====test2====");}publicstaticvoidmain(String[]args){AnnotationTest4a=newAnnotationTest4();//1.先获取Class对象Classc=AnnotationTest4.class;//2.解析AnnotationTest4类中所有的方法对象Method[]methods=c.getDeclaredMethods();for(Methodm:methods){//3.判断方法上是否有MyTest注解，有就执行该方法if(m.isAnnotationPresent(MyTest.class)){m.invoke(a);}}}}
恭喜小伙伴们，学习到这里，关于注解的使用就学会了(^▽^)
各位同学，这节课我们学习一个Java的高级技术叫做动态代理。首先我们认识一下代理长什么样？我们以大明星“杨超越”例。
假设现在有一个大明星叫杨超越，它有唱歌和跳舞的本领，作为大明星是要用唱歌和跳舞来赚钱的，但是每次做节目，唱歌的时候要准备话筒、收钱，再唱歌；跳舞的时候也要准备场地、收钱、再唱歌。杨超越越觉得我擅长的做的事情是唱歌，和跳舞，但是每次唱歌和跳舞之前或者之后都要做一些繁琐的事情，有点烦。于是杨超越就找个一个经济公司，请了一个代理人，代理杨超越处理这些事情，如果有人想请杨超越演出，直接找代理人就可以了。如下图所示
我们说杨超越的代理是中介公司派的，那中介公司怎么知道，要派一个有唱歌和跳舞功能的代理呢？
解决这个问题，Java使用的是接口，杨超越想找代理，在Java中需要杨超越实现了一个接口，接口中规定要唱歌和跳舞的方法。Java就可以通过这个接口为杨超越生成一个代理对象，只要接口中有的方法代理对象也会有。
接下来我们就先把有唱歌和跳舞功能的接口，和实现接口的大明星类定义出来。
publicinterfaceStar{Stringsing(Stringname);voiddance();}/***@author：石破天*@date：Createdin2023年02月07日*@description：*@version:1.0*/publicclassBigStarimplementsStar{privateStringname;publicBigStar(Stringname){this.name=name;}@OverridepublicStringsing(Stringname){System.out.println("您点了:"+name+"歌曲,"+this.name+"就唱着歌曲");return"栓Q！！！";}@Overridepublicvoiddance(){System.out.println(this.name+"正在跳freestyledance!!");}}
下面我们写一个为BigStar生成动态代理对象的工具类。这里需要用Java为开发者提供的一个生成代理对象的类叫Proxy类。
通过Proxy类的newInstance(...)方法可以为实现了同一接口的类生成代理对象。调用方法时需要传递三个参数，该方法的参数解释可以查阅API文档，如下。
调用我们写好的ProxyUtil工具类，为BigStar对象生成代理对象
/***@date：Createdin2023年02月07日*@description：*动态代理*在不修改原来的基础上，实现功能的增强*谁来谁先增强，是代理对象。*只不过代理对象的生成非常的麻烦。*@version:1.0*/publicclassTest{publicstaticvoidmain(String[]args){//通过经纪公司给杨超越产生一个代理Starstar=ProxyFactory.createProxy(newBigStar("杨超越"));Stringsing=star.sing("好日子");System.out.println(sing);star.dance();}}
运行测试类，结果如下图所示
恭喜同学们，当你把上面的案例写出来，并且理解，那么动态代理的基本使用就学会了。
学习完动态代理的基本使用之后，接下来我们再做一个应用案例。
现有如下代码
观察上面代码发现有什么问题吗？
我们会发现每一个方法中计算耗时的代码都是重复的，我们可是学习了动态代理的高级程序员，怎么能忍受在每个方法中写重复代码呢！况且这些重复的代码并不属于UserSerivce的主要业务代码。
所以接下来我们打算，把计算每一个方法的耗时操作，交给代理对象来做。
先在UserService类中把计算耗时的代码删除，代码如下
publicclassProxyUtil{publicstaticUserServicecreateProxy(UserServiceuserService){UserServiceuserServiceProxy=(UserService)Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),newClass[]{UserService.class},newInvocationHandler(){@OverridepublicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{if(method.getName().equals("login")||method.getName().equals("deleteUsers")||method.getName().equals("selectUsers")){//方法运行前记录毫秒值longstartTime=System.currentTimeMillis();//执行方法Objectrs=method.invoke(userService,args);//执行方法后记录毫秒值longendTime=System.currentTimeMillis();System.out.println(method.getName()+"方法执行耗时："+(endTime-startTime)/1000.0+"s");returnrs;}else{Objectrs=method.invoke(userService,args);returnrs;}}});//返回代理对象returnuserServiceProxy;}}
在测试类中为UserService创建代理对象
/***目标：使用动态代理解决实际问题，并掌握使用代理的好处。*/publicclassTest{publicstaticvoidmain(String[]args)throwsException{//1、创建用户业务对象。UserServiceuserService=ProxyUtil.createProxy(newUserServiceImpl());//2、调用用户业务的功能。userService.login("admin","123456");System.out.println("----------------------------------");userService.deleteUsers();System.out.println("----------------------------------");String[]names=userService.selectUsers();System.out.println("查询到的用户是："+Arrays.toString(names));System.out.println("----------------------------------");}}
执行结果如下图所示
动态代理对象的执行流程如下图所示，每次用代理对象调用方法时，都会执行InvocationHandler中的invoke方法。