五阶段--day01--1--搭建springcloud 业务模块

最新推荐文章于 2024-09-09 00:20:36 发布
最新推荐文章于 2024-09-09 00:20:36 发布
阅读量149 收藏
点赞数
分类专栏： 五阶段 文章标签： maven java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58580280/article/details/120194225
版权

一 搭建springcloud 业务模块

1 新建maven配置

  • File-->new project seetings -->settings for new project
  • 这里配置好,每次新建工程,都应用这个配置

1 新建Empty project 工程: springcloud1

2  新建maven模块:sp01-commons  ,用于存放业务模块中的通用代码

 3.配置maven环境,基础环境配置

 在这里插入图片描述

 JDK版本:8在这里插入图片描述

 工程编码:在这里插入图片描述

4.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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.tedu</groupId>
    <artifactId>sp01-commons</artifactId>
    <version>1.0-SNAPSHOT</version>
    <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>
           <1-- <version>1.18.18</version> 这个版本可能导致找不到符号,就使用12版本-->
            <version>1.18.12</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>

5.编辑代码

5.1 商品/用户/订单实体类--model层

创建enity包,也就是pojo包封装数据

第一步:创建商品类

package cn.tedu.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;
}

第二步:创建用户类

package cn.tedu.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;
}

第三步:创建订单类

package cn.tedu.sp01.entity;

import java.util.List;

/*订单类*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order {
    private String id;
    private User user; //订单所属的用户
    private List<Item> items;//购买的商品列表,因为用户不只购买一两个商品
}

 三个服务

 在这里插入图片描述

 5.2 三个业务接口--业务层service        

service包创建接口

第一步:商品业务

package cn.tedu.sp01.service;

import cn.tedu.sp01.entity.Item;

import java.util.List;
/*商品业务*/
public interface ItemService {
    //获取一个订单中的商品列表
    List<Item> getItems(String orderId);

    //减少商品库存
    void decreaseNumber(List<Item> items);


}

第二步:用户业务

package cn.tedu.sp01.service;

import cn.tedu.sp01.entity.User;

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

   第三步:用户的订单业务

package cn.tedu.sp01.service;

import cn.tedu.sp01.entity.Order;
/*订单接口*/
public interface OrderService {
    //获取订单
    Order getOrder(String orderId);
    //添加订单
    void addOrder(Order order);
}

6 三个工具类:CookieUtil  /  JsonUtil    /JsonResult

创建cn.tedu.web.util包,其中web包和sp1包同级

这三个工具类以后直接复制粘贴即可

第一步:创建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);
    }
}

错误说明:

 二 商品模块

第一步:新建spring模块:sp02-itemservice

注意:修改版本

 

第二步:在sp02工程的pom文件添加sp01工程的通用代码

 <!--依赖通用项目sp01的代码-->
        <dependency>
            <groupId>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

第三步:编辑配置文件

# 向注册中心注册的名称
spring:
  application:
    name: item-service
#item  8001
#user  8101
#order 8201
server:
  port: 8001

第四步:创建业务层cn.tedu.service包,创建ItemServiceImpl实现类

package cn.tedu.sp02.service;

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

import java.util.ArrayList;
import java.util.List;
/**商品业务接口的实现类*/
@Service
@Slf4j
public class ItemServiceImpl implements ItemService {
    @Override
    public List<Item> getItems(String orderId) {
        log.info("获取商品,order="+orderId);
        List<Item> items =new ArrayList<>();
        items.add(new Item(1,"商品1",1));
        items.add(new Item(2,"商品2",5));
        items.add(new Item(3,"商品3",2));
        items.add(new Item(4,"商品4",3));
        items.add(new Item(5,"商品5",1));
        return items;
    }

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

第五步: 创建cn.tedu.sp02.controller包,再创建ItemController类

package cn.tedu.sp02.controller;

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

import java.util.List;

@RestController
@Slf4j
public class ItemController {
    @Autowired
    private ItemService itemService;

    //直接用浏览器访问测试
    @GetMapping("/{orderId}")
    public JsonResult<List<Item>> getItems(
            @PathVariable String orderId){
        List<Item> items = itemService.getItems(orderId);
        return JsonResult.ok().data(items);
    }

