SpringBoot详解

前言

所有的技术框架的发展似乎都遵循了一条主线规律:

1. 从一个复杂应用场景衍生一种规范框架, 人们只需要进行各种配置而不需要自己去实现它, 这时候强大的配置功能成了优点;
2. 发展到一定程度之后, 人们根据实际生产应用情况, 选取其中实用功能和设计精华, 重构出一些轻量级的框架;
3. 之后为了提高开发效率, 嫌弃原先的各类配置过于麻烦, 于是开始提倡 “约定大于配置″, 进而衍生出一些一站式的解决方案。
   这就是 Java 企业级应用 ->J2EE-> spring-> spring boot 的过程。

一、SpringBoot 是什么？

1.1、概念

• SpringBoot 是一个 javaweb 开发的框架。
• 对比于其他 Javaweb 框架，更简化开发，约定大于配置。

1.2、目的

• 让大家更容易使用 spring，更容易集成各种常用的中间件、开源软件。
• SpringBoot 基于 Spring 开发, SpringBoot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。
• SpringBoot 不是用来替代 spring 的解决方案，而是和 spring 框架紧密结合提升 spring 开发者体验的工具。

1.3、什么是微服务

• 微服务是一种架构风格, 它要求我们在开发一个应用的时候, 这个应用必须构建成一系列小服务的组合; 可以通过 http 的方式进行互通。
• MVC 架构，MVVM 架构，微服务架构。
• 微服务架构, 就是把每个功能元素独立出来。把独立出来的功能元素的动态组合, 需要的功能元素才去拿来组合, 需要多一些时可以整合多个功能元素。
• 所以微服务架构是对功能元素进行复制, 而没有对整个应用进行复制。

优点：1. 节省了调用资源。2. 每个功能元素的服务都是一个可替换的、可独立升级的软件代码。

1.4、单体应用架构

• 单体应用架构 (all in one) 是指，我们将一个应用的中的所有应用服务都封装在一个应用中；
• 无论是 ERP、CRM 或是其他什么系统看，都把数据库访问，web 访问，等等各个功能放到一个 war 包内。

优点：易于开发和测试，方便部署；当需要扩展时，只需要将 war 复制多份, 然后放到多个服务器上, 再做个负载均衡就可以了。
缺点：修改一个非常小的地方, 都需要停掉整个服务, 重新打包部署这个应用 War 包；对于一个大型应用，如何维护，如何分工合作都是问题。

1.5、如何构建微服务

二、SpringBoot 原理

2.1、pom.xml

1. spring-boot-dependencie：核心依赖在父工程中。大部分依赖的版本都是在父工程中管理着，我们拿过来调用即可，因此我们引用一些依赖时不需要指定版本。并且父工程中已经帮我们配置好资源过滤和一些插件。

2.2、启动器

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>

1. 启动器其实就是 springboot 的启动场景，比如 spring-boot-starter-web 启动器会帮我们自动导入 web 环境所有依赖。
2. springboot 会将所有的功能场景，都变成一个个启动器。
3. 我们要使用什么功能，只需要找到对应的启动器就可以了即 starter

2.3、主程序

2.3.1、注解

@SpringBootApplication

1. @SpringBootConfiguration：springboot 的配置。
   • @Configuration：spring 配置类。
     • @Component：说明他也是 spring 的一个组件。
2. @EnableAutoConfiguration：自动导入配置。
   1. @AutoConfigurationPackage：自动配置包。
      • @Import({Registrar.class})：自动配置包注册。
   2. @Import({AutoConfigurationImportSelector.class})：自动配置导入选择器。（自动导包的核心）
3. @ComponentScan()：扫描当前主启动类同级的包。（扫描的包到 Registrar.class 注册）

自动导包的核心 AutoConfigurationImportSelector 类：选择了什么东西
AutoConfigurationImportSelector 类中的方法：

// 1.获得自动配置实体（调用“获取所有候选配置”的方法获取实体）。
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata)
// 2.获取所有候选配置（候选配置是哪些配置）。
List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes){
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
}
// 3.候选配置是所有标注@EnableAutoConfiguration注解的类下的所有配置。（即获取主启动类下的所有配置）
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }
// 4.获取所有的配置从哪里来，上面第二个方法调用了loadFactoryNames方法
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }
// 5.loadFactoryNames方法调用了loadSpringFactories方法
// 6.loadSpringFactories方法从项目资源和系统资源中获取配置文件
classLoader.getResources("META-INF/spring.factories") ClassLoader.getSystemResources("META-INF/spring.factories")

META-INF/spring.factories：自动配置的核心文件。

// 遍历所有的资源，封装成properties供我们使用
Properties properties = PropertiesLoaderUtils.loadProperties(resource);

结论: springboot 所有自动配置都是在启动的时候扫描并加载: 所有的自动配置类都在 spring.factories 里面，但是不一定生效；要判断条件是否成立：只要导入了对应的 start，就有对应的启动器，有了启动器，我们自动装配就会生效，然后自动配置就可以成功。

详细步骤：

1. springboot 在启动的时候, 从类路径下 / META-INF/spring.factories 获取指定的值。
2. 将这些自动配置的类导入容器, 自动配置就会生效, 帮我进行自动配置。
3. 以前我们需要自动配置的东西, 现在 springboot 帮我们做了。
4. 整合 javaEE, 解决方案和自动配置的东西都在 spring-boot-autoconfigure-2.2.0.RELEASE.jar 这个包下。
5. 它会把所有需要导入的组件, 以类名的方式返回, 这些组件就会被添加到容器中。
6. 容器中也会存在非常多的 XXXAutoConfiguration 的文件 (@Bean), 就是这些类给容器中导入了这个场景需要的所有组件并自动配置。@Configuration（JavaConfig）
7. 有了自动配置类, 免去了我们手动编写配置文件的工作。

2.3.2、Run 方法

main 方法中的 run 方法启动会开启一个服务。

