Spring Cloud入门操作手册(Hoxton)

家有喜娟儿

已于 2022-03-25 23:28:45 修改

阅读量2.1k

点赞数

分类专栏：微服务架构文章标签： Spring Cloud入门

于 2022-03-23 12:50:27 首次发布

本文链接：https://blog.csdn.net/chengtengfei352/article/details/123683178

版权

微服务架构专栏收录该内容

4 篇文章 2 订阅

订阅专栏

一，spring cloud 介绍

spring cloud 是一系列框架的集合。

它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和部署。

spring cloud 并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过 spring boot 风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

spring cloud 对于中小型互联网公司来说是一种福音，因为这类公司往往没有实力或者没有足够的资金投入去开发自己的分布式系统基础设施，使用 spring cloud 一站式解决方案能在从容应对业务发展的同时大大减少开发成本。同时，随着近几年微服务架构和 docker 容器概念的火爆，也会让 spring cloud 在未来越来越“云”化的软件开发风格中立有一席之地，尤其是在目前五花八门的分布式解决方案中提供了标准化的、一站式的技术方案，意义可能会堪比当年 servlet 规范的诞生，有效推进服务端软件系统技术水平的进步。

二，spring cloud 技术组成

(1)、eureka
微服务治理，服务注册和发现

(2)、ribbon
负载均衡、请求重试

(3)、hystrix
断路器，服务降级、熔断

(4)、feign
ribbon + hystrix 集成，并提供声明式客户端

(5)、hystrix dashboard 和 turbine
hystrix 数据监控

(6)、zuul
API 网关，提供微服务的统一入口，并提供统一的权限验证

(7)、config
配置中心

(8)、bus
消息总线, 配置刷新

(9)、sleuth+zipkin
链路跟踪

Spring Cloud Netflix （核心组件）

注册中心
- Eureka
配置中心
- Spring cloud config
远程调用/负载均衡
- Feign
- Ribbon
系统容错、限流
- Hystrix
- 容错：
  - 容错的手段：降级
- 限流：
  - 限流的手段：熔断
数据监控
- Hystrix dashboard / Turbine
- 链路跟踪 Sleuth / Zipkin

三，Spring Cloud 与 Dubbo 对比

Dubbo
- Dubbo只是一个远程调用(RPC)框架
- 默认基于长连接,支持多种序列化格式
Spring Cloud
- 框架集
- 提供了一整套微服务解决方案(全家桶)
- 基于http调用, Rest API

四，spring cloud 项目实战

1、业务模块分析

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

2、commons 通用模块项目搭建

(1)、创建聚合项目子模块，采用maven默认骨架，并填写模块名称

(2)、导入如下POM配置文件内容

<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.20</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>

(3)、创建POJO实体类

Item商品类

package cn.tedu.pojo;

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

import java.io.Serializable;

/**
 * 商品信息
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Item implements Serializable {
    private Integer id;
    private String name;
    private Integer number;
}

User用户类

package cn.tedu.pojo;

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

import java.io.Serializable;

/**
 * 用户信息
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private Integer id;
    private String username;
    private String password;
}

Order订单类

package cn.tedu.pojo;

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

import java.io.Serializable;
import java.util.List;

/**
 * 订单信息
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order implements Serializable {
    private String id;
    private User user;
    private List<Item> items;
}

(4)、创建Service接口

ItemService商品信息业务层接口

package cn.tedu.service;

import cn.tedu.pojo.Item;

import java.util.List;

/**
 * 商品信息业务层接口
 *
 */
public interface ItemService {
    /**
     * 获取订单商品列表
     *
     * @param orderId
     * @return
     */
    List<Item> getItems(String orderId);

    /**
     * 下单时减少商品库存
     *
     *
     * @param list
     */
    void decreaseNumbers(List<Item> list);
}

UserService用户信息业务层接口

package cn.tedu.service;

import cn.tedu.pojo.User;

/**
 * 用户信息业务层接口
 *
 */
public interface UserService {
    /**
     * 获取用户信息
     *
     * @param id
     * @return
     */
    User getUser(Integer id);

    /**
     * 下订单时增加用户积分
     *
     * @param id
     * @param score
     */
    void addScore(Integer id, Integer score);
}

OrderService订单信息业务层接口

package cn.tedu.service;

import cn.tedu.pojo.Order;

/**
 * 订单信息业务层接口
 *
 */
public interface OrderService {
    /**
     * 获取订单信息
     *
     * @param orderId
     * @return
     */
    Order getOrder(String orderId);

    /**
     * 创建订单
     *
     * @param order
     */
    void addOrder(Order order);
}

(5)、创建Util工具类

CookieUtil 处理cookie信息工具类

package cn.tedu.web.util;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 处理cookie信息工具类
 *
 */
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);
    }

}

JsonUtil 处理json数据工具类

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;

/**
 * 处理json数据工具类
 *
 */
@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);
    }
}

JsonResult 响应信息工具类

package cn.tedu.web.util;

import lombok.Getter;
import lombok.Setter;

/**
 * 响应信息工具类
 *
 * @param <T>
 */
@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);
    }
}

3、item service 商品服务模块项目创建

(1)、创建聚合项目子模块，采用spring initializr，并填写模块名称

(2)、导入如下POM配置文件内容

要填加 sp01-commons 项目依赖

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
	

	<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>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        
	</dependencies>

</project>

(3)、修改配置文件，并添加服务名称和端口号

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: item-service

# 服务端口号(item8001,user8101,order8201)
server:
  port: 8001

(4)、主程序如下(默认代码不需要修改)

package cn.tedu.sp02;

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

@SpringBootApplication
public class Sp02ItemserviceApplication {

	public static void main(String[] args) {
		SpringApplication.run(Sp02ItemserviceApplication.class, args);
	}

}

(5)、创建商品信息业务层接口实现类(数据暂未从数据库查询)

package cn.tedu.sp02.service;

import cn.tedu.pojo.Item;
import cn.tedu.service.ItemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 商品信息业务层接口实现类
 *
 */
