Springcloud Netfix学习之--服务的发现与注册

主要业务：3个业务模块
商品模块：item
用户模块:user
订单模块:order
新下了订单，增加用户积分，远程调用，订单远程调用user,获取积分，调用商品，减少库存
访问订单时，会从订单远程调用商品，调用用户

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.2.RELEASE
         
    
    cn.tedu
    springcloud1
    0.0.1-SNAPSHOT
    springcloud1
    Demo project for Spring Boot
    pom
    
        1.8
        Hoxton.SR12
    

    
        
            
                org.springframework.cloud
                spring-cloud-dependencies
                ${spring-cloud.version}
                pom
                import
            
        
    

  

新建modelu–maven项目
springcloud比maven工程多了几个依赖，还可以自己手动勾选依赖

    

        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
        

    

user,item,order
itemservice,userservice,orderservice
utils

ItemService
package cn.tedu.sp01.service;

import java.util.List;

import cn.tedu.sp01.pojo.Item;

public interface ItemService {
	List getItems(String orderId);
	void decreaseNumbers(List 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);
}

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

}

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

}

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;

	/** 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().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);
	}
}