SpringCloud（三）服务发现与负载均衡ribbon

古城微笑少年丶 2022-03-28 06:17 198阅读 0赞

# SpringCloud学习总结 #

## 3、服务发现与负载均衡ribbon ##

**一、服务发现**

**修改provider8001主启动类，增加注解@EnableDiscoveryClient**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @SpringBootApplication
    @EnableEurekaClient //本服务启动后会自动注册进eureka服务中
    @EnableDiscoveryClient //服务发现
    public class DeptProvider8001_App
    { 
    	public static void main(String[] args)
    	{ 
    		SpringApplication.run(DeptProvider8001_App.class, args);
    	}
    }

**修改provider8001中的Controller**

package com.atguigu.springcloud.controller;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.client.ServiceInstance;
    import org.springframework.cloud.client.discovery.DiscoveryClient;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.atguigu.springcloud.entities.Dept;
    import com.atguigu.springcloud.service.DeptService;
    
    @RestController
    public class DeptController
    { 
    	@Autowired
    	private DeptService service;
    	@Autowired
    	private DiscoveryClient client;
    
    	@RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    	public boolean add(@RequestBody Dept dept)
    	{ 
    		return service.add(dept);
    	}
    
    	@RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
    	public Dept get(@PathVariable("id") Long id)
    	{ 
    		return service.get(id);
    	}
    
    	@RequestMapping(value = "/dept/list", method = RequestMethod.GET)
    	public List<Dept> list()
    	{ 
    		return service.list();
    	}
    
    	
    // @Autowired
    // private DiscoveryClient client;
    	@RequestMapping(value = "/dept/discovery", method = RequestMethod.GET)
    	public Object discovery()
    	{ 
    		List<String> list = client.getServices();
    		System.out.println("**********" + list);
    
    		List<ServiceInstance> srvList = client.getInstances("MICROSERVICECLOUD-DEPT");
    		for (ServiceInstance element : srvList) { 
    			System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
    					+ element.getUri());
    		}
    		return this.client;
    	}
    
    }

**修改服务消费consumer80的服务处理类**

package com.atguigu.springcloud.controller;
    
    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://localhost:8001";
    	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);
    	}
    
    }

**发送请求查看服务发现的情况 [http://localhost:80/consumer/dept/discovery][http_localhost_80_consumer_dept_discovery]**

**二、负载均衡ribbon**

**新建服务提供者provider8001模块**

**拷贝provider8001的pom文件以及yml文件**

server:
     port: 8002
    
    mybatis:
     config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
     type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包
     mapper-locations:
     - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件
    
    spring:
      application:
       name: microservicecloud-dept
      datasource:
       type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
       driver-class-name: com.mysql.jdbc.Driver              # mysql驱动包
       url: jdbc:mysql://localhost:3306/cloudDB02              # 数据库名称
       username: root
       password: 123321
       dbcp2:
         min-idle: 5                                           # 数据库连接池的最小维持连接数
         initial-size: 5                                       # 初始化连接数
         max-total: 5                                          # 最大连接数
         max-wait-millis: 200                                  # 等待连接获取的最大超时时间
    
    eureka:
     client: #客户端注册进eureka服务列表内
       service-url:
         defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
     instance:
       instance-id: microservicecloud-dept8002 #自定义服务名称信息
       prefer-ip-address: true     #访问路径可以显示IP地址
    #
    info:
     app.name: atguigu-microservicecloud
     company.name: www.atguigu.com
     build.artifactId: $project.artifactId$
     build.version: $project.version$

注意：不同的微服务提供者可以连接不同的数据库！！！ 8001连接cloudDB01 8002连接cloudDB02

**修改consumer80中的配置类**

**在注入的RestTemplate 上标注注解@LoadBalanced则可实现负载均衡**

package com.atguigu.springcloud.cfgbeans;
    
    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 
    {  
    	@Bean
    	@LoadBalanced //Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端 负载均衡的工具。
    	public RestTemplate getRestTemplate()
    	{ 
    		return new RestTemplate();
    	}
    }

**启动三个eureka,启动两个provider,启动consumer,查看结果  
[http://localhost:80/consumer/dept/list][http_localhost_80_consumer_dept_list]**

**三、选择载均衡算法与自定义算法**

**在consumer80创建一个配置类**

**在容器中注入相应的算法类**

package com.atguigu.myrule;
    
    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次
    	}
    }

**自定义负载均衡算法**

注意：要实现自定义算法，配置类与算法类不能与主启动类在同一个包下！！！，自定义算法类，继承AbstractLoadBalancerRule

//循环调用每个微服务，并且每个调用5次
    package com.atguigu.myrule;
    
    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
    	}
    }

**有点模糊，看结构图**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70]

**仅仅选择不同的负载均衡算法，则直接在ConfigBean里面 注入相应的类  
自定义算法，则在myrule包下新建配置类与算法类。  
主启动类在springcloud包下**

**启动三个eureka,启动两个provider,启动consumer,再次查看结果  
[http://localhost:80/consumer/dept/list][http_localhost_80_consumer_dept_list]**

后续：负载均衡feign与Hystrix断路器…

[http_localhost_80_consumer_dept_discovery]: http://localhost:80/consumer/dept/discovery
[http_localhost_80_consumer_dept_list]: http://localhost:80/consumer/dept/list
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDAxOTQ1_size_16_color_FFFFFF_t_70]: /images/20220328/efeeec251e304c8bbab2d8efbdc5019b.png