前瞻java Dubbo搭建

1. 简介

Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC（Remote Procedure Cal远程过程调用）远程服务调用方案。

 2. 架构

Provider: 暴露服务的服务提供方。

Consumer: 调用远程服务的服务消费方。

Registry: 服务注册与发现的注册中心。 

Monitor: 统计服务的调用次调和调用时间的监控中心。 

Container: 服务运行容器。

 关于Dubbo的详细介绍请参考http://dubbo.io/

3. 用Eclipse搭建Dubbo项目（使用Maven进行项目管理）
Dubbo项目一般分为两个部分，一个是service-api,一个是service.其中api为暴露在外的Dubbo服务接口，为提供者和消费者所公用。而Dubbo服务则部署在服务器上不对外公开。
作为Dubbo消费者(调用方)只需要知道有哪些接口、接口需要的参数以及接口能做的事情，而具体怎么实现交给dubbo服务来实现，dubbo服务作为提供者provider 在注册中心注册。
3.1. 搭建Dubbo Api
3.1.1. 搭建Maven项目
File- new – others 或者使用快捷键ctrl+n
下一步
选择 maven-archetype-quickstart，下一步
输入GAV，这三项为一个项目区别其它项目的“指纹”，
点击完成
Grop Id- 项目组名称，大项目名称
Atifact Id- 子项目名
Version –版本号
这个时候一个简单的maven项目搭建完成，打开POM文件可以看到刚才输入的GAV，如下
<groupId>com.mldn</groupId>
<artifactId>mldn-user-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
如果其他项目需要调用本项目的api 则需要在其POM文件中添加以上的依赖即可。
3.1.2. 增加maven 编译插件
在项目开发中，时常会需要执行更新maven的操作，如果不固定编译的JDK版本，所依赖的JRE系统包会变回默认版本，所以在POM中加入以下内容
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source><!-- 源码JDK版本 -->
<target>1.8</target><!-- 生成class的编译版本 -->
<encoding>utf-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
3.1.3. 增加maven 打包发布插件
一般团队开发都要使用到maven私服，用来统一管理jar包，需要将Dubbo api 发布jar包到私服 或者install到本地仓库使用，打包插件配置如下：  执行 mvn install，maven会自动将source install到repository 。  执行 mvn deploy，maven会自动将source deploy到remote-repository 。  执行 mvn source:jar，单独打包源码
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source><!-- 源码JDK版本 -->
<target>1.8</target><!-- 生成class的编译版本 -->
<encoding>utf-8</encoding>
</configuration>
</plugin> <plugin><!-- 打包插件 -->
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<configuration>
<encoding>UTF-8</encoding>
</configuration>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
3.1.4. 编写Dubbo接口
在base package(com.mldn)下新建api包
在api包中新建api接口
代码示例
package com.mldn.api;
publicinterface userApi {
publicboolean Insert();
}
此时 Dubbo api部分搭建完成，下面搭建Dubbo服务项目
3.2. 搭建Dubbo Service
3.2.1. 搭建Maven项目
步骤跟api搭建一样, 不同的是GAV
http://dubbo.io/. 新建assembly ，用于项目打包
在main目录下新建assembly 文件夹，并将maven打包插件配置文件拷进文件夹
文件来源：http://maven.apache.org/plugins/maven-assembly-plugin/assembly.html
3.2.3. 新建bin，用于linux上执行脚本
在main目录下新建bin文件夹，来源：mave jar包：
3.2.4. 建立profliles，用于定义不同环境的DB和Dubbo连接
在main目录下新建profiles 文件夹，在profiles 下新建 dev, beta-gn, product 三个profile 存放三 个不同环境的配置文件，dev 用于开发环境，beta-gn用于测试环境，product用于生产环境（线 上环境），存放的配置文件有：主要有三个 数据库配置文件、Dubbo配置文件、日志文件。
在每个profile下放入logback.xml 日志文件，然后在每个profile下新建conf放入 数据库配置 db.properties和dubbo配置文件dubbo.properties。profiles配置完成
3.2.5. 数据库连接配置(db.properties)详解：
数据库连接池使用alibaba的druid 连接池，配置详解如下：
#################alibabadruiddatasource###############
# 数据库连接驱动
driver=com.mysql.jdbc.Driver
# 数据库连接url
account.url=jdbc:mysql://127.0.01:3306/demo?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
# 数据库账户名
account.username = root
# 数据库密码
account.password = mysqladmin
# 初始化连接数量
druid.initialSize = 5
# 最大并发连接数
druid.maxActive = 10
# 最小空闲连接数
druid.minIdle = 3
# 配置获取连接等待超时的时间
druid.maxWait = 60000
# 超过时间限制是否回收
druid.removeAbandoned = true
# 超过时间限制多长
druid.removeAbandonedTimeout = 180
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
druid.timeBetweenEvictionRunsMillis = 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
druid.minEvictableIdleTimeMillis = 300000
# 用来检测连接是否有效的sql，要求是一个查询语句
druid.validationQuery = SELECT1FROMDUAL
# 申请连接的时候检测
druid.testWhileIdle = true
# 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能
druid.testOnBorrow = false
# 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能
druid.testOnReturn = false
# 打开PSCache，并且指定每个连接上PSCache的大小
druid.poolPreparedStatements = true
druid.maxPoolPreparedStatementPerConnectionSize = 50
# 监控统计用的filter:stat
druid.filters = stat
此配置会在以下XML中引用
src/main/resources/META-INF/spring/spring-datasource.xmlspring-datasource.xml
3.2.6. Dubbo配置文件(dubbo.properties)详解
# 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样，此参数不是匹配条件，你当前项目叫什么名字就填什么，和提供者消费者角色无关
dubbo.application.name=mldn-user-service
# 远程服务调用超时时间(毫秒)
dubbo.provider.timeout=10000000
# 注册中心配置 使用multicast广播注册中心暴露服务地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#用dubbo协议在9327端口暴露服务
dubbo.protocol.port=9327
# 服务版本
dubbo.iterface.version=dev
# dubbo会默认会在本地缓存注册中心的信息文件，默认路径在//home/[user]/.dubbo/dubbo-registry-192.168.1.109.cache
dubbo.registry.file=/data/www/log/dubbo/dubbo-registry.properties
# 监控中心服务地址
dubbo.monitor.address=127.0.0.1:6066
此配置会在以下XML中引用
src/main/resources/META-INF/spring/provider.xml
3.2.7. 新建resources 目录, 配置XML
在main目录下新建resources 文件夹，在resources文件夹内新建MATE-INF文件夹，然后再MATE-INF下新建mybatis 和 spring 两个文件夹。分别用来存放mybatis和spring配置文件。其中mybatis 下复制进去准备好的mybatis 配置mybatis-config.xml。在spring文件下复制进以下三个文件：
provider.xml（Dubbo提供者配置文件）
spring-common.xml（spring配置文件）
spring-datasource.xml（数据源配置文件）
这三个文件的变量位于profiles下的properties文件
最后在mybatis文件夹下新建map文件夹，用来存放mybatis mapper文件，XML配置完成，结构如下
这样布局的原因是: Dubbo 在运行的时候会自动加载META-INF/spring目录下的所有Spring配置。
配置详解：
mybatis-config.xml mybatis配置 <configuration>
<settings>
<!-- 这个配置使全局的映射器启用或禁用缓存。默认true -->
<settingname="cacheEnabled"value="true"/>
<!-- 全局启用或禁用延迟加载。默认true，为true的会使用cglib作代理 -->
<settingname="lazyLoadingEnabled"value="false"/>
<!-- 允许或不允许多种结果集从一个单独的语句中返回。默认true -->
<settingname="multipleResultSetsEnabled"value="true"/>
<!-- 启用自动映射到骆驼标识 -->
<settingname="mapUnderscoreToCamelCase"value="true"/>
<!-- 使用列标签代替列名。默认true -->
<settingname="useColumnLabel"value="true"/>
<!-- 允许JDBC支持生成的键。需要适合的驱动。默认false -->
<settingname="useGeneratedKeys"value="false"/>
<!-- 。REUSE执行器重用预处理语句。BATCH执行器重用语句和批量更新 。默认SIMPLE -->
<settingname="defaultExecutorType"value="SIMPLE"/>
<!-- 设置超时时间，它决定驱动等待一个数据库响应的时间。 -->
<settingname="defaultStatementTimeout"value="25000"/>
</settings>
</configuration>
spring-common.xml spring 配置入口
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xmlns:util="http://www.springframework.org/schema/util"
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/util
http://www.springframework.org/schema/util/spring-util-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- 开启注解 -->
<context:annotation-config/>
<context:component-scanbase-package="com.mldn"/>
<!-- 声明资源文件存放位置 -->
<context:property-placeholderlocation="classpath:conf/*.properties"/>
</beans>
provider.xml Dubbo提供者配置
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<dubbo:applicationname="${dubbo.application.name}"/><!--当前应用名称， -->
<!--注册中心配置 使用multicast广播注册中心暴露服务地址 -->
<dubbo:registryprotocol="zookeeper"address="${dubbo.registry.address}"/>
<!--用dubbo协议在xxx端口暴露服务 -->
<dubbo:protocolname="dubbo"port="${dubbo.protocol.port}"/>
<!--远程服务调用超时时间(毫秒) -->
<dubbo:providertimeout="${dubbo.provider.timeout}"/>
<!--监控中心 -->
<dubbo:monitoraddress="${dubbo.monitor.address}"/>
<!-- 声明需要暴露的服务接口 -->
<dubbo:serviceinterface="com.mldn.api.UserApi"ref="userApi"version="${dubbo.iterface.version}"/>
</beans>
spring-datasource.xml 数据源配置
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- dataSource -->
<!-- 配置数据源 Druid -->
<beanname="dataSource"id="dataSource"class="com.alibaba.druid.pool.DruidDataSource"
init-method="init"destroy-method="close">
<propertyname="driverClassName"value="${driver}"/>
<propertyname="url"value="${account.url}"/>
<propertyname="username"value="${account.username}"/>
<propertyname="password"value="${account.password}"/>
<!-- 初始化连接数量 -->
<propertyname="initialSize"value="${druid.initialSize}"/>
<!-- 最大并发连接数 -->
<propertyname="maxActive"value="${druid.maxActive}"/>
<!-- 最小空闲连接数 -->
<propertyname="minIdle"value="${druid.minIdle}"/>
<!-- 配置获取连接等待超时的时间 -->
<propertyname="maxWait"value="${druid.maxWait}"/>
<!-- 超过时间限制是否回收 -->
<propertyname="removeAbandoned"value="${druid.removeAbandoned}"/>
<!-- 超过时间限制多长； -->
<propertyname="removeAbandonedTimeout"value="${druid.removeAbandonedTimeout}"/>
<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
<propertyname="timeBetweenEvictionRunsMillis"value="${druid.timeBetweenEvictionRunsMillis}"/>
<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
<propertyname="minEvictableIdleTimeMillis"value="${druid.minEvictableIdleTimeMillis}"/>
<!-- 用来检测连接是否有效的sql，要求是一个查询语句 -->
<propertyname="validationQuery"value="${druid.validationQuery}"/>
<!-- 申请连接的时候检测 -->
<propertyname="testWhileIdle"value="${druid.testWhileIdle}"/>
<!-- 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能 -->
<propertyname="testOnBorrow"value="${druid.testOnBorrow}"/>
<!-- 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能 -->
<propertyname="testOnReturn"value="${druid.testOnReturn}"/>
<!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
<propertyname="poolPreparedStatements"value="${druid.poolPreparedStatements}"/>
<propertyname="maxPoolPreparedStatementPerConnectionSize"value="${druid.maxPoolPreparedStatementPerConnectionSize}"/>
<!-- 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：
监控统计用的filter:stat
日志用的filter:log4j
防御SQL注入的filter:wall -->
<propertyname="filters"value="${druid.filters}"/>
<propertyname="proxyFilters">
<list>
<refbean="log-filter"/>
</list>
</property>
</bean>
<beanid="log-filter"class="com.alibaba.druid.filter.logging.Log4jFilter">
<propertyname="statementExecutableSqlLogEnable"value="true"/>
<propertyname="statementExecuteAfterLogEnabled"value="false"/>
<propertyname="statementCreateAfterLogEnabled"value="false"/>
<propertyname="statementPrepareAfterLogEnabled"value="false"/>
<propertyname="statementPrepareCallAfterLogEnabled"value="false"/>
<propertyname="statementParameterClearLogEnable"value="false"/>
<propertyname="statementParameterSetLogEnabled"value="false"/>
</bean>
<!-- dataSource -->
<!-- mybatis -->
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">
<propertyname="dataSource"ref="dataSource"/>
<propertyname="configLocation"
value="classpath:META-INF/mybatis/mybatis-config.xml"/>
<propertyname="mapperLocations">
<list>
<value>classpath:META-INF/mybatis/mapper/*.xml</value>
<value>classpath:META-INF/mybatis/ReuseSQL.xml</value>
</list>
</property>
</bean>
<!-- 配置Mybatis模版 -->
<beanid="orderSqlSessionTemplate"class="org.mybatis.spring.SqlSessionTemplate">
<constructor-argindex="0"ref="sqlSessionFactory"/>
</bean>
<!--集成 spring jdbc template -->
<!-- <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource"ref="dataSource"></property>
</bean> -->
<beanid="txManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<propertyname="dataSource"ref="dataSource"/>
</bean>
<tx:adviceid="txAdvice"transaction-manager="txManager">
<tx:attributes>
<tx:methodname="insert*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="save*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="update*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="exec*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="delete*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="remove*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="add*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="minus*"propagation="REQUIRED"isolation="READ_COMMITTED"/>
<tx:methodname="find*"propagation="REQUIRED"isolation="READ_COMMITTED"
read-only="true"/>
<tx:methodname="get*"propagation="REQUIRED"isolation="READ_COMMITTED"
read-only="true"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcutid="txPointcut"
expression="execution(* com.mldn.service..*.*(..))"/>
<aop:advisorpointcut-ref="txPointcut"advice-ref="txAdvice"/>
</aop:config>
<tx:annotation-driventransaction-manager="txManager"/>
</beans>
3.2.8. POM 配置：
这里要引入Dubbo api的依赖以及其他依赖包，并配置maven插件
<projectxmlns="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.mldn</groupId>
<artifactId>mldn-user-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>mldn-user-service</name>
<url>http://maven.apache.org</url>
<properties>
<project.artifactId>cloud-live-service</project.artifactId><!-- 项目名 -->
<profiles.dir>src/main/profiles</profiles.dir><!--profie根目录 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><!-- 构建编码 -->
<druid.version>1.0.0</druid.version>
<dubbo-version>2.4.10</dubbo-version>
<zookeeper-version>3.4.5</zookeeper-version>
<zkclient.version>0.4</zkclient.version>
<mybatis-version>3.2.8</mybatis-version>
<mybatis-spring-version>1.2.1</mybatis-spring-version>
<mysql-version>5.1.29</mysql-version>
<logback-version>1.1.3</logback-version>
<org.slf4j-version>1.7.5</org.slf4j-version>
<commons-beanutils-version>1.9.1</commons-beanutils-version>
<commons-lang3-version>3.1</commons-lang3-version>
<net.sf.json-version>2.3</net.sf.json-version>
<spring-version>4.0.4.RELEASE</spring-version>
<aspectj-version>1.7.0</aspectj-version>
</properties>
<dependencies>
<!—api依赖引入 -->
<dependency>
<groupId>com.mldn</groupId>
<artifactId>mldn-user-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<!--Druid连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!--dubbo依赖 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>dubbo</artifactId>
<version>${dubbo-version}</version>
<exclusions>
<exclusion>
<artifactId>spring</artifactId><!-- 移除依赖，有版本冲突 -->
<groupId>org.springframework</groupId>
</exclusion>
</exclusions>
</dependency>
<!--zookeeper依赖 s-->
<dependency>
<groupId>org.apache.zookeeper</groupId>
<artifactId>zookeeper</artifactId>
<version>${zookeeper-version}</version>
<exclusions>
<exclusion>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
</exclusion>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</exclusion>
<!-- <exclusion>
<groupId>org.jboss.netty</groupId>
<artifactId>netty</artifactId>
</exclusion> -->
</exclusions>
</dependency>
<dependency>
<groupId>com.101tec</groupId>
<artifactId>zkclient</artifactId>
<version>${zkclient.version}</version>
<exclusions>
<exclusion>
<artifactId>log4j</artifactId>
<groupId>log4j</groupId>
</exclusion>
<exclusion>
<artifactId>zookeeper</artifactId>
<groupId>org.apache.zookeeper</groupId>
</exclusion>
</exclusions>
</dependency>
<!--zookeeper依赖 e-->
<!-- mybatis 依赖 s -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis-version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis-spring-version}</version><!--MyBatis-Spring integrates MyBatis
seamlessly with Spring -->
</dependency>
<!-- mybatis 依赖 e -->
<!-- mysql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-version}</version>
</dependency>
<!--日志 s -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>log4j-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<exclusions>
<exclusion>
<artifactId>slf4j-api</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<exclusions>
<exclusion>
<artifactId>slf4j-api</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>${logback-version}</version>
<exclusions>
<exclusion>
<artifactId>slf4j-api</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
<version>${logback-version}</version>
</dependency>
<!--日志 e -->
<!--工具类依赖 s-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3-version}</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>${commons-beanutils-version}</version>
<exclusions>
<exclusion>
<artifactId>commons-logging</artifactId>
<groupId>commons-logging</groupId>
</exclusion>
</exclusions>
</dependency>
<!--工具类依赖 e-->
<!--JSON -->
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>${net.sf.json-version}</version>
<classifier>jdk15</classifier>
<scope>compile</scope>
</dependency>
<!--集成Spring 和 spring JDBC -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring-version}</version>
</dependency>
<!-- Spring AOP所要用到的包 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>${aspectj-version}</version>
</dependency>
</dependencies>
<profiles>
<profile>
<id>dev</id>
<properties>
<profile.dir>${profiles.dir}/dev</profile.dir>
</properties>
<activation>
<activeByDefault>true</activeByDefault><!-- 默认激活 -->
</activation>
</profile>
<profile>
<id>beta-gn</id>
<properties>
<profile.dir>${profiles.dir}/beta-gn</profile.dir>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
<profile>
<id>product</id>
<properties>
<profile.dir>${profiles.dir}/product</profile.dir>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
</profiles>
<build>
<finalName>${project.artifactId}</finalName>
<defaultGoal>package</defaultGoal><!-- 预定义执行的目标或者阶段，必须和命令行的参数相同 -->
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
<resource>
<directory>${profile.dir}</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<descriptor>src/main/assembly/assembly.xml</descriptor><!--描述文件路径 -->
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase><!-- 绑定到package生命周期阶段上 -->
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<encoding>utf-8</encoding>
<excludes>
<exclude>conf/</exclude>
<exclude>META-INF/</exclude>
<exclude>logback.xml</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
3.2.9. 实现api服务
这块跟平时service曾的实现接口并进行逻辑处理基本相同。
3.3. 编写本地测试程序
Dubbo服务在开发的过程中需要本地调试，因此在maven生成的test下编写本地启动程序：
在test下的com.mldn目录下新建ProviderStartup类
package com.mldn;
import com.alibaba.dubbo.container.Main;
publicclass ProviderStartup {
publicstaticvoid main(String[] args) {
Main.main(args);
}
}
3.4. 配置build path
项目要想正常本地启动，需要配置相应的build path，步骤如下：
右击项目 Build Path Configure Build Path
点击add Folder
勾选resources 和profiles下的dev
完整的source列表是：
3.5. 配本地启动Dubbo服务
首先在本地启动zookeeper 或者服务器上启动。
然后右击ProviderStartup类，Run as Java Application,看到以下日志输出，Dubbo项目启动成功。
16-09-23.00:53:36.910 [main ] INFO Main - [DUBBO] Dubbo SpringContainer started!, dubbo version: 2.4.10, current host: 127.0.0.1
[2016-09-23 00:53:36] Dubbo service server started!