JavaPayjava
Java 常用设计模式与 WebSocket 集成实践
在 Java Spring Boot 项目中应用模板设计模式和工厂策略设计模式的实现方法，包括 API 执行流程控制及多支付渠道（银行、微信、支付宝）的处理。同时详细讲解了 WebSocket 的集成步骤，涵盖环境搭建、依赖配置、鉴权机制以及客户端连接管理与消息收发功能。
在 Java Spring Boot 项目中应用模板设计模式和工厂策略设计模式的实现方法，包括 API 执行流程控制及多支付渠道（银行、微信、支付宝）的处理。同时详细讲解了 WebSocket 的集成步骤，涵盖环境搭建、依赖配置、鉴权机制以及客户端连接管理与消息收发功能。
package com.sunxiansheng.designPattern.template;
/**
* Description: 行为能力接口
*/
public interface Action {
/**
* 参数校验
*/
void validate();
/**
* 执行
*/
void execute();
/**
* 后续
*/
void after();
}
package com.sunxiansheng.designPattern.template;
import com.sunxiansheng.response.Result;
/**
* Description: api 模板
*/
public class ApiTemplate {
/**
* 执行方法聚合 Action 的不同对象逻辑，从而实现模板的动态变化
*
* @param result
* @param action
*/
public void execute(Result result, final Action action) {
try {
action.validate();
action.execute();
action.after();
result.setSuccess(true);
result.setCode(200);
} catch (Exception e) {
result.setSuccess(false);
result.setCode(500);
}
}
}
package com.sunxiansheng.designPattern.template;
import com.sunxiansheng.response.Result;
/**
* Description:
*/
public class ApiDemo {
public static void main(String[] args) {
ApiTemplate apiTemplate = new ApiTemplate();
Result result = Result.ok();
// 这个模板，根据传入的不同行为，就会有不同的体现
apiTemplate.execute(result, new Action() {
@Override
public void validate() {
System.out.println("开始校验");
}
@Override
public void execute() {
System.out.println("执行");
}
@Override
public void after() {
System.out.println("后续执行");
}
});
}
}
package com.sunxiansheng.designPattern.factoryandstragy;
import lombok.Getter;
/**
* Description: 支付策略的类型枚举
*/
@Getter
public enum PayChannelEnum {
ZFB_PAY(0, "支付宝支付"),
WX_PAY(1, "微信支付"),
BANK_PAY(2, "银行支付");
private int code;
private String desc;
PayChannelEnum(int code, String desc) {
this.code = code;
this.desc = desc;
}
/**
* 根据 code 来获取枚举
*
* @param code
* @return
*/
public static PayChannelEnum getByCode(int code) {
for (PayChannelEnum payChannelEnum : PayChannelEnum.values()) {
if (payChannelEnum.code == code) {
return payChannelEnum;
}
}
return null;
}
}
package com.sunxiansheng.designPattern.factoryandstragy;
/**
* Description: 支付策略的能力接口
*/
public interface PayHandler {
/**
* 标识自己的类型的能力
*
* @return
*/
PayChannelEnum getChannel();
/**
* 解决支付的能力
*/
void dealPay();
}
package com.sunxiansheng.designPattern.factoryandstragy.handler;
import com.sunxiansheng.designPattern.factoryandstragy.PayChannelEnum;
import com.sunxiansheng.designPattern.factoryandstragy.PayHandler;
import org.springframework.stereotype.Component;
/**
* Description: 银行支付策略
*/
@Component
public class BankPayHandler implements PayHandler {
/**
* 标识自己的类型
*
* @return
*/
@Override
public PayChannelEnum getChannel() {
return PayChannelEnum.BANK_PAY;
}
/**
* 银行支付策略
*/
@Override
public void dealPay() {
System.out.println("银行支付策略");
}
}
package com.sunxiansheng.designPattern.factoryandstragy.handler;
import com.sunxiansheng.designPattern.factoryandstragy.PayChannelEnum;
import com.sunxiansheng.designPattern.factoryandstragy.PayHandler;
import org.springframework.stereotype.Component;
/**
* Description: 微信支付策略
*/
@Component
public class WxPayHandler implements PayHandler {
/**
* 标识自己的类型
*
* @return
*/
@Override
public PayChannelEnum getChannel() {
return PayChannelEnum.WX_PAY;
}
@Override
public void dealPay() {
System.out.println("微信支付策略");
}
}
package com.sunxiansheng.designPattern.factoryandstragy.handler;
import com.sunxiansheng.designPattern.factoryandstragy.PayChannelEnum;
import com.sunxiansheng.designPattern.factoryandstragy.PayHandler;
import org.springframework.stereotype.Component;
/**
* Description: 支付宝支付策略
*/
@Component
public class ZfbPayHandler implements PayHandler {
/**
* 标识自己的类型
*
* @return
*/
@Override
public PayChannelEnum getChannel() {
return PayChannelEnum.ZFB_PAY;
}
@Override
public void dealPay() {
System.out.println("支付宝支付策略");
}
}
package com.sunxiansheng.designPattern.factoryandstragy;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Description: 获取策略对象的工厂
*/
@Component
public class PayFactory implements InitializingBean {
/**
* 所有的具体支付策略的对象逻辑会被注入到这里
*/
@Resource
private List<PayHandler> payHandlerList;
/**
* 存储策略标识和具体策略的 map
*/
private Map<PayChannelEnum, PayHandler> handlerMap = new HashMap<>();
/**
* 根据枚举的 code 来获取对应的策略
*
* @param code
* @return
*/
public PayHandler getHandlerByCode(int code) {
PayChannelEnum byCode = PayChannelEnum.getByCode(code);
return handlerMap.get(byCode);
}
/**
* 在 bean 初始化之后，这个方法会被调用
*
* @throws Exception
*/
@Override
public void afterPropertiesSet() throws Exception {
// 将所有的策略从 list 放到 map 中，直接通过枚举即可获得对应的策略
for (PayHandler payHandler : payHandlerList) {
handlerMap.put(payHandler.getChannel(), payHandler);
}
}
}
package com.sunxiansheng.designPattern.factoryandstragy;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* Description: 业务层
*/
@Service
public class ServiceHandler {
/**
* 依赖存放策略的策略工厂
*/
@Resource
private PayFactory payFactory;
public void dealPay(int code) {
PayHandler handlerByCode = payFactory.getHandlerByCode(code);
handlerByCode.dealPay();
}
}
package com.sunxiansheng.designPattern.factoryandstragy;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.annotation.Resource;
import java.util.Objects;
/**
* Description: 测试的 controller
*/
@Controller
public class PayTestController {
@Resource
private ServiceHandler serviceHandler;
@RequestMapping("/payTest/{payType}")
public void test(@PathVariable("payType") String payType) {
// 根据类型来判断使用哪个策略
if (Objects.equals(payType, "支付宝")) {
serviceHandler.dealPay(PayChannelEnum.ZFB_PAY.getCode());
} else if (Objects.equals(payType, "微信")) {
serviceHandler.dealPay(PayChannelEnum.WX_PAY.getCode());
} else if (Objects.equals(payType, "银行")) {
serviceHandler.dealPay(PayChannelEnum.BANK_PAY.getCode());
}
}
}
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- 继承父模块的版本和通用依赖 -->
<parent>
<groupId>com.sunxiansheng</groupId>
<artifactId>sun-common</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>sun-common-websocket</artifactId>
<!-- 子模块的 version，如果不写就默认跟父模块的一样 -->
<version>${children.version}</version>
</project>
<spring.websocket.version>2.4.2</spring.websocket.version>
<!-- websocket -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
<version>${spring.websocket.version}</version>
</dependency>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
</dependencies>
package com.sunxiansheng.websocket.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
/**
* Description: websocket 配置类（固定配置）
*/
@Configuration
public class WebSocketConfig {
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
package com.sunxiansheng.websocket.config;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.websocket.HandshakeResponse;
import javax.websocket.server.HandshakeRequest;
import javax.websocket.server.ServerEndpointConfig;
import java.util.List;
import java.util.Map;
/**
* Description: websocket 鉴权和获取信息
*/
@Component
public class WebSocketServerConfig extends ServerEndpointConfig.Configurator {
/**
* 鉴权
*
* @param originHeaderValue
* @return
*/
@Override
public boolean checkOrigin(String originHeaderValue) {
// 获取 request
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = servletRequestAttributes.getRequest();
// ============================== 校验逻辑 ==============================
// 校验失败就返回 false
// ============================== 校验逻辑 ==============================
return true;
}
/**
* 获取信息
*
* @param sec
* @param request
* @param response
*/
@Override
public void modifyHandshake(ServerEndpointConfig sec, HandshakeRequest request, HandshakeResponse response) {
Map<String, List<String>> parameterMap = request.getParameterMap();
// 这里从参数中获取名为 erp 的信息
List<String> erpList = parameterMap.get("erp");
// 如果不为空，就放到 UserProperties 中，使得 socket 可以读取
if (!CollectionUtils.isEmpty(erpList)) {
sec.getUserProperties().put("erp", erpList.get(0));
}
}
}
<!-- 引入 sun-common-websocket -->
<dependency>
<groupId>com.sunxiansheng</groupId>
<artifactId>sun-common-websocket</artifactId>
<version>${sun-common-version}</version>
</dependency>
package com.sunxiansheng.user.websocket;
import com.sunxiansheng.websocket.config.WebSocketServerConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
@Slf4j
// 设置 WebSocket 路径，配置创建的 WebSocketCheckConfig 鉴权配置类
@ServerEndpoint(value = "/sys/socket", configurator = WebSocketServerConfig.class)
@Component
public class SysWebSocket {
/**
* 记录当前在线连接数
*/
private static AtomicInteger onlineCount = new AtomicInteger(0);
/**
* 存放所有在线的客户端
*/
private static Map<String, SysWebSocket> clients = new ConcurrentHashMap<>();
/**
* 与某个客户端的连接会话，需要通过它来给客户端发送数据
*/
private Session session;
/**
* 当前会话的唯一标识 key
*/
private String erp = "";
/**
* 连接建立成功调用的方法
*/
@OnOpen
public void onOpen(Session session, EndpointConfig conf) throws IOException {
// 获取用户信息
try {
// 获取用户配置
Map<String, Object> userProperties = conf.getUserProperties();
// 从用户配置中获取 "erp" 的用户内容
String erp = (String) userProperties.get("erp");
this.erp = erp;
this.session = session;
// 如果在线的客户端中存在这个用户，则先关闭下线
if (clients.containsKey(this.erp)) {
clients.get(this.erp).session.close();
clients.remove(this.erp);
onlineCount.decrementAndGet();
}
// 将当前用户再连接上去
clients.put(this.erp, this);
onlineCount.incrementAndGet();
log.info("有新连接加入：{}，当前在线人数为：{}", erp, onlineCount.get());
sendMessage("连接成功", this.session);
} catch (Exception e) {
log.error("建立链接错误{}", e.getMessage(), e);
}
}
/**
* 连接关闭调用的方法
*/
@OnClose
public void onClose() {
try {
if (clients.containsKey(erp)) {
clients.get(erp).session.close();
clients.remove(erp);
onlineCount.decrementAndGet();
}
log.info("有一连接关闭：{}，当前在线人数为：{}", this.erp, onlineCount.get());
} catch (Exception e) {
log.error("连接关闭错误，错误原因{}", e.getMessage(), e);
}
}
/**
* 收到客户端消息后调用的方法
*/
@OnMessage
public void onMessage(String message, Session session) {
log.info("服务端收到客户端 [{}] 的消息:{}", this.erp, message);
// 模拟心跳机制：
// 前端可以通过 setInterval 定时任务每个 15 秒钟调用一次 reconnect 函数
// reconnect 会通过 socket.readyState 来判断这个 websocket 连接是否正常
// 如果不正常就会触发定时连接，每 15s 钟重试一次，直到连接成功
if (message.equals("ping")) {
this.sendMessage("pong", session);
}
}
@OnError
public void onError(Session session, Throwable error) {
log.error("Socket:{},发生错误，错误原因{}", erp, error.getMessage(), error);
try {
session.close();
} catch (Exception e) {
log.error("onError.Exception{}", e.getMessage(), e);
}
}
/**
* 指定发送消息
*/
public void sendMessage(String message, Session session) {
log.info("服务端给客户端 [{}] 发送消息：{}", this.erp, message);
try {
session.getBasicRemote().sendText(message);
} catch (IOException e) {
log.error("{}发送消息发生异常，异常原因{}", this.erp, message);
}
}
/**
* 群发消息
*/
public void sendMessage(String message) {
for (Map.Entry<String, SysWebSocket> sessionEntry : clients.entrySet()) {
String erp = sessionEntry.getKey();
SysWebSocket socket = sessionEntry.getValue();
Session session = socket.session;
log.info("服务端给客户端 [{}] 发送消息{}", erp, message);
try {
session.getBasicRemote().sendText(message);
} catch (IOException e) {
log.error("{}发送消息发生异常，异常原因{}", this.erp, message);
}
}
}
}
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online