Spring Security（安全框架）_飞道的博客

Spring Security（安全框架）

2022-11-08 18:09 322人阅读评论(0)

一、概念

（1）Spring Security是一个高度自定义的安全框架。利用Spring IoC/DI和AOP功能，为系统提供了声明式安全访问控制功能，减少了为系统安全而编写大量重复代码的工作。

（2）认证（Authentication）：应用程序确认用户身份的过程，常见认证：登录。

（3）身份（principal）/主体（Subject）：认证用户的主要凭证之一。可以是账号、邮箱、手机号等。在java中主体是Object类型。

（4）凭证（Credential）：用户认证过程中的依据之一。常见就是密码。

（5）授权（Authorization）：判断用户具有哪些权限或角色。

（6）Spring Security所有功能都是基于Filter（过滤器）实现的。

二、使用方式

（1）导入依赖

导入依赖后默认会有一个登录页，并且没有登录时访问其他资源会自动跳到登录页，用户名为user，密码会打印在控制台。

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>

（2）可以在配置文件中配置用户名和密码

spring.security.user.name=user
spring.security.user.password=123

（3）使用数据库中的数据认证

1.给配置Spring Security密码解析器


  
   
    
     
    
    
     
      package com.bjsxt.config;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      import org.springframework.context.annotation.Bean;
     
    
   
    
     
    
    
     
      import org.springframework.context.annotation.Configuration;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.password.PasswordEncoder;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      @Configuration
     
    
   
    
     
    
    
     
      public 
      class 
      UserDetailConfig {
     
    
   
    
     
    
    
         
      @Bean
     
    
   
    
     
    
    
         
      public PasswordEncoder 
      passwordEncoder
      (){
     
    
   
    
     
    
    
             
      return 
      new 
      BCryptPasswordEncoder();
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
     
      }

2.实现 UserDetailsService 接口并重写 loadUserByUsername( )方法


  
   
    
     
    
    
     
      package com.bjsxt.service.impl;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      import com.bjsxt.mapper.AdminMapper;
     
    
   
    
     
    
    
     
      import com.bjsxt.pojo.Admin;
     
    
   
    
     
    
    
     
      import org.springframework.beans.factory.annotation.Autowired;
     
    
   
    
     
    
    
     
      import org.springframework.security.core.authority.AuthorityUtils;
     
    
   
    
     
    
    
     
      import org.springframework.security.core.userdetails.User;
     
    
   
    
     
    
    
     
      import org.springframework.security.core.userdetails.UserDetails;
     
    
   
    
     
    
    
     
      import org.springframework.security.core.userdetails.UserDetailsService;
     
    
   
    
     
    
    
     
      import org.springframework.security.core.userdetails.UsernameNotFoundException;
     
    
   
    
     
    
    
     
      import org.springframework.stereotype.Service;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      @Service
     
    
   
    
     
    
    
     
      public 
      class 
      UserDetailsServiceImpl 
      implements 
      UserDetailsService {
     
    
   
    
     
    
    
         
      @Autowired
     
    
   
    
     
    
    
         
      private AdminMapper adminMapper;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      @Override
     
    
   
    
     
    
    
         
      public UserDetails 
      loadUserByUsername
      (String username) 
      throws UsernameNotFoundException {
     
    
   
    
     
    
    
             
      Admin 
      admin 
      = adminMapper.selectByName(username);
     
    
   
    
     
    
    
             
      if(admin == 
      null){
     
    
   
    
     
    
    
                 
      throw 
      new 
      UsernameNotFoundException(
      "用户名不存在");
     
    
   
    
     
    
    
     
              }
     
    
   
    
     
    
    
             
      return 
      new 
      User(username,admin.getApwd(), AuthorityUtils.NO_AUTHORITIES);
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
     
      }

（4）自定义登录页面：新建一个配置类继承WebSecurityConfigurerAdapter类并重写configure(HttpSecurity http)方法，在该方法中进行配置。


  
   
    
     
    
    
     
      package com.bjsxt.config;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      import org.springframework.context.annotation.Bean;
     
    
   
    
     
    
    
     
      import org.springframework.context.annotation.Configuration;
     
    
   
    
     
    
    
     
      import org.springframework.security.config.annotation.web.builders.HttpSecurity;
     
    
   
    
     
    
    
     
      import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.password.PasswordEncoder;
     
    
   
    
     
    
    
     
      import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
     
    
   
    
     
    
    
     
      import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      @Configuration
     
    
   
    
     
    
    
     
      public 
      class 
      UserDetailConfig 
      extends 
      WebSecurityConfigurerAdapter {
     
    
   
    
     
    
    
         
      @Override
     
    
   
    
     
    
    
         
      protected 
      void 
      configure
      (HttpSecurity http) 
      throws Exception {
     
    
   
    
     
    
    
     
              http.formLogin()
     
    
   
    
     
    
    
     
                      .loginPage(
      "/")
      //配置哪个页面是登录页面
     
    
   
    
     
    
    
     
                      .loginProcessingUrl(
      "/login")
      //配置哪个请求是提交登录表单的请求
     
    
   
    
     
    
    
     
                      .usernameParameter(
      "username")
      //配置用户名参数名
     
    
   
    
     
    
    
     
                      .passwordParameter(
      "password")
      //配置密码参数名
     
    
   
    
     
    
    
     
                      .successForwardUrl(
      "/showMain")
      //登录成功转发到哪
     
    
   
    
     
    
    
     
                      .failureForwardUrl(
      "/")
      //登录失败转发到哪
     
    
   
    
     
    
    
     
                      .successHandler(
      new 
      SimpleUrlAuthenticationSuccessHandler(
      "/showMain"))
      //登录成功重定向到哪
     
    
   
    
     
    
    
     
                      .failureHandler(
      new 
      SimpleUrlAuthenticationFailureHandler(
      "/"));
      //登录失败后重定向到哪
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              http.authorizeRequests()
     
    
   
    
     
    
    
     
                      .antMatchers(
      "/",
      "/login").permitAll()
      //允许
     
    
   
    
     
    
    
     
                      .antMatchers(
      "**").authenticated();
      //需要认证
     
    
   
    
     
    
    
                     
      /* anyRequest()等价于antMatchers("**") */
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              http.logout()
     
    
   
    
     
    
    
     
                      .logoutRequestMatcher(
      new 
      AntPathRequestMatcher(
      "/logout"))
      //哪个URl执行退出登录的功能
     
    
   
    
     
    
    
     
                      .logoutSuccessUrl(
      "/");
      //退出登录后跳转到哪
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
             
      //http.csrf().disable();//禁用csrf
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      @Bean
     
    
   
    
     
    
    
         
      public PasswordEncoder 
      passwordEncoder
      (){
     
    
   
    
     
    
    
             
      return 
      new 
      BCryptPasswordEncoder();
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
     
      }

三、PasswordEncoder密码解析器

（1）用途：给密码进行加密处理。它是一个接口

（2）接口介绍：

encode():把参数按照特定的解析规则进行解析。

matches()验证从存储中获取的编码密码与编码后提交的原始密码是否匹配。如果密码匹配，则返回true；如果不匹配，则返回false。第一个参数表示需要被解析的密码。第二个参数表示存储的密码。

upgradeEncoding()：如果解析的密码能够再次进行解析且达到更安全的结果则返回true，否则返回false。默认返回false。

（3）官方推荐实现类BCryptPasswordEncoder


  
   
    
     
    
    
     
      package com.bjsxt;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      import org.junit.jupiter.api.Test;
     
    
   
    
     
    
    
     
      import org.springframework.boot.test.context.SpringBootTest;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      @SpringBootTest
     
    
   
    
     
    
    
     
      class 
      Day03ApplicationTests {
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      @Test
     
    
   
    
     
    
    
         
      void 
      contextLoads
      () {
     
    
   
    
     
    
    
             
      BCryptPasswordEncoder 
      be 
      = 
      new 
      BCryptPasswordEncoder();
     
    
   
    
     
    
    
             
      String 
      encode 
      = be.encode(
      "123");
     
    
   
    
     
    
    
     
              System.out.println(encode);
     
    
   
    
     
    
    
             
      boolean 
      matches 
      = be.matches(
      "123", encode);
     
    
   
    
     
    
    
     
              System.out.println(matches);
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
     
      }

四、Spring Security中的CSRF

（1） CSRF（Cross-site request forgery）跨站请求伪造，也被称为“One Click Attack” 或者Session Riding。通过伪造用户请求访问受信任站点的非法请求访问。

（2）原理

当服务器加载登录页面。（loginPage中的值，默认/login），先生成csrf对象，并放入作用域中，key为_csrf。之后会对${_csrf.token}进行替换，替换成服务器生成的token字符串。
用户在提交登录表单时，会携带csrf的token。如果客户端的token和服务器的token匹配说明是自己的客户端，否则无法继续执行。
用户退出的时候，必须发起POST请求，且和登录时一样，携带csrf的令牌。

<input type="hidden" th:value="${_csrf.token}" name="_csrf" th:if="${_csrf}"/>

五、Spring Security实现记住我的功能

（1）在客户端登录页面中添加remember-me的复选框，只要用户勾选了复选框下次就不需要进行登录了。


  
   
    
     
    
    
     
      <form action = "/login" method="post">
     
    
   
    
     
    
    
     
          用户名：
      <input type="text" name="username"/>
      <br/>
     
    
   
    
     
    
    
     
          密码:
      <input type="text" name="password"/>
      <br/>
     
    
   
    
     
    
    
         
      <input type="checkbox" name="remember-me" value="true"/> 
      <br/>
     
    
   
    
     
    
    
         
      <input type="submit" value="登录"/>
     
    
   
    
     
    
    
     
      </form>

（2）配置数据源，告诉Spring Security存储记住的账号信息的数据源是哪里。


  
   
    
     
    
    
     
      @Configuration
     
    
   
    
     
    
    
     
      public 
      class 
      RememberMeConfig {
     
    
   
    
     
    
    
         
      @Autowired
     
    
   
    
     
    
    
         
      private DataSource dataSource;
     
    
   
    
     
    
    
         
      @Bean
     
    
   
    
     
    
    
         
      public PersistentTokenRepository 
      getPersistentTokenRepository
      () {
     
    
   
    
     
    
    
     
              JdbcTokenRepositoryImpl jdbcTokenRepositoryImpl=
      new 
      JdbcTokenRepositoryImpl();
     
    
   
    
     
    
    
     
              jdbcTokenRepositoryImpl.setDataSource(dataSource);
     
    
   
    
     
    
    
             
      // 自动建表，第一次启动时需要，第二次启动时注释掉
     
    
   
    
     
    
    
             
      // jdbcTokenRepositoryImpl.setCreateTableOnStartup(true);
     
    
   
    
     
    
    
             
      return jdbcTokenRepositoryImpl;
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
     
      }

（3）配置remember-me，让记住我功能生效


  
   
    
     
    
    
     
      package com.bjsxt.config;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      import org.springframework.beans.factory.annotation.Autowired;
     
    
   
    
     
    
    
     
      import org.springframework.context.annotation.Bean;
     
    
   
    
     
    
    
     
      import org.springframework.context.annotation.Configuration;
     
    
   
    
     
    
    
     
      import org.springframework.security.config.annotation.web.builders.HttpSecurity;
     
    
   
    
     
    
    
     
      import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
     
    
   
    
     
    
    
     
      import org.springframework.security.core.userdetails.UserDetailsService;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
     
    
   
    
     
    
    
     
      import org.springframework.security.crypto.password.PasswordEncoder;
     
    
   
    
     
    
    
     
      import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
     
    
   
    
     
    
    
     
      import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
     
    
   
    
     
    
    
     
      import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      @Configuration
     
    
   
    
     
    
    
     
      public 
      class 
      UserDetailConfig 
      extends 
      WebSecurityConfigurerAdapter {
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      @Autowired
     
    
   
    
     
    
    
         
      private UserDetailsService userDetailsService;
     
    
   
    
     
    
    
         
      @Autowired
     
    
   
    
     
    
    
         
      private PersistentTokenRepository persistentTokenRepository;
     
    
   
    
     
    
    
         
      @Override
     
    
   
    
     
    
    
         
      protected 
      void 
      configure
      (HttpSecurity http) 
      throws Exception {
     
    
   
    
     
    
    
     
              http.formLogin()
     
    
   
    
     
    
    
     
                      .loginPage(
      "/")
      //配置哪个页面是登录页面
     
    
   
    
     
    
    
     
                      .loginProcessingUrl(
      "/login")
      //配置哪个请求是提交登录表单的请求
     
    
   
    
     
    
    
     
                      .usernameParameter(
      "username")
      //配置用户名参数名
     
    
   
    
     
    
    
     
                      .passwordParameter(
      "password")
      //配置密码参数名
     
    
   
    
     
    
    
     
                      .successForwardUrl(
      "/showMain")
      //登录成功转发到哪
     
    
   
    
     
    
    
     
                      .failureForwardUrl(
      "/")
      //登录失败转发到哪
     
    
   
    
     
    
    
     
                      .successHandler(
      new 
      SimpleUrlAuthenticationSuccessHandler(
      "/showMain"))
      //登录成功重定向到哪
     
    
   
    
     
    
    
     
                      .failureHandler(
      new 
      SimpleUrlAuthenticationFailureHandler(
      "/"));
      //登录失败后重定向到哪
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              http.authorizeRequests()
     
    
   
    
     
    
    
     
                      .antMatchers(
      "/",
      "/login").permitAll()
      //允许
     
    
   
    
     
    
    
     
                      .antMatchers(
      "**").authenticated();
      //需要认证
     
    
   
    
     
    
    
                     
      /* anyRequest()等价于antMatchers("**") */
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              http.logout()
     
    
   
    
     
    
    
     
                      .logoutUrl(
      "/abc")
      //哪个URl执行退出登录的功能
     
    
   
    
     
    
    
     
                      .logoutSuccessUrl(
      "/");
      //退出登录后跳转到哪
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
             
      /*http.csrf().disable();//禁用csrf*/
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
             
      //配置rememberMe
     
    
   
    
     
    
    
     
              http.rememberMe()
     
    
   
    
     
    
    
     
                      .userDetailsService(userDetailsService)
     
    
   
    
     
    
    
     
                      .tokenRepository(persistentTokenRepository);
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      @Bean
     
    
   
    
     
    
    
         
      public PasswordEncoder 
      passwordEncoder
      (){
     
    
   
    
     
    
    
             
      return 
      new 
      BCryptPasswordEncoder();
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
     
      }

六、访问控制url匹配

在配置类中http.authorizeRequests()主要是对url进行控制，也就是我们所说的授权（访问控制）。

（1）antMatcher()：参数是不定向参数，每个参数是一个ant表达式，用于匹配URL规则。

（2）anyRequest()：在之前认证过程中我们就已经使用过anyRequest()，表示匹配所有的请求。一般情况下此方法都会使用，设置全部内容都需要进行认证。

（3）regexMatchers()：使用正则表达式进行匹配。和antMatchers()主要的区别就是参数，antMatchers()参数是ant表达式，regexMatchers()参数是正则表达式。

七、内置访问控制方法

（1）permitAll()：表示所匹配的URL任何人都允许访问。

（2）authenticated()：表示所匹配的URL都需要被认证才能访问。

（3）anonymous()：表示可以匿名访问匹配的URL，登录后不能访问。

（4）denyAll()：表示所匹配的URL都不允许被访问。

（5）rememberMe()：被“remember me”的用户允许访问

（6）fullyAuthenticated()：如果用户不是被remember me的，才可以访问。

八、角色和权限判断

（1）hasAuthority(String)：判断用户是否具有特定的权限，用户的权限是在自定义登录逻辑中创建User对象时指定的。

（2）hasAnyAuthority(String ...)：如果用户具备给定权限中某一个，就允许访问。

（3）hasRole(String)：如果用户具备给定角色就允许访问。否则出现403。

（4）hasAnyRole(String ...)：如果用户具备给定角色的任意一个，就允许被访问

（5）hasIpAddress(String)：如果请求是指定的IP就运行访问。

九、自定义403处理方案

（1）新建类实现AccessDeniedHandler。


  
   
    
     
    
    
     
      @Component
     
    
   
    
     
    
    
     
      public 
      class 
      MyAccessDeniedHandler 
      implements 
      AccessDeniedHandler {
     
    
   
    
     
    
    
         
      @Override
     
    
   
    
     
    
    
         
      public 
      void 
      handle
      (HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) 
      throws IOException, ServletException {
     
    
   
    
     
    
    
             
      //这里写出现403异常后的操作
     
    
   
    
     
    
    
     
              httpServletResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);
     
    
   
    
     
    
    
     
              httpServletResponse.setHeader(
      "Content-Type",
      "application/json;charset=utf-8");
     
    
   
    
     
    
    
             
      PrintWriter 
      out 
      = httpServletResponse.getWriter();
     
    
   
    
     
    
    
     
              out.write(
      "{\"status\":\"error\",\"msg\":\"权限不足，请联系管理员!\"}");
     
    
   
    
     
    
    
     
              out.flush();
     
    
   
    
     
    
    
     
           }
     
    
   
    
     
    
    
     
      }

（2）配置类中重点添加异常处理器

@Autowired
private AccessDeniedHandler accessDeniedHandler;

//异常处理
http.exceptionHandling()
.accessDeniedHandler(accessDeniedHandler);

十、权限控制注解

（1）@Secured：是专门用于判断是否具有角色的。能写在方法或类上。@Secured参数要以ROLE_开头。

开启注解：在启动类(也可以在配置类等能够扫描的类上)上添加

@EnableGlobalMethodSecurity(securedEnabled = true)

（2）@PreAuthorize：表示访问方法或类在执行之前先判断权限，大多情况下都是使用这个注解，注解的参数和access()方法参数取值相同，都是权限表达式。

@PostAuthorize：表示方法或类执行结束后判断权限，此注解很少被使用到。

开启注解：在启动类(也可以在配置类等能够扫描的类上)上添加

@EnableGlobalMethodSecurity(prePostEnabled = true)

十一、Thymeleaf中Spring Security的使用

（1）导入依赖

<dependency>
<groupId>org.thymeleaf.extras</groupId>
<artifactId>thymeleaf-extras-springsecurity5</artifactId>
<version>3.0.4.RELEASE</version>
</dependency>

（2）在html页面中引入thymeleaf命名空间和security命名空间

<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org"
xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">

获取属性


  
   
    
     
    
    
     
      <!DOCTYPE html>
     
    
   
    
     
    
    
     
      <html xmlns="http://www.w3.org/1999/xhtml"
     
    
   
    
     
    
    
           
      xmlns:th=
      "http://www.thymeleaf.org"
     
    
   
    
     
    
    
           
      xmlns:sec=
      "http://www.thymeleaf.org/thymeleaf-extras-springsecurity5">
     
    
   
    
     
    
    
     
      <head>
     
    
   
    
     
    
    
         
      <meta charset="UTF-8">
     
    
   
    
     
    
    
         
      <title>Title
      </title>
     
    
   
    
     
    
    
     
      </head>
     
    
   
    
     
    
    
     
      <body>
     
    
   
    
     
    
    
     
          登录账号:
      <span sec:authentication="name">123
      </span>
      <br/>
     
    
   
    
     
    
    
     
          登录账号:
      <span sec:authentication="principal.username">456
      </span>
      <br/>
     
    
   
    
     
    
    
     
          凭证：
      <span sec:authentication="credentials">456
      </span>
      <br/>
     
    
   
    
     
    
    
     
          权限和角色：
      <span sec:authentication="authorities">456
      </span>
      <br/>
     
    
   
    
     
    
    
     
          客户端地址：
      <span sec:authentication="details.remoteAddress">456
      </span>
      <br/>
     
    
   
    
     
    
    
     
          sessionId：
      <span sec:authentication="details.sessionId">456
      </span>
      <br/>
     
    
   
    
     
    
    
     
      </body>
     
    
   
    
     
    
    
     
      </html>

权限判断


  
   
    
     
    
    
     
      通过权限判断：
     
    
   
    
     
    
    
     
      <button sec:authorize="hasAuthority('/insert')">新增
      </button>
     
    
   
    
     
    
    
     
      <button sec:authorize="hasAuthority('/delete')">删除
      </button>
     
    
   
    
     
    
    
     
      <button sec:authorize="hasAuthority('/update')">修改
      </button>
     
    
   
    
     
    
    
     
      <button sec:authorize="hasAuthority('/select')">查看
      </button>
     
    
   
    
     
    
    
     
      <br/>
     
    
   
    
     
    
    
     
      通过角色判断：
     
    
   
    
     
    
    
     
      <button sec:authorize="hasRole('abc')">新增
      </button>
     
    
   
    
     
    
    
     
      <button sec:authorize="hasRole('abc')">删除
      </button>
     
    
   
    
     
    
    
     
      <button sec:authorize="hasRole('abc')">修改
      </button>
     
    
   
    
     
    
    
     
      <button sec:authorize="hasRole('abc')">查看
      </button>

转载：https://blog.csdn.net/weixin_53455615/article/details/127645178

查看评论

飞道的博客

飞道的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章