关于java:肝了一周总结的SpringBoot实战教程太实用了

天天在用 SpringBoot，但有些 SpringBoot 的实用知识点却不是很分明！最近又对 SpringBoot 中的实用知识点做了个总结，置信对从 Spring 过渡到 SpringBoot 的敌人会很有帮忙！

SpringBoot 实战电商我的项目 mall（40k+star）地址：https://github.com/macrozheng/mall

前言

首先咱们来理解下为什么要有 SpringBoot？

Spring 作为 J2EE 的轻量级代替品，让咱们无需开发重量级的 Enterprise JavaBean（EJB），通过依赖注入和面向切面编程，应用简略的 Java 对象（POJO）即可实现 EJB 的性能。

尽管 Spring 的组件代码是轻量级的，但它的配置却是重量级的。即便起初 Spring 引入了基于注解的组件扫描和基于 Java 的配置，让它看上去简洁不少，但 Spring 还是须要不少配置。除此之外，我的项目的依赖治理也很麻烦，咱们无奈确保各个版本的依赖都能兼容。

为了简化 Spring 中的配置和对立各种依赖的版本，SpringBoot 诞生了！

简介

SpringBoot 从实质上来说就是 Spring，它通过了一些本人的个性帮忙咱们简化了 Spring 应用程序的开发。次要有以下三个外围个性：

• 主动配置：对于很多 Spring 应用程序常见的利用性能，SpringBoot 能主动提供相干配置，集成性能开发者仅需很少的配置。
• 起步依赖：通知 SpringBoot 须要什么性能，它就能引入对应的库，无需思考该性能依赖库的版本问题。
• Actuator：能够深刻理解 SpringBoot 应用程序外部状况，比方创立了哪些 Bean、主动配置的决策、应用程序的状态信息等。

开始应用

创立利用

创立 SpringBoot 利用的形式有很多种，这里应用最风行的开发工具 IDEA 来创立利用。

• 首先通过 File->New Project 来创立一个我的项目；

• 而后抉择通过 Spring Initializr 来创立一个 SpringBoot 利用；

• 填写好 Maven 我的项目的 groupId 和artifactId及抉择好 Java 版本；

• 抉择好起步依赖，这里抉择的是开启 Web 性能的起步依赖；

• 抉择好我的项目的寄存地位即可顺利创立一个 SpringBoot 利用。

查看利用

我的项目构造

一个新创建的 SpringBoot 利用根本构造如下。

mall-tiny-boot
├─pom.xml # Maven 构建文件
└─src
   ├─main
   │  ├─java
   │  │  └─MallTinyApplication.java # 应用程序启动类
   │  └─resources
   │     └─application.yml # SpringBoot 配置文件
   └─test
       └─java
           └─MallTinyApplicationTests.java # 根本的集成测试类

利用启动类

MallTinyApplication在 SpringBoot 利用中有配置和疏导的作用，通过 @SpringBootApplication 注解开启组件扫描和主动配置，通过 SpringApplication.run() 疏导应用程序启动；

// 开启组件扫描和利用拆卸
@SpringBootApplication
public class MallTinyApplication {public static void main(String[] args) {
        // 负责疏导应用程序启动
        SpringApplication.run(MallTinyApplication.class, args);
    }

}

@SpringBootApplication注解是三个注解的结合体，领有以下三个注解的性能：

• @Configuration：用于申明 Spring 中的 Java 配置；
• @ComponentScan：启用组件扫描，当咱们申明组件时，会主动发现并注册为 Spring 利用上下文中的 Bean；
• @EnableAutoConfiguration：开启 SpringBoot 主动配置性能，简化配置编写。

测试利用

能够应用 @RunWith 和@SpringBootTest来创立 Spring 利用上下文，通过 @Test 注解来申明一个测试方法。

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class MallTinyApplicationTests {
    @Autowired
    private PmsBrandService pmsBrandService;

    @Test
    public void contextLoads() {}

    @Test
    public void testMethod() {List<PmsBrand> brandList = pmsBrandService.listAllBrand();
        log.info("testMethod:{}", brandList);
    }

}

