SpringCloud和SpringBoot的负载均衡的实现办法LoadBalanced+ConfigBean+RestTemplate转发操作

我不是女神ヾ 2023-07-10 14:29 10阅读 0赞

#  实例化RestTemplate---负载均衡 #

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    import com.netflix.loadbalancer.IRule;
    import com.netflix.loadbalancer.RetryRule;
    
    @Configuration
    public class ConfigBean //boot -->spring   applicationContext.xml --- @Configuration配置   ConfigBean = applicationContext.xml
    { 
    	@Bean
    	@LoadBalanced//Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端       负载均衡的工具。
    	public RestTemplate getRestTemplate()
    	{
    		return new RestTemplate();
    	}
    	
    	@Bean
    	public IRule myRule()
    	{
    		//return new RoundRobinRule();
    		//return new RandomRule();//达到的目的，用我们重新选择的随机算法替代默认的轮询。
    		return new RetryRule();
    	}
    }

#  DeptController\_Consumer实现请求转化 #

import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import com.atguigu.springcloud.entities.Dept;
    
    @RestController
    public class DeptController_Consumer
    {
    
     
    	private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-DEPT";
    
    	/**
    	 * 使用 使用restTemplate访问restful接口非常的简单粗暴无脑。 (url, requestMap,
    	 * ResponseBean.class)这三个参数分别代表 REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
    	 */
    	@Autowired
    	private RestTemplate restTemplate;
    
    	@RequestMapping(value = "/consumer/dept/add")
    	public boolean add(Dept dept)
    	{
    		return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    	}
    
    	@RequestMapping(value = "/consumer/dept/get/{id}")
    	public Dept get(@PathVariable("id") Long id)
    	{
    		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    	}
    
    	@SuppressWarnings("unchecked")
    	@RequestMapping(value = "/consumer/dept/list")
    	public List<Dept> list()
    	{
    		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    	}
    
    	// 测试@EnableDiscoveryClient,消费端可以调用服务发现
    	@RequestMapping(value = "/consumer/dept/discovery")
    	public Object discovery()
    	{
    		return restTemplate.getForObject(REST_URL_PREFIX + "/dept/discovery", Object.class);
    	}
    
    }

# 启动类： #

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.cloud.netflix.ribbon.RibbonClient;
    
    import com.atguigu.myrule.MySelfRule;
    
    @SpringBootApplication
    @EnableEurekaClient
    //在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
    //@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
    @RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
    public class DeptConsumer80_App
    {
    	public static void main(String[] args)
    	{
    		SpringApplication.run(DeptConsumer80_App.class, args);
    	}
    }

# 自定义负载均衡的规则 #

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import com.netflix.loadbalancer.IRule;
    import com.netflix.loadbalancer.RoundRobinRule;
    
    @Configuration
    public class MySelfRule
    {
    	@Bean
    	public IRule myRule()
    	{
    		//return new RandomRule();// Ribbon默认是轮询，我自定义为随机
    		//return new RoundRobinRule();// Ribbon默认是轮询，我自定义为随机
    		
    		return new RandomRule_ZY();// 我自定义为每台机器5次
    	}
    }

# 实现Irule规则的实现，负载均衡的实现 #

import java.util.List;
    
    import com.netflix.client.config.IClientConfig;
    import com.netflix.loadbalancer.AbstractLoadBalancerRule;
    import com.netflix.loadbalancer.ILoadBalancer;
    import com.netflix.loadbalancer.Server;
    
    public class RandomRule_ZY extends AbstractLoadBalancerRule
    {
    
    	// total = 0 // 当total==5以后，我们指针才能往下走，
    	// index = 0 // 当前对外提供服务的服务器地址，
    	// total需要重新置为零，但是已经达到过一个5次，我们的index = 1
    	// 分析：我们5次，但是微服务只有8001 8002 8003 三台，OK？
    	// 
    	
    	
    	private int total = 0; 			// 总共被调用的次数，目前要求每台被调用5次
    	private int currentIndex = 0;	// 当前提供服务的机器号
    
    	public Server choose(ILoadBalancer lb, Object key)
    	{
    		if (lb == null) {
    			return null;
    		}
    		Server server = null;
    
    		while (server == null) {
    			if (Thread.interrupted()) {
    				return null;
    			}
    			List<Server> upList = lb.getReachableServers();
    			List<Server> allList = lb.getAllServers();
    
    			int serverCount = allList.size();
    			if (serverCount == 0) {
    				/*
    				 * No servers. End regardless of pass, because subsequent passes only get more
    				 * restrictive.
    				 */
    				return null;
    			}
    
    //			int index = rand.nextInt(serverCount);// java.util.Random().nextInt(3);
    //			server = upList.get(index);
    
    			
    //			private int total = 0; 			// 总共被调用的次数，目前要求每台被调用5次
    //			private int currentIndex = 0;	// 当前提供服务的机器号
                if(total < 5)
                {
    	            server = upList.get(currentIndex);
    	            total++;
                }else {
    	            total = 0;
    	            currentIndex++;
    	            if(currentIndex >= upList.size())
    	            {
    	              currentIndex = 0;
    	            }
                }			
    			
    			
    			if (server == null) {
    				/*
    				 * The only time this should happen is if the server list were somehow trimmed.
    				 * This is a transient condition. Retry after yielding.
    				 */
    				Thread.yield();
    				continue;
    			}
    
    			if (server.isAlive()) {
    				return (server);
    			}
    
    			// Shouldn't actually happen.. but must be transient or a bug.
    			server = null;
    			Thread.yield();
    		}
    
    		return server;
    
    	}
    
    	@Override
    	public Server choose(Object key)
    	{
    		return choose(getLoadBalancer(), key);
    	}
    
    	@Override
    	public void initWithNiwsConfig(IClientConfig clientConfig)
    	{
    		// TODO Auto-generated method stub
    
    	}
    
    }

# XML的配置 #

server:
      port: 80
    eureka:
      client:
        register-with-eureka: false
        service-url: 
          defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/