【Java基础】【java.lang.reflect】Junit单元测试、反射

单元测试

快速入门

单元测试

• 单元测试就是针对最小的功能单元(方法)，编写测试代码对该功能进行正确性测试。

目前测试方法是怎么进行的？ 存在什么问题 ？

• 只能编写main方法，并在main方法中再去调用其他方法进行测试。
• 使用起来很不灵活，无法实现自动化测试。
• 无法得到测试的报告，需要程序员自己去观察测试是否成功。

Junit单元测试框架

• JUnit是使用Java语言实现的单元测试框架，它是第三方公司开源出来的，很多开发工具已经集成了Junit框架，比如IDEA。

优点

• 编写的测试代码很灵活，可以指某个测试方法执行测试，也支持一键完成自动化测试。
• 不需要程序员去分析测试的结果，会自动生成测试报告出来。
• 提供了更强大的测试能力。

需求

• 某个系统，有多个业务方法，请使用Junit框架完成对这些方法的单元测试。

具体步骤

1. 将Junit框架的jar包导入到项目中（注意：IDEA集成了Junit框架，不需要我们自己手工导入了）。
2. 编写测试类、测试类方法（注意：测试方法必须是公共的，无参数，无返回值的非静态方法）。
3. 【灵魂】必须在测试方法上使用@Test注解（标注该方法是一个测试方法）。（在报错的地方使用alt+enter，导入JUnit4。这个是经典版本，但是版本5可读性更好。）
4. 在测试方法中，编写程序调用被测试的方法即可。（测试某个方法直接右键该方法启动测试。测试全部方法，可以选择类或者模块启动。）
5. 选中测试方法，右键选择“JUnit运行” ，如果测试通过则是绿色；如果测试失败，则是红色。

先准备一个类，假设写了一个StringUtil工具类，代码如下

public class StringUtil{
    public static void printNumber(String name){
        System.out.println("名字长度："+name.length());
    }
}

接下来，写一个测试类，测试StringUtil工具类中的方法能否正常使用。

public class StringUtilTest{
    @Test
    public void testPrintNumber(){
        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }
}

写完代码之后，我们会发现测试方法左边，会有一个绿色的三角形按钮。点击这个按钮，就可以运行测试方法。

单元测试断言

断言：意思是程序员可以预测程序的运行结果，检查程序的运行结果是否与预期一致。**

我们在StringUtil类中新增一个测试方法

public static int getMaxIndex(String data){
    if(data == null){
        return -1;
    }
    return data.length();
}

接下来，我们在StringUtilTest类中写一个测试方法

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);
        
        //断言机制：预测index2的结果
        Assert.assertEquals("方法内部有Bug",4,index2);
    }
}

运行测试方法，结果预期值与实际值不一致。

Junit框架的常见注解

常见注解(Junit 4.xxxx版本)

1. @Test。测试方法。
2. @Before。用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。
3. @After。用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。
4. @BeforeClass。用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。
5. @AfterClass。用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。

特点如下

1.被@BeforeClass标记的方法,执行在所有方法之前
2.被@AfterCalss标记的方法，执行在所有方法之后
3.被@Before标记的方法，执行在每一个@Test方法之前
4.被@After标记的方法，执行在每一个@Test方法之后

常见注解(Junit 5.xxxx版本)

1. @Test。测试方法。
2. @BeforeEach。用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。
3. @AfterEach。用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。
4. @BeforeAll。用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。
5. @AfterAll。用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。

• 开始执行的方法:初始化资源。
• 执行完之后的方法:释放资源。

作用？应用场景？

假设我想在每个测试方法中使用Socket对象，并且用完之后，需要把Socket关闭。代码就可以按照下面的结构来设计

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对象
        socket = new Socket();
    }
    @After
    public void test2(){
        System.out.println("--> test2 After 执行了");
    }
    @AfterCalss
    public static void test22(){
        System.out.println("--> test22 AfterCalss 执行了");
         //关闭Socket
        socket.close();
    }
}

反射

认识反射Reflection

【核心思想】得到编译以后的class文件对象。

