@Controller
@RequestMapping(path = "sse")
public class SseController {

    private final static Map<String, SseEmitter> sseCache = new ConcurrentHashMap<>();


    @GetMapping(path = "subscribe", produces = {MediaType.TEXT_EVENT_STREAM_VALUE})
    public SseEmitter create(@RequestParam(name = "token", required = true)String token) throws IOException {

        Claims claims = JwtUtil.parse(token);
        String csId;
        if (claims == null) {
            return  null;
        }else{
             csId = claims.getSubject();
        }
        // 超时时间设置为5分钟，用于演示客户端自动重连
        SseEmitter sseEmitter = new SseEmitter(5_60_000L);
        // 设置前端的重试时间为1s
        // send(): 发送数据，如果传入的是一个非SseEventBuilder对象，那么传递参数会被封装到 data 中
        //sseEmitter.send(SseEmitter.event().reconnectTime(1000).data("连接成功"));
        sseCache.put(csId, sseEmitter);
        System.out.println("add " + csId);
       // System.out.println("现在有"+sseCache.size()+"客服");
        //sseEmitter.send("你好", MediaType.APPLICATION_JSON);
       // SseEmitter.SseEventBuilder data = SseEmitter.event().name("finish").id(csId).data("你好"+csId);
       // sseEmitter.send(data);
        // onTimeout(): 超时回调触发
        sseEmitter.onTimeout(() -> {
            System.out.println(csId + "超时");
            sseCache.remove(csId);
        });
        // onCompletion(): 结束之后的回调触发
        sseEmitter.onCompletion(() -> System.out.println("完成！"));
        return sseEmitter;
    }


    @ResponseBody
    @GetMapping(path = "push")
    public String push( String content) throws IOException {

        Set<Map.Entry<String,SseEmitter>> entries=sseCache.entrySet();
        System.out.println("需要push"+sseCache.size());
        for (Map.Entry entry:entries){
            SseEmitter sseEmitter = (SseEmitter) entry.getValue();
            if (sseEmitter != null) {
                sseEmitter.send(content);
            } 
        }

        return "over";
    }

    @ResponseBody
    @GetMapping(path = "over")
    public String over(String token) {
        Claims claims = JwtUtil.parse(token);
        String csId;
        if (claims == null) {
            return  "异常";
        }else{
            csId = claims.getSubject();
        }
        SseEmitter sseEmitter = sseCache.get(csId);
        if (sseEmitter != null) {
            // complete(): 表示执行完毕，会断开连接
            sseEmitter.complete();
            sseCache.remove(csId);
            System.out.println("清除"+csId);
        }
        return "over";
    }
}

@FeignClient(name="cs-service")
public interface CsServiceFeignClient {
    @GetMapping("/sse/push")
    String push(@RequestParam String content) throws IOException;
}

new Thread(() -> {        
    try{
        Thread.sleep(5000);
        String res = csServiceFeignClient.push("yctf");
    }catch (InterruptedException e){
        e.printStackTrace();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }    
}).start();

public final class JwtUtil {
   
   //自定义secretKey
    private final static String secretKey = "xxxxxxxxxxxx";
    
    private final static Duration expiration = Duration.ofHours(2);

     
    public static String generate(String userName) {
        // 过期时间
        Date expiryDate = new Date(System.currentTimeMillis() + expiration.toMillis());

        return Jwts.builder()
                .setSubject(userName) // 将userName放进JWT
                .setIssuedAt(new Date()) // 设置JWT签发时间
                .setExpiration(expiryDate)  // 设置过期时间
                .signWith(SignatureAlgorithm.HS512, secretKey) // 设置加密算法和秘钥
                .compact();
    } 
    public static Claims parse(String token) { 

        if (StringUtils.isEmpty(token)) {
            return null;
        }
 
        Claims claims = null; 
        try {
            claims = Jwts.parser()
                    .setSigningKey(secretKey) // 设置秘钥
                    .parseClaimsJws(token)
                    .getBody();
        } catch (JwtException e) { 
            System.err.println("解析失败！");
        }
        return claims;
    }
}

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private SecureServiceImpl secureService;

    @Autowired
    private LoginFilter loginFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 关闭csrf和frameOptions，如果不关闭会影响前端请求接口（这里不展开细讲了，感兴趣的自行了解）
        http.csrf().disable();
        http.headers().frameOptions().disable();
        // 开启跨域以便前端调用接口
        http.cors();
        http.addFilterBefore(loginFilter, UsernamePasswordAuthenticationFilter.class);

        //禁用session
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);


        // 这是配置的关键，决定哪些接口开启防护，哪些接口绕过防护
        http.authorizeRequests()
                // 注意这里，是允许前端跨域联调的一个必要配置
                .requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
                // 指定某些接口不需要通过验证即可访问。登陆、注册接口肯定是不需要认证的
                .antMatchers("/secure/login", "/secure/register").permitAll()
                // 这里意思是其它所有接口需要认证才能访问
                .anyRequest().authenticated()
                // 指定认证错误处理器
                 .and().exceptionHandling().authenticationEntryPoint(new MyEntryPoint());
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 指定UserDetailService和加密器
        auth.userDetailsService( secureService).passwordEncoder(passwordEncoder());
    }

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


    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

