负载均衡框架 ribbon 三

Ribbon 在 SpringCloud 中的使用

1.构建 Eureka 注册中心 smart-platform-eureka1

（1）导入jar包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.2.RELEASE</version>
  </parent>

  <dependencyManagement>
      <dependencies>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-dependencies</artifactId>
             <version>Finchley.SR2</version>
             <type>pom</type>
             <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
      </dependency>
  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

（2）添加eureka配置 application.yml

server:
  port: 8761
spring:
  application:
    name: smart-platform-eureka1
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  server:
    #eureka服务自我保护模式 默认是开启的
    enable-self-preservation: true
    #eureka服务 指定时间清理死掉的服务 默认60秒 单位毫秒
    eviction-interval-timer-in-ms: 60000

(3) 编写启动类

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * eureka注册中心服务
 */
@SpringBootApplication
@EnableEurekaServer
public class Application {
    public static void main( String[] args) throws Exception{
        new SpringApplicationBuilder(Application.class).run(args);
    }
}

2.构建生产者服务 smart-platform-base

（1）导入jar包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.2.RELEASE</version>
  </parent>

  <dependencyManagement>
      <dependencies>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-dependencies</artifactId>
             <version>Finchley.SR2</version>
             <type>pom</type>
             <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

(2) 编写接口

public class User {
    private int id;
    private String userName;
    private String sex;
    private int age;
    private String createTime;
    private String message;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

@RestController
@RequestMapping(value = "/platform/base")
public class TestController {

    @GetMapping(value = "/getUser")
    public User getUser(HttpServletRequest request){
        User user = new User();
        user.setId(1);
        user.setUserName("delan");
        user.setAge(5);
        user.setMessage(request.getRequestURL().toString());
        return user;
    }

}

（3）编写启动类（由于此处要做负载均衡，所以启动两个端口）

@SpringBootApplication
@EnableEurekaClient
public class Application {
    public static void main( String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入端口号：");
        String port = scan.nextLine();
        new SpringApplicationBuilder(Application.class).properties("server.port="+port).run(args);
    }
}

3.构建消费者服务 smart-platform-sm

(1) 导入jar包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.2.RELEASE</version>
  </parent>

  <dependencyManagement>
      <dependencies>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-dependencies</artifactId>
             <version>Finchley.SR2</version>
             <type>pom</type>
             <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
      </dependency>

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-devtools</artifactId>
          <optional>true</optional>
          <scope>true</scope>
      </dependency>
  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

（2）编写调用代码

import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.ZoneAwareLoadBalancer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@Configuration　　//由于此类种有使用@Bean注解将 RestTemplate 注入到 spring 容器所以需要此注解
@RequestMapping(value = "/platform/shumeng")
public class TestController {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    @GetMapping(value = "/getUser")
    public String getUser(){　　　　//此种方式会通过轮询服务列表的方式访问服务接口
       RestTemplate restTemplate = getRestTemplate();
       String json = restTemplate.getForObject("http://smart-platform-base/platform/base/getUser", String.class);
        return json;
    }

    //获取实例
    @Autowired
    private LoadBalancerClient client;

    @GetMapping(value = "/lb", produces = MediaType.APPLICATION_JSON_VALUE)
    public ServiceInstance lb() {
        ServiceInstance serviceInstance = client.choose("smart-platform-base");
        return serviceInstance;
    }

    //获取spring客户端
    @Autowired
    private SpringClientFactory factory;