编写利用配置

当咱们须要微调主动配置的参数时，能够在 application.yml 文件中进行配置，比方微调下端口号。

server:
  port: 8088

我的项目构建过程

SpringBoot 我的项目能够应用 Maven 进行构建，首先咱们须要继承 spring-boot-starter-parent 这个父依赖，父依赖能够管制所有 SpringBoot 官网起步依赖的版本，接下来当咱们应用官网起步依赖时，就不必指定版本号了。咱们还须要应用 SpringBoot 的插件，该插件次要用于将利用打包为可执行 Jar。

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.macro.mall</groupId>
    <artifactId>mall-tiny-boot</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>mall-tiny-boot</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <skipTests>true</skipTests>
    </properties>
    
    <!-- 继承 SpringBoot 父我的项目，管制所有依赖版本 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <!--SpringBoot 起步依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <!--SpringBoot 插件，能够把利用打包为可执行 Jar-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

应用起步依赖

应用起步依赖的益处

在应用起步依赖之前，咱们先来理解下应用起步依赖的益处，当咱们应用 SpringBoot 须要整合 Web 相干性能时，只需在 pom.xml 中增加一个起步依赖即可。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

如果是 Spring 我的项目的话，咱们须要增加很多依赖，还须要思考各个依赖版本的兼容性问题，是个相当麻烦的事件。

指定基于性能的依赖

当咱们须要开发一个 Web 利用，须要应用 MySQL 数据库进行存储，应用 Swagger 生成 API 文档，增加如下起步依赖即可。须要留神的是只有官网的起步依赖不须要指定版本号，其余的还是须要自行指定的。

<dependencies>
    <!--SpringBoot Web 性能起步依赖 -->
    <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>
    <!--MyBatis 分页插件 -->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper-spring-boot-starter</artifactId>
        <version>1.2.10</version>
    </dependency>
    <!-- 集成 druid 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    <!--Mysql 数据库驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.15</version>
    </dependency>
    <!--springfox swagger 官网 Starter-->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>3.0.0</version>
    </dependency>
</dependencies>

笼罩起步依赖中的库

其实起步依赖和你平时应用的依赖没什么区别，你能够应用 Maven 的形式来排除不想要的依赖。比方你不想应用 tomcat 容器，想应用 undertow 容器，能够在 Web 性能依赖中排除掉 tomcat。

<dependencies>
    <!--SpringBoot Web 性能起步依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <!-- 排除 tomcat 依赖 -->
            <exclusion>
                <artifactId>spring-boot-starter-tomcat</artifactId>
                <groupId>org.springframework.boot</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <!--undertow 容器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-undertow</artifactId>
    </dependency>
</dependencies>

应用主动配置

SpringBoot 的主动配置是一个运行时（更精确地说，是应用程序启动时）的过程，思考了泛滥因素，才决定 Spring 配置应该用哪个，不该用哪个。

举个例子，当咱们应用 Spring 整合 MyBatis 的时候，须要实现如下几个步骤：

• 依据数据库连贯配置，配置一个 dataSource 对象；
• 依据 dataSource 对象和 SqlMapConfig.xml 文件（其中蕴含 mapper.xml 文件门路和 mapper 接口门路配置），配置一个 sqlSessionFactory 对象。

当咱们应用 SpringBoot 整合 MyBatis 的时候，会主动创立 dataSource 和 sqlSessionFactory 对象，只需咱们在 application.yml 和 Java 配置中增加一些自定义配置即可。

在 application.yml 中配置好数据库连贯信息及 mapper.xml 文件门路。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: root

mybatis:
  mapper-locations:
    - classpath:mapper/*.xml
    - classpath*:com/**/mapper/*.xml

应用 Java 配置，配置好 mapper 接口门路。

/**
 * MyBatis 配置类
 * Created by macro on 2019/4/8.
 */
@Configuration
@MapperScan("com.macro.mall.tiny.mbg.mapper")
public class MyBatisConfig {}

