乐趣区

关于intellij-idea:SpringClub01基础建设

jiezi

一、SpringClub

1. spring cloud 介绍

spring cloud 是一系列框架的汇合。它利用 spring boot 的开发便利性奇妙地简化了分布式系统基础设施的开发，如服务发现注册、配置核心、音讯总线、负载平衡、断路器、数据监控等，都能够用 spring boot 的开发格调做到一键启动和部署。spring cloud 并没有反复制作轮子，它只是将目前各家公司开发的比拟成熟、经得起理论考验的服务框架组合起来，通过 spring boot 格调进行再封装屏蔽掉了简单的配置和实现原理，最终给开发者留出了一套简略易懂、易部署和易保护的分布式系统开发工具包。
spring cloud 对于中小型互联网公司来说是一种福音，因为这类公司往往没有实力或者没有足够的资金投入去开发本人的分布式系统基础设施，应用 spring cloud 一站式解决方案能在从容应对业务倒退的同时大大减少开发成本。同时，随着近几年微服务架构和 docker 容器概念的火爆，也会让 spring cloud 在将来越来越“云”化的软件开发格调中立有一席之地，尤其是在目前形形色色的分布式解决方案中提供了标准化的、一站式的技术计划，意义可能会堪比当年 servlet 标准的诞生，无效推动服务端软件系统技术水平的提高。

2. spring cloud 技术组成

  • eureka
    微服务治理，服务注册和发现
  • ribbon
    负载平衡、申请重试
  • hystrix
    断路器，服务降级、熔断
  • feign
    ribbon + hystrix 集成，并提供申明式客户端
  • hystrix dashboard 和 turbine
    hystrix 数据监控
  • zuul
    API 网关，提供微服务的对立入口，并提供对立的权限验证
  • config
    配置核心
  • bus
    音讯总线, 配置刷新
  • sleuth+zipkin
    链路跟踪

3. Spring Cloud 比照 Dubbo

  • Dubbo

    • Dubbo 只是一个近程调用 (RPC) 框架
    • 默认基于长连贯, 反对多种序列化格局

  • Spring Cloud

    • 框架集
    • 提供了一整套微服务解决方案(全家桶)
    • 基于 http 调用, Rest API

二、业务服务

  • 商品服务 item service，端口 8001
  • 用户服务 user service，端口 8101
  • 订单服务 order service，端口 8201

1. 创立 commons 通用我的项目

1.1 新建 maven 我的项目

1.2 编辑 pom.xml 文件

<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>cn.tedu</groupId>
    <artifactId>sp01-commons</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sp01-commons</name>
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-parameter-names</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jdk8</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-jsr310</artifactId>
            <version>2.9.8</version>
        </dependency>
        <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-guava</artifactId>
            <version>2.9.8</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.3 创立 pojo 类

1.3.1 Item
package cn.tedu.sp01.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Item {
    private Integer id;
    private String name;
    private Integer number;
}
1.3.2 User
package cn.tedu.sp01.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
}
1.3.3 Order
package cn.tedu.sp01.pojo;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order {
    private String id;
    private User user;
    private List<Item> items;
}

1.4 创立 service 类

1.4.1 ItemService
package cn.tedu.sp01.service;
import cn.tedu.sp01.pojo.Item;
import java.util.List;
public interface ItemService {
    // 获取订单的商品列表
 List<Item> getItems(String orderId);
    // 缩小商品库存
 void decreaseNumber(List<Item> items);
}
1.4.2 UserService
package cn.tedu.sp01.service;
import cn.tedu.sp01.pojo.User;
public interface UserService {
    // 获取用户
 User getUser(Integer userId);
    // 增加用户积分
 void addScore(Integer userId,Integer score);
}
1.4.3 OrderService
package cn.tedu.sp01.service;
import cn.tedu.sp01.pojo.Order;
public interface OrderService {
    // 获取订单
 Order getOrder(String orderId);
    // 增加订单
 void addOrder(Order order);
}

1.5 创立 util 类

