SpringCloud

最新推荐文章于 2024-08-18 17:14:32 发布
最新推荐文章于 2024-08-18 17:14:32 发布
阅读量33 收藏
点赞数
文章标签： spring cloud eureka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44554784/article/details/129836526
版权

1.Spring模块

pom文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.coco</groupId>
    <artifactId>springcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <modules>
<!--        模块只管pojo-->
        <module>springcloud-api</module>
        <module>springcloud-provider-dept-8001</module>
        <module>springcloud-consumer-dept-80</module>
        <module>springcloud-eureka-7001</module>
        <module>springcloud-zuui-9527</module>
        <module>vue</module>
    </modules>

    <packaging>pom</packaging>
    <properties>
        <java.version>1.8</java.version>
        <junit.version>4.12</junit.version>
        <lombok.version>1.18.24</lombok.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2021.0.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.7.3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.30</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.13-SNSAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.2</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

2.api模块-只负责pojo

pom文件

<?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.coco</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-api</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
<!--        父依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
<!--        自己的依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
    </dependencies>


</project>

编写pojo类

package com.coco.springcloud.pojo;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Accessors(chain = true)
@Getter
@Setter
@ToString
@NoArgsConstructor
public class Dept implements Serializable {

  private long deptno;
  private String dname;
  private String db_source;

}

3.服务提供者

application.yml

server:
  port: 8001
mybatis:
  type-aliases-package: com.coco.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml
spring:
  application:
    name: springcloud-provider-TiGongZhe
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/corainld?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

编写mybatis-config.xml

<?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>
    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

编写dao层

package com.coco.springcloud.dao;

import com.coco.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

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

    public Dept queryById(Long id);

    public List<Dept> queryAll();
}

编写service层

package com.coco.springcloud.service;

import com.coco.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService {
    public boolean addDept(Dept dept);

    public Dept queryById(Long id);

    public List<Dept> queryAll();
}

package com.coco.springcloud.service;

import com.coco.springcloud.dao.DeptDao;
import com.coco.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
    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();
    }
}

编写mapper

<?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.coco.springcloud.dao.DeptDao">
    <insert id="addDept" parameterType="Dept">
        insert into dept (dname, db_source)
        values (#{dname}, DATANASE());
    </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>

编写controller层

package com.coco.springcloud.controller;

import com.coco.springcloud.pojo.Dept;
import com.coco.springcloud.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Controller;
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
    private DeptService deptService;

    @Autowired
    private DiscoveryClient discoveryClient;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept) {
        return deptService.addDept(dept);
    }

    @HystrixCommand(fallbackMethod = "hystrixGet")
    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        Dept dept = deptService.queryById(id);
        System.out.println(dept);

        if (dept == null) {
            throw new RuntimeException("id=>" + id + ", 不存在该用户");
        }
        return dept;
    }

    public Dept hystrixGet(@PathVariable("id") Long id) {
        return new Dept().setDeptno(id).setDname("id=>" + id + ", 不存在该用户").setDb_source("no Databased");
    }

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

    @GetMapping("dept/discovery")
    public Object discovery() {
        //获取微服务名单

        List<String> services = discoveryClient.getServices();
        System.out.println("服务清单：" + services);

        List<ServiceInstance> instances = discoveryClient.getInstances("springcloud-provider提供者");
        instances.forEach(x->{
            System.out.println(x.getHost());
            System.out.println(x.getPort());
            System.out.println(x.getUri());
            System.out.println(x.getServiceId());
        });

        return this.discoveryClient;
    }
}

编写启动类，启动访问：http://localhost:8001/dept/list

package com.coco.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

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

3.服务消费者-远程调用

pom文件

<?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.coco</groupId>
        <version>0.0.1-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>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.coco</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>0.0.1-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>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-loadbalancer</artifactId>
            <version>2.3.0</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix-ribbon</artifactId>
            <version>2.2.10.RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
</project>

application.yml

server:
  port: 80

注册一个restTemplate bean注入到controller层


import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public IRule myrule() {
        return new RandomRule();
    }
}

编写controller层

package com.coco.springcloud.controller;

