确保对象的唯一性——单例模式 （二）

3.3 负载均衡器的设计与实现

Sunny软件公司承接了一个服务器负载均衡(Load Balance)软件的开发工作，该软件运行在一台负载均衡服务器上，可以将并发访问和数据流量分发到服务器集群中的多台设备上进行并发处理，提高系统的整体处理能力，缩短响应时间。由于集群中的服务器需要动态删减，且客户端请求需要统一分发，因此需要确保负载均衡器的唯一性，只能有一个负载均衡器来负责服务器的管理和请求的分发，否则将会带来服务器状态的不一致以及请求分配冲突等问题。如何确保负载均衡器的唯一性是该软件成功的关键。

Sunny公司开发人员通过分析和权衡，决定使用单例模式来设计该负载均衡器，结构图如图3-3所示：

确保对象的唯一性——单例模式 （二） - 图1

在图3-3中，将负载均衡器LoadBalancer设计为单例类，其中包含一个存储服务器信息的集合serverList，每次在serverList中随机选择一台服务器来响应客户端的请求，实现代码如下所示：

  1. import java.util.*;  
  3. //负载均衡器LoadBalancer：单例类，真实环境下该类将非常复杂，包括大量初始化的工作和业务方法，考虑到代码的可读性和易理解性，只列出部分与模式相关的核心代码  
  4. class LoadBalancer {  
  5.     //私有静态成员变量，存储唯一实例  
  6.     private static LoadBalancer instance = null;  
  7.     //服务器集合  
  8.     private List serverList = null;  
  10.     //私有构造函数  
  11.     private LoadBalancer() {  
  12.         serverList = new ArrayList();  
  13.     }  
  15.     //公有静态成员方法，返回唯一实例  
  16.     public static LoadBalancer getLoadBalancer() {  
  17.         if (instance == null) {  
  18.             instance = new LoadBalancer();  
  19.         }  
  20.         return instance;  
  21.     }  
  23.     //增加服务器  
  24.     public void addServer(String server) {  
  25.         serverList.add(server);  
  26.     }  
  28.     //删除服务器  
  29.     public void removeServer(String server) {  
  30.         serverList.remove(server);  
  31.     }  
  33.     //使用Random类随机获取服务器  
  34.     public String getServer() {  
  35.         Random random = new Random();  
  36.         int i = random.nextInt(serverList.size());  
  37.         return (String)serverList.get(i);  
  38.     }  
  39. }

编写如下客户端测试代码：

  2. class Client {  
  3.     public static void main(String args[]) {  
  4.         //创建四个LoadBalancer对象  
  5.         LoadBalancer balancer1,balancer2,balancer3,balancer4;  
  6.         balancer1 = LoadBalancer.getLoadBalancer();  
  7.         balancer2 = LoadBalancer.getLoadBalancer();  
  8.         balancer3 = LoadBalancer.getLoadBalancer();  
  9.         balancer4 = LoadBalancer.getLoadBalancer();  
  11.         //判断服务器负载均衡器是否相同  
  12.         if (balancer1 == balancer2 && balancer2 == balancer3 && balancer3 == balancer4) {  
  13.             System.out.println("服务器负载均衡器具有唯一性！");  
  14.         }  
  16.         //增加服务器  
  17.         balancer1.addServer("Server 1");  
  18.         balancer1.addServer("Server 2");  
  19.         balancer1.addServer("Server 3");  
  20.         balancer1.addServer("Server 4");  
  22.         //模拟客户端请求的分发  
  23.         for (int i = 0; i < 10; i++) {  
  24.             String server = balancer1.getServer();  
  25.             System.out.println("分发请求至服务器： " + server);  
  26.       }  
  27.     }  
  28. }

编译并运行程序，输出结果如下：

服务器负载均衡器具有唯一性！

  1. 分发请求至服务器：  Server 1
  2. 分发请求至服务器：  Server 3
  3. 分发请求至服务器：  Server 4
  4. 分发请求至服务器：  Server 2
  5. 分发请求至服务器：  Server 3
  6. 分发请求至服务器：  Server 2
  7. 分发请求至服务器：  Server 3
  8. 分发请求至服务器：  Server 4
  9. 分发请求至服务器：  Server 4
  10. 分发请求至服务器：  Server 1

虽然创建了四个LoadBalancer对象，但是它们实际上是同一个对象，因此，通过使用单例模式可以确保LoadBalancer对象的唯一性。