Java Toolbox

Sunny__Guo

已于 2022-10-17 15:38:47 修改

阅读量899

点赞数

文章标签： java 开发语言

于 2022-10-17 15:07:21 首次发布

本文链接：https://blog.csdn.net/Sunny__Guo/article/details/127360513

版权

文章目录

前言
一、Sm4加密（可逆）
二、Md5加密（不可逆）
- 1、导入依赖
- 2、Md5加密类使用
三、Websocket服务
总结

前言

提示：本文是小白学习Springboot开发，在项目中需要使用的。如有帮助请”食用“：

本文是一个小白学习记录Java真实开发用到的工具箱，会记录一些Java开发者常用到的工具。例如：Sm4加密（可逆）、Md5加密（不可逆）、Websocket服务（后续遇到继续添加）

一、Sm4加密（可逆）

小知识：在真实项目开发过程中，开发软件需要和甲方的业务需求紧密结合，信息加密是其中常见的一种。
加密算法我们整体可以分为：可逆加密和不可逆加密，可逆加密又可以分为：对称加密和非对称加密。
（理论上只要条件允许（时间），没有密码是解不出来的）

可逆加密：进行需要加密数据加密后，可以进行反向解密出来。
不可逆加密：数据加密后无法反向将数据解密还原出来。

1、导入依赖

 <dependency>
         <groupId>cn.hutool</groupId>
         <artifactId>hutool-all</artifactId>
         <version>选合适的版本</version>
 </dependency>

2、Sm4加密类

代码如下：

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import java.nio.charset.StandardCharsets;
public class Sm4Utils {

    /**
     * 加密key
     */
    private static final String key = "加密key";

    private static SymmetricCrypto sm4 = SmUtil.sm4(key.getBytes(StandardCharsets.UTF_8));

    /**
     * 加密
     * @param text
     * @return
     */
    public static String sm4EncryptHex(String text) {
        if (StrUtil.isBlank(text)) {
            return null;
        }

        return sm4.encryptHex(text, CharsetUtil.CHARSET_UTF_8);
    }

    /**
     * 解密
     * @param text
     * @return
     */
    public static String sm4DecryptStr(String text) {
        if (StrUtil.isBlank(text)) {
            return null;
        }
        return sm4.decryptStr(text, CharsetUtil.CHARSET_UTF_8);
    }
}

3、Sm4加密类使用

// 加密静态方法
Sm4Utils.sm4EncryptHex();
// 解密静态方法
Sm4Utils.sm4DecryptStr();

代码如下（示例）：

 //	加密静态方法
String sm4EncryptHex = Sm4Utils.sm4EncryptHex("加密方法");
System.out.println("sm4EncryptHex:"+sm4EncryptHex);
//	解密静态方法
String sm4DecryptStr = Sm4Utils.sm4DecryptStr(sm4EncryptHex);
System.out.println("sm4DecryptStr:"+sm4DecryptStr);

结果：
在这里插入图片描述

二、Md5加密（不可逆）

1、导入依赖

cn.hutool.crypto.SecureUtil
这个包下有md5的加密方法，导入依赖后，直接使用md5的方法。

依赖如下：

<dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>选合适的版本</version>
</dependency>

2、Md5加密类使用

import cn.hutool.crypto.SecureUtil;

 // md5 加密方法
 String MD5 = "QAZ@1243";
 String md5 = SecureUtil.md5(MD5);
 System.out.println("md5加密："+md5);

结果：
在这里插入图片描述

三、Websocket服务

1、导入依赖

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

2、编写配置文件

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * WebSocketConfig
 * 创建 端点，必须有，不然链接不上
 */
@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

3、编写websocket工具类

import cn.hutool.core.util.ObjectUtil;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.log4j.Log4j2;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

@Log4j2
@Component
@ServerEndpoint(value = "/websocket/base/socket/{id}")
public class WebSocketServer {

    /**
     * concurrent包的线程安全Set，用来存放每个客户端对应的WebSocket对象。
     */
    private static CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<>();

    /**
     * 与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    @Getter
    @Setter
    private String id;

    @Getter
    @Setter
    private Session session;

    @Getter
    @Setter
    private Date startTime;

    private static Map<String, CopyOnWriteArraySet<WebSocketServer>> socketList = new HashMap<>();


    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(@PathParam("id") String id, Session session) {
        synchronized (this) {
            this.setSession(session);
            this.setId(id);
            this.setStartTime(new Date());
            webSocketSet.add(this);
            CopyOnWriteArraySet<WebSocketServer> list;
            if (ObjectUtil.isEmpty(socketList)) {
                socketList = new HashMap<>();
                list = new CopyOnWriteArraySet<>();

            } else {
                list = socketList.get(id);
                if (ObjectUtil.isEmpty(list)) {
                    list = new CopyOnWriteArraySet<>();
                }
            }
            list.add(this);
            socketList.put(id, list);
            log.info("webSocket连接成功，id:" + id + "sessionId:" + session.getId());
        }
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session) throws IOException {
        synchronized (this) {
            session.close();
            CopyOnWriteArraySet<WebSocketServer> list = removeConnection(session, id);
            socketList.put(id, list);
            log.info("webSocket连接已断开，id:" + id + "sessionId:" + session.getId());
        }
    }

    /**
     * 收到客户端消息后调用的方法
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("webSocket接收到消息，id:" + id + "sessionId:" + session.getId() + "内容：" + message);
        try {
            //TODO 接受消息后处理
        } catch (Exception e) {
            log.error("接受到ws消息解析失败:", e);
        }
    }

    /**
     * 发生错误
     *
     * @param session 链接
     * @param error   错误信息
     * @throws IOException 异常
     */
    @OnError
    public void onError(Session session, Throwable error) throws IOException {
        session.close();
        CopyOnWriteArraySet<WebSocketServer> list = removeConnection(session, id);
        socketList.put(id, list);
        log.error("webSocket发生错误:", error);
    }

