SpringCloud微服务架构第一篇

SpringCloud是什么?

SpringCloud是分布式一站式的解决方案。
SpringCloud是微服务技术的一种落地的体现和实现。

SpringCloud和SpringBoot的区别和关系?

1.SpringBoot专注于快速方便的开发单个个体微服务。
2.SpringCloud是关注全局的微服务协调整理治理框架以及一整套的落地解决方案,它将SpringBoot开发的一个个单体微服务整合并管理起来,为各个微服务之间提供:配置管理,服务发现,断路器,路由,微代理,事件总线等的集成服务。
3.SpringBoot可以离开SpringCloud独立使用,但是SpringCloud离不开SpringBoot,属于依赖的关系。
总结:SpringBoot专注于快速,方便的开发单个微服务个体,SpringCloud关注全局的服务治理框架。

SpringCloud和Dubbo区别和对比:

SpringCloud微服务架构第一篇
很显然,SpringCloud功能比Dubbo更加强大,涵盖面更广,并且作为Spring的拳头项目,它能够与Spring Framework,SpringBoot,Spring Data等其他Spring项目完美整合,这些对于微服务而言是至关重要的。
而使用Dubbo构建的微服务架构就像组装电脑,各环节我们的选择自由度很高,但是最终很可能因为一条内存质量不行就点不亮了,而SpringCloud就像品牌机,在Spring Source的整合下,做了大量的兼容性测试,保证了机器拥有更高的稳定性,但是如果要在使用非原装组件外的东西,就需要对其基础有足够的了解。
那么最大的区别在于:SpringCloud抛弃了Dubbo的RPC通信,采用的是基于HTTP的REST方式。

SpringCloud的各类资料:

SpringCloud中文API参考使用文档
https://springcloud.cc/spring-cloud-dalston.html
SpringCloud中午API参考使用文档2:
https://springcloud.cc/spring-cloud-netflix.html
学SpringCloud能看懂上面的两个使用文档,都比你去花钱买书强!!
SpringCloud中国社区网:
http://springcloud.cn/
SpirngCloud中文网:
https://springcloud.cc/
使用SpringCloud的时候出现技术故障或者有使用疑问的都可以来这上面两个网站来进行提问。

Rest微服务项目实战:

项目介绍:承接着我们之前学的spring+springmvc+mybatis+mysql+SpringBoot,以Dept部门模块做一个微服务通用案例。
Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务

1.创建整体父工程:

