day17【测试单元、反射、注解】

野性酷女 2022-09-04 01:55 139阅读 0赞

# day17【测试单元、反射、注解】 #

# 一、测试单元 #

## 1.1 Junit的概述 ##

我们知道程序的入口是main方法，想要执行任何的代码都必须编写一个main方法；而一个类中只能有一个main方法，有时我们仅仅想要测试某段代码的运行而已，这样会导致类的数量变得很多，且都是测试类；

Junit是一个单元测试框架，只需要在我们自己定义的任何方法上面标注一个`@Test`注解，那么这个方法就可以单独的独立运行了，再也不需要main方法了，Junit属于第三方工具，一般情况下需要导入jar包。不过，多数Java开发环境已经集成了JUnit作为单元测试工具，我们的idea开发工具就已经集成Junit单元测试框架了；

*  Junit官网：[https://junit.org/junit5/][https_junit.org_junit5]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

## 1.2 Junit的简单使用 ##

Junit的使用非常简单，我们定义一个任意的方法，在方法的上面标注一个`@Test`注解即可；

package com.dfbz.demo01;
    
    import org.junit.Test;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        // 标注一个@Test注解
        @Test
        public void demo01(){ 
            System.out.println("我是Junit");
        }
    }

标注完@Test注解后，按住`Alt+回车`，引入Junit依赖：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

依赖引入完毕之后，左边出现一个可运行的按钮：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

## 1.3 Junit常用注解 ##

*  `@Before`：在执行每个测试方法**之前**都会执行一次
 *  `@After`：在执行每个测试方法**之后**都会执行一次
 *  `@BeforeClass`：在执行每个测试方法**之前**执行一次，比`@Before`**更先**执行，方法必须被static修饰
 *  `@AfterClass`：在执行每个测试方法**之后**执行一次，比`@After`**更后**执行，方法必须被static修饰

示例代码：

package com.dfbz.demo01;
    
    import org.junit.*;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
    
    
        @BeforeClass
        public static void init() {          // 一般用于资源的初始化
            System.out.println("BeforeClass...");
        }
    
        @Before
        public void before() { 
            System.out.println("Before...");
        }
    
        /* 测试方法 */
        @Test
        public void test1() { 
            System.out.println("test1...");
        }
    
        /* 测试方法 */
        @Test
        public void test2() { 
            System.out.println("test2...");
        }
    
        @After
        public void after() { 
            System.out.println("After");
        }
    
        @AfterClass
        public static void destory() {           // 一般用于释放系统资源
            System.out.println("AfterClass...");
        }
    }

# 二、反射 #

## 2.1 类加载器 ##

我们之前学习过JVM的内存划分，当Java程序运行时，会将指定的类首先加载到方法区，方法区保存该类一些基本信息，例如有哪些成员、变量、构造方法，以及这些变量的修饰符等，最终将类的实体存储在堆内存；

而`将类加载到内存`这一过程则是由类加载器（ClassLoader）来完成的；Java中类加载器共分为3种：

*  **启动类加载器（BootstrapClassLoader）：** 是嵌在JVM内核中的加载器，该加载器是用C++语言写的，主要负则加载JAVA\_HOME/lib下的类库，启动类加载器无法被应用程序直接使用。
 *  \*\*扩展类加载器（Extension ClassLoader）：\*\*该加载器器是用JAVA编写，且它的父类加载器是Bootstrap，是由sun.misc.Launcher$ExtClassLoader实现的，主要加载`JAVA_HOME/lib/ext`目录中的类库。开发者可以这几使用扩展类加载器。
 *  \*\*系统类加载器（App ClassLoader）：\*\*系统类加载器，也称为应用程序类加载器，负责加载应用程序classpath目录下的所有jar和class文件（第三方jar）。它的父加载器为`Ext ClassLoader`。

通过类加载器获取资源：

通过类加载器可以获取src下的任意一个资源，**此类加载器必须是`App ClassLoader`类加载器**

在src目录下新建一个hello.txt：

我是中国人

使用类加载器

package com.dfbz.demo01;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws IOException { 
    
            // 获取类加载器(类加载器类型为App classloader)
            ClassLoader classLoader = Demo01.class.getClassLoader();
    
            // 通过类加载获取类路径下的资源(src下)
            InputStream is = classLoader.getResourceAsStream("hello.txt");
    
            // 包装成缓冲字符流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
    
            String str = br.readLine();
    
            System.out.println(str);
    
            br.close();
        }
    }

## 2.2 Class类 ##

反射是Java中的一种机制，可以通过Java代码对一个类进行解析；例如获取类的属性、方法、构造方法等

Java中一个类被加载到内存中后被`java.lang.Class`类所描述，该类又称字节码类，我们可以通过该类获取所描述的属性、方法、构造方法等；也就是说使用反射就必须先获取到Class对象（字节码对象）；

