java学习 SSM整合dubbo+zookeeper

叁歲伎倆 2022-04-08 19:45 192阅读 0赞

最近刚好有点时间，特意来整合一下项目，以后会陆续把前端框架和一些组件也给整合进去，今天就先来整合一下SSM+mysql+dubbo+zookeeper来做一个用户列表功能。关于理论性的知识，大家可以自行查阅下资料，这里重点讲解一下怎么搭建这一套开发环境。

# 背景 #

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

\[外链图片转存失败(img-BxsE3Mfo-1562220757468)(http://dubbo.io/dubbo-architecture-roadmap.jpg-version=1&modificationDate=1331143666000.jpg)\]

*  **单一应用架构**
    
     *  当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。
     *  此时，用于简化增删改查工作量的 **数据访问框架(ORM)** 是关键。
     *  早期的JSP，ASP，PHP都是把数据操作写在前端，功能相当简单。
 *  **垂直应用架构**
    
     *  当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。
     *  此时，用于加速前端页面开发的 **Web框架(MVC)** 是关键。现在很多非互联网公司仍然采用这种架构设计。
 *  **分布式服务架构**
    
     *  当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。
     *  此时，用于提高业务复用及整合的 **分布式服务框架(RPC)** 是关键。
 *  **流动计算架构**
    
     *  当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。
     *  此时，用于提高机器利用率的 **资源调度和治理中心(SOA)** 是关键。

# 开发工具： #

这里贴出自己的开发工具和版本号，因为有的时候可能会因为版本号而造成很多不必要的冲突。

zookeeper-3.4.6+windows系统+mysql 5.6+jdk7+eclipse+tomcat7+dubbo 2.5.3

zookeeper:

下载zookeeper注册中心，下载地址：[http://www.apache.org/dyn/closer.cgi/zookeeper/][http_www.apache.org_dyn_closer.cgi_zookeeper] 下载后解压即可。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923103100519?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

然后进入conf里面，改一下我们的配置，打开zoo.cfg，有得可能不叫这个名字,把zoo\_sample.cfg改成zoo.cfg；

clientPort=2181 
         #server.1=127.0.0.1:3881:4881 
         #server.2=127.0.0.1:3882:4882 
         #server.3=127.0.0.1:3883:4883 
         
         
         
         
         dataDir=../data 
         dataLogDir=../log 
         
         
         # The number of milliseconds of each tick 
         tickTime=10000 
         # The number of ticks that the initial 
         # synchronization phase can take 
         initLimit=10 
         # The number of ticks that can pass between 
         # sending a request and getting an acknowledgement 
         syncLimit=5 
         # the directory where the snapshot is stored. 
         # do not use /tmp for storage, /tmp here is just 
         # example sakes. 
         
         #dataDir=../data 
         #dataLogDir=../dataLog 
         
         # the port at which the clients will connect 
         #clientPort=2181 
         # the maximum number of client connections. 
         # increase this if you need to handle more clients 
         #maxClientCnxns=60 
         # 
         # Be sure to read the maintenance section of the 
         # administrator guide before turning on autopurge. 
         # 
         # http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance 
         # 
         # The number of snapshots to retain in dataDir 
         #autopurge.snapRetainCount=3 
         # Purge task interval in hours 
         # Set to "0" to disable auto purge feature 
         #autopurge.purgeInterval=1

tickTime：这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。  
dataDir：顾名思义就是 Zookeeper 保存数据的目录，默认情况下，Zookeeper 将写数据的日志文件也保存在这个目录里clientPort：这个端口就是客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求。  
当这些配置项配置好后，你现在就可以启动 Zookeeper 了，启动后要检查 Zookeeper 是否已经在服务，可以通过 netstat – ano 命令查看是否有你配置的 clientPort 端口号在监听服务。

*  server.A=B：C：D：其中 A 是一个数字，表示这个是第几号服务器；B 是这个服务器的 ip 地址；C 表示的是这个服务器与集群中的 Leader 服务器交换信息的端口；D 表示的是万一集群中的 Leader 服务器挂了，需要一个端口来重新进行选举，选出一个新的 Leader，而这个端口就是用来执行选举时服务器相互通信的端口。如果是伪集群的配置方式，由于 B 都是一样，所以不同的 Zookeeper 实例通信端口号不能一样，所以要给它们分配不同的端口号。

最后到bin目录下面启动，客户端和服务端。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923131413657?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

# Dubbo: #

需要下载：dubbo-admin-2.5.3的war包

然后Tomcat启动一下。这里有两种启动方式，一种是找到自己的tomcat安装目录，替换掉tomcat/webapps下自带的ROOT文件夹内容（即替换tomcat的启动主页），将下载的war包解压到webapps/ROOT中，直接替换即可。

我用的是下面这种，比较简单点。打开eclipse里面的tomcat管理页面。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923111251697?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

然后选择第二个，找到自己刚刚下载的war**包，部署并且启动一下。**

**这个时候在浏览器输入自己的ip和端口,我的是localhost:8080**

**!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923161034929?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)**

**看到这个管理页面就代表成功了。可以来检测我们的消费者和生产者了。**

# **SSM整合：** #

**这里先编写我们的服务端，我把提供服务的统称为服务端，所以这里先创建一个服务端。**

**所以这里新建一个项目叫做user-service**

## Maven引入需要的JAR包 ##

<?xml version="1.0"?> 
          <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" 
          xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"> 
          <modelVersion>4.0.0 </modelVersion> 
          <parent> 
          <groupId>user </groupId> 
          <artifactId>user </artifactId> 
          <version>0.0.1-SNAPSHOT </version> 
          </parent> 
          <artifactId>user-service </artifactId> 
          <packaging>jar </packaging> 
           
          <properties> 
          <project.build.sourceEncoding>UTF-8 </project.build.sourceEncoding> 
           
          <org.springframework.version>4.1.7.RELEASE </org.springframework.version> 
          </properties> 
          <dependencies> 
          <dependency> 
          <groupId>user-api </groupId> 
          <artifactId>user-api </artifactId> 
          <version>0.0.1-SNAPSHOT </version> 
          </dependency> 
          <dependency> 
          <groupId>junit </groupId> 
          <artifactId>junit </artifactId> 
          <version>3.8.1 </version> 
          <scope>test </scope> 
          </dependency> 
          
          <dependency> 
          <groupId>com.alibaba </groupId> 
          <artifactId>dubbo </artifactId> 
          <version>2.5.3 </version> 
          <exclusions> 
          <exclusion> 
          <artifactId>spring </artifactId> 
          <groupId>org.springframework </groupId> 
          </exclusion> 
          </exclusions> 
          </dependency> 
          <dependency> 
          <groupId>org.apache.zookeeper </groupId> 
          <artifactId>zookeeper </artifactId> 
          <version>3.4.6 </version> 
          <exclusions> 
          <exclusion> 
          <artifactId>log4j </artifactId> 
          <groupId>log4j </groupId> 
          </exclusion> 
          </exclusions> 
          </dependency> 
          <dependency> 
          <groupId>org.slf4j </groupId> 
          <artifactId>slf4j-api </artifactId> 
          <version>1.7.12 </version> 
          </dependency> 
          <dependency> 
          <groupId>ch.qos.logback </groupId> 
          <artifactId>logback-core </artifactId> 
          <version>1.1.1 </version> 
          </dependency> 
           
          <dependency> 
          <groupId>ch.qos.logback </groupId> 
          <artifactId>logback-classic </artifactId> 
          <version>1.1.1 </version> 
          </dependency> 
           
          <dependency> 
          <groupId>mysql </groupId> 
          <artifactId>mysql-connector-java </artifactId> 
          <version>5.1.35 </version> 
          <scope>runtime </scope> 
          </dependency> 
          <dependency> 
          <groupId>c3p0 </groupId> 
          <artifactId>c3p0 </artifactId> 
          <version>0.9.1.2 </version> 
          </dependency> 
          
           
          <dependency> 
          <groupId>org.mybatis </groupId> 
          <artifactId>mybatis </artifactId> 
          <version>3.3.0 </version> 
          </dependency> 
           
          <dependency> 
          <groupId>org.mybatis </groupId> 
          <artifactId>mybatis-spring </artifactId> 
          <version>1.2.3 </version> 
          </dependency> 
          
           
          <dependency> 
          <groupId>taglibs </groupId> 
          <artifactId>standard </artifactId> 
          <version>1.1.2 </version> 
          </dependency> 
          <dependency> 
          <groupId>jstl </groupId> 
          <artifactId>jstl </artifactId> 
          <version>1.2 </version> 
          </dependency> 
          <dependency> 
          <groupId>com.fasterxml.jackson.core </groupId> 
          <artifactId>jackson-databind </artifactId> 
          <version>2.5.4 </version> 
          </dependency> 
          <dependency> 
          <groupId>javax.servlet </groupId> 
          <artifactId>javax.servlet-api </artifactId> 
          <version>3.1.0 </version> 
          </dependency> 
          
           
           
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-core </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-beans </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-context </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
           
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-jdbc </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-tx </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
           
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-web </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-webmvc </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
          
           
          <dependency> 
          <groupId>org.springframework </groupId> 
          <artifactId>spring-test </artifactId> 
          <version>${org.springframework.version} </version> 
          </dependency> 
           
          <dependency> 
          <groupId>redis.clients </groupId> 
          <artifactId>jedis </artifactId> 
          <version>2.7.3 </version> 
          </dependency> 
           
          <dependency> 
          <groupId>com.dyuproject.protostuff </groupId> 
          <artifactId>protostuff-core </artifactId> 
          <version>1.0.8 </version> 
          </dependency> 
          <dependency> 
          <groupId>com.dyuproject.protostuff </groupId> 
          <artifactId>protostuff-runtime </artifactId> 
          <version>1.0.8 </version> 
          </dependency> 
          <dependency> 
          <groupId>commons-collections </groupId> 
          <artifactId>commons-collections </artifactId> 
          <version>3.2 </version> 
          </dependency> 
          
          <dependency> 
          <groupId>com.github.sgroschupf </groupId> 
          <artifactId>zkclient </artifactId> 
          <version>0.1 </version> 
          </dependency> 
          </dependencies> 
           
          </project>

## Web.xml ##

这里使用contextConfigLocation来加载我们spring的配置文件。

<servlet> 
          <servlet-name>user-service </servlet-name> 
          <servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class> 
           
          <init-param> 
          <param-name>contextConfigLocation </param-name> 
          <param-value>classpath:spring/spring-*.xml </param-value> 
          </init-param> 
          </servlet> 
          <servlet-mapping> 
          <servlet-name>user-service </servlet-name> 
           
          <url-pattern>/ </url-pattern> 
          </servlet-mapping>

## 配置视图解析器： ##

## 建立JDBC属性文件 ##

jdbc.properties（文件编码修改为utf-8)

jdbc.driver=com.mysql.jdbc.Driver 
          jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8 
          jdbc.username=root 
          jdbc.password=root

## Spring整合mybatis DAO层 ##

<?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:context= "http://www.springframework.org/schema/context" 
          xsi:schemaLocation= "http://www.springframework.org/schema/beans 
          http://www.springframework.org/schema/beans/spring-beans.xsd 
          http://www.springframework.org/schema/context 
          http://www.springframework.org/schema/context/spring-context.xsd"> 
           
           
          <context:property-placeholder location="classpath:jdbc.properties"/> 
          
           
          <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
           
          <property name="driverClass" value="${jdbc.driver}"/> 
          <property name="jdbcUrl" value="${jdbc.url}"/> 
          <property name="user" value="${jdbc.username}"/> 
          <property name="password" value="${jdbc.password}"/> 
          
           
          <property name="maxPoolSize" value="30"/> 
          <property name="minPoolSize" value="10"/> 
           
          <property name="autoCommitOnClose" value="false"/> 
           
          <property name="checkoutTimeout" value="1000"/> 
           
          <property name="acquireRetryAttempts" value="2"/> 
          </bean> 
          
           
           
          <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
           
          <property name="dataSource" ref="dataSource"/> 
           
          <property name="configLocation" value="classpath:mybatis-config.xml"/> 
           
          <property name="typeAliasesPackage" value="com.dubbo.entity"/> 
           
          <property name="mapperLocations" value="classpath:mapper/*.xml"/> 
          </bean> 
          
           
          <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> 
           
          <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> 
           
          <property name="basePackage" value="com.dubbo.dao"/> 
          </bean> 
          
           
          <bean id="redisDao" class="com.dubbo.dao.cache.RedisDao"> 
          <constructor-arg index="0" value="localhost"/> 
          <constructor-arg index="1" value="6379"/> 
          </bean> 
          </beans>

redisDao以后会用到，现在先不管。

## spring整合service层,开启事务 ##

## mybatis配置文件 ##

<?xml version="1.0" encoding="UTF-8" ?> 
          <!DOCTYPE configuration 
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
          "http://mybatis.org/dtd/mybatis-3-config.dtd"> 
          <configuration> 
           
          <settings> 
           
          <setting name="useGeneratedKeys" value="true"/> 
           
          <setting name="useColumnLabel" value="true"/> 
           
          <setting name="mapUnderscoreToCamelCase" value="true"/> 
          </settings> 
          </configuration>

基本上配置就这些，log4我感觉用处不大，懒得配置了。下面还有有一些mybatis的xml配置，这个后面再讲。

## mysql: ##

创建我们的sql

CREATE TABLE `user` ( 
          `userId` BIGINT ( 20), 
          `userName` VARCHAR ( 108), 
          `account` VARCHAR ( 108), 
          `password` VARCHAR ( 108), 
          `phone` VARCHAR ( 66), 
          `address` VARCHAR ( 108) 
          ); DEFAULT CHARSET=utf8;

简单创建几个字段，随便加几条数据就好。

## 创建实体类： ##

在创建实体类之前我先把包结构给建立好了；

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923135855656?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

在我们的entity里面创建一下User的实体类。

public class User implements Serializable{ 
          private String userId; 
          private String userName; 
          private String account; 
          private String phone; 
          private String password; 
          private String address; 
          public String getUserId() { 
          return userId; 
          } 
          public void setUserId(String userId) { 
          this.userId = userId; 
          } 
          public String getUserName() { 
          return userName; 
          } 
          public void setUserName(String userName) { 
          this.userName = userName; 
          } 
          public String getAccount() { 
          return account; 
          } 
          public void setAccount(String account) { 
          this.account = account; 
          } 
          public String getPhone() { 
          return phone; 
          } 
          public void setPhone(String phone) { 
          this.phone = phone; 
          } 
          public String getAddress() { 
          return address; 
          } 
          public void setAddress(String address) { 
          this.address = address; 
          } 
          public String getPassword() { 
          return password; 
          } 
          public void setPassword(String password) { 
          this.password = password; 
          } 
          
          }

## 编写dao和service ##

public interface UserDao { 
          public List<User> getListUser(); 
          }

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

@Service 
          public class UserServiceImpl implements UserService { 
          private final Logger logger = LoggerFactory.getLogger( this.getClass()); 
          
          //注入Service依赖 
          @Autowired 
          private UserDao userDao; 
          
          /** 
          * @return 
          * @see com.dubbo.service.UserService#getListUser() 
          *<pre> 
          *<li>Author:</li> 
          *<li>Date: 2016年9月23日</li> 
          *</pre> 
          */ 
          @Override 
          public List<User> getListUser() { 
          return userDao.getListUser(); 
          } 
          
          
          
          
          }

<?xml version="1.0" encoding="UTF-8" ?> 
          <!DOCTYPE mapper 
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> 
          <mapper namespace="com.dubbo.dao.UserDao"> 
           
          
          <select id="getListUser" resultType="User"> 
          SELECT*FROM USER 
          </select> 
          </mapper>

## 编写Controller ##

@Autowired 
          private UserService userService; 
          @RequestMapping(value = "/list", method = RequestMethod.GET) 
          public String list(Model model) { 
          //获取列表页 
          List<User> list = userService.getListUser(); 
          model.addAttribute( "list", list); 
          //list.jsp + model = ModelAndView 
          return "list"; // /WEB-INF/jsp/"list".jsp 
          }

## 启动Tomcat测试： ##

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923161017870?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

# 整合Dubbo和zookeeper #

在整合之前首先要明白Dubbo和zookeeper是干嘛用的。

SOA的框架也正是现在网站的系统架构演化史，也从侧面反映了我国网民数量的增加和对网站性能的提升。

## 大型网站系统特点 ##

（1）高并发、大流量：PV量巨大

（2）高可用：7\*24小时不间断服务

（3）海量数据：文件数目分分钟xxTB

（4）用户分布广泛，网络情况复杂：网络运营商

（5）安全环境恶劣：黑客的攻击

（6）需求快速变更，发布频繁：快速适应市场，满足用户需求

（7）渐进式发展：慢慢地运营出大型网站

## 例子： ##

小明作为一个屌丝码农，有一天创建了一个网站，最开始只是小明一个人在运营，所有的程序都在一个Server里面跑，数据库访问和逻辑控制也都写在jsp文件里面。应用程序、数据库、文件等所有资源都集中在一台Server上。这就是典型的纯jsp网站。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923145856700?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)  
  
