Java --> 单元测试、反射、注解、动态代理

 温馨提示：由于图片中内容较多，字节很小，选中图片右键选择 ”在新标签页中打开图片“，在新的页面中可放大查看~

 

• 步骤：单元测试的快速入门

需求：使用单元测试进行业务方法预期结果、正确性测试的快速入门

分析：

1. 将JUnit的jar包导入到项目中

• IDEA通常整合好了JUnit框架，一般不需要导入
• 如果IEDA没有整合好，需要自己手工导入如下hamcrest-core-1.3.jar library root、junit-4.12.jar library root

2.编写测试方法：改测试方法必须是 公开的、无参数、无返回值的 非静态方法

3.在测试方法上使用@Test注解 ：标注改方法是一个测试方法

4.在测试方法中完成被测试方法的预期正确性测试

5.选中测试方法，选择”JUnit运行“，如果测试良好则是绿色、测试失败是红色

 

//Junit单元测试
public class UserService {
    public String loginName(String loginName, String password){
        String ret = "登录成功";
        if ("admin".equals(loginName) && "123456".equals(password)){
            return ret;
        }else {
            return "登录失败";
        }
    }
    public void selectNames(){
        System.out.println(10 / 0);
        System.out.println("查询用户名完成");
    }
}

 

import org.junit.*;

//测试类
public class TestUserService {
    //修饰实例方法的
    @Before
    public void before(){
        System.out.println("-------before()执行一次--------");
    }
    @After
    public void after(){
        System.out.println("-----------after()执行一次----------------");
    }

    //修饰静态犯法
    @BeforeClass
    public static void beforeClass(){
        System.out.println("-----------beforClass()执行一次------------");
    }
    @AfterClass
    public static void afterClass(){
        System.out.println("-----------afterClass()执行一次----------------");
    }


    /** 1、测试方法必须：公开、无参、无返回值、非静态
        2、测试方法必须使用@Test注解标记
     */
    @Test //第一次导入建议联网【alt + 回车】
    public void testLoginName(){
        UserService userService = new UserService();
        String ret = userService.loginName("admin","123456");

        //预期结果正确性测试结果 断言
        Assert.assertEquals("您的登录功能可能出现问题","登录成功",ret);
    }

    @Test
    public void testSelectName(){
        UserService userService = new UserService();
        userService.selectNames();
    }
}

 

•  反射：获取Class类对象

//反射的第一步：获取Class类对象
public class Test {
    public static void main(String[] args) throws Exception{
        //包名 + 类名 ==> 全限名
        //1、使用Class类中的静态方法：forName()
        Class c = Class.forName("com.companyName.d2_reflect_class.Student");
        System.out.println(c);

        //2、类名.class
        Class c1 = Student.class;
        System.out.println(c1);

        //3、对象.getClass() : 获取对象对应类的Class对象
        Student student = new Student();
        Class c2 = student.getClass();
        System.out.println(c2);
    }
}

public class Student {
}

 

 从运行结果也可以看出，这三个类对象c、c1、c2均为同一个类对象，因为它们指向同一个地址

• 使用反射获取构造器对象并使用

1. 获取class类对象
2. 获取Constructo对象
3. 创建对象【构造器是用来创建对象的】

public class Student {
    private String name;
    private int age;

    private Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import org.junit.Test;

import java.lang.reflect.Constructor;

//使用反射获取类对象中的构造器
public class TestStudentDemo1 {
    @Test
    public void getConstructors(){
        //1、获取类对象
        Class c1 = Student.class;
        //2、提取类中全部的构造器对象【只能拿到public修饰的构造器】
        Constructor[] constructors = c1.getConstructors();
        //遍历构造器
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "-->" + constructor.getParameterCount());
        }
    }

    @Test
    public void getConstructor() throws Exception{
        //1、获取类对象
        Class c1 = Student.class;
        //2、提取类中某个指定的构造器对象【只能拿到public修饰的构造器】
        Constructor constructor = c1.getConstructor(String.class,int.class);
        //2.1 获取无参数构造器
        Constructor constructor2 = c1.getConstructor(); //无法拿到私有的构造器
        //打印构造器
        System.out.println(constructor.getName() + "-->" + constructor.getParameterCount());
        System.out.println(constructor2.getName() + "-->" + constructor2.getParameterCount());
    }

    @Test
    public void getDeclaredConstructor() throws Exception{
        //1、获取类对象
        Class c1 = Student.class;
        //2、提取类中某个指定的构造器对象【无权限限制】
        Constructor constructor = c1.getDeclaredConstructor(String.class,int.class);
        //2.1 获取无参数构造器
        Constructor constructor2 = c1.getDeclaredConstructor();
        //打印构造器
        System.out.println(constructor.getName() + "-->" + constructor.getParameterCount());
        System.out.println(constructor2.getName() + "-->" + constructor2.getParameterCount());
    }
}

 