@SpringBootApplication
public class SpringbootWeb01Application {
    public static void main(String[] args) {
        // 该方法返回一个ConfigurableApplicationContext对象
        // 参数一：应用入口的类， 参数二：命令行参数
        SpringApplication.run(SpringbootWeb01Application.class, args);
    }
}

2.3.3、SpringApplication.run 分析

主要两部分

• 一是 SpringApplication 的实例化。
• 二是 run 方法的执行。

2.3.4、SpringApplication 类主要做了四件事情

• 判断应用的类型是普通项目还是 web 项目。（普通项目直接就结束了，web 项目可以一直启动）
• 查找并加载所有可用初始化器，设置到 initializers 属性中。
• 查找所有的应用程序监听器，设置到 listeners 属性中。（获取上下文处理 bean）
• 推断并设置 main 方法的定义类，找到运行的主类。

2.4、自动装配再理解

springboot 配置文件能够配置的东西都有一个固有的规律：
他们都有对应的 xxxAutoConfiguration 配置类，这个配置类都会绑定一个 xxxProperties 类，xxxProperties 类和 springboot 的配置文件绑定；这样我们就可以在 springboot 配置文件中自定义配置了。

2.4.1、自动装配原理再理解

1. springboot 启动会加载大量的自动配置类。
2. 我们要看我们需要的功能有没有在 springboot 默认写好的自动配置类中。
3. 我们看这个自动配置类中配置了哪些组件。（不存在就需要全部手动写，如果存在我们就不需要再手动配置；也可以自定义配置覆盖默认的配置）
4. 给容器中自动配置类添加组件时，会从 xxxProperties 类中获取相应的属性。我们只需要在 springboot 配置中指定这些属性就可以了。

• xxxAutoConfiguration：自动配置类（给容器中添加组件）
• xxxProperties：封装配置文件中的属性

2.5、自动配置类中存放了大量的配置没有全部都生效的原因

spring 的底层注解：根据不同的条件，来判断当前配置或者类是否生效。@Conditionalxxx

• @ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
• @ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
• @ConditionalOnMissingFilterBean({RequestContextFilter.class})
• @ConditionalOnProperty(prefix = “spring.mvc.formcontent.filter”,name = {“enabled”},matchIfMissing = true)
  。。。

三、SpringBoot

3.1、yaml 语法

SpringBoot 使用一个全局的配置文件，配置文件名是固定的。

• application.properties（语法结构：key=value）
• application.yml（语法结构：key: 空格 value）

全局配置文件的作用：修改 SpringBoot 自动配置的默认值，它会在底层帮我们自动配置。

3.1.1、基本语法

# 对象
student:
  name: 'zs'
  age: 12
# 对象的行内写法
student1: {name: 'zs',age: 12}
# 数组
pets:
  - cat
  - dog
  - pig
# 数组行内写法
pets1: [cat,dog,pig]

3.1.2、@ConfigurationProperties绑定 application.yml 配置的属性（属性需要 set 方法才能取值）

/*
ConfigurationProperties作用
将yml配置文件中配置的每个属性的值,映射到这个组件中;
告诉SpringBoot将本类中的所有属性和yml配置文件中相关的配置进行绑定;
参数prefix="person":将yml配置文件中的person下面的所有属性和本类属性对应。
（只有这个组件是容器中的组件,才能使用容器提供的ConfigurationProperties功能）
 */
 // 可以直接拿到复杂类型的值
@Component
@ConfigurationProperties(prefix = "person")
@Data
public class Person {
    private String name;
    private Integer age;
    private Boolean flag;
    private Date birth;
    private Map<String,Object> map;
    private List<Object> list;
    private Dog dog;
}

// application.yml
person:
  name: zs
  age: 12
  flag: false
  birth: 2021/04/20
  map: {k1: v1,k2: v2}
  list: [code,music,girl]
  dog:
    name: 旺财
    age: 3

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

3.1.3、@Configuration和@Value配合取值（没有 set 方法也可以取值）

// 复杂类型不能用@Value直接取值
@Configuration
@Data
public class Person {
    @Value("${person222.name}")
    private String name;
    @Value("${person222.age}")
    private Integer age;
    @Value("${person222.flag}")
    private Boolean flag;
    @Value("${person222.birth}")
    private Date birth;
    private Map<String,Object> map;
    private List<Object> list;
    private Dog dog;
}

// application.yml
person222:
  name: zs
  age: 12
  flag: false
  birth: 2021/04/20
  map: {k1: v1,k2: v2}
  list: [code,music,girl]
  dog:
    name: 旺财
    age: 3

3.1.4、@PropertySource读取 xxx.properties 配置（没有 set 方法也可以取值）

@Component
@PropertySource(value = "classpath:test.properties")//可以这样配置@PropertySource({"classpath:test.properties"})
@Data
public class Person {
    // SPEL表达式取出配置文件的值
    @Value("${name}")
    private String name;
    @Value("${age}")
    private Integer age;
    private Boolean flag;
    private Date birth;
    private Map<String,Object> map;
    private List<Object> list;
    private Dog dog;
}

// test.properties
name=zhangsan
age=13

3.1.5、松散绑定

yml 配置属性的 - 可以和实体属性的驼峰对应绑定

@Component
@ConfigurationProperties(prefix = "person")
@Data
public class Person {
    private String firstName;
}

// application.yml
person:
  first-name: zs

3.1.6、JSR303 数据校验

@Component
@ConfigurationProperties(prefix = "person")
@Data
@Validated //数据校验
public class Person {
    @Email(message="邮箱格式错误")
    private String name;
}

HibernateValidator 是 BeanValidation 的参考实现；HibernateValidator 提供了 JSR 303 规范中所有内置 constraint 的实现；和附加的 constraint

HibernateValidator 附加的 constraint

3.2、多环境配置和配置文件位置

3.2.1、配置文件位置

3.2.2、多环境配置切换

四、SpringBootWeb 开发

4.1、SpringBootWeb 开发需要解决的问题

• 导入静态资源
• 首页定制
• 模板引擎 Thymeleaf
• 装配扩展 springMVC
• 增删改查
• 拦截器
• 国际化
• SpringMvcConfig 配置
• 错误页定制

