解释一下什么是前后端分离的核心 JWT

JWT 详解

JWT是为了在网络应用中,前后端交付中,进行页面传值的一种手段。
该TOKEN 设计紧凑,安全,适用于分布式站点的单点登录。

起源

传统的HTTP协议是无状态的,一个用户,只能保存一份用户信息。
这份登录信息,会在传递的时候,无状态的传递给浏览器,告诉其保存为cookie。以便下次的时候,告诉那个用户。
即传统的给予session的前后端认证。
基于Token的鉴权机制。基于token的鉴权机制,类似于HTTP也是无状态的,不需要服务端保留,用户的信息。意味着token认证机制,不需要考虑在那台机器上登录了。
具体的流程如下
1. 用户使用用户名密码请求服务器。
2. 服务器验证,用户信息。
3. 服务器通过认证,颁发token
4. 客户端保存token。每次请求附带token。
5. 服务器端验证token值,并返回数据。

JWT 长什么样子

由三部分组成。

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

构成

第一部分我们称它为头部(header),第二部分我们称其为载荷(payload, 类似于飞机上承载的物品),第三部分是签证(signature).

头部

声明类型,这里是jwt
声明加密的算法 通常直接使用 HMAC SHA256

对头部进行加密

{
  'typ': 'JWT',
  'alg': 'HS256'
}

然后进行base64加密

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

playload

保存有效信息的地方。

通常包含三个部分

标准中注册的声明
公共的声明
私有的声明

标准中注册的声明

iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间,这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前,该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识,主要用来作为一次性token,从而回避重放攻击。

公共的声明 :

公共的声明可以添加任何的信息,一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息,因为该部分在客户端可解密.

私有的声明 :

私有声明是提供者和消费者所共同定义的声明,一般不建议存放敏感信息,因为base64是对称解密的,意味着该部分信息可以归类为明文信息。

signature

用于验证jwt是否发生了改变。

通过秘钥加密,实现jwt是否发生了更改

// javascript
var encodedString = base64UrlEncode(header) + '.' + base64UrlEncode(payload);

var signature = HMACSHA256(encodedString, 'secret'); // TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

这样通过加密实现了base64位的加密

  eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

应用

Authorization 加上 Bearer 标注

Eureka 简介

Eureka 简介


思维导图如下

 

Eureka在微服务中的位置

  Eureka 在微服务中的位置为注册中心,注册中心管理的功能有以下几点:

  1. 服务的注册。

  2. 服务的发现

  3. 服务的熔断

  4. 服务的负载

  5. 服务的降级

  按照网站的发展历史来进行说明。

  最开始,是单体应用,所有的都被封装在一个Spring Boot 中。

  如下图:

  

  后来由于维护不方便等各种原因,开始进行拆分,拆分成为一个个的类

  

  类与类之间通过new的方法相互调用。

  伴随着流量的加大,进行应用的拆分。

  应用之间通过Feign等方式进行远程调用。

  

  有了注册中心,通过注册中心的方式进行调用。

  

  这个时候的调用就变成了,项目A调用项目B的时候,先通过注册中心,找到代理的地址,通过注册中心的代理地址,找到应用B。

  两者之间相互进行调用。

  这个时候,各个应用之间,不需要知道各自的ip地址,只需要通过注册中心的方式,由注册中心,代为提供地址。

  这个时候,注册中心起到代理的作用。

  到这一步,注册中心,就有了相当多的高级功能,例如服务的注册,服务的发现,服务的负载,服务的降级。

客户端-服务端的通信方式

  这里将会主要介绍,服务注册中心的通信方式,客户端-服务端的通信方式。

  这种通信方式,有两种通信方式,分别为socket通信和Http通信这两种方式。

基础知识

Socket

  socket为一种抽象层,应用程序通过其发送和接受数据,使用socket可以把应用程序添加到网络中,与处于同一网络中的应用程序进行通信。

  具体分为流套接字,和数据报套接字。这两种套接字,分别基于Tcp,和Udp,这两种方式。

  具体通信模型为

  

Http

  Http 分为Post,Get,Delete,Put,这四种通信方式。

  这四种通信方式,分别描述了对于一个资源的增删查改。

  用一张表格进行介绍:

通信方法 链接方式 表示含义
POST /url 表示对资源的请求,其具体内容包含在请求体中
GET /url/XXXX 表示对资源的查看,其具体内容再链接上
PUT /url/XXXXX 更新,表示对资源的更新
DELETE /url/XXXX 删除,表示对资源的删除

  用一句话进行简单的描述,在Get 请求的时候,取得了该文章的主题,Post 增加了该文章,Put 对文章进行修改,Delete 表示对文章的删除。

