设计模式学习笔记之(三)设计模式之单例模式

た入场券 2023-07-10 08:22 12阅读 0赞

## 单例模式（Singleton） ##

*  单例模式需要保证对应的实例在全局中只有一个(唯一性)，**即在系统全局中只有一个应用实例。**

*  应用场景：保证一个类仅有一个实例，并提供一个访问它的全局访问点。  
    Spring 中的单例模式完成了后半句话，即提供了全局的访问点 BeanFactory。但没有从构造器级别去 控制单例，这是因为 Spring 管理的是是任意的 Java 对象。 Spring 下默认的 Bean 均为单例。  
    ![在这里插入图片描述][20200301132544625.png]

## 单例模式的若干形式 ##

#### 饿汉式 ####

**不管系统是否使用，在使用之前实例就已经产生，这样就解决了线程安全问题**（注意是单个的类访问的线程安全问题而不是业务引起的线程安全问题）。  
在创建懒汉式单例模式时要注意以下几点  
1、将其构造函数私有化  
2、先静态、后动态。并最好用final修饰，防止其他线程创建实例时将原先的实例覆盖，确保唯一性  
单例代码

public class Hungry {
        private Hungry(){}
        //先静态、后动态
        //先属性、后方法
        //先上后下
        private static final Hungry hungry = new Hungry();
        public static Hungry getInstance(){
    //        Hungry hungry;
            System.out.println(System.currentTimeMillis()+":"+hungry);
            return  hungry;
        }
    }

*  测试代码