准备一个Cate类：

*  获取Class对象：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) throws ClassNotFoundException { 
            // 获得Cate的Class的对象
            Class c1 = Cate.class;
            // 打印输出: class com.dfbz.demo01.Cate
            System.out.println(c1);
    
            // 创建学生对象
            Cate Cate = new Cate();
            // 获得学生类的Class对象
            Class c2 = Cate.getClass();
            // 打印输出: class com.dfbz.demo01.Cate
            System.out.println(c2);
    
            // 获得字符串的Class对象
            Class c3 = Class.forName("com.dfbz.demo01.Cate");
            // 打印输出: class com.dfbz.demo01.Cate
            System.out.println(c3);
    
            System.out.println(c1 == c2);       // true
            System.out.println(c2 == c3);       // true
        }
    }

> tips：不管哪种方式获取到的字节码对象始终是同一个，因此类只会被加载一次；

### 2.3.1 Class类相关方法 ###

*  `public String getSimpleName()`： 获得简单类名，只是类名，没有包
 *  `public String getName()`： 获取完整类名，包含包名+类名
 *  `public T newInstance()` ：创建此 Class 对象所表示的类的一个新实例。要求：类必须有public的无参数构造方法

示例代码：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException { 
    
            // 通过全类目的方式获取字节码对象
            Class<Cate> cateClass = (Class<Cate>) Class.forName("com.dfbz.demo01.Cate");
    
            // 获取简单类名
            System.out.println(cateClass.getSimpleName());       // Cate
    
            // 获取字节码对象的全类名
            System.out.println(cateClass.getName());             // com.dfbz.demo01.Cate
    
            // 通过字节码对象创建对象(底层调用的是空参构造方法)
            Cate Cate = cateClass.newInstance();
        }
    }

## 2.3 Constructor类 ##

我们获取到一个类的字节码对象时，可以通过该字节码对象获取类的成员变量、成员方法、构造方法等，`java.lang.reflect.Constructor`类就是用于描述一个构造方法的；类中的每一个构造方法都是Constructor的对象，通过Constructor对象可以实例化对象。

### 2.3.1 Class中获取Constructor 相关方法 ###

*  `public Constructor getConstructor(Class... parameterTypes)`根据参数类型获取构造方法对象，**只能获得public修饰的构造方法**。如果不存在对应的构造方法，则会抛出 `java.lang.NoSuchMethodException` 异常。
 *  `Constructor getDeclaredConstructor(Class... parameterTypes)`：根据参数类型获取构造方法对象\*\*，能获取所有的构造方法（public、默认、protected、private ）\*\*。如果不存在对应的构造方法，则会抛出 `java.lang.NoSuchMethodException` 异常。
 *  `Constructor[] getConstructors()`： 获取所有的public修饰的构造方法
 *  `Constructor[] getDeclaredConstructors()`：获取所有构造方法，包括public、默认、protected、private