import com.coco.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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 org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {
    //消费者不该有service
    //RestTemplate供直接调用
    //public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables)
    //通过configBean注入
    @Autowired
    private RestTemplate restTemplate;

//    private static final String Rest_url_prefix = "http://localhost:8001";
    private static final String Rest_url_prefix = "http://SPRINGCLOUD-PROVIDER-TIGONGZHE";

    @GetMapping("/consumer/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
//        Dept dept = deptService.queryById(id);
        Dept dept = restTemplate.getForObject(Rest_url_prefix + "/dept/get/" + id, Dept.class);
        System.out.println(dept);

        return dept;
    }

    @GetMapping("/consumer/list")
    public List<Dept> queryAll() {
        return restTemplate.getForObject(Rest_url_prefix + "/dept/list", List.class);
    }

    @PostMapping("/consumer/add")
    public boolean addDept(Dept dept) {
        return restTemplate.postForObject(Rest_url_prefix + "/dept/add", dept, boolean.class);
    }


}

编写启动类，启动访问：http://localhost/consumer/list

package com.coco.springcloud;

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

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

4.将远程注册中心从zookeeper变成Eureka，舍弃一致性，实现可用性

pom文件

<?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.coco</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-eureka-7001</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

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

    </dependencies>
</project>

application.yml

server:
  port: 7001
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false #是否向eureka注册中心注册自己
    fetch-registry: false #false表示自己为注册中心
    service-url: #与注册中心交互
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #http://127.0.0.1:7002/eureka/,http://127.0.0.1:7003/eureka/
      #this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");

编写启动类，启动访问：http://localhost:7001/

package com.coco.springcloud;

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

@SpringBootApplication
@EnableEurekaServer //表示为服务端的启动类，可以接受别人注册进来
public class Eureka_7001 {
    public static void main(String[] args) {
        SpringApplication.run(Eureka_7001.class, args);
    }
}

服务提供者配置注册中心地址

pom中增加依赖

<!--服务提供者配置Eureka注册中心依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
<!--Eureka界面上的status监控描述依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

application.yml中增加配置

#服务端配置Eureka注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    instance-id: spri-pro-8001 #status描述信息
    prefer-ip-address: true #隐藏ip


info:
  app.name: 监控信息 #点击status进入
  company.name: 996

management:
  endpoints:
    web:
      exposure:
        include: "*"
  info:
    env:
      enabled: true

启动类中添加注解

@EnableEurekaClient //添加后服务启动时自动注册进Eureka中
@EnableDiscoveryClient//向controller中注册discovery获取配置信息

获取配置方法

//获取一些配置信息
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("dept/discovery")
    public Object discovery() {
        //获取微服务名单

        List<String> services = discoveryClient.getServices();
        System.out.println("服务清单：" + services);

        List<ServiceInstance> instances = discoveryClient.getInstances("springcloud-provider-TiGongZhe");
        instances.forEach(x->{
            System.out.println(x.getHost());
            System.out.println(x.getPort());
            System.out.println(x.getUri());
            System.out.println(x.getServiceId());
        });

        return this.discoveryClient;
    }

添加集群，将defaultZone从单机改为集群

server:
  port: 7001
eureka:
  instance:
    hostname: eureka7001.com
  client:
    register-with-eureka: false #是否向eureka注册中心注册自己
    fetch-registry: false #false表示自己为注册中心
    service-url: #与注册中心交互
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
      #单机：http://${eureka.instance.hostname}:${server.port}/eureka/
      #默认：this.serviceUrl.put("defaultZone", "http://localhost:8761/eureka/");

服务提供者修改defaultZone

#服务端配置Eureka注册中心地址
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: status
    prefer-ip-address: true #自我保护机制，不推荐关闭

服务消费者

添加Eureka依赖

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

添加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/

 启动类添加注解

@EnableEurekaClient

5.Ribbon-为服务客户端做一些简单的负载均衡：用某种规则为客户端平摊分配到多台服务器上，从而实现高可用

进程式负载均衡，将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选出一个合适的服务器

pom文件添加Ribbon依赖