• 反射指的是允许以编程方式访问已加载类的成分（成员变量、方法、构造器等）。
• 在java.lang.reflect包中。
• 主要是用来做框架的。好理解一点，我们在写代码的时候，IDEA给我们提示的可以调用的方法。

反射学什么？

1. 加载类，获取类的字节码：Class对象。
   1. 反射第一步：获取类：Class。
   2. 获取类的构造器：Constructor。
   3. 获取类的成员变量：Field。
   4. 获取类的成员方法：Method。
2. 获取类的构造器：Constructor对象。
3. 获取类的成员变量：Field对象。
4. 获取类的成员方法：Method对象。

之后再看反射的应用场景。

获取类

反射第一步，获取Class类的对象。（3种方式。）

1. Class c1 = 类名.class。
2. 调用Class提供的方法：public static Class.forName(String package)。
3. Object提供的方法：public Class getClass()。

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); //true
        
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c2 == c3); //true
    }
}

获取类的构造器

Class类提供的几个方法

1. Constructor<?>[] getConstructors()。返回所有构造器对象的数组（只能拿public的）。
2. Constructor<?>[] getDeclaredConstructors()。返回所有构造器对象的数组，存在就能拿到。
3. Constructor getConstructor(Class<?>… parameterTypes)。返回单个构造器对象（只能拿public的）。
4. Constructor getDeclaredConstructor(Class<?>… parameterTypes)。返回单个构造器对象，存在就能拿到。

方便记忆：

get:获取
Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的
Constructor: 构造方法的意思
后缀s: 表示可以获取多个，没有后缀s只能获取一个

假设现在有一个Cat类，里面有几个构造方法，代码如下：

public class Cat{
    private String name;
    private int age;
    
    public Cat(){
        
    }
    
    private Cat(String name, int age){
        
    }
}

接下来，我们写一个测试方法，来测试获取类中所有的构造器：

public class Test2Constructor(){
    @Test
    public void testGetConstructors(){
        //1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        
        //2、获取类的全部构造器
        Constructor[] constructors = c.getDeclaredConstructors();
        //3、遍历数组中的每一个构造器对象。
        for(Constructor constructor: constructors){
            System.out.println(constructor.getName()+"---> 参数个数："+constructor.getParameterCount());
        }
    }
}

刚才的是获取Cat类中所有的构造器，接下来试一试单个构造器：

public class Test2Constructor(){
    @Test
    public void testGetConstructor(){
        //1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        
        //2、获取类public修饰的空参数构造器
        Constructor constructor1 = c.getConstructor();
        System.out.println(constructor1.getName()+"---> 参数个数："+constructor1.getParameterCount());
        
        //3、获取private修饰的有两个参数的构造器，第一个参数String类型，第二个参数int类型
        Constructor constructor2 = 
            c.getDeclaredConstructor(String.class,int.class);
        
        System.out.println(constructor2.getName()+"---> 参数个数："+constructor1.getParameterCount());

    }
}

获取类构造器的作用

初始化对象返回。注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。

1. T newInstance(Object… initargs)。根据指定的构造器创建对象。（反射后的构造器依然是创建对象的。）
2. public void setAccessible(boolean flag)。设置为true,表示取消访问检查，进行暴力反射。（–>反射会破坏封装性，私有的也可以执行了。）

代码演示

constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来

由于构造器是private修饰的，先需要调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。

代码如下：为了看到构造器真的执行， 故意在两个构造器中分别加了两个打印语句

注意：上面这种代码风格，看起来没什么必要，可以先稍微记一记，以后学习框架的时候有用。

获取类的成员变量&使用

Class类中提供的获取成员变量的方法

1. Field[] getFields()。返回所有成员变量对象的数组（只能拿public的）。
2. Field[] getDeclaredFields()。返回所有成员变量对象的数组，存在就能拿到。
3. Field getField(String name)。返回单个成员变量对象（只能拿public的）。
4. Field getDeclaredField(String name)。返回单个成员变量对象，存在就能拿到。

记忆规则

get:获取
Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的
Field: 成员变量的意思
后缀s: 表示可以获取多个，没有后缀s只能获取一个

获取成员变量的作用

依然是在某个对象中取值、赋值。

Field类中用于取值、赋值的方法