4.2、静态资源导入

1. 在 SpringBoot，可以使用以下方式处理静态资源。
   • webjars 文件夹下：映射访问 localhost:8080/webjars/
   • public 文件夹，static 文件夹，resources 文件夹下和 /**(即 classpath:)：映射访问 localhost:8080/
2. 文件夹优先级（即访问一个静态文件先查找 resources 文件夹）：resources>static>public

4.3、首页定制和图标定制

4.3.1、首页定制

1. 首页名称需要是 index.html
2. index.html 放在静态资源文件夹下（resources，static，public）
3. localhost:8080 / 就可以访问到 index.html 页面

4.3.2、老版本 springboot 支持 (2.1.7)

1. favicom.ico 图标放在 static 文件夹下。
2. 配置关闭默认的图标 spring.mvc.favicon.ico.enabled=false

4.4、模板引擎 Thymeleaf

4.4.1、thymeleaf 使用步骤

1. 导入 jar 包

<dependency>
 <groupId>org.thymeleafgroupId>
 <artifactId>thymeleaf-spring5artifactId>
dependency>
<dependency>
 <groupId>org.thymeleaf.extrasgroupId>
 <artifactId>thymeleaf-extras-java8timeartifactId>
dependency>

2. ThymeleafProperties 默认配置
   
3. controller 跳转
   
4. xxx.html 放在 templates 文件夹下
   
   xxx.html 页面上使用 thymeleaf 语法，需要引入头文件

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>首页title>
head>
<body>
<div th:text="${msg}">div>
body>
html>

4.4.2、thymeleaf 语法

1. html和css的元素都可以被thymeleaf接管。
2. ${}用来取值，
3. @{}用来表示url。
4. 消息文字的表达式#{} 。
5. 提取公共页面。
   • th:fragment=”siderbar”

4.5、扩展 springMVC

package com.sywl.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
// 扩展springMVC：只加上@Configuration注解
// 如果再加上@EnableWebMvc就会全面接管springMVC配置。（默认的配置不生效）
@Configuration
@EnableWebMvc // 就是导入了DelegatingWebMvcConfiguration类：作用是获取容器中所有的WebMvcConfig
public class SpringMvcConfig implements WebMvcConfigurer {
    /**
     * 视图跳转
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 访问/test跳转到test.html页面
        registry.addViewController("/test").setViewName("test");
    }
}

4.6、CRUD

4.7、拦截器

1. 自定义拦截器。

package com.sywl.config;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 自定义拦截器
*/
public class LoginHandlerInterceptor implements HandlerInterceptor {
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     // 登录成功之后，应该有用户的session
     Object loginUser = request.getSession().getAttribute("loginUser");
     if (loginUser == null) {// 1.没有登录
         // 2.给出提示信息
         request.setAttribute("msg", "没有权限，请先登录");
         // 3.转发到登录页面
         request.getRequestDispatcher("index.html").forward(request, response);
         return false;
     } else {
         return true;
     }
 }
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
 }
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
 }
}

2. 通过 springMVC 配置文件注入自定义拦截器并设置拦截所有请求和排除拦截的路径。

package com.sywl.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {
 /**
  * 配置拦截器
  *
  * @param registry
  */
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
     registry.addInterceptor(new LoginHandlerInterceptor())// 1.添加自定义拦截器
             // 2.添加拦截所有的的路径和页面
             .addPathPatterns("/**")
             // 3.排除不需要拦截的路径和页面
             .excludePathPatterns("/index.html", "/", "/user/login","/css/**","/js/**","/img/**");
 }
}

4.8、国际化

1. 创建 login.properties,login_zh_CN.properties,login_en_US.properties 三个配置文件。
   
2. 配置这三个文件。通过 ResourceBundle 可以同时配置三个文件。
   
3. 配置好的效果。
   
4. 把配置好的属性通过 th:text=”#{login.username}” 放到对应的位置上。
5. 自定义国际化组件。

package com.sywl.config;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.LocaleResolver;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Locale;
/**
* 自定义国际化组件
*/
public class MyLocaleResolver implements LocaleResolver {
 /**
  * 解析请求
  * @param httpServletRequest
  * @return
  */
 @Override
 public Locale resolveLocale(HttpServletRequest httpServletRequest) {
     // 1.获取请求中的语言参数。
     String language = httpServletRequest.getParameter("l");
     // 2.如果没有就使用默认的。
     Locale locale = Locale.getDefault();
     // 3.如果请求的链接携带了国际化的参数。
     if (!StringUtils.isEmpty(language)){
         // zh_CN
         String[] split = language.split("_");
         // 国家，地区
         locale = new Locale(split[0], split[1]);
     }
     return locale;
 }
 @Override
 public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {
 }
}

6. 在 springMVC 配置文件把自定义国际化组件注入到 spring 容器中。

package com.sywl.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {
 /**
  * 自定义国际化组件注入到spring容器
  *
  * @return
  */
 @Bean
 public LocaleResolver localeResolver() {
     return new MyLocaleResolver();
 }
}

7. 登录界面切换国际化时带上参数。
   

4.9、SpringMvcConfig 配置

