BY-Team
/
customer-service-websocket
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

初始化项目结构

Browse Source
master
bynt 3 months ago
commit 2aff309853
91 changed files with 4508 additions and 0 deletions
Show Stats Download Patch File Download Diff File

0
.gitignore vendored
Unescape Escape View File

373
pom.xml
Unescape Escape View File

@ -0,0 +1,373 @@
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.eco</groupId>
<artifactId>customer-service-websocket</artifactId>
<version>0.0.1</version>
<name>customer-service-websocket</name>
<description>customer-service-websocket</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.4.RELEASE</version>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/com.googlecode.protobuf-java-format/protobuf-java-format -->
<dependency>
<groupId>com.googlecode.protobuf-java-format</groupId>
<artifactId>protobuf-java-format</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba.nacos/nacos-client -->
<dependency>
<groupId>com.alibaba.nacos</groupId>
<artifactId>nacos-client</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<!-- 整合 javaweb -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-undertow</artifactId>
<exclusions>
<exclusion>
<groupId>io.undertow</groupId>
<artifactId>undertow-websockets-jsr</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- freemarker包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
<!-- 整合redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 整合netty -->
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.25.Final</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.16</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<!-- 表情转换 -->
<dependency>
<groupId>com.github.binarywang</groupId>
<artifactId>java-emoji-converter</artifactId>
<version>0.1.1</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/jaxen/jaxen -->
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.2.0</version>
</dependency>
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.2.2</version>
<classifier>jdk15</classifier>
</dependency>
<dependency>
<groupId>xom</groupId>
<artifactId>xom</artifactId>
<version>1.2.5</version>
</dependency>
<dependency>
<groupId>xom</groupId>
<artifactId>xom</artifactId>
<version>1.2.5</version>
<classifier>sources</classifier>
</dependency>
<dependency>
<groupId>ws.schild</groupId>
<artifactId>jave-all-deps</artifactId>
<version>3.1.1</version>
</dependency>
<dependency>
<groupId>com.jcraft</groupId>
<artifactId>jsch</artifactId>
<version>0.1.54</version>
</dependency>
<dependency>
<groupId>com.eco.common</groupId>
<artifactId>fission-base</artifactId>
<version>0.0.1</version>
<exclusions>
<exclusion>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-registry-nacos</artifactId>
</exclusion>
<exclusion>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
</exclusion>
<exclusion>
<artifactId>hutool-all</artifactId>
<groupId>cn.hutool</groupId>
</exclusion>
<exclusion>
<artifactId>mybatis-plus-boot-starter</artifactId>
<groupId>com.baomidou</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-registry-nacos</artifactId>
<version>2.7.4.1</version>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>2.7.3</version>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>2.5.5</version>
</dependency>
<dependency>
<groupId>com.eco.common</groupId>
<artifactId>common-job</artifactId>
<version>0.0.1</version>
<exclusions>
<exclusion>
<artifactId>hutool-all</artifactId>
<groupId>cn.hutool</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
<version>8.5.2</version>
</dependency>
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.2.2</version>
</dependency>
<dependency>
<groupId>com.eco</groupId>
<artifactId>common</artifactId>
<version>0.0.1</version>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.0.0.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<!--JDK版本-->
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<testFailureIgnore>true</testFailureIgnore>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<includeSystemScope>true</includeSystemScope>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
<delimiters>
<delimiter>@</delimiter>
<delimiter>${*}</delimiter>
</delimiters>
<useDefaultDelimiters>false</useDefaultDelimiters>
</configuration>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
</build>
<profiles>
<profile>
<id>local</id>
<properties>
<activatedProperties>local</activatedProperties>
<addr>172.18.0.228:8848</addr>
<namespace>d5123679-020d-46d6-8ac8-f17bdd08e8e2</namespace>
<logfile></logfile>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<profile>
<id>inner</id>
<properties>
<activatedProperties>inner</activatedProperties>
<addr>172.18.0.228:8848</addr>
<namespace>d5123679-020d-46d6-8ac8-f17bdd08e8e2</namespace>
<logfile></logfile>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<profile>
<id>prod</id>
<properties>
<activatedProperties>prod</activatedProperties>
<addr>192.168.1.2:8848</addr>
<namespace>8c3bab0f-c9b4-4f4d-a833-487f7c1977db</namespace>
<logfile>classpath:logback-client.xml</logfile>
</properties>
</profile>
<profile>
<id>prod_wss</id>
<properties>
<activatedProperties>prod_wss</activatedProperties>
<addr>192.168.1.2:8848</addr>
<namespace>8c3bab0f-c9b4-4f4d-a833-487f7c1977db</namespace>
<logfile>classpath:logback-client.xml</logfile>
</properties>
</profile>
</profiles>
</project>

15
src/main/java/com/eco/websocket/CustomerServiceWebsocketApplication.java
Unescape Escape View File

@ -0,0 +1,15 @@
package com.eco.websocket;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableDubbo
@SpringBootApplication
public class CustomerServiceWebsocketApplication {
public static void main(String[] args) {
SpringApplication.run(CustomerServiceWebsocketApplication.class, args);
}
}

183
src/main/java/com/eco/websocket/netty/NettyConnectionUtil.java
Unescape Escape View File

@ -0,0 +1,183 @@
package com.eco.websocket.netty;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.eco.common.rpc.CommunityCustomerInfoService;
import com.eco.common.rpc.NettyConnectionService;
import com.eco.websocket.netty.utils.MessageUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import static org.apache.dubbo.common.constants.CommonConstants.DUBBO_PROTOCOL;
@Slf4j
@Service
@org.apache.dubbo.config.annotation.Service(protocol = DUBBO_PROTOCOL, timeout = 10000)
public class NettyConnectionUtil implements NettyConnectionService {
/**
* key 为deviceid
* value 为channel 用于存贮通道
*/
public static Map<String, ChannelHandlerContext> deviceid_nettyChannel = new ConcurrentHashMap<>();
/**
* key userId 微信唯一id 或者 pc端账号名
* value ChannelHandlerContext
*/
public static Map<String, ChannelHandlerContext> userId_nettyChannel = new ConcurrentHashMap<>();
@Reference(check = false)
private CommunityCustomerInfoService communityCustomerInfoService;
/**
* 存储通道
*/
public synchronized void saveDeviceChannel(ChannelHandlerContext cx, String deviceid) {
ChannelHandlerContext cc = getNettyChannelByDeviceId(deviceid);
if (null != cc) {
deviceid_nettyChannel.remove(deviceid);
}
deviceid_nettyChannel.put(deviceid, cx);
}
/**
* 注册真实用户，客户端以imei为准、pc端以账号用户名为准
*/
public synchronized void registerUserid(String account, ChannelHandlerContext cx) {
log.info("register:当前netty通道连接数：{}，有效通道连接数：{}", deviceid_nettyChannel.size(), userId_nettyChannel.size());
ChannelHandlerContext chc = userId_nettyChannel.get(account);
if (null != chc) {
userId_nettyChannel.remove(account);
}
userId_nettyChannel.put(account, cx);
// 更新客服上线
communityCustomerInfoService.updateOnlineStatus(account, true);
}
/**
* 通过deviceid获取通道
*
* @return
*/
public static synchronized ChannelHandlerContext getNettyChannelByDeviceId(String deviceid) {
return deviceid_nettyChannel.get(deviceid);
}
/**
* 删除通道
*/
public synchronized void removeChannel(ChannelHandlerContext cx) {
// 清除设备通道
try {
String nettyId = getNettyId(cx);
if (!StringUtils.isEmpty(nettyId)) {
String deviceid = getDeviceIdByNettyId(nettyId);
if (null != deviceid && !"".equals(deviceid)) {
deviceid_nettyChannel.remove(deviceid);
}
// 清除微信通道
String userId = getUserIdByNettyId(nettyId);
if (!StringUtils.isEmpty(userId)) {
userId_nettyChannel.remove(userId);
}
// 更新客服下线
communityCustomerInfoService.updateOnlineStatus(userId, false);
}
} catch (Exception e) {
log.error("error --> ", e);;
}
}
/**
* 客户端退出时调用，清理数据
*/
public synchronized void exit(ChannelHandlerContext ctx) {
try {
log.info("exit:当前netty通道连接数：{}，有效通道连接数：{}", deviceid_nettyChannel.size(), userId_nettyChannel.size());
removeChannel(ctx);
ctx.close();
} catch (Exception e) {
log.error("error --> ", e);;
}
}
/**
* 通过userId获取nettyId
*/
public synchronized String getUserIdByNettyId(String nettyId) {
return getKey(userId_nettyChannel, nettyId);
}
/**
* 根据通道获取用户id
*
* @param cx 通道
* @return
*/
public synchronized String getUserIdByNettyId(ChannelHandlerContext cx) {
return getUserIdByNettyId(cx.channel().id().asShortText());
}
/**
* 通过nettyid获取deviceid
*/
public synchronized String getDeviceIdByNettyId(String nettyId) {
return getKey(deviceid_nettyChannel, nettyId);
}
public synchronized ChannelHandlerContext getClientChannelHandlerContextByUserId(String userId) {
if (userId == null) {
return null;
}
return userId_nettyChannel.get(userId);
}
@Override
public boolean containsKey(String userId) {
return userId_nettyChannel.containsKey(userId);
}
public synchronized String getNettyId(ChannelHandlerContext cx) {
return cx.channel().id().asShortText();
}
/**
* 根据map的value获取map的key
*/
private synchronized String getKey(Map<String, ChannelHandlerContext> map, String value) {
for (Map.Entry<String, ChannelHandlerContext> entry : map.entrySet()) {
if (StrUtil.equals(value, getNettyId(entry.getValue()))) {
return entry.getKey();
}
}
return null;
}
@Override
public void accountPush(String account, String enumMsgType, String refMsgId, JSONObject object) {
ChannelHandlerContext chxOther = getClientChannelHandlerContextByUserId(account);
if (null != chxOther) {
if (StringUtils.isNotEmpty(refMsgId)) {
MessageUtil.sendJsonStringMsg(chxOther, enumMsgType, getNettyId(chxOther), refMsgId, object);
} else {
MessageUtil.sendJsonStringMsg(chxOther, enumMsgType, getNettyId(chxOther), null, object);
}
}
}
}