    @GetMapping(value = "/factory", produces = MediaType.APPLICATION_JSON_VALUE)
    public String factory() {

        ILoadBalancer balancer = factory.getLoadBalancer("default");
        System.out.println("默认使用的负载均衡器是：" + balancer.getClass().getName());

        ZoneAwareLoadBalancer zb = (ZoneAwareLoadBalancer) balancer;
        System.out.println("默认使用的负载均衡规则是：" + zb.getRule().getClass().getName());

        //默认使用的负载均衡器是：com.netflix.loadbalancer.ZoneAwareLoadBalancer
        //默认使用的负载均衡规则：com.netflix.loadbalancer.ZoneAvoidanceRule

        ZoneAwareLoadBalancer zbm = (ZoneAwareLoadBalancer)factory.getLoadBalancer("smart-platform-base");
        return zbm.getRule().getClass().getName();
    }

}

(3) 自定义负载均衡规则

① 创建规则类

import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.Random;

public class MyRule implements IRule {

    private ILoadBalancer iLoadBalancer;

    @Override
    public Server choose(Object o) {
        List<Server> servers = iLoadBalancer.getAllServers();
        System.out.println("自定义负载均衡规则,服务器数量:"+servers.size());
        Random random = new Random();
        int num = random.nextInt(10);
        if (num > 7) {　　　　　　　　//特别注意为了方便测试此处将生产者服务的启动端口写死为了8001，8002 如果不一样记得修改
            return getServerByPort(servers, 8001);
        }
        return getServerByPort(servers, 8002);
    }

    @Override
    public void setLoadBalancer(ILoadBalancer iLoadBalancer) {
        this.iLoadBalancer = iLoadBalancer;
    }

    @Override
    public ILoadBalancer getLoadBalancer() {
        return this.iLoadBalancer;
    }

    private Server getServerByPort(List<Server> servers, int port) {
        for (Server server : servers) {
            if (server.getPort() == port) {
                return server;
            }
        }
        return null;
    }
}

② 创建规则实例并注入到spring容器中

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

public class MyConfig {

