1、Spring Boot Starter

Spring Boot Starter是什么？
Spring Boot Starter就是封装了一定功能的模块，能够提供给springboot项目使用。

这里我们新建一个spring boot项目，实现一个简单的 “说hello谁谁”这样的功能，然后打包到maven本地仓库，供另一个项目中作为依赖使用

1.1、自己封装一个Starter

新建spring boot项目，起名spring-boot-starter-webhello

官方命名格式为： spring-boot-starter-{name}

新建项目时注意，这三个地方一一对应，需要记住

根据我们这个Starter项目需求，创建以下目录、删除不需要的目录

HelloAutoConfiguration.java

package com.hello.springbootstarterwebhello;import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;//定义为配置类
@Configuration//在web工程条件下成立
@ConditionalOnWebApplication//启用HelloProperties配置功能，并加入到IOC容器中
@EnableConfigurationProperties({HelloProperties.class})//导入HelloService组
@Import(HelloService.class)
@ComponentScan
public class HelloAutoConfiguration {
}

HelloProperties.java

package com.hello.springbootstarterwebhello;import org.springframework.boot.context.properties.ConfigurationProperties;@ConfigurationProperties(prefix = "hello")
public class HelloProperties {/*** 打招呼的内容，默认为“World!”*/private String msg = "World!";public String getMsg() {return msg;}public void setMsg(String msg) {this.msg = msg;}
}

HelloService.java

package com.hello.springbootstarterwebhello;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class HelloService {@Autowiredprivate HelloProperties helloProperties;public HelloService(HelloProperties helloProperties) {this.helloProperties = helloProperties;}public String sayHello(String name) {return "来自 自定义Starter：你好 " + name + " " + helloProperties.getMsg();}
}

spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.haha.springbootstarterwebhello.HelloAutoConfiguration

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.3.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.hello</groupId><artifactId>spring-boot-starter-webhello</artifactId><version>0.0.1-SNAPSHOT</version><name>spring-boot-starter-webhello</name><description>Demo project for Spring Boot</description><properties><java.version>11</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>
</project>

我们在pom.xml只导入了spring-boot-starter-web这一个依赖，其他的都是不需要的。

之后我们只需要点击install就可以安装到本地仓库了（如图）

这里我们之封装了一个简单的功能。
也可以封装更多更复杂的功能

1.2、使用自己封装的Starter

新建一个spring boot项目，然后在项目中导入我们自己的Starter

        <dependency><groupId>com.hello</groupId><artifactId>spring-boot-starter-webhello</artifactId><version>0.0.1-SNAPSHOT</version></dependency>

使用spring-boot-starter-hello的sayHello功能
新建HelloController.java

package com.haha.myboot003;import com.hello.springbootstarterwebhello.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;@RestController
public class HelloController {@AutowiredHelloService helloService;@RequestMapping(value = "/sayHello")@ResponseBodypublic String sayHello(String name){System.out.println(helloService.sayHello(name));return helloService.sayHello(name);}}

访问http://localhost:8080/sayHello?name=zhangshan
浏览器打印：来自 自定义Starter：Hello zhangshan World!

在application.properties文件中配置属性：hello.msg = 你好！

重启项目，再次刷新访问，浏览器响应：来自 自定义Starter：Hello zhangshan 你好！

出现 Could not autowire. No beans of ‘xxxx’ type found这个错误解决方案
https://www.cnblogs.com/expiator/p/8991545.html

运行时出现java.lang.IllegalStateException: Unable to read meta-data for class xxx 异常
解决：首先考虑starter的配置文件是否写错，使得找不到class文件

1.3、元数据的配置

在application.properties中配置hello.msg属性时，你会发现并没有提示你有关该配置的信息。接下来实现这个功能，如图

在spring-boot-starter-webhello中新建META-INF/spring-configuration-metadata.json文件

