Spring Cloud入门操作手册(Greenwich)

一、创建SpringBoot项目

删除SpringBoot的src文件夹

二、commons 通用项目 1.新建 maven 项目(commons)

项目结构

pom.xml



    
        springcloud1
        cn.tedu
        0.0.1-SNAPSHOT
    
    4.0.0

    sp01-commons

    

        
            com.fasterxml.jackson.module
            jackson-module-parameter-names
            2.9.8
        

        
            com.fasterxml.jackson.datatype
            jackson-datatype-jdk8
            2.9.8
        

        
            com.fasterxml.jackson.datatype
            jackson-datatype-jsr310
            2.9.8
        

        
            com.fasterxml.jackson.datatype
            jackson-datatype-guava
            2.9.8
        

        
        
            org.projectlombok
            lombok
        

        
            javax.servlet
            javax.servlet-api
            3.1.0
        

        
            org.slf4j
            slf4j-api
            1.7.26
        

        
            org.apache.commons
            commons-lang3
            3.9

1.添加实体类 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;		   //20210812USE745678YUGHJ9485Y
	private User user;		   //用户
	private List items;  //订单的商品列表
}

2.业务接口 service

ItemService

package cn.tedu.sp01.server;

import cn.tedu.sp01.pojo.Item;
import java.util.List;

public interface ItemService {
    //获取订单中的商品列表
    List getItems(String orderId);
    //减少商品库存
    void decreaseNumbers(List list);
}

UserService

package cn.tedu.sp01.server;

import cn.tedu.sp01.pojo.User;

public interface UserService {
    //获取用户
    User getUser(Integer id);
    //增加积分
    void addScore(Integer id, Integer score);
}

OrderService

package cn.tedu.sp01.server;

import cn.tedu.sp01.pojo.Order;

public interface OrderService {
    //获取订单
    Order getOrder(String orderId);
    //添加订单
    void addOrder(Order order);
}