    @Bean
    public IRule getRule() {
        return new MyRule();
    }
}

③ 给 ribbon 客户端添加自定规则

import org.springframework.cloud.netflix.ribbon.RibbonClient;

@RibbonClient(name = "smart-platform-base", configuration = MyConfig.class)
public class MyClient {
}

上诉② ③方法是通过代码的方式将自定义的负载均衡规则添加给了ribbon客户端 smart-platform-base

通过application.yml配置文件的方式添加自定义规则，如下

server:
  port: 9001
spring:
  application:
    name: smart-platform-shumeng
#设置自定义规则 如果将smart-platform-base 改成default 则会对所有的客户端生效，将默认的规则改成 MyRule
smart-platform-base:
  ribbon:
    NFLoadBalancerRuleClassName: com.idelan.platform.config.MyRule
eureka:
  client:
    #指定时间去抓取一次服务列表 默认30秒
    registry-fetch-interval-seconds: 30
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

原文地址：https://www.cnblogs.com/gyli20170901/p/10073385.html

时间： 2024-11-02 13:41:56

负载均衡框架 ribbon 三的相关文章

API网关spring cloud gateway和负载均衡框架ribbon实战

通常我们如果有一个服务,会部署到多台服务器上,这些微服务如果都暴露给客户,是非常难以管理的,我们系统需要有一个唯一的出口,API网关是一个服务,是系统的唯一出口.API网关封装了系统内部的微服务,为客户端提供一个定制的API.客户端只需要调用网关接口,就可以调用到实际的微服务,实际的服务对客户不可见,并且容易扩展服务. API网关可以结合ribbon完成负载均衡的功能,可以自动检查微服务的状况,及时剔除或者加入某个微服务到可用服务列表.此外网关可以完成权限检查.限流.统计等功能.下面我们将一一完

LVS负载均衡群集（三种工作模式原理详解）

LVS负载均衡群集(三种工作模式原理详解) 一.前言 ? 在互联网应用中,随着站点对硬件性能.响应速度.服务稳定性.数据可靠性等要求越来越高,单台服务器力不从心.所以我们需要通过一些方法来解决这样的瓶颈. ? 最简单的方法就是使用价格昂贵的大.小型的主机:但这样在大多数企业中显然是不可取或者说不现实的.那么我们就需要通过多个普通服务器构建服务器群集. 二.相关概念概述 2.1何为LVS? ? LVS--Linux Virtual Server,即Linux虚拟服务器(虚拟主机.共享主机),虚拟主

Spring Cloud Alibaba之负载均衡组件 - Ribbon

负载均衡我们都知道在微服务架构中,微服务之间总是需要互相调用,以此来实现一些组合业务的需求.例如组装订单详情数据,由于订单详情里有用户信息,所以订单服务就得调用用户服务来获取用户信息.要实现远程调用就需要发送网络请求,而每个微服务都可能会存在有多个实例分布在不同的机器上,那么当一个微服务调用另一个微服务的时候就需要将请求均匀的分发到各个实例上,以此避免某些实例负载过高,某些实例又太空闲,所以在这种场景必须要有负载均衡器. 目前实现负载均衡主要的两种方式: 1.服务端负载均衡:例如最经典的使用N

springCloud（8）：Ribbon实现客户端侧负载均衡-自定义Ribbon配置

一.简介很多场景下,可能根据需要自定义的Ribbon的配置,例如修改Ribbon的负载均衡规则等.Spring cloud Camden允许使用Java代码或属性自定义Ribbon的配置. 二.使用Java代码自定义Ribbon配置在Spring cloud中,Ribbon的默认配置如下,格式是:BeanType beanName:ClassName 1.IClientConfig ribbonClientConfig:DefaultClientConfigImpl 2.IRule ribb

客户端负载均衡Ribbon之一：Spring Cloud Netflix负载均衡组件Ribbon介绍

Netflix:['netfli?ks] ribbon:英[?r?b?n]美[?r?b?n]n. 带; 绶带; (打印机的) 色带; 带状物;v. 把…撕成条带; 用缎带装饰; 形成带状; LB方案分类目前主流的LB方案可分成两类: 一种是集中式LB, 即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件,如F5, 也可以是软件,如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方: 另一种是进程内LB,将LB逻辑集成到消费方,消费方从服务注册中心获知有哪些地址

负载均衡array的三种转发模式

array负载均衡设备支持三种转发模式: 1.Reverse Proxy Mode(反向代理模式) Array APV 的反向代理模式是指负载均衡接收到用户的请求后,以代理的方式转发给内部的服务器.因此,与后台服务器建连的源地址为APV的接口地址.反向代理模式下,无需对原有网络进行额外调整,同时结合TCP连接服用技术,对应用性能进行优化,但是不好的地方就是在服务器那里看不到客户端的IP地址,无法分析数据. 2.Transparent Mode (透明模式) Array APV的透明模式是指 Ar

Spring Cloud Netflix负载均衡组件Ribbon介绍

应用负载均衡之LVS(三)：使用ipvsadm以及详细分析VS/DR模式

*/ .hljs { display: block; overflow-x: auto; padding: 0.5em; color: #333; background: #f8f8f8; } .hljs-comment, .hljs-template_comment, .diff .hljs-header, .hljs-javadoc { color: #998; font-style: italic; } .hljs-keyword, .css .rule .hljs-keyword, .h

SpringCloud系列五：Ribbon 负载均衡（Ribbon 基本使用、Ribbon 负载均衡、自定义 Ribbon 配置、禁用 Eureka 实现 Ribbon 调用）

1.概念:Ribbon 负载均衡 2.具体内容现在所有的服务已经通过了 Eureka 进行了注册,那么使用 Eureka 注册的目的是希望所有的服务都统一归属到 Eureka 之中进行处理,但是现在的问题,所有的微服务汇集到了 Eureka 之中,而客户端的调用也应该通过 Eureka 完成.而这种调用就可以利用 Ribbon 技术来实现. Ribbon 是一个服务调用的组件,并且是一个客户端实现负载均衡处理的组件.服务器端实现负载均衡可以使用 Nginx. HAProxy.LVS 等. 2