springcloud

最新推荐文章于 2024-06-16 09:46:44 发布

qq_37786118

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量250

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_37786118/article/details/104276933

版权

文章目录

一.单体应用和微服务

一.单体应用

1.什么的单体应用

项目所有的资源都在一个应用中，打包成一个war包，使用一个tomcat去运行，运行在一个进程中

2.单体应用的问题

一个模块挂了，整个项目都受影响
单个tomcat更能处理的并发有限，可以做集群，但是不方便局部(某一个模块)扩展
维护/开发/升级比较麻烦
代码臃肿,编译，打包都比较慢
技术选型单一
数据库选型单一

二.微服务架构

1.什么是微服务架构

微服务就是把一个大的系统，拆分成多个小的服务，每个微服务只专注一个业务，每个服务有各自的进程，微服务之间使用网络通信协议进行数据交互(通常是基于HTTP的RESTful API)。

2.微服务的特点

数据库选型多样化
技术选型多样化
每个微服务专注一个业务
每个维护有自己的进程
微服务之间通过网络协议进行通信
方便做局部拓展
开发/维护/升级更方便

3.微服务缺点

成本高
技术要求比较高
部署麻烦

在这里插入图片描述

4.SpringCloud简介

Spring cloud是一个基于Spring Boot实现的服务治理工具包，用于微服务架构中管理和协调服务的

5.SpringCloud和Dubbo的区别

dubbo是rpc框架
SpringCloud是一系列微服务解决方案
dubbo给予tcp
SpringCloud基于http
dubbo在通信方面的性能高于SpringCloud

二.SpringCloud入门

一.注册中心原理

在这里插入图片描述 #### 二.搭建注册中心

1.创建多模块工程

springcloud-parent
  springcloud-eureka-server-1000 //注册中心EurekaServer 
  springcloud-order-server-3000  //订单服务EurekaClient ,消费者
  springcloud-user-server-2000   //用户服务EurekaClient ,提供者

2.springcloud-parent管理依赖

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

    <groupId>cn.itsource.springcloud</groupId>
    <artifactId>springcloud-parent</artifactId>
    <version>1.0-SNAPSHOT</version>

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

3.springcloud-eureka-server-1000导入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

4.主配置类

/**
 * @EnableEurekaServer :开启注册中心
 */
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication1000 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication1000.class);
    }
}

5.配置文件application.yml

server:
  port: 1000
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false #禁用注册中心向自己注册
    fetchRegistry: false  #不让注册中心获取服务的注册列表
    serviceUrl:
      defaultZone: http://localhost:1000/eureka/
      #注册中心的注册地址 ，其他微服务需要向这个地址注册

三.搭建提供者服务 springcloud-user-server-2000

1.导入依赖

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

    </dependencies>

2.创建配置类

//@EnableDiscoveryClient:开启注册中心客户端 EurekaClient
@SpringBootApplication
@EnableDiscoveryClient
public class UserServerApplication2000 {
    public static void main(String[] args) {
        SpringApplication.run(UserServerApplication2000.class);
    }
}

3.配置文件

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1000/eureka/ #注册中心地址
server:
  port: 2000
spring:
  application:
    name: user-server

四.搭建消费者服务 springcloud-order-server-3000

步骤同上(搭建提供者服务)

五.使用ip注册

1.修改用户服务和订单服务如下

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1000/eureka/ #注册中心地址
  instance:
    prefer-ip-address: true #使用ip地址注册
    instance-id: order-server  #指定服务的id

三.订单服务和用户服务完成通信

在这里插入图片描述

一.搭建公共的用户模块

1.建立domain : user

二.user-server提供者服务编写接口

1.依赖公共模块

<dependency>
    <groupId>cn.itsource.springcloud</groupId>
    <artifactId>springcloud-common-user</artifactId>
    <version>...</version>
</dependency>

2.创建controller

/**
 * 用户提供者服务
 */
@RestController
public class UserProviderController {

    /**
     * 提供者方法，orderServer消费者来调用
     * @param id
     * @return
     */
    // @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    @GetMapping("/user/{id}")
    public User getUserById(@PathVariable("id")Long id){
        System.out.println("UserProviderController.getUserById被调用了......");
        return new User(id,"zs:"+id , "123");
    }
}

三.order-server消费者服务

1.依赖公共模块

<dependency>
    <groupId>cn.itsource.springcloud</groupId>
    <artifactId>springcloud-common-user</artifactId>
    <version>...</version>
</dependency>

2.定义RestTemplate的bean

  /**
     * SpringMvc提供的一个基于Rest风格的http调用工具
     * @return
     */
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

3.定义消费者的Controller

/**
 * 订单消费者服务
 */
@RestController
public class OrderConsumerController {

