投稿
  1. 首页
  2. 随笔

【二】、SpringCloud工程的搭建

手机编程 • 2022-12-17 • 随笔 • 阅读 23

【二】、SpringCloud工程的搭建,第1张

【二】、SpringCloud工程的搭建 1.开发步骤（实用）
    建module改pom写yml主启动写业务类

前后端分离，后端传json字符串给前端，前端不需要了解后端的具体业务，前端按照约定和规范判断里面的编码是不是成功，成功的话就去完成逻辑的展现

2.搭建父工程 1.新建空项目

2.在空项目中建父项目

删除src无关文件

3.配置JDK版本

4.在父工程中导入相关依赖

注意：

    父工程dependencyManagement中管理的依赖在你们仓库中可能没有，所以要注释掉dependencyManagement先下载对应版本的依赖dependencyManagement只是声明依赖，并不实现引入，因此子项目需要显示声明需要用的依赖子模块继承之后，提供作用：锁定版本并且子modlue不用写groupId和version如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并没有指定具体版本，才会从父项目中继承该项依赖，并且version和scope都取自父pom如果子项目中指定了版本号，则使用子项目指定的jar版
 
    
        UTF-8
        1.8
        1.8
        4.12
        1.2.17
        1.16.18
        8.0.27
        1.2.6
        1.3.0
    

    
    
    
    
    
        
            
            
                org.springframework.boot
                spring-boot-dependencies
                2.2.2.RELEASE
                pom
                import
            
            
            
                org.springframework.cloud
                spring-cloud-dependencies
                Hoxton.SR1
                pom
                import
            
            
            
                com.alibaba.cloud
                spring-cloud-alibaba-dependencies
                2.2.0.RELEASE
                pom
                import
            
            
            
                mysql
                mysql-connector-java
                ${mysql.version}
            
            
            
                com.alibaba
                druid-spring-boot-starter
                ${druid.verison}
            
            
            
                org.mybatis.spring.boot
                mybatis-spring-boot-starter
                ${mybatis.spring.boot.verison}
            
            
            
                org.projectlombok
                lombok
                ${lombok.version}
            
            
            
                junit
                junit
                ${junit.version}
            
            
            
                log4j
                log4j
                ${log4j.version}
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    true
                    true
5.创建数据库 
CREATE DATAbase `cloud` ;
	​
	USE `cloud`;
	​
	
	​
	DROp TABLE IF EXISTS `payment`;
	​
	CREATE TABLE `payment` (
	  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
	  `serial` varchar(200) COLLATE utf8_unicode_ci DEFAULT NULL,
	  PRIMARY KEY (`id`)
	) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
	​
	
	​
	insert  into `payment`(`id`,`serial`) values (1,'尚硅谷'),(2,'alibaba'),(3,'京东'),(4,'头条');
3.搭建cloud-provider-payment8001子工程 1.在父工程下创建cloud-provider-payment8001子工程

2.在子工程中导入相关依赖 

       
           org.springframework.boot
           spring-boot-starter-web
       
       
           org.springframework.boot
           spring-boot-starter-actuator
       
       
           org.mybatis.spring.boot
           mybatis-spring-boot-starter
       
       
           com.alibaba
           druid-spring-boot-starter
       
       
       
           mysql
           mysql-connector-java
       
       
       
           org.springframework.boot
           spring-boot-starter-jdbc
       
       
           org.springframework.boot
           spring-boot-devtools
           runtime
           true
       
       
           org.projectlombok
           lombok
           true
       
       
           org.springframework.boot
           spring-boot-starter-test
3.在子工程中新建application.yml文件

注意：

    MySQL5用的驱动url是com.mysql.jdbc.DriverMySQL6以后用的是com.mysql.cj.jdbc.Driver
server:
  port: 8001 #服务端口