83
src/main/java/com/eco/websocket/netty/WebSocketServer.java
Unescape Escape View File

@ -0,0 +1,83 @@
package com.eco.websocket.netty;
import com.eco.websocket.netty.handler.WebSocketJsonHandler;
import com.eco.websocket.utils.PropertyUtils;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
@Service
@Slf4j
public class WebSocketServer {
@Resource
private Environment env;
@Autowired
private WebSocketJsonHandler webSocketFrameHandler;
// 程序初始方法入口注解，提示spring这个程序先执行这里
@PostConstruct
public void nettyMain() {
new Thread(() -> {
// 1 创建线两个程组
// 一个是用于处理服务器端接收客户端连接的
// 一个是进行网络通信的（网络读写的）
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
// 2 创建辅助工具类，用于服务器通道的一系列配置
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup);
b.channel(NioServerSocketChannel.class);// 指定NIO的模式
// b.option(ChannelOption.SO_KEEPALIVE, true); // 保持连接
b.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//websocket协议本身是基于http协议的，所以这边也要使用http解编码器
pipeline.addLast(new HttpServerCodec());
//以块的方式来写的处理器
pipeline.addLast(new ChunkedWriteHandler());
//netty是基于分段请求的，HttpObjectAggregator的作用是将请求分段再聚合,参数是聚合字节的最大长度
pipeline.addLast(new HttpObjectAggregator(65536));
pipeline.addLast(new WebSocketServerProtocolHandler("/"));
pipeline.addLast(webSocketFrameHandler);
}
});
// 3、绑定端口 同步等待成功
Integer port = PropertyUtils.getNettyWebsocketPort(env);
ChannelFuture f = b.bind(port).sync();
log.info("netty启动成功。。。" + "websocket占用端口" + port);
// 4、等待服务端监听端口关闭
f.channel().closeFuture().sync();
} catch (Exception e) {
log.info("netty启动失败 -- > ", e);
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}).start();
}
}

57
src/main/java/com/eco/websocket/netty/async/AsyncTaskService.java
Unescape Escape View File

@ -0,0 +1,57 @@
package com.eco.websocket.netty.async;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.google.protobuf.Message;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
@Service
@EnableAsync
@Slf4j
public class AsyncTaskService {
/**
* 转发消息给手机客户端
*/
@Async
public void msgSend2Phone(ChannelHandlerContext ctx, String wechatId, TransportMessageOuterClass.EnumMsgType type, TransportMessageOuterClass.TransportMessage vo, Message req) throws Exception {
try {
log.info(LocalDateTime.now() + " msgSend2Phone 对应的线程名: " + Thread.currentThread().getName());
if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.TalkToFriendTask.getNumber()) {
// 客服发送消息给客户
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.TriggerConversationPushTask.getNumber()) {
// 会话列表
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.TriggerHistoryMsgPushTask.getNumber()) {
// 历史聊天记录
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.RequestTalkDetailTask.getNumber()) {
// 同步视频、图片、音频资源
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.ModifyFriendMemoTask.getNumber()) {
// 备注、电话
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.ContactLabelTask.getNumber()) {
// 打标签
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.TriggerFriendPushTask.getNumber()) {
// 通讯录
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.TriggerChatroomPushTask.getNumber()) {
// 群聊通讯录
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.TriggerMessageReadTask.getNumber()) {
// 消息已读
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.RequestChatRoomInfoTask.getNumber()) {
// 请求具体群聊的详细信息
} else if (type.getNumber() == TransportMessageOuterClass.EnumMsgType.RequestContactsInfoTask.getNumber()) {
// 获取联系人详细信息（不一定是好友，如群聊成员）
}
} catch (Throwable e) {
log.error("error --> ", e);;
}
}
}

16
src/main/java/com/eco/websocket/netty/common/Constant.java
Unescape Escape View File

@ -0,0 +1,16 @@
package com.eco.websocket.netty.common;
public class Constant {
public static final String ERROR_MSG_ILLEGALDEVICE = "非法设备";
public static final String ERROR_MSG_DECODFAIL = "服务器繁忙";
public static final String ERROR_MSG_VERIFYWAY = "认证方式不支持";
public static final String ERROR_MSG_LOGINFAIL = "账号密码错误";
public static final String ERROR_MSG_NOT_ACCOUNT = "账号不存在或账号密码错误";
public static final String ERROR_MSG_NOTONLINE = "对方不在线";
public static final String ERROR_MSG_PARAMERROR = "参数传入错误";
public static final String ERROR_MSG_LOGINNORIGHT = "登录账号无权限";
public static final String ERROR_MSG_ELSEWHERELOGINN = "账号已在别处登录";
public static final String ERROR_MSG_DATABASENOTBIND = "数据库未绑定";
}

33
src/main/java/com/eco/websocket/netty/common/listener/HttpEventListener.java
Unescape Escape View File

@ -0,0 +1,33 @@
package com.eco.websocket.netty.common.listener;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.context.WebServerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
/**
* @author qp
* @date 2023/5/31 12:03
*/
@Slf4j
@Component
public class HttpEventListener implements ApplicationListener<WebServerInitializedEvent> {
private volatile boolean isServerStarted = false;
public boolean isServerStarted() {
return isServerStarted;
}
@Override
public void onApplicationEvent(@NonNull WebServerInitializedEvent event) {
if (event.getWebServer() == null) {
return;
}
int port = event.getWebServer().getPort();
if (port > 0) {
log.info("http server started, port：{}", port);
isServerStarted = true;
}
}
}

62
src/main/java/com/eco/websocket/netty/decoder/SelfDecoder.java
Unescape Escape View File

@ -0,0 +1,62 @@
package com.eco.websocket.netty.decoder;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.google.protobuf.MessageLite;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import java.util.List;
public class SelfDecoder extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
while (in.readableBytes() > 4) { // 如果可读长度小于包头长度，退出。
in.markReaderIndex();
// 获取包头中的body长度
byte b3 = in.readByte();
byte b2 = in.readByte();
byte b1 = in.readByte();
byte b0 = in.readByte();
int length = (b0 & 0xff) | ((b1 << 8) & 0xff00) | ((b2 << 16) & 0xff0000) | ((b3 << 24) & 0xff000000);
// 如果可读长度小于body长度，恢复读指针，退出。
if (in.readableBytes() < length) {
in.resetReaderIndex();
return;
}
// 读取body
ByteBuf bodyByteBuf = in.readBytes(length);
byte[] array;
int offset;
int readableLen = bodyByteBuf.readableBytes();
if (bodyByteBuf.hasArray()) {
array = bodyByteBuf.array();
offset = bodyByteBuf.arrayOffset() + bodyByteBuf.readerIndex();
} else {
array = new byte[readableLen];
bodyByteBuf.getBytes(bodyByteBuf.readerIndex(), array, 0, readableLen);
offset = 0;
}
//反序列化
MessageLite result = decodeBody(array, offset, readableLen);
out.add(result);
bodyByteBuf.release();//待验证
}
}
public MessageLite decodeBody(byte[] array, int offset, int length) throws Exception {
return TransportMessageOuterClass.TransportMessage.getDefaultInstance().
getParserForType().parseFrom(array, offset, length);
}
}

32
src/main/java/com/eco/websocket/netty/decoder/SelfEncoder.java
Unescape Escape View File