    /**/
    //用 postman 测试 post 请求
    @PostMapping("decreaseNumber")
    public JsonResult<?> decreaseNumber(
            @RequestBody List<Item> items){
        itemService.decreaseNumber(items);
        return JsonResult.ok().msg("减少库存成功");
    }
}

第六步:测试

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

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

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

三 用户服务模块

 

 第一步:修改pom文件版本

添加sp01模块依赖

 <!--sp01通用项目代码依赖-->
        <dependency>
            <groupId>cn.tedu</groupId>
            <artifactId>sp01-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

 第二步:配置文件添加服务名称和端口号以及自定义用户名

spring:
  application:
    name: user-service
server:
  port: 8101
#三个测试用户数据,Demo数据: 7,8,9三个用户
#自定义的配置属性
sp:
  user-service:
    users: "[{\"id\":7, \"username\":\"abc\",\"password\":\"123\"},
            {\"id\":8, \"username\":\"def\",\"password\":\"456\"},
            {\"id\":9, \"username\":\"ghi\",\"password\":\"789\"}]"

 第三步:创建cn.tedu.sp03.service包下创建UserServiceImpl实现类

package cn.tedu.sp03.service;

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

import java.util.List;

@Service
@Slf4j
public class UserServiceImpl implements UserService {

    //注入配置文件中的自定义用户
    @Value("${sp.user-service.users}")
    private String userJson;

    @Override
    public User getUser(Integer userId) {
        //日志获取用户id
        log.info("获取用户,userId="+userId);
        //userJson -->List<User>
        List<User> list = JsonUtil.from(
                userJson, new TypeReference<List<User>>() {});//大括号是匿名内部类,继承父类类型
        for (User u : list){
            if(u.getId().equals(userId)){
                return u;
            }
        }
        return new User(userId,"用户名"+userId,"密码"+userId);
    }

    @Override
    public void addScore(Integer userId, Integer score) {
        //获取用户及用户积分
        log.info("增加用户积分,userId="+userId+",score="+score);


    }
}

第四步:创建cn.tedu.sp03.controller包,创建UserController类

package cn.tedu.sp03.controller;

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

@RestController
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{userId}")
    public JsonResult<User> getUser(
            @PathVariable Integer userId) {
        User user = userService.getUser(userId);
        return JsonResult.ok().data(user);
    }

    // /8/score?score=1000
    @GetMapping("/{userId}/score")
    public JsonResult<?> addScore(
            @PathVariable Integer userId,
            Integer score){ //提交参数和变量名一致,就不使用@RequestParam("score"),不一致就是要该注解指定
        userService.addScore(userId,score);
        return JsonResult.ok().msg("增加积分成功");
    }
}

第五步:测试

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

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

四 订单模块

 

第一步:pom.xml文件修改,添加sp01通用代码依赖

 

 第二步:配置文件修改为.yml后缀,编辑配置文件内容

#yml文件中如果写中文注释,右下角必须是UTF-8,不能是GBK
spring:
  application:
    name: order-service

server:
  port: 8201

第三步:cn.tedu.sp04创建service包,创建OrderServiceImpl实现类

package cn.tedu.sp04.service;

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

@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    @Override
    public Order getOrder(String orderId) {
        log.info("获取订单,orderId="+orderId);
        // TODO: 远程调用商品,获取商品列表
        // TODO: 远程调用用户,获取用户数据
        //等添加nacos服务注册中心时再修改
        Order order = new Order();
        order.setId(orderId);
//        order.setUser(用户数据);
//        order.setItems(商品列表);
        return order;
    }

    /*添加订单*/
    @Override
    public void addOrder(Order order) {
        //目前只做一个日志,后期会添加数据库
        log.info("添加订单:"+ order);
        // TODO: 远程调用商品,减少库存
        // TODO: 远程调用用户,增加积分
    }
}

第四步:创建cn.tedu.sp04.controller包,创建OrderController类

package cn.tedu.sp04.controller;

import cn.tedu.sp01.entity.Item;
import cn.tedu.sp01.entity.Order;
import cn.tedu.sp01.entity.User;
import cn.tedu.sp01.service.OrderService;
import cn.tedu.web.util.JsonResult;
import com.sun.org.apache.xpath.internal.operations.Or;
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;

@RestController
@Slf4j
public class OrderController {

