[Dubbo开发]配置简单的生产者和消费者

配置好jdk1.7、Zookeeper和Maven环境之后,开始尝试第一次搭建简单的dubbo生产者和消费者。

dubbo服务的原理,引用经典的官方图(cr.Dubbo官网):

关于Dubbo的原理和机制,在此不做赘述,具体可以查询官方文档:http://dubbo.apache.org/#!/?lang=zh-cn。

接下来开始搭建生产者和消费者。

1.生产者(Provider)

创建一个maven项目,

代码如下:

(1)接口ProviderService.java

package com.mohrss.service;

public interface ProviderService {
	public void sayHello();
}

(2)实现类ProviderServiceImpl.java

package com.mohrss.service.impl;

import com.mohrss.service.ProviderService;

import org.springframework.stereotype.Service;

@Service("providerService")
public class ProviderServiceImpl implements ProviderService {

	public void sayHello() {
		// TODO Auto-generated method stub
		System.out.println("Hello I am Provider");
	}

}

(3)程序入口TestProviderService.java

package com.mohrss.service;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestProviderService {
	public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"dubbo-provider.xml"});
        context.start();
        System.out.println("生产者服务已经注册成功!");
        try {
            System.in.read();//让此程序一直跑,表示一直提供服务
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

(4)dubbo配置文件dubbo-provider.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd ">   

	<!--用注解方式实现bean-->
	<context:component-scan base-package="com.mohrss.service">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
	</context:component-scan>

    <!-- 提供方应用信息,用于计算依赖关系 -->
    <dubbo:application name="provider"  />    

    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />     

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="29014" />  

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:service interface="com.mohrss.service.ProviderService" ref="providerService" />
</beans>

(5)依赖文件配置pom.xml

<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">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mohrss</groupId>
  <artifactId>provider</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <properties>
      <spring.version>4.3.2.RELEASE</spring.version>
  </properties>  

  <dependencies>
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>dubbo</artifactId>
          <version>2.5.6</version>  

      </dependency>
      <dependency>
          <groupId>com.github.sgroschupf</groupId>
          <artifactId>zkclient</artifactId>
          <version>0.1</version>
      </dependency>  

  </dependencies>  

</project>

2.消费者(Consumer)

消费者搭建和生产者相同的maven项目

(1)TestConsumerService.java

package com.mohrss.consumer;

import java.io.IOException;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.mohrss.service.ProviderService;

public class TestConsumerService {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext(new String[]{"dubbo-consumer.xml"});
        context.start();
        ProviderService testService = (ProviderService) context.getBean("testProviderService");
        testService.sayHello();
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

(2)dubbo-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd ">   

    <!-- 消费方应用名,用于计算依赖关系,不是匹配条件,不要与提供方一样 -->
    <dubbo:application name="consumer" />     

      <!-- 使用multicast广播注册中心暴露发现服务地址 -->
    <dubbo:registry  protocol="zookeeper" address="127.0.0.1:2181" />       

      <!-- 生成远程服务代理,可以和本地bean一样使用demoService -->
    <dubbo:reference id="testProviderService" interface="com.mohrss.service.ProviderService" />
</beans>

3.启动zookeeper,右键启动TestProviderService.java,将看到生产者成功注册:

然后右键TestConsumerService.java, Run as Application,将看到:

注意:消费者调用服务方接口,应当将provider编译成jar包放到消费者中进行引用,此处为了方便,直接引用了生产者的接口文件ProviderService.java

注:原创博客,转载请注明。

原文地址:https://www.cnblogs.com/Vivianwang/p/9408493.html

时间: 2024-11-11 20:01:34

[Dubbo开发]配置简单的生产者和消费者的相关文章

Java线程学习整理--4---一个简单的生产者、消费者模型

 1.简单的小例子: 下面这个例子主要观察的是: 一个对象的wait()和notify()使用情况! 当一个对象调用了wait(),那么当前掌握该对象锁标记的线程,就会让出CPU的使用权,转而进入该对象的等待池中等待唤醒,这里说明一下,每一个对象都有一个独立的等待池和锁池! 等待池:上述的wait()后的线程会进入等待池中,处于下图线程声明周期(简单示意图) 中的这个状态,等待池中的线程任然具有对象的锁标记,但是处于休眠状态,不是可运行状态! 当该对象调用notify方法之后,就会在等待池中系统

多线程----简单的生产者和消费者

package cn.zz; //简单的生产者和消费者class Resource { private String name; private int count; private boolean flag = false; public synchronized void Set(String name) { if (flag) { try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated cat

RabbitMQ基础概念详解(一)——环境配置及模拟生产者和消费者简单消息发送

一.简介: RabbitMq 是实现了高级消息队列协议(AMQP)的开源消息代理中间件.消息队列是一种应用程序对应用程序的通行方式,应用程序通过写消息,将消息传递于队列,由另一应用程序读取 完成通信.而作为中间件的 RabbitMq 无疑是目前最流行的消息队列之一. AMQP,即Advanced Message Queuing Protocol,高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计.消息中间件主要用于组件之间的解耦,消息的发送者无需知道消息使用者的存在,反之亦然.

用阻塞队列和线程池简单实现生产者和消费者场景

本例子仅仅是博主学习阻塞队列和后的一些小实践,并不是真正的应用场景! 生产者消费者场景是我们应用中最常见的场景,我们可以通过ReentrantLock的Condition和对线程进行wait,notify同通信来实现生产者和消费者场景,前者可以实现多生产者和多消费者模式,后者仅可以实现一生产者,一消费者模式. 今天我们就利用阻塞队列来实现下生产者和消费者模式(里面还利用了线程池). 看过我关于阻塞队列博文的朋友已经知道,阻塞队列其实就是由ReentrantLock实现的! 场景就不描述了,为简单

简单的生产者和消费者模式

package com.roger.produceConsumer; /**  * 生产者和消费者  * 生产的数量需要和消费的数量一致  * @author Roger  */ public class Main {     public static void main(String[] args) {         // 初始化一个盛放数据的容器         SyncStack ss = new SyncStack();         Producer p = new Produc

java使用lock实现一个简单的生产者和消费者模式

import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class Five { public static void main(String[] args) { final Service myService = new Service(); for(int i = 0 ; i < 10 ; i ++){ Thread thread = new Th

Dubbo学习-4-dubbo简单案例-2-服务提供者和消费者配置

在上一篇帖子的基础上,开始使用dubbo来实现RPC调用: 根据dubbo的架构图可知,需要做以下几件事情: 1.将服务提供者注册到注册中心(暴露服务) (1)引入dubbo依赖, 这里依赖2.6.2版本(版本如果使用zookeeper作为注册中心,那么对应的客户端是curator,不是原来的zkClient) (2)注册中心使用的是zookeeper,需要引入操作zookeeper的客户端  2.6.以上版本的dubbo,如果使用zookeeper作为注册中心,那么注册中心客户端使用的是cur

4.利用python生成器实现简单的“生产者消费者”模型

假如说,没有生成器这种对象,那么如何实现这种简单的"生产者消费者"模型呢? import time def producer(): pro_list = [] for i in range(10000): print "包子%s制作ing" %(i) time.sleep(0.5) pro_list.append("包子%s" %i) return pro_list def consumer(pro_list): for index,stuffe

生产者与消费者的一个简单例子

生产者 #include<fstream> #include<iostream> #include<Windows.h> using namespace std; int main(void) { ofstream out; const char ch = '*'; long long k = 0; DWORD64 time = GetTickCount64(); while (true) { if (GetTickCount64() - time > 5000)