@ -0,0 +1,32 @@
package com.eco.websocket.netty.decoder;
import com.google.protobuf.MessageLite;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
public class SelfEncoder extends MessageToByteEncoder<MessageLite> {
@Override
protected void encode(ChannelHandlerContext ctx, MessageLite msg, ByteBuf out) throws Exception {
byte[] body = msg.toByteArray();
byte[] header = encodeHeader(msg, body.length);
out.writeBytes(header);
out.writeBytes(body);
}
private byte[] encodeHeader(MessageLite msg, int value) {
byte[] src = new byte[4];
src[0] = (byte) ((value >> 24) & 0xFF);
src[1] = (byte) ((value >> 16) & 0xFF);
src[2] = (byte) ((value >> 8) & 0xFF);
src[3] = (byte) (value & 0xFF);
return src;
}
}

8
src/main/java/com/eco/websocket/netty/handler/JsonMessageHandler.java
Unescape Escape View File

@ -0,0 +1,8 @@
package com.eco.websocket.netty.handler;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import io.netty.channel.ChannelHandlerContext;
public interface JsonMessageHandler {
void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) throws Exception;
}

8
src/main/java/com/eco/websocket/netty/handler/MessageHandler.java
Unescape Escape View File

@ -0,0 +1,8 @@
package com.eco.websocket.netty.handler;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import io.netty.channel.ChannelHandlerContext;
public interface MessageHandler {
void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo);
}

63
src/main/java/com/eco/websocket/netty/handler/WebSocketJsonHandler.java
Unescape Escape View File

@ -0,0 +1,63 @@
package com.eco.websocket.netty.handler;
import com.eco.websocket.netty.processor.WebSocketMessageProcessor;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
@Sharable
@Slf4j
public class WebSocketJsonHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
@Autowired
private NettyConnectionUtil nettyConnectionUtil;
@Autowired
private WebSocketMessageProcessor messageProcessor;
/**
* 覆盖了 channelRead0() 事件处理方法。 每当从服务端读到客户端写入信息时， 其中如果你使用的是 Netty 5.x 版本时， 需要把
* channelRead0() 重命名为messageReceived()
*/
@Override
protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
String text = msg.text();
log.debug("收到消息：{}", text);
messageProcessor.handler(ctx, msg);
ctx.flush();
}
/**
* 每当从服务端收到新的客户端连接时
*/
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
// 打印出channel唯一值，asLongText方法是channel的id的全名
log.info("handlerAdded：" + ctx.channel().id().asLongText());
}
/**
* 每当从服务端收到客户端断开时
*/
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
log.info("handlerRemoved：" + ctx.channel().id().asLongText());
//NettyConnectionUtil.exit(ctx);
nettyConnectionUtil.exit(ctx);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
log.error("websocket exception exit{}", cause.toString());
//NettyConnectionUtil.exit(ctx);
nettyConnectionUtil.exit(ctx);
}
}