public class ThreadSafeHungryTest {
        public static void main(String[] args) {
            int count = 10;
            CountDownLatch countDownLatch = new CountDownLatch(count);
            for (int i = 0; i < count; i++) {
                new Thread(){
                    @Override
                    public void run(){
                        try {
                            countDownLatch.await();
                            Hungry.getInstance();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }.start();
                countDownLatch.countDown();
            }
        }
    }

*  测试结果  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70]
 *  **对于饿汉式单例模式来说，保证了绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题**
 *  优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好
 *  缺点：类加载的时候就初始化，不管用不用都占用空间，浪费了宝贵的内存。

### 懒汉式 ###

*  在应用实例的时候再进行创建实例，在**spring的领域内特有的解释是延迟加载**，下面给出tom老师讲的案例。

#### 懒汉类第一版 ####

*  懒汉类

public class LazyOne {
        private LazyOne(){}
        //静态块，公共内存区域
        private static LazyOne lazy = null;
        public static LazyOne getInstance(){
    
            //调用方法之前，先判断
            //如果没有初始化，将其进行初始化,并且赋值
            //将该实例缓存好
            if(lazy == null){
                //两个线程都会进入这个if里面
                lazy = new LazyOne();
            }
            //如果已经初始化，直接返回之前已经保存好的结果
            return lazy;
        }
    }

*  测试类

public class ThreadSafeTest {
        public static void main(String[] args) {
            int count = 100;
            //发令枪，我就能想到运动员
            CountDownLatch latch = new CountDownLatch(count);
            long start = System.currentTimeMillis();
            for (int i = 0; i < count;i ++) {
                new Thread(){
                    @Override
                    public void run() {
                        try{
                            try {
                                // 阻塞
                                // count = 0 就会释放所有的共享锁
                                // 万箭齐发
                                latch.await();
                                //必然会调用，可能会有很多线程同时去访问getInstance()
                                Object obj = LazyOne.getInstance();
                                System.out.println(System.currentTimeMillis() + ":" + obj);
                            }catch(Exception e){
                                e.printStackTrace();
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }.start(); //每循环一次，就启动一个线程,具有一定的随机性
    
                //每次启动一个线程，count --
                latch.countDown();
            }
            long end = System.currentTimeMillis();
            System.out.println("总耗时：" + (end - start));
    //        CountDownLatch 并不是这样子用,实际应用场景中不要学老师这样投机取巧
           // Color.INSTANCE.getInstance();
        }
    }

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

#### 懒汉模式第二版 ####

*  懒汉类

public class LazyTwo {
        private LazyTwo(){}
        private static LazyTwo lazy = null;
        public static synchronized LazyTwo getInstance(){
            if(lazy == null){
                lazy = new LazyTwo();
            }
            return lazy;
        }
    }

*  效果测试类一

public class ThreadSafeLazyTwoTest {
        public static void main(String[] args) {
            int count = 100;
            //发令枪，我就能想到运动员
            CountDownLatch latch = new CountDownLatch(count);
            long start = System.currentTimeMillis();
            for (int i = 0; i < count;i ++) {
                new Thread(){
                    @Override
                    public void run() {
                        try{
                            try {
                                // 阻塞
                                // count = 0 就会释放所有的共享锁
                                // 万箭齐发
                                latch.await();
                                //必然会调用，可能会有很多线程同时去访问getInstance()
                                Object obj = LazyTwo.getInstance();
                                System.out.println(System.currentTimeMillis() + ":" + obj);
                            }catch(Exception e){
                                e.printStackTrace();
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }.start(); //每循环一次，就启动一个线程,具有一定的随机性
    
                //每次启动一个线程，count --
                latch.countDown();
            }
            long end = System.currentTimeMillis();
            System.out.println("总耗时：" + (end - start));
    //        CountDownLatch 并不是这样子用,实际应用场景中不要学老师这样投机取巧
            // Color.INSTANCE.getInstance();
        }
    }

测试结果表明加入synchronize同步锁后线程安全问题确实得到解决  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 2]

*  性能测试类二

public class LazyTest {
    
        public static void main(String[] args) {
            System.out.println("--------------------");
            long start1 = System.currentTimeMillis();
            for (int i = 0; i < 200000000;i ++) {
                Object obj = LazyTwo.getInstance();
            }
            long end1 = System.currentTimeMillis();
            System.out.println("LazyTwo总耗时：" + (end1 - start1));
            System.out.println("--------------------");
            long start2=System.currentTimeMillis();
            for (int i = 0; i < 200000000; i++) {
                Object obj2 = LazyOne.getInstance();
            }
            long end2 = System.currentTimeMillis();
            System.out.println("LazyOne总耗时：" + (end2 - start2));
            System.out.println("--------------------");
        }
    }

*  测试结果
 *  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 3]
 *  **测试结果表明加入同步锁会实现了线程安全的目的，但却也同时大大增加时间复杂度**，为了解决上述同步锁带来的时间性能问题，对同步锁机制做了进一步改进。

#### 懒汉模式第三版 ####

*  第三版懒汉类

public class LazyThree {
        private static boolean initialized = false;
        //默认使用LazyThree的时候，会先初始化内部类
        //如果没使用的话，内部类是不加载的
        private LazyThree(){
            synchronized (LazyThree.class){
                if(initialized == false){
                    initialized = !initialized;
                }else{
                    throw new RuntimeException("单例已被侵犯");
                }
            }
        }
        //每一个关键字都不是多余的
        //static 是为了使单例的空间共享
        //保证这个方法不会被重写，重载
        public static final LazyThree getInstance(){
            //在返回结果以前，一定会先加载内部类
            return LazyHolder.LAZY;
        }
        //默认不加载
        private static class LazyHolder{
            private static final LazyThree LAZY = new LazyThree();
        }
    }

*  在上述中加入synchronize的原因是防止被反射暴力破解访问，可能会造成线程不安全，所以我们强制其抛出异常，这样就保证了单例
 *  测试类代码（一）

public class ReflectLazyThreeTest {
        public static void main(String[] args) {
                try {
                    Class<LazyThree> lazyThreeClass = LazyThree.class;
                    //Method[] declaredMethods = lazyThreeClass.getDeclaredMethods();
                    Constructor<?>[] declaredConstructors = lazyThreeClass.getDeclaredConstructors();
                    for (Constructor c :
                            declaredConstructors) {
                        c.setAccessible(true);
                        System.out.println(c);
                        //  Object obj=c.newInstance(null);
                    }
                    System.out.println("----------------");
                    System.out.println(declaredConstructors.length);
                    System.out.println("----------------");
                    Constructor<?> c = declaredConstructors[1];
                    c.setAccessible(true);
                    Object o1 = c.newInstance();
                    System.out.println(o1);
                    System.out.println("----------------");
                    Object o2 = c.newInstance();
                    System.out.println(o2);
                    System.out.println("----------------");
                }catch (Exception e){
                    e.printStackTrace();
                }
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 4]

*  测试类代码，线程安全测试（二）

public class ThreadSafeLazyThreeTest {
        public static void main(String[] args) {
            int count = 20;
            //发令枪，我就能想到运动员
            CountDownLatch latch = new CountDownLatch(count);
            long start = System.currentTimeMillis();
            for (int i = 0; i < count;i ++) {
                new Thread(){
                    @Override
                    public void run() {
                        try{
                            try {
                                // 阻塞
                                // count = 0 就会释放所有的共享锁
                                // 万箭齐发
                                latch.await();
                                //必然会调用，可能会有很多线程同时去访问getInstance()
                                Object obj = LazyThree.getInstance();
                                System.out.println(System.currentTimeMillis() + ":" + obj);
                            }catch(Exception e){
                                e.printStackTrace();
                            }
                        }catch (Exception e){
                            e.printStackTrace();
                        }
                    }
                }.start(); //每循环一次，就启动一个线程,具有一定的随机性
    
                //每次启动一个线程，count --
                latch.countDown();
            }
            long end = System.currentTimeMillis();
            System.out.println("总耗时：" + (end - start));
    //        CountDownLatch 并不是这样子用,实际应用场景中不要学老师这样投机取巧
            // Color.INSTANCE.getInstance();
        }
    }

*  测试多次结果  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 5]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 6]  
    测试后没有发现线程安全问题，
 *  测试代码性能测试(三)

public class LazyTest {
    
        public static void main(String[] args) {
            System.out.println("--------------------");
            long start1 = System.currentTimeMillis();
            for (int i = 0; i < 200000000;i ++) {
                Object obj = LazyTwo.getInstance();
            }
            long end1 = System.currentTimeMillis();       System.out.println("LazyTwo总耗时：" + (end1 - start1));
            System.out.println("--------------------");
            long start2=System.currentTimeMillis();
            for (int i = 0; i < 200000000; i++) {
                Object obj2 = LazyOne.getInstance();
            }
            long end2 = System.currentTimeMillis();
            System.out.println("LazyOne总耗时：" + (end2 - start2));
            System.out.println("--------------------");
            long start3=System.currentTimeMillis();
            for (int i = 0; i < 200000000; i++) {
                Object obj2 = LazyThree.getInstance();
            }
            long end3 = System.currentTimeMillis();
            System.out.println("LazyThree总耗时：" + (end3 - start3));
            System.out.println("--------------------");
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 7]  
由时间复杂度知见LazyThree的执行效率与LazyOne无异；从空间复杂度来看，LazyThree要优于饿汉模式实例；同时第三种懒汉模式也可解决线程安全问题，所以在spring中一般常常采用第三种懒汉式模式。

### 注册登记式 ###

#### 图式 ####

如何注册，直接上实例

*  图式实例类

public class RegisterMap {
        private RegisterMap(){}
        private static volatile Map<String,Object> register = new ConcurrentHashMap<String,Object>();
        /*static{
            RegisterMap rs=new RegisterMap();
            register.put(rs.getClass().getName(),rs);
        }*/
        //如果不加synchronized 则该方法会产生线程安全问题
        public static synchronized RegisterMap getInstance(String name){
            if(name == null){
                name = RegisterMap.class.getName();
            }
            if(register.get(name) == null){
                try {
                    //register.put(name, new RegisterMap());
                    register.put(name,RegisterMap.class.newInstance());
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
          /*  System.out.println(register.get(name));*/
            RegisterMap o = (RegisterMap)register.get(name);
            System.out.println(o);
            return o;
        }
    }

测试类

public class RegisterTest {
        public static void main(String[] args) {
            int count =100;
            CountDownLatch countDownLatch = new CountDownLatch(count);
            for (int i = 0; i < count; i++) {
                new Thread(){
                    @Override
                    public void run() {
                        try {
                            RegisterMap map = RegisterMap.getInstance("monalu");
                           // RegiterEnum instance = RegiterEnum.INSTANCE;
                           // System.out.println(System.currentTimeMillis()+":"+instance);
                            countDownLatch.await();
    
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                    }
                }.start();
                countDownLatch.countDown();
            }
        }
    }

值得说明的是concurrenthashmap并不能解决线程安全问题，最好getInstance方法中加入synchronized关键字来保证线程安全。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 8]

#### 枚举式 ####

枚举类代码

public enum RegiterEnum {
        INSTANCE,BLACK,WHITE;
        public RegiterEnum getInstance(RegiterEnum regiterEnum){
            return regiterEnum;
        }
    }

测试代码

public class RegisterTest {
        public static void main(String[] args) {
            int count =20;
            CountDownLatch countDownLatch = new CountDownLatch(count);
            for (int i = 0; i < count; i++) {
                new Thread(){
                    @Override
                    public void run() {
                        try {
                            //RegisterMap map = RegisterMap.getInstance("monalu");
                           RegiterEnum instance = RegiterEnum.INSTANCE.getInstance(RegiterEnum.BLACK);
                            System.out.println(System.currentTimeMillis()+":"+instance);
                            countDownLatch.await();
    
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
    
                    }
                }.start();
                countDownLatch.countDown();
            }
        }
    }

测试后没有发现线程安全问题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 9]

### 序列化与反序列化式 ###

public class Singleton implements Serializable {
        private volatile static Singleton singleton;
        private Singleton(){}
        public static Singleton getSingleton(){
            if(singleton == null){
                synchronized (Singleton.class){
                    if(singleton == null){
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

测试类

public class SeriableTest {
        public static void main(String[] args) {
    
            //Seriable s1 = null;
           // Seriable s2 = Seriable.getInstance();
            Serializable s1 = null;
            Serializable s2 = Singleton.getSingleton();
    
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream("seriable.obj");
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                oos.writeObject(s2);
                oos.flush();
                oos.close();
    
    
                FileInputStream fis = new FileInputStream("seriable.obj");
                ObjectInputStream ois = new ObjectInputStream(fis);
               // s1 = (Seriable)ois.readObject();
                s1=(Serializable)ois.readObject();
                ois.close();
    
                System.out.println(s1);
                System.out.println(s2);
                System.out.println(s1 == s2);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

实验效果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 10]  
上述代码存在序列化破坏单例的问题，需要寻找解决序列化破坏单例的解决方法，就是在类中加入readResolve方法。  
单例类

public class SingletonGet implements Serializable {
        public volatile static SingletonGet singleton;
        private SingletonGet(){};
        public static SingletonGet getSingleton(){
            if(singleton== null){
                synchronized (SingletonGet.class){
                    if(singleton == null){
                        singleton = new SingletonGet();
                    }
                }
    
            }
            return singleton;
        }
        //在ReadObject中会反射这个方法
        private Object readResolve(){
            return singleton;
        }
    }

测试类

public class SeriableTestGet {
        public static void main(String[] args) {
    
            //Seriable s1 = null;
            // Seriable s2 = Seriable.getInstance();
            Serializable s1 = null;
            Serializable s2 = SingletonGet.getSingleton();
    
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream("seriable.obj");
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                oos.writeObject(s2);
                oos.flush();
                oos.close();
                FileInputStream fis = new FileInputStream("seriable.obj");
                ObjectInputStream ois = new ObjectInputStream(fis);
                // s1 = (Seriable)ois.readObject();
                s1=(Serializable)ois.readObject();
                ois.close();
                System.out.println(s1);
                System.out.println(s2);
                System.out.println(s1 == s2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

关于为什么能决绝序列化破坏单例，请参考文章[单例设计模式-序列化破坏单例模式？][-]  
测试结果![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 11]  
行笔至此，有关单例的知识就复习到这里。

[20200301132544625.png]: https://img-blog.csdnimg.cn/20200301132544625.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200303195026333.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200303215035521.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200303215331328.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200301164911886.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200301221920963.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200301224259483.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200301224348888.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200301223818376.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200303234708945.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200303235730365.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200403221302114.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70
[-]: https://www.cnblogs.com/shenwen/p/10719817.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200413214100486.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu,size_16,color_FFFFFF,t_70