springcloud学习项目

最新推荐文章于 2022-10-24 01:43:31 发布

段落总是简写

最新推荐文章于 2022-10-24 01:43:31 发布

阅读量181

点赞数 1

分类专栏： springcloud spring

本文链接：https://blog.csdn.net/weixin_41746577/article/details/103683790

版权

spring 同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

springcloud

2 篇文章 0 订阅

订阅专栏

maven配置

父项目

<?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.mao</groupId>
    <artifactId>spring-cloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloud-api</module>
    </modules>

    <!-- 打包方式：pom -->
    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <lombok.version>1.16.10</lombok.version>
        <log4j.version>1.2.17</log4j.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <!-- springcloud的依赖 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- springboot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.1.4.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 数据库 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.10</version>
            </dependency>
            <!-- springboot 启动器 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.2</version>
            </dependency>
            <!-- junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!-- lombom -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!-- log4j -->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

代码释义：

<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <junit.version>4.12</junit.version> <lombok.version>1.16.10</lombok.version> <log4j.version>1.2.17</log4j.version> </properties> 这段代码中配置的属性是用于动态赋值的,可以在下面的包中需要再去固定写死了,面对大项目的时候方便了配置
<packaging>pom</packaging>由默认的jar改为pom,因为这是父项目,会有很多子项目
<dependencyManagement>表明只是依赖管理,只有在子类用到的时候才会去导入。
<modules> <module>springcloud-api</module> </modules> 配置子模块的地方

子项目配置

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

    <groupId>com.mao</groupId>
    <artifactId>springcloud-api</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--  当前的module自己需要的依赖,如果父依赖中已经配置了版本。这里就不用写了 -->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

指定了父项目,直接用其中的包而不需要指定版本了。

实体类

package com.mao.springcloud.pojo;


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

import java.io.Serializable;

@Data
@NoArgsConstructor
@Accessors(chain = true)//开启链式写法  就相当于可以用以下的写法:
//Dept dept = new Dept(); dept.setDeptno(1).setDname("xxx").set.....,有点类似建造者模式
//因为需要网络传输,所以需要序列化
public class Dept implements Serializable {//实体类  orm映射

    private int deptno;//主键
    private String dname;//名称
    private String db_source;//来自哪个数据库;因为微服务一个服务对应一个数据库,同一个信息可能存在于不同的数据库

    public Dept(String dname) {
        this.dname = dname;
    }
}

根据数据库建立了与之对应的实体类。要注意的两点是序列化和链式写法:

序列化,实现了序列化的标识接口Serializable,这样在多服务器之间的网络传输之中就可以在序列化后传输了。
链式编程,@Accessors(chain = true)该注解开启了链式编程,其实就是建造者模式。

服务端

server:
  port: 8001 #服务器端口号
