一、 软件架构的演进过程

1、单体架构

---

架构说明：

所有的功能集中在1个项目内。

优点：

架构简单，前期开发成本低、开发周期短，适合小型项目。

缺点：

1、项目不利于扩展、难以维护
2、技术栈受限：只能使用1种开发语言
3、系统性能扩展只能通过扩展集群节点，成本高

2、垂直架构

---

架构说明：

按照业务进行切割，形成小的单体项目。

优点：

技术栈可扩展（不同的系统可以用不同的编程语言编写）

缺点：

1、项目不利于扩展、难以维护
2、技术栈受限：只能使用1种开发语言
3、系统性能扩展只能通过扩展集群节点，成本高
4、 项目之间功能冗余、数据冗余、耦合性强。

3、SOA架构（主流）

SOA全称为Service-Oriented Architecture，即面向服务的架构。它可以根据需求通过网络对松散耦合的粗粒度应用组件(服务)进行分布式部署、组合和使用。一个服务通常以独立的形式存在于操作系统进程中。

站在功能的角度，把业务逻辑抽象成可复用的服务，通过服务的编排实现业务的快速再生，目的： 把原先固有的业务功能转变为通用的业务服务，实现业务逻辑的快速复用。

---

架构说明：

将重复功能or模块抽取成组件的形式，对外提供服务，在项目与服务之间使用ESB（企业服务总线）的形式作为通信的桥梁。

优点：

1、重复功能或模块抽取为服务，提高开发效率。
2、可重用性高。
3、可维护性高。

缺点：

1、各系统之间业务不同，很难确认功能或模块是重复的。
2、抽取服务的粒度大。
3、系统和服务之间耦合度高。

4、微服务架构（流行）

架构说明：

1、将系统服务层完全独立出来，抽取为一个一个的微服务（每一个服务都独立运行在服务器上）。
2、抽取的粒度更细，遵循单一原则。(即，每1个功能是1个服务)
3、采用轻量级框架协议传输。

优点：

1、 服务拆分粒度更细，有利于提高开发效率。
2、 可以针对不同服务制定对应的优化方案。
3、适用于互联网时代，产品迭代周期更短。

缺点：

1、粒度太细导致服务太多，维护成本高。
2、分布式系统开发的技术成本高，对团队的挑战大。

二、Apache Dubbo

Apache Dubbo是一款高性能的Java RPC框架。其前身是阿里巴巴公司开源的一个高性能、轻量级的开源Java RPC框架，可以和Spring框架无缝集成。

什么是PRC？

RPC全称为remote procedure call，即远程过程调用。

比如：服务器A和B分别部署了一个应用，A想调用B的方法，但是它们的部署的应用不在同一个内存空间，就不能直接调用，所以需要通过网络来表达调用的语义和传达的数据。

需要注意的是RPC并不是一个具体的技术，而是指整个网络远程调用过程。

RPC是一个泛化的概念，严格来说一切远程过程调用手段都属于RPC范畴。各种开发语言都有自己的RPC框架。Java中的RPC框架比较多，广泛使用的有RMI、Hessian、Dubbo等。

---

三、Dubbo架构

1、概述

Dubbo官网地址：http://dubbo.apache.org

Dubbo提供了三大核心能力：面向接口的远程方法调用、智能容错 和负载均衡，以及服务自动注册和发现。

节点角色说明：

节点	角色名称
Provider	暴露服务的服务提供方（服务方）
Consumer	调用远程服务的服务消费方 （消费方）
Registry	服务注册与发现的注册中心 （注册中心）
Monitor	统计服务的调用次数和调用时间的监控中心 （监控中心）
Container	服务运行容器

• 虚线都是异步访问，实线都是同步访问
• 蓝色虚线： 在启动时完成的功能
• 红色虚线(实线)： 都是程序运行过程中执行的功能

调用关系说明:

