springcloud使用（基本搭建，Eureka注册中心，Ribbon负载均衡， Feign接口调用服务，Hystrix （熔断机制，dashboard监控）， zuul路由网关，config连接git配置中心）

1.基本的搭建（springcloud，mybatis）

父项目

导入父项目依赖（这里做的是依赖的管理，可以统一管理控制子项目依赖的版本）

    <!--打包方式  pom-->
    <packaging>pom</packaging>

    <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>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>0.2.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springCloud的依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--SpringBoot-->
            <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.10</version>
            </dependency>
            <!--SpringBoot 启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.2</version>
            </dependency>
            <!--日志测试~-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

项目依赖

子项目 api（实体类，提供者提供的接口）

在子项目中可以引用父项目的依赖（不需要写版本号）

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

View Code

在数据库db01下创建表dept插入数据

创建实体类（必须要实现序列化implements Serializable）

//创建get，set方法
@Data
//链式写法
@Accessors(chain = true)
public class Dept implements Serializable {
    private Long deptno;
    //主键
    private String dname;

    //这个数据数存在哪个数据库的字段
    // 微服务一个服务对应一个数据库，同一个信息可能存在不同的数据库
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }

    public Dept() {
    }
}

Dept实体类

链式写法：就是支持这样赋值。

子项目提供者

创建使用8001端口的提供者项目

导入依赖（这里会用到api项目中的pojo，需要依赖之前创建的项目springcloud-api）

    <dependencies>
        <!--   需要在别的项目中的pojo，引入springcloud-api     -->
        <dependency>
            <artifactId>springcloud-api</artifactId>
            <groupId>com.easyjava</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <!--SpringBoot 启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--日志测试~-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

View Code

application.yml其中的pojo需要根据创的文件夹路径填写

server:
  port: 8001
#mybatis配置
mybatis:
  type-aliases-package: com.kuang.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: 1234

application.yml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
</configuration>

mybatis-config.xml必须要写

编写mybatis映射，dao层和service层（DeptMapper.xml和DeptDao相互映射，需要修改<mapper namespace="com.demo.dao.DeptDao">中的namespace）

@Mapper
@Repository
public interface DeptDao {
    public boolean addDept(Dept dept);
    public Dept queryById(Long id);
    public List<Dept> queryAll();
}

DeptDao

<?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.demo.dao.DeptDao">

    <insert id="addDept" parameterType="Dept">
    insert into dept(dname, db_source)
    values (#{dname},DATABASE());
    </insert>

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

    <select id="queryAll" resultType="Dept">
        select * from  dept;
    </select>

</mapper>

DeptMapper.xml

public interface DeptService {
    public boolean addDept(Dept dept);
    public Dept queryById(Long id);
    public List<Dept> queryAll();
}

DeptService

public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptDao deptDao;


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

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

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

DeptServiceImpl

@RestController
public class DeptController {
    @Autowired
    DeptService deptService;
    
    @PostMapping("/dept/add")
    public boolean addDept(@RequestBody Dept dept) {
        return deptService.addDept(dept);
    }

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

    @GetMapping("/dept/list")
    public List<Dept> queryAll() {
        return deptService.queryAll();
    }
}

DeptController

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

springboot主运行方法DeptProvider_8001

子项目消费者（不要使用port：80，占用的太多了）

创建maven子项目作为消费者

    <!--   需要在别的项目中的pojo，引入springcloud-api     -->
    <dependency>
        <artifactId>springcloud-api</artifactId>
        <groupId>com.easyjava</groupId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>

依赖

server:
  port: 80

application.yml

消费者不该有service层

在Configuration中添加RestTemplate的bean，使其能够通过@Autowired自动注入

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

ConfigBean

controller层使用RestTemplate进行对restful风格的hhtp请求访问（即使用网络链接http://....请求数据）

@Controller
public class DeptConsumerController {
    //理解:消费者，不应该有service层
    //RestTempLate ....供我们直接调用就可以了!注册到Spring中
    // (请求网络路径urL, 实体: Map ,响应类型cLass<T> responseType)
    @Autowired
    private RestTemplate restTemplate;
    private static final String REST_URL_PREFIX = "http://localhost:8001";

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

    @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/list")
    public List<Dept> list() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }
}