@Slf4j
@Service
public class ItemServiceImpl implements ItemService {

    /**
     * 获取订单商品列表
     *
     * @param orderId
     * @return
     */
    @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;
    }

    /**
     * 下单时减少商品库存
     *
     *
     * @param list
     */
    @Override
    public void decreaseNumbers(List<Item> list) {
        for(Item item : list) {
            log.info("减少库存 - "+item);
        }
    }
}

(6)、创建商品信息控制层

package cn.tedu.sp02.controller;

import cn.tedu.pojo.Item;
import cn.tedu.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;

/**
 * 商品信息控制层
 *
 */
@Slf4j
@RestController
public class ItemController {
    @Autowired
    private ItemService itemService;

    @Value("${server.port}")
    private int port;

    /**
     * 获取订单列表
     *
     * @param orderId
     * @return
     */
    @GetMapping("/{orderId}")
    public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
        log.info("server.port="+port+", orderId="+orderId);

        List<Item> items = itemService.getItems(orderId);
        return JsonResult.ok(items).msg("port="+port);
    }


    /**
     * 减少库存
     *
     * @param items
     * @return
     */
    @PostMapping("/decreaseNumber")
    public JsonResult decreaseNumber(@RequestBody List<Item> items) {
        itemService.decreaseNumbers(items);
        return JsonResult.ok();
    }
}

注意：

@RequestBody 完整的接收协议体数据

@RequestParam 接收表单提交的名值对参数 k1=v1&k2=v2&k3=v3

@PathVariable 接收路径参数

(7)、访问测试(postman测试)

4、user service 用户服务模块项目创建

(1)、创建聚合项目子模块，采用spring initializr，并填写模块名称

(2)、导入如下POM配置文件内容

要填加 sp01-commons 项目依赖

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <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>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

(3)、修改配置文件，并添加服务名称和端口号

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: user-service

# 服务端口号(item8001,user8101,order8201)
server:
  port: 8101

# Demo用户数据 [{7,xxx,xxx},{8,xxx,xxx},{9,xxx,xxx}]
sp:
  user-service:
    users: "[{\"id\":7, \"username\":\"abc\",\"password\":\"123\"},{\"id\":8, \"username\":\"def\",\"password\":\"456\"},{\"id\":9, \"username\":\"ghi\",\"password\":\"789\"}]"

(4)、主程序如下(默认代码不需要修改)

package cn.tedu.sp03;

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

@SpringBootApplication
public class Sp03UserserviceApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp03UserserviceApplication.class, args);
    }

}

(5)、创建用户信息业务层接口实现类(数据暂未从数据库查询)

package cn.tedu.sp03.service;

import cn.tedu.pojo.User;
import cn.tedu.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;

    /**
     * 获取用户信息
     *
     * @param id
     * @return
     */
    @Override
    public User getUser(Integer id) {
        log.info("users json string : "+userJson);
        List<User> list = JsonUtil.from(userJson, new TypeReference<List<User>>() {});
        for (User u : list) {
            if (u.getId().equals(id)) {
                return u;
            }
        }

        return new User(id, "name-"+id, "pwd-"+id);
    }

    /**
     * 下订单时增加用户积分
     *
     * @param id
     * @param score
     */
    @Override
    public void addScore(Integer id, Integer score) {
        // 这里增加积分
        log.info("user "+id+" - 增加积分 "+score);
    }
}

(6)、创建用户信息控制层

package cn.tedu.sp03.controller;

import cn.tedu.pojo.User;
import cn.tedu.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;

/**
 * 用户信息业控制层
 * 
 */
@Slf4j
@RestController
public class UserController {
    @Autowired
    private UserService userService;

    /**
     * 获取用户信息
     *
     * @param userId
     * @return
     */
    @GetMapping("/{userId}")
    public JsonResult<User> getUser(@PathVariable Integer userId) {
        log.info("get user, userId="+userId);
        User u = userService.getUser(userId);
        return JsonResult.ok(u);
    }

    /**
     * 增加用户积分
     *
     * @param userId
     * @param score
     * @return
     */
    @GetMapping("/{userId}/score")
    public JsonResult addScore(
            @PathVariable Integer userId, Integer score) {
        userService.addScore(userId, score);
        return JsonResult.ok();
    }
}

(7)、访问测试(IDEA中Rest测试)

5、order service 订单服务模块项目创建

(1)、创建聚合项目子模块，采用spring initializr，并填写模块名称

(2)、导入如下POM配置文件内容

要填加 sp01-commons 项目依赖

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <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>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

(3)、修改配置文件，并添加服务名称和端口号

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: order-service

# 服务端口号(item8001,user8101,order8201)
server:
  port: 8201

(4)、主程序如下(默认代码不需要修改)

package cn.tedu.sp04;

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

@SpringBootApplication
public class Sp04OrderserviceApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp04OrderserviceApplication.class, args);
    }

}

(5)、创建订单信息业务层接口实现类(数据暂未从数据库查询)

package cn.tedu.sp04.service;

import cn.tedu.pojo.Order;
import cn.tedu.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * 订单信息业务层接口实现类
 *
 */
@Slf4j
@Service
public class OrderServiceImpl implements OrderService {


    /**
     * 获取订单信息
     *
     * @param orderId
     * @return
     */
    @Override
    public Order getOrder(String orderId) {
        //TODO: 调用user-service获取用户信息
        //TODO: 调用item-service获取商品信息
        Order order = new Order();
        order.setId(orderId);
        return order;
    }


    /**
     * 创建订单
     * 
     * @param order
     */
    @Override
    public void addOrder(Order order) {
        //TODO: 调用item-service减少商品库存
        //TODO: 调用user-service增加用户积分
        log.info("保存订单："+order);
    }
}

(6)、创建订单信息控制层

package cn.tedu.sp04.controller;