import org.junit.Test;

import java.lang.reflect.Constructor;

//拿到构造器后创建对象
public class TestStudentDemo2 {
    @Test
    public void getDeclaredConstructor() throws Exception{
        Class c = Student.class;
        Constructor constructor = c.getDeclaredConstructor();
        //如果构造器私有则打开权限【暴力反射】<仅仅打开这一次>
        constructor.setAccessible(true);
        Student student =  (Student) constructor.newInstance(); //返回Student类型的对象
        System.out.println(student);

        //公开的构造器无需打开权限
        Constructor constructor1 =  c.getDeclaredConstructor(String.class,int.class);
        Student student1 = (Student) constructor1.newInstance("大熊", 6);
        System.out.println(student1);
    }
}

 

public class Student {
    private String name;
    private int age;
    public static String schoolName;
    public static final String COUNTRY = "China";

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static String getSchoolName() {
        return schoolName;
    }

    public static void setSchoolName(String schoolName) {
        Student.schoolName = schoolName;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import org.junit.Test;

import java.lang.reflect.Field;

public class FieldDemo1 {
    @Test
    public void getDeclaredFields(){
        //获取Class类对象
        Class c = Student.class;
        //获取全部成员变量
        Field[] fields = c.getDeclaredFields();
        //遍历数组
        for (Field field : fields) {
            System.out.println(field.getName() + "-->" + field.getType());
        }
    }

    @Test
    public void getDeclaredField() throws Exception{
        //获取Class类对象
        Class c = Student.class;
        //获取某个指定的成员变量
        Field field = c.getDeclaredField("name");
        field.setAccessible(true);
        System.out.println(field.getName() + "-->" + field.getType());

        //赋值
        Student student = new Student();
        field.set(student,"张楠");
        System.out.println(student);

        //取值
        String name = (String) field.get(student);
        System.out.println(name);
    }
}

public class Dog {
    private String name;
    public Dog(){

    }

    public Dog(String name){
        this.name = name;
    }

    public void eat(){
        System.out.println("狗吃骨头");
    }

    private String eat(String name){
        System.out.println(name + "吃骨头");
        return "吃的很开心";
    }

    public static void inAddress(){
        System.out.println("北京市朝阳区平安街32号宠物诊所");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

import org.junit.Test;

import java.lang.reflect.Method;

public class MethodDemo {
    @Test
    public void getDeclaredMethods(){
        //获取类对象
        Class d = Dog.class;
        //提取全部的方法【包括私有的】
        Method[] methods = d.getDeclaredMethods();
        //遍历全部方法
        for (Method method : methods) {
            //拓展：方法的名称、返回值类型
            System.out.println("方法名：" + method.getName() + "-->" + "返回值类型：" + method.getReturnType()
            + ",参数个数：" + method.getParameterCount());
        }
    }
    @Test
    public void getDeclaredMethod() throws Exception{
        Class d = Dog.class;
        //拿到某个指定的方法
        Method method = d.getDeclaredMethod("eat"); //拿到无参构造器
        Method method1 = d.getDeclaredMethod("eat", String.class); //拿到有参构造器

        //触发方法的执行
        Dog dog = new Dog();
        Object ret = method.invoke(dog);
        System.out.println(ret);

        method1.setAccessible(true);
        Object ret2 = method1.invoke(dog,"小汪");
        System.out.println(ret2);
    }
}

•  反射的作用：

一、绕过编译阶段为集合添加数据

• 反射是作用在运行时的技术，此时集合的泛型将不能产生数据了，此时可以为集合存入其它任意类型的元素的。
• 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段但的时候，其真实类型都是ArrayList了，泛型相当于被擦出了。

import java.lang.reflect.Method;
import java.util.ArrayList;

//反射实现绕过编译阶段在集合中添加数据
public class ReflectDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        System.out.println(list.getClass());
        System.out.println(list2.getClass());

        System.out.println(list.getClass() == list2.getClass());

        list.add("张一栋");
        list.add("李斯");
     //   list.add(32); //报错

        //获取list的Class类对象
        Class c = list.getClass();
        //public boolean add(E e)
        //定位c类中的add方法
        try {                                     //方法名         任意类型
            Method addMethod = c.getDeclaredMethod("add",Object.class);
            addMethod.invoke(list,32);
            System.out.println(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        //其实，不使用反射也是可以做到的
        ArrayList list3 = new ArrayList<>();
        list3 = list;
        list3.add(89);
        System.out.println(list3);
    }
}

 

•  案例：反射做通用框架
• 需求：给你任意一个对象，在不清楚对象字段的情况可以把对象的字段和对应值存储到文件中去

 分析：

1. 定义一个方法，可以接受任意对象
2. 每次收到一个对象，解析这个对象的全部成员变量名称
3. 这个对象可能是任意的，那么怎么样才可以知道这个对象的全部成员变量呢？【只有反射可以解决】
4. 使用反射获取对象的Class类对象，然后获取全部成员变量信息
5. 遍历成员变量信息，然后提取本成员变量在对象中的具体值
6. 存入成员变量名称和值到文件中去即可

两个类就只截取较为关键的字段信息

 

 

 

 

import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;

public class MybatisUtil {
    public static void save(Object obj){
        try(
                FileOutputStream fileOutputStream = new FileOutputStream("junit-reflect-annotation-proxy-app/src/data.txt",true);
                PrintStream printStream = new PrintStream(fileOutputStream);
        ){
        //提取这个对象的全部成员变量【只有反射可以解决】
        Class c = obj.getClass();
        //获取当前类名
        System.out.println("============" + c.getSimpleName() + "===============");
        //获取它的全部成员变量对象
        Field[] fields = c.getDeclaredFields();
        //获取成员变量的信息
        for (Field field : fields) {
            //字段名
            String name = field.getName();
            //属性
            /** 源码解释
             * Returns:
             * the value of the represented field in object obj;
             * 对象obj中表示字段的值
             */
            field.setAccessible(true); //暴力反射
            String value = field.get(obj) + ""; //都要存入文件中，将其变为字符串即可
            printStream.println(name + "==" + value);
            System.out.println(name + "==" + value);
          }
        } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

//提供通用框架可以保存所有对象的具体信息
public class ReflectDemo {
    public static void main(String[] args) {
        Student student = new Student("老六",36,'男',"大二管理学三班",176);
        MybatisUtil.save(student);
        Teacher teacher = new Teacher("张梅",32,"2015060213");
        MybatisUtil.save(teacher);
    }
}

•  注解

 

 

 

 

•  自定义注解

 

 

 

 

•  注解解析的案例

步骤：

1. 定义注解Book，要求如下：包含属性（String title 书名、double price 价格、String[ ]  authors 作者），限制注解的使用范围：类、成员方法上，指定注解的有效范围：RUNTIME
2. 定义BookStore类，在类和成员方法上使用Book注解
3. 定义AnnotationDemo3测试类获取Book注解上的数据

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface BookDemo {
    String title();
    double price() default 100;
    String[] authors();
}

@BookDemo(title = "《平凡的世界》",price = 45.5,authors = {"路遥","Tom"})
public class BookStore {
    @BookDemo(title = "《活着》",price = 25.5,authors = {"余华"})
    public void delete(){

    }
}

import org.junit.Test;

import java.lang.reflect.Method;
import java.util.Arrays;

public class AnnotationDemo3  {
    @Test
    public void parseClass() throws Exception{
        //得到类对象
        Class c = BookStore.class;
        //判断是否存在注解
        if (c.isAnnotationPresent(BookDemo.class)){
            //获取注解对象
            BookDemo bookDemo = (BookDemo) c.getDeclaredAnnotation(BookDemo.class); //拿子类独有的属性
            System.out.println(bookDemo.title());
            System.out.println(Arrays.toString(bookDemo.authors()));
            System.out.println(bookDemo.price());

            System.out.println("-----------拿方法-----------");

            Method method = c.getDeclaredMethod("delete");
            BookDemo bookDemo2 = method.getDeclaredAnnotation(BookDemo.class); //拿子类独有的属性
            System.out.println(bookDemo2.title());
            System.out.println(Arrays.toString(bookDemo2.authors()));
            System.out.println(bookDemo2.price());
        }
    }
}

•  注解的应用场景：模拟Junit框架

需求：定义若干个方法，只要加了MyTest注释，就可以在启动时被触发执行

1. 自定义一个注解MyTest，只能注解方法，存活范围为一致都在
2. 定义若干个方法，只要有@MyTest注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行

import java.lang.reflect.Method;

//模拟Junit框架
public class SimulationJunitDemo {
    @MyTest
    public void test1(){
        System.out.println("=======test1=========");
    }

    public void test2(){
        System.out.println("=======test2=========");
    }
    @MyTest
    public void test3(){
        System.out.println("=======test3=========");
    }

    //启动有被注解标志的
    public static void main(String[] args) throws Exception{
        SimulationJunitDemo sjd = new SimulationJunitDemo();
        //1、获取类对象
        Class c = SimulationJunitDemo.class;
        //2、获取所有的方法
        Method[] methods = c.getDeclaredMethods();
        //3、遍历，选择具有注解标志的方法执行
        for (Method method : methods) {
            if (method.isAnnotationPresent(MyTest.class)){
                method.invoke(sjd);
            }
        }
    }
}

 

 

•  动态代理

//接口：定义明星必须有表演、唱歌的技能
public interface Skill {
    void act(); //演戏
    void sing(); //唱歌
}

//实现类，创建具体的明星对象，改明星类里必须实现接口定义的方法
public class Star implements Skill{

    private String name;
    public Star(String name){
        this.name = name;
    }

    @Override
    public void act() {
        System.out.println(name + "演戏");
    }

    @Override
    public void sing() {
        System.out.println(name + "唱歌");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class StarAgent {
    //设计一个方法返回一个明星对象的代理对象
    public static Skill getProxy(Star star){
        /*
        * public static Object newProxyInstance(
        *          ClassLoader loader, 类加载器【底层会用自己生成的类加载器加载代理类】
                   Class<?>[] interfaces, 对象实现的接口【对象必须要做的行为在其接口中，用于告诉代理具体执行那些方法】
                   InvocationHandler h) 代理的核心处理逻辑
        * */
        return (Skill) Proxy.newProxyInstance(star.getClass().getClassLoader(),
                star.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("对接额外工作，如收首付款");
                        //让明星真正地行使自己的技能：演戏、唱歌
                        //method ： 表示正在调用的方法
                        Object ret = method.invoke(star,args); //对象：star、 args:实现类中方法的参数
                        System.out.println("对接额外工作完成，收尾款");
                        return ret;
                    }
                });
    }
}

//学习开发出一个代理对象、理解动态代理的执行流程
public class Test {
    public static void main(String[] args) {
        //1、创建要给对象，对象必须实现接口
        Star star = new Star("胡歌");
        //为star对象找一个dialing对象【经纪人】
        Skill star2 = StarAgent.getProxy(star);

        star2.act();
        star2.sing();
    }
}

 

这样，就实现了功能的分化与细化，即胡歌只用关注自己本身的技能 - - 表演和唱歌，而经纪人负责对其额外的工作。

• 案例：模拟企业业务开发，并完成每个功能的性能统计
• 模拟某企业用户管理业务，需包含用户登录，用户删除，用户查询等功能，并要统计每个功能的耗时

分析：

1. 定义一个UserService表示用户业务接口，规定必须完成用户登录、删除、查询等功能
2. 定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时
3. 定义测试类，创建类对象，调用方法

public interface UserService {
    String login(String loginName, String password);
    void deleteUser();
    String selectUsers();
}

//使用代理，可以将注释部分的（即相同业务逻辑功能的）代码交给代理(工具类)来处理
//可以看出，代理对于做通用功能的框架技术是很有优势的
public class UserServiceImpl implements UserService{
    @Override
    public String login(String loginName, String password) {
//        long startTime = System.currentTimeMillis();
        System.out.println("正在登录中...");
        String str = "登录失败";
        if ("admin".equals(loginName) && "123".equals(password)){
            str = "登录成功";
        }
        try {
            Thread.sleep(1500);
        } catch (Exception e) {
            e.printStackTrace();
        }
//        long endTime = System.currentTimeMillis();
        System.out.println("登录方法调用完毕......");
//        System.out.println("login方法耗时：" + (endTime - startTime) / 1000.0 + "s");
        return str;
    }

    @Override
    public void deleteUser() {
//        long startTime = System.currentTimeMillis();
        System.out.println("正在删除用户中......");
        try {
            System.out.println("正在删除用户~");
            Thread.sleep(2500);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("删除用户操作完成......");
//        long endTime = System.currentTimeMillis();
//        System.out.println("deleteUser方法耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    @Override
    public String selectUsers() {
//        long startTime = System.currentTimeMillis();
        System.out.println("正在查询中...");
        String str = "登录失败";
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("查询方法调用完毕......");
//        long endTime = System.currentTimeMillis();
//        System.out.println("selectUsers方法耗时：" + (endTime - startTime) / 1000.0 + "s");
        return str;
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {
    //通过一个静态方法为用户的业务对象返回代理对象
    public static UserService getProxy(UserServiceImpl userService){
        return (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long startTime = System.currentTimeMillis();
                        Object obj = method.invoke(userService,args);
                        long endTime = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时：" + (endTime - startTime) / 1000.0 + "s") ;
                        return obj;
                    }
                });
    }
}

public class Test {
    public static void main(String[] args) {
//        UserService userService = new UserServiceImpl(); //多态
//        System.out.println(userService.login("admin", "123"));
//        userService.deleteUser();
//        userService.selectUsers();

        UserService userService = ProxyUtil.getProxy(new UserServiceImpl());
        userService.login("admin","123");
        userService.deleteUser();
        userService.selectUsers();
    }
}

 

 使用泛型可以接收任意类型的实现类对象做代理：