消费者controller

springboot运行类

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

DeptConsumer_80

2.Eureka搭建（注册中心）(尤瑞卡)

eureka服务器

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

eureka服务器依赖（eureka-server）

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

EurekaServer_7001

server:
  port: 7001

eureka:
  instance:
    hostname: localhost #Eureka服务端的实例名称
  client:
    register-with-eureka: false #表示是否向eureka注册中心注册自己
    fetch-registry: false #false:表示自己为注册中心
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

application.yml

提供者（需要在eureka中注册自己的服务）

        <!--eureka的注册-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

eureka的注册依赖

#eureka配置
#服务注册到哪
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka

application.yml

在springboot运行方法上添加

@EnableEurekaClient

修改eureka的默认描述信息

eureka自我保护机制

Eureka 的自我保护模式是有意义的，该模式被激活后，它不会从注册列表中剔除因长时间没收到心跳导致租期过期的服务，而是等待修复，直到心跳恢复正常之后，它自动退出自我保护模式。

这种模式旨在避免因网络分区故障导致服务不可用的问题。例如，两个客户端实例 C1 和 C2 的连通性是良好的，但是由于网络故障，C2 未能及时向 Eureka 发送心跳续约，这时候 Eureka 不能

简单的将 C2 从注册表中剔除。因为如果剔除了，C1 就无法从 Eureka 服务器中获取 C2 注册的服务，但是这时候 C2 服务是可用的。

显示提供者微服务的详细信息

    @Autowired
    private DiscoveryClient client;

    @GetMapping("/dept/discovery")
    public Object discovery() {
        //获取微服务列表清单
        List<String> services = client.getServices();
        System.out.println(services);

        //得到一个具体的微服务信息，通过微服务id，applicationName
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getHost() + "/t" + 
                    instance.getPort() + "/t" +
                    instance.getUri() + "/t" +
                    instance.getServiceId()
            );
        }
        return this.client;
    }

View Code

DiscoveryClient引用的是springcloud的，不是netflix

同时也是

在springboot运行方法上使用

@EnableDiscoveryClient

显示内容

Eureka服务器集群搭建

依赖没变化

修改hosts，添加域名和ip映射

修改eureka7001，eureka7002和eureka7003的application.yml（例子为eureka7002的）

修改提供者的application.yml（向集群中所有的eureka服务器注册服务）

结果：（能在一个eureka服务器中看到其他的服务器，提供者提供的服务能注册到所有的服务器上）

此为7001

此为7002

Eureka客户端（消费者）

    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>

依赖

#Eureka配置
eureka:
  client:
    register-with-eureka: false #不向Eureka注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

application.yml

springboot启动方法上添加

@EnableEurekaClient

--------------------------------------------------------------------------------------------------------------------------------------

actuator（完善eureka监控信息）

可以不使用actuator（不是必需的）

        <!--完善eureka监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

actuator 完善eureka监控信息

#添加eureka监控信息
info:
  app.name: springcloud-dept
  xxx.name: zzz

application.yml

在eureka的监控中心点击微服务的状态，跳转页面

可以显示在yml中配置的监控信息（json格式）

--------------------------------------------------------------------------------------------------------------------------------------

Ribbon负载均衡（消费方，将用户的请求平均的分摊在各个服务器上）默认使用轮询机制（按顺序访问提供者）

负载均衡简单分类（集中式，进程式）

集中式（Nginx）：由负载均衡中间件将请求通过某种负载均衡策略转发到服务的提供方