import cn.tedu.pojo.Item;
import cn.tedu.pojo.Order;
import cn.tedu.pojo.User;
import cn.tedu.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;

    /**
     * 获取订单信息
     *
     * @param orderId
     * @return
     */
    @GetMapping("/{orderId}")
    public JsonResult<Order> getOrder(@PathVariable String orderId) {
        log.info("get order, id="+orderId);

        Order order = orderService.getOrder(orderId);
        return JsonResult.ok(order);
    }

    /**
     * 创建订单
     *
     * @return
     */
    @GetMapping("/")
    public JsonResult addOrder() {
        //模拟post提交的数据
        Order order = new Order();
        order.setId("123abc");
        order.setUser(new User(7,null,null));
        order.setItems(Arrays.asList(new Item[] {
                new Item(1,"aaa",2),
                new Item(2,"bbb",1),
                new Item(3,"ccc",3),
                new Item(4,"ddd",1),
                new Item(5,"eee",5),
        }));
        orderService.addOrder(order);
        return JsonResult.ok();
    }
}

(7)、访问测试(IDEA中Rest测试)

6、eureka server 注册服务模块创建

eureka注册中心

(1)、创建聚合项目子模块，采用spring initializr，并填写模块名称

(2)、导入如下POM配置文件内容

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sp05-eureka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sp05-eureka</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>2021.0.1</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

(3)、修改配置文件，并添加服务名称和端口号以及自我保护机制

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: eureka-server

# 服务端口号(2001,3001,4001,5001,6001)
server:
  port: 2001

# 注册服务配置
eureka:
  server:
    enable-self-preservation: false # 禁用自我保护模式
  instance:
    hostname: eureka1 # eureka 集群服务器之间，通过 hostname 来区分
  client:
    register-with-eureka: false # 不向自己注册服务
    fetch-registry: false # 不从自己拉取注册表

eureka 集群服务器之间，通过 hostname 来区分
eureka.server.enable-self-preservation

eureka 的自我保护状态：心跳失败的比例，在15分钟内是否超过85%，如果出现了超过的情况，Eureka Server会将当前的实例注册信息保护起来，同时提示一个警告，一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据。也就是不会注销任何微服务
eureka.client.register-with-eureka=false 不向自身注册
eureka.client.fetch-registry=false 不从自身拉取注册信息
eureka.instance.lease-expiration-duration-in-seconds 最后一次心跳后，间隔多久认定微服务不可用，默认90

eureka运行机制

客户端应用一次一次的反复注册，直到注册成功为止

拉取

客户端应用每隔30秒拉取一次注册表，来刷新本地缓存的注册列表

心跳

客户端应用每隔30秒发送一次心跳

服务器连续3次收不到一个模块的心跳，会删除它的注册信息

自我保护模式

由于网络故障，15分钟内85%服务器出现心跳异常，则会自动进入保护模式，即：所有信息都不会删除，等待网络恢复，待网络恢复后会自动退出保护模式，恢复至正常模式。

(4)、主程序如下，开启Eureka注册服务

添加 @EnableEurekaServer 注解，开启注册服务

package cn.tedu.sp05;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer
@SpringBootApplication
public class Sp05EurekaApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp05EurekaApplication.class, args);
    }

}

(5)、修改host文件，添加Eureka域名映射

打开”C:\Windows\System32\drivers\etc\hosts“ 文件，在其内部添加如下域名映射：

127.0.0.1       eureka1
127.0.0.1       eureka2

(6)、测试，浏览器内输入主机名称+端口号，即：http://eureka1:2001/

7、eureka client 服务提供者(调整，即：商品服务、用户服务、订单服务实现服务提供)

eureka注册中心

(1)、pom.xml添加eureka client依赖

item-service 商品服务、user-service 用户服务、order-service 订单服务均添加依赖如下：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

(2)、application.yml 添加eureka注册配置

item-service 商品服务、user-service 用户服务、order-service 订单服务均添加配置如下：

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka

eureka.instance.lease-renewal-interval-in-seconds ,心跳间隔时间，默认 30 秒
defaultZone ，默认位置，可以修改为具体地理位置，比如：beiJing, shangHai, shenZhen 等，表示 eureka 服务器的部署位置, 需要云服务器提供
eureka.client.registry-fetch-interval-seconds ,拉取注册信息间隔时间，默认 30 秒

(3)、主程序启用eureka客户端

@EnableEurekaClient

(4)、测试，浏览器内输入主机名称+端口号，即：http://eureka1:2001/

8、eureka 和 service 的高可用(以注册中心与商品服务的高可用为例)

eureka和item高可用

(1)、item-service 高可用

第一种设置端口号的方式，即：命令行来设置端口号

启动参数 --server.port 可以覆盖yml中的端口配置，即：

java -jar item.jar --server.port=8001
java -jar item.jar --server.port=8002

第二种设置端口号的方式，即：IDEA启动配置中来设置端口号，具体方式如下：

运行配置的下拉菜单 -- Edit Configuration
修改 program arguments ，添加参数：--server.port=8001
左边的商品启动配置，复制一份，改成：--server.port=8002

配置参数

item-service-8001

item-service-8002

启动测试

(2)、eureka-server高可用

添加两个服务器的 profile 配置文件(profile的配置会和主配置会合并，覆盖主配置)

创建application-eureka1.yml 配置文件，如下：

# 服务端口号
server:
  port: 2001

# 注册服务配置
eureka:
  instance:
    hostname: eureka1 # eureka 集群服务器之间，通过 hostname 来区分
  client:
    register-with-eureka: true # 互相注册服务
    fetch-registry: true # 互相拉取注册表
    service-url:
      defaultZone: http://eureka2:2002/eureka  #eureka1启动时向eureka2注册

创建application-eureka2.yml 配置文件，如下：

# 服务端口号
server:
  port: 2002

# 注册服务配置
eureka:
  instance:
    hostname: eureka2 # eureka 集群服务器之间，通过 hostname 来区分
  client:
    register-with-eureka: true # 互相注册服务
    fetch-registry: true # 互相拉取注册表
    service-url:
      defaultZone: http://eureka1:2001/eureka  #eureka2启动时向eureka1注册

配置启动参数(参考item-service 高可用配置)

