springcloud搭建 初级人员的使用搭建。sentinel使用官网有详细的使用方法

这篇具有很好参考价值的文章主要介绍了springcloud搭建 初级人员的使用搭建。sentinel使用官网有详细的使用方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

代码仓库地址:https://github.com/zhaoyiwen-wuxian/shop-trench

package com.trench.filters;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**全局拦截器进行拦截未登录等操作
 * 当然可以拦截其他等操作,需要进行根据自己等需求从而进行逻辑添加
 *
 *
 * */
@Component
public class AuthGatewayFilters implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token=exchange.getRequest().getQueryParams().getFirst("token");
        if(StringUtils.isEmpty(token)){
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }
}

package com.trench.filters;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;

@Component
@Slf4j
/**局部过滤器使用方法*/
public class TimeGatewayFiltersFactory extends
        AbstractGatewayFilterFactory<TimeGatewayFiltersFactory.Config> {


    public TimeGatewayFiltersFactory(){
        super(Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("show");
    }

    @Override
    public GatewayFilter apply(TimeGatewayFiltersFactory.Config config) {
        return new GatewayFilter() {
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                if (!config.isShow()){
                   return chain.filter(exchange);
                }
                long start = System.currentTimeMillis();

                return chain.filter(exchange).then(Mono.fromRunnable(()->{
                    //添加自己想要进行存储的逻辑。可以存储数据库red is/es等中
                    log.info("请求耗时:{}",System.currentTimeMillis()-start);
                }));
            }
        };
    }

    @Getter
    @Setter
    public static class Config {
        private boolean show;
    }
}


spring:
application:
name: api-gateway
cloud:
nacos:
config:
file-extension: yaml
server-addr: 127.0.0.1:8848
#添加其他的配置文件的读取
shared-configs:
- dataId: redis.yaml
refresh: true #是否支持动态刷新
profiles:
active: dev

#在nacos中创建一个api-gateway-dev.yaml 后将application.yml文件中数据全部copy到nacos中,并且删除application.yml文件

#appConfig:
#name: gateway 动态更新