package com.sywl.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // 访问localhost:8080/跳转到index.html
        registry.addViewController("/").setViewName("index");
        // 访问localhost:8080/index.html跳转到index.html
        registry.addViewController("/index.html").setViewName("index");
        // 访问localhost:8080/main.html跳转到dashboard.html
        // "redirect:/main.html"即跳转到dashboard.html
        registry.addViewController("/main.html").setViewName("dashboard");
    }
    /**
     * 自定义国际化组件注入到spring容器
     *
     * @return
     */
    @Bean
    public LocaleResolver localeResolver() {
        return new MyLocaleResolver();
    }
    /**
     * 配置拦截器
     *
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor())// 1.添加自定义拦截器
                // 2.添加拦截所有的的路径和页面
                .addPathPatterns("/**")
                // 3.排除不需要拦截的路径和页面
                .excludePathPatterns("/index.html", "/", "/user/login","/css/**","/js/**","/img/**");
    }
}

4.10、错误页定制。

1. 在 Resources 文件夹下的 templates 文件夹下创建 error 文件夹。
2. 定义相应错误页面（400.html,500.html 等等），放到 error 文件夹中，就完成了。
   

五、SpringBoot 集成的技术框架

5.1、Druid

• Druid 是阿里巴巴开源平台上一个数据库连接池实现, 结合了 C3P0、DBCP、PROXOOL 等 DB 连接池的优点，同时加入了日志监控。
• Druid 可以很好的监控 DB 连接池连接和 SQL 的执行情况, 天生就是针对监控而生的 DB 连接池。
• SpringBoot2.0 以上默认使用 Hikari 数据源，可以说 Hikari 与 Diud 都是当前 JavaWeb 上最优秀的数据源。
• Druid 配置。

5.2、springSecurity

SpringSecurity 是针对 Spring 项目的安全框架，也是 Springboot 底层安全模块默认的技术选型；他可以实现强大的 web 安全控制，对于安全控制，我们仅需要引入 spring-boot-starter-security 模块, 进行少量的配置, 即可实现强大的安全管理。

• WebSecurityConfigurerAdapter 类：可以继承这个类自定义 security 授权策略。
• AuthenticationManagerBuilder 类：自定义 security 认证策略。
• @EnableWebSecurity：开启 WebSecurity 模式。
• 认证：authentication
• 授权：authorization

5.3、shiro

// 获取当前的用户对象Subject
Subject currentUser = SecurityUtils.getSubject();
// 通过当前用户获取shiro的session
Session session = currentUser.getSession();
// 判断当前用户是否被认证
currentUser.isAuthenticated()
// 获得当前用户的认证
currentUser.getPrincipal()
// 判断当前用户是否拥某些角色
currentUser.hasRole("schwartz")
// 判断当前用户是否拥某些权限（参数不同，产生不同效果）
currentUser.isPermitted("lightsaber:wield")
currentUser.isPermitted("winnebago:drive:eagle5")
// 注销
currentUser.logout();

5.4、swagger

• swagger 是最流行的 api 框架。
• restful api 文档在线自动生成（api 文档和 api 定义同步更新）。
• 可以直接运行在线测试 api 接口。
• 支持多种语言（Java，php）。
• 通过 swagger 接口给一些难理解的属性、接口增加注释。

5.5、redis

在 springboot2.x 之后，原来使用的 jedis 被替换为 lettuce

• jedis：底层采用直线服务，多线程使用不安全。如果避免不安全，需要使用 jedis Pool 连接池。更像 BIO 模式。
• lettuce：底层采用 netty，实例可以在多个线程中进行共享, 不存在线程不安全的情况，可以减少线程数量了。更像 NIO 模式。

六、SpringBoot 整合

6.1、整合 JDBC

1. 导入 spring-jdbc 和 mysql 驱动的依赖

<dependency>
 <groupId>org.springframework.bootgroupId>
 <artifactId>spring-boot-starter-jdbcartifactId>
dependency>

<dependency>
 <groupId>mysqlgroupId>
 <artifactId>mysql-connector-javaartifactId>
 <scope>runtimescope>
dependency>

2. 配置好数据库连接。
3. springboot 已经配置好了 jdbc 模板可以直接使用。

@RestController
public class JDBCController {
 @Autowired
 JdbcTemplate jdbcTemplate;
 @GetMapping("/list")
 public List<Map<String, Object>> selectDeptList() {
     String sql = "select * from depart";
     List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
     System.out.println(maps);
     return maps;
 }
 @GetMapping("/add")
 public void add() {
     String sql = "insert into depart values (6,'部门6')";
     int update = jdbcTemplate.update(sql);
     System.out.println(update);
 }
 @GetMapping("/delete/{id}")
 public void delete(@PathVariable("id") Integer id) {
     String sql = "delete from depart where id = ?";
     int update = jdbcTemplate.update(sql,id);
     System.out.println(update);
 }
 @GetMapping("/update/{id}")
 public void update(@PathVariable("id") Integer id) {
     String sql = "update depart set id = ?,dept_name = ? where id = "+id;
     Object[] params = new Object[2];
     params[0] = 100;
     params[1] = "部门100";
     int update = jdbcTemplate.update(sql,params);
     System.out.println(update);
 }

6.2、整合 druid

1. 导入 druid 和 mysql 驱动的依赖。

<dependency>
 <groupId>mysqlgroupId>
 <artifactId>mysql-connector-javaartifactId>
 <scope>runtimescope>
dependency>

<dependency>
 <groupId>com.alibabagroupId>
 <artifactId>druidartifactId>
 <version>1.1.21version>
dependency>

<dependency>
 <groupId>log4jgroupId>
 <artifactId>log4jartifactId>
 <version>1.2.12version>
dependency>

2. 配置好数据库连接和 druid 配置。

spring:
datasource:
 driver-class-name: com.mysql.jdbc.Driver
 url: jdbc:mysql://localhost:3306/z-springboot?useUnicode=true&characterEncoding=utf-8&serverTimezone=
 username: root
 password: xxx
 type: com.alibaba.druid.pool.DruidDataSource
 # druid数据源配置
 initialSize: 5
 minIdle: 5
 maxActive: 20
 maxWait: 60000
 timeBetweenEvictionRunsMillis: 60000
 minEvictableIdleTimeMillis: 300000
 validationQuery: SELECT 1 FROM DUAL
 testWhileIdle: true
 testOnBorrow: false
 testOnReturn: false
 poolPreparedStatements: true
 # 配置监控统计拦截的filters：stat(监控统计)，log4j(日志记录)，wall(防御sql注入)
 # 如果允许时报错java.lang.ClassNotFoundException:org.apache.log4j.Priority则需要导入log4j依赖
 filters: stat,wall,log4j
 maxPoolPreparedStatementPerConnectionSize: 20
 useGlobalDataSourceStat: true
 connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

3. 配置 DruidConfig 类

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.Filter;
import javax.sql.DataSource;
import java.util.HashMap;
@Configuration
public class DruidConfig {
 /**
  * 关联application.yml的druid配置
  * @return
  */
 @ConfigurationProperties("spring.datasource")
 @Bean
 public DataSource druidDataSource(){
     return new DruidDataSource();
 }
 // 后台监控：web.xml，ServletRegistrationBean
 // 因为springboot内置了Servlet容器，所以没有web.xml；替代方法：ServletRegistrationBean
 /**
  * druid后台监控配置
  * @return
  */
 @Bean
 public ServletRegistrationBean a(){
     // 1.配置访问路径localhost:8080/druid
     ServletRegistrationBean<StatViewServlet> bean = new ServletRegistrationBean<>(new StatViewServlet(),"/druid/*");
     // 2.后台需要有人登录，账号密码配置
     HashMap<String, String> initParameters = new HashMap<>();
     initParameters.put("loginUsername","xxx");// 登录的key是固定的：必须是loginUsername,loginPassword
     initParameters.put("loginPassword","xxx");
     // 3.配置允许谁可以访问：""意思是谁都可以访问
     initParameters.put("allow","");
     // 4.禁止谁能访问
     initParameters.put("sywl","localhost");
     // 设置初始化参数
     bean.setInitParameters(initParameters);
     return bean;
 }
 /**
  * druid过滤器
  * @return
  */
 @Bean
 public FilterRegistrationBean webStatFilter(){
     FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<>();
     bean.setFilter(new WebStatFilter());
     HashMap<String, String> initParameters = new HashMap<>();
     // 可以过滤哪些请求（这些东西不进行统计）
     initParameters.put("exclusions","*.js,*.css,/druid/*");
     bean.setInitParameters(initParameters);
     return bean;
 }
}

