基于Session实现认证授权功能

忘是亡心i 2023-02-28 15:29 54阅读 0赞

## 目录 ##

*  基于Session的认证方式

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

# 一、认证流程 #

*  基于`Session认证方式`的流程是，用户认证成功后，在`服务`端生成用户相关的数据保存在`session`(当前会话)，而发给`客户端`的 `sesssion_id` 存放到 `cookie` 中，这样**用客户端请求时cookie中带上 session\_id 就可以验证服务器端是否存在 session 数据，以此完成用户的合法校验**。当用户退出系统或session过期销毁时,客户端的session\_id也就无效了。 下图是session认证方式的流程图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]  
基于Session的认证机制由**Servlet规范**定制，Servlet容器已实现，用户通过`HttpSession`的操作方法即可实现，如下是**HttpSession**相关的操作API。

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

# 二、基于Session实现认证授权 #

### 1、创建maven工程 ###

*  使用maven进行构建，使用SpringMVC、Servlet3.0实现。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]

**pom文件**

引入如下依赖如下，注意：  
1、由于是web工程，packaging设置为war  
2、使用tomcat7-maven-plugin插件来运行工程

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.zy</groupId>
        <artifactId>security-springmvc</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>war</packaging>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.1.5.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.0.1</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.8</version>
            </dependency>
        </dependencies>
        <build>
            <finalName>security-springmvc</finalName>
            <pluginManagement>
                <plugins>
                    <plugin>
                        <groupId>org.apache.tomcat.maven</groupId>
                        <artifactId>tomcat7-maven-plugin</artifactId>
                        <version>2.2</version>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                        </configuration>
                    </plugin>
    
                    <plugin>
                        <artifactId>maven-resources-plugin</artifactId>
                        <configuration>
                            <encoding>utf-8</encoding>
                            <useDefaultDelimiters>true</useDefaultDelimiters>
                            <resources>
                                <resource>
                                    <directory>src/main/resources</directory>
                                    <filtering>true</filtering>
                                    <includes>
                                        <include>**/*</include>
                                    </includes>
                                </resource>
                                <resource>
                                    <directory>src/main/java</directory>
                                    <includes>
                                        <include>**/*.xml</include>
                                    </includes>
                                </resource>
                            </resources>
                        </configuration>
                    </plugin>
                </plugins>
            </pluginManagement>
        </build>
    </project>

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

### 2、Spring容器配置 ###

在`config`包下定义`ApplicationConfig.java`，它对应`web.xml`中`ContextLoaderListener`的配置

/** * Description: 使用 session来实现用户的认证和授权 * * @author zygui * @date Created on 2020/7/12 14:02 */
    @Configuration  // 相当于applicationCotroller.xml
    @ComponentScan(basePackages = "com.zy.security.springmvc",
        // 排除对Controller的扫描
        excludeFilters = { @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class)})
    public class ApplicationConfig { 
    	//在此配置除了Controller的其它bean，比如：数据库链接池、事务管理器、业务bean等
    }

### 3、ServletContext配置 ###

例采用`Servlet3.0无web.xml`方式，的config包下定义`WebConfig.java`，它对应于`springmvc.xml`配置。

@Configuration // 相当于springmvc.xml
    @EnableWebMvc
    @ComponentScan(basePackages = "com.zy.security.springmvc", includeFilters = { @ComponentScan.Filter(
            type = FilterType.ANNOTATION, value = Controller.class)})
    public class WebConfig implements WebMvcConfigurer { 
    
        @Autowired
        SimpleAuthenticationInterceptor simpleAuthenticationInterceptor;
    
        // 视频解析器
        @Bean
        public InternalResourceViewResolver viewResolver() { 
            InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
            viewResolver.setPrefix("/WEB-INF/view/");
            viewResolver.setSuffix(".jsp");
            return viewResolver;
        }
    
        // 配置映射到jsp页面
        @Override
        public void addViewControllers(ViewControllerRegistry registry) { 
            registry.addViewController("/").setViewName("login");
        }
    
        // 相当于在springmvc.xml中配置拦截器
        @Override
        public void addInterceptors(InterceptorRegistry registry) { 
            registry.addInterceptor(simpleAuthenticationInterceptor).addPathPatterns("/r/**");
        }
    }

### 4、加载Spring容器 ###

在`init包`下定义`Spring容器`初始化类`SpringApplicationInitializer`，此类实现`WebApplicationInitializer`接口， Spring容器启动时加载WebApplicationInitializer接口的所有实现类。该类相当于`web.xml`文件

