分布式学习之Dubbo框架的学习

1 dubbo框架

Dubbo(读音[ˈdʌbəʊ])是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和Spring框架无缝集成。
Dubbo是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

1.1 dubbo框架的介绍

https://dubbo.apache.org/zh-cn/
Apache Dubbo |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现

1.2 dubbo的工作原理

1.3 dubbo的入门案例

1.3.1 添加Jar包

 		<dependency>
			<groupId>com.alibaba.boot</groupId>
			<artifactId>dubbo-spring-boot-starter</artifactId>
			<version>0.2.0</version>
		</dependency>

1.3.2 创建第三方接口

代码结构

说明：因为数据需要在网络中进行传递，所以 必须要进行序列化

package com.jt.dubbo.pojo;

import java.io.Serializable;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain=true)
@TableName //如果对象的名称与表的名称一致，则可以忽略不写
public class User implements Serializable{  //
							//dubbo协议中传输的对象必须序列化
	private static final long serialVersionUID = 1L;
	@TableId(type=IdType.AUTO)
	private Integer id;
	private String name;
	private Integer age;
	private String sex;
}

package com.jt.dubbo.service;

import java.util.List;

import org.springframework.transaction.annotation.Transactional;

import com.jt.dubbo.pojo.User;

public interface UserService {
	
	//查询全部的用户信息
	List<User> findAll();
	//新增用户入库操作.
	@Transactional
	void saveUser(User user);
}

1.3.3 创建生产者

代码结构

//添加依赖项：
	<dependency>
  		<groupId>com.jt.dubbo</groupId>
  		<artifactId>dubbo-jt-demo-interface</artifactId>
  		<version>0.0.1-SNAPSHOT</version>
  	</dependency>

注意：这里service的注解是dubbo的注解

//重写xieservice中的方法
package com.jt.dubbo.service;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import com.alibaba.dubbo.config.annotation.Service;
import com.jt.dubbo.mapper.UserMapper;
import com.jt.dubbo.pojo.User;
@Service(timeout=3000)	//3秒超时 内部实现了rpc
//@org.springframework.stereotype.Service//将对象交给spring容器管理
public class UserServiceImpl implements UserService {
	@Autowired
	private UserMapper userMapper;
	@Override
	public List<User> findAll() {
		System.out.println("我是第一个服务的提供者");
		return userMapper.selectList(null);
	}
	@Override
	public void saveUser(User user) {
		userMapper.insert(user);
	}
}

数据层：

package com.jt.dubbo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.dubbo.pojo.User;

public interface UserMapper extends BaseMapper<User>{
	
}

yml配置文件的书写

server:
  port: 9000   #定义端口

spring:
  datasource:
    #引入druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: 125805

#关于Dubbo配置   
dubbo:
  scan:
    basePackages: com.jt    #指定dubbo的包路径,扫描的dubbo的注解
  application:              #应用名称
    name: provider-user     #一个接口对应一个服务名称,相同的接口，服务的名称一定一致，不一 样的接口服务名称肯定不一致
  registry:
    address: zookeeper://192.168.126.129:2181?backup=192.168.126.129:2182,192.168.126.129:2183
  protocol:  #指定协议
    name: dubbo  #使用dubbo协议(tcp-ip)  web-controller直接调用sso-Service
    port: 20880  #每一个服务都有自己特定的端口 不能重复.

      
mybatis-plus:
  type-aliases-package: com.jt.dubbo.pojo       #配置别名包路径
  mapper-locations: classpath:/mybatis/mappers/*.xml  #添加mapper映射文件
  configuration:
    map-underscore-to-camel-case: true                #开启驼峰映射规则

主启动类

package com.jt;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.jt.dubbo.mapper")
public class SpringBoot_Run {
	
	public static void main(String[] args) {
		
		SpringApplication.run(SpringBoot_Run.class, args);
	}
}

1.3.4 消费者服务器

代码结构

依赖的添加

	<dependency>
  		<groupId>com.jt.dubbo</groupId>
  		<artifactId>dubbo-jt-demo-interface</artifactId>
  		<version>0.0.1-SNAPSHOT</version>
  	</dependency>

控制层代码的编写

package com.jt.dubbo.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.dubbo.config.annotation.Reference;
import com.jt.dubbo.pojo.User;
import com.jt.dubbo.service.UserService;

@RestController
public class UserController {	
	//定义第三方接口，利用代理机制为其创建代理对象
	@Reference(loadbalance="leastactive")
	private UserService userService; 	
	/**
	 * Dubbo框架调用特点:远程RPC调用就像调用自己本地服务一样简单
	 * @return
	 */
	@RequestMapping("/findAll")
	public List<User> findAll(){
		//远程调用时传递的对象数据必须序列化.
		return userService.findAll();
	}
	@RequestMapping("/saveUser/{name}/{age}/{sex}")
	public String saveUser(User user) {	
		userService.saveUser(user);
		return "用户入库成功!!!";
	}
}

yml配置文件的编写

server:
  port: 9001
dubbo:
  scan:
    basePackages: com.jt
  application:
    name: consumer-user   #定义消费者名称
  registry:               #注册中心地址
    address: zookeeper://192.168.126.129:2181?backup=192.168.126.129:2182,192.168.126.129:2183

问题：

问题1：如果其中的一个提供者宕机，问用户访问是否受限？不受限
问题2：如果zk集群宕机，用户访问是否受限？不受限，但是要及时修复避免出现问题

2 dubbo的负载均衡策略：

2.1 hash一致性原则：port进行hash运算，之后绑定固定的提供者进行访问

2.2 客户端的负载均衡

1 什么是集中式的负载均衡
特点;1\用户在访问服务器时，自己不清楚访问的真实的服务器是谁？由nginx服务器动态反向代理实现
统一有负载均衡服务器进行负载，。问题：负载均衡服务器访问压力高

客户端负载均衡：
消费者在放翁服务提供者是清除的了解应该访问那台服务器
由于每个客户端都进行负载均衡，相当于将压力均匀的发呢配给客户端，访问压力低

核心：nginx一般只扶着反向代理
在服务情况家中，几乎都是客户端给负载均很服务器