微服务之初体验（3）

承接上一篇，此篇将简单完成负载均衡的效果，会了解到Ribbon（电脑运存8G以下的朋友不要轻易尝试）

---

上一篇：微服务之初体验（2）

一、添加依赖

Eureka用于模块通信，Ribbon用于负载均衡
需要添加依赖的几个模块：springcloud-consumer-dept-80、springcloud-eureka-7001、springcloud-eureka-7002、springcloud-eureka-7003、springcloud-provider-dept-8001
记得在DeptConsumer_80启动类加上注解@EnableEurekaClient，且在ConfigBean配置类中的 getRestTemplate() 方法上添加注解@LoadBalanced

<!-- Ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!-- Eureka -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

二、数据库构建

为了体现效果，我们在数据库新建两个和 db01 大致一样的 db02 、db03

DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept` (
  `deptno` bigint(20) NOT NULL AUTO_INCREMENT,
  `dname` varchar(60) DEFAULT NULL,
  `db_source` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`deptno`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='部门表';
-- ----------------------------------------------
INSERT INTO `dept` VALUES ('1', '开发部', DATABAES());
INSERT INTO `dept` VALUES ('2', '人事部', DATABAES());
INSERT INTO `dept` VALUES ('3', '财务部', DATABAES());
INSERT INTO `dept` VALUES ('4', '市场部', DATABAES());
INSERT INTO `dept` VALUES ('5', '运维部', DATABAES());

接着，模仿springcloud-provider-dept-8001模块创建springcloud-provider-dept-8002和springcloud-provider-dept-8003分别连接 db01、db02、db03 数据库

三、启动

这些都弄好之后，依次启动 Eureka_7001、DeptProvider_8001、DeptProvider_8002、DeptProvider_8003、DeptConsumer_80。（由于内存消耗太大，这里只启动了一个服务器 Eureka_7001）

自定义负载均衡算法

可以看到每次刷新网页，服务器会轮选着数据库，而我们也可以模仿默认的负载均衡编写自己的路由选择
新建一个 myrule 包，在包里写一个 KuangRule 的配置类

package com.myrule;
import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class KuangRule {
    @Bean
    public IRule myRule(){
        return new MyRandomRule();
    }
}

和一个 MyRandomRule 自定义类

package com.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class MyRandomRule extends AbstractLoadBalancerRule {
    /*
     每个服务，访问5次，换下一个服务节点（3个）
     total默认为0，如果total=5，指向下一个节点
     index默认为0，如果total=5，则index＋1
     */
    private int total = 0;// 被调用次数
    private int currentIndex = 0;// 当前是谁提供服务

    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            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) {
                    return null;
                }

//                int index = this.chooseRandomInt(serverCount);// 生成区间随机数
//                server = upList.get(index);
                if (total < 5) {
                    server = upList.get(currentIndex);
                    total++;
                } else {
                    total = 0;
                    currentIndex++;
                    if (currentIndex > upList.size()) {
                        currentIndex = 0;
                    }
                    server = upList.get(currentIndex);
                }

                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }
            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }
    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

如果包不在启动类的同级目录下，要配置注解@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = KuangRule.class)

package com.zh;
import com.myrule.KuangRule;
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;

@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = KuangRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

依次启动 Eureka_7001、DeptProvider_8001、DeptProvider_8002、DeptProvider_8003、DeptConsumer_80，可观察效果……未完待续！