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=false

server.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对服务调用的负载均衡。

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

猜你喜欢