EurekaServer 与 EurekaClient

  EurekaServer 与 EurekaClient 之间的关系如下图所示:

  

  Service Provider 与 Service Consumer 都为Eureka Client 服务的提供方和服务的消费方都通过Eureka Server 实现相关的交流通信。

EurekaServer

  

  上方为一个简单的Eureka Server

  通过在配置上增加

  @EnableEurekaServer

  并添加相关的Maven依赖

  org.springframework.cloud

  spring-cloud-starter-eureka-server

  就可以运行启该Eureka Server 。

Eureka Client

EurekaClient 为微服务的客户端,分为两个部分,分别为Service Consumer 与 Service Provider,这两种方式。
一个为微服务的服务提供方,一个为微服务的服务消费方,这两方共同作用,相辅相成,以Server 为纽带,相互联系。

客户端向注册中心注册的时候,会提供一系列的元信息,例如主机,端口,健康检查的URL,主页等,服务会不断的发送心跳信息,进行健康检查,如果某个服务在30s外仍然没有接受到注册中心的信息,将会在注册中心,移除掉该列表内容。

最为核心的一点,是健康检查

具体操作为
先添加相关的依赖

<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>


然后在启动类上添加相关的注解。

@EnableDiscoveryClient

然后再次添加相关的配置文件

server:
  port: 8101 #运行端口号
spring:
  application:
    name: eureka-client #服务名称
eureka:
  client:
    register-with-eureka: true #注册到Eureka的注册中心
    fetch-registry: true #获取注册实例列表
    service-url:
      defaultZone: http://localhost:8001/eureka/ #配置注册中心地址

启动以后,访问注册中心,会发现,已经注册到了注册中心上。

其余主流注册中心

注册中心,不单单只有,Eureka,还有其余的注册中心,例如zookeeper,consul,nacos,等。
这里进行分别的介绍。

Zookeeper


Zookeeper是 Apache Hadoop 的一个子项目,为一个树形的目录服务,支持变更推送,适合作为Dubbo的注册中心,工业强度,相当的高,可以用于生产环境。

这里进行一下流程说明:
1. 服务提供者启动时,向 /dubbo/com.foo.BarService/providers 目录下写入自己的URL地址。
2. 服务消费者启动时,向 /dubbo/com.foo.BarService/providers 读取当前服务提供者提供的地址。并向目录下/dubbo/com.foo.BarService/consumers 写入自己的URL地址。
3. 监控中心启动的时候,将会订阅所有的目录下的地址。

其地址链接格式为:

zookeeper://127.0.0.1:2181

Nacos


这里介绍Nacos注册中心。在Nacos中,最核心,最重要的是服务,Nacos几乎支持所有的主流的服务发现,配置和管理。
Nacos的关键特性包括以下几种。
1. 服务发现和服务健康监测
2. 动态配置服务
3. 动态 DNS 服务
4. 服务及其元数据管理
对于Nacos,其思维导图如下。

同属于dubbo生态范围下的,

Hello World

下载源码

git clone https://github.com/alibaba/nacos.git 
cd nacos/ 
mvn -Prelease-nacos -Dmaven.test.skip=true clean install -U 
ls -al distribution/target/ // change the $version to your actual path 
cd distribution/target/nacos-server-$version/nacos/bin

使用命令启动服务器

unzip nacos-server-$version.zip 或者 tar -xvf nacos-server-$version.tar.gz
cd nacos/bin

启动服务器

对于Linux 系统而言,直接输入

sh startup.sh -m standalone

启动服务以后,需要对服务进行注册

curl -X POST 'http://127.0.0.1:8848/nacos/v1/ns/instance?serviceName=nacos.naming.serviceName&ip=20.18.7.10&port=8080'

注册完后,服务需要发现

curl -X GET 'http://127.0.0.1:8848/nacos/v1/ns/instance/list?serviceName=nacos.naming.serviceName'

Consul

