SpringCloud学习二：实现Springboot

标签：Springboot Dept SpringCloud boot 学习 dept spring mybatis org

文章目录

一、架构
二、实战学习

2.1 第一步：SpringCloud版本选择
2.2 第二步：创建父工程
2.3 第三步：创建子工程：（用于一些公共类的直接调用）pojo管理：springcloud-api

2.3.1 导入依赖
2.3.2 创建数据库
2.3.3 创建实体类
2.3.4 使用方式

1 首先看一下本项目pom
2 其他项目需要引用
3 直接使用

2.4 第四步：创建子工程服务提供者：springcloud-provider-dept-8001

2.4.1 创建maven项目端口号加上最好
2.4.2 导入依赖
2.4.3 配置

2.4.3.1 pom配置
2.4.3.2 mybatis-config.xml配置
2.4.3.3 配置主类

2.4.4 编写 dao service controller

dao
service
DeptController

2.5 第五步：创建子工程服务消费者：springcloud-consumer-dept-80

2.5.1 创建maven项目端口号加上50最好
2.5.2 导入依赖
2.5.3 配置

pom
yml
配置类ConfigBean(RestTemplate )
配置主启动类DeptConsumer_80

2.5.4 编写 controller

DeptConsumerController

一、架构

SpringCloud学习二：实现Springboot_maven

二、实战学习

2.1 第一步：SpringCloud版本选择

SpringCloud学习二：实现Springboot_spring cloud_02

SpringCloud学习二：实现Springboot_spring cloud_03

SpringCloud学习二：实现Springboot_java_04

2.2 第二步：创建父工程

直接创建一个名为SpringCloud的Maven空项目即可

然后后面全部的项目都是父工程的一个子模块，并且都是maven的空项目

建立一个数据库：db01

SpringCloud学习二：实现Springboot_spring boot_05

pom.xml

第一步：修改打包方式为 pom

第二步：导入springcloud依赖

第三步：导入springboot依赖

第四步：导入数据库的依赖

第五步：导入数据源的依赖 用阿里巴巴的druid连接池比较好

第六步：加入springboot的启动器依赖

第七步：加入log4j的日志依赖

第八步：加入lombok 的依赖

   <!--这只是依赖管理，如果子项目需要用到依赖，只是省略了版本号而已，实际上还是要导依赖-->
    <dependencyManagement>

<?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.wu</groupId>
    <artifactId>SpringCloud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--打包方式-->
    <packaging>pom</packaging>

    <!--定义版本号-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <lombok.version>1.18.16</lombok.version>
        <log4j.version>1.2.17</log4j.version>
        <logback-core.version>1.2.3</logback-core.version>
        <mysql-connector-java.version>8.0.21</mysql-connector-java.version>
        <druid.version>1.1.23</druid.version>
        <mybatis-spring-boot-starter.version>2.1.4</mybatis-spring-boot-starter.version>
        <spring-boot-dependencies.version>2.3.8.RELEASE</spring-boot-dependencies.version>
        <spring-cloud-dependencies.version>Hoxton.SR9</spring-cloud-dependencies.version>
    </properties>

    <!--这只是依赖管理，如果子项目需要用到依赖，只是省略了版本号而已，实际上还是要导依赖-->
    <dependencyManagement>
        <dependencies>
            <!--很重要的包：springcloud的依赖-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--springboot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot-dependencies.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql-connector-java.version}</version>
            </dependency>
            <!--数据源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!--mybatis的springboot启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis-spring-boot-starter.version}</version>
            </dependency>
            <!--日志测试-->
            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback-core.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <!--打包插件-->
    </build>

</project>

2.3 第三步：创建子工程：（用于一些公共类的直接调用）pojo管理：springcloud-api

创建一个maven的Api工程就好了

SpringCloud学习二：实现Springboot_java_06

2.3.1 导入依赖

因为有父工程，所以这里的导入依赖了版本号，但是依旧要导入

<!--当前的Module自己需要的依赖，如果父依赖中已经配置了，这里就不用写了-->
<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

SpringCloud学习二：实现Springboot_spring cloud_07

2.3.2 创建数据库

SpringCloud学习二：实现Springboot_spring cloud_08

2.3.3 创建实体类

必须要实现序列化===》网络通信
@Accessors(chain = true) //链式写法就是可以连续set

@Data
@NoArgsConstructor
@Accessors(chain = true)  //链式写法
//所有的实体类务必实现序列化,通讯需求
public class Dept implements Serializable {//Dept,实体类 orm 类表关系映射
    private static final long serialVersionUID = 708560364349809174L;
    private Long deptno; //主键
    private String dname;

    //看下这个数据存在哪个数据库的字段~ 微服务 ，一个服务对应一个数据库
    //同一个信息可能存在不同的数据库
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }

}

2.3.4 使用方式

其他项目直接在pom引入本项目就好了

比如下面的服务提供者需要引用一些公共类

1 首先看一下本项目pom

SpringCloud学习二：实现Springboot_spring cloud_09

2 其他项目需要引用

SpringCloud学习二：实现Springboot_spring boot_10

3 直接使用

SpringCloud学习二：实现Springboot_maven_11

2.4 第四步：创建子工程服务提供者：springcloud-provider-dept-8001

2.4.1 创建maven项目端口号加上最好

SpringCloud学习二：实现Springboot_spring_12

2.4.2 导入依赖

我们需要拿到实体类，所以要配置api module(导入就可以用他的实体类了)
添加相关依赖

