• 【Spring Cloud 远程调用】管理员服务系统

    • 💂 个人主页: 程序员爱摸鱼
    • 🤟 版权: 本文由【程序员爱摸鱼】原创、在CSDN首发、需要转载请联系博主
    • 💬 如果文章对你有帮助、欢迎关注+点赞+收藏(一键三连)哦
    • 💅 想寻找共同成长的小伙伴，可以互粉哦

                                                                            

    1. 什么是远程调用

    • 客户端程序通过接口调用服务端程序，并获得该服务返回的数据的过程，称为远程调用。

    • “商品管理系统”调用“用户管理系统”的过程，就是“远程调用”。此时“商品管理系统”相当于模拟“浏览器”。

     

     

    1.1 调用方式

    • 常见的远程调用方式有2种：

      • RPC：Remote Produce Call远程过程调用，==自定义数据==格式的远程调用方式。基于原生TCP通信，速度快，效率高。

      • Http：采用http协议远程调用方式，==规定==了数据传输的格式，缺点是消息封装臃肿。现在热门的Rest风格，就可以通过http协议来实现。

    • 常见框架 ：

      • RPC常见框架： dubbo、WebService

      • Http常见框架：HttpClient、RestTemplat

    区别HTTPRPC
    速度较慢快
    难度简单复杂
    灵活性灵活，跨平台，跨语言

    2. 搭建环境

            2.1 创建父项目：daykaohe6_22        

                    2.1.1配置pom文件

    1.  <parent>
    2.         <groupId>org.springframework.cloud</groupId>
    3.         <artifactId>spring-cloud-build</artifactId>
    4.         <version>2.3.5.RELEASE</version>
    5.     </parent>
    6.  
    7.     <properties>
    8.         <spring.cloud.version>Hoxton.SR12</spring.cloud.version>
    9.         <spring.cloud.alibaba.version>2.2.7-SNAPSHOT</spring.cloud.alibaba.version>
    10.         <mybatis.plus.starter.version>3.4.0</mybatis.plus.starter.version>
    11.         <durid.starter.version>1.1.10</durid.starter.version>
    12.         <swagger.version>2.7.0</swagger.version>
    13.         <jwt.jjwt.version>0.9.0</jwt.jjwt.version>
    14.         <jwt.joda.version>2.9.7</jwt.joda.version>
    15.     </properties>
    16.  
    17.  
    18.  
    19.     <dependencyManagement>
    20.         <dependencies>
    21.             <!-- Spring Dependencies -->
    22.             <dependency>
    23.                 <groupId>org.springframework.boot</groupId>
    24.                 <artifactId>spring-boot-dependencies</artifactId>
    25.                 <version>${spring-boot.version}</version>
    26.                 <type>pom</type>
    27.                 <scope>import</scope>
    28.             </dependency>
    29.  
    30.             <dependency>
    31.                 <groupId>org.springframework.cloud</groupId>
    32.                 <artifactId>spring-cloud-dependencies</artifactId>
    33.                 <version>${spring.cloud.version}</version>
    34.                 <type>pom</type>
    35.                 <scope>import</scope>
    36.             </dependency>
    37.  
    38.             <dependency>
    39.                 <groupId>com.alibaba.cloud</groupId>
    40.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    41.                 <version>2.2.7.RELEASE</version>
    42.                 <type>pom</type>
    43.             </dependency>
    44.  
    45.             <!-- mybatis-plus -->
    46.             <dependency>
    47.                 <groupId>com.baomidou</groupId>
    48.                 <artifactId>mybatis-plus-boot-starter</artifactId>
    49.                 <version>${mybatis.plus.starter.version}</version>
    50.             </dependency>
    51.  
    52.             <!-- Druid连接池 -->
    53.             <dependency>
    54.                 <groupId>com.alibaba</groupId>
    55.                 <artifactId>druid-spring-boot-starter</artifactId>
    56.                 <version>${durid.starter.version}</version>
    57.             </dependency>
    58.  
    59.             <!--swagger2-->
    60.             <dependency>
    61.                 <groupId>io.springfox</groupId>
    62.                 <artifactId>springfox-swagger2</artifactId>
    63.                 <version>${swagger.version}</version>
    64.             </dependency>
    65.             <dependency>
    66.                 <groupId>io.springfox</groupId>
    67.                 <artifactId>springfox-swagger-ui</artifactId>
    68.                 <version>${swagger.version}</version>
    69.             </dependency>
    70.         </dependencies>
    71.     </dependencyManagement>

        2.2 创建子项目：company-data

    1.  环境 
      1.  
      2.     <dependencies>
      3.         <!--web起步依赖-->
      4.         <dependency>
      5.             <groupId>org.springframework.boot</groupId>
      6.             <artifactId>spring-boot-starter-web</artifactId>
      7.         </dependency>
      8.  
      9.         <!--swagger2-->
      10.         <dependency>
      11.             <groupId>io.springfox</groupId>
      12.             <artifactId>springfox-swagger2</artifactId>
      13.         </dependency>
      14.         <dependency>
      15.             <groupId>io.springfox</groupId>
      16.             <artifactId>springfox-swagger-ui</artifactId>
      17.         </dependency>
      18.  
      19.         <!--支持lombok-->
      20.         <dependency>
      21.             <groupId>org.projectlombok</groupId>
      22.             <artifactId>lombok</artifactId>
      23.         </dependency>
      24.  
      25.         <dependency>
      26.             <groupId>com.baomidou</groupId>
      27.             <artifactId>mybatis-plus-boot-starter</artifactId>
      28.             <version>3.4.0</version>
      29.         </dependency>
      30.         <!--MySQL数据库驱动-->
      31.         <dependency>
      32.             <groupId>mysql</groupId>
      33.             <artifactId>mysql-connector-java</artifactId>
      34.         </dependency>
      35.         <!--测试-->
      36.         <dependency>
      37.             <groupId>org.springframework.boot</groupId>
      38.             <artifactId>spring-boot-starter-test</artifactId>
      39.         </dependency>
      40.         <dependency>
      41.             <groupId>com.czxy.</groupId>
      42.             <artifactId>test-mybatis-plus</artifactId>
      43.             <version>1.0-SNAPSHOT</version>
      44.             <scope>test</scope>
      45.         </dependency>
      46.  
      47.     </dependencies>

    2. application.yml配置文件 
      1. server:
      2.   port: 8081
      3. spring:
      4.   datasource:
      5.     driver-class-name: com.mysql.cj.jdbc.Driver
      6.     url: jdbc:mysql://localhost:3306/20220622exam?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
      7.     username: root
      8.     password: 1234
      9. mybatis-plus:
      10.   configuration:
      11.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  #输出日志
      12.     map-underscore-to-camel-case: true
      13.   global-config:
      14.     db-config:
      15.       table-prefix: t_

    3. 创建javaBean 
      1. package com.czxy.domain;
      2.  
      3. import com.baomidou.mybatisplus.annotation.TableId;
      4. import com.baomidou.mybatisplus.annotation.TableName;
      5. import lombok.AllArgsConstructor;
      6. import lombok.Data;
      7. import lombok.NoArgsConstructor;
      8.  
      9. @Data
      10. @NoArgsConstructor
      11. @AllArgsConstructor
      12. @TableName("companys")
      13. public class Companys {
      14.     @TableId
      15.     private  String keyno;
      16.  
      17.     private  String cname;
      18.  
      19.     private  String oper;
      20.  
      21.     private  String industry;
      22. }

    4. 创建CompanysContoller 
      1. @RestController
      2. @RequestMapping("/companys")
      3. public class CompanysContoller {
      4.     @Resource
      5.     private CompanysMapper companysMapper;
      6.  
      7.     @GetMapping
      8.     public BaseResult selectAll(){
      9.         List<Companys> list = companysMapper.selectList(null);
      10.         if(list ==null){
      11.             return  BaseResult.error("查询失败");
      12.         }
      13.         return BaseResult.ok("查询成功",list);
      14.     }
      15.  
      16.     @GetMapping("/{keyno}")
      17.     public BaseResult selectById(@PathVariable("keyno") String keyno){
      18.         Companys companys = companysMapper.selectById(keyno);
      19.         if(companys ==null){
      20.             return  BaseResult.error("查询失败");
      21.         }
      22.         return BaseResult.ok("查询成功",companys);
      23.     }
      24.     @PostMapping
      25.     public BaseResult save(@RequestBody Companys companys){
      26.         int insert = companysMapper.insert(companys);
      27.         if(insert !=1){
      28.             return  BaseResult.error("添加失败");
      29.         }
      30.         return BaseResult.ok("添加成功");
      31.     }
      32.     @DeleteMapping("/{keyno}")
      33.     public BaseResult deleteById(@PathVariable("keyno") String keyno){
      34.         int i = companysMapper.deleteById(keyno);
      35.         if(i !=1){
      36.             return  BaseResult.error("删除失败");
      37.         }
      38.         return BaseResult.ok("删除成功");
      39.     }
      40.  
      41.     @PutMapping
      42.     public BaseResult updata(@RequestBody Companys companys){
      43.         int i = companysMapper.updateById(companys);
      44.         if(i !=1){
      45.             return  BaseResult.error("修改失败");
      46.         }
      47.         return BaseResult.ok("修改成功");
      48.     }
      49.  
      50.  
      51. }

    5. 创建Mapper 
      1. @Mapper
      2. public interface CompanysMapper extends BaseMapper<Companys> {
      3. }

    6. 创建启动类 
      1. @SpringBootApplication
      2. public class TestCompanyApplication {
      3.  
      4.     public static void main(String[] args) {
      5.         SpringApplication.run(TestCompanyApplication.class,args);
      6.     }
      7. }

      2.2 创建子项目：company-http

    1. 创建启动类 
      1. @SpringBootApplication
      2. public class TesthttpApplication {
      3.     public static void main(String[] args) {
      4.         SpringApplication.run(TesthttpApplication.class,args);
      5.     }
      6. }

    2. 创建javaBean 
      1. @Data
      2. @NoArgsConstructor
      3. @AllArgsConstructor
      4. public class Companys {
      5.     private  String keyno;
      6.  
      7.     private  String cname;
      8.  
      9.     private  String oper;
      10.  
      11.     private  String industry;
      12. }

    3. 创建contoller 
      1. @RestController
      2. @RequestMapping("/companys")
      3. public class CompanysContoller {
      4.   @Resource
      5.   private CompanysService companysService;
      6.  
      7.     @GetMapping
      8.     public BaseResult selectAll() {
      9.         List<Companys> list=companysService.list();
      10.         return BaseResult.ok("查询成功",list);
      11.     }
      12.  
      13.  
      14.     @GetMapping("/{keyno}")
      15.     public BaseResult selectById(@PathVariable("keyno") String keyno){
      16.         BaseResult<Companys> user = companysService.getById(keyno);
      17.         return  BaseResult.ok("查询成功",user);
      18.     }
      19.     @PostMapping
      20.     public BaseResult save(@RequestBody Companys companys){
      21.         try {
      22.             companysService.insert(companys);
      23.             return BaseResult.ok("添加成功");
      24.         } catch (Exception e) {
      25.             return  BaseResult.error(e.getMessage());
      26.         }
      27.     }
      28.     @DeleteMapping("/{keyno}")
      29.     public BaseResult deleteById(@PathVariable("keyno") String keyno){
      30.         Boolean i = companysService.deleteById(keyno);
      31.         if(i){
      32.             return BaseResult.ok("删除成功");
      33.         }
      34.         return  BaseResult.error("删除失败");
      35.     }
      36.  
      37.     @PutMapping
      38.     public BaseResult updata(@RequestBody Companys companys){
      39.         try {
      40.             companysService.updateById(companys);
      41.             return BaseResult.ok("修改成功");
      42.         } catch (Exception e) {
      43.             return  BaseResult.error(e.getMessage());
      44.         }
      45.     }
      46.  
      47.  
      48. }

    4. 创建service 
      1. package com.czxy.service.impl;
      2.  
      3. import com.czxy.admin.AdminTest;
      4. import com.czxy.domain.Companys;
      5. import com.czxy.service.CompanysService;
      6. import com.czxy.vo.BaseResult;
      7. import org.springframework.stereotype.Service;
      8. import org.springframework.transaction.annotation.Transactional;
      9.  
      10. import javax.annotation.Resource;
      11. import java.util.List;
      12.  
      13. @Service
      14. @Transactional
      15. public class CompanysServiceimpl implements CompanysService {
      16.  
      17.     @Resource
      18.     private AdminTest adminTest;
      19.     @Override
      20.     public List<Companys> list() {
      21.            List<Companys> list= adminTest.list();
      22.         return list;
      23.     }
      24.  
      25.     @Override
      26.     public BaseResult<Companys> getById(String keyno) {
      27.         BaseResult<Companys> userBaseResult = adminTest.selectById(keyno);
      28.         return userBaseResult;
      29.     }
      30.  
      31.     @Override
      32.     public void insert(Companys companys) {
      33.        adminTest.insert(companys);
      34.  
      35.     }
      36.  
      37.     @Override
      38.     public Boolean deleteById(String keyno) {
      39.         Boolean result=adminTest.delete(keyno);
      40.         return result;
      41.     }
      42.  
      43.     @Override
      44.     public void updateById(Companys companys) {
      45.       adminTest.update(companys);
      46.     }
      47. }

    5. 创建admin进行远程调用 
      1. package com.czxy.admin;
      2.  
      3. import com.czxy.domain.Companys;
      4. import com.czxy.vo.BaseResult;
      5. import org.checkerframework.checker.units.qual.C;
      6. import org.springframework.core.ParameterizedTypeReference;
      7. import org.springframework.http.HttpMethod;
      8. import org.springframework.http.ResponseEntity;
      9. import org.springframework.stereotype.Component;
      10. import org.springframework.web.client.RestTemplate;
      11.  
      12. import javax.annotation.Resource;
      13. import java.util.List;
      14.  
      15. @Component
      16. public class AdminTest {
      17.  
      18.     @Resource
      19.     private RestTemplate restTemplate;
      20.  
      21.  
      22.     public List<Companys> list() {
      23.         String url="http://localhost:8081/companys";
      24.         ResponseEntity<BaseResult> entity = restTemplate.getForEntity(url, BaseResult.class);
      25.         List<Companys> list = (List<Companys>) entity.getBody().getData();
      26.         return  list;
      27.     }
      28.  
      29.  
      30.     public BaseResult<Companys> selectById(String keyno) {
      31.         String  url="http://localhost:8081/companys/"+keyno;
      32.         ResponseEntity<BaseResult<Companys>> resultResponseEntity = restTemplate.exchange(url, HttpMethod.GET, null, new ParameterizedTypeReference<BaseResult<Companys>>() {
      33.         });
      34.         return resultResponseEntity.getBody();
      35.     }
      36.  
      37.     public void insert(Companys companys) {
      38.         String url="http://localhost:8081/companys";
      39.         RestTemplate restTemplate = new RestTemplate();
      40.         ResponseEntity<BaseResult> entity = restTemplate.postForEntity(url, companys, BaseResult.class);
      41.         
      42.     }
      43.  
      44.     public Boolean delete(String keyno) {
      45.         String url="http://localhost:8081/companys/"+keyno;
      46.         RestTemplate restTemplate = new RestTemplate();
      47.         restTemplate.delete(url);
      48.         return true;
      49.     }
      50.  
      51.     public void update(Companys companys) {
      52.         String url="http://localhost:8081/companys";
      53.         RestTemplate restTemplate = new RestTemplate();
      54.         restTemplate.put(url,companys,BaseResult.class);
      55.     }
      56. }

    最后进行测试

    http://localhost:8082/swagger-ui.html#/

       

     

      最后只要能调用到就说明你已经学会了哦~

     

                            

    想要了解更多吗？没时间解释了，快来点一点！！！
    程序员爱摸鱼🐟
    ————————————————
    版权声明：本文为CSDN博主「程序员爱摸鱼」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    原文链接：    https://blog.csdn.net/lcshen1234?type=blog

  • 相关阅读:
    Gooxi国鑫搭载第四代英特尔至强可扩展处理器系列服务器焕新登场
    Spring Boot接口设计规范
    [CTF] 2018-百越杯-Misc-血小板天下第一可爱
    小程序数据导出文件
    Window部署Jaeger
    HJ33整数与IP地址间的转换
    [网络工程师]-防火墙-防火墙体系
    携职教育：注会和中级哪个在体制内有用？
    Spring底层核心原理解析
    日常遇到的数据库上的常用排查命令
  • 原文地址：https://blog.csdn.net/lcshen1234/article/details/125438561