Measuring Website Performance Metrics

Response Time: Total duration from request initiation to response reception.

Concurrency: Number of simultaneous requests a system can handle.

Concurrent Connections: Total TCP connections established between clients and server per second.

Queries Per Second (QPS): Requests processed per second.

Concurrent Users: Users active within a specific timeframe.

Throughput: Requests processed per unit time.

- QPS: Queries per second
- TPS: Transactions per second
- A transaction encompasses client request transmission and server response.
- Page visits generate one TPS but multiple QPS if the page triggers additional requests.
- Relationship: QPS ≥ Concurrent Connections ≥ TPS

Dubbo Framework Fundamentals

Dubbo is an open-source Java RPC framework by Alibaba, designed for high-performance distributed service invocation and SOA governance.

Key Roles:

• Provider: Service provider
• Container: Runtime environment
• Consumer: Service consumer
• Registry: Service discovery registry
• Monitor: Call metrics tracking center

Advanced Dubbo Features

Dubbo Admin

• Web-based management interface
• Manages providers/consumers via registry
• Configures routing, dynamic settings, degradation, access control, weights, and load balancing
• Uses Vue frontend and Spring Boot backend

Serialization

1. Serialization/deserialization is internallly handled
2. POJOs must implement Serializable
3. Shared POJO module recommended for provider-consumer consistency

Address Caching

• Consumers cache provider addresses after first call
• Registry notifies consumers of address changes

Timeouts

Prevents thread buildup during service unavailability. Sets maximum wait duration before connection termination.

// Default timeout: 1000ms
@Service(timeout = 3000, retries = 0)

Retries

Automatically retries failed requests due to transient errors. Configured via retries attribute (default: 2).

@Service(timeout = 3000, retries = 2)

Multi-Version Support (Canary Release)

Deploys new features incrementally using version attribute.

Provider:

@Service(version = "v2.0")
public class UserServiceImpl implements UserService { ... }

Consumer:

@Reference(version = "v2.0")
private UserService userService;

Load Balancing Strategies

1. Random (default): Weight-based random selection
2. RoundRobin: Weight-based rotation
3. LeastActive: Select least busy provider
4. ConsistentHash: Parameter-consistent routing

Provider Weight Configuration:

@Service(weight = 100)
public class UserServiceImpl implements UserService { ... }

Consumer Strategy Selection:

@Reference(loadbalance = "random") // Options: roundrobin, leastactive, consistenthash
private UserService userService;

Cluster Fault Tolerance

• Failover: Retry others on failure (default, retries configurable)
• Failfast: Fail immediately without retry
• Failsafe: Ignore errors, return empty result
• Failback: Record failures for delayed retry
• Forking: Concurrently call multiple providers
• Broadcast: Invoke all providers, fail if any errors

Consumer Configuration:

@Reference(cluster = "failover")
private UserService userService;

Service Degradation

Releases resources during high load by simplifying non-critical services.

Strategies:

• mock=force:return null: Bypass remote calls, return null
• mock=fail:return null: Return null on failure without exception

Consumer Configuration:

@Reference(mock = "force:return null")
private UserService userService;