进程式（Ribbon）：将负载均衡策略集成到消费方，消费方从注册中心获取服务的提供方

提供者

创建三个提供者

创建三个数据库（一个提供者对应一个数据库）（例子为8002端口提供者的数据库db02）

修改application.yml的内容（例子为8002端口的提供者）

修改启动类

消费者

依赖编写在消费方

依赖

在config的获取RestTemplate的方法上添加

@LoadBalanced

修改访问方式为应用名

如下是几种负载均衡策略：

修改负载均衡策略

默认的的策略是循环访问，可修改配置改变策略
1）全局配置，所有的RibbonClient都使用此策略

@Configuration
public class RibbonGlobalLoadBalanceConfig {
    /**
     * 随机原则
     * @return
     */
    @Bean
    public IRule ribbonRule(){
        return new RandomRule();
    }
}

2）通过配置文件application.properties (或 application.yml)配置单个服务的策略，SERVICE-TEST是服务ID

SERVICE-TEST.ribbon.NFLoadBalancerRuleClassName = com.netflix.loadbalancer.RandomRule

3）通过注解

自定义注解，标记不自动扫描类

public @interface IgnoreScan {
}

配置策略，使用不自动扫描注解。如果包含在应用程序上下文的@ComponentScan中，则该类的配置信息就被所有的@RibbonClient共享

@Configuration
@IgnoreScan
public class CustomLoadBalanceConfig {
    @Bean
    public IRule ribbonRule(){
        return new RandomRule();
    }
}

4）启动类，定义组件扫码和设置服务的负载均衡策略

@RibbonClient(name = "SERVICE-TEST", configuration = CustomLoadBalanceConfig.class)
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value =IgnoreScan.class)})

Feign使用接口调用服务，而不是ribbon中使用应用名调用

依赖要写在消费者和api处

        <!--Feign接口防守调用服务-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

依赖

api（将提供的服务接口写入service）

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {
    @PostMapping("/dept/add")
    public boolean addDept(@RequestBody Dept dept);

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

    @GetMapping("/dept/list")
    public List<Dept> queryAll();
}

DeptClientService

当@Autowired出现没有找到bean的情况，检查是否api的包和消费者的包所处的位置一样（两个都是com.demo）（因为自动引入必须要在springboot启动类的上级）

消费者

@RestController
public class DeptConsumerController {

    //Feign使用接口方式远程调用
    @Autowired
    private DeptClientService service = null;

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        return service.addDept(dept);
    }

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        return service.get(id);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return service.queryAll();
    }
}

消费者controller使用Feign

springboot启动类添加

@EnableFeignClients

Hystrix 熔断机制（解决服务雪崩，服务熔断，服务降级，dashboard监控）

服务雪崩

微服务之间会有大量的调用

服务A——>服务B——>服务C——>。。。。

当出现某个服务不可用或因网络问题响应时间过长，会导致调用服务A时占用大量的资源，引起系统崩溃

服务熔断（提供者）

Hystrix解决服务雪崩的方案（服务熔断）：在不可用的服务中给调用方返回备用响应，就可以继续运行调用之后的服务，就可以避免长时间的等待或抛出无法解决的异常，无法释放调用线程，导致服务雪崩

提供者（在抛出异常时调用备用方法）

<!--hystrix服务熔断-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

依赖

    @HystrixCommand(fallbackMethod = "hystrixGet")
    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        Dept dept = deptService.queryById(id);
        if (dept==null){
            throw new RuntimeException("id:"+id+" 没查到对应的信息");
        }
        return deptService.queryById(id);
    }

    public Dept hystrixGet(@PathVariable("id") Long id) {
        Dept dept = new Dept();
        dept.setDeptno(id);
        dept.setDname("id:"+id+" 没查到对应的名称信息");
        dept.setDb_source("id:"+id+" 没查到对应的数据库信息");
        return dept;
    }

Dept get的备用方法

在springboot启动类上添加