准备一个Cate类，提供若干构造：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Cate { 
        private String name;            // 美食名称
        private String taste;          // 口味偏重
        private Boolean recommend;      // 是否推荐
    
        // 有参构造
        public Cate(String name, String taste, Boolean recommend) { 
            System.out.println("公共方法");
            this.name = name;
            this.taste = taste;
            this.recommend = recommend;
        }
    
    
        // 受保护的构造
        protected Cate(String name, String taste) { 
            System.out.println("受保护方法");
            this.name = name;
            this.taste = taste;
        }
    
    
        // 默认构造
        Cate(String name) { 
            System.out.println("默认方法");
            this.name = name;
        }
    
    
        // 私有构造
        private Cate(String name, Boolean recommend) { 
            System.out.println("私有方法");
            this.name = name;
            this.recommend = recommend;
        }
    
        // 空参构造
        public Cate() { 
            System.out.println("公共方法");
        }
    
        @Override
        public String toString() { 
            return "Cate{" +
                    "name='" + name + '\'' +
                    ", taste='" + taste + '\'' +
                    ", recommend=" + recommend +
                    '}';
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getTaste() { 
            return taste;
        }
    
        public void setTaste(String taste) { 
            this.taste = taste;
        }
    
        public Boolean getRecommend() { 
            return recommend;
        }
    
        public void setRecommend(Boolean recommend) { 
            this.recommend = recommend;
        }
    }

示例代码：

### 2.3.2 Constructor 常用方法 ###

*  `T newInstance(Object... initargs)`： 根据指定参数创建对象。
 *  `void setAccessible(true)`：开启强制访问，除public修饰的构造方法外，其他构造方法反射都需要暴力反射

示例代码：

package com.dfbz.demo02;
    
    import com.dfbz.demo01.Cate;
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import java.lang.reflect.Constructor;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        static Class<Cate> clazz;
    
        @BeforeClass
        public static void before() { 
            clazz = Cate.class;
        }
    
        @Test
        public void test1() throws Exception {         // 反射 受保护的方法
    
            //获取任何修饰符修饰的构造方法(根据参数列表获取)
            Constructor<Cate> dc = clazz.getDeclaredConstructor(String.class, String.class);
    
            // 开启强制访问(只要不是public修饰的方法都需要开启强制访问)
            dc.setAccessible(true);
    
            // 实例化对象,并传入参数
            Cate cate = dc.newInstance("辣子鸡", "辣");
    
            System.out.println(cate);
            System.out.println("-------------");
        }
    
        @Test
        public void test2() throws Exception {         // 反射默认方法
    
            //获取任何修饰符修饰的构造方法(根据参数列表获取)
            Constructor<Cate> dc = clazz.getDeclaredConstructor(String.class);
    
            // 开启强制访问
            dc.setAccessible(true);
    
            // 实例化对象,并传入参数
            Cate cate = dc.newInstance("新疆馕饼");
    
            System.out.println(cate);
            System.out.println("-------------");
        }
    
        @Test
        public void test3() throws Exception {         // 反射私有方法
    
            Constructor<Cate> dc = clazz.getDeclaredConstructor(String.class, Boolean.class);
    
            // 开启强制访问
            dc.setAccessible(true);
    
            // 实例化对象,并传入参数
            Cate cate = dc.newInstance("猪肉炖粉条",true);
    
            System.out.println(cate);
            System.out.println("-------------");
        }
    
    
        @Test
        public void test6() throws Exception {         // 反射public修饰的构造方法
    
            //获取构造器对象
            Constructor<Cate> dc = clazz.getConstructor(String.class, String.class,Boolean.class);
    
            // 实例化对象,并传入参数
            Cate cate = dc.newInstance("粉蒸肉","鲜香",true);
    
            System.out.println(cate);
            System.out.println("-------------");
        }
    }

## 2.3 Method类 ##

`Method`类是Java中用于描述的方法的一个类，当通过反射获剖析到一个类的方法时返回该对象，通过该对象可以执行该对象封装的方法；

### 2.3.1 Class中获取Method相关方法 ###

*  `public Method getMethod(String name, Class<?>... parameterTypes)`：根据方法名和参数类型获得一个方法对象，只能是获取public修饰的
 *  `public Method getDeclaredMethod(String name, Class<?>... parameterTypes)`：根据方法名和参数类型获得一个方法对象，包含任意修饰符的
 *  `public Method[] getMethods()`：获取所有的public修饰的成员方法，**包括父类中的方法**。
 *  `public Method[] getDeclaredMethods()`：获取当前类中所有的方法，包含任意修饰符的，**但不包括父类中**。

提供一个测试类：

package com.dfbz.demo03;
    
    /** * @author lscl * @version 1.0 * @intro: 测试实体类 */
    public class TestEntity { 
        // 共有方法
        public void a() { 
            System.out.println("我是共有方法");
        }
    
        // 共有有参方法
        public void b(String param) { 
            System.out.println("我是共有方法,传递的参数为: " + param);
        }
    
        // 私有方法
        private void c() { 
            System.out.println("我是私有方法");
        }
    
        // 共有方法
        public static void d() { 
            System.out.println("我静态共有方法");
        }
    
        // 共有方法
        private static void e() { 
            System.out.println("我是静态私有方法");
        }
    }

示例代码：

### 2.3.2 Method常用方法 ###

*  `public Object invoke(Object obj, Object... args)`：根据参数args调用对象obj的该成员方法，如果obj=null，则表示该方法是静态方法
 *  `public void setAccessible(boolean flag)`：开启强制访问，设置为可以直接调用非public修饰的方法
 *  `public String getName()`：获取此对象封装的方法名

示例代码：