1. void set(Object obj, Object value)。赋值。
2. Object get(Object obj)。获取值。
3. setAccessible(boolean)。如果某成员变量是非public的，需要打开权限（暴力反射），然后再取值、赋值。

代码演示

• 设有一个Cat类它有若干个成员变量，用Class类提供 的方法将成员变量的对象获取出来。

执行完上面的代码之后，我们可以看到控制台上打印输出了，每一个成员变量的名称和它的类型。

• 获取到成员变量的对象之后该如何使用呢？

在Filed类中提供给给成员变量赋值和获取值的方法：

1. void set(object obj,Object value)。赋值。
2. object get(object obj)。取值。
3. public voidsetAccessible(boolean flag)。设置为true，表示禁止检查访问控制(暴力反射)。

再次强调一下设置值、获取值的方法时Filed类的需要用Filed类的对象来调用，而且不管是设置值、还是获取值，都需要依赖于该变量所属的对象。代码如下

获取类的成员方法

使用反射技术获取方法对象并使用

• 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。

Class类中用于获取成员方法的方法

1. Method[] getMethods()。返回所有成员方法对象的数组（只能拿public的）。
2. Method[] getDeclaredMethods()。返回所有成员方法对象的数组，存在就能拿到。
3. Method getMethod(String name, Class<?>… parameterTypes)。返回单个成员方法对象（只能拿public的）。
4. Method getDeclaredMethod(String name, Class<?>… parameterTypes)。返回单个成员方法对象，存在就能拿到。

使用反射技术获取方法对象并使用

• 获取成员方法的作用依然是在某个对象中进行执行此方法。

Method类中用于触发执行的方法

1. Object invoke(Object obj, Object… args)。
   • 参数一：用obj对象调用该方法
   • 参数二：调用方法的传递的参数（如果没有就不写）
   • 返回值：方法的返回值（如果没有就不写）
2. setAccessible(boolean)。如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行。

把run()方法和eat(String name)方法执行起来。看分割线之下的代码

public class Test3Method{
    public static void main(String[] args){
        //1、反射第一步：先获取到Class对象
        Class c = Cat.class;
        
        //2、获取类中的全部成员方法
        Method[] methods = c.getDecalaredMethods();
        
        //3、遍历这个数组中的每一个方法对象
        for(Method method : methods){
            System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());
        }
        
        System.out.println("-----------------------");
        //4、获取private修饰的run方法，得到Method对象
        Method run = c.getDecalaredMethod("run");
        //执行run方法,在执行前需要取消权限检查
        Cat cat = new Cat();
        run.setAccessible(true);
        Object rs1 = run.invoke(cat);
        System.out.println(rs1)
        
        //5、获取private 修饰的eat(String name)方法，得到Method对象
        Method eat = c.getDeclaredMethod("eat",String.class);
        eat.setAccessible(true);
        Object rs2 = eat.invoke(cat,"鱼儿");
        System.out.println(rs2)
    }
}

作用、应用场景

作用

1. 基本作用：得到一个类的全部成分然后操作；
2. 破坏封装性；
3. 最重要的用途：适合做Java的框架，基本上，主流的框架都会基于反射设计出一些通用的功能。

一个简易的框架

步骤

1.先写好两个类，一个Student类和Teacher类
2.写一个ObjectFrame类代表框本架
	在ObjectFrame类中定义一个saveObject(Object obj)方法，用于将任意对象存到文件中去
	参数：Object obj: 就表示要存入文件中的对象
	
3.编写方法内部的代码，往文件中存储对象的属性名和属性值
	1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。
	2)接着就通过反射获取类的成员变量信息了（变量名、变量值）
	3)把变量名和变量值写到文件中去

写一个ObjectFrame表示自己设计的框架，代码如下图所示

public class ObjectFrame{
    public static void saveObject(Object obj) throws Exception{
        PrintStream ps = 
            new PrintStream(new FileOutputStream("模块名\\src\\data.txt",true));
        //1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。
		//2)接着就通过反射获取类的成员变量信息了（变量名、变量值）
        Class c = obj.getClass(); //获取字节码
        ps.println("---------"+class.getSimpleName()+"---------");
        
        Field[] fields = c.getDeclaredFields(); //获取所有成员变量
		//3)把变量名和变量值写到文件中去
        for(Field field : fields){
            String name = field.getName();
            Object value = field.get(obj)+"";
            ps.println(name);
        }
        ps.close();
    }
}