@EnableCircuitBreaker

服务降级（消费者）

当某个时间段访问压力大，需要停掉不重要的某些功能（例如：广告。。），释放占用资源以保证主要核心重要业务能够顺利完成

api子项目

@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory {
    public Object create(Throwable throwable) {
        return new DeptClientService() {
            public boolean addDept(Dept dept) {
                return false;
            }

            public Dept get(Long id) {
                Dept dept = new Dept();
                dept.setDeptno(id);
                dept.setDname("该服务已关闭");
                dept.setDb_source("该服务已关闭");
                return dept;
            }

            public List<Dept> queryAll() {
                Dept dept = new Dept();
                dept.setDeptno(1L);
                dept.setDname("该服务已关闭");
                dept.setDb_source("该服务已关闭");
                return Arrays.asList(dept);
            }
        };
    }
}

DeptClientServiceFallbackFactory用于降级回调

在调用接口处@FeignClient中添加fallbackFactory属性

消费者（要有Feign依赖）

        <!--Feign接口调用服务-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

Feign依赖

#开启服务降级
feign:
  hystrix:
    enabled: true

application.yml

结果（当提供者关闭时，客户端做出相应的响应）

The bean 'XXX.FeignClientSpecification', defined in null, could not be registered报错

这是说Feign的注册，有同名的feign的名字重复注册。

解决方案：

1.如果按照之前的步骤操作，应该不会出错，可能修改项目名称时，target没删完会报错，删完消费者的target会重新创建，就不报错了

2.消费者application.yml添加

spring:
  main:
    allow-bean-definition-overriding: true

dashboard流监控（需要实现hystrix的服务熔断功能，才能监控）

提供者必须要有hystrix和actuator依赖

        <!--完善eureka监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--hystrix服务熔断-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

依赖

监控客户端

springboot启动方法使用@EnableHystrixDashboard

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

启动方法

server:
  port: 9001

application.yml

需要被监控的提供者

springboot启动类

    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet(){
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        servletRegistrationBean.addUrlMappings("/actuator/hystrix.stream");
        return servletRegistrationBean;
    }

启动类添加一个和actuator关联的servlet

监控中心网站：http://localhost:9001/hystrix

监控路径（提供者）：http://localhost:8001/actuator/hystrix.stream

然后运行有服务熔断功能的接口

http://localhost:8001/dept/get/1

dashboard监控解释（圆圈大小代表访问频次，线条代表相对访问次数增加或减少）

zuul路由网关(应用通过zuul中配置的固定网址访问)

    <dependencies>
        <!--   需要在别的项目中的pojo，引入springcloud-api     -->
        <dependency>
            <artifactId>springcloud-api</artifactId>
            <groupId>com.easyjava</groupId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--eureka的注册-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!--  Ribbon负载均衡  -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!--zuul路由网关-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
    </dependencies>

依赖

server:
  port: 9527

#eureka注册名称
spring:
  application:
    name: springcloud-zuul
#eureka注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka
  instance:
    instance-id: zuul9527
    #显示ip
    prefer-ip-address: true

#actuator配置（eureka详细信息）
info:
  app.name: demo-springcloud

