微服务------环境搭建和创建工程

模拟场景：电商项目中的商品微服务、订单微服务为案例

1. 准备

1.1 模块设计

test01-parent 父工程 ------jar的版本管理

test01-common 公共模块（实体类）{实体类，公共依赖，工具类}

test01-product 商品微服务 

test01-order 订单微服务

 1.2 微服务的调用

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

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

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

2. 创建工程

 2.1 test01-parent 父工程 ------jar的版本管理

第一步：新建springboot工程，且不添加任何依赖

第二步： 在pom.xml中设置jar的版本

<!--dependencyManagement:它只负责jar的版本号管理，不负责jar的下载,交于子模块，子模块在使用时无需指定版本号
         :springboot springcloud  springcloudalibaba之间版本一定要匹配
   -->
    <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>
            <!--springcloudalibaba的版本管理-->
            <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>

2.2 test01-common 公共模块（实体类）{实体类，公共依赖，工具类}

第一步：在父工程中新建maven工程，名字命名为test01-common

 

 第二部：添加公共实体的对象、依赖、工具类

<dependencies>
    <!--        将数据转换为JSON，在转换为相应的实体对象-->
    <dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.4</version>
        <classifier>jdk15</classifier>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.2</version>
    </dependency>
</dependencies>

 工具类：

package com.sal.until;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author bian
 * @Date 2022/6/10 19:57
 * @PackageName:com.sal.until
 * @ClassName: CommonResult
 * @Description: TODO
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CommonResult {
    private Integer code;
    private String msg;
    private Object data;
}

实体类：

package com.sal.entity;

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

@Data
@TableName("shop_order")
public class Order {
    @TableId(type = IdType.AUTO)
    private Long oid; //订单id
    private Integer uid;//用户id
    private String username;//用户名
    private Integer pid;//商品id
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer number;//购买数量
}

package com.sal.entity;

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

@Data
@TableName(value="shop_product")
public class Product {
    @TableId(type= IdType.AUTO)
    private Integer pid;
    private String pname;//商品名称
    private Double pprice;//商品价格
    private Integer stock;//库存
}

2.3 test01-product  商品微服务

第一步：添加依赖

<dependencies>
        <!--        nacos：在配置中心获取配置信息-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--        引入alibaba的nacos作为注册中心进行收集服务信息-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--        引入公共部分-->
        <dependency>
            <groupId>com.sal</groupId>
            <artifactId>test01-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <!--        用于启动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

第二步：编写代码和启动类

controller：

package com.sal.controller;

import com.sal.server.ProductService;
import com.sal.until.CommonResult;
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;

/**
 * @Author bian
 * @Date 2022/8/18 19:45
 * @PackageName:com.sal.controller
 * @ClassName: ProductController
 * @Description: TODO
 * @Version 1.0
 */
@RestController
@RequestMapping("product")
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping("selects/{ids}")
    public CommonResult selects(@PathVariable Integer ids){
        return productService.selectByids(ids);
    }

}

server：

package com.sal.server;


import com.sal.until.CommonResult;

/**
 * @Author bian
 * @Date 2022/8/18 19:43
 * @PackageName:com.sal.server.impl
 * @ClassName: ProductService
 * @Description: TODO
 * @Version 1.0
 */
public interface ProductService {
    CommonResult selectByids(Integer ids);
}

server--》impl

package com.sal.server.impl;

import com.sal.dao.ProductMapper;
import com.sal.entity.Product;
import com.sal.server.ProductService;
import com.sal.until.CommonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @Author bian
 * @Date 2022/8/18 19:43
 * @PackageName:com.sal.server.impl
 * @ClassName: ProductServiceImpl
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private ProductMapper productMapper;

    @Override
    public CommonResult selectByids(Integer ids) {
        Product product = productMapper.selectById(ids);
        if(product!=null){
            return new CommonResult(2000,"查询成功",product);
        }
        return new CommonResult(5000,"查询失败",null);
    }
}

dao：

package com.sal.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sal.entity.Product;
import org.apache.ibatis.annotations.Mapper;

/**
 * @Author bian
 * @Date 2022/8/18 19:40
 * @PackageName:com.sal.dao
 * @ClassName: ProductMapper
 * @Description: TODO
 * @Version 1.0
 */
@Mapper
public interface ProductMapper extends BaseMapper<Product> {
}

启动类：

package com.sal;

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

