Technology Stack

// Using records for immutable payloads
record AnalyzeTaskPayload(Long resumeId, String content) {}

// Virtual threads for consumer pools (Spring Boot 4.0 auto-configures)
@Bean
ExecutorService executor() {
    return Executors.newVirtualThreadPerTaskExecutor();
}

// From build.gradle
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

# gradle/libs.versions.toml
[versions]
spring-boot = "4.0.1"
spring-ai = "2.0.0-M1"
tika = "2.9.2"
lombok = "1.18.36"
redisson = "4.0.0"
mapstruct = "1.6.3"
aws-sdk = "2.29.51"
itext = "8.0.5"

[libraries]
tika-core = { module = "org.apache.tika:tika-core", version.ref = "tika" }
tika-parsers = { module = "org.apache.tika:tika-parsers-standard-package", version.ref = "tika" }

-- Similarity search query (Spring AI generates this)
SELECT id, content, metadata,
       1 - (embedding <=> '[0.1, 0.2, ...]') AS similarity
FROM vector_store
WHERE 1 - (embedding <=> '[0.1, 0.2, ...]') > 0.7
ORDER BY embedding <=> '[0.1, 0.2, ...]'
LIMIT 5;

@Entity
@Table(name = "resumes")
public class ResumeEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String fileName;
    
    @Enumerated(EnumType.STRING)
    private AsyncTaskStatus analyzeStatus;  // PENDING/PROCESSING/COMPLETED/FAILED
    
    @Column(columnDefinition = "TEXT")
    private String content;
    
    @Column(columnDefinition = "TEXT")
    private String analyzeError;
    
    // Analysis results stored as JSON
    @Type(JsonType.class)
    @Column(columnDefinition = "jsonb")
    private ResumeAnalysisResponse analysis;
}

public interface ResumeRepository extends JpaRepository<ResumeEntity, Long> {
    // Custom query methods
    List<ResumeEntity> findByAnalyzeStatus(AsyncTaskStatus status);
    
    @Query("SELECT r FROM ResumeEntity r WHERE r.contentHash = :hash")
    Optional<ResumeEntity> findByContentHash(@Param("hash") String hash);
}

// Create consumer group (app/infrastructure/redis/RedisService.java:255)
public void createStreamGroup(String streamKey, String groupName) {
    RStream<String, String> stream = redissonClient.getStream(streamKey, StringCodec.INSTANCE);
    stream.createGroup(StreamCreateGroupArgs.name(groupName).makeStream());
}

// Producer sends task (app/common/async/AbstractStreamProducer.java:22)
protected void sendTask(T payload) {
    String messageId = redisService.streamAdd(
        streamKey(),
        buildMessage(payload),
        AsyncTaskStreamConstants.STREAM_MAX_LEN  // 1000 messages
    );
}

// Consumer processes task with blocking read (app/infrastructure/redis/RedisService.java:222)
public boolean streamConsumeMessages(
        String streamKey, String groupName, String consumerName,
        int count, long blockTimeoutMs,
        StreamMessageProcessor processor) {
    
    RStream<String, String> stream = redissonClient.getStream(streamKey, StringCodec.INSTANCE);
    
    // BLOCK parameter offloads waiting to Redis server
    Map<StreamMessageId, Map<String, String>> messages = stream.readGroup(
        groupName, consumerName,
        StreamReadGroupArgs.neverDelivered()
            .count(count)
            .timeout(Duration.ofMillis(blockTimeoutMs))  // 1000ms
    );
    
    messages.forEach((id, data) -> processor.process(id, data));
    return !messages.isEmpty();
}

implementation "com.itextpdf:itext-core:8.0.5"
implementation "com.itextpdf:font-asian:8.0.5"  // Chinese font support

@Service
public class PdfExportService {
    private final PdfFont chineseFont;
    
    @PostConstruct
    public void init() throws IOException {
        // Load custom font from resources
        InputStream fontStream = getClass()
            .getResourceAsStream("/fonts/ZhuqueFangsong-Regular.ttf");
        this.chineseFont = PdfFontFactory.createFont(
            fontStream.readAllBytes(),
            PdfEncodings.IDENTITY_H  // Unicode encoding
        );
    }
    
    public byte[] generateResumeAnalysisPdf(ResumeAnalysis analysis) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PdfWriter writer = new PdfWriter(baos);
        PdfDocument pdf = new PdfDocument(writer);
        Document document = new Document(pdf);
        
        // Add styled content
        document.add(new Paragraph("简历分析报告")
            .setFont(chineseFont)
            .setFontSize(20)
            .setBold());
        
        // Add analysis sections...
        
        document.close();
        return baos.toByteArray();
    }
}

// src/types/resume.ts
export interface ResumeAnalysis {
  id: number;
  fileName: string;
  analyzeStatus: 'PENDING' | 'PROCESSING' | 'COMPLETED' | 'FAILED';
  overallScore: number;
  skills: string[];
  experience: ExperienceItem[];
}

export interface ExperienceItem {
  company: string;
  position: string;
  duration: string;
  description: string;
}

// vite.config.ts
export default defineConfig({
  plugins: [react()],
  server: {
    port: 5173,
    proxy: {
      '/api': {
        target: 'http://localhost:8080',
        changeOrigin: true
      }
    }
  }
});

import { Virtuoso } from 'react-virtuoso';

<Virtuoso
  data={messages}
  itemContent={(index, message) => (
    <ChatMessage key={message.id} message={message} />
  )}
  followOutput="smooth"  // Auto-scroll to bottom
  initialTopMostItemIndex={messages.length - 1}
/>

// src/api/client.ts
import axios from 'axios';

const apiClient = axios.create({
  baseURL: '/api',
  timeout: 30000
});

// Request interceptor
apiClient.interceptors.request.use(config => {
  // Add auth token if exists
  const token = localStorage.getItem('token');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

// Response interceptor
apiClient.interceptors.response.use(
  response => response.data,
  error => {
    if (error.response?.status === 401) {
      // Redirect to login
    }
    return Promise.reject(error);
  }
);