spring:
  application:
  	#设置当前应用的名称，将来会在eureka中显示。将来需要该名称来获取路径
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource  #当前数据源 *** 作类型
    driver-class-name: com.mysql.cj.jdbc.Driver   #数据库驱动包
    #characterEncoding=UTF-8  指定所处理字符的解码和编码的格式
    #useSSL=false     MySQL在高版本需要指明是否进行SSL连接  1.true 需要连接  2.false 不需要连接
    #serverTimezone   配置连接数据库驱动的时区参数
        #TC代表的是全球标准时间，是以原子时计时，更加精准，适应现代社会的精确计时。
        #GMT格林威治标准时间，是指位于伦敦郊区的皇家格林尼治天文台的标准时间。
        #但是我们使用的时间是北京时区也就是东八区，领先UTC和GMT八个小时。
        #一般视为无差别，即：北京时间=UTC+8=GMT+8。
    #rewriteBatchedStatements 这个参数允许JDBC连接能够一次执行多条增删改查，假如没配这个参数的话，所有批量 *** 作都会报错。
        #MySQL的JDBC连接的url中要加rewriteBatchedStatements参数，并保证5.1.13以上版本的驱动，才能实现高性能的批量插入。
        #MySQL JDBC驱动在默认情况下会无视executeBatch()语句，
        #把我们期望批量执行的一组sql语句拆散，一条一条地发给MySQL数据库，
        #批量插入实际上是单条插入，直接造成较低的性能。
        #只有把rewriteBatchedStatements参数置为true, 驱动才会帮你批量执行SQL
        #另外这个选项对INSERT/UPDATE/DELETE都有效
    url: jdbc:mysql://localhost:3306/cloud?characterEncoding=UTF-8&&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
    username: root
    password: 123456

  devtools:
    restart:
      enabled: true

mybatis:
  #如果mapper类和mapper.xml不在同一个路径下的时候，可以指定mapper.xml的路径
  #1.classpath：只会到你的classes路径中查找找文件。
  #2.classpath*：不仅会到classes路径，还包括jar文件中(classes路径)进行查找。
  mapper-locations: classpath*:mapper
//@Data：生成@Setter、@Getter、@RequiredArgsConstructor、@ToString、@EqualsAndHashCode
@Data
//@AllArgsConstructor：生产全参构造器
@AllArgsConstructor
//@NoArgsConstructor：生产无参构造器
@NoArgsConstructor
public class Payment implements Serializable {

    BigInteger id;
    String serial;
}

Json封装体CommonResult

package com.asule.entities;

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


@Data
@AllArgsConstructor
@NoArgsConstructor
//泛型，不管传过来什么类型都可以接受并且发送给前端
public class CommonResult {

    //报错信息：404 not_found
    private Integer code;
    private String message;
    private T data;

    //当data为空的时候需要这个构造方法
    public CommonResult(Integer code,String message){
        this(code,message,null);
    }

}
5.创建dao层

    新建PaymentDao接口

    package com.asule.dao;

import com.asule.entities.Payment;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;



@Mapper
public interface PaymentDao {