// 相当于加载了web.xml文件
    public class SpringApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer { 
    
        //spring容器，相当于加载 applicationContext.xml
        @Override
        protected Class<?>[] getRootConfigClasses() { 
            return new Class[]{ ApplicationConfig.class};
        }
    
        //servletContext，相当于加载springmvc.xml
        @Override
        protected Class<?>[] getServletConfigClasses() { 
            return new Class[]{ WebConfig.class};
        }
    
        //url-mapping
        @Override
        protected String[] getServletMappings() { 
            return new String[]{ "/"};
        }
    }

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

### 5、实现认证功能 ###

##### 认证页面 #####

在`webapp/WEB-INF/views`下定义`认证页面login.jsp`，本案例只是**测试认证流程**，页面没有添加css样式，**页面实现可填入用户名，密码 触发登录将提交表单信息至/login**，内容如下：

<%@ page contentType="text/html;charset=UTF-8" pageEncoding="utf-8" %>
    <html>
    <head>
        <title>用户登录</title>
    </head>
    <body>
    <form action="login" method="post">
        用户名：<input type="text" name="username"><br>
        密   码:
        <input type="password" name="password"><br>
        <input type="submit" value="登录">
    </form>
    </body>
    </html>

在`WebConfig`中新增如下配置，将/直接导向`login.jsp`页面：

// 配置映射到jsp页面
    @Override
    public void addViewControllers(ViewControllerRegistry registry) { 
        registry.addViewController("/").setViewName("login");
    }

![在这里插入图片描述][20200721225151851.png]

##### 认证接口 #####

*  用户进入认证页面，输入账号和密码，点击登录，请求`/login`进行身份认证。

（1）定义`认证接口`，此接口用于对传来的用户名、密码校验，若成功则返回该用户的详细信息，否则抛出错误异常：

public interface AuthenticationService { 
        /** * 用户认证 * @param authenticationRequest 用户认证请求，账号和密码 * @return 认证成功的用户信息 */
        UserDto authentication(AuthenticationRequest authenticationRequest);
    }

/** * Description: 认证请求参数, 账号, 密码 * * @author zygui * @date Created on 2020/7/12 15:00 */
    @Getter
    @Setter
    public class AuthenticationRequest { 
    
        private String username;
    
        private String password;
    }

*  认证成功后返回的用户详细信息，也就是`当前登录用户的信息`：

@Data
    public class UserDto { 
        public static final String SESSION_USER_KEY = "_user";
        private String id;
        private String username;
        private String password;
        private String fullname;
        private String mobile;
    	// 用户的权限列表
        private Set<String> authorities;
    
        public UserDto() { }
    
        public UserDto(String id, String username, String password, String fullname, String mobile, Set<String> authorities) { 
            this.id = id;
            this.username = username;
            this.password = password;
            this.fullname = fullname;
            this.mobile = mobile;
            this.authorities = authorities;
        }
    }

（2）认证实现类，根据`用户名查找用户信息，并校验密码`，这里模拟了两个用户：

@Service
    public class AuthenticationServiceImpl implements AuthenticationService { 
        /** * 用户认证，校验用户身份信息是否合法 * * @param authenticationRequest 用户认证请求，账号和密码 * @return 认证成功的用户信息 */
        @Override
        public UserDto authentication(AuthenticationRequest authenticationRequest) { 
            //校验参数是否为空
            if (authenticationRequest == null
                    || StringUtils.isEmpty(authenticationRequest.getUsername())
                    || StringUtils.isEmpty(authenticationRequest.getPassword())) { 
                throw new RuntimeException("账号和密码为空");
            }
    
            // 根据账号去查询数据库
            //根据账号去查询数据库,这里测试程序采用模拟方法
            UserDto user = getUserDto(authenticationRequest.getUsername());
            //判断用户是否为空
            if (user == null) { 
                throw new RuntimeException("查询不到该用户");
            }
            //校验密码
            if (!authenticationRequest.getPassword().equals(user.getPassword())) { 
                throw new RuntimeException("账号或密码错误");
            }
            //认证通过，返回用户身份信息
            return user;
        }
    
        //根据账号查询用户信息
        private UserDto getUserDto(String userName) { 
            return userMap.get(userName);
        }
    
        //用户信息
        private Map<String, UserDto> userMap = new HashMap<>();
    
        { 
            Set<String> authorities1 = new HashSet<>();
            authorities1.add("p1");//这个p1我们人为让它和/r/r1对应
            Set<String> authorities2 = new HashSet<>();
            authorities2.add("p2");//这个p2我们人为让它和/r/r2对应
            userMap.put("zhangsan", new UserDto("1010", "zhangsan", "123", "张三", "133443", authorities1));
            userMap.put("lisi", new UserDto("1011", "lisi", "456", "李四", "144553", authorities2));
        }
    }