public class UserDetail extends User { 
    /**
     * 用户实体对象，要调取用户信息时直接获取这个实体对象
     */
    private Client client; 
    
    public UserDetail(Client client, Collection<? extends GrantedAuthority> authorities) {
        // 必须调用父类的构造方法，以初始化用户名、密码、权限
        super(client.getName(), client.getPassword(), authorities);
        this.client = client;
    }
} 

//在SecuriConfig中导入
 public class MyEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = null;
        try {
            out = response.getWriter();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
        // 直接提示前端认证错误
        out.write("认证错误");
        out.flush();
        out.close();
    }
}

 //controller
@RestController
@RequestMapping("secure")
public class SecureController { 
    @Autowired
    private SecureService secureService; 
    @PostMapping("/login")
    public ResultVo login(String name,String password){  
        return secureService.login(name,password);
    }  
    @Autowired
    private PasswordEncoder passwordEncoder; 
    @PostMapping("/register")
    public ResultVo register(String name ,String password) {
        Client client = new Client();
        // 调用加密器将前端传递过来的密码进行加密
        client.setName(name);
        client.setPassword((passwordEncoder.encode(password)));
        // 将用户实体对象添加到数据库 
        return secureService.register(client);
    } 
}
//service 必须  implement UserDetailsService ，重写loadUserByUsername
@Service
public class SecureServiceImpl implements SecureService  , UserDetailsService { 

    @Autowired
    private SecureMapper secureMapper; 
    @Autowired
    private PasswordEncoder passwordEncoder; 

    @Override
    public ResultVo login(String name, String password) {
        //登录校验 
        QueryWrapper<Client> queryWrapper = new QueryWrapper<Client>();
        queryWrapper.eq("name",name); 
        Client client = secureMapper.selectOne(queryWrapper); 
        if (client == null  ||  !passwordEncoder.matches(password, client.getPassword()) ){
            return ResultVo.fail("账号密码错误");
        } 
        //jwt生成token 
        ClientVo csvo = new ClientVo(); 
        csvo.setId(client.getId());
        csvo.setName(client.getName());
        csvo.setToken(JwtUtil.generate(client.getId().toString())); 
        return ResultVo.success(csvo);
    }

    @Override
    public ResultVo register(Client client) {
        // 从数据库中查询出用户实体对象
        QueryWrapper<Client> queryWrapper = new QueryWrapper<Client>();
        queryWrapper.eq("name",client.getName());

        Client client1 = secureMapper.selectOne(queryWrapper); 
        if (client1 != null) {
            return ResultVo.fail("已存在此客户");
        } 
        Date now = new Date(); 
        client.setCreateTime(now);
        client.setUpdateTime(now); 
        return ResultVo.success(secureMapper.insert(client));
    }

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {

        System.out.println("exe loaduserbyusername");

        // 从数据库中查询出用户实体对象
        QueryWrapper<Client> queryWrapper = new QueryWrapper<Client>();
        queryWrapper.eq("id",Integer.parseInt(s)); 
        Client client = secureMapper.selectOne(queryWrapper);
        // 若没查询到一定要抛出该异常，这样才能被Spring Security的错误处理器处理
        if (client == null) {
            throw new UsernameNotFoundException("没有找到该用户");
        }  
        //增加一个权限
        Set<GrantedAuthority> dbAuthsSet = new HashSet<>(); 
        dbAuthsSet.add(new SimpleGrantedAuthority("ROLE_client")); 
        return new UserDetail(client,dbAuthsSet);
    } 
}