6.3、整合 mybatis

1. 导入 springboot 整合 mybatis 的依赖和 mysql 驱动包的依赖。

<dependency>
  <groupId>org.mybatis.spring.bootgroupId>
  <artifactId>mybatis-spring-boot-starterartifactId>
  <version>2.1.1version>
dependency>
<dependency>
  <groupId>mysqlgroupId>
  <artifactId>mysql-connector-javaartifactId>
  <scope>runtimescope>
dependency>

2. 配置好数据库连接和 mybatis 配置。

// application.properties
server.port=8888
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/z-springboot?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=xxx
# mybatis
mybatis.type-aliases-package=com.sywl.entity
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
# classpath:mybatis/mapper/*.xml是从resources文件夹下开始扫描。
# classpath:/mybatis/mapper/*.xml是从项目的根目录开始扫描。

3. UserMapper 接口和 UserMapper.xml

@Mapper// 这个注解表示这是mybatis的一个mapper类
@Repository
public interface UserMapper {
 List<User> selectUserList();
 User selectUserById(@Param("id")Integer id);
 void insertUser(User user);
 void deleteUser(@Param("id")Integer id);
 void updateUser(User user);
}

6.4、springSecurity 使用

1. 导入 springSecurity 依赖。

<dependency>
 <groupId>org.springframework.bootgroupId>
 <artifactId>spring-boot-starter-securityartifactId>
dependency>

2. 配置 SecurityConfig 类。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 /**
  * 授权
  * @param http
  * @throws Exception
  */
 @Override
 protected void configure(HttpSecurity http) throws Exception {
     // 首页所有人可以访问，功能页只有对应有权限的人可以访问。
     // 1.请求权限的规则
     http.authorizeRequests()
             .mvcMatchers().permitAll()
             .mvcMatchers("/level1/**").hasRole("vip1")
             .mvcMatchers("/level2/**").hasRole("vip2")
             .mvcMatchers("/level3/**").hasRole("vip3");
     // 2.开启登录页面（security自带的登录页）（没有权限默认跳转到登录页面）
     http.formLogin().loginPage("/toLogin")// 定制登录页：localhost:8080/toLogin会访问RouterController的/toLogin请求跳转到登录页
             .loginProcessingUrl("/login")// 设置表单提交的地址。（默认就是/login，可以改成其他的路径，比如：/toLogin）
             .usernameParameter("user")// 设置表单提交的用户名的name，默认是username
             .passwordParameter("pwd");// 设置表单提交的密码的name，默认是password
     // 3.开启注销功能（logoutSuccessUrl设置登出成功跳转的页面，一般跳转到首页）
     // logoutUrl("/logout")是设置登出访问的请求地址。（默认是logout）
     // 防止网站传输：登出是get的请求
     http.csrf().disable();// 关闭csrf功能(默认是开启的)：登出失败可能的原因就是没有关闭csrf
     http.logout().logoutSuccessUrl("/").logoutUrl("/logout");
     // 4.开启记住我功能：cookies 默认保存两周；自定义"记住我"的name
     http.rememberMe().rememberMeParameter("remember");
 }
 /**
  * 认证：springboot2.1.x可以直接使用
  * passwordEncoder：密码编码
  * springSecurity 5.0+新增了需要加密算法
  * @param auth
  * @throws Exception
  */
 @Override
 protected void configure(AuthenticationManagerBuilder auth) throws Exception {
     /*User.UserBuilder user = User.withDefaultPasswordEncoder();
     auth.jdbcAuthentication()
             .dataSource(datasource)
             .withDefaultSchema()
             .withUser(user.username("user")).password(user.password("password")).roles("ADMIN");*/
     // 这些数据正常从数据库中取
     auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
             .withUser("sywl").password(new BCryptPasswordEncoder().encode("123456")).roles("vip2","vip3")
             .and()
             .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2","vip3")
             .and()
             .withUser("guest").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1");
 }
}

3. 扩展整合 thymeleaf。

<dependency>
 <groupId>org.thymeleaf.extrasgroupId>
 <artifactId>thymeleaf-extras-springsecurity4artifactId>
 <version>3.0.4.RELEASEversion>
dependency>

4. html 页面使用 sec:xxx 语法。