后来他的好朋友小王来了，他觉得小明的网站做的不错，于是就提出了改造建议，小王可是受过培训的啊，什么MVC人家可是经常背，于是他们的网站就开始拆分MVC三层了。并且把文件服务器和数据库单独部署到一个Server上。

这个时候**三台Server平天下，**应用和数据服务分离。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923150212120?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

再到后来，他们的网站越来越大了，普通的架构已经满足不了他们了，怎么办，必须得做集群，必须要有缓存，什么读写分离啊，redis啊和反向代理和CDN加速等等，慢慢的开始应用起来。

分布式服务：既然每一个应用系统都需要执行许多相通的业务操作，比如用户管理、商品管理等，那么可以将这些共用的业务提取出来，独立部署。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923150521233)

好了，其实dubbo简单来说就是用来管理我们的服务的，以前我们都是自己调自己的服务，如果服务挂掉的话，那么整个系统就挂掉了，现在是我们把服务交给dubbo去统一管理,而zookeeper是管理我们的dubbo的。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923153142441)

创建user-api；user-api的作用很简单，作为一个API，把接口暴露出来供我们的客户端调用。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923153344210)

public interface UserService { 
          public List getListUser(); 
          }

修改服务端代码，这里要修改一下我们的user-service。把他作为一个服务层，只和数据库进行交互。

