/**
* Security配置类
*/
@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
  /**
  * http请求处理方法
  *
  * @param http
  * @throws Exception
  */
  @Override
  protected void configure(HttpSecurity http) throws Exception {
  /*http.httpBasic()//开启httpbasic认证
  .and().authorizeRequests().
  anyRequest().authenticated();//所有请求都需要登录认证才能访问*/
  http.formLogin()//开启表单认证
  .and().authorizeRequests().
  .anyRequest().authenticated();//所有请求都需要登录认证才能访问;
  }
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    /*http.httpBasic()//开启httpbasic认证
    .and().authorizeRequests().
    anyRequest().authenticated();//所有请求都需要登录认证才能访问*/
    http.formLogin()//开启表单认证
    .loginPage("/toLoginPage")//自定义登录页面
    .loginProcessingUrl("/login")// 登录处理Url
    .usernameParameter("username").passwordParameter("password"). //修改
    自定义表单name值.
    .successForwardUrl("/")// 登录成功后跳转路径
    .and().authorizeRequests().
    antMatchers("/toLoginPage").permitAll()//放行登录页面
    .anyRequest().authenticated();//所有请求都需要登录认证才能访问;
    // 关闭csrf防护
    http..csrf().disable();
}

http.formLogin()//开启表单认证
.loginPage("/toLoginPage")//自定义登录页面
.loginProcessingUrl("/login")// 登录处理Url
.usernameParameter("username").passwordParameter("password"). //修改自定义表单name值.
.successForwardUrl("/")// 登录成功后跳转路径
.and().authorizeRequests().
antMatchers("/toLoginPage").permitAll()//放行登录页面与静态资源
.anyRequest().authenticated();//所有请求都需要登录认证才能访问;
// 关闭csrf防护
http.csrf().disable();
// 允许iframe加载页面
http.headers().frameOptions().sameOrigin();

@Service
public class MyUserDetailsService implements UserDetailsService {


    @Autowired
    UserService userService;

    @Autowired
    PermissionService permissionService;