/**
 * @Author bian
 * @Date 2022/8/18 18:07
 * @PackageName:com.sal.produce
 * @ClassName: ProductApp
 * @Description: TODO
 * @Version 1.0
 */
//启动类
@SpringBootApplication
public class ProductApp {
    public static void main(String[] args) {
        SpringApplication.run(ProductApp.class,args);
    }
}

bootstrap.properties：

需要将服务的注册放到注册中心去，这样在可以便于获取服务之间的信息，例如：可以在服务上拉取所要调用的服务的接口、服务名，从而获取该服务所实现的功能。

#为了以后配置集群，设定接口为8080~~8099之间
server.port=8081

#sql配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springcould?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456

#sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl


#指定微服务名称
spring.application.name=product

#指定服务中心接口  默认接口是8848 我这是后面配置的负载均衡配置了两个备用接口
spring.cloud.nacos.discovery.server-addr=localhost:82

2.4 test01-order  订单微服务

第一步：加载依赖

<dependencies>
        <!--        获取配置信息-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--        openfeign依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--        引入公共部分-->
        <dependency>
            <groupId>com.sal</groupId>
            <artifactId>test01-common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <!--        用于启动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

第二步：编写代码和启动类

controller：

OrderController：

使用restTemplate获取别的服务中的信息

package com.order.controller;

import com.order.service.OrderService;
import com.sal.entity.Order;
import com.sal.entity.Product;
import com.sal.until.CommonResult;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
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;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * @Author bian
 * @Date 2022/8/18 20:04
 * @PackageName:com.order.controller
 * @ClassName: OrderController
 * @Description: TODO
 * @Version 1.0
 */
@RestController
@RequestMapping("order")
public class OrderController {

    @Autowired
    private OrderService orderService;

//  spring提供的一个工具类，该类可以从注册中心获取微服务信息
    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("inserts/{pid}/{num}")
    public String inserts(@PathVariable Integer pid,@PathVariable Integer num){
        Order order = new Order();
        order.setNumber(num);
        //用户的信息可以根据token从redis中获取用户信息
        order.setUid(1);
        order.setUsername("张三");

        //需要设置订单对象中商品的信息
        //商品操作都在商品微服务---订单微服务远程调用商品微服务即可拿到商品信息。
        // 远程调用:http协议的restFul风格调用适合微服务，基于TCP协议的RPC调用适合SOA分布式
        //一定采用的为http协议:
        //（1）自己写代码完成http调用【httpclient】微信支付 ---适合调用第三方网址。
        //（2）spring提高了一个工具类RestTemplate，该类也是基于http协议完成的调用

        //因为查询的信息返回的是CommonResult的数据，因此接的话要接与之对应的数据

//      根据服务名获取对应的所有实例对象
        List<ServiceInstance> product = discoveryClient.getInstances("product");
//      获取第一个实例对象
//        ServiceInstance serviceInstance = product.get(0);
//      负载均衡：（实例对象不止一个）
//      获取实例对象(随机获取)
//      获取指定范围的随机数：Math.random*product.size() -->返回的是double数据，需要转为int    或者  new Random().nextInt(product.size())  -->直接用
        ServiceInstance serviceInstance = product.get(new Random().nextInt(product.size()));
        System.out.println("serviceInstance:"+serviceInstance.toString());
//      获取端口号
        int port = serviceInstance.getPort();
        System.out.println("port:"+port);
//      获取ip地址
        String host = serviceInstance.getHost();
        System.out.println("host:"+host);
//      null
        String instanceId = serviceInstance.getInstanceId();
        System.out.println("instanceId:"+instanceId);
//      获取服务名称
        String serviceId = serviceInstance.getServiceId();
        System.out.println("serviceId:"+serviceId);
//      获取服务信息
        /*
            metadata:{nacos.instanceId=192.168.137.1#8081#DEFAULT#DEFAULT_GROUP@@product,
            nacos.weight=1.0, nacos.cluster=DEFAULT, nacos.ephemeral=true,
            nacos.healthy=true, preserved.register.source=SPRING_CLOUD}
         */
        Map<String, String> metadata = serviceInstance.getMetadata();
        System.out.println("metadata:"+metadata);
//      null
        String scheme = serviceInstance.getScheme();
        System.out.println("scheme:"+scheme);
//      http://192.168.137.1:8081  -->获取的信息
        URI uri = serviceInstance.getUri();
        System.out.println("uri:"+uri);
//      获取实例对象的http+ip+port
//      http://192.168.137.1:8081  -->获取的信息,以string类型
        String s = uri.toString();
        System.out.println("s:"+s);

        CommonResult forObject = restTemplate.getForObject(s+"/product/selects/" + pid, CommonResult.class);
        System.out.println("product:"+forObject);

        //返回的数据都在data中存放着，需要获取出来
        Object data = forObject.getData();
        //将Object数据转换成JSON数据
        JSONObject jsonObject = JSONObject.fromObject(forObject.getData());
        //在将JSON数据转换成Product类型的数据
        Product o = (Product) jsonObject.toBean(jsonObject, Product.class);

        order.setPid(o.getPid());
        order.setPname(o.getPname());
        order.setPprice(o.getPprice());

        int inserts = orderService.inserts(order);
        if(inserts!=0){
            return "下单成功";
        }
        return "下单失败";
    }

}

