day69_淘淘商城项目_02_dubbo介绍 + dubbo框架整合 + zookeeper + 商品列表查询实现 + 分页 + 逆向工程_匠心笔记

时间 2019-11-13

标签 day69 day 淘淘商城项目 dubbo 介绍框架整合 zookeeper 商品列表查询实现分页逆向工程匠心笔记栏目 Dubbo 繁體版

原文原文链接

课程计划
- 次日：商品列表功能实现
一、功能分析
二、服务中间件Dubbo
三、SSM框架整合+Zookeeper
四、Dubbo的Admin管理平台
五、后台商品列表查询功能实现

一、功能分析

1.一、后台系统所用的技术

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

1.二、建立数据库

一、安装mysql数据库，要求5.5以上版本。
二、在mysql中建立一个taotao数据库。
三、将建立数据库的脚本taotao.sql导入到taotao中。

1.三、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>
    <context id="testTables" targetRuntime="MyBatis3">
        <!-- 配置生成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>

使用方法：将Java工程generatorSqlmapCustom导入到eclipse中，运行/generatorSqlmapCustom/src/下的GeneratorSqlmap.java文件生成咱们所需的代码。php

1.四、系统间通讯问题

1.4.一、分析

因为淘淘商城是基于soa的架构，表现层和服务层是不一样的工程。因此要实现商品列表查询须要两个系统之间进行通讯。
如何实现远程通讯？css

一、使用Webservice：效率不高，它是基于soap协议（html+xml）。项目中不推荐使用。优势是：跨语言、跨平台。适用于两个公司之间。
二、使用Restful形式的服务：http+json。不少项目中应用。若是服务愈来愈多，服务与服务之间的调用关系复杂，调用服务的URL管理复杂，何时添加机器难以肯定。须要治疗服务。适用于中小型企业。
三、使用Dubbo：使用RPC协议进行远程调用，直接使用socket通讯。传输效率高，而且能够统计出系统之间的调用关系、调用次数，管理服务。适用于大型企业。缺点：不能跨语言。只能java语言。

二、Dubbo

2.一、什么是dubbo

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

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

2.二、Dubbo的架构

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

2.三、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" />

表现层调用服务：java

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

2.四、注册中心--zookeeper

2.4.一、zookeeper的介绍

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

2.4.二、环境准备

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

2.4.三、使用SecureCRT链接Linux系统

清除全部文件，咱们先要有一个干干净净的Linux系统。以下图：

2.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的防火墙。不然不建议关闭防火墙，而是配置防火墙。

三、SSM框架整合+Zookeeper

3.一、需求

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

3.二、配置对dubbo的依赖

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

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

    <!-- 配置对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中要添加的内容以下：git

    <!-- 配置对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>

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

二种方式本质是同样的！
表现层：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.三、整合思路

一、Dao层：
mybatis整合spring，经过spring管理SqlSessionFactory、Mapper代理对象。须要mybatis和spring的整合包。由spring建立数据库链接池。
下图所示为文件所对应的工程：
二、Service层：
全部的service实现类都放到spring容器中管理，并由spring管理事务。发布dubbo服务。
下图所示为文件所对应的工程：

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

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

3.四、Dao整合

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

3.4.一、建立SqlMapConfig.xml配置文件

SqlMapConfig.xml（因为和spring进行整合了，里面空空如也，可是该文件必需要有！）web

<?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.二、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.五、Service整合

3.5.一、配置管理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" />

    <!-- 使用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.二、配置事务管理

建立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.三、配置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-manage-servicer</display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <!-- 初始化spring容器：也即加载spring容器，taotao-manager-service是web工程，须要在web容器中运行 -->
    <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.四、spring父子容器的关系

思考：以上咱们的服务层已经配置好了，在表现层的springmvc咱们还须要初始化spring容器吗？即springmvc能够初始化一个容器吗？亦即咱们还须要写上面web.xml中的那段代码吗？
答：在表现层的springmvc咱们不须要初始化spring容器了。为何呢？缘由以下图所示：

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

3.六、表现层整合

3.6.一、配置管理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.二、配置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-web</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>
        <!-- /表示拦截全部请求，但不拦截jsp，/*表示拦截全部请求 -->
        <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><!-- 1表示tomcat启动以后就会加载servlet前端控制器，不然表示第一次请求的时候才加载 -->>
    </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.三、编写Controller

@Controller
public class ItemController {

    @Autowired
    private ItemService itemService;

    /**
     * 根据商品id查询商品信息，并将商品信息使用json数据格式返回。
     * @param itemId
     * @return
     */
    @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.七、dubbo服务调用测试