运行配置的下拉菜单 -- Edit Configuration
修改 program arguments ，添加参数：--spring.profiles.active=eureka1
左边的商品启动配置，复制一份，改成：--spring.profiles.active=eureka2

启动测试

(3)、eureka客户端注册时，向两个服务器注册

修改以下微服务

sp02-itemservice
sp03-userservice
sp04-orderservice

eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

当一个 eureka 服务宕机时，仍可以连接另一个 eureka 服务

9、远程访问方式一--> feign 远程调用(以order-service订单服务为例)

注意：feign默认启用负载均衡和重试的功能

修改order-service订单信息服务

(1)、添加feign依赖，如下：

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

(2)、添加开启Feign注解，如下：

触发Feign自动配置，扫描远程调用接口，创建动态代理对象

@EnableFeignClients

(3)、定义远程调用接口，如下：

声明式客户端接口、远程调用，需要配置三部分：调用哪个模块、调用哪个路径、提交什么参数

注意：

@GetMapping 和 @PostMapping 注解说明：
在控制器类中，表示响应客户端的调用，而在远程调用接口中则表示向服务器发送调用

ItemClient 商品远程调用接口

package cn.tedu.sp04.feign;

import cn.tedu.pojo.Item;
import cn.tedu.web.util.JsonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.util.List;

/**
 * 商品远程调用接口
 * item-service 从注册表得到该模块的服务器地址列表
 */
@FeignClient("item-service")
public interface ItemClient {
    /**
     * 获取订单商品列表
     *
     * @param orderId
     * @return
     */
    @GetMapping("/{orderId}")
    JsonResult<List<Item>> getItems(@PathVariable("orderId") String orderId);

    /**
     * 减少商品库存
     * 通过Post请求则商品信息作为参数存放至请求体内
     * @param items
     * @return
     */
    @PostMapping("/decreaseNumber")
    JsonResult<?> decreaseNumber(@RequestBody List<Item> items);
}

UserClient 用户远程调用接口

package cn.tedu.sp04.feign;

import cn.tedu.pojo.User;
import cn.tedu.web.util.JsonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * 用户远程调用接口
 * user-service 从注册表得到该模块的服务器地址列表
 */
@FeignClient("user-service")
public interface UserClient {
    /**
     * 获取用户信息
     * 
     * @param userId
     * @return
     */
    @GetMapping("/{userId}")
    JsonResult<User> getUser(@PathVariable("userId") Integer userId);

    /**
     * 增加用户积分
     * 
     * @param userId
     * @param score
     * @return
     */
    @GetMapping("/{userId}/score")
    JsonResult<?> addScore(@PathVariable("userId") Integer userId, @RequestParam("score") Integer score);
}

(4)、完成远程调用(修改 orderServiceImpl 订单信息业务层接口实现类，完成待TODO的远程调用)，如下：

注入远程调用接口的依赖：ItemClient、UserClient

@Autowired
private ItemClient itemClient;

@Autowired
private UserClient userClient;

重新调整编辑getOrder 获取订单信息的方法

/**
 * 获取订单信息
 *
 * @param orderId
 * @return
 */
@Override
public Order getOrder(String orderId) {
    //调用user-service获取用户信息(userId应该是已经得到的登录用户Id)
    JsonResult<User> user = userClient.getUser(8);
    //调用item-service获取商品信息
    JsonResult<List<Item>> items = itemClient.getItems(orderId);

    Order order = new Order();
    order.setId(orderId);
    order.setUser(user.getData());
    order.setItems(items.getData());
    return order;
}

重新调整编辑addOrder 创建订单信息的方法

/**
 * 创建订单
 *
 * @param order
 */
@Override
public void addOrder(Order order) {
    //调用item-service减少商品库存
    itemClient.decreaseNumber(order.getItems());
    //调用user-service增加用户积分
    userClient.addScore(order.getUser().getId(),1000);
    log.info("保存订单："+order);
}

(5)、测试

10、远程访问方式二--> ribbon 服务消费者服务模块创建

服务消费者

ribbon 提供了负载均衡和重试功能, 它底层是使用 RestTemplate 进行 Rest api 调用

RestTemplate

RestTemplate 是SpringBoot提供的一个Rest远程调用工具

它的常用方法:

getForObject() - 执行get请求
postForObject() - 执行post请求

之前的系统结构是浏览器直接访问后台服务

直接访问

后面我们通过一个Demo项目演示 Spring Cloud 远程调用

Demo

下面我们先不使用ribbon, 单独使用RestTemplate来执行远程调用

(1)、创建聚合项目子模块，采用spring initializr，并填写模块名称

(2)、导入如下POM配置文件内容

要填加 sp01-commons 项目依赖

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sp06-ribbon</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sp06-ribbon</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.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.tedu</groupId>
            <artifactId>springboot1</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

(3)、修改配置文件，并添加服务名称和端口号

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: ribbon

# 服务端口号
server:
  port: 3001

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

(4)、主程序创建RestTemplate实例

RestTemplate 是用来调用其他微服务的工具类，封装了远程调用代码，提供了一组用于远程调用的模板方法，例如：getForObject()、postForObject() 等

package cn.tedu.sp06;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableEurekaClient
@SpringBootApplication
public class Sp06RibbonApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp06RibbonApplication.class, args);
    }


    /**
     * 创建 RestTemplate 实例，并存入 spring 容器
     *
     * @return
     */
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

(5)、创建远程调用控制层

package cn.tedu.sp06.controller;

import cn.tedu.pojo.Item;
import cn.tedu.pojo.Order;
import cn.tedu.pojo.User;
import cn.tedu.web.util.JsonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * 远程访问控制层
 *
 */