package com.dfbz.demo03;
    
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import java.lang.reflect.Method;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        static Class<TestEntity> clazz;
    
        @BeforeClass            // 首先获取到TestEntity的字节码对象(反射的前提)
        public static void before() { 
            clazz = TestEntity.class;
        }
    
    
        @Test
        public void test1() throws Exception {       // 反射共有方法
    
            // 原有对象
            TestEntity testEntity1 = new TestEntity();
    
            // 原有对象
            TestEntity testEntity2 = clazz.newInstance();
    
            // 原有对象
            TestEntity testEntity3 = clazz.getConstructor().newInstance();
    
            // 根据方法名和参数列表 获取对应的方法对象
            Method method = clazz.getMethod("a");
    
            // 执行目标方法(需要传递原有对象来执行)
            Object invoke = method.invoke(testEntity1);
    
            System.out.println(method.getName() + "方法的返回值是: " + invoke);
        }
    
    
        @Test
        public void test2() throws Exception {       // 反射共有有参方法
    
            // 原有对象
            TestEntity testEntity1 = new TestEntity();
    
            // 根据方法名和参数列表获取对应的方法对象
            Method method = clazz.getMethod("b",String.class);
    
            // 执行目标方法(需要传递原有对象来执行),并传递方法参数
            Object invoke = method.invoke(testEntity1,"abc");
    
            System.out.println(method.getName() + "方法的返回值是: " + invoke);
        }
    
    
        @Test
        public void test3() throws Exception {       // 反射私有方法
    
            // 原有对象
            TestEntity testEntity1 = new TestEntity();
    
            // 根据方法名和参数列表 获取对应的方法对象
            Method method = clazz.getDeclaredMethod("c");
    
            // 开启强制访问
            method.setAccessible(true);
    
            // 执行目标方法(需要传递原有对象来执行),并传递方法参数
            Object invoke = method.invoke(testEntity1);
    
            System.out.println(method.getName() + "方法的返回值是: " + invoke);
        }
    
    
        @Test
        public void test4() throws Exception {       // 反射共有静态方法
    
            // 原有对象
            TestEntity testEntity1 = new TestEntity();
    
            // 根据方法名和参数列表 获取对应的方法对象
            Method method = clazz.getMethod("d");
    
            // 执行目标方法,并传递方法参数
            Object invoke = method.invoke(testEntity1);
            Object invoke2 = method.invoke(null);        // 静态方法可以不用对象来调用
    
            System.out.println(method.getName() + "方法的返回值是: " + invoke);
        }
    
    
        @Test
        public void test5() throws Exception {       // 反射私有静态方法
    
            // 原有对象
            TestEntity testEntity1 = new TestEntity();
    
            // 注意:非public修饰的方法需要用getDeclaredMethod()来获取
            Method method = clazz.getDeclaredMethod("e");
    
            // 非public修饰的方法需要开启强制访问
            method.setAccessible(true);
            
            // 执行目标方法,并传递方法参数
            Object invoke = method.invoke(testEntity1);
            Object invoke2 = method.invoke(null);        // 静态方法可以不用对象来调用
    
            System.out.println(method.getName() + "方法的返回值是: " + invoke);
        }
    }

## 2.4 Field类 ##

Field是Java中用于描述成员属性的类，通过反射获取到类的某个属性时，用Field将其封装；当我们获取到Field时，可以通过Field对象来获取属性的值；

### 2.4.1 Class中获取Field相关方法 ###

*  `Field getDeclaredField(String name)`：根据属性名获得属性对象，包括private修饰的
 *  `Field getField(String name)`：根据属性名获得属性对象，只能获取public修饰的
 *  `Field[] getFields()`：获取所有的public修饰的属性对象，返回数组。
 *  `Field[] getDeclaredFields()`：获取所有的属性对象，包括private修饰的，返回数组。

### 2.4.2 Field常用方法 ###

*  `void set(Object obj, Object value)`：给指定的属性设置值
 *  `Object get(Object obj)`：获取属性字段的值
 *  `void setAccessible(boolean flag)`：开启强制访问
 *  `Class getType()`：获取属性的类型，返回Class对象。

在TestEntity类中添加如下属性：

public class TestEntity { 
    
        public String username = "root";
        protected String password = "admin";
        String phone = "110";
        private String email = "110@abc.com";
    }

示例代码：

package com.dfbz.demo04;
    
    import com.dfbz.demo01.Cate;
    import com.dfbz.demo03.TestEntity;
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import java.lang.reflect.Field;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        static Class<TestEntity> clazz;
    
        @BeforeClass            // 首先获取到TestEntity的字节码对象(反射的前提)
        public static void before() { 
            clazz = TestEntity.class;
        }
    
    
        @Test
        public void test1(){                 // 反射所有公有的字段
            Field[] fields = clazz.getFields();
    
            for(Field field:fields){ 
                System.out.println(field);
            }
    
            System.out.println("---------");
        }
    
        @Test
        public void test2() throws Exception {                 // 反射公有字段
    
            // 获取实体对象
            TestEntity testEntity = clazz.newInstance();
    
            // 根据字节码对象获取属性对象
            Field field = clazz.getField("username");
    
            // 通过属性对象给指定的书设置值
            field.set(testEntity,"zhangsan");
    
            // 获取属性对象的值
            Object obj = field.get(testEntity);
    
            System.out.println(obj);
        }
    
        @Test
        public void test3() throws Exception {                 // 反射非public修饰的字段
    
            TestEntity testEntity = clazz.newInstance();
    
            // 注意: 获取非public修饰的字段时,需要使用getDeclaredField方法
            Field field = clazz.getDeclaredField("password");
    
            // 开启强制访问
            field.setAccessible(true);
    
            // 设置该属性字段的额值
            field.set(testEntity,"123456");
    
            // 获取属性字段的值
            Object object = field.get(testEntity);
    
            System.out.println(object);
        }
    }

