微服务课程之SpringCloud 概述及微服务搭建

刺骨的言语ヽ痛彻心扉 2023-09-29 16:37 57阅读 0赞

1，课程回顾

2，本章重点
微服务的概念，特点，优点，缺点
分布式框架（微服务）的演变过程
springcloud简介和特征
springcloud组件和体系架构
搭建父子项目，编写一个微服务
3，具体内容
3.1 微服务的概念
微服务(micro service),是一种架构风格，它将一个复杂的应用拆分成多个独立自治的服务，服务与服务间通过松耦合的形式交互。这些服务都可以单独的开发，测试，部署，运行；相互协作，更好完成原来大的业务系统的所有功能。
3.2 微服务的特点，优点和缺点
1）特点
解耦：服务做了拆分，相互影响会大大降低，符合软件设计的低耦合原则。
组件化：每个服务都相当于一个独立的组件，可以进行独立升级和扩展，可以被重复使用，节省人力成本。
业务能力强：职责明确，更专注于某一个业务
自治：一个微服务就是一个独立的实体，它可以独立部署、升级，服务与服务之间通过REST等形式的标准接口进行通信，并且一个微服务实例可以被替换成另一种实现，而对其它的微服务不产生影响。
敏捷性： 微服务可以敏捷开发（迭代）非常适合。 中国扶贫办->中国移动(华为，亚信)-> 精简版上线30天上线->每隔2-3周迭代一个新功能（修复旧版本的BUG），直到整个10个月全部完成
2）优点
易于开发和部署（单个项目）
启动快
局部更新，对整体影响很小
技术不受限制
按需求伸缩
devops（develop开发 operations运维） 促进开发，运维和测试（质检QA）的协作
DevOps（Development和Operations的组合词）是一组过程、方法与系统的统称，用于促进开发（应用程序/软件工程）、技术运营和质量保障（QA）部门之间的沟通、协作与整合。
它是一种重视“软件开发人员（Dev）”和“IT运维技术人员（Ops）”之间沟通合作的文化、运动或惯例。透过自动化“软件交付”和“架构变更”的流程，来使得构建、测试、发布软件能够更加地快捷、频繁和可靠。

3）缺点
复杂度高：微服务间通过REST（restful）、RPC(dubbo)等形式交互，需要考虑被调用方故障、过载、消息丢失等，分布式锁，分布式事务
运维复杂：需要一个设计良好的监控系统对各个微服务的运行状态进行监控。
影响性能：微服务的间通过REST、RPC等形式进行交互，通信的时延会受到较大的影响
3.3 分布式服务系统框架演变
随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。
3.3.1 单一应用架构
当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
3.3.2 垂直应用架构
当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，提升效率的方法之一是将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。
3.3.3 分布式服务架构
当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC(remote procedure call))是关键。
3.3.4 流动计算架构
当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。
在这里插入图片描述

3.4 springcloud简介
英文官网： https://spring.io/projects/spring-cloud
中文官网： https://www.springcloud.cc/
微服务架构集大成者，云计算最佳业务实践。Spring Cloud 为开发者提供了工具来快速构建分布式系统中的一些常见模式（例如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话，集群状态）。分布式系统的协调导致了样板模式，使用 Spring Cloud 开发人员可以快速建立实现这些模式的服务和应用程序。它们在任何分布式环境中都能很好地工作，包括开发人员自己的笔记本电脑、裸机数据中心以及 Cloud Foundry 等托管平台。
3.5 springcoud特征
分布式/版本化配置
服务注册和发现
路由
服务到服务调用
负载均衡
断路器
全局锁
领导选举和集群状态
分布式消息传递

3.6 springcloud的主要组件，体系架构及版本号

图片: https://uploader.shimo.im/f/Wg6W9CNy8im8GUmi.png

