SpringCloud之注册中心

1.Eureka(服务注册与发现)

1.1RestTemplate

它提供了多种访问远程http服务的方法，是一种简单便捷的访问restful服务模板类，是spring提供的用于访问Rest服务的客户端模板工具集。

1.2RestTemplate项目模块搭建

这里使用maven和mybatis进行模块的搭建，步骤如下。

1.2.1搭建父模块cloud-eureka-demo

1）创建一个maven工程名为cloud-eureka-demo，删除src目录

2）在pom中导入依赖

<!--统一管理jar包版本-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <lombok.version>1.16.18</lombok.version>
        <log4j.version>1.2.17</log4j.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!--  依赖管理，父工程锁定版本-->
    <dependencyManagement>
    <dependencies>
        <!--spring boot 2.2.2-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--spring cloud Hoxton.SR1-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Hoxton.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--spring cloud alibaba 2.1.0-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2.1.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.spring.boot.version}</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
    </dependencies>
    </dependencyManagement>

View Code

1.2.2搭建公共服务模块eureka-demo-api

公共服务模块用于存放公用的东西，如实体类等。

1）创建maven的工程名为eureka-demo-api，在pom中导入依赖

 <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

View Code

2）创建包com.zys.cloud.entity，在包下创建实体类User，内容如下

package com.zys.cloud.entity;

import lombok.*;


@Getter
@Setter
@ToString
public class User {
    private Long id;
    private String name;
    private String phone;
}

View Code

1.2.3搭建服务提供者模块eureka-demo-provider

1）创建maven的工程名为eureka-demo-provider，在pom中导入依赖

<dependencies>
        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--引入自己定义的模块-->
        <dependency>
            <groupId>com.zys.springcloud</groupId>
            <artifactId>eureka-demo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--eureka-client-->
       

    </dependencies>

View Code

2）创建包com.zys.cloud，在包下新建启动类ProviderMain8001

package com.zys.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

View Code

3）在com.zys.cloud包下在创建controller包，存放UserController

package com.zys.cloud.controller;

import com.zys.cloud.entity.User;
import com.zys.cloud.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/get/{id}")
    public User getUser(@PathVariable("id")long id){
        return userService.getUser(id);
    }

    @PostMapping("/add")
    public Map<String,Object> addUser(User user){
        System.out.println(user);
        Map<String,Object> map=new HashMap<>();
        if(userService.addUser(user)!=0){
            map.put("msg","添加成功");
            map.put("code",200);
        }else{
            map.put("msg","添加失败");
            map.put("code",444);
        }
        return map;
    }
}

View Code

4）在com.zys.cloud包下在创建service包，存放UserService

package com.zys.cloud.service;

import com.zys.cloud.entity.User;

public interface UserService {
    public User getUser(long id);

    int addUser(User user);
}

View Code

5）在com.zys.cloud.service包下在创建impl包，存放UserServiceImpl

package com.zys.cloud.service.impl;

import com.zys.cloud.dao.UserDao;
import com.zys.cloud.entity.User;
import com.zys.cloud.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public User getUser(long id) {
        return userDao.getById(id);
    }

    @Override
    public int addUser(User user) {
       return userDao.create(user);
    }
}

View Code

6）在com.zys.cloud包下在创建dao包，存放UserDao

package com.zys.cloud.dao;

import com.zys.cloud.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

@Mapper
public interface UserDao {
    int create(User user);

    User getById(@Param("id") Long id);
}

View Code

