springboot入门

Spring Boot概述

什么是Spring Boot

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。简单的来说 Spring Boot 这个项目整合目前很多的流行的第三方框架,并且做了一系列的默认配置,我们无需在进行手动配置,直接拿过来直接使用! 比如我们要使用 Spring mvc 开发 web 应用,那么我们可能需要经过以下几步

  • 导入 spring mvc 的相关依赖包
  • 在 web.xml 文件中配置 Spring mvc 的前端控制器
  • 创建一个 spring mvc 的配置文件
  • 在 spring mvc 的配置文件中进行相关配置
  1. 配置注解扫描路径
  2. 配置处理器映射器
  3. 配置处理器适配器
  4. 配置视图解析器
  • 开发 Controller

那么现在如果我们使用 Spring Boot 开发我们的 web 应用,那么具体的步骤如下:

  • 导入相关的依赖包
  • 开发 Controller
    单单从开发步骤上讲都比我们的原始开发少了很多,其中的配置部分 Spring Boot 帮我们完成了,不需要我们在进行配置,当然如果我们想
    更改 Spring Boot 的默认配置也是可以的.极大的简化了我们的开发.

Spring Boot 的核心功能

  • 独立运行的 spring 项目: Spring Boot 可以以 jar 包形式直接运行，如 java -jar xxx.jar 优点是：节省服务器资源
  • 内嵌 servlet 容器: Spring Boot 可以选择内嵌 Tomcat，Jetty，这样我们无须以 war 包形式部署项目。
  • 提供 starter 简化 Maven 配置: 在 Spring Boot 项目中为我们提供了很多的 spring-boot-starter-xxx 的项目(我们把这个依赖可以称之为
    起步依赖),我们导入指定的这些项目的坐标,就会自动导入和该模块相关的依赖包:
    例如我们后期再使用 Spring Boot 进行 web 开发我们就需要导入 spring-boot-starter-web 这个项目的依赖,导入这个依赖以后!那么
    Spring Boot 就会自动导入 web 开发所需要的其他的依赖包,如下图所示:
  • 自动配置 spring: Spring Boot 会根据在类路径中的 jar 包，类，为 jar 包里的类自动配置 Bean，这样会极大减少我们要使用的配置。
    当然 Spring Boot 只考虑了大部分开发场景，并不是所有的场景，如果在实际的开发中我们需要自动配置 Bean，而 Spring Boot 不
    能满足，则可以自定义自动配置。
  • 准生产的应用监控: Spring Boot 提供基于 http，ssh，telnet 对运行时的项目进行监控
  • 无代码生成和 xml 配置: Spring Boot 大量使用 spring4.x 提供的注解新特性来实现无代码生成和 xml 配置。spring4.x 提倡使用 Java
    配置和注解配置组合，而 Spring Boot 不需要任何 xml 配置即可实现 spring 的所有配置。

Spring Boot 的优点和缺点

优点

  • 快速构建项目
  • 对主流框架无缝集成
  • 项目可以独立运行，无需依赖外部 servlet 容器
  • 提供运行时的应用监控
  • 极大提高了开发，部署效率

缺点

  • 资料相对比较少
  • 版本迭代较快

Spring Boot 入门案例

使用 Spring Boot 开发 web 应用

在 pom.xml 添加依赖

在 pom.xml 文件我们需要添加两部分的依赖:

  • 让我们的项目继承 spring-boot-starter-parent 的工程
  • 加入 spring-boot-starter-web 的依赖
<!-- 添加父工程 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.9.RELEASE</version>
</parent>
<dependencies>
<!-- 加入web开发的支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

Spring Boot 项目默认的编译版本是 1.6,如果我们想使用 1.7 的编译版本我们就需要在 pom.xml 文件中定义一个变量

<!-- 定义变量 -->
<properties>
<java.version>1.7</java.version>
</properties>

新建controller

HelloController.java

package com.itheima.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "hello springboot";
    }
}

新建启动类

package com.itheima.springboot.controller;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//设置springboot启动类
@SpringBootApplication
public class HelloSpringBootApplication {

    public static void main(String[] args) {
        
        //启动应用
        SpringApplication.run(HelloSpringBootApplication.class, args);
        
    }
}

访问

localhost:8080/hello

以jar包方式运行

pom.xml

<build>
        <plugins>
            <!-- Spring Boot的maven插件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

maven-run-build...-输入命令：package，以命令行运行jar

Spring Boot核心

无 xml 配置的实现