## 2.5 反射小案例 ##

准备一个properties文件，内容如下：

class=com.dfbz.demo01.Cate
    name=藜蒿炒腊肉
    taste=鲜香辣
    recommend=true

根据配置文件创建一个Cate对象，利用反射创建对象并设置属性值；

示例代码：

package com.dfbz.demo05;
    
    import com.dfbz.demo01.Cate;
    import com.dfbz.demo01.Demo02;
    import com.sun.org.apache.xpath.internal.operations.Bool;
    
    import java.io.FileInputStream;
    import java.io.InputStreamReader;
    import java.lang.reflect.Field;
    import java.util.Properties;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws Exception { 
    
            Properties prop = new Properties();
            prop.load(
                    new InputStreamReader(
                            Demo01.class.getClassLoader().getResourceAsStream("cate.properties"),
                            "UTF-8"
                    )
            );
            System.out.println(prop);
    
            // 从集合中获得类名
            String className = prop.getProperty("class");
            // 通过反射获得Class对象
            Class<Cate> clazz = (Class<Cate>) Class.forName(className);
    
            // 快速创建对象
            Cate cate = clazz.newInstance();
    
            // 获取字段的真实值
            String name = prop.getProperty("name");
            String taste = prop.getProperty("taste");
            String recommend = prop.getProperty("recommend");
    
            // 通过反射获取到Filed对象
            Field nameField = clazz.getDeclaredField("name");
            // 开启强制访问
            nameField.setAccessible(true);
            // 给指定对象设置值
            nameField.set(cate,name);
    
            Field tasteField = clazz.getDeclaredField("taste");
            tasteField.setAccessible(true);
            tasteField.set(cate,taste);
    
            Field recommendFiled = clazz.getDeclaredField("recommend");
            recommendFiled.setAccessible(true);
            recommendFiled.set(cate, Boolean.parseBoolean(recommend));
    
            System.out.println(cate);
        }
    }

# 三、注解 #

注解是一种标记，可以作用于类、方法、方法形参、成员变量上，给类携带一些额外的参数信息，通过反射来提取这些注解上的信息，然后进行一些操作；

## 3.1 常见的注解 ##

**生成帮助文档**：**@author和@version**

*  **@author**：用来标识作者姓名。
 *  **@version**：用于标识对象的版本号，适用范围：文件、类、方法。

我们之前写的每个类上面都标注了@author和@version注解：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

> 使用\*\*@author和@version**注解就是告诉**Javadoc工具\*\*在生成帮助文档时把作者姓名和版本号也标记在文档中。

使用javadoc工具生成帮助文档：

javadoc -encoding utf-8 -author -version TestAnnotation.java

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

查看生成的帮助文档：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

**编译检查注解：@Override**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

## 3.2 自定义注解 ##

### 3.2.1 定义注解格式 ###

public @interface 注解名{ 
    
    }
    如：定义一个名为Book的注解
    public @interface Book { 
    	字段类型 字段名1();
        字段类型 字段名2();
    }

### 3.2.2 字段类型的格式 ###

**属性的格式**

*  **格式1：数据类型 属性名();**
 *  **格式2：数据类型 属性名() default 默认值;**

示例：

public @interface Book { 
      String name(); // 书名
      String author() ; // 作者
      Double price() default 20.8; // 价格
    }

> tips：注解字段类型可以有如下：
> 
>  *  八种基本数据类型（**int,float,boolean,byte,double,char,long,short**)
>  *  String类型，Class类型，枚举类型，注解类型
>  *  以上所有类型的一维数组

## 3.3 使用自定义注解 ##

### 3.3.1 定义注解 ###

**定义一个注解：Book**

*  包含属性：String value() 书名
 *  包含属性：double price() 价格，默认值为 100
 *  包含属性：String\[\] authors() 多位作者

示例代码：

public @interface Book { 
            // 书名
            String value();
            // 价格
            double price() default 100;
            // 多位作者
            String[] authors();
    }

### 3.3.2 使用注解 ###

public class BookShelf { 
        @Book(value = "《汉书》",price = 108,authors = { "班固","班昭"})
        public void showBook(){ 
    		
        }
    }

> 注意事项：
> 
>  *  如果属性有默认值，则使用注解的时候，这个属性可以不用赋值。
> 
>  *  如果属性没有默认值，那么在使用注解时一定要给属性赋值。

### 3.3.3 特殊属性value ###

**当注解中只有一个属性且名称是value，在使用注解时给value属性赋值可以直接给属性值，无论value是单值元素还是数组类型。**

1.  定义一个注解：