43
src/main/java/com/eco/websocket/netty/handler/websocket/AcceptFriendAddRequestTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,43 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.AcceptFriendAddRequestTask.AcceptFriendAddRequestTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class AcceptFriendAddRequestTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 接受微信好友请求
*/
@Async
@Override
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
AcceptFriendAddRequestTaskMessage.Builder bd = AcceptFriendAddRequestTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
AcceptFriendAddRequestTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.AcceptFriendAddRequestTask, vo, req);
}
catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/AccountLogoutNoticeWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class AccountLogoutNoticeWebsocketHandler implements JsonMessageHandler {
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* pc客户端退出通知
*/
@Override
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// AccountLogoutNoticeMessage.Builder bd = AccountLogoutNoticeMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// AccountLogoutNoticeMessage req = bd.build();
//3、告诉客户端消息已收到
MessageUtil.sendJsonMsg(ctx, TransportMessageOuterClass.EnumMsgType.DeviceExitNotice, vo.getAccessToken(), vo.getId(), null);
//关闭连接
nettyConnectionUtil.exit(ctx);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/AddFriendFromPhonebookTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.AddFriendFromPhonebookTask.AddFriendFromPhonebookTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class AddFriendFromPhonebookTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信通讯录加好友
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
AddFriendFromPhonebookTaskMessage.Builder bd = AddFriendFromPhonebookTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
AddFriendFromPhonebookTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.AddFriendFromPhonebookTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/AddFriendInChatRoomTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.AddFriendInChatRoomTask.AddFriendInChatRoomTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class AddFriendInChatRoomTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信群内加好友
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
AddFriendInChatRoomTaskMessage.Builder bd = AddFriendInChatRoomTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
AddFriendInChatRoomTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.AddFriendInChatRoomTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/AddFriendWithSceneTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.AddFriendWithSceneTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class AddFriendWithSceneTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信各场景加好友
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
AddFriendWithSceneTask.AddFriendWithSceneTaskMessage.Builder bd = AddFriendWithSceneTask.AddFriendWithSceneTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
AddFriendWithSceneTask.AddFriendWithSceneTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.AddFriendWithSceneTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/AddFriendsTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.AddFriendsTask.AddFriendsTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class AddFriendsTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信添加好友任务
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
AddFriendsTaskMessage.Builder bd = AddFriendsTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
AddFriendsTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.AddFriendsTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

29
src/main/java/com/eco/websocket/netty/handler/websocket/AgreeJoinChatRoomTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,29 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
@Slf4j
public class AgreeJoinChatRoomTaskWebsocketHandler implements JsonMessageHandler {
/**
* 同意微信加入群聊
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.info("同意微信加入群聊：{}", contentJsonStr);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

45
src/main/java/com/eco/websocket/netty/handler/websocket/ChatRoomActionTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,45 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.ChatRoomActionTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ChatRoomActionTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private ChatRoomActionTaskService chatRoomActionTaskService;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 微信群聊管理
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// ChatRoomActionTaskMessage.Builder bd = ChatRoomActionTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// ChatRoomActionTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
//将消息转发送给手机客户端
chatRoomActionTaskService.chatRoomActionTask(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/ChatRoomInviteApproveTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ChatRoomInviteApproveTask.ChatRoomInviteApproveTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ChatRoomInviteApproveTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信群主通过入群申请
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ChatRoomInviteApproveTaskMessage.Builder bd = ChatRoomInviteApproveTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ChatRoomInviteApproveTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ChatRoomInviteApproveTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

42
src/main/java/com/eco/websocket/netty/handler/websocket/CircleCommentDeleteTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,42 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.CircleCommentDeleteTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class CircleCommentDeleteTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信朋友圈评论删除
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
CircleCommentDeleteTask.CircleCommentDeleteTaskMessage.Builder bd = CircleCommentDeleteTask.CircleCommentDeleteTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
CircleCommentDeleteTask.CircleCommentDeleteTaskMessage req = bd.build();
// CircleCommentDeleteTaskMessage req =
// vo.getContent().unpack(CircleCommentDeleteTaskMessage.class);
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.CircleCommentDeleteTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

42
src/main/java/com/eco/websocket/netty/handler/websocket/CircleCommentReplyTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,42 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.CircleCommentReplyTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class CircleCommentReplyTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信朋友圈评论回复
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
CircleCommentReplyTask.CircleCommentReplyTaskMessage.Builder bd = CircleCommentReplyTask.CircleCommentReplyTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
CircleCommentReplyTask.CircleCommentReplyTaskMessage req = bd.build();
// CircleCommentReplyTaskMessage req = vo.getContent().unpack(CircleCommentReplyTaskMessage.class);
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.CircleCommentReplyTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/CircleLikeTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.CircleLikeTask.CircleLikeTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class CircleLikeTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信朋友圈点赞
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
CircleLikeTaskMessage.Builder bd = CircleLikeTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
CircleLikeTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.CircleLikeTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/CircleMsgClearTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.CircleMsgClearTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class CircleMsgClearTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 清除朋友圈消息
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
CircleMsgClearTask.CircleMsgClearTaskMessage.Builder bd = CircleMsgClearTask.CircleMsgClearTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
CircleMsgClearTask.CircleMsgClearTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.CircleMsgClearTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

38
src/main/java/com/eco/websocket/netty/handler/websocket/CircleMsgReadTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,38 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.CircleMsgReadTask.CircleMsgReadTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class CircleMsgReadTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 朋友圈消息已读
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
CircleMsgReadTaskMessage.Builder bd = CircleMsgReadTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
CircleMsgReadTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.CircleMsgReadTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/ClearAllChatMsgTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ClearAllChatMsgTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ClearAllChatMsgTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 清空微信聊天记录
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ClearAllChatMsgTask.ClearAllChatMsgTaskMessage.Builder bd = ClearAllChatMsgTask.ClearAllChatMsgTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ClearAllChatMsgTask.ClearAllChatMsgTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ClearAllChatMsgTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

60
src/main/java/com/eco/websocket/netty/handler/websocket/ClipBoardTalkToFriendTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,60 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.alibaba.fastjson.JSONObject;
import com.eco.common.base.dto.WeChatChatRoomDto;
import com.eco.common.rpc.helper.ClipBoardTalkToFriendTaskService;
import com.eco.common.rpc.helper.qw.QwClipBoardTalkToFriendTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* 剪切板信息发送
*
* @author qp
*/
@Service
@Slf4j
public class ClipBoardTalkToFriendTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private ClipBoardTalkToFriendTaskService clipBoardTalkToFriendTaskHelper;
@Reference(check = false)
private QwClipBoardTalkToFriendTaskService qwClipBoardTalkToFriendTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 给微信好友发消息
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 发送信息
JSONObject jsonObject = JSONObject.parseObject(contentJsonStr);
String weChatId = jsonObject.getString("WeChatId");
if (WeChatChatRoomDto.isEnterpriseId(weChatId)) {
qwClipBoardTalkToFriendTaskHelper.clipBoardTalkToFriendTask(contentJsonStr, account);
} else {
clipBoardTalkToFriendTaskHelper.clipBoardTalkToFriendTask(contentJsonStr, account);
}
} catch (Exception e) {
log.error("ClipBoardTalkToFriendTaskWebsocketHandler -> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/ContactLabelDeleteTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ContactLabelDeleteTask.ContactLabelDeleteTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ContactLabelDeleteTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 删除微信标签
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ContactLabelDeleteTaskMessage.Builder bd = ContactLabelDeleteTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ContactLabelDeleteTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ContactLabelDeleteTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

46
src/main/java/com/eco/websocket/netty/handler/websocket/ContactLabelTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,46 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.ContactLabelTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ContactLabelTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private ContactLabelTaskService contactLabelTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 设置联系人标签---pc端经过服务端转发给手机端
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// ContactLabelTaskMessage.Builder bd = ContactLabelTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// ContactLabelTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
//将消息转发送给手机客户端
contactLabelTaskHelper.ContactLabelTask(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/ContactSetLabelTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ContactSetLabelTask.ContactSetLabelTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ContactSetLabelTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 设置用户标签
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ContactSetLabelTaskMessage.Builder bd = ContactSetLabelTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ContactSetLabelTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ContactSetLabelTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/DeleteFriendTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.DeleteFriendTask.DeleteFriendTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class DeleteFriendTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 删除好友 ---pc端经过服务端转发给手机端
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
DeleteFriendTaskMessage.Builder bd = DeleteFriendTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
DeleteFriendTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.DeleteFriendTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/DeleteSNSNewsTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.DeleteSNSNewsTask.DeleteSNSNewsTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class DeleteSNSNewsTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 删除微信朋友圈
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
DeleteSNSNewsTaskMessage.Builder bd = DeleteSNSNewsTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
DeleteSNSNewsTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.DeleteSNSNewsTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

187
src/main/java/com/eco/websocket/netty/handler/websocket/DeviceAuthReqWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,187 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.DeviceAuthReq.DeviceAuthReqMessage;
import Jubo.JuLiao.IM.Wx.Proto.DeviceAuthRsp.DeviceAuthRspMessage;
import Jubo.JuLiao.IM.Wx.Proto.DeviceAuthRsp.DeviceAuthRspMessage.ExtraMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.eco.common.base.dto.SupportLoginDto;
import com.eco.common.base.entity.CommunityCustomerInfo;
import com.eco.common.redis.RedisCacheHelper;
import com.eco.common.rpc.CommunityCustomerInfoService;
import com.eco.common.rpc.CommunityDockingConfigService;
import com.eco.common.utils.CacheDataUtil;
import com.eco.fission.common.param.constants.Consts;
import com.eco.fission.common.rpc.RpcCustomerVisibleRangesService;
import com.eco.websocket.netty.NettyConnectionUtil;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.common.listener.HttpEventListener;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
import java.util.Base64;
import java.util.concurrent.TimeUnit;
@Service
@Slf4j
public class DeviceAuthReqWebsocketHandler implements JsonMessageHandler {
@Resource
private NettyConnectionUtil nettyConnectionUtil;
@Reference(check = false)
private CommunityCustomerInfoService communityCustomerInfoService;
@Reference(check = false)
private RpcCustomerVisibleRangesService rpcCustomerVisibleRangesService;
@Reference(check = false)
private CommunityDockingConfigService communityDockingConfigService;
@Resource
private RedisCacheHelper redisCacheHelper;
@Autowired
HttpEventListener httpEventListener;
/**
* 设备校验 如果校验通过存储token、账号建立连接
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
if (!httpEventListener.isServerStarted()) {
// http 服务还没启动
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InternalError, Constant.ERROR_MSG_DECODFAIL);
return;
}
DeviceAuthReqMessage.Builder bd = DeviceAuthReqMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
DeviceAuthReqMessage req = bd.build();
// 1、校验用户信息
byte[] byteArray = Base64.getDecoder().decode(req.getCredential());
String str = new String(byteArray);
CommunityCustomerInfo customerInfo = null;
if (req.getAuthType().equals(DeviceAuthReqMessage.EnumAuthType.Username)) {
// 用户名密码方式（此方式Credential应传入base64(user:pwd)）
if (StringUtils.isEmpty(str)) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_PARAMERROR);
return;
}
log.debug("账号密码登录：name=" + str);
String[] strs = str.split(":");
if (strs.length < 1 || strs[0] == null) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_PARAMERROR);
return;
}
// pc客服端
customerInfo = communityCustomerInfoService.getByAccount(strs[0]);
if (customerInfo == null || !StrUtil.equals(customerInfo.getPwd(), strs[1])) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_NOT_ACCOUNT);
return;
}
} else if (req.getAuthType().equals(DeviceAuthReqMessage.EnumAuthType.DeviceCode)) {
// 手机端openid的方式（此方式Credential应传入base64(openid)）
if (StringUtils.isEmpty(str)) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
return;
}
String key = CacheDataUtil.getKey("SUPPORT", str);
String value = redisCacheHelper.getValueCache(key);
SupportLoginDto supportLoginDto = JSON.parseObject(value, SupportLoginDto.class);
String openId = supportLoginDto.getOpenId();
log.debug("openid登录：openid=" + openId);
if (StrUtil.equalsIgnoreCase(openId, "null")) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_PARAMERROR);
return;
}
customerInfo = communityCustomerInfoService.getByOpenid(str);
} else {
// 暂不支持的方式
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.NoRight, Constant.ERROR_MSG_VERIFYWAY);
return;
}
if (customerInfo == null) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.NoRight, Constant.ERROR_MSG_NOT_ACCOUNT);
return;
}
// 账号状态正常的时候
if (!customerInfo.getIsEnable()) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.NoRight, Constant.ERROR_MSG_LOGINNORIGHT);
return;
}
// 判断是否有登录，如果有登录直接踢下线
ChannelHandlerContext chc = nettyConnectionUtil.getClientChannelHandlerContextByUserId(customerInfo.getAccount());
if (null != chc) {
// 账号已在别处登录
MessageUtil.sendJsonErrMsg(chc, TransportMessageOuterClass.EnumErrorCode.NoRight, Constant.ERROR_MSG_ELSEWHERELOGINN);
chc.close();
}
// 生成用户token信息
String token = nettyConnectionUtil.getNettyId(ctx);
// 存储 用户id 和 通道信息
nettyConnectionUtil.saveDeviceChannel(ctx, customerInfo.getAccount());
// 存储微信全局id 与通道
nettyConnectionUtil.registerUserid(customerInfo.getAccount(), ctx);
sendMsg(customerInfo, token, ctx, vo);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
private void sendMsg(CommunityCustomerInfo customerInfo, String token, ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo) {
Integer supplierid = customerInfo.getUserId();
// 商家名称
String suppliername = customerInfo.getUserId() + "_" + customerInfo.getAccount();
// 个人账号id
String unionid = customerInfo.getAccount();
// 昵称
String nickname = customerInfo.getNick();
ExtraMessage.Builder buider = ExtraMessage.newBuilder();
buider.setSupplierId(supplierid);
buider.setSupplierName(suppliername);
// 账号类型 子账号
buider.setAccountType(TransportMessageOuterClass.EnumAccountType.SubUser);
if (!StringUtils.isEmpty(nickname)) {
buider.setUnionId(unionid);
buider.setNickName(nickname);
}
buider.setToken(token);
String cacheKeyLogin = Consts.APP_KEY_CUSTOMER + ":CUSTOMER_LOGIN:" + buider.getToken();
redisCacheHelper.addValueCache(cacheKeyLogin, unionid, 1, TimeUnit.DAYS);
ExtraMessage ext = buider.build();
DeviceAuthRspMessage resp = DeviceAuthRspMessage.newBuilder().setAccessToken(token).setExtra(ext).build();
// 缓存此客服可见的会话、通讯录、群聊数据
rpcCustomerVisibleRangesService.initCustomerVisibleRanges(unionid);
MessageUtil.sendJsonMsg(ctx, TransportMessageOuterClass.EnumMsgType.DeviceAuthRsp, null, vo.getId(), resp);
// 初始化配置推送
Integer userId = customerInfo.getUserId();
communityDockingConfigService.pushConfig(userId, unionid);
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/FindContactTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.FindContactTask.FindContactTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class FindContactTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 查找微信联系人
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
FindContactTaskMessage.Builder bd = FindContactTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
FindContactTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.FindContactTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/ForwardMessageByContentTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ForwardMessageByContentTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ForwardMessageByContentTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 转发微信消息内容
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ForwardMessageByContentTask.ForwardMessageByContentTaskMessage.Builder bd = ForwardMessageByContentTask.ForwardMessageByContentTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ForwardMessageByContentTask.ForwardMessageByContentTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ForwardMessageByContentTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/ForwardMessageTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ForwardMessageTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ForwardMessageTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信消息转发
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ForwardMessageTask.ForwardMessageTaskMessage.Builder bd = ForwardMessageTask.ForwardMessageTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ForwardMessageTask.ForwardMessageTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ForwardMessageTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

39
src/main/java/com/eco/websocket/netty/handler/websocket/ForwardMultiMessageTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,39 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.ForwardMultiMessageTask.ForwardMultiMessageTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ForwardMultiMessageTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 转发多条微信聊天消息（逐条转发）
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
ForwardMultiMessageTaskMessage.Builder bd = ForwardMultiMessageTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
ForwardMultiMessageTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.ForwardMultiMessageTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/GetContactInfoTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.GetContactInfoTask.GetContactInfoTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class GetContactInfoTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 通过指令获取信息，可获取群成员的详细信息
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
GetContactInfoTaskMessage.Builder bd = GetContactInfoTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
GetContactInfoTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.GetContactInfoTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/GetFriendDetectResultWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.GetFriendDetectResult.GetFriendDetectResultMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class GetFriendDetectResultWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取最后一次清粉的结果
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
GetFriendDetectResultMessage.Builder bd = GetFriendDetectResultMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
GetFriendDetectResultMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.GetFriendDetectResult, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

33
src/main/java/com/eco/websocket/netty/handler/websocket/HeartBeatReqWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,33 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
public class HeartBeatReqWebsocketHandler implements JsonMessageHandler {
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* websocket 心跳接口
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
if (!nettyConnectionUtil.getNettyId(ctx).equals(vo.getAccessToken())) {
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.NoRight, "token过期");
nettyConnectionUtil.exit(ctx);
} else {
MessageUtil.sendJsonMsg(ctx, TransportMessageOuterClass.EnumMsgType.MsgReceivedAck, vo.getAccessToken(), vo.getId(), null);
}
}
}

44
src/main/java/com/eco/websocket/netty/handler/websocket/JoinGroupByQrTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,44 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.JoinGroupByQrTask.JoinGroupByQrTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class JoinGroupByQrTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信扫二维码加群
*
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
JoinGroupByQrTaskMessage.Builder bd = JoinGroupByQrTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
JoinGroupByQrTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.JoinGroupByQrTask, vo, req);
}
catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

46
src/main/java/com/eco/websocket/netty/handler/websocket/ModifyFriendMemoTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,46 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.ModifyFriendMemoTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class ModifyFriendMemoTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private ModifyFriendMemoTaskService modifyFriendMemoTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 修改微信备注
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// ModifyFriendMemoTaskMessage.Builder bd = ModifyFriendMemoTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// ModifyFriendMemoTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
//将消息转发送给手机客户端
modifyFriendMemoTaskHelper.ModifyFriendMemoTask(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

28
src/main/java/com/eco/websocket/netty/handler/websocket/MsgReceivedAckWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,28 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
@Slf4j
public class MsgReceivedAckWebsocketHandler implements JsonMessageHandler {
/**
* 消息接收确认回复（接收或拒绝接收）
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
//1、校验用户信息
//2、告诉客户端消息已收到
MessageUtil.sendJsonMsg(ctx, TransportMessageOuterClass.EnumMsgType.MsgReceivedAck, vo.getAccessToken(), vo.getId(), null);
} catch (Exception e) {
log.error("error --> ", e);
}
}
}

43
src/main/java/com/eco/websocket/netty/handler/websocket/OneKeyLikeTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,43 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.OneKeyLikeTask.OneKeyLikeTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class OneKeyLikeTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信朋友圈点赞
*
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
OneKeyLikeTaskMessage.Builder bd = OneKeyLikeTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
OneKeyLikeTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.OneKeyLikeTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/PhoneActionTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PhoneActionTask.PhoneActionTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PhoneActionTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 操作手机指令
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PhoneActionTaskMessage.Builder bd = PhoneActionTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PhoneActionTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PhoneActionTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/PhoneStateTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PhoneStateTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PhoneStateTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 查询手机状态
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PhoneStateTask.PhoneStateTaskMessage.Builder bd = PhoneStateTask.PhoneStateTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PhoneStateTask.PhoneStateTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PhoneStateTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

42
src/main/java/com/eco/websocket/netty/handler/websocket/PostFriendDetectTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,42 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PostFriendDetectTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PostFriendDetectTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信清粉
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PostFriendDetectTask.PostFriendDetectTaskMessage.Builder bd = PostFriendDetectTask.PostFriendDetectTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PostFriendDetectTask.PostFriendDetectTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PostFriendDetectTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

43
src/main/java/com/eco/websocket/netty/handler/websocket/PostSNSNewsTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,43 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PostSNSNewsTask.PostSNSNewsTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PostSNSNewsTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 发微信朋友圈
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PostSNSNewsTaskMessage.Builder bd = PostSNSNewsTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PostSNSNewsTaskMessage req = bd.build();
//PostSNSNewsTaskMessage req = vo.getContent().unpack(PostSNSNewsTaskMessage.class);
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PostSNSNewsTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/PostStopFriendDetectTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PostStopFriendDetectTask.PostStopFriendDetectTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PostStopFriendDetectTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 终止微信清粉任务
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PostStopFriendDetectTaskMessage.Builder bd = PostStopFriendDetectTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PostStopFriendDetectTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PostStopFriendDetectTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/PullChatRoomQrCodeTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PullChatRoomQrCodeTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PullChatRoomQrCodeTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取微信群二维码
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PullChatRoomQrCodeTask.PullChatRoomQrCodeTaskMessage.Builder bd = PullChatRoomQrCodeTask.PullChatRoomQrCodeTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PullChatRoomQrCodeTask.PullChatRoomQrCodeTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PullChatRoomQrCodeTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/PullCircleDetailTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PullCircleDetailTask.PullCircleDetailTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PullCircleDetailTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取微信朋友圈图片
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PullCircleDetailTaskMessage.Builder bd = PullCircleDetailTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PullCircleDetailTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PullCircleDetailTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/PullEmojiInfoTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PullEmojiInfoTask.PullEmojiInfoTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PullEmojiInfoTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 推送emoji表情
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PullEmojiInfoTaskMessage.Builder bd = PullEmojiInfoTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PullEmojiInfoTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PullEmojiInfoTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/PullFriendAddReqListTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PullFriendAddReqListTask.PullFriendAddReqListTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PullFriendAddReqListTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取微信加好友请求列表
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PullFriendAddReqListTaskMessage.Builder bd = PullFriendAddReqListTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PullFriendAddReqListTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PullFriendAddReqListTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/PullFriendCircleTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PullFriendCircleTask.PullFriendCircleTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PullFriendCircleTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取微信指定好友朋友圈
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PullFriendCircleTaskMessage.Builder bd = PullFriendCircleTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PullFriendCircleTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PullFriendCircleTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

42
src/main/java/com/eco/websocket/netty/handler/websocket/PullWeChatQrCodeTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,42 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.PullWeChatQrCodeTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class PullWeChatQrCodeTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 上传当前登录的微信二维码
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
PullWeChatQrCodeTask.PullWeChatQrCodeTaskMessage.Builder bd = PullWeChatQrCodeTask.PullWeChatQrCodeTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
PullWeChatQrCodeTask.PullWeChatQrCodeTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.PullWeChatQrCodeTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/QueryHbDetailTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.QueryHbDetailTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class QueryHbDetailTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 请求微信红包详情
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
QueryHbDetailTask.QueryHbDetailTaskMessage.Builder bd = QueryHbDetailTask.QueryHbDetailTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
QueryHbDetailTask.QueryHbDetailTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.QueryHbDetailTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/RemittanceTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.RemittanceTask.RemittanceTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class RemittanceTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信转账
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
RemittanceTaskMessage.Builder bd = RemittanceTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
RemittanceTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.RemittanceTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

46
src/main/java/com/eco/websocket/netty/handler/websocket/RequestChatRoomInfoTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,46 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.RequestChatRoomInfoTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class RequestChatRoomInfoTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private RequestChatRoomInfoTaskService requestChatRoomInfoTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 请求微信群聊的详细信息
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// RequestChatRoomInfoTaskMessage.Builder bd = RequestChatRoomInfoTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// RequestChatRoomInfoTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 将消息转发送给手机客户端
requestChatRoomInfoTaskHelper.ChatRoomAddNotice(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

46
src/main/java/com/eco/websocket/netty/handler/websocket/RequestContactsInfoTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,46 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.RequestContactsInfoTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class RequestContactsInfoTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private RequestContactsInfoTaskService requestContactsInfoTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 获取微信联系人详细信息（不一定是好友，如群聊成员）
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// RequestContactsInfoTaskMessage.Builder bd = RequestContactsInfoTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// RequestContactsInfoTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 将消息转发送给手机客户端
requestContactsInfoTaskHelper.FriendChangeNotice(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

34
src/main/java/com/eco/websocket/netty/handler/websocket/RequestTalkContentTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,34 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.RequestTalkContentTask.RequestTalkContentTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class RequestTalkContentTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取微信聊天消息的原始内容（主要是xml内容）
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) throws Exception {
log.debug(contentJsonStr);
RequestTalkContentTaskMessage.Builder bd = RequestTalkContentTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
RequestTalkContentTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.RequestTalkContentTask, vo, req);
}
}

48
src/main/java/com/eco/websocket/netty/handler/websocket/RequestTalkDetailTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,48 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.RequestTalkDetailTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class RequestTalkDetailTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private RequestTalkDetailTaskService requestTalkDetailTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 请求微信图片或视频消息的详细内容
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// RequestTalkDetailTaskMessage.Builder bd = RequestTalkDetailTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// RequestTalkDetailTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
//将消息转发送给手机客户端
requestTalkDetailTaskHelper.RequestTalkDetailTask(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/RevokeMessageTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.RevokeMessageTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class RevokeMessageTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private RevokeMessageTaskService revokeMessageTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 微信消息撤回
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 将消息转发送给手机客户端
revokeMessageTaskHelper.revoke(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/SendFriendVerifyTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.SendFriendVerifyTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class SendFriendVerifyTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信聊天界面发送朋友验证
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
SendFriendVerifyTask.SendFriendVerifyTaskMessage.Builder bd = SendFriendVerifyTask.SendFriendVerifyTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
SendFriendVerifyTask.SendFriendVerifyTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.SendFriendVerifyTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/SendJielongTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.SendJielongTask.SendJielongTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class SendJielongTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信发接龙消息，任务结果TalkToFriendTaskResultNotice
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
SendJielongTaskMessage.Builder bd = SendJielongTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
SendJielongTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.SendJielongTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

47
src/main/java/com/eco/websocket/netty/handler/websocket/SendLuckyMoneyTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,47 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.SendLuckyMoneyTask.SendLuckyMoneyTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class SendLuckyMoneyTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信发红包
*
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
SendLuckyMoneyTaskMessage.Builder bd = SendLuckyMoneyTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
SendLuckyMoneyTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.SendLuckyMoneyTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/SendMultiPictureTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.SendMultiPictureTask;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class SendMultiPictureTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信聊天发送多张图片
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
SendMultiPictureTask.SendMultiPictureTaskMessage.Builder bd = SendMultiPictureTask.SendMultiPictureTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
SendMultiPictureTask.SendMultiPictureTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.SendMultiPictureTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

42
src/main/java/com/eco/websocket/netty/handler/websocket/TakeLuckyMoneyTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,42 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TakeLuckyMoneyTask.TakeLuckyMoneyTaskMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TakeLuckyMoneyTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信领取红包或转账
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
TakeLuckyMoneyTaskMessage.Builder bd = TakeLuckyMoneyTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
TakeLuckyMoneyTaskMessage req = bd.build();
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.TakeLuckyMoneyTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

59
src/main/java/com/eco/websocket/netty/handler/websocket/TalkToFriendTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,59 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.alibaba.fastjson.JSONObject;
import com.eco.common.base.dto.WeChatChatRoomDto;
import com.eco.common.rpc.helper.TalkToFriendTaskService;
import com.eco.common.rpc.helper.qw.QwTalkToFriendTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TalkToFriendTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private TalkToFriendTaskService talkToFriendTaskHelper;
@Reference(check = false)
private QwTalkToFriendTaskService qwTalkToFriendTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 给微信好友发消息
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// TalkToFriendTaskMessage.Builder bd = TalkToFriendTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// TalkToFriendTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 消息记录数据库
// 将消息转发送给手机客户端
JSONObject jsonObject = JSONObject.parseObject(contentJsonStr);
String weChatId = jsonObject.getString("WeChatId");
if (WeChatChatRoomDto.isEnterpriseId(weChatId)) {
qwTalkToFriendTaskHelper.talkToFriendTask(contentJsonStr, account);
} else {
talkToFriendTaskHelper.TalkToFriendTask(contentJsonStr, account);
}
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerBizContactPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.TriggerBizContactPushTask.TriggerBizContactPushTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerBizContactPushTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 获取公众号列表
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
TriggerBizContactPushTaskMessage.Builder bd = TriggerBizContactPushTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
TriggerBizContactPushTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.TriggerBizContactPushTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

49
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerChatroomPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,49 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.TriggerChatroomPushTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerChatroomPushTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private TriggerChatroomPushTaskService triggerChatroomPushTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 触发推送微信群聊列表
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// TriggerChatRoomPushTaskMessage.Builder bd = TriggerChatRoomPushTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// TriggerChatRoomPushTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 将消息转发送给手机客户端
// triggerChatroomPushTaskHelper.TriggerChatroomPushTask(contentJsonStr, account);
triggerChatroomPushTaskHelper.TriggerChatroomPushTaskForPage(contentJsonStr, account);
}
catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerCircleMsgPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.TriggerCircleMsgPushTask;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerCircleMsgPushTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 触发朋友圈消息列表推送
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
TriggerCircleMsgPushTask.TriggerCircleMsgPushTaskMessage.Builder bd = TriggerCircleMsgPushTask.TriggerCircleMsgPushTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
TriggerCircleMsgPushTask.TriggerCircleMsgPushTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.TriggerCircleMsgPushTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

44
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerCirclePushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,44 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.TriggerCirclePushTask.TriggerCirclePushTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerCirclePushTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 触发推送朋友圈列表
* @author xiaoxx
* startTime传秒
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
TriggerCirclePushTaskMessage.Builder bd = TriggerCirclePushTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
TriggerCirclePushTaskMessage req = bd.build();
// TriggerCirclePushTaskMessage req =
// vo.getContent().unpack(TriggerCirclePushTaskMessage.class);
// 将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.TriggerCirclePushTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

46
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerConversationPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,46 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.TriggerConversationPushTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerConversationPushTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private TriggerConversationPushTaskService triggerConversationPushTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 触发推送微信会话列表
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// TriggerConversationPushTaskMessage.Builder bd = TriggerConversationPushTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// TriggerConversationPushTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// triggerConversationPushTaskHelper.ConversationPushNotice(contentJsonStr, account);
triggerConversationPushTaskHelper.conversationPushNoticeV2(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

46
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerFriendPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,46 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.TriggerFriendPushTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerFriendPushTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private TriggerFriendPushTaskService triggerFriendPushTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 触发手机推送微信好友列表任
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// TriggerFriendPushTaskMessage.Builder bd = TriggerFriendPushTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// TriggerFriendPushTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
//将消息转发送给手机客户端
triggerFriendPushTaskHelper.FriendPushNotice(contentJsonStr, account);
// triggerFriendPushTaskHelper.FriendPushNoticeForPage(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

45
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerHistoryMsgPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,45 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.TriggerHistoryMsgPushTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerHistoryMsgPushTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private TriggerHistoryMsgPushTaskService triggerHistoryMsgPushTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 触发微信推送聊天记录
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// TriggerHistoryMsgPushTaskMessage.Builder bd = TriggerHistoryMsgPushTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// TriggerHistoryMsgPushTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
// 将消息转发送给手机客户端
triggerHistoryMsgPushTaskHelper.HistoryMsgPushNotice(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

47
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerMessageReadTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,47 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.eco.common.rpc.helper.TriggerMessageReadTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.eco.websocket.netty.NettyConnectionUtil;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerMessageReadTaskWebsocketHandler implements JsonMessageHandler {
@Reference(check = false)
private TriggerMessageReadTaskService triggerMessageReadTaskHelper;
@Resource
private NettyConnectionUtil nettyConnectionUtil;
/**
* 通知微信将某个聊天窗口置为已读
*
* @author xiaoxx
*/
@Override
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
// TriggerMessageReadTaskMessage.Builder bd = TriggerMessageReadTaskMessage.newBuilder();
// JsonFormat.parser().merge(contentJsonStr, bd);
// TriggerMessageReadTaskMessage req = bd.build();
String account = nettyConnectionUtil.getUserIdByNettyId(ctx);
//将消息转发送给手机客户端
triggerMessageReadTaskHelper.MessageRead(contentJsonStr, account);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerUnReadTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.TriggerUnReadTask.TriggerUnReadTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerUnReadTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 已读置未读
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
TriggerUnReadTaskMessage.Builder bd = TriggerUnReadTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
TriggerUnReadTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.TriggerUnReadTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/TriggerWechatPushTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.TriggerWechatPushTask;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class TriggerWechatPushTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 触发微信上线通知，用于更新微信账号的信息
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
TriggerWechatPushTask.TriggerWechatPushTaskMessage.Builder bd = TriggerWechatPushTask.TriggerWechatPushTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
TriggerWechatPushTask.TriggerWechatPushTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.TriggerWechatPushTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/VoiceTransTextTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.VoiceTransTextTask.VoiceTransTextTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class VoiceTransTextTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信语音消息转文字
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
VoiceTransTextTaskMessage.Builder bd = VoiceTransTextTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
VoiceTransTextTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.VoiceTransTextTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

41
src/main/java/com/eco/websocket/netty/handler/websocket/WeChatGroupSendTaskWesocketHandler.java
Unescape Escape View File

@ -0,0 +1,41 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.WeChatGroupSendTask.WeChatGroupSendTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class WeChatGroupSendTaskWesocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信群发消息
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
WeChatGroupSendTaskMessage.Builder bd = WeChatGroupSendTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
WeChatGroupSendTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.WeChatGroupSendTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/WechatLogoutTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.WechatLogoutTask.WechatLogoutTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class WechatLogoutTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信账号登出
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
WechatLogoutTaskMessage.Builder bd = WechatLogoutTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
WechatLogoutTaskMessage req = bd.build();
//将消息转发送给手机客户端
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.WechatLogoutTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

40
src/main/java/com/eco/websocket/netty/handler/websocket/WechatSettingTaskWebsocketHandler.java
Unescape Escape View File

@ -0,0 +1,40 @@
package com.eco.websocket.netty.handler.websocket;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import Jubo.JuLiao.IM.Wx.Proto.WechatSettingTask.WechatSettingTaskMessage;
import com.eco.websocket.netty.async.AsyncTaskService;
import com.eco.websocket.netty.common.Constant;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service
@Slf4j
public class WechatSettingTaskWebsocketHandler implements JsonMessageHandler {
@Resource
private AsyncTaskService asyncTaskService;
/**
* 微信改昵称，头像
* @author xiaoxx
*/
@Async
public void handleMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.TransportMessage vo, String contentJsonStr) {
try {
log.debug(contentJsonStr);
WechatSettingTaskMessage.Builder bd = WechatSettingTaskMessage.newBuilder();
JsonFormat.parser().merge(contentJsonStr, bd);
WechatSettingTaskMessage req = bd.build();
asyncTaskService.msgSend2Phone(ctx, req.getWeChatId(), TransportMessageOuterClass.EnumMsgType.WechatSettingTask, vo, req);
} catch (Exception e) {
log.error("error --> ", e);;
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, Constant.ERROR_MSG_DECODFAIL);
}
}
}

72
src/main/java/com/eco/websocket/netty/processor/WebSocketMessageProcessor.java
Unescape Escape View File

@ -0,0 +1,72 @@
package com.eco.websocket.netty.processor;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.eco.common.commonbase.exception.ServiceException;
import com.eco.websocket.netty.handler.JsonMessageHandler;
import com.eco.websocket.netty.utils.MessageUtil;
import com.googlecode.protobuf.format.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Map;
/**
* 消息处理分发器
*/
@Service
@Slf4j
public class WebSocketMessageProcessor {
@Autowired
private Map<String, JsonMessageHandler> handlers;
public void handler(ChannelHandlerContext ctx, TextWebSocketFrame msg) {
String text = msg.text();
if (!StringUtils.isEmpty(text)) {
try {
JSONObject jsonObject = JSONObject.parseObject(text);
Object objMsgType = jsonObject.get("MsgType");
if (null == objMsgType) {
log.error("MsgType消息类型传入错误！");
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, "MsgType消息类型传入错误");
return;
}
String contentJsonStr = jsonObject.getString("Content");
if (StringUtils.isEmpty(contentJsonStr)) {
log.error("Content消息类型传入错误！");
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, "Content消息类型传入错误");
return;
}
TransportMessageOuterClass.TransportMessage.Builder builder = TransportMessageOuterClass.TransportMessage.newBuilder();
String jsonFormat = jsonObject.toJSONString();
log.debug("请求json:" + jsonFormat);
JsonFormat.merge(jsonFormat, builder);
TransportMessageOuterClass.TransportMessage vo = builder.build();
String msgtype = StrUtil.lowerFirst(objMsgType + "WebsocketHandler");
log.debug("websocket:" + msgtype);
if (handlers.containsKey(msgtype)) {
handlers.get(msgtype).handleMsg(ctx, vo, contentJsonStr);
}
} catch (Exception e) {
log.error("WebSocketMessageProcessor --> ", e);
String errMsg = "参数传入错误";
if (e instanceof ServiceException) {
// 系统抛出异常
errMsg = e.getMessage();
}
MessageUtil.sendJsonErrMsg(ctx, TransportMessageOuterClass.EnumErrorCode.InvalidParam, errMsg);
}
}
text = null;// 清空一下
}
}

45
src/main/java/com/eco/websocket/netty/utils/ByteStringToString.java
Unescape Escape View File

@ -0,0 +1,45 @@
package com.eco.websocket.netty.utils;
import com.google.protobuf.ByteString;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
public class ByteStringToString {
public static String bytesToString(ByteString src, String charSet) {
if (StringUtils.isEmpty(charSet)) {
charSet = "GB2312";
}
return bytesToString(src.toByteArray(), charSet);
}
private static String bytesToString(byte[] input, String charSet) {
if (ArrayUtils.isEmpty(input)) {
return StringUtils.EMPTY;
}
ByteBuffer buffer = ByteBuffer.allocate(input.length);
buffer.put(input);
buffer.flip();
Charset charset = null;
CharsetDecoder decoder = null;
CharBuffer charBuffer = null;
try {
charset = Charset.forName(charSet);
decoder = charset.newDecoder();
charBuffer = decoder.decode(buffer.asReadOnlyBuffer());
return charBuffer.toString();
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
}

138
src/main/java/com/eco/websocket/netty/utils/MessageUtil.java
Unescape Escape View File

@ -0,0 +1,138 @@
package com.eco.websocket.netty.utils;
import Jubo.JuLiao.IM.Wx.Proto.ErrorMessageOuterClass.ErrorMessage;
import Jubo.JuLiao.IM.Wx.Proto.TransportMessageOuterClass;
import com.alibaba.fastjson.JSONObject;
import com.google.protobuf.Any;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Message;
import com.google.protobuf.util.JsonFormat;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class MessageUtil {
/**
* 发送消息
*/
public static void sendMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.EnumMsgType msgType, String accessToken, Long refMsgId,
Message resp) {
Message msg = MessageUtil.getMessage(msgType, accessToken, refMsgId, resp);
ctx.channel().writeAndFlush(msg);
}
/**
* json 形式
*/
private static void sendJsonStringMsg(ChannelHandlerContext ctx, String msgType, String accessToken, String refMsgId,
String object) {
JSONObject obj = new JSONObject();
obj.put("msgType", msgType);
obj.put("accessToken", accessToken);
obj.put("refMsgId", refMsgId);
obj.put("message", object);
log.debug("发送消息：{}", obj.toJSONString());
//if (object != null) {
// JSONObject encryptValueByKey = encryptValueByKey(JSON.parseObject(object), "FriendId");
// obj.put("message", encryptValueByKey.toJSONString());
// log.info("加密后JSON：{}", obj.toJSONString());
//}
ctx.channel().writeAndFlush(new TextWebSocketFrame(obj.toJSONString()));
}
/**
* json 形式
*/
private static void sendJsonStringMsg(ChannelHandlerContext ctx, String msgType, String accessToken, Long refMsgId,
String object) {
//JSONObject obj = new JSONObject();
//obj.put("msgType", msgType);
//obj.put("accessToken", accessToken);
//obj.put("refMsgId", refMsgId);
//obj.put("message", object);
//ctx.channel().writeAndFlush(new TextWebSocketFrame(obj.toJSONString()));
sendJsonStringMsg(ctx, msgType, accessToken, String.valueOf(refMsgId), object);
}
/**
* 发送json字符串消息
*/
public static void sendJsonMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.EnumMsgType msgType, String accessToken, Long refMsgId,
Message resp) {
String json = null;
if (null != resp) {
try {
json = JsonFormat.printer().print(resp);
} catch (InvalidProtocolBufferException e) {
log.error("error --> ", e);;
}
}
sendJsonStringMsg(ctx, msgType, accessToken, refMsgId, json);
}
/**
* json 形式
*/
public static void sendJsonStringMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.EnumMsgType msgType, String accessToken, Long refMsgId,
String object) {
sendJsonStringMsg(ctx, msgType.name(), accessToken, refMsgId, object);
}
/**
* json 形式
*/
public static void sendJsonStringMsg(ChannelHandlerContext ctx, String msgType, String accessToken, String refMsgId,
JSONObject object) {
sendJsonStringMsg(ctx, msgType, accessToken, refMsgId, object.toJSONString());
}
/**
* 发送错误消息
*/
public static void sendErrMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.EnumErrorCode errorCode, Long refMsgId, String errMsg) {
ErrorMessage resp = MessageUtil.getErrMessage(errorCode, errMsg);
sendMsg(ctx, TransportMessageOuterClass.EnumMsgType.Error, null, refMsgId, resp);
}
/**
* 发送json错误消息
*/
public static void sendJsonErrMsg(ChannelHandlerContext ctx, TransportMessageOuterClass.EnumErrorCode errorCode, String errMsg) {
ErrorMessage resp = MessageUtil.getErrMessage(errorCode, errMsg);
sendJsonMsg(ctx, TransportMessageOuterClass.EnumMsgType.Error, null, null, resp);
}
/**
* 封装错误消息消息体
*/
private static ErrorMessage getErrMessage(TransportMessageOuterClass.EnumErrorCode errorCode, String errorMsg) {
return ErrorMessage.newBuilder().setErrorCode(errorCode).setErrorMsg(errorMsg).build();
}
/**
* 封装base消息体
*/
private static Message getMessage(TransportMessageOuterClass.EnumMsgType type, String accessToken, Long refMsgId, Message resp) {
TransportMessageOuterClass.TransportMessage.Builder builder = TransportMessageOuterClass.TransportMessage.newBuilder();
builder.setId(MsgIdBuilder.getId());
if (null != accessToken) {
builder.setAccessToken(accessToken);
}
if (null != type) {
builder.setMsgType(type);
}
if (null != refMsgId) {
builder.setRefMessageId(refMsgId);
}
if (null != resp) {
builder.setContent(Any.pack(resp));
}
return builder.build();
}
}