应用主动配置当前，咱们整合其余性能的配置大大减少了，能够更加专一程序性能的开发了。

自定义配置

自定义 Bean 笼罩主动配置

尽管主动配置很好用，但有时候主动配置的 Bean 并不能满足你的须要，咱们能够本人定义雷同的 Bean 来笼罩主动配置中的 Bean。

例如当咱们应用 Spring Security 来爱护利用平安时，因为主动配置并不能满足咱们的需要，咱们须要自定义基于 WebSecurityConfigurerAdapter 的配置。这里咱们自定义了很多配置，比方将基于 Session 的认证改为应用 JWT 令牌、配置了一些门路的无受权拜访，自定义了登录接口门路，禁用了 csrf 性能等。

/**
 * SpringSecurity 的配置
 * Created by macro on 2018/4/26.
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UmsAdminService adminService;
    @Autowired
    private RestfulAccessDeniedHandler restfulAccessDeniedHandler;
    @Autowired
    private RestAuthenticationEntryPoint restAuthenticationEntryPoint;
    @Autowired
    private IgnoreUrlsConfig ignoreUrlsConfig;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {List<String> urls = ignoreUrlsConfig.getUrls();
        String[] urlArray = ArrayUtil.toArray(urls, String.class);
        httpSecurity.csrf()// 因为应用的是 JWT，咱们这里不须要 csrf
                .disable()
                .sessionManagement()// 基于 token，所以不须要 session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET,urlArray) // 容许对于网站动态资源的无受权拜访
                .permitAll()
                .antMatchers("/admin/login")// 对登录注册要容许匿名拜访
                .permitAll()
                .antMatchers(HttpMethod.OPTIONS)// 跨域申请会先进行一次 options 申请
                .permitAll()
                .anyRequest()// 除下面外的所有申请全副须要鉴权认证
                .authenticated();
        // 禁用缓存
        httpSecurity.headers().cacheControl();
        // 增加 JWT filter
        httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        // 增加自定义未受权和未登录后果返回
        httpSecurity.exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler)
                .authenticationEntryPoint(restAuthenticationEntryPoint);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {auth.userDetailsService(userDetailsService())
                .passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {return new BCryptPasswordEncoder();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        // 获取登录用户信息
        return username -> {AdminUserDetails admin = adminService.getAdminByUsername(username);
            if (admin != null) {return admin;}
            throw new UsernameNotFoundException("用户名或明码谬误");
        };
    }

    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {return new JwtAuthenticationTokenFilter();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {return super.authenticationManagerBean();
    }

}

主动配置微调

有时候咱们只须要微调下主动配置就能满足需要，并不需要笼罩主动配置的 Bean，此时咱们能够在 application.yml 属性文件中进行配置。

比方微调下利用运行的端口。

server:
  port: 8088

比方批改下数据库连贯信息。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: root

读取配置文件的自定义属性

有时候咱们会在属性文件中自定义一些属性，而后在程序中应用。此时能够将这些自定义属性映射到一个属性类里来应用。

比如说咱们想给 Spring Security 配置一个白名单，拜访这些门路无需受权，咱们能够先在 application.yml 中添增加如下配置。

secure:
  ignored:
    urls:
      - /
      - /swagger-ui/
      - /*.html
      - /favicon.ico
      - /**/*.html
      - /**/*.css
      - /**/*.js
      - /swagger-resources/**
      - /v2/api-docs/**

之后创立一个属性类，应用 @ConfigurationProperties 注解配置好这些属性的前缀，再定义一个 urls 属性与属性文件绝对应即可。

/**
 * 用于配置白名单资源门路
 * Created by macro on 2018/11/5.
 */
@Getter
@Setter
@Component
@ConfigurationProperties(prefix = "secure.ignored")
public class IgnoreUrlsConfig {private List<String> urls = new ArrayList<>();

}

Actuator

SpringBoot Actuator 的要害个性是在应用程序里提供泛滥 Web 端点，通过它们理解利用程序运行时的外部情况。