    /**
     * <p>超时会话检查</p>
     */
    @Scheduled(fixedDelay = 180000)
    private void timeoutCheck() {
        synchronized (this) {
            for (WebSocketServer next : webSocketSet) {
                Session session = next.getSession();
                Date startTime = next.getStartTime();
                if (startTime != null) {
                    long time = startTime.getTime();
                    long l = System.currentTimeMillis();
                    long difference = l - time;
                    long timeOut = 30 * 60 * 1000L;
                    if (difference > timeOut) {
                        CopyOnWriteArraySet<WebSocketServer> list = removeConnection(session, next.getId());
                        socketList.put(next.getId(), list);
                        log.error("webSocket会话超时，id:" + id + "sessionId:" + session.getId());
                    }
                }
            }
        }
    }

    /**
     * 发消息
     *
     * @param session 链接
     * @param message 消息
     * @throws IOException 异常
     */
    private void sendMessage(Session session, String message) throws IOException {
        if (session.isOpen()) {
            session.getBasicRemote().sendText(message);
        }
    }

    /**
     * 发送消息
     *
     * @param message
     */
    public static void sendMsg(String message, String id) {
        Set<WebSocketServer> list = socketList.get(id);
        if (ObjectUtil.isNotEmpty(list)) {
            list.forEach(e -> {
                try {
                    e.sendMessage(e.getSession(), message);
                } catch (IOException ioException) {
                    log.error("webSocket发送消息失败，id:" + id + "sessionId:" + e.getSession().getId() + "原因：" + ioException.getMessage());
                }
            });
        }
    }


    /**
     * 发送消息
     *
     * @param message
     */
    public static void sendMsgV2(String message, String id) {
        Set<WebSocketServer> list = socketList.get(id);
        if (ObjectUtil.isNotEmpty(list)) {
            list.forEach(e -> {
                try {
                    e.sendMessage(e.getSession(), message);
                } catch (IOException ioException) {
                    log.error("webSocket发送消息失败，id:" + id + "sessionId:" + e.getSession().getId() + "原因：" + ioException.getMessage());
                }
            });
        }
    }

    /**
     * 发送消息
     *
     * @param message
     */
    public static void sendMsgV3(String message, String id) {
        Set<WebSocketServer> list = socketList.get(id);
        if (ObjectUtil.isNotEmpty(list)) {
            list.forEach(e -> {
                try {
                    e.sendMessage(e.getSession(), message);
                } catch (IOException ioException) {
                    log.error("webSocket发送消息失败，id:" + id + "sessionId:" + e.getSession().getId() + "原因：" + ioException.getMessage());
                }
            });
        }
    }

    /**
     * 给所有发送消息
     *
     * @param msg
     */
    public static void sendMsgAll(String msg) {
        Collection<CopyOnWriteArraySet<WebSocketServer>> copyOnWriteArraySets = socketList.values();
        for (CopyOnWriteArraySet<WebSocketServer> set : copyOnWriteArraySets) {
            if (ObjectUtil.isNotEmpty(set)) {
                for (WebSocketServer e : set) {
                    try {
                        e.sendMessage(e.getSession(), msg);
                    } catch (IOException ioException) {
                        log.error("webSocket发送消息失败，id:" + e.id + "sessionId:" + e.getSession().getId() + "原因：" + ioException.getMessage());
                    }
                }
            }
        }
    }

    /**
     * 删除连接
     *
     * @param session
     * @param id
     * @return
     */
    private CopyOnWriteArraySet<WebSocketServer> removeConnection(Session session, String id) {
        webSocketSet.remove(this);
        CopyOnWriteArraySet<WebSocketServer> list = socketList.get(id);
        if (ObjectUtil.isNotEmpty(list)) {
            list.removeIf(e -> session.getId().equals(e.getSession().getId()));
        }
        return list;
    }
}

4、websocket使用

 // JSon 存储
 JSONObject obj = new JSONObject();
 obj.put("ID",123123);
 obj.put("SN","sc23423432234");
 // Websocket 发送字符串(发给所有链接的用户)
 WebSocketServer.sendMsgAll(obj.toString());
 // Websocket 发送字符串(发给指定用户1)
 WebSocketServer.sendMsg(obj.toString(),"1");

客户端请求地址：http://服务端ip:端口/websocket/base/socket/{id}
结果：这里需要Websocket连接上看实际效果，后续自行测试。常用静态方法上述两个，其他需求，可参考工具类中相关方法。

总结

第一次写，有不足的地方看官见谅。希望大家给予指正。年轻就要加油，努力。不喜勿喷。【感谢】

Sunny__Guo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Java Toolbox

提示：本文是小白学习Springboot开发，在项目中需要使用的。本文是一个小白学习记录Java真实开发用到的工具箱，会记录一些Java开发者常用到的工具。例如：Sm4加密（可逆）、Md5加密（不可逆）、Websocket服务（后续遇到继续添加）第一次写，有不足的地方看官见谅。希望大家给予指正。年轻就要加油，努力。不喜勿喷。
复制链接

扫一扫