手撸一个java网关(四)

服务发现和负载均衡是微服务架构中非常重要的功能，它们允许Gateway根据服务注册信息动态地路由请求到不同的服务实例，并能够平衡各个实例的负载。
在这个简化的例子中，我们将使用一个简单的服务注册表和轮询负载均衡算法。在实际应用中，你可能会使用如Eureka、Consul或Zookeeper，nacos等成熟的服务发现解决方案。
首先，我们定义一个服务注册表接口和一个简单的实现：

package com.example.gateway.discovery;
import java.util.List;
public interface ServiceRegistry {
    List<ServiceInstance> getInstances(String serviceName);
}
package com.example.gateway.discovery;
import java.util.ArrayList;
import java.util.List;
public class SimpleServiceRegistry implements ServiceRegistry {
    private final List<ServiceInstance> serviceInstances = new ArrayList<>();
    public SimpleServiceRegistry() {
        // 假设我们在这里初始化服务实例列表
        serviceInstances.add(new ServiceInstance("service1", "http://localhost:8081"));
        serviceInstances.add(new ServiceInstance("service1", "http://localhost:8082"));
        serviceInstances.add(new ServiceInstance("service2", "http://localhost:8083"));
    }
    @Override
    public List<ServiceInstance> getInstances(String serviceName) {
        return serviceInstances.stream()
                .filter(instance -> instance.getServiceName().equals(serviceName))
                .toList();
    }
}

然后，我们定义一个服务实例类和一个负载均衡器：

package com.example.gateway.discovery;
public class ServiceInstance {
    private final String serviceName;
    private final String url;
    public ServiceInstance(String serviceName, String url) {
        this.serviceName = serviceName;
        this.url = url;
    }
    public String getServiceName() {
        return serviceName;
    }
    public String getUrl() {
        return url;
    }
}
package com.example.gateway.loadbalance;
import com.example.gateway.discovery.ServiceInstance;
import com.example.gateway.discovery.ServiceRegistry;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class RoundRobinLoadBalancer {
    private final ServiceRegistry serviceRegistry;
    private final AtomicInteger counter = new AtomicInteger(0);
    public RoundRobinLoadBalancer(ServiceRegistry serviceRegistry) {
        this.serviceRegistry = serviceRegistry;
    }
    public ServiceInstance getInstance(String serviceName) {
        List<ServiceInstance> instances = serviceRegistry.getInstances(serviceName);
        if (instances.isEmpty()) {
            return null;
        }
        int index = Math.abs(counter.getAndIncrement()) % instances.size();
        return instances.get(index);
    }
}

现在，我们修改GatewayServlet来使用服务发现和负载均衡器：

package com.example.gateway;
import com.example.gateway.discovery.ServiceInstance;
import com.example.gateway.discovery.ServiceRegistry;
import com.example.gateway.discovery.SimpleServiceRegistry;
import com.example.gateway.loadbalance.RoundRobinLoadBalancer;
// ... 其他 import ...
public class GatewayServlet extends HttpServlet {
    private final ServiceRegistry serviceRegistry = new SimpleServiceRegistry();
    private final RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(serviceRegistry);
    // ... 其他代码 ...
    private void routeRequest(HttpServletRequest request, HttpServletResponse response) throws IOException {
        // ... 过滤器链代码 ...
        // 使用负载均衡器选择一个服务实例
        String path = request.getRequestURI();
        if (path.startsWith("/service1")) {
            ServiceInstance instance = loadBalancer.getInstance("service1");
            if (instance != null) {
                // 这里可以添加转发到选定实例的逻辑
                response.getWriter().write("Forwarded to " + instance.getUrl());
            } else {
                response.setStatus(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
                response.getWriter().write("Service Unavailable");
            }
        } else if (path.startsWith("/service2")) {
            ServiceInstance instance = loadBalancer.getInstance("service2");
            if (instance != null) {
                // 这里可以添加转发到选定实例的逻辑
                response.getWriter().write("Forwarded to " + instance.getUrl());
            } else {
                response.setStatus(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
                response.getWriter().write("Service Unavailable");
            }
        } else {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            response.getWriter().write("Not Found");
        }
    }
}

在这个例子中，我们使用了一个简单的轮询负载均衡算法，它每次从服务实例列表中按顺序选择一个实例来处理请求。在实际应用中，你可能需要实现更复杂的负载均衡策略，如基于权重的轮询、最小连接数等。
此外，服务实例的信息通常是从服务注册中心动态获取的，而不是在代码中硬编码。在这个例子中，我们使用了一个简单的服务注册表实现，但在生产环境中，你可能会使用Consul、Eureka或Zookeeper, nacos等服务发现工具。
这个简化的实现提供了一个基本的服务发现和负载均衡框架，可以根据具体需求进行进一步的扩展和优化。