# What Middleware Technologies Are Covered in the architect-awesome Repository?

> Explore the architect-awesome repository's catalog of nine key middleware technologies including web servers caching message queues RPC and database sharding solutions Find essential tools for system architecture

- Repository: [xingshaocheng/architect-awesome](https://github.com/xingshaocheng/architect-awesome)
- Tags: overview
- Published: 2026-03-05

---

**The architect-awesome repository catalogs nine essential middleware categories—including web servers, caching layers, message queues, RPC frameworks, and database sharding solutions—all indexed under the "中间件" (Middleware) section of the README.md file.**

The **architect-awesome** repository (maintained by `xingshaocheng/architect-awesome`) serves as a comprehensive knowledge base for system architects, documenting **middleware technologies** essential for building scalable, resilient back-end systems. All entries are organized within the [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md) file under the dedicated **"中间件"** heading, providing direct navigation to specific technology deep-dives.

## Web Servers and Reverse Proxies

The **Web Server** subsection of [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md) identifies six core technologies that act as HTTP(S) entry points. These components handle request routing, load balancing, TLS termination, and static content delivery.

- **Nginx** – High-performance reverse proxy and load balancer
- **OpenResty** – Lua-embedded web platform extending Nginx
- **Tengine** – Alibaba's Nginx distribution optimized for large-scale sites
- **Apache Httpd** – Versatile open-source HTTP server
- **Tomcat** – Servlet container for Java web applications
- **Jetty** – Lightweight embedded web server

## Caching Strategies and Technologies

According to the **缓存** (Cache) section in [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md), the repository organizes caching **middleware technologies** into three architectural layers. These solutions reduce database load and minimize latency by storing frequently accessed data close to consumers.

The documented categories include:

- **本地缓存** (Local caching) – In-process storage for single-node optimization
- **客户端缓存** (Client caching) – Browser and application-level cache control
- **服务端缓存** (Server-side caching) – Distributed storage including:
  - **Web caching** – HTTP cache proxies
  - **Memcached** – Distributed memory object caching system
  - **Redis** – In-memory data structure store with persistence options
  - **Tair** – Alibaba's distributed key/value storage system

## Message Queues and Event Streaming

The **消息队列** (Message Queue) section documents eight solutions that enable asynchronous communication and service decoupling. These **middleware technologies** span enterprise messaging platforms to high-throughput event streaming systems.

Specific technologies listed:

- **RabbitMQ** – AMQP-compliant message broker
- **RocketMQ** – Alibaba's distributed messaging and streaming platform
- **ActiveMQ** – Multi-protocol JMS messaging server
- **Kafka** – Distributed event streaming platform for high-volume data pipelines
- **ZeroMQ** – Lightweight messaging kernel for high-performance asynchronous I/O
- **Redis message push** – Pub/sub messaging capabilities using Redis
- **Message bus** – Enterprise service bus architectural patterns
- **Message ordering** – Strategies for guaranteeing event sequence

## RPC Frameworks for Service Communication

The **RPC** subsection covers three high-performance **remote procedure call** frameworks that facilitate binary communication between distributed services. These tools provide language-agnostic interfaces with superior performance characteristics compared to REST/HTTP.

Documented frameworks include:

- **Dubbo** – Alibaba's high-performance RPC framework with built-in service discovery
- **Thrift** – Facebook's scalable cross-language service development framework
- **gRPC** – Google's HTTP/2-based RPC framework using Protocol Buffers

## Database Middleware

For data layer scalability, the repository documents **ShardingJdbc** within the **数据库中间件** (Database Middleware) section of [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md). This technology implements database sharding patterns to split logical databases across multiple physical nodes.

Key capabilities include:

- SQL routing to appropriate database shards based on sharding keys
- Read/write splitting for master-slave replication topologies
- Distributed transaction management across multiple data sources

## Infrastructure and Operational Middleware

Beyond core communication and data layers, [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md) catalogs four additional **middleware technologies** critical for production operations.

### Job Scheduling

The **Scheduler** category distinguishes between **单机定时调度** (single-node scheduling) and **分布式定时调度** (distributed scheduling) for executing recurring tasks across compute clusters.

### Log Systems

The **日志系统** (Log System) section addresses **日志搜集** (log collection) strategies for centralized observability, parsing, and storage in distributed environments.

### Configuration Centers

Reference entries for **配置中心** (Configuration Center) describe centralized storage mechanisms for dynamic application configuration accessed by multiple services at runtime.

### API Gateways

The **API 网关** (API Gateway) entry documents unified façades responsible for routing, authentication, rate-limiting, and protocol translation.

## Practical Configuration Examples

While the repository focuses on architectural guidance rather than implementation code, typical configuration patterns for key **middleware technologies** align with the following examples.

### Nginx as Reverse Proxy

```nginx

# /etc/nginx/conf.d/app.conf

upstream backend {
    server 127.0.0.1:8080;
    keepalive 16;
}
server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

```

This configuration demonstrates the **Nginx** reverse proxy pattern documented in the repository, terminating client connections and forwarding requests to backend services.

### Redis Caching Implementation

```java
import redis.clients.jedis.Jedis;

public class RedisCache {
    private final Jedis jedis = new Jedis("localhost", 6379);

    public void put(String key, String value, int ttlSeconds) {
        jedis.setex(key, ttlSeconds, value);
    }

    public String get(String key) {
        return jedis.get(key);
    }
}

```

This Java implementation illustrates **Redis** usage for server-side caching as referenced in the **缓存** section.

### RabbitMQ Event Publishing

```java
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;

@Service
public class OrderEventProducer {
    private final RabbitTemplate rabbitTemplate;

    public OrderEventPublisher(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void publishOrderCreated(String orderId) {
        MessageProperties props = new MessageProperties();
        props.setHeader("eventType", "order.created");
        Message msg = new Message(orderId.getBytes(), props);
        rabbitTemplate.send("order.exchange", "order.created", msg);
    }
}

```

This Spring AMQP example shows asynchronous messaging with **RabbitMQ**, matching the **消息队列** documentation.

### Dubbo Service Exposure

```java
// Service interface definition
public interface OrderService {
    Order getOrder(String orderId);
}

```

```xml
<!-- Dubbo provider configuration -->
<dubbo:application name="order-provider"/>
<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
<dubbo:protocol name="dubbo" port="20880"/>
<bean id="orderService" class="com.example.OrderServiceImpl"/>
<dubbo:service interface="com.example.OrderService" ref="orderService"/>

```

This XML configuration exposes services via the **Dubbo** RPC framework as cataloged in the repository.

### Sharding-JDBC Configuration

```yaml
spring:
  shardingsphere:
    datasource:
      names: ds0, ds1
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        jdbc-url: jdbc:mysql://localhost:3306/db0
        username: root
        password: password
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        jdbc-url: jdbc:mysql://localhost:3306/db1
    sharding:
      tables:
        t_order:
          actual-data-nodes: ds${0..1}.t_order_${0..1}
          table-strategy:
            inline:
              sharding-column: user_id
              algorithm-expression: t_order_${user_id % 2}

```

This YAML configuration demonstrates **ShardingJdbc** database middleware routing queries to sharded tables based on the `user_id` column.

## Summary

The **architect-awesome** repository provides systematic coverage of **middleware technologies** across nine architectural domains:

- **Web servers** including Nginx, OpenResty, Tengine, Apache Httpd, Tomcat, and Jetty for HTTP traffic management
- **Caching solutions** spanning local, client-side, and server-side layers with Redis, Memcached, and Tair
- **Message queues** such as Kafka, RabbitMQ, RocketMQ, ActiveMQ, and ZeroMQ for asynchronous communication
- **RPC frameworks** including Dubbo, gRPC, and Thrift for high-performance service calls
- **Database middleware** specifically ShardingJdbc for horizontal data partitioning
- **Job schedulers** for both standalone and distributed task execution
- **Log collection systems** for centralized observability
- **Configuration centers** for dynamic settings management
- **API gateways** for unified access control and protocol translation

## Frequently Asked Questions

### What middleware technologies are documented in the architect-awesome repository?

According to the [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md) **"中间件"** section in `xingshaocheng/architect-awesome`, the repository documents nine categories: web servers (Nginx, Tomcat, Jetty), caching (Redis, Memcached, Tair), message queues (Kafka, RabbitMQ, RocketMQ), RPC frameworks (Dubbo, gRPC, Thrift), database middleware (ShardingJdbc), schedulers, log systems, configuration centers, and API gateways.

### Where are the middleware entries located in the repository?

All **middleware technologies** reside in the [`README.md`](https://github.com/xingshaocheng/architect-awesome/blob/main/README.md) file at the repository root, organized under the **"中间件"** (Middleware) heading with subsections for **Web Server**, **缓存** (Cache), **消息队列** (Message Queue), **RPC**, **数据库中间件** (Database Middleware), **日志系统** (Log System), **配置中心** (Configuration Center), and **API 网关** (API Gateway).

### Does the repository cover both traditional enterprise and cloud-native middleware?

Yes, the catalog includes traditional enterprise solutions like **Apache Httpd**, **ActiveMQ**, and **Tomcat** alongside cloud-native technologies such as **Nginx**, **gRPC**, **Kafka**, and **RocketMQ**, providing architectural guidance for diverse infrastructure requirements.

### How does architect-awesome categorize caching solutions?

The **缓存** section organizes caching **middleware technologies** into three distinct tiers: **本地缓存** (local/in-process), **客户端缓存** (client-side/browser), and **服务端缓存** (server-side/distributed), with specific product listings including **Redis**, **Memcached**, **Tair**, and **Web caching** proxies.