（3）登录`Controller`，对/login请求处理，它调用AuthenticationService完成认证并返回登录结果提示信息：

@RestController
    public class LoginController { 
    
        @Resource
        private AuthenticationService authenticationService;
    
        @RequestMapping(value = "/login", produces = { "text/plain;charset=UTF-8"})
        public String login(AuthenticationRequest authenticationRequest, HttpSession session) { 
            UserDto userDto = authenticationService.authentication(authenticationRequest);
    
            // 认证通过后, 将用户的信息存储到seesion中
            session.setAttribute(UserDto.SESSION_USER_KEY, userDto);
            return userDto.getUsername() + "登录成功";
        }
    }

##### 测试认证功能 #####

![在这里插入图片描述][2020072123014497.png]  
![在这里插入图片描述][20200721230159441.png]  
以上的测试全部符合预期，到目前为止最基础的认证功能已经完成，**它仅仅实现了对用户身份凭证的校验，若某用 户认证成功，只能说明他是该系统的一个合法用户**，仅此而已。

### 6、实现会话功能 ###

*  `因为http请求是无状态的请求, 所以要使用会话机制`会话是指用户登入系统后，系统会`记住该用户的登录状态`，他可以在系统连续操作直到退出系统的过程。
 *  `认证`的`目的`是对`系统资源的保护`，每次对资源的访问，系统必须得知道是谁在访问资源，才能对该请求进行合法性拦截。因此，在认证成功后，一般会把`认证成功的用户信息放入Session`中，在后续的请求中，系统能够**从Session 中获取到当前用户**，用这样的方式来实现`会话机制`。

（1）增加会话控制

首先在UserDto中定义一个`SESSION_USER_KEY`，作为`Session中存放登录用户信息的key`。

public static final String SESSION_USER_KEY = "_user";

然后修改LoginController，`认证成功后，将用户信息放入当前会话。并增加用户登出方法，登出时将session置为失效`。

@RestController
    public class LoginController { 
    
        @Resource
        private AuthenticationService authenticationService;
    
        @RequestMapping(value = "/login", produces = { "text/plain;charset=UTF-8"})
        public String login(AuthenticationRequest authenticationRequest, HttpSession session) { 
            UserDto userDto = authenticationService.authentication(authenticationRequest);
    
           // 认证通过后, 将用户的信息存储到seesion中
            session.setAttribute(UserDto.SESSION_USER_KEY, userDto);
            return userDto.getUsername() + "登录成功";
        }
    
        @GetMapping(value = "/logout", produces = { "text/plain;charset=UTF-8"})
        public String logout(HttpSession session) { 
            session.invalidate();
            return "退出成功";
        }
    }

（2）增加测试资源 `修改LoginController`，增加测试资源1，它从当前会话session中获取当前登录用户，并返回提示信息给前台

@GetMapping(value = "/r/r1", produces = { "text/plain;charset=UTF-8"})
        public String r1(HttpSession session) { 
            String fullname = null;
            // 当session中有数据的时候
            Object object = session.getAttribute(UserDto.SESSION_USER_KEY);
            if (object == null) { 
                fullname = "匿名";
            } else { 
                // 取出session中的用户信息
                UserDto userDto = (UserDto) object;
                fullname = userDto.getFullname();
            }
            return fullname + "访问资源r1";
        }
    
        @GetMapping(value = "/r/r2", produces = { "text/plain;charset=UTF-8"})
        public String r2(HttpSession session) { 
            String fullname = null;
            Object userObj = session.getAttribute(UserDto.SESSION_USER_KEY);
            if (userObj != null) { 
                fullname = ((UserDto) userObj).getFullname();
            } else { 
                fullname = "匿名";
            }
            return fullname + " 访问资源2";
        }

（3）测试

*  未登录情况下直接访问测试资源/r/r1：  
    ![在这里插入图片描述][20200721230859127.png]
 *  成功登录的情况下访问测试资源/r/r1:  
    ![在这里插入图片描述][202007212309060.png]  
    测试结果说明，**在用户登录成功时，该用户信息已被成功放入session，并且后续请求可以正常从session中获取当前登录用户信息，符合预期结果。**