3.工具类 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 {

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

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

    
    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 from(URL url, Class 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 from(InputStream inputStream, Class c) {
        try {
            return mapper.readValue(inputStream, c);
        } catch (IOException e) {
            log.error("jackson from error, type: {}", c, e);
            return null;
        }
    }

    public static  V from(File file, Class 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 from(Object jsonObj, Class 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 from(String json, Class 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 from(URL url, TypeReference 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 from(InputStream inputStream, TypeReference type) {
        try {
            return mapper.readValue(inputStream, type);
        } catch (IOException e) {
            log.error("jackson from error, type: {}", type, e);
            return null;
        }
    }

    public static  V from(File file, TypeReference 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 from(Object jsonObj, TypeReference 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 from(String json, TypeReference type) {
        try {
            return mapper.readValue(json, type);
        } catch (IOException e) {
            log.error("jackson from error, json: {}, type: {}", json, type, e);
            return null;
        }
    }

    public static  String to(List list) {
        try {
            return mapper.writevalueAsString(list);
        } catch (JsonProcessingException e) {
            log.error("jackson to error, obj: {}", list, e);
            return null;
        }
    }

    public static  String to(V v) {
        try {
            return mapper.writevalueAsString(v);
        } catch (JsonProcessingException e) {
            log.error("jackson to error, obj: {}", v, e);
            return null;
        }
    }

    public static  void toFile(String path, List 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  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  ArrayList getList(String json, String key) {
        if (StringUtils.isEmpty(json)) {
            return null;
        }
        String string = getString(json, key);
        return from(string, new TypeReference>() {});
    }

    public static  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  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  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 {
    
    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;

    
    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().code(code).msg(msg);
    }
    public static  JsonResult build(int code, T data) {
        return new JsonResult().code(code).data(data);
    }
    public static  JsonResult build(int code, String msg, T data) {
        return new JsonResult().code(code).msg(msg).data(data);
    }

    public JsonResult code(int code) {
        this.code = code;
        return this;
    }
    public JsonResult msg(String msg) {
        this.msg = msg;
        return this;
    }
    public JsonResult 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  JsonResult 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);
    }
}

三、item service 商品服务 1.新建 spring boot 起步项目

选择依赖项

只选择 web

配置依赖 pom.xml

注意要填加 sp01-commons 项目依赖
注意 parent 标签中的内容需要改成父工程的



	
	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	
	
	4.0.0

	sp02-itemservice
	0.0.1-SNAPSHOT
	sp02-itemservice
	Demo project for Spring Boot
	
	
		1.8
	
	
	
	
		
			org.springframework.boot
			spring-boot-starter-web
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
		
		
		
			cn.tedu
			sp01-commons
			0.0.1-SNAPSHOT
		
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

配置 application.yml

# 向注册中心注册的名字
spring:
  application:
    name: item-service

# item   8001
# user   8101
# order  8201
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);
	}
}

2.项目结构

3.编写代码 1.ItemServiceImpl

package cn.tedu.sp02.service;

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

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

@Slf4j
@Service
public class ItemServiceImpl implements ItemService {

    @Override
    public List getItems(String orderId) {
        log.info("获取商品列表，orderId="+orderId);
        
        // Demo 数据
        ArrayList items = new ArrayList<>();
        items.add(new Item(1,"商品1",1));
        items.add(new Item(2,"商品2",4));
        items.add(new Item(3,"商品3",1));
        items.add(new Item(4,"商品4",2));
        items.add(new Item(5,"商品5",6));
        return items;
    }

    @Override
    public void decreaseNumbers(List items) {
        for (Item item : items) {
            log.info("减少库存："+item);
        }
    }
}

2.ItemController

如果存在 jackson-dataformat-xml 依赖，会根据请求协议头，可能返回 xml 或 json；可以强制返回 json:
produces=MediaType.APPLICATION_JSON_UTF8_VALUE

package cn.tedu.sp02.controller;

import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.server.ItemService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
public class ItemController {

    @Autowired
    private ItemService itemService;

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

    @GetMapping("/{orderId}")
    public JsonResult> getItems(@PathVariable String orderId) {
        log.info("server.port="+port+", orderId="+orderId);

        List items = itemService.getItems(orderId);
        return JsonResult.ok().msg("查询成功").data(items);
    }

    //@RequestBody 完整接收请求协议体数据
    @PostMapping("/decreaseNumber")
    public JsonResult decreaseNumber(@RequestBody List items) {
        itemService.decreaseNumbers(items);
        return JsonResult.ok().msg("减少库存成功");
    }

    @GetMapping("/favicon.ico")
    public void ico(){

    }
}

4.访问测试

根据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 用户服务 1.新建 spring boot 起步项目

选择依赖项

只选择 web

配置依赖 pom.xml

注意要填加 sp01-commons 项目依赖
注意 parent 标签中的内容需要改成父工程的



	
	4.0.0
	
	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	

	cn.tedu
	sp03-userservice
	0.0.1-SNAPSHOT
	sp03-userservice
	Demo project for Spring Boot

	
		1.8
	
	
	
		
			org.springframework.boot
			spring-boot-starter-web
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		

		
		
			cn.tedu
			sp01-commons
			0.0.1-SNAPSHOT
		
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

配置 application.yml

spring:
  application:
    name: user-service

# item    8001
# user    8101
# order   8201
server:
  port: 8101


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

配置主程序

默认代码，不需要修改

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

2.项目结构

3.编写代码 1.UserServiceImpl

package cn.tedu.sp03.service;

import cn.tedu.sp01.pojo.User;
import cn.tedu.sp01.server.UserService;
import cn.tedu.web.util.JsonUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.List;

@Slf4j
@Service
public class UserServiceImpl implements UserService {

    //注入 yml中配置的 demo 数据
    @Value("${sp.user-service.users}")
    private String userJson;

    @Override
    public User getUser(Integer id) {
        log.info("获取用户，id = "+id);
        //TypeReference 利用匿名内部类继承语法，写泛型类型：List
        //userJson  -->  List
        List list = JsonUtil.from(userJson, new TypeReference>() {});
        for (User u : list) {
            if (u.getId().equals(id)) {
                return u;
            }
        }
        //不是7，8，9用户，返回一个写死的用户数据
        return new User(id, "用户名："+id, "密码："+id);
    }

    @Override
    public void addScore(Integer id, Integer score) {
        //TODO 这里增加积分
        log.info("增加用户积分，id = "+id+",score = "+score);
    }
}

2.UserController

如果存在 jackson-dataformat-xml 依赖，会根据请求协议头，可能返回 xml 或 json；可以强制返回 json:
produces=MediaType.APPLICATION_JSON_UTF8_VALUE

package cn.tedu.sp03.controller;

import cn.tedu.sp01.pojo.User;
import cn.tedu.sp01.server.UserService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{userId}")
    public JsonResult getUser(@PathVariable Integer userId) {
        log.info("get user, userId="+userId);

        User user = userService.getUser(userId);
        return JsonResult.ok().msg("查询成功").data(user);
    }

    //http://localhost:8101/8/score?score=1000
    @GetMapping("/{userId}/score")
    public JsonResult addScore(
            @PathVariable Integer userId,
            Integer score) {
        userService.addScore(userId, score);
        return JsonResult.ok().msg("增加积分成功");
    }

    @GetMapping("/favicon.ico")
    public void ico(){

    }
}

4.访问测试

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

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

五、order service 订单服务 1.新建 spring boot 起步项目

选择依赖项

只选择 web

配置依赖 pom.xml

注意要填加 sp01-commons 项目依赖
注意 parent 标签中的内容需要改成父工程的



	4.0.0

	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	

	cn.tedu
	sp04-orderservice
	0.0.1-SNAPSHOT
	sp04-orderservice
	Demo project for Spring Boot

	
		1.8
	

	
		
			org.springframework.boot
			spring-boot-starter-web
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		

		
			cn.tedu
			sp01-commons
			0.0.1-SNAPSHOT
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

配置 application.yml

spring:
  application:
    name: order-service

# 8001  8101  8201
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);
	}
}

