Java 常用设计模式与 WebSocket 集成实践

3. 客户端

ApiDemo.java

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("后续执行");
            }
        });
    }
}

2. 工厂 + 策略设计模式

1. PayChannelEnum.java 策略标识枚举

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;
    }
}

2. 超类型

PayHandler.java 策略能力接口

package com.sunxiansheng.designPattern.factoryandstragy;

/**
 * Description: 支付策略的能力接口
 */
public interface PayHandler {
    /**
     * 标识自己的类型的能力
     *
     * @return
     */
    PayChannelEnum getChannel();

    /**
     * 解决支付的能力
     */
    void dealPay();
}

3. 具体实现

BankPayHandler.java 银行支付策略

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("银行支付策略");
    }
}

WxPayHandler.java 微信支付策略

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("微信支付策略");
    }
}

ZfbPayHandler.java 支付宝支付策略

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("支付宝支付策略");
    }
}

4. 支付策略工厂

PayFactory.java

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);
        }
    }
}

5. 客户端

ServiceHandler.java 业务层，根据 code 可以直接执行对应策略

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();
    }
}

TestController.java 测试的 controller

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());
        }
    }
}

集成 websocket

1. 环境搭建

1. 创建新模块 sun-common-websocket

pom.xml

<?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>

sun-common 统一管理子模块

删除 sun-frame 对 websocket 模块的管理

2. 配置依赖

sun-dependencies

<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>

sun-common-websocket

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

2. 基础应用

1. 目录结构

2. WebSocketConfig.java（固定配置）

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();
    }
}

3. WebSocketServerConfig.java

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));
        }
    }
}

3. sun-demo 使用 websocket

1. 引入依赖

<!-- 引入 sun-common-websocket -->
<dependency>
    <groupId>com.sunxiansheng</groupId>
    <artifactId>sun-common-websocket</artifactId>
    <version>${sun-common-version}</version>
</dependency>

2. SysWebSocket.java

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);
            }
        }
    }
}