dubbo的负载均衡是基于服务层面的，是一个中间件，而nginx的负载均衡是在http请求层面，是一个软件。两者所处的位置是不同的，至于二者哪个优秀，感觉没办法去比较。不过，如果没要去比较，也能说出个一二三来。 

        dubbo具备了server服务的注册，发现、路由、负载均衡的功能，在所有实现了这些功能的服务治理组件中，dubbo的性能与高效率是毋庸置疑的，毕竟dubbo撑起了阿里的很多业务，跟阿里内部使用的tddl（头都大了），hsf（好师傅、好舒服（别理解错了哦））都是为了解决同样的问题而衍生出的不同中间件。dubbo在服务发现这个地方做的更像一个dns，一个消费者需要知道哪里有这么一个服务，dubbo告诉他，然后他自己去调用。 

        nginx在具备了以上功能，还有两个最主要的功能是：维持尽可能多的连接；把每个连接的具体服务需求根据负载均衡算法pass到真正的worker上（即nginx的反向代理、负载均衡特性）。  

        nginx是横在用户的浏览器和自家的服务器之间，nginx似乎跟web应用有着撇不清的关系，而dubbo是横在自家的服务器和自家的服务器之间，dubbo处理的可以是纯粹的java接口服务，并不一定跟web有关。

 

微服务间的互相调用和负载均衡实现
一、Eureka作为服务注册中心
二、feign实现微服务的之间的调用
三、在模块中添加Feign依赖，在主启动类中添加扫描注解
四、编写测试demo
五、启动访问测试，会发现访问时带有轮询机制的负载均衡。

一、Eureka作为服务注册中心
服务注册中心对整个微服务架构起着最核心的整合作用，因此对Eureka还是有很大的必要进行深入研究。

Eureka与zookeeper的区别：
著名的CAP理论指出，一个分布式系统不可能同时满足C(一致性)、A(可用性)和P(分区容错性)。由于分区容错性在是分布式系统中必须要保证的，因此我们只能在A和C之间进行权衡。在此Zookeeper保证的是CP, 而Eureka则是AP。Zookeeper保证CP
Eureka保证AP
Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册或时如果发现连接失败，则会自动切换至其它节点，只要有一台Eureka还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。除此之外，Eureka还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障，此时会出现以下几种情况：

Eureka不再从注册列表中移除因为长时间没收到心跳而应该过期的服务
Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)
当网络稳定时，当前实例新的注册信息会被同步到其它节点中

Eureka具体设置流程

一、改造工作

在eureka-server工程中resources文件夹下，创建配置文件application-peer1.yml:

server:
  port: 8761

spring:
  profiles: peer1
eureka:
  instance:
    hostname: peer1
  client:
    serviceUrl:
      defaultZone: http://peer2:8769/eureka/

并且创建另外一个配置文件application-peer2.yml：
server:
  port: 8769

spring:
  profiles: peer2
eureka:
  instance:
    hostname: peer2
  client:
    serviceUrl:
      defaultZone: http://peer1:8761/eureka/

这时eureka-server就已经改造完毕。
按照官方文档的指示，需要改变etc/hosts，linux系统通过vim /etc/hosts ,加上：
127.0.0.1 peer1
127.0.0.1 peer2

windows电脑，在c:/windows/systems/drivers/etc/hosts 修改。
这时需要改造下service-hi:
eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:8761/eureka/
server:
  port: 8762
spring:
  application:
    name: service-hi


二、启动工程

启动eureka-server：

java -jar eureka-server-0.0.1-SNAPSHOT.jar - -spring.profiles.active=peer1
java -jar eureka-server-0.0.1-SNAPSHOT.jar - -spring.profiles.active=peer2

启动service-hi:
java -jar service-hi-0.0.1-SNAPSHOT.jar

访问：localhost:8761,如图：


你会发现注册了service-hi，并且有个peer2节点，同理访问localhost:8769你会发现有个peer1节点。
client只向8761注册，但是你打开8769，你也会发现，8769也有 client的注册信息。
二、feign实现微服务的之间的调用
Feign简介

Feign是一个声明式的伪Http客户端，它使得写Http客户端变得更简单。使用Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。
简而言之：

Feign 采用的是基于接口的注解
Feign 整合了ribbon

Feign解决了什么问题

封装了Http调用流程，更适合面向接口化的变成习惯

