• 课程计划
    • 第二天：商品列表功能实现
  • 1、功能分析
  • 2、服务中间件Dubbo
  • 3、SSM框架整合+Zookeeper
  • 4、Dubbo的Admin管理平台
  • 5、后台商品列表查询功能实现
  • 5、dubbo监控中心的搭建

1、功能分析

1.1、后台系统所用的技术

  • 框架：Spring + SpringMVC + Mybatis + Dubbo
  • 前端：EasyUI
  • 数据库：MySQL

1.2、创建数据库

  • 1、安装mysql数据库，要求5.5以上版本。
  • 2、在mysql中创建一个taotao数据库。
  • 3、将创建数据库的脚本taotao.sql导入到taotao中。

1.3、Mybatis逆向工程

  • 使用mybatis官方提供的mybatis-generator生成pojo、mapper接口及映射文件。
  • 并且将pojo放到toatao-manager-pojo工程中。
  • 将mapper接口及映射文件放到taotao-manager-dao工程中。
    • 注意1：因为涉及到各个工程（系统）之间来回传递对象，所以使用时需要对涉及到的POJO实现序列化接口。
      • 我们发现mybatis的插件，有一个可以自动给所有pojo实现序列化接口（example除外）
    • 注意2：如果生成的pojo能够有toString()的重写会给开发、调试带来很大的方便，所以我们也将生成的pojo重写toString()方法。
      • 同样使用mybatis的插件。
    • 即我们在使用Mybatis逆向工程的时候，在其配置文件generatorConfig.xml中配置下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
        <!-- 配置生成pojo的序列化的插件，mybatis支持很多插件，这些插件都在 org.mybatis.generator.plugins包下  -->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin" />

        <!--配置生成pojo的tostring()方法的插件，mybatis支持很多插件，这些插件都在 org.mybatis.generator.plugins包下 -->
        <plugin type="org.mybatis.generator.plugins.ToStringPlugin" />

        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/taotao" userId="root" password="root">
        </jdbcConnection>
        <!-- 默认false时，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer
              当为 true时，把JDBC DECIMAL 和  NUMERIC 类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject：生成PO类的位置 -->
        <javaModelGenerator targetPackage="com.taotao.pojo" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject：mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="com.taotao.mapper" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.taotao.mapper" targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!-- 指定数据库表 -->
        <table schema="" tableName="tb_content"></table>
        <table schema="" tableName="tb_content_category"></table>
        <table schema="" tableName="tb_item"></table>
        <table schema="" tableName="tb_item_cat"></table>
        <table schema="" tableName="tb_item_desc"></table>
        <table schema="" tableName="tb_item_param"></table>
        <table schema="" tableName="tb_item_param_item"></table>
        <table schema="" tableName="tb_order"></table>
        <table schema="" tableName="tb_order_item"></table>
        <table schema="" tableName="tb_order_shipping"></table>
        <table schema="" tableName="tb_user"></table>
    </context>
</generatorConfiguration>

1.4、系统间通信问题

1.4.1、分析

  由于淘淘商城是基于soa的架构，表现层和服务层是不同的工程。所以要实现商品列表查询需要两个系统之间进行通信。
  如何实现远程通信？

  • 1、使用Webservice：效率不高，它是基于soap协议（html+xml）。项目中不推荐使用。优点是：跨语言、跨平台。适用于两个公司之间。
  • 2、使用Restful形式的服务：http+json。很多项目中应用。如果服务越来越多，服务与服务之间的调用关系复杂，调用服务的URL管理复杂，什么时候添加机器难以确定。 需要治疗服务。适用于中小型企业。
  • 3、使用Dubbo：使用RPC协议进行远程调用，直接使用socket通信。传输效率高，并且可以统计出系统之间的调用关系、调用次数，管理服务。适用于大型企业。缺点：不能跨语言。只能java语言。

2、Dubbo

2.1、什么是dubbo

  最新中文网址：https://dubbo.incubator.apache.org/zh-cn/index.html
  DUBBO是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，是阿里巴巴SOA服务化治理方案的核心框架，每天为2,000+个服务提供3,000,000,000+次访问量支持，并被广泛应用于阿里巴巴集团的各成员站点。
  随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

  • 单一应用架构
    当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。
    此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
  • 垂直应用架构
    当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。
    此时，用于加速前端页面开发的Web框架(MVC)是关键。
  • 分布式服务架构
    当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。
    此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。
  • 流动计算架构
    当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。
    此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。
  • Dubbo就是资源调度和治理中心的管理工具。
  • Dubbo 就是类似于webservice的关于系统之间通信的框架，并可以统计和管理服务直接的调用情况（包括服务被谁调用了，调用的次数是如何，以及服务的使用状况）。