7）在资源目录下新建mapper文件夹，然后再创建UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zys.cloud.dao.UserDao">

    <insert id="create" parameterType="User" >
        insert into user values(null,#{name},#{phone})
    </insert>

    <resultMap id="BaseResultMap" type="com.zys.cloud.entity.User">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="name" property="name" jdbcType="VARCHAR"/>
        <result column="phone" property="phone" jdbcType="VARCHAR"/>
    </resultMap>
    <select id="getById" parameterType="Long" resultMap="BaseResultMap">
        select * from user where id=#{id};
    </select>
</mapper>

View Code

8）在资源目录下创建配置文件application.yml　　

server:
  port: 8001

spring:
  application:
    name: cloud-eureka-demo-provider
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource      #当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver        #mysql驱动包
    url: jdbc:mysql://localhost:3306/db2020?useUnicode=true&characterEncoding-utr-8&useSSL=false
    username: root
    password: 123456

mybatis:
  mapper-locations: classpath:mapper/*.xml
  #所有Entity别名类所在包
  type-aliases-package: com.zys.cloud.entity

View Code

9）创建mysql的数据库和表

create database db2021;

create table user (
  id bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'id',
  name varchar(200) DEFAULT '',
    phone varchar(200) DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;


insert into user values(null,'李明','12345600');
insert into user values(null,'赵慧','12345602');
insert into user values(null,'李凯','12345601');

View Code

10）运行测试

启动主启动类，使用postman工具输入http://127.0.0.1:8001/user/get/2使用get方式测试，再输入http://127.0.0.1:8001/user/add?name=哈哈哈&phone=123使用post方式测试。

1.2.4搭建服务消费者模块eureka-demo-consumer

1）创建maven的工程名为eureka-demo-consumer，在pom中导入依赖

    <dependencies>
        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--引入自己定义的模块-->
        <dependency>
            <groupId>com.zys.springcloud</groupId>
            <artifactId>eureka-demo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

View Code

2）创建包com.zys.cloud，在包下新建启动类ConsumerMain80

package com.zys.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

View Code

3）在com.zys.cloud包下在创建config包，存放配置类

package com.zys.cloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

//相当于spring中的applicationContext.xml
@Configuration
public class ConfigBean {

    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

View Code

4）在com.zys.cloud包下在创建controller包，存放UserController

package com.zys.cloud.controller;

import com.zys.cloud.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@RestController
@RequestMapping("/consumer")
public class UserController {
    private final  String BASE_URL="http://127.0.0.1:8001";

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/get/{id}")
    public User getUser(@PathVariable("id") long id){
        return restTemplate.getForObject(BASE_URL+"/user/get/"+id,User.class);
    }

    @PostMapping("/add")
    public Map<String,Object> addUser(User user){
        return restTemplate.postForObject(BASE_URL+"/user/add",user,Map.class);
    }

}

View Code

5）在资源目录下创建配置文件application.yml

server:
  port: 80

View Code

6）修改eureka-demo-provider的UserController类中addUser方法，给User参数添加@RequestBody注解

7）运行测试

启动主启动类，使用postman工具输入http://127.0.0.1/consumer/get/1使用get方式测试，再输入http://127.0.0.1/consumer/add?name=嘻嘻嘻&phone=1255使用post方式测试。

1.3Eureka

1.3.1定义

它是一个基于REST的服务，用于定位服务，以实现云端中间层发现和故障转移。简单来说就是服务注册与发现，只要使用服务的标识就可以访问到服务，类似于Dubbo的注册中心Zookeeper。
它采用cs架构，Eureka Server作为服务注册的服务器，是注册中心；Eureka Client是客户端，需要注册的服务使用客户端连接到服务器并维持心跳。可以通过服务器来监测各个微服务是否正常运行。

1.4Eureka结合RestTemplate开发

有了1.2的例子，这里就在这个基础上进行后续的操作。

1.4.1搭建eureka的服务中心

所谓服务中心，也就是Eureka Server。服务中心需要在启动类上添加注解@EnableEurekaServer表示这是一个Eureka的服务中心

1）创建maven的工程名为eureka-demo-server7001，在pom中导入依赖

<dependencies>
        <!--eureka server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!--boot web actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--引入自己定义的模块-->
        <dependency>
            <groupId>com.zys.springcloud</groupId>
            <artifactId>eureka-demo-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>

View Code

2）创建包com.zys.cloud，在包下新建启动类EurekaMain7001

package com.zys.cloud;

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

@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class, args);
    }
}

View Code

3）在资源目录下创建配置文件application.yml

server:
  port: 7001

eureka:
  instance:
    #eureka服务端的实例名称
    hostname: localhost
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

View Code

4）运行测试

启动主启动类，在浏览器输入http://127.0.0.1:7001测试server是否搭建成功，看到下图说明已搭建成功。

1.4.2将服务提供者注册到eureka

1）在eureka-demo-provider的pom中添加eureka客户端的依赖

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

View Code

2）在eureka-demo-provider的yml文件中添加eureka客户端的配置

#把客户端注册到服务列表中
eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka

View Code

3）在eureka-demo-provider的启动类上添加eureka客户端的注解@EnableEurekaClient

@SpringBootApplication
@EnableEurekaClient
public class ProviderMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(ProviderMain8001.class, args);
    }
}

View Code

4）运行测试