<div class="nav" th:fragment="nav-menu">
 
 <div sec:authorize="!isAuthenticated()">
     <a th:href="@{/toLogin}">登录a>
 div>
 <div sec:authorize="isAuthenticated()">
     用户名：<span sec:authentication="name">span>
     <a th:href="@{/logout}">注销a>
 div>
div>

6.5、shiro 使用

1. 导入 shiro 依赖和 shiro 整合 thymeleaf 的依赖。

<dependency>
 <groupId>org.apache.shirogroupId>
 <artifactId>shiro-springartifactId>
 <version>1.4.1version>
dependency>

<dependency>
 <groupId>com.github.theborakompanionigroupId>
 <artifactId>thymeleaf-extras-shiroartifactId>
 <version>2.0.0version>
dependency>

2. 自定义 UserReam 类继承 AuthorizingRealm 类重写两个方法。用于认证和授权

public class UserRealm extends AuthorizingRealm {
 @Autowired
 UserMapper userMapper;
 /**
  * 授权
  * @param principalCollection
  * @return
  */
 @Override
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
     System.out.println("执行了授权");
     SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
     // 拿到当前登录对象：subject.getPrincipal()可以获得认证时SimpleAuthenticationInfo传递的user
     Subject subject = SecurityUtils.getSubject();
     User currentUser = (User) subject.getPrincipal();
     info.addStringPermission(currentUser.getPerms());
     return info;
 }
 /**
  * 认证
  * @param authenticationToken
  * @return
  * @throws AuthenticationException
  */
 @Override
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
     System.out.println("执行了认证");
     // 1.拿到用户输入的用户名和密码
     UsernamePasswordToken userToken = (UsernamePasswordToken) authenticationToken;
     // 2.连接真实数据库
     User user = userMapper.selectUser(userToken.getUsername());
     if (user==null){
         return null;
     }
     Session session = SecurityUtils.getSubject().getSession();
     session.setAttribute("loginUser",user);
     return new SimpleAuthenticationInfo(user,user.getPassword(),"");
 }
}

3. ShiroConfig 配置类，配置 Ream，SecurityManager，ShiroFilterFactoryBean。

@Configuration
public class ShiroConfig {
 @Bean
 public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
     ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
     bean.setSecurityManager(securityManager);
     /**
      * anon:无需认证就可以访问
      * authc:必须认证了才能访问
      * user:必须加有"记住我"功能才能用
      * perms:拥有对某个资源的权限才能访问
      * roLe:拥有某个角色权限才能访问
      */
     LinkedHashMap<String, String> filterMap = new LinkedHashMap<>();
     filterMap.put("/user/add", "perms[user:add]");
     filterMap.put("/user/update", "perms[user:update]");
     filterMap.put("/user/*", "authc");// authc配置需要在perms下面
     bean.setFilterChainDefinitionMap(filterMap);
     // 登录失败设置跳转到登录的请求
     bean.setLoginUrl("/toLogin");
     // 未授权跳转页面
     bean.setUnauthorizedUrl("/unauth");
     return bean;
 }
 @Bean(name = "securityManager")
 public DefaultWebSecurityManager securityManager(UserRealm userRealm) {
     DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
     securityManager.setRealm(userRealm);
     return securityManager;
 }
 @Bean
 public UserRealm userRealm() {
     return new UserRealm();
 }
 /**
  * 整合shiroDialect：用来整合shiro thymeleaf
  *（需要导入shiro整合thymeleaf的依赖）
  * @return
  */
 @Bean
 public ShiroDialect shiroDialect() {
     return new ShiroDialect();
 }
}

4. 登录方法。

@RequestMapping("/login")
 public String login(String username, String password, Model model){
     Subject subject = SecurityUtils.getSubject();
     UsernamePasswordToken token = new UsernamePasswordToken(username,password);
     try {
         subject.login(token);
         return "index";
     } catch (UnknownAccountException e) {
         model.addAttribute("msg","用户名不存在");
         return "login";
     }catch (IncorrectCredentialsException e){
         model.addAttribute("msg","密码错误");
         return "login";
     }
 }

5. html 使用 shrio:xxx 语法需要导入头文件。

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org"
   xmlns:shiro="http://www.thymeleaf.org/thymeleaf-extras-shiro">
<head>
 <meta charset="UTF-8">
 <title>首页title>
head>
<body>
<h1>首页h1>
<div th:if="${session.loginUser!=null}">
 <a th:href="@{/logout}">注销a>
div>
<div th:if="${session.loginUser==null}">
 <a th:href="@{/toLogin}">登录a>
div>
<hr>
<div shiro:hasPermission="user:add">
 <a th:href="@{/user/add}">adda>
div>
<div shiro:hasPermission="user:update">
 <a th:href="@{/user/update}">updatea>
div>
body>
html>

6.6、整合 swagger

1. 导入依赖。

<dependency>
 <groupId>io.springfoxgroupId>
 <artifactId>springfox-swagger2artifactId>
 <version>2.9.2version>
dependency>

<dependency>
 <groupId>io.springfoxgroupId>
 <artifactId>springfox-swagger-uiartifactId>
 <version>2.9.2version>
dependency>

2. 配置类 SwaggerConfig。

@Configuration
@EnableSwagger2 // 开启swagger2
public class SwaggerConfig {
}

3. 测试访问：http://localhost:8080/swagger-ui.html
   
4. 自定义 swagger 相关配置。