@RestController
public class RibbonController {
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 获取订单列表
     * 
     * @param orderId
     * @return
     */
    @GetMapping("/item-service/{orderId}")
    public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
        //向指定微服务地址发送 get 请求，并获得该服务的返回结果
        //{1} 占位符，用 orderId 填充
        return restTemplate.getForObject("http://localhost:8001/{1}", JsonResult.class, orderId);
    }

    /**
     * 减少库存
     * 
     * @param items
     * @return
     */
    @PostMapping("/item-service/decreaseNumber")
    public JsonResult decreaseNumber(@RequestBody List<Item> items) {
        //发送 post 请求
        return restTemplate.postForObject("http://localhost:8001/decreaseNumber", items, JsonResult.class);
    }

    /**
     * 获取用户信息
     * 
     * @param userId
     * @return
     */
    @GetMapping("/user-service/{userId}")
    public JsonResult<User> getUser(@PathVariable Integer userId) {
        return restTemplate.getForObject("http://localhost:8101/{1}", JsonResult.class, userId);
    }

    /**
     * 增加用户积分
     * 
     * @param userId
     * @param score
     * @return
     */
    @GetMapping("/user-service/{userId}/score")
    public JsonResult addScore(
            @PathVariable Integer userId, Integer score) {
        return restTemplate.getForObject("http://localhost:8101/{1}/score?score={2}", JsonResult.class, userId, score);
    }

    /**
     * 获取订单信息
     * 
     * @param orderId
     * @return
     */
    @GetMapping("/order-service/{orderId}")
    public JsonResult<Order> getOrder(@PathVariable String orderId) {
        return restTemplate.getForObject("http://localhost:8201/{1}", JsonResult.class, orderId);
    }

    /**
     * 创建订单
     * 
     * @return
     */
    @GetMapping("/order-service")
    public JsonResult addOrder() {
        return restTemplate.getForObject("http://localhost:8201/", JsonResult.class);
    }
}

(6)、测试

11、Ribbon负载均衡和重试

ribbon
Ribbon

Ribbon 负载均衡

负载均衡

(1)、添加 ribbon 起步依赖（可选，因为eureka 依赖中已经包含了 ribbon）

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

(2)、主程序中的RestTemplate 设置 @LoadBalanced

@LoadBalanced 负载均衡注解，会对 RestTemplate 实例进行封装，创建动态代理对象，并切入（AOP）负载均衡代码，把请求分发到集群中的服务器

/**
 * 创建 RestTemplate 实例，并存入 spring 容器
 *
 * @return
 */
@Bean
@LoadBalanced
public RestTemplate getRestTemplate() {
    return new RestTemplate();
}

(3)、访问路径设置为服务ID

package cn.tedu.sp06.controller;

import cn.tedu.pojo.Item;
import cn.tedu.pojo.Order;
import cn.tedu.pojo.User;
import cn.tedu.web.util.JsonResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * 远程访问控制层
 *
 */
@RestController
public class RibbonController {
    @Autowired
    private RestTemplate restTemplate;

    /**
     * 获取订单列表
     *
     * @param orderId
     * @return
     */
    @GetMapping("/item-service/{orderId}")
    public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
        //向指定微服务地址发送 get 请求，并获得该服务的返回结果
        //{1} 占位符，用 orderId 填充
        //return restTemplate.getForObject("http://localhost:8001/{1}", JsonResult.class, orderId);

        // 访问路径设置为服务ID
        return restTemplate.getForObject("http://item-service/{1}", JsonResult.class, orderId);
    }

    /**
     * 减少库存
     *
     * @param items
     * @return
     */
    @PostMapping("/item-service/decreaseNumber")
    public JsonResult decreaseNumber(@RequestBody List<Item> items) {
        //发送 post 请求
        //return restTemplate.postForObject("http://localhost:8001/decreaseNumber", items, JsonResult.class);

        // 访问路径设置为服务ID
        return restTemplate.postForObject("http://item-service/decreaseNumber", items, JsonResult.class);
    }

    /**
     * 获取用户信息
     *
     * @param userId
     * @return
     */
    @GetMapping("/user-service/{userId}")
    public JsonResult<User> getUser(@PathVariable Integer userId) {
        //return restTemplate.getForObject("http://localhost:8101/{1}", JsonResult.class, userId);

        // 访问路径设置为服务ID
        return restTemplate.getForObject("http://user-service/{1}", JsonResult.class, userId);
    }

    /**
     * 增加用户积分
     *
     * @param userId
     * @param score
     * @return
     */
    @GetMapping("/user-service/{userId}/score")
    public JsonResult addScore(
            @PathVariable Integer userId, Integer score) {
        //return restTemplate.getForObject("http://localhost:8101/{1}/score?score={2}", JsonResult.class, userId, score);

        // 访问路径设置为服务ID
        return restTemplate.getForObject("http://user-service/{1}/score?score={2}", JsonResult.class, userId, score);
    }

    /**
     * 获取订单信息
     *
     * @param orderId
     * @return
     */
    @GetMapping("/order-service/{orderId}")
    public JsonResult<Order> getOrder(@PathVariable String orderId) {
        //return restTemplate.getForObject("http://localhost:8201/{1}", JsonResult.class, orderId);

        // 访问路径设置为服务ID
        return restTemplate.getForObject("http://order-service/{1}", JsonResult.class, orderId);
    }

    /**
     * 创建订单
     *
     * @return
     */
    @GetMapping("/order-service")
    public JsonResult addOrder() {
        //return restTemplate.getForObject("http://localhost:8201/", JsonResult.class);

        // 访问路径设置为服务ID
        return restTemplate.getForObject("http://order-service/", JsonResult.class);
    }
}

(4)、测试

访问测试，ribbon 会把请求分发到 8001 和 8002 两个服务端口上

Ribbon 重试

(1)、pom.xml 添加 spring-retry 依赖

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

(2)、application.yml 配置 ribbon 重试

# 配置 ribbon 重试
ribbon:
  MaxAutoRetries : 1 # 默认为0 单台服务器没有重试
  MaxAutoRetriesNextServer: 2 # 默认为1 更换服务器更换一次后响应
  OkToRetryOnAllOperations: true

ConnectionTimeout
ReadTimeout
OkToRetryOnAllOperations=true 默认只对GET请求重试, 当设置为true时, 对POST等所有类型请求都重试
MaxAutoRetries 当前实例重试次数，尝试失败会更换下一个实例
MaxAutoRetriesNextServer 更换实例的次数