Consul也是一个注册中心,包含多个组件,主要包含以下的组件:
1. 服务发现Consul的客户端可用提供一个服务,比如 api 或者mysql ,另外一些客户端可用使用Consul去发现一个指定服务的提供者.通过DNS或者HTTP应用程序可用很容易的找到他所依赖的服务.
2. 健康检查Consul客户端可用提供任意数量的健康检查,指定一个服务(比如:webserver是否返回了200 OK 状态码)或者使用本地节点(比如:内存使用是否大于90%). 这个信息可由operator用来监视集群的健康.被服务发现组件用来避免将流量发送到不健康的主机
3. Key/Value存储应用程序可用根据自己的需要使用Consul的层级的Key/Value存储.比如动态配置,功能标记,协调,领袖选举等等,简单的HTTP API让他更易于使用.
4. 多数据中心: Consul支持开箱即用的多数据中心.这意味着用户不需要担心需要建立额外的抽象层让业务扩展到多个区域.

HelloWorld

下载安装相关的内容

wget https://releases.hashicorp.com/consul/0.7.5/consul_0.7.5_linux_amd64.zip 
[root@localhost soft]# wget  https://releases.hashicorp.com/consul/0.7.5/consul_0.7.5_linux_amd64.zip 
--2017-07-02 19:01:02--  https://releases.hashicorp.com/consul/0.7.5/consul_0.7.5_linux_amd64.zip
Resolving releases.hashicorp.com (releases.hashicorp.com)... 151.101.73.183, 2a04:4e42:11::439
Connecting to releases.hashicorp.com (releases.hashicorp.com)|151.101.73.183|:443... failed: Connection timed out.
Connecting to releases.hashicorp.com (releases.hashicorp.com)|2a04:4e42:11::439|:443... failed: Network is unreachable.
[root@localhost soft]# wget https://releases.hashicorp.com/consul/0.7.5/consul_0.7.5_linux_amd64.zip 
--2017-07-02 19:04:23--  https://releases.hashicorp.com/consul/0.7.5/consul_0.7.5_linux_amd64.zip
Resolving releases.hashicorp.com (releases.hashicorp.com)... 151.101.73.183, 2a04:4e42:11::439
Connecting to releases.hashicorp.com (releases.hashicorp.com)|151.101.73.183|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 8764587 (8.4M) [application/zip]
Saving to: 鈥榗onsul_0.7.5_linux_amd64.zip鈥

100%[==================================================================================================================================================================================================>] 8,764,587   59.4KB/s   in 3m 31s 

2017-07-02 19:07:55 (40.7 KB/s) - 鈥榗onsul_0.7.5_linux_amd64.zip鈥saved [8764587/8764587]

[root@localhost soft]# ll

解压

unzip consul_0.7.5_linux_amd64.zip

执行安装

[root@localhost soft]# ./consul
usage: consul [--version] [--help] <command> [<args>]

Available commands are:
    agent          Runs a Consul agent
    configtest     Validate config file
    event          Fire a new event
    exec           Executes a command on Consul nodes
    force-leave    Forces a member of the cluster to enter the "left" state
    info           Provides debugging information for operators
    join           Tell Consul agent to join cluster
    keygen         Generates a new encryption key
    keyring        Manages gossip layer encryption keys
    kv             Interact with the key-value store
    leave          Gracefully leaves the Consul cluster and shuts down
    lock           Execute a command holding a lock
    maint          Controls node or service maintenance mode
    members        Lists the members of a Consul cluster
    monitor        Stream logs from a Consul agent
    operator       Provides cluster-level tools for Consul operators
    reload         Triggers the agent to reload configuration files
    rtt            Estimates network round trip time between nodes
    snapshot       Saves, restores and inspects snapshots of Consul server state
    version        Prints the Consul version
    watch          Watch for changes in Consul

启动

 ./consul agent -dev -ui -node=consul-dev -client=10.11.3.161

分布式系统CAP

CAP定理指的是,对于一个分布式系统而说,不可能同时满足,一致性,可用性,以及分区容错性。

这里依次介绍,这三种特性。

一致性

所有节点的数据在同一时刻,完全一致。
一致性分为强一致性,弱一致性,最终一致性这三种。
对于强一致性而言,要求更新过的数据能被后续的访问都能看到
对于弱一致性而言,如果能容忍后续的部分或者全部访问不到
最终一致性:经过一段时间后要求能访问到更新后的数据

可用性

指服务在正常响应时间内一直可用。
一般情况下的可用性与分布式数据冗余,负载均衡等有着很大的关联。

分区容错性

分区容错性指分布式系统在遇到某节点或网络分区故障的时候,仍然能够对外提供满足一致性或可用性的服务。

Eureka Hello World

这里进行相关的简单的描述。
描述Eureka的相关的内容、
1. File->new->project->spring initializer->select dependencies Eureka Server->下一步 创建

2. 选择注册中心

  1. 编写配置文件
