step04day09文件上传案例总结及单点登录系统准备

1.结合gateway的文件上传案例

1.1案例结构

说明：gateway的文件上传的会启动资源端，网关和ui端，资源端负责执行对应功能，网关转发存储请求，ui端执行前端页面功能。 

1.2案例流程分析

说明：比较基础的单点登录系统是客户通过网关，访问相应的数据资源

1.3案例代码及测试结果

1.项目依赖

<dependency>
      <groupId>com.alibaba.cloud</groupId>
     <artifactId>spring-cloud-alibaba-dependencies</artifactId>
      <version>2.2.6.RELEASE</version>
       <scope>import</scope>
      <type>pom</type>
</dependency>
 <dependency>
      <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-dependencies</artifactId>
      <version>2.3.2.RELEASE</version>
       <scope>import</scope>
      <type>pom</type>
 </dependency>

2.配置文件bootstrap.yml

server:
  port: 9000
spring:
  application:
    name: sca-resource-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848
        file-extension: yml
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
        - id: router01
          uri: lb://sca-resource
          predicates:
            - Path=/sca/resource/upload/**
          filters:
            - StripPrefix=1

3.建项目启动类

@SpringBootApplication
public class ResourceGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(
                ResourceGatewayApplication.class);
    }
}

4 跨域配置

@Configuration
public class CorsFilterConfig {
    @Bean
    public CorsWebFilter corsWebFilter(){
        //1.构建基于url方式的跨域配置
        UrlBasedCorsConfigurationSource source=
                new UrlBasedCorsConfigurationSource();
        //2.进行跨域配置
        CorsConfiguration config=new CorsConfiguration();
        //2.1允许所有ip:port进行跨域
        config.addAllowedOrigin("*");
        //2.2允许所有请求头跨域
        config.addAllowedHeader("*");
        //2.3允许所有请求方式跨域:get,post,..
        config.addAllowedMethod("*");
        //2.4允许携带有效cookie进行跨域
        config.setAllowCredentials(true);
        source.registerCorsConfiguration("/**",config);
        return new CorsWebFilter(source);
    }
}

5.网关状态码设置

@Configuration
public class GatewayConfig {
    public GatewayConfig(){
        GatewayCallbackManager.setBlockHandler(
                new BlockRequestHandler() {
                    @Override
                    public Mono<ServerResponse> handleRequest
                            (ServerWebExchange serverWebExchange,
                             Throwable throwable) {
                        //ServerHttpResponse response=
                                //serverWebExchange.getResponse();
                        //第二种方式
                        Map<String,Object> map=new HashMap<>();
                        map.put("state",429);
                        map.put("message","two many request");
                        //String jsonStr= JSON.toJSONString(map);
                        Gson gson=new Gson();
                        String jsonStr=gson.toJson(map);

                        return ServerResponse.ok().body(
                                Mono.just(jsonStr),String.class);
                        //第一种方式
                        //return response.writeWith(Mono.just(dataBuffer));
                        //return ServerResponse.ok().body(Mono.just(""), Map.class);//webFlux提供的操作

                    }
                }
        );
    }
}

6.测试访问

启动网关，资源，ui端和nacos,输入网址http://localhost:8080/fileupload.html上传文件测试

 7.调用过程分析

1.4  可能出现的bug

• 401 : 访问资源时没有认证。
• 403 : 访问资源时没有权限。
• 404：访问的资源找不到（一定要检查你访问资源的url）
• 405: 请求方式不匹配（客户端请求方式是GET，服务端处理请求是Post就是这个问题）
• 500: 不看后台无法解决？（error,warn）

1.5 FAQ分析

为什么要单点登陆（分布式系统，再访问不同服务资源时，不要总是要登陆，进而改善用户体验）
单点登陆解决方案？(市场常用两种: spring security+jwt+oauth2,spring securit+redis+oauth2)
Spring Security 是什么？（spring框架中的一个安全默认，实现了认证和授权操作）
JWT是什么？（一种令牌格式，一种令牌规范，通过对JSON数据采用一定的编码，加密进行令牌设计）
OAuth2是什么？（一种认证和授权规范，定义了单点登陆中服务的划分方式，认证的相关类型）
 

2.单点登录系统的相关知识准备

2.1.认证管理器及认证配置核心

1.在SecurityConfig中添加如下方法

 @Bean
    public AuthenticationManager authenticationManagerBean()
            throws Exception {
        return super.authenticationManagerBean();
    }

2、拼装最后的主体部分，这个主体部分就是授权服务器的核心配置

@AllArgsConstructor
@Configuration
@EnableAuthorizationServer //开启认证和授权服务
public class Oauth2Config extends AuthorizationServerConfigurerAdapter {
    //此对象负责完成认证管理
    private AuthenticationManager authenticationManager;
    //TokenStore负责完成令牌创建,信息读取
    private TokenStore tokenStore;
    //JWT令牌转换器(基于用户信息构建令牌,解析令牌)
    private JwtAccessTokenConverter jwtAccessTokenConverter;
    //密码加密匹配器对象
    private PasswordEncoder passwordEncoder;
    //负责获取用户信息信息
    private UserDetailsService userDetailsService;



    //设置认证端点的配置(/oauth/token),客户端通过这个路径获取JWT令牌
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
        //配置认证管理器
        .authenticationManager(authenticationManager)
        //验证用户的方法获得用户详情
        .userDetailsService(userDetailsService)
        //要求提交认证使用post请求方式,提高安全性
        .allowedTokenEndpointRequestMethods(HttpMethod.POST,HttpMethod.GET)
        //要配置令牌的生成,由于令牌生成比较复杂,下面有方法实现
        .tokenServices(tokenService());//这个不配置,默认令牌UUID.randomUUID().toString()
    }

//定义令牌生成策略
    @Bean
    public AuthorizationServerTokenServices tokenService(){
        //这个方法的目标就是获得一个令牌生成器
        DefaultTokenServices services=new DefaultTokenServices();
        //支持令牌刷新策略(令牌有过期时间)
        services.setSupportRefreshToken(true);
        //设置令牌生成策略(tokenStore在TokenConfig配置了,本次我们应用JWT-定义了一种令牌格式)
        services.setTokenStore(tokenStore);
        //设置令牌增强(允许设置令牌生成策略,默认是非jwt方式,现在设置为jwt方式,并在令牌Payload部分允许添加扩展数据,例如用户权限信息)
        TokenEnhancerChain chain=new TokenEnhancerChain();
        chain.setTokenEnhancers(Arrays.asList(jwtAccessTokenConverter));
        services.setTokenEnhancer(chain);
        //设置令牌有效期
        services.setAccessTokenValiditySeconds(3600);//1小时
        //刷新令牌应用场景：一般在用户登录系统后，令牌快过期时，系统自动帮助用户刷新令牌，提高用户的体验感
        services.setRefreshTokenValiditySeconds(3600*72);//3天
        return services;
    }

    //设置客户端详情类似于用户详情
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()
        //客户端id (客户端访问时需要这个id)
        .withClient("gateway-client")
        //客户端秘钥(客户端访问时需要携带这个密钥)
        .secret(passwordEncoder.encode("123456"))
        //设置权限
        .scopes("all")//all只是个名字而已和写abc效果相同
        //允许客户端进行的操作  这里的认证方式表示密码方式,里面的字符串千万不能写错
        .authorizedGrantTypes("password","refresh_token");
    }
    // 认证成功后的安全约束配置,对指定资源的访问放行,我们登录时需要访问/oauth/token,需要对这样的url进行放行
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        //认证通过后,允许客户端进行哪些操作
        security
        //公开oauth/token_key端点
        .tokenKeyAccess("permitAll()")
        //公开oauth/check_token端点
        .checkTokenAccess("permitAll()")
        //允许提交请求进行认证(申请令牌)
        .allowFormAuthenticationForClients();
    }
}

2.1.JWT令牌

@Configuration
public class TokenConfig {
    //定义令牌签发口令(暗号),这个口令自己定义即可
    //在对header和PAYLOAD部分进行签名时,需要的一个口令
    private String SIGNING_KEY= "auth";
    //初始化令牌生成策略(默认生成策略 UUID)
    //这里我们采用JWT方式生成令牌
    @Bean
    public TokenStore tokenStore(){
        return new JwtTokenStore(jwtAccessTokenConverter());
    }
    //构建JWT令牌转换器对象,基于此对象创建令牌,解析令牌
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(){
        JwtAccessTokenConverter converter=new JwtAccessTokenConverter();
        converter.setSigningKey(SIGNING_KEY);
        return converter;
    }
}

创建JWT令牌配置类,基于这个类实现令牌对象的创建和解析.
* JWT令牌的构成有三部分构成:
* 1)HEADER (头部信息:令牌类型,签名算法)
* 2)PAYLOAD (数据信息-用户信息,权限信息,令牌失效时间,...)
* 3)SIGNATURE (签名信息-对header和payload部分进行加密签名)

2.1.oauth2协议

oauth2将系统登录所需的授权以及颁发令牌的功能进行了封装，将获取用户信息信息（userDetailsService），JWT令牌转换器，令牌创建器（tokenStore），认证管理器（authenticationManager）等功能封装到一个对象，好方便使用者调用，具体代码如下：

@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Autowired
    private TokenStore tokenStore;
    /** token服务配置*/
    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.tokenStore(tokenStore);
    }
    /**路由安全认证配置 */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.csrf().disable();
        http.exceptionHandling()
                .accessDeniedHandler(accessDeniedHandler());
        http.authorizeRequests().anyRequest().permitAll();

    }
    //没有权限时执行此处理器方法
    public AccessDeniedHandler accessDeniedHandler() {
        return (request, response, e) -> {
            Map<String, Object> map = new HashMap<>();
            map.put("state", HttpServletResponse.SC_FORBIDDEN);//SC_FORBIDDEN的值是403
            map.put("message", "没有访问权限,请联系管理员");
            //1设置响应数据的编码
            response.setCharacterEncoding("utf-8");
            //2告诉浏览器响应数据的内容类型以及编码
            response.setContentType("application/json;charset=utf-8");
            //3获取输出流对象
            PrintWriter out=response.getWriter();
            //4 输出数据
            String result=
                    new ObjectMapper().writeValueAsString(map);
            out.println(result);
            out.flush();
        };
    }

