首页 / 负载均衡 / springcloud(五)：Ribbon负载均衡机制

springcloud(五)：Ribbon负载均衡机制

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了springcloud(五)：Ribbon负载均衡机制，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5934字，纯文字阅读大概需要9分钟。

内容图文

1. 测试自定义负载均衡规则

1.1 服务器

创建first-boot项目：

pom：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.crazyi.cloud</groupId>
    <artifactId>first-boot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>1.5.7.RELEASE</version>
        </dependency>
    </dependencies>
    
</project>

Person：

            package
             org.crazyit.cloud;


            public
            class
             Person {

    
            private
             Integer id;
    
            private
             String name;
    
            private
             Integer age;
    
            private
             String message;
    
            public
             Integer getId() {
        
            return
             id;
    }
    
            public
            void
             setId(Integer id) {
        
            this.id = id;
    }
    public String getName() {
        return name;
    }
    publicvoid setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    publicvoid setAge(Integer age) {
        this.age = age;
    }
    public String getMessage() {
        return message;
    }
    publicvoid setMessage(String message) {
        this.message = message;
    }
    
}

MyController：

            package
             org.crazyit.cloud;


            import
             org.springframework.stereotype.Controller;

            import
             org.springframework.web.bind.annotation.GetMapping;

            import
             org.springframework.web.bind.annotation.ResponseBody;

@Controller

            public
            class
             MyController {

    @GetMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello World";
    }
}

MyRestController：

            package
             org.crazyit.cloud;


            import
             javax.servlet.http.HttpServletRequest;


            import
             org.springframework.http.MediaType;

            import
             org.springframework.web.bind.annotation.PathVariable;

            import
             org.springframework.web.bind.annotation.RequestMapping;

            import
             org.springframework.web.bind.annotation.RequestMethod;

            import
             org.springframework.web.bind.annotation.RestController;

@RestController

            public
            class
             MyRestController {

    @RequestMapping(value = "/person/{id}", method = RequestMethod.GET, 
            produces = MediaType.APPLICATION_JSON_VALUE)
    public Person getPerson(@PathVariable Integer id, HttpServletRequest request) {
        Person p = new Person();
        p.setId(id);
        p.setName("angus");
        p.setAge(30);
        p.setMessage(request.getRequestURL().toString());
        return p;
    }
}

FirstApp：

            package
             org.crazyit.cloud;


            import
             java.util.Scanner;


            import
             org.springframework.boot.autoconfigure.SpringBootApplication;

            import
             org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication

            public
            class
             FirstApp {

    
            public
            static
            void
             main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String port = scan.nextLine();
        new SpringApplicationBuilder(FirstApp.class).properties("server.port=" + port).run(args);
        
    }

}

1.2 客户端

创建项目user-ribbon：

直接使用：

LBMain：

            package
             org.crazyit.cloud;


            import
             java.util.ArrayList;

            import
             java.util.List;


            import
             com.netflix.loadbalancer.BaseLoadBalancer;

            import
             com.netflix.loadbalancer.ILoadBalancer;

            import
             com.netflix.loadbalancer.Server;


            public
            class
             LBMain {

    
            public
            static
            void
             main(String[] args) {
        ILoadBalancer lb = new BaseLoadBalancer();
        List<Server> servers = new ArrayList<Server>();
        servers.add(new Server("localhost", 8080));
        servers.add(new Server("localhost", 8081));
        
        lb.addServers(servers);
        for(int i = 0; i < 10; i++) {
            Server s = lb.chooseServer(null);
            System.out.println(s);
        }
    }

}

使用Rule：

MyRule：

            package
             org.crazyit.cloud;


            import
             java.util.List;

            import
             java.util.Random;


            import
             com.netflix.loadbalancer.ILoadBalancer;

            import
             com.netflix.loadbalancer.IRule;

            import
             com.netflix.loadbalancer.Server;


            public
            class MyRule implements IRule {
    
    private ILoadBalancer lb;

    public Server choose(Object key) {
        Random r = new Random();
        int rNum = r.nextInt(10);
        
        List<Server> servers = lb.getAllServers();
        
        if(rNum > 7) {
            return getServerByPort(servers, 8081);
        }
        return getServerByPort(servers, 8080);
    }
    
    private Server getServerByPort(List<Server> servers, int port) {
        for(Server s : servers) {
            if(s.getPort() == port) {
                return s;
            }
        }
        returnnull;
    }

    publicvoid setLoadBalancer(ILoadBalancer lb) {
        this.lb = lb;
    }

    public ILoadBalancer getLoadBalancer() {
        returnthis.lb;
    }

}

TestMyRule：

            package
             org.crazyit.cloud;


            import
             java.util.ArrayList;

            import
             java.util.List;


            import
             com.netflix.loadbalancer.BaseLoadBalancer;

            import
             com.netflix.loadbalancer.ILoadBalancer;

            import
             com.netflix.loadbalancer.Server;


            public
            class
             TestMyRule {

    
            public
            static
            void
             main(String[] args) {
        BaseLoadBalancer lb = new BaseLoadBalancer();
        MyRule rule = new MyRule();
        rule.setLoadBalancer(lb);
        lb.setRule(rule);
        
        List<Server> servers = new ArrayList<Server>();
        servers.add(new Server("localhost", 8080));
        servers.add(new Server("localhost", 8081));
        lb.addServers(servers);
        for(int i = 0; i < 10; i++) {
            Server s = lb.chooseServer(null);
            System.out.println(s);
        }
    }

}

TestRibbon：

            package
             org.crazyit.cloud;


            import
             com.netflix.client.ClientFactory;

            import
             com.netflix.client.http.HttpRequest;

            import
             com.netflix.client.http.HttpResponse;

            import
             com.netflix.config.ConfigurationManager;

            import
             com.netflix.niws.client.http.RestClient;


            public
            class
             TestRibbon {

    
            public
            static
            void main(String[] args) throws Exception {
        ConfigurationManager.getConfigInstance().setProperty(
                  "my-client.ribbon.listOfServers", "localhost:8080,localhost:8081");
        ConfigurationManager.getConfigInstance().setProperty(
                  "my-client.ribbon.NFLoadBalancerRuleClassName", MyRule.class.getName());
        
        // 获取REST请求客户端
        RestClient client = (RestClient) ClientFactory
                .getNamedClient("my-client");
        // 创建请求实例
        HttpRequest request = HttpRequest.newBuilder().uri("/person/1").build();
        // 发 送10次请求到服务器中for (int i = 0; i < 10; i++) {
            HttpResponse response = client.executeWithLoadBalancer(request);
            String result = response.getEntity(String.class);
            System.out.println(result);
        }
    }

}

原文：https://www.cnblogs.com/liuhui0308/p/13908218.html

内容总结

以上是互联网集市为您收集整理的springcloud(五)：Ribbon负载均衡机制全部内容，希望文章能够帮你解决springcloud(五)：Ribbon负载均衡机制所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1229633.html

来源：【匿名】