Java负载均衡案例如何实现

本文目录导读：

1. 基于Nginx的反向代理负载均衡
2. Spring Cloud LoadBalancer实现
3. 基于Ribbon的负载均衡（Spring Cloud Netflix）
4. Dubbo的负载均衡
5. 简单的Java实现
6. 生产环境最佳实践

我来介绍几种常见的Java负载均衡实现案例,从简单到复杂逐步说明。

基于Nginx的反向代理负载均衡

配置示例

# nginx.conf
upstream backend_servers {
    # 负载均衡策略：轮询（默认）
    server 127.0.0.1:8081;
    server 127.0.0.1:8082;
    server 127.0.0.1:8083 weight=3;  # 权重配置
    # 其他策略示例
    # ip_hash;  # IP哈希
    # least_conn;  # 最少连接
}
server {
    listen 80;
    server_name example.com;
    location / {
        proxy_pass http://backend_servers;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Spring Cloud LoadBalancer实现

添加依赖

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

RestTemplate配置

@Configuration
public class LoadBalancerConfig {
    @Bean
    @LoadBalanced  // 添加负载均衡能力
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

服务调用

@Service
public class OrderService {
    @Autowired
    private RestTemplate restTemplate;
    public String getProductInfo(String productId) {
        // 直接使用服务名调用，自动负载均衡
        String url = "http://product-service/api/products/" + productId;
        return restTemplate.getForObject(url, String.class);
    }
}

自定义负载均衡策略

@Component
public class CustomLoadBalancerConfiguration {
    @Bean
    public ReactorLoadBalancer<ServiceInstance> customLoadBalancer(
            Environment environment,
            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(
            loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class),
            name
        );
    }
}

基于Ribbon的负载均衡（Spring Cloud Netflix）

配置方式

# application.yml
product-service:
  ribbon:
    listOfServers: localhost:8081,localhost:8082,localhost:8083
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule  # 随机策略
    ConnectTimeout: 3000
    ReadTimeout: 60000

自定义策略

public class CustomRule extends AbstractLoadBalancerRule {
    private int currentIndex = 0;
    private int currentWeight = 0;
    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // 初始化配置
    }
    @Override
    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        if (lb == null) {
            return null;
        }
        List<Server> servers = lb.getAllServers();
        if (servers.isEmpty()) {
            return null;
        }
        // 自定义选择逻辑（轮询加权）
        return getNextServer(servers);
    }
    private synchronized Server getNextServer(List<Server> servers) {
        // 简单的加权轮询
        Server server = servers.get(currentIndex % servers.size());
        currentIndex++;
        return server;
    }
}

Dubbo的负载均衡

配置方式

<!-- dubbo-consumer.xml -->
<dubbo:reference id="orderService" 
                 interface="com.example.OrderService"
                 loadbalance="roundrobin" />  <!-- 轮询策略 -->

自定义负载均衡算法

public class CustomLoadBalance extends AbstractLoadBalance {
    @Override
    protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, 
                                       URL url, 
                                       Invocation invocation) {
        int length = invokers.size();
        int totalWeight = 0;
        boolean sameWeight = true;
        int firstWeight = getWeight(invokers.get(0), invocation);
        // 计算总权重
        for (int i = 0; i < length; i++) {
            int weight = getWeight(invokers.get(i), invocation);
            totalWeight += weight;
            if (sameWeight && weight != firstWeight) {
                sameWeight = false;
            }
        }
        // 加权随机选择
        if (totalWeight > 0 && !sameWeight) {
            int offset = ThreadLocalRandom.current().nextInt(totalWeight);
            for (int i = 0; i < length; i++) {
                offset -= getWeight(invokers.get(i), invocation);
                if (offset < 0) {
                    return invokers.get(i);
                }
            }
        }
        return invokers.get(ThreadLocalRandom.current().nextInt(length));
    }
}

简单的Java实现

轮询算法

public class RoundRobinLoadBalancer {
    private List<String> servers;
    private AtomicInteger index = new AtomicInteger(0);
    public RoundRobinLoadBalancer(List<String> servers) {
        this.servers = servers;
    }
    public String getServer() {
        if (servers.isEmpty()) {
            return null;
        }
        int currentIndex = index.getAndIncrement() % servers.size();
        return servers.get(currentIndex);
    }
}

加权随机算法

public class WeightedRandomLoadBalancer {
    private List<ServerNode> servers;
    private int totalWeight;
    public WeightedRandomLoadBalancer(List<ServerNode> servers) {
        this.servers = servers;
        this.totalWeight = servers.stream()
            .mapToInt(ServerNode::getWeight)
            .sum();
    }
    public String getServer() {
        Random random = new Random();
        int randomNumber = random.nextInt(totalWeight);
        int currentWeight = 0;
        for (ServerNode server : servers) {
            currentWeight += server.getWeight();
            if (randomNumber < currentWeight) {
                return server.getAddress();
            }
        }
        return servers.get(0).getAddress();
    }
    @Data
    @AllArgsConstructor
    public static class ServerNode {
        private String address;
        private int weight;
    }
}

生产环境最佳实践

完整配置示例

# 生产环境配置
spring:
  cloud:
    loadbalancer:
      retry:
        enabled: true  # 启用重试
        max-retries-on-same-service-instance: 1
        max-retries-on-next-service-instance: 3
      health-check:
        interval: 30s  # 健康检查间隔
        path: /actuator/health
# Nacos作为注册中心
spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.1.100:8848
        namespace: prod
        weight: 100  # 实例权重

服务端配置

# 服务端 application.yml
server:
  port: ${PORT:8081}
spring:
  application:
    name: user-service
eureka:
  instance:
    lease-renewal-interval-in-seconds: 10  # 心跳间隔
    lease-expiration-duration-in-seconds: 30  # 过期时间
    metadata-map:
      version: v1
      zone: zone1

选择合适的负载均衡方案需要考虑：

1. 应用场景：微服务间调用、网关分发、数据库读写分离
2. 性能要求：吞吐量、响应时间
3. 可用性要求：故障转移、健康检查
4. 扩展性需求：动态扩容、灰度发布

对于微服务架构，推荐使用Spring Cloud LoadBalancer + Nacos/Eureka，配合Hystrix或Sentinel实现熔断降级,构建高可用的系统。