springcloud

最新推荐文章于 2023-06-07 10:00:00 发布

mitu_echo

最新推荐文章于 2023-06-07 10:00:00 发布

阅读量75

点赞数

分类专栏： aaa

本文链接：https://blog.csdn.net/qq_15513905/article/details/118526954

版权

aaa 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

创建父子项目，父项目用来管理依赖，但不进行依赖的添加，每一个子项目就是一个功能的模块。

一：创建父项目

创建一个maven项目，作为父项目，引入springboot父依赖，管理springcloud和springcloud Alibaba 的版本。将父项目的 src删除，只留下 pom即可

<?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>com.hyn</groupId>
    <artifactId>springcloud01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>shop-common</module>
        <module>shop-product</module>
        <module>shop-order</module>
    </modules>
    <packaging>pom</packaging>

    <!-- 引入springboot父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
    </parent>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF- 8</project.reporting.outputEncoding>
        <spring-cloud.version>Hoxton.SR8</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.5.RELEASE</spring-cloud-alibaba.version>
    </properties>

    <!--
        dependencyManagement：它只负责jar的管理,不负责jar的下载，如果想下载需要再子工程中引入依赖来下载。
    -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

二：创建一个公用的子项目

公用的子项目用来存放实体类、工具类，以及一些公有的依赖的导入，这样，其他的子项目直接引入这个公有的子项目依赖，就可以无需进行依赖的引入和一些贡工具类和实体类的编写。

创建一个model、选择为maven项目、导入 lombok 依赖、mybatis-plus 依赖、fastjson依赖，fastjson 用来将json数据转换为Object类型

<?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">
    <parent>
        <artifactId>springcloud01</artifactId>
        <groupId>com.hyn</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-common</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.61</version>
        </dependency>
    </dependencies>

</project>

创建实体类包，创建 utils包，

/**
 * @program: springcloud01
 * @description: 订单实体类
 * @author: mitu_echo
 * @create: 2021-07-06 14:46
 **/

package com.hyn.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("shop_order")
public class Order {

    @TableId(type = IdType.ASSIGN_ID)
    private Long oid;
    private Integer uid;
    private String username;
    private Integer pid;
    private String pname;
    private Double pprice;
    private Integer number;
}



/**
 * @program: springcloud01
 * @description: 商品实体类
 * @author: mitu_echo
 * @create: 2021-07-06 14:44
 **/

package com.hyn.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("shop_product")
public class Product {

    @TableId(type = IdType.AUTO)
    private Integer pid;
    private String pname;
    private Double pprice;
    private Integer stock;
}



/**
 * @program: springcloud01
 * @description: 工具类
 * @author: mitu_echo
 * @create: 2021-07-06 14:49
 **/

package com.hyn.until;

import lombok.Data;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@Data
public class ReturnData<T> {

    private Integer code;
    private String msg;
    private T object;
    private List<T> data;
}

三：创建子项目，实现商品的查询功能

创建一个子项目，作为对商品操作的服务器，创建model 选择maven项目，引入公有项目的依赖、引入 mysql、引入druid依赖

<?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">
    <parent>
        <artifactId>springcloud01</artifactId>
        <groupId>com.hyn</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-product</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.hyn</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.5</version>
        </dependency>
    </dependencies>

</project>

创建一个配置文件，设置端口号、连接数据库的信息

server.port=8083
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springcloud
spring.datasource.username=root
spring.datasource.password=803929.0
logging.level.com.hyn.dao.ProductDao=debug

编写service层，和controller层，查询数据库中的商品信息并返回

/**
 * @program: springcloud01
 * @description: 控制层
 * @author: mitu_echo
 * @create: 2021-07-06 14:57
 **/

package com.hyn.controller;

import com.hyn.entity.Product;
import com.hyn.service.ProductService;
import com.hyn.until.ReturnData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/product")
public class ProductController {

    @Autowired
    private ProductService productService;

    @RequestMapping("/queryById")
    private ReturnData<Product> doQueryById(Integer pid) {

        return productService.doQueryById(pid);
    }
}



/**
 * @program: springcloud01
 * @description:
 * @author: mitu_echo
 * @create: 2021-07-06 14:55
 **/

package com.hyn.service.impl;

