SpringCloud Eureka

什么是服务治理

在传统的RPC远程调用中，服务与服务依赖关系，管理比较复杂，所以需要使用服务治理，用于管理服务与服务之间的依赖关系，实现服务调用，负载均衡，容错，服务发现与注册

服务注册与发现

在RPC远程调用，其关键是服务治理，服务治理的核心是注册中心，当服务启动时，生产者会以别名的方式，将自己的通讯地址注册到注册中心，消费者从注册中心获取获取生产者通讯地址列表，然后在本地根据通讯地址，轮询调用生产者接口

Eureka

Eureka是Netflix开发的服务发现框架，本身是一个基于REST的服务，主要用于定位运行在AWS域中的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务发现功能。
Eureka包含两个组件：Eureka Server和Eureka Client。
Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。
Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就是一个内置的、使用轮询(round-robin)负载算法的负载均衡器。
在应用启动后，将会向Eureka Server发送心跳,默认周期为30秒，如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。
Eureka Server之间通过复制的方式完成数据的同步，Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API。综上，Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。

搭建eureka Server服务

废话不多说，使用maven 管理包，搭建eureka服务

pom文件

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>
    <!-- 管理依赖 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.M7</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <!--SpringCloud eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>
    <!-- 注意： 这里必须要添加， 否者各种依赖有问题 -->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/libs-milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

application.yml

server:
  port: 8200
eureka:
  instance:
    ###注册到eurekaip地址
    hostname: 127.0.0.1
  client:
    serviceUrl:
      defaultZone: http://127.0.0.1:8200/eureka/
      ###因为自己是为注册中心，不需要自己注册自己
      register-with-eureka: false
      ###因为自己是为注册中心，不需要检索服务
      fetch-registry: false
  server:
    # 测试时关闭自我保护机制，保证不可用服务及时踢出
    enable-self-preservation: false
    ##剔除失效服务间隔
    eviction-interval-timer-in-ms: 2000

spring:
    application:
      name: eureka-server

在java目录创建java类AppEureka

package com.huakai.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * @author 花开
 * @create 2019-08-13 20:17
 * @desc Eureka 服务注册中心启动类
 **/
@EnableEurekaServer  //开启eurekaServer
@SpringBootApplication // 开启springboot业务
public class AppEureka {

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

在AppEureka 执行main方法，启动EurekaServer端

生产服务 member

demo 采用聚合项目，首先创建springcloud-api 项目，maven类型为pom
在springcloud-api 创建module springcloud-api-member-interface，定义接口类，将接口类和实现类分开
在spring cloud-api 创建module springcloud-api-memer-interface-impl 定义实现类

springcloud-api-member-interface

pom.xml
应为该项目为接口项目，不需要引用任何jar包配置

<?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">
    <parent>
        <artifactId>springcloud-2.0-api</artifactId>
        <groupId>com.zhibinwang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-api-member-interfacee</artifactId>


</project>

创建java类 IMemberService

import com.zhibinwang.api.entity.UserEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @author 花开
 * @create 2019-08-08 23:45
 * @desc
 **/
public interface IMemberService {


    @RequestMapping("/getMember")
    String  getMember(@RequestParam(value = "name") String name);

    @RequestMapping("getUserinfo")
    String getUserinfo();
}

接口Module springcloud-api-member-interface 创建完成

springcloud-api-memer-interface-impl

pom.xml

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>
    <!-- 管理依赖 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.M7</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <!-- SpringBoot整合Web组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- SpringBoot整合eureka客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- SpringBoot整合fegnin客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--引入接口类-->
        <dependency>
            <groupId>com.huakai</groupId>
            <artifactId>springcloud-api-member-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>
    <!-- 注意： 这里必须要添加， 否者各种依赖有问题 -->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/libs-milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

接口实现类

import com.zhibinwang.api.entity.UserEntity;
import com.zhibinwang.api.service.IMemberService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 花开
 * @create 2019-08-08 23:51
 * @desc
 **/
@RestController
public class MemberServiceImpl implements IMemberService {


    @Value("${server.port}")
    private String port;
	
	// 也可以直接返回对象， 简单测试
    @RequestMapping("/getMember")
    public String getMember( @RequestParam("name") String name) {
        UserEntity userEntity = new UserEntity();
        userEntity.setName(name);
        userEntity.setAge(11);
        System.out.println(port);
        return userEntity.toString();
    }

    @RequestMapping("/getUserinfo")
    public String getUserinfo() {
        System.out.println("getUserInfo");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "orderT oMember 成功";
    }
}

启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

/**
 * @author 花开
 * @create 2019-08-09 0:00
 * @desc
 **/
@SpringBootApplication 
@EnableEurekaClient // 启动eureka 客户端
@EnableFeignClients // 启用feign客户端
public class AppMember {

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

application.yml

###服务启动端口号
server:
  port: 8003
###服务名称(服务注册到eureka名称)
spring:
  application:
    name: app-member
###服务注册到eureka地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8100/eureka


    ###因为该应用为注册中心，不会注册自己
    register-with-eureka: true
    ###是否需要从eureka上获取注册信息
    fetch-registry: true

启动AppMember 的main方法，将服务注册到eureka上

消费者服务 Order

在springcloud-api 创建module springcloud-api-order-interface，定义接口类，将接口类和实现类分开
在spring cloud-api 创建module springcloud-api-order-interface-impl 定义实现类

springcloud-api-order-interface

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

/**
 * @author 花开
 * @create 2019-08-09 0:02
 * @desc
 **/
public interface IOrderService {

    @RequestMapping("/getOrder")
    String getOrder(@RequestParam("name") String name);
}

springcloud-api-order-interface -impl

pom.xml 和springcloud-api-member-interface-impl 一样

接口实现类

import com.itmayiedu.base.BaseApiService;
import com.itmayiedu.base.ResponseBase;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.zhibinwang.api.entity.UserEntity;
import com.zhibinwang.service.IOrderService;
import com.zhibinwang.service.feign.IMemberFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 花开
 * @create 2019-08-09 0:08
 * @desc
 **/
@RestController
public class OrderSeriviceImp implements IOrderService {

    @Autowired
    private IMemberFeign memberFeign;

    @Override
    @RequestMapping("/getOrder")
    public  String getOrder( @RequestParam(value = "name") String name){

        UserEntity member = memberFeign.getMember(name);

        return member == null ?"会员为空":member.getName();
    }


}

创建FeignClient接口类

import com.zhibinwang.api.service.IMemberService;
import org.springframework.cloud.openfeign.FeignClient;

/**
 * @author 花开
 * @create 2019-08-09 0:06
 * @desc
 **/
@FeignClient(name = "app-member",) //这里为member服务别名
public interface IMemberFeign extends IMemberService {
}

AppOrder 服务启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.openfeign.EnableFeignClients;

/**
 * @author 花开
 * @create 2019-08-09 0:13
 * @desc
 **/
@SpringBootApplication
@EnableFeignClients  //启用feign
@EnableEurekaClient //启动用eurekaClient

public class AppOrder {

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

application.yml

###服务启动端口号
server:
  port: 8001
###服务名称(服务注册到eureka名称)
spring:
  application:
    name: app-order
###服务注册到eureka地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8100/eureka
    ###因为该应用为注册中心，不会注册自己
    register-with-eureka: true
    ###是否需要从eureka上获取注册信息
    fetch-registry: true

执行main方法启动服务，向eureka 注册服务

访问order服务

此时启动了三个服务，eureka Server ，order服务，member服务

通过浏览器访问http://127.0.0.1:8001/getOrder?name=aa
即可实现order远程调用member服务

简单的eureke 初步调用就到这里了