###服务端口号
server:
  port: 8000
###eureka 基本信息配置
eureka:
  instance:
    ###注册到eurekaip地址
    hostname: 127.0.0.1
  client:
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
    ###因为自己是为注册中心,不需要自己注册自己
    register-with-eureka: false
    ###因为自己是为注册中心,不需要检索服务
    fetch-registry: false
  server:
    # 测试时关闭自我保护机制,保证不可用服务及时踢出
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 2000
  1. 启动服务
@EnableEurekaServer
@SpringBootApplication
public class AppEureka {

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

}
#@EnableEurekaServer作用:开启eurekaServer
  1. 搭建完成

Spring Cloud 简介

Spring Cloud 简介
思维导图如下

总说

这里将会首先简单介绍一下Spring Cloud 。
其Logo 如下

Spring Cloud 是一系列有序框架的集合,其主要的设施有,服务发现与注册,配置中心,消息总线,负载均衡,断路器,数据监控等,通过Spring Boot的方式,可以实现一键启动,和部署。
Spring 没有重新造车轮,只是把各家的应用给综合起来。最后给开发者遗留下了一个足够简单的,相当容易部署的,相当容易学习的Spring 体系。
至于为什么要学习Spring Cloud的体系,因为原先的体系过于复杂了,导致开发的环境艰难,正是由于开发的环境的艰难,Spring Cloud 的是Spring体系的简化版,简化了原有的复杂,使得开发变的更加的简单快速。
其核心如下:
Spring Cloud Config、Spring Cloud Netflix(Eureka、Hystrix、Zuul、Archaius…)、Spring Cloud Bus、Spring Cloud for Cloud Foundry、Spring Cloud Cluster、Spring Cloud Consul、Spring Cloud Security、Spring Cloud Sleuth、Spring Cloud Data Flow、Spring Cloud Stream、Spring Cloud Task、Spring Cloud Zookeeper、Spring Cloud Connectors、Spring Cloud Starters、Spring Cloud CLI
这里将会一一的介绍。

服务注册与发现

其英文名称为 Spring Cloud Eureka,为Spring Cloud Netflix 子项目的核心组件之一,主要用于微服务的服务治理与发现。
在微服务的架构中,往往都有一个注册中心,每个微服务都会向注册中心,注册自己的微服务,注册中心,维护着,服务名称与服务实例对应的关系,每个微服务都会定时的从注册中心,获取注册列表,同时汇报自己的运行情况,这样当有其他服务需要调用该服务的时候,就可以向自己获取到的列表中,获取地址进行调用,Eureka实现了这套机制。即服务注册与发现。

其为微服务架构体系中最为核心的一点,用于其他微服务注册到该注册中心,配合路由可以实现路由的转发。通过寻找,遍历出其微服务。
同类型产品的还有Apahe Zookeeper 相对于高可用来说,zk 将不会保证,服务的可用性,当节点挂掉以后,需要进行Leader 选举,选举的时候会出现短暂的挂掉。而 eureka 当一个节点宕机以后,会进行自动的转移。所以其高可用性比zookeeper 相比更高。

配置中心

伴随着配置的增长,服务也有很多个配置,每个配置文件都各个不相同,其中,许多配置文件都是可以共用的,如果每个服务都去管理这些配置,会带来极大的麻烦,这个时候,需要引入基于Git的配置中心,去配置这个服务,例如Spring Cloud 体系中的,Spring Cloud Config,但是服务之间如何通信,这里使用 Spring Cloud Bus,即消息总线,作为配置中心,通知到配置体系中。

服务消费者

这里是相当经典的生产者,消费者模型,通过生产者,和消费者,统一进行布置,通过Spring Cloud Feign 远程调用,实现服务消费者,和生产者之间的相关联。实现经典的服务消费者和生产者之间的关系。

服务容错

当调用服务出错以后,服务如何保证整个体系不崩塌,这里就需要使用服务容错进行处理。这里称为服务雪崩,当出现服务雪崩的时候,整个服务链路会出现调用崩塌的情况。
Spring Cloud 组件中的 Spring Cloud HyStrix 实现了这种服务降级,与故障隔离。

网关

网关为整个系统,提供路由,鉴权,监控,负载均衡等功能,Spring Cloud 为此提供的解决方案有Zuul,与Gateway。

服务追踪

伴随着整个服务链路的增长,服务越来越多,排查问题,监控指标的时候,服务追踪变的相当的重要,Spring Cloud 体系提供的是,Sleuth,对整个服务链路进行追踪,并以图表的形式表现出来。