28
src/main/java/com/eco/websocket/netty/utils/MsgIdBuilder.java
Unescape Escape View File

@ -0,0 +1,28 @@
package com.eco.websocket.netty.utils;
import java.util.Random;
public class MsgIdBuilder {
private static Long id = null;
private MsgIdBuilder(){}
public static synchronized Long getId(){
if(id == null){
id = Math.abs(new Random().nextLong());
}else{
id = id + 1;
}
return id;
} public static synchronized String getId2(){
return String.valueOf(getId());
}
public static void main(String[] args) {
for(int i =0;i<1000;i++){
System.out.println(MsgIdBuilder.getId());
}
}
}

54
src/main/java/com/eco/websocket/utils/PropertyUtils.java
Unescape Escape View File

@ -0,0 +1,54 @@
package com.eco.websocket.utils;
import org.springframework.core.env.Environment;
public class PropertyUtils {
private static final String HTTP_PORT = "server.port";
private static final String SOCKET_PORT = "com.eco.socket.port";
private static final String WEBSOCKET_PORT = "com.eco.websocket.port";
private static final String UPLOAD_URL = "com.eco.upload.url";
private static final String SERVER_IP = "com.eco.upload.ip";
private static final String FILE_PATH = "com.eco.upload.filePath";
private static final String PREFIX_FILE_PATH = "com.eco.upload.prefixFilePath";
private static final String SILK_V3_DECODER_PATH = "client.silkV3DecoderPath";
// http端口
public static Integer getHttpPort(Environment env) {
return Integer.valueOf(env.getProperty(HTTP_PORT));
}
// socket端口
public static Integer getNettySocketPort(Environment env) {
return Integer.valueOf(env.getProperty(SOCKET_PORT));
}
// websocket端口
public static Integer getNettyWebsocketPort(Environment env) {
return Integer.valueOf(env.getProperty(WEBSOCKET_PORT));
}
// 全局上传网络地址
public static String getUploadUrl(Environment env) {
return env.getProperty(UPLOAD_URL);
}
// 服务器ip
public static String getServerIp(Environment env) {
return env.getProperty(SERVER_IP);
}
// 服务器文件存储地址
public static String getServerFilePath(Environment env) {
return env.getProperty(FILE_PATH);
}
// silkV3DecoderPath
public static String getSilkV3DecoderPath(Environment env) {
return env.getProperty(SILK_V3_DECODER_PATH);
}
// 服务器文件访问前缀
public static String getServerPrefixFilePath(Environment env) {
return env.getProperty(PREFIX_FILE_PATH);
}
}

