dubbo项目实战代码展示

最近公司项目使用dubbo服务，于是就去网上搜索关于dubbo的相关资料，真的很多，但是对于很多人并不是很了解框架或者

不是太适合新手的片段代码，于是我就根据项目的相关内容把dubbo部分单独切出来，所有代码可以运行。推荐先看一下

dubbo的一篇文章http://doc.okbase.net/congcong68/archive/112508.html 。

dubbo的介绍网上已经有很多了，我就不介绍它是什么了，我主要介绍怎么在项目中使用，怎么让一个小白会在项目中运用起

来，就像买一辆汽车，你肯定是先让他跑起来，不会先把所有组件拆开来看看是怎么安装的吧。（如果你是，那么恭喜你，你

已经是大神了），文字内容比较肤浅，适合初学者，如果有不当的地方欢迎指出来，留言

下面我就介绍一下我的项目结构

整个项目结构分为3个部分，dubbo-client 是消费者或者是调用方的代码（可以理解你自己的代码）,dubbo-service存放的是

dubbo的对外接口，只是接口的定义和基础实体类已经一些公共工具类，如果你想做的更细，可以把基础实体类和公共工具类

提取出来放在dubbo-domain中，dubbo-web存放的是dubbo的对外接口的实现和dubbo的生产者的配置信息。

那我们就开始对每个模块单独解释，首先从最基础的dubbo-service模块解释，一层层往上。

这里我定一个一个User实体类，用于存放用户基本信息，一个返回结果集的封装类（可根据自己项目需求而定，不是必须要

有），最后定义一个接口UserService.java和平常的接口并没有什么差异，看下具体内容

1. package com.lwl.dubbo.service;
2. import com.lwl.dubbo.domain.User;
3. import com.lwl.dubbo.rpc.RPCResponse;
4. /**
5. * 用户的接口
6. * @author Administrator
7. * @create 2016-8-9 下午2:42:56
8. * @version 1.0
9. */
10. public interface UserService {
11. /**
12. * 正常调用
13. * @param id
14. * @return
15. * @author Administrator
16. * @create 2016-8-9 上午10:16:50
17. */
18. public RPCResponse<User> findUserById(long id);
19. /**
20. * 调用该方法会抛出异常
21. * @return
22. * @author Administrator
23. * @create 2016-8-9 上午10:17:33
24. */
25. public RPCResponse<User> findUserThrowsException();
26. }

定义了2个接口方法，第一个方法是根据ID 获取用户信息，第二个方法比较特殊，因为我在实现的时候是让他直接抛出异常，

这样比较更加有代表性。好了，dubbo-service这个项目已经结束了，如果你需要更多的接口，请自行添加即可。然后把这项目

maven打包成JAR包供dubbo-web和dubbo-client依赖。

那接下来我们就要让dubbo服务先启起来，开启dubbo-web的项目，首先介绍一下dubbo-web的项目结构

dubbo-web的结构要比dubbo-service复杂一点，但是对于已经开发过J2EE的各位看客来说，这个其实很简单的。还记得上一

个dubbo-service项目的完成之后我们把他打包成一个JAR包了嘛，这时候我们就有使用这个JAR了，在pom文件中引入这个文

件即可。

然后UserServiceImpl实现dubbo-service接口中的UserService.java接口，接下来就是UserDao和UserDaoImpl这2个和数据库打

交道的类了，但是我为了项目整洁去除了和数据库的交流，如果看客需要则自行添加即可。

那我们看下UserServiceImpl.java干了什么事情呢？

1. package com.lwl.dubbo.service.impl;
2. import javax.annotation.Resource;
3. import org.springframework.stereotype.Service;
4. import com.lwl.dubbo.dao.UserDao;
5. import com.lwl.dubbo.domain.User;
6. import com.lwl.dubbo.rpc.RPCResponse;
7. import com.lwl.dubbo.service.UserService;
8. @Service("userService")
9. public class UserServiceImpl implements UserService {
10. @Resource(name="userDao")
11. private UserDao userDao;
12. @Override
13. public RPCResponse<User> findUserById(long id) {
14. //这里使用封装类,而不是DAO继续使用封装类,是为了DAO层更好的复用起来
15. RPCResponse<User> response = new RPCResponse<User>();
16. try {
17. //DAO层和我们之前开发的模式一样，没有使用封装类
18. User result = userDao.findUserById(id);
19. response.setResult(result);
20. } catch (Exception e) {
21. e.printStackTrace();
22. response.setSuccess(false);
23. response.setErrorMessage(e.getMessage());
24. }
25. return response;
26. }
27. //调用这个方法 会抛出异常
28. @Override
29. public RPCResponse<User> findUserThrowsException() {
30. RPCResponse<User> response = new RPCResponse<User>();
31. try {
32. User result = userDao.findUserThrowsException();
33. response.setResult(result);
34. } catch (Exception e) {
35. e.printStackTrace();
36. response.setSuccess(false);
37. response.setErrorMessage(e.getMessage());
38. }
39. return response;
40. }
41. }