端点概览

Actuator 提供了大略 20 个端点，罕用端点门路及形容如下：

查看配置明细

• 间接拜访根端点，能够获取到所有端点拜访门路，根端点拜访地址：http://localhost:8088/actuator

{
    "_links": {
        "self": {
            "href": "http://localhost:8088/actuator",
            "templated": false
        },
        "beans": {
            "href": "http://localhost:8088/actuator/beans",
            "templated": false
        },
        "caches-cache": {"href": "http://localhost:8088/actuator/caches/{cache}",
            "templated": true
        },
        "caches": {
            "href": "http://localhost:8088/actuator/caches",
            "templated": false
        },
        "health": {
            "href": "http://localhost:8088/actuator/health",
            "templated": false
        },
        "health-path": {"href": "http://localhost:8088/actuator/health/{*path}",
            "templated": true
        },
        "info": {
            "href": "http://localhost:8088/actuator/info",
            "templated": false
        },
        "conditions": {
            "href": "http://localhost:8088/actuator/conditions",
            "templated": false
        },
        "configprops": {
            "href": "http://localhost:8088/actuator/configprops",
            "templated": false
        },
        "env": {
            "href": "http://localhost:8088/actuator/env",
            "templated": false
        },
        "env-toMatch": {"href": "http://localhost:8088/actuator/env/{toMatch}",
            "templated": true
        },
        "loggers": {
            "href": "http://localhost:8088/actuator/loggers",
            "templated": false
        },
        "loggers-name": {"href": "http://localhost:8088/actuator/loggers/{name}",
            "templated": true
        },
        "heapdump": {
            "href": "http://localhost:8088/actuator/heapdump",
            "templated": false
        },
        "threaddump": {
            "href": "http://localhost:8088/actuator/threaddump",
            "templated": false
        },
        "metrics-requiredMetricName": {"href": "http://localhost:8088/actuator/metrics/{requiredMetricName}",
            "templated": true
        },
        "metrics": {
            "href": "http://localhost:8088/actuator/metrics",
            "templated": false
        },
        "scheduledtasks": {
            "href": "http://localhost:8088/actuator/scheduledtasks",
            "templated": false
        },
        "mappings": {
            "href": "http://localhost:8088/actuator/mappings",
            "templated": false
        }
    }
}

• 通过 /beans 端点，能够获取到 Spring 利用上下文中的 Bean 的信息，比方 Bean 的类型和依赖属性等，拜访地址：http://localhost:8088/actuator/beans

{
    "contexts": {
        "application": {
            "beans": {
                "sqlSessionFactory": {"aliases": [],
                    "scope": "singleton",
                    "type": "org.apache.ibatis.session.defaults.DefaultSqlSessionFactory",
                    "resource": "class path resource [org/mybatis/spring/boot/autoconfigure/MybatisAutoConfiguration.class]",
                    "dependencies": ["dataSource"]
                },
                "jdbcTemplate": {"aliases": [],
                    "scope": "singleton",
                    "type": "org.springframework.jdbc.core.JdbcTemplate",
                    "resource": "class path resource [org/springframework/boot/autoconfigure/jdbc/JdbcTemplateConfiguration.class]",
                    "dependencies": [
                        "dataSource",
                        "spring.jdbc-org.springframework.boot.autoconfigure.jdbc.JdbcProperties"
                    ]
                }
            }
        }
    }
}

• 通过 /conditions 端点，能够获取到以后利用的主动配置报告，positiveMatches示意失效的主动配置，negativeMatches示意没有失效的主动配置。

{
    "contexts": {
        "application": {
            "positiveMatches": {
                "DruidDataSourceAutoConfigure": [{
                    "condition": "OnClassCondition",
                    "message": "@ConditionalOnClass found required class'com.alibaba.druid.pool.DruidDataSource'"
                }]
            },
            "negativeMatches": {
                "RabbitAutoConfiguration": {
                    "notMatched": [{
                        "condition": "OnClassCondition",
                        "message": "@ConditionalOnClass did not find required class'com.rabbitmq.client.Channel'"}],"matched": []}
            }
        }
    }
}

