2021-05-28

一、创建服务提供者

• 1、创建新Model
• 2、导入需要的pom依赖
• 3、创建YML文件
• 4、创建主启动类
• 5、处理业务逻辑
• 6、提供返回的类型

1.1、我们需要创建服务提供类

在创建类的时候最好才用规定的方式进行创建，当然由于初学阶段我们不需要太过于专业

我们创建的方式采用：springcloud-{功能}-{使用技术}-{提供或消费者}-端口号；即可

例如：springcloud-provider-payment8001 就可以啦

在开始之前先创建一个数据库：数据名称自己弄或者和我的保持一致就行啦！然后开始代码啦！！！

1.2、第一步创建一个model

名称：springcloud-provider-payment8001

1.3、修改POM

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

 
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>


</dependencies>

1.4、创建yml文件

server:
port: 8001
spring:
application:
name: cloud-payment-service
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/db2021?serverTimezone=GMT&useSSL=false
username: root
password: root

mybatis:
mapper-locations: classpath:mapper/*.xml
type-aliases-package: com.zhang.springcloud.pojo

几乎都是大家熟悉的普通配置 端口号，spring的名称，数据源，以及Mapper的映射

1.5、创建主启动类

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

1.6、创建业务逻辑

i、创建POJO实体类

package com.zhang.springcloud.pojo;

import java.io.Serializable;

public class Payment implements Serializable {
    private Long id;
    private String serial;

    public Payment() {
    }

    public Payment(Long id, String serial) {
        this.id = id;
        this.serial = serial;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getSerial() {
        return serial;
    }

    public void setSerial(String serial) {
        this.serial = serial;
    }

    @Override
    public String toString() {
        return "Payment{" +
                "id=" + id +
                ", serial='" + serial + '\'' +
                '}';
    }
}

我们还去实现了序列化，为什么要实现序列化呢？

就像我们搬桌子，桌子太大了不能通过比较小的门，所以我们要把它拆了再运进去，这个拆桌子的过程就是序列化。
而反序列化就是等我们需要用桌子的时候再把它窦起来 好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

注意：因为项目是前后端分离的我们需要传递给前端的不是对象而是一个类似网页的404 网页找不到

所以我们去新建一个类，去实现给前端放回

package com.zhang.springcloud.pojo;
//该类给前端传参

public class CommonResult<T> {
    // 404 -not find
    private Integer code;
    private String message;
    private T     data;

    public CommonResult() {
    }

    public CommonResult(Integer code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public CommonResult(Integer code, String message){
        this(code,message,null);
    }

    getter/setter......
}

ii、创建Dao类

@Mapper
public interface PaymentDao {
    public int create(Payment payment);
    public Payment byPaymentById(@Param("id") Long id);
}

注意这里最好使用Mapper注解，记得配置Mapper.xml 而且 必须被核心配置文件映射到

<mapper namespace="com.zhang.springcloud.dao.PaymentDao">
   <!--useGeneratedKeys自动生成主键  keyProperty主键声明 -->
   <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
       insert into payment(serial) values(#{serial});
   </insert>
   
    <resultMap id="BaseResultMap" type="com.zhang.springcloud.pojo.Payment">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <id column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>
    <select id="byPaymentById" parameterType="Long" resultMap="BaseResultMap">
        select * from payment where ID = #{id}
    </select>
</mapper>

iii、创建service类

public interface PaymentService {
    public int create(Payment payment);
    public Payment byPaymentById(@Param("id") Long id);
}

实现service

@Service
public class PaymentServiceImpl implements PaymentService {

    @Resource
    private PaymentDao paymentDao;

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

    @Override
    public Payment byPaymentById(Long id) {
        return paymentDao.byPaymentById(id);
    }
}

这里我们使用的是@Resource的注解

1.7、创建Controller类

package com.zhang.springcloud.controller;

import com.zhang.springcloud.pojo.CommonResult;
import com.zhang.springcloud.pojo.Payment;
import com.zhang.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

@RestController
@Slf4j
public class PaymentController {

    @Resource
    private PaymentService paymentService;
 	
    @Value("${server.port}")
    private String ServerPort;
    
    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment){
        int result = paymentService.create(payment);
        log.info("******插入结果:"+result);

        if (result>0){
           return new CommonResult(200,"插入数据库成功,serverPort"+ServerPort,result);
        }else {
            return new CommonResult(444,"插入数据库失败",null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult getPaymentById(@PathVariable("id") Long id){
        Payment payment = paymentService.byPaymentById(id);
        log.info("*****插入结果"+payment);
        int m = 10/2;
        if (payment != null){
            return new CommonResult(200,"查询成功,serverPort"+ServerPort,payment);
        }else {
            return new CommonResult(404,"没有对应记录,查询ID:"+id,null);
        }

    }
}

终于，我们的服务提供类写好啦，当然我们可以多用几个内容都是一样的所以我们就不多聊啦！！ 是不是比你想象中还要简单的很多呢？

有问题可以留言呀