看到这个类调用了DAO层的接口，但是DAO层并没有使用封装类，这是因为为了更好的复用DAO层的代码，所有就在接口实

现层做封装。

那DAO层的实现层是怎么实现的呢？

1. package com.lwl.dubbo.dao.impl;
2. import org.springframework.stereotype.Repository;
3. import com.lwl.dubbo.dao.UserDao;
4. import com.lwl.dubbo.domain.User;
5. /**
6. * DAO数据层操作
7. * @author Administrator
8. * @create 2016-8-9 上午10:30:03
9. * @version 1.0
10. */
11. @Repository("userDao")
12. public class UserDaoImpl implements UserDao {
13. /**
14. * 通过模拟数据库数据，返回结果
15. *      看客可以根据自己需要 从数据库获取数据然后返回
16. * @param id
17. * @return
18. * @author Administrator
19. * @create 2016-8-9 上午10:31:34
20. */
21. @Override
22. public User findUserById(long id) {
23. User info = new User();
24. info.setId(id);
25. info.setEmail("xxxxxxxxxx@163.com");
26. info.setMobile("13844445555");
27. info.setUsername("宇宙最帅");
28. info.setPassword("12345600");
29. return info;
30. }
31. @Override
32. public User findUserThrowsException() {
33. //让程序出错，便于返回测试
34. int i = 1/0;
35. System.out.println(i);
36. return null;
37. }
38. }

和想像的一样吧，就是我们平常开发中的那些代码，并没有什么特殊。

好了代码都写完了，接下来才是重点，怎么让他和dubbo服务有关联，首先当然要引入dubbo的jar包，然后在给服务添加配置

文件。

下面是dubbo的配置文件dubbo_config.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
5. xsi:schemaLocation="http://www.springframework.org/schema/beans
6. http://www.springframework.org/schema/beans/spring-beans.xsd
7. http://code.alibabatech.com/schema/dubbo
8. http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
9. <!--
10. dubbo:registry 标签一些属性的说明：
11. 1）register是否向此注册中心注册服务，如果设为false，将只订阅，不注册。
12. 2）check注册中心不存在时，是否报错。
13. 3）subscribe是否向此注册中心订阅服务，如果设为false，将只注册，不订阅。
14. 4）timeout注册中心请求超时时间(毫秒)。
15. 5）address可以Zookeeper集群配置，地址可以多个以逗号隔开等。
16. dubbo:service标签的一些属性说明：
17. 1）interface服务接口的路径
18. 2）ref引用对应的实现类的Bean的ID
19. 3）registry向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A
20. 4）register 默认true ，该协议的服务是否注册到注册中心。
21. -->
22. <!-- 提供方应用信息，用于计算依赖关系 -->
23. <dubbo:application name="dobbu-web"/>
24. <dubbo:registry address="N/A"/>
25. <!-- 用dubbo协议在20880端口暴露服务 -->
26. <dubbo:protocol name="dubbo" port="20880"/>
27. <!-- 等待时间，重试2次 -->
28. <dubbo:provider timeout="120000" retries="0"/>
29. <!-- 启动时不检查消费者 -->
30. <dubbo:consumer check="false" timeout="120000" retries="0" lazy="true"/>
31. <!-- 基础信息 -->
32. <dubbo:service ref="userService"
33. interface="com.lwl.dubbo.service.UserService"/>
34. </beans>

每个都有注释，如果对dubbo的标签不是很明白的看客，可以看看本文一开始推荐的那篇文章看看。

接下里就是在applicationContext.xml文件中引入dubbo的配置文件即可：

<import resource="classpath:dubbo_config.xml"/>

好了，dubbo-web的开发已经完成了，现在运行一下，如果没有问题就打包成WAR包，发布服务吧！

最后一个dubbo-client项目了，然后你发布服务了，肯定要有人来订阅吧，就好像你在卖东西，没有人来你这里买，你是不是很

不开心啊。所以服务起来了，我们就要利用起来。