62
src/main/resources/bootstrap.yml
Unescape Escape View File

@ -0,0 +1,62 @@
server:
max-http-header-size: 102400
undertow:
buffer-size: 8192
direct-buffers: true
io-threads: 8
worker-threads: 128
spring:
application:
name: ${spring.cloud.nacos.discovery.service}-@activatedProperties@
profiles:
active: @activatedProperties@
cloud:
nacos:
discovery:
server-addr: @addr@
service: customer-service-websocket
namespace: @namespace@
config:
namespace: @namespace@
server-addr: @addr@
file-extension: yml
ext-config:
- data-id: customer_core_redis.yml
- data-id: fission_v2_job.yml
- data-id: customer-websocket.yml
refresh: true
servlet:
multipart:
max-file-size: 100MB
max-request-size: 100MB
thymeleaf:
check-template: false
check-template-location: false
mvc:
servlet:
load-on-startup: 1
dubbo:
application:
name: ${spring.cloud.nacos.discovery.service}
protocol:
id: dubbo
# host: 192.168.6.201
port: -1
registry:
address: nacos://@addr@
parameters:
namespace: @namespace@
metadata-report:
address: nacos://@addr@
management:
endpoints:
web:
exposure:
include: '*'
logging:
config: @logfile@
level:
root: info