服务测试

在微服务体系中,一个服务可能会依赖其他的服务,这里使用服务测试来使用。通过Mock数据,实现服务的测试。
这里使用的是 Spring Cloud Contract

更多工具

Spring Cloud Security

Spring Cloud Security 的安全工具包,用于对Spring Security 提供基本的RBAC服务。

Spring Cloud Sleuth

用于进行相关的日志收集,实现分布式追踪的一种解决方案。

Spring Cloud Data Flow

用于进行大规模的数据处理。

Spring Cloud Stream

事件触发的机制,让其实现事件触发。

Spring Cloud Task

调度工作,定时任务,需要使用 Task

Spring Cloud Zookeeper

同属于 注册中心 Zookeeper 体系。

Spring Cloud Connectors

利用 Spring Cloud Connectors 实现云平台的搭建。

Spring Cloud Starters

开箱即用,可以实现Boot形式的启动项目。

Spring Cloud CLI

同上,使用命令行的方式实现开箱即用。

继续走下去啦

理由很简单,我没钱,没权,啥都没有,害我没啥用处。光身的来到这个世界,再光身的回去,就是这样的,这世界走一遭,然后就彻底的结束啦,谁不是这个样子呢,谁不是这样子走一遭呢。
这个理由相当的简单,没钱,没权,啥都没有,也不可能有人来巴结我的,没啥利益可图,就是这么简单。
这个世界上,不可能有人会害我的,目前为止是这样的,因为我一无所有。哪又会有什么灯微凉,人微凉呢。这就是这个世界。对于一个一无所有的小毛孩子来说,除了实习以外似乎啥也不能做了。或许上培训班,或许上学校,再学习一点东东。
这样想就对了,一件事情有两种不同的想法,如果换一个角度想,将会有另外一种想法,这就是这个世界,我猛然间发现,见的越多,整个人思想的深度,也在增长,其实到头来就我一个人,这个世界就我一个人,在走路,这就是这个世界,就我一个人的世界。
好吧,最近可能真的有点病了,有点错乱了。或许是这样的吧。
继续坚持走下去,一切只是撞车而已,一切都只是如此。一切都只是这样子而已。

近日总结

感觉近日过的相当的不错。整个人已经逐步的适应了,从原先最开始的找工作到现在这种状态,已经相当的不错了。
生活嘛,总是要继续进行的,因为这就是这个生活。
生活总是相当的艰难,继续存钱,整个人的技术已经开始逐步接轨了,因为这个社会已经开始正常了。
我知道这个blog可能没有几个人看,继续慢悠悠的生活着,争取尽快的断奶,这是我这一身的第一次开会,不正常相当的正常,因为这就是这个生活。

QmxeEhq6V1zCDy9

定时任务框架 Quartz

小小最近开始实习了,开始学习Quartz

Quartz 是一个定时任务。
这里进行使用。

Spring boot 整合 Quartz 内存方式

1. 新建Spring Boot 项目

新建目录如下

9ti6sfs

添加maven依赖

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

继承 QuartzJobBean 实现executeInternal方法,作为定时任务的执行方法

9ti6sfs

代码如下

public class TestTask1 extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务执行");
    }
}

创建Config类,并添加 @Configuration注解、

%E6%90%9C%E7%8B%97%E6%88%AA%E5%9B%BE20200522214547

其代码如下

@Bean
    public JobDetail testQuartz1() {
        return JobBuilder.newJob(TestTask1.class).withIdentity("testTask").storeDurably().build();
    }

    @Bean
    public Trigger testQuartzTrigger1() {
        //5秒执行一次
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(5)
                .repeatForever();
        return TriggerBuilder.newTrigger().forJob(testQuartz1())
                .withIdentity("testTask1")
                .withSchedule(scheduleBuilder)
                .build();
    }

执行以后,控制台输出

zjh9mu

给他人解释什么是dubbo

小小最近开始学习dubbo了,这次进行相关的学习。

简介

思维导图如下

什么是Dubbo

dubbo 是一款高性能的分布式服务框架,高性能的,透明化的RPC远程调用方案,SOA服务治理方案,与Spring 体系同时并驾崎岖于Java体系生态中。
每天为上千个服务提供,使用以及应用。
在上方的词语中,出现了,分布式服务,RPC远程调用执行方案,SOA服务治理方案,这里对这几个词语进行依次解释。

分布式服务 包含,服务注册中心和服务治理中心,对微服务进行有效的治理。