{"hints":[{"name":"hello.msg","values":[{"value":"你好","description":"中文方式打招呼"},{"value":"Hi","description":"英文方式打招呼"}]}],"groups":[{"sourceType": "com.example.springbootstarterhello.HelloProperties","name": "hello","type": "com.example.springbootstarterhello.HelloProperties"}],"properties":[{"sourceType": "com.example.springbootstarterhello.HelloProperties","name": "hello.msg","type": "java.lang.String","description": "打招呼的内容","defaultValue": "Worlds"}]
}

重新打包install，在就可以使用了

1.3.1、 元数据的配置 详解（了解就可以）

如上的spring-configuration-metadata.json包含了三个对象groups、properties、hints。
以下是详细配置：
groups

properties

hints

2、maven报错记录

报错信息

JAVA_HOME should point to a jdk not a jre

解决办法

应该是win10才会出现这个问题

在环境变量里，把java的环境变量配置往用户变量里也写一份

3、springboot + MyBatis

新建项目myboot05，这次我们再新建项目时就将依赖勾选

新建完成再在pom里面检查一下是不是有这三个依赖（注意mysql的依赖要是compile）

3.1、新建数据库 和 实体类

新建数据库webtest，里面新建表user

CREATE DATABASE webtest;use webtest;DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (`id` int(11) NOT NULL,`name` varchar(30) NOT NULL,`pwd` varchar(50) NOT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;INSERT INTO `user` VALUES ('1', 'zs', '123');
INSERT INTO `user` VALUES ('2', 'ls', '111');
INSERT INTO `user` VALUES ('3', 'wmz', '000');

新建实体类User.java

idea快捷键alt+j：选中同一个单词

package com.haha.myboot05.pojo;import java.io.Serializable;public class User implements Serializable {private int id;private String name;private String pwd;public User() {}public User(int id, String name, String pwd) {this.id = id;this.name = name;this.pwd = pwd;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getPwd() {return pwd;}public void setPwd(String pwd) {this.pwd = pwd;}
}

3.2、配置mybatis

application.properties配置文件代码如下：

这里注意mysql数据库名、账号、密码

spring.datasource.url=jdbc:mysql://localhost:3306/webtest?characterEncoding=utf-8&useSSL=true&serverTimezone=GMT
spring.datasource.username=root
spring.datasource.password=root123
spring.datasource.driver-class-name= com.mysql.cj.jdbc.Drivermybatis.config-location=classpath:config/mybatis-config.xml
mybatis.mapper-locations=classpath:mapper/*.xml

新建一个UserMapper接口，里面写findById、findAll方法

import com.haha.myboot05.pojo.User;
import java.util.List;public interface UserMapper {User findById(Long id);List<User> findAll();
}

在resources文件夹下建立config文件夹，并创建mybatis-config.xml，代码如下：

package name="要扫描的实体类包路径“

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration><typeAliases><package name="com.haha.myboot05.pojo"/></typeAliases><!--<mappers>--><!--</mappers>-->
</configuration>

在resources文件夹下建立mapper文件夹,并创建UserMapper.xml，代码如下:

mapper namespace="mapper类全名”
type="实体类全名“

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.haha.myboot05.mapper.UserMapper"><resultMap id="BaseResultMap" type="com.haha.myboot05.pojo.User" ><result column="id" property="id" /><result column="name" property="name" /><result column="password" property="password" /></resultMap><select id="findById" resultMap="BaseResultMap">select * from user where id = #{id}</select><select id="findAll" resultMap="BaseResultMap">select * from user</select>
</mapper>

建立controller包,并在该包下建立UserController类

import com.haha.myboot05.mapper.UserMapper;
import com.haha.myboot05.pojo.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;import javax.annotation.Resource;@RestController
@RequestMapping("/user")
public class UserController {@Resourceprivate UserMapper userMapper;@GetMappingpublic User findUser(@RequestParam(value = "id") Long id){return userMapper.findById(id);}
}

在启动类上面加入扫描的注解
@MapperScan(" com.haha.myboot05.mapper")

运行项目，在浏览器访问http://localhost:8080/user?id=1

4、springboot + JDBC + Druid

JDBC： Java数据库连接 工具
Druid：数据库连接池，负责分配、管理和释放数据库连接

Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP 等 DB 池的优点，同时加入了日志监控。

4.1、springboot + JDBC

加入jdbc、mysql依赖

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope>
</dependency>

application.yaml配置

spring:datasource:username: rootpassword: root123url: jdbc:mysql://localhost:3306/webtest?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8driver-class-name: com.mysql.cj.jdbc.Driver

注意上面的配置中 账号、密码、数据库名，改成自己的。
对应的数据库一定要是存在的，不然后面会报错.

然后在测试类里面就可以直接使用了
我们输出一下数据源看看

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;@SpringBootTest
class Myboot04ApplicationTests {//DI注入数据源@AutowiredDataSource ds;@Testvoid contextLoads() throws SQLException {//看一下默认数据源System.out.println(ds.getClass());//获得连接Connection connection =   ds.getConnection();System.out.println(connection);//关闭连接connection.close();}}

运行结果

可以看到数据源为HikariDataSource

HikariDataSource 号称 Java WEB 当前速度最快的数据源

4.2、JDBCTemplate

JdbcTemplate是Spring 对原生的JDBC 做的轻量级封装。

JdbcTemplate主要提供以下几类方法：

JdbcTemplate方法	用途
execute	执行任何SQL语句
update	执行新增、修改、删除等语句
batchUpdate	执行批处理相关语句
query、queryForXXX	执行查询相关语句
call	执行存储过程、函数相关语句

增删改查：

编写一个Controller，注入 jdbcTemplate，编写测试方法进行访问测试

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.Date;
import java.util.List;
import java.util.Map;@RestController
@RequestMapping("/jdbc")
public class JdbcController {/*** Spring Boot 默认提供了数据源，默认提供了 org.springframework.jdbc.core.JdbcTemplate* JdbcTemplate 中会自己注入数据源，用于简化 JDBC操作* 还能避免一些常见的错误,使用起来也不用再自己来关闭数据库连接*/@AutowiredJdbcTemplate jdbcTemplate;//查询employee表中所有数据//List 中的1个 Map 对应数据库的 1行数据//Map 中的 key 对应数据库的字段名，value 对应数据库的字段值@GetMapping("/list")public List<Map<String, Object>> userList(){String sql = "select * from employee";List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);return maps;}//新增一个用户@GetMapping("/add")public String addUser(){//插入语句，注意时间问题String sql = "insert into employee(last_name, email,gender,department,birth)" +" values ('zhangsan','*********@qq.com',1,101,'"+ new Date().toLocaleString() +"')";jdbcTemplate.update(sql);//查询return "addOk";}//修改用户信息@GetMapping("/update/{id}")public String updateUser(@PathVariable("id") int id){//插入语句String sql = "update employee set last_name=?,email=? where id="+id;//数据Object[] objects = new Object[2];objects[0] = "lisi";objects[1] = "*******@sina.com";jdbcTemplate.update(sql,objects);//查询return "updateOk";}//删除用户@GetMapping("/delete/{id}")public String delUser(@PathVariable("id") int id){//插入语句String sql = "delete from employee where id=?";jdbcTemplate.update(sql,id);//查询return "deleteOk";}}

4.3、springboot + Druid

上一章中用到的jdbc、mysql、web依赖也是必须要的

导入依赖

<dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.21</version>
</dependency>

springboot + jdbc ，Spring Boot 2.0 以上默认使用 com.zaxxer.hikari.HikariDataSource 数据源，

这里我们可以 通过 spring.datasource.type 指定数据源

type: com.alibaba.druid.pool.DruidDataSource # 自定义数据源

还是像上一章那样，输出一下数据源试试

切换数据源成功了。接下来可以配置初始化大小、最大连接数、等待时间、最小连接数 等设置项。

spring:datasource:username: rootpassword: root123#?serverTimezone=UTC解决时区的报错url: jdbc:mysql://localhost:3306/webtast?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8driver-class-name: com.mysql.cj.jdbc.Drivertype: com.alibaba.druid.pool.DruidDataSource#Spring Boot 默认是不注入这些属性值的，需要自己绑定#druid 数据源专有配置initialSize: 5minIdle: 5maxActive: 20maxWait: 60000timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: SELECT 1 FROM DUALtestWhileIdle: truetestOnBorrow: falsetestOnReturn: falsepoolPreparedStatements: true#配置监控统计拦截的filters，stat:监控统计、log4j：日志记录、wall：防御sql注入filters: stat,wall,log4jmaxPoolPreparedStatementPerConnectionSize: 20useGlobalDataSourceStat: trueconnectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

如上配置需要导入log4j依赖

<dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version>
</dependency>

运行log4j需要加人这个配置文件log4j.properties

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

新建配置类DruidConfig.java

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;import javax.sql.DataSource;@Configuration
public class DruidConfig {@ConfigurationProperties(prefix = "spring.datasource")@Beanpublic DataSource druidDataSource() {return new DruidDataSource();}
}

这个配置类的作用是

将自定义的 Druid数据源添加到容器中，不再让 Spring Boot 自动创建
绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource从而让它们生效@ConfigurationProperties(prefix = "spring.datasource")的作用：
全局配置文件中前缀为 spring.datasource的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中

测试一下获取最大连接数

        DruidDataSource druidDataSource = (DruidDataSource) dataSource;System.out.println("druidDataSource 数据源最大连接数：" + druidDataSource.getMaxActive());System.out.println("druidDataSource 数据源初始化连接数：" + druidDataSource.getInitialSize());

运行结果

Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看
在DruidConfig.java添加如下方法

//配置 Druid 监控管理后台的Servlet；
//内置 Servlet 容器时没有web.xml文件，所以使用 Spring Boot 的注册 Servlet 方式
@Bean
public ServletRegistrationBean statViewServlet() {ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");// 这些参数可以在 com.alibaba.druid.support.http.StatViewServlet // 的父类 com.alibaba.druid.support.http.ResourceServlet 中找到Map<String, String> initParams = new HashMap<>();initParams.put("loginUsername", "admin"); //后台管理界面的登录账号initParams.put("loginPassword", "123456"); //后台管理界面的登录密码//后台允许谁可以访问//initParams.put("allow", "localhost")：表示只有本机可以访问//initParams.put("allow", "")：为空或者为null时，表示允许所有访问initParams.put("allow", "");//deny：Druid 后台拒绝谁访问//initParams.put("kuangshen", "192.168.1.20");表示禁止此ip访问//设置初始化参数bean.setInitParameters(initParams);return bean;
}

之后运行，访问http://localhost:8080/druid/login.html

还可以配置 Druid web 监控 filter 过滤器，在DruidConfig.java添加如下方法

//配置 Druid 监控 之  web 监控的 filter
//WebStatFilter：用于配置Web和Druid数据源之间的管理关联监控统计
@Bean
public FilterRegistrationBean webStatFilter() {FilterRegistrationBean bean = new FilterRegistrationBean();bean.setFilter(new WebStatFilter());//exclusions：设置哪些请求进行过滤排除掉，从而不进行统计Map<String, String> initParams = new HashMap<>();initParams.put("exclusions", "*.js,*.css,/druid/*,/jdbc/*");bean.setInitParameters(initParams);//"/*" 表示过滤所有请求bean.setUrlPatterns(Arrays.asList("/*"));return bean;
}

如下是访问截图：

5、SpringBoot + Dubbo + Zookeeper

什么是分布式系统？
分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统

什么RPC?
是一种远程过程调用的思想，也就是一种进程间通信方式的思想。

举例：两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，是不能直接调用的。RPC可以让他们互相调用。

什么是Dubbo?
是一款高性能、轻量级的开源Java RPC框架，提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

dubbo官网 http://dubbo.apache.org/zh-cn/index.html

什么是ZooKeeper？
是一个分布式的，开放源码的分布式应用程序协调服务。我们用ZooKeeper来管理Dubbo中一些配置来实现服务。

5.1、Window下安装zookeeper

下载地址:https://zookeeper.apache.org/releases.html

下载完解压，找到/bin/zkServer.cmd
在endlocal前一排加个pause。保存。

找到/conf/zoo_sample.cfg，复制一份，改名zoo.cfg

zoo.cfg就是我们的配置文件了，暂时先不改里面的内容

运行zkServer.cmd试试

再运行zkCli.cmd

输入以下指令

ls / ：列出zookeeper根下保存的所有节点
create –e /haha 123：创建一个haha节点，值为123
get /haha：获取/haha节点的值

5.2、Window下安装dubbo-admin

下载地址：https://github.com/apache/dubbo-admin/archive/master.zip

下载完解压，把它放在zookeeper同目录下

之后就可以打包dubbo-admin了。

打包之前核对一下zookeeper地址
1、先找到zookeeper里的zoo.cfg，里面的clientPort=2181的就是zookeeper的端口号
2、这个端口号需要和dubbo-admin\src\main\resources \application.properties里的dubbo.registry.address=zookeeper://127.0.0.1:2181一致

首先保持zookeeper的服务处于开启状态。

也就是zkServer.cmd一直开着

然后在dubbo-admin-master目录下，打开一个新的cmd
打包dubbo-admin

mvn clean package -Dmaven.test.skip=true

等待执行完成

执行 dubbo-admin\target 下的dubbo-admin-0.0.1-SNAPSHOT.jar

	java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

执行完毕，访问：http://localhost:7001/
默认账号root，密码root


到此安装完成
接下来仍然保持 Dubbo 和 zookeeper运行

5.3 、SpringBoot + Dubbo + zookeeper

我们现在要实现两个板块间相互通信：

用卖票举例：
先创建一个主项目，然后里面创建两个板块：Provider提供服务者、Consumer服务消费者。

1、先在主项目中创建一个接口，这个接口两个项目都要调用。

2、为两个模块provider、consumer添加相同的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="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 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.3.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.haha</groupId><artifactId>provider</artifactId><version>0.0.1-SNAPSHOT</version><name>provider</name><description>Demo project for Spring Boot</description><properties><java.version>11</java.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope><exclusions><exclusion><groupId>org.junit.vintage</groupId><artifactId>junit-vintage-engine</artifactId></exclusion></exclusions></dependency><dependency><groupId>com.haha</groupId><artifactId>myboot005</artifactId><version>0.0.1-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.3</version><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo</artifactId><version>2.7.3</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>4.0.1</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>2.8.0</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.13</version><type>pom</type><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>0.10</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

需要注意的是，其中这个依赖是主项目。

和你自己建的主项目对应就可以

        <dependency><groupId>com.haha</groupId><artifactId>myboot005</artifactId><version>0.0.1-SNAPSHOT</version></dependency>

3、服务提供者provider
配置文件

server.port=8081
#spring项目名
spring.application.name=dubbo_auto_configuration_provider_demo
#Dubbo provider configuration
dubbo.application.name=dubbo_provider
dubbo.registry.protocol=zookeeper
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
#扫描注解包通过该设置将服务注册到zookeeper
dubbo.scan.base-packages=com.haha.provider.service

提供一个服务TestServiceImpl

package com.haha.provider.service;import com.haha.myboot005.TestService;
import org.apache.dubbo.config.annotation.Service;@Service(version = "1.0.0",interfaceClass = TestService.class)
public class TestServiceImpl implements TestService {@Overridepublic void ins() {System.out.println("这是我提供的服务");}
}

4、服务消费者consumer
配置文件

#避免端口冲突
server.port=8082
#dubbo configuration
dubbo.application.name=dubbo_consumer
dubbo.registry.protocol=zookeeper
dubbo.registry.address=zookeeper://127.0.0.1:2181

消费服务

package com.haha.consumer.controller;import com.haha.myboot005.TestService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
public class TestController {@Reference(version = "1.0.0")private TestService testServiceImpl;@RequestMapping("/ins")public String ins(){testServiceImpl.ins();return "ins";}}

然后将两个项目分别启动，这时浏览器访问http://localhost:8082/ins

再看看控制器后台

运行成功

两个不同的应用实现了数据通信