This repository is a Spring Boot-based demo application for integrating with WeChat Pay APIs. It provides REST endpoints demonstrating various WeChat Pay functionalities including payment processing, refunds, enterprise payments, red packet distribution, and coupon handling for both V2 and V3 versions of the WeChat Pay API. The application uses the WxJava library to handle the actual communication with WeChat's servers. The architecture follows standard Spring Boot MVC patterns with controllers handling HTTP requests, delegating to the WxPayService from WxJava for business logic, and returning formatted responses. Configuration is managed through application.yml using Spring Boot's @ConfigurationProperties, with a dedicated configuration class setting up the WxJava service as a Spring bean. The project includes Swagger for API documentation and basic error handling via custom error pages. While the code demonstrates solid enterprise Java practices with proper dependency injection, configuration separation, and API documentation, it is primarily intended as a learning tool rather than a production-ready library. The controllers contain TODO comments indicating areas where users need to implement their own business logic, and some dependencies (particularly Springfox for Swagger) are outdated relative to current Spring Boot versions.
The 21-Points Health application is a full-stack health tracking system built with a Spring Boot backend and an Angular frontend. It allows users to register, log in, and track various health metrics including weight, blood pressure, and activity points (from exercises, meals, and alcohol). Users can set personal preferences such as weekly goals and weight units (kg/lb). The application provides data visualization through lists, calendars, and charts, and includes administrative features for user management. The architecture follows a standard monolithic pattern with a clear separation of concerns. The backend exposes a RESTful API secured with JWT authentication, uses Spring Data JPA for persistence with a PostgreSQL database (H2 for development), and integrates Elasticsearch for search capabilities. The frontend is a modular Angular application that consumes the API, implements reactive state management with RxJS, and uses Bootstrap for responsive styling. The application also includes internationalization (English and French), Docker Compose configurations for development dependencies, and monitoring setups with Prometheus and Grafana. While the application leverages the JHipster generator for much of its boilerplate, it contains several custom components that demonstrate good engineering practices. Notable among these are a custom Logback converter for handling multi-line log messages, a utility service for file operations (base64 encoding and blob downloading), and a pipe for formatting time durations. These components are relatively isolated and could be reused in other projects with minimal modification.
This is a full-stack web application starter kit combining Angular (frontend) and Spring Boot (backend) with JWT-based authentication. The system provides user registration, login, role-based access control (USER/ADMIN), and protected API endpoints. The frontend communicates with the backend via RESTful APIs, with authentication handled through JWT tokens stored in cookies. The architecture follows a standard client-server pattern with clear separation of concerns: Angular handles UI presentation and user interactions, while Spring Boot manages business logic, data persistence, and security. Key features include route guards for client-side protection, custom JWT filters for server-side authentication, and centralized service layers for API communication.
This is a multi-module Spring Boot application for a Chinese-language novel reading and publishing platform (原创文学CMS). It comprises four interconnected modules: novel-admin (back-office management with Layui/Shiro RBAC), novel-front (user-facing reader/author portal with JWT auth), novel-crawl (automated content ingestion from external novel sites), and novel-common (shared entities, mappers, utilities). The system provides full CRUD for books, chapters, comments, users, and payments; templated front-end themes (blue, green, orange, dark); Alipay/WeChat integration; AI-assisted writing via Spring AI (SiliconFlow); and a MyBatis-based data layer with Sharding-JDBC for sharding. While functionally rich and actively maintained, the codebase suffers from significant static asset duplication, mixed javax/jakarta imports, and multiple legacy third-party front-end libraries bundled directly.
This repository is the official Spring Boot getting started guide (gs-spring-boot). It provides a minimal web application that demonstrates Spring Boot's auto-configuration, embedded Tomcat, and actuator endpoints. The codebase consists of a single REST controller returning a static greeting string, a Spring Boot application class with a CommandLineRunner that lists all beans, and corresponding unit and integration tests. The complete variant includes Spring Boot Actuator for production-ready features. The repo serves purely as a tutorial scaffold, not a production-grade application. The architecture is a trivial monolith with no external services, database, or complex data flow. All source files are framework boilerplate generated or inspired by Spring Initializr. There are no reusable components or non-obvious patterns. The value lies in its documentation and as a starting point for learning Spring Boot. Despite its simplicity, the repository is actively maintained with up-to-date dependencies (Spring Boot 4.0.x, Kotlin 2.2.x, Gradle 9.3.x) and CI pipelines. It includes both Java and Kotlin implementations, and both Maven and Gradle build systems.
This repository provides a full-stack demonstration of a permission management system using Spring Boot for the backend and Vue.js for the frontend. Despite its name, it does not use Apache Shiro; instead, it implements a custom, annotation-based permission control via AOP (RequiresPermissions annotation and PermissionAspect) and token-based authentication using Caffeine local cache. The backend is a monolithic Spring Boot 2.3.10 application with MyBatis for database access, serving a REST API. The frontend is a Vue 2 application (based on vueAdmin-template) with dynamic routing and ElementUI, featuring a custom directive for button-level permission checks. The system supports multi-role users, role-based menu and permission assignment, and a clean separation of concerns between backend and frontend permission enforcement. The codebase is well-structured and serves as a clear reference for implementing RBAC-like permission systems in Java+Vue projects, though it is not intended for production use without significant hardening and updates.
This repository is a comprehensive collection of example applications for the Apache KIE ecosystem, specifically Kogito, Drools, and jBPM. It demonstrates how to build cloud-native business automation services using DMN decision models, PMML predictive models, DRL rules, and BPMN process orchestration. The examples are structured as runnable microservices for both Quarkus and Spring Boot runtimes, covering a wide range of capabilities including event-driven messaging with Kafka, persistence with PostgreSQL/MongoDB/Infinispan, security with Keycloak OIDC, monitoring with Prometheus/Grafana, and deployment on Kubernetes/OpenShift. The repository serves primarily as a learning and demonstration resource, not as a production library. It features high duplication across the two runtime stacks, with many near-identical examples maintained in parallel. The code is functional and follows standard Kogito patterns, but the emphasis is on showcasing features rather than providing reusable, production-grade components. Some examples use snapshot versions and older infrastructure configurations, indicating active development but also potential drift.
This repository is a comprehensive AI inference and application platform built primarily on Java (Spring Boot) and Vue.js. It provides a suite of SDKs for computer vision (face recognition, OCR, segmentation), NLP (text embedding, translation), and AIGC (Stable Diffusion, ControlNet). The architecture is modular, separating inference logic (SDKs) from application logic (Web Apps, Desktop Apps, API Platform). It utilizes Deep Java Library (DJL) for model inference, integrating PyTorch and ONNX Runtime backends. The system supports multimodal search (Face, Image, Code, Text) using vector databases like Milvus. Hybridity: While it contains AI research components (models, inference), the codebase is structured as a production-ready software platform with web interfaces, APIs, and desktop wrappers, rather than a research notebook collection. It functions as a monorepo containing multiple distinct Spring Boot applications and Vue.js frontends, each serving a specific AI task (e.g., face_search, image_search, aigc_image_gen).
mini-spring-cloud is an educational, simplified reimplementation of core Spring Cloud components, designed to help developers understand the underlying principles of service registration, discovery, client-side load balancing, declarative HTTP clients (Feign), and API gateway (Zuul). The codebase implements a custom lightweight registry called 'Tutu' and integrates with Netflix Ribbon, OpenFeign, and Netflix Zuul libraries. It follows Spring Cloud Commons abstractions and uses Spring Boot auto-configuration. The project is not intended for production use; it serves as a learning resource with minimal error handling, incomplete feature coverage (e.g., only POST mapping support in Feign contract), and no comprehensive test suite. The architecture is modular with separate Maven modules for each concern, and the code is clean and well-commented in Chinese. However, dependencies are somewhat outdated (Spring Cloud 2021.0.1, Ribbon 2.3.0, Zuul 1.3.1) and the project has not seen recent updates.
This is a large, sprawling collection of tutorial and demo projects authored by a single developer (blogger '程序员欣宸'). It covers dozens of technologies including Spring Boot internals, Flink, Kafka, gRPC, JavaCV/OpenCV, Kubernetes controllers, LangChain4j, JUnit 5, and more. Each subdirectory is an independent, self-contained demo typically with a single main class or test. The code is educational: full of Chinese comments, simplified logic, and hardcoded paths. While not a cohesive application, it serves as a rich reference for learning how to use specific frameworks and patterns. The quality is average overall—functional but boilerplate-heavy, with many outdated dependencies and duplicated code across projects.
Direct File is a full-stack, multi-service tax preparation and electronic filing system built by the IRS for federal and state tax returns. The architecture is a microservices monorepo with a Spring Boot Java backend (REST APIs, PDF generation, S3/SQS/SNS/KMS integration), a Scala.js fact-graph engine (declarative tax computation rules shared between JVM and JavaScript), a React/TypeScript frontend (Vite, USWDS, Redux, i18n), and supporting services for submission batching, status tracking, email notifications, and state tax authority integration. The fact-graph is the core innovation: a domain-specific declarative rule system using typed nodes (Dollar, Tin, Enum) and composable operators (Sum, Maximum, Switch, Placeholder) to encode the Internal Revenue Code as a knowledge graph that can be evaluated both server-side and client-side. The frontend uses a declarative flow configuration (JSX trees of Screen, Gate, CollectionLoop) driven by fact-graph state. The system integrates with MeF (Modernized e-File) for submission, SADI for identity verification, and a State API for exporting federal data to third-party state filing tools. The repository is archived and no longer maintained, so it represents a frozen snapshot of the 2024 tax season codebase with known deprecations and hardcoded constants.
This repository is a curated collection of Java interview questions and answers, organized by topics such as Core Java, Collections, Concurrency, Spring, Hibernate, SQL, and more. It also includes several small, self-contained Java projects that demonstrate specific concepts: a custom Stream API implementation (custom-stream), a deadlock example (deadlock), a set of LeetCode algorithm solutions (leetcode-221-maximal-square), and a flawed code review snippet (review). The primary value is the extensive markdown documentation with links to external resources, making it a useful study aid for Java interview preparation. The code examples are educational but not production-grade; the custom-stream project is the most notable for illustrating the internal pipeline pattern of Java Streams. The repository is static and has not been actively updated in some time, though the content remains relevant for many core Java topics.
This repository is a historical demo application showcasing JWT-based authentication and authorization in a Spring WebFlux reactive stack. It implements a custom security filter chain that first authenticates via HTTP Basic (returning a signed JWT) and then validates Bearer tokens on protected endpoints. The code uses Spring Boot 2.1.1, Java 8, and the Nimbus JOSE library for JWT signing and verification. The architecture is a simple monolith with in-memory user details and hardcoded secrets, intended for educational purposes rather than production use. The README explicitly states the project has been superseded by a modernized version (Spring Boot 4, Java 21, Spring Security 7) and is kept for historical reference. The code demonstrates key patterns: custom ServerAuthenticationSuccessHandler, functional bearer token converter, and a dummy ReactiveAuthenticationManager for stateless JWT authentication. However, it suffers from significant technical drift (outdated dependencies, Java 8, deprecated APIs) and lacks proper error handling, tests, and configurability.
This repository is primarily a learning resource: a Java developer roadmap presented as a PNG image and an editable Draw.io XML file. The only actual code is a trivial Main.java class that prints a welcome message when executed. There is no meaningful functionality, architecture, or data flow beyond this placeholder. The project serves as a reference guide for developers to explore Java ecosystem topics, but the codebase itself does not implement any of those topics.