2.项目结构

3.编写代码 1.OrderServiceImpl

package cn.tedu.sp04.service;

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

@Slf4j
@Service
public class OrderServiceImpl implements OrderService {

    @Override
    public Order getOrder(String orderId) {
        log.info("获取订单，orderId = "+orderId);

        //TODO: 远程调用user-service，获取用户信息
        //TODO: 调用item-service，获取商品信息

        Order order = new Order();
        order.setId(orderId);
//        order.setItems(用户);
//        order.setItems(商品列表);
        return order;
    }

    @Override
    public void addOrder(Order order) {

        log.info("保存订单："+order);

        //TODO: 调用item-service，减少商品库存
        //TODO: 调用user-service，增加用户积分
    }
}

2.OrderController

package cn.tedu.sp04.controller;

import cn.tedu.sp01.pojo.Item;
import cn.tedu.sp01.pojo.Order;
import cn.tedu.sp01.pojo.User;
import cn.tedu.sp01.server.OrderService;
import cn.tedu.web.util.JsonResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;

@Slf4j
@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @GetMapping("/{orderId}")
    public JsonResult getOrder(@PathVariable String orderId) {
        log.info("get order, id="+orderId);

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

    @GetMapping("/add")
    public JsonResult addOrder() {
        //模拟post提交的数据
        Order order = new Order();
        order.setId("123abc");
        order.setUser(new User(8,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().msg("保存订单成功");
    }
}

4.访问测试

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

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

六、eureka 注册与发现

Eureka四条运行机制：
	1.客户端并启动时，会反复连接注册中心尝试注册，直到注册成功为止
	2.客户端每30秒发送一次心跳数据，服务器连续3次收不到一个服务心跳，会删除它的注册信息
	3.客户端每30秒拉去一次注册表，书信本次注册表缓存
	4.自我保护模式
		由于网络中断，15分钟内，85%服务器出现心跳异常，自动进入保护模式，自我保护模式下所有的注册信息都不删除
		网络恢复后，自动退出保护模式
		开发调式期间，可以关闭保护模式，避免影响调试

创建eureka项目
配置依赖 pom.xml
配置 application.yml
主程序启用 eureka 服务器
启动，访问测试

1.创建 eureka server 项目：sp05-eureka

新建 spring boot 起步项目

选择依赖项

只选择 eureka
eureka 依赖中已经包含了 ribbon

配置依赖 pom.xml

注意 parent 标签中的内容需要改成父工程的
注意删掉springcloud版本号和dependencyManagement中的内容



	
	4.0.0

	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	

	cn.tedu
	sp05-eureka
	0.0.1-SNAPSHOT
	sp05-eureka
	Demo project for Spring Boot

	
		1.8
	

	
		
			org.springframework.cloud
			spring-cloud-starter-netflix-eureka-server
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

删除如下：

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  # 针对单台服务器，不从自己拉取

配置主程序

2.修改 hosts 文件，添加 eureka 域名映射

C:WindowsSystem32driversetchosts

添加内容：

127.0.0.1       eureka1
127.0.0.1       eureka2

3.启动，并访问测试

http://eureka1:2001

七、service provider 服务提供者

修改 item-service、user-service、order-service，把微服务注册到 eureka 服务器

1.pom.xml 添加eureka依赖
2.application.yml 添加eureka注册配置
3.主程序启用eureka客户端
4.启动服务，在eureka中查看注册信息

1.pom.xml(sp05-eureka) 添加 eureka 客户端依赖


	org.springframework.cloud
	spring-cloud-starter-netflix-eureka-client

2.application.yml 添加 eureka注册配置

编码格式设置

eureka:
  client:
    service-url:
      # 可以从云服务商购买不同地点的eureka服务器
      # 自己的服务器只能写 defaultZone
      defaultZone: http://eureka1:2001/eureka

eureka.instance.lease-renewal-interval-in-seconds

心跳间隔时间，默认 30 秒
defaultZone，默认位置，可以修改为具体地理位置，比如：beiJing, shangHai, shenZhen 等，表示eureka 服务器的部署位置
eureka.client.registry-fetch-interval-seconds

拉取注册信息间隔时间，默认 30 秒

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

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

4.启动，并访问 eureka 查看注册信息

http://eureka1:2001

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

1.eureka 高可用 1.application.yml

application-eureka1.yml

# application-eureka1.yml
eureka:
  instance:
    hostname: eureka1
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka2:2002/eureka

application-eureka2.yml

# application-eureka2.yml
eureka:
  instance:
    hostname: eureka2
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka1:2001/eureka

2.STS 配置启动参数 --spring.profiles.active

eureka1 启动参数：

--spring.profiles.active=eureka1 --server.port=2001

命令行运行时添加参数：

java -jar xxx.jar --spring.profiles.active=eureka1

3.访问 eureka 服务器，查看注册信息

http://eureka1:2001/

http://eureka2:2002/

4.eureka客户端注册时，向两个服务器注册

修改以下微服务

sp02-itemservice
sp03-userservice
sp04-orderservice

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

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

2.item-service 高可用 1.application.yml

spring:
  application:
    name: item-service
    
#server:
#  port: 8001
  
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

---
spring:
  profiles: item1
  
server:
  port: 8001
---
spring:
  profiles: item2

server:
  port: 8002

2.配置启动参数

item-service-8001

--spring.profiles.active=item1

item-service-8002

--spring.profiles.active=item2

3.启动测试

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

访问两个端口测试

http://localhost:8001/35
http://localhost:8002/35

九、ribbon

ribbon 提供了负载均衡和重试功能

Feign集成Ribbon负载均衡和重试

Feign集成Ribbon，默认实现负载均衡和重试

Ribbon的重试
远程调用失败，可以自动发起重试调用

异常
服务器宕机
后台服务阻塞超时

重试参数：

MaxAutoRetries - 单台服务器的重试次数，模式0
MaxAutoRetriesNextServer - 更换服务器的次数，默认1
Readatimeout - 等待响应的超时时间，默认1000毫秒
OkToRetryonAllOperations - 是否对所有的类型都重试，默认只对GET请求重试
ConnectTimeout - 与后台服务器建立连接的等待超时时间，默认1000毫秒

1.在sp04的pom文件中添加

2.在启动类添加下面注解

测试：
http://eureka1:2001

http://localhost:8201/y45t33

十、zuul API网关

zuul API 网关，为微服务应用提供统一的对外访问接口。
zuul 还提供过滤器，对所有微服务提供统一的请求权限校验。
继承Ribbon负载均衡和重试
集成Hystrix容错和限流

1.新建spring boot项目

zuul API 网关，为微服务应用提供统一的对外访问接口

配置依赖 pom.xml

注意要填加 sp01-commons 项目依赖
注意 parent 标签中的内容需要改成父工程的
添加zuul依赖
删除 spring-cloud.version
删除 dependencyManagement



	4.0.0

	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	

	cn.tedu
	sp06-zuul
	0.0.1-SNAPSHOT
	sp06-zuul
	Demo project for Spring Boot

	
		1.8
	
	
	
		
			org.springframework.cloud
			spring-cloud-starter-netflix-eureka-client
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		

		
			org.springframework.cloud
			spring-cloud-starter-netflix-zuul
		

		
			org.springframework.retry
			spring-retry
		
		
		
			cn.tedu
			sp01-commons
			0.0.1-SNAPSHOT
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

配置 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 注解

package cn.tedu.sp06zuul;

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

@EnableZuulProxy
@EnableDiscoveryClient
@SpringBootApplication
public class Sp06ZuulApplication {

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

启动服务，访问测试

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/

2.zuul 请求过滤

1.定义过滤器，继承 ZuulFilter

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

package cn.tedu.sp06zuul.filter;

import cn.tedu.web.util.JsonResult;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import lombok.ToString;
import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Component
public class AccessFilter extends ZuulFilter {
    // 过滤器的类型：pre、route、post、error
    
    @Override
    public String filterType() {
        // return "pre";
        return FilterConstants.PRE_TYPE;
    }

    
    @Override
    public int filterOrder() {
        return 6;//第6个，前面还有5个，默认加到末尾
    }

    
    @Override
    public boolean shouldFilter() {
        // 调用后台商品服务需要检查权限
        // 调用用户额订单可以直接访问

        // 获得 RequestContext 对象
        // 从上下文对象获取范文后台服务id
        // 判断服务id是否是 "item-service"
        RequestContext ctx = RequestContext.getCurrentContext();
        String serviceId = (String) ctx.get(FilterConstants.SERVICE_ID_KEY);//相当于 "serviceId"
        return "item-service".equals(serviceId);
    }

    
    @Override
    public Object run() throws ZuulException {
        // http://localhost:3001/item-service/t45t4?token=4324huug

        // 获取请求上下文对象
        // 从上下文对象获取 request 对象
        // 接收 token 参数
        // 若没有 token，阻止继续调用，直接返回响应
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        String token = request.getParameter("token");
        if(StringUtils.isBlank(token)){
            //阻止继续调用
            ctx.setSendZuulResponse(false);

            //直接返回响应
            //JsonResult -- {code:400, msg:未登录, data:null}
            String json = JsonResult.err().code(400).msg("Not Login,未登录").toString();

            ctx.addZuulResponseHeader("Content-Type","application/json;charset=UTF-8");
            ctx.setResponseBody(json);
        }
        // zuul当前版本中，这个返回值不起任何作用
        return null;
    }
}

2.访问测试

没有token参数不允许访问
http://localhost:3001/item-service/35

有token参数可以访问
http://localhost:3001/item-service/35?token=1234

3.Zuul + Ribbon zuul + ribbon 负载均衡

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

zuul + ribbon 重试 1.pom.xml 添加 spring-retry 依赖

需要 spring-retry 依赖


	org.springframework.retry
	spring-retry

2.配置 zuul 开启重试，并配置 ribbon 重试参数

需要开启重试，默认不开启

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/**
  retryable: true

#对所有服务的通用配置
ribbon:
  MaxAutoRetries: 1

# 针对一个服务单独配置重试参数
item-service:
  ribbon:
    MaxAutoRetries: 0

OkToRetryonAllOperations=true

对连接超时、读取超时都进行重试
MaxAutoRetriesNextServer

更换实例的次数
MaxAutoRetries

当前实例重试次数，尝试失败会更换下一个实例

3.Zull + Hystrix Zull + Hystrix 降级

创建降级类

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

ItemFB - 对商品服务降级

package cn.tedu.sp06zuul.fb;

import cn.tedu.web.util.JsonResult;
import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;

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

public class ItemFB implements FallbackProvider {
    
    @Override
    public String getRoute() {
        return "item-service";//表示只针对商品降级
    }

    
    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        return new ClientHttpResponse(){

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders h = new HttpHeaders();
                h.add("Content-Type","application/json;charset=UTF-8");
                return h;
            }

            @Override
            public InputStream getBody() throws IOException {
                //JsonResult - {code:500,msg:调用商品失败，dara:null}
                String json = JsonResult.err().code(500).msg("调用商品失败").toString();

                return new ByteArrayInputStream(json.getBytes("UTF-8"));//把返回的数据封装到流中
            }

            //封装状态码和状态文本
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.INTERNAL_SERVER_ERROR;
            }

            //单独返回状态码
            @Override
            public int getRawStatusCode() throws IOException {
                return HttpStatus.INTERNAL_SERVER_ERROR.value();
            }

            //单独返回状态文本
            @Override
            public String getStatusText() throws IOException {
                return HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase();
            }

            @Override
            public void close() {
                //用来关闭下面方法中的流
                //BAIS(ByteArrayInputStream) 流中存数组的流，不占用底层系统资源，不需要关闭
            }
        };
    }
}

OrderFB - 对订单服务降级

package cn.tedu.sp06zuul.fb;

import cn.tedu.web.util.JsonResult;
import org.springframework.cloud.netflix.zuul.filters.route.FallbackProvider;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;

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

public class OrderFB implements FallbackProvider {
    
    @Override
    public String getRoute() {
        return "order-service";//表示只针对订单降级
    }

    
    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        return new ClientHttpResponse(){

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders h = new HttpHeaders();
                h.add("Content-Type","application/json;charset=UTF-8");
                return h;
            }

            @Override
            public InputStream getBody() throws IOException {
                //JsonResult - {code:500,msg:调用订单失败，dara:null}
                String json = JsonResult.err().code(500).msg("调用订单失败").toString();

                return new ByteArrayInputStream(json.getBytes("UTF-8"));//把返回的数据封装到流中
            }

            //封装状态码和状态文本
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.INTERNAL_SERVER_ERROR;
            }

            //单独返回状态码
            @Override
            public int getRawStatusCode() throws IOException {
                return HttpStatus.INTERNAL_SERVER_ERROR.value();
            }

            //单独返回状态文本
            @Override
            public String getStatusText() throws IOException {
                return HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase();
            }

            @Override
            public void close() {
                //用来关闭下面方法中的流
                //BAIS(ByteArrayInputStream) 流中存数组的流，不占用底层系统资源，不需要关闭
            }
        };
    }
}

访问测试

没有token参数不允许访问
http://localhost:3001/item-service/35

有token参数可以访问
http://localhost:3001/item-service/35?token=1234

http://localhost:3001/user-service/8
http://localhost:3001/user-service/8/score?score=1000
http://localhost:3001/order-service/8o7i6u5y4t
http://localhost:3001/order-service/add

Zull + Hystrix 熔断

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

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

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

zuul + Hystrix dashboard 监控 1.新建springboot项目 sp07-hystrix-dashboard

不添加任何依赖

项目结构

2.pom.xml



	4.0.0

	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	

	cn.tedu
	sp07-hystrix-dashboard
	0.0.1-SNAPSHOT
	sp07-hystrix-dashboard
	Demo project for Spring Boot

	
		1.8
	

	
		
			org.springframework.boot
			spring-boot-starter
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		

		
			org.springframework.cloud
			spring-cloud-starter-netflix-hystrix-dashboard
		

	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

3.yml文件

server:
  port: 4001

hystrix:
  dashboard:
    proxy-stream-allow-list:
      - localhost

4.启动项添加注解 @@EnableHystrixDashboard

package cn.tedu.sp07;

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

@EnableHystrixDashboard
@SpringBootApplication
public class Sp07HystrixDashboardApplication {

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

暴露 hystrix.stream 监控端点

zuul 已经包含 actuator 依赖
在sp06-zuul中配置文件中添加下列内容
```
management:
  endpoints:
    web:
      exposure:
     include: hystrix.stream
```
查看暴露的监控端点

http://localhost:3001/actuator
http://localhost:3001/actuator/hystrix.stream

5.开启监控

前提：
http://localhost:3001/actuator/hystrix.stream
http://localhost:3002/actuator/hystrix.stream
这两个都要有访问日志信息，若没有，则访问下面服务

访问服务
http://localhost:3001/item-service/iu56y4t3?token=46332
http://localhost:3001/user-service/8
http://localhost:3001/user-service/8/score?score=1000
http://localhost:3001/order-service/8o7i6u5y4t
http://localhost:3001/order-service/add

http://localhost:3002/item-service/iu56y4t3?token=46332
http://localhost:3002/user-service/8
http://localhost:3002/user-service/8/score?score=1000
http://localhost:3002/order-service/8o7i6u5y4t
http://localhost:3002/order-service/add

http://localhost:3001/actuator/hystrix.stream
http://localhost:3002/actuator/hystrix.stream

http://localhost:4001/hystrix

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

http://localhost:4001/hystrix

填入监控端点：

http://localhost:3001/actuator/hystrix.stream

在dos命令窗口输入下面指令ab -n 20000 -c 50 http://localhost:3001/item-service/iu56y4t3?token=uy455tg3来模仿压力测试

zuul + turbine 聚合监控

Turbine

聚合多台服务器的日志数据，提供给仪表盘显示
	1.新建模块：sp08-turbine
	2.添加依赖
		eureka client
		turbine
	3.yml配置
		聚合的服务：zuul,a,b,c 等服务
		为聚合之后的日志数据命名：new String("default")
	4.启动类注解：@EnableTurbine
	合并日志地址：http://localhost:5001/turbine.stream

1.新建springboot项目 sp08-turbine

2.pom.xml文件

添加下面依赖


	org.springframework.cloud
	spring-cloud-starter-netflix-turbine

3.yml文件

spring:
  application:
    name: turbine

# 2001 eureka
# 3001 zuul
# 4001 hystrix dashboard
server:
  port: 5001
  
eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka,http://eureka2:2002/eureka
    
turbine:
  app-config: zuul
  cluster-name-expression: new String("default")

4.启动类+注解 @EnableTurbine

package cn.tedu.sp08;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.turbine.EnableTurbine;

@EnableTurbine
@SpringBootApplication
public class Sp08TurbineApplication {

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

5.开启监控

前提：
http://localhost:3001/actuator/hystrix.stream
http://localhost:3002/actuator/hystrix.stream
这两个都要有访问日志信息，若没有，则访问下面服务

下面的是turbine的日志访问
http://localhost:5001/turbine.stream

http://localhost:4001/hystrix

在dos命令窗口输入下面指令ab -n 20000 -c 50 http://localhost:3001/item-service/iu56y4t3?token=uy455tg3来模仿压力测试

十一、config 配置中心

yml 配置文件保存到 git 服务器，例如 github.com 或 gitee.com

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

1.github 上存放配置文件在springcloud1项目下新建文件夹,命名为 config 将sp02,sp03,sp04三个项目的yml配置文件,复制到config项目,并改名

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

在复制到config中的三个yml文件中填入下列内容

将 config 项目上传到 github

commit提交

创建仓库

push推送

查看远程仓库

2.config 服务器

1.新建模块：sp-config
2.添加依赖
	- eureka client
	- config server
3.yml文件
	- 仓库的地址
	- 存放配置文件夹路径
	- 之后测试，如果有问题，果断换仓库
4.启动类注解：@EnableConfigServer

1.新建springboot项目 sp09-config

2.pom.xml

配置依赖 pom.xml

注意 parent 标签中的内容需要改成父工程的
删除 spring-cloud.version
删除 dependencyManagement



	
	
		springcloud1
		cn.tedu
		0.0.1-SNAPSHOT
	

	4.0.0

	cn.tedu
	sp09-config
	0.0.1-SNAPSHOT
	sp09-config
	Demo project for Spring Boot

	
		1.8
	

	
		
			org.springframework.cloud
			spring-cloud-config-server
		

		
			org.springframework.cloud
			spring-cloud-starter-netflix-eureka-client
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		
	

	
		
			
				org.springframework.boot
				spring-boot-maven-plugin

3.yml文件

spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/fish-river/springcloud1.git # https://gitee.com/用户名/仓库
          search-paths: /config  #/子目录/子目录

# eureka2001  zuul3001 dashboard4001  turbine5001
server:
  port: 6001

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

4.启动类 + 注解 @EnableConfigServer

package cn.tedu.sp09config;

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

@EnableConfigServer
@SpringBootApplication
public class Sp09ConfigApplication {

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

5.启动，访问测试

确认配置中心是否正确

http://eureka1:2001/ 检查是否有 config-server 的注册信息
访问配置中心的配置文件
1 http://localhost:6001/item-service/dev
2 http://localhost:6001/user-service/dev
3 http://localhost:6001/order-service/dev

3.config 客户端

1.把2，3，4的配置文件全部注释掉
2.添加依赖：config cline
3.新建配置文件：bootstrap.yml
4.添加配置：	
	- eureka地址
	- 指定配置中心的服务id：CONFIG-SERVER
	- 指定下载配置文件和profile
5.

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

sp02-itemservice
sp03-userservice
sp04-orderservice

pom.xml 添加 config 客户端依赖


	org.springframework.cloud
	spring-cloud-starter-config

在三个项目中添加 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

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

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

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

Rabbitmq

消息队列、消息服务、消息中间件、Broker

Rabbitmq
Activemq
Rocketmq 阿里
Kafka
Tubemq 腾讯

1.rabbitmq 安装

Rabbitmq安装笔记

搭建Rabbitmq服务器

克隆虚拟机"docker-base" --> rabbitmq
设置ip
```
./ip-static
ip: 192.168.64.140
```

下载 rabbitmq 镜像

docker pull rabbitmq:management

或者从 code 下载 rabbit-image.gz
上传到服务器，然后执行镜像导入
docker load -i rabbit-image.gz

启动rabbitmq容器

关闭防火墙
systemctl stop firewalld
systemctl disable firewalld

重启 docker 系统服务
systemctl restart docker

mkdir /etc/rabbitmq
vim /etc/rabbitmq/rabbitmq.conf

# 添加两行配置：
default_user = admin
default_pass = admin

docker run -d --name rabbit 
-p 5672:5672 
-p 15672:15672 
-v /etc/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf 
-e RABBITMQ_CONFIG_FILE=/etc/rabbitmq/rabbitmq.conf 
rabbitmq:management

访问管理控制台 http://192.168.64.140:15672
用户名密码是 admin

Spring Cloud入门操作手册(Greenwich)

大数据系统相关栏目本月热门文章