In enterprise Java projects, teams often need to integrate numerous component frameworks on top of Spring Boot, facing challenges such as compatibility differences, high learning curves, and inconsistent standards across teams — directly impacting system stability, performance, and security.

Houtu was built to solve exactly these problems. It encapsulates the most common infrastructure concerns in enterprise development, allowing developers to focus on business logic while delegating cross-cutting concerns — security, session management, caching, logging, encryption, rate limiting, and canary routing — to the framework.

• Zero-config startup — Spring Boot Starter style; auto-configured on dependency import, no manual setup required
• On-demand modules — Loosely coupled modules with all extension dependencies marked as optional; only include what you need
• Annotation-driven — Declarative APIs like @Lock, @CheckSession, @SecurityWatch, @AccessLog handle cross-cutting concerns with a single annotation
• Security built-in — Session management (JWT/Redis), request signing, replay protection, data encryption/decryption, RBAC access control
• Microservice-ready — Deep integration with the Spring Cloud ecosystem: full-link canary routing, weighted load balancing, enhanced service discovery, circuit breaking and rate limiting

┌─────────────────────────── Business Application Layer ──────────────────────────┐
│                              Your Business Code                                  │
└───────────────────────────────────┬─────────────────────────────────────────────┘
                                    │
┌───────────────────────────────────┼── Houtu Framework Layer ────────────────────────────────┐
│                                   │                                                         │
│  ┌─── Web & Security ──────┐  ┌─── Data & Cache ────────┐  ┌─── Observability ──────────┐  │
│  │ houtu-web               │  │ houtu-cache             │  │ houtu-access-log           │  │
│  │ houtu-web-security      │  │ houtu-data-security     │  │ houtu-actuator             │  │
│  │ houtu-web-swagger       │  └─────────────────────────┘  └────────────────────────────┘  │
│  └─────────────────────────┘                                                               │
│                                                                                             │
│  ┌─── Spring Cloud Enhancements ───────────────────────────────────────────────────────┐   │
│  │ spring-cloud-houtu-loadbalancer  (canary/weighted/auto-failover)                    │   │
│  │ spring-cloud-houtu-feign         (@AutoFeign auto-publish / exception propagation)  │   │
│  │ spring-cloud-houtu-discovery     (service health self-check / discovery enhancement)│   │
│  │ spring-cloud-houtu-sentinel      (circuit breaking / Nacos rule persistence)        │   │
│  └─────────────────────────────────────────────────────────────────────────────────────┘   │
│                                                                                             │
│  ┌─── Foundation Layer ────────────────────────────────────────────────────────────────┐   │
│  │ houtu-core (context/exceptions/i18n/thread propagation)  houtu-utils (crypto/HTTP)  │   │
│  └─────────────────────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────────────────────┘

Manage all versions uniformly via dependencyManagement in your project's pom.xml:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.github.lujiafa</groupId>
            <artifactId>houtu-dependencies</artifactId>
            <version>3.5.2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- Web enhancements: unified parameter resolution, response wrapping, exception handling -->
<dependency>
    <groupId>io.github.lujiafa</groupId>
    <artifactId>houtu-web</artifactId>
</dependency>

<!-- Distributed lock & cache enhancements -->
<dependency>
    <groupId>io.github.lujiafa</groupId>
    <artifactId>houtu-cache</artifactId>
</dependency>

<!-- Transparent encryption/decryption for sensitive data -->
<dependency>
    <groupId>io.github.lujiafa</groupId>
    <artifactId>houtu-data-security</artifactId>
</dependency>

Distributed Lock — concurrency control with a single annotation:

// key supports: empty (auto class.method), param name ("orderId"), SpEL ("#orderId", "#order.id")
@Lock(prefix = "order", key = "#orderId", waitTime = 3, leaseTime = 10)
public void processOrder(String orderId) {
    // Business logic; the framework handles locking and releasing automatically
}

Sensitive Data Encryption — transparent encryption at the DAO layer:

@SecurityWatch
public interface UserMapper {
    int insert(@SecurityParam User user); // Auto-encrypted on insert
    User selectById(Long id);             // Auto-decrypted on query
}

Session Authentication & Access Control:

@CheckSession
@RequiresPermission("user:manage")
@PostMapping("/user/update")
public ResponseData<Void> updateUser(UserForm form) {
    // The framework automatically validates the session and permissions
}

Access Logging — annotation-based or full interception:

@AccessLog
@PostMapping("/api/order")
public ResponseData<Order> createOrder(OrderForm form) {
    // Auto-recorded: POST|/api/order|192.168.1.1|Mozilla/5.0...|null|-|ResponseData XxController.createOrder(OrderForm)|{...}|{...}||56
}

For detailed documentation, see spring-cloud-houtu/README.md

The major and minor version numbers of the project align with Spring Boot, making it easy to locate compatible versions.

Note: Spring Cloud Alibaba spring-cloud-starter-alibaba-nacos-config has switched to the spring.config.import loading mechanism since version >= 2023.0.1.3. See the SCA official documentation for details.

All forms of contribution are welcome:

• Report Issues — Submit bugs or feature requests via Issues
• Submit Code — Fork the repo → create a feature branch → submit a Pull Request
• Improve Docs — Fix errors, add examples, or improve explanations
• Testing Feedback — Test in different environments and report compatibility findings

MIT License