// 定义注解Book
    public @interface Book { 
    	// 书名
    	String value();
    }

1.  使用注解：

// 使用注解Book
    public class BookShelf { 
        @Book("《史记》")
        public void showBook(){ 
    
        }
    }

或者：

public class BookShelf { 
        @Book(value="《史记》")
        public void showBook(){ 
    
        }
    }

**如果注解中除了value属性还有其他属性，且至少有一个属性没有默认值，则在使用注解给属性赋值时，value属性名不能省略。**

1.  定义注解

// 定义注解Book
    public @interface Book { 
            // 书名
            String value();
      		// 价格
            double price() default 100;
            // 多位作者
            String[] authors();
    }

1.  使用注解

// 使用Book注解：正确方式
    @Book(value="《三国志》",authors = "陈寿")
    public class BookShelf { 
      // 使用Book注解：正确方式
        @Book(value="《后汉书》",authors = { "范晔"})
        public void showBook(){ 
    
        }
    }

> 当注解中除了value还有其他属性时，在赋值时必须指定全部的属性名，value属性名不能省略。

错误示例：

// 使用Book注解：错误方式
    public class BookShelf { 
        @Book("《后汉书》",authors = { "范晔"})
        public void showBook(){ 
    
        }
    }

> 不能省略value

## 3.4 元注解 ##

元注解是Java API提供的注解，是用来定义注解的注解。元注解可以限制注解标注的位置，生命周期等；

### 3.4.1 @Target注解 ###

**作用：指明此注解用在哪个位置，如果不写默认是任何地方都可以使用。**

可选的参数值在枚举类**ElemenetType**中包括：

TYPE： 用在类,接口上
     FIELD：用在成员变量上
     METHOD： 用在方法上
     PARAMETER：用在参数上
     CONSTRUCTOR：用在构造方法上
     LOCAL_VARIABLE：用在局部变量上
     ANNOTATION_TYPE：用在注解上

### 3.4.2 @Retention注解 ###

**作用：定义该注解的生命周期(有效范围)。**

可选的参数值在枚举类型RetentionPolicy中包括：

*  `SOURCE`：注解只存在于Java源代码中，编译生成的字节码文件中就不存在了。
 *  `CLASS`：注解存在于Java源代码、编译以后的字节码文件中，运行的时候内存中没有，**默认值**。
 *  `RUNTIME`：注解存在于Java源代码中、编译以后的字节码文件中、运行时内存中，程序可以通过反射获取该注解。

### 3.4.3 元注解的使用 ###

1.  定义注解：

package com.dfbz.demo01;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Target;
    
    /** * @author lscl * @version 1.0 * @intro: */
    // 允许在方法、类上使用
    @Target({ ElementType.METHOD,ElementType.TYPE})
    @interface Student{ 
        String name();
    }