服务注册中心（服务注册和发现）
eureka:一个基于 REST 的服务，用于定位服务，以实现云端中间层服务发现和故障转移。
nacos：Nacos 致力于帮助您发现、配置和管理微服务。

服务配置中心
springcloud config：配置管理工具包，让你可以把配置放到远程服务器，集中化管理集群配置，目前支持本地存储、Git以及Subversion。
nacos：Nacos 致力于帮助您发现、配置和管理微服务。
服务路由(网关)
zuul：Zuul 是在云平台上提供动态路由,监控,弹性,安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。
gateway：该项目提供了一个库，用于在 Spring WebFlux 之上构建 API 网关。Spring Cloud Gateway 旨在提供一种简单而有效的方式来路由到 API，并为它们提供横切关注点，例如：安全性、监控/指标和弹性。
服务熔断器
hystrix：熔断器，容错管理工具，旨在通过熔断机制控制服务和第三方库的节点,从而对延迟和故障提供更强大的容错能力。
sentinel：流量控制和服务降级，断路和系统自适应保护
消息队列（异步）
kafka：kafka是由apache软件基金会开发的一个开源流处理框架，由JAVA和scala语言编写。是一个高吞吐量的分布式的发布和订阅消息的一个系统。Kafka® 用于构建实时的数据管道和流式的app.它可以水平扩展，高可用，速度快，并且已经运行在数千家公司的生产环境。
服务到服务调用（同步）
ribbon：提供云端负载均衡，有多种负载均衡策略可供选择，可配合服务发现和断路器使用
open feign：Feign是一种声明式、模板化的HTTP客户端。

版本号：
https://github.com/spring-projects/spring-cloud/wiki

图片: https://uploader.shimo.im/f/r0uPEaZx20frCwuC.png