2.4 Spring Security 技术

Spring Security 是一个企业级安全框架,由spring官方推出,它对软件系统中的认证,授权,加密等功能进行封装,并在springboot技术推出以后,配置方面做了很大的简化.现在市场上分布式架构中的安全控制，正在逐步的转向Spring Security。Spring Security 在企业中实现认证和授权业务时,底层构建了大量的过滤器，如图所示：

Spring Security技术执行流程如下：

3,单点登录流程分析

1.自定义登陆逻辑

业务描述

我们的单点登录系统最终会按照如下结构进行设计和实现,例如:

 我们在实现登录时,会在UI工程中,定义登录页面(login.html),然后在页面中输入自己的登陆账号，登陆密码,将请求提交给网关,然后网关将请求转发到auth工程,登陆成功和失败要返回json数据。

具体过程：

1定义安全配置类

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    /**初始化密码加密对象*/
    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //关闭跨域工具
        http.csrf().disable();
        //放行所有请求
        http.authorizeRequests().anyRequest().permitAll();
        //登录成功与失败的处理
        http.formLogin()
                .successHandler(successHandler())
                .failureHandler(failureHandler());
    }

    @Bean
    public AuthenticationSuccessHandler successHandler(){
        return (request,response,authentication) ->{
            //1.构建map对象,封装响应数据
            Map<String,Object> map=new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //2.将map对象写到客户端
            writeJsonToClient(response,map);
        };
    }
    @Bean
    public AuthenticationFailureHandler failureHandler(){
        return (request,response, e)-> {
            //1.构建map对象,封装响应数据
            Map<String,Object> map=new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //2.将map对象写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,
                                   Object object) throws IOException {
        //1.将对象转换为json
        //将对象转换为json有3种方案:
        //1)Google的Gson-->toJson  (需要自己找依赖)
        //2)阿里的fastjson-->JSON (spring-cloud-starter-alibaba-sentinel)
        //3)Springboot web自带的jackson-->writeValueAsString (spring-boot-starter-web)
        //我们这里借助springboot工程中自带的jackson
        //jackson中有一个对象类型为ObjectMapper,它内部提供了将对象转换为json的方法
        //例如:
        String jsonStr=new ObjectMapper().writeValueAsString(object);
        //3.将json字符串写到客户端
        PrintWriter writer = response.getWriter();
        writer.println(jsonStr);
        writer.flush();
    }
}

