SpringCloud-Rest环境搭建

其他 2021-03-07 23:54:39 阅读次数: 0

数据库

  • 创建数据库 db01
CREATE TABLE dept(
deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
dname VARCHAR(60),
db_source VARCHAR(60)
);
INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE());
INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());
SELECT * FROM dept;

1. 创建父工程，进行依赖管理

 <dependencyManagement>
        
        <dependencies>
            <!--springcloud依赖-->
            <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--springboot依赖-->
            <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.4.3</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.23</version>
            </dependency>

            <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.5</version>
            </dependency>

            <!--springboot启动器-->
            <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.4</version>
            </dependency>

            <!--junit-->
            <!-- https://mvnrepository.com/artifact/junit/junit -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>

            <!--lombok-->
            <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <!--log4j-->
            <!-- https://mvnrepository.com/artifact/log4j/log4j -->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>

            <!--logback-->
            <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-core -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
            
        </dependencies>
    </dependencyManagement>
  • spring-cloud-dependencies和spring-boot-dependencies的作用范围设置为：< scope>import< /scope>，这样其他的相关插件的版本就可以根据cloud和boot的版本自动导入

2. 建立第一个 api Moudle，存放实体类，模拟一个服务器

  1. 导入所需要的依赖
<!--当前module所需要的依赖-->
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
  1. 编写实体类
@Data
@NoArgsConstructor
public class Dept implements Serializable {
    
    
    private long deptno;
    private String dname;
    //来自哪个数据库，因为微服务架构可以一个服务对应一个数据库，同一个信息被存到多个不同的数据库
    private String db_source;
    
    public Dept(String dname){
    
    
        this.dname = dname;
    }

}
  • tips：开启链式写法
//@Accessors(chain = true)   开启链式写法

    /**
     *链式写法
     * user.setId(1).setName("qk").setGender("男")
     */
  • 为了安全，实体类要序列化，实现Serializable接口
implements Serializable

3. 建立第二个 provider Moudle，存放mapper、service和controller三层，模拟一个服务器

  1. 导入模块所需依赖（通过pom坐标，引入第一个Moudle）
 <dependencies>
        <!--引入自定义的模块，我们就可以使用这个模块中的类了-->
        <dependency>
            <groupId>com.qk</groupId>
            <artifactId>springcloud-01-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>

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

    </dependencies>
  1. mapper层
@Mapper
@Repository
public interface DeptMapper {
    
    
    public boolean addDept(Dept dept); //添加一个部门
    public Dept queryById(Long id); //根据id查询部门
    public List<Dept> queryAll(); //查询所有部门
}
  • mapper映射文件
<?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.qk.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 deptno,dname,db_source from dept where deptno = #{deptno};
    </select>
    <select id="queryAll" resultType="Dept">
        select deptno,dname,db_source from dept;
    </select>
</mapper>
  1. service层
public interface DeptService {
    
    

    public boolean addDept(Dept dept); //添加一个部门
    public Dept queryById(Long id); //根据id查询部门
    public List<Dept> queryAll(); //查询所有部门
}
  • service层实现类
@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();
    }
}
  1. springboot配置文件
server:
  port: 8001

mybatis:
  type-aliases-package: com.qk.springcloud.pojo   #扫描api Moudle 下的实体类
  mapper-locations: classpath:mybatis/mapper/*.xml   #扫描provider Moudle 下的实体类映射文件

spring:
  application:
    name: springcloud-provider-dept   #给项目起个名字
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
  1. 编写springboot主启动类
@SpringBootApplication
public class DeptProvider_8001 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}
  1. 可以编写controller层，进行测试检验前两个Moudle是否可以顺利调用
@RestController
@RequestMapping("/dept")
public class DeptController {
    
    
    @Autowired
    private DeptService service;
    // @RequestBody
// 如果参数是放在请求体中，传入后台的话，那么后台要用@RequestBody才能接收到
    @PostMapping("/add")
    public boolean addDept(Dept dept) {
    
    
        return service.addDept(dept);
    }
    @GetMapping("/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
    
    
        return service.queryById(id);
    }
    @GetMapping("/list")
    public List<Dept> queryAll() {
    
    
        return service.queryAll();
    }
}

在这里插入图片描述
在这里插入图片描述

4. 建立第三个 consumer Moudle，调用第二个服务器的service层，模拟一个服务器

  1. 端口配置
server:
  port: 80
  1. 编写controller层
  • RestTemplate 需要自己配置，再注入
@RestController
@RequestMapping("/consumer")
public class DeptConsumerController {
    
    
    //理解：消费者，不应该有service层
    // 远程调用 调用http://localhost:8001下的数据
    // 使用RestTemplate访问restful接口非常的简单粗暴且无脑，提供多种便捷访问远程http服务的方法，简单的restful服务模板
    // getForObject （请求地址 ， 实体 ，响应类型）
    // （url，requestMap，ResponseBean.class） 这三个参数分别代表
    // REST请求地址，请求参数，Http响应转换 被 转换成的对象类型
    @Autowired
    private RestTemplate restTemplate;
    private static final String REST_URL_PREFIX = "http://localhost:8001";
    @RequestMapping("/dept/add")
    public boolean add(Dept dept){
    
    
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }
    @RequestMapping("/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
    
    
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
    }
    @RequestMapping("/dept/list")
    public List<Dept> list(){
    
    
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }
}
  1. 获取 RestTemplate
@Configuration
public class RestTemplateBean {
    
    
    @Bean
    public RestTemplate getRestTemplate(){
    
    
        return new RestTemplate();
    }
}
  • 在SpringCloud中，远程调用需要使用RestTemplate
  • RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful服务模板
    类，是Spring提供的用于访问Rest服务的客户端模板工具集
  • 使用RestTemplate访问restful接口非常的简单，（url，requsetMap，ResponseBean.class） 三个参数分别代表REST请求地址，请求参数，Http响应转换 被 转换成的对象类型
  1. 编写主启动类
@SpringBootApplication
public class DeptConsumer_80 {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

5. 完毕

在这里插入图片描述
在这里插入图片描述

对比

  • RPC（Dubbo+Zookeeper）：
    需要暴露接口，消费者有生产者相同的接口，通过@Reference远程引用生产者的service
  • SpringCloud
    只需要知道远程的url地址，通过RestTemplate的get或post等方法去请求调用service层的方法

猜你喜欢

转载自blog.csdn.net/qq_40429067/article/details/113976251
今日推荐
周排行
简述ArrayList、Vector、LinkedList三者的特点
什么是 Shell？
湖南省株洲市谷歌高清卫星地图下载
99乘法表（for循环嵌套）
pat-1027
简单算法面试题（附自己的答案）
全国乡镇边界 / 乡镇界线 / 乡镇行政面数据 分享
【JAVA】学习记录【递归查询子节点】
CSS里的BFC和IFC的用法
04.CSS3 transition属性及案例分享
每日归档
更多
2025-02-10(0)
2025-02-09(0)
2025-02-08(0)
2025-02-07(0)
2025-02-06(0)
2025-02-05(0)
2025-02-04(0)
2025-02-03(0)
2025-02-02(0)
2025-02-01(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022