RPC 远程调用方案 RPC为一种通信方式,用于进行远程通信。

SOA服务治理 一种面向服务的体系架构。

YRgHpQ.png
dubbo的logo

Dubbo的由来

网站需要由单一的架构演化到分布式架构,以及流动计算架构,如图所示。
YRgLXn.png
网站演化图
在上图中,网站由最初的一个应用,即单一应用架构,由jsp,hibernate等逐步应用,当流量变大时,逐步发展到垂直应用架构,对机器进行拆分,拆分出多个,用F5等应用,进行负载均衡,流量越来越大,进行分布式服务架构,此时,应用之间交互相当复杂,把核心的抽取出来,使用RPC进行远程调用。流量达到越来越大,此时,增加一个调度中心基于访问压力实时管理集群容量,提高集群利用率,即资源调度与治理,即SOA。

在整个过程中,逐步的衍生出了一些问题,需要解决以下的问题。
1 依赖管理,服务逐渐的变的更加的多,服务的URL配置变的更加的艰难,负债均衡保持单点的压力相当的大,此时需要注册中心,管理相关的依赖管理,以及服务注册等。
2 路由透明,服务的注册,由原先的手动,变成了自动化,这里全部依赖于路由透明。
3 服务治理,当单一节点出现故障的时候,链路出现血崩的时候,如何治理服务。这里需要服务治理。对微服务进行相关的治理。

由此Dubbo应生而出,提供了以上问题的解决方案。

Dubbo的主要应用

dubbo主要应用于中大型应用,主要解决中大型应用的各种疑难问题。即分布式应用架构。

Dubbo 架构

核心 生产者与消费者问题

Dubbo 对应于计算机核心知识的生产者与消费者的问题
生产者与消费者是经典的并发协助的经典问题,该问题描述了共享固定大小缓冲区的两个进程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。与此同时,消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据,消费者也不会在缓冲区中空时消耗数据。
YRgv7V.png
Dubbo的核心应用为生产者与消费者问题

节点调用关系

YR2StU.png
此时节点调用关系如上所示

调用关系说明

  1. 服务提供者启动时,向注册中心注册自己的服务。
  2. 消费者启动时候,注册中心订阅自己的服务。
  3. 注册中心返回地址列表给消费者。
  4. 服务消费者,从地址中,获取进行调用。
  5. 服务消费者和提供者,用于每隔一段时间,统计数据到监控中心。

特点

具有以下的特点,连通性,健壮性,伸缩性和升级性。
连通性指注册中心负责注册与查找。监控中心负责进行相关的统计,注册中心和其余服务都是连通的,监控中心与其他服务也是连通的。
健壮性指,监控中心宕机的时候,其余应用也可使用。
伸缩性,可以动态的部署集群。
升级性,未来可以进行逐步的升级。

第一个项目 Hello World

zookeeper 节点安装

这里安装zk节点。使用docker镜像安装

PS C:\Users\Administrator\Desktop\试写参考>  docker pull zookeeper:3.5
3.5: Pulling from library/zookeeper
afb6ec6fdc1c: Pull complete
ee19e84e8bd1: Pull complete
6ac787417531: Pull complete
f3f781d4d83e: Pull complete
424c9e43d19a: Pull complete
f0929561e8a7: Pull complete
f1cf0c087cb3: Pull complete
2f47bb4dd07a: Pull complete
Digest: sha256:883b014b6535574503bda8fc6a7430ba009c0273242f86d401095689652e5731
Status: Downloaded newer image for zookeeper:3.5
docker.io/library/zookeeper:3.5
PS C:\Users\Administrator\Desktop\试写参考>
PS C:\Users\Administrator\Desktop\试写参考> docker create --name zddk -p 2181:2181 zookeeper:3.5
15b27748e07dc6cf44ca7943c49f9881e6d488a7cc5c61bfc5d3170a58321ff9
PS C:\Users\Administrator\Desktop\试写参考> docker start zk
zk
PS C:\Users\Administrator\Desktop\试写参考> docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                                  NAMES
d3eb0b087850        zookeeper           "/docker-entrypoint.…"   2 weeks ago         Up 22 seconds       2888/tcp, 3888/tcp, 0.0.0.0:2181->2181/tcp, 8080/tcp   zk
PS C:\Users\Administrator\Desktop\试写参考>

先拉取镜像,再创建相关的容器,最后启动docker容器。

编写服务提供方

YR2ic9.png
选择新的maven工程

创建工程目录如下
YR2FXR.png