(3)、主程序设置 RestTemplate 的请求工厂的超时属性

/**
 * 创建 RestTemplate 实例，并存入 spring 容器
 *
 * @return
 */
@Bean
@LoadBalanced
public RestTemplate getRestTemplate() {
    //未启用超时，也不会触发重试
    // return new RestTemplate();

    // 启用超时
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();

    factory.setConnectTimeout(1000);
    factory.setReadTimeout(1000);

    return new RestTemplate(factory);
}

(4)、item-service 的 ItemController 添加延迟代码，以便测试 ribbon 的重试机制

package cn.tedu.sp02.controller;

import cn.tedu.pojo.Item;
import cn.tedu.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;
import java.util.Random;

/**
 * 商品信息控制层
 *
 */
@Slf4j
@RestController
public class ItemController {
    @Autowired
    private ItemService itemService;

    @Value("${server.port}")
    private int port;

    /**
     * 获取订单列表
     *
     * @param orderId
     * @return
     */
    @GetMapping("/{orderId}")
    public JsonResult<List<Item>> getItems(@PathVariable String orderId) throws InterruptedException {
        log.info("server.port="+port+", orderId="+orderId);

        // 设置延时
        if(Math.random()<0.6){
            long t = new Random().nextInt(5000);
            log.info("item-service-"+port+"-暂停："+t);
            Thread.sleep(t);
        }

        List<Item> items = itemService.getItems(orderId);
        return JsonResult.ok(items).msg("port="+port);
    }


    /**
     * 减少库存
     *
     * @param items
     * @return
     */
    @PostMapping("/decreaseNumber")
    public JsonResult decreaseNumber(@RequestBody List<Item> items) {
        itemService.decreaseNumbers(items);
        return JsonResult.ok();
    }
}

(5)、测试

通过 ribbon 访问 item-service，当超时，ribbon 会重试请求集群中其他服务器

重试测试

Ribbon的重试机制，在 feign 和 zuul 中进一步进行了封装，后续可以使用feign或zuul的重试机制

12、Zuul Api 网关

zuul 统一的调用接口
zuul 统一的权限校验
zuul 集成Ribbon
zuul 集成Hystrix

zuul

zuul 统一的调用接口

(1)、创建聚合项目子模块，采用spring initializr，并填写模块名称

(2)、导入如下POM配置文件内容

要填加 sp01-commons 项目依赖

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sp07-zuul</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sp07-zuul</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
    </dependencies>
</project>

(3)、修改配置文件，并添加服务名称和端口号以及路由规则

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: zuul

# 服务端口号
server:
  port: 4001

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

# zuul 路由参数配置
zuul:
  routes:
    item-service: /item-service/**
    user-service: /user-service/**
    order-service: /order-service/**

(4)、主程序添加启用网关注解

添加 @EnableZuulProxy 和 @EnableDiscoveryClient 注解

package cn.tedu.sp07;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@EnableZuulProxy
@EnableEurekaClient
@SpringBootApplication
public class Sp07ZuulApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp07ZuulApplication.class, args);
    }

}

(5)、测试

zuul 统一的权限校验

zuul过滤器

模拟登录

(1)、定义前置过滤器AccessFilter，继承ZuulFilter

(2)、按照规则实现抽象方法

(3)、添加@Compoment注解

Zuul自动配置，会在Spring容器中发现过滤器实例，完成自动配置，如下：

package cn.tedu.sp07.filter;

import javax.servlet.http.HttpServletRequest;

import com.ctc.wstx.util.StringUtil;
import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.stereotype.Component;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import cn.tedu.web.util.JsonResult;

/**
 * Zull过滤器
 *
 */
@Component
public class AccessFilter extends ZuulFilter {

    /**
     * 设置过滤器的类型 pre routing post error
     *
     * @return
     */
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE;
    }

    /**
     * 设置过滤器的序号
     *
     * @return
     */
    @Override
    public int filterOrder() {
        //该过滤器顺序要 > 6，才能得到 serviceid
        return FilterConstants.PRE_DECORATION_FILTER_ORDER+1;
    }

    /**
     * 判断当前请求是否需要执行下面的过滤代码
     *
     * @return
     */
    @Override
    public boolean shouldFilter() {
        // 对指定的serviceid过滤，如果要过滤所有服务，直接返回 true
        // 调用商品时执行权限判断，而调用用户或订单时不执行权限判断

        // 获取当前请求的上下文对象
        RequestContext ctx = RequestContext.getCurrentContext();

        // 从上下文对象中获取调用的 server id
        String serviceId = (String) ctx.get(FilterConstants.SERVICE_ID_KEY);

        // 权限判断(调用商品时执行权限判断，而调用用户或订单时不执行权限判断)
        if("item-service".equals(serviceId)) {
            return true;
        }

        return false;
    }

    /**
     * 过滤代码
     *
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        // 获取当前请求的上下文对象
        RequestContext ctx = RequestContext.getCurrentContext();

        // 上下文对象中获取request对象
        HttpServletRequest req = ctx.getRequest();

        // 用request对象获取jwt参数
        String jwt = req.getParameter("jwt");

        // 如果参数不存在则阻止继续调用，直接返回响应
        if (StringUtils.isBlank(jwt)) {
            // 此设置会阻止请求被路由到后台微服务
            ctx.setSendZuulResponse(false);

            // 向客户端的响应
            ctx.addZuulResponseHeader("Content-Type","application/json;charset=UTF-8");
            ctx.setResponseBody(JsonResult.err().code(JsonResult.NOT_LOGIN).toString());
        }

        // zuul过滤器返回的数据设计为以后扩展使用，
        // 目前该返回值没有被使用
        return null;
    }
}

(4)、测试

没有token参数不允许访问

有oken参数可以访问

zuul 集成Ribbon

负载均衡

zuul 已经集成了 ribbon，默认已经实现了负载均衡

重试

zuul 已经集成了 ribbon，默认未启用重试，原因是在最前面网关位置重试，会造成大量服务器压力翻倍，如若启用重试功能，则操作如下：

(1)、添加spring-retry依赖

(2)、配置文件内配置重试参数

# 配置 ribbon 重试参数
ribbon:
  ConnectTimeout: 1000
  ReadTimeout: 1000
  MaxAutoRetriesNextServer: 1
  MaxAutoRetries: 1

zuul 集成Hystrix

Hystrix容错和限流

容错 - 处理远程调用的错误，其容错手段为：降级

限流 - 由于流量过大造成故障，要限制后台模块的访问流量，减轻压力，其限流的手段为：熔断

容错、降级

(1)、创建降级类，实现zuul接口：FallbackProvider

getRoute() 方法中指定应用此降级类的服务id，星号或null值可以通配所有服务

(2)、按照规则实现接口方法

(3)、添加@Commponent注解

Zuul自动配置降级类，如下：

ItemServiceFallback

package cn.tedu.sp07.fallback;

import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 商品信息容错降级服务
 *
 */