使用自己设计的框架，往文件中写入Student对象的信息和Teacher对象的信息。

先准备好Student类和Teacher类

public class Student{
    private String name;
    private int age;
    private char sex;
    private double height;
    private String hobby;
}

public class Teacher{
    private String name;
    private double salary;
}

创建一个测试类，在测试中类创建一个Student对象，创建一个Teacher对象，用ObjectFrame的方法把这两个对象所有的属性名和属性值写到文件中去。

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 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。

自定义注解 — 格式

自定义注解就是自己做一个注解来使用。

public @interface 注解名称 {
	public 属性类型 属性名() default 默认值 ;
}

• 属性类型：Java支持的数据类型基本上都支持。

注解的作用

• 对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定。
• 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

特殊属性

• value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写!!
• 但是如果有多个属性, 且多个属性没有默认值，那么value名称是不能省略的。

比如：现在我们自定义一个MyTest注解

public @interface MyTest{
    String aaa();
    boolean bbb() default true;	//default true 表示默认值为true,使用时可以不赋值。
    String[] ccc();
}

定义好MyTest注解之后，我们可以使用MyTest注解在类上、方法上等位置做标记。注意使用注解时需要加@符号，如下

@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})
public class AnnotationTest1{
    @MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"})
    public void test1(){
        
    }
}

注意：注解的属性名如何是value的话，并且只有value没有默认值，使用注解时value名称可以省略。比如现在重新定义一个MyTest2注解

public @interface MyTest2{
    String value(); //特殊属性
    int age() default 10;
}

定义好MyTest2注解后，再将@MyTest2标记在类上，此时value属性名可以省略，代码如下

@MyTest2("孙悟空") //等价于 @MyTest2(value="孙悟空")
@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})
public class AnnotationTest1{
    @MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"})
    public void test1(){
        
    }
}

注解的本质是接口

想要搞清楚注解本质是什么东西，我们可以把注解的字节码进行反编译，使用XJad工具进行反编译。经过对MyTest1注解字节码反编译我们会发现：

1.MyTest1注解本质上是接口，每一个注解接口都继承子Annotation接口
2.MyTest1注解中的属性本质上是抽象方法
3.@MyTest1实际上是作为MyTest接口的实现类对象
4.@MyTest1(aaa="孙悟空",bbb=false,ccc={"Python","前端","Java"})里面的属性值，可以通过调用aaa()、bbb()、ccc()方法获取到。 【别着急，继续往下看，再解析注解时会用到】

元注解

元注解：注解注解的注解。

元注解有两个：

• @Target: 约束自定义注解只能在哪些地方使用。
• @Retention：申明注解的生命周期。

@Target注解和@Retention注解

@Target是用来声明注解只能用在那些位置，比如：类上、方法上、成员变量上等
@Retetion是用来声明注解保留周期，比如：源代码时期、字节码时期、运行时期

@Target元注解的使用：

比如定义一个MyTest3注解，并添加@Target注解用来声明MyTest3的使用位置

@Target(ElementType.TYPE)	//声明@MyTest3注解只能用在类上
public @interface MyTest3{
    
}

接下来，把@MyTest3用来类上观察是否有错，再把@MyTest3用在方法上、变量上再观察是否有错。

如果我们定义MyTest3注解时，使用@Target注解属性值写成下面样子

//声明@MyTest3注解只能用在类上和方法上
@Target({ElementType.TYPE,ElementType.METHOD})	
public @interface MyTest3{
    
}

再观察，@MyTest用在类上、方法上、变量上是否有错。

@Retetion元注解的使用

定义MyTest3注解时，给MyTest3注解添加@Retetion注解来声明MyTest3注解保留的时期。