<!--Ribbon配置-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix-ribbon</artifactId>
            <version>2.2.10.RELEASE</version>
            <scope>compile</scope>
        </dependency>
<!--负载均衡依赖-->
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-loadbalancer</artifactId>
            <version>2.3.0</version>
            <scope>compile</scope>
        </dependency>

ConfigBean中添加Ribbon注解，并设置负载均衡规则

package com.coco.springcloud.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {

    @Bean
    @LoadBalanced //开启负载均衡注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public IRule myrule() {
        return new RandomRule();
    }
}

controller中将固定服务器地址修改为服务器名

package com.coco.springcloud.controller;

import com.coco.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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 org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {
    //消费者不该有service
    //RestTemplate供直接调用
    //public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables)

    @Autowired
    private RestTemplate restTemplate;

    //无Ribbon通过固定地址请求
    //private static final String Rest_url_prefix = "http://localhost:8001";

    //有Ribbon通过服务名请求
    private static final String Rest_url_prefix = "http://SPRINGCLOUD-PROVIDER-TIGONGZHE";

    @GetMapping("/consumer/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
//        Dept dept = deptService.queryById(id);
        Dept dept = restTemplate.getForObject(Rest_url_prefix + "/dept/get/" + id, Dept.class);
        System.out.println(dept);

        return dept;
    }

    @GetMapping("/consumer/list")
    public List<Dept> queryAll() {
        return restTemplate.getForObject(Rest_url_prefix + "/dept/list", List.class);
    }

    @PostMapping("/consumer/add")
    public boolean addDept(Dept dept) {
        return restTemplate.postForObject(Rest_url_prefix + "/dept/add", dept, boolean.class);
    }


}

启动并访问：http://localhost/consumer/list

自定义规则组件

package com.coco.springcloud.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class myRule {
    @Bean
    public IRule myrule() {
        return new RandomRule();
    }
}

启动类添加注解

@RibbonClient(name = "springcloud-provider-TiGongZhe",configuration = myRule.class)

6.Feign-通过创建接口并使用注解实现负载均衡

api中添加服务接口

package com.coco.springcloud.service;

import com.coco.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

@Component
public interface DeptClientService {

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

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

    @PostMapping("/dept/add")
    boolean addDept(Dept dept);

    @GetMapping("/dept/json")
    String js(String s);
}

服务客户端

pom文件添加Feign依赖

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

controller层添加注解实现接口

package com.coco.springcloud.controller;

import com.coco.springcloud.pojo.Dept;
import com.coco.springcloud.service.DeptClientService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
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 org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    //不再通过restTemplate实现
    @Autowired
    private RestTemplate restTemplate;

    //通过Feign实现
    @Autowired
    private DeptClientService deptClientService;

//    private static final String Rest_url_prefix = "http://localhost:8001";
    //加了ribbon后
//    private static final String Rest_url_prefix = "http://SPRINGCLOUD-PROVIDER-TIGONGZHE";

    @GetMapping("/consumer/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
//        Dept dept = deptService.queryById(id);
//        Dept dept = restTemplate.getForObject(Rest_url_prefix + "/dept/get/" + id, Dept.class);
        return this.deptClientService.queryById(id);
    }

    @GetMapping("/consumer/list")
    public List<Dept> queryAll() {
        return this.deptClientService.queryAll();
    }

    @PostMapping("/consumer/add")
    public boolean addDept(Dept dept) {
        return this.deptClientService.addDept(dept);
    }

    @GetMapping("/consumer/js")
    public String json(Dept dept) throws JsonProcessingException {
        dept.setDeptno(1).setDname("111").setDb_source("cococo");

        ObjectMapper mapper = new ObjectMapper();
        String str = mapper.writeValueAsString(dept);

        return str;
    }


}

启动类添加注解

package com.coco.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;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.coco.springcloud"})
//@ComponentScan("com.coco.springcloud")
public class FeignDeptConsumer_feign {
    public static void main(String[] args) {
        SpringApplication.run(FeignDeptConsumer_feign.class, args);
    }
}

7.Hystrix-服务熔断机制

服务客户端

pom文件添加hystrix依赖

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