1.在做案例之前,先在eclipse/IDEA里面创建一个maven的整体父工程项目名为:microservicecloud
备注:在创建整体父工程的时候Packaging要选择pom而不是选择jar
2.将需要用到的mavenjar包配置好
1<project xmlns=“http://maven.apache.org/POM/4.0.0” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
2    xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
3    <modelVersion>4.0.0</modelVersion>
4
5    <groupId>com.hhf.springcloud</groupId>
6    <artifactId>microservicecloud</artifactId>
7    <version>0.0.1-SNAPSHOT</version>
8    <packaging>pom</packaging>
9
10
11    <properties>
12        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
13        <maven.compiler.source>1.8</maven.compiler.source>
14        <maven.compiler.target>1.8</maven.compiler.target>
15        <junit.version>4.12</junit.version>
16        <log4j.version>1.2.17</log4j.version>
17        <lombok.version>1.16.18</lombok.version>
18    </properties>
19
20    <dependencyManagement>
21        <dependencies>
22            <dependency>
23                <groupId>org.springframework.cloud</groupId>
24                <artifactId>spring-cloud-dependencies</artifactId>
25                <version>Dalston.SR1</version>
26                <type>pom</type>
27                <scope>import</scope>
28            </dependency>
29            <dependency>
30                <groupId>org.springframework.boot</groupId>
31                <artifactId>spring-boot-dependencies</artifactId>
32                <version>1.5.9.RELEASE</version>
33                <type>pom</type>
34                <scope>import</scope>
35            </dependency>
36            <dependency>
37                <groupId>mysql</groupId>
38                <artifactId>mysql-connector-java</artifactId>
39                <version>5.0.4</version>
40            </dependency>
41            <dependency>
42                <groupId>com.alibaba</groupId>
43                <artifactId>druid</artifactId>
44                <version>1.0.31</version>
45            </dependency>
46            <dependency>
47                <groupId>org.mybatis.spring.boot</groupId>
48                <artifactId>mybatis-spring-boot-starter</artifactId>
49                <version>1.3.0</version>
50            </dependency>
51            <dependency>
52                <groupId>ch.qos.logback</groupId>
53                <artifactId>logback-core</artifactId>
54                <version>1.2.3</version>
55            </dependency>
56            <dependency>
57                <groupId>junit</groupId>
58                <artifactId>junit</artifactId>
59                <version>${junit.version}</version>
60                <scope>test</scope>
61            </dependency>
62            <dependency>
63                <groupId>log4j</groupId>
64                <artifactId>log4j</artifactId>
65                <version>${log4j.version}</version>
66            </dependency>
67        </dependencies>
68    </dependencyManagement>
69
70    <build>
71        <finalName>microservicecloud</finalName>
72        <resources>
73            <resource>
74                <directory>src/main/resources</directory>
75                <filtering>true</filtering>
76            </resource>
77        </resources>
78        <plugins>
79            <plugin>
80                <groupId>org.apache.maven.plugins</groupId>
81                <artifactId>maven-resources-plugin</artifactId>
82                <configuration>
83                    <delimiters>
84                        <delimit>$</delimit>
85                    </delimiters>
86                </configuration>
87            </plugin>
88        </plugins>
89    </build>
90</project>

2.创建第一个子工程(公共子模块)