0. 服务容器负责启动，加载，运行服务提供者。
1. 服务提供者在启动时，向注册中心注册自己提供的服务。
2. 服务消费者在启动时，向注册中心订阅自己所需的服务。
3. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
5. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

2、服务注册中心Zookeeper

Zookeeper 是 Apache Hadoop 的子项目，是一个树型的目录服务，支持变更推送，适合作为 Dubbo 服务的注册中心，工业强度较高，可用于生产环境，并推荐使用 。

---

类比：树形结构

流程说明：

• 服务提供者(Provider)启动时:
  向 /dubbo/com.foo.BarService/providers 目录下写入自己的 URL 地址
• 服务消费者(Consumer)启动时:
  订阅 /dubbo/com.foo.BarService/providers 目录下的提供者 URL 地址。并向 /dubbo/com.foo.BarService/consumers 目录下写入自己的 URL 地址
• 监控中心(Monitor)启动时:
  订阅 /dubbo/com.foo.BarService 目录下的所有提供者和消费者 URL 地址

3、安装“注册中心”到服务器

4、启动、停止Zookeeper

• 进入Zookeeper的bin目录，启动服务命令
  ./zkServer.sh start

• 停止服务命令
  ./zkServer.sh stop

• 查看服务状态：
  ./zkServer.sh status

四、入门案例

1）开发：服务提供方

1、创建Maven中Web骨架，导入相关依赖

 <properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><maven.compiler.source>1.8</maven.compiler.source><maven.compiler.target>1.8</maven.compiler.target><spring.version>5.0.5.RELEASE</spring.version></properties><!--spring相关--><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jms</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>${spring.version}</version></dependency><!-- dubbo相关 --><dependency><groupId>com.alibaba</groupId><artifactId>dubbo</artifactId><version>2.6.0</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.7</version></dependency><dependency><groupId>com.github.sgroschupf</groupId><artifactId>zkclient</artifactId><version>0.1</version></dependency><dependency><groupId>javassist</groupId><artifactId>javassist</artifactId><version>3.12.1.GA</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.47</version></dependency></dependencies><build><!--指定maven插件之指定jdk编译版本--><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>2.3.2</version><configuration><source>1.8</source><target>1.8</target></configuration></plugin><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><configuration><!-- 指定端口 --><port>8081</port><!-- 请求路径 --><path>/</path></configuration></plugin></plugins></build>

2、配置web.xml

<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""http://java.sun.com/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><!--全局初始化参数：指定spring相关配置文件--><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext*.xml</param-value></context-param><!--配置监听器：加载配置文件，创建spring容器--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener></web-app>

3、创建service接口和实现类（提供服务）

接口：

public interface HelloService {public String sayHello(String name);
}

实现类：

import com.alibaba.dubbo.config.annotation.Service;
@Service //发布服务必须使用dubbo提供的注解
public class HelloServiceImpl implements HelloService {@Overridepublic String sayHello(String name) {return "Hello" +name;}
}

4、配置dubbo的spring配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!--每个dubbo应用（提供者和消费者）都必须指定1个唯一的名称--><!-- 当前应用名称，用于注册中心计算应用间依赖关系 --><dubbo:application name="dubbodemo_provider" /><!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址--><dubbo:registry address="zookeeper://118.178.16.132:2181"/><!-- 注册  协议和port   端口默认是20880 --><dubbo:protocol name="dubbo" port="20881"></dubbo:protocol><!-- 扫描指定包，加入@Service注解的类会被发布为服务  --><dubbo:annotation package="com.itheima.service.impl" />
</beans>

2）开发：服务消费方

注意： 消费方和服务方是在不同服务器上的，而消费方(Controller)根据@Reference注解到注册中心寻找对应接口的服务并远程调用服务方提供的服务(Serivce)

其实，以前使用MVC架构的时候，也是使用controller调用service，只是现在它们都分别在不同的服务器上，再进行远程调用。
好处是提高了service的复用性吧，理解

1、创建Maven中Web骨架，导入相关依赖