自从 spring3.0 以后 spring 提供了很多的注解来替代 xml 文件的配置.最为核心的是下面的两个注解:

  • @Configuration 标注该类是一个配置类.类似于我们定义的 applicationContext.xml
  • @Bean 类似于我们在之前的 spring 配置文件中配置的<bean id=”” class=””/>

有了上面的两个注解我们就可以使用编码的方式来完成 spring 的相关配置,接下来我们就来使用 java 编码的方式来完成 spring 的配置

入门Demo
  1. 导入相关依赖

pom.xml

<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.itheima</groupId>
    <artifactId>itheima-javaconfig</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <spring.version>4.3.7.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!-- Spring依赖包 -->
        <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-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
    
    
    
    <build>
        <plugins>
            <!-- maven的编译插件 -->
            <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.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
            </plugin>
        </plugins>
    </build>
    
</project>

HelloService.java

package com.itheima.javaconfig.service;

public class HelloService {
    
    public String sayHello(){
        return "Hello JavaConfig";
    }

}

配置类ApplicationConfiguration.java

package com.itheima.javaconfig.service;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration    //相当于我们定义了一个applicationContext.xml文件
public class ApplicationConfiguration {

    @Bean // 相当于我们在配置文件中定义了一个bean
    public HelloService helloService() {
        return new HelloService() ;
    }

}

测试类JavaConfigTest.java

package com.itheima.javaconfig.service;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class JavaConfigTest {

    public static void main(String[] args) {
        // 通过AnnotationConfigApplicationContext这个类获取Spring容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ApplicationConfiguration.class);
        
        //从spring容器获取bean
        HelloService helloService = applicationContext.getBean(HelloService.class);
        
        //调用sayHello方法
        String result = helloService.sayHello() ;
        System.out.println(result);
        }

}
练习(配置 JdbcTemplate)

需求使用 JdbcTemplate 查询所有的用户数据
导入 user.sql 脚本文件

pom.xml

<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.itheima</groupId>
    <artifactId>itheima-javaconfig-jdbctemplate</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <druid.version>1.1.6</druid.version>
        <mysql.version>5.1.44</mysql.version>
        <spring.version>4.3.7.RELEASE</spring.version>
    </properties>

    <dependencies>
        <!-- 加入spring-jdbc的依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 加入druid的数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!-- 加入mysql的驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- Spring依赖包 -->
        <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-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- maven的编译插件 -->
            <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.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
            </plugin>
        </plugins>
    </build>


</project>

创建javabean
User.java

package com.itheima.javaconfig.domain;

public class User {

    
    private Integer id ; // 唯一标识
    
    private String userName ; // 用户名
    
    private String sex ; // 性别
    
    private String address ; // 住址

    /**
     * @return id
     */
    public Integer getId() {
        return id;
    }

    /**
     * @return userName
     */
    public String getUserName() {
        return userName;
    }

    /**
     * @return sex
     */
    public String getSex() {
        return sex;
    }

    /**
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * @param id 要设置的 id
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * @param userName 要设置的 userName
     */
    public void setUserName(String userName) {
        this.userName = userName;
    }

    /**
     * @param sex 要设置的 sex
     */
    public void setSex(String sex) {
        this.sex = sex;
    }

    /**
     * @param address 要设置的 address
     */
    public void setAddress(String address) {
        this.address = address;
    }

    /* （非 Javadoc）
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return "User [id=" + id + ", userName=" + userName + ", sex=" + sex + ", address=" + address + "]";
    }

    public User(Integer id, String userName, String sex, String address) {
        super();
        this.id = id;
        this.userName = userName;
        this.sex = sex;
        this.address = address;
    }

    public User() {
        super();
        // TODO 自动生成的构造函数存根
    }
    
    

}

db.properties

jdbcDriverClassName=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/spring-boot
jdbcUserName=root
jdbcPassword=suntong

编写配置类

JdbcTemplateConfiguration.java

package com.itheima.javaconfig;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.JdbcTemplate;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration
@PropertySource("classpath:db.properties")
public class JdbcTemplateConfiguration {
    
    @Value("${jdbcDriverClassName}")
    private String driverClassName;
    
    @Value("${jdbcUrl}")
    private String jdbcUrl;
    
    @Value("${jdbcUserName}")
    private String jdbcUserName;
    
    @Value("${jdbcPassword}")
    private String jdbcPassword;

    

    /**
     * 配置数据源
     * 
     * @return
     */
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(jdbcUrl);
        dataSource.setUsername(jdbcUserName);
        dataSource.setPassword(jdbcPassword);
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        return jdbcTemplate;
    }
}