    /**
     * 根据用户名查询用户
     *
     * @param username 前端传入的用户名
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userService.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户没有找到," + username);
        }
        // 权限的集合, 先声明一个权限集合, 因为构造方法里面不能传入null
        Collection<GrantedAuthority> authorities = new ArrayList<>();

        UserDetails userDetails = new org.springframework.security.core.userdetails.User
                (username, "{bcrypt}" + user.getPassword(),//noop不使用密码加密 , bcrypt使用加密算法
                        true,// 用户是否启用
                        true,// 用户是否过期
                        true,// 用户凭证是否过期
                        true,// 用户是否锁定
                        authorities);
        return userDetails;
    }
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  auth.userDetailsService(myUserDetailsService);
}

public final class PasswordEncoderFactories {
    private PasswordEncoderFactories() {
    }

    public static PasswordEncoder createDelegatingPasswordEncoder() {
        String encodingId = "bcrypt";
        Map<String, PasswordEncoder> encoders = new HashMap();
        encoders.put(encodingId, new BCryptPasswordEncoder());
        encoders.put("ldap", new LdapShaPasswordEncoder());
        encoders.put("MD4", new Md4PasswordEncoder());
        encoders.put("MD5", new MessageDigestPasswordEncoder("MD5"));
        encoders.put("noop", NoOpPasswordEncoder.getInstance());
        encoders.put("pbkdf2", new Pbkdf2PasswordEncoder());
        encoders.put("scrypt", new SCryptPasswordEncoder());
        encoders.put("SHA-1", new MessageDigestPasswordEncoder("SHA-1"));
        encoders.put("SHA-256", new MessageDigestPasswordEncoder("SHA-256"));
        encoders.put("sha256", new StandardPasswordEncoder());
        encoders.put("argon2", new Argon2PasswordEncoder());
        return new DelegatingPasswordEncoder(encodingId, encoders);
    }
}

/**
     * 获取当前登录用户
     */
    @GetMapping("/loginUser")
    @ResponseBody
    public UserDetails getCurrentUser() {
        UserDetails principal = (UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        return principal;
    }

    /**
     * 获取当前登录用户
     */
    @GetMapping("/loginUser2")
    @ResponseBody
    public UserDetails getCurrentUser1(Authentication authentication) {
        UserDetails principal = (UserDetails) authentication.getPrincipal();
        return principal;
    }

    /**
     * 获取当前登录用户
     */
    @GetMapping("/loginUser3")
    @ResponseBody
    public UserDetails getCurrentUser2(@AuthenticationPrincipal UserDetails userDetails) {
        return userDetails;
    }

.successHandler(myAuthenticationService)
            .failureHandler(myAuthenticationService)//登录成功或者失败的处理
            .and().logout().logoutUrl("/logout")
            .logoutSuccessHandler(myAuthenticationService)

@Service
public class MyAuthenticationService implements AuthenticationSuccessHandler,
        AuthenticationFailureHandler, LogoutSuccessHandler {


    RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();

    @Autowired
    ObjectMapper objectMapper;

    /**
     * 登录成功后处理逻辑
     *
     * @param request
     * @param response
     * @param authentication
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        System.out.println("登录成功后继续处理......");
        // 重定向到index页面,同步操作时这样处理
        // redirectStrategy.sendRedirect(request, response, "/");

        Map result = new HashMap();
        result.put("code", HttpStatus.OK.value());//200
        result.put("message", "登录成功");

        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(result));
    }

    /**
     * 登录失败的处理逻辑
     *
     * @param request
     * @param response
     * @param exception
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        System.out.println("登录失败后继续处理......");
        // 重定向到login页面,同步操作时这样处理
        // redirectStrategy.sendRedirect(request, response, "/toLoginPage");

        Map result = new HashMap();
        result.put("code", HttpStatus.UNAUTHORIZED.value());//401
        result.put("message", exception.getMessage());

        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().write(objectMapper.writeValueAsString(result));
    }

    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        System.out.println("退出之后继续处理...");
        redirectStrategy.sendRedirect(request, response, "/toLoginPage");
    }
}

/**
 * 处理生成验证码的请求
 */
@RestController
@RequestMapping("/code")
public class ValidateCodeController {

    public final static String REDIS_KEY_IMAGE_CODE = "REDIS_KEY_IMAGE_CODE";
    public final static int expireIn = 600;  // 验证码有效时间 60s

    //使用sessionStrategy将生成的验证码对象存储到Session中，并通过IO流将生成的图片输出到登录页面上。
    @Autowired
    public StringRedisTemplate stringRedisTemplate;

    @RequestMapping("/image")
    public void createCode(HttpServletRequest request, HttpServletResponse response) throws IOException {
        //获取访问IP
        String remoteAddr = request.getRemoteAddr();
        //生成验证码对象
        ImageCode imageCode = createImageCode();
        //生成的验证码对象存储到redis中 KEY为REDIS_KEY_IMAGE_CODE+IP地址
        stringRedisTemplate.boundValueOps(REDIS_KEY_IMAGE_CODE + "-" + remoteAddr)
                .set(imageCode.getCode(), expireIn, TimeUnit.SECONDS);
        //通过IO流将生成的图片输出到登录页面上
        ImageIO.write(imageCode.getImage(), "jpeg", response.getOutputStream());
    }

    /**
     * 用于生成验证码对象
     *
     * @return
     */
    private ImageCode createImageCode() {

        int width = 100;    // 验证码图片宽度
        int height = 36;    // 验证码图片长度
        int length = 4;     // 验证码位数
        //创建一个带缓冲区图像对象
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        //获得在图像上绘图的Graphics对象
        Graphics g = image.getGraphics();

        Random random = new Random();

        //设置颜色、并随机绘制直线
        g.setColor(getRandColor(200, 250));
        g.fillRect(0, 0, width, height);
        g.setFont(new Font("Times New Roman", Font.ITALIC, 20));
        g.setColor(getRandColor(160, 200));
        for (int i = 0; i < 155; i++) {
            int x = random.nextInt(width);
            int y = random.nextInt(height);
            int xl = random.nextInt(12);
            int yl = random.nextInt(12);
            g.drawLine(x, y, x + xl, y + yl);
        }

        //生成随机数 并绘制
        StringBuilder sRand = new StringBuilder();
        for (int i = 0; i < length; i++) {
            String rand = String.valueOf(random.nextInt(10));
            sRand.append(rand);
            g.setColor(new Color(20 + random.nextInt(110), 20 + random.nextInt(110), 20 + random.nextInt(110)));
            g.drawString(rand, 13 * i + 6, 16);
        }
        g.dispose();
        return new ImageCode(image, sRand.toString());
    }

    /**
     * 获取随机演示
     *
     * @param fc
     * @param bc
     * @return
     */
    private Color getRandColor(int fc, int bc) {
        Random random = new Random();
        if (fc > 255) {
            fc = 255;
        }
        if (bc > 255) {
            bc = 255;
        }
        int r = fc + random.nextInt(bc - fc);
        int g = fc + random.nextInt(bc - fc);
        int b = fc + random.nextInt(bc - fc);
        return new Color(r, g, b);
    }

}

/**
 * 验证码过滤器 OncePerRequestFilter 一次请求只会经过一次过滤器
 */
@Component
public class ValidateCodeFilter extends OncePerRequestFilter {

    @Autowired
    MyAuthenticationService myAuthenticationService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        // 判断是否是登录请求
        if (request.getRequestURI().equals("/login") &&
            request.getMethod().equalsIgnoreCase("post")) {
            String imageCode = request.getParameter("imageCode");
            System.out.println(imageCode);
            // 具体的验证流程....
            try {
                validate(request, imageCode);
            } catch (ValidateCodeException e) {
                myAuthenticationService.onAuthenticationFailure(request, response, e);
                return;
            }

        }

        // 如果不是登录请求直接放行
        filterChain.doFilter(request, response);
    }

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    private void validate(HttpServletRequest request, String imageCode) {
        //从redis中获取验证码
        String redisKey = ValidateCodeController.REDIS_KEY_IMAGE_CODE + "-" + request.getRemoteAddr();
        String redisImageCode = stringRedisTemplate.boundValueOps(redisKey).get();
        // 验证码的判断
        if (!StringUtils.hasText(imageCode)) {
            throw new ValidateCodeException("验证码的值不能为空!");
        }
        if (redisImageCode == null) {
            throw new ValidateCodeException("验证码已过期!");
        }
        if (!redisImageCode.equals(imageCode)) {
            throw new ValidateCodeException("验证码不正确!");
        }
        //从redis中删除验证码
        stringRedisTemplate.delete(redisKey);
    }

}

// 加入用户名密码验证过滤器的前面
http.addFilterBefore(validateCodeFilter, UsernamePasswordAuthenticationFilter.class);

server:
  port: 8080
  servlet:
    session:
      timeout: 600

http.sessionManagement()// 设置session管理
            .invalidSessionUrl("/toLoginPage")// session失效之后跳转的路径
            .maximumSessions(1)// session最大会话数量 1,同一时间只能有一个用户可以登录  互踢
            .maxSessionsPreventsLogin(true)//如果达到最大会话数量,就阻止登录
            .expiredUrl("/toLoginPage");// session过期之后跳转的路径

<!-- 基于redis实现session共享 -->
<dependency>
  <groupId>org.springframework.session</groupId>
  <artifactId>spring-session-data-redis</artifactId>
</dependency>

spring:
  session:
    store-type: redis

/**
 * 跨域配置信息源
 */
public CorsConfigurationSource corsConfigurationSource() {
  CorsConfiguration corsConfiguration = new CorsConfiguration();
  //允许跨域的站点
  corsConfiguration.addAllowedOrigin("*");
  //允许跨域的http方法
  corsConfiguration.addAllowedMethod("*");
  // 允许跨域的请求头
  corsConfiguration.addAllowedHeader("*");
  // 允许带凭证
  corsConfiguration.setAllowCredentials(true);

  UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
  // 对所有url都生效
  urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);

  return urlBasedCorsConfigurationSource;
}

// 开启跨域支持
http.cors().configurationSource(corsConfigurationSource());