    @Autowired
    private RestTemplate restTemplate ;

    /**
     * 该方法是浏览器来调用
     * @param id
     * @return
     */
    @GetMapping("/order/user/{id}")
    public User getUserById(@PathVariable("id") Long id){
        System.out.println("OrderConsumerController.getUserById被调用了......");
        String url = "http://localhost:2000/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }
}

四.EurekaServer高可用集群

一.单节点故障

1.什么是EurekaServer单节点故障

如果只有一个EurekaSever，如果EurekaSever挂了那么整个微服务都不可用

2.解决方案

EurekaServer高可用集群

二.EurekaServer集群

1.原理图

在这里插入图片描述

2.搭建EurekaServer集群

创建两个本地域名 C:\Windows\System32\drivers\etc\hosts

127.0.0.1 peer1
127.0.0.1 peer2

修改注册中心eureka-server-1000

server:
  port: 1000
eureka:
  instance:
    hostname: peer1
  client:
    registerWithEureka: false #禁用注册中心向自己注册
    fetchRegistry: false  #不让注册中心获取服务的注册列表
    serviceUrl:
      defaultZone: http://peer2:1001/eureka/
      #注册中心的注册地址 ，其他微服务需要向这个地址注册

搭建第二个注册中心eureka-server-1001 - 复制

server:
  port: 1001
eureka:
  instance:
    hostname: peer2
  client:
    registerWithEureka: false #禁用注册中心向自己注册
    fetchRegistry: false  #不让注册中心获取服务的注册列表
    serviceUrl:
      defaultZone: http://peer1:1000/eureka/
      #注册中心的注册地址 ，其他微服务需要向这个地址注册

3.修改EurekaClient (UserServer ,OrderServer)

eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:1000/eureka/,http://peer2:1001/eureka/ #注册中心地址
      ...

五.Ribbon

ribbon是负载均衡器，是基于RestTemplate ,它赋予了RestTemplate 负载均衡的能力

一.集群和负载均衡原理

在这里插入图片描述

二.提供者user-server集群

1.创建user-server服务2001 - 赋值

2.修改配置

eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:1000/eureka/,http://peer2:1001/eureka/ #注册中心地址
  instance:
    prefer-ip-address: true #使用ip地址注册
    instance-id: user-server1  #指定服务的id
server:
  port: 2000 
spring:
  application:
    name: user-server

注意：instance-id需要修改，而 spring.application.name 不需要修改，端口需要修改

3.修改主类名，pom中的名字，parent中的模块增加

三.order-server集成Ribbon

1.导入依赖

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

2.修改RestTemplate的Bean的定义

 /**
     * SpringMvc提供的一个基于Rest风格的http调用工具
     * @LoadBalanced ：ribbon的负载均衡标签，赋予RestTemplate有负债均衡的能力
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

@LoadBalanced ：ribbon的负载均衡标签，赋予RestTemplate有负债均衡的能力

3.修改Controller调用方式

 @GetMapping("/order/user/{id}")
    public User getUserById(@PathVariable("id") Long id){
        System.out.println("OrderConsumerController.getUserById被调用了......");
        //String url = "http://localhost:2000/user/"+id;
        String url = "http://user-server/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }

修改效果： String url = “http://user-server/user/”+id;

ribbon默认使用的轮询策略

六.Feign

一.什么是Feign

基于Ribbon封装的客户端负载均衡器

二.Feign的集成 - springcloud-dept-server-4000

1.导入依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2.配置类开启Feign

@SpringBootApplication
@EnableFeignClients("cn.itsource.client")
public class DeptServerApplication4000 
...

3.编写Feign的接口

/**
 * @FeignClient(value="user-server") : 针对于用户服务调用的 Fiegn的客户端接口
 *  value属性就是该接口要调用的目标服务的名字
 * Feign是如何实现服务调用的：
 *   1.通过@FeignClient(value="user-server")标签上的服务名字能够找到要调用的目标服务
 *   2.通过接口中的方法的 @GetMapping的url路径找到目标服务的controller的方法 ，
 *   所以要保证Feign客户端接口的方法和目标服务的对应的方法要完全一致。
 *
 */
@FeignClient(value="user-server")
public interface UserFeignClient {

    @GetMapping("/user/{id}")
    User getUserById(@PathVariable("id")Long id);
}

Feign客户端接口的方法和目标服务的对应的方法要完全一致

4.调用

@RestController
public class DeptConsumerController {

    @Autowired
    private UserFeignClient userFeignClient ;