import com.hyn.dao.ProductDao;
import com.hyn.entity.Product;
import com.hyn.service.ProductService;
import com.hyn.until.ReturnData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ProductServiceImpl implements ProductService {

    @Autowired
    private ProductDao productDao;
    @Autowired
    private ReturnData<Product> returnData;

    @Override
    public ReturnData<Product> doQueryById(Integer pid) {

        Product product = productDao.selectById(pid);
        returnData.setObject(product);
        return returnData;
    }
}

创建主启动类，就加入 SpringBootApplciation 注解

/**
 * @program: springcloud01
 * @description: 主启动类
 * @author: mitu_echo
 * @create: 2021-07-06 14:58
 **/

package com.hyn;

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

@SpringBootApplication
public class ProductMain {

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

四：创建子项目，实现订单创建功能

创建一个订单子项目，作为对订单操作的服务器，创建model 选择maven项目，引入公有项目的依赖、引入 mysql、引入druid依赖

在这个子项目中，要进行对 shop-product 子项目的服务进行调用

<?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">
    <parent>
        <artifactId>springcloud01</artifactId>
        <groupId>com.hyn</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shop-order</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.hyn</groupId>
            <artifactId>shop-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.5</version>
        </dependency>
    </dependencies>
</project>

编写service层，进行对另一个服务的调用，使用springboot 封装的 RestTemplate 对象，要先将 RestTemplate 对象进行创建，然后交给spring容器进行管理，

/**
 * @program: springcloud01
 * @description: 主启动类
 * @author: mitu_echo
 * @create: 2021-07-06 15:09
 **/

package com.hyn;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class OrderMain {

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

    /**
     * 创建 RestTemplate 对象，并交给spring容器进行管理
     * @return
     */
    @Bean
    public RestTemplate restTemplate() {

        return new RestTemplate();
    }
}

/**
 * @program: springcloud01
 * @description:
 * @author: mitu_echo
 * @create: 2021-07-06 15:07
 **/

package com.hyn.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.hyn.dao.OrderDao;
import com.hyn.entity.Order;
import com.hyn.entity.Product;
import com.hyn.service.OrderService;
import com.hyn.until.ReturnData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import sun.dc.pr.PRError;

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderDao orderDao;
    @Autowired
    private ReturnData<Order> returnData;
    @Autowired
    private RestTemplate restTemplate;

    @Override
    public ReturnData<Order> doCreateOrder(Integer pid, Integer number) {

        // 获取到用户购买的商品id，使用商品id调用 shop-product 微服务 controller层中的方法，查询商品的信息
        // 因为是不同的服务，所以要使用 restTemplate 对象 发送 http 请求
        // 第一个参数是请求的路径，第二个参数是请求返回的结果,第三个参数是请求需要携带的参数
        ReturnData data = restTemplate.getForObject("http://localhost:8083/product/queryById?pid={pid}", ReturnData.class,pid);
        // 从返回的 ReturnData 对象中的 Object 属性中取出 Product 对象
        // 返回的是Json格式的数据 ，需要使用 fastjson 进行格式转换
        String string = JSON.toJSONString(data.getObject());
        Product product = JSONObject.parseObject(string, Product.class);
        // 创建一个 Order 对象
        Order order = new Order();
        // 给 order 对象设置值
        order.setPid(pid);
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        order.setUid(1);
        order.setUsername("迷途");
        order.setNumber(number);
        // 执行数据库操作
        int i = orderDao.insert(order);
        if (i>0) {
            returnData.setCode(200);
            returnData.setMsg("创建订单成功");
            returnData.setObject(order);
        } else {
            returnData.setCode(000);
            returnData.setMsg("创建订单失败");
        }
        return returnData;
    }
}

/**
 * @program: springcloud01
 * @description: 控制层
 * @author: mitu_echo
 * @create: 2021-07-06 15:25
 **/

package com.hyn.controller;

import com.hyn.entity.Order;
import com.hyn.service.OrderService;
import com.hyn.until.ReturnData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @RequestMapping("/createOrder")
    private ReturnData<Order> doCreateOrder(Integer pid,Integer number) {

        return orderService.doCreateOrder(pid,number);
    }
}

mitu_echo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springcloud

创建父子项目，父项目用来管理依赖，但不进行依赖的添加，每一个子项目就是一个功能的模块。一：创建父项目创建一个maven项目，作为父项目，引入springboot父依赖，管理springcloud和springcloud Alibaba 的版本。将父项目的 src删除，只留下 pom即可<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0"
复制链接

扫一扫