dubbo-client项目看上去和平常项目没什么区别，只是多了一个dubbo的配置文件，用于订阅dubbo服务而已，当然dubbo-clien

t项目也要依赖dubbo的JAR 和 dubbo-service ，将这2个添加到pom文件中。

来我们先看一下项目的结构

项目的关键至于dubbo-config配置文件,该文件告诉你订阅了哪些接口和哪个dubbo服务。项目主要有一个控制器和前端返回封装类，各自的代码是：

1. package com.lwl.dubbo.controller;
2. import javax.annotation.Resource;
3. import org.springframework.stereotype.Controller;
4. import org.springframework.web.bind.annotation.RequestMapping;
5. import org.springframework.web.bind.annotation.RequestMethod;
6. import org.springframework.web.bind.annotation.ResponseBody;
7. import com.lwl.dubbo.domain.User;
8. import com.lwl.dubbo.respone.ResultRespone;
9. import com.lwl.dubbo.rpc.RPCResponse;
10. import com.lwl.dubbo.service.UserService;
11. @Controller
12. @RequestMapping("/user")
13. public class UserController {
14. @Resource(name="userService")
15. private UserService userService;
16. @ResponseBody
17. @RequestMapping(value="/id",method=RequestMethod.POST)
18. public ResultRespone findUserById(long id){
19. ResultRespone respone = new ResultRespone();
20. RPCResponse<User>  result = userService.findUserById(id);
21. if(result.isSuccess()){
22. respone.setData(result.getResult());
23. }else{
24. respone.setSuccess(false);
25. respone.setMsg(result.getErrorMessage());
26. }
27. return respone;
28. }
29. @ResponseBody
30. @RequestMapping(value="/exception",method=RequestMethod.POST)
31. public ResultRespone findUserThrowsException(){
32. ResultRespone respone = new ResultRespone();
33. RPCResponse<User>  result = userService.findUserThrowsException();
34. if(result.isSuccess()){
35. respone.setData(result.getResult());
36. }else{
37. respone.setSuccess(false);
38. respone.setMsg(result.getErrorMessage());
39. }
40. return respone;
41. }
42. }

1. package com.lwl.dubbo.respone;
2. /**
3. * 用于将结果集返回给前端
4. * @author Administrator
5. * @create 2016-8-9 下午12:21:24
6. * @version 1.0
7. */
8. public class ResultRespone {
9. private boolean success = true;//是否成功
10. private String msg;//错误信息或者提示信息
11. private Object data;//数据结果集
12. public boolean isSuccess() {
13. return success;
14. }
15. public void setSuccess(boolean success) {
16. this.success = success;
17. }
18. public String getMsg() {
19. return msg;
20. }
21. public void setMsg(String msg) {
22. this.msg = msg;
23. }
24. public Object getData() {
25. return data;
26. }
27. public void setData(Object data) {
28. this.data = data;
29. }
30. }

然后前端使用html + ajax 请求后台控制器,代码如下index.html：

1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
2. <html>
3. <head>
4. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
5. <meta http-equiv="X-UA-Compatible" content="IE=edge">
6. <meta name="viewport" content="width=device-width, initial-scale=1">
7. <script type="text/javascript" src="resources/jquery-1.8.3.min.js"></script>
8. </head>
9. <body>
10. <input type="button" value="根据ID获取用户对象" id="findUserById" />
11. <input type="button" value="findUserThrowsException" id="findUserThrowsException" />
12. <script type="text/javascript">
13. $("#findUserById").click(function(){
14. var data = {id : 102};
15. ajaxDo("/dubbo-client/user/id",data);
16. });
17. $("#findUserThrowsException").click(function(){
18. ajaxDo("/dubbo-client/user/exception",null);
19. });
20. function ajaxDo(url,data){
21. $.ajax({
22. url:url ,
23. type: "post",
24. dataType: "json",
25. data: data,
26. success:function(result){
27. if(result.success){
28. var obj = JSON.stringify(result.data);
29. alert(obj);
30. }else{
31. alert(result.msg);
32. }
33. }
34. });
35. }
36. </script>
37. </body>
38. </html>

运行结果：

好了，整个dubbo的服务以及完成了，稍后会将使用的代码上传到GIT上，到时候如果有需要的看客可以自己去查看，我也只是

一个初学者，如果有不当的地方请指出来，文字内容比较浅，肤浅，没什么深奥的，我只是希望能帮到那些不知道怎么用的

人。

项目已经上传到github上，有需要的可以移步到https://github.com/1181888200/dubbo.git