1.  测试类：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    // 类
    @Student(name="jack")
    public class AnnotationDemo02 { 
    
        // 成员变量
        @Student(name = "lily")  // 编译失败
        private String gender;
    
        // 成员方法
        @Student(name="rose")
        public void  test(){ 
    
        }
    
        // 构造方法
        @Student(name="lucy") // 编译失败
        public AnnotationDemo02(){ }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

## 3.5 注解解析 ##

当我们标注注解后，注解中携带的信息需要我们手动来解析，通过反射技术来剖析一个类的注解，然后提取里面的信息；

### 3.5.1 注解解析相关接口 ###

*  **Anontation**：所有注解类型的公共接口，类似所有类的父类是Object。
 *  **AnnotatedElement**：定义了与注解解析相关的方法，常用方法以下四个：
    
     *  `boolean isAnnotationPresent(Class annotationClass)`：判断当前对象是否有指定的注解，有则返回true，否则返回false。
     *  `T getAnnotation(Class<T> annotationClass)`：获得当前对象上指定的注解对象。
     *  `Annotation[] getAnnotations()`：获得当前对象及其从父类上继承的所有的注解对象。
     *  `Annotation[] getDeclaredAnnotations()`：获得当前对象上所有的注解对象，不包括父类的。

### 3.5.2 获取注解 ###

注解作用在那个成员上，就通过反射获得该成员的对象来得到它的注解。

*  **如注解作用在方法上，就通过方法(Method)对象得到它的注解**

// 得到方法对象
     Method method = clazz.getDeclaredMethod("方法名"); 
    
     // 根据注解字节码对象得到方法上的注解对象
     Student student = method.getAnnotation(Student.class);

*  **如注解作用在类上，就通过Class对象得到它的注解**

// 获得Class对象
    Class c = 类名.class;
    // 根据注解字节码对象得到类上的注解对象
    Student student = c.getAnnotation(Student.class);

### 3.5.3 注解信息解析案例 ###

#### 1）需求如下： ####

1.  定义注解Computer，要求如下：
    
     *  包含属性：String value() 计算机名
     *  包含属性：double price() 价格，默认值为 2000
     *  包含属性：String\[\] factories() 多个厂商
     *  限制注解使用的位置：类和成员方法上
     *  指定注解的有效范围：RUNTIME
2.  定义TestComputer类，在类和成员方法上使用Computer注解
3.  定义TestAnnotation测试类获取Computer注解上的数据

#### 2）代码实现 ####

1.  定义Computer注解：

package com.dfbz.demo01;
    
    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 Computer { 
        // 计算机名
        String name();
    
        // 计算机价格
        double price() default 2000;
    
        // 厂商
        String[] factories();
    }

1.  定义TestComputerr类：

package com.dfbz.demo01;
    
    @Computer(name ="神舟战神",price = 3800,factories = { "华南厂商","华北厂商"})
    public class TestComputerr { 
    
        @Computer(name = "神舟优雅",price = 4200,factories = { "华中厂商","华东厂商"})
        public void buyComputer(){ 
            System.out.println("买神舟电脑啦~~好开森~~");
        }
    }

1.  定义测试类：

package com.dfbz.demo01;
    
    import org.junit.Test;
    
    import java.lang.reflect.Method;
    import java.util.Arrays;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
    
        //获取类上的注解信息
        @Test
        public void test1() throws IllegalAccessException, InstantiationException { 
            System.out.println("类上注解信息：");
            //获取字节码对象
            Class<TestComputer> clazz= TestComputer.class;
    
            //获取注解对象
            Computer c = clazz.getAnnotation(Computer.class);
    
            //判断TestCompute类上是否使用了Compute注解，或者该注解的生命周期是否是RUNTIME
            if(clazz.isAnnotationPresent(Computer.class)){ 
                //通过注解对象获取注解上的值
                String name = c.name();
                double price = c.price();
                String[] factories = c.factories();
    
                System.out.println(name);
                System.out.println(price);
                System.out.println(Arrays.toString(factories));
                System.out.println("-------------");
            }
    
    
        }
    
        //获取方法上注解信息
        @Test
        public void test2() throws IllegalAccessException, InstantiationException, NoSuchMethodException { 
            System.out.println("方法上注解信息：");
            //获取字节码对象
            Class<TestComputer> clazz= TestComputer.class;
    
            //通过类字节码对象获取方法对象
            Method method = clazz.getMethod("buyCompute");
    
            //判断该方法上是否使用了Compute注解，或者该注解的生命周期是否是RUNTIME
            if(method.isAnnotationPresent(Computer.class)){ 
                //通过方法对象获取该方法上的注解
                Computer c = method.getAnnotation(Computer.class);
    
                //通过注解对象获取注解上的值
                String name = c.name();
                double price = c.price();
                String[] factories = c.factories();
    
                System.out.println(name);
                System.out.println(price);
                System.out.println(Arrays.toString(factories));
    
            }
    
        }
    }

## 3.6 注解案例 ##

我们尝试自己定义一个@MyTest注解来模拟Junint的@Test注解的功能

#### 1）案例分析如下： ####

1.  模拟Junit测试的注释@Test，首先需要编写自定义注解@MyTest，并添加元注解，保证自定义注解只能修饰方法，且在运行时可以获得。
2.  然后编写目标类（测试类），然后给目标方法（测试方法）使用 @MyTest注解，编写三个方法，其中两个加上@MyTest注解。
3.  最后编写调用类，使用main方法调用目标类，模拟Junit的运行，只要有@MyTest注释的方法都会运行。

#### 2）代码实现 ####

1.  定义@MyTest注解

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyTest { 
    
    }

1.  定义目标类：

package com.dfbz.demo02;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class MyTestDemo { 
    
        @MyTest
        public void test1(){ 
            System.out.println("自定义的Test1方法执行啦！！~~~");
        }
    
        @MyTest
        public void test2(){ 
            System.out.println("自定义的Test2方法执行啦！！~~~");
        }
    
        @MyTest
        public void test3(){ 
            System.out.println("自定义的Test3方法执行啦！！~~~");
        }
    }

1.  定义测试类：