跟服务方一样，就是Tomcat插件端口不一样

2、配置web.xml

<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app><display-name>Archetype Created Web Application</display-name><!--配置前端控制器--><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载 --><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-web.xml</param-value></init-param><load-on-startup>1</load-on-startup><!--项目一启动就加载配置文件--></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping>
</web-app>

3、创建服务方的HelloService接口

直接复制服务方的服务接口，包名类名一致即可

4、编写Controller

@Controller
@RequestMapping("/hello")
public class HelloController {@Reference  //到注册中心找对应接口的服务（service方法）private HelloService helloService;@RequestMapping("/sayHello")@ResponseBodypublic String sayHello (String name){return helloService.sayHello(name);}
}

5、配置dubbo的spring配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd"><!--每个dubbo应用（提供者和消费者）都必须指定1个唯一的名称--><!-- 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样 --><dubbo:application name="dubbodemo-consumer" /><!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址--><dubbo:registry address="zookeeper://192.168.134.129:2181"/><!-- 扫描的方式暴露接口：创建Bean  --><dubbo:annotation package="com.itheima.controller" />
</beans>

看看现在的结构：

6、测试

1、将服务提供方和服务消费方开启Tomcat服务
2、输入浏览器地址：https://localhost:8082/hello/sayHello.do?name=lizhixi
3、页面显示：hello lizhixi

Caused by: java.lang.IllegalStateException: Failed to register dubbo://192.168.3.1:20881

意外错误回顾：

在启动的时候，Tomcat项目是启动成功的，但是当我访问远程服务的时候，报错了：Caused by: java.lang.IllegalStateException: Failed to register dubbo://192.168.3.1:20881（提示我注册dubbo失败）和controller中注入service失败，即，null

原因：（请配合文字联想dubbo架构图）

• 1、提供者 先 向【注册中心】提供服务，消费者 再 向 【注册中心】订阅服务。
  这个过程中，都是围绕着注册中心来进行协作，而消费者和提供者启动是有先后之分的，如果是启动顺序颠倒，那么消费者已经实例化了controller，而controller里面的远程service并没有注入。因为注册中心得先有远程service才有注入service的可能。
  在第六节，第3小节有说明，这个不成立。这里只是个人猜测，当然如果配置不当，先后启动顺序颠倒还是会报错的，只是 不是报空指针异常。
• 2、安装注册中心的服务器，必须开放 消费者和服务者在spring配置文件中配置对应连接注册中心的端口。（上面是2181）
  因为注册中心得先有远程service才有注入service的可能，注册中心没有开放端口等于没有注册中心，既然没有注册中心那么消费方的service又怎么不会是null呢？

3）问题思考（优化消费方接口的问题）

思考一： 上面的Dubbo入门案例中我们是将HelloService接口从服务提供者工程(dubbodemo_provider)复制到服务消费者工程(dubbodemo_consumer)中，这种做法是否合适？还有没有更好的方式？

答： 这种做法显然是不好的，同一个接口被复制了两份，不利于后期维护。更好的方式是单独创建一个maven工程，将此接口创建在这个maven工程中。0（将接口抽取成单独的maven的模块，消费方使用的时候再导入pom） 需要依赖此接口的工程只需要在自己工程的pom.xml文件中引入maven坐标即可。

思考二： 在服务消费者工程(dubbodemo_consumer)中只是引用了HelloService接口，并没有提供实现类，Dubbo是如何做到远程调用的？

答： Dubbo底层是基于代理技术为HelloService接口创建代理对象，远程调用是通过此代理对象完成的。可以通过开发工具的debug功能查看此代理对象的内部结构。另外，Dubbo实现网络传输底层是基于Netty框架完成的。

思考三： 上面的Dubbo入门案例中我们使用Zookeeper作为服务注册中心，服务提供者需要将自己的服务信息注册到Zookeeper，服务消费者需要从Zookeeper订阅自己所需要的服务，此时Zookeeper服务就变得非常重要了，那如何防止Zookeeper单点故障呢？