GA = General Availability,通用版本 一般可用性（发布）; 应该非常稳定，功能齐全
SR = Server RELEASE 服务发布版本（主要版本之后的后续维护版本-RELEASE）
RC = Release Candidate 候选版本
3.7 微服务规划父子项目搭建
父子项目（以springboot为基础）
父： springcloud_demo_20220216(方便jar包管理 type=‘pom’)
注册中心eureka：
子项目(单机版注册中心-独立模式）： eureka_registry (14110)
子子项目(HA(High Available)注册中心)：
registry_a(14111)
registry_b(14112)
registry_c(14113)
nacos 默认端口：8848（独立项目之外的）
nacos 集群 3台主机及端口为 192.168.170.41:18841 192.168.170.42:18842 192.168.170.43:18843
微服务:（springboot+mybatis）：
子项目micro_services（统一管理微服务的jar包）
子子项目：
订单管理（3个项目，目的讲解ribbon和open feign负载均衡）
order_server_a(14121) 订单管理1（真正开发，开发一份代码，部署3个服务器）
order_server_b(14122) 订单管理2
order_server_c(14123) 订单管理3
商品管理（讲解ribbon）
goods_server_ribbon (14131)
sns管理(讲解openfeign)
sns_server_feign (14132)
营销活动管理(讲解ribbon的hystrix路由熔断)
market_server_ribbon_hystrix(14141)
market_server_openfeign_hystrix(14142)
会员服务管理（讲解feign的hystrix路由熔断）
member_server_ribbon_sentinel(14143)
member_server_openfeign_sentinel(14144)
单点登录：sso_server(14188)
member_server_feign_sentinel(14144)
路由过滤中心
子项目: zuul_server(14151)
子项目： gateway_server(14152)
配置中心
子项目： config_server(14160)
nacos 默认端口：8848（独立项目之外的）

3.8 搭建父子工程
pom.xml的properties配置：

  1. <properties>
  2.        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3.         <maven.compiler.source>1.8</maven.compiler.source>
  4.         <maven.compiler.target>1.8</maven.compiler.target>
  5.         <spring-boot.version>2.3.4.RELEASE</spring-boot.version>
  6.         <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
  7.         <spring-cloud-alibaba.version>2.2.3.RELEASE</spring-cloud-alibaba.version>
  8.         <mybatis-plus.version>3.4.0</mybatis-plus.version>
  9.         <mybatis-plus-extension.version>3.4.0</mybatis-plus-extension.version>
  10.         <hutool.version>5.7.18</hutool.version>
  11.         <swagger.fox.version>3.0.0</swagger.fox.version>
  12.         <swagger-spring-boot>2.0.2.RELEASE</swagger-spring-boot>
  13.         <nacos.version>2.0.3</nacos.version>
  14.         <fastjson.version>1.2.78</fastjson.version>
  15.         <mysql.version>5.1.10</mysql.version>
  16.         <lombok.version>1.18.22</lombok.version>
  17.         <druid.version>1.2.8</druid.version>
  18.         <pagehelper.version>1.4.1</pagehelper.version>
  20.     </properties>

pom.xml的dependencyManagement配置：

  1. <dependencyManagement>
  2.           <dependencies>
  3.               <!-- spring boot 依赖 -->
  4.               <dependency>
  5.                   <groupId>org.springframework.boot</groupId>
  6.                   <artifactId>spring-boot-dependencies</artifactId>
  7.                   <version>${spring-boot.version}</version>
  8.                   <type>pom</type>
  9.                   <scope>import</scope>
  10.               </dependency>
  11.               <!-- spring cloud 依赖 -->
  12.               <dependency>
  13.                   <groupId>org.springframework.cloud</groupId>
  14.                   <artifactId>spring-cloud-dependencies</artifactId>
  15.                   <version>${spring-cloud.version}</version>
  16.                   <type>pom</type>
  17.                   <scope>import</scope>
  18.               </dependency>
  19.               <!-- spring cloud alibaba 依赖 -->
  20.               <dependency>
  21.                   <groupId>com.alibaba.cloud</groupId>
  22.                   <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  23.                   <version>${spring-cloud-alibaba.version}</version>
  24.                   <type>pom</type>
  25.                   <scope>import</scope>
  26.               </dependency>
  27.               <!--springboot整合mybatis包-->
  28. <!--              <dependency>-->
  29. <!--                  <groupId>org.mybatis.spring.boot</groupId>-->
  30. <!--                  <artifactId>mybatis-spring-boot-starter</artifactId>-->
  31. <!--                  <version>2.2.1</version>-->
  32. <!--              </dependency>-->
  33.               <!--mybatis-plus-->
  34.               <dependency>
  35.                   <groupId>com.baomidou</groupId>
  36.                   <artifactId>mybatis-plus-boot-starter</artifactId>
  37.                   <version>${mybatis-plus.version}</version>
  38.               </dependency>
  39.               <!--mybatis-plus扩展包-->
  40.             <!--  <dependency>
  41.                   <groupId>com.baomidou</groupId>
  42.                   <artifactId>mybatis-plus-extension</artifactId>
  43.                   <version>${mybatis-plus-extension.version}</version>
  44.               </dependency>-->
  45.               <!--简化entity写法包-->
  46.               <dependency>
  47.                   <groupId>org.projectlombok</groupId>
  48.                   <artifactId>lombok</artifactId>
  49.                   <version>${lombok.version}</version>
  50.               </dependency>
  51.               <!-- mysql驱动包-->
  52.               <dependency>
  53.                   <groupId>mysql</groupId>
  54.                   <artifactId>mysql-connector-java</artifactId>
  55.                   <version>${mysql.version}</version>
  56.               </dependency>
  57.               <!--测试包-->
  58.               <dependency>
  59.                   <groupId>org.springframework.boot</groupId>
  60.                   <artifactId>spring-boot-starter-test</artifactId>
  61.                   <version>${spring-boot.version}</version>
  62.                   <scope>test</scope>
  63.               </dependency>
  64.               <!--druid 连接池  其他常用连接池：dbcp  c3p0  proxool  -->
  65.               <dependency>
  66.                   <groupId>com.alibaba</groupId>
  67.                   <artifactId>druid</artifactId>
  68.                   <version>${druid.version}</version>
  69.               </dependency>
  70.               <dependency>
  71.                   <groupId>com.alibaba</groupId>
  72.                   <artifactId>druid-spring-boot-starter</artifactId>
  73.                   <version>${druid.version}</version>
  74.               </dependency>
  75.               <!-- 分页插件pagehelper -->
  76.               <dependency>
  77.                   <groupId>com.github.pagehelper</groupId>
  78.                   <artifactId>pagehelper-spring-boot-starter</artifactId>
  79.                   <version>${pagehelper.version}</version>
  80.               </dependency>
  81.               <!-- 分页插件pagehelper -->
  82.               <!-- swagger2 -->
  83.             <!--  <dependency>
  84.                   <groupId>io.springfox</groupId>
  85.                   <artifactId>springfox-swagger2</artifactId>
  86.                   <version>${swagger.fox.version}</version>
  87.               </dependency>
  88.               <dependency>
  89.                   <groupId>io.springfox</groupId>
  90.                   <artifactId>springfox-swagger-ui</artifactId>
  91.                    <version>${swagger.fox.version}</version>
  92.               </dependency>-->
  93.               <!-- swagger-spring-boot-starter -->
  94.               <dependency>
  95.                   <groupId>com.spring4all</groupId>
  96.                   <artifactId>swagger-spring-boot-starter</artifactId>
  97.                   <version>${swagger-spring-boot}</version>
  98.               </dependency>
  99.               <!-- fastjson -->
  100.               <dependency>
  101.                   <groupId>com.alibaba</groupId>
  102.                   <artifactId>fastjson</artifactId>
  103.                   <version>${fastjson.version}</version>
  104.               </dependency>
  105.           </dependencies>
  106.     </dependencyManagement>

知识点：
dependencyManagement和dependencies区别：
dependencies:自动引入声明在dependencies里的所有依赖，并默认被所有的子项目继承。如果项目中不写依赖项，则会从父项目继承（属性全部继承）声明在父项目dependencies里的依赖项。
dependencyManagement里只是声明依赖， 子项目按需依赖。只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom。 如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
dependency中type属性：
引入包的类型 默认为jar 当为pom时，作用为需要引入很多jar包的时候会导致pom.xml过大，可以定义一个父项目，通过type=pom把父项目的所有包都可以引入，选择性使用。
dependency中scope属性：
打包范围，有以下选项：
compile， 缺省值，适用于所有阶段，会随着项目一起发布。在编译和打包时都会将依赖存储进去
provided，类似compile，期望JDK、容器或使用者会提供这个依赖。
runtime， 在运行时使用，如JDBC驱动，适用运行和测试阶段。
test 只在测试时使用，用于编译和运行测试代码。不会随项目发布。
打包命令示例： mvn package -Dmaven.test.skip=true
system， 类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。
import， 引入一个父类项目pom,选择性的继承，达到类似parent标签的作用，解决了单继承问题

解决工程默认java编译版本：

maven-compiler-plugin 3.6.0 true 1.8 1.8 UTF-8

3.9 编写一个微服务工程
3.9.1，数据库表及数据：

  1. CREATE TABLE tb_order (
  2. id int(11) PRIMARY key NOT NULL AUTO_INCREMENT COMMENT '订单id' ,
  3. member_id int(10) NOT NULL ,
  4. shop_id int(10) NULL DEFAULT NULL ,
  5. group_promotion_id int(10) NULL DEFAULT NULL COMMENT '拼团活动ID' ,
  6. coupon_id int(10) NULL DEFAULT NULL COMMENT '促销活动ID' ,
  7. order_sn varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '订单编号' ,
  8. member_username varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户帐号' ,
  9. total_amount decimal(10,2) NULL DEFAULT NULL COMMENT '订单总金额'
  10. );
  11. INSERT INTO  tb_order (id, member_id, shop_id, group_promotion_id, coupon_id, order_sn, member_username, total_amount) VALUES ('1', '1', '1', '1', '1', 'order001', 'admin1', '101.00');
  12. INSERT INTO  tb_order (id, member_id, shop_id, group_promotion_id, coupon_id, order_sn, member_username, total_amount) VALUES ('2', '1', '1', '1', '1', 'order002', 'admin2', '102.00');
  13. INSERT INTO  tb_order (id, member_id, shop_id, group_promotion_id, coupon_id, order_sn, member_username, total_amount) VALUES ('3', '1', '1', '1', '1', 'order003', 'admin3', '103.00');

3.9.2 ,创建一个micro_services引入jar
（父类jar管理项目）：

  1. <!--微服务按需引入jar-->
  2. <dependencies>
  3.     <!--springboot  web包-->
  4.     <dependency>
  5.         <groupId>org.springframework.boot</groupId>
  6.         <artifactId>spring-boot-starter-web</artifactId>
  7.     </dependency>
  8.     <!--springboot整合druid包-->
  9.     <dependency>
  10.         <groupId>com.alibaba</groupId>
  11.         <artifactId>druid-spring-boot-starter</artifactId>
  12.     </dependency>
  13.     <!--mysql驱动包-->
  14.     <dependency>
  15.         <groupId>mysql</groupId>
  16.         <artifactId>mysql-connector-java</artifactId>
  17.     </dependency>
  18.     <!--lombok 简化实体写法包-->
  19.     <dependency>
  20.         <groupId>org.projectlombok</groupId>
  21.         <artifactId>lombok</artifactId>
  22.     </dependency>
  23.     <!--mybatisplus整合springboot的包-->
  24.     <dependency>
  25.         <groupId>org.mybatis.spring.boot</groupId>
  26.         <artifactId>mybatis-spring-boot-starter</artifactId>
  27.     </dependency>
  28.     <!-- swagger-spring-boot-starter -->
  29.     <dependency>
  30.         <groupId>com.spring4all</groupId>
  31.         <artifactId>swagger-spring-boot-starter</artifactId>
  32.     </dependency>
  33.     <!-- 分页插件pagehelper -->
  34.     <dependency>
  35.         <groupId>com.github.pagehelper</groupId>
  36.         <artifactId>pagehelper-spring-boot-starter</artifactId>
  37.     </dependency>
  38.     <!--引入公共包-->
  39.     <dependency>
  40.         <groupId>com.aaa</groupId>
  41.         <artifactId>common</artifactId>
  42.         <version>1.0-SNAPSHOT</version>
  43.     </dependency>
  44. </dependencies>

3.9.3，创建子项目,配置application.yml：
#当前服务端口号1024-49151
server:
port: 14911

servlet:

#配置上下文对象 访问的项目名称

context-path: /ordera

#阿里druid连接池配置

  1. spring:
  2.   datasource:
  3.     druid:
  4.       url: jdbc:mysql://localhost:3306/db_qy149?useSSL=false&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
  5.       username: root
  6.       password: root
  7.       initial-size: 5
  8.       max-active: 20
  9.       min-idle: 10
  10.       max-wait: 10
  11. #mybatis-plus:

# mapper.xml配置

  1. #  mapper-locations: classpath:mapper/*.xml
  2. #  configuration:
  3. #    #控制台日志输出配置
  4. #    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  5. #  #别名包配置
  6. #  type-aliases-package: com.aaa.os.entity
  7. mybatis:
  8.   # mapper.xml配置位置
  9.   mapper-locations: classpath:mapper/*.xml
  10.   configuration:
  11.     #控制台日志输出配置
  12.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  13.     #order_type  -> orderType    数据库列下划线和java大小写映射
  14.     map-underscore-to-camel-case: true
  15.   #别名包配置
  16.   type-aliases-package: com.aaa.os.entity
  17.   #
  18. #swagger配置
  19. swagger:
  20.   base-package: com.aaa.os.controller
  21.   title: "电商项目-订单模块-订单swagger"
  22.   description: "描述"
  23.   version: "3.0"
  24.   contact:
  25.     name: "AAA"
  26.     email: "test@163.com"
  27.     url: "https://www.baidu.com"
  28.   terms-of-service-url: "服务条款：https://www.baidu.com"

3.9.4，编写代码（实体和业务分开）
使用EasyCode自动生成（省略）
分页插件配置：

  1. package com.aaa.os.config;
  2. import com.baomidou.mybatisplus.annotation.DbType;
  3. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
  4. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. /**
  8.  * @ fileName:MyBatisPlusPageConfig
  9.  * @ description:
  10.  * @ author:zhz
  11.  * @ createTime:2022/2/17 9:34
  12.  * @ version:1.0.0
  13.  */
  14. @Configuration
  15. public class MyBatisPlusPageConfig {
  17.     /**
  18.      *  最新版 mp分页插件配置
  19.      * @return
  20.      */
  21.     @Bean //<bean id=mybatisPlusInterceptor class='com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor'
  22.     public MybatisPlusInterceptor mybatisPlusInterceptor() {
  24.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  25.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
  26.         return interceptor;
  27.     }
  28. }

3.9.5，启动类配置：

3.9.6， 测试
http://localhost:1110/

http://localhost:2221/order/list

3.10 整合swagger
3.10.1 父子项目pom.xml
最外层父项目需要引入：

2.0.2.RELEASE

com.spring4all
swagger-spring-boot-starter
${swagger-spring-boot}

micro_services 引入：

com.spring4all
swagger-spring-boot-starter

3.10.2 application.yml配置
#swagger配置
swagger:
base-package: com.aaa.order.controller
title: “swagger标题”
description: “描述”
version: “3.0”
contact:
name: “AAA”
email: “test@163.com”
url: “https://www.baidu.com”
terms-of-service-url: “服务条款：https://www.baidu.com”

3.10.3 启动类配置
@EnableSwagger2 //开启swagger
3.10.4 测试
http://localhost:xxxx(port)/swagger-ui/index.html
3.11 EasyCode模板修改
3.11.1 entity模板修改
##导入宏定义
$!{define.vm}

##保存文件（宏定义）
#save(“/entity”, “.java”)

##包路径（宏定义）
#setPackageSuffix(“entity”)

##自动导入包（全局变量）
$!autoImport
import com.baomidou.mybatisplus.extension.activerecord.Model;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

##表注释（宏定义）
#tableComment(“表实体类”)
@SuppressWarnings(“serial”)
@TableName(“tb_$!{tableInfo.name}”)
@Data
public class ! t a b l e I n f o . n a m e e x t e n d s M o d e l < !{tableInfo.name} extends Model< !tableInfo.nameextendsModel<!{tableInfo.name}> {
#foreach($column in KaTeX parse error: Expected ‘EOF’, got ‘#‘ at position 27: …ullColumn) #̲if({column.comment})//${column.comment}#end

  1. private $!{tool.getClsNameByFullName($column.type)} $!{column.name};

#end
}

3.11.2 controller模板修改
##导入宏定义
$!{define.vm}

##设置表后缀（宏定义）
#setTableSuffix(“Controller”)

##保存文件（宏定义）
#save(“/controller”, “Controller.java”)

##包路径（宏定义）
#setPackageSuffix(“controller”)

##定义服务名
#set($serviceName = ! t o o l . a p p e n d ( !tool.append( !tool.append(!tool.firstLowerCase($!tableInfo.name), “Service”))

##定义实体对象名
#set($entityName = ! t o o l . f i r s t L o w e r C a s e ( !tool.firstLowerCase( !tool.firstLowerCase(!tableInfo.name))

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.api.ApiController;
import com.baomidou.mybatisplus.extension.api.R;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import ! t a b l e I n f o . s a v e P a c k a g e N a m e . e n t i t y . !{tableInfo.savePackageName}.entity. !tableInfo.savePackageName.entity.!tableInfo.name;
import ! t a b l e I n f o . s a v e P a c k a g e N a m e . s e r v i c e . !{tableInfo.savePackageName}.service. !tableInfo.savePackageName.service.!{tableInfo.name}Service;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.List;

##表注释（宏定义）
#tableComment(“表控制层”)
@RestController
@RequestMapping(“ ! t o o l . f i r s t L o w e r C a s e ( !tool.firstLowerCase( !tool.firstLowerCase(!tableInfo.name)”)
public class $!{tableName} extends ApiController {
/**
* 服务对象
*/
@Resource
private $!{tableInfo.name}Service $!{serviceName};

  1. /**
  2.  * 分页查询所有数据
  3.  *
  4.  * @param page 分页对象
  5.  * @param $!entityName 查询实体
  6.  * @return 所有数据
  7.  */
  8. @GetMapping("selectAll")
  9. public R selectAll(Page<$!tableInfo.name> page, $!tableInfo.name $!entityName) {
  10.     return success(this.$!{serviceName}.page(page, new QueryWrapper<>($!entityName)));
  11. }
  13. /**
  14.  * 通过主键查询单条数据
  15.  *
  16.  * @param id 主键
  17.  * @return 单条数据
  18.  */
  19. @GetMapping("/selectOne/{id}")
  20. public R selectOne(@PathVariable Serializable id) {
  21.     return success(this.$!{serviceName}.getById(id));
  22. }
  24. /**
  25.  * 新增数据
  26.  *
  27.  * @param $!entityName 实体对象
  28.  * @return 新增结果
  29.  */
  30. @PostMapping("insert")
  31. public R insert(@RequestBody $!tableInfo.name $!entityName) {
  32.     return success(this.$!{serviceName}.save($!entityName));
  33. }
  35. /**
  36.  * 修改数据
  37.  *
  38.  * @param $!entityName 实体对象
  39.  * @return 修改结果
  40.  */
  41. @PutMapping("update")
  42. public R update(@RequestBody $!tableInfo.name $!entityName) {
  43.     return success(this.$!{serviceName}.updateById($!entityName));
  44. }
  46. /**
  47.  * 删除数据
  48.  *
  49.  * @param id 主键
  50.  * @return 删除结果
  51.  */
  52. @DeleteMapping("delete")
  53. public R delete(Integer id) {
  54.     return success(this.$!{serviceName}.removeById(id));
  55. }

}

4，知识点总结
easy code插件安装

https://www.toyaml.com/index.html
5，本章面试题

发表评论

表情：
评论列表 （有 0 条评论，57人围观）

还没有评论，来说两句吧...

相关阅读

    相关 springcloud微服务-项目搭建

    前言：      乐优商城这个视频还可以，于是拿来练练手，我对着视频搭环境一直在service服务模块卡住了，注册中心和网关可以启动，服务模块却一直启动不了，报各种奇怪的错，

    小灰灰小灰灰/ 0 赞/ 427 阅读

    相关 SpringCloud微服务框架搭建

    一、微服务架构 1.1什么是分布式 不同模块部署在不同服务器上 作用：分布式解决网站高并发带来问题 1.2什么是集群 多台服务器部署相同应用构成一个集群

    小鱼儿小鱼儿/ 0 赞/ 608 阅读

    相关 SpringCloud--微服务概述

    微服务 微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底 地去耦合,每一个微服务提供单个业务功能的服务，一个服务做一件事。 从技术角度看就是

    亦凉亦凉/ 0 赞/ 674 阅读