    /**
     * 该方法是浏览器来调用
     * @param id
     * @return
     */
    @GetMapping("/dept/user/{id}")
    public User getUserById(@PathVariable("id") Long id){
        User user = userFeignClient.getUserById(id); //使用Feign的接口调用
        return user;
    }
}

七.Hystrix

一.雪崩效应

一个微服务的故障导致整个微服务调用链全部瘫痪

二.Hystrix介绍

解决服务器故障(雪崩)的一个组件，它可以实现：隔离，熔断，降级，缓存

隔离：包括线程池隔离和信号量隔离，限制调用分布式服务的资源使用，某一个调用的服务出现问题不会影响其他服务调用。

熔断 :当请求次数达到规定的阀值都出现服务故障(超时),Hystrix就把服务标记为短路状态.

正常情况下，断路器处于关闭状态(Closed)，如果调用持续出错或者超时，电路被打开进入熔断状态(Open)，后续一段时间内的所有调用都会被拒绝(Fail Fast)，一段时间以后，保护器会尝试进入半熔断状态(Half-Open)，允许少量请求进来尝试，
如果调用仍然失败，则回到熔断状态
如果调用成功，则回到电路闭合状态;

降级：高并发情况下，为了保证一些主要的服务有足够的资源不出问题，会认为的关掉一些无关紧要的服务，然后返回一些托底的数据，给用户一个友好的提示。
缓存：Hystrix内部会把请求做缓存

三.Ribbon集成Hystrix - springcloud-order-server-3000

1.导入依赖

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

2.controller方法贴注解

@Autowired
    private RestTemplate restTemplate ;
 /**
     * 该方法是浏览器来调用
     *  @HystrixCommand ：开启方法的短路功能 ， 如果方法出现异常，会调用 fallbackMethod
     *  指向的方法 ，然后返回托底数据
     */
  	 @HystrixCommand(fallbackMethod = "payFallback")
    @GetMapping("/pay/user/{id}")
    public User getUserById(@PathVariable("id") Long id){
        //String url = "http://localhost:1000/user/"+id;
        String url = "http://user-server/user/"+id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }

3.托底方法

/**
     * 托底方法
     * @param id
     * @return
     */
    public User payFallback(@PathVariable("id") Long id){
       return new User(-1L,"用户不存在","不存在");
    }

注意：托底方法的参数和返回结果要和原方法一致

四.Feign集成Hystrix - springcloud-dept-server-4000

1.开启Hystrix

feign:
  hystrix:
    enabled: true #开启熔断支持
  client:
    config:
      remote-service:           #服务名，填写default为所有服务
        connectTimeout: 30000
        readTimeout: 30000
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 30000

2.修改Fiegn客户端接口

@FeignClient(value="user-server" ,fallback = UserFeignClientFallback.class)
public interface UserFeignClient {

    @GetMapping("/user/{id}")
    User getUserById(@PathVariable("id")Long id);
}

fallback = UserFeignClientFallback.class : 该类是当前接口的实现类，也是托底数据所在的处理类

3.托底实现

@Component
public class UserFeignClientFallback implements UserFeignClient {
    @Override
    public User getUserById(Long id) {
        System.out.println("托底数据执行....");
        return new User(-1L,"托底数据","");
    }
}

八.SpirngCloud ZUUL

一.基本概念

Zuul是一个SpringCloud的网关组件，它是微服务的入口，网络关卡，通过Zuul我们可以实现请求的分发(负载均衡)，鉴权，限流等等操作。

在这里插入图片描述

二.zuul的基本使用

在这里插入图片描述

1.导入依赖

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.55</version>
        </dependency>
    </dependencies>

2.配置开开启Zuul

/**
 * @EnableZuulProxy :开启 网关
 * @EnableZuulServer
 */
@SpringBootApplication
@EnableZuulProxy
@EnableDiscoveryClient
public class ZuulApplication5000
...

3.配置文件配置zuul

eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:1000/eureka/,http://peer2:1001/eureka/ #注册中心地址
  instance:
    prefer-ip-address: true #使用ip地址注册
    instance-id: zuul-server  #指定服务的id
server:
  port: 5000
spring:
  application:
    name: zuul-server
    
zuul:
  ignored-services: "*"   #禁止使用服务名字进行访问
  prefix: "/servers"  #统一的前缀
  routes: #配置路由，指定服务的访问路径
    dept-server: "/dept/**"
    user-server: "/user/**"
    order-server: "/order/**"
    
