<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-deepseek</artifactId>
    <version>1.0.0</version>
</dependency>

@SpringBootApplication
@EnableSpringAI
public class MySpringAiApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringAiApplication.class, args);
    }
}

spring:
  ai:
    deepseek:
      api-key: your_deepseek_api_key
      base-url: https://api.deepseek.com/v1

@Configuration
public class AiClientConfig {
    @Bean
    public DeepSeekClient deepSeekClient(DeepSeekClientProperties properties) {
        return new DeepSeekClient(properties.getApiKey());
    }
}

@Service
public class MyAiService {
    private final DeepSeekClient deepSeekClient;

    public MyAiService(DeepSeekClient deepSeekClient) {
        this.deepSeekClient = deepSeekClient;
    }

    public String generateText(String prompt) {
        // 使用DeepSeekClient進(jìn)行文本生成
        return deepSeekClient.generate(prompt).getGeneratedText();
    }
}

public class SummaryService {
    private static final String SUMMARY_TEMPLATE = "請(qǐng)總結(jié)以下內(nèi)容：{text}";

    public String summarizeText(String text) {
        PromptTemplate promptTemplate = new PromptTemplate(SUMMARY_TEMPLATE);
        // 使用模板生成具體的提示詞
        String prompt = promptTemplate.render("text", text);
        // 這里假設(shè)已經(jīng)有一個(gè)AiClient實(shí)例用于生成文本
        String summary = aiClient.generate(prompt).getGeneratedText();
        return summary;
    }
}

@Component
public class JsonMessageConverter implements MessageConverter {
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public Message toMessage(String json) {
        try {
            // 假設(shè)JSON結(jié)構(gòu)中有一個(gè)"content"字段表示用戶(hù)輸入
            JsonInput jsonInput = objectMapper.readValue(json, JsonInput.class);
            return new UserMessage(jsonInput.getContent());
        } catch (Exception e) {
            throw new RuntimeException("Failed to convert JSON to Message", e);
        }
    }

    @Override
    public String fromMessage(Message message) {
        try {
            JsonOutput jsonOutput = new JsonOutput(message.getContent());
            return objectMapper.writeValueAsString(jsonOutput);
        } catch (Exception e) {
            throw new RuntimeException("Failed to convert Message to JSON", e);
        }
    }

    private static class JsonInput {
        private String content;

        public String getContent() {
            return content;
        }

        public void setContent(String content) {
            this.content = content;
        }
    }

    private static class JsonOutput {
        private String result;

        public JsonOutput(String result) {
            this.result = result;
        }

        public String getResult() {
            return result;
        }
    }
}

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

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
           .csrf().disable()
           .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
           .and()
           .authorizeRequests()
                .antMatchers("/ai/**").authenticated()
                .anyRequest().permitAll()
           .and()
           .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() throws Exception {
        return new JwtAuthenticationFilter();
    }
}

public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private static final String HEADER_STRING = "Authorization";
    private static final String TOKEN_PREFIX = "Bearer ";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String header = request.getHeader(HEADER_STRING);
        if (header == null ||!header.startsWith(TOKEN_PREFIX)) {
            filterChain.doFilter(request, response);
            return;
        }
        String token = header.replace(TOKEN_PREFIX, "");
        Claims claims = Jwts.parser().setSigningKey("your_secret_key").parseClaimsJws(token).getBody();
        String username = claims.getSubject();
        List<String> roles = (List<String>) claims.get("roles");
        List<SimpleGrantedAuthority> authorities = roles.stream()
               .map(SimpleGrantedAuthority::new)
               .collect(Collectors.toList());
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, null, authorities);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        filterChain.doFilter(request, response);
    }
}

@Component
public class DiscountService {
    @AiFunction(
        name = "calculateDiscountPrice",
        description = "計(jì)算商品的折扣價(jià)格，輸入商品原價(jià)和折扣率，返回折扣后的價(jià)格"
    )
    public double calculateDiscountPrice(double originalPrice, double discountRate) {
        return originalPrice * (1 - discountRate);
    }
}

spring:
  ai:
    deepseek:
      client:
        connection-timeout: 5000
        read-timeout: 10000
        max-retries: 3

@Configuration
public class DeepSeekClientConfig {
    @Bean
    public DeepSeekClient deepSeekClient(DeepSeekClientProperties properties) {
        DeepSeekClient client = new DeepSeekClient(properties.getApiKey());
        client.setConnectionTimeout(properties.getConnectionTimeout());
        client.setReadTimeout(properties.getReadTimeout());
        client.setMaxRetries(properties.getMaxRetries());
        return client;
    }
}

@Service
public class ReactiveAiTextGenerationService {
    private final ReactiveDeepSeekClient reactiveDeepSeekClient;

    public ReactiveAiTextGenerationService(ReactiveDeepSeekClient reactiveDeepSeekClient) {
        this.reactiveDeepSeekClient = reactiveDeepSeekClient;
    }

    public Mono<String> generateText(String promptText) {
        Prompt prompt = new Prompt(new UserMessage(promptText));
        return reactiveDeepSeekClient.generate(prompt)
               .map(response -> response.getGeneratedText());
    }
}

@Service
public class ChatService {
    private final AiMessageHistory messageHistory;
    private final DeepSeekClient deepSeekClient;

    public ChatService(DeepSeekClient deepSeekClient, AiMessageHistory messageHistory) {
        this.deepSeekClient = deepSeekClient;
        this.messageHistory = messageHistory;
    }

    public String chat(String userInput) {
        UserMessage userMessage = new UserMessage(userInput);
        messageHistory.addMessage(userMessage);
        String response = deepSeekClient.generate(messageHistory.getMessages()).getGeneratedText();
        AiMessage aiResponse = new AiMessage(response);
        messageHistory.addMessage(aiResponse);
        return response;
    }
}

public class CustomAiResponseHandler implements AiResponseHandler {
    private final List<String> partialTexts = new ArrayList<>();

    @Override
    public void handleResponse(AiResponse response) {
        String partialText = response.getGeneratedText();
        partialTexts.add(partialText);
        System.out.println("接收到分段文本: " + partialText);
    }

    public String getFullText() {
        return String.join("", partialTexts);
    }
}

@Service
public class StreamingTextGenerationService {
    private final ReactiveDeepSeekClient reactiveDeepSeekClient;

    public StreamingTextGenerationService(ReactiveDeepSeekClient reactiveDeepSeekClient) {
        this.reactiveDeepSeekClient = reactiveDeepSeekClient;
    }

    public Mono<Void> generateStreamingText(String promptText, CustomAiResponseHandler handler) {
        Prompt prompt = new Prompt(new UserMessage(promptText));
        return reactiveDeepSeekClient.generateStreaming(prompt)
                .doOnNext(handler::handleResponse)
                .then();
    }
}