@Retetion是用来声明注解保留周期，比如：源代码时期、字节码时期、运行时期
	@Retetion(RetetionPloicy.SOURCE): 注解保留到源代码时期、字节码中就没有了
	@Retetion(RetetionPloicy.CLASS): 注解保留到字节码中、运行时注解就没有了
	@Retetion(RetetionPloicy.RUNTIME)：注解保留到运行时期
	【自己写代码时，比较常用的是保留到运行时期】

//声明@MyTest3注解只能用在类上和方法上
@Target({ElementType.TYPE,ElementType.METHOD})	
//控制使用了@MyTest3注解的代码中，@MyTest3保留到运行时期
@Retetion(RetetionPloicy.RUNTIME)
public @interface MyTest3{
    
}

解析注解

注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。

• 可以通过反射技术把类上、方法上、变量上的注解对象获取出来，然后通过调用方法就可以获取注解上的属性值了。

解析注解套路如下

1.如果注解在类上，先获取类的字节码对象，再获取类上的注解
2.如果注解在方法上，先获取方法对象，再获取方法上的注解
3.如果注解在成员变量上，先获取成员变量对象，再获取变量上的注解
总之：注解在谁身上，就先获取谁，再用谁获取谁身上的注解

Class 、Method、Field,Constructor、都实现了AnnotatedElement接口，它们都拥有解析注解的能力。

1. public Annotation[]getDeclaredAnnotations()。获取当前对象上面的注解。
2. public TgetDeclaredAnnotation(ClassannotationClass)。获取指定的注解对象。
3. public boolean isAnnotationPresent(class annotationclass)。判断当前对象上是否存在某个注解。

案例需求

1. 定义注解MyTest4，要求如
   • 包含属性:String value()。
   • 包含属性:double aaa()，默认值为 100。
   • 包含属性:Stringllbbb()。
   • 限制注解使用的位置:类和成员方法上。
   • 指定注解的有效范围:一直到运行时。
2. 定义一个类叫:Demo，在类中定义一个test1方法，并在该类和其方法上使用MyTest4注解。
3. 定义AnnotationTest3测试类，解析Demo类中的全部注解。

代码：

① 先定义一个MyTest4注解

//声明@MyTest4注解只能用在类上和方法上
@Target({ElementType.TYPE,ElementType.METHOD})	
//控制使用了@MyTest4注解的代码中，@MyTest4保留到运行时期
@Retetion(RetetionPloicy.RUNTIME)
public @interface MyTest4{
    String value();
    double aaa() default 100;
    String[] bbb();
}

② 定义有一个类Demo

@MyTest4(value="蜘蛛侠",aaa=99.9, bbb={"至尊宝","黑马"})
public class Demo{
    @MyTest4(value="孙悟空",aaa=199.9, bbb={"紫霞","牛夫人"})
    public void test1(){
        
    }
}

③ 写一个测试类AnnotationTest3解析Demo类上的MyTest4注解

public class AnnotationTest3{
    @Test
    public void parseClass(){
        //1.先获取Class对象
        Class c = Demo.class;
        
        //2.解析Demo类上的注解
        if(c.isAnnotationPresent(MyTest4.class)){
            //获取类上的MyTest4注解
            MyTest4 myTest4 = (MyTest4)c.getDeclaredAnnotation(MyTest4.class);
            //获取MyTests4注解的属性值
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(myTest4.bbb());
        }
    }
    
    @Test
    public void parseMethods(){
        //1.先获取Class对象
        Class c = Demo.class;
        
        //2.解析Demo类中test1方法上的注解MyTest4注解
        Method m = c.getDeclaredMethod("test1");
        if(m.isAnnotationPresent(MyTest4.class)){
            //获取方法上的MyTest4注解
            MyTest4 myTest4 = (MyTest4)m.getDeclaredAnnotation(MyTest4.class);
            //获取MyTests4注解的属性值
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(myTest4.bbb());
        }
    }
}

注解的应用场景

注解是用来写框架的，比如现在我们要模拟Junit写一个测试框架，要求有@MyTest注解的方法可以被框架执行，没有@MyTest注解的方法不能被框架执行。

第一步：先定义一个MyTest注解

@Target(ElementType.METHOD)	
@Retetion(RetetionPloicy.RUNTIME)
public @interface MyTest{
    
}

