SpringCloud-Eureka服务注册中心-02

Eureka服务注册中心

使用Eureka之前

新建一个父maven工程springcloud

  1. pom.xml引入依赖并修改打包方式
<packaging>pom</packaging>
<properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <lombok.version>1.16.18</lombok.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--springcloud的依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.4.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.21</version>
            </dependency>
            <!--springboot启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.0</version>
            </dependency>
            <!--日志测试-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
        </dependencies>
      </dependencyManagement>
  1. 创建三个子module,分别为springcloud-api,springcloud-provider-dept-8001(提供者),springcloud-consumer-dept-80(调用者)
    image

api

  1. 根据数据库配置api的实体类(com.sli.springcloud.pojo.Dept)
@Data
@NoArgsConstructor
@Accessors(chain = true)//链式写法
public class Dept implements Serializable {//Dept 实体类, 实体类需要序列化
    private Long deptno;
    private String dname;
    //这个数据存在哪个数据库字段,一个服务对应一个数据库,同一个信息可能存在不同的数据库中
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }
    /*
    链式写法
        Dept dept = new Dept();
        dept.setDeptNo(11);
            .setDname('qwq')
            .setDb_source();
     */
}

提供者

  1. 导入依赖
  <dependencies>
        <!--需要拿到实体列,需要配置api module-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>spirngcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
  1. 配置提供者的appliaction.yaml
server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.sli.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#spring配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: ?????
  1. 在resource中新建mybatis并配置mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-/mybatis.ort//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>
  1. 创建com.sli.springcloud.dao.DeptDao接口
@Mapper
@Repository
public interface DeptDao {

    //此处的Dept为上一个服务中的,是通过刚开始配置的pom文件导入的
    public boolean addDept(Dept dept);

    public Dept queryDeptById(Long id);

    public List<Dept> queryAll();

}
  1. 创建在mybatis中新建mapper.DeptMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-/mybatis.ort//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sli.springcloud.dao.DeptDao">
    <insert id="addDept" parameterType="Dept">/*传入值为parameterType,返回值为resourceType*/
        insert into dept (dname,db_source)
        value (#{dname},DATABASE())
    </insert>

    <select id="queryDeptById" resultType="Dept" parameterType="Long">
        select * from dept where deptno = #{deptno}
    </select>

    <select id="queryAll" resultType="Dept" parameterType="Long">
        select * from dept;
    </select>
</mapper>
  1. 创建server.Deptservice接口和其实现类
public interface DeptService {

    public boolean addDept(Dept dept);

    public Dept queryDeptById(Long id);

    public List<Dept> queryAll();

}

@Service
public class DeptServiceImpl implements DeptService{

    @Autowired
    private DeptDao deptDao;

    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }

    @Override
    public Dept queryDeptById(Long id) {
        return deptDao.queryDeptById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}
  1. 创建controller.DeptController实现业务逻辑
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @Autowired
    private DiscoveryClient client;

    //提交用post提交安全
    @PostMapping("/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/dept/get/{id}")
    public Dept queryDeptById(@PathVariable("id")Long id){
        return deptService.queryDeptById(id);
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }
  1. 创建主启动类DeptProvider_8001
    1. 添加注解@SpringBootApplication
    2. main方法中SpringApplication.run(DeptProvider_8001.class,args);
@SpringBootApplication
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}
  1. 完成之后启动测试一下看看能否访问到数据库中的文件

调用者

  1. 导入依赖
 <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>spirngcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
  1. application.yaml
server:
  port: 80
  1. com.sli.springcloud.config.ConfigBean
@Configuration//是spring中的注解,相当于applicationContext.xml
public class ConfigBean {
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}
  1. controller
@RestController
public class DeptConsumerController {
    //理解:调用者没有service层
    //如何调用提供者的service层呢
    //RestTemplate:方法可以被我们直接调动--->需要注册到spring中
    //(url , 实体:Map , Class<T> responseType)--->(url地址,需要传递一个参数的时候需要写,返回值)
    @Autowired
    private RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法,简单的restful服务模板

    private static final String REST_URL_PREFIX = "http://localhost:8001";


    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id")Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);

    }

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add/",dept,Boolean.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }
}
  1. 主启动类
@SpringBootApplication
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}
  1. 完成之后先开启提供者,然后开启调用者,看看能否使用三个方法

使用Eureka

什么是eureka?

类似于zookeeper注册中心

原理理解

image

  • Eureka 包含两个组件：Eureka Server 和 Eureka Client.
  • Eureka Server 提供服务注册，各个节点启动后，回在EurekaServer中进行注册，这样Eureka Server中的服务注册表中将会储存所有课用服务节点的信息，服务节点的信息可以在界面中直观的看到.
  • Eureka Client 是一个Java客户端，用于简化EurekaServer的交互，客户端同时也具备一个内置的，使用轮询负载算法的负载均衡器。在应用启动后，将会向EurekaServer发送心跳 (默认周期为30秒) 。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除掉 (默认周期为90s).