• 通过 /env 端点，能够获取全副配置属性，包含环境变量、JVM 属性、命令行参数和 application.yml 中的属性。

{"activeProfiles": [],
    "propertySources": [{
            "name": "systemProperties",
            "properties": {
                "java.runtime.name": {"value": "Java(TM) SE Runtime Environment"
                },
                "java.vm.name": {"value": "Java HotSpot(TM) 64-Bit Server VM"
                },
                "java.runtime.version": {"value": "1.8.0_91-b14"}
            }
        },
        {"name": "applicationConfig: [classpath:/application.yml]",
            "properties": {
                "server.port": {
                    "value": 8088,
                    "origin": "class path resource [application.yml]:2:9"
                },
                "spring.datasource.url": {
                    "value": "jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai",
                    "origin": "class path resource [application.yml]:6:10"
                },
                "spring.datasource.username": {
                    "value": "root",
                    "origin": "class path resource [application.yml]:7:15"
                },
                "spring.datasource.password": {
                    "value": "******",
                    "origin": "class path resource [application.yml]:8:15"
                }
            }
        }
    ]
}

• 通过 /mappings 端点，能够查看全副的 URI 门路和控制器或过滤器的映射关系，这里能够看到咱们本人定义的 PmsBrandController 和JwtAuthenticationTokenFilter的映射关系。

{
    "contexts": {
        "application": {
            "mappings": {
                "dispatcherServlets": {
                    "dispatcherServlet": [{"handler": "com.macro.mall.tiny.controller.PmsBrandController#createBrand(PmsBrand)",
                        "predicate": "{POST /brand/create}",
                        "details": {
                            "handlerMethod": {
                                "className": "com.macro.mall.tiny.controller.PmsBrandController",
                                "name": "createBrand",
                                "descriptor": "(Lcom/macro/mall/tiny/mbg/model/PmsBrand;)Lcom/macro/mall/tiny/common/api/CommonResult;"
                            },
                            "requestMappingConditions": {"consumes": [],
                                "headers": [],
                                "methods": ["POST"],
                                "params": [],
                                "patterns": ["/brand/create"],
                                "produces": []}
                        }
                    }]
                }
            },
            "servletFilters": [{"servletNameMappings": [],
                "urlPatternMappings": [
                    "/*",
                    "/*",
                    "/*",
                    "/*",
                    "/*"
                ],
                "name": "jwtAuthenticationTokenFilter",
                "className": "com.macro.mall.tiny.component.JwtAuthenticationTokenFilter"
            }]
        }
    }
}

查看运行时度量

• 通过 /metrics 端点，能够获取应用程序度量指标，不过只能获取度量的名称；

{
    "names": [
        "http.server.requests",
        "jvm.buffer.count",
        "jvm.buffer.memory.used",
        "jvm.buffer.total.capacity",
        "jvm.classes.loaded",
        "jvm.classes.unloaded",
        "jvm.gc.live.data.size",
        "jvm.gc.max.data.size",
        "jvm.gc.memory.allocated",
        "jvm.gc.memory.promoted",
        "jvm.gc.pause",
        "jvm.memory.committed",
        "jvm.memory.max",
        "jvm.memory.used",
        "jvm.threads.daemon",
        "jvm.threads.live",
        "jvm.threads.peak",
        "jvm.threads.states",
        "logback.events",
        "process.cpu.usage",
        "process.start.time",
        "process.uptime",
        "system.cpu.count",
        "system.cpu.usage"
    ]
}

• 须要增加指标名称能力获取对应的值，比方获取以后 JVM 应用的内存信息，拜访地址：http://localhost:8088/actuator/metrics/jvm.memory.used