## Web-xml ##

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
          http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" 
          version="3.1" metadata-complete="true"> 
           
           
          <listener> 
          <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
          </listener> 
          <context-param> 
          <param-name>contextConfigLocation</param-name> 
          <param-value>classpath:spring/spring-*.xml</param-value> 
          </context-param> 
          <servlet> 
          <servlet-name>user-service</servlet-name> 
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
           
          <init-param> 
          <param-name>contextConfigLocation</param-name> 
          <param-value>classpath:spring/spring-*.xml</param-value> 
          </init-param> 
          </servlet> 
          <servlet-mapping> 
          <servlet-name>user-service</servlet-name> 
           
          <url-pattern>/</url-pattern> 
          </servlet-mapping> 
          </web-app>

这里如果不用<listener>加载的话dubbo服务注册不上去，具体原因还没有找到，还有这里加载了两遍配置文件才起作用，具体原因也还在探索中（迷茫。。）最后一个拦截器，可以不需要，因为我们不通过user-service访问页面。

去掉service接口，这里我们通过引入user-api里面的接口，并且也基础里面的接口，所以user-service里面的接口可以去掉。

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923154549539)

## 创建dubbo配置文件 spring-dubbo.xml ##

最后启动Tomcat；

## 我们使用zk-Inspector，来监控一下zk的服务。 ##

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923154858089)