在服务调用的场景中，我们经常调用基于Http协议的服务，而我们经常使用到的框架可能有HttpURLConnection、Apache HttpComponnets、OkHttp3 、Netty等等，这些框架在基于自身的专注点提供了自身特性。而从角色划分上来看，他们的职能是一致的提供Http调用服务。具体流程如下：


三、在模块中添加Feign依赖，在主启动类中添加扫描注解
添加Feign依赖

新建一个spring-boot工程，取名为serice-feign，在它的pom文件引入Feign的起步依赖spring-cloud-starter-feign、Eureka的起步依赖spring-cloud-starter-eureka、Web的起步依赖spring-boot-starter-web，代码如下：
<?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.forezp</groupId>
	<artifactId>service-feign</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>service-feign</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.2.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>
	</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-feign</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</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>Dalston.RC1</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>

	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
	</repositories>


</project>

在主启动类中添加扫描注解

在程序的启动类ServiceFeignApplication ，加上@EnableFeignClients注解开启Feign的功能：
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ServiceFeignApplication {

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

四、编写测试demo
在工程的配置文件application.yml文件，指定程序名为service-feign，端口号为8765，服务注册地址为http://localhost:8761/eureka/ ，代码如下：
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
server:
  port: 8765
spring:
  application:
    name: service-feign

定义一个feign接口，通过@ FeignClient（“服务名”），来指定调用哪个服务。比如在代码中调用了service-hi服务的“/hi”接口，代码如下：
/**
 * Created by fangzhipeng on 2017/4/6.
 */
@FeignClient(value = "service-hi")
public interface SchedualServiceHi {
    @RequestMapping(value = "/hi",method = RequestMethod.GET)
    String sayHiFromClientOne(@RequestParam(value = "name") String name);
}

在Web层的controller层，对外暴露一个"/hi"的API接口，通过上面定义的Feign客户端SchedualServiceHi 来消费服务。代码如下：
@RestController
public class HiController {

    @Autowired
    SchedualServiceHi schedualServiceHi;
    @RequestMapping(value = "/hi",method = RequestMethod.GET)
    public String sayHi(@RequestParam String name){
        return schedualServiceHi.sayHiFromClientOne(name);
    }
}

五、启动访问测试，会发现访问时带有轮询机制的负载均衡。
启动程序，多次访问http://localhost:8765/hi?name=forezp,浏览器交替显示：
hi forezp,i am from port:8762

hi forezp,i am from port:8763

在微服务架构中，业务都会被拆分成一个独立的服务，服务与服务的通讯是基于http restful的。Spring cloud有两种服务调用方式，一种是ribbon+restTemplate模式，另一种是feign模式

Ribbon+RestTemplate

Ribbon 是一个基于 HTTP 和 TCP 客户端 的负载均衡的工具。它可以 在客户端 配置 RibbonServerList（服务端列表），使用 HttpClient 或 RestTemplate 模拟 http 请求，步骤比较繁琐。

Feign

Feign 是在 Ribbon 的基础上进行了一次改进，是一个使用起来更加方便的 HTTP 客户端。采用接口的方式， 只需要创建一个接口，然后在上面添加注解即可 ，将需要调用的其他服务的方法定义成抽象方法即可， 不需要自己构建 http 请求。然后就像是调用自身工程的方法调用，而感觉不到是调用远程方法，使得编写客户端变得非常容易。 

Feign和 RestTemplate都内置了Ribbon

一、创建Eureka注册中心

1.创建一个maven项目，在pom.xml添加依赖jar文件

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>
    <dependencyManagement>
        <dependencies>
            <!-- 导入Spring Cloud的依赖管理 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <!--springboot 整合eureka服务端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

2.创建application.yml文件

###服务端口号
server:
  port: 1011
###服务名称
spring:
  application:
    name: app-eureka-center
eureka:
  instance:
    #注册中心地址
    hostname: 192.168.199.101
###客户端调用地址
  client:
    serviceUrl:
      defaultZone: http://192.168.199.101:1011/eureka/
###是否将自己注册到Eureka服务中,因为该应用本身就是注册中心，不需要再注册自己（集群的时候为true）
    register-with-eureka: false
###是否从Eureka中获取注册信息,因为自己为注册中心,不会在该应用中的检索服务信息
    fetch-registry: false
  server:
    enable-self-preservation:true

3.创建服务启动类

@SpringBootApplication
@EnableEurekaServer //申明这是一个Eureka服务
public class SncApplication {

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


4.项目结构图



5、测试



二、创建服务提供者

1.创建一个maven项目，在pom.xml中导入依赖jar

     <parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.12.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.shsnc</groupId>
	<artifactId>snc-base-service</artifactId>
	<version>1.0</version>
	<name>snc-base-service</name>
	<description>snc-base-service</description>

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

	</dependencyManagement>  

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

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

2.创建application.properties文件

spring.application.name=base-user-center
server.port=10011
eureka.client.serviceUrl.defaultZone=http://192.168.199.101:1011/eureka/

3.创建UserController接口

@RestController
@RequestMapping("/user")
public class UserController {
	
	@RequestMapping("/getUserList")
	@ResponseBody
	public ModelMap getUserList() {
		ModelMap modelMap = new ModelMap();
		List<String> userList = new ArrayList<String>();
		userList.add("用户1");
		userList.add("用户2");
		userList.add("用户3");
		modelMap.put("data", userList);
		return modelMap;
	}
}

4.创建启动类

@SpringBootApplication
@EnableFeignClients
@EnableEurekaClient
public class SncApplication {

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

5.测试 



6、在eureka注册中心上的效果



 

三、创建服务消费者

1.创建一个maven项目，在pom.xml中导入依赖jar文件

	<groupId>com.shsnc</groupId>
	<artifactId>snc-kanban-service</artifactId>
	<version>1.0</version>
	<name>snc-kanban-service</name>
	<description>snc-kanban-service</description>

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

     <dependencyManagement>
		   <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
	</dependencyManagement>  
     <dependency>
	 	    <groupId>org.springframework.cloud</groupId>
		    <artifactId>spring-cloud-starter-openfeign</artifactId>
		</dependency>
		<dependency>
		    <groupId>org.springframework.cloud</groupId>
		    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
	  </dependency>

2.创建application.properties文件

spring.application.name=snc-kanban-service
server.port=30006
eureka.client.serviceUrl.defaultZone=http://192.168.199.101:1011/eureka/

3.创建feign客户端接口

@FeignClient(name = "BASE-USER-CENTER")
public interface UserService {
	@RequestMapping(value = "/user/getUserList")
	public ModelMap getUserList();
}

4.创建消费者接口

@RestController
@RequestMapping("/order")
public class OrderController {
	@Autowired
	UserService userService;
	@RequestMapping("/getUserList")
	public ModelMap getUserList() {
		return userService.getUserList();
	}
}

5.创建启动类

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class SncApplication {

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


6、测试， 成功！

 



参考：https://blog.csdn.net/qq_42296117/article/details/106073073

Spring、Spring Boot和Spring Cloud的区别
Spring 以 Bean（对象） 为中心，提供 IOC、AOP 等功能。

Spring Boot 以 Application（应用） 为中心，提供自动配置、监控等功能。

Spring Cloud 以 Service（服务） 为中心，提供服务的注册与发现、服务的调用与负载均衡等功能。
Spring Cloud 功能
Spring Cloud focuses on providing good out of box experience for typical use cases and extensibility mechanism to cover others.

Distributed/versioned configuration
Service registration and discovery
Routing
Service-to-service calls
Load balancing
Circuit Breakers
Global locks
Leadership election and cluster state
Distributed messaging

Spring Boot 功能

Create stand-alone Spring applications
Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
Provide opinionated ‘starter’ dependencies to simplify your build configuration
Automatically configure Spring and 3rd party libraries whenever possible
Provide production-ready features such as metrics, health checks, and externalized configuration
Absolutely no code generation and no requirement for XML configuration

Spring 功能

Core technologies: dependency injection, events, resources, i18n, validation, data binding, type conversion, SpEL, AOP.
Testing: mock objects, TestContext framework, Spring MVC Test, WebTestClient.
Data Access: transactions, DAO support, JDBC, ORM, Marshalling XML.
Spring MVC and Spring WebFlux web frameworks.
Integration: remoting, JMS, JCA, JMX, email, tasks, scheduling, cache.
Languages: Kotlin, Groovy, dynamic languages.

参考资料
https://spring.io/projects/spring-cloud

https://spring.io/projects/spring-boot

https://spring.io/projects/spring-framework

http://start.spring.io