Dubbo

Apache Dubbo是一个高可用的，基于java的开源RPC框架

不仅包含RPC访问功能，还包含服务治理功能

由阿里巴巴建立，最后由apache维护至今，所以我们选择由apache维护的dubbo

官方地址：https://mvnrepository.com/artifact/org.apache.dubbo/dubbo

常用版本2.7.3

Dubbo架构

Dubbo支持的协议

Dubbo协议（官方推荐）

采用NIO复用单一长连接，使用线程池并发处理请求，减少握手和加大并发效率

大文件上传时，可能出现问题（不适用Dubbo文件上传）

RMI协议（Remote Method Invocation）

优点：JDK自带的能力

缺点：偶尔连接失败

Hessian协议

优点：可以与原生Hessian互操作，基于HTTP协议

缺点：需hessian.jar支持，http短连接的开销大

Dubbo支持的注册中心

Zookeeper（官方推荐）

优点：支持分布式，周边产品

缺点：受限于Zookeeper软件的稳定性，Zookeeper专门分布式辅助软件，稳定较优

Multicast

优点：去中心化，不需要单独安装

缺点：Provider和Consumer和Registry不能跨机房（只能在局域网内使用）

Redis

优点：支持集群，性能高

缺点：要求服务器时间同步，否则可能出现集群失败问题

Simple

优点：标准RPC服务，没有兼容问题

缺点：不支持集群

第一个Dubbo的Provider

Dubbo目录结构

创建父工程，添加依赖

<parent>
    <group>org.springframework.boot</group>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.10.RELEASE</version>
</parent>

<dependencyManagement>
<dependencies>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.4.2</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.4.2</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.1.10 RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>4.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>4.2.0</version>
</dependency>
</dependencyManagement>

DubboService接口

public interface DubboService{
    public String service(String param);
}

接口实现

@Service
public class DubboServiceImpl implements DubboService{

    @Reference
    private dubboService DubboService;

    @Override
    public String service(String param){
        return DubboService.service("dubbo");
    }
}

启动类

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

控制器

public class DubboController{
    @Autowired
    private DubboService dubboService;
    
    @RequestMapping("/dubboservice")
    @RequestBody
    public String service(){
        return dubboService.service();
    }
}

provider中的application.yml

dubbo:
    application:
        name: dubbo-provider
        registry:
          address: zookeeper://192.168.0.1:2181
    protocol:
      port: 20884

consumer中的application.yml

dubbo:
    application:
        name: dubbo-consumer
        registry:
          address: zookeeper://192.168.0.1:2181
    protocol:
      port: 20884

Admin管理界面搭建

负载均衡

集群：一个内容，部署多次，形成的整体称为集群，每个个体应该部署到不同的服务器

伪集群：集群中内容部署到同一台服务器上，通过不同端口区分不同个体

负载均衡是在集群前提下，当访问整个集群时，集群中每个节点都被访问次数或频率的规则

Dubbo内置了四个负载均衡策略，默认为Random

内置策略

• Random，随机，随机访问集群中结点，访问概率和权重有关
• RoundRobin，轮询，访问频率和权重有关；权重，占有比例，集群中每个项目部署的服务器性能可能不同，性能好的权重高
• LeastActive，活跃数相同的随机，不同的活跃数高的放前面
• ConsistentHash，一致性Hash，相同参数请求总是发到一个提供者

Provider集群

新建四个启动类

每次启动启动类修改配置文件dubbo.protocal.port

设置负载均衡

调用的服务采用负载均衡

@Reference(loadbalance = "roundrobin")
private DubboService dubboService;

当前拂去采用的负载均衡算法

@Service(loadbalance = "random")
public class DubboServiceImpl implements DubboService{}

设置权重

@Service(weight = 4)

配置文件

dubbo:
    application:
        name: dubbo-provider
    registry:
        address: zookeeper://192.168.32.128:2181
    protocol:
        port: 20884

结构图

pojo.Dept.java

public class Dept implements Serializable{
    private Integer id;
    private String name;
    // getter setter
}

pojo.Emp.java

public class Emp implements Serializable{
    private Integer id;
    private String name;
    private Stgring phote;
    private Integer did;
    // getter setter
}

持久层myBatis

application-mybatis.yml

spring:
    datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test
        username: root
        password: root
