AI超级智能体——AI恋爱大师应用后端开发

LoveAppConfig

▼
java
复制代码
import com.lzx.lzxaiagent.advisor.MyLoggerAdvisor;
import com.lzx.lzxaiagent.advisor.SensitiveWordAdvisor;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;
import org.springframework.ai.chat.memory.MessageWindowChatMemory;
import org.springframework.ai.chat.memory.repository.jdbc.JdbcChatMemoryRepository;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LoveAppConfig {

    private static final String SYSTEM_PROMPT = "你叫林微，扮演深耕恋爱心理领域的专家。开场向用户表明身份，告知用户可倾诉恋爱难题。围绕单身、恋爱、已婚三种状态提问：单身状态询问社交圈拓展及追求心仪对象的困扰；恋爱状态询问沟通、习惯差异引发的矛盾；已婚状态询问家庭责任与亲属关系处理的问题。引导用户详述事情经过、对方反应及自身想法，以便给出专属解决方案。\n";

//    private static final String SYSTEM_PROMPT = "you are a helpful assistant.";

    @Bean
    public ChatClient chatClient(ChatModel dashscopeChatModel, JdbcChatMemoryRepository chatMemoryRepository) {

        // 创建一个消息窗口的聊天记忆
        MessageWindowChatMemory messageWindowChatMemory = MessageWindowChatMemory.builder()
                .chatMemoryRepository(chatMemoryRepository)
                .maxMessages(10)
                .build();
        MessageChatMemoryAdvisor chatMemoryAdvisor = MessageChatMemoryAdvisor.builder(messageWindowChatMemory).build();

        // 创建一个 ChatClient 对象，并设置默认的 system prompt 和默认的 ChatMemoryAdvisor
        ChatClient chatClient = ChatClient.builder(dashscopeChatModel)
                .defaultSystem(SYSTEM_PROMPT)
                .defaultAdvisors(
                        chatMemoryAdvisor,
                        new SensitiveWordAdvisor(),
                        new MyLoggerAdvisor())
                .build();
        return chatClient;
    }
}

LoveAppController

▼
java
复制代码
import com.lzx.lzxaiagent.sevice.LoveAppService;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

@RestController
@Slf4j
@RequestMapping("/love")
@Tag(name = "恋爱应用", description = "恋爱相关的API接口")
public class LoveAppController {

    @Autowired
    private LoveAppService loveAppService;

    @GetMapping("/chat")
    public Flux<ServerSentEvent<String>> doChat(String chatId, String userMessage) {
        log.info("💬 收到聊天请求 - chatId: {}, 消息: {}", chatId, userMessage);
        Flux<ServerSentEvent<String>> aiResponse = loveAppService.doChat(chatId, userMessage);
        return aiResponse;
    }
}

LoveAppService

▼
java
复制代码
import org.springframework.http.codec.ServerSentEvent;
import reactor.core.publisher.Flux;

public interface LoveAppService {
    Flux<ServerSentEvent<String>> doChat(String chatId, String userMessage);
}

LoveAppServiceImpl

▼
java
复制代码
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
@Slf4j
public class LoveAppServiceImpl implements LoveAppService{

    @Resource
    private ChatClient chatClient;

    @Override
    public Flux<ServerSentEvent<String>> doChat(String chatId, String userMessage) {

        return chatClient.prompt()
                .user(userMessage)
                .advisors(advisor -> advisor.param(ChatMemory.CONVERSATION_ID, chatId))
                .stream()
                .content()
                .map(content -> ServerSentEvent.<String>builder()
                        .data(content)
                        .event("message")
                        .build())
                .concatWith(doneEvent())
                .onErrorResume(this::errorEvent);
    }

    // 辅助方法:创建done事件
    private Flux<ServerSentEvent<String>> doneEvent() {
        return Flux.just(
                ServerSentEvent.<String>builder()
                        .data("[DONE]")
                        .event("done")
                        .build()
        );
    }

    // 辅助方法:创建error事件
    private Flux<ServerSentEvent<String>> errorEvent(Throwable error) {
        return Flux.just(
                ServerSentEvent.<String>builder()
                        .data("抱歉，服务暂时不可用")
                        .event("error")
                        .build()
        );
    }
}