1.5.1 CookieUtil
package cn.tedu.web.util;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class CookieUtil {
    /**
     * @param response
     * @param name
     * @param value
     * @param maxAge
     */
    public static void setCookie(HttpServletResponse response,
            String name, String value, String domain, String path, int maxAge) {Cookie cookie = new Cookie(name, value);
        if(domain != null) {cookie.setDomain(domain);
        }
        cookie.setPath(path);
        cookie.setMaxAge(maxAge);
        response.addCookie(cookie);
    }
    public static void setCookie(HttpServletResponse response, String name, String value, int maxAge) {setCookie(response, name, value, null, "/", maxAge);
    }
    public static void setCookie(HttpServletResponse response, String name, String value) {setCookie(response, name, value, null, "/", 3600);
    }
    public static void setCookie(HttpServletResponse response, String name) {setCookie(response, name, "", null,"/", 3600);
    }
    /**
     * @param request
     * @param name
     * @return
     */
    public static String getCookie(HttpServletRequest request, String name) {
        String value = null;
        Cookie[] cookies = request.getCookies();
        if (null != cookies) {for (Cookie cookie : cookies) {if (cookie.getName().equals(name)) {value = cookie.getValue();
                }
            }
        }
        return value;
    }
    /**
     * @param response
     * @param name
     * @return
     */
    public static void removeCookie(HttpServletResponse response, String name, String domain, String path) {setCookie(response, name, "", domain, path, 0);
    }
}
1.5.2 #### JsonUtil
package cn.tedu.web.util;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Writer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.datatype.guava.GuavaModule;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class JsonUtil {
    private static ObjectMapper mapper;
    private static JsonInclude.Include DEFAULT_PROPERTY_INCLUSION = JsonInclude.Include.NON_DEFAULT;
    private static boolean IS_ENABLE_INDENT_OUTPUT = false;
    private static String CSV_DEFAULT_COLUMN_SEPARATOR = ",";
    static {
        try {initMapper();
            configPropertyInclusion();
            configIndentOutput();
            configCommon();} catch (Exception e) {log.error("jackson config error", e);
        }
    }
    private static void initMapper() {mapper = new ObjectMapper();
    }

    private static void configCommon() {config(mapper);
    }
    private static void configPropertyInclusion() {mapper.setSerializationInclusion(DEFAULT_PROPERTY_INCLUSION);
    }
    private static void configIndentOutput() {mapper.configure(SerializationFeature.INDENT_OUTPUT, IS_ENABLE_INDENT_OUTPUT);
    }
    private static void config(ObjectMapper objectMapper) {objectMapper.enable(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN);
        objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        objectMapper.enable(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY);
        objectMapper.enable(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY);
        objectMapper.enable(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS);
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        objectMapper.disable(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES);
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        objectMapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
        objectMapper.disable(JsonGenerator.Feature.ESCAPE_NON_ASCII);
        objectMapper.enable(JsonGenerator.Feature.IGNORE_UNKNOWN);
        objectMapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES);
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        objectMapper.enable(JsonParser.Feature.ALLOW_SINGLE_QUOTES);
        objectMapper.registerModule(new ParameterNamesModule());
        objectMapper.registerModule(new Jdk8Module());
        objectMapper.registerModule(new JavaTimeModule());
        objectMapper.registerModule(new GuavaModule());
    }
    public static void setSerializationInclusion(JsonInclude.Include inclusion) {
        DEFAULT_PROPERTY_INCLUSION = inclusion;
        configPropertyInclusion();}
    public static void setIndentOutput(boolean isEnable) {
        IS_ENABLE_INDENT_OUTPUT = isEnable;
        configIndentOutput();}
    public static <V> V from(URL url, Class<V> c) {
        try {return mapper.readValue(url, c);
        } catch (IOException e) {log.error("jackson from error, url: {}, type: {}", url.getPath(), c, e);
            return null;
        }
    }
    public static <V> V from(InputStream inputStream, Class<V> c) {
        try {return mapper.readValue(inputStream, c);
        } catch (IOException e) {log.error("jackson from error, type: {}", c, e);
            return null;
        }
    }
    public static <V> V from(File file, Class<V> c) {
        try {return mapper.readValue(file, c);
        } catch (IOException e) {log.error("jackson from error, file path: {}, type: {}", file.getPath(), c, e);
            return null;
        }
    }
    public static <V> V from(Object jsonObj, Class<V> c) {
        try {return mapper.readValue(jsonObj.toString(), c);
        } catch (IOException e) {log.error("jackson from error, json: {}, type: {}", jsonObj.toString(), c, e);
            return null;
        }
    }
    public static <V> V from(String json, Class<V> c) {
        try {return mapper.readValue(json, c);
        } catch (IOException e) {log.error("jackson from error, json: {}, type: {}", json, c, e);
            return null;
        }
    }
    public static <V> V from(URL url, TypeReference<V> type) {
        try {return mapper.readValue(url, type);
        } catch (IOException e) {log.error("jackson from error, url: {}, type: {}", url.getPath(), type, e);
            return null;
        }
    }
    public static <V> V from(InputStream inputStream, TypeReference<V> type) {
        try {return mapper.readValue(inputStream, type);
        } catch (IOException e) {log.error("jackson from error, type: {}", type, e);
            return null;
        }
    }
    public static <V> V from(File file, TypeReference<V> type) {
        try {return mapper.readValue(file, type);
        } catch (IOException e) {log.error("jackson from error, file path: {}, type: {}", file.getPath(), type, e);
            return null;
        }
    }
    public static <V> V from(Object jsonObj, TypeReference<V> type) {
        try {return mapper.readValue(jsonObj.toString(), type);
        } catch (IOException e) {log.error("jackson from error, json: {}, type: {}", jsonObj.toString(), type, e);
            return null;
        }
    }
    public static <V> V from(String json, TypeReference<V> type) {
        try {return mapper.readValue(json, type);
        } catch (IOException e) {log.error("jackson from error, json: {}, type: {}", json, type, e);
            return null;
        }
    }
    public static <V> String to(List<V> list) {
        try {return mapper.writeValueAsString(list);
        } catch (JsonProcessingException e) {log.error("jackson to error, obj: {}", list, e);
            return null;
        }
    }
    public static <V> String to(V v) {
        try {return mapper.writeValueAsString(v);
        } catch (JsonProcessingException e) {log.error("jackson to error, obj: {}", v, e);
            return null;
        }
    }
    public static <V> void toFile(String path, List<V> list) {try (Writer writer = new FileWriter(new File(path), true)) {mapper.writer().writeValues(writer).writeAll(list);
            writer.flush();} catch (Exception e) {log.error("jackson to file error, path: {}, list: {}", path, list, e);
        }
    }
    public static <V> void toFile(String path, V v) {try (Writer writer = new FileWriter(new File(path), true)) {mapper.writer().writeValues(writer).write(v);
            writer.flush();} catch (Exception e) {log.error("jackson to file error, path: {}, obj: {}", path, v, e);
        }
    }
    public static String getString(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).toString();} else {return null;}
        } catch (IOException e) {log.error("jackson get string error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static Integer getInt(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).intValue();} else {return null;}
        } catch (IOException e) {log.error("jackson get int error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static Long getLong(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).longValue();} else {return null;}
        } catch (IOException e) {log.error("jackson get long error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static Double getDouble(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).doubleValue();} else {return null;}
        } catch (IOException e) {log.error("jackson get double error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static BigInteger getBigInteger(String json, String key) {if (StringUtils.isEmpty(json)) {return new BigInteger(String.valueOf(0.00));
        }
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).bigIntegerValue();} else {return null;}
        } catch (IOException e) {log.error("jackson get biginteger error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static BigDecimal getBigDecimal(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).decimalValue();} else {return null;}
        } catch (IOException e) {log.error("jackson get bigdecimal error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static boolean getBoolean(String json, String key) {if (StringUtils.isEmpty(json)) {return false;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).booleanValue();} else {return false;}
        } catch (IOException e) {log.error("jackson get boolean error, json: {}, key: {}", json, key, e);
            return false;
        }
    }
    public static byte[] getByte(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        try {JsonNode node = mapper.readTree(json);
            if (null != node) {return node.get(key).binaryValue();} else {return null;}
        } catch (IOException e) {log.error("jackson get byte error, json: {}, key: {}", json, key, e);
            return null;
        }
    }
    public static <T> ArrayList<T> getList(String json, String key) {if (StringUtils.isEmpty(json)) {return null;}
        String string = getString(json, key);
        return from(string, new TypeReference<ArrayList<T>>() {});
    }
    public static <T> String add(String json, String key, T value) {
        try {JsonNode node = mapper.readTree(json);
            add(node, key, value);
            return node.toString();} catch (IOException e) {log.error("jackson add error, json: {}, key: {}, value: {}", json, key, value, e);
            return json;
        }
    }
    private static <T> void add(JsonNode jsonNode, String key, T value) {if (value instanceof String) {((ObjectNode) jsonNode).put(key, (String) value);
        } else if (value instanceof Short) {((ObjectNode) jsonNode).put(key, (Short) value);
        } else if (value instanceof Integer) {((ObjectNode) jsonNode).put(key, (Integer) value);
        } else if (value instanceof Long) {((ObjectNode) jsonNode).put(key, (Long) value);
        } else if (value instanceof Float) {((ObjectNode) jsonNode).put(key, (Float) value);
        } else if (value instanceof Double) {((ObjectNode) jsonNode).put(key, (Double) value);
        } else if (value instanceof BigDecimal) {((ObjectNode) jsonNode).put(key, (BigDecimal) value);
        } else if (value instanceof BigInteger) {((ObjectNode) jsonNode).put(key, (BigInteger) value);
        } else if (value instanceof Boolean) {((ObjectNode) jsonNode).put(key, (Boolean) value);
        } else if (value instanceof byte[]) {((ObjectNode) jsonNode).put(key, (byte[]) value);
        } else {((ObjectNode) jsonNode).put(key, to(value));
        }
    }
    public static String remove(String json, String key) {
        try {JsonNode node = mapper.readTree(json);
            ((ObjectNode) node).remove(key);
            return node.toString();} catch (IOException e) {log.error("jackson remove error, json: {}, key: {}", json, key, e);
            return json;
        }
    }
    public static <T> String update(String json, String key, T value) {
        try {JsonNode node = mapper.readTree(json);
            ((ObjectNode) node).remove(key);
            add(node, key, value);
            return node.toString();} catch (IOException e) {log.error("jackson update error, json: {}, key: {}, value: {}", json, key, value, e);
            return json;
        }
    }
    public static String format(String json) {
        try {JsonNode node = mapper.readTree(json);
            return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(node);
        } catch (IOException e) {log.error("jackson format json error, json: {}", json, e);
            return json;
        }
    }
    public static boolean isJson(String json) {
        try {mapper.readTree(json);
            return true;
        } catch (Exception e) {log.error("jackson check json error, json: {}", json, e);
            return false;
        }
    }
    private static InputStream getResourceStream(String name) {return JsonUtil.class.getClassLoader().getResourceAsStream(name);
    }
    private static InputStreamReader getResourceReader(InputStream inputStream) {if (null == inputStream) {return null;}
        return new InputStreamReader(inputStream, StandardCharsets.UTF_8);
    }
}
1.5.3 #### JsonResult
package cn.tedu.web.util;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class JsonResult<T> {
    /** 胜利 */
    public static final int SUCCESS = 200;
    /** 没有登录 */
    public static final int NOT_LOGIN = 400;
    /** 产生异样 */
    public static final int EXCEPTION = 401;
    /** 零碎谬误 */
    public static final int SYS_ERROR = 402;
    /** 参数谬误 */
    public static final int PARAMS_ERROR = 403;
    /** 不反对或曾经废除 */
    public static final int NOT_SUPPORTED = 410;
    /** AuthCode 谬误 */
    public static final int INVALID_AUTHCODE = 444;
    /** 太频繁的调用 */
    public static final int TOO_FREQUENT = 445;
    /** 未知的谬误 */
    public static final int UNKNOWN_ERROR = 499;
    private int code;
    private String msg;
    private T data;
    public static JsonResult build() {return new JsonResult();
    }
    public static JsonResult build(int code) {return new JsonResult().code(code);
    }
    public static JsonResult build(int code, String msg) {return new JsonResult<String>().code(code).msg(msg);
    }
    public static <T> JsonResult<T> build(int code, T data) {return new JsonResult<T>().code(code).data(data);
    }
    public static <T> JsonResult<T> build(int code, String msg, T data) {return new JsonResult<T>().code(code).msg(msg).data(data);
    }
    public JsonResult<T> code(int code) {
        this.code = code;
        return this;
    }
    public JsonResult<T> msg(String msg) {
        this.msg = msg;
        return this;
    }
    public JsonResult<T> data(T data) {
        this.data = data;
        return this;
    }
    public static JsonResult ok() {return build(SUCCESS);
    }
    public static JsonResult ok(String msg) {return build(SUCCESS, msg);
    }
    public static <T> JsonResult<T> ok(T data) {return build(SUCCESS, data);
    }
    public static JsonResult err() {return build(EXCEPTION);
    }
    public static JsonResult err(String msg) {return build(EXCEPTION, msg);
    }
    @Override
    public String toString() {return JsonUtil.to(this);
    }
}

2. 创立 item service 商品服务项目

2.1 创立 sp02-itemservice 我的项目

2.2 编辑 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.3.7.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
 </parent>
   <groupId>com.tedu</groupId>
   <artifactId>sp02-itemservice</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>sp02-itemservice</name>
   <description>Demo project for Spring Boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
      <dependency>
         <groupId>com.tedu</groupId>
         <artifactId>sp01-commons</artifactId>
         <version>1.0-SNAPSHOT</version>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

2.3 批改 application.yml

首先将 application.propertie 改为 application.yml

# 利用名：作为 "服务 id"，注册到注册核心
spring:
  application:
    name: item-service
# 端口号别离为：8001, 8101, 8201
service:
  port: 8001

2.4 编辑 ItemServiceImpl

import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.service.ItemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
@Slf4j
public class ItemServiceImpl implements ItemService {
    // 依据订单 id 获取商品列表
 @Override
 public List<Item> getItems(String orderId) {ArrayList<Item> list = new ArrayList<Item>();
        list.add(new Item(1, "商品 1",1));
        list.add(new Item(2, "商品 2",2));
        list.add(new Item(3, "商品 3",3));
        list.add(new Item(4, "商品 4",4));
        list.add(new Item(5, "商品 5",5));
        return list;
    }
    // 缩小商品库存
 @Override
 public void decreaseNumber(List<Item> items) {for (Item item:items){log.info("缩小商品库存:"+item);
        }
    }
}

2.5 编辑 ItemController

package com.tedu.sp02.item.controller;
import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.service.ItemService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@Slf4j
public class ItemController {
    @Autowired
 private ItemService itemService;
    // 注入端口号：为了配置多台集群服务器
 @Value("${server.port}")
    private int port;
    @GetMapping("/{orderId}")
    public JsonResult<List<Item>>getItems(@PathVariable String orderId){log.info("orderId"+orderId+",port+"+port);
        List<Item> items= itemService.getItems(orderId);
        return JsonResult.ok().msg("port="+port).data(items);
    }
    // 只解决 post 申请
 //@RequestBody: 残缺承受申请协定体数据
 @PostMapping("/decreaseNumber")
    public JsonResult<?> decreaseNumber(@RequestBody List<Item> items){itemService.decreaseNumber(items);
        return JsonResult.ok().msg("缩小商品库存胜利");
    }
}

2.6 Spring MVC 接管参数的注解阐明

2.7 拜访测试

依据 orderid，查问商品
http://localhost:8001/35
缩小商品库存
http://localhost:8001/decreaseNumber
应用 postman，POST 发送以下格局数据：
[{"id":1, "name":"abc", "number":23},{"id":2, "name":"def", "number":11}]

3. userservice 用户服务我的项目

3.1 创立 sp03-userservice 我的项目

3.2 编辑 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.3.7.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
 </parent>
   <groupId>com.tedu</groupId>
   <artifactId>sp03-userservice</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>sp03-userservice</name>
   <description>Demo project for Spring Boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>com.tedu</groupId>
         <artifactId>sp01-commons</artifactId>
         <version>1.0-SNAPSHOT</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

3.3 批改 application.yml

首先将 application.propertie 改为 application.yml

# 利用名：作为 "服务 id"，注册到注册核心
spring:
  application:
    name: user-service
#端口号
server:
  port: 8101
#自定义配置属性
#配置三个测试用的用户数据
sp:
  user-service:
    users: "[{"id":7,"username":"abc","password":"123"},{"id":8,"username":"def","password":"456"},{"id":9,"username":"ghi","password":"789"}]"

3.4 编辑 UserServiceImpl

package com.tedu.sp03.service;
import cn.tedu.sp01.pojo.User;
import cn.tedu.sp01.service.UserService;
import cn.tedu.web.util.JsonUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.List;
@Slf4j
@Service
public class UserServiceImpl implements UserService {@Value("${sp.user-service.users}")
    private String userJson;
    @Override
 public User getUser(Integer userId) {log.info("获取用户，userId="+userId);
        //userJson 转成 List<User> //new TypeReference<List<User>>(){} 只是为了应用匿名外部类继承的语法格局, 写两头的 List<User> 类型
 //
 List<User> users=JsonUtil.from(userJson, new TypeReference<List<User>>(){});
        for (User user:users){if (user.getId().equals(userId)){return user;}
        }
        // 找不到用户，也返回一个假的用户数据
 return new User(userId,"用户名"+userId,"明码"+userId);
    }
    @Override
 public void addScore(Integer userId, Integer score) {log.info("减少用户积分，userId="+userId+",score="+score);
    }
}

3.5 编辑 UserController

package com.tedu.sp03.controller;
import cn.tedu.sp01.pojo.User;
import cn.tedu.sp01.service.UserService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Slf4j
public class UserController {
    @Autowired
 private UserService userService;
    @GetMapping("/{UserId}")
    public JsonResult<User> getUser(@PathVariable Integer userId){User user= userService.getUser(userId);
        return JsonResult.ok(user);
    }
    @GetMapping("/{userIs}/score")
    public JsonResult<?> addScore(@PathVariable Integer userId,Integer score){userService.addScore(userId,score);
        return JsonResult.ok().msg("用户积分增加胜利");
    }
}

3.6 测试

依据 userid 查问用户信息
http://localhost:8101/7
依据 userid，为用户减少积分
http://localhost:8101/7/score?score=100

4. order service 订单服务项目

4.1 创立 sp04-orderservice 我的项目

4.2 编辑 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.3.7.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
 </parent>
   <groupId>com.tedu</groupId>
   <artifactId>sp04-orderservice</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>sp04-orderservice</name>
   <description>Demo project for Spring Boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
         <groupId>com.tedu</groupId>
         <artifactId>sp01-commons</artifactId>
         <version>1.0-SNAPSHOT</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
         <exclusions>
            <exclusion>
               <groupId>org.junit.vintage</groupId>
               <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
         </exclusions>
      </dependency>
   </dependencies>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

3.3 批改 application.yml

首先将 application.propertie 改为 application.yml

# 利用名：作为 "服务 id"，注册到注册核心
spring:
  application:
  name: order-service
#端口号
server:
  port: 8201

4.4 编辑 OrderServiceImpl

package com.tedu.sp04.service;
import cn.tedu.sp01.pojo.Order;
import cn.tedu.sp01.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Override
 public Order getOrder(String orderId) {log.info("获取订单,orderId="+orderId);
        // 假订单数据
 Order order=new Order();
        order.setId(orderId);
        //TODO: 近程调用用户，获取用户信息
 //order.setUser(用户数据);
 //TODO: 近程调用商品，获取商品列表
 //order.setItems(商品列表);
 return null;
    }
    @Override
 public void addOrder(Order order) {log.info("增加订单:"+order);
        //TODO: 近程调用商品，缩小商品库存
 //TODO: 近程调用用户，增加用户积分
 }
}

4.5 编辑 OrderController

package com.tedu.sp04.controller;
import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.pojo.Order;
import cn.tedu.sp01.pojo.User;
import cn.tedu.sp01.service.OrderService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
@Slf4j
@RestController
public class OrderController {
    @Autowired
 private OrderService orderService;
    @GetMapping("/{orderId}")
    public JsonResult<Order> getOrder(@PathVariable String OrderId){Order order=orderService.getOrder(OrderId);
        return JsonResult.ok().data(order);
    }
    @GetMapping("/")
    public JsonResult<?> addOrder(){Order order=new Order();
        order.setId("123");
        order.setUser(new User(8,null,null));
        order.setItems(Arrays.asList(new Item[]{new Item(1,"商品 1",2),
                new Item(2,"商品 2",1),
                new Item(3,"商品 3",3),
                new Item(4,"商品 4",1),
                new Item(5,"商品 5",5),
        }));
        orderService.addOrder(order);
        return JsonResult.ok().msg("保留订单胜利");
    }
}

4.6 测试

依据 orderid，获取订单
http://localhost:8201/123abc
保留订单，察看控制台日志输入
[http://localhost:8201/](http://localhost:8201

退出移动版