SSM整合+Dubbo+zookeeper-3.4.6

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

背景

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

  • 单一应用架构
    • 当网站流量很小时,只需一个应用,将所有功能都部署在一起,以减少部署节点和成本。
    • 此时,用于简化增删改查工作量的 数据访问框架(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/ 下载后解压即可。


然后进入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目录下面启动,客户端和服务端。


Dubbo:

需要下载:dubbo-admin-2.5.3的war

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

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


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

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


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

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>
<!--   <name>user-service Maven Webapp</name>
  <url>http://maven.apache.org</url> -->
      <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 设置 Spring 的版本 -->
	<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>
        <!-- 实现slf4j接口并整合 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!--2:数据库相关依赖 -->
        <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>

        <!-- DAO框架:MyBatis依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- mybats自身实现的spring整合依赖 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!-- 3:Servlet web相关依赖 -->
        <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>

        <!--4:spring依赖 -->
        <!--1)spring核心依赖  -->
        <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>
        <!--2)spring dao层依赖 -->
        <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>
        <!--3)spring web相关依赖 -->
        <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>

        <!-- 4)spring test相关依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <!-- redis客户端:Jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>
        <!-- protostuff序列化依赖 -->
        <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>
<!--   <build>
    <finalName>user-service</finalName>
  </build> -->
</project>

Web.xml

这里使用contextConfigLocation来加载我们spring的配置文件。
	<servlet>
		<servlet-name>user-service</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 配置springMVC需要加载的配置文件 spring-dao.xml,spring-service.xml,spring-web.xml 
			Mybatis -> spring -> springMVC -->
		<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>

配置视图解析器:

<?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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
        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://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
    <!-- 配置SpringMVC -->
    <!-- 1:开启SpringMVC注解模式 -->
    <!-- 简化配置:
        (1)自动注册DefaultAnnotationHandlerMapping,AnnotationMethodHandlerAdapter
        (2)提供一系列:数据绑定,数字和日期的format @NumberFormat,@DataTimeFormat,
            xml,json默认读写支持.
     -->
    <mvc:annotation-driven/>

    <!--
        2:静态资源默认servlet配置
        1:加入对静态资源的处理:js,gif,png
        2:允许使用"/"做整体映射
     -->
    <mvc:default-servlet-handler/>

    <!--3:配置jsp 显示ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>

    </bean>
     <!--4:扫描web相关的bean -->
    <context:component-scan base-package="com.dubbo.controller"/>
</beans>

建立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">
    <!-- 配置整合mybatis过程 -->
    <!-- 1:配置数据库相关参数properties的属性:${url} -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 2:数据库连接池 -->
    <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}"/>

        <!-- c3p0连接池的私有属性 -->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!-- 关闭连接后不自动commit -->
        <property name="autoCommitOnClose" value="false"/>
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="1000"/>
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

    <!-- 约定大于配置 -->
    <!-- 3:配置SqlSessionFactory对象 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据库连接池 -->
        <property name="dataSource"  ref="dataSource"/>
        <!-- 配置MyBatis全局配置文件:mybatis-config.xml -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!-- 扫描entity包 使用别名 -->
        <property name="typeAliasesPackage" value="com.dubbo.entity"/>
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 4:配置扫描Dao接口包,动态实现Dao接口,注入到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.dubbo.dao"/>
    </bean>

    <!-- RedisDao -->
    <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层,开启事务

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="com.dubbo.service"/>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 配置基于注解的声明式事务
        默认使用注解来管理事务行为
    -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
		 <!-- 具体的实现bean -->  
</beans>

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>
        <!-- 使用jdbc的getGeneratedKeys 获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true"/>
        <!-- 使用列别名替换列名 默认:true
         select name as title from table
         -->
        <setting name="useColumnLabel" value="true"/>
        <!-- 开启驼峰命名转换:Table(create_time) -> Entity(createTime) -->
        <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; 

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

创建实体类:

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


在我们的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">
    <!-- 目的:为DAO接口方法提供sql语句配置-->

    <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测试:


整合Dubbo和zookeeper

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

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

大型网站系统特点

  (1)高并发、大流量:PV量巨大

  (2)高可用:7*24小时不间断服务

  (3)海量数据:文件数目分分钟xxTB

  (4)用户分布广泛,网络情况复杂:网络运营商

  (5)安全环境恶劣:黑客的攻击

  (6)需求快速变更,发布频繁:快速适应市场,满足用户需求

  (7)渐进式发展:慢慢地运营出大型网站


例子:

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



后来他的好朋友小王来了,他觉得小明的网站做的不错,于是就提出了改造建议,小王可是受过培训的啊,什么MVC人家可是经常背,于是他们的网站就开始拆分MVC三层了。并且把文件服务器和数据库单独部署到一个Server上。

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



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

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


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

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

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">
	<!-- 修改servlet版本为3.1 -->
	<!-- 配置DispatcherServlet -->
<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>
		<!-- 配置springMVC需要加载的配置文件 spring-dao.xml,spring-service.xml,spring-web.xml 
			Mybatis -> spring -> springMVC -->
		<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里面的接口可以去掉。

创建dubbo配置文件 spring-dubbo.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:p="http://www.springframework.org/schema/p"
	xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://code.alibabatech.com/schema/dubbo
	http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

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

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

	<!-- 用dubbo协议在20880端口暴露服务 -->
	<dubbo:protocol name="dubbo" port="20880" />
	<!-- 声明需要暴露的服务接口 -->
	<dubbo:service interface="com.dubbo.service.UserService"  ref="userService" />
	<!-- 具体的实现bean -->
	<bean id="userService" class="com.dubbo.service.impl.UserServiceImpl" />

	<!-- 声明需要暴露的服务接口 -->
	<dubbo:service interface="com.dubbo.service.TestService"  ref="testService" />
	<!-- 具体的实现bean -->
	<bean id="testService" class="com.dubbo.service.impl.TestServiceImpl" />
	
	<!-- 声明需要暴露的服务接口 -->
	<dubbo:service interface="com.dubbo.service.SeckillService"  ref="seckillService" />
	<!-- 具体的实现bean -->
	<bean id="seckillService" class="com.dubbo.service.impl.SeckillServiceImpl" />
	

</beans>

最后启动Tomcat;

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



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

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


也创建了三个服务,证明我们的服务端已经开发完成。

客户端:

这个时候要创建我们的客户端了,客户端也采用SSM架构,其实根本不用Mybatis,因为数据交互都交给了我们的客户端,这里直接把服务端的架构复制过来;
<?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="test_consumer" />

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

	<!-- 用dubbo协议在20880端口暴露服务 -->
	<dubbo:protocol name="dubbo" port="20880" />
		<!-- 声明需要暴露的服务接口 -->
	<dubbo:reference interface="com.dubbo.service.UserService" id="userService" check="false" />
	<!-- 声明需要暴露的服务接口 -->
	<dubbo:reference interface="com.dubbo.service.TestService" id="testService" check="false" />
	
	<!-- 声明需要暴露的服务接口 -->
	<dubbo:reference interface="com.dubbo.service.SeckillService" id="seckillService" check="false" />

</beans>

这里加载一下视图解析器和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。

访问我们的客户端




发布了181 篇原创文章 · 获赞 299 · 访问量 68万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 酷酷鲨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览