答： Zookeeper其实是支持集群模式的，可以配置Zookeeper集群来达到Zookeeper服务的高可用，防止出现单点故障。

五、Dubbo管理控制台

这个是dubbo官方提供并打成web包的web应用，它的作用是为了能够直观的知道有哪些消费者消费哪些服务。

下面说说如何部署：

其实，将war包放在Tomcat的webapps目录下，启动startup.bat即可。但是可能会报错，因为war包被解压后的项目中的WEB-INF有个dubbo.properties配置文件，里面配置了关于注册中心信息，你可能没有配对注册中心的ip地址。

---

看看访问成功的页面：

• 每一个提供方和消费方都是属于"应用"，所以在“application（应用）”分类中可以找到。
• 你会发现在详细信息中出现了1个新的ip，我们不需要关心它，知道它是个虚拟ip，每一个应用都有唯一的虚拟ip即可。

---

1）加入log4j.properties日志

为什么要加入日志？

能够清楚得知道服务方和消费方详细的状态信息。
注意：
为了利于开发，一般日志信息我们在开发阶段使用debug级别，项目上线以后就使用info级别，提示信息少一些。

怎么加？

很简单，将下面的日志配置文件，放到消费方和服务方的resourse下面即可。

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:\\mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n### set log levels - for more verbose logging change 'info' to 'debug' ###log4j.rootLogger=debug, stdout

六、dubbo配置相关说明

1）包扫描

服务者：

• 注解方式：（推荐）

配合@Service

<dubbo:annotation package="com.itheima.service" />

配置了dubbo才能知道哪个service类要注册

• 配置方式：

<bean id="helloService" class="com.itheima.service.impl.HelloServiceImpl" />
<dubbo:service interface="com.itheima.api.HelloService" ref="helloService" />

---

消费者：

• 注解方式：（推荐）

配合@Reference

<dubbo:annotation package="com.itheima.controller" />

配置了注解才能注入成功，并且调用远程service

• 配置方式：

<!-- 生成远程服务代理，可以和本地bean一样使用helloService -->
<dubbo:reference id="helloService" interface="com.itheima.service.HelloService" />

2）协议

<dubbo:protocol name="dubbo" port="20880"/>

一般在服务提供者一方配置，可以指定使用的协议名称和端口号，而上面的配置其实是默认的配置，
即，不配置也是这样，但是我们一般推荐显式配置。

---

问：Dubbo就有1种协议么？

其中Dubbo支持的协议有：dubbo、rmi、hessian、http、webservice、rest、redis等。
但是，我们推荐使用的是dubbo协议。

问：为什么推荐使用Dubbo协议？

dubbo 协议采用单一长连接和 NIO 异步通讯，适合于小数据量大并发（并发量大但是请求数据小）的服务调用，以及服务消费者机器数远 > 服务提供者机器数的情况。不适合传送大数据量的服务，比如传文件，传视频等，除非请求量很低。

问：在同1个项目工程中，可以使用多协议配置吗？怎么配置？

同一个工程中配置多个协议，不同服务可以使用不同的协议，例如：

<!-- 多协议配置 -->
<dubbo:protocol name="dubbo" port="20880" />
<dubbo:protocol name="rmi" port="1099" />
<!-- 使用dubbo协议暴露服务 -->
<dubbo:service interface="com.itheima.api.HelloService" ref="helloService" protocol="dubbo" />
<!-- 使用rmi协议暴露服务 -->
<dubbo:service interface="com.itheima.api.DemoService" ref="demoService" protocol="rmi" /> 

但是，上面已经说了，我们不推荐使用xml配置关于服务提供者的服务，因为当服务多了，配置的动作就变得繁多。下面就举个如何使用注解配置提供服务的协议的例子：

@Service(protocol = "dubbo")    //发布服务必须使用Dubbo提供的service
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "hello " + name;}
}

3）启动时检查

启动时检查是什么意思？