package com.dfbz.demo02;
    
    import java.lang.reflect.Method;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) throws Exception { 
    
            //获取MyTestDemo字节码对象
            Class<MyTestDemo> clazz= MyTestDemo.class;
            
            //通过字节码对象创建对象
            MyTestDemo obj= clazz.newInstance();
            
            //获取所有public修饰的方法对象
            Method[] methods = clazz.getMethods();
            
            for(Method m:methods){ 
                
                //如果该方法上存在MyTest注解,就把该方法执行
                if(m.isAnnotationPresent(MyTest.class)){ 
                    m.invoke(obj);
                }
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

## 3.7 Lombok插件 ##

Lombok 是一种 Java 实用工具，可用来帮助开发人员消除 JavaBean 的冗长，尤其是对于简单的 Java 对象（POJO）。它通过注解实现这一目的。通过在开发环境中实现 Lombok，开发人员可以节省构建诸如 hashCode() 和 equals() 这样的方法

### 3.7.1 下载Lombok ###

官方地址：https://projectlombok.org/download

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

### 3.7.2 IDEA配置Lombok插件 ###

#### 1）官网下载 ####

> IDEA插件官网：[https://plugins.jetbrains.com/][https_plugins.jetbrains.com]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]

选择指定的项目：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]

找到合适的版本：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]

#### 2）配置插件 ####

下载完成之后，拷贝到idea安装目录下的plugins目录下（我的是：`D:\IntelliJ IDEA 2020.1.3\plugins`）

然后打开IDEA，打开Settings–>Plugins，然后选择从磁盘安装插件：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]

选择刚刚的插件：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]

点击重启IDEA：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]

完成：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]

#### 3）开启IDEA对注解的支持 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 17]

### 3.7.3 Lombok插件的使用 ###

在模块的一级目录下，创建一个lib文件夹（名称随意），将lombok的jar包拷贝到目录中，然后右击选择：`Add as Library...`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 18]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 19]

Lombok中提供了很多的注解来代替JavaBean中的一些方法，如：

*  `@ToString`：重写toString方法。
 *  `@Setter`：提供set方法。
 *  `@Getter`：提供get方法。
 *  `@NoArgsConstructor`：为类提供一个无参的构造方法。
 *  `@AllArgsConstructor`：为类提供一个全参的构造方法。
 *  `@Data`： @Data 是 @Getter、 @Setter、 @ToString、 @EqualsAndHashCode 和 @RequiredArgsConstructor 的快捷方式。
 *  `@NonNull`：注解在属性上，用来校验参数非空，可以帮助我们避免空指针。
 *  `@Slf4j`：为类提供一个 属性名为log 的 log4j 日志对象。
 *  `@Log4j`：为类提供一个 属性名为log 的 log4j 日志对象。

编写一个Student类：

package com.dfbz.demo03;
    
    import lombok.*;
    
    /** * @author lscl * @version 1.0 * @intro: */
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    @EqualsAndHashCode
    @Getter
    @Setter
    public class Student { 
        private String name;
        private Integer age;
    
        public void eat(@NonNull String food) { 
            System.out.println(name + "刚刚吃了: " + food);
        }
    }

测试类：

package com.dfbz.demo03;
    
    import java.util.HashMap;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
    
            // 提供了有参和无参构造
            Student s1  = new Student("小灰", 20);
            Student s2  = new Student();
    
            // 提供了get/set
            s2.setName("小灰");
            s2.setAge(20);
    
            HashMap map = new HashMap<>();
            map.put(s1,1);
            map.put(s2,1);
    
            System.out.println(map.size());     // 1(提供了hashCode和equals)
    
            System.out.println(s2);         // 提供了toString
    
            s1.eat(null);           // 出现空指针异常
        }
    }

输出结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 20]

--------------------

**上一篇**：[day16【TCP、UDP、网络通信】][day16_TCP_UDP]

**下一篇**：

**目录**：【JavaSE零基础系列教程目录】

--------------------

[https_junit.org_junit5]: https://junit.org/junit5/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/67184a98c5994b819669c6cb84a66b7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/bdbf8b1172a44c7db1f67fefb7255e97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/d5bdb6c43d854bd185da4105017e62ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/6de800710977482e8341ab026cb0c273.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/7f4daee279ce4bffa7757972240ca2fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/ffc192f1298441ad951af9fb9f8a0d6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/966d0cbaa300432b81e2cc6190ab47c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/f7011ba39d9e41f185a149994e688844.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/5186189120bb43b1a924c0ff8e024e28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/8150086d9eec462baeef4a8a99e3400a.png
[https_plugins.jetbrains.com]: https://plugins.jetbrains.com/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/d588b87335254aae9d276a7af6270211.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/a7ccb1e795744e15a552c7952ad14de7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/0feb17ff2f2f4968b125dd53154aa0be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/6fcbcacc85e14fac811a13c6fc4cd6d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20220829/283c6cff058347cd886f076833e1fa51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20220829/c7e6057215304692a744557d344b2355.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20220829/adb1300cf352436fb4a9456d9b18ffb3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20220829/472b12f8bee14c308bd4a87262c1c4f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20220829/b1636807b08a42fcb1fb7403d4b33318.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20220829/8fe27ab196214b738f36265b5da82bb4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20220829/691337e23064467fa627522e5be87f07.png
[day16_TCP_UDP]: https://blog.csdn.net/Bb15070047748/article/details/119452768