Spring Cloud入门项目操作实战流程 Day01~02

〇、Service - 业务服务结构

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

一、IDEA创建项目及基本配置

以下所有案例均为 IntelliJ Idea 2020.1.4 64位版本软件截图，不同版本可能在位置上有所不同请注意！！

创建空项目（Empty Project）

此处要注意项目名和位置不要写错，如果写错会在后续实战项目中遇到麻烦。

配置JDK和语言等级

这里默认是 No SDK 和 等级11 的，我们需要将 JDK 和 语言等级 设置成 1.8 和 8 。

项目必要设定（主要是为了省事）

在创建新项目之前可以先自定义新建项目的预设，或者后期创建项目以后在Settings选项中调整也行。

这里将自动Build和编译选上，主要是方便找错

这里修改一下项目的编码，一般使用UTF-8，若使用默认项目配置文件里中文注释可能无法识别导致无法启动项目。

在这里修改Maven项目的Meven配置文件（settings.xml）和Maven的本地仓库（建议一定要修改，默认c盘很伤）

在这里调整Java编码版本，推荐version选择 8

最后下载几个关键插件
1.EditStarters 2.Free Mybatis Plugin 3.Lombok 4.Maven Helper

后期还有一些代码习惯上的配置就在项目里面再去修改就可以了

二、Commons 通用项目模块

创建新的Maven项目

新建Maven项目以后下一步会到如下配置界面，Name和GroupId其实无所谓，见名知意即可
最重要的是本地位置（Location）处 不能默认路径，要选之前创建的空目录下

修改pom.xml文件

主要是添加一部分依赖和build

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

Commons 项目结构

entity目录代码(复制即可)

Item 类

package com.jt.sp01.entity;

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 com.jt.sp01.entity;

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 com.jt.sp01.entity;

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

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order {
   
    private Integer id;
    private User user;
    private List<Item> items;
}

service目录代码(复制即可)

ItemService接口

package com.jt.sp01.service;

import java.util.List;
import com.jt.sp01.entity.Item;

public interface ItemService {
   
    List<Item> getItems(String orderId);
    void decreaseNumbers(List<Item> list);
}

UserService接口

package com.jt.sp01.service;

import com.jt.sp01.entity.User;

public interface UserService {
   
    User getUser(Integer id);
    void addScore(Integer id, Integer score);
}

OrderService接口

package com.jt.sp01.service;

import com.jt.sp01.entity.Order;

public interface OrderService {
   
    Order getOrder(String orderId);
    void addOrder(Order order);
}

web.util工具包目录代码(复制)

CookieUtil工具类

package com.jt.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 com.jt.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.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());
    }
    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