OrderController01：

根据服务名发送服务请求获取信息

package com.order.controller;

import com.order.service.OrderService;
import com.sal.entity.Order;
import com.sal.entity.Product;
import com.sal.until.CommonResult;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
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;
import org.springframework.web.client.RestTemplate;

import java.net.URI;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
 * @Author bian
 * @Date 2022/8/18 20:04
 * @PackageName:com.order.controller
 * @ClassName: OrderController
 * @Description: TODO
 * @Version 1.0
 */
@RestController
@RequestMapping("order")
public class OrderController01 {

    @Autowired
    private OrderService orderService;

//  spring提供的一个工具类，该类可以从注册中心获取微服务信息
    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("inserts/{pid}/{num}")
    public String inserts(@PathVariable Integer pid,@PathVariable Integer num){
        Order order = new Order();
        order.setNumber(num);
        //用户的信息可以根据token从redis中获取用户信息
        order.setUid(1);
        order.setUsername("张三");

        //需要设置订单对象中商品的信息
        //商品操作都在商品微服务---订单微服务远程调用商品微服务即可拿到商品信息。
        // 远程调用:http协议的restFul风格调用适合微服务，基于TCP协议的RPC调用适合SOA分布式
        //一定采用的为http协议:
        //（1）自己写代码完成http调用【httpclient】微信支付 ---适合调用第三方网址。
        //（2）spring提高了一个工具类RestTemplate，该类也是基于http协议完成的调用

        //因为查询的信息返回的是CommonResult的数据，因此接的话要接与之对应的数据

//      根据服务名获取对应的所有实例对象
        List<ServiceInstance> product = discoveryClient.getInstances("product");
//      获取第一个实例对象
//        ServiceInstance serviceInstance = product.get(0);
//      负载均衡：（实例对象不止一个）
//      获取实例对象(随机获取)
//      获取指定范围的随机数：Math.random*product.size() -->返回的是double数据，需要转为int    或者  new Random().nextInt(product.size())  -->直接用
        ServiceInstance serviceInstance = product.get(new Random().nextInt(product.size()));
        System.out.println("serviceInstance:"+serviceInstance.toString());
//      获取端口号
        int port = serviceInstance.getPort();
        System.out.println("port:"+port);
//      获取ip地址
        String host = serviceInstance.getHost();
        System.out.println("host:"+host);
//      null
        String instanceId = serviceInstance.getInstanceId();
        System.out.println("instanceId:"+instanceId);
//      获取服务名称
        String serviceId = serviceInstance.getServiceId();
        System.out.println("serviceId:"+serviceId);
//      获取服务信息
        /*
            metadata:{nacos.instanceId=192.168.137.1#8081#DEFAULT#DEFAULT_GROUP@@product,
            nacos.weight=1.0, nacos.cluster=DEFAULT, nacos.ephemeral=true,
            nacos.healthy=true, preserved.register.source=SPRING_CLOUD}
         */
        Map<String, String> metadata = serviceInstance.getMetadata();
        System.out.println("metadata:"+metadata);
//      null
        String scheme = serviceInstance.getScheme();
        System.out.println("scheme:"+scheme);
//      http://192.168.137.1:8081  -->获取的信息
        URI uri = serviceInstance.getUri();
        System.out.println("uri:"+uri);
//      获取实例对象的http+ip+port
//      http://192.168.137.1:8081  -->获取的信息,以string类型
        String s = uri.toString();
//        System.out.println("s:"+s);

//      restTemplate调用必须 http://服务提供者的名称/服务提供资源路径   --> 默认使用的是轮询模式(一个一个的执行)
        CommonResult forObject = restTemplate.getForObject("http://product/product/selects/" + pid, CommonResult.class);
//      步骤：
        /*
            基于Ribbon实现负载均衡  --组件
                是Netflix发布的一个负载均衡器，在SpringCloud中，nacos一般配合着Ribbon使用,Ribbon提供了客户端给负载均衡的功能

             实现：
                1.在RestTemplate获取方法上的@LoadBalanced注解  使用Ribbon完成负载均衡
                2.修改RestTemplate调用代码  http://服务名称/资源路径
         */

        System.out.println("product:"+forObject);

        //返回的数据都在data中存放着，需要获取出来
        Object data = forObject.getData();
        //将Object数据转换成JSON数据
        JSONObject jsonObject = JSONObject.fromObject(forObject.getData());
        //在将JSON数据转换成Product类型的数据
        Product o = (Product) jsonObject.toBean(jsonObject, Product.class);

        order.setPid(o.getPid());
        order.setPname(o.getPname());
        order.setPprice(o.getPprice());

        int inserts = orderService.inserts(order);
        if(inserts!=0){
            return "下单成功";
        }
        return "下单失败";
    }

}