<dependencies>
    <!--我们需要拿到实体类，所以要配置api module-->
    <dependency>
        <groupId>com.kuang</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>
    <!--日志门面-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <!--test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--jetty：尝试着用这个当应用服务器，与Tomcat没什么区别-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

2.4.3 配置

2.4.3.1 pom配置

server:
  port: 8001

#mybatis配置
mybatis:
  type-aliases-package: com.wu.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#spring的配置
spring:
  application:
    name: springcloud-provider-dept  # 3个服务名称一致是前提
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource  #数据源
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/db01?useUnicode=true&characterEncoding=UTF-8&useSSL=true&serverTimezone=UTC
    username: root
    password: root

SpringCloud学习二：实现Springboot_java_13

2.4.3.2 mybatis-config.xml配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- configuration核心配置文件 -->
<configuration>
    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

SpringCloud学习二：实现Springboot_java_14

2.4.3.3 配置主类

//启动类
@SpringBootApplication
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class, args);
    }
}

2.4.4 编写 dao service controller

dao

SpringCloud学习二：实现Springboot_java_15

SpringCloud学习二：实现Springboot_spring cloud_16

@Mapper
@Repository
public interface DeptMapper {
    //添加部门
    boolean addDept(Dept dept);

    //根据ID查询部门
    Dept queryById(@Param("deptno") long id);

    //查询全部部门
    List<Dept> queryall();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.wu.springcloud.mapper.DeptMapper">
    <insert id="addDept" parameterType="Dept">
        insert into dept(dname,db_source)
        values (#{dname},DATABASE());
    </insert>

    <select id="queryById" resultType="Dept" parameterType="Long">
        select * from dept where deptno = #{deptno};
    </select>

    <select id="queryall" resultType="Dept">
        select * from dept;
    </select>
</mapper>

service

public interface DeptService {
    boolean addDept(Dept dept);

    Dept queryById(long id);

    List<Dept> queryall();

}

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;

    @Override
    public boolean addDept(Dept dept) {
        return deptMapper.addDept(dept);
    }

    @Override
    public Dept queryById(long id) {
        return deptMapper.queryById(id);
    }

    @Override
    public List<Dept> queryall() {
        return deptMapper.queryall();
    }
}

DeptController

//提供Restfull服务!!
@RestController
public class DeptController {

    @Autowired
    private DeptServiceImpl deptService;

    @PostMapping("/dept/add")
    public boolean addDept(Dept dept) {
        return deptService.addDept(dept);
    }


    @GetMapping("/dept/get/{id}")
    public Dept getDept(@PathVariable("id") Long id) {
        Dept dept = deptService.queryById(id);
        if (dept == null) {
            throw new RuntimeException("Fail");
        }
        return dept;
    }

    @GetMapping("/dept/list")
    public List<Dept> queryAll() {
        return deptService.queryall();
    }

}

2.5 第五步：创建子工程服务消费者：springcloud-consumer-dept-80

2.5.1 创建maven项目端口号加上50最好

SpringCloud学习二：实现Springboot_java_17

2.5.2 导入依赖

<!--消费者只需要  实体类  +  Web 依赖即可-->
<dependencies>
    <dependency>
        <groupId>com.wu</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

2.5.3 配置

pom

<!--消费者只需要  实体类  +  Web 依赖即可-->
<dependencies>
    <dependency>
        <groupId>com.wu</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

yml

server：
  port:80

配置类ConfigBean(RestTemplate )

这里要用到 RestTemplate ,但是它的类中没有Bean，所以我们要把它注册到Bean中

@Configuration
public class ConfigBean {  //@Configuration ... 相当于spring中的配置文件 applicationContext.xml文件
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

配置主启动类DeptConsumer_80

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

2.5.4 编写 controller

DeptConsumerController

不应该有服务层
RestTemplate 有很多方法给我们直接调用 ! 它的类中没有Bean所以要我们自己把它注册到Bean中

RestTemplate 使用方式

配置config类
@Autowired private RestTemplate restTemplate; //提供多种便捷访问远程http服务的方法，简单的restful服务模板
private static final String REST_URL_PREFIX = “http://localhost:8001”;
请求：restTemplate.getForObject(REST_URL_PREFIX + “/dept/get/” + id, Dept.class

@Controller
public class DeptConsumerController {

    //消费者 : 不因该有service层
    //RestTemplate  有很多方法给我们直接调用  !  它的类中没有Bean所以要我们自己把它注册到Bean中
    //(url, 实体：Map, Class<T> responseType)
    @Autowired
    private RestTemplate restTemplate;  //提供多种便捷访问远程http服务的方法，简单的restful服务模板

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

    @RequestMapping("/consumer/dept/get/{id}")
    @ResponseBody
    public Dept getDept(@PathVariable("id") Long id) {
        //service不在本项目中，所以要去远程项目获取
        //远程只能用  get 方式请求，那么这里也只能通过 get 方式获取
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    }

    @RequestMapping("/consumer/dept/add")
    @ResponseBody
    public boolean add(Dept dept) {
        //远程只能用  post 方式请求，那么这里也只能通过 post 方式获取
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    }

    @RequestMapping("/consumer/dept/list")
    @ResponseBody
    public List<Dept> queryAll() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }

}

最后启动服务提供者 springcloud-provider-dept-8001
然后启动服务消费者 springcloud-consumer-dept-80
通过服务消费者的url请求去获取服务提供者对应的请求，照样可以拿到

标签：Springboot,Dept,SpringCloud,boot,学习,dept,spring,mybatis,org
From： https://blog.51cto.com/u_15854304/5809336