说明：   在这个方法中定义登录规则
     * 1)对所有请求放行(当前工程只做认证)
     * 2)登录成功信息的返回
     * 3)登录失败信息的返回

 2.定义用户信息处理对象

在spring security应用中底层会借助UserDetailService对象获取数据库信息,并进行封装,最后返回给认证管理器,完成认证操作,例如:

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;
    //UserDetails用户封装用户信息(认证和权限信息)

    @Override
    public UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException {
        //1.基于用户名查询用户信息(用户名,用户状态,密码,....)
        //Userinfo userinfo=userMapper.selectUserByUsername(username);
        String encodedPassword=passwordEncoder.encode("123456");
        //2.查询用户权限信息(后面会访问数据库)
        //这里先给几个假数据
        List<GrantedAuthority> authorities =
        AuthorityUtils.createAuthorityList(//这里的权限信息先这么写,后面讲
                "sys:res:create", "sys:res:retrieve");
        //3.对用户信息进行封装
        return new User(username,encodedPassword,authorities);
    }
}

3.登陆路由配置

在网关配置文件中添加登录路由配置,例如

 - id: router02
   uri: lb://sca-auth  #lb表示负载均衡,底层默认使用ribbon实现
   predicates: #定义请求规则(请求需要按照此规则设计)
      - Path=/auth/login/** #请求路径设计
   filters:
      - StripPrefix=1 #转发之前去掉path中第一层路径

4 . 添加前端页面

页面关键代码
<h3>Please Login</h3>
    <form>
        <button type="button" @click="doLogin()" class="btn btn-primary">Submit</button>
    </form>




<script>
    var vm=new Vue({
        el:"#app",//定义监控点，vue底层会基于此监控点在内存中构建dom树
        data:{ //此对象中定义页面上要操作的数据
            username:"",
            password:""
        },
        methods: {//此位置定义所有业务事件处理函数
            doLogin() {
                //1.定义url
                let url = "http://localhost:9000/auth/login"
                //2.定义参数

                let params = new URLSearchParams()
                params.append('username',this.username);
                params.append('password',this.password);
                //3.发送异步请求
                axios.post(url, params).then((response) => {
                    debugger
                    let result=response.data;
                    console.log(result);
                    if (result.state == 200) {
                        alert("login ok");
                    } else {
                        alert(result.message);
                    }
                })
            }
        }
    });
</script>

5.启动sca-resource-ui服务后，进入登陆页面，输入用户名jack,密码123456进行登陆测试

6. 基于Postman进行访问测试

启动sca-gateway，sca-auth服务，然后基于postman访问网关,执行登录测试，例如：

4.结合redis数据库的单点登录系统简单运用

4.1分布式架构图

4.2 代码实现

4.3 结构分析