第二步：写一个测试类AnnotationTest4，在类中定义几个被@MyTest注解标记的方法

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();
        
        //1.先获取Class对象
        Class c = AnnotationTest4.class;
        
        //2.解析AnnotationTest4类中所有的方法对象
        Method[] methods = c.getDeclaredMethods();
        for(Method m: methods){
            //3.判断方法上是否有MyTest注解，有就执行该方法
            if(m.isAnnotationPresent(MyTest.class)){
            	m.invoke(a);
        	}
        }
    }
}

动态代理

代理思想就是被代理者没有能力，或者不愿意去完成某件事情，需要找个人（代理）代替自己去完成这件事。

动态代理主要是对被代理对象的行为进行代理。是一个对象。

先把有唱歌和跳舞功能的接口，和实现接口的大明星类定义出来：

动态代理的开发步骤

1. 必须定义接口，里面定义一些行为，用来约束被代理对象和代理对象都要完成的事情。
2. 定义一个实现类实现接口，这个实现类的对象代表被代理的对象。
3. 定义一个测试类，在里面创建被代理对象，然后为其创建一个代理对象返回。（重点）
4. 代理对象中，需要模拟收首付款，真正触发被代理对象的行为，然后接收尾款操作。
5. 通过返回的代理对象进行方法的调用，观察动态代理的执行流程。

如何创建代理对象

• Java中代理的代表类是：java.lang.reflect.Proxy，它提供了一个静态方法，用于为被代理对象，产生一个代理对象返回。

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h) 

为被代理对象返回一个代理对象。
参数一：类加载器 加载代理类，产生代理对象。，。
参数二：真实业务对象的接口。(被代理的方法交给代理对象)
参数三：代理的核心处理程序。

写一个为BigStar生成动态代理对象的工具类。这里需要用Java为开发者提供的一个生成代理对象的类叫Proxy类。

通过Proxy类的newInstance(…)方法可以为实现了同一接口的类生成代理对象。 调用方法时需要传递三个参数：

public class ProxyUtil {
    public static Star createProxy(BigStar bigStar){
       /* newProxyInstance(ClassLoader loader,
                Class<?>[] interfaces,
                InvocationHandler h)
                参数1：用于指定一个类加载器
                参数2：指定生成的代理长什么样子，也就是有哪些方法
                参数3：用来指定生成的代理对象要干什么事情
                */
        // Star starProxy = ProxyUtil.createProxy(s);
        // starProxy.sing("好日子") starProxy.dance()
        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对象生成代理对象

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，并完成相关功能，且统计每个功能的耗时。
• 定义测试类，创建实现类对象，调用方法。

现有如下代码

/**
 *  用户业务接口
 */
public interface UserService {
    // 登录功能
    void login(String loginName,String passWord) throws Exception;
    // 删除用户
    void deleteUsers() throws Exception;
    // 查询用户，返回数组的形式。
    String[] selectUsers() throws Exception;
}

UserService接口的实现类，每一个方法中要计算方法运行时间：

/**
 * 用户业务实现类（面向接口编程）
 */
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的主要业务代码。接下来打算把计算每一个方法的耗时操作交给代理对象来做。

优化的关键步骤

1. 必须有接口，实现类要实现接口（代理通常是基于接口实现的）。
2. 创建一个实现类的对象，该对象为业务对象，紧接着为业务对象做一个代理对象。

先在UserService类中把计算耗时的代码删除，代码如下

/**
 * 用户业务实现类（面向接口编程）
 */
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生成一个动态代理对象，在动态代理中调用目标方法，在调用目标方法之前和之后记录毫秒值，并计算方法运行的时间。代码如下

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创建代理对象

/**
 * 目标：使用动态代理解决实际问题，并掌握使用代理的好处。
 */
public class Test {
    public static void main(String[] args) throws Exception{
        // 1、创建用户业务对象。
        UserService userService = ProxyUtil.createProxy(new UserServiceImpl());

        // 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方法。

动态代理的优点

• 可以在不改变方法源码的情况下，实现对方法功能的增强，提高了代码的复用。
• 简化了编程工作、提高了开发效率，同时提高了软件系统的可扩展性。
• 可以为被代理对象的所有方法做代理。
• 非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。