3.创建好父工程并且将相应的maven配置好以后,开始创建第一个子工程的项目。
1.在已经创建好的父工程下创建公共子模块工程名为:microservicecloud-api(maven Module)
备注:创建子工程时Packaging要选择jar的打包方式。
2.在子工程中添加mavenjar包
1<project xmlns=“http://maven.apache.org/POM/4.0.0” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
2    xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
3    <modelVersion>4.0.0</modelVersion>
4
5      <!– 子类里面显示声明才能有明确的继承表现,无意外就是父类的默认版本否则自己定义 –>
6    <parent>
7        <groupId>com.hhf.springcloud</groupId>
8        <artifactId>microservicecloud</artifactId>
9        <version>0.0.1-SNAPSHOT</version>
10    </parent>
11    <!– 当前Module我自己叫什么名字 –>
12    <artifactId>microservicecloud-api</artifactId>
13
14  <!– 当前Module需要用到的jar包,按自己需求添加,如果父类已经包含了,可以不用写版本号 –>
15    <dependencies>
16        <dependency>
17            <groupId>org.projectlombok</groupId>
18            <artifactId>lombok</artifactId>
19        </dependency>
20        <dependency>
21            <groupId>org.springframework.cloud</groupId>
22            <artifactId>spring-cloud-starter-feign</artifactId>
23        </dependency>
24    </dependencies>
25</project>
4.然后在microservicecloud-api这个子项目的src/main/java下创建一个aip公共模块名为Dept的类,并且在这个类里面添加以下代码。
备注:如果无参/有参注解设置了,但最终如果无效的话,那就请用老办法方式一个个方法搞出来吧!
1//@AllArgsConstructor //全参构造注解
2@Data    //set设置值/get获取值注解
3@NoArgsConstructor //无参数构造注解
4@Accessors(chain=true//链式访问
5public class Dept {
6    //主键
7    private Long deptno; 
8    //部门名称
9    private String  dname; 
10    //来自那个数据库,因为微服务架构可以一个服务对应一个数据库,同一个信息被存储到不同数据库。
11    private String  db_source;
12
13    public Dept(String dname)
14    {
15        super();
16        this.dname = dname;
17    }
5.编写完以上代码以后,在microservicecloud-api这个子项目右键点击Run As里面列表下的maven clean和maven install,让我们的工程重新在本地库生成最新的jar包使其给其他模块引用,达到通用之目的。

3.创建第二个子工程(部门微服务提供者)

6.我们在父项目microservicecloud中再创建一个maven的module名为:microservicecloud-provider-dept-8001
1.这个microservicecloud-provider-dept-8001用来做部门服务提供者
2.在microservicecloud-provider-dept-8001这个项目的pom文件中加入以下jar包:
1<project xmlns=“http://maven.apache.org/POM/4.0.0” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
2    xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
3    <modelVersion>4.0.0</modelVersion>
4
5    <parent>
6        <groupId>com.hhf.springcloud</groupId>
7        <artifactId>microservicecloud</artifactId>
8        <version>0.0.1-SNAPSHOT</version>
9    </parent>
10
11    <artifactId>microservicecloud-provider-dept-8001</artifactId>
12
13    <dependencies>
14        <!– 引入自己定义的api通用包,可以使用Dept部门Entity –>
15        <dependency>
16            <groupId>com.hhf.springcloud</groupId>
17            <artifactId>microservicecloud-api</artifactId>
18            <version>${project.version}</version>
19        </dependency>
20        <!– actuator监控信息完善 –>
21        <dependency>
22            <groupId>org.springframework.boot</groupId>
23            <artifactId>spring-boot-starter-actuator</artifactId>
24        </dependency>
25        <!– 将微服务provider侧注册进eureka –>
26        <dependency>
27            <groupId>org.springframework.cloud</groupId>
28            <artifactId>spring-cloud-starter-eureka</artifactId>
29        </dependency>
30        <dependency>
31            <groupId>org.springframework.cloud</groupId>
32            <artifactId>spring-cloud-starter-config</artifactId>
33        </dependency>
34        <dependency>
35            <groupId>junit</groupId>
36            <artifactId>junit</artifactId>
37        </dependency>
38        <dependency>
39            <groupId>mysql</groupId>
40            <artifactId>mysql-connector-java</artifactId>
41        </dependency>
42        <dependency>
43            <groupId>com.alibaba</groupId>
44            <artifactId>druid</artifactId>
45        </dependency>
46        <dependency>
47            <groupId>ch.qos.logback</groupId>
48            <artifactId>logback-core</artifactId>
49        </dependency>
50        <dependency>
51            <groupId>org.mybatis.spring.boot</groupId>
52            <artifactId>mybatis-spring-boot-starter</artifactId>
53        </dependency>
54        <dependency>
55            <groupId>org.springframework.boot</groupId>
56            <artifactId>spring-boot-starter-jetty</artifactId>
57        </dependency>
58        <dependency>
59            <groupId>org.springframework.boot</groupId>
60            <artifactId>spring-boot-starter-web</artifactId>
61        </dependency>
62        <dependency>
63            <groupId>org.springframework.boot</groupId>
64            <artifactId>spring-boot-starter-test</artifactId>
65        </dependency>
66        <!– 修改后立即生效,热部署 –>
67        <dependency>
68            <groupId>org.springframework</groupId>
69            <artifactId>springloaded</artifactId>
70        </dependency>
71        <dependency>
72            <groupId>org.springframework.boot</groupId>
73            <artifactId>spring-boot-devtools</artifactId>
74        </dependency>
75    </dependencies>
76</project>
6.然后在microservicecloud-provider-dept-8001这个项目的resources文件下创建一个application.yml文件
将如下代码添加到application.yml中
1server:
2  port: 8001
3
4mybatis:
5  config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
6  type-aliases-package: com.hhf.springcloud.entities    # 所有Entity别名类所在包
7  mapper-locations:
8  – classpath:mybatis/mapper/**/*.xml                       # mapper映射文件
9
10spring:
11   application:
12    name: microservicecloud-dept 
13   datasource:
14    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
15    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
16    url: jdbc:mysql://localhost:3306/cloudDB01              # 数据库名称
17    username: root                                                
18    password: 520hhf
19    dbcp2:
20      min-idle: 5                                           # 数据库连接池的最小维持连接数
21      initial-size: 5                                       # 初始化连接数
22      max-total: 5                                          # 最大连接数
23      max-wait-millis: 200                                  # 等待连接获取的最大超时时间
7.然后在resources文件夹里再创建一个mybatis文件夹,在mybatis文件夹里面创建一个mybatis.cfg.xml文件。
8.在mysql中创建部门数据库脚本:
1DROP DATABASE IF EXISTS cloudDB01;
2CREATE DATABASE cloudDB01 CHARACTER SET UTF8;
3USE cloudDB01;
4
5CREATE TABLE dept
6(
7  deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT,
8  dname VARCHAR(60),
9  db_source VARCHAR(60)
10 );
11
12INSERT INTO dept(dname,db_source) VALUES(‘开发部’,DATABASE());
13INSERT INTO dept(dname,db_source) VALUES(‘人事部’,DATABASE());
14INSERT INTO dept(dname,db_source) VALUES(‘财务部’,DATABASE());
15INSERT INTO dept(dname,db_source) VALUES(‘市场部’,DATABASE());
16INSERT INTO dept(dname,db_source) VALUES(‘运维部’,DATABASE());
9.然后在microservicecloud-provider-dept-8001这个项目下的dao包下创建一个dao接口名为:DeptDao
1import com.hhf.springcloud.entities.Dept;
2import org.apache.ibatis.annotations.Mapper;
3
4import java.util.List;
5//整合mybatis
6@Mapper
7public interface DeptDao {
8
9    public boolean addDept(Dept dept);
10
11    public Dept findById(Long id);
12
13    public List<Dept> findAll();
14}
10.然后在从resources文件夹里再mybatis文件夹里面再创建一个mapper文件夹,并在mapper文件夹下创建DeptMapper.xml这个文件
1<?xml version=”1.0″ encoding=”UTF-8″ ?>
2<!DOCTYPE mapper PUBLIC “-//mybatis.org//DTD Mapper 3.0//EN”
3“http://mybatis.org/dtd/mybatis-3-mapper.dtd”>
4
5<mapper namespace=“com.hhf.springcloud.dao.DeptDao”>
6
7    <select id=“findById” resultType=“Dept” parameterType=“Long”>
8        select deptno,dname,db_source from dept where deptno=#{deptno};
9    </select>
10    <select id=“findAll” resultType=“Dept”>
11        select deptno,dname,db_source from dept;
12    </select>
13    <insert id=“addDept” parameterType=“Dept”>
14        INSERT INTO dept(dname,db_source) VALUES(#{dname},DATABASE());
15    </insert>
16</mapper>
11.然后在service包下创建DeptService部门服务接口类
1package com.hhf.springcloud.service;
2
3import com.hhf.springcloud.entities.Dept;
4
5import java.util.List;
6
7public interface DeptService {
8    public boolean add(Dept dept);
9    public Dept  get(Long id);
10    public List<Dept> list();
11}
12.当然,有了创建DeptService部门服务接口,肯定也要有它的实现类,那么在service包下在创建一个包名为:impl,在这个impl包下创建DeptServiceimpl实现类
1package com.hhf.springcloud.service.impl;
2
3import com.hhf.springcloud.dao.DeptDao;
4import com.hhf.springcloud.entities.Dept;
5import com.hhf.springcloud.service.DeptService;
6import org.springframework.beans.factory.annotation.Autowired;
7import org.springframework.stereotype.Service;
8
9import java.util.List;
10
11@Service
12public class DeptServiceimpl implements DeptService {
13    @Autowired
14    private DeptDao dao;
15
16    @Override
17    public boolean add(Dept dept)
18    {
19        return dao.addDept(dept);
20    }
21
22    @Override
23    public Dept get(Long id)
24    {
25        return dao.findById(id);
26    }
27
28    @Override
29    public List<Dept> list()
30    {
31        return dao.findAll();
32    }
33
34}
13.好,接下来我们在controller包下创建一个DeptController的类来实现页面数据显示
1package com.hhf.springcloud.controller;
2
3import com.hhf.springcloud.entities.Dept;
4import com.hhf.springcloud.service.DeptService;
5import org.springframework.beans.factory.annotation.Autowired;
6import org.springframework.web.bind.annotation.*;
7
8import java.util.List;
9
10@RestController
11public class DeptController {
12    @Autowired
13    private DeptService service;
14
15    @RequestMapping(value=“/dept/add”,method=RequestMethod.POST)
16    public boolean add(@RequestBody Dept dept)
17    {
18        return service.add(dept);
19    }
20
21    @RequestMapping(value=“/dept/get/{id}”,method=RequestMethod.GET)
22    public Dept get(@PathVariable(“id”) Long id)
23    {
24        return service.get(id);
25    }
26
27    @RequestMapping(value=“/dept/list”,method=RequestMethod.GET)
28    public List<Dept> list()
29    {
30        return service.list();
31    }
32}
14.接下来我们进入一个测试阶段,看看能不能把数据显示到页面中
在主包下创建一个名为:DeptProvider8001_App的启动类进行测试
1package com.hhf.springcloud;
2
3import org.springframework.boot.SpringApplication;
4import org.springframework.boot.autoconfigure.SpringBootApplication;
5
6@SpringBootApplication
7public class DeptProvider8001_App {
8    public static void main(String[] args) {
9        SpringApplication.run(DeptProvider8001_App.class,args);
10    }
11}
15.好,激动人心的时刻到来了!如果无误,那么我们从数据库读取的数据能够全部在页面中进行一个显示。
在浏览器输入:http://localhost:8001/dept/list    进行页面测试!
测试效果图:
SpringCloud微服务架构第一篇

4.创建第三个子工程(部门微服务消费者)

1.在整体父工程下再创建一个子工程,名为:microservicecloud-consumer-dept-80
2.在microservicecloud-consumer-dept-80子工程pom文件下添加jar包
1<project xmlns=“http://maven.apache.org/POM/4.0.0” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
2         xsi:schemaLocation=“http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
3    <modelVersion>4.0.0</modelVersion>
4
5    <parent>
6        <groupId>com.hhf.springcloud</groupId>
7        <artifactId>microservicecloud</artifactId>
8        <version>0.0.1-SNAPSHOT</version>
9    </parent>
10
11    <artifactId>microservicecloud-consumer-dept-80</artifactId>
12    <description>部门微服务消费者</description>
13
14    <dependencies>
15        <dependency>
16          <!– 自己定义的api –>
17            <groupId>com.hhf.springcloud</groupId>
18            <artifactId>microservicecloud-api</artifactId>
19            <version>${project.version}</version>
20        </dependency>
21        <dependency>
22            <groupId>org.springframework.boot</groupId>
23            <artifactId>spring-boot-starter-web</artifactId>
24        </dependency>
25        <!– 修改后立即生效,热部署 –>
26        <dependency>
27            <groupId>org.springframework</groupId>
28            <artifactId>springloaded</artifactId>
29        </dependency>
30        <dependency>
31            <groupId>org.springframework.boot</groupId>
32            <artifactId>spring-boot-devtools</artifactId>
33        </dependency>
34    </dependencies>
35</project>
3.然后在resources资源文件下创建一个application.yml文件,并添加如下内容:
1server:
2  port: 80
4.然后在java包下创建一个com.hhf.springcloud.cfgbeans包,并在此包创建一个ConfigBean类
1package com.hhf.springcloud.cfgbeans;
2
3import org.springframework.context.annotation.Bean;
4import org.springframework.context.annotation.Configuration;
5import org.springframework.web.client.RestTemplate;
6
7@Configuration
8public class ConfigBean {
9    /**
10     * RestTemplate提供了多种便捷访问远程Http服务的方法,
11     * 是一种简单便捷的访问restful服务模板类,是Spring提供的用于访问Rest服务的客户端模板工具集。
12     */
13
14    @Bean
15    public RestTemplate getRestTemplate(){
16            return new RestTemplate();
17    }
18
19}
5.并在com.hhf.springcloud包下创建一个controller包,在controller包下创建一个名为:DeptController_Consumer的类
1package com.hhf.springcloud.controller;
2
3import com.hhf.springcloud.entities.Dept;
4import org.springframework.beans.factory.annotation.Autowired;
5import org.springframework.web.bind.annotation.PathVariable;
6import org.springframework.web.bind.annotation.RequestMapping;
7import org.springframework.web.bind.annotation.RestController;
8import org.springframework.web.client.RestTemplate;
9
10import java.util.List;
11
12@RestController
13public class DeptController_Consumer {
14
15    private static final String REST_URL_PREFIX = “http://localhost:8001”;
16
17    @Autowired
18    private RestTemplate restTemplate;
19
20    @RequestMapping(value=“/consumer/dept/add”)
21    public boolean add(Dept dept)
22    {
23        return restTemplate.postForObject(REST_URL_PREFIX+“/dept/add”, dept, Boolean.class);
24    }
25
26    @RequestMapping(value=“/consumer/dept/get/{id}”)
27    public Dept get(@PathVariable(“id”) Long id)
28    {
29        return restTemplate.getForObject(REST_URL_PREFIX+“/dept/get/”+id, Dept.class);
30    }
31
32    @SuppressWarnings(“unchecked”)
33    @RequestMapping(value=“/consumer/dept/list”)
34    public List<Dept> list()
35    {
36        return restTemplate.getForObject(REST_URL_PREFIX+“/dept/list”, List.class);
37    }
38}
6.创建一个主启动类名为:DeptConsumer80_App
1package com.hhf.springcloud;
2
3import org.springframework.boot.SpringApplication;
4import org.springframework.boot.autoconfigure.SpringBootApplication;
5
6@SpringBootApplication
7public class DeptConsumer80_App {
8    public static void main(String[] args) {
9        SpringApplication.run(DeptConsumer80_App.class, args);
10    }
11}
7.激动人心的时候又到啦!!!
我们先启动microservicecloud-provider-dept-8001这个子工程下的主启动类:DeptProvider8001_App。
8.启动了DeptProvider8001_App成功以后,我们再启动microservicecloud-consumer-dept-80这个子工程下的主启动类:DeptConsumer80_App
9.然后在浏览器中进行测试:
1).在浏览器输入:
http://localhost/consumer/dept/get/2
SpringCloud微服务架构第一篇
2).在浏览器输入:
http://localhost/consumer/dept/add?dname=AI
SpringCloud微服务架构第一篇
3).然后查看你自己的mysql数据库里面有没有添加到AI这个数据
SpringCloud微服务架构第一篇
4).然后我们最后来看看浏览器中会不会显示我们新添加的数据
在浏览器输入:
http://localhost/consumer/dept/list
SpringCloud微服务架构第一篇
好,目前SpringCloud第一篇的所有内容我们已经完成,接下来也就是我们在这构建的四个工程里面去真正深入学习和使用SpringCloud的重点知识,这一块会马上更新,敬请期待!!!
本站所有文章均来自互联网,如有侵权,请联系站长删除。极客文库 » SpringCloud微服务架构第一篇
分享到:
赞(0)

评论抢沙发

评论前必须登录!