#mybatis配置
mybatis:
  type-aliases-package: com.mao.springcloud.pojo
  config-location: classpath:mybatis-config.xml
  mapper-locations: classpath:mappers/*.xml
  map-underscore-to-camel-case: true
#spring配置
spring:
  application:
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource #数据源
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: ******

dao

package com.mao.springcloud.dao;

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

import java.util.List;

@Mapper
@Repository
public interface DeptDao {

    boolean addDept(Dept dept);

    Dept queryDeptById(int id);

    List<Dept> queryAll();
}

mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mao.springcloud.dao.DeptDao">
    <insert id="addDept" parameterType="dept">
        insert into dept (dname,db_source) values (#{dname},database())
    </insert>
    
    <select id="queryDeptById" resultType="dept">
        select * from dept where deptno = #{id}
    </select>
    
    <select id="queryAll" resultType="dept">
        select * from dept
    </select>
</mapper>

service

package com.mao.springcloud.service;


import com.mao.springcloud.dao.DeptDao;
import com.mao.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService {

    boolean addDept(Dept dept);

    Dept queryBuId(int id);

    List<Dept> queryAll();

}

serviceimpl

package com.mao.springcloud.service.impl;


import com.mao.springcloud.dao.DeptDao;
import com.mao.springcloud.pojo.Dept;
import com.mao.springcloud.service.DeptService;
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 queryBuId(int id) {
        return deptDao.queryDeptById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

Controller

package com.mao.springcloud.controller;

import com.mao.springcloud.pojo.Dept;
import com.mao.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;


@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

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

    @GetMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") int id){
        return deptService.queryBuId(id);
    }
    @GetMapping("/dept/list")
    public List<Dept> getAll(){
        return deptService.queryAll();
    }
}

消费者客户端

首先配置一下端口:

application.yml

server:
  port: 80

spring:
  application:
    name: consumer

要注意此处端口设置为80之后就无需在URL中再写端口了,因为默认的端口就是80.

controller

package com.mao.springcloud.controller;

import com.mao.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    //消费者不应该有Service层
    //RestTemplate  .... 供我们直接调用就可以了!直接注册到spring中
    //(url,实体,Map,Class<T> responseType)
    @Autowired
    private RestTemplate restTemplate;

    private static String REST_URL_PREFIX = "http://localhost:8001";

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") int id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
    }
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }
}

这里消费者直接就写到Controller层了,这是因为消费者所要做的就是去调用服务端的接口,而不需要执行什么业务。但是如何去调用服务端的接口呢?就要用到RestTemplate,而这个RestTemplate并不是直接在启动的时候自动配置,注册在spring容器之中,所以我们需要在config中配置他:

package com.mao.springcloud.config;


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

@Configuration
public class ConfigBean {//@Configuration就相当于我们的application.xml

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

这样就相当于在application.xml中注入了RestTemplate的bean,且bean的id就是方法名restTemplate;

测试

先启动服务端,调用服务端的接口,走通了。

在这里插入图片描述

再去调用客户端:
在这里插入图片描述

也走通了,这个项目也就走通了。

Eureka

创建Eureka服务端

application.yml

server:
  port: 7001
#Eureka配置
eureka:
  instance:
    hostname: localhost #Eureka的服务端实例名称
  client:
    register-with-eureka: false #表示是否向Eureka注册中心注册自己
    fetch-registry: false #如果该配置为false,则表示自己为注册中心
    service-url: #表示eureka的监控页面,可以看各服务的运行情况
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

可以看到eureka的服务端通常我们设置是不会把自己注册到自己当中,还修改了defaultZone,覆盖了原来的8761端口。

java启动器

package com.mao.springcloud;

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

@SpringBootApplication
@EnableEurekaServer //表明这是一个服务端的启动类
public class EurekaServer_7001 {

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

Eureka 客户端

前面的8001Dept端口就是一个很好的实例,在他的application.yml中可以配置

application.yml

#Eureka配置,服务注册到哪里
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept8001 #修改eureka上的默认信息

可以看到Eureka被注册到了http://localhost:7001/eureka/之中,而实例的id也改为了springcloud-provider-dept8001

Eureka的自我保护机制

简介:某一刻某一微服务不可用了,Eureka不会立即清理,依旧会对该微服务的信息进行保存。假如在网络发生问题的时候,可以通过心跳机制来确认服务器是否还活着,给你90秒确定,如果确定死了,再剔除。

Eureka注册中心集群的搭建

集群的概念:
在这里插入图片描述
就是一堆服务器都是做同一个功能的

而配置如下

server:
  port: 7001
#Eureka配置
eureka:
  instance:
    hostname: eureka7001.com #Eureka的服务端实例名称
  client:
    register-with-eureka: false #表示是否向Eureka注册中心注册自己
    fetch-registry: false #如果该配置为false,则表示自己为注册中心
    service-url: #表示eureka的监控页面,可以看各服务的运行情况
      #defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #上面是单机的写法
      #集群：关联其他的服务器
      defaultZone: http://eureka7003.com:7003/eureka/

而这里的eureka7001/7002/7003.com都是在本机中配置的127.0.0.1,所以三个域名本质上访问的是同一个地址。
访问7001可以看到
在这里插入图片描述
集群中有eureka7003.com

Ribbon

Ribbon是什么

Ribbon是一套客户端负载均衡工具。
简单的说：就是在配置文件中列出所有的Load Balance(简称LB)后面的所有机器。Ribbon会自动帮助你基于某种算法（例如简单轮询或者随机连接等）去连接这些机器,我们也很容易使用Ribbon实现自定义的负载均衡算法。

在客户端实现负载均衡

负载均衡的形式

集中式LB

即在服务的提供方和消费方之间使用独立的LB设施,如Nginx提供的反向代理服务器！由该设施通过某种策略把访问的请求转发至服务的提供方

进程式LB

将LB逻辑继承到消费者端,消费方从服务注册中心去发现还有哪些地址可以用,然后自己再从这些地址里选择一个合适的服务器,Ribbon就属于进程式LB。

Ribbon的maven包

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

在config中实现负载均衡：

@Configuration
public class ConfigBean {//@Configuration就相当于我们的application.xml

    //配置负载均衡实现restTemplate
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

我们只需要在restTemplate上添加一个注解@LoadBalanced即可。
在这里插入图片描述
注意在Controller中不能再讲域名写死了,而是应该由服务名来分配。

设置好了之后,我们再启动所有需要的服务器,通过消费者端的接口去访问:
在这里插入图片描述
可以看到该接口可以拿到想要的数据。

注意

Ribbon和Eureka整合以后，客户端可以直接调用,无需关心ip和端口号

Ribbon负载均衡算法

默认是轮询

自定义负载均衡算法

在java中通过配置去实现自定义负载均衡算法

package com.mao.springcloud;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
//Ribbon和Eureka 整合以后,客户端可以直接调用,不用关心IP地址和端口号
@SpringBootApplication
@EnableEurekaClient
//微服务启动的时候就能启动自定义的负载均衡算法
@RibbonClient(name="SPRINGCLOUD-PROVIDER-DEPT",configuration = 自定义负载均衡算法类.class)
public class DeptCunsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptCunsumer_80.class,args);
    }
}

注意！

自定义的负载均衡算法类不能和其他spring的类放在一个包内,否则会被compmentScan自动扫描到被注册进spring容器之中。

Feign负载均衡

feign是声明式的web service客户端,它让微服务之间的调用变得简单了,类似controller调用service,Springcloud集成了Eureka和Ribbon,可在使用Feign的时候提供负载均衡的http客户端。

只需要创建一个接口,添加注解即可。
Feign集成了Ribbon,相当于以前的@Mapper接口让我们不用写实现类,而我们也不用再用RestTemplate和Ribbon来封装了。

Hystrix 熔断机制

服务雪崩

服务雪崩是熔断器解决的最核心的问题。那么什么是服务雪崩呢:
在这里插入图片描述
微服务中的服务可以互相调用,服务雪崩就是因为一个服务出现了异常而导致其他服务也不可用的情况。如上图,因为A的不可用导致了B也不可用,而B不可用,导致了CD也不可用。

通常情况有可能是这样的,期间所有的都是服务,而箭头指向的就是需要的服务。

Hystrix简介及它的三个核心

Hystrix是一个用于处理分布式系统的延迟和容错的开源库,在分布式系统里,许多依赖会不可避免的调用失败,比如超时,异常等,Hystrix可以保证在一个依赖出问题的情况下,不会导致整体的服务失败,避免级联故障,以提高分布式系统的弹性。
Hystrix的三个核心特性是:断路器机制、Fallback和资源隔离

断路器机制

当Hystrix Command 请求后端失败数量超过一个阈值,直接成为开路（即直接让所有Http请求失败,不走后端）；
断路器本身是一种开关装置，当某个服务单元发生故障之后,通过断路器的故障监控机制（类似熔断保险丝）,向调用方返回一个服务预期的,可处理的备选响应（Fallback）,而不是长时间等待或者抛出异常,这样就可以保证了服务调用方的线程不被长时间占用

熔断机制

当某个微服务不可用或者响应时间太长了,就会进行服务的降级。进而熔断该微服务的调用,快速返回错误的响应信息。当检测到该节点恢复正常之后,恢复调用链路。SpringCloud中使用Hystrix来实现熔断机制,它会监控服务调用情况,当失败的调用到达一定阈值，缺省是5秒内有20次失败就会调用熔断机制。熔断机制的注解是@HystrixCommand。

使用方式

要导的核心maven包

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

Controller

package com.mao.springcloud.controller;

import com.mao.springcloud.pojo.Dept;
import com.mao.springcloud.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @GetMapping("/dept/get/{id}")
    @HystrixCommand(fallbackMethod = "hystrixGet")
    public Dept get(@PathVariable("id") int id){
        Dept dept = deptService.queryBuId(id);

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

        return dept;
    }

    public Dept hystrixGet(@PathVariable("id") int id){
        return new Dept().setDname("id=>"+id+"没有对应的信息、null--@Hystrix").setDeptno(id)
                .setDb_source("no this database in MySQL");
    }
}

这里的HystrixCommand注解使得当服务调用出现异常的时候,主动调用备用方法hystrixGet。

在启动器中开启Hystrix

package com.mao.springcloud;

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


//启动类
@SpringBootApplication
@EnableEurekaClient //表明是Eureka的客户端
//添加对熔断的支持
@EnableCircuitBreaker
public class DeptProvider_8001 {

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

使用@EnableCircuitBreaker开启Hystrix而不是

Fallback

降级回滚策略,进行一个兜底的返回。比如你访问课表的服务失败,返回的是一个空列表或者缓存的列表而不是错误。

服务降级

当一个服务的并发量贼大的时候,客户端可以设置先牺牲两台做其他不太忙的服务停掉,先做大并发的服务器的服务功能。等到不忙的时候,再开启另外的服务。而当服务器不使用该服务的时候,可以在客户端使用一个FallbackFactory,访问服务不再去调原来的接口,而是友情提示了。

资源隔离

不同的微服务开辟一个属于自己的线程池,让不同的微服务去通过自己的线程池去调用资源。

本质

Hystrix就类似于一个断路器,当服务不可用的时候,保险丝就断了,要采用其他的方法形成通路了。

Zuul网关

Zuul的主要功能就是对请求进行路由和过滤,路由的功能就是把外部请求转发到具体的微服务实例上,是实现外部访问统一入口的基础,而过滤功能则负责对请求过程进行干预,是实现请求校验,服务聚合等功能的基础。Zuul和Eureka,将Zuul自身注册为Eureka服务治理下的应用,同时从Eureka中获得其他微服务的消息。也即以后访问的微服务都是通过Zuul跳转后获得。
注意:Zuul最后自己还是会注册进Eureka。
提供:路由+代理+过滤三大功能！

Zuul能干嘛

说白了就是两点

路由
过滤

总结

其实所有springcloud的组件使用就是4步:

导入依赖
编写配置文件
开启这个功能 @EnableXXXX
配置类

段落总是简写

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springcloud学习项目

文章目录maven配置父项目子项目配置实体类maven配置父项目<?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" ...
复制链接

扫一扫