    @Autowired
    private OrderService orderService;

    //获取订单
    @GetMapping("/{orderId}")
    public JsonResult<Order> getOrder(@PathVariable String orderId){
        Order order = orderService.getOrder(orderId);
        return JsonResult.ok().data(order);
    }
    //增加订单
    @GetMapping("/add")
    public JsonResult<?> add(){//泛型?代表没有条件,加不加都不影响
        Order order = new Order();
        order.setId("123");
        order.setUser(new User(8,null,null));
        order.setItems(Arrays.asList(new Item[]{
                new Item(1,"商品1",1),
                new Item(2,"商品2",5),
                new Item(3,"商品3",2),
                new Item(4,"商品4",3),
                new Item(5,"商品5",1),
        }));
        orderService.addOrder(order);
        return JsonResult.ok();
    }
}

第五步:测试:

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

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

心猿意码~~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搭建 springcloud 业务模块--
weixin_58678891的博客
09-10 467
文章目录spring cloud1.搭建 springcloud 业务模块2.注册中心高可用04订单，远程调用商品和用户API 网关 spring cloud 集成多种工具，解决微服务中的各种问题 -注册和发现 Nacos Eureka -远程调用 - OpenFeign 负载均衡 重试 -系统容错和限流 - Sentinel, Hystrix 降级 熔断 -错误监控 - Hystrix Dashboard、Turbine -配置中心 - Nacos、Config -链路跟踪 - Sleuth、Zipkin
day01-SpringCloud01
weixin_45444336的博客
07-14 246
0.学习目标 了解系统架构的演变 了解RPC与Http的区别 掌握HttpClient的简单使用 知道什么是SpringCloud 独立搭建Eureka注册中心 独立配置Robbin负载均衡 1.系统架构演变 随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压力。系统架构也因此也不断的演进、升级、迭代。从单一应用，到垂直拆分，到分布式服务，到SOA，以及现在火热的微服务架构，还有在Google带领下来势汹涌的Service Mesh。我们到底是该乘坐微服务的船只驶向远方，还是偏安一
SpringCloud——Day01
风间琉璃の博客
08-01 191
SpringCloud Day01 文章总结自B站狂神说Java 1. 什么是微服务 通常而言，微服务架构是一种架构模式，或者说是一种架构风格，提倡将单一的应用程序划分组成一组小的服务，每个服务独立运行在自己的进程内，服务之间相互协调，互相配置，为用户提供最终价值。每个服务都围绕着具体的业务进行构建，并且能够独立的部署到生产环境中。 简而言之：微服务就是将一个大型的项目划分为多个小型项目，项目之间相互协调，又相互制约，每个小型项目做不同的工作，共同为整个大型项目服务。 1.1 微服务与微服务架构 微服务
SpringCloud-day01-微服务场景模拟
雁迟的博客
06-04 280
一、微服务场景模拟 首先，我们需要模拟一个服务调用的场景，搭建两个工程：springcloud-provider（服务提供方）和ispringcloud-consumer（服务调用方）。方便后面学习微服务架构 服务提供方：使用mybatis操作数据库，实现对数据的增删改查；并对外提供rest接口服务。 服务消费方：使用restTemplate远程调用服务提供方的rest接口服务，获取数据。 1.1、创建项目springcloud-provider（服务提供方） pom 导入依赖
20-springCloud-day01
拒绝熬夜啊的博客
04-07 391
一. 初识SpringCloud 1.1 初识微服架构 微服务架构： "微服务”一词源于 Martin Fowler的名为 Microservices的博文,可以在他的官方博客上找到 http://martinfowler.com/articles/microservices.html 微服务是系统架构上的一种设计风格,它的主旨是将一个原本独立的系统拆分成多个小型服务,这些小型服务都在各自独立的进程中运行,服务之间一般通过 HTTP 的 RESTfuLAPI 进行通信协作。 被拆分成的每一个小型服
Spring-cloud-alibaba 系统搭建
u014614478的博客
10-26 2941
Spring-cloud-alibaba 微服务系统架构搭建，设计模块 nacos，feign，gateway，sentinel，sleuth，zipkin
day01-springcloud-nacos
qq_74289024的博客
07-13 927
单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝微服务：一种良好的分布式架构方案①优点：拆分粒度更小、服务更独立、耦合度更低②缺点：架构非常复杂，运维、监控、部署难度提高SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件。
JSD-2204-Vant-微服务-Spring Cloud-Day01
TheNewSystrm的博客
08-18 615
JSD-2204-Vant-微服务-Spring Cloud-Day01
SpringCloud-day2-Feign、Gateway
onoeono的博客
07-25 288
SpringCloud学习
SpringCloud-3-基础组件（zuul，gateway，sleuth）
m0_60875109的博客
07-29 657
微服务网关zuul，gateway的身份验证、监控、负载均衡、缓存、请求分片与管理、静态响应处理等功能； 链路追踪sleuth搭配zipkin完成微服务之间调用的链路追踪和日志记录；
JSD-2204-使用Idea启动Nacos-创建csmall项目-Dubbo-Day03
TheNewSystrm的博客
08-22 728
JSD-2204-使用Idea启动Nacos-创建csmall项目-Dubbo-Day03
【微服务】springcloud集成sleuth与zipkin实现链路追踪
congge
01-21 7138
springcloud集成sleuth与zipkin实现链路追踪
Java学习五阶段-SpringCloud入门操作手册（Hoxton）
奔跑的小猫
08-23 3792
文章目录 环境spring cloud 介绍spring cloud 技术组成Spring Cloud 对比 Dubbo一、service - 服务二、commons 通用项目新建 maven 项目pom.xmljava 源文件pojoItemUserOrder se...
基于 Spring Cloud 完整的微服务架构实战
weixin_34238642的博客
12-17 2516
基于 Spring Cloud 完整的微服务架构实战 @作者：Sheldon地址：https://github.com/zhangxd1989 本项目是一个基于 Spring Boot、Spring Cloud、Spring Oauth2 和 Spring Cloud Netflix 等框架构建的微服务项目。 技术栈 Spring bo...
Maven:简化Java项目管理的利器
weixin_52007179的博客
09-06 1329
在传统的Java项目开发中，我们经常面临一些常见问题：手动下载和管理JAR包、在不同项目间复制粘贴依赖、解决复杂的依赖关系等。这些琐碎而繁重的工作不仅耗时，还容易引入错误。Maven应运而生，旨在解决这些问题，为Java开发者提供一个标准化的项目管理和构建工具。依赖管理：通过简单的配置，自动下载和管理项目所需的所有JAR包。标准化项目结构：提供统一的目录结构，使项目更加清晰和易于维护。构建流程自动化：一键完成编译、测试、打包等操作，大大提高开发效率。跨项目重用：便于在不同项目间共享和重用代码。
Maven创建项目中的groupId, artifactId, 和 version的意思
最新发布
qq_45705626的博客
09-09 230
比如针对微服务项目，每个模块都是不一样的名字，而artifactId就是识别各个模块的，每个模块下的pom.xml都是不一样的。不同的依赖或者插件都拥有其自己的版本号，不同的版本号会有不一样的内容，团队项目中必须保证每一个人的版本必须一致。
一、Maven工程的GAVP属性及项目结构说明
weixin_58738870的博客
09-07 579
Maven 中的 GAVP 是指 GroupId、ArtifactId、Version、Packaging 等四个属性的缩写，其中前三个是必要的，而 Packaging 属性为可选项。这四个属性主要为每个项目在maven仓库总做一个标识，类似人的《姓-名》。有了具体标识，方便maven软件对项目进行管理和互相引用！gav需要我们在创建项目的时指定，p有默认值，后期通过配置文件修改。（1）GroupID 格式：com.{公司/BU }.业务线.[子业务线]，最多 4 级。
maven
zzzzzucc的博客
09-01 504
​ MAVEN_HOME 解压目录。​ PATH bin目录。
Vegaboard RV32M1RM: RISC-V开发板主控芯片详细手册
第1章"AboutThisManual"（关于本手册）提供了手册的受众指南，包括目标读者和手册组织结构。章节1.3着重介绍芯片特有的信息，区分了那些在本章内详述的特定于芯片的内容以及指向其他章节的参考资料。此外，还讲解了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值