Eureka服务消费

首先在provider中提供一个接口，然后创建一个新的consumer项目，消费这个端口
在provider中提供一个hello接口。如下

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello(){
        return "hello jiangbeicheng!";
    }
}

接下来创建一个consumer项目，consumer项目中，去消费provider提供的接口。comsumer 要能获取到provider这个接口的地址，也就需要去Eureka Server 中查询。如果直接在consumer中写死provider地址，意味着这两个服务之间的耦合度太高了，我们要降低耦合度，首先我们看一个写死的调用。
创建一个consumer项目，添加web和eureka client依赖：


创建完成后，我们首先也在application.properties中配置一下注册信息：

spring.application.name=consumer
server.port=1115
eureka.client.service-url.defaultZone=http://localhost:1111/eureka

配置完成后，我们现在想在consumer 中调用provider提供的服务，我们可以直接将调用写死，就是说，整个调用过程不会涉及到eureka server.

 @GetMapping("/hello1")
    public String hello1(){
        HttpURLConnection con=null;
        URL url= null;
        try {
            url = new URL("http://localhost:1113/hello");
            con=(HttpURLConnection) url.openConnection();
            if(con.getResponseCode()==200){
                BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
                String s=br.readLine();
                br.close();
                return s;

            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";
    }

这是一段利用了HttpUrlConnect来发起的请求，请求中provider的地址写死了，意味着provider和consumer高度绑定在一起，这个不符合微服务的思想。要改造他，我们可以借助Eureka Client提供的工具，利用这个工具。我们可以更具服务从Eureka Server上查询到一个服务的详细信息。改造后的代码如下：

@Autowired
    DiscoveryClient discoveryClient;
    //包不要导入出错了（import org.springframework.cloud.client.discovery.DiscoveryClient;）
    @GetMapping("/hello2")
    public String hello2(){
       List<ServiceInstance> list =discoveryClient.getInstances("provider");
       ServiceInstance instance=list.get(0);
       String host=instance.getHost();
       int port = instance.getPort();
       StringBuffer sb= new StringBuffer();
       sb.append("http://")
               .append(host)
               .append(":")
               .append(port)
               .append("/hello");
        HttpURLConnection con=null;
        try {
            URL url = new URL(sb.toString());
            con=(HttpURLConnection) url.openConnection();
            if(con.getResponseCode()==200){
                BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
                String s=br.readLine();
                br.close();
                return s;

            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";
    }

注意，DiscoverClient查询到的服务列表是一个集合，因为服务在部署的时候，可能是集群化部署，首先修改provider中的hello接口

@RestController
public class HelloController {
    @Value("${server.port}")
    Integer port;
    @GetMapping("/hello")
    public String hello(){
        return "hello jiangbeicheng!";
    }
}

因为我一会启动多个provider实例，多个provider实例的端口号不同，为了区分调用时到底调用的是哪一provider提供的服务，在这个接口返回端口，修改完成后对provider进行打包，打包成功后，在命令行启动两个个provider实例

java-jar provider-0.0.1-SNAPSHOT.jar --server.port=1113
java-jar provider-0.0.1-SNAPSHOT.jar --server.port=1116

启动成功后，检查Eureka Server 是否成功注册进来
注册成功后，在consumer中在去调用provider DiscoveryClient集合中，获取到的不是一个实例而是两个实例。
从集合中获取数据时候通过一个小小举动就可以实现线性负载均衡

 int count =0;
    @GetMapping("/hello3")
    public String hello3(){
        List<ServiceInstance> list =discoveryClient.getInstances("provider");
        ServiceInstance instance=list.get((count++)%list.size());
        String host=instance.getHost();
        int port = instance.getPort();
        StringBuffer sb= new StringBuffer();
        sb.append("http://")
                .append(host)
                .append(":")
                .append(port)
                .append("/hello");
        HttpURLConnection con=null;
        try {
            URL url = new URL("http://localhost:1113/hello");
            con=(HttpURLConnection) url.openConnection();
            if(con.getResponseCode()==200){
                BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
                String s=br.readLine();
                br.close();
                return s;

            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";
    }

升级改造：
http调用
负载均衡
Http调用，我们使用Spring提供的RestTemplate来实现。

package org.jiangbeicheng.comsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class ComsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ComsumerApplication.class, args);
    }
    @Bean
    RestTemplate restTemplateOne(){
        return new RestTemplate();
    }
}

然后，在Http调用时候，不在使用HttpUrlConnection 而是直接使用RestTemplate

    @Autowired
    RestTemplate restTemplate;
    @Autowired
    DiscoveryClient discoveryClient;
    //包不要导入出错了（import org.springframework.cloud.client.discovery.DiscoveryClient;）
    @GetMapping("/hello2")
    public String hello2(){
       List<ServiceInstance> list =discoveryClient.getInstances("provider");
       ServiceInstance instance=list.get(0);
       String host=instance.getHost();
       int port = instance.getPort();
       StringBuffer sb= new StringBuffer();
       sb.append("http://")
               .append(host)
               .append(":")
               .append(port)
               .append("/hello");
        /*HttpURLConnection con=null;
        try {
            URL url = new URL("http://localhost:1113/hello");
            con=(HttpURLConnection) url.openConnection();
            if(con.getResponseCode()==200){
                BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));
                String s=br.readLine();
                br.close();
                return s;

            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";*/
        String s = restTemplate.getForObject(sb.toString(), String.class);
        return s;
    }

用一行代码就实现了Http的调用
接下来使用Rubbon来快速实现负载均衡
首先，我们需要给RestTemplate实例添加一个@LoadBalancer注解，开启负载均衡：

package org.jiangbeicheng.comsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class ComsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ComsumerApplication.class, args);
    }
    @Bean
    RestTemplate restTemplateOne(){
        return new RestTemplate();
    }
    @Bean
    @LoadBalanced
    RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

此时候RestTemplate 就自动具备了负载均衡的功能。

    @Autowired
    @Qualifier("restTemplate")
    RestTemplate restTemplate;
    @GetMapping("/hello3")
    public String hello3(){
        return restTemplate.getForObject("http://provider/hello",String.class);
    }