意思就是说：以前面案例中的消费者和服务者代码为例，当我在启动它们时是先启动消费方，再启动服务方，然后，你会发现消费方已经报错了，提示：没有在注册中心找到对应的服务。而这个情况，跟后来服务方启没启动没有关系，是跟在开始的时，消费方和服务方的启动先后顺序有关。

• 原理：
  在消费方启动之前，它会先去注册中心寻找有没有被@Reference上的服务，如果没有，它找不到就报错了，并且阻止spring初始化完成，这就是启动时检查。

但是，这里有个配置可以解决此异常，并且不在乎它们的启动顺序，只要都启动都可以正常使用：

<dubbo:consumer check="false"/>

上面这个配置需要配置在服务消费者一方，如果不配置默认check值为true。

那么我们一定要配置吗？

在开发时，是把启动检查关闭的：
因为当项目庞大的时候，项目有很多的服务方和消费方都互相交叉依赖。如果我们不关闭，为了测试1个服务方和消费方代码是否正常时，就要启动项目全部的服务方，因为他们是交叉依赖嘛，这样就很麻烦了。

---

在项目上线时，是把启动检查开着的（默认）：
是因为以便上线时，能及早发现问题。

4）负载均衡

概念：

负载均衡（Load Balance）：其实就是将请求分摊到多个操作单元上进行执行，从而共同完成工作任务。

Dubbo的负载均衡策略：

在集群负载均衡时，Dubbo 提供了多种均衡策略（包括随机、轮询、最少活跃调用数、一致性Hash），缺省(默认)为random随机调用。

---

配置负载均衡策略，既可以在服务提供者一方配置，也可以在服务消费者一方配置，如下：

【必须清楚】前提：部署有多个提供方服务器

消费者：

    @Controller@RequestMapping("/demo")public class HelloController {//在服务消费者一方配置负载均衡策略@Reference(check = false,loadbalance = "random")private HelloService helloService;@RequestMapping("/hello")@ResponseBodypublic String getName(String name){//远程调用String result = helloService.sayHello(name);System.out.println(result);return result;}}

服务者：

//在服务提供者一方配置负载均衡
@Service(loadbalance = "random")
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "hello " + name;}
}

在【前提】的基础上，其实无论在哪一方配置了使用随机负载均衡策略，意思都是，多个服务方服务器都会将自己的服务（即使是大家相同的）注册到注册中心上，然后消费方会随机挑选相同的服务，但是不同服务器的服务。

---

下面在本地计算机来演示一下场景：（还是“入门案例”的代码）

注意： 因为我们是在一台机器上启动多个服务提供者，所以需要修改tomcat的端口号和Dubbo服务的协议端口号来防止端口冲突。

在实际生产环境中，多个服务提供者是分别部署在不同的机器上（ip地址不同），所以不存在端口冲突问题。

---

启动步骤：

我在下面，我就不放出所有代码了，因为【入门案例】中有，我只放我修改过的：

步骤2：修改service方法的输出：

@Service(loadbalance = "random")    //发布服务必须使用Dubbo提供
的service
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "8082 hello " + name;}
}

步骤4：修改service方法的输出：

@Service(loadbalance = "random")    //发布服务必须使用Dubbo提供
的service
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "8083 hello " + name;}
}

步骤3：修改端口

applicationContext-service.xml

步骤2的协议端口是20881

    <!-- 注册  协议和port   端口默认是20880 --><dubbo:protocol name="dubbo" port="20882"></dubbo:protocol>

pom.xml中Tomcat端口：

步骤2的是8081

<port>8083</port>

5）解决无法Dubbo无法发布被事务管理的服务

----------(注意： 本小节的代码是根据在入门案例的服务提供者dubbodemo_provider工程基础上进行讲解)

前面我们已经完成了Dubbo的入门案例，通过入门案例我们可以看到通过Dubbo提供的标签配置就可以进行包扫描，扫描到 @Service注解的类 就可以被发布为服务 。
但是，如果直接给服务增加事务管理，即，加@Transactional注解，那么被注上注解的服务类就不会被发布到注册中心。