@RestController
@RequestMapping("/client")
public class ClientController {  
    @Autowired
    private ClientService clientService; 

    @Secured("ROLE_client")
    @PostMapping("/uploadAvatar")
    public ResultVo uploadAvatar(MultipartFile file ,@RequestHeader("Authorization") String token)  {   
        Claims claims = JwtUtil.parse(token);
        if (claims != null) { 
            String clientid = claims.getSubject(); 
            return   clientService.uploadAvatar(file,Integer.parseInt(clientid)); 
        }else{
            return ResultVo.fail("token错误");
        } 
    }

    @Secured("ROLE_client")
    @GetMapping("/avatar")
    public ResultVo getAvatar(@RequestHeader("Authorization") String token)  {  
        Claims claims = JwtUtil.parse(token);
        if (claims != null) { 
            String clientid = claims.getSubject(); 
            return   clientService.getAvatar(Integer.parseInt(clientid)); 
        }else{
            return ResultVo.fail("token错误");
        } 
    }  
}

@Component
public class LoginFilter extends OncePerRequestFilter {
 
    @Autowired
    private SecureServiceImpl secureService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        // 从请求头中获取token字符串并解析 
        Claims claims = JwtUtil.parse(request.getHeader("Authorization"));
        if (claims != null) {
            // 从jwt中提取出之前存储好的用户名
            String clientid = claims.getSubject();
            // 查询出用户对象
            UserDetails user = secureService.loadUserByUsername(clientid);
            //user 中携带角色信息（ROLE）
            Authentication authentication = new UsernamePasswordAuthenticationToken(user,
                    user.getPassword(),
                    user.getAuthorities());
            // 将认证对象放到上下文中
            SecurityContextHolder.getContext().setAuthentication(authentication); 
        }
        chain.doFilter(request, response); 
    }
}

ftp:
  hostname: 192.168.xx
  port: 21
  encoding: utf-8
  username: ftpuser
  password: xx
  dir: /home/ftpuser/store
  accessUri: http://192.168.xx:8888/


@Value("${ftp.hostname}")
private String hostname;

@Value("${ftp.port}")
private Integer port;

@Value("${ftp.username}")
private String username;

@Value("${ftp.password}")
private String password;

@Value("${ftp.encoding}")
private String encoding;

@Value("${ftp.dir}")
private String dir;



@Value("${ftp.accessUri}")
private String accessUri;


@PostMapping("/singleImageUpload")
public ResultVo singleImageUpload(MultipartFile file){ 
    return  ResultVo.success(singleFile(file));
}