熔断备用方法

    @HystrixCommand(fallbackMethod = "hystrixGet")
    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        Dept dept = deptService.queryById(id);
        System.out.println(dept);

        if (dept == null) {
            throw new RuntimeException("id=>" + id + ", 不存在该用户");
        }
        return dept;
    }

    //抛出异常后执行备选方案
    public Dept hystrixGet(@PathVariable("id") Long id) {
        return new Dept().setDeptno(id).setDname("id=>" + id + ", 不存在该用户").setDb_source("no Databased");
    }

启动类添加hystrix注解

package com.coco.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@SpringBootApplication
@EnableEurekaClient //添加后服务启动时自动注册进Eureka中
@EnableDiscoveryClient//向controller中注册discovery获取配置信息
@EnableHystrix//开启熔断
public class DeptProvider_8002 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8002.class, args);
    }
}

服务降级

api中添加工厂类

package com.coco.springcloud.service;

import com.coco.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

//服务降级，服务全部停止时批量处理熔断
@Component
public class DeptClientFallbackFactory implements FallbackFactory {

    @Override
    public DeptClientService create(Throwable cause) {
        return new DeptClientService() {
            @Override
            public Dept queryById(Long id) {
                return new Dept().setDeptno(id)
                        .setDname("没有对应信息，服务已经关闭")
                        .setDb_source("no database");
            }

            @Override
            public List<Dept> queryAll() {
                Dept dept = new Dept().setDname("all server down").setDb_source("null");
                List a = new ArrayList();
                a.add(dept);
                return a;
            }

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

            @Override
            public String js(String s) {
                return null;
            }

        };
    }
}

 添加注解

package com.coco.springcloud.service;

import com.coco.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;

import java.util.List;

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-TIGONGZHE", fallbackFactory = DeptClientFallbackFactory.class)
public interface DeptClientService {

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

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

    @PostMapping("/dept/add")
    boolean addDept(Dept dept);

    @GetMapping("/dept/json")
    String js(String s);
}

8.HystrixDashboard-流监控

pom文件

<?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.coco</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dashboard</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.coco</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>0.0.1-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.7.RELEASE</version>
        </dependency>
<!--Ribbon-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
<!--Hystrix-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
<!--Dashboard-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
    </dependencies>

</project>

 application.yml

server:
  port: 9001
hystrix:
  dashboard:
    proxy-stream-allow-list: "*"

编写启动类，启动并访问：http://localhost:9001/hystrix

package com.coco.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

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

服务提供者

编写流监控Servlet，开启熔断机制，并在控制类中具备熔断操作

package com.coco.springcloud;

import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@EnableEurekaClient //添加后服务启动时自动注册进Eureka中
@EnableDiscoveryClient//向controller中注册discovery获取配置信息
@EnableHystrix//开启熔断
public class DeptProvider_8002 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8002.class, args);
    }


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

package com.coco.springcloud.controller;

import com.coco.springcloud.pojo.Dept;
import com.coco.springcloud.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Controller;
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
    private DeptService deptService;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept) {
        return deptService.addDept(dept);
    }

    @HystrixCommand(fallbackMethod = "hystrixGet")
    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        Dept dept = deptService.queryById(id);
        System.out.println(dept);

        if (dept == null) {
            throw new RuntimeException("id=>" + id + ", 不存在该用户");
        }
        return dept;
    }

    //抛出异常后执行备选方案
    public Dept hystrixGet(@PathVariable("id") Long id) {
        return new Dept().setDeptno(id).setDname("id=>" + id + ", 不存在该用户").setDb_source("FROM 8002");
    }

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

9.Zuul-路由网关，统一外部请求访问的地址

 pom文件

<?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.coco</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-zuui-9527</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--拿到实体类-->
        <dependency>
            <groupId>com.coco</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
    </dependencies>
</project>

application.yml

server:
  port: 9527
spring:
  application:
    name: springcloud-zuul-gateway

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: spri-zuul-9527
    prefer-ip-address: true


info:
  app.name: Zuul网关
  company.name: FROM 9527

management:
  endpoints:
    web:
      exposure:
        include: "*"
  info:
    env:
      enabled: true