2.2、Dubbo的架构

  • Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。
  • 节点角色说明：
    • Provider: 暴露服务的服务提供方。
    • Consumer: 调用远程服务的服务消费方。
    • Registry: 服务注册与发现的注册中心。
    • Monitor: 统计服务的调用次调和调用时间的监控中心。
    • Container: 服务运行容器。
  • 调用关系说明：
    • 0、服务容器负责启动，加载，运行服务提供者。
    • 1、服务提供者在启动时，向注册中心注册自己提供的服务。
    • 2、服务消费者在启动时，向注册中心订阅自己所需的服务。
    • 3、注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于`长连接`推送变更数据给消费者。
    • 4、服务消费者，从提供者地址列表中，基于`软负载均衡算法`，选一台提供者进行调用，如果调用失败，再选另一台调用。
    • 5、服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次`统计`数据到监控中心。

2.3、Dubbo的使用方法

  • spring配置
    • Dubbo采用全Spring配置方式，透明化接入应用，对应用没有任何API侵入，只需用Spring加载Dubbo的配置即可，Dubbo基于Spring的Schema扩展进行加载。
  • 单一工程中spring的配置local.xml（没有使用dubbo时）：
    <bean id="xxxService" class="com.xxx.XxxServiceImpl" />
    <bean id="xxxAction" class="com.xxx.XxxAction">
        <property name="xxxService" ref="xxxService" />
    </bean>
  • 远程服务（使用dubbo时）：
    在本地服务的基础上，只需做简单配置，即可完成远程化：
    将上面的local.xml配置拆分成两份，将服务定义部分放在服务提供方remote-provider.xml，将服务引用部分放在服务消费方remote-consumer.xml。
    并在服务提供方增加暴露服务配置，在服务消费方增加引用服务配置。

服务层发布服务：

    <!-- 和本地服务一样实现远程服务 -->
    <bean id="xxxService" class="com.xxx.XxxServiceImpl" />
    <!-- 增加暴露远程服务配置 -->
    <dubbo:service interface="com.xxx.XxxService" ref="xxxService" />

表现层调用服务：

    <!-- 增加引用远程服务配置 -->
    <dubbo:reference id="xxxService" interface="com.xxx.XxxService" />
    <!-- 和本地服务一样使用远程服务 -->
    <bean id="xxxAction" class="com.xxx.XxxAction">
        <property name="xxxService" ref="xxxService" />
    </bean>

2.4、注册中心–zookeeper

2.4.1、zookeeper的介绍

  Zookeeper（集群管理工具:动物管理员）适用于大数据里面的生态系统。比如：大数据中的hadoop（大象）、Hive（蜂巢）等等动物需要动物管理员来管理哈！
  Dubbo中使用Zookeeper是作为注册中心使用的，注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小。使用dubbo-2.3.3以上版本，建议使用Zookeeper注册中心。
  Zookeeper是Apacahe Hadoop的子项目，是一个树型的目录服务，支持变更推送，适合作为Dubbo服务的注册中心，工业强度较高(稳定性好)，可用于生产环境，并推荐使用。

2.4.2、环境准备

  • 虚拟机软件环境：VMware 14 PRO
  • linux环境：CentOS 7.5
  • 环境我已经装备好了，我们使用VMWare打开虚拟机。

2.4.3、使用SecureCRT连接Linux系统

  • 清除所有文件，我们先要有一个干干净净的Linux系统。如下图：

2.4.4、zookeeper的安装

  • 第一步：linux上安装jdk，参考链接：https://www.cnblogs.com/chenmingjun/p/9931593.html
  • 第二步：上传linux版本的zookeeper压缩包至linux系统下的/user/local/zookeeper目录下，解压缩zookeeper压缩包
  • 第三步：进入zookeeper解压目录，将conf文件夹下zoo_sample.cfg改名为zoo.cfg，命令：mv zoo_sample.cfg zoo.cfg
  • 第四步：编辑zoo.cfg文件，修改配置dataDir属性，指定一个真实目录（进入zookeeper解压目录，创建data目录：mkdir data)
  • 第五步：
    • 启动zookeeper：bin/zkServer.sh start
    • 关闭zookeeper：bin/zkServer.sh stop
    • 查看zookeeper状态：bin/zkServer.sh status
    • 注意：如果出现问题，需要关闭linux的防火墙。否则不建议关闭防火墙，而是配置防火墙。

3、SSM框架整合+Zookeeper

3.1、需求

  • 根据商品id查询商品信息，并将商品信息使用json数据返回。
  • 分析：
    • 请求的url：`/item/{itemId}`  注意：(把参数放在了请求的里面，使用Restfull软件架构设计模式)
    • 参数：商品id，从请求的url中获得
    • 返回值：TbItem对象，逆向工程生成的pojo（响应json数据）

3.2、配置对dubbo的依赖

  • 加入dubbo相关的jar包。服务层、表现层都要配置。在服务层、表现层的pom.xml文件中添加依赖。