#zuul配置
zuul:
  routes:
    deptapplication:
      serviceId: springcloud-provider-dept
      path: /deptapi/**
  #忽略该路径访问服务,通配符*忽略全部的微服务路径，即不能通过/springcloud-provider-dept/dept/get/1访问
  ignored-services: "*"

application.yml

修改host文件（添加域名映射）

springcloud-config

git仓库搭建

搭建git仓库

克隆并创建application.yml

创建生产环境dev，test，设置生产环境为dev

spring:
  profiles:
    active: dev

---
spring:
  profiles: dev
  application:
    name: springcloud-config-dev

---
spring:
  profiles: test
  application:
    name: springcloud-config-test

application.yml

提交git

git add .

git status

git commit -m “first commit”

git push origin master

服务端连接git远端获取配置

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>
    </dependencies>

依赖

server:
  port: 3344
spring:
  application:
    name: springcloud-config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/zeng-haoran/springcloud-config.git

application.yml

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

springboot启动类

启动后显示

客户端连接服务端获取（服务端访问远程git的配置）

spring:
  profiles:
    active: dev
---
server:
  port: 8201
#spring的配置
spring:
  profiles: dev
  application:
    name: springcloud-provider-dept


#eureka配置
#服务注册到哪
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

---
server:
  port: 8202
#spring的配置
spring:
  profiles: test
  application:
    name: springcloud-provider-dept


#eureka配置
#服务注册到哪
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

config-client.yml

提交git

git add .

git status

git commit -m “second commit”

git push origin master

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>
    </dependencies>

依赖

bootstrap.yml主要配置与config服务器相关联的配置（系统级别，比application.yml先执行，可以使用来配置application.yml中使用到参数）

#系统级别的配置
spring:
  cloud:
    config:
      #需要从git上读取的资源名称，不需要后缀
      name: config-client
      #配置环境
      profile: dev
      #git分支
      label: master
      #springcloud-config连接git的服务器地址
      uri: http://localhost:3344

bootstrap.yml

application.yml主要配置的是项目启动的配置（用户级别）

#用户级别的配置
spring:
  application:
    name: springcloud-config-client-3355

application.yml

@RestController
public class ConfigClientController {
    @Value("${spring.application.name}")
    private String applicationName;

    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServer;

    @Value("${server.port}")
    private String port;

    @RequestMapping("/config")
    public String getConfig(){
        return "applicationName:"+applicationName+
                "eurekaServer:"+eurekaServer+
                "port:"+port;
    }
}

controller测试客户端是否获取到了服务器在git远端中获取的配置

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

springboot启动类

先启动服务器，再启动客户端，通过8201端口获取测试内容，已代表服务器获取git远端配置到客户端成功

posted @ 2021-08-27 15:45 低调的。。。阅读(312) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

springcloud使用（基本搭建，Eureka注册中心，Ribbon负载均衡， Feign接口调用服务，Hystrix （熔断机制，dashboard监控）， zuul路由网关，config连接git配置中心）

1.基本的搭建（springcloud，mybatis）

父项目

子项目 api（实体类，提供者提供的接口）

子项目 提供者

子项目 消费者（不要使用port：80，占用的太多了）

2.Eureka搭建（注册中心）(尤瑞卡)

eureka服务器

提供者（需要在eureka中注册自己的服务）

eureka自我保护机制

显示提供者微服务的详细信息

Eureka服务器集群搭建

Eureka客户端（消费者）

actuator（完善eureka监控信息）

Ribbon负载均衡（消费方，将用户的请求平均的分摊在各个服务器上）默认使用轮询机制（按顺序访问提供者）

提供者

消费者

修改负载均衡策略

Feign使用接口调用服务，而不是ribbon中使用应用名调用

api（将提供的服务接口写入service）

消费者

Hystrix 熔断机制（解决服务雪崩，服务熔断，服务降级，dashboard监控）

服务雪崩

服务熔断（提供者）

提供者（在抛出异常时调用备用方法）

服务降级（消费者）

api子项目

消费者（要有Feign依赖）

The bean 'XXX.FeignClientSpecification', defined in null, could not be registered报错

dashboard流监控（需要实现hystrix的服务熔断功能，才能监控）

监控客户端

需要被监控的提供者

dashboard监控解释（圆圈大小代表访问频次，线条代表相对访问次数增加或减少）

zuul路由网关(应用通过zuul中配置的固定网址访问)

springcloud-config

git仓库搭建

服务端连接git远端获取配置

客户端连接服务端获取（服务端访问远程git的配置）

公告

子项目提供者

子项目消费者（不要使用port：80，占用的太多了）