springboot-cloud--微服务

最新推荐文章于 2023-06-20 20:00:30 发布

竹修墨客

最新推荐文章于 2023-06-20 20:00:30 发布

阅读量204

点赞数

本文链接：https://blog.csdn.net/qy132/article/details/118524575

版权

1.1系统架构演变

随着互联网的发展，网站应用的规模也在不断的扩大，进而导致系统架构也在不断的进行变化。从互联网早起到现在，系统架构大体经历了下面几个过程: 单体应用架构--->垂直应用架构--->分布式架构--->SOA架构--->微服务架构，当然还有悄然兴起的Service Mesh(服务网格化)。

接下来我们就来了解一下每种系统架构是什么样子的，以及各有什么优缺点。

1. 1. 单体应用架构

互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这样可以减少开发、部署和维护的成本。

比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块，我们会把它们做成一个web项目，然后部署到一台tomcat服务器上。

优点：

项目架构简单，小型项目的话，开发成本低。
项目部署在一个节点上，维护方便

缺点：

全部功能集成在一个工程中，对于大型项目来讲不易开发和维护[修改代码]。
项目模块之间紧密耦合，单点容错率低。
无法针对不同模块进行针对性优化和水平扩展
1. 1. 垂直应用架构

随着访问量的逐渐增大，单一应用只能依靠增加节点来应对，但是这时候会发现并不是所有的模块都会有比较大的访问量.

还是以上面的电商为例子，用户访问量的增加可能影响的只是用户和订单模块，但是对消息模块的影响就比较小. 那么此时我们希望只多增加几个订单模块，而不增加消息模块. 此时单体应用就做不到了，垂直应用就应运而生了.

所谓的垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效率。比如我们可以将上面电商的单体应用拆分成:

电商系统(用户管理商品管理订单管理)

后台系统(用户管理订单管理客户管理)

CMS系统(广告管理营销管理)

这样拆分完毕之后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而无需增加后台和CMS的节点。建立三个工程。

优点：

系统拆分实现了流量分担，解决了并发问题，可以针对不同模块进行优化和水平扩展
一个系统的问题不会影响到其他系统，提高容错率

缺点：

系统之间相互独立，无法进行相互调用
系统之间相互独立，会有重复的开发任务
1. 1. 分布式架构

当垂直应用越来越多，重复的业务代码就会越来越多。这时候，我们就思考可不可以将重复的代码抽取出来，做成统一的业务层作为独立的服务（service），然后由前端控制层(controller)调用不同的业务层服务呢？

这就产生了新的分布式系统架构。它将把工程拆分成表现层和服务层两个部分，服务层中包含业务逻辑。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

优点:

抽取公共的功能为服务层，提高代码复用性

缺点：

系统间耦合度变高，调用关系错综复杂，难以维护
1. 1. SOA架构----阿里dubbo

在分布式架构下，当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心对集群进行实时管理。此时，用于资源调度和治理中心(SOA Service Oriented Architecture，面向服务的架构)是关键。

优点:

使用注册中心解决了服务间调用关系的自动调节

缺点:

服务间会有依赖关系，一旦某个环节出错会影响较大( 服务雪崩 )
服务关心复杂，运维、测试部署困难

1.1.5微服务架构

微服务架构在某种程度上是面向服务的架构SOA继续发展的下一步，它更加强调服务的"彻底拆分"---->必须要springboot(独立的系统)

第二章微服务环境搭建

我们本次是使用的电商项目中的商品微服务、订单微服务为案例进行讲解。

2.1 案例准备

2.1.1 技术选型

maven：3.5.0+

数据库：MySQL 5.7 以上

持久层: Mybatis-plus 《Mybatis Mapper Mybatis-plus》

其他: SpringCloud Alibaba 技术栈 druid

2.1.2 模块设计

springcloud-alibaba 父工程《jar版本的管理》

shop-common 公共模块【实体类】《实体类，公共依赖，工具类。》

shop-product 商品微服务【端口: 8080~8089 搭建集群】