#共享的环境配置:api-gateway.yaml 将公共的丢到这个里面。文章来源地址https://www.toymoban.com/news/detail-835192.html

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

    <artifactId>shop-gateway</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-cloud-alibaba-nacos-discovery.version>2.1.1.RELEASE</spring-cloud-alibaba-nacos-discovery.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-nacos-discovery</artifactId>
            <version>${spring-cloud-alibaba-nacos-discovery.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--sentinel-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!--sleuth-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
    </dependencies>
</project>
package com.trench.util.snow;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class SnowFlakeFactory {
        /**
         * 默认的雪花算法句柄
         */
        private static final String DEFAULT_SNOW_FLAKE = "snow_flake";
        /**
         * 缓存SnowFlake对象
         */
        private static ConcurrentMap<String, SnowFlake> snowFlakeCache = new
                ConcurrentHashMap<>(2);
        public static SnowFlake getSnowFlake(long datacenterId, long machineId) {
            return new SnowFlake(datacenterId, machineId);
        }
        public static SnowFlake getSnowFlake() {
            return new SnowFlake(SnowFlakeLoader.getDataCenterId(), SnowFlakeLoader.getMachineId());
        }
        public static SnowFlake getSnowFlakeFromCache() {
            SnowFlake snowFlake = snowFlakeCache.get(DEFAULT_SNOW_FLAKE);
            if(snowFlake == null) {
                snowFlake = new SnowFlake(SnowFlakeLoader.getDataCenterId(),
                        SnowFlakeLoader.getMachineId());
                snowFlakeCache.put(DEFAULT_SNOW_FLAKE, snowFlake);
            }
            return snowFlake;
        }
        /**
         * 根据数据中心id和机器id从缓存中获取全局id
         * @param dataCenterId: 取值为1~31
         * @param machineId: 取值为1~31
         */
        public static SnowFlake getSnowFlakeByDataCenterIdAndMachineIdFromCache(Long dataCenterId, Long machineId) {
            if (dataCenterId > SnowFlake.getMaxDataCeneterNum() || dataCenterId < 0) {
                throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");
            }
            if (machineId > SnowFlake.getMaxMachineNum() || machineId < 0) {
                throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
            }
            String key =
                    DEFAULT_SNOW_FLAKE.concat("_").concat(String.valueOf(dataCenterId)).concat("_").
                            concat(String.valueOf(machineId));
            SnowFlake snowFlake = snowFlakeCache.get(key);
            if(snowFlake == null) {
                snowFlake = new SnowFlake(dataCenterId, machineId);
                snowFlakeCache.put(key, snowFlake);
            }
            return snowFlake;
        }
}

package com.trench.util.snow;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class SnowFlakeLoader {
    public static final String DATA_CENTER_ID = "data.center.id";
    public static final String MACHINE_ID = "machine.id";
    private volatile static Properties instance;
    static {
        InputStream in =
                SnowFlakeLoader.class.getClassLoader().getResourceAsStream("snowflake.properties");
                        instance = new Properties();
        try {
            instance.load(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static String getStringValue(String key){
        if(instance == null) return "";
        return instance.getProperty(key, "");
    }
    private static Long getLongValue(String key){
        String v = getStringValue(key);
        return (v == null || v.trim().isEmpty()) ? 0 : Long.parseLong(v);
    }
    public static Long getDataCenterId() {
        return getLongValue(DATA_CENTER_ID);
    }
    public static Long getMachineId() {
        return getLongValue(MACHINE_ID);
    }
}

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.trench</groupId>
    <artifactId>shop-trench</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>shop-product-api</module>
        <module>shop-product-server</module>
        <module>shop-util</module>
        <module>shop-order-api</module>
        <module>shop-order-server</module>
        <module>shop-gateway</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.3.RELEASE</version>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <spring-cloud-dependencies.version>Hoxton.SR8</spring-cloud-dependencies.version>
        <spring-cloud-alibaba-dependencies.version>2.2.3.RELEASE</spring-cloud-alibaba-dependencies.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

到了这里,关于springcloud搭建 初级人员的使用搭建。sentinel使用官网有详细的使用方法的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • SpringCloud Alibaba微服务-- Sentinel的使用(保姆级)

    随着微服务的流行,服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点,从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。 1、sentinel的特征 丰富的应用场景 : Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景,例如秒杀(即突

    2024年02月16日
    浏览(40)
  • springcloud Alibaba中gateway和sentinel联合使用

    看到这个文章相信你有一定的sentinel和gateway基础了吧。 官网的gateway和sentinel联合使用有些过时了,于是有了这个哈哈,给你看看官网的: 才sentinel1.6,现在都几了啊,所以有些过时。 下面开始讲解: 首先我们总的回顾一下,sentinel就是需要运行一个jar包,开启dashbord页面,来

    2024年01月17日
    浏览(47)
  • 【springcloud 微服务】Spring Cloud Alibaba Sentinel使用详解

    目录 一、前言 二、分布式系统遇到的问题 2.1 服务可用性问题 2.1.1  单点故障

    2024年01月16日
    浏览(48)
  • 【SpringCloud Alibaba】(六)使用 Sentinel 实现服务限流与容错

    今天,我们就使用 Sentinel 实现接口的限流,并使用 Feign 整合 Sentinel 实现服务容错的功能,让我们体验下微服务使用了服务容错功能的效果。 因为内容仅仅围绕着 SpringCloud Alibaba技术栈展开,所以,这里我们使用的服务容错组件是阿里开源的 Sentinel。 当然,能够实现服务容错

    2024年02月14日
    浏览(46)
  • 【SpringCloud】11、Spring Cloud Gateway使用Sentinel实现服务限流

    1、关于 Sentinel Sentinel 是阿里巴巴开源的一个流量防卫防护组件,可以为微服务架构提供强大的流量防卫能力,包括流量控制、熔断降级等功能。Spring Cloud Gateway 与 Sentinel 结合,可以实现强大的限流功能。 Sentinel 具有以下特性: 丰富的应用场景:Sentinel 承接了阿里巴巴近

    2024年02月01日
    浏览(54)
  • SpringCloud Alibaba - Sentinel 微服务保护解决雪崩问题、Hystrix 区别、安装及使用

    目录 一、Sentinel 1.1、背景:雪崩问题 1.2、雪崩问题的解决办法 1.2.1、超时处理 缺陷:为什么这里只是 “缓解” 雪崩问题,而不是百分之百解决了雪问题呢? 1.2.2、舱壁模式 缺陷:资源浪费 1.2.3、熔断降级 1.2.4、流量控制 误区:那是不是只用流量控制就可以,前面三种方法

    2024年02月07日
    浏览(33)
  • SpringCloud小项目——订单积分商城 & 使用Nacos、Open Feign、Gateway、Sentinel技术栈

    使用Nacos、Open Feign、Gateway、Sentinel技术栈实现XX公司订单、库存、积分的案例开发,以下是服务调用关系 git代码:https://gitee.com/pet365/spring-cloud-goods https://github.com/RainbowForest/e-commerce-microservices https://awesomeopensource.com/project/RainbowForest/e-commerce-microservices 使用Nacos、Open Feign、Gate

    2024年02月08日
    浏览(44)
  • SpringCloud面试题——Sentinel

    Sentinel是一个面向分布式架构的轻量级服务保护框架,实现服务降级、服务熔断、服务限流等功能 降级是通过开关配置将某些不重要的业务功能屏蔽掉,降级并不是功能不可用,而是用一种默认返回、异步执行、延迟处理等方式进行降低处理。 在服务的依赖调用中,当被调用

    2024年04月28日
    浏览(31)
  • 【SpringCloud——Sentinel】

    微服务调用链路中的某个服务发生故障,引起整个链路中的所有微服务都不可用,这就是雪崩。 设定超时时间,请求超过一定时间没有响应就返回错误信息,不会无休止等待。  弊端:假设等待时间为1s,但是每秒钟传递过来的请求为2个,迟早有一天,线程数量也会填满整个

    2024年02月08日
    浏览(38)
  • springcloud~Sentinel

    随着微服务的流行,服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件,主要以流量为切入点,从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳

    2024年02月02日
    浏览(29)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包