OrderController2:

之：ProductFeign：

package com.order.feign;

import com.sal.until.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * @Author bian
 * @Date 2022/8/20 17:22
 * @PackageName:com.order.feign
 * @ClassName: ProductFeign
 * @Description: TODO
 * @Version 1.0
 */
@FeignClient(value = "product")
public interface ProductFeign {

    @GetMapping("product/selects/{ids}")
    CommonResult selects(@PathVariable Integer ids);

}

 从openfeign中调用服务获取所要获取信息的接口：

<!--        openfeign依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

package com.order.controller;

import com.order.feign.ProductFeign;
import com.order.service.OrderService;
import com.sal.entity.Order;
import com.sal.entity.Product;
import com.sal.until.CommonResult;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.context.config.annotation.RefreshScope;
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;
import org.springframework.web.client.RestTemplate;

/**
 * @Author bian
 * @Date 2022/8/18 20:04
 * @PackageName:com.order.controller
 * @ClassName: OrderController
 * @Description: TODO
 * @Version 1.0
 */
@RestController
@RequestMapping("order")
//实时刷新读取配置 --》 读取的为自定义的配置信息，像端口一类的不可更改,只能改自己定义的属性，之后就会自动刷新重新获取自己定义的属性中的值
@RefreshScope
public class OrderController02 {

    @Autowired
    private OrderService orderService;

//  spring提供的一个工具类，该类可以从注册中心获取微服务信息
    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private ProductFeign productFeign;

    @Autowired
    private RestTemplate restTemplate;

    @Value("${student.name}")
    private String name;

    @GetMapping("getOrder")
    public String getOrder(){
        return "姓名："+name;
    }