编写测试类
JdbcTemplateJavaConfigTest.java

package com.itheima.javaconfig;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import com.itheima.javaconfig.domain.User;

public class JdbcTemplateJavaConfigTest {

    public static void main(String[] args) {
        // 获取spring容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(JdbcTemplateConfiguration.class);
        // 获取JdbcTemplate
        JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class);
        // 进行查询
        List<User> users = jdbcTemplate.query("select * from user", new RowMapper<User>(){
        
            @Override
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                //创建User对象
                User user = new User();
                
                user.setId(rs.getInt("id"));
                user.setUserName(rs.getString("username"));
                user.setSex(rs.getString("sex"));
                user.setAddress(rs.getString("address"));
                return user;
            }
        }) ;
        
        // 输出
        System.out.println(users);
    }
}

以上就是通过spring3.0之后提供的注解方式实现无xml配置。

接下来看怎么实现的自动化配置。

自动化配置

编写入门案例的时候我们使用的是 Spring mvc 作为我们的表现层框架,但是要使用 Spring mvc 我们就需要在web.xml 文件中配置 Spring mvc 的前端控制器(DispatcherServlet). 但是我们刚才在编写入门案例的时候我们并没有去做任何的配置.那么接下来我们就来讲解一下 Spring Boot 中自动配置的原理.

入口类和@SpringBootApplication

Spring Boot 的项目一般都会有*Application 的入口类，入口类中会有 main 方法，这是一个标准的 Java 应用程序的入口方法。Spring Boot会自动扫描@SpringBootApplication 所在类的同级包以及下级包中的 bean(如果是 jpa 项目还会自动扫描标注@Entity 的实体类)
@SpringBootApplication 注解是 Spring Boot 的核心注解

以上为该注解的源码，在其中还有很多的注解，所以@SpringBootAplication称为组合注解

组合注解作用就是简化我们的注解使用: 我们在某一个类上使用了@SpringBootApplication
那么就相当于在该类上使用了该注解上定义的其他的三个注解

@SpringBootConfiguration(注意不是SpringBootApplication)

@SpringBootConfiguration 这是 Spring Boot 项目的配置注解，源码如下:

这个注解也是一个组合注解, 在 Spring Boot 项目中推荐使用@ SpringBootConfiguration 替代@Configuration

@EnableAutoConfiguration

启用自动配置，该注解会使 Spring Boot 根据项目中类路径依赖的 jar 包自动配置项目的配置项：例如: 我们添加了 spring-boot-starter-web
依赖,会自动添加会自动添加 tomcat 和 springmvc 的依赖

那么 spring boot 项目会自动为我们配置 tomcat 和 springmvc; 具体体现在tomcat的配置使用的是8080 端口,Springmvc请求处理方式为 /

@ComponentScan

默认扫描@SpringBootApplication 所在类的同级目录以及它的子目录(所以之前的案例中把controller放到和启动类同一个包下)

DispatcherServlet 自动配置分析

DispatcherServlet 自动配置源码解析

入门案例中我们只是加入了 spring-boot-starter-web 这么一个依赖,就可以实现 DispatcherServlet 的相关配置,这是为什么呢?注意当我们加
入了 spring-boot-starter-web 的依赖以后,根据 maven 的依赖传递特性,会自动将一些依赖包加入到我们的项目中; 比如会自动添加 tomcat
和 springmvc 的依赖:

那么这些依赖包的确加入到了我们的项目中,那么怎么完成的自动配置呢? 因为在加入 spring-boot-starter-web 依赖的时候,会自动将另外
一个依赖加入进来: 这个依赖包就是

这个包中其实定义了很多技术点的自动配置

那么和我们 web 开发相关的自动配置类是在 web 包下,在这个 web 包中定义了很多的 xxxAutoConfiguration 这样的类,这些类其实就是用
来完成自动配置的; 我们打开 DispatcherServletAutoConfiguration 看看

上面的是关于 DispatcherServletAutoConfiguration 的定义,通过源码我们发现在这个类上定义了很多的好几个注解:

  • @AutoConfigureOrder: 这个注解自动配置的顺序定义,取值为 int 的最小值,优先级最高
  • @Configuration: 这个表示该类是一个配置类,类似于我们定义了一个 applicationContext.xml 文件
  • @ConditionalOnWebApplication: 这是一个条件注解,当前项目是 web 环境的条件下，启动自动化配置
  • @ ConditionalOnClass: 当前类路径下有指定的类的条件下，会启用自动化配置
  • @ AutoConfigureAfter: 定义该配置类的载入顺序;该类上表示(后于 EmbeddedServletContainerAutoConfiguration)载入

