springcloud学习笔记二：服务提供、消费与ribbon

在学习笔记一里，我们简单实现了一个注册中心，我们就可以在上面进行服务的注册与订阅消费。

编写服务，进行注册

同样，我们可以在STS中右键New->Spring Starter Project ，填写相应内容->点击next


选择需要的依赖包，我们这里由于是构建一个服务提供者，要发现注册中心，所以我们勾选Eureka Dicovery，然后点击finish



这样STS就帮我们创建了一个服务提供者应用，下面是完整的pom文件。

<?xml version="1.0" encoding="UTF-8"?>
<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>com.point</groupId>
<artifactId>point-provider</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>point-provider</name>
<description>test provider</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-cloud.version>Dalston.SR2</spring-cloud.version>
</properties>

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

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>
我们还需要配置一些功能完成我们的服务注册。
在入口类添加注解@EnableDiscoveryClient，用于发现注册中心。

@EnableDiscoveryClient
@SpringBootApplication
public class PointProviderApplication {

public static void main(String[] args) {
SpringApplication.run(PointProviderApplication.class, args);
}
}

在application.properties中添加相应配置
spring.application.name=point-provider
server.port=2000
eureka.client.serviceUrl.defaultZone=http://localhost:1000/eureka/spring.application.name:服务名称，注册到注册中心中的名称，用于消费者使用。
server.port：服务端口

eureka.client.serviceUrl.defaultZone：注册中心注册地址

配置完以上后，我们启动该服务，然后访问我们的注册中心(注册中心的创建可以参考上一篇文章http://blog.csdn.net/u011890101/article/details/77116090)。



我们发现名称为point-provider的服务已经成功在注册中心完成注册，这样我们就可以编写消费端来消费我们已经注册的服务。

服务消费端

编写消费端不得不提到的一个技术就是Ribbon，它能帮我们实现负载均衡，即我们可以部署多个同样的服务提供者，通过ribbon，消费者可以根据多种负载策略去消费其中一个服务提供者。

我们先在服务提供者中编写一个服务方法

@RestController
@RequestMapping("provider")
public class ProviderController {

@GetMapping("getName")
public String getName(){
System.out.println("服务被调用2000");
  return "meepoGuan";
}
}然后我们将服务提供者point-provider编译成jar部署下，同时修改端口为2001，启动，我们的2000同样也进行启动，这样就相当于我们启动了两个point-provider。



访问注册中心，可以看到名称为point-provider的服务，已经有2000、2001两个实例在运行。

下一步我们就可以编写我们的消费者，通过ribbon进行负载均衡来访问我们的point-provider服务。

还是通过STS进行创建

右键New->Spring Starter Project ，填写相应内容->点击next



选择需要的依赖包，我们这里选择Eureka Dicovery与Ribbon



点击finish创建完毕，完整pom为：

<?xml version="1.0" encoding="UTF-8"?>
<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>com.point</groupId>
<artifactId>point-consumer</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>point-consumer</name>
<description>test consumer</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-cloud.version>Dalston.SR2</spring-cloud.version>
</properties>

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

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

</project>
开始对消费端进行一些配置
与服务提供者一样，在入口类添加@EnableDiscoveryClient，用于发现注册中心。

由于我们服务提供者是提供rest服务，所以我们需要引入下RestTemplate类，进行远程访问，同时加入@LoadBalanced，用ribbon帮我们实现负载均衡，访问服务列表。

@EnableDiscoveryClient
@SpringBootApplication
public class PointConsumerApplication {

public static void main(String[] args) {
SpringApplication.run(PointConsumerApplication.class, args);
}

@Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}
}配置application.properties
server.port=3000
spring.application.name=point-consumer
eureka.client.serviceUrl.defaultZone=http://localhost:1000/eureka/
eureka.client.register-with-eureka=falseserver.port：端口
spring.application.name：服务名称

eureka.client.serviceUrl.defaultZone：注册中心地址

eureka.client.register-with-eureka：是否注册到注册中心，因为我们这里是编写的消费端，所以不需要。

编写controller远程访问服务提供者提供的方法。

@RestController
@RequestMapping("consumer")
public class ConsumerController {

@Autowired
private RestTemplate restTemplate;

@GetMapping("getName")
public String getName(){
return restTemplate.getForObject("http://point-provider/provider/getName", String.class);
}
}

http://point-provider/provider/getName

这里的point-provider即是我们的服务提供者的名称，因为我们部署了两个point-provider实例，所以我们可以依靠ribbon对两个实例进行轮询访问（ribbon默认提供的负载策略为轮询方式，当然也可以改为其它策略）。
访问消费端的方法http://localhost:3000/consumer/getName，访问两次。





可以看到两个实例分别都被调用到了一次，这样我们就实现了在消费者端用ribbon对服务调用的负载均衡。