三大角色

  • Eureka Server：提供服务的注册与发现
  • Service Provider：服务提供方，将自身服务注册到Eureka中，从而使服务调用方能狗找到
  • Service Consumer：服务调用方，从Eureka中获取注册服务列表，从而找到调用的服务

使用了Eureka之后

  1. springcloud-eureka-7001模块建立
  2. pom.xml配置
 <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

3.application.yaml

server:
  port: 7001
#Eurka配置
eureka:
  instance:
    hostname: eureka7001.com #Eureka服务端的实例名称
  client:
    register-with-eureka: false #是否向eureka中心注册自己
    fetch-registry: false #如果为false则表示自己为注册中心
    service-url:
      #单机的:如下  deafaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #监控页面的地址
      #集群:关联
      deafaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  1. 主启动类
@SpringBootApplication
@EnableEurekaServer//表示这是服务端的启动类,可以接收别人注册进去
public class EurekaServer_7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7001.class,args);
    }
}
  1. 启动之后访问http://localhost:7001/ 就可以看到一个spring eureka页面
  2. 修改之前的提供者,让其可以注册到注册中心
    1. 导入依赖
    <!--加入eureka依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>
    <!--actuator完善监控信息-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
        <version>2.3.1.RELEASE</version>
    </dependency>
    1. application.yaml中增加如下的设置
    #eureka配置
eureka:
client:
	service-url:
 	 defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance-id: springcloud-provider-dept8001 #修改eureka的默认描	述信息
#info配置
info:
	app.name: sli-springcloud
	company.name: blog.sli.com
    1. 在主启动类中添加@@EnableEurekaClient //在服务启动后自动注册到eureka的服务中心中
  3. 开启7001之后再开启8001进行测试,访问监控页面,能看到application中有一个springcloud-provider-dept则成功
  4. 集群不单独介绍,和上面差不多,详见workspace SpringCloud

对比和Zookeeper的区别

  1. ACID是什么?
  • A原子性
  • C一致性
  • I隔离性
  • D持久性
  1. CAP是什么?
  • C强一致性
  • A可用性
  • P分区容错性
    三个只能生效两个
  1. CAP理论的核心

  • 一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求

  • 根据CAP原理，将NoSQL数据库分成了满足CA原则，满足CP原则和满足AP原则三大类

  • CA：单点集群，满足一致性，可用性的系统，通常可扩展性较差

  • CP：满足一致性，分区容错的系统，通常性能不是特别高

  • AP：满足可用性，分区容错的系统，通常可能对一致性要求低一些

  1. 作为分布式服务注册中心,Eureka比Zookeeper好在哪里
  • zookeeper保证的是一致性,分区容错的系统,通常性能不高
  • Eureka保证的是可用性,分区容错性,通常可能对一致性的要求低

Zookeeper保证的是CP

当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的注册信息，但不能接收服务直接down掉不可用。也就是说，服务注册功能对可用性的要求要高于一致性。但zookeeper会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举。问题在于，选举leader的时间太长，30-120s，且选举期间整个zookeeper集群是不可用的，这就导致在选举期间注册服务瘫痪。在云部署的环境下，因为网络问题使得zookeeper集群失去master节点是较大概率发生的事件，虽然服务最终能够恢复，但是，漫长的选举时间导致注册长期不可用，是不可容忍的。

Eureka保证的是AP

Eureka看明白了这一点，因此在设计时就优先保证可用性。Eureka各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而Eureka的客户端在向某个Eureka注册时，如果发现连接失败，则会自动切换至其他节点，只要有一台Eureka还在，就能保住注册服务的可用性，只不过查到的信息可能不是最新的，除此之外，Eureka还有之中自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就认为客户端与注册中心出现了网络故障

因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像zookeeper那样使整个注册服务瘫痪

Eureka的集群环境配置

  1. 初始化(新建两个module为springcloud-eureka-7002/7003)并未pom.xml添加依赖
<!--导包~-->
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
    <!--导入Eureka Server依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>
  1. application.yaml配置(与springcloud-eureka-7001相同)
#eureka配置
eureka:
  client:
    service-url:
     defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
    instance-id: springcloud-provider-dept8001 #修改eureka的默认描	述信息
#info配置
info:
  	app.name: sli-springcloud
  	company.name: blog.sli.com
  1. 主启动类(与springcloud-eureka-7001相同)
@SpringBootApplication
// @EnableEurekaServer 服务端的启动类，可以接受别人注册进来~
public class EurekaServer_7003 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer_7003.class,args);
    }
}
  1. C:\Windows\System32\drivers\etc\host修改
    image
  2. 修改applicaiton.yaml配置,将各自的hostname改为eureka7001/7002/7003.com
  3. 在集群中使springcloud-eureka-7001关联7002,7003.并使他们三个互相关联
    image
  4. springcloud-provider-dept-8001下的yaml配置文件,修改Eureka配置:配置注册服务中心地址
    image
  5. 模拟集群就搭建好了,可以将一个项目挂载到三个服务器上
    image
posted @ 2021-10-03 20:27  1_f  阅读(19)  评论(0)    收藏  举报