### 7、 实现授权功能 ###

现在我们已经完成了`用户身份凭证的校验`以及`登录的状态保持`，并且我们也知道了`如何获取当前登录用户(从 Session中获取)的信息`，接下来，**用户访问系统需要经过授权**，即需要完成如下功能：

*  `匿名用户（未登录用户）访问拦截`：禁止匿名用户访问某些资源。
 *  `登录用户访问拦截`：根据**用户的权限**决定**是否能访问某些资源**。

（1）增加权限数据

*  为了实现这样的功能，我们需要在`UserDto`里`增加权限属性`，用于表示该登录用户所拥有的权限，同时修改 UserDto的构造方法。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]
 *  并在`AuthenticationServiceImpl`中为模拟用户`初始化权限`，其中**张三给了p1权限**，**李四给了p2权限**。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]

（2）增加测试资源 我们想实现针对不同的用户能访问不同的资源，前提是得有多个资源，因此在LoginController中增加测试资源2。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 7]  
（3）实现授权拦截器在`interceptor`包下定义`SimpleAuthenticationInterceptor`拦截器，实现授权拦截：

*  1、校验用户是否登录
 *  2、校验用户是否拥有操作权限

@Component
    public class SimpleAuthenticationInterceptor implements HandlerInterceptor { 
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
            //在这个方法中校验用户请求的url是否在用户的权限范围内
            //取出用户身份信息
            Object object = request.getSession().getAttribute(UserDto.SESSION_USER_KEY);
            if(object == null){ 
                //没有认证，提示登录
                writeContent(response,"请登录");
            }
            UserDto userDto = (UserDto) object;
            if (userDto != null) { 
                //请求的url
                String requestURI = request.getRequestURI();
                // 登录的用户包含p1权限, 且请求的url中包含/r/r1, 代表有权访问
                if (userDto.getAuthorities().contains("p1") && requestURI.contains("/r/r1")) { 
                    return true;
                }
                if (userDto.getAuthorities().contains("p2") && requestURI.contains("/r/r2")) { 
                    return true;
                }
                writeContent(response, "没有权限，拒绝访问");
            }
            return false;
        }
    
        //响应信息给客户端
        private void writeContent(HttpServletResponse response, String msg) throws IOException { 
            response.setContentType("text/html;charset=utf-8");
            PrintWriter writer = response.getWriter();
            writer.print(msg);
            writer.close();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 8]  
（4）测试 未登录情况下，/r/r1与/r/r2均提示 “请先登录”。

*  张三登录情况下，`由于张三有p1权限，因此可以访问/r/r1，张三没有p2权限，访问/r/r2时提示 "权限不足 "`。
 *  李四登录情况下，`由于李四有p2权限，因此可以访问/r/r2，李四没有p1权限，访问/r/r1时提示 "权限不足 "`。

测试结果全部符合预期结果。

# 三、小结 #

*  基于`Session的认证方式`是一种常见的`认证方式`，至今还有非常多的系统在使用。我们在此小节使用Spring MVC技 术对它进行简单实现，旨在让大家更清晰实在的了解`用户认证、授权以及会话的功能`意义及实现套路，也就是它们 分别干了哪些事儿？大概需要怎么做？
 *  而在正式生产项目中，我们往往会考虑使用`第三方安全框架`（如 `spring security，shiro`等安全框架）来实现`认证 授权`功能，因为这样做能一定程度提高生产力，提高软件标准化程度，另外往往这些框架的可扩展性考虑的非常全面。但是缺点也非常明显，这些通用化组件为了提高支持范围会增加很多可能我们不需要的功能，结构上也会比较抽象，如果我们不够了解它，一旦出现问题，将会很难定位。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]: /images/20230209/211ceaf1839d4e0e86db0d0094fcdbbb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200721222425769.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200721223359147.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200721223603687.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200721224943185.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[20200721225151851.png]: https://img-blog.csdnimg.cn/20200721225151851.png
[2020072123014497.png]: https://img-blog.csdnimg.cn/2020072123014497.png
[20200721230159441.png]: https://img-blog.csdnimg.cn/20200721230159441.png
[20200721230859127.png]: https://img-blog.csdnimg.cn/20200721230859127.png
[202007212309060.png]: https://img-blog.csdnimg.cn/202007212309060.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200721231445886.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20201204190742800.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200721231537736.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200721231657956.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw,size_16,color_FFFFFF,t_70