点击绿色的箭头，然后开启监控，我们可以看到

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923155255891?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

## dubbo服务已经注册成功，然后我们再进入dubbo管理页面看看。 ##

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923155351627?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)  
也创建了三个服务，证明我们的服务端已经开发完成。

# 客户端： #

这个时候要创建我们的客户端了，客户端也采用SSM架构，其实根本不用Mybatis，因为数据交互都交给了我们的客户端，这里直接把服务端的架构复制过来；

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923160505962?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

## 这里加载一下视图解析器和dubbo配置就好了。 ##

@Controller 
          public class UserController { 
          
          @Autowired 
          private UserService userService; 
          @ResponseBody 
          @RequestMapping(value = "/list", method = RequestMethod.GET) 
          public String list(Model model) { 
          //获取列表页 
          List list = userService.getListUser(); 
          model.addAttribute( "list", list); 
          //list.jsp + model = ModelAndView 
          return "list"; // /WEB-INF/jsp/"list".jsp 
          } 
          
          }

## 最后另外启动一个tomcat。 ##

访问我们的客户端

!\[在这里插入图片描述\](https://img-blog.csdn.net/20160923160657862?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center)

[http_www.apache.org_dyn_closer.cgi_zookeeper]: http://www.apache.org/dyn/closer.cgi/zookeeper/