下面直接将解决方案，如果想知道为什么就往下看：

（1）修改服务类applicationContext-service.xml配置文件，开启事务控制注解支持时指定proxy-target-class属性，值为true。其作用是使用cglib代理方式为Service类创建代理对象

<!--开启事务控制的注解支持-->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>

（2）修改HelloServiceImpl类，在Service注解中加入interfaceClass属性，值为HelloService.class，作用是指定服务的接口类型

@Service(interfaceClass = HelloService.class)
@Transactional
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "hello " + name;}
}

此处也是必须要修改的，否则会导致发布的服务接口为SpringProxy（spring代理对象的接口），而不是HelloService接口（真正对应的服务接口）

---

“无法Dubbo无法发布被事务管理的服务” 是什么意思？

意思是说，当我们在定义服务类时，加上@Transactional(事务控制)是不会发布sping产生事务控制的service代理对象的服务的。

---

场景显示：

注意： 在入门案例的服务提供者dubbodemo_provider工程基础上进行展示

pom.xml：

<!--mysql驱动--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><!--连接池--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.6</version></dependency><!--spring整合mybatis--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>1.3.2</version></dependency>

applicationContext-service.xml：

    <!--数据源--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close"><property name="username" value="root" /><property name="password" value="root" /><property name="driverClassName" value="com.mysql.jdbc.Driver" /><property name="url" value="jdbc:mysql://localhost:3306/test" /></bean><!-- 事务管理器  --><bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><!--开启事务控制的注解支持：默认使用JDK自动生成的动态代理对象--><tx:annotation-driven transaction-manager="transactionManager"/>

HelloServiceIpml：

package com.itheima.service.impl;
@Service(protocol = "dubbo") //发布服务必须使用Dubbo提供的Service注解
@Transactional
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "8084 hello " + name;}
}

---

为什么 “无法Dubbo无法发布被事务管理的服务” ？

先看下面代码：

applicationContext-service.xml：

    <!-- 扫描指定包，加入@Service注解的类会被发布为服务  --><dubbo:annotation package="com.itheima.service.impl"/>

service：

package com.itheima.service.impl;
@Service(protocol = "dubbo") //发布服务必须使用Dubbo提供的Service注解
@Transactional
public class HelloServiceImpl implements HelloService {public String sayHello(String name) {return "8084 hello " + name;}
}

applicationContext-service.xml配置会扫描指定包的@Service，并将该service发布到注册中心。请注意在此处是：com.itheima.service.impl包下。但是，事务控制的底层原理是为服务提供者类创建代理对象，而默认情况下Spring是基于JDK动态代理方式创建代理对象，而此代理对象的完整类名为com.sun.proxy.$Proxy42（最后两位数字不是固定的），毕竟是spring提供的代理对象嘛（也就是本来是该服务类的全类名是com.itheima.service.impl.xxxServiceImpl，但是被spring代理对象后，实际上出面干事情的是com.sun.proxy.\$Proxy4）。也就是说： Dubbo是根据配置去扫描指定包下的com.itheima.service.impl包下的类，而不是com.sun.proxy.\$Proxy42，导致Dubbo在发布服务前进行包匹配时无法完成匹配，进而没有进行服务的发布（也就是被事务管理的服务没有被发布``到注册中心）。

查看dubbo管理控制台可知，没有服务者：

可以通过断点调试的方式查看Dubbo执行过程，Dubbo通过AnnotationBean的postProcessAfterInitialization方法进行处理

总结：

• 如果声明式事务管理是基于JDK动态代理对象的话，那么被代理的对象和对象的全类名是不一致的！
• 如果声明式事务管理是基于cglib动态代理对象的话，那么被代理的对象和对象的全类名是一致的，但是被代理对象和代理对象对应的接口就不一致了，所以你要在@Service指定该服务的接口。