    int create(Payment payment);

    
    Payment getPaymentById(@Param("id")Long id);
}

    在resources下创建mapper文件夹，并在文件夹下创建PaymentMapper.xml文件

    



    
    
        
        
    

    
    
        insert into payment(serial) values(#{serial})
6.创建服务层

    创建PaymentService接口

    package com.asule.service;

import com.asule.entities.Payment;
import org.apache.ibatis.annotations.Param;


public interface PaymentService {

    int create(Payment payment);

    Payment getPaymentById(Long id);
}

    创建PaymentServiceImpl实现类实现PaymentService接口

    package com.asule.service.impl;

import com.asule.dao.PaymentDao;
import com.asule.entities.Payment;
import com.asule.service.PaymentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


@Service
public class PaymentServiceImpl implements PaymentService {

    @Autowired
    private PaymentDao paymentDao;

    @Override
    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

    @Override
    public Payment getPaymentById(Long id) {
        return paymentDao.getPaymentById(id);
    }
}
7.创建控制层

@RestController、@Controller、@ResponseBody注解的区别
后续自己写一个自己的理解

package com.asule.controller;

import com.asule.entities.CommonResult;
import com.asule.entities.Payment;
import com.asule.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;


@RestController
//用于做日志输出
@Slf4j
@RequestMapping("/payment")
public class PaymentController {
    
    @Autowired
    private PaymentService paymentService;

    
    @PostMapping("/create")
    public CommonResult create(@RequestBody Payment payment){
        int result = paymentService.create(payment);
        log.info("插入数据的ID:t" + payment.getId());
        log.info("插入数据的结果:" + result);
        if (result > 0){
            return new CommonResult(200,"插入数据成功",result);
        }else {
            return new CommonResult(444,"插入数据失败",null);
        }
    }

    @GetMapping("/get/{id}")
    
    public CommonResult getPaymentById(@PathVariable("id") Long id){
        Payment payment = paymentService.getPaymentById(id);
        int age = 10/2;
        System.out.println(age);
        log.info("***查询结果：" + payment);
        if(payment != null){
            return new CommonResult(200,"查询数据成功",payment);
        }else {
            return new CommonResult(444,"没有对应记录",null);
        }
    }
}
8.使用Postman测试
    post测试
    get测试
4.搭建cloud-consumer-order80 1.在父工程下创建cloud-consumer-order80子工程

2.在子工程中导入相关依赖 

    
        org.springframework.boot
        spring-boot-starter-web
    
    
        org.springframework.boot
        spring-boot-starter-actuator
    
    
        org.springframework.boot
        spring-boot-devtools
        runtime
        true
    
    
        org.projectlombok
        lombok
        true
    
    
        org.springframework.boot
        spring-boot-starter-test
3.在子工程中新建application.yml文件 
server:
  port: 80
  
#设置当前应用的名称，将来会在eureka中显示。将来需要该名称来获取路径  
spring:
  application:
    name: cloud-consumer-order80
4.启动类（此后启动类代码无特殊情况不再赘述） 
package com.asule;

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


@SpringBootApplication
public class Order80Application {
    public static void main(String[] args) {
        SpringApplication.run(Order80Application.class,args);
    }
}
5.实体类与payment8001工程中相同

直接拷贝payment8001工程中的entities文件

6.使用RestTemplate完成远程调用

RestTemplate是一种简单便捷的访问restful服务的模板类，用于在Java代码里访问restful服务。

package com.asule.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;


@Configuration
public class Config {
    
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}
7.创建控制层 
package com.asule.controller;

import com.asule.entities.CommonResult;
import com.asule.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;


@RestController
@Slf4j
@RequestMapping("/consumer")
public class OrderController {

    private final static String PAYMENT_URL = "http://localhost:8001";

    @Autowired
    private RestTemplate restTemplate;
    
    @PostMapping ("/payment/create")
    public CommonResult create(Payment payment){
        return restTemplate.postForObject(PAYMENT_URL+"/payment/create",payment,CommonResult.class);
    }

    @GetMapping("/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }
}
5.工程重构

观察到的问题：系统中有重复的部分，所以要重构

    建立cloud-api-commons模块

    导入相关依赖

    
    
        org.projectlombok
        lombok
        true
    
    
        org.springframework.boot
        spring-boot-devtools
        runtime
        true
    
    
        cn.hutool
        hutool-all
        5.1.0

    将消费者和服务者中重复的部分（即entities）拷贝到新模块当中，删除消费者和服务中的重复的那部分

    clean

    install

将项目本身编译并打包到本地仓库，这样其他项目引用本项目的jar包时不用去私服上下载jar包，直接从本地就可以拿到刚刚编译打包好的项目的jar包

    在consumer和provider中引入自己所定义的包
 
       
           com.asule
           
           cloud-api-commons
           1.0-SNAPSHOT

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5709014.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
手机编程 手机编程 一级用户组
0 0
上一篇 2022-12-17
下一篇 2022-12-17

发表评论

登录后才能评论

评论列表（0条）

保存