精华内容
下载资源
问答
  • SpringCloud服务拆分实践1、新建一个普通的maven项目 springcloud2、新建一个maven项目,springcloud-api子模块1. 编写pom.xml文件2. 编写User实体类3、新建一个maven项目,springcloud-provider-user-8001子模块,...


    关于为什么要拆分与什么情况需要拆分,我在这里不再说明,读者可以自行网上找答案。

    1、新建一个普通的maven项目 springcloud

    编写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">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.example</groupId>
        <artifactId>springcloud</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
        <modules>
            <module>springcloud-api</module>
            <module>springcloud-provier-user-8001</module>
            <module>springcloud-consumer-user-80</module>
        </modules>
    
        <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.3.5.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
    
                <!--druid-->
                <dependency>
                    <groupId>com.alibaba</groupId>
                    <artifactId>druid</artifactId>
                    <version>1.1.18</version>
                </dependency>
    
                <!-- 数据库驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.21</version>
                </dependency>
    
                <!-- lombok -->
                <dependency>
                    <groupId>org.projectlombok</groupId>
                    <artifactId>lombok</artifactId>
                    <version>1.18.18</version>
                </dependency>
    
                <!-- mybatis_plus -->
                <dependency>
                    <groupId>com.baomidou</groupId>
                    <artifactId>mybatis-plus-boot-starter</artifactId>
                    <version>3.0.5</version>
                </dependency>
    
                <!-- Velocity -->
                <dependency>
                    <groupId>org.apache.velocity</groupId>
                    <artifactId>velocity-engine-core</artifactId>
                    <version>2.0</version>
                </dependency>
    
                <!-- swagger2 -->
                <dependency>
                    <groupId>io.springfox</groupId>
                    <artifactId>springfox-swagger2</artifactId>
                    <version>2.7.0</version>
                </dependency>
    
                <!-- junit -->
                <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>4.13.1</version>
                    <scope>test</scope>
                </dependency>
    
                <!-- log4j -->
                <dependency>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                    <version>1.2.12</version>
                </dependency>
    
                <!-- 日志测试 -->
                <dependency>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                    <version>1.2.3</version>
                </dependency>
            </dependencies>
    
        </dependencyManagement>
    
    </project>
    

    2、新建一个maven项目,springcloud-api子模块

    这个模块用来放实体类

    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</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>springcloud-api</artifactId>
    
    <dependencies>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>
    
        <!-- mybatis_plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>
    </dependencies>
    </project>
    

    2. 编写User实体类

    如果,那些注释不会,可以去百度找一个mybatis的文档

    package com.hzxy.springcloud.model;
    
    import com.baomidou.mybatisplus.annotation.FieldFill;
    import com.baomidou.mybatisplus.annotation.TableField;
    import com.baomidou.mybatisplus.annotation.TableLogic;
    import com.baomidou.mybatisplus.annotation.Version;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    
    import java.io.Serializable;
    import java.util.Date;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Accessors(chain = true)
    public class User implements Serializable {
        private Long id;
        private String name;
        private Integer age;
        private String email;
    
        @Version    //乐观锁version注解
        private Integer version;
    
        @TableLogic  //逻辑删除
        private Integer deleted;
    
        //  字段添加填充
        @TableField(fill = FieldFill.INSERT)
        private Date CreateTime;
    
        @TableField(fill = FieldFill.INSERT_UPDATE)
        private Date UpdateTime;
    }
    
    

    3、新建一个maven项目,springcloud-provider-user-8001子模块,表示服务提供者

    取名为springcloud-provider-user-8001这样比较直观

    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</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>springcloud-provier-user-8001</artifactId>
    
        <dependencies>
            <!-- 我们需要拿到实体类 ,所以配置api module -->
            <dependency>
                <groupId>org.example</groupId>
                <artifactId>springcloud-api</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
    
            <!-- junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <scope>test</scope>
            </dependency>
    
            <!-- 数据库驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
    
            <!-- mybatis_plus -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
            </dependency>
    
            <!--druid-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.18</version>
            </dependency>
    
            <!-- springboot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-test</artifactId>
            </dependency>
    
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
            </dependency>
    
            <!-- jetty -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jetty</artifactId>
            </dependency>
    
            <!-- 热部署工具 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
        </dependencies>
    
    </project>
    

    2、编写application.yml

    server:
      port: 8001
    spring:
      application:
        name: springcloud-provider-user
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
        username: root
        password: 520China
    
    
    mybatis-plus:
      configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
      global-config:
        db-config:
          logic-delete-value: 1
          logic-not-delete-value: 0
    

    3. 编写Mapper

    package com.hzxy.springcloud.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.hzxy.springcloud.model.User;
    import org.springframework.stereotype.Repository;
    
    // 在对应的Mapper上面继承基本的类 BaseMapper
    @Repository    //代表持久层
    public interface UserMapper extends BaseMapper<User> {
        // 所有的CRUD操作已经编写完成
        // 你不需要像以前的配置一大堆文件了
    }
    

    4. 编写service和service的实现

    UserService

    package com.hzxy.springcloud.service;
    
    import com.hzxy.springcloud.model.User;
    
    import java.util.List;
    
    public interface UserService {
        public List<User> findAll();
    }
    

    UserServiceImpl

    package com.hzxy.springcloud.service.impl;
    
    import com.hzxy.springcloud.mapper.UserMapper;
    import com.hzxy.springcloud.model.User;
    import com.hzxy.springcloud.service.UserService;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    @Service
    public class UserServiceImpl implements UserService {
        @Resource
        private UserMapper userMapper;
    
        public List<User> findAll() {
            return userMapper.selectList(null);
        }
    }
    

    5. 编写controller

    package com.hzxy.springcloud.controller;
    
    import com.hzxy.springcloud.model.User;
    import com.hzxy.springcloud.service.UserService;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    @RestController
    public class UserController {
    
        @Resource
        private UserService userService;
    
        @RequestMapping("/hello")
        public List<User> hello(){
            return userService.findAll();
        }
    }
    
    

    6. 编写springboot的启动类

    package com.hzxy.springcloud;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @MapperScan("com.hzxy.springcloud.mapper")
    @SpringBootApplication
    public class Provider_8001 {
        public static void main(String[] args) {
            SpringApplication.run(Provider_8001.class,args);
        }
    }
    

    编写完后,启动,测试
    在这里插入图片描述
    如图,表示成功!

    4、新建一个maven项目,springcloud-consumer-user-80子模块,表示服务消费者

    端口为80是因为一般网站都是80为端口的,这样可以省略,如www.baidu.com

    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</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>springcloud-consumer-user-80</artifactId>
    
        <dependencies>
            <!-- 我们需要拿到实体类 ,所以配置api module -->
            <dependency>
                <groupId>org.example</groupId>
                <artifactId>springcloud-api</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
    
            <!-- springboot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <!-- 热部署工具 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>
    
            <!-- 数据库驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
    
        </dependencies>
    </project>
    

    2. 编写application.yml

    server:
      port: 80
    spring:
      application:
        name: springcloud-consumer-user
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8
        username: root
        password: 520China
    

    3. 编写配置类

    编写配置类,注册RestTemplate对象

    package com.hzxy.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 -- spring applicationContext.xml
    
        @Bean
        public RestTemplate getRestTemplate(){
            return new RestTemplate();
        }
    }
    
    

    4. 编写controller,调用服务提供者的服务

    package com.hzxy.springcloud.controller;
    
    import com.hzxy.springcloud.model.User;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    
    @RestController
    public class UserController {
    
        @Resource
        private RestTemplate restTemplate;
    
        private static final String REST_URL = "http://localhost:8001/hello";
    
        @RequestMapping("/hi")
        public List<User> Hi(){
            return restTemplate.getForObject(REST_URL,List.class);
        }
    }
    
    

    5. 编写springboot启动类

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

    6. 测试

    启动服务提供者和服务消费者
    在这里插入图片描述
    在浏览器输入http://localhost/hi,回车
    在这里插入图片描述
    访问成功,拆分成功!

    展开全文
  • 一种用于构建应用的架构方案,将应用进行拆分成多个核心功能,每个功能即服务,可以单独构建和部署,服务间不相互影响。 单一职责:每个服务对应唯一业务 自治:团队独立部署和交付 面向服务:提供统一标准接口 隔离...

    一、何为微服务?

    一种用于构建应用的架构方案,将应用进行拆分成多个核心功能,每个功能即服务,可以单独构建和部署,服务间不相互影响。

    单一职责:每个服务对应唯一业务
    自治:团队独立部署和交付
    面向服务:提供统一标准接口
    隔离性强:做好隔离避免出现级联问题                                  
    

    微服务架构如下
    在这里插入图片描述
    微服务实则就是在解决下面几个问题

    1. 客户端如何访问服务?
    2. 服务之间如何通信?
    3. 如何治理服务?
    4. 服务挂了如何解决?
    常见的解决方案有SpringCloud NetflixDubbo+ZookeeperSpringCloud Alibaba(很火)
    

    在这里插入图片描述

    二、微服务与其他架构的区别

    1.单体架构

    简单但可扩展性差,高度耦合,适合小型项目
    

    2.分布式架构

    复杂但可扩展性好,松耦合,适合大型互联网项目
    

    3.微服务

    一种良好的分布式架构方案
    拆分粒度更小、服务更独立、耦合度更低,但是更复杂、运维监控部署难度更高
    

    4.SpringCloud

    微服务架构的一站式解决方案。
    集成了很多优秀的微服务组件
    

    三、服务拆分

    1.服务拆分原则

    • 不同微服务不出现重复业务
    • 不访问其他微服务数据库
    • 向外暴露自己的业务接口
    下面以商城为例,对其进行拆分可以得到如下四个大模块(商品、用户、订单、支付)
    

    在这里插入图片描述

    2.服务拆分示例

    • 订单微服务和用户微服务都必须有各自的数据库,相互独立
    • 订单服务和用户服务都对外暴露Restful的接口
    • 订单服务如果需要查询用户信息,只能调用用户服务的Restful接口,不能查询用户数据库
    cloud-demo:父工程,管理依赖
    
    - order-service:订单微服务,负责订单相关业务
    - user-service: 用户微服务,负责用户相关业务
    

    在这里插入图片描述

    3.服务查询数据如下
    订单服务
    在这里插入图片描述

    用户服务
    在这里插入图片描述

    四、服务调用

    订单服务调用用户服务,把订单里的用户信息查询出来,思路如下
    在这里插入图片描述

    1.注册RestTemplate实例到Spring容器
    2.在订单服务中调用用户服务接口
    

    1.注册RestTemplate
    在order-service服务中的OrderApplication启动类中,注册RestTemplate实例
    在这里插入图片描述
    2.远程服务调用
    修改order-service服务中OrderService类中的queryOrderById方法:

    public Order queryOrderById(Long orderId) {
       // 1.查询订单
       Order order = orderMapper.findById(orderId);
       // 2.远程调用路径
       String url = "http://localhost:8081/user/" + order.getUserId();
       // 3.远程调用返回数据
       User user = restTemplate.getForObject(url, User.class);
       //存入order
       order.setUser(user);
       // 4.返回
       return order;
    }
    

    3.服务调用成功
    在这里插入图片描述
    4.服务调用总结

    基于RestTemplate发起的http请求实现远程调用
    http请求做远程调用与语言无关,只需ip、端口、接口路径、请求参数即可
    

    五、服务提供者和消费者

    1.在服务调用关系中,会有两个不同的角色
    在这里插入图片描述

    服务提供者:一次业务中,被其它微服务调用的服务。(提供接口)
    服务消费者:一次业务中,调用其它微服务的服务。(调用接口)
    

    2.但是,服务提供者和服务消费者是相对业务而言的,例如:服务A调用服务B,服务B调用服务C

    对于A调用B而言:A是服务消费者,B是服务提供者
    对于B调用C而言:B是服务消费者,C是服务提供者
    
    展开全文
  • 业务能力定义了一个组织的工作 识别业务能力 从业务能力到服务

    业务能力定义了一个组织的工作

    组织的业务能力通常是指这个组织的业务是做什么,它们通常是稳定的。

    与之相反,组织采用何种方式来实现它的业务能力,是随着时间不断变化的。

    识别业务能力

    一个组织有哪些业务能力,是通过对组织的目标、结构和商业流程的分析得来的。

    从业务能力到服务

    一旦确定了业务能力,就可以为每个能力或相关能力组定义服务。

     

    展开全文
  • 一、服务拆分与远程调用 1.1、创建父工程:cloud-demo …\cloud-demo\pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=...

    一、服务拆分与远程调用

    1.1、创建父工程:cloud-demo

    在这里插入图片描述
    在这里插入图片描述
    …\cloud-demo\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">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.xbmu</groupId>
        <artifactId>cloud-demo</artifactId>
        <version>1.0</version>
        <modules>
            <module>user-service</module>
            <module>order-service</module>
        </modules>
    
        <packaging>pom</packaging>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.9.RELEASE</version>
            <relativePath/>
        </parent>
    
        <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>Hoxton.SR10</spring-cloud.version>
            <mysql.version>5.1.47</mysql.version>
            <mybatis.version>2.1.1</mybatis.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <!-- springCloud -->
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!-- mysql驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>${mysql.version}</version>
                </dependency>
                <!--mybatis-->
                <dependency>
                    <groupId>org.mybatis.spring.boot</groupId>
                    <artifactId>mybatis-spring-boot-starter</artifactId>
                    <version>${mybatis.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    </project>
    

    1.2、module工程:user-service

    在这里插入图片描述
    …\cloud-demo\user-service\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>cloud-demo</artifactId>
            <groupId>com.xbmu</groupId>
            <version>1.0</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>user-service</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <!--mybatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
            </dependency>
        </dependencies>
        <build>
            <finalName>app</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    …\cloud-demo\user-service\src\main\resources\application.yml

    server:
      port: 8981
    spring:
      datasource:
        url: jdbc:mysql://localhost:3306/cloud_user?useSSL=false
        username: root
        password: root
        driver-class-name: com.mysql.jdbc.Driver
    mybatis:
      type-aliases-package: com.xbmu.user.pojo
      configuration:
        map-underscore-to-camel-case: true
    logging:
      level:
        com.xbmu: debug
      pattern:
        dateformat: MM-dd HH:mm:ss:SSS
    

    com.xbmu.user.UserApplication

    package com.xbmu.user;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.mybatis.spring.annotation.MapperScan;
    
    @MapperScan("com.xbmu.user.mapper")
    @SpringBootApplication
    public class UserApplication {
        public static void main(String[] args) {
            SpringApplication.run(UserApplication.class, args);
        }
    }
    

    com.xbmu.user.web.UserController

    package com.xbmu.user.web;
    
    import com.xbmu.user.pojo.User;
    import com.xbmu.user.service.UserService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    
    @Slf4j
    @RestController
    @RequestMapping("/user")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        /**
         * 路径: /user/110
         *
         * @param id 用户id
         * @return 用户
         */
        @GetMapping("/{id}")
        public User queryById(@PathVariable("id") Long id) {
            return userService.queryById(id);
        }
    }
    

    com.xbmu.user.service.UserService

    package com.xbmu.user.service;
    
    import com.xbmu.user.mapper.UserMapper;
    import com.xbmu.user.pojo.User;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        @Autowired
        private UserMapper userMapper;
    
        public User queryById(Long id) {
            return userMapper.findById(id);
        }
    }
    

    com.xbmu.user.pojo.User

    package com.xbmu.user.pojo;
    
    import lombok.Data;
    
    @Data
    public class User {
        private Long id;
        private String username;
        private String address;
    }
    

    com.xbmu.user.mapper.UserMapper

    package com.xbmu.user.mapper;
    
    import com.xbmu.user.pojo.User;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    
    public interface UserMapper {
        
        @Select("select * from tb_user where id = #{id}")
        User findById(@Param("id") Long id);
    }
    

    1.3、module工程:order-service

    在这里插入图片描述
    …\cloud-demo\order-service\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>cloud-demo</artifactId>
            <groupId>com.xbmu</groupId>
            <version>1.0</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>order-service</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <!--mybatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    …\cloud-demo\order-service\src\main\resources\application.yml

    server:
      port: 8982
    spring:
      datasource:
        url: jdbc:mysql://localhost:3306/cloud_order?useSSL=false
        username: root
        password: root
        driver-class-name: com.mysql.jdbc.Driver
    mybatis:
      type-aliases-package: com.xbmu.user.pojo
      configuration:
        map-underscore-to-camel-case: true
    logging:
      level:
        com.xbmu: debug
      pattern:
        dateformat: MM-dd HH:mm:ss:SSS
    

    …\cloud-demo\order-service\src\main\java\com\xbmu\order\OrderApplication.java

    package com.xbmu.order;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.Bean;
    import org.springframework.web.client.RestTemplate;
    
    @MapperScan("com.xbmu.order.mapper")
    @SpringBootApplication
    public class OrderApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(OrderApplication.class, args);
        }
        /**
         * 创建RestTemplate并注入Spring容器
         */
        @Bean
        public RestTemplate restTemplate() {
            return new RestTemplate();
        }
    }
    

    com.xbmu.order.web.OrderController

    package com.xbmu.order.web;
    
    import com.xbmu.order.pojo.Order;
    import com.xbmu.order.service.OrderService;
    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.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("order")
    public class OrderController {
    
       @Autowired
       private OrderService orderService;
    
        @GetMapping("{orderId}")
        public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
            // 根据id查询订单并返回
            return orderService.queryOrderById(orderId);
        }
    }
    

    com.xbmu.order.service.OrderService

    package com.xbmu.order.service;
    
    import com.xbmu.order.mapper.OrderMapper;
    import com.xbmu.order.pojo.Order;
    import com.xbmu.order.pojo.User;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.client.RestTemplate;
    
    @Service
    public class OrderService {
    
        @Autowired
        private OrderMapper orderMapper;
        @Autowired
        private RestTemplate restTemplate;
        public Order queryOrderById(Long orderId) {
            // 1.查询订单
            Order order = orderMapper.findById(orderId);
            // 2.利用RestTemplate发起http请求,查询用户
            // 2.1.url路径
            String url = "http://localhost:8981/user/" + order.getUserId();
            // 2.2.发送http请求,实现远程调用
            User user = restTemplate.getForObject(url, User.class);
            // 3.封装user到Order
            order.setUser(user);
            // 4.返回
            return order;
        }
    }
    

    com.xbmu.order.pojo.User

    package com.xbmu.order.pojo;
    
    import lombok.Data;
    
    @Data
    public class User {
        private Long id;
        private String username;
        private String address;
    }
    

    com.xbmu.order.pojo.Order

    package com.xbmu.order.pojo;
    
    import lombok.Data;
    
    @Data
    public class Order {
        private Long id;
        private Long price;
        private String name;
        private Integer num;
        private Long userId;
        private User user;
    }
    

    com.xbmu.order.mapper.OrderMapper

    package com.xbmu.order.mapper;
    
    import com.xbmu.order.pojo.Order;
    import org.apache.ibatis.annotations.Select;
    
    public interface OrderMapper {
    
        @Select("select * from tb_order where id = #{id}")
        Order findById(Long id);
    }
    

    1.4、结果演示:

    在这里插入图片描述
    在这里插入图片描述

    1.5、查询逻辑:

    需求:在order-service中根据id查询订单业务,要求在查询订单的同时,根据订单中包含的userId查询出用户信息,一起返回。
    在这里插入图片描述
    因此,我们在order-service中向user-service发起一个http的请求,调用 http://localhost:8981/user/{userId}这个接口。

    大概的步骤是这样的:

    • 注册一个RestTemplate的实例到spring容器
    • 修改order-service服务中的OrderService类中的queryOrderById方法,根据Order对象中的userId查询User
    • 将查询的User填充到Order对象,一起返回

    1.5.1、注册RestTemplate

    首先,在order-service服务中的OrderApplication启动类中,注册了RestTemplate实例:
    在这里插入图片描述

    1.5.2、实现远程调用

    修改order-service服务中的com.xbmu.order.service包下的OrderService类中的queryOrderById方法:
    在这里插入图片描述

    展开全文
  • 子域 领域驱动为每个子域定义单独的领域模型。子域是领域的一部分,领域是DDD中用来描述应用程序问题域的一个术语。识别子域的方式跟识别业务...当使用微服务架构时,每一个界限上下文对应一个或者一组服务。 ...
  • 服务拆分和远程调用2-1 服务拆分原则2-2 服务拆分示例(1) 准备数据库环境(2) 导入demo工程2-3 实现远程调用案例(1) 案例需求(2) 注册RestTemplate(3) 实现远程调用2-4 提供者与消费者3.Eureka注册中心3-1 Eureka的...
  • 服务拆分的原则

    2021-04-02 23:21:13
    拆分的原则 1.粒度与规模相当 扩张期:3人对应1个服务 维护期:2人对应多个服务 2.演进式拆分 不要一味跟风“大厂” 拆分是为了解决复杂度,提高性能 权衡拆分收益和成本 3.以模型职责拆分 二.数据库拆分后数据...
  • 服务拆分之后,我们如何做服务的治理? 5.4.1 服务注册中心:zookeeper 文件系统+监听机制 所谓的服务注册,就是在zookeeper的服务器上创建一个节点,而且是临时节点,保存着服务的地址信息。 所谓的服务发现,就是...
  • 服务拆分-案例Demo

    2021-11-05 23:15:12
    服务拆分原则 这里我总结了微服务拆分时的几个原则: 不同微服务,不要重复开发相同业务 微服务数据独立,不要访问其它微服务的数据库 微服务可以将自己的业务暴露为接口,供其它微服务调用 ...
  • 《微服务架构设计模式》笔记2—服务拆分策略二、服务拆分策略1、软件架构2、架构的风格1、分层式架构风格2、六边形架构:3、微服务架构是一种架构风格1、什么是服务2、什么是松耦合3、共享类库的角色4、服务大小并不...
  • 一、创建RestTemplate并注入Spring容器 /** * 创建RestTemplate并注入Spring容器 * @return */ @Bean public RestTemplate restTemplate(){ return new RestTemplate(); } 二、发送http请求,实现远程....
  • 微服务拆分之道

    2021-06-05 00:24:46
    接下来一起谈谈服务拆分的策略和坚持的原则。 拆分目的是什么? ALIWARE 在介绍如何拆分之前,我们需要了解下拆分的目的是什么,这样才不会在后续的拆分过程中忘了最初的目的。 拆分的本质是为了将复杂的问题简单化...
  • 经历过稍有些规模的IM系统开发的同行们都有体会,要想实现大规模并发IM(比如亿级用户和数十亿日消息量这样的规模),在架构设计上需要一些额外的考虑,尤其是要解决用户高并发、服务高可用,架构和实现细节上都需要...
  • 微服务拆分微服务拆分时机为了快速迭代高并发场景可重用提交代码经常冲突小功能要积累到大版本才能上线服务拆分原则原则一:高内聚和低耦合。原则二:服务拆分正交性原则原则三:服务粒度适中、演进式拆分原则四:...
  • 服务拆分及远程调用 1 服务拆分注意事项 不同微服务,不要重复开发相同业务 微服务数据独立,不要访问其它微服务的数据库 微服务可以将自己的业务暴露为接口,供其它微服务调用 2 微服务远程调用 2.1 根据订单id...
  • 拆分大型PHP类

    2021-04-21 02:25:02
    我有一个很大的类(1500行,但很快就会好几倍),我想分割它以便它更适合SRP(并且每个文件都更小,更易于管理.)该类包含50-100个属性,并具有针对它执行的几种不同类型的操作 – 其中一种是更新,而后者又执行多个步骤,例如...
  • 微服务拆分没有一个绝对正确的方案,服务拆分的粒度完全要根据业务场景来规划,而随着业务的发展,原先的架构方案也需要做调整。既然没有标准答案,那我们就使出“乱拳打死老师傅”的招数,想怎么拆怎么拆好了?且慢...
  • 文章目录微服务架构到底是什么软件架构架构风格为应用程序定义微服务架构识别系统操作创建抽象领域模型定义系统操作微服务拆分根据业务能力进行服务拆分根据子域进行服务拆分拆分指导原则拆分单体应用为服务的难点...
  • 微服务拆分原则之AKF

    2021-11-25 01:11:56
    主主相当于多台服务器同时对外提供读写: 主从,主机可以读写,但是一般只对外提供写,从机对外提供读: 主备,主机提供读写,备机不对外提供服务,当主机挂了的时候,备机通过选举产生主机对外提供服务。 X轴拆分 可以看到的...
  • 微服务合并拆分原则

    2021-06-07 17:11:41
    几个要素 1.人数:同一个服务维护的人员过多
  • 电商项目之订单拆分

    2021-04-29 08:31:13
    电商项目之订单拆分 什么是订单拆分: 用户提交的订单在理论上并不是一个不可拆分的单元,也即:他不是一个颗粒度最小的实体,可以进行多种形式的分解,具体如何根据不同的业务场景,可以进行不同形式的拆分。 为什么...
  • 微服务拆分原则

    2021-01-15 17:22:32
    拆分的大原则是当一块业务不依赖或极少依赖其它服务,有独立的业务语义,为超过 2 个的其他服务或客户端提供数据,那么它就应该被拆分成一个独立的服务模块 单一职责、高内聚低耦合:简单来说一张表划分为一个服务...
  • 当下微服务盛行,微服务架构解决了单点系统的可用性问题、突破单节点服务的性能瓶颈同时提升了整个系统的稳定性。因此各大公司纷纷转向微服务架构,但是在实际的微服务拆分过程中也会遇到不少的问题。而 DDD 中的...
  • Maven多模块项目,适用于一些比较大的项目,通过合理的模块拆分,实现代码的复用,便于维护和管理。尤其是一些开源框架,也是采用多模块的方式,提供插件集成,用户可以根据需要配置指定的模块。一 什么是Maven多模块...
  • 电商平台商品订单拆分模式分析

    千次阅读 2021-01-08 10:16:05
    电商平台(天猫、淘宝、拼多多等)有很多商家入驻,用户下单普遍存在跨店结算,所以要拆分订单内的信息,同时将商品信息与优惠信息分摊到各自店铺的订单上。 2.仓库拆分 电商平台存在多仓库的情况,且不同的商品...
  • 接下来一起谈谈服务拆分的策略和坚持的原则。 拆分目的是什么? 在介绍如何拆分之前,我们需要了解下拆分的目的是什么,这样才不会在后续的拆分过程中忘了最初的目的。 拆分的本质是为了将复杂的问题简单化,那么...
  • Foodie微服务化的构想 现有结构 拆迁通知 项目结构
  • SpringBoot项目拆分(按模块拆分) 在了解SpringBoot项目拆分之前首先我们需要了解微服务架构 什么是微服务? 单个轻量级服务一般为一个单独微服务,微服务讲究的是 专注某个功能的实现,比如登录系统只专注于用户...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 230,079
精华内容 92,031
关键字:

服务拆分

友情链接: tboltvechat.zip