3.7.一、添加日志文件log4j.properties

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

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

3.7.二、启动工程

注意：使用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.三、测试访问

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

缘由是：映射文件并无拷贝到classpath下致使。
解决mapper映射文件不发布的问题：
在taotao-manager-dao工程中的pom文件中添加以下内容：

    <build>
        <resources>
            <!-- 若是不添加此节点，mybatis的mapper.xml文件都会被漏掉 -->
            <!-- 注意：配置了此方式，原来的默认的资源拷贝行为将无效了 -->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <!-- 若是不添加此节点，src/main/resources目录下的配置文件将被忽略 -->
            <resource>
                <directory>src/main/resource</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格式数据：

四、Dubbo的Admin管理平台

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

4.一、环境准备

一、准备好war包
二、准备好tomcat
三、使用SecureCRT上传到linux系统中
四、须要安装先tomcat
即解压tomcat，命令：tar -zxvf apache-tomcat-7.0.47.tar.gz
而后删除tomcat压缩包，命令：rm -rf apache-tomcat-7.0.47.tar.gz

4.二、部署监控中心

部署监控中心，拷贝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.三、测试访问

测试访问：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]#

同理，增长端口8080、808一、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.一、整合静态页面

静态页面位置：如图：

使用方法：把静态页面添加到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.二、展现后台首页+展现菜单页面

5.2.一、功能分析

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

5.2.二、Controller

/**
 * 页面展现Controller
 * @author  chenmingjun
 * @date    2018年11月9日下午7:59:33
 * @version 1.0
 */

@Controller
public class PageController {

    /**
     * 展现后台首页
     * @return
     */
    @RequestMapping("/")
    public String showIndex() {
        return "index";
    }

    /**
     * 展现后台菜单各页面
     * @param page
     * @return
     */
    @RequestMapping("/{page}")
    public String showPage(@PathVariable String page) {
        return page;
    }

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

5.三、后台商品列表查询功能分析

5.3.一、商品列表页面

浏览器界面效果：
浏览器请求的网址：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.二、响应的json数据格式EasyUIDataGridResult

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

package com.taotao.common.pojo;

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

/**
 * 列表查询时的返回的数据类
 * @author    chenmingjun
 * @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;
    }

    @Override
    public String toString() {
        return "EasyUIDataGridResult [total=" + total + ", rows=" + rows + "]";
    }
}

5.3.三、分页处理

因为逆向工程生成的代码是不支持分页处理的，若是想进行分页须要本身编写mapper，这样就失去逆向工程的意义了。为了提升开发效率可使用mybatis的分页插件PageHelper。

5.四、Mybatis的分页插件PageHelper

5.4.一、Mybatis分页插件PageHelper的说明

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

5.4.二、使用方法

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.三、分页测试

在/taotao-manager-service/src/test/java/com/taotao/pagehelper/中新建PagehelperTest.java文件，文件内容以下：

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

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

        // 三、执行查询，使用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); // 本测试没有条件，表示查询全部

        // 四、取出分页信息，分页后，实际返回的结果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.五、Service层

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

5.5.一、接口代码

    /**
     * 分页查询后台商品列表信息
     * @param page
     * @param rows
     * @return
     */
    EasyUIDataGridResult getItemList(Integer page, Integer rows);

5.5.二、接口实现类代码

    @Override
    public EasyUIDataGridResult getItemList(Integer page, Integer rows) {
        // 设置分页信息，使用PageHelper
        if (page == null) {
            page = 1;
        }
        if (rows == null) {
            rows = 30;
        }
        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.三、发布服务

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

因为taotao-manager-interface工程中新加了代码，因此须要向本地仓库更新下：
选中taotao-manager-interface工程右键 --> Run As --> Maven install

5.六、表现层

5.6.一、Controller

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

    /**
     * 分页查询后台商品列表信息，并将商品列表信息使用json数据格式返回。
     * @param page
     * @param rows
     * @return
     */
    @RequestMapping("/item/list")
    @ResponseBody // 在后台，把JavaBean强制转换成json格式数据返回给前台页面。
    public EasyUIDataGridResult getItemList(Integer page, Integer rows) {
        EasyUIDataGridResult result = itemService.getItemList(page, rows);
        return result;
    }

5.6.二、引用服务

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

5.七、测试

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

步骤二：

步骤三：

5.八、解决错误+缘由

1）表现层警告：

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

2）表现层异常：

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

5.九、安装maven工程时跳过测试

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