其实看到这里我们就可以明白,Spring Boot 中的自动配置其实使用的就是这些条件注解来完成的,当满足某一些添加以后就可以启动自动配置，条件注解时核心注解

常见的条件注解

自定义自动配置

需求: 自定义自动配置类,完成 HelloService 的自动配置(itheima-spring-starter-hello)

pom.xml

<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.itheima</groupId>
    <artifactId>itheima-autoconfig-helloservice</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <!-- 引入springboot自动配置的jar包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>1.5.9.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <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>
        </plugins>
    </build>

</project>

HelloService.java

package com.itheima.autoconfig.service;

public class HelloService {

    private final String DEFAULT_SAYWORD = "hello";

    public String sayHello(String sayWord) {
        if (sayWord != null && !sayWord.trim().equals("")) {
            return sayWord;
        }
        return DEFAULT_SAYWORD;
    }

}

编写配置类
HelloServiceAutoConfig.java


package com.itheima.autoconfig.service;

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(HelloService.class) //开启自动配置,如果类路径下有HelloService就启动这个自动化配置
public class HelloServiceAutoConfig {
    
    @Bean
    @ConditionalOnMissingBean(HelloService.class) //当spring容器没有HelloService的Bean时启用配置
    public HelloService helloService() {
            
        return new HelloService();
        
    }

}

注册自动配置类

在 src/main/resources 目录下创建一个: META-INF 这个文件夹,然后在该文件夹下创建一个文件: spring.factories; 内容如下

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.itheima.autoconfig.service.HelloServiceAutoConfig

Spring boot 项目在运行的时候会读取这个配置文件中的自动配置,来完成自动配置

编写测试工程

新建工程

pom.xml

<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.itheima</groupId>
    <artifactId>itheima-autoconfig-test</artifactId>
    <version>0.0.1-SNAPSHOT</version>


    <!-- 定义变量 -->
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <dependencies>
        <!-- 导入spring-boot-starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- 导入spring boot 测试的依赖包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 加入itheima-autoconfig-helloservice依赖 -->
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>itheima-autoconfig-helloservice</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>


</project>

测试类

AutoConfigApplication.java

package com.itheima.autoconfig;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.itheima.autoconfig.service.HelloService;

@SpringBootApplication
public class AutoConfigApplication {

    public static void main(String[] args) {
        //启动项目,返回spring容器
        ConfigurableApplicationContext applicationContext = SpringApplication.run(AutoConfigApplication.class, args);
        
        //获取bean
        HelloService helloService = applicationContext.getBean(HelloService.class);
        
        //调用
        String sayHello = helloService.sayHello(null);
        
        //输出
        System.out.println(sayHello);
        
    }
}

JUnit测试
SpringBootAutoConfigTest.java



import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.itheima.autoconfig.AutoConfigApplication;
import com.itheima.autoconfig.service.HelloService;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = AutoConfigApplication.class)
public class SpringBootAutoConfigTest {
    
    @Autowired
    private HelloService helloService;

    @Test
    public void testAutoConfig() {
        String sayHello = helloService.sayHello(null);
        System.out.println(sayHello);
    }
}

(注意在pom中配置的test依赖的scope是test，所以文件要放在test目录下)

关闭自动配置

如果我们不需要 Spring Boot 自动配置，想关闭某一项的自动配置，该如何设置呢？比如我们不想要 Spring Boot 为我们配置的
DispatcherServlet,如何完成呢?@SpringBootApplication(exclude = {DispatcherServletAutoConfiguration.class})

更改默认的配置

Spring Boot 使用一个全局的配置文件,这个全局配置文件为 application.properties 或者 application.yml; 放置在 src/main/resources 目录下,
这个全局配置文件的作用是对一些默认配置的配置值进行修改

比如我们可以更改 tomcat 的端口号: server.port=8088

我们也可以更改 springmvc 的拦截规则: server.servlet-path=*.do
测试: http://localhost:8088/hello.do
更多的配置参见资料(Spring Boot 常用配置.docx)

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,271评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,275评论 2赞 380
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,151评论 0赞 336
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,550评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,553评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,559评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,924评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,580评论 0赞 257
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,826评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,578评论 2赞 320
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,661评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,363评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,940评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,926评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,156评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,872评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,391评论 2赞 342

推荐阅读更多精彩内容