微服务环境搭建

最新推荐文章于 2023-02-08 01:32:25 发布
最新推荐文章于 2023-02-08 01:32:25 发布
阅读量170 收藏
点赞数
分类专栏： 微服务环境搭建 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/krator_zhuo/article/details/120614211
版权

第一章：
    1.    项目构建：
        springcloud-parent 项目名
            1.1 要导入的依赖包：
                    <!--导入springboot相关的jar包-->
                    <parent>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-parent</artifactId>
                        <version>2.0.5.RELEASE</version>
                    </parent>
                    <properties>
                        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
                        <java.version>1.8</java.version>
                        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
                    </properties>
                    <!--引入spring-cloud-dependencies，里面管理了springcloud很多组件版本，所以在子模块引入相关组件时不需要加版本-->
                    <dependencyManagement>
                        <dependencies>
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-dependencies</artifactId>
                                <version>${spring-cloud.version}</version>
                                <type>pom</type>
                                <scope>import</scope>
                            </dependency>
                        </dependencies>
                    </dependencyManagement>    

            1.2 product-common 模块名
                1.2.1 准备实体类
                        @Data
                        public class Product {
                            private Long id;
                            private String name;
                            public Product() {}
                            public Product(Long id, String name) {
                                this.id = id;
                                this.name = name;
                            }
                        }    
                1.2.2 要导入的依赖包：
                
                
            1.3 服务提供者：product-service-2010 模块名
                1.3.1 yml：
                        server:
                          port: 2010
                        spring:
                          application:
                            name: product-service
                1.3.2 测试类：
                        @RestController
                        @RequestMapping("/product")
                        public class ProductController {
                            @GetMapping("/{id}")
                            public Product getById(@PathVariable("id") Long id){
                                //正常请求应该调用service，并且service调用Mapper，现在直接返回
                                return new Product(id,"莫尔");
                            }
                        }
                1.3.3 要导入的依赖包：
                        <dependencies>
                            <!--依赖于product公共代码-->
                            <dependency>
                                <groupId>cn.itsource</groupId>
                                <artifactId>product-common</artifactId>
                                <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-starter-test</artifactId>
                            </dependency>
                        </dependencies>
                1.3.4 启动类：
                        @SpringBootApplication
                        public class ProductApplication2010 {
                            public static void main(String[] args) {
                                SpringApplication.run(ProductApplication2010.class,args);
                            }
                        }
                        
                1.3.5 注册到eureka:
                        1.3.5.1 导包：
                            <!--eureka客户端支持 -->
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
                            </dependency>
                        1.3.5.2 yml配置：
                            eureka:
                              client:
                                service-url:
                                 defaultZone: http://localhost:1010/eureka #告诉服务提供者要把服务注册到哪儿
                              instance:
                                prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                        1.3.5.3 加注解：
                            @EnableEurekaClient //Eureka的客户端
                1.3.6   集群：（修改yml配置就行了）                            
                            eureka:
                              client:
                                service-url:
                                 defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka #告诉服务提供者要把服务注册到哪儿
                              instance:
                                prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                1.3.7   测试集群：http://localhost:2010/product/5    
                
                
            1.4 服务消费者：order-service-2020 模块名
                1.4.1 yml：
                        server:
                          port: 2020
                        spring:
                          application:
                            name: order-service
                1.4.2 controller:
                        @RestController
                        @RequestMapping("/order")
                        public class OrderController {
                            @Autowired
                            private RestTemplate restTemplate;

                            @GetMapping("/{productId}")
                            public Product getByProductId(@PathVariable("productId") Long productId){
                                String url="http://localhost:2010/product/"+productId;
                                return restTemplate.getForObject(url, Product.class);
                            }
                        }
                1.4.3 要导入的依赖包：
                        <dependencies>
                            <!--依赖于product公共代码-->
                            <dependency>
                                <groupId>cn.itsource</groupId>
                                <artifactId>product-common</artifactId>
                                <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-starter-test</artifactId>
                            </dependency>
                        </dependencies>
                1.4.4 启动类：
                        @SpringBootApplication
                        public class OrderApplication2020 {
                            public static void main(String[] args) {
                                SpringApplication.run(OrderApplication2020.class,args);
                            }
                        }
                1.4.5 配置类：
                        @Configuration
                        public class Confi {
                            @Bean
                            public RestTemplate restTemplate(){
                                return new RestTemplate();
                            }
                        }
                1.5.5 注册到eureka:
                        1.5.5.1 导包：
                            <!--eureka客户端支持 -->
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
                            </dependency>
                        1.5.5.2 yml配置：
                            eureka:
                              client:
                                service-url:
                                 defaultZone: http://localhost:1010/eureka #告诉服务提供者要把服务注册到哪儿
                              instance:
                                prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                        1.5.5.3 加注解：
                            @EnableEurekaClient //Eureka的客户端
                1.5.6   改造controller：
                            controller:
                            @RestController
                            @RequestMapping("/order")
                            public class OrderController {
                                @Autowired
                                private RestTemplate restTemplate;

                                @Autowired
                                private DiscoveryClient discoveryClient;


                                @GetMapping("/{productId}")
                                public Product getByProductId(@PathVariable("productId") Long productId){

                                    List<ServiceInstance> instances = discoveryClient.getInstances("product-service");

                                    //有可能同一个服务注册多次，但是现在只考虑一个
                                    ServiceInstance instance = instances.get(0);
                                    String ip = instance.getHost();
                                    int port = instance.getPort();
                                    String url = "http://"+ip+":"+port+"/product/"+productId;
                                    return  restTemplate.getForObject(url,Product.class);
                                }
                            }
                1.5.7   测试：http://localhost:1010/
                                http://localhost:2020/order/5
                                
                1.5.8   集群：（修改yml配置就行了）                            
                            eureka:
                              client:
                                service-url:
                                 defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka #告诉服务提供者要把服务注册到哪儿
                              instance:
                                prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                1.5.9   测试集群：http://localhost:2020/order/5        
                
                
            1.5 增加eureka-server-1010
                1.5.1 导包：
                        <dependencies>
                            <!--导入服务实所依赖的包-->
                            <dependency>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-starter-web</artifactId>
                            </dependency>
                            <dependency>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-starter-test</artifactId>
                            </dependency>
                            <!--Eureka服务端支持-->
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
                            </dependency>
                        </dependencies>
                1.5.2 yml配置：
                        server:
                          port: 1010
                        spring:
                          application:
                            name: eureka
                        eureka:
                          instance:
                            hostname: localhost
                          client:
                            registerWithEureka: false #是否要注册到eureka
                            fetchRegistry: false #表示是否从Eureka Server获取注册信息
                            serviceUrl:
                              defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置

                1.5.3 启动类：
                        @SpringBootApplication
                        @EnableEurekaServer //标识是注册中心
                        public class EurekaServer {
                            public static void main(String[] args) {
                                SpringApplication.run(EurekaServer.class,args);
                            }
                        }
                1.5.4 访问：
                        localhost:1010
                1.5.5 eureka集群：
                        application.yml:
                            spring:
                              profiles:
                                active: eureka1
                        application-eureka1.yml:
                            server:
                              port: 1010
                            spring:
                              application:
                                name: eureka-server-1
                            eureka:
                              instance:
                                hostname: eureka1
                              client:
                                registerWithEureka: true #是否要注册到eureka
                                fetchRegistry: true #表示是否从Eureka Server获取注册信息
                                serviceUrl:
                            #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置
                                  defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka
                        application-eureka2.yml:
                            server:
                              port: 1011
                            spring:
                              application:
                                name: eureka-server-2
                            eureka:
                              instance:
                                hostname: eureka2
                              client:
                                registerWithEureka: true #是否要注册到eureka
                                fetchRegistry: true #表示是否从Eureka Server获取注册信息
                                serviceUrl:
                            #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置
                                  defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka
                        application-eureka3.yml:
                            server:
                              port: 1012
                            spring:
                              application:
                                name: eureka-server-3
                            eureka:
                              instance:
                                hostname: eureka3
                              client:
                                registerWithEureka: true #是否要注册到eureka
                                fetchRegistry: true #表示是否从Eureka Server获取注册信息
                                serviceUrl:
                            #      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #单机配置
                                  defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka
                1.5.6    测试：
                            eureka1：1010   
                            eureka2：1011 
                            eureka3：1012
                            
                            
            1.6    多个服务提供者时的负载均衡：
                    ribbon的使用：
                    1.6.1 导包：
                            order-service-2020的pom中：
                                <!--客户端负载均衡实现 ribbon-->
                                <dependency>
                                    <groupId>org.springframework.cloud</groupId>
                                    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
                                </dependency>
                    1.6.2 配置类加注解：
                            @Bean
                            @LoadBalanced
                            public RestTemplate restTemplate(){
                                return new RestTemplate();
                            }
                    1.6.3 order-service-2020的controller改造：
                            @RestController
                            @RequestMapping("/order")
                            public class OrderController {
                                @Autowired
                                private RestTemplate restTemplate;

                                @Autowired
                                private DiscoveryClient discoveryClient;


                                @GetMapping("/{productId}")
                                public Product getByProductId(@PathVariable("productId") Long productId){
                                    String url = "http://PRODUCT-SERVICE/product/"+productId;
                                    return  restTemplate.getForObject(url,Product.class);
                                }
                            }
                    1.6.4    product-service-2010 的controller改造：    
                                @RestController
                                @RequestMapping("/product")
                                public class ProductController {

                                    @Autowired
                                    private ApplicationContext context;

                                    @GetMapping("/{id}")
                                    public Product getById(@PathVariable("id") Long id){
                                        System.out.println("getById......");
                                        String[] activeProfiles = context.getEnvironment().getActiveProfiles();
                                        System.out.println(activeProfiles[0]);
                                        //正常请求应该调用service，并且service调用Mapper，现在直接返回
                                        return new Product(id,"莫尔"+activeProfiles[0]);
                                    }
                                }
                    1.6.5    yml配置：
                                application.yml:
                                        spring:
                                          profiles:
                                            active: server1
                                application-server1.yml:
                                    server:
                                      port: 2010
                                    spring:
                                      application:
                                        name: product-service
                                    eureka:
                                      client:
                                        service-url:
                                         defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka  #告诉服务提供者要把服务注册到哪儿
                                      instance:
                                        prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                        ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                                application-server2.yml:
                                    server:
                                      port: 2011
                                    spring:
                                      application:
                                        name: product-service
                                    eureka:
                                      client:
                                        service-url:
                                         defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka  #告诉服务提供者要把服务注册到哪儿
                                      instance:
                                        prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                        ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                                application-server3.yml:
                                    server:
                                      port: 2012
                                    spring:
                                      application:
                                        name: product-service
                                    eureka:
                                      client:
                                        service-url:
                                         defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka  #告诉服务提供者要把服务注册到哪儿
                                      instance:
                                        prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                                        ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                
                    1.5.6    配置轮询或权重：
                                配置类加方法：
                                    配置类：
                                    @Configuration
                                    public class Confi {
                                        @Bean
                                        public RestTemplate restTemplate(){
                                            return new RestTemplate();
                                        }
                                        //配置内置负载均衡
                                        @Bean
                                        public IRule rule(){

                                            return new WeightedResponseTimeRule();
                                        }
                                    }
                    1.5.7    优化配置：超时和饥饿加载
                                ribbon:
                                  connectTimeout: 3000                #链接超时时间
                                  readTimeout: 3000                    #读取超时时间
                                  maxAutoRetries: 1                 #重试机制：同一台实例最大重试次数
                                  maxAutoRetriesNextServer: 1         #重试负载均衡其他的实例最大重试次数
                                  okToRetryOnAllOperations: false   #是否所有操作都重试，因为针对post请求如果没做幂等处理可能会造成数据多次添加/修改
                                  eager-load:
                                    enabled: true
                                    clients: product-service    #如果不配置，所有都饥饿加载，当然可以一个一个配置
                    1.5.8    测试：
                            http://localhost:2020/order/5
            
            
            1.7    多个服务提供者时使用feign的负载均衡：拷贝order-service                    
                    1.7.1 yml配置：
                            去掉ribbon相关。
                            
                            ribbon:
                              ConnectTimeout: 3000
                              ReadTimeout: 6000
                    1.7.2 导包：
                            去掉ribbon相关。
                            
                            <!--feign支持-->
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-openfeign</artifactId>
                            </dependency>
                    1.7.3  只要controller进行改造：
                                @RestController
                                @RequestMapping("/order")
                                public class OrderController {

                                    @Autowired
                                    private ProductClient productClient;

                                    @GetMapping("/{productId}")
                                    public Product getByProductId(@PathVariable("productId") Long productId){
                                        System.out.println(productClient.getClass());
                                        return productClient.getById(productId);
                                    }
                                }
                    1.7.4  写client接口：
                                @RequestMapping("/product")
                                @FeignClient("PRODUCT-SERVICE")
                                public interface ProductClient {
                                    @GetMapping("/{id}")
                                     Product getById(@PathVariable("id") Long id);
                                }
                    1.7.5  启动类：
                                @SpringBootApplication
                                @EnableEurekaClient
                                @EnableFeignClients
                                //扫描当前包及其子孙包下面加了@FeignClient这个注解的即可
                                //会为这些接口创建本地代码对象，代理对象的底层其实就是通过ribbon完成服务的远程调用
                                public class OrderApplication2020 {

                                    public static void main(String[] args) {
                                        SpringApplication.run(OrderApplication2020.class,args);
                                    }
                                }
                                
                                
            1.8 服务提供者使用feign时的熔断：拷贝order-service    
                    1.8.1 创建一个client包：
                        类1：
                        @RequestMapping("/product")
                        @FeignClient(value = "PRODUCT-SERVICE",fallbackFactory = RroductClientFallbackFactory.class)
                        public interface ProductClient {
                            @GetMapping("/{id}")
                            Product getById(@PathVariable("id") Long id);
                            @GetMapping()
                            List<Product> getAll();
                        }
                        
                        类2：
                        @Component
                        public class RroductClientFallbackFactory implements FallbackFactory<ProductClient> {
                            @Override
                            public ProductClient create(Throwable throwable) {
                                return new ProductClient() {
                                    @Override
                                    public Product getById(Long id) {
                                        return new Product(id,"报错！");
                                    }

                                    @Override
                                    public List<Product> getAll() {
                                        System.out.println("报错了！");
                                        return new ArrayList<>();
                                    }
                                };
                            }
                        }
                    1.8.2 controller中：
                        @RestController
                        @RequestMapping("/order")
                        public class OrderController {
                            @Autowired
                            private ProductClient productClient;

                            @GetMapping("/{productId}")
                            public Product getByProductId(@PathVariable("productId") Long productId){
                                System.out.println(productClient.getClass());
                                return productClient.getById(productId);
                            }
                        }
                    1.8.3 yml配置：
                        feign:
                          hystrix:
                            enabled: true #开启熔断支持
                          client:
                            config:
                              remote-service:           #服务名，填写default为所有服务
                                connectTimeout: 3000
                                readTimeout: 3000
                        hystrix:
                          command:
                            default:
                              execution:
                                isolation:
                                  thread:
                                    timeoutInMilliseconds: 3000
                                    
                                    
            1.9    histrx
                    1.9.1 拷贝服务提供者
                    1.9.2 Pom
                            <!--断路器-->
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
                            </dependency>
                    1.9.3 Yml
                        server:
                          port: 2015
                        spring:
                          application:
                            name: product-service
                        eureka:
                          client:
                            service-url:
                             defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka #告诉服务提供者要把服务注册到哪儿
                          instance:
                            prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                            ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                        ribbon:
                          MaxAutoRetries: 1 #最大重试次数
                          MaxAutoRetriesNextServer: 1 #切换实例的重试次数
                          OkToRetryOnAllOperations: false # 对所有的操作请求都进行重试，
                          ConnectTimeout: 1000 #请求连接的超时时间
                          ReadTimeout: 1800 #请求处理的超时时间hystrix:
                          command:
                            default:
                              execution:
                                isolation:
                                  thread:
                                    timeoutInMilliseconds: 3000 #hystrix超时,置thread和semaphore两种隔离策略的超时时间
                    1.9.4 代码
                        启动类：@EnableHystrix //开启断路支持
                        ProductController中：@HystrixCommand(fallbackMethod = "getByIdFallBack")

                    1.9.5 测试
                    
                    
            2.0 zuul的使用：
                    2.0.1 导包：
                        <dependencies>
                            <!--springboot支持-->
                            <dependency>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-starter-web</artifactId>
                            </dependency>
                            <dependency>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-starter-test</artifactId>
                            </dependency>

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

                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
                            </dependency>
                        </dependencies>
                        
                    2.0.2 yml配置：
                        server:
                          port: 1020
                        spring:
                          application:
                            name: zuul-gateway
                        eureka:
                          client:
                            service-url:
                             defaultZone: http://eureka1:1010/eureka,http://eureka2:1011/eureka,http://eureka3:1012/eureka #告诉服务提供者要把服务注册到哪儿
                          instance:
                            prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
                            ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
                        zuul:
                          retryable: true #可重试
                          routes:
                            myProduct.serviceId: product-service #服务名称
                            myProduct.path: /myProduct/** # 把myProduct打头的所有请求都转发给product-service
                            myOrder.serviceId: order-service #服务名称
                            myOrder.path: /myOrder/** # 把myOrder打头的所有请求都转发给order-service
                          ignored-services: "*" #所有服务都不允许以服务名来访问
                          prefix: "/services" #统一前缀
                        ribbon:
                          ConnectTimeout: 250 # 连接超时时间(ms)
                          ReadTimeout: 2000 # 通信超时时间(ms)
                          OkToRetryOnAllOperations: true # 是否对所有操作重试
                          MaxAutoRetriesNextServer: 2 # 同一服务不同实例的重试次数
                          MaxAutoRetries: 1 # 同一实例的重试次数
                        hystrix:
                          command:
                            default:
                              execution:
                                isolation:
                                  thread:
                                    timeoutInMillisecond: 3000 # 熔断超时时长：3000ms
                            
                    2.0.3 启动类：
                        @SpringBootApplication
                        @EnableEurekaClient
                        @EnableZuulProxy //启动zuul网关
                        public class ZuulGatewayApp1020 {
                            public static void main(String[] args) {
                                SpringApplication.run(ZuulGatewayApp1020.class,args);
                            }
                            
                    2.0.4 测试：http://localhost:1020/services/myOrder/order/5
                    
                    2.0.5 过滤器：
                        //交给Spring管理
                        @Component
                        public class LoginFilter extends ZuulFilter {
                            //过滤器类型-前置过滤器
                            @Override
                            public String filterType() {
                                return "pre";
                            }
                            //同一种过滤器执行顺序
                            @Override
                            public int filterOrder() {
                                return 1;
                            }
                            //时候过滤
                            @Override
                            public boolean shouldFilter() {
                                //现在认为所有的都要拦截
                                return true;
                            }
                            //真正业务逻辑
                            @Override
                            public Object run() throws ZuulException {
                                //1 获取请求上下文对象
                                RequestContext context = RequestContext.getCurrentContext();
                                //2 获取请求对象
                                HttpServletRequest request = context.getRequest();
                                //3 从请求头中获取token
                                String token = request.getHeader("token");
                                //4 登录判断-是否有token，并且redis可以获取， 现在模拟只需要判断null
                                if (StringUtils.isEmpty(token)){
                                    context.setSendZuulResponse(false); //出错了
                                    context.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value()); //401 未登录
                                }
                                //5 权限判断 //@TODO
                                //放行
                                return null;
                            }
                        }
                    2.0.6 用config的gitee改造zuul
                            2.0.6.1 导包：
                                        <!--configclient端-->
                                        <dependency>
                                            <groupId>org.springframework.cloud</groupId>
                                            <artifactId>spring-cloud-starter-config</artifactId>
                                        </dependency>
                            2.0.6.2 bootstrap.yml配置：
                                        spring:
                                          cloud:
                                            config:
                                              name: zuul #gitee上面名称
                                              profile: dev #环境
                                              label: master #分支
                                              uri: http://127.0.0.1:1030 #配置configserver
                                              
                                    application.yml配置：
                                        spring:
                                          application:
                                            name: zuul-gateway
                                             
                                
            2.1    config配置
                    2.1.1 创建项目config-server-1030
                    2.1.2 导包：
                            <dependencies>
                                <!--导入服务实所依赖的包-->
                                <dependency>
                                    <groupId>org.springframework.boot</groupId>
                                    <artifactId>spring-boot-starter-web</artifactId>
                                </dependency>
                                <dependency>
                                    <groupId>org.springframework.boot</groupId>
                                    <artifactId>spring-boot-starter-test</artifactId>
                                </dependency>

                                <!--配置中心支持-->
                                <dependency>
                                    <groupId>org.springframework.cloud</groupId>
                                    <artifactId>spring-cloud-config-server</artifactId>
                                </dependency>
                            </dependencies>
                    2.1.3 yml配置：
                            server:
                              port: 1030
                            spring:
                              application:
                                name: config-server
                              cloud:
                                config:
                                  server:
                                    git:
                                      uri: https://gitee.com/krator/test.git
                                      username: xx
                                      password: xx
                    2.1.4 启动类：
                            @SpringBootApplication
                            @EnableConfigServer //启动configserver
                            public class ConfigServerApp1030 {
                                public static void main(String[] args) {
                                    SpringApplication.run(ConfigServerApp1030.class,args);
                                }
                            }
                    2.1.5 测试：http://localhost:1030/zuul/dev
            
            
            2.2 热更新
                    2.2.1（config-server中）
                     2.2.1.1 导包：
                            <!--config热刷新jar包-->
                            <dependency>
                                <groupId>org.springframework.cloud</groupId>
                                <artifactId>spring-cloud-starter-bus-amqp</artifactId>
                            </dependency>
                            <dependency>
                                <groupId>org.springframework.boot</groupId>
                                <artifactId>spring-boot-starter-actuator</artifactId>
                            </dependency>

                            <dependency>
                                <groupId>com.alibaba</groupId>
                                <artifactId>fastjson</artifactId>
                                <version>1.2.60</version>
                            </dependency>
                    2.2.1.2  yml配置增加：
                                rabbitmq: #集成RabbitMQ如果配置是默认，可以省略
                                    host: localhost #mq连接地址
                                    port: 5672 #mq端口
                                    username: guest
                                    password: guest
                                #actuator配置
                                management:
                                  endpoint:
                                    health:
                                      show-details: always #打印日志
                                  endpoints:
                                    web:
                                      exposure:
                                        include: "*" #向外暴露的接口，这里*则表示所有的actuator接口都可以被访问
                                    enabled-by-default: true  #开启actuator监控
                    2.2.2 （zuul-gateway中yml）
                        2.2.2.1 spring:
                                  cloud:
                                    config:
                                      name: application-zuul #gitee上面名称
                                      profile: dev #环境
                                      label: master #分支
                                      uri: http://127.0.0.1:1030 #配置configserver
                                      bus: #这行代码很重要，根据官方定义的标准来的 ,就是为了产生一个bus.id
                                        id: ${spring.application.name}:${spring.cloud.config.profile}:${random.value}
                                  rabbitmq: #集成RabbitMQ如果配置是默认，可以省略
                                    host: localhost #mq连接地址
                                    port: 5672 #mq端口
                                    username: guest
                                    password: guest
                    2.2.3 （eureka中yml）
                        2.2.3.1 spring:    
                                  cloud:
                                    config:
                                      name: application-eureka #gitee上面名称
                                      profile: dev #环境
                                      label: master #分支
                                      uri: http://127.0.0.1:1030 #配置configserver
                                      bus: #这行代码很重要，根据官方定义的标准来的 ,就是为了产生一个bus.id
                                        id: ${spring.application.name}:${spring.cloud.config.profile}:${random.value}
                                  rabbitmq: #集成RabbitMQ如果配置是默认，可以省略
                                    host: localhost #mq连接地址
                                    port: 5672 #mq端口
                                    username: guest
                                    password: guest
                    2.2.4 修改gitee的webhooks地址为内网穿透的修改地址
                    2.2.5 config-server中增加配置类：
                            @Component
                            public class WebHooksFilter implements Filter {
                                @Override
                                public void init(FilterConfig filterConfig) throws ServletException {
                                }

                                @Override
                                public void destroy() {
                            }

                            @Override
                            public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
                                HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
                                String url = new String(httpServletRequest.getRequestURI());

                                if(!url.endsWith("/bus-refresh")){
                                    filterChain.doFilter(servletRequest,servletResponse);
                                    return;
                                }
                                RequestWrapper requestWrapper = new RequestWrapper(httpServletRequest);
                                filterChain.doFilter(requestWrapper, servletResponse);
                            }

                            private class RequestWrapper extends HttpServletRequestWrapper {
                                public RequestWrapper(HttpServletRequest request) {
                                    super(request);
                                }

                            @Override
                            public ServletInputStream getInputStream() throws IOException {
                                byte[] bytes = new byte[0];
                                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
                                ServletInputStream servletInputStream = new ServletInputStream() {
                                @Override
                                public int read() throws IOException {
                                    return byteArrayInputStream.read();
                                }

                                @Override
                                public boolean isFinished() {
                                    return byteArrayInputStream.read() == -1 ? true : false;
                                }

                                @Override
                                public boolean isReady() {
                                    return false;
                                }

                                @Override
                                public void setReadListener(ReadListener listener) {

                                }
                                    };
                                    return servletInputStream;
                                }
                                }
                            }
                    2.2.6    启动类：加@ServletComponentScan("cn.itsource.config")
                            

技术流-天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud之微服务环境搭建
qq_65345936的博客
12-12 939
微服务架构，简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独 立运行的项目。
微服务实验环境搭建
aaquecn6047的博客
07-27 219
MicroService 微服务学习 目录结构 eureka-client:测试使用 eureka-client2:consumerB eureka-client3:consumerA eureka-server:注册中心 gateway-service-zuul:网关中心 hystrix-dashboard-turbine:monitor监控中心 service:springboot...
微服务实施笔记（二）——搭建实验部署环境
lizpen的专栏
02-08 1180
上回书为微服务的实施定下了基调，接下来就开干吧。 搭建服务器环境 实验环境使用虚拟机搭建。本次实验需要搭建3台服务器，分别命名为server1、server2和server3。在虚拟机中安装ubuntu server 16.04 LTS操作系统。把虚拟机的网络连接方式设置为桥接方式，这样每台虚拟机就可以被当做连在网络中的物理机了。本次实验的宿主电脑所在的网络的ip地址段为192.168.1...
如何快速搭建微服务开发测试环境
chinaherolts2008的博客
09-05 385
一、背景 作为后端开发一名，在某天下午接到紧急任务，需要根据客户需求快速搭建一套微服务架构的开发测试环境，以供客户联调。但是我们是小公司资源有限，在个人电脑上部署又很难对外提供服务。 经过一番查找，市场上符合开箱即用条件的厂商不多，有一些还是需要公有云或私有云部署，能提供开箱即用的SaaS化服务的就更少了。 比如：华为云提供了软件开发平台DevCloud，腾讯云收购CODING后也推出了自己的研发管理平台，但是要使用这些大厂的服务，就要为他们的其他生态工具买单，在前期投入有限的情况下，只能放弃。 二
第二章 : 微服务环境搭建
12-22
我们承接上一篇开始 第一章 ：微服务的架构介绍发展 SpringCloudAlibaba技术栈的学习 我们本次是使用的电商项目中的商品、订单、用户为案例进行讲解。 2.1 案例准备 2.1.1 技术选型 maven：3.6.0 数据库：MySQL 5.7 ...
第二章:微服务环境搭建
02-24
user用户微服务【端口:807x】shop-product商品微服务【端口:808x】shop-order订单微服务【端口:809x】2.1.3微服务调用在微服务架构中，最常见的场景就是微服务之间的相互调用。我们以电商系统中常见的用户下单为例来...
微服务部署搭建实战教程
最新发布
12-13
微服务部署搭建实战教程主要涵盖了微服务的基础概念、持续集成/部署、接入层设计、无状态化、容器化以及服务拆分的相关规范。以下是对这些知识点的详细解释： 1. **持续集成/部署 (CICD)** 持续集成强调开发者频繁...
自己做的微服务环境简单搭建----网上书店
03-26
项目博客地址...包含微服务内容有 1:服务的注册与发现（Eureka） 2:服务消费者（Feign）(Finchley版本) 3:路由网关(zuul)(Finchley版本) 4：服务消费者（rest+ribbon）(Finchley版本)
亲自动手搭建微服务框架和测试环境-11-Spring Framework
changjingya1879的博客
08-04 282
一、架构和组件关系图Spring 5的架构图如下：各组件之间的依赖图如下：Spring5有20 个组件（1300多个文件），这些组件被分别整合在核心容器（Core Container）、AOP（Aspect Oriented Programming）和设备支持（Instrmentation）、数据访问及集成（Data Access/Integeration）、Web、报文发送...
微服务开发环境搭建
llh304的博客
06-09 783
为了避免每次拉取代码或提交代码输入账号密码，设置ssh免密连接，设置好后通过命令 ssh -T git@gitee.com查看是否成功，会提示是否需要使用这个密钥作为连接，输入yes即可，以后就会使用这个密钥提交拉取。所有模块添加成功后，把这个项目作为一个总项目，把微服务其他服务作为一个模块添加进来，复制其他一个服务中的pom.xml到这个总目录底下修改配置文件，删除没有到文件，添加package为pom。点击maven+号，把总服务添加进来，对总服务进行操作，其他都会更新。安装后，需要安装一些插件。
亲自动手搭建微服务框架和测试环境-1-背景
weixin_33709364的博客
06-01 312
团队技能提升和转型需求如下，为了满足该需求，亲自手搭建微服务框架和测试环境。这是第一部分，实际写于去年。后续部分会陆陆续续补充。 转载于:https://blog.51cto.com/5526964/2403501...
微服务部署和测试 (五）
chixushuchu的博客
01-14 773
    目录 一Netflix oss微服务架构 边缘服务器Netflix Zuul Server 负载均衡 Netflix Ribbon  客户端负载均衡 服务器端负载均衡 电路断路器： Netflix Hystrix 电路断路器和帮助系统运行 启动断路器：使用其他服务的微服务的主类应使用  配置回退方法 定义回退方法 服务注册和发现：Netflix Eureka 用于服...
Kratos战神微服务框架(一)
qq_53267860的博客
06-29 1738
Kratos 一套轻量级 Go 微服务框架，包含大量微服务相关框架及工具。我们致力于提供完整的微服务研发体验，整合相关框架及工具后，微服务治理相关部分可对整体业务开发周期无感，从而更加聚焦于业务交付。对每位开发者而言，整套 Kratos 框架也是不错的学习仓库，可以了解和参考到微服务方面的技术积累和经验。 创建项目 通过 kratos 命令创建项目模板： 使用 添加服务, 共用 ,大仓模式 项目结构 代码生成与运行 生成 运行 测试接口 测试HTTP接口相关逻辑代码位于......
微服务架构的环境搭建及简单测试
qq_63492318的博客
11-25 1867
简单介绍了系统架构的演变过程，以及微服务架构的环境搭建案例及测试...
第5天-微服务环境搭建（注册中心、配置中心、网关、远程调用测试）
zenggeweiss的博客
02-08 1110
微服务环境搭建-注册中心、配置中心、网关、远程调用测试
亲自动手搭建微服务框架和测试环境-10-配置中心
changjingya1879的博客
08-04 409
1实例（1）创建服务器使用FileàNewàSpring Starter Project创建项目，按照向导选择config server。使用注解@EnableConfigServer，如下：修改application.properties:（2）创建客户端使用FileàNewàSpring Starter Project创建项目，按照向导选择config server、we...
二、springcloud微服务测试环境搭建
含江君
10-28 781
版本说明： springcloud:Greenwich.SR3 springboot:2.1.8 1、构建步骤 1.1、microservicecloud整体父工程Project 新建父工程microservicecloud，切记是Packageing是pom模式 此maven project目的：主要是定义POM文件，将后续各个子模块公用的jar包等统一提出来，类似一个抽象父类 pom.xml...
微服务架构之测试环境部署
张利剑(Java)
07-11 1024
背景 微服务架构已然成为主流，对于快速成长中的中公司，随着公司规模逐渐扩大，业务需求越来越多， 传统的部署方式弊端已经越来越明显，尤其是对于测试环境，服务分配不均导致资源浪费，环境混乱导致需求各种撞车，前后端联调流程繁琐浪费时间等等问题，为了解决以上问题，自研部署平台应运而生。 技术选型 平台基于java开发，采用spring boot2.0 底层采用k8s + docker 中间层通过shell...
黑马头条项目开发笔记——SpringCloud微服务环境搭建与基础
我们将重点关注环境搭建、SpringCloud微服务的使用，包括注册发现、服务调用以及网关等关键概念。 **环境搭建** 在开始项目开发之前，首要任务是搭建开发环境。这通常包括安装Java开发工具(JDK)、配置IDE（如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值