添加服务提供方
YR2V76.png

添加相关依赖

<?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">
    <parent>
        <artifactId>untitled9</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service-dubbo</artifactId>

    <dependencies>
        <!--添加SpringBoot测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
        <!--添加dubbo依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.4</version>
        </dependency>
    </dependencies>
</project>

创建User对象

package com.ming.pojo;

import java.io.Serial;
import java.io.Serializable;

// 使用dubbo要求传输的对象必须实现序列化接口
public class User implements Serializable {
    private static final long serialversionUID = -809897897879L;

    private Long id;

    private String username;

    private String password;

    private Integer age;

    public static long getSerialversionUID() {
        return serialversionUID;
    }

    public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

创建UserService(接口)提供查询服务

package com.ming.pojo;

import java.util.List;

public interface UserService {
    List<User> queryAll();
}

创建实现类

package com.ming.pojo;

import com.alibaba.dubbo.config.annotation.Service;

import java.util.ArrayList;
import java.util.List;

@Service(version = "${dubbo.service.version}")  // 声明一个服务
public class UserServiceImpl implements UserService {
    public List<User> queryAll() {
        // 实现查询
        List<User> list = new ArrayList<User>();
        for(int i = 0; i < 10; i++){
            User user = new User();
            user.setAge(10 + i);
            user.setId(Long.valueOf(i + 1));
            user.setPassword("123456");
            user.setUsername("username_" + 1);
            list.add(user);
        }
        return list;
    }
}

编写相关的application

// 版本
dubbo:
  service:
    version: 1.0.0
  protocol:
    name: dubbo
    port: 20880
  // 服务扫描
  scan:
    basePackages: com.ming.pojo
  application:
    name: dubbo-provider-demo

//zk
  registry:
    address: zookeeper://172.0.0.1:2181
    client: zkclient

启动以后,查看注册中心,已经注册

服务消费方

导入相关依赖

<?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">
    <parent>
        <artifactId>untitled9</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer-dubbo</artifactId>

    <dependencies>
        <!--添加springboot依赖,非web项目-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.13</version>
        </dependency>
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <!--引入service的依赖-->
        <dependency>
            <groupId>cn.itcast.dubbo</groupId>
            <artifactId>itcast-dubbo-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

编写测试用例

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestUserService {
    @Reference(version="1.0.0")
    private UserService userService;

    @TestpublicvoidtestQueryAll(){
        List<User>users=this.userService.queryAll();
    }
    for(Useruser:users){
        System.out.println(user);
    }
}

编写配置文件

spring:
  application:
    name: ming-consumer
  port: 9091

dubbo:
  registry:
    address: zookeeper://172.0.0.1:2181
    client: zkclient

测试

前置知识

Java 基本语法,计算机科学的基础知识体系

适合人群

刚刚走入社会,或正在实习的,大学生们

Spring Boot系列之 入门应用

以后几天书写一个Spring Boot 系列的内容 小小最近学习Spring Boot体系中
Spring Boot 一种化繁为简的一种体系。把原先复杂的SSM,替换为简单的Spring Boot 一键式启动。

什么是Springboot

其实Springboot是Spring家族中的一个全新的框架,它是用来简单应用程序的创建和开发过程,化繁为简,简化SSM框架的配置。比如说在使用SSM框架开发的时候,我们需要配置web.xml,配置spring,配置mybatis,并将它们整合到一起,而是用Springboot就不同了,它采用了大量的默认配置来简化这些文件的配置过程。我们在百度指数看看这几年springboot和SSM框架的搜索指数:

在2017年下半年,spingboot就是出于一个喷发的状态,因此学习springboot是多么的有必要。

说实话在学习springboot的时候千万不要把他想象的太麻烦,因为它确实太简单,而且也不是什么全新框架,只是把很多其他的框架整合了进来,不需要自己去配置而已。有了这个概念,你就可以带着轻松的心情去学习了。

创建第一个Spring Boot项目

选择 File -> project -> Srin Inition

单击Next


选择相关的包

选择相关的web项目的Spring Web项目选择Next。进入下一步

项目创建完成。

编写简单的Hello World

这里编写简单的Hello World

package com.example.demo.web;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorld {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

此时的目录结构

单击启动

此时已经启动完成

访问,一下

可以看到已经访问成功

码农之路 第三刊 实习之路,长路漫漫

各种诱惑太多了

小小终于不停的面试,不停的面试,终于面试上了一家,那家企业是一家小型的创业型公司,小小加入进去了,小小很喜欢这家企业的猫,小猫对于小小而言是一个诱惑,嗯嗯,屏住呼吸,眼不见,心不烦,猫是诱惑,经过强大的内心的心里斗争,终于斗争过了心里的那只猫,那是一只小猫而已,这只是第一个诱惑。
小小继续工作,Boos,说让做一个内容,小小很听话,做了一个内容,旁边的人很嘈杂,都在走线,都在不停的走线,嗯嗯,小小屏住呼吸,呼吸屏住以后,继续眼不见,心不烦,充分的体现出,各自为政的特点。这次小小又逃过了一个诱惑,这个诱惑对于小小来说太多了。
小小继续工作,又来了个前端,前端已经工作一年有余,小小继续和前端交流,那是一所重点大学,对于小小而言,的的确确如此,没啥事情,只要坚持干活,就能适应企业,毕竟干活能力很重要,这是小小认为的。

兼职和正经工作的问题

小小还有一大堆的兼职工作,这种兼职工作,小小根本不知道该如何协调,这让小小一团糟糕,对于小小而言,这种糟糕的生活不需要,小小需要的是那种生活,小小需要保持稳定,保持稳定相当相当的重要,哦,不错了是保持住平衡,对于保持住平衡是一个相当相当重要的问题。
最后经过不断衰减,小小慢慢的放弃掉一些内容,小小最后就剩下了三个职业,一个职业是小说家,一个职业是淘宝店店主,一个职业是程序员,最后小小也就只剩下了这三个职业,这三个职业长路漫漫,是啊,长路漫漫,啥时候才能走完所有的路,貌似最近有些目标了。

目标的问题

刚刚进入社会,没有什么胆怯的,只管往前冲就行,小小,毕竟有点小,有点胆怯,不过也没有什么问题,所以小小继续规划小目标,对于小说来说,这次投稿比17年的投稿,不是那么好的过了,这次能明显感觉到。编辑要求高的很多,审稿的要求,高了不少,不再像之前那么容易过,不过能明显感觉到,经过几次交流,这本小说,已经有感觉了,可以说已经有经验,20走向30,这貌似是一条很长很长的路。
生活继续稳定,生活继续恢复正常,淘宝店,店主,上架的商品的数量,仍然不断的往前增加,商品,先期进行不断的添加,不断的添加,码农之路,貌似并不好走,码农之路,貌似走的相当的相当的艰辛,这就是码农的道路。

以后到底该怎么走

其实小小也不知道,小小有些时候也会在夜晚处于一种冥思的状态,这种冥思的状态对于小小而言,是比较好的,不断的思考,唯有思考才能继续走下去,目前可以说,矿机是自己的后面,还有赚钱宝这些稳定的内容,毕竟这些内容是一个稳定的收入,类似于这种的太少了,我也感觉类似于这种的太少了。生活只要进行下去就行。
我也想考研啊,貌似考研的道路更好,但是能考上吗,或许很难,每天少背几个就行了,一天少背点,然后一点点的背,迟早有可能回校园的,因为毕竟这张毕业证还是相当重要的,没有毕业证的生活更加的郁闷,毕业证相当的重要,这也是我这几天,不停的往学校跑的原因,对于毕业证的问题,牵挂的比较重,牵挂的相当的重,因为有可能有考研的打算,因为研究生或许是自己的一个相当好的选择,因为我可能离不开学校。
如果这次毕业证丢了,那么肯定会继续回去考的,因为证的重要性比较高的,我愿意怎么走,有些时候自己的问题,有些话语,别乱接话,很烦人的。我有些时候。这张证的还是有点重要的。

稍微的调整一下

继续小说家,淘宝店店主,程序员,。这张毕业证还是要的,毕竟很重要,因为这张证关乎档案的问题,不能乱来。
还有什么,貌似没有什么了。务必近日回校一趟。看看学校,毕竟这几年过的太封闭了,啥也没干,天天埋着头学了。能考学还是尽量考的,毕竟考学还是蛮重要的,专升本没有机会了,那么非专升本肯定就能行的通的。例如考研。继续沉迷计算机不可自拔,证要真丢了,回去高考也来的级,没准这次能考个本科呢,也是吧。证还是很重要的,因为这是知乎上的政治正确。政治正确嘛,没有绝对的。刘看山。有些时候考虑的问题太少了。有些时候,嘴长在对方脸上,不能控制对方,有些时候,直接可能有些控制权需要翻转一下,这点相当重要。

End

以上内容,来自一个处于迷茫期的小小