private String singleFile(MultipartFile file)   {
    FTPClient ftpClient = new FTPClient();
    ftpClient.setControlEncoding(encoding);
    String fileName;
    try { 

        ftpClient.connect(hostname,port);
        ftpClient.login(username,password);
        ftpClient.enterLocalPassiveMode();
        int replycode = ftpClient.getReplyCode();
        if (!FTPReply.isPositiveCompletion(replycode)) {
            System.out.println(" connect failed. . .ftp服务器:" + hostname + ":" + port);
        }

        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        boolean boo = ftpClient.changeWorkingDirectory(dir);
        if(!boo) {
            System.out.println("进入文件夹失败");
        }

        fileName = UUID.randomUUID().toString() + file.getOriginalFilename().substring(
                file.getOriginalFilename().lastIndexOf(".")); 

        ftpClient.storeFile(fileName,file.getInputStream()); 
        ftpClient.logout();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return accessUri +  fileName; 
}

//主要方法   String re = doPostFormData(file,id);
@Service
public class ClientServiceImpl implements ClientService {  
    @Autowired
    private ClientMapper clientMapper;
    @Override
    public ResultVo uploadAvatar(MultipartFile file,  Integer id)   { 
        if (null == file && !file.isEmpty()) {  return ResultVo.fail("文件为空");  }
        if (null == id  ) {  return ResultVo.fail("id为空");  }
        String re = doPostFormData(file,id);
        if(re.equals("异常")){  return ResultVo.fail(re);  } 
        return ResultVo.success(re);
    }
}

OkHttpClient发送http请求，获取结果并导入数据库
public   String doPostFormData( MultipartFile file ,Integer id) { 
    try {
        OkHttpClient client = new OkHttpClient().newBuilder()
                .build();
        MediaType mediaType = MediaType.parse("multipart/form-data; boundary=--------------------------500812903788481473868931");
        String newFileName = UUID.randomUUID().toString()+file.getOriginalFilename();
        File tempfile =  multipartFileToFile(file,newFileName);

        RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
                .addFormDataPart("smfile", newFileName,
                        RequestBody.create(MediaType.parse("application/octet-stream"),
                                tempfile  ))
                .build();
        Request request = new Request.Builder()
                .url("https://smms.app/api/v2/upload")
                .method("POST", body)
                .addHeader("Authorization", "ZvaUPBNxxxxxxxxxxxxx4soUj7zUNb")
                .addHeader("User-Agent", "Apifox/1.0.0 (https://apifox.com)")
                .addHeader("Accept", "*/*")
                .addHeader("Host", "smms.app")
                .addHeader("Connection", "keep-alive")
                .addHeader("Content-Type", "multipart/form-data; boundary=--------------------------500812903788481473868931")
                .addHeader("Cookie", "PHPSESSID=5babcaa3-e606-bf37-812b-5e8b880a0cad; smms=rIuamMGvf7qF2K8NHiLOsPQSodVzb0Y9")
                .build();
        Response  response = client.newCall(request).execute();
        String res = response.body().string(); 
        tempfile.delete(); 
        ObjectMapper mapper =new ObjectMapper();
        JsonNode node = mapper.readTree(res);// 这里的JsonNode和XML里面的Node很像  
        if( node.get("success").toString().equals("true") ){
            node = node.get("data");
            String imageurl = node.get("url").toString();
            String imagedelete = node.get("delete").toString();
            
            //导入数据库
            imageurl = imageurl.trim().replace("\"", "");
            imagedelete = imagedelete.trim().replace("\"", "");  
            UpdateWrapper updateWrapper = new UpdateWrapper();
            updateWrapper.eq("id", id);
            updateWrapper.set("image_url",imageurl);
            updateWrapper.set("image_delete",imagedelete); 
            clientMapper.update(null, updateWrapper); 
            return  imageurl; 
        }else if(node.get("message").toString().contains("Image upload repeated limit")){
            System.out.println("已存在");
            String imageurl = node.get("images").toString();
            imageurl = imageurl.trim().replace("\"", ""); 
            UpdateWrapper updateWrapper = new UpdateWrapper();
            updateWrapper.eq("id", id);
            updateWrapper.set("image_url",imageurl); 
            clientMapper.update(null, updateWrapper); 
            return imageurl;
        }else{ 
            return "异常";
        } 
    } catch (IOException e) {
        throw new RuntimeException(e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    } 
} 

@Autowired
private RocketMQTemplate rocketMQTemplate;
@GetMapping("/mq")
public ResultVo mq(){
    List<Integer> x = new ArrayList<>();
    x.add(1);x.add(2);
    Group a = new Group(3,"awd",x);
    rocketMQTemplate.convertAndSend("gg",a); 
    return ResultVo.DEFAULT_SUCCESS;
} 

//启动类注解
@EnableBinding(Source.class)

//service
@Autowired
private Source source;

@GetMapping("/mail")
public ResultVo mail(){
    source.output().send(MessageBuilder.withPayload("group mail aaaa").build());
    return ResultVo.DEFAULT_SUCCESS;
}
//消费在邮件服务中使用

//启动类注解 rocketmq 消费
@EnableBinding(Sink.class)


@Autowired
private JavaMailSender mailSender; 

@Value("${spring.mail.username}")
private String from;  

//消费在邮件服务中使用
@StreamListener(Sink.INPUT)
public void sendmail(String message){
    System.err.println(message);
    sendSimpleMail("xx@qq.com", "这是一封简单邮件", message+"这是一封普通的SpringBoot测试邮件");
}
/**
 * 发送文本邮件
 *
 * @param to      收件人地址
 * @param subject 邮件主题
 * @param content 邮件内容
 * @param cc      抄送地址
 */
@Override
public void sendSimpleMail(String to, String subject, String content, String... cc) {
    SimpleMailMessage message = new SimpleMailMessage();
    message.setFrom(from);
    message.setTo(to);
    message.setSubject(subject);
    message.setText(content);
    if (ArrayUtil.isNotEmpty(cc)) {
        message.setCc(cc);
    }
    mailSender.send(message);
}