@Slf4j
@Component
public class ItemServiceFallback implements FallbackProvider {

    /**
     * 针对哪个模块应用降级类
     * 该方法目前只针对 item-service 模块实行降级
     * 星号和null都表示所有微服务失败都应用当前降级类
     *
     * @return
     */
    @Override
    public String getRoute() {
        return "item-service";
    }

    /**
     * 发送给客户端的降级响应
     * 返回数据封装为Response对象
     * @param route
     * @param cause
     * @return
     */
    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        return response();
    }

    /**
     * 响应方法
     *
     * @return
     */
    private ClientHttpResponse response() {
        return new ClientHttpResponse() {
            //下面三个方法都是协议号
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.OK;
            }

            @Override
            public int getRawStatusCode() throws IOException {
                return HttpStatus.OK.value();
            }

            @Override
            public String getStatusText() throws IOException {
                return HttpStatus.OK.getReasonPhrase();
            }

            @Override
            public void close() {
            }

            @Override
            public InputStream getBody() throws IOException {
                log.info("fallback body");
                String s = JsonResult.err().msg("后台服务错误").toString();
                return new ByteArrayInputStream(s.getBytes("UTF-8"));
            }

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.APPLICATION_JSON);
                return headers;
            }
        };
    }
}

OrderServiceFallback

package cn.tedu.sp07.fallback;

import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 订单信息容错降级服务
 *
 */
@Slf4j
@Component
public class OrderServiceFallback implements FallbackProvider {

    /**
     * 针对哪个模块应用降级类
     * 该方法目前只针对 order-service 模块实行降级
     * 星号和null都表示所有微服务失败都应用当前降级类
     *
     * @return
     */
    @Override
    public String getRoute() {
        return "order-service";
    }

    /**
     * 发送给客户端的降级响应
     * 返回数据封装为Response对象
     * @param route
     * @param cause
     * @return
     */
    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        return response();
    }

    /**
     * 响应方法
     *
     * @return
     */
    private ClientHttpResponse response() {
        return new ClientHttpResponse() {
            //下面三个方法都是协议号
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.OK;
            }

            @Override
            public int getRawStatusCode() throws IOException {
                return HttpStatus.OK.value();
            }

            @Override
            public String getStatusText() throws IOException {
                return HttpStatus.OK.getReasonPhrase();
            }

            @Override
            public void close() {
            }

            @Override
            public InputStream getBody() throws IOException {
                log.info("fallback body");
                String s = JsonResult.err().msg("后台服务错误").toString();
                return new ByteArrayInputStream(s.getBytes("UTF-8"));
            }

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.APPLICATION_JSON);
                return headers;
            }
        };
    }
}

(4)、测试

限流、熔断

Hystry熔断条件，断路器默认是关闭的，打开条件：

10秒20次请求(首先满足)

50%请求出错，执行降级

断路器打开后，会进入”半开状态“，即：

尝试向后台模块发送一次客户端调用

如果调用成功，会关闭断路器，恢复正常

如果调用失败，则继续保持打开状态

测试：

该状态目前只可在浏览器内访问查看，但效果不明显，则可以使用监控工具查看，即：hystrix dashboard 断路器仪表盘

13、hystrix dashboard 断路器仪表盘

dashboard

hystrix 对请求的降级和熔断，可以产生监控信息，hystrix dashboard可以实时的进行监控

利用Actuator来暴露Hystrix的监控日志，Hystrix dashboard 会抓取日志，对日志进行分析处理，最终显示如下图表：

监控界面

Actuator，是Spring提供的一个项目指标监控工具，其主要提供了各种监控信息的监控端点，如：

健康状态

Spring容器中的所有对象

SpringMVC所有的访问路径

JVM堆内存镜像文件

Hystrix监控日志

management.endpoints.web.exposure.include 配置选项，可以指定端点名，来暴露监控端点，如果要暴露所有的端点，可以用 "*" 表示

Actuator

(1)、添加Actuator依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

(2)、调整配置文件，并暴露 hystrix.stream 监控端点

# 暴露监控端点
management:
  endpoints:
    web:
      exposure:
        include: hystrix.stream

(3)、测试访问

浏览器内输入：http://localhost:4001/actuator

Hystrix dashboard

dashboard

(1)、创建Spring模块，并填写模块名称 sp08-hystrix-dashboard

(2)、添加 hystrix dashboard 依赖，POM文件如下：

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sp08-hystrix-dashboard</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sp08-hystrix-dashboard</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</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>
    </dependencies>
</project>

(3)、配置文件添加允许抓取服务器的列表

# 服务端口号
server:
  port: 5001
  
# 允许抓取服务器的列表
hystrix:
  dashboard:
    proxy-stream-allow-list: localhost

(4)、主程序上添加 @EnableHystrixDashboard 注解，开启断路器数据监控看板

package cn.tedu.sp08;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableHystrixDashboard
public class Sp08HystrixDashboardApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp08HystrixDashboardApplication.class, args);
    }

}

(5)、测试访问

浏览器内输入：http://localhost:5001/hystrix

使用ab命令，测试并发