{
    "name": "jvm.memory.used",
    "description": "The amount of used memory",
    "baseUnit": "bytes",
    "measurements": [
        {
            "statistic": "VALUE",
            "value": 3.45983088E8
        }
    ],
    "availableTags": [
        {
            "tag": "area",
            "values": [
                "heap",
                "nonheap"
            ]
        },
        {
            "tag": "id",
            "values": [
                "Compressed Class Space",
                "PS Survivor Space",
                "PS Old Gen",
                "Metaspace",
                "PS Eden Space",
                "Code Cache"
            ]
        }
    ]
}

• 通过 loggers 端点，能够查看应用程序中的日志级别信息，能够看出咱们把 ROOT 范畴日志设置为了 INFO，而 com.macro.mall.tiny 包范畴的设置为了 DEBUG。

{
    "levels": [
        "OFF",
        "ERROR",
        "WARN",
        "INFO",
        "DEBUG",
        "TRACE"
    ],
    "loggers": {
        "ROOT": {
            "configuredLevel": "INFO",
            "effectiveLevel": "INFO"
        },
        "com.macro.mall.tiny": {
            "configuredLevel": "DEBUG",
            "effectiveLevel": "DEBUG"
        }
    }
}

• 通过 /health 端点，能够查看利用的衰弱指标。

{"status": "UP"}

敞开利用

通过 POST 申请 /shutdown 端点能够间接敞开利用，然而须要将 endpoints.shutdown.enabled 属性设置为 true 才能够应用。

{"message": "Shutting down, bye..."}

定制 Actuator

有的时候，咱们须要自定义一下 Actuator 的端点能力满足咱们的需要。

• 比如说 Actuator 有些端点默认是敞开的，咱们想要开启所有端点，能够这样设置；

management:
  endpoints:
    web:
      exposure:
        include: '*'

• 比如说咱们想自定义 Actuator 端点的根底门路，比方改为/monitor，这样咱们咱们拜访地址就变成了这个：http://localhost:8088/monitor

management:
  endpoints:
    web:
      base-path: /monitor

罕用起步依赖

起步依赖不仅能让构建利用的依赖配置更简略，还能依据提供给应用程序的性能将它们组织到一起，这里整顿了一些罕用的起步依赖。

官网依赖

<dependencies>
    <!--SpringBoot 整合 Web 性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--SpringBoot 整合 Actuator 性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--SpringBoot 整合 AOP 性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <!--SpringBoot 整合测试性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--SpringBoot 整合注解解决性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    <!--SpringBoot 整合 Spring Security 平安性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!--SpringBoot 整合 Redis 数据存储性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--SpringBoot 整合 Elasticsearch 数据存储性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
    </dependency>
    <!--SpringBoot 整合 MongoDB 数据存储性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <!--SpringBoot 整合 AMQP 音讯队列性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <!--SpringBoot 整合 Quartz 定时工作性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>
    <!--SpringBoot 整合 JPA 数据存储性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!--SpringBoot 整合邮件发送性能依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-mail</artifactId>
    </dependency>
</dependencies>

第三方依赖

<dependencies>
    <!--SpringBoot 整合 MyBatis 数据存储性能依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis-version.version}</version>
    </dependency>
    <!--SpringBoot 整合 PageHelper 分页性能依赖 -->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper-spring-boot-starter</artifactId>
        <version>${pagehelper-starter.version}</version>
    </dependency>
    <!--SpringBoot 整合 Druid 数据库连接池性能依赖 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>${druid.version}</version>
    </dependency>  
    <!--SpringBoot 整合 Springfox 的 Swagger API 文档性能依赖 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>${springfox-version}</version>
    </dependency>
    <!--SpringBoot 整合 MyBatis-Plus 数据存储性能依赖 -->  
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>${mybatis-plus-version}</version>
    </dependency>
    <!--SpringBoot 整合 Knife4j API 文档性能依赖 --> 
    <dependency>
        <groupId>com.github.xiaoymin</groupId>
        <artifactId>knife4j-spring-boot-starter</artifactId>
        <version>${knife4j-version}</version>
    </dependency>        
</dependencies>

我的项目源码地址

https://github.com/macrozheng…

本文 GitHub https://github.com/macrozheng/mall-learning 曾经收录，欢送大家 Star！