zuul:
  routes:
    mydept.serverId: springcloud-provider-TiGongZhe
    mydept.path: /mydept/**

编写启动类，启动并访问：http://www.star.com:9527/springcloud-provider-tigongzhe/dept/list

package com.coco.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

潮雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springcloud
06-25
在 "springcloud" 这个主题中，我们主要讨论的是 Spring Cloud Alibaba，它是阿里巴巴提供的与 Spring Cloud 兼容的一系列微服务解决方案。Spring Cloud Alibaba 提供了包括服务发现（Nacos）、配置中心（Nacos）、...
SpringCloud视频教程全套百度网盘
03-01
根据提供的文件信息，以下是对SpringCloud相关知识点的详细解析： ### 一、SpringCloud简介 #### 1.1 SpringCloud是什么？ Spring Cloud 是一个基于 Spring Boot 的开发框架，旨在为微服务架构提供全面的支持，...
Spring Cloud原理详解
Java笔记
11-07 18万+
概述 毫无疑问，Spring Cloud是目前微服务架构领域的翘楚，无数的书籍博客都在讲解这个技术。不过大多数讲解还停留在对Spring Cloud功能使用的层面，其底层的很多原理，很多人可能并不知晓。因此本文将通过大量的手绘图，给大家谈谈Spring Cloud微服务架构的底层原理。 实际上，Spring Cloud是一个全家桶式的技术栈，包含了很多组件。本文先从其最核心的几个组件入手，来剖...
微服务架构Spring Cloud概述和基本讲解
张彦峰的博客
02-14 164万+
微服务架构Spring Cloud概述和基本讲解
深入解析Spring Cloud Config：多样配置中心的实现与高可用策略
张彦峰的博客
02-14 163万+
微服务架构Spring Cloud Config原理与注意事项分享讲解 在分布式系统中，配置管理是一项关键任务。随着应用规模和复杂度的增加，传统的配置管理方式已无法满足需求。Spring Cloud Config应运而生，为分布式系统提供了一套集中化的配置管理解决方案。本文将深入探讨配置中心的由来与选择，并详细介绍如何利用Spring Cloud Config结合Git、MySQL和MongoDB等多种数据源实现配置中心。通过实际案例，我们将展示如何扩展其功能，确保高可用性
【微服务】Spring Cloud中如何使用Eureka
Venus's Blog
07-10 3万+
通过以上步骤，我们使用 Spring Cloud 和 Eureka 实现了基本的服务注册和发现机制。Eureka 服务注册中心负责管理和协调服务的注册与发现，而各个微服务通过 Eureka 客户端与注册中心进行交互，实现服务的动态注册和发现。😊🙏如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot, spring cloud等系列文章，一系列干货随时送达!如果有项目或者毕设合作，请V:fengyelin8866,备注毕设。
史上最简单的 SpringCloud 教程 | 终章
热门推荐
方志朋的专栏
04-12 197万+
转载请标明出处： http://blog.csdn.net/forezp/article/details/70148833 本文出自方志朋的博客 错过了这一篇，你可能再也学不会 Spring Cloud 了！Spring Boot做为下一代 web 框架，Spring Cloud 作为最新最火的微服务的翘楚，你还有什么理由拒绝。赶快上船吧，老船长带你飞。终章不是最后一篇，它是一个...
Spring Cloud五大组件
小新没有蜡笔的博客
10-14 2万+
SpringCloud五大组件：Eureka、Ribbon、Hystrix、Gateway、Config
springcloud整合nacos配置中心
Venus's Blog
06-07 7万+
如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot,spring cloud等系列文章，一系列干货随时送达!
SpringCloud 微服务框架
m0_50601240的博客
04-08 6625
springCloud简单运用，Eureka注册中心，Ribbon负载均衡，Nacos注册管理中心
spring cloud搭建教程
ANGEL CITY
04-26 5万+
Spring cloud是一个基于Spring Boot实现的服务治理工具包,在微服务架构中用于管理和协调服务的微服务:就是把一个单体项目,拆分为多个微服务,每个微服务可以独立技术选型,独立开发,独立部署,独立运维.并且多个服务相互协调,相互配合,最终完成用户的价值. Spring Cloud是一系列框架的有序集合。其主要的设施有，服务发现与注册，配置中心，消息总线，负载均衡，断路器，数据监控等，通过Spring Boot的方式，可以实现一键启动，和部署。
Spring Cloud 微服务项目实战 -
小工匠
11-15 3万+
Milestone 版本：在大版本正式发布前的里程碑版本，例如 2021.0.0-M1，M1 代表当前大版本的第一个里程碑版本，M2 代表第二个迭代里程碑，以此类推。使用模板的好处是可以对优惠券消费规则做一层抽象，比如满减类、打折类这些优惠券只是具体的优惠金额不同，但是玩法类似，把相类似的玩法功能抽象成一个模板，就可以简化具体优惠券的创建和核销流程。建议： 当框架有重大版本更新时，建议你先按兵不动，等大版本做了一两次迭代之后，明显的 Bug 修复得差不多了了，再应用到项目中也不迟。
Spring cloud
02-28
### Spring Cloud 知识点详解 #### 春云科技概览 **Spring Cloud** 是一套完整的微服务解决方案，它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、智能路由、消息...
SpringCloud中文文档
03-10
Spring Cloud中文文档 Spring Cloud 是一个用于快速构建分布式系统的工具集，提供了配置管理、服务发现、断路器、智能路由、微代理、控制总线等多种功能。这些功能可以帮助开发人员快速地支持实现分布式系统中的...
Cannot connect to the Docker daemon at unix:///var/run/docker.sock. 问题解决
时间静止
08-14 560
这个实例可能与系统中原有的 Docker 实例（可能是通过包管理器如 apt, yum, dnf 等安装的）发生冲突。无法访问docker服务了, 查看状态是正常, 并且重启也没报错, 就是无法通过docker命令操作docker了。至此我的问题解决完成, 如果执行到此步骤你还没有成功, 建议查看下面推荐的其他文章, 或者卸载重装。原来我的服务器docker服务运行正常， 但在某次尝试用, 根据系统的提示执行了。文件被新的 Docker 实例使用，或者原有的 Docker 服务被停止。用户组）有权访问它。
深入Eureka架构：服务注册与负载均衡的实现原理
2401_85639015的博客
08-15 774
Eureka主要由两个核心组件组成：Eureka Server和Eureka Client。作用：Eureka Server充当服务注册中心，负责存储所有已注册服务的元数据。功能接受和存储服务实例的注册信息。提供服务实例查询功能，供其他服务获取服务地址。支持服务实例的续约机制，以保持服务实例的有效性。提供服务下线通知机制，以便及时清理无效服务信息。作用。
【Docker】Docker Compose（容器编排）
最新发布
Elena's Blog
08-18 1012
什么是 Docker Compose。
Eureka原理与实践：深入探索微服务架构的核心组件
招风的黑耳CSDN
08-15 618
在微服务架构日益盛行的今天，服务之间的注册与发现成为了保证系统高可用性和灵活性的关键。Eureka，作为Netflix开源的服务注册与发现框架，凭借其简单、健壮的特性，在微服务领域占据了举足轻重的地位。本文将深入剖析Eureka的原理，并通过实践案例展示其在实际项目中的应用，以期为开发者提供一个高端、深入的视角。
工具/平台--分享（杂乱）
金灰的博客
08-14 1029
链接：https://pan.baidu.com/s/1-4Zd4ZXLeKiwAw4op27ziA?9、深信服安全中心：https://wiki.sec.sangfor.com.cn/index/abroad。牛客竞赛 ：https://ac.nowcoder.com/acm/contest/vip-index。3、venuseye威胁情报平台：https://www.venuseye.com.cn/4、安恒威胁情报平台：https://ti.dbappsecurity.com.cn/
spring cloud
09-13
Spring Cloud是一个用于构建分布式系统的开发工具集合。它提供了一些常用的组件和框架，包括服务注册和发现、负载均衡、断路器、分布式配置等等。在使用Spring Cloud时，有一些常见的错误和注意事项需要注意。 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值