单元测试 快速入门 单元测试
单元测试就是针对最小的功能单元 (方法)，编写测试代码对该功能进行正确性测试 。
目前测试方法是怎么进行的？ 存在什么问题 ？
只能编写main方法，并在main方法中再去调用其他方法进行测试。
使用起来很不灵活，无法实现自动化测试。
无法得到测试的报告，需要程序员自己去观察测试是否成功。
Junit单元测试框架
JUnit是使用Java语言实现的单元测试框架，它是第三方公司开源出来的，很多开发工具已经集成了Junit框架 ，比如IDEA。
优点
编写的测试代码很灵活，可以指某个测试方法执行测试，也支持一键完成自动化测试 。
不需要程序员去分析测试的结果，会自动生成测试报告 出来。
提供了更强大的测试能力。
需求
某个系统，有多个业务方法，请使用Junit框架完成对这些方法的单元测试。
具体步骤
将Junit框架的jar包导入到项目中（注意：IDEA集成了Junit框架，不需要我们自己手工导入了）。
编写测试类、测试类方法 （注意：测试方法必须是公共的，无参数，无返回值的非静态方法 ）。【灵魂】必须在测试方法上使用@Test注解 （标注该方法是一个测试方法）。（在报错的地方使用alt+enter，导入JUnit4。这个是经典版本，但是版本5可读性更好。）
在测试方法中，编写程序调用被测试的方法即可。（测试某个方法直接右键该方法启动测试。测试全部方法，可以选择类或者模块启动。）
选中测试方法，右键选择“JUnit运行” ，如果测试通过 则是绿色 ；如果测试失败 ，则是红色 。
先准备一个类，假设写了一个StringUtil工具类，代码如下
1 2 3 4 5 public class StringUtil { public static void printNumber (String name) { System.out.println("名字长度：" +name.length()); } }
接下来，写一个测试类，测试StringUtil工具类中的方法能否正常使用。
1 2 3 4 5 6 7 public class StringUtilTest { @Test public void testPrintNumber () { StringUtil.printNumber("admin" ); StringUtil.printNumber(null ); } }
写完代码之后，我们会发现测试方法左边，会有一个绿色的三角形按钮。点击这个按钮，就可以运行测试方法。
单元测试断言 断言：意思是程序员可以预测程序的运行结果，检查程序的运行结果是否与预期一致。**
我们在StringUtil类中新增一个测试方法
1 2 3 4 5 6 public static int getMaxIndex (String data) { if (data == null ){ return -1 ; } return data.length(); }
接下来，我们在StringUtilTest类中写一个测试方法
1 2 3 4 5 6 7 8 9 10 11 12 13 public class StringUtilTest { @Test public void testGetMaxIndex () { int index1 = StringUtil.getMaxIndex(null ); System.out.println(index1); int index2 = StringUtil.getMaxIndex("admin" ); System.out.println(index2); Assert.assertEquals("方法内部有Bug" ,4 ,index2); } }
运行测试方法，结果预期值与实际值不一致。
Junit框架的常见注解 常见注解(Junit 4.xxxx版本)
@Test。测试方法。
@Before。用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。
@After。用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。
@BeforeClass。用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。
@AfterClass。用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。
特点如下
1 2 3 4 1. 被@BeforeClass 标记的方法,执行在所有方法之前2. 被@AfterCalss 标记的方法，执行在所有方法之后3. 被@Before 标记的方法，执行在每一个@Test 方法之前4. 被@After 标记的方法，执行在每一个@Test 方法之后
常见注解(Junit 5.xxxx版本)
@Test。测试方法。
@BeforeEach。用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。
@AfterEach。用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。
@BeforeAll。用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。
@AfterAll。用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。
开始执行的方法:初始化资源。
执行完之后的方法:释放资源。
作用？应用场景？
假设我想在每个测试方法中使用Socket对象，并且用完之后，需要把Socket关闭。代码就可以按照下面的结构来设计
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public class StringUtilTest { private static Socket socket; @Before public void test1 () { System.out.println("--> test1 Before 执行了" ); } @BeforeClass public static void test11 () { System.out.println("--> test11 BeforeClass 执行了" ); socket = new Socket (); } @After public void test2 () { System.out.println("--> test2 After 执行了" ); } @AfterCalss public static void test22 () { System.out.println("--> test22 AfterCalss 执行了" ); socket.close(); } }
反射 认识反射Reflection 【核心思想】得到编译以后的class文件对象。
反射指的是允许以编程方式访问已加载类的成分（成员变量、方法、构造器等） 。
在java.lang.reflect包中。
主要是用来做框架的。好理解一点，我们在写代码的时候，IDEA给我们提示的可以调用的方法。
反射学什么？
加载类，获取类的字节码 ：Class对象。
反射第一步：获取类：Class。
获取类的构造器：Constructor。
获取类的成员变量：Field。
获取类的成员方法：Method。
获取类的构造器：Constructor对象。
获取类的成员变量：Field对象。
获取类的成员方法：Method对象。
之后再看反射的应用场景。
获取类 反射第一步，获取Class类的对象。（3种方式。）
Class c1 = 类名.class。
调用Class提供的方法：public static Class.forName(String package)。
Object提供的方法：public Class getClass()。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Test1Class { public static void main (String[] args) { Class c1 = Student.class; System.out.println(c1.getName()); System.out.println(c1.getSimpleName()); Class c2 = Class.forName("com.itheima.d2_reflect.Student" ); System.out.println(c1 == c2); Student s = new Student (); Class c3 = s.getClass(); System.out.println(c2 == c3); } }
获取类的构造器 Class类提供的几个方法
Constructor<?>[] getConstructors()。返回所有构造器对象的数组（只能拿public的 ）。
Constructor<?>[] getDeclaredConstructors()。返回所有构造器对象的数组，存在就能拿到 。
Constructor getConstructor(Class<?>… parameterTypes)。返回单个构造器对象 （只能拿public 的）。
Constructor getDeclaredConstructor(Class<?>… parameterTypes)。返回单个构造器对象，存在就能拿到。
方便记忆：
1 2 3 4 get:获取 Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public 修饰的 Constructor: 构造方法的意思 后缀s: 表示可以获取多个，没有后缀s只能获取一个
假设现在有一个Cat类，里面有几个构造方法，代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 public class Cat { private String name; private int age; public Cat () { } private Cat (String name, int age) { } }
接下来，我们写一个测试方法，来测试获取类中所有的构造器：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Test2Constructor (){ @Test public void testGetConstructors () { Class c = Cat.class; Constructor[] constructors = c.getDeclaredConstructors(); for (Constructor constructor: constructors){ System.out.println(constructor.getName()+"---> 参数个数：" +constructor.getParameterCount()); } } }
刚才的是获取Cat类中所有的构造器，接下来试一试单个构造器：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class Test2Constructor (){ @Test public void testGetConstructor () { Class c = Cat.class; Constructor constructor1 = c.getConstructor(); System.out.println(constructor1.getName()+"---> 参数个数：" +constructor1.getParameterCount()); Constructor constructor2 = c.getDeclaredConstructor(String.class,int .class); System.out.println(constructor2.getName()+"---> 参数个数：" +constructor1.getParameterCount()); } }
获取类构造器的作用 初始化对象返回。注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。
T newInstance(Object… initargs)。根据指定的构造器创建对象。（反射后的构造器依然是创建对象的。）
public void setAccessible(boolean flag)。设置为true,表示取消访问检查，进行暴力反射。（–>反射会破坏封装性，私有的也可以执行了。）
代码演示 constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来
由于构造器是private修饰的，先需要调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。
代码如下：为了看到构造器真的执行， 故意在两个构造器中分别加了两个打印语句
注意：上面这种代码风格，看起来没什么必要，可以先稍微记一记，以后学习框架 的时候有用。
获取类的成员变量&使用 Class类中提供的获取成员变量的方法
Field[] getFields()。返回所有成员变量对象的数组 （只能拿public 的）。
Field[] getDeclaredFields()。返回所有成员变量对象的数组 ，存在就能拿到 。
Field getField(String name)。返回单个 成员变量对象（只能拿public 的）。
Field getDeclaredField(String name)。返回单个 成员变量对象，存在就能拿到 。
记忆规则
1 2 3 4 get:获取 Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public 修饰的 Field: 成员变量的意思 后缀s: 表示可以获取多个，没有后缀s只能获取一个
获取成员变量的作用 依然是在某个对象中取值、赋值 。
Field类中用于取值、赋值的方法
void set(Object obj, Object value)。赋值。
Object get(Object obj)。获取值。
setAccessible(boolean)。如果某成员变量是非public的，需要打开权限（暴力反射），然后再取值、赋值。
代码演示
设有一个Cat类它有若干个成员变量，用Class类提供 的方法将成员变量的对象获取出来。
执行完上面的代码之后，我们可以看到控制台上打印输出了，每一个成员变量的名称和它的类型。
在Filed类中提供给给成员变量赋值和获取值的方法：
void set(object obj,Object value)。赋值。
object get(object obj)。取值。
public voidsetAccessible(boolean flag)。设置为true，表示禁止检查访问控制(暴力反射)。
再次强调一下设置值、获取值的方法时Filed类的需要用Filed类的对象来调用，而且不管是设置值、还是获取值，都需要依赖于该变量所属的对象。代码如下
获取类的成员方法 使用反射技术获取方法对象并使用
反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
Class类中用于获取成员方法的方法
Method[] getMethods()。返回所有成员方法对象的数组 （只能拿public 的）。
Method[] getDeclaredMethods()。返回所有成员方法对象的数组 ，存在就能拿到 。
Method getMethod(String name, Class<?>… parameterTypes)。返回单个 成员方法对象（只能拿public 的）。
Method getDeclaredMethod(String name, Class<?>… parameterTypes)。返回单个 成员方法对象，存在就能拿到 。
使用反射技术获取方法对象并使用
获取成员方法的作用依然是在某个对象中进行执行此方法 。
Method类中用于触发执行的方法
Object invoke(Object obj, Object… args)。
参数一：用obj对象调用该方法
参数二：调用方法的传递的参数（如果没有就不写）
返回值：方法的返回值（如果没有就不写）
setAccessible(boolean)。如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行。
把run()方法和eat(String name)方法执行起来。看分割线之下的代码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 public class Test3Method { public static void main (String[] args) { Class c = Cat.class; Method[] methods = c.getDecalaredMethods(); for (Method method : methods){ System.out.println(method.getName()+"-->" +method.getParameterCount()+"-->" +method.getReturnType()); } System.out.println("-----------------------" ); Method run = c.getDecalaredMethod("run" ); Cat cat = new Cat (); run.setAccessible(true ); Object rs1 = run.invoke(cat); System.out.println(rs1) Method eat = c.getDeclaredMethod("eat" ,String.class); eat.setAccessible(true ); Object rs2 = eat.invoke(cat,"鱼儿" ); System.out.println(rs2) } }
作用、应用场景 作用
基本作用：得到一个类的全部成分然后操作；
破坏封装性；
最重要的用途：适合做Java的框架，基本上，主流的框架都会基于反射设计出一些通用的功能。
一个简易的框架
步骤
1 2 3 4 5 6 7 8 9 1. 先写好两个类，一个Student类和Teacher类2. 写一个ObjectFrame类代表框本架 在ObjectFrame类中定义一个saveObject(Object obj)方法，用于将任意对象存到文件中去 参数：Object obj: 就表示要存入文件中的对象 3. 编写方法内部的代码，往文件中存储对象的属性名和属性值 1 )参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。 2 )接着就通过反射获取类的成员变量信息了（变量名、变量值） 3 )把变量名和变量值写到文件中去
写一个ObjectFrame表示自己设计的框架，代码如下图所示
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 public class ObjectFrame { public static void saveObject (Object obj) throws Exception{ PrintStream ps = new PrintStream (new FileOutputStream ("模块名\\src\\data.txt" ,true )); Class c = obj.getClass(); ps.println("---------" +class.getSimpleName()+"---------" ); Field[] fields = c.getDeclaredFields(); for (Field field : fields){ String name = field.getName(); Object value = field.get(obj)+"" ; ps.println(name); } ps.close(); } }
使用自己设计的框架，往文件中写入Student对象的信息和Teacher对象的信息。
先准备好Student类和Teacher类
1 2 3 4 5 6 7 public class Student { private String name; private int age; private char sex; private double height; private String hobby; }
1 2 3 4 public class Teacher { private String name; private double salary; }
创建一个测试类，在测试中类创建一个Student对象，创建一个Teacher对象，用ObjectFrame的方法把这两个对象所有的属性名和属性值写到文件中去。
1 2 3 4 5 6 7 8 9 10 public class Test5Frame { @Test public void save () throws Exception{ Student s1 = new Student ("黑马吴彦祖" ,45 , '男' , 185.3 , "篮球，冰球，阅读" ); Teacher s2 = new Teacher ("播妞" ,999.9 ); ObjectFrame.save(s1); ObjectFrame.save(s2); } }
注解 认识注解&定义注解
Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。
Java 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。
自定义注解 — 格式 自定义注解就是自己做一个注解来使用。
1 2 3 public @interface 注解名称 { public 属性类型 属性名() default 默认值 ; }
注解的作用
对Java中类、方法、成员变量做标记，然后进行特殊处理 ，至于到底做何种处理由业务需求来决定。例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。
特殊属性
value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写!!
但是如果有多个属性, 且多个属性没有默认值，那么value名称是不能省略的。
比如：现在我们自定义一个MyTest注解
1 2 3 4 5 public @interface MyTest{ String aaa () ; boolean bbb () default true ; String[] ccc(); }
定义好MyTest注解之后，我们可以使用MyTest注解在类上、方法上等位置做标记。注意使用注解时需要加@符号，如下
1 2 3 4 5 6 7 @MyTest1(aaa="牛魔王",ccc={"HTML","Java"}) public class AnnotationTest1 { @MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"}) public void test1 () { } }
注意：注解的属性名如何是value的话，并且只有value没有默认值，使用注解时value名称可以省略。比如现在重新定义一个MyTest2注解
1 2 3 4 public @interface MyTest2{ String value () ; int age () default 10 ; }
定义好MyTest2注解后，再将@MyTest2标记在类上，此时value属性名可以省略，代码如下
1 2 3 4 5 6 7 8 @MyTest2("孙悟空") @MyTest1(aaa="牛魔王",ccc={"HTML","Java"}) public class AnnotationTest1 { @MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"}) public void test1 () { } }
注解的本质是接口
想要搞清楚注解本质是什么东西，我们可以把注解的字节码进行反编译，使用XJad工具进行反编译。经过对MyTest1注解字节码反编译我们会发现：
1 2 3 4 1. MyTest1注解本质上是接口，每一个注解接口都继承子Annotation接口2. MyTest1注解中的属性本质上是抽象方法3. @MyTest1 实际上是作为MyTest接口的实现类对象4. @MyTest1(aaa="孙悟空",bbb=false,ccc={"Python","前端","Java"}) 里面的属性值，可以通过调用aaa()、bbb()、ccc()方法获取到。 【别着急，继续往下看，再解析注解时会用到】
元注解 元注解：注解注解的注解。
元注解有两个：
@Target: 约束自定义注解只能在哪些地方使用。
@Retention：申明注解的生命周期。
@Target注解和@Retention注解 1 2 @Target 是用来声明注解只能用在那些位置，比如：类上、方法上、成员变量上等@Retetion 是用来声明注解保留周期，比如：源代码时期、字节码时期、运行时期
@Target元注解的使用： 比如定义一个MyTest3注解，并添加@Target注解用来声明MyTest3的使用位置
1 2 3 4 @Target(ElementType.TYPE) public @interface MyTest3{ }
接下来，把@MyTest3用来类上观察是否有错，再把@MyTest3用在方法上、变量上再观察是否有错。
如果我们定义MyTest3注解时，使用@Target注解属性值写成下面样子
1 2 3 4 5 @Target({ElementType.TYPE,ElementType.METHOD}) public @interface MyTest3{ }
再观察，@MyTest用在类上、方法上、变量上是否有错。
@Retetion元注解的使用 定义MyTest3注解时，给MyTest3注解添加@Retetion注解来声明MyTest3注解保留的时期 。
1 2 3 4 5 @Retetion 是用来声明注解保留周期，比如：源代码时期、字节码时期、运行时期 @Retetion(RetetionPloicy.SOURCE) : 注解保留到源代码时期、字节码中就没有了 @Retetion(RetetionPloicy.CLASS) : 注解保留到字节码中、运行时注解就没有了 @Retetion(RetetionPloicy.RUNTIME) ：注解保留到运行时期 【自己写代码时，比较常用的是保留到运行时期】
1 2 3 4 5 6 7 @Target({ElementType.TYPE,ElementType.METHOD}) @Retetion(RetetionPloicy.RUNTIME) public @interface MyTest3{ }
解析注解 注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。
可以通过反射技术把类上、方法上、变量上的注解对象获取出来，然后通过调用方法就可以获取注解上的属性值了。
解析注解套路如下
1 2 3 4 1. 如果注解在类上，先获取类的字节码对象，再获取类上的注解2. 如果注解在方法上，先获取方法对象，再获取方法上的注解3. 如果注解在成员变量上，先获取成员变量对象，再获取变量上的注解总之：注解在谁身上，就先获取谁，再用谁获取谁身上的注解
Class 、Method、Field,Constructor、都实现了AnnotatedElement接口，它们都拥有解析注解的能力。
public Annotation[]getDeclaredAnnotations()。获取当前对象上面的注解。
public TgetDeclaredAnnotation(ClassannotationClass)。获取指定的注解对象。
public boolean isAnnotationPresent(class annotationclass)。判断当前对象上是否存在某个注解。
案例需求
定义注解MyTest4，要求如
包含属性:String value()。
包含属性:double aaa()，默认值为 100。
包含属性:Stringllbbb()。
限制注解使用的位置:类和成员方法上。
指定注解的有效范围:一直到运行时。
定义一个类叫:Demo，在类中定义一个test1方法，并在该类和其方法上使用MyTest4注解。
定义AnnotationTest3测试类，解析Demo类中的全部注解。
代码：
① 先定义一个MyTest4注解
1 2 3 4 5 6 7 8 9 @Target({ElementType.TYPE,ElementType.METHOD}) @Retetion(RetetionPloicy.RUNTIME) public @interface MyTest4{ String value () ; double aaa () default 100 ; String[] bbb(); }
② 定义有一个类Demo
1 2 3 4 5 6 7 @MyTest4(value="蜘蛛侠",aaa=99.9, bbb={"至尊宝","黑马"}) public class Demo { @MyTest4(value="孙悟空",aaa=199.9, bbb={"紫霞","牛夫人"}) public void test1 () { } }
③ 写一个测试类AnnotationTest3解析Demo类上的MyTest4注解
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 public class AnnotationTest3 { @Test public void parseClass () { Class c = Demo.class; if (c.isAnnotationPresent(MyTest4.class)){ MyTest4 myTest4 = (MyTest4)c.getDeclaredAnnotation(MyTest4.class); System.out.println(myTest4.value()); System.out.println(myTest4.aaa()); System.out.println(myTest4.bbb()); } } @Test public void parseMethods () { Class c = Demo.class; Method m = c.getDeclaredMethod("test1" ); if (m.isAnnotationPresent(MyTest4.class)){ MyTest4 myTest4 = (MyTest4)m.getDeclaredAnnotation(MyTest4.class); System.out.println(myTest4.value()); System.out.println(myTest4.aaa()); System.out.println(myTest4.bbb()); } } }
注解的应用场景 注解是用来写框架的，比如现在我们要模拟Junit写一个测试框架，要求有@MyTest注解的方法可以被框架执行，没有@MyTest注解的方法不能被框架执行。
第一步：先定义一个MyTest注解
1 2 3 4 5 @Target(ElementType.METHOD) @Retetion(RetetionPloicy.RUNTIME) public @interface MyTest{ }
第二步：写一个测试类AnnotationTest4，在类中定义几个被@MyTest注解标记的方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 public class AnnotationTest4 { @MyTest public void test1 () { System.out.println("=====test1====" ); } @MyTest public void test2 () { System.out.println("=====test2====" ); } public void test3 () { System.out.println("=====test2====" ); } public static void main (String[] args) { AnnotationTest4 a = new AnnotationTest4 (); Class c = AnnotationTest4.class; Method[] methods = c.getDeclaredMethods(); for (Method m: methods){ if (m.isAnnotationPresent(MyTest.class)){ m.invoke(a); } } } }
动态代理 代理思想就是被代理者没有能力，或者不愿意去完成某件事情，需要找个人（代理）代替自己去完成这件事。
动态代理 主要是对被代理对象的行为 进行代理。是一个对象。
先把有唱歌和跳舞功能的接口，和实现接口的大明星类定义出来：
动态代理的开发步骤
必须定义接口 ，里面定义一些行为 ，用来约束被代理对象和代理对象都要完成的事情 。
定义一个实现类实现接口 ，这个实现类的对象代表被代理的对象 。
定义一个测试类，在里面创建被代理对象，然后为其创建一个代理对象返回。（重点）
代理对象中，需要模拟收首付款，真正触发被代理对象的行为，然后接收尾款操作。
通过返回的代理对象进行方法的调用，观察动态代理的执行流程。
如何创建代理对象
Java中代理的代表类是：java.lang.reflect.Proxy，它提供了一个静态方法，用于为被代理对象，产生一个代理对象 返回。
1 2 3 4 5 6 7 public static Object newProxyInstance (ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 为被代理对象返回一个代理对象。 参数一：类加载器 加载代理类，产生代理对象。，。 参数二：真实业务对象的接口。(被代理的方法交给代理对象) 参数三：代理的核心处理程序。
写一个为BigStar生成动态代理对象的工具类。这里需要用Java为开发者提供的一个生成代理对象的类叫Proxy类 。
通过Proxy类的newInstance(…)方法 可以为实现了同一接口的类生成代理对象。 调用方法时需要传递三个参数 ：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 public class ProxyUtil { public static Star createProxy (BigStar bigStar) { Star starProxy = (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(), new Class []{Star.class}, new InvocationHandler () { @Override public Object invoke (Object proxy, Method method, Object[] args) throws Throwable { if (method.getName().equals("sing" )){ System.out.println("准备话筒，收钱20万" ); }else if (method.getName().equals("dance" )){ System.out.println("准备场地，收钱1000万" ); } return method.invoke(bigStar, args); } }); return starProxy; } }
调用我们写好的ProxyUtil工具类，为BigStar对象生成代理对象
1 2 3 4 5 6 7 8 9 10 11 public class Test { public static void main (String[] args) { BigStar s = new BigStar ("杨超越" ); Star starProxy = ProxyUtil.createProxy(s); String rs = starProxy.sing("好日子" ); System.out.println(rs); starProxy.dance(); } }
通过代理对象调用方法，执行流程？
先走向代理。
代理中可以真正触发被代理对象的方法执行。
回到代理中，由代理负责返回结果给调用者。
案例 需求
模拟某企业用户管理业务，需包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。
分析
定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。
定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时。
定义测试类，创建实现类对象，调用方法。
现有如下代码
1 2 3 4 5 6 7 8 9 10 11 public interface UserService { void login (String loginName,String passWord) throws Exception; void deleteUsers () throws Exception; String[] selectUsers() throws Exception; }
UserService接口的实现类，每一个方法中要计算方法运行时间：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 public class UserServiceImpl implements UserService { @Override public void login (String loginName, String passWord) throws Exception { long time1 = System.currentTimeMillis(); if ("admin" .equals(loginName) && "123456" .equals(passWord)){ System.out.println("您登录成功，欢迎光临本系统~" ); }else { System.out.println("您登录失败，用户名或密码错误~" ); } Thread.sleep(1000 ); long time2 = System.currentTimeMillis(); System.out.println("login方法耗时：" +(time2-time1)); } @Override public void deleteUsers () throws Exception{ long time1 = System.currentTimeMillis(); System.out.println("成功删除了1万个用户~" ); Thread.sleep(1500 ); long time2 = System.currentTimeMillis(); System.out.println("deleteUsers方法耗时：" +(time2-time1)); } @Override public String[] selectUsers() throws Exception{ long time1 = System.currentTimeMillis(); System.out.println("查询出了3个用户" ); String[] names = {"张全蛋" , "李二狗" , "牛爱花" }; Thread.sleep(500 ); long time2 = System.currentTimeMillis(); System.out.println("selectUsers方法耗时：" +(time2-time1)); return names; } }
本案例存在哪些问题？
答：业务对象的的每个方法都要进行性能统计，存在大量重复的代码。
每一个方法中计算耗时的代码都是重复的，这些重复的代码并不属于UserSerivce的主要业务代码。接下来打算把计算每一个方法的耗时操作交给代理对象来做。
优化的关键步骤
必须有接口，实现类要实现接口（代理通常是基于接口实现的）。
创建一个实现类的对象，该对象为业务对象，紧接着为业务对象做一个代理对象。
先在UserService类中把计算耗时的代码删除，代码如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 public class UserServiceImpl implements UserService { @Override public void login (String loginName, String passWord) throws Exception { if ("admin" .equals(loginName) && "123456" .equals(passWord)){ System.out.println("您登录成功，欢迎光临本系统~" ); }else { System.out.println("您登录失败，用户名或密码错误~" ); } Thread.sleep(1000 ); } @Override public void deleteUsers () throws Exception{ System.out.println("成功删除了1万个用户~" ); Thread.sleep(1500 ); } @Override public String[] selectUsers() throws Exception{ System.out.println("查询出了3个用户" ); String[] names = {"张全蛋" , "李二狗" , "牛爱花" }; Thread.sleep(500 ); return names; } }
然后为UserService生成一个动态代理对象，在动态代理中调用目标方法，在调用目标方法之前和之后记录毫秒值，并计算方法运行的时间。代码如下
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 public class ProxyUtil { public static UserService createProxy (UserService userService) { UserService userServiceProxy = (UserService) Proxy.newProxyInstance( ProxyUtil.class.getClassLoader(), new Class []{UserService.class}, new InvocationHandler () { @Override public Object invoke ( Object proxy, Method method, Object[] args) throws Throwable { if ( method.getName().equals("login" ) || method.getName().equals("deleteUsers" )|| method.getName().equals("selectUsers" )){ long startTime = System.currentTimeMillis(); Object rs = method.invoke(userService, args); long endTime = System.currentTimeMillis(); System.out.println(method.getName() + "方法执行耗时：" + (endTime - startTime)/ 1000.0 + "s" ); return rs; }else { Object rs = method.invoke(userService, args); return rs; } } }); return userServiceProxy; } }
在测试类中为UserService创建代理对象
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class Test { public static void main (String[] args) throws Exception{ UserService userService = ProxyUtil.createProxy(new UserServiceImpl ()); 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方法。
动态代理的优点
可以在不改变方法源码的情况下，实现对方法功能的增强，提高了代码的复用。
简化了编程工作、提高了开发效率，同时提高了软件系统的可扩展性。
可以为被代理对象的所有方法做代理。
非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。
