962e1dc722
- 实现环境配置管理，支持外部和本地主机模式切换 - 集成Demo API接口，包含登录、注册、文件上传等功能 - 构建附件处理仓库，支持图片、视频、音频和文件发送 - 开发认证仓库，管理用户会话和IM令牌刷新机制 - 添加语音录制功能，支持实时音频消息录制 - 创建依赖注入容器，统一管理应用组件实例 - 实现登录界面，提供用户认证交互功能 - 开发聊天界面，集成消息收发和媒体处理功能
450 行
20 KiB
Java
450 行
20 KiB
Java
package com.xuqm.im.service;
|
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import com.xuqm.common.exception.BusinessException;
|
|
import com.xuqm.im.cluster.ImClusterPublisher;
|
|
import com.xuqm.im.entity.ImGroupEntity;
|
|
import com.xuqm.im.entity.ImMessageEntity;
|
|
import com.xuqm.im.entity.WebhookConfigEntity;
|
|
import com.xuqm.im.model.ConversationView;
|
|
import com.xuqm.im.model.SendMessageRequest;
|
|
import com.xuqm.im.repository.ImFriendRepository;
|
|
import com.xuqm.im.repository.WebhookConfigRepository;
|
|
import org.springframework.beans.factory.annotation.Value;
|
|
import org.springframework.data.domain.Page;
|
|
import org.springframework.data.domain.PageRequest;
|
|
import org.springframework.scheduling.annotation.Async;
|
|
import org.springframework.stereotype.Service;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import java.net.URI;
|
|
import java.net.http.HttpClient;
|
|
import java.net.http.HttpRequest;
|
|
import java.net.http.HttpResponse;
|
|
import java.time.LocalDateTime;
|
|
import java.time.ZoneOffset;
|
|
import com.xuqm.im.repository.ImMessageRepository;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.UUID;
|
|
|
|
@Service
|
|
public class MessageService {
|
|
|
|
private static final Logger log = LoggerFactory.getLogger(MessageService.class);
|
|
|
|
private final ImMessageRepository messageRepository;
|
|
private final WebhookConfigRepository webhookRepository;
|
|
private final KeywordFilterService keywordFilterService;
|
|
private final ImClusterPublisher clusterPublisher;
|
|
private final ImGroupService groupService;
|
|
private final BlacklistService blacklistService;
|
|
private final ConversationStateService conversationStateService;
|
|
private final ImPushBridgeClient pushBridgeClient;
|
|
private final ImFeatureConfigClient featureConfigClient;
|
|
private final ImFriendRepository friendRepository;
|
|
private final ObjectMapper objectMapper;
|
|
|
|
@Value("${im.webhook-timeout-ms:3000}")
|
|
private int webhookTimeoutMs;
|
|
|
|
public MessageService(ImMessageRepository messageRepository,
|
|
WebhookConfigRepository webhookRepository,
|
|
KeywordFilterService keywordFilterService,
|
|
ImClusterPublisher clusterPublisher,
|
|
ImGroupService groupService,
|
|
BlacklistService blacklistService,
|
|
ConversationStateService conversationStateService,
|
|
ImPushBridgeClient pushBridgeClient,
|
|
ImFeatureConfigClient featureConfigClient,
|
|
ImFriendRepository friendRepository,
|
|
ObjectMapper objectMapper) {
|
|
this.messageRepository = messageRepository;
|
|
this.webhookRepository = webhookRepository;
|
|
this.keywordFilterService = keywordFilterService;
|
|
this.clusterPublisher = clusterPublisher;
|
|
this.groupService = groupService;
|
|
this.blacklistService = blacklistService;
|
|
this.conversationStateService = conversationStateService;
|
|
this.pushBridgeClient = pushBridgeClient;
|
|
this.featureConfigClient = featureConfigClient;
|
|
this.friendRepository = friendRepository;
|
|
this.objectMapper = objectMapper;
|
|
}
|
|
|
|
public ImMessageEntity send(String appId, String fromUserId, SendMessageRequest req) {
|
|
String content = req.content();
|
|
if (req.msgType() == ImMessageEntity.MsgType.TEXT) {
|
|
content = keywordFilterService.filter(appId, content);
|
|
if (content == null) {
|
|
throw new BusinessException("消息包含违禁内容");
|
|
}
|
|
}
|
|
ImGroupEntity group = null;
|
|
if (req.chatType() == ImMessageEntity.ChatType.GROUP) {
|
|
group = groupService.get(req.toId());
|
|
if (!groupService.memberIds(group).contains(fromUserId)) {
|
|
throw new BusinessException(403, "不在群内");
|
|
}
|
|
if (groupService.isMemberMuted(req.toId(), fromUserId)) {
|
|
throw new BusinessException(403, "当前用户已被禁言");
|
|
}
|
|
} else if (blacklistService.isEitherBlocked(appId, fromUserId, req.toId())) {
|
|
throw new BusinessException(403, "已被拉黑，无法发送消息");
|
|
} else if (!isFriend(appId, fromUserId, req.toId())
|
|
&& !featureConfigClient.allowStrangerMessage(appId)) {
|
|
throw new BusinessException(403, "仅允许好友之间发送消息");
|
|
}
|
|
|
|
ImMessageEntity message = new ImMessageEntity();
|
|
message.setId(req.messageId() != null && !req.messageId().isBlank()
|
|
? req.messageId()
|
|
: UUID.randomUUID().toString());
|
|
message.setAppId(appId);
|
|
message.setFromUserId(fromUserId);
|
|
message.setToId(req.toId());
|
|
message.setChatType(req.chatType());
|
|
message.setMsgType(req.msgType());
|
|
message.setContent(content);
|
|
message.setStatus(ImMessageEntity.MsgStatus.SENT);
|
|
message.setMentionedUserIds(req.mentionedUserIds());
|
|
message.setCreatedAt(LocalDateTime.now());
|
|
ImMessageEntity saved = messageRepository.save(message);
|
|
if (req.chatType() == ImMessageEntity.ChatType.GROUP) {
|
|
saved.setGroupReadCount(groupReadCount(appId, req.toId(), saved.getCreatedAt(), saved.getFromUserId()));
|
|
}
|
|
|
|
String destination = req.chatType() == ImMessageEntity.ChatType.SINGLE
|
|
? "/user/" + req.toId() + "/queue/messages"
|
|
: "/topic/group/" + req.toId();
|
|
log.debug("send message appId={} from={} to={} chatType={} msgType={} destination={}",
|
|
appId, fromUserId, req.toId(), req.chatType(), req.msgType(), destination);
|
|
clusterPublisher.publish(destination, saved);
|
|
if (req.chatType() == ImMessageEntity.ChatType.SINGLE && !fromUserId.equals(req.toId())) {
|
|
log.debug("echo message back to sender appId={} from={} to={}",
|
|
appId, fromUserId, req.toId());
|
|
clusterPublisher.publish("/user/" + fromUserId + "/queue/messages", saved);
|
|
conversationStateService.clearHiddenForUsers(appId, req.toId(), req.chatType().name(), List.of(fromUserId, req.toId()));
|
|
pushBridgeClient.notifyUsers(
|
|
appId,
|
|
List.of(req.toId()),
|
|
"新消息",
|
|
saved.getContent(),
|
|
buildPushPayload(saved)
|
|
);
|
|
} else if (req.chatType() == ImMessageEntity.ChatType.GROUP) {
|
|
List<String> memberIds = groupService.memberIds(group);
|
|
conversationStateService.clearHiddenForUsers(appId, req.toId(), req.chatType().name(), memberIds);
|
|
pushBridgeClient.notifyUsers(
|
|
appId,
|
|
memberIds.stream()
|
|
.filter(memberId -> !memberId.equals(fromUserId))
|
|
.toList(),
|
|
"群聊消息",
|
|
saved.getContent(),
|
|
buildPushPayload(saved)
|
|
);
|
|
}
|
|
|
|
dispatchWebhooks(appId, saved);
|
|
return saved;
|
|
}
|
|
|
|
private boolean isFriend(String appId, String userId, String friendId) {
|
|
return friendRepository.existsByAppIdAndUserIdAndFriendId(appId, userId, friendId)
|
|
|| friendRepository.existsByAppIdAndUserIdAndFriendId(appId, friendId, userId);
|
|
}
|
|
|
|
public ImMessageEntity revoke(String appId, String messageId, String requestUserId) {
|
|
ImMessageEntity message = messageRepository.findById(messageId)
|
|
.orElseThrow(() -> new BusinessException(404, "消息不存在"));
|
|
if (!message.getAppId().equals(appId)) {
|
|
throw new BusinessException(403, "无权操作");
|
|
}
|
|
if (!message.getFromUserId().equals(requestUserId)) {
|
|
throw new BusinessException(403, "只能撤回自己发送的消息");
|
|
}
|
|
message.setStatus(ImMessageEntity.MsgStatus.REVOKED);
|
|
message.setMsgType(ImMessageEntity.MsgType.REVOKED);
|
|
ImMessageEntity saved = messageRepository.save(message);
|
|
|
|
if (saved.getChatType() == ImMessageEntity.ChatType.SINGLE) {
|
|
log.debug("revoke single messageId={} destinationTo={} destinationFrom={}",
|
|
saved.getId(), saved.getToId(), saved.getFromUserId());
|
|
clusterPublisher.publish("/user/" + saved.getToId() + "/queue/messages", saved);
|
|
if (!saved.getFromUserId().equals(saved.getToId())) {
|
|
clusterPublisher.publish("/user/" + saved.getFromUserId() + "/queue/messages", saved);
|
|
}
|
|
} else {
|
|
log.debug("revoke group messageId={} groupId={}", saved.getId(), saved.getToId());
|
|
clusterPublisher.publish("/topic/group/" + saved.getToId(), saved);
|
|
}
|
|
return saved;
|
|
}
|
|
|
|
public ImMessageEntity adminRevoke(String appId, String messageId) {
|
|
ImMessageEntity message = messageRepository.findById(messageId)
|
|
.orElseThrow(() -> new BusinessException(404, "消息不存在"));
|
|
if (!message.getAppId().equals(appId)) {
|
|
throw new BusinessException(403, "无权操作");
|
|
}
|
|
message.setStatus(ImMessageEntity.MsgStatus.REVOKED);
|
|
message.setMsgType(ImMessageEntity.MsgType.REVOKED);
|
|
ImMessageEntity saved = messageRepository.save(message);
|
|
if (saved.getChatType() == ImMessageEntity.ChatType.SINGLE) {
|
|
log.debug("admin revoke single messageId={} destinationTo={} destinationFrom={}",
|
|
saved.getId(), saved.getToId(), saved.getFromUserId());
|
|
clusterPublisher.publish("/user/" + saved.getToId() + "/queue/messages", saved);
|
|
if (!saved.getFromUserId().equals(saved.getToId())) {
|
|
clusterPublisher.publish("/user/" + saved.getFromUserId() + "/queue/messages", saved);
|
|
}
|
|
} else {
|
|
log.debug("admin revoke group messageId={} groupId={}", saved.getId(), saved.getToId());
|
|
clusterPublisher.publish("/topic/group/" + saved.getToId(), saved);
|
|
}
|
|
return saved;
|
|
}
|
|
|
|
public Page<ImMessageEntity> history(
|
|
String appId,
|
|
String userId,
|
|
String toId,
|
|
ImMessageEntity.MsgType msgType,
|
|
String keyword,
|
|
LocalDateTime startTime,
|
|
LocalDateTime endTime,
|
|
int page,
|
|
int size) {
|
|
return messageRepository.findSingleConversationFiltered(
|
|
appId, userId, toId, msgType, keyword, startTime, endTime, PageRequest.of(page, size));
|
|
}
|
|
|
|
public Page<ImMessageEntity> groupHistory(
|
|
String appId,
|
|
String groupId,
|
|
String userId,
|
|
ImMessageEntity.MsgType msgType,
|
|
String keyword,
|
|
LocalDateTime startTime,
|
|
LocalDateTime endTime,
|
|
int page,
|
|
int size) {
|
|
ImGroupEntity group = groupService.get(groupId);
|
|
if (!groupService.memberIds(group).contains(userId)) {
|
|
throw new BusinessException(403, "不在群内");
|
|
}
|
|
Page<ImMessageEntity> pageResult = messageRepository.findGroupHistoryFiltered(
|
|
appId, groupId, msgType, keyword, startTime, endTime, PageRequest.of(page, size));
|
|
pageResult.forEach(message -> message.setGroupReadCount(
|
|
groupReadCount(appId, groupId, message.getCreatedAt(), message.getFromUserId())));
|
|
return pageResult;
|
|
}
|
|
|
|
public void syncReadReceipt(String appId, String readerId, String peerId, String chatType, LocalDateTime readAt) {
|
|
if (!ImMessageEntity.ChatType.SINGLE.name().equals(chatType) || readerId.equals(peerId)) {
|
|
return;
|
|
}
|
|
List<ImMessageEntity> messages = messageRepository
|
|
.findByAppIdAndFromUserIdAndToIdAndCreatedAtLessThanEqualOrderByCreatedAtAsc(
|
|
appId, peerId, readerId, readAt);
|
|
if (messages.isEmpty()) {
|
|
return;
|
|
}
|
|
for (ImMessageEntity message : messages) {
|
|
if (message.getStatus() == ImMessageEntity.MsgStatus.READ) {
|
|
continue;
|
|
}
|
|
message.setStatus(ImMessageEntity.MsgStatus.READ);
|
|
ImMessageEntity saved = messageRepository.save(message);
|
|
clusterPublisher.publish("/user/" + peerId + "/queue/messages", saved);
|
|
}
|
|
}
|
|
|
|
public void syncGroupReadReceipt(String appId, String readerId, String groupId, LocalDateTime readAt) {
|
|
ImGroupEntity group = groupService.get(groupId);
|
|
if (!groupService.memberIds(group).contains(readerId)) {
|
|
return;
|
|
}
|
|
List<ImMessageEntity> messages = messageRepository
|
|
.findByAppIdAndToIdAndChatTypeAndCreatedAtLessThanEqualOrderByCreatedAtAsc(
|
|
appId, groupId, ImMessageEntity.ChatType.GROUP, readAt);
|
|
if (messages.isEmpty()) {
|
|
return;
|
|
}
|
|
for (ImMessageEntity message : messages) {
|
|
message.setGroupReadCount(groupReadCount(appId, groupId, message.getCreatedAt(), message.getFromUserId()));
|
|
clusterPublisher.publish("/topic/group/" + groupId, message);
|
|
}
|
|
}
|
|
|
|
public Page<ImMessageEntity> adminHistory(
|
|
String appId,
|
|
String userA,
|
|
String userB,
|
|
ImMessageEntity.MsgType msgType,
|
|
String keyword,
|
|
LocalDateTime startTime,
|
|
LocalDateTime endTime,
|
|
int page,
|
|
int size) {
|
|
return messageRepository.findSingleConversationFiltered(
|
|
appId, userA, userB, msgType, keyword, startTime, endTime, PageRequest.of(page, size));
|
|
}
|
|
|
|
public Page<ImMessageEntity> adminGroupHistory(
|
|
String appId,
|
|
String groupId,
|
|
ImMessageEntity.MsgType msgType,
|
|
String keyword,
|
|
LocalDateTime startTime,
|
|
LocalDateTime endTime,
|
|
int page,
|
|
int size) {
|
|
Page<ImMessageEntity> pageResult = messageRepository.findGroupHistoryFiltered(
|
|
appId, groupId, msgType, keyword, startTime, endTime, PageRequest.of(page, size));
|
|
pageResult.forEach(message -> message.setGroupReadCount(
|
|
groupReadCount(appId, groupId, message.getCreatedAt(), message.getFromUserId())));
|
|
return pageResult;
|
|
}
|
|
|
|
public List<ImMessageRepository.ConversationSummary> conversations(String appId, String userId, int size) {
|
|
return messageRepository.findConversations(appId, userId, size);
|
|
}
|
|
|
|
public List<ConversationView> conversationViews(String appId, String userId, int size) {
|
|
int fetchSize = Math.max(size * 3, size);
|
|
return messageRepository.findConversations(appId, userId, fetchSize).stream()
|
|
.map(summary -> toConversationView(appId, userId, summary))
|
|
.filter(Objects::nonNull)
|
|
.limit(size)
|
|
.toList();
|
|
}
|
|
|
|
private ConversationView toConversationView(
|
|
String appId,
|
|
String userId,
|
|
ImMessageRepository.ConversationSummary summary
|
|
) {
|
|
String targetId = summary.getTargetId();
|
|
String chatType = summary.getChatType();
|
|
var state = conversationStateService.find(appId, userId, targetId, chatType);
|
|
if (state != null && state.isHidden()) {
|
|
return null;
|
|
}
|
|
Page<ImMessageEntity> page = chatType.equals("GROUP")
|
|
? messageRepository.findGroupHistory(appId, targetId, PageRequest.of(0, 1))
|
|
: messageRepository.findSingleConversation(appId, userId, targetId, PageRequest.of(0, 1));
|
|
ImMessageEntity lastMessage = page.getContent().stream().findFirst().orElse(null);
|
|
LocalDateTime lastReadAt = state == null ? null : state.getLastReadAt();
|
|
long unreadCount = chatType.equals("GROUP")
|
|
? messageRepository.countUnreadGroupConversation(appId, userId, targetId, lastReadAt)
|
|
: messageRepository.countUnreadSingleConversation(appId, userId, targetId, lastReadAt);
|
|
return new ConversationView(
|
|
targetId,
|
|
chatType,
|
|
lastMessage != null ? conversationPreview(lastMessage) : null,
|
|
lastMessage != null ? lastMessage.getMsgType().name() : null,
|
|
toEpochMillis(lastMessage != null ? lastMessage.getCreatedAt() : summary.getLastTime()),
|
|
(int) unreadCount,
|
|
state != null && state.isMuted(),
|
|
state != null && state.isPinned()
|
|
);
|
|
}
|
|
|
|
private long toEpochMillis(LocalDateTime time) {
|
|
return time == null ? 0L : time.toInstant(ZoneOffset.UTC).toEpochMilli();
|
|
}
|
|
|
|
private String buildPushPayload(ImMessageEntity message) {
|
|
try {
|
|
return objectMapper.writeValueAsString(Map.of(
|
|
"messageId", message.getId(),
|
|
"appId", message.getAppId(),
|
|
"fromUserId", message.getFromUserId(),
|
|
"toId", message.getToId(),
|
|
"chatType", message.getChatType().name(),
|
|
"msgType", message.getMsgType().name()
|
|
));
|
|
} catch (Exception e) {
|
|
return "{}";
|
|
}
|
|
}
|
|
|
|
private String conversationPreview(ImMessageEntity message) {
|
|
String content = message.getContent();
|
|
return switch (message.getMsgType()) {
|
|
case TEXT -> extractJsonField(content, "text").orElse(content);
|
|
case IMAGE -> "[图片]";
|
|
case AUDIO -> "[语音]";
|
|
case VIDEO -> "[视频]";
|
|
case FILE -> "[文件]" + extractJsonField(content, "name").map(name -> " " + name).orElse("");
|
|
case LOCATION -> "[位置]";
|
|
case CUSTOM -> "[自定义]";
|
|
case RICH_TEXT -> "[富文本]";
|
|
case CALL_AUDIO -> "[语音通话]";
|
|
case CALL_VIDEO -> "[视频通话]";
|
|
case FORWARD -> "[转发]";
|
|
case QUOTE -> extractJsonField(content, "text").orElse("[引用]");
|
|
case MERGE -> extractJsonField(content, "title").orElse("[合并转发]");
|
|
case REVOKED -> "[消息已撤回]";
|
|
case NOTIFY -> extractJsonField(content, "content").orElse("[通知]");
|
|
default -> content;
|
|
};
|
|
}
|
|
|
|
private int groupReadCount(String appId, String groupId, LocalDateTime createdAt, String senderId) {
|
|
ImGroupEntity group = groupService.get(groupId);
|
|
int count = 0;
|
|
for (String memberId : groupService.memberIds(group)) {
|
|
if (memberId.equals(senderId)) {
|
|
count += 1;
|
|
continue;
|
|
}
|
|
var state = conversationStateService.find(appId, memberId, groupId, ImMessageEntity.ChatType.GROUP.name());
|
|
if (state != null && state.getLastReadAt() != null && !state.getLastReadAt().isBefore(createdAt)) {
|
|
count += 1;
|
|
}
|
|
}
|
|
return Math.max(count, 1);
|
|
}
|
|
|
|
private java.util.Optional<String> extractJsonField(String content, String field) {
|
|
try {
|
|
var node = objectMapper.readTree(content);
|
|
if (node.hasNonNull(field)) {
|
|
String value = node.get(field).asText();
|
|
if (!value.isBlank()) {
|
|
return java.util.Optional.of(value);
|
|
}
|
|
}
|
|
} catch (Exception ignored) {
|
|
}
|
|
return java.util.Optional.empty();
|
|
}
|
|
|
|
@Async
|
|
protected void dispatchWebhooks(String appId, ImMessageEntity message) {
|
|
List<WebhookConfigEntity> webhooks = webhookRepository.findByAppIdAndEnabledTrue(appId);
|
|
if (webhooks.isEmpty()) return;
|
|
|
|
try {
|
|
String body = objectMapper.writeValueAsString(message);
|
|
HttpClient client = HttpClient.newHttpClient();
|
|
for (WebhookConfigEntity webhook : webhooks) {
|
|
try {
|
|
HttpRequest request = HttpRequest.newBuilder()
|
|
.uri(URI.create(webhook.getUrl()))
|
|
.header("Content-Type", "application/json")
|
|
.POST(HttpRequest.BodyPublishers.ofString(body))
|
|
.build();
|
|
client.send(request, HttpResponse.BodyHandlers.ofString());
|
|
} catch (Exception ignored) {
|
|
}
|
|
}
|
|
} catch (Exception ignored) {
|
|
}
|
|
}
|
|
}
|