69
src/main/resources/logback-client.xml
Unescape Escape View File

@ -0,0 +1,69 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!--设置存储路径变量-->
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
<conversionRule conversionWord="wex"
converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
<conversionRule conversionWord="wEx"
converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
<property name="LOG_PATTERN"
value="${CONSOLE_LOG_PATTERN:-%clr(%d{${LOG_DATEFORMAT_PATTERN:-yyyy-MM-dd HH:mm:ss.SSS}}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(--){faint} [%X{tid}] %clr(--){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
<property name="APP_HOME" value="/opt/customer-websocket/"/>
<property name="LOG_HOME" value="/opt/customer-websocket/log"/>
<property name="APP_NAME" value="customer-websocket"/>
<!--控制台输出appender-->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<!--设置输出格式-->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>${LOG_PATTERN}</pattern>
<!--设置编码-->
<charset>UTF-8</charset>
</encoder>
</appender>
<!--文件输出,时间窗口滚动-->
<appender name="timeFileOutput" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!--日志名,指定最新的文件名，其他文件名使用FileNamePattern -->
<File>${APP_HOME}/${APP_NAME}.log</File>
<!--文件滚动模式-->
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!--日志文件输出的文件名,使用gz压缩-->
<FileNamePattern>${LOG_HOME}/${APP_NAME}.%d{yyyy-MM-dd}.%i.log</FileNamePattern>
<!--日志文件保留天数-->
<maxFileSize>1024MB</maxFileSize>
<MaxHistory>3</MaxHistory>
<totalSizeCap>5000MB</totalSizeCap>
<cleanHistoryOnStart>true</cleanHistoryOnStart>
</rollingPolicy>
<!--输出格式-->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符
参考 https://logback.qos.ch/manual/layouts.html
-->
<pattern>${LOG_PATTERN}</pattern>
<!--设置编码-->
<charset>UTF-8</charset>
</encoder>
<!--在root指定的级别之上再次进行过滤,输出大于等于level,可通过onMatch和onMisMatch来确定只输出某个级别的 -->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>INFO</level>
<!--接受匹配-->
<!-- <onMatch>ACCEPT</onMatch>-->
<!--拒绝不匹配的-->
<!-- <onMismatch>DENY</onMismatch>-->
</filter>
</appender>
<!--指定基础的日志输出级别-->
<root level="INFO">
<!--appender将会添加到这个loger-->
<!-- <appender-ref ref="console"/>-->
<appender-ref ref="timeFileOutput"/>
</root>
</configuration>
Write Preview
Loading…
Cancel
Save