    @GetMapping("inserts/{pid}/{num}")
    public String inserts(@PathVariable Integer pid,@PathVariable Integer num){
        Order order = new Order();
        order.setNumber(num);
        //用户的信息可以根据token从redis中获取用户信息
        order.setUid(1);
        order.setUsername("张三");

        //需要设置订单对象中商品的信息
        //商品操作都在商品微服务---订单微服务远程调用商品微服务即可拿到商品信息。
        // 远程调用:http协议的restFul风格调用适合微服务，基于TCP协议的RPC调用适合SOA分布式
        //一定采用的为http协议:
        //（1）自己写代码完成http调用【httpclient】微信支付 ---适合调用第三方网址。
        //（2）spring提高了一个工具类RestTemplate，该类也是基于http协议完成的调用

        //因为查询的信息返回的是CommonResult的数据，因此接的话要接与之对应的数据

//      根据服务名获取对应的所有实例对象
//        List<ServiceInstance> product = discoveryClient.getInstances("product");

//      获取第一个实例对象
//        ServiceInstance serviceInstance = product.get(0);
//      负载均衡：（实例对象不止一个）
//      获取实例对象(随机获取)
//      获取指定范围的随机数：Math.random*product.size() -->返回的是double数据，需要转为int    或者  new Random().nextInt(product.size())  -->直接用
//        ServiceInstance serviceInstance = product.get(new Random().nextInt(product.size()));
//        System.out.println("serviceInstance:"+serviceInstance.toString());
//      获取端口号
//        int port = serviceInstance.getPort();
//        System.out.println("port:"+port);
//      获取ip地址
//        String host = serviceInstance.getHost();
//        System.out.println("host:"+host);
//      null
//        String instanceId = serviceInstance.getInstanceId();
//        System.out.println("instanceId:"+instanceId);
//      获取服务名称
//        String serviceId = serviceInstance.getServiceId();
//        System.out.println("serviceId:"+serviceId);
//      获取服务信息
        /*
            metadata:{nacos.instanceId=192.168.137.1#8081#DEFAULT#DEFAULT_GROUP@@product,
            nacos.weight=1.0, nacos.cluster=DEFAULT, nacos.ephemeral=true,
            nacos.healthy=true, preserved.register.source=SPRING_CLOUD}
         */
//        Map<String, String> metadata = serviceInstance.getMetadata();
//        System.out.println("metadata:"+metadata);
//      null
//        String scheme = serviceInstance.getScheme();
//        System.out.println("scheme:"+scheme);
//      http://192.168.137.1:8081  -->获取的信息
//        URI uri = serviceInstance.getUri();
//        System.out.println("uri:"+uri);
//      获取实例对象的http+ip+port
//      http://192.168.137.1:8081  -->获取的信息,以string类型
//        String s = uri.toString();
//        System.out.println("s:"+s);

        CommonResult forObject = productFeign.selects(pid);

//      restTemplate调用必须 http://服务提供者的名称/服务提供资源路径   --> 默认使用的是轮询模式(一个一个的执行)
//        CommonResult forObject = restTemplate.getForObject("http://product/product/selects/" + pid, CommonResult.class);
//      步骤：
        /*
            基于Ribbon实现负载均衡  --组件
                是Netflix发布的一个负载均衡器，在SpringCloud中，nacos一般配合着Ribbon使用,Ribbon提供了客户端给负载均衡的功能

             实现：
                1.在RestTemplate获取方法上的@LoadBalanced注解  使用Ribbon完成负载均衡
                2.修改RestTemplate调用代码  http://服务名称/资源路径
         */

        System.out.println("product:"+forObject);

        //返回的数据都在data中存放着，需要获取出来
        Object data = forObject.getData();
        //将Object数据转换成JSON数据
        JSONObject jsonObject = JSONObject.fromObject(forObject.getData());
        //在将JSON数据转换成Product类型的数据
        Product o = (Product) jsonObject.toBean(jsonObject, Product.class);

        order.setPid(o.getPid());
        order.setPname(o.getPname());
        order.setPprice(o.getPprice());

        int inserts = orderService.inserts(order);
        if(inserts!=0){
            return "下单成功";
        }
        return "下单失败";
    }

}

server：

OrderService：

package com.order.service;


import com.sal.entity.Order;

/**
 * @Author bian
 * @Date 2022/8/18 20:03
 * @PackageName:com.order.service
 * @ClassName: OrderService
 * @Description: TODO
 * @Version 1.0
 */
public interface OrderService {

    int inserts(Order order);
}

impl：

OrderServiceImpl：

package com.order.service.impl;

import com.order.dao.OrderMapper;
import com.order.service.OrderService;
import com.sal.entity.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @Author bian
 * @Date 2022/8/18 20:04
 * @PackageName:com.order.service.impl
 * @ClassName: OrderServiceImpl
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Override
    public int inserts(Order order) {
        return orderMapper.insert(order);
    }
}

dao：

OrderMapper：

package com.order.dao;


import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sal.entity.Order;
import org.apache.ibatis.annotations.Mapper;

/**
 * @Author bian
 * @Date 2022/8/18 20:03
 * @PackageName:com.order.dao
 * @ClassName: OrderMapper
 * @Description: TODO
 * @Version 1.0
 */
@Mapper
public interface OrderMapper extends BaseMapper<Order> {
}

启动类：

OrderApp：

package com.order;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * @Author bian
 * @Date 2022/8/18 18:07
 * @PackageName:com.sal.produce
 * @ClassName: ProductApp
 * @Description: TODO
 * @Version 1.0
 */
//启动类
@SpringBootApplication
//开启feign注解
@EnableFeignClients
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class,args);
    }

    @Bean
    //ribbon借助RestTemplate完成负载均衡
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

配置类：

#为了以后配置集群，设定接口为8080~~8099之间
server.port=8082

#sql配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springcould?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=123456

#sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl


#指定微服务名称
spring.application.name=order

#指定服务中心接口  默认接口是8848 我这是后面配置的负载均衡配置了两个备用接口
spring.cloud.nacos.discovery.server-addr=localhost:82