本地模拟一台客户端三台服务器的负载均衡算法过程

布满荆棘的人生 2023-09-24 20:49 40阅读 0赞

目录结构：

![ae21fcb262d81d76f5755822945c1740.png][]

按目录结构顺序上传：

ServicePort：定义端口值、权重值

package com.load.balancing.config;
    
    import java.util.*;
    
    public class ServicePort {
        //不带权重
        public static final List<String> LIST = Arrays.asList(
                "8081",
                "8082",
                "8083"
        );
        //带权重
        public static final HashMap<String,Integer> WEIGHT_MAP = new LinkedHashMap<>();
        static {
            WEIGHT_MAP.put("8081",20);
            WEIGHT_MAP.put("8082",30);
            WEIGHT_MAP.put("8083",50);
        }
    }

WeightInfo：封装端口、权重值、当前权重值，便于后续操作

package com.load.balancing.config;
    
    public class WeightInfo {
        public  String port;
        public Integer curWeight;
        public Integer weight;
        public WeightInfo(String port, Integer curWeight, Integer weight){
            this.port = port;
            this.curWeight = curWeight;
            this.weight = weight;
        }
    }

ClientLoad：客户端访问

package com.load.balancing.Controller;
    
    import com.load.balancing.service.CallLoadService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class ClientLoad {
        @Autowired
        CallLoadService callLoadService;
        @GetMapping(value = "call/{loadType}/{times}")
        public  String CallService(@PathVariable String loadType, @PathVariable int times){
            return callLoadService.loadService(loadType,times);
        }
    }

ServerLoad：服务器端访问

package com.load.balancing.Controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.concurrent.atomic.AtomicInteger;
    @RestController
    public class ServerLoad {
        AtomicInteger callTimes = new AtomicInteger();
    
        @GetMapping(value = "/hello")
        public int hello(){
            callTimes.incrementAndGet();
            return  callTimes.get();
        }
    
        @GetMapping(value = "/times")
        public int countTimes(){
            return callTimes.get();
        }
    }

CallLoadService：负载的策略，远程访问服务器端资源

package com.load.balancing.service;
    
    
    import com.load.balancing.config.ServicePort;
    import org.apache.http.HttpResponse;
    import org.apache.http.client.HttpClient;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.apache.http.util.EntityUtils;
    import org.springframework.stereotype.Service;
    
    import java.io.IOException;
    import java.util.concurrent.ConcurrentHashMap;
    
    @Service
    public class CallLoadService {
         final String url = "http://localhost:";
         final String method = "/hello";
    
         //负载策略
         public String loadService(String loadType, int times){
            ConcurrentHashMap serverName = new ConcurrentHashMap();
            serverName.put("8081","serverA");
            serverName.put("8082","serverB");
            serverName.put("8083","serverC");
             String port;
             StringBuffer sb = new StringBuffer();
             for (int i = 0; i < times; i++){
                 switch (loadType){
                     case "random":
                         port = LoadService.RandomBalance();
                         break;
                     case "weight":
                         port = LoadService.WeightBalance();
                         break;
                     default:
                         port = LoadService.RandomBalance();;
                 }
                sb.append("</br>" + serverName.get(port) + "服务器被调用的端口是：" + port + ",被访问的次数是：" + callService(url,port, method) + "</br>");
             }
    
             for (String ipPort : ServicePort.LIST){
                 sb.append("<br>" + "服务名为"+ serverName.get(ipPort) +" ,端口："+ ipPort + ",最终统计已被调用 "+callService(url,ipPort, "/times")+"次 </br>");
             }
             return sb.toString();
        }
    
        //远程调用服务器资源
        public String callService(String url , String port ,String methodName){
            HttpClient httpClient = HttpClientBuilder.create().build();
            HttpGet httpRequest = new HttpGet(url + port + methodName);
            httpRequest.setHeader("Content-Type","application/json");
            httpRequest.setHeader("Accept","application/json");
            HttpResponse httpResponse;
            try {
                httpResponse = httpClient.execute(httpRequest);
                return EntityUtils.toString(httpResponse.getEntity(),"UTF-8");
            } catch (IOException e) {
                e.printStackTrace();
                return "请求转换失败" + e.getMessage();
            }
            finally {
                try {
                    ((CloseableHttpClient)httpClient).close();
                } catch (IOException e) {
                    e.printStackTrace();
                    return "请求关闭失败" + e.getMessage();
                }
            }
        }
    }

LoadService：负载均衡算法

package com.load.balancing.service;
    
    import com.load.balancing.config.ServicePort;
    import com.load.balancing.config.WeightInfo;
    import org.springframework.stereotype.Service;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    
    @Service
    public class LoadService {
        private static Map<String, WeightInfo> weightPathMap = new HashMap();
    
        //随机算法
        public static String RandomBalance(){
            Random random = new Random();
            int port = random.nextInt(3);
            return ServicePort.LIST.get(port);
        }
    
        //权重算法
        public static String WeightBalance(){
    
            //拿到总权重
            int totalWeight = 0;
            for (Integer weight : ServicePort.WEIGHT_MAP.values()){
                totalWeight += weight;
            }
            //初始化动态权重值
            if (weightPathMap.isEmpty()){
                ServicePort.WEIGHT_MAP.forEach((port,weight) -> weightPathMap.put(port,new WeightInfo(port,weight,0)));
            }
            WeightInfo maxWeightPath = null;
            for (WeightInfo weightPath : weightPathMap.values()){
                if (maxWeightPath == null || weightPath.curWeight > maxWeightPath.curWeight){
                    maxWeightPath = weightPath;
                }
            }
            //减去总权重
            maxWeightPath.curWeight -= totalWeight;
            //获取对应的端口
            return maxWeightPath.port;
        }
    }

结果：

![7b55d208cb4abad2614db30625fce001.png][]

![75c35d43551c6aff2e79d086c18344b9.png][]

[ae21fcb262d81d76f5755822945c1740.png]: https://img-blog.csdnimg.cn/img_convert/ae21fcb262d81d76f5755822945c1740.png
[7b55d208cb4abad2614db30625fce001.png]: https://img-blog.csdnimg.cn/img_convert/7b55d208cb4abad2614db30625fce001.png
[75c35d43551c6aff2e79d086c18344b9.png]: https://img-blog.csdnimg.cn/img_convert/75c35d43551c6aff2e79d086c18344b9.png