@Configuration
@EnableSwagger2 // 开启swagger2
public class SwaggerConfig {
 // 注册多个Docket实例可以实现分组
 @Bean
 public Docket docket(){
     return new Docket(DocumentationType.SWAGGER_2)
             .apiInfo(info())
             .groupName("sywl")// 组名
             .enable(true)// 是否开启访问swagger；默认true
             .select()
             // 配置需要扫描接口的方式RequestHandlerSelectors
             // basePackage：指定要扫描的包
             // any()：扫描全部
             // none()：不扫描
             // withClassAnnotation()：扫描类上的注解；参数是注解的反射对象
             // withMethodAnnotation()：扫描方法上的注解
             .apis(RequestHandlerSelectors.basePackage("com.sywl.controller"))
             // paths：过滤路径（只扫描这些请求下的接口）
             .paths(PathSelectors.ant("/user/**"))
             .build();
 }
 /**
  * 配置swagger信息
  * @return
  */
 @Bean
 public ApiInfo info(){
     // 作者信息
     Contact contact = new Contact("sywl", "", "[email protected]");
     return new ApiInfo("SwaggerApi文档",
             "这是一个文档描述",
             "1.0",
             "http://www.xxx.com",
             contact,
             "Apache 2.0",
             "http://www.apache.org/licenses/LICENSE-2.0",
             new ArrayList());
 }
}

5. 常用标识注解

• @ApiModel(“用户实体类”)：用在实体类上，对类的说明。
• @ApiModelProperty(“用户名”)：用在实体类的属性字段上，对字段的说明。
• @ApiOperation(“跳转首页的接口”)：用在方法上，对方法的说明。
• @ApiParam(“用户名”)：用在请求参数上，对请求参数的说明。

6.7、整合 redis

1. 导入依赖。

<dependency>
 <groupId>org.springframework.bootgroupId>
 <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

2. 配置 redis 连接。

// application.yml
spring:
     redis:
       host: 127.0.0.1
       port: 6379
       username: root
       password: xxx

3. 测试。

七、springboot 实现任务

• 异步任务：执行的程序需要时间时，需要开启一个线程执行，并给客户一个提示。
• 定时任务：可以在某一个时间点执行一个任务。
• 邮件发送：

7.1、异步任务

1. springboot 开启异步任务。

@SpringBootApplication
@EnableAsync // 开启异步任务
public class Springboot05taskApplication {
 public static void main(String[] args) {
     SpringApplication.run(Springboot05taskApplication.class, args);
 }
}

2. 在需要开启线程的方法上加上@Async注解。

