精华内容
下载资源
问答
  • Spring Cloud入门操作手册(Hoxton)

    万次阅读 多人点赞 2019-10-28 09:21:20
    文章目录@[toc]spring cloud 介绍spring cloud 技术组成Spring Cloud 对比 Dubbo一、service - 服务二、commons 通用项目新建 maven 项目pom.xmljava 源文件...

    文章目录

    环境

    在这里插入图片描述

    spring cloud 介绍

    spring cloud 是一系列框架的集合。它利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发,如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等,都可以用 spring boot 的开发风格做到一键启动和部署。spring cloud 并没有重复制造轮子,它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来,通过 spring boot 风格进行再封装屏蔽掉了复杂的配置和实现原理,最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

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

    spring cloud 技术组成

    Spring Cloud

    • eureka
      微服务治理,服务注册和发现

    • ribbon
      负载均衡、请求重试

    • hystrix
      断路器,服务降级、熔断

    • feign
      ribbon + hystrix 集成,并提供声明式客户端

    • hystrix dashboard 和 turbine
      hystrix 数据监控

    • zuul
      API 网关,提供微服务的统一入口,并提供统一的权限验证

    • config
      配置中心

    • bus
      消息总线, 配置刷新

    • sleuth+zipkin
      链路跟踪

    Spring Cloud 对比 Dubbo

    Spring Cloud对比Dubbo

    • Dubbo

      • Dubbo只是一个远程调用(RPC)框架
      • 默认基于长连接,支持多种序列化格式
    • Spring Cloud

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

    在这里插入图片描述

    一、service - 服务

    三个服务

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

    在这里插入图片描述

    在这里插入图片描述

    二、commons 通用项目

    新建 maven 项目

    新建maven项目

    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>
    

    java 源文件

    Java源文件

    pojo

    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;
    }
    

    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;
    }
    

    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;
    }
    

    service

    ItemService

    package cn.tedu.sp01.service;
    
    import java.util.List;
    
    import cn.tedu.sp01.pojo.Item;
    
    public interface ItemService {
    	List<Item> getItems(String orderId);
    	void decreaseNumbers(List<Item> list);
    }
    

    UserService

    package cn.tedu.sp01.service;
    
    import cn.tedu.sp01.pojo.User;
    
    public interface UserService {
    	User getUser(Integer id);
    	void addScore(Integer id, Integer score);
    }
    
    

    OrderService

    package cn.tedu.sp01.service;
    
    
    import cn.tedu.sp01.pojo.Order;
    
    public interface OrderService {
    	Order getOrder(String orderId);
    	void addOrder(Order order);
    }
    
    

    util

    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);
    	}
    
    }
    

    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);
        }
    }
    

    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);
    	}
    }
    

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    三、item service 商品服务

    1. 新建项目
    2. 配置依赖 pom.xml
    3. 配置 application.yml
    4. 配置主程序
    5. 编写代码

    新建 spring boot 起步项目

    新建项目

    选择依赖项

    • 只选择 web

    选择依赖

    pom.xml

    • 要填加 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">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.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>cn.tedu</groupId>
    			<artifactId>sp01-commons</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    </project>
    

    application.yml

    改名

    spring:
      application:
        name: item-service
        
    server:
      port: 8001
    

    主程序

    • 默认代码,不需要修改
    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);
    	}
    
    }
    

    java 源文件

    java源文件

    ItemServiceImpl

    package cn.tedu.sp02.item.service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import org.springframework.stereotype.Service;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.service.ItemService;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Service
    public class ItemServiceImpl implements ItemService {
    
    	@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 decreaseNumbers(List<Item> list) {
    		for(Item item : list) {
    			log.info("减少库存 - "+item);
    		}
    	}
    }
    

    ItemController

    package cn.tedu.sp02.item.controller;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    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 org.springframework.web.bind.annotation.RestController;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.service.ItemService;
    import cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @RestController
    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("server.port="+port+", orderId="+orderId);
    		
    		List<Item> items = itemService.getItems(orderId);
    		return JsonResult.ok(items).msg("port="+port);
    	}
    	
    	@PostMapping("/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    		itemService.decreaseNumbers(items);
    		return JsonResult.ok();
    	}
    }
    

    Spring MVC 接收参数的几个注解

    接收参数

    访问测试

    根据orderid,查询商品
    http://localhost:8001/35

    减少商品库存
    http://localhost:8001/decreaseNumber

    使用postman,POST发送以下格式数据:
    [{"id":1, "name":"abc", "number":23},{"id":2, "name":"def", "number":11}]

    postman

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    四、user service 用户服务

    1. 新建项目
    2. 配置依赖 pom.xml
    3. 配置 application.yml
    4. 配置主程序
    5. 编写代码

    新建 spring boot 起步项目

    新建项目

    选择依赖项

    • 只选择 web

    选择依赖

    pom.xml

    • 要填加 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">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.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>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>cn.tedu</groupId>
    			<artifactId>sp01-commons</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    • 其中 sp.user-service.users 属性为自定义属性,提供用于测试的用户数据
    sp:
      user-service:
        users: "[{\"id\":7, \"username\":\"abc\",\"password\":\"123\"},{\"id\":8, \"username\":\"def\",\"password\":\"456\"},{\"id\":9, \"username\":\"ghi\",\"password\":\"789\"}]"
    
    spring:
      application:
        name: user-service
        
    server:
      port: 8101
    

    主程序

    • 默认代码,不需要修改
    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);
    	}
    
    }
    

    java源文件

    Java源文件

    UserServiceImpl

    package cn.tedu.sp03.user.service;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    
    import com.fasterxml.jackson.core.type.TypeReference;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.sp01.service.UserService;
    import cn.tedu.web.util.JsonUtil;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Service
    public class UserServiceImpl implements UserService {
    	@Value("${sp.user-service.users}")
    	private String userJson;
    	
    	@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);
    	}
    
    	@Override
    	public void addScore(Integer id, Integer score) {
    		// 这里增加积分
    		log.info("user "+id+" - 增加积分 "+score);
    	}
    
    }
    

    UserController

    package cn.tedu.sp03.user.controller;
    
    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 cn.tedu.sp01.pojo.User;
    import cn.tedu.sp01.service.UserService;
    import cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @RestController
    public class UserController {
    	
    	@Autowired
    	private UserService userService;
    	
    	@GetMapping("/{userId}")
    	public JsonResult<User> getUser(@PathVariable Integer userId) {
    		log.info("get user, userId="+userId);
    		User u = userService.getUser(userId);
    		return JsonResult.ok(u);
    	}
    	
    	@GetMapping("/{userId}/score") 
    	public JsonResult addScore(
    			@PathVariable Integer userId, Integer score) {
    		userService.addScore(userId, score);
    		return JsonResult.ok();
    	}
    }
    
    

    访问测试

    根据userid查询用户信息
    http://localhost:8101/7

    根据userid,为用户增加积分
    http://localhost:8101/7/score?score=100

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    五、order service 订单服务

    1. 新建项目
    2. 配置依赖 pom.xml
    3. 配置 application.yml
    4. 配置主程序
    5. 编写代码

    新建 spring boot 起步项目

    新建项目

    选择依赖项

    • 只选择 web

    选择依赖

    pom.xml

    • 要填加 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">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.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>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>cn.tedu</groupId>
    			<artifactId>sp01-commons</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    
    

    application.yml

    spring:
      application:
        name: order-service
        
    server:
      port: 8201
    

    主程序

    • 默认代码,不需要修改
    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);
    	}
    
    }
    

    java 源文件

    Java源文件

    OrderServiceImpl

    package cn.tedu.sp04.order.service;
    
    import org.springframework.stereotype.Service;
    
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.service.OrderService;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Service
    public class OrderServiceImpl implements OrderService {
    
    	@Override
    	public Order getOrder(String orderId) {
    		//TODO: 调用user-service获取用户信息
    		//TODO: 调用item-service获取商品信息
    		Order order = new Order();
    		order.setId(orderId);
    		return order;
    	}
    
    	@Override
    	public void addOrder(Order order) {
    		//TODO: 调用item-service减少商品库存
    		//TODO: 调用user-service增加用户积分
    		log.info("保存订单:"+order);
    	}
    
    }
    

    OrderController

    package cn.tedu.sp04.order.controller;
    
    import java.util.Arrays;
    
    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 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;
    
    @Slf4j
    @RestController
    public class OrderController {
    	@Autowired
    	private OrderService orderService;
    	
    	@GetMapping("/{orderId}")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) {
    		log.info("get order, id="+orderId);
    		
    		Order order = orderService.getOrder(orderId);
    		return JsonResult.ok(order);
    	}
    	
    	@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();
    	}
    }
    

    访问测试

    根据orderid,获取订单
    http://localhost:8201/123abc

    保存订单,观察控制台日志输出
    http://localhost:8201/

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    六、service 访问测试汇总

    • item-service

    根据orderid,查询商品
    http://localhost:8001/35

    减少商品库存
    http://localhost:8001/decreaseNumber

    使用postman,POST发送以下格式数据:
    [{"id":1, "name":"abc", "number":23},{"id":2, "name":"def", "number":11}]

    • user-service

    根据userid查询用户信息
    http://localhost:8101/7

    根据userid,为用户增加积分
    http://localhost:8101/7/score?score=100

    • order-service

    根据orderid,获取订单
    http://localhost:8201/123abc

    保存订单,观察控制台日志输出
    http://localhost:8201/

    postman

    在这里插入图片描述

    七、eureka 注册与发现

    eureka注册中心

    1. 创建eureka项目
    2. 配置依赖 pom.xml
    3. 配置 application.yml
    4. 主程序启用 eureka 服务器
    5. 启动,访问测试

    创建 eureka server 项目:sp05-eureka

    创建项目
    添加依赖

    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.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<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>Hoxton.RELEASE</spring-cloud.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-eureka-server</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>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    
    

    application.yml

    spring:
      application:
        name: eureka-server
        
    server:
      port: 2001
      
    eureka:
      server:
        enable-self-preservation: false
      instance:
        hostname: eureka1
      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

    主程序

    • 添加 @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);
    	}
    
    }
    

    修改 hosts 文件,添加 eureka 域名映射

    C:\Windows\System32\drivers\etc\hosts

    添加内容:

    127.0.0.1       eureka1
    127.0.0.1       eureka2
    

    启动,并访问测试

    eureka

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    八、service provider 服务提供者

    eureka注册中心

    • 修改 item-service、user-service、order-service,把微服务注册到 eureka 服务器
    1. pom.xml 添加eureka依赖
    2. application.yml 添加eureka注册配置
    3. 主程序启用eureka客户端
    4. 启动服务,在eureka中查看注册信息

    pom.xml 添加 eureka 客户端依赖

    右键点击项目,或点击pom.xml,用 STS 工具编辑起步依赖
    编辑起步依赖
    添加依赖
    上面的操作会在pom.xml中添加以下依赖

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

    application.yml 添加 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 秒

    主程序启用服务注册发现客户端

    修改 item-service、user-service 和 order-service,
    主程序添加 @EnableDiscoveryClient 注解

    启动,并访问 eureka 查看注册信息

    启动服务

    eureka

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    九、eureka 和 “服务提供者”的高可用

    eureka和item高可用

    item-service 高可用

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

    配置启动参数

    • item-service-8001
    --server.port=8001
    

    在这里插入图片描述

    端口

    复制

    • item-service-8002
    --server.port=8002
    

    端口

    启动项

    启动测试

    • 访问 eureka 查看 item-service 注册信息

    集群

    eureka 高可用

    添加两个服务器的 profile 配置文件

    application-eureka1.yml

    eureka:
      instance:
        hostname: eureka1
      client:
        register-with-eureka: true  #profile的配置会覆盖公用配置
        fetch-registry: true        #profile的配置会覆盖公用配置
        service-url: 
          defaultZone: http://eureka2:2002/eureka  #eureka1启动时向eureka2注册
    

    application-eureka2.yml

    eureka:
      instance:
        hostname: eureka2
      client:
        register-with-eureka: true  #profile的配置会覆盖公用配置
        fetch-registry: true        #profile的配置会覆盖公用配置
        service-url: 
          defaultZone: http://eureka1:2001/eureka  #eureka2启动时向eureka1注册
    

    配置启动参数 --spring.profiles.active--server.port

    • eureka1 启动参数:
    --spring.profiles.active=eureka1 --server.port=2001
    

    配置启动项

    启动参数

    • eureka2 启动参数:
    --spring.profiles.active=eureka2 --server.port=2002
    

    复制启动项

    启动参数

    启动项

    如果在命令行运行,可以在命令行中添加参数:

    java -jar xxx.jar --spring.profiles.active=eureka1 --server.port=2001
    

    访问 eureka 服务器,查看注册信息

    eureka1

    eureka2

    eureka客户端注册时,向两个服务器注册

    修改以下微服务

    • sp02-itemservice
    • sp03-userservice
    • sp04-orderservice
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    

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

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十、ribbon 服务消费者

    服务消费者

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

    RestTemplate

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

    它的常用方法:

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

    之前的系统结构是浏览器直接访问后台服务
    直接访问
    后面我们通过一个Demo项目演示 Spring Cloud 远程调用

    Demo

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

    1. 新建 ribbon 项目
    2. pom.xml
    3. application.yml
    4. 主程序
    5. controller
    6. 启动,并访问测试

    新建 sp06-ribbon 项目

    新建项目
    选择依赖

    pom.xml

    • eureka-client 中已经包含 ribbon 依赖

    • 需要添加 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">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<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>
    		<spring-cloud.version>Hoxton.RELEASE</spring-cloud.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>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>cn.tedu</groupId>
    			<artifactId>sp01-commons</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    spring:
      application:
        name: ribbon
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    

    主程序

    • 创建 RestTemplate 实例

      RestTemplate 是用来调用其他微服务的工具类,封装了远程调用代码,提供了一组用于远程调用的模板方法,例如:getForObject()postForObject()
    package cn.tedu.sp06;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.context.annotation.Bean;
    import org.springframework.web.client.RestTemplate;
    
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp06RibbonApplication {
    	
    	//创建 RestTemplate 实例,并存入 spring 容器
    	@Bean
    	public RestTemplate getRestTemplate() {
    		return new RestTemplate();
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp06RibbonApplication.class, args);
    	}
    
    }
    
    

    RibbonController

    package cn.tedu.sp06.controller;
    
    import java.util.List;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @RestController
    public class RibbonController {
    	@Autowired
    	private RestTemplate rt;
    	
    	@GetMapping("/item-service/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
    	    //向指定微服务地址发送 get 请求,并获得该服务的返回结果 
    	    //{1} 占位符,用 orderId 填充
    		return rt.getForObject("http://localhost:8001/{1}", JsonResult.class, orderId);
    	}
    
    	@PostMapping("/item-service/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    	    //发送 post 请求
    		return rt.postForObject("http://localhost:8001/decreaseNumber", items, JsonResult.class);
    	}
    
    	/
    	
    	@GetMapping("/user-service/{userId}")
    	public JsonResult<User> getUser(@PathVariable Integer userId) {
    		return rt.getForObject("http://localhost:8101/{1}", JsonResult.class, userId);
    	}
    
    	@GetMapping("/user-service/{userId}/score") 
    	public JsonResult addScore(
    			@PathVariable Integer userId, Integer score) {
    		return rt.getForObject("http://localhost:8101/{1}/score?score={2}", JsonResult.class, userId, score);
    	}
    	
    	/
    	
    	@GetMapping("/order-service/{orderId}")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) {
    		return rt.getForObject("http://localhost:8201/{1}", JsonResult.class, orderId);
    	}
    
    	@GetMapping("/order-service")
    	public JsonResult addOrder() {
    		return rt.getForObject("http://localhost:8201/", JsonResult.class);
    	}
    }
    
    

    启动服务,并访问测试

    在这里插入图片描述

    http://eureka1:2001

    http://localhost:3001/item-service/35
    http://localhost:3001/item-service/decreaseNumber
    使用postman,POST发送以下格式数据:
    [{"id":1, "name":"abc", "number":23},{"id":2, "name":"def", "number":11}]

    http://localhost:3001/user-service/7
    http://localhost:3001/user-service/7/score?score=100

    http://localhost:3001/order-service/123abc
    http://localhost:3001/order-service/

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十一、ribbon 负载均衡和重试

    ribbon
    Ribbon

    Ribbon 负载均衡

    负载均衡

    • 修改 sp06-ribbon 项目
    1. 添加 ribbon 起步依赖(可选)
    2. RestTemplate 设置 @LoadBalanced
    3. 访问路径设置为服务id

    添加 ribbon 起步依赖(可选)

    • eureka 依赖中已经包含了 ribbon
    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
    </dependency>
    

    RestTemplate 设置 @LoadBalanced

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

    package cn.tedu.sp06;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.web.client.RestTemplate;
    
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp06RibbonApplication {
    	
    	@LoadBalanced //负载均衡注解
    	@Bean
    	public RestTemplate getRestTemplate() {
    		return new RestTemplate();
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp06RibbonApplication.class, args);
    	}
    
    }
    

    访问路径设置为服务id

    package cn.tedu.sp06.controller;
    
    import java.util.List;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @RestController
    public class RibbonController {
    	@Autowired
    	private RestTemplate rt;
    	
    	@GetMapping("/item-service/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
    	    //这里服务器路径用 service-id 代替,ribbon 会向服务的多台集群服务器分发请求
    		return rt.getForObject("http://item-service/{1}", JsonResult.class, orderId);
    	}
    
    	@PostMapping("/item-service/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    		return rt.postForObject("http://item-service/decreaseNumber", items, JsonResult.class);
    	}
    
    	/
    	
    	@GetMapping("/user-service/{userId}")
    	public JsonResult<User> getUser(@PathVariable Integer userId) {
    		return rt.getForObject("http://user-service/{1}", JsonResult.class, userId);
    	}
    
    	@GetMapping("/user-service/{userId}/score") 
    	public JsonResult addScore(
    			@PathVariable Integer userId, Integer score) {
    		return rt.getForObject("http://user-service/{1}/score?score={2}", JsonResult.class, userId, score);
    	}
    	
    	/
    	
    	@GetMapping("/order-service/{orderId}")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) {
    		return rt.getForObject("http://order-service/{1}", JsonResult.class, orderId);
    	}
    
    	@GetMapping("/order-service")
    	public JsonResult addOrder() {
    		return rt.getForObject("http://order-service/", JsonResult.class);
    	}
    }
    
    

    访问测试

    访问测试

    访问测试

    ribbon 重试

    重试

    pom.xml 添加 spring-retry 依赖

    复制代码到 pom.xml

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

    application.yml 配置 ribbon 重试

    spring:
      application:
        name: ribbon
        
    server:
      port: 3001
      
    eureka:
      client:    
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    ribbon:
      MaxAutoRetriesNextServer: 2
      MaxAutoRetries: 1
      OkToRetryOnAllOperations: true
    
    • ConnectionTimeout
    • ReadTimeout
    • OkToRetryOnAllOperations=true
      默认只对GET请求重试, 当设置为true时, 对POST等所有类型请求都重试
    • MaxAutoRetriesNextServer
      更换实例的次数
    • MaxAutoRetries
      当前实例重试次数,尝试失败会更换下一个实例

    主程序设置 RestTemplate 的请求工厂的超时属性

    package cn.tedu.sp06;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp06RibbonApplication {
    
    	@LoadBalanced
    	@Bean
    	public RestTemplate getRestTemplate() {
    		SimpleClientHttpRequestFactory f = new SimpleClientHttpRequestFactory();
    		f.setConnectTimeout(1000);
    		f.setReadTimeout(1000);
    		return new RestTemplate(f);
    		
    		//RestTemplate 中默认的 Factory 实例中,两个超时属性默认是 -1,
    		//未启用超时,也不会触发重试
    		//return new RestTemplate();
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp06RibbonApplication.class, args);
    	}
    
    }
    

    item-service 的 ItemController 添加延迟代码,以便测试 ribbon 的重试机制

    package cn.tedu.sp02.item.controller;
    
    import java.util.List;
    import java.util.Random;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    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 org.springframework.web.bind.annotation.RestController;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.service.ItemService;
    import cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @RestController
    public class ItemController {
    	@Autowired
    	private ItemService itemService;
    	
    	@Value("${server.port}")
    	private int port;
    	
    	@GetMapping("/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) throws Exception {
    		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);
    	}
    	
    	@PostMapping("/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    		itemService.decreaseNumbers(items);
    		return JsonResult.ok();
    	}
    }
    

    访问,测试 ribbon 重试机制

    重试测试
    重试测试

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

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十二、Hystrix 断路器

    Hystrix

    微服务宕机时,ribbon 无法转发请求

    • 关闭 user-service 和 order-service

    关闭
    白板

    复制 sp06-ribbon 项目,命名为sp07-hystrix

    • 选择 sp06-ribbon 项目,ctrl-c,ctrl-v,复制为sp07-hystrix
    • 关闭 sp06-ribbon 项目,后续测试使用 sp07-hystrix 项目

    复制项目

    修改 pom.xml

    修改pom

    添加 hystrix 起步依赖

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

    修改 application.yml

    修改yml

    
    spring:
      application:
        name: hystrix
        
    server:
      port: 3001
      
    eureka:
      client:    
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    ribbon:
      MaxAutoRetries: 1
      MaxAutoRetriesNextServer: 2
      OkToRetryOnAllOperations: true
    

    主程序添加 @EnableCircuitBreaker 启用 hystrix 断路器

    启动断路器,断路器提供两个核心功能:

    • 降级,超时、出错、不可到达时,对服务降级,返回错误信息或者是缓存数据

    • 熔断,当服务压力过大,错误比例过多时,熔断所有请求,所有请求直接降级

    • 可以使用 @SpringCloudApplication 注解代替三个注解

    package cn.tedu.sp06;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.cloud.client.SpringCloudApplication;
    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    import org.springframework.web.client.RestTemplate;
    
    //@EnableCircuitBreaker
    //@EnableDiscoveryClient
    //@SpringBootApplication
    
    @SpringCloudApplication
    public class Sp06RibbonApplication {
    
    	@LoadBalanced
    	@Bean
    	public RestTemplate getRestTemplate() {
    		SimpleClientHttpRequestFactory f = new SimpleClientHttpRequestFactory();
    		f.setConnectTimeout(1000);
    		f.setReadTimeout(1000);
    		return new RestTemplate(f);
    		
    		//RestTemplate 中默认的 Factory 实例中,两个超时属性默认是 -1,
    		//未启用超时,也不会触发重试
    		//return new RestTemplate();
    	}
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp06RibbonApplication.class, args);
    	}
    
    }
    

    RibbonController 中添加降级方法

    • 为每个方法添加降级方法,例如 getItems() 添加降级方法 getItemsFB()
    • 添加 @HystrixCommand 注解,指定降级方法名
    package cn.tedu.sp06.controller;
    
    import java.util.List;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @RestController
    public class RibbonController {
    	@Autowired
    	private RestTemplate rt;
    	
    	@GetMapping("/item-service/{orderId}")
    	@HystrixCommand(fallbackMethod = "getItemsFB") //指定降级方法的方法名
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
    		return rt.getForObject("http://item-service/{1}", JsonResult.class, orderId);
    	}
    
    	@PostMapping("/item-service/decreaseNumber")
    	@HystrixCommand(fallbackMethod = "decreaseNumberFB")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    		return rt.postForObject("http://item-service/decreaseNumber", items, JsonResult.class);
    	}
    
    	/
    	
    	@GetMapping("/user-service/{userId}")
    	@HystrixCommand(fallbackMethod = "getUserFB")
    	public JsonResult<User> getUser(@PathVariable Integer userId) {
    		return rt.getForObject("http://user-service/{1}", JsonResult.class, userId);
    	}
    
    	@GetMapping("/user-service/{userId}/score") 
    	@HystrixCommand(fallbackMethod = "addScoreFB")
    	public JsonResult addScore(@PathVariable Integer userId, Integer score) {
    		return rt.getForObject("http://user-service/{1}/score?score={2}", JsonResult.class, userId, score);
    	}
    	
    	/
    	
    	@GetMapping("/order-service/{orderId}")
    	@HystrixCommand(fallbackMethod = "getOrderFB")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) {
    		return rt.getForObject("http://order-service/{1}", JsonResult.class, orderId);
    	}
    
    	@GetMapping("/order-service")
    	@HystrixCommand(fallbackMethod = "addOrderFB")
    	public JsonResult addOrder() {
    		return rt.getForObject("http://order-service/", JsonResult.class);
    	}
    	
    	/
    
        //降级方法的参数和返回值,需要和原始方法一致,方法名任意
    	public JsonResult<List<Item>> getItemsFB(String orderId) {
    		return JsonResult.err("获取订单商品列表失败");
    	}
    	public JsonResult decreaseNumberFB(List<Item> items) {
    		return JsonResult.err("更新商品库存失败");
    	}
    	public JsonResult<User> getUserFB(Integer userId) {
    		return JsonResult.err("获取用户信息失败");
    	}
    	public JsonResult addScoreFB(Integer userId, Integer score) {
    		return JsonResult.err("增加用户积分失败");
    	}
    	public JsonResult<Order> getOrderFB(String orderId) {
    		return JsonResult.err("获取订单失败");
    	}
    	public JsonResult addOrderFB() {
    		return JsonResult.err("添加订单失败");
    	}
    }
    
    

    hystrix 超时设置

    hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds

    hystrix等待超时后, 会执行降级代码, 快速向客户端返回降级结果, 默认超时时间是1000毫秒

    为了测试 hystrix 降级,我们把 hystrix 等待超时设置得非常小(500毫秒)

    此设置一般应大于 ribbon 的重试超时时长,例如 10 秒

    
    spring:
      application:
        name: hystrix
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    ribbon:
      MaxAutoRetriesNextServer: 2
      MaxAutoRetries: 1
      OkToRetryOnAllOperations: true
      
    hystrix:
      command:
        default:
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: 500
                
    

    启动项目进行测试

    启动测试

    • 通过 hystrix 服务,访问可能超时失败的 item-service
      http://localhost:3001/item-service/35

    • 通过 hystrix 服务,访问未启动的 user-service
      http://localhost:3001/user-service/7

    • 可以看到,如果 item-service 请求超时,hystrix 会立即执行降级方法

    • 访问 user-service,由于该服务未启动,hystrix也会立即执行降级方法

    降级

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十三、hystrix dashboard 断路器仪表盘

    dashboard

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

    sp07-hystrix 项目添加 actuator,并暴露 hystrix 监控端点

    actuator 是 spring boot 提供的服务监控工具,提供了各种监控信息的监控端点

    management.endpoints.web.exposure.include 配置选项,
    可以指定端点名,来暴露监控端点

    如果要暴露所有端点,可以用 “*”

    Actuator

    pom.xml 添加 actuator 依赖

    右键点击项目或pom.xml, 编辑起步依赖, 添加 actuator 依赖
    编辑起步依赖

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

    调整 application.yml 配置,并暴露 hystrix.stream 监控端点

    spring:
      application:
        name: hystrix
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    ribbon:
      MaxAutoRetriesNextServer: 1
      MaxAutoRetries: 1
      OkToRetryOnAllOperations: true
      
    hystrix:
      command:
        default:
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: 500
    
    management:
      endpoints:
        web:
          exposure:
            include: hystrix.stream
    

    访问 actuator 路径,查看监控端点

    actuator

    Hystrix dashboard 仪表盘

    dashboard

    新建 sp08-hystrix-dashboard 项目
    新建项目

    添加依赖

    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.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<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>
    		<spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</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>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    spring:
      application:
        name: hystrix-dashboard
        
    server:
      port: 4001
    
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    
    hystrix:
      dashboard:
        proxy-stream-allow-list: localhost
    

    主程序添加 @EnableHystrixDashboard@EnableDiscoveryClient

    package cn.tedu.sp08;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
    
    @EnableDiscoveryClient
    @EnableHystrixDashboard
    @SpringBootApplication
    public class Sp08HystrixDashboardApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp08HystrixDashboardApplication.class, args);
    	}
    
    }
    
    

    启动,并访问测试

    启动访问测试

    访问 hystrix dashboard

    dashboard

    填入 hystrix 的监控端点,开启监控

    开启监控

    • 通过 hystrix 访问服务多次,观察监控信息

    http://localhost:3001/item-service/35

    http://localhost:3001/user-service/7
    http://localhost:3001/user-service/7/score?score=100

    http://localhost:3001/order-service/123abc
    http://localhost:3001/order-service/

    监控界面

    监控界面

    hystrix 熔断

    整个链路达到一定的阈值,默认情况下,10秒内产生超过20次请求,则符合第一个条件。
    满足第一个条件的情况下,如果请求的错误百分比大于阈值,则会打开断路器,默认为50%
    Hystrix的逻辑,先判断是否满足第一个条件,再判断第二个条件,如果两个条件都满足,则会开启断路器

    断路器打开 5 秒后,会处于半开状态,会尝试转发请求,如果仍然失败,保持打开状态,如果成功,则关闭断路器

    使用 apache 的并发访问测试工具 ab

    http://httpd.apache.org/docs/current/platform/windows.html#down
    下载Apache

    • 用 ab 工具,以并发50次,来发送20000个请求
    ab -n 20000 -c 50 http://localhost:3001/item-service/35
    
    • 断路器状态为 Open,所有请求会被短路,直接降级执行 fallback 方法

    熔断

    hystrix 配置

    https://github.com/Netflix/Hystrix/wiki/Configuration

    • hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds
      请求超时时间,超时后触发失败降级

    • hystrix.command.default.circuitBreaker.requestVolumeThreshold
      10秒内请求数量,默认20,如果没有达到该数量,即使请求全部失败,也不会触发断路器打开

    • hystrix.command.default.circuitBreaker.errorThresholdPercentage
      失败请求百分比,达到该比例则触发断路器打开

    • hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds
      断路器打开多长时间后,再次允许尝试访问(半开),仍失败则继续保持打开状态,如成功访问则关闭断路器,默认 5000

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十四、feign 声明式客户端接口

    微服务应用中,ribbon 和 hystrix 总是同时出现,feign 整合了两者,并提供了声明式消费者客户端

    • 用 feign 代替 hystrix+ribbon

    feign

    新建 sp09-feign 项目

    在这里插入图片描述

    在这里插入图片描述

    pom.xml

    • 需要添加 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">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<artifactId>sp09-feign</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>sp09-feign</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    		<spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-actuator</artifactId>
    		</dependency>
    		<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>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-openfeign</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>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    spring:
      application:
        name: feign
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    

    主程序添加 @EnableDiscoveryClient@EnableFeignClients

    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.openfeign.EnableFeignClients;
    
    @EnableFeignClients
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp09FeignApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp09FeignApplication.class, args);
    	}
    
    }
    
    

    java 源文件

    java源文件

    feign 声明式客户端

    feign 利用了我们熟悉的 spring mvc 注解来对接口方法进行设置,降低了我们的学习成本。
    通过这些设置,feign可以拼接后台服务的访问路径和提交的参数

    例如:

    @GetMapping("/{userId}/score") 
    JsonResult addScore(@PathVariable Integer userId, @RequestParam Integer score);
    

    当这样调用该方法:

    service.addScore(7, 100);
    

    那么 feign 会向服务器发送请求:

    http://用户微服务/7/score?score=100
    
    • 注意:如果 score 参数名与变量名不同,需要添加参数名设置:
    @GetMapping("/{userId}/score") 
    JsonResult addScore(@PathVariable Integer userId, @RequestParam("score") Integer s);
    

    ItemFeignService

    package cn.tedu.sp09.service;
    
    import java.util.List;
    
    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 cn.tedu.sp01.pojo.Item;
    import cn.tedu.web.util.JsonResult;
    
    @FeignClient("item-service")
    public interface ItemFeignService {
    	@GetMapping("/{orderId}")
    	JsonResult<List<Item>> getItems(@PathVariable String orderId);
    
    	@PostMapping("/decreaseNumber")
    	JsonResult decreaseNumber(@RequestBody List<Item> items);
    }
    

    UserFeignService

    • 注意,如果请求参数名与方法参数名不同,@RequestParam不能省略,并且要指定请求参数名:
      @RequestParam("score") Integer s
    package cn.tedu.sp09.service;
    
    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;
    
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @FeignClient("user-service")
    public interface UserFeignService {
    	@GetMapping("/{userId}")
    	JsonResult<User> getUser(@PathVariable Integer userId);
    
        // 拼接路径 /{userId}/score?score=新增积分
    	@GetMapping("/{userId}/score") 
    	JsonResult addScore(@PathVariable Integer userId, @RequestParam Integer score);
    }
    

    OrderFeignService

    package cn.tedu.sp09.service;
    
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.web.util.JsonResult;
    
    @FeignClient("order-service")
    public interface OrderFeignService {
    	@GetMapping("/{orderId}")
    	JsonResult<Order> getOrder(@PathVariable String orderId);
    
    	@GetMapping("/")
    	JsonResult addOrder();
    
    }
    

    FeignController

    package cn.tedu.sp09.controller;
    
    import java.util.List;
    
    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.PostMapping;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.sp09.service.ItemFeignService;
    import cn.tedu.sp09.service.OrderFeignService;
    import cn.tedu.sp09.service.UserFeignService;
    import cn.tedu.web.util.JsonResult;
    
    @RestController
    public class FeignController {
    	@Autowired
    	private ItemFeignService itemService;
    	@Autowired
    	private UserFeignService userService;
    	@Autowired
    	private OrderFeignService orderService;
    	
    	@GetMapping("/item-service/{orderId}")
    	public JsonResult<List<Item>> getItems(@PathVariable String orderId) {
    		return itemService.getItems(orderId);
    	}
    
    	@PostMapping("/item-service/decreaseNumber")
    	public JsonResult decreaseNumber(@RequestBody List<Item> items) {
    		return itemService.decreaseNumber(items);
    	}
    
    	/
    	
    	@GetMapping("/user-service/{userId}")
    	public JsonResult<User> getUser(@PathVariable Integer userId) {
    		return userService.getUser(userId);
    	}
    
    	@GetMapping("/user-service/{userId}/score") 
    	public JsonResult addScore(@PathVariable Integer userId, Integer score) {
    		return userService.addScore(userId, score);
    	}
    	
    	/
    	
    	@GetMapping("/order-service/{orderId}")
    	public JsonResult<Order> getOrder(@PathVariable String orderId) {
    		return orderService.getOrder(orderId);
    	}
    
    	@GetMapping("/order-service")
    	public JsonResult addOrder() {
    		return orderService.addOrder();
    	}
    }
    

    调用流程

    流程

    启动服务,并访问测试

    启动服务

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十五、feign + ribbon 负载均衡和重试

    • 无需额外配置,feign 默认已启用了 ribbon 负载均衡重试机制。可以通过配置对参数进行调整

    重试的默认配置参数:

    ConnectTimeout=1000
    ReadTimeout=1000
    MaxAutoRetries=0
    MaxAutoRetriesNextServer=1
    

    application.yml 配置 ribbon 超时和重试

    • ribbon.xxx 全局配置
    • item-service.ribbon.xxx 对特定服务实例的配置
    spring:
      application:
        name: feign
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    ribbon:
      ConnectTimeout: 1000
      ReadTimeout: 1000
      
    item-service:
      ribbon:
        MaxAutoRetries: 1
        MaxAutoRetriesNextServer: 2
        ConnectTimeout: 1000
        ReadTimeout: 500
    

    启动服务,访问测试

    http://localhost:3001/item-service/35

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十六、feign + hystrix 降级

    feign 启用 hystrix

    feign 默认没有启用 hystrix,添加配置,启用 hystrix

    • feign.hystrix.enabled=true

    application.yml 添加配置

    feign:
      hystrix:
        enabled: true
    

    启用 hystrix 后,访问服务
    http://localhost:3001/item-service/35

    默认1秒会快速失败,没有降级方法时,会显示白板页

    白板页

    可以添加配置,暂时减小降级超时时间,以便后续对降级进行测试

    ......
    
    feign:
      hystrix:
        enabled: true
        
    hystrix:
      command:
        default:
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: 500
    

    feign + hystrix 降级

    feign 远程接口中指定降级类

    远程调用失败, 会执行降级类中的代码

    ItemFeignService

    ...
    @FeignClient(name="item-service", fallback = ItemFeignServiceFB.class)
    public interface ItemFeignService {
    ...
    

    UserFeignService

    ...
    @FeignClient(name="user-service", fallback = UserFeignServiceFB.class)
    public interface UserFeignService {
    ...
    

    OrderFeignService

    ...
    @FeignClient(name="order-service",fallback = OrderFeignServiceFB.class)
    public interface OrderFeignService {
    ...
    

    降级类

    降级类需要实现远程接口

    ItemFeignServiceFB

    package cn.tedu.sp09.service;
    
    import java.util.List;
    import org.springframework.stereotype.Component;
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.web.util.JsonResult;
    
    @Component
    public class ItemFeignServiceFB implements ItemFeignService {
    
    	@Override
    	public JsonResult<List<Item>> getItems(String orderId) {
    		return JsonResult.err("无法获取订单商品列表");
    	}
    
    	@Override
    	public JsonResult decreaseNumber(List<Item> items) {
    		return JsonResult.err("无法修改商品库存");
    	}
    
    }
    
    

    UserFeignServiceFB

    package cn.tedu.sp09.service;
    
    import org.springframework.stereotype.Component;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @Component
    public class UserFeignServiceFB implements UserFeignService {
    
    	@Override
    	public JsonResult<User> getUser(Integer userId) {
    		return JsonResult.err("无法获取用户信息");
    	}
    
    	@Override
    	public JsonResult addScore(Integer userId, Integer score) {
    		return JsonResult.err("无法增加用户积分");
    	}
    
    }
    
    

    OrderFeignServiceFB

    package cn.tedu.sp09.service;
    
    import org.springframework.stereotype.Component;
    import cn.tedu.sp01.pojo.Order;
    import cn.tedu.web.util.JsonResult;
    
    @Component
    public class OrderFeignServiceFB implements OrderFeignService {
    
    	@Override
    	public JsonResult<Order> getOrder(String orderId) {
    		return JsonResult.err("无法获取商品订单");
    	}
    
    	@Override
    	public JsonResult addOrder() {
    		return JsonResult.err("无法保存订单");
    	}
    
    }
    
    

    启动服务,访问测试

    http://localhost:3001/item-service/35

    访问测试

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十七、feign + hystrix 监控和熔断测试

    监控

    修改sp09-feign项目
    pom.xml 添加 hystrix 起步依赖

    • feign 没有包含完整的 hystrix 依赖
      右键点击项目,编辑起步依赖,添加hystrix依赖
      编辑起步依赖
    <dependency>
    	<groupId>org.springframework.cloud</groupId>
    	<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
    

    主程序添加 @EnableCircuitBreaker

    package cn.tedu.sp09;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    @EnableCircuitBreaker
    @EnableFeignClients
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp09FeignApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp09FeignApplication.class, args);
    	}
    
    }
    
    

    sp09-feign 配置 actuator,暴露 hystrix.stream 监控端点

    actuator 依赖

    查看pom.xml, 确认已经添加了 actuator 依赖

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

    application.yml 暴露 hystrix.stream 端点

    management:
      endpoints:
        web:
          exposure:
            include: hystrix.stream
    

    启动服务,查看监控端点

    http://localhost:3001/actuator
    监控端点

    hystrix dashboard

    启动 hystrix dashboard 服务,填入 feign 监控路径,开启监控
    访问 http://localhost:4001/hystrix

    • 填入 feign 监控路径:
      http://localhost:3001/actuator/hystrix.stream

    • 访问微服务,以产生监控数据

    http://localhost:3001/item-service/35

    http://localhost:3001/user-service/7
    http://localhost:3001/user-service/7/score?score=100

    http://localhost:3001/order-service/123abc
    http://localhost:3001/order-service/

    监控

    熔断测试

    • 用 ab 工具,以并发50次,来发送20000个请求
    ab -n 20000 -c 50 http://localhost:3001/item-service/35
    
    • 断路器状态为 Open,所有请求会被短路,直接降级执行 fallback 方法

    压力测试

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十八、order service 调用商品库存服务和用户服务

    关系图
    sp09-feign项目关闭,不再使用
    关闭项目

    修改 sp04-orderservice 项目,添加 feign,调用 item service 和 user service

    1. pom.xml
    2. application.yml
    3. 主程序
    4. ItemFeignService
    5. UserFeignService
    6. ItemFeignServiceFB
    7. UserFeignServiceFB
    8. OrderServiceImpl

    pom.xml

    编辑起步依赖

    • 右键点击项目编辑起步依赖,添加以下依赖:
    • actuator
    • feign
    • hystrix
    <?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.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.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>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>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-eureka-client
    			</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-actuator</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>
    				spring-cloud-starter-netflix-hystrix
    			</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-openfeign</artifactId>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>Hoxton.RELEASE</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    </project>
    

    application.yml

    • ribbon 重试和 hystrix 超时这里没有设置,采用了默认值
    spring:
      application:
        name: order-service
        
    server:
      port: 8201  
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    feign:
      hystrix:
        enabled: true
        
    management:
      endpoints:
        web:
          exposure:
            include: hystrix.stream
    

    主程序

    package cn.tedu.sp04;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.cloud.client.SpringCloudApplication;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    //@EnableDiscoveryClient
    //@SpringBootApplication
    
    @EnableFeignClients
    @SpringCloudApplication
    public class Sp04OrderserviceApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp04OrderserviceApplication.class, args);
    	}
    }
    

    ItemFeignService

    package cn.tedu.sp04.order.feignclient;
    
    import java.util.List;
    
    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 cn.tedu.sp01.pojo.Item;
    import cn.tedu.web.util.JsonResult;
    
    @FeignClient(name="item-service", fallback = ItemFeignServiceFB.class)
    public interface ItemFeignService {
    	@GetMapping("/{orderId}")
    	JsonResult<List<Item>> getItems(@PathVariable String orderId);
    
    	@PostMapping("/decreaseNumber")
    	JsonResult decreaseNumber(@RequestBody List<Item> items);
    }
    
    

    UserFeignService

    package cn.tedu.sp04.order.feignclient;
    
    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;
    
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @FeignClient(name="user-service", fallback = UserFeignServiceFB.class)
    public interface UserFeignService {
    	@GetMapping("/{userId}")
    	JsonResult<User> getUser(@PathVariable Integer userId);
    
    	@GetMapping("/{userId}/score") 
    	JsonResult addScore(@PathVariable Integer userId, @RequestParam Integer score);
    }
    

    ItemFeignServiceFB

    • 获取商品列表的降级方法,模拟使用缓存数据
    package cn.tedu.sp04.order.feignclient;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.springframework.stereotype.Component;
    
    import cn.tedu.sp01.pojo.Item;
    import cn.tedu.web.util.JsonResult;
    
    @Component
    public class ItemFeignServiceFB implements ItemFeignService {
    
    	@Override
    	public JsonResult<List<Item>> getItems(String orderId) {
    		if(Math.random()<0.5) {
    			return JsonResult.ok().data(
    			
    				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)
    				})
    			
    			);
    		}
    		return JsonResult.err("无法获取订单商品列表");
    	}
    
    	@Override
    	public JsonResult decreaseNumber(List<Item> items) {
    		return JsonResult.err("无法修改商品库存");
    	}
    
    }
    

    UserFeignServiceFB

    • 获取用户信息的降级方法,模拟使用缓存数据
    package cn.tedu.sp04.order.feignclient;
    
    import org.springframework.stereotype.Component;
    
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.web.util.JsonResult;
    
    @Component
    public class UserFeignServiceFB implements UserFeignService {
    
    	@Override
    	public JsonResult<User> getUser(Integer userId) {
    		if(Math.random()<0.4) {
    			return JsonResult.ok(new User(userId, "缓存name"+userId, "缓存pwd"+userId));
    		}
    		return JsonResult.err("无法获取用户信息");
    	}
    
    	@Override
    	public JsonResult addScore(Integer userId, Integer score) {
    		return JsonResult.err("无法增加用户积分");
    	}
    
    }
    

    OrderServiceImpl

    package cn.tedu.sp04.order.service;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    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.sp04.order.feignclient.ItemFeignService;
    import cn.tedu.sp04.order.feignclient.UserFeignService;
    import cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Service
    public class OrderServiceImpl implements OrderService {
    	
    	@Autowired
    	private ItemFeignService itemService;
    	@Autowired
    	private UserFeignService userService;
    
    	@Override
    	public Order getOrder(String orderId) {
    		//调用user-service获取用户信息
    		JsonResult<User> user = userService.getUser(7);
    		
    		//调用item-service获取商品信息
    		JsonResult<List<Item>> items = itemService.getItems(orderId);
    		
    		
    		Order order = new Order();
    		order.setId(orderId);
    		order.setUser(user.getData());
    		order.setItems(items.getData());
    		return order;
    	}
    
    	@Override
    	public void addOrder(Order order) {
    		//调用item-service减少商品库存
    		itemService.decreaseNumber(order.getItems());
    		
    		//TODO: 调用user-service增加用户积分
    		userService.addScore(7, 100);
    		
    		log.info("保存订单:"+order);
    	}
    
    }
    

    order-service 配置启动参数,启动两台服务器

    • --server.port=8201
    • --server.port=8202
      配置启动项
      配置启动项
      复制
      配置启动项
      启动项

    启动服务,访问测试

    启动服务

    hystrix dashboard 监控 order service 断路器

    监控

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    十九、hystrix + turbine 集群聚合监控

    turbine

    hystrix dashboard 一次只能监控一个服务实例,使用 turbine 可以汇集监控信息,将聚合后的信息提供给 hystrix dashboard 来集中展示和监控

    新建 sp10-turbine 项目

    新建项目

    选择依赖

    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.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<artifactId>sp10-turbine</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>sp10-turbine</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    		<spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-turbine</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>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    spring:
      application:
        name: turbin
        
    server:
      port: 5001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    turbine:
      app-config: order-service
      cluster-name-expression: new String("default")
    

    主程序

    添加 @EnableTurbine@EnableDiscoveryClient 注解

    package cn.tedu.sp10;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.turbine.EnableTurbine;
    
    @EnableTurbine
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp10TurbineApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp10TurbineApplication.class, args);
    	}
    
    }
    

    访问测试

    监控

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    二十、zuul API网关

    zuul

    zuul API 网关,为微服务应用提供统一的对外访问接口。
    zuul 还提供过滤器,对所有微服务提供统一的请求校验。

    新建 sp11-zuul 项目

    新建项目

    添加依赖

    pom.xml

    • 需要添加 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">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<artifactId>sp11-zuul</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>sp11-zuul</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    		<spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-zuul</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>cn.tedu</groupId>
    			<artifactId>sp01-commons</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>
    	</dependencies>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    • zuul 路由配置可以省略,缺省以服务 id 作为访问路径
    spring:
      application:
        name: zuul
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    
    zuul:
      routes:
        item-service: /item-service/**
        user-service: /user-service/**
        order-service: /order-service/**
    

    主程序

    添加 @EnableZuulProxy@EnableDiscoveryClient 注解

    package cn.tedu.sp11;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
    
    @EnableZuulProxy
    @EnableDiscoveryClient
    @SpringBootApplication
    public class Sp11ZuulApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp11ZuulApplication.class, args);
    	}
    
    }
    

    启动服务,访问测试

    启动服务

    zuul + ribbon 负载均衡

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

    zuul + ribbon 重试

    pom.xml 添加 spring-retry 依赖

    • 需要 spring-retry 依赖
    <dependency>
    	<groupId>org.springframework.retry</groupId>
    	<artifactId>spring-retry</artifactId>
    </dependency>
    

    配置 zuul 开启重试,并配置 ribbon 重试参数

    • 需要开启重试,默认不开启
    spring:
      application:
        name: zuul
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    
    zuul:
      retryable: true
    
    #  routes:
    #    item-service: /item-service/**
    #    user-service: /user-service/**
    #    order-service: /order-service/**
        
    ribbon:
      ConnectTimeout: 1000
      ReadTimeout: 1000
      MaxAutoRetriesNextServer: 1
      MaxAutoRetries: 1
    

    zuul + hystrix 降级

    创建降级类

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

    ItemServiceFallback

    package cn.tedu.sp11.fallback;
    
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    
    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 cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Component
    public class ItemServiceFallback implements FallbackProvider {
    	@Override
    	public String getRoute() {
    	    //当执行item-service失败,
    	    //应用当前这个降级类
    		return "item-service";
    		//星号和null都表示所有微服务失败都应用当前降级类
    		//"*"; //null;
    	}
    
        //该方法返回封装降级响应的对象
        //ClientHttpResponse中封装降级响应
    	@Override
    	public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
            return response();
    	}
    
    	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.sp11.fallback;
    
    import java.io.ByteArrayInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    
    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 cn.tedu.web.util.JsonResult;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Component
    public class OrderServiceFallback implements FallbackProvider {
    	@Override
    	public String getRoute() {
    		return "order-service"; //"*"; //null;
    	}
    
    	@Override
    	public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
            return response();
    	}
    
    	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;
                }
            };
        }
    }
    
    

    降低 hystrix 超时时间,以便测试降级

    spring:
      application:
        name: zuul
        
    server:
      port: 3001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    
    zuul:
      retryable: true
        
    ribbon:
      ConnectTimeout: 1000
      ReadTimeout: 2000
      MaxAutoRetriesNextServer: 1
      MaxAutoRetries: 1
      
    hystrix:
      command:
        default:
          execution:
            isolation:
              thread:
                timeoutInMilliseconds: 500
    

    启动服务,测试降级

    http://localhost:3001/item-service/35
    降级

    zuul + hystrix 数据监控

    暴露 hystrix.stream 监控端点

    • zuul 已经包含 actuator 依赖
    management:
      endpoints:
        web:
          exposure:
            include: hystrix.stream
    

    开启监控

    启动 sp08-hystrix-dashboard,填入 zuul 的监控端点路径,开启监控

    http://localhost:4001/hystrix

    填入监控端点:
    http://localhost:3001/actuator/hystrix.stream

    监控
    必须通过zuul网关访问后台服务才会长生监控数据

    zuul + turbine 聚合监控

    修改 turbine 项目,聚合 zuul 服务实例

    
    spring:
      application:
        name: turbin
        
    server:
      port: 5001
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    turbine:
      app-config: order-service, zuul
      cluster-name-expression: new String("default")
    

    监控

    熔断测试

    ab -n 20000 -c 50 http://localhost:3001/order-service/123abc
    

    熔断

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    二十一、zuul 请求过滤

    zuul过滤器

    定义过滤器,继承 ZuulFilter

    在 sp11-zuul 项目中新建过滤器类

    package cn.tedu.sp11.filter;
    
    import javax.servlet.http.HttpServletRequest;
    
    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;
    
    @Component
    public class AccessFilter extends ZuulFilter{
    	@Override
    	public boolean shouldFilter() {
    	    //对指定的serviceid过滤,如果要过滤所有服务,直接返回 true
    	    
    		RequestContext ctx = RequestContext.getCurrentContext();
    		String serviceId = (String) ctx.get(FilterConstants.SERVICE_ID_KEY);
    		if(serviceId.equals("item-service")) {
    			return true;
    		}
    		return false;
    	}
    
    	@Override
    	public Object run() throws ZuulException {
    		RequestContext ctx = RequestContext.getCurrentContext();
    		HttpServletRequest req = ctx.getRequest();
    		String token = req.getParameter("token");
    		if (token == null) {
    			//此设置会阻止请求被路由到后台微服务
    			ctx.setSendZuulResponse(false);
    			//向客户端的响应
    			ctx.setResponseStatusCode(200);
    			ctx.setResponseBody(JsonResult.err().code(JsonResult.NOT_LOGIN).toString());
    		}
    		//zuul过滤器返回的数据设计为以后扩展使用,
    		//目前该返回值没有被使用
    		return null;
    	}
    
    	@Override
    	public String filterType() {
    		return FilterConstants.PRE_TYPE;
    	}
    
    	@Override
    	public int filterOrder() {
    	    //该过滤器顺序要 > 5,才能得到 serviceid
    		return FilterConstants.PRE_DECORATION_FILTER_ORDER+1;
    	}
    }
    

    访问测试

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    二十二、zuul Cookie过滤

    zuul 会过滤敏感 http 协议头,默认过滤以下协议头:

    • Cookie
    • Set-Cookie
    • Authorization

    可以设置 zuul 不过滤这些协议头

    zuul:
      sensitive-headers: 
    

    在这里插入图片描述

    二十三、config 配置中心

    配置中心

    yml 配置文件保存到 git 服务器,例如 github.comgitee.com

    微服务启动时,从服务器获取配置文件

    github 上存放配置文件

    新建 “Project”,命名为 config

    新建空白项目
    新建空白项目

    将sp02,sp03,sp04,sp11四个项目的yml配置文件,复制到config项目,并改名

    • item-service-dev.yml
    • user-service-dev.yml
    • order-service-dev.yml
    • zuul-dev.yml

    配置文件
    最后,清空四个项目中的application.yml文件

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

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

    item-service 启动参数:

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

    order-service 启动参数

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

    我们可以设置禁止配置中心的配置将客户端配置覆盖掉
    在四个配置文件中添加下面的配置

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

    将 config 项目上传到 github

    • 新建仓库

    新建仓库

    • 仓库命名

    仓库命名

    • 将项目分享到仓库

    分享

    • 选择新建本地仓库
    • 仓库目录选择工作空间目录下一个新目录: sp-config

    新建目录

    • 提交项目

    提交

    提交

    • 填写sp-config仓库地址

    仓库

    • 查看远程仓库文件

    远程仓库

    config 服务器

    config 配置中心从 git 下载所有配置文件。

    而其他微服务启动时从 config 配置中心获取配置信息。

    新建 sp12-config 项目

    新建项目

    选择依赖

    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.2.1.RELEASE</version>
    		<relativePath/> <!-- lookup parent from repository -->
    	</parent>
    	<groupId>cn.tedu</groupId>
    	<artifactId>sp12-config</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>sp12-config</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    		<spring-cloud.version>Hoxton.RELEASE</spring-cloud.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>
    
    		<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>
    
    	<dependencyManagement>
    		<dependencies>
    			<dependency>
    				<groupId>org.springframework.cloud</groupId>
    				<artifactId>spring-cloud-dependencies</artifactId>
    				<version>${spring-cloud.version}</version>
    				<type>pom</type>
    				<scope>import</scope>
    			</dependency>
    		</dependencies>
    	</dependencyManagement>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

    application.yml

    spring:
      application:
        name: config-server
      
      cloud:
        config:
          server:
            git:
              uri: https://github.com/你的个人路径/sp-config
              searchPaths: config
              #username: your-username
              #password: your-password
        
    server:
      port: 6001
        
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    

    主程序添加 @EnableConfigServer@EnableDiscoveryClient

    package cn.tedu.sp12;
    
    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 Sp12ConfigApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Sp12ConfigApplication.class, args);
    	}
    
    }
    

    启动,访问测试

    访问 item-service-dev.yml 可以使用以下形式:

    http://localhost:6001/item-service-dev.yml
    http://localhost:6001/item-service/dev

    测试其他文件

    http://localhost:6001/user-service/dev
    http://localhost:6001/zuul/dev
    http://localhost:6001/order-service/dev

    config 客户端

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

    • sp02-itemservice
    • sp03-userservice
    • sp04-orderservice
    • sp11-zuul

    pom.xml 添加 config 客户端依赖

    右键点击项目,编辑起步依赖,添加 config client 依赖
    编辑起步依赖

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

    在四个项目中添加 bootstrap.yml

    bootstrap.yml,引导配置文件,先于 application.yml 加载

    • item-service
    spring: 
      cloud:
        config:
          discovery:
            enabled: true
            service-id: config-server
          name: item-service
          profile: dev
          
    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:
      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:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    
    • zuul
    spring: 
      cloud:
        config:
          discovery:
            enabled: true
            service-id: config-server
          name: zuul
          profile: dev
          
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
    

    启动服务,观察从配置中心获取配置信息的日志

    启动项目

    config

    配置刷新

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

    user-service 为例演示配置刷新

    pom.xml

    user-service 的 pom.xml 中添加 actuator 依赖
    右键点击sp03-user-service项目,编辑起步依赖,添加 actuator 依赖
    编辑起步依赖

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

    yml 配置文件中暴露 refresh 端点

    • 修改 config 项目中的 user-service-dev.yml,并提交推送到远程仓库
    sp:
      user-service:
        users: "[{\"id\":7, \"username\":\"abc\",\"password\":\"123\"},{\"id\":8, \"username\":\"def\",\"password\":\"456\"},{\"id\":9, \"username\":\"ghi\",\"password\":\"789\"}]"
    
    spring:
      application:
        name: user-service
      cloud:
        config:
          override-none: true
        
    server:
      port: 8101
      
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka  
    
    management:
      endpoints:
        web:
          exposure:
            include: refresh
    

    UserServiceImpl 添加 @RefreshScope 注解

    • 只允许对添加了 @RefreshScope@ConfigurationProperties 注解的 Bean 刷新配置,可以将更新的配置数据注入到 Bean 中
    package cn.tedu.sp03.user.service;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.stereotype.Service;
    
    import com.fasterxml.jackson.core.type.TypeReference;
    import cn.tedu.sp01.pojo.User;
    import cn.tedu.sp01.service.UserService;
    import cn.tedu.web.util.JsonUtil;
    
    import lombok.extern.slf4j.Slf4j;
    
    @RefreshScope
    @Slf4j
    @Service
    public class UserServiceImpl implements UserService {
    	@Value("${sp.user-service.users}")
    	private String userJson;
    	
    	@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);
    	}
    
    	@Override
    	public void addScore(Integer id, Integer score) {
    		// 这里增加积分
    		log.info("user "+id+" - 增加积分 "+score);
    	}
    
    }
    

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

    刷新端点

    修改config项目的user-service-dev.yml文件并提交

    现在的配置数据中只有7,8,9三个测试用户的数据,没有99这个用户的数据

    sp:
      user-service:
        users: "[{\"id\":7, \"username\":\"abc\",\"password\":\"123\"},{\"id\":8, \"username\":\"def\",\"password\":\"456\"},{\"id\":9, \"username\":\"ghi\",\"password\":\"789\"},{\"id\":99, \"username\":\"aaa\",\"password\":\"111\"}]"
    

    修改后提交推送到远程仓库

    用postman访问刷新端点, 刷新配置

    postman

    访问 user-service,查看动态更新的新用户数据

    新数据

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    二十四、config bus + rabbitmq 消息总线配置刷新

    bus

    post 请求消息总线刷新端点,服务器会向 rabbitmq 发布刷新消息,接收到消息的微服务会向配置服务器请求刷新配置信息

    rabbitmq 安装笔记

    需要动态更新配置的微服务,添加 spring cloud bus 依赖,并添加 rabbitmq 连接信息

    修改以下微服务

    • sp02-item-service
    • sp03-user-service
    • sp04-order-service
    • sp11-zuul
    • sp12-config

    pom.xml 添加 spring cloud bus 依赖

    使用 STS 编辑起步依赖,分别添加 busrabbitmq 依赖

    修改5个项目
    编辑起步依赖

    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-amqp</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-bus</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-stream-binder-rabbit</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.amqp</groupId>
    			<artifactId>spring-rabbit-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    

    配置文件中添加 rabbitmq 连接信息

    在以下配置文件中修改:

    • config中的4个配置文件
    • sp12-config项目的application.yml

    注意:

    • 连接信息请修改成你的连接信息
    • config项目需要提交
    spring:
      ......
      rabbitmq:
        host: 192.168.64.140
        port: 5672
        username: admin
        password: admin
    

    config-server 暴露 bus-refresh 刷新端点

    修改 sp12-config 项目的 application.yml, 暴露bus-refresh端点

    management:
      endpoints:
        web:
          exposure:
            include: bus-refresh
    

    刷新端点

    启动服务,请求刷新端点发布刷新消息

    启动服务

    注意:

    config 本地文系统

    可以把配置文件保存在配置中心服务的 resources 目录下,直接访问本地文件

    把配置文件保存到 sp12-config 项目的 resources/config 目录下

    本地目录

    修改 application.yml 激活 native profile,并指定配置文件目录

    • 必须配置 spring.profiles.active=native 来激活本地文件系统

    • 本地路径默认:[classpath:/, classpath:/config, file:./, file:./config]

    spring:
      application:
        name: config-server
      profiles:
        active: native
      
      cloud:
        config:
          server:
            native:
              search-locations: classpath:/config
    
    #        git:
    #          uri: https://github.com/你的用户路径/sp-config
    #          searchPaths: config
    #          username: your-username
    #          password: your-password
            
        
      rabbitmq:
        host: 192.168.64.140
        port: 5672
        username: admin
        password: admin
    
        
    server:
      port: 6001
        
    eureka:
      client:
        service-url:
          defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
          
    management:
      endpoints:
        web:
          exposure:
            include: bus-refresh
    

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    二十五、sleuth 链路跟踪

    随着系统规模越来越大,微服务之间调用关系变得错综复杂,一条调用链路中可能调用多个微服务,任何一个微服务不可用都可能造整个调用过程失败

    spring cloud sleuth 可以跟踪调用链路,分析链路中每个节点的执行情况

    微服务中添加 spring cloud sleuth 依赖

    修改以下微服务的 pom.xml,添加 sleuth 依赖

    • sp02-item-service
    • sp03-user-service
    • sp04-order-service
    • sp11-zuul

    编辑起步依赖,分别 sleuth 依赖
    编辑起步依赖

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

    在控制台查看链路跟踪日志

    四个微服务的控制台日志中,可以看到以下信息:
    [服务id,请求id,span id,是否发送到zipkin]

    • 请求id:请求到达第一个微服务时生成一个请求id,该id在调用链路中会一直向后面的微服务传递
    • span id:链路中每一步微服务调用,都生成一个新的id

    [zuul,6c24c0a7a8e7281a,6c24c0a7a8e7281a,false]

    [order-service,6c24c0a7a8e7281a,993f53408ab7b6e3,false]

    [item-service,6c24c0a7a8e7281a,ce0c820204dbaae1,false]

    [user-service,6c24c0a7a8e7281a,fdd1e177f72d667b,false]

    在这里插入图片描述

    二十六、sleuth + zipkin 链路分析

    zipkin 可以收集链路跟踪数据,提供可视化的链路分析

    链路数据抽样比例

    默认 10% 的链路数据会被发送到 zipkin 服务。可以配置修改抽样比例

    spring:
      sleuth:
        sampler:
          probability: 0.1
    

    zipkin 服务

    下载 zipkin 服务器

    下载zipkin

    启动 zipkin 时,连接到 rabbitmq

    java -jar zipkin-server-2.12.9-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:admin@192.168.64.140:5672

    启动

    zipkin

    微服务添加 zipkin 起步依赖

    修改以下微服务

    • sp02-item-service
    • sp03-user-service
    • sp04-order-service
    • sp11-zuul
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zipkin</artifactId>
    </dependency>
    

    如果没有配置过 spring cloud bus,还需要添加 rabbitmq 依赖和连接信息

    启动并访问服务,访问 zipkin 查看链路分析

    zipkin

    zipkin

    zipkin

    源码: https://github.com/benwang6/spring-cloud-repo

    在这里插入图片描述

    二十七、向eureka注册正确的ip地址

    eureka客户端向eureka注册时, 会自动选择网卡, 并可能注册主机名而不是ip地址.

    下面配置可以选择正确网卡的ip向eureka进行注册.

    选择正确网卡

    服务器有多块网卡,要选择正确网卡的ip地址向eureka进行注册

    修改 bootstrap.yml

    spring:
      cloud:
        inetutils:
          ignored-interfaces: # 忽略的网卡
            - VM.*
          preferred-networks: # 要是用的网卡的网段
            - 192.168.0
    

    注册ip地址,而不是主机名

    注册时,有可能自动选择主机名进行注册,而不使用ip地址. 主机名在局域网内有可能不会被正确的解析

    最好使用ip地址进行注册,而不注册主机名

    在应用配置application.yml中配置:

    eureka:
      instance:
        prefer-ip-address: true # 使用ip进行注册
        instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port} # 界面列表中显示的格式也显示ip
    
    展开全文
  • 操作手册

    千次阅读 热门讨论 2013-12-06 15:02:21
    操作手册 1引言 1.1编写目的   这份操作手册目的在于告诉用户,本系统提供了哪些功能,以及如何正确地、有效地使用这些功能。  预期的读者:用户、系统维护人员。 1.2前景  系统的名称:机房收费系统  ...


     

                                     操作手册


    1引言

    1.1编写目的


       这份操作手册目的在于告诉用户,本系统提供了哪些功能,以及如何正确地、有效地使用这些功能。


        预期的读者:用户、系统维护人员。


    1.2前景

     系统的名称:机房收费系统

     任务提出者:学校机房管理人员

     开发者:提高班软件开发小组

     用户:机房值班教师


    1.3定义


     列出本文件中用到的专门术语的定义和外文首字母组词的原词组。


    1.4参考资料


    [1]《软件工程事务》刘学俊李继芳刘汉中编著 浙江大学出版社


    2软件征述

     2.1软件的结构


        软件的总体结构图表如下:


        

    2.2程序表   


    程序名

    编号

    助记名

    登录

    01

    login

    查看学生信息

    2.1

    Student_information

    学生余额信息

    2.2

    remaincash

    注册

    3.1

    Register

    退卡

    3.2

    Return

    学生上机信息

    3.3

    Online

    结账

    4.1

    recharge

    日账单

    4.2

    Dayinfo

    周账单

    4.3

    Weekinfo

    教师值班记录

    4.4

    ondate

    帮助

    5.1

    help


    2.3文卷表


     列出将由本系统引用、建立或更新的每个永久性文卷,说明他们各自的标识符、编号、助记名、存储媒体和存储要求。


    3安装与初始化


       由于软件简单易懂,所以直接点击安装软件的setup.exe;然后根据软件的提示进行即可。


    4运行说明

     4.1运行表


    1. 登录:完成用户登录本系统的过程。

    2. 注册:实现用户对学生账号注册的过程。

    3. /退卡:实现用户管理学生账号的功能

    4. 上机状况:实现用户管理学生上机过程。

    5. 结账:完成管理员对账号金额的核对过程。


    4.2运行步骤


    1. 用户登录系统

    2. 注册学生账号

    3. 学生上机

    4. 用户管理学生上机

    5. 管理员核对账目

    6. 账目汇总账单


    4.3运行11)说明


      在登录运行过程中,操作员只需要输入自己的帐户名和密码就可以登陆本系统。


    4.3.1运行控制


     本运行直接就进入到系统的主界面。


    4.3.2操作信息


    1. 运行目的:登录本系统

    2. 操作要求:按照提示输入相应的信息即可

    3. 启动方法:直接点击应用程序即可。

    4. 预计的运行时间:3S

    5. 与运行有联系的其他事项:暂无


        4.3.3输入输出文卷


          提供被本运行建立、更新或访问的数据文卷的有关信息:


    1. 文卷的标识符:userinfo

    2. 存留的目录表:数据库的userinfo表中保存

    3. 当用户被注销时,相应的用户信息就被消除


    4.3.4输出文段


          本运行直接就进入到系统的主界面。


    4.3.5输出文段的复制


         对由计算机产生,而后需用其他方法复制的哪些文段提供有关的信息。


    4.3.6恢复过程


        如果在本运行过程中出现故障的话,重新启动本系统即可。


    4.4运行22)说明


     在注册学生信息时,采用录入的方式进行填写学生的信息。


    4.4.1运行控制


       本运行的结束直接就保存学生的信息到后台数据。


    4.3.2操作信息


    1. 运行目的:保存学生信息。

    2. 操作要求:采用键盘输入的方式对信息进行录入。

    3. 启动方法:在系统内部点击相应的菜单即可

    4. 预计的运行时间和解题时间:3s

    5. 与运行有联系的其他事项:本运行的发生,必须在登录窗体的身份为操作员级别以上时才可发生。

       


    4.4.3输入输出文 

       提供被本运行建立、更新或访问的数据文卷的有关信息,如:

    1. 文卷的标识符:student_information

    2. 存留的目录表:数据库中

    3. 当学生卡被注销时,相关的信息也被删除。

       

    4.4.4输出文段


    1. 当录入的卡号不正确时,给予提示:卡号有误,请重新输入!

    2. 学生的备注要求在100字以内

    3. 对于学生的信息,只有操作员以上的级别才可以查看。


    4.4.5输出文段的复制

        对由计算机产生,而后需用其他方法复制的那些文段提供的有关信息。


    4.4.6恢复过程

     如果在本运行阶段出现故障后,可采取以下方法:

    1. 根据提示进行操作

    2. 等待系统响应


     

    4.5运行33)说明


      充、退卡的操作,直接通过刷卡机实现即可


    4.5.1运行控制


     充值操作直接更新学生余额。


     退卡操作直接注销学生账号


    4.5.2操作信息

      给出为操作中心的操作人员和管理人员所需要的信息,如:

    1. 运行目的:对学生账号更新或注销

    2. 操作要求:通过刷卡机刷卡即可实现相应的操作

    3. 启动方法:点击充值或退卡菜单即可

    4. 与运行有联系的其他事项:同运行2相同


     4.5.3输入-输出文卷

    1. 文卷的标识符:rechargereturn

    2. 存留的目录表:在数据库内部对相关的表进行更新

    3. 对于充值记录表,有关半年以上的记录会自动删除;学生注销的账号也会自动消除


    4.5.4输出文段


    1. 文段的标识符:recharge/return

    2. 文字容量:充值金额不得高于10000

    3. 保密要求:有关于学生账户金额的信息,只能有管理员最高级别查看

       

    4.5.5输出文段的复制


        对由计算机产生,而后需用其他方法复制的那些文段提供有关信息。


     

    4.5.6恢复过程

         

         本运行过程恢复过程与运行2相同。


    4.6运行44)说明

            

           对于学生上机信息查看,点击相应菜单即可


    4.6.1运行控制

        在本运行控制中,强制下机,会影响到主界面中的上机人数的显示、上机记录表中的学生上下机时间。


    4.6.2操作信息


    1. 运行目的:可以查看在线人数,同时可以强迫下机

    2. 操作要求:点击相关菜单操作

    3. 与运行有联系的其他事项:本运行的有关操作会影响到学生上机记录中的有关信息


     


    4.6.3输入-输出文卷


    1. 文段的标识符:online

    2. 存留的目录:有关的记录将会更新online数据表

       

    4.6.4输出文段


     大致与4.6.3相同


    4.6.5输出文段的复制


     暂无


    4.6.6恢复过程

       与运行3中的恢复过程相同


    5非常规过程


    1. 在运行过程中,出现错误时,按照提示操作即可

    2. 后台的数据需要定时的备份防止故障的发生

    3. 如果出现不可抗力的因素,如死机等故障的话,直接重新启动本系统即可。

    4. 由于本系统设计到账目的金额的汇总,所以维护人员要定期检查系统的安全性。


    6远程操作


      如果本软件能够通过远程终端控制运行,则在本章说明通过远程终端运行本软件的操作过程。


    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,490
精华内容 9,796
关键字:

操作手册