  retryable: true #开启重试
ribbon:
  ConnectTimeout: 2000  # 连接超时时间(ms)
  ReadTimeout: 2000 # 通信超时时间(ms)
  OkToRetryOnAllOperations: true # 是否对所有操作重试
  MaxAutoRetriesNextServer: 2 # 同一服务不同实例的重试次数
  MaxAutoRetries: 1 # 同一实例的重试次数
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMillisecond: 3000 # 熔断超时时长：3000ms

三.zuul原理

在这里插入图片描述

- 正常流程：
  - 请求到达首先会经过pre类型过滤器，而后到达routing类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。
- 异常流程：
  - 整个过程中，pre或者routing过滤器出现异常，都会直接进入error过滤器，再error处理完毕后，会将请求交给POST过滤器，最后返回给用户。
  - 如果是error过滤器自己出现异常，最终也会进入POST过滤器，而后返回。
  - 如果是POST过滤器出现异常，会跳转到error过滤器，但是与pre和routing不同的时，请求不会再到达POST过滤器了。

四.自定义Filter实现登录检查

@Component
public class LoginCheckFilter extends ZuulFilter {
    public static final int LOGIN_CHECK_FILTER_ORDER = 1;
    //过滤器的类型 ：
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE; //pre 前置
    }
    @Override
    public int filterOrder() {
        return LOGIN_CHECK_FILTER_ORDER;
    }
    /**
     * 返回true执行run，否则不执行run
     * @return
     */
    @Override
    public boolean shouldFilter() {
        //  login 路径要放行，不需要检查登录
        //请求对象
        HttpServletRequest request = RequestContext.getCurrentContext().getRequest();
        //访问路径
        if(request.getRequestURI().contains("login")){
            return false;
        }
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        //做登录的判断
        RequestContext currentContext = RequestContext.getCurrentContext();
        //请求对象
        HttpServletRequest request = currentContext.getRequest();
        String token = request.getHeader("access-token");
        if(!StringUtils.hasLength(token)){
            //没有登录
            HttpServletResponse response = currentContext.getResponse();
            response.setContentType("text/json;charset=utf-8");
            //响应码：没有授权
            response.setStatus(HttpStatus.SC_UNAUTHORIZED);
            //设置错误响应信息
            Map<String,Object> map = new HashMap<>();
            map.put("success",false );
            map.put("message","没有登录，请先登录");
            String jsonString = JSON.toJSONString(map);

            try {
                response.getWriter().write(jsonString);
            } catch (IOException e) {
                e.printStackTrace();
            }

            //阻止放行
            currentContext.setSendZuulResponse(false);
        }
        //判断token是否正确，来确定是否已经
        return null;
    }
}

九.配置中心

一.基本概念

1.什么是配置中心

集中管理微服务的配置： SpringCloud-config 是分布式配置中心组件

2.配置中心原理图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBcLGVsu-1581482412901)(SpringCloud.assets/1568959920095.png)]

二.集成配置中心

1.使用码云创建远程仓库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4oL7FH1K-1581482412910)(SpringCloud.assets/1568962044739.png)]

2.导入依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>

    </dependencies>

3.配置类开启配置中心

/**
 * @EnableConfigServer:开启配置中心
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableConfigServer
public class ConfigServerApplication6000 
...

4.配置文件

eureka:
  client:
    serviceUrl:
      defaultZone: http://peer1:1000/eureka/,http://peer2:1001/eureka/ #注册中心地址
  instance:
    prefer-ip-address: true #使用ip地址注册
    instance-id: config-server  #指定服务的id
server:
  port: 6001
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/baidu11.com/springcloud-config.git #配置远程仓库地址
          username: 1456868501@qq.com
          password: wodemima123

5.测试

http://localhost:6001/application-dept-test.yml

三.修改dept-server微服务

1.导入依赖

		<!--config客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>

2.创建bootstrap.yml配置文件 - 删除原来的

spring:
  cloud:
    config:
      uri: http://localhost:6001
      name: application-dept       #-test.yml
      profile: test #环境  组成完整的文件名：application-dept-test.yml
      label: master

3.方式二：使用服务名方式发现配置中心

spring:
  cloud:
    config:
      #uri: http://localhost:1030
      name: application-dept
      profile: dev
      label: master
      discovery:
        service-id: config-server #配置中心服务名
        enabled: true #使用服务名访问配置中心
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:1000/eureka/ #注册中心地址,需要从注册中心使用服务名发现配置中心

如果ConfigServer配置中心做了集群，那么配置中心客户端就需要使用服务名的方式发现配置中心

十.五大神兽集成图

在这里插入图片描述

qq_37786118

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springcloud

一.单体应用和微服务一.单体应用1.什么的单体应用项目所有的资源都在一个应用中，打包成一个war包，使用一个tomcat去运行，运行在一个进程中2.单体应用的问题一个模块挂了，整个项目都受影响单个tomcat更能处理的并发有限，可以做集群，但是不方便局部(某一个模块)扩展维护/开发/升级比较麻烦代码臃肿,编译，打包都比较慢技术选型单一数据库选型单一二.微服务架构1....
复制链接

扫一扫