@Service
public class AsyncService {
 @Async
 public void hello(){
     try {
         Thread.sleep(3000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }
}

3. 执行时，可以先给用户反馈信息”OK”，任务仍在执行，不需要用户在加载页面等待。

@RestController
public class AsyncController {
 @Autowired
 private AsyncService asyncService;
 @RequestMapping("/hello")
 public String Async(){
     asyncService.hello(); // 睡眠3秒
     System.out.println("正在处理数据");
     return "OK";
 }
}

7.2、邮件发送

1. 导入 mail 依赖

<dependency>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starter-mailartifactId>
dependency>

2. 配置 mail

// application.yml
spring:
   mail:
     username: [email protected]
     password: xxx
     host: smtp.qq.com
     # QQ邮箱需要开启加密验证；其他的邮箱不需要。
     properties: {mail.smtp.ssl.enable: true}

3. 编写邮件发送。

@SpringBootTest
class Springboot05taskApplicationTests {
 @Autowired
 private JavaMailSenderImpl mailSender;
 @Test
 void contextLoads01() {
     SimpleMailMessage message = new SimpleMailMessage();
     message.setSubject("你好啊！");
     message.setText("这是一个问候邮件");
     message.setFrom("[email protected]");
     message.setTo("[email protected]");
     mailSender.send(message);
 }
 @Test
 void contextLoads02() throws MessagingException {
     // 1.一个复杂的邮件。
     MimeMessage mimeMessage = mailSender.createMimeMessage();
     // 2.组装。
     MimeMessageHelper helper = new MimeMessageHelper(mimeMessage,true);
     helper.setSubject("你好啊！");
     helper.setText("
这一个问候邮件！
",true);
     // 附件
     helper.addAttachment("1.jpg",new File("C:\\Users\\SYWL\\Desktop\\2.jpg"));
     helper.setFrom("[email protected]");
     helper.setTo("[email protected]");
     mailSender.send(mimeMessage);
 }
}

八、dubbo 和 Zookeeper

8.1、分布式理论

在《分布式系统原理与范型》一书中有如下定义:“分布式系统是若干独立计算机的集合, 这些计算机对于用户来说就像单个相关系统”。

8.1.1、分布式系统概念

分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。

8.1.2、分布式系统目的

为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。（其目的是利用更多的机器，处理更多的数据）

8.1.3、发展

1. 单一应用架构。
   当网站流量很小时, 只需—个应用, 将所有功能都部署在一起, 以减少部署节点和成本。此时, 用于简化增删改查工作量的数据访问框架 (ORM) 是关键。
   优点：适用于小型网站, 小型管理系统, 将所有功能都部署到一个功能里, 简单易用。
   缺点：1 性能扩展比较难。2 协同开发问题。3 不利于升级维护。
2. 垂直应用架构。
   当访问量逐渐增大, 单一应用增加机器帶来的加速度越来越小, 将应用拆成互不相干的几个应用, 以提升效率。此时, 用于加速前端页面开发的 Web 框架 (MVC) 是关键。
   优点：通过切分业务来实现各个模块独立部署, 降低了维护和部署的难度, 团队各司其职更易管理, 性能扩展也更方便, 更有针对性。
   缺点：公用模块无法重复利用, 开发性的浪费。
3. 分布式服务架构。
   当垂直应用越来越多, 应用之间交互不可避免, 将核心业务抽取出来, 作为独立的服务, 逐渐形成稳定的服务中心, 使前端应用能更快速的响应多变的市场需求。此时, 用于提高业务复用及整合的分布式服务框架（RPC）是关键。
4. 流动计算架构。
   当服务越来越多, 容量的评估, 小服务资源的浪费等问题逐渐显现, 此时需增加一个调度中心基于访问压力实时管理集群容量, 提高集群利用率。此时, 用于提高机器利用率的资源调度和治理中心 (SOA)[Service Oriented Architecture]是关键。

8.2、什么是 RPC

RPC【Remote procedure cal】是指远程过程调用, 是—种进程间通信方式, 他是一种技术的思想, 而不是规范。它允许程序调用另一个地址空间 (通常是共亨网络的另一台机器上) 的过程或函数而不用程序员显式编码这个远程调用的细节。（即程序员无论是调用本地的还是远程的函数, 本质上编写的调用代码基本相同）

RPC 两个核心模块：

• 通讯
• 序列化（数据传输需要转换）

8.3、什么是 dubbo

Apache dubbob 是一款高性能、轻量级的开源 Java rpc 框架。
它提供了三大核心能力:

• 面向接口的远程方法调用。
• 智能容错和负载均衡。
• 以及服务自动注册和发现。

8.4、dubbo

• 服务提供者（provider）：暴露服务的服务提供方, 服务提供者在启动时, 向注册中心注册自己提供的服务。
• 服务消费者（Consomer）：调用远程服务的服务消费方, 服务消费者在启动时, 向注册中心订阅自己所需的服务, 服务消费者, 从提供者地址列表中, 基于软负载均衡算法, 选一台提供者进行调用, 如果调用失败, 再选另一台调用。
• 注册中心（Registy）：注册中心返回服务提供者地址列表给消费者, 如果有变更, 注册中心将基于长连接推送变更数据给消费者。
• 监控中心：服务消费者和提供者, 在内存中累计调用次数和调用时间, 定时每分钟发送一次统计数据到监控中心。

8.5、zookeeper

zookeeper 是注册中心

1. 下载 zookeeper
   https://downloads.apache.org/zookeeper/
2. 修改配置文件名称
   修改 apache-zookeeper-3.6.3-bin/conf/zoo_sample.cfg 名称为 zoo.cfg
3. 启动 zookeeper
   windows 下密令：双击 apache-zookeeper-3.6.3-bin/bin/zkServer.cmd
4. 可以启动客户端连接
   windows 下密令：双击 apache-zookeeper-3.6.3-bin/bin/zkCli.cmd

8.6、dubbo-admin

dubbo-admin 是一个监控管理后台，查看我们注册了哪些服务，哪些服务被消费了

1. 下载 dubbo-admin
   https://github.com/apache/dubbo-admin/tree/master
2. 进入到项目中打包

• dubbo-admin-master 目录下打开 cmd
• 执行打包密令 mvn clean package -D maven.test.skip=true
• 启动 dubbo-admin 项目
• 启动 jar 包密令：java -jar xxx.jar
• 访问 localhost:7001 (默认端口 7001)

8.7、springboot 整合 dubbo+zookeeper

1. 启动 zookeeper 注册中心
   默认端口号是 2181
2. 提供者提供服务。
   1. 导入依赖。

 <dependency>
     <groupId>org.apache.dubbogroupId>
     <artifactId>dubbo-spring-boot-starterartifactId>
     <version>2.7.3version>
 dependency>
 
 <dependency>
     <groupId>com.github.sgroschupfgroupId>
     <artifactId>zkclientartifactId>
     <version>0.1version>
 dependency>
 
 <dependency>
     <groupId>org.apache.curatorgroupId>
     <artifactId>curator-frameworkartifactId>
     <version>5.1.0version>
 dependency>
 <dependency>
     <groupId>org.apache.curatorgroupId>
     <artifactId>curator-recipesartifactId>
     <version>5.1.0version>
 dependency>
 <dependency>
     <groupId>org.apache.zookeepergroupId>
     <artifactId>zookeeperartifactId>
     <version>3.6.3version>
     
     <exclusions>
         <exclusion>
             <groupId>org.slf4jgroupId>
             <artifactId>slf4j-log4j12artifactId>
         exclusion>
     exclusions>
 dependency>

2. 配置注册中心地址，提供者提供的服务名，需要扫描的包

// application.yml
server:
   port: 8081
dubbo:
   application:
     name: provider-server # 注册的服务应用名称
   registry:
     address: zookeeper://localhost:2181 # 注册中心地址
   scan:
     base-packages: com.sywl.service # 哪些服务要被注册

3. 在想被注册的服务上面增加一个 dubbo 的@Service注解。

import org.apache.dubbo.config.annotation.Service;
// zookeeper：服务注册与发现
@Service //dubbo的@sevice注解：可以被扫描到，在项目一启动就自动注册到注册中心
public class TickerServiceImpl implements TicketService {
@Override
public String getTicket() {
 return "你好啊";
}
}

3. 消费者如何消费
   1. 导入依赖。

 <dependency>
     <groupId>org.apache.dubbogroupId>
     <artifactId>dubbo-spring-boot-starterartifactId>
     <version>2.7.3version>
 dependency>
 
 <dependency>
     <groupId>com.github.sgroschupfgroupId>
     <artifactId>zkclientartifactId>
     <version>0.1version>
 dependency>
 
 <dependency>
     <groupId>org.apache.curatorgroupId>
     <artifactId>curator-frameworkartifactId>
     <version>5.1.0version>
 dependency>
 <dependency>
     <groupId>org.apache.curatorgroupId>
     <artifactId>curator-recipesartifactId>
     <version>5.1.0version>
 dependency>
 <dependency>
     <groupId>org.apache.zookeepergroupId>
     <artifactId>zookeeperartifactId>
     <version>3.6.3version>
     
     <exclusions>
         <exclusion>
             <groupId>org.slf4jgroupId>
             <artifactId>slf4j-log4j12artifactId>
         exclusion>
     exclusions>
 dependency>

2. 配置注册中心地址，消费者自己的的服务名。

// application.yml
server:
   port: 8082
dubbo:
   application:
         name: consumer-server # 消费者去拿服务需要暴露自己的名字
   registry:
         address: zookeeper://localhost:2181 # 注册中心地址

3. 从远程注入服务@Reference

import org.springframework.stereotype.Service;
@Service // 注入容器
public class UserService {
// 去注册中心拿provider-server提供的票
@Reference //引用（远程调用），需要定义服务提供者路径相同的接口名
TicketService tiketService;
public void buyTiket(){
 String ticket = tiketService.getTicket();
 System.out.println("在注册中心拿到服务："+ ticket);
}
}