服务层：taotao-manager-service/pom.xml

    <!-- 配置对dubbo的依赖 -->
    <!-- dubbo相关 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <version>${dubbo.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>${zookeeper.version}</version>
    </dependency>
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>${zkclient.version}</version>
    </dependency>

注意：当我们配置对dubbo的依赖后，要查看dubbo的依赖关系，排除掉dubbo依赖的低版本的jar，比如：spring-2.5.6.SEC03.jar和netty-3.2.5.Final.jar（这同样也是编程的好习惯）！
排除方法：
方法一：在taotao-manager-service/pom.xml中手动编写代码，所以最终pom.xml中要添加的内容如下：

    <!-- 配置对dubbo的依赖 -->
    <!-- dubbo相关 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <!-- 排除对低版本jar包的依赖 -->
        <exclusions>
            <exclusion>
                <artifactId>spring</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
            <exclusion>
                <artifactId>netty</artifactId>
                <groupId>org.jboss.netty</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
    </dependency>

方法二：使用图形化界面，如下图所示：


二种方式本质是一样的！
表现层：taotao-manager-web/pom.xml

    <!-- 配置对dubbo的依赖 -->
    <!-- dubbo相关 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <!-- 排除对低版本jar包的依赖 -->
        <exclusions>
            <exclusion>
                <artifactId>spring</artifactId>
                <groupId>org.springframework</groupId>
            </exclusion>
            <exclusion>
                <artifactId>netty</artifactId>
                <groupId>org.jboss.netty</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
    </dependency>

3.3、整合思路

  • 1、Dao层：
    mybatis整合spring，通过spring管理SqlSessionFactory、Mapper代理对象。需要mybatis和spring的整合包。由spring创建数据库连接池。
    下图所示为文件所对应的工程：
  • 2、Service层：
    所有的service实现类都放到spring容器中管理，并由spring管理事务。发布dubbo服务。
    下图所示为文件所对应的工程：

    web.xml中：配置加载spring容器
  • 3、表现层：
    springmvc框架，由springmvc管理Controller。引用dubbo服务。
    下图所示为文件所对应的工程：

    web.xml中：配置前端控制器，配置URL拦截形式。

3.4、Dao整合

  • 整合后的目录结构如下：后面的配置文件可以参考此图片创建目录（这样的目录结构赏心悦目啊！）

3.4.1、创建SqlMapConfig.xml配置文件

SqlMapConfig.xml（由于和spring进行整合了，里面空空如也，但是该文件必须要有！）

<?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>

</configuration>

3.4.2、spring整合mybatis

创建applicationContext-dao.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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.2.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
    http://www.springframework.org/schema/util 
    http://www.springframework.org/schema/util/spring-util-4.2.xsd">
    <!-- 配置数据库连接池 -->
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:properties/*.properties" />
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        destroy-method="close">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="maxActive" value="10" />
        <property name="minIdle" value="5" />
    </bean> 
    <!-- 配置让spring管理sqlsessionfactory，使用mybatis和spring整合包中的 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 数据库连接池 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 加载mybatis的全局配置文件 -->
        <property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />
    </bean> 
    <!-- 配置Mapper映射文件的包扫描器 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.taotao.mapper" />
    </bean>
</beans>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/taotao?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

备注：
  Druid（德鲁伊）是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。
  Druid已经在阿里巴巴部署了超过600个应用，经过多年多生产环境大规模部署的严苛考验。

3.5、Service整合

3.5.1、配置管理Service

applicationContext-service.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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.2.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
    http://code.alibabatech.com/schema/dubbo 
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd
    http://www.springframework.org/schema/util 
    http://www.springframework.org/schema/util/spring-util-4.2.xsd">
    <!-- 配置包扫描器，扫描所有需要带@Service注解的类 -->
    <context:component-scan base-package="com.taotao.service"></context:component-scan>

    <!-- 使用dubbo发布服务：需要先引入dubbo的约束 -->
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="taotao-manager" />
    <dubbo:registry protocol="zookeeper" address="192.168.5.130:2181" />
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />
    <!-- 声明需要暴露的服务接口 -->
    <dubbo:service interface="com.taotao.service.ItemService" ref="itemServiceImpl" />
</beans>

3.5.2、配置事务管理

创建applicationContext-transaction.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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.2.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
    http://www.springframework.org/schema/util 
    http://www.springframework.org/schema/util/spring-util-4.2.xsd">

    <!-- 配置事务管理器 ：包括：通知、切面-->
    <!-- 事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 传播行为 -->
            <!-- 增删改操作需要配置事务 -->
            <tx:method name="save*" propagation="REQUIRED" />
            <tx:method name="insert*" propagation="REQUIRED" />
            <tx:method name="add*" propagation="REQUIRED" />
            <tx:method name="create*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <!-- 查询操作不需要配置事务 -->
            <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="select*" propagation="SUPPORTS" read-only="true" />
            <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
        </tx:attributes>
    </tx:advice>
    <!-- 切面 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.taotao.service.*.*(..))" />
    </aop:config>
</beans>

3.5.3、配置web.xml

由于taotao-manager-service是一个聚合工程中的web工程，所以我们需要配置下该工程的web.xml
web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <display-name>taotao-manager</display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <!-- 初始化spring容器：也即加载spring容器 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

3.5.4、spring父子容器的关系

  • 思考：以上我们的服务层已经配置好了，在表现层的springmvc我们还需要初始化spring容器吗？即springmvc可以初始化一个容器吗？亦即我们还需要写上面web.xml中的那段代码吗？
    答：在表现层的springmvc我们不需要初始化spring容器了。为什么呢？原因如下图所示：

    访问规则：子容器可以访问父容器的对象，父容器不可以访问子容器的对象。
    即：spring父容器里面的对象可以注入spring子容器中，而spring子容器中的对象不可以注入spring父容器中。

3.6、表现层整合

3.6.1、配置管理Controller

springmvc.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:context="http://www.springframework.org/schema/context"
    xmlns:dubbo="http://code.alibabatech.com/schema/dubbo" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    http://www.springframework.org/schema/mvc 
    http://www.springframework.org/schema/mvc/spring-mvc-4.2.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-4.2.xsd">
    <!-- 配置包扫描器，扫描所有需要带@Controller注解的类 -->
    <context:component-scan base-package="com.taotao.controller" />
    <!-- 配置注解驱动 -->
    <mvc:annotation-driven />
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 引用dubbo服务 ：需要先引入dubbo的约束-->
    <dubbo:application name="taotao-manager-web"/>
    <dubbo:registry protocol="zookeeper" address="192.168.5.130:2181"/> 
    <dubbo:reference interface="com.taotao.service.ItemService" id="itemService" />
</beans>

注意：如果没有添加interface的依赖，还需要在表现层工程的pom文件中添加taotao-manager-interface工程的依赖。
添加的内容如下：

    <!-- 配置对interface的依赖：表现层调用服务要通过该接口 -->
    <dependency>
        <groupId>com.taotao</groupId>
        <artifactId>taotao-manager-interface</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>

3.6.2、配置web.xml

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    id="WebApp_ID" version="2.5">
    <display-name>taotao-manager</display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <!-- 配置解决post乱码的过滤器 -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- 配置springmvc的前端控制器 -->
    <servlet>
        <servlet-name>taotao-manager-web</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- contextConfigLocation不是必须的， 如果不配置contextConfigLocation， 
             springmvc的配置文件默认在：WEB-INF/servlet的name+"-servlet.xml" -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>taotao-manager-web</servlet-name>
        <!-- 拦截所有请求，jsp除外 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

注意：其中配置项<load-on-startup>1</load-on-startup>表示tomcat启动之后就会加载这个servlet前端控制器，如果不配置的话，就表示第一次请求的时候才加载这个servlet前端控制器。

3.6.3、编写Controller

@Controller
public class ItemController {

    @Autowired
    private ItemService itemService;

    @RequestMapping("/item/{itemId}")
    @ResponseBody // 在后台，把JavaBean强制转换成json格式数据返回给前台页面。
    public TbItem getItemById(@PathVariable Long itemId) {
        TbItem item = itemService.getItemById(itemId);
        return item;
    }

}

注意：使用注解@ResponseBody可能会出现访问406错误，90%的情况下，是由于没有把jackson注解的jar包没有引入
@ResponseBody的作用：在后台，把JavaBean强制转换成json格式数据返回给前台页面。没有该jar，就不能把对象转成一个json格式的数据（json串）。服务器会出现406错误。
  本工程taotao-manager-web中有jackson的jar依赖，因为工程taotao-manager-web依赖工程taotao-common了，而在工程taotao-common依赖了jackson的jar包。

3.7、dubbo服务调用测试

3.7.1、添加日志文件log4j.properties

  • 测试之前我们先将log4j的日志配置文件log4j.properties拷贝至要启动工程的classpath目录下，如下图所示：

    这样工程启动报错就能输出错误信息，便于我们解决问题！

3.7.2、启动工程

  • 注意：使用tomcat插件要先启动服务层工程taotao-manager，再启动表现层工程taotao-manager-web。
  • 控制台会报错如下图：

    是由于目标主机无法访问，在cmd中都无法ping通，可能是远程主机没有启动，我们启动远程主机，启动zookeeper服务，问题仍旧在，为什么呢？突然想到了，远程主机的防火墙没有关闭，把端口2181屏蔽掉了。由于本博主使用的CentOS 7.5，防火墙使用的是firewalld，我们使用命令的方式来添加端口（修改后需要重启firewalld服务），操作如下：
  [root@itheima ~]# cd /etc/firewalld/zones/
  [root@itheima zones]# firewall-cmd --permanent --add-port=2181/tcp 
  [root@itheima zones]# service firewalld restart
  Redirecting to /bin/systemctl restart firewalld.service
  [root@itheima zones]# 
  • 再次启动服务层工程taotao-manager，启动成功，没有问题。
  • 然后我们启动表现层工程taotao-manager-web

3.7.3、测试访问

  • 测试访问地址：localhost:8081/item/830972
    测试报错如下图所示：

    原因是：映射文件并没有拷贝到classpath下导致。
  • 解决mapper映射文件不发布的问题：
    在taotao-manager-dao工程中的pom文件中添加如下内容：
    <build>
        <!-- 如果不添加此节点，mybatis的mapper.xml文件都会被漏掉 -->
        <!-- 注意：配置了此方式，原来的默认的资源拷贝行为将无效 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <!-- 
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
             -->
        </resources>
    </build>

taotao-manager-dao我们在表现层也会用到，所以改好后需要选择taotao-manager-dao工程进行安装，选中工程右键 Run as –> Maven install
注意：由于taotao-manager是一个聚合工程，taotao-manager-dao是该聚合工程中的模块工程，所以taotao-manager-dao中有修改的话，taotao-manager-dao也不需要安装，所以我们直接重启工程taotao-manager即可，命令：clean tomcat7:run
再次测试访问：localhost:8081/item/830972，出现了新的错误，如下：


原因是：因为涉及到各个工程（系统）之间来回传递对象，所以使用时需要对涉及到的POJO实现序列化接口。
  解决方式一：所以我们需要修pojo类，实现序列化接口。
  解决方式二：我们发现mybatis的插件，有一个可以自动给所有pojo实现序列化接口和序列化版本id（example除外）。即我们在使用Mybatis逆向工程的时候，在其配置文件generatorConfig.xml中配置下：

    <!-- 配置pojo的序列化 -->
    <plugin type="org.mybatis.generator.plugins.SerializablePlugin" />

修改完成后，由于我们在表现层也会用到taotao-manager-pojo，所以我们需要重新安装下，选中工程右键 Run as –> Maven install，安装完成后然后我们重启服务端工程和表现层工程。整合成功！
浏览器效果如下图：
浏览器美化后的json格式数据：


浏览器原始的json格式数据：

4、Dubbo的Admin管理平台

  • Dubbo监控中心其实就是一个web工程，目前推荐将Dubbo监控中心和注册中心安装在同一台服务器上，这样可以不需要任何配置。

4.1、环境准备

  • 1、准备好war包
  • 2、准备好tomcat
  • 3、使用SecureCRT上传到linux系统中
  • 4、需要安装先tomcat
      即解压tomcat，命令：tar -zxvf apache-tomcat-7.0.47.tar.gz
      然后删除tomcat压缩包，命令：rm -rf apache-tomcat-7.0.47.tar.gz

4.2、部署监控中心

  • 部署监控中心，拷贝dubbo-admin-2.5.4.war包到/usr/local/tomcat/apache-tomcat-7.0.47/webapps/下，并起个别名，名字太长了（下面演示本博主没有起别名，觉得名字还能接受）
[root@itheima tomcat]# ll
总用量 26296
drwxr-xr-x. 9 root root      160 11月 10 15:04 apache-tomcat-7.0.47
-rw-r--r--. 1 root root 26924417 9月  26 22:11 dubbo-admin-2.5.4.war
[root@itheima tomcat]# cp dubbo-admin-2.5.4.war apache-tomcat-7.0.47/webapps/
[root@itheima tomcat]# rm -rf dubbo-admin-2.5.4.war 
[root@itheima tomcat]# ll apache-tomcat-7.0.47/webapps/
总用量 26304
drwxr-xr-x. 13 root root     4096 11月 10 15:04 docs
drwxr-xr-x.  8 root root      149 11月 10 15:18 dubbo-admin-2.5.4
-rw-r--r--.  1 root root 26924417 11月 10 15:18 dubbo-admin-2.5.4.war
drwxr-xr-x.  7 root root      111 11月 10 15:04 examples
drwxr-xr-x.  5 root root       87 11月 10 15:04 host-manager
drwxr-xr-x.  5 root root      103 11月 10 15:04 manager
drwxr-xr-x.  3 root root     4096 11月 10 15:04 ROOT
[root@itheima tomcat]# 
  • 启动tomcat（注意：要先启动注册中心zookeeper）
[root@itheima tomcat]# cd apache-tomcat-7.0.47/bin/
[root@itheima bin]# ./startup.sh    --启动tomcat
Using CATALINA_BASE:   /usr/local/tomcat/apache-tomcat-7.0.47
Using CATALINA_HOME:   /usr/local/tomcat/apache-tomcat-7.0.47
Using CATALINA_TMPDIR: /usr/local/tomcat/apache-tomcat-7.0.47/temp
Using JRE_HOME:        /usr/local/java/jdk1.7.0_80/jre
Using CLASSPATH:       /usr/local/tomcat/apache-tomcat-7.0.47/bin/bootstrap.jar:/usr/local/tomcat/apache-tomcat-7.0.47/bin/tomcat-juli.jar
[root@itheima bin]# ps -ef|grep tomcat  --查看Tomcat的日志
root       4741      1 18 15:07 pts/1    00:00:03 /usr/local/java/jdk1.7.0_80/jre/bin/java -Djava.util.logging.config.file=/usr/local/tomcat/apache-tomcat-7.0.47/conf/logging.properties -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager -Djava.endorsed.dirs=/usr/local/tomcat/apache-tomcat-7.0.47/endorsed -classpath /usr/local/tomcat/apache-tomcat-7.0.47/bin/bootstrap.jar:/usr/local/tomcat/apache-tomcat-7.0.47/bintomcat-juli.jar -Dcatalina.base=/usr/local/tomcat/apache-tomcat-7.0.47 -Dcatalina.home=/usr/local/tomcat/apache-tomcat-7.0.47 -Djava.io.tmpdir=/usr/local/tomcat/apache-tomcat-7.0.47/temp org.apache.catalina.startup.Bootstrap start
root       4761   3081  0 15:07 pts/1    00:00:00 grep --color=auto tomcat
[root@itheima bin]# 

4.3、测试访问

  • 测试访问：http://192.168.5.130:8080/dubbo-admin-2.5.4/，浏览器弹出访问连接超时
    原因是：远程主机的防火墙没有关闭，把端口8080屏蔽掉了。由于本博主使用的CentOS 7.5，防火墙使用的是firewalld，我们使用命令的方式来添加端口（修改后需要重启firewalld服务），操作如下：
[root@itheima ~]# cd /etc/firewalld/zones/
[root@itheima zones]# firewall-cmd --permanent --add-port=8080/tcp 
[root@itheima zones]# service firewalld restart
Redirecting to /bin/systemctl restart firewalld.service
[root@itheima zones]# 
  • 同理，增加端口8081、8082、20880、7070（dubbo监控使用端口）
  • 查看tomcat目录下logs日志命令：tail -f logs/catalina.out
  • 再次访问：：http://192.168.5.130:8080/dubbo-admin-2.5.4/，依然不行，tomcat主页可以访问但是项目dubbo-admin-2.5.4无法访问，经过几个小时的谷歌和百度并尝试，发现了最终原因：dubbo-admin不能在jdk1.8的环境下运行，mmp！于是我卸载了jdk1.8，重新安装了jdk1.7。问题解决了！！！弹出了我想要的界面：
      用户名：root
      密码：root
  • 相关截图如下：

    成功登录界面如下：

    点击【服务治理】 –> 【服务】，就能看见我们发布的服务了

    点击【该服务】，可以看到本地电脑的IP和端口号

    点击【本地电脑的IP】，查看【服务提供者】的一些信息

    查看【服务消费者】的一些信息

    查看【应用】

    如果监控中心和注册中心在同一台服务器上，可以不需要任何配置。
    如果不在同一台服务器，需要修改配置文件：
    文件位置：/usr/local/tomcat/apache-tomcat-7.0.86/webapps/dubbo-admin-2.5.4/WEB-INF/dubbo.properties

    如果要运行监控中心，必须先启动zookeeper。
    监控中心对于dubbo的服务的调用来说不是必须的，不安装也可以运行。安装的目的是为了更好的统计其调用的次数，方便管理。

5、后台商品列表查询功能

5.1、整合静态页面

静态页面位置：如图：


使用方法：把静态页面添加到taotao-manager-web工程中的WEB-INF下，如下图所示：

由于在web.xml中定义的url拦截形式为“/”表示拦截所有的url请求，包括静态资源例如css、js等。所以需要在springmvc.xml中添加资源映射标签：

    <!-- 配置资源映射标签 -->
    <mvc:resources location="/WEB-INF/js/" mapping="/js/**" />
    <mvc:resources location="/WEB-INF/css/" mapping="/css/**" />

5.2、展示后台首页+展示菜单页面

5.2.1、功能分析

  • 首页的请求的url：/
  • 请求参数：无
  • 返回值：index.jsp （首页）

5.2.2、Controller

/**
 * 页面展示Controller
 * <p>Title: PageController</p>
 * <p>Description: </p>
 * <p>Company: www.itheima.com</p> 
 * @author    黑泽
 * @date    2018年11月9日下午7:59:33
 * @version 1.0
 */

@Controller
public class PageController {

    /**
     * 展示后台首页
     * <p>Title: showIndex</p>
     * <p>Description: </p>
     * @return
     */
    @RequestMapping("/")
    public String showIndex() {
        return "index";
    }

    /**
     * 展示菜单页面
     * <p>Title: showPage</p>
     * <p>Description: </p>
     * @param page
     * @return
     */
    @RequestMapping("/{page}")
    public String showPage(@PathVariable String page) {
        return page;
    }

注意：要先删掉webapp下测试用的的index.jsp。

5.3、后台商品列表查询功能分析

5.3.1、商品列表页面

  • 浏览器界面效果：
  • 浏览器请求的网址：http://localhost:8081/item/list?page=1&rows=30
    • 对应的jsp：
      item-list.jsp
    • 请求的url：
      /item/list
    • 请求的参数：
      page=1&rows=30
  • 服务端响应的json数据格式：
    Easyui中datagrid控件要求的数据格式为：
    {total:”2″,rows:[{“id”:”1″,”name”:”张三”},{“id”:”2″,”name”:”李四”}]}

5.3.2、响应的json数据格式EasyUIDataGridResult

创建商品列表查询时的返回的数据类EasyUIDataGridResult（包装类），将该类放入taotao-common中，因为服务层和表现层都要用它！

package com.taotao.common.pojo;

import java.io.Serializable;
import java.util.List;

/**
 * 列表查询时的返回的数据类
 * <p>Title: EasyUIDataGridResult</p>
 * <p>Description: </p>
 * <p>Company: www.itheima.com</p> 
 * @author    黑泽
 * @date    2018年11月11日上午11:54:31
 * @version 1.0
 */
public class EasyUIDataGridResult implements Serializable{

    private Long total;

    private List<?> rows;

    private static final long serialVersionUID = 1L;

    public Long getTotal() {
        return total;
    }

    public void setTotal(Long total) {
        this.total = total;
    }

    public List<?> getRows() {
        return rows;
    }

    public void setRows(List<?> rows) {
        this.rows = rows;
    }
}

5.3.3、分页处理

  • 由于逆向工程生成的代码是不支持分页处理的，如果想进行分页需要自己编写mapper，这样就失去逆向工程的意义了。为了提高开发效率可以使用mybatis的分页插件PageHelper。

5.4、Mybatis的分页插件PageHelper

5.4.1、Mybatis分页插件PageHelper的说明

  • 如果你也在用Mybatis，建议尝试该分页插件，这个一定是最方便使用的分页插件。
  • 该插件目前支持Oracle、Mysql、MariaDB、SQLite、Hsqldb、PostgreSQL六种数据库分页。不支持SQLServer数据库（微软）。

5.4.2、使用方法

Maven中央仓库最近更新的Artifact：http://maven.outofmemory.cn/
第一步：把PageHelper依赖的jar包添加到工程中。官方提供的代码对逆向工程支持的不好，使用参考资料中的pagehelper-fix。


注意：我们使用的PageHelper3.4.2-fix在Maven的中央仓库下载不到（因为有一点小bug，被我们修改过了，重新起了个名字），所以需要使用参考资料中的工程 ，将其导入到eclipse中，再使用maven安装到本地仓库。 即选中项目 –> 右键 –> Run As –> Maven install
第二步：在/taotao-manager-dao/pom.xml文件中添加对该分页插件的依赖，之前我们配置该文件的时候已经配置依赖过了。
虽然添加过依赖了，但是为了笔记记录的完整，我们将添加的内容展示出来，如下：

    <!-- 添加对分页插件pagehelper的依赖 -->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
    </dependency>

第三步：在Mybatis的全局配置文件中配置对拦截器插件的依赖
配置文件位置：/taotao-manager-service/src/main/resources/mybatis/SqlMapConfig.xml

<?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>
    <!-- 配置拦截器插件：作用是在执行sql语句之前，将sql语句拦截下来，在sql语句中拼接上limit -->   
    <plugins>
        <!-- com.github.pagehelper为PageHelper类所在包名 -->
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <!-- 设置支持数据库类型 ：目前该分页插件支持Oracle,Mysql,MariaDB,SQLite,Hsqldb,PostgreSQL六种数据库-->        
            <property name="dialect" value="mysql"/>
        </plugin>
    </plugins>
</configuration>

第四步：在代码中使用，参考“分页测试”的代码

5.4.3、分页测试

    @Test
    public void pagehelperTest() throws Exception {
        // 1、先在Mybatis的配置文件中配置拦截器插件：作用是在执行sql语句之前，将sql语句拦截下来，在sql语句中拼接上limit

        // 2、在执行查询之前设置分页条件，使用Pagehelper的静态方法
        PageHelper.startPage(1, 10);

        // 3、执行查询，使用mapper，需要初始化一个spring容器，从spring容器中的得到这个mapper的代理对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-dao.xml");
        TbItemMapper itemMapper = applicationContext.getBean(TbItemMapper.class);
        // 创建TbItemExample对象
        TbItemExample example = new TbItemExample();
        // 调用createCriteria()方法，创建条件查询对象，本测试没有条件，可以不用调用，表示查询所有
        // Criteria criteria = example.createCriteria();
        List<TbItem> list = itemMapper.selectByExample(example); // 本测试没有条件，表示查询所有

        // 4、取出分页信息，分页后，实际返回的结果list类型是Page<E>，如果想取出分页信息
        // 方式一：需要强制转换为Page<E>
        // Page<TbItem> listIteam = (Page<TbItem>)list;
        // 方式二：我们使用PageInfo对象对查询出来的结果进行包装，推荐使用第二种
        PageInfo<TbItem> pageInfo = new PageInfo<>(list);
        // PageInfo中包含了非常全面的分页属性，下面演示几个
        System.out.println("总记录数：" + pageInfo.getTotal());
        System.out.println("总页数：" + pageInfo.getPages());
        System.out.println("当前页数：" + pageInfo.getPageNum());
        System.out.println("每页记录数：" + pageInfo.getPageSize());
    }

5.5、Service层

  参数：int page、int rows
  业务逻辑：查询所有商品列表，要进行分页处理。
  返回值：EasyUIDataGridResult

5.5.1、接口代码

    public EasyUIDataGridResult getItemList(int page, int rows);

5.5.2、接口实现类代码

    @Override
    public EasyUIDataGridResult getItemList(int page, int rows) {
        // 设置分页信息
        PageHelper.startPage(page, rows);
        // 执行查询
        TbItemExample example = new TbItemExample();
        List<TbItem> list = itemMapper.selectByExample(example);
        // 取分页信息
        PageInfo<TbItem> pageInfo = new PageInfo<>(list);
        // 创建返回结果对象
        EasyUIDataGridResult result = new EasyUIDataGridResult();
        // 给返回的结果对象设置值
        result.setTotal(pageInfo.getTotal());
        result.setRows(list);

        return result;
    }

5.5.3、发布服务

在taotao-manager-service中的applicationContext-service.xml中发布服务。
注意address的值：使用自己的zookeeper所在的系统的ip地址和端口。


由于taotao-manager-interface工程中新加了代码，所以需要向本地仓库更新下：
选中taotao-manager-interface工程右键 –> Run As –> Maven install

5.6、表现层

5.6.1、Controller

1、初始化表格请求的url：/item/list
2、Datagrid默认请求参数：
  1）page：当前的页码，从1开始。
  2）rows：每页显示的记录数。
3、服务器响应的数据：json格式的数据。EasyUIDataGridResult

    @RequestMapping("/item/list")
    @ResponseBody // 在后台，把JavaBean强制转换成json格式数据返回给前台页面。
    public EasyUIDataGridResult getItemList(Integer page, Integer rows) {
        EasyUIDataGridResult result = itemService.getItemList(page, rows);
        return result;
    }

5.6.2、引用服务

在taotao-manager-web工程中的springmvc.xml中引入服务。
注意address的值：使用自己的zookeeper所在的系统的ip地址和端口。

5.7、测试

1）需要先启动zookeeper，再启动服务层，再启动表现层。
如果先启动表现层，后启动服务层，会报错，但是不影响使用。
2）为了更方便的进行测试，表现层工程和服务层工程属于不同的工程，要debug的时候需要设置源码，如下：
Debug设置源代码，涉及到工程都要添加，为了方便，可以添加所有的工程。
以工程taotao-manager为例：
步骤一：


步骤二：

步骤三：

5.8、解决错误+原因

1）表现层警告：


说明：
  反序列化时，使用Page<E>，在表现层没有这个类，但是我们有这个类的父类ArrayList，因为该类Page继承ArrayList，如下图，所以说这个警告我们可以不用管！若想解决这个警告，我们可以在web层加入对分页pagehelper的jar包的依赖（该包中有该类）。

2）表现层异常：


dubbo服务调用超时时间默认1秒，即表现层调用服务层，服务层在1秒钟内不响应（重试3次），表现层就抛出异常。
由于我们要使用debug模式调试代码，所以需要设置服务调用超时时间，dubbo服务调用超时时间默认1秒，我们设置成300秒。便于我们调试。

5.9、安装maven工程时跳过测试

  • 1、maven命令安装jar包时跳过测试：clean install -DskipTests
    表示先清理再安装，打包时跳过测试。
  • 2、还可以使用跳过测试的插件：maven-sufire-plugin

版权声明：本文为chenmingjun原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/chenmingjun/p/9943123.html