命令行输入：ab -n 20000 -c 50 http://localhost:4001/item-service/35?jwt=1234

命令行输入：ab -n 20000 -c 50 http://localhost:4001/user-service/35

监控数据详细说明

监控界面

14、Spring cloud config 配置中心

集中的管理各个模块中的配置文件

yml 配置文件保存到 git 服务器，例如 github.com 或 gitee.com ，微服务启动时，从服务器获取配置文件

(1)、配置git服务器

检查git环境

**1**、访问git官网下载git

**2**、安装git应用程序

**3**、IDEA 内通过 setting -> git 配置 git.exe 的路径

准备本地git仓库

**1**、在springboot1工程目录下，新建config文件夹

**2**、复制item-service、user-service、order-service模块中的application.yml文件到config文件夹内

item-service-dev.yml

user-service-dev.yml

order-service-dev.yml

禁止配置中心的配置信息覆盖客户端配置

默认配置中心配置优先级高,配置中心配置会覆盖客户端的所有配置,包括命令行参数配置,这样我们在item-service和order-service中配置的端口号启动参数会无效

item-service 启动参数:

--service.port=8001
--service.port=8002

order-service 启动参数

--service.port=8201
--service.port=8202

我们可以设置禁止配置中心的配置将客户端配置覆盖掉，需要在四个配置文件中添加下面的配置(注意在spring的节点下)：

spring:
  ......
  cloud:
    config:
      override-none: true

**3**、double shift -- actions 搜索 create git repository

"4"、选择springboot1工程目录作为本地的仓库目录

**5**、点击提交按钮，提交文件，全选文件，填写提交信息，完成提交

准备远程git仓库

浏览器打开 Gitee - 基于 Git 的代码托管和研发协作平台并登录系统

**1**、创建私有仓库

**2**、私有仓库调整为开源仓库

点击仓库管理按钮，启用仓库开源

**3**、提交至远程仓库

(2)、搭建配置中心

**1**、新建Spring模块，并填写名称：sp09-config

**2**、导入如下POM配置文件内容(添加 config server 、eureka client 两个依赖)

<?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">
    <parent>
        <artifactId>springboot1</artifactId>
        <groupId>cn.tedu</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>sp09-config</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sp09-config</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>
</project>

**3**、修改配置文件，并添加 git 仓库的地址以及存放配置文件的文件夹

# 服务名称(注册到注册表的名称)
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/jiayouxijuan/springcloud1 # https://github.com/账户/仓库
          searchPaths: config
          #username: your-username
          #password: your-password

# 服务端口号
server:
  port: 6001

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

**4**、主程序如下，添加 @EnableConfigServer 注解

package cn.tedu.sp09;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.config.server.EnableConfigServer;

@EnableConfigServer
@EnableDiscoveryClient
@SpringBootApplication
public class Sp09ConfigApplication {

    public static void main(String[] args) {
        SpringApplication.run(Sp09ConfigApplication.class, args);
    }

}

**5**、测试

(3)、搭建客户端配置中心

修改以下项目，从配置中心获取配置信息

sp02-itemservice 、sp03-userservice 、sp04-orderservice

**1**、修改上述三个服务的POM配置文件内容(添加 config client 两个依赖)

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

**2**、添加引导配置文件

在四个项目中分别添加 bootstrap.yml 配置文件，并填写相应的配置信息，bootstrap.yml，引导配置文件，先于 application.yml 加载，内容如下：

item-service

# 配置中心配置，下载配置文件
spring:
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config-server
      name: item-service
      profile: dev

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

user-service

# 配置中心配置，下载配置文件
spring:
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config-server
      name: user-service
      profile: dev

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

order-service

# 配置中心配置，下载配置文件
spring:
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config-server
      name: order-service
      profile: dev

# eureka 注册配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

(4)、配置刷新配置文件(以 user-service 为例)

spring cloud 允许运行时动态刷新配置，可以重新从配置中心获取新的配置信息

**1**、user-service 的 pom.xml 中添加 actuator 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

**2**、yml 配置文件中暴露 refresh 端点

修改 config 项目中的 user-service-dev.yml，并提交推送到远程仓库

# 配置暴露 refresh 端点
management:
  endpoints:
    web:
      exposure:
        include: refresh

**3**、UserServiceImpl 添加 @RefreshScope 注解

只允许对添加了 @RefreshScope 或 @ConfigurationProperties 注解的 Bean 刷新配置，可以将更新的配置数据注入到 Bean 中

package cn.tedu.sp03.service;

import cn.tedu.pojo.User;
import cn.tedu.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.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 用户信息业务层接口实现类
 *
 */
@Slf4j
@Service
@RefreshScope
public class UserServiceImpl implements UserService {

    // 注入用户信息列表
    @Value("${sp.user-service.users}")
    private String userJson;

    /**
     * 获取用户信息
     *
     * @param id
     * @return
     */
    @Override
    public User getUser(Integer id) {
        log.info("users json string : "+userJson);
        List<User> list = JsonUtil.from(userJson, new TypeReference<List<User>>() {});

        // 在Demo数据中找用户
        for (User u : list) {
            if (u.getId().equals(id)) {
                return u;
            }
        }

        // 如果找不到，这里写死一个数据
        return new User(id, "name-"+id, "pwd-"+id);
    }

    /**
     * 下订单时增加用户积分
     *
     * @param id
     * @param score
     */
    @Override
    public void addScore(Integer id, Integer score) {
        // 这里增加积分
        log.info("user "+id+" - 增加积分 "+score);
    }
}

**4**、重启配置中心, 再重启sp03, 查看暴露的刷新端点

查看暴露的刷新端点 http://localhost:8101/actuato

待完善

**5**、

**6**、

**7**、

**8**、

**9**、

(5)、

15、

16、

17、

18、

五，待定

家有喜娟儿

关注

0
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
Spring Cloud入门操作手册(Hoxton)

一，spring cloud 介绍spring cloud 是一系列框架的集合。它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和部署。spring cloud 并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过 spring boot 风格进行再封装...
复制链接

扫一扫

专栏目录