springcloud知识

最新推荐文章于 2024-05-09 11:07:33 发布
最新推荐文章于 2024-05-09 11:07:33 发布
阅读量56 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianqi11/article/details/115667720
版权

springcloud

服务提供者

  1. 导入依赖

    <?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</artifactId>
        <groupId>com.zhao</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provide-dept-8001</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.zhao</groupId>
            <artifactId>springcloud-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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
            <version>2.4.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.4.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
            <version>2.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>2.4.4</version>
        </dependency>
    </dependencies>

</project>

  2. 配置yaml

    server:
  port: 8001
#mybatis的配置
mybatis:
  type-aliases-package: com/zhao/springcloud/pojo
  mapper-locations: classpath:com/zhao/mapper/*.xml
#spring的配置
spring:
  application:
    name: springcloud-provide-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=UTF-8&useSSL=false

  3. 编写实体类、pojo，service和controller

    package com.zhao.springcloud.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;
@Data
@NoArgsConstructor
@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;
    }
}

    package com.zhao.springcloud.mapper;

import com.zhao.springcloud.pojo.dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface deptmapper {
    public boolean addDept(dept dept);

    public dept queryDeptById(long id);

    public List<dept> queryAll();
}

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

<mapper namespace="com.zhao.springcloud.mapper.deptmapper">
    <select id="queryDeptById" resultType="com.zhao.springcloud.pojo.dept">
        select *
        from dept where deptno = #{deptno};
    </select>
    <select id="queryAll" resultType="com.zhao.springcloud.pojo.dept" parameterType="Long">
        select *
        from dept ;
    </select>
    <insert id="addDept" parameterType="com.zhao.springcloud.pojo.dept">
        insert into dept (dname,db_source)
        values (#{dname},DATABASE());
    </insert>
</mapper>

    package com.zhao.springcloud.service;

import com.zhao.springcloud.pojo.dept;

import java.util.List;

public interface deptService {
    public boolean addDept(dept dept);

    public dept queryDeptById(long id);

    public List<dept> queryAll();
}


    package com.zhao.springcloud.service;

import com.zhao.springcloud.mapper.deptmapper;
import com.zhao.springcloud.pojo.dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class deptServiceImpl implements deptService{
    @Autowired
     deptmapper deptmapper;
    @Override
    public boolean addDept(dept dept) {
        return deptmapper.addDept(dept);
    }

    @Override
    public dept queryDeptById(long id) {
        return deptmapper.queryDeptById(id);
    }

    @Override
    public List<dept> queryAll() {
        return deptmapper.queryAll();
    }
}

    package com.zhao.springcloud.controller;

import com.zhao.springcloud.pojo.dept;
import com.zhao.springcloud.service.deptServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class deptController {
    @Autowired
    deptServiceImpl deptService;

    @PostMapping("/dept/add")
    public Boolean addDept(dept dept){
        return deptService.addDept(dept);
    }
    @GetMapping("/dept/add/{deptno}")
    public dept queryDeptById(@PathVariable("deptno") long deptno){
        return deptService.queryDeptById(deptno);
    }
    @GetMapping("/dept/addAll")
    public List<dept> queryAll(){
        return deptService.queryAll();
    }
}

  4. 编写启动类启动测试

    package com.zhao.springcloud;

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

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

使用服务者

通过RestTemplate即可动态通过网址去本地调用

<?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</artifactId>
        <groupId>com.zhao</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-80</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.zhao</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.4.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>2.4.4</version>
        </dependency>
    </dependencies>

</project>

把RestTemplate注册到spring中方便使用

package com.zhao.springcloud.config;

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

@Configuration
public class RestConfig {
    @Bean
    public RestTemplate getRest(){
        return new RestTemplate();
    }
}


package com.zhao.springcloud.controller;

import com.zhao.springcloud.pojo.dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;


@RestController
public class deptConsumerController {
    private final String PREFIX = "http://localhost:8001";
    @Autowired
    RestTemplate restTemplate;

    @RequestMapping("/consumer/getdept/{id}")
    public dept getDeptById(@PathVariable("id") long id){
        return restTemplate.getForObject(PREFIX+"/dept/get/"+id, dept.class);
    }
    @RequestMapping("/consumer/getdept")
    public List<dept> getAll(){
        return restTemplate.getForObject(PREFIX+"/dept/getAll", List.class);
    }
    @RequestMapping("/consumer/adddept")
    public boolean addDept(String dname){
        return restTemplate.postForObject(PREFIX+"/dept/add",dname, Boolean.class);

    }

}

package com.zhao.springcloud;

import javafx.application.Application;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Eureka 注册中心

导包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <version>2.4.4</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka-server -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka-server</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

配置

server:
  port: 7001
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false  #不把自己注册到注册中心
    fetch-registry: false   #为false说明自己是个注册中心
    service-url:  #监控页面
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

开启eureka并启动测试

package com.zhao.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class eurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(eurekaApplication.class,args);
    }
}

使用服务者整合eureka

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

server:
  port: 8001
  #mybatis的配置
mybatis:
  type-aliases-package: com/zhao/springcloud/pojo
  mapper-locations: classpath:com/zhao/mapper/*.xml
#spring的配置
spring:
  application:
    name: springcloud-provide-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=UTF-8&useSSL=false
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/

package com.zhao.springcloud;

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

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

集群的配置

例如三个，写三个相同的eureka注册中心即可，端口不同，只需要对配置文件修改一下即可

集群1

server:
  port: 7001
eureka:
  instance:
    hostname: eureka7001.com
  client:
    register-with-eureka: false  #不把自己注册到注册中心
    fetch-registry: false   #为false说明自己是个注册中心
    service-url: #监控页面,单个注册中心写自己http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群写其余的注册中心地址即可,相当于把自己和谁关联
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

集群2

server:
  port: 7002
eureka:
  instance:
    hostname: eureka7002.com
  client:
    register-with-eureka: false  #不把自己注册到注册中心
    fetch-registry: false   #为false说明自己是个注册中心
    service-url: #监控页面,单个注册中心写自己http://${eureka.instance.hostname}:${server.port}/eureka/
      # 集群写其余的注册中心地址即可,相当于把自己和谁关联
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/

集群3

server:
  port: 7003
eureka:
  instance:
    hostname: eureka7003.com
  client:
    register-with-eureka: false  #不把自己注册到注册中心
    fetch-registry: false   #为false说明自己是个注册中心
    service-url:  #监控页面,单个注册中心写自己http://${eureka.instance.hostname}:${server.port}/eureka/
                  # 集群写其余的注册中心地址即可,相当于把自己和谁关联
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

服务提供者

server:
  port: 8001
  #mybatis的配置
mybatis:
  type-aliases-package: com/zhao/springcloud/pojo
  mapper-locations: classpath:com/zhao/mapper/*.xml
#spring的配置
spring:
  application:
    name: springcloud-provide-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=UTF-8&useSSL=false
eureka:
  client:
    service-url:   #相当于把自己和谁关联，相当于把自己交给了谁管理
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

客户端整合ribbon（负载均衡）

  1. 需要添加ribbon和eureka的依赖

    <!--       客户端需要从eureka中找服务地址，并通过负载均衡，所以导入ribbon和eureka=的包-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

  2. 编写配置，与哪些eureka地址关联

    server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

  3. 把RestTemlate交给spring方便之后的调用，并且使用注解标记这个类是负载均衡方式

    @Configuration
public class RestConfig {
    @Bean
    @LoadBalanced
    public RestTemplate getRest(){
        return new RestTemplate();
    }
}

  4. controller层，前缀地址换成服务提供者在eureka中的名称

    @RestController
public class deptConsumerController {
    //private final String PREFIX = "http://localhost:8001";
    private final String PREFIX = "http://SPRINGCLOUD-PROVIDE-DEPT";
    @Autowired
    RestTemplate restTemplate;

    @RequestMapping("/consumer/getdept/{id}")
    public dept getDeptById(@PathVariable("id") long id){
        return restTemplate.getForObject(PREFIX+"/dept/get/"+id, dept.class);
    }
    @RequestMapping("/consumer/getdept")
    public List<dept> getAll(){
        return restTemplate.getForObject(PREFIX+"/dept/getAll", List.class);
    }
    @RequestMapping("/consumer/adddept")
    public boolean addDept(String dname){
        return restTemplate.postForObject(PREFIX+"/dept/add",dname, Boolean.class);

    }

}

ribbon实现负载均衡

由于ribbon负载均衡是针对多个提供者通过特定算法选择对哪个提供者进行调度，因此增加了两个服务提供者，增加时注意修改端口，数据库即可。

（略）

feign实现负载均衡

添加feign的依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

需要在service层写一个接口，标注feignClient，属性写eureka里的服务名称，接口写对用的方法和对应的访问路径

package com.zhao.springcloud.service;

import com.zhao.springcloud.pojo.dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;
@FeignClient(value = "SPRINGCLOUD-PROVIDE-DEPT")
@Service
@Component
public interface feignService {
    @PostMapping("/dept/add")
    public boolean addDept(dept dept);
    @GetMapping("/dept/get/{deptno}")
    public dept getDeptById(@PathVariable("deptno") long id);
    @RequestMapping("/dept/discovery")
    public List<dept> getAll();
}

使用服务者的controller层得到这个接口的bean并，在相应的方法上调用对应的方法

package com.zhao.springcloud.controller;

import com.zhao.springcloud.pojo.dept;
import com.zhao.springcloud.service.feignService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


import java.util.List;


@RestController
public class deptConsumerController {
    //private final String PREFIX = "http://localhost:8001";
    //private final String PREFIX = "http://SPRINGCLOUD-PROVIDE-DEPT";

//    @Autowired
//    RestTemplate restTemplate;

    @Autowired
    feignService feignService;

    @RequestMapping("/consumer/getdept/{id}")
    public dept getDeptById(@PathVariable("id") long id){
        return feignService.getDeptById(id);

    }
    @RequestMapping("/consumer/getdept")
    public List<dept> getAll(){
        return feignService.getAll();
    }
    @RequestMapping("/consumer/adddept")
    public boolean addDept(dept dept){
        return feignService.addDept(dept);
    }
}

启动类上开启feign的支持并扫描然后测试

package com.zhao.springcloud;


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

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

hystrix熔断机制（整合到服务提供者）

添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

controller中使用hystrix的注解，来实现对错误信息的重新定义

package com.zhao.springcloud.controller;


import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.ribbon.proxy.annotation.Hystrix;
import com.zhao.springcloud.pojo.dept;
import com.zhao.springcloud.service.deptServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class deptController {
    @Autowired
    deptServiceImpl deptService;

    @HystrixCommand(fallbackMethod = "myFull") //这个注解说明此方法抛出异常后会调用对应的其他方法
    @GetMapping("/dept/get/{deptno}")
    public dept queryDeptById(@PathVariable("deptno") long deptno){
        dept dept = deptService.queryDeptById(deptno);
        if(dept==null){
            throw  new RuntimeException("error");
        }
        return deptService.queryDeptById(deptno);
    }


    private dept myFull(@PathVariable("deptno") long id){
        return new dept().setDeptno(id).setDname("查无此人---Hystrix").setDb_source("数据库中没有这个信息");
    }
}

启动类上开启熔断机制并测试

package com.zhao.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker //开启熔断机制
public class DeptProviderHystrix_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProviderHystrix_8001.class,args);
    }
}

hystrix服务降级（整合到客户端）

在公共模块中的service写个类，实现FallbackFactory接口，重写方法，返回对应的feignService接口

package com.zhao.springcloud.service;

import com.zhao.springcloud.pojo.dept;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class myFallBackFactory implements FallbackFactory {
    @Override
    public feignService create(Throwable throwable) {
        return new feignService() {
            @Override
            public boolean addDept(dept dept) {
                return false;
            }

            @Override
            public dept getDeptById(long id) {
                return new dept().setDeptno(id).setDname("服务已经被关闭，Hystrix==》").setDb_source("连接数据库失败");
            }

            @Override
            public List<dept> getAll() {
                return null;
            }
        };
    }
}

把上面的类当作feign的失败调用类。

package com.zhao.springcloud.service;

import com.zhao.springcloud.pojo.dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.List;
@FeignClient(value = "SPRINGCLOUD-PROVIDE-DEPT",fallbackFactory = myFallBackFactory.class)
@Service
@Component
public interface feignService {
    @PostMapping("/dept/add")
    public boolean addDept(dept dept);
    @GetMapping("/dept/get/{deptno}")
    public dept getDeptById(@PathVariable("deptno") long id);
    @RequestMapping("/dept/discovery")
    public List<dept> getAll();
}

在服务使用者中的配置信息中 打开降级服务

server:
  port: 80
eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

#打开hystrix服务降级开关
feign:
  hystrix:
    enabled: true

测试： 首先打开eureka服务中心，在打开服务提供者把服务注册到服务中心，打开服务使用者，进入服务中心，通过自己拿到的服务id去找对应的服务，找到后，调用对应的方法即可。若找不到，就会调用自身的失败调用的类中去调用对应方法。即，当服务提供者断掉的时候，客户端仍然可以使用事先在自身内部就设置好的方法去执行，不至于客户访问不到。

dashboard监控页面

写一个监控模块，引入dashboard和hystrix依赖，修改对应端口，启动类上添加启动dashboard注解

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>

server:
  port: 9001

hystrix:
  dashboard:
    proxy-stream-allow-list: "localhost"

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

启动eureka服务

服务提供者也添加dashboard和hystrix依赖和允许监控的依赖。启动类添加监控地址映射。，启动。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
    <version>2.4.4</version>
</dependency>


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

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

访问dashboard页面，填入要=监控的映射页面，即可

http://localhost:9001/hystrix

http://localhost:8001/hystrix.stream

Zuul路由跳转

写一个zuul的模块，添加Eureka和zuul的依赖，

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

配置自己的服务名，eureka注册地址，替换访问的路径

server:
  port: 8001
  #mybatis的配置
mybatis:
  type-aliases-package: com/zhao/springcloud/pojo
  mapper-locations: classpath:com/zhao/mapper/*.xml
#spring的配置
spring:
  application:
    name: springcloud-provide-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=UTF-8&useSSL=false
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

启动类开启Zuul

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

Config

Git搭建

码云创建项目，git clone 项目地址 ，把项目下载到当前目录，添加配置文件，再上传到码云上，

上传命令：

git add .

git status

git commit -m “1”

git push origin master

配置服务端连接码云

添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

编写配置

server:
  port: 3307
spring:
  application:
    name: spring-config-3307
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/ipanp/springcloud.git

启动类开启config

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

启动测试

http://localhost:3307/application-test.yaml

配置客户端连接配置服务端

添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-config -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
    <version>2.2.7.RELEASE</version>
</dependency>

写配置项

spring:
  cloud:
    config:
      uri: http://localhost:3307
      profile: dev
      name: config-client
      label: master

controller层注入属性

@RestController
public class configController {
    @Value("${server.port}")
    private String port;
    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaName;
    @Value("${spring.profiles}")
    private String profiles;

    @RequestMapping("/config")
    public String config(){
        return "eurekaName:"+eurekaName+
         ",profiles:"+profiles+
         ",port:"+port;
    }

启动测试

tianqi11
关注
Spring Cloud知识点学习思维导图
10-26
这个"Spring Cloud知识点学习思维导图"将帮助我们系统地理解和掌握这个强大的框架。 首先，让我们从服务管理开始。服务发现是Spring Cloud的核心组件之一，主要由Eureka来实现。Eureka Server作为一个服务中心，...
Spring Cloud思维导图. Spring Cloud知识点学习思维导图
11-17
在"Spring Cloud知识点学习思维导图"中，我们可以期待找到以下关键知识点的结构化呈现： 1. **服务发现**：Spring Cloud 提供了 Eureka 和 Consul 等服务注册与发现组件，使得微服务可以互相发现并通信，确保服务...
spring cloud 知识点汇总
JoyceYoung的博客
06-02 2077
目录一、Spring Cloud 综述（一）Spring Cloud 是什么（二）Spring Cloud 解决什么问题（三）Spring Cloud 架构1、Spring Cloud 核⼼组件2、Spring Cloud 体系结构（组件协同⼯作机制）（四）Spring Cloud 与 Dubbo 对⽐（五）Spring Cloud 与 Spring Boot 的关系二、第⼀代 Spring Cloud 核⼼组件（一）Eureka服务注册中⼼1、关于服务注册中⼼①服务注册中⼼⼀般原理②主流服务中⼼对⽐2、服
SpringCloud知识总结
qq_50048558的博客
02-07 2646
SpringCloud微服务一、微服务架构1.互联网应用架构演进①单体应用架构②垂直应用架构③SOA应用架构④微服务应用架构2.微服务架构体现的思想及优缺点3.微服务架构中的核心概念二、Spring Cloud 综述1.Spring Cloud 是什么2.Spring Cloud 解决什么问题3.Spring Cloud 架构①Spring Cloud 核心组件②Spring Cloud 体系结构（组件协同工作机制）④Spring Cloud 与 Dubbo 对比⑤Spring Cloud 与 Spring
SpringCloud知识体系汇总
light的博客
07-07 699
SpringCloud知识体系汇总
SpringCloud知识点
One_hundred_nice的博客
01-30 8483
一、系统架构的演变 单机版 把我们的所有的模块都放置一个项目上，最后将项目打包成war包或者jar包部署到你的服务器上； ​ 优点：1、方便开发；2、部署简单 ​缺点：1、代码耦合，开发维护困哪；2、并发性差、容错率高；3、无法针对对不同的模块进行优化 分布式 不同的业务在不同的模块上，然后发布在不同的服务器上，物理上的分离，逻辑上的集中 优点：1、降...
spring cloud知识体系
林的博客
06-10 1193
spring cloud五大组件一、 Eureka（一）、基础架构1、服务注册中心2、服务提供者3、服务消费者（二）、服务治理机制1、服务提供者（1）、服务注册（2）、服务续约2、服务消费者（1）、获取服务（2）、服务调用（3）、服务下线3、服务注册中心（1）、服务同步（2）、失效剔除（3）、自我保护二、客户端负载均衡（一）、ribbon1、简介2、使用如何使用Ribbon3、负载均衡（二）、feign1、简介2、使用如何使用feign3、负载均衡4、断路器三、断路器（一）、简介（二）、功能1、服务降级2、
知识点系列~SpringCloud知识点
weixin_62868720的博客
05-09 1816
单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝微服务：一种良好的分布式架构方案①优点：拆分粒度更小、服务更独立、耦合度更低②缺点：架构非常复杂，运维、监控、部署难度提高SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。
Spring Cloud知识点全总结
weixin_50216991的博客
05-10 2502
这一节正式的来入门学习一下Spring Cloud 这个微服务框架。本篇是按照我自己的学习思路来编写的入门知识点总结。 一.Spring Cloud 框架概述1.基本介绍2.Spring Cloud与Spring Boot的版本兼容二.Spring Cloud 框架使用1.服务拆分2.案例准备4.微服务远程调用 一.Spring Cloud 框架概述 1.基本介绍 SpringCloud是目前国内使用最广泛的微服务框架之一。官网地址：https://spring.io/projects/spring-.
springcloud知识速记与上手
sinat
09-02 2万+
一、前言 首先你得知道什么是springboot,最好有自己的理解 可以参考这个文章： https://www.cnblogs.com/badofboy/p/9575870.html springcloud知识速记与上手   二、集群/分布式/微服务/SOA是什么？ 看到这些词(集群/分布式/微服务/SOA)的时候，感觉就是遥不可及的(高大尚的技术！！)。就好像刚学Java面向对...
面试springcloud知识点
DKPT的博客
01-23 1080
面试springcloud知识点
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
SpringCloud知识点暨面试题总结(2).pdf
04-22
SpringCloud是当前微服务架构下非常流行的一个框架，它是基于SpringBoot的，用于快速构建分布式系统中的一些常见模式，比如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举...
springcloud知识点脑图demo全家桶菜鸟入门
01-18
本资源“springcloud知识点脑图demo全家桶菜鸟入门”显然是为了帮助初学者掌握Spring Cloud的基础知识和实践应用。这里我们将深入探讨其中提到的关键组件——Eureka、OpenFeign、Redis以及Nacos。 首先，Eureka是...
SpringCloud知识汇总
06-07
SpringCloud是基于Spring Boot实现的一套微服务框架，它提供了在分布式系统中常见的诸多功能，如服务发现、负载均衡、断路器、智能路由、消息总线、配置中心等。以下是对SpringCloud基础及热点技术的详细阐述： 一...
开题报告SpringBoot家具商城系统.docx
最新发布
11-02
毕业设计开题报告
Flask-2.2.3-py3-none-any.zip
11-02
Flask-2.2.3-py3-none-any.zip
编译器前端与后端设计.docx
11-02
编译原理试题
google-2.0.1.tar.gz
11-02
google-2.0.1.tar.gz
springcloud 知识点
10-13
以下是 Spring Cloud 的一些知识点： 1. 服务注册与发现：Spring Cloud 提供了多种服务注册与发现的实现方式，例如 Eureka、Consul、Zookeeper 等。 2. 配置中心：Spring Cloud Config 可以将应用程序的配置集中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值