shop-order 订单微服务【端口: 8090~8099 搭建集群】

2.1.3 微服务调用

在微服务架构中，最常见的场景就是微服务之间的相互调用。我们以电商系统中常见的用户下单为

例来演示微服务的调用：客户向订单微服务发起一个下单的请求，在进行保存订单之前需要调用商品微服务查询商品的信息。

我们一般把服务的主动调用方称为服务消费者，把服务的被调用方称为服务提供者。

‘

在这种场景下，订单微服务就是一个服务消费者，商品微服务就是一个服务提供者。

2.2 创建父工程

创建一个maven工程，然后在pom.xml文件中添加下面内容

https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E

<?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.ykq</groupId>
    <artifactId>springcloud-alibaba</artifactId>
    <version>1.0-SNAPSHOT</version>

   <!--引入父依赖-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.2.RELEASE</version>
</parent>
<!--定义版本号-->
<properties>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF- 8</project.reporting.outputEncoding>
    <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
    <spring-cloud-alibaba.version>2.2.3.RELEASE</spring-cloud-alibaba.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>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

版本对应：

2.3 创建基础模块

1 创建 shop-common 模块，在pom.xml中添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-alibaba</artifactId>
        <groupId>com.ykq</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-common</artifactId>
   <!--加入依赖-->
<dependencies>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.1</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.56</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>
</project>

2 创建实体类

package shopcommon.entity;


import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
 * @program: springcloud-parent
 * @description: 订单实体类
 * @author: 孙彦伟
 * @create: 2021-07-06 14:15
 **/
@Data
@TableName("shop_order")
public class ShopOrder {
    @TableId(type = IdType.AUTO)
    private Long oid; //订单id
    private Integer uid;//用户id
    private String username;//用户名
    private Long pid;//商品id
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer number;//购买数量
}

package shopcommon.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
 * @program: springcloud-parent
 * @description: 商品实体类
 * @author: 孙彦伟
 * @create: 2021-07-06 14:14
 **/
@Data
@TableName("shop_product")
public class ShopProduct {
    @TableId(type= IdType.AUTO)
    private Integer pid;
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer stock;//库存
}

2.4 创建用户微服务

步骤:

1 创建模块导入依赖

2 创建SpringBoot主类

3 加入配置文件

4 创建必要的接口和实现类(controller service dao)

新建一个 shop-user 模块，然后进行下面操作

1 创建pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-alibaba</artifactId>
        <groupId>com.ykq</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-user</artifactId>
    <!--引入shop-common模块的依赖-->
    <dependencies>
        <dependency>
            <groupId>com.ykq</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

2 编写主类

package com.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

3 创建配置文件

server:
  port: 8071
spring:
  application:
    name: shop-user
  # 配置数据源
  datasource:
    url: jdbc:mysql://localhost:3306/shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
  jpa:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

2.5 创建商品微服务

1 创建一个名为 shop_product 的模块，并添加springboot依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-alibaba</artifactId>
        <groupId>com.ykq</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-product</artifactId>
    <dependencies>
        <dependency>
            <groupId>com.ykq</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

2 创建工程的主类

package com
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ProductApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class,args);
    }
}

3 创建配置文件application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud?serverTimezone=Asia/Shanghai
    username: root
    password: root

server:
  port: 8080

4 创建ProductDao接口

package com..dao;

import co.domain.Product;


public interface ProductDao extends BaseMap<Product> {
}

5 创建ProductService接口

package com..service;

import com.domain.Product;

public interface ProductService {
    public Product findById(Integer pid);
}

6 创建ProductServiceImpl实现类

package com.ykq.service.impl;

import com.dao.ProductDao;
import com..domain.Product;
import com..service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductDao productDao;
    @Override
    public Product findById(Integer pid) {
        return productDao.findById(pid).get();
    }
}

7 创建ProductController类

package co.controller;

import com.alibaba.fastjson.JSON;
import codomain.Product;
import com.ervice.ProductService;
import lombok.extern.slf4j.Slf4j;
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;

@RestController
@Slf4j
public class ProductController {
    @Autowired
    private ProductService productService;

    @RequestMapping("/product/{pid}")
    public Product product(@PathVariable(value = "pid")Integer pid){
        Product product = productService.findById(pid);
        log.info("查询到商品:" + JSON.toJSONString(product));
        return product;
    }
}

8 启动工程，等到数据库表创建完毕之后，加入测试数据

2.6 创建订单微服务

1 创建一个名为 shop-order 的模块,并添加springboot依赖

<?xml version="1.0" encoding="UTF-8"?>

  <project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>

        <artifactId>springcloud-alibaba</artifactId>

        <groupId>com.ykq</groupId>

        <version>1.0-SNAPSHOT</version>

    </parent>

    <modelVersion>4.0.0</modelVersion>

  

    <artifactId>shop-order</artifactId>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <dependency>

            <groupId>com.ykq</groupId>

            <artifactId>shop-common</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

    </dependencies>

  

</project>

2 创建启动类

package com

  

  import org.springframework.boot.SpringApplication;

  import org.springframework.boot.autoconfigure.SpringBootApplication;

  

  @SpringBootApplication

  public class OrderApplication {

    public static void main(String[] args) {

        SpringApplication.run(OrderApplication.class,args);

    }

}

3 创建配置文件application.yml

server:

  port: 8091

  spring:

  application:

    name: shop-order

  # 配置数据源

  datasource:

    url: jdbc:mysql://localhost:3306/shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true

    driver-class-name: com.mysql.cj.jdbc.Driver

    username: root

    password: root

4 创建OrderDao接口

package com.dao;

  

  import com.domain.Order;

  import org.springframework.data.jpa.repository.JpaRepository;

  

  public interface   OrderDao  extends BaseMapper<Order> {

  

}

5 创建OrderService接口

package com..service;

  

  import com..domain.Order;

  

  public interface OrderService {

  

    public void save(Order order);

}

6 创建OrderServiceImpl实现类

package com.y.service.impl;

  

  import com.y.dao.OrderDao;

  import com.q.domain.Order;

  import comservice.OrderService;

  import org.springframework.beans.factory.annotation.Autowired;

  import org.springframework.stereotype.Service;

  

  @Service

  public class OrderServiceImpl implements OrderService {

    @Autowired

    private OrderDao orderDao;

    @Override

    public void save(Order order) {

        orderDao.save(order);

    }

}

7 创建OrderController类

package com.controller;

  

  import com.alibaba.fastjson.JSON;
domain.Order;

  import com..domain.Product;

  import com..service.OrderService;

  import lombok.extern.slf4j.Slf4j;

  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.RestController;

  import org.springframework.web.client.RestTemplate;

  

  @RestController

@Slf4j

  public class OrderController {

    @Autowired

    private OrderService orderService;

  

    @Autowired

    private RestTemplate restTemplate;

  

    @GetMapping("/order/prod/{pid}")

    public Order order(@PathVariable("pid")Integer pid){

        log.info(">>客户下单，这时候要调用商品微服务查询商品信息");

        Product product = restTemplate.getForObject("http://localhost:8081/product/" + pid, Product.class);

        log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));

        Order order = new Order();

        order.setPid(product.getPid());

        order.setPname(product.getPname());

        order.setPprice(product.getPprice());

        order.setNumber(1);

  

        order.setUid(1);

        order.setUsername("妲己");

        orderService.save(order);

  

        return order;

    }

}

8 启动工程并在浏览器上测试

竹修墨客

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springboot-cloud--微服务

1.1系统架构演变随着互联网的发展，网站应用的规模也在不断的扩大，进而导致系统架构也在不断的进行变化。从互联网早起到现在，系统架构大体经历了下面几个过程: 单体应用架构--->垂直应用架构--->分布式架构--->SOA架构--->微服务架构，当然还有悄然兴起的Service Mesh(服务网格化)。接下来我们就来了解一下每种系统架构是什么样子的，以及各有什么优缺点。单体应用架构互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能...
复制链接

扫一扫