mybatis:
    mapper-locations: classpath:mybatis/*.xml
    type-aliases-package: com.test.pojo

mapper.DeptMapper

mapper.EmpMapper

provider启动类

@SpringBootApplication
@EnableDubbo
@MapperScan(com.test.mapper)
public class ProviderApplication{
    public static void main(String[] args){
        SpringApplication.run(ProviderApplication.class, args);
    }
}

provider的applicaton.yml

dubbo:
    application:
        name: dubbo-provider
    registry:
        address: zookeeper://192.168.0.1:2181
# 加载其它配置文件, 加载其它的application-*.yml文件
# 多个名称之间用 "," 分隔
spring: 
    profiles:
        active: mybatis

dept子项目的创建

DeptMapper.xml

<mapper namespace="com.test.mapper.DeptMapper">
    <select id="findAll" resultType="com.test.pojo.Dept">
        select id, name from dept;
    </select>
</mapper>

DeptDubboService

public interface DeptDubboService{
    public List<Dept> findAllDept();

}

DeptMapper

public interface DeptMapper{
    public List<Dept> findAll();
}

DeptDubboServiceImpl

// 选择Dubbo注解
@Service
public class DeptDuboServiceImpl implements DeptDubboService(){
    @Autowired
    private DeptMapper deptMapper;

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

DeptService

public interface DeptService{
    public List<Dept> findAll();
    public List<Emp> findEmpByDeptId(Integer did);
}

DeptServiceImpl

public class DeptServiceImpl implements DeptService{

    @Reference
    private DeptDubboService deptDubboService;
    
    @Override
    public List<Dept> findAll(){
        return null;
    }
}

DeptController

@Controller
public class DeptController{
    @Autowired
    private DeptService deptService;
    @GetMapping("/dept")
    public String showDept(Model model){
        model.setAttribute("list", deptService.findAll());
        return "dept";
    }
}

启动类

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

emp下的application.yml

dubbo:
    application:
        name: dubbo-emp-consumer
    registry:
        address: zookeeper://192.168.0.1
server:
    port: 8081

EmpApplication

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

EmpDubboService

public interface EmpDubboService{
    public int insertEmp(Emp emp);    
    public List<Emp> findEmpByDeptId(Integer did);
}

EmpDubboServiceImpl

public class EmpDubboServiceImpl implements EmpDubboService{
    @Autowired
    private EmpMapper empMapper;

    @Override
    public int insertEmp(Emp emp){
        return empMapper.insertEmp(emp);
    }
}

EmpMapper.xml

<mapper namespace="com.test.mapper.EmpMapper" >
    <insert id="insertEmp" parameterType="com.test.pojo.Emp">
        insert into emp(name, photo, did) values(#{name}, #{photo}, #{did})
    </insert>
    <select id="findEmpByDeptId" parameterType="int" resultType="com.test.pojo.Emp">
        select id, name, photo from emp where did = #(did)
    </select>
</mapper>

EmpService

public interface EmpService{
    public List<Dept> showAll();
    public int insert(Emp emp, MultipartFile file);    
}

EmpDubboServiceImpl

public class EmpDubboServiceImpl implements EmpService{
    // Dubbo 的 Reference
    @Reference
    private DeptDubboService deptDubboService;
    @Reference
    private EmpDubboService empDubboService;
    @Override
    public List<Dept> showAll(){
        return deptDubboService.findAllDept();
    }
    @Override
    public int insert(Emp emp, MultipartFile file){    
        try{
            // 通过spring容器获取HttpServletRequeest对象
            HttpServletRequeest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
            // 通过HttpServletRequest对象获取图片上传的路径
            String path = request.getServletContext().getRealPath("/img");
            System.out.println("path == " + path);

            // 为上传到服务器中的图片的名称不重复, 编写随机数
            long currentTimeMills = System.currentTimeMillis();
            Random random = new Random();
            String fileName = currentTimeMills + "" + random.nextInt(1000);
            String oldName = file.getOriginalFilename();
            fileName += oldName.substring(oldName.lastIndexOf("."));

            File pathFile = new File(path);
            // 第一次上传图片, 检查目录是否存在, 如果不存在, 创建响应目录
            if(!pathFile.exist()){
                pathFile.mkdirs();
            }
            // 图片上传        
            file.transferTo(new File(path, fileName));
            // 封装emp对象, 把图片路径封装到emp对象中
            emp.setPhoto("http://localhost:8081/img/" + fileName);
            return empDubboService.insertEmp(emp);
        }catch(IOException e){
            e.printStackTrace();
        }        
        return 0;
    }
}

EmpController

public class EmpController{
    @Autowired
    private EmpService empService;

    @GetMapping("/empadd")
    public String empAdd(Model model){
        model.addAttribute("list", empService.showAll());

        return "emp-add";
    }

    @PostMapping("/add")
    public String add(Emp emp, MultipartFile file){
        empService.insert(emp, file);
        return "emp-add";
    }
}

DeptController

@Controller
public class DeptController{
    @Autowired
    private DeptService deptService;
    @GetMapping("/dept")
    public String showDept(Model model){
        model.addAttribute("list", deptService.findAll());    
        return "dept";    
    }

    @GetMapping("/showEmp")
    public String showEmp(Integer did, Model model){
        model.addAttribute("list", deptService.findEmpByDeptId(did));    
        return "showEmp";    
    }
}