springboot学习教程 springboot详细入门

一、springboot简介

Spring Boot是用一些固定的方式来构建生产级别的spring应用。Spring Boot 推崇约定大于配置的方式以便于你能够尽可能快速的启动并运行程序。

简单点说：Spring Boot 称为搭建程序的脚手架。其最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让我们关注业务而非配置。

通俗的说：Spring Boot就是用来帮我们搭建spring项目的一个工具。以前我们花一天时间搭建的spring项目，现在加一个启动器，保存后idea会自动下载相应的jar包，我们直接执行main方法就可以执行了。

二、快速入门

1：创建新项目

2：选择一个空的工程

点击Finish，生成一个什么也没有的空项目

3：创建一个Module。使用maven构建

输入坐标

目录结构：

Finish创建完成的项目结构

4：引用依赖

      此时该项目跟springboot没有任何关系，需要引入相关依赖。

      SpringBoot提供了一个名为spring-boot-starter-parent的工程，里面已经对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，不用关心依赖的版本问题，需要什么依赖，直接引入坐标即可！

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

       为了让SpringBoot帮我们完成各种自动配置，我们必须引入SpringBoot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器：

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

   管理JDK版本

<properties>
        <java.version>1.8</java.version>
    </properties>

到这里我们springboot的pom依赖就配置完成了，pom完整代码如下：

<?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.dwh</groupId>
    <artifactId>spring-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 管理jdk版本 -->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <!-- 依赖父项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>

    <!-- 添加web启动器 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 需要其他相关启动器，在该节点下添加即可 -->
    </dependencies>

</project>

5：创建启动类：

Spring Boot项目通过main函数即可启动，我们需要创建一个启动类：

名字的命名为某某Application的格式，比如SpringbootApplication。

编写们main方法，加上springboot启动类注解，表示当前类为启动类。通过main方法启动springboot项目。

package com.springboot;

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

@SpringBootApplication
public class SpringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }

}

到这里我们就可以像以前那样开发SpringMVC的项目了。编写测试controller，注意，controller要写在启动类的同包以及子包下，这样spring就会自动扫描controller并自动注入。结构如下：

Controller代码：

package com.springboot.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    //@RestController注解相当于@ResponseBody ＋ @Controller合在一起的作用。

    //@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。该注解将HTTP Get 映射到 特定的处理方法上。
    @GetMapping("hello")
    public String hello(){
        //该方法只接受get请求
        return "hello, spring boot!";
    }
}

到这里我们的第一个springboot项目就创建完成了，接下来就是测试：在启动类中右键运行main方法，我们来解读一下启动信息

我们可以看到，最后一行提示我们启动的端口为8080，那我们的测试路径就为：localhost:8080/hello

浏览器访问，成功：

三、springboot的Java配置

Spring1.0时代 

在此时因为jdk1.5刚刚出来，注解开发并未盛行，因此一切Spring配置都是xml格式，所有的bean都用xml配置，十分繁琐。

Spring2.0时代

Spring引入了注解开发，但是因为并不完善，因此并未完全替代xml，此时的程序员往往是把xml与注解进行结合，我们之前都是这种方式。

Spring3.0及以后

3.0以后Spring的注解已经非常完善了，因此Spring推荐大家使用完全的java配置来代替以前的xml，不过似乎在国内并未推广盛行。然后当SpringBoot来临，人们才慢慢认识到java配置的优雅。

 

尝试java配置

java配置主要靠java类和一些注解，比较常用的注解有：

• @Configuration：声明一个类作为配置类，代替xml文件
• @Bean：声明在方法上，将方法的返回值加入Bean容器，代替<bean>标签
• @value：属性注入
• @PropertySource：指定外部属性文件

接下来用java配置来尝试实现连接池配置：

首先引入Druid连接池依赖： 在pom文件<dependencies></dependencies>节点下添加如下代码

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

创建一个jdbc.properties文件，填写jdbc属性,路径在resources下：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=123456

创建配置类，完成Java配置连接数据库，在controller同级目录下，创建配置包，config，创建类JdbcConfig.java，结构如下

JdbcConfig.java代码如下：

package com.springboot.config;

import com.alibaba.druid.pool.DruidDataSource;
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 javax.sql.DataSource;

@Configuration          //@Configuration：声明我们JdbcConfig是一个配置类
@PropertySource("classpath:jdbc.properties")        //@PropertySource：指定属性文件的路径是:classpath:jdbc.properties
public class JdbcConfig {

    @Value("${jdbc.url}")   //@Value为属性注入值
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean       // @Bean注解：将 dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。
    public DataSource dataSource() {
        //这段跟之前xml配置的原理是一样的，只不过xml是通过配置文件的形式，这里用的Java配置方式
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

到这里数据库连接池的Java配置完成了，我们在TestController中测试一下：

@RestController
public class TestController {
    //@RestController注解相当于@ResponseBody ＋ @Controller合在一起的作用。

    @Autowired
    private DataSource dataSource;  //将DataSource注入到当前类

    //@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。该注解将HTTP Get 映射到 特定的处理方法上。
    @GetMapping("hello")
    public String hello(){
        //该方法只接受get请求
        return "hello, spring boot!"+dataSource;
    }
}

运行项目，请求该方法，如下图，注入成功：

接下来我们了解下SpringBoot的属性注入：

在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。在SpringBoot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

新建一个类，用来进行属性注入，在config目录下创建：

package com.springboot.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {

    //- 在类上通过@ConfigurationProperties注解声明当前类为属性读取类
    //- prefix="jdbc"读取属性文件中，前缀为jdbc的值。
    //- 在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致
    //- 需要注意的是，这里我们并没有指定属性文件的地址，
    // 所以我们需要把jdbc.properties名称改为application.properties，这是SpringBoot默认读取的属性文件名：或者新建，防止之前的测试报错

    private String url;
    private String driverClassName;
    private String username;
    private String password;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

使用@ConfigurationProperties(prefix = "jdbc")注解时，idea提醒我们需要引入一个依赖，在pom文件加入

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

现在我们更改一下JdbcConfig.java，用新的方式注入，将之前的注入注释掉：

package com.springboot.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

//@Configuration          //@Configuration：声明我们JdbcConfig是一个配置类
//@PropertySource("classpath:jdbc.properties")        //@PropertySource：指定属性文件的路径是:classpath:jdbc.properties
@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {

   /* @Value("${jdbc.url}")   //@Value为属性注入值
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean       // @Bean注解：将 dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。
    public DataSource dataSource() {
        //这段跟之前xml配置的原理是一样的，只不过xml是通过配置文件的形式，这里用的Java配置方式
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }*/

    @Bean
    public DataSource dataSource(JdbcProperties jdbc) {
        //@EnableConfigurationProperties(JdbcProperties.class)来声明要使用JdbcProperties这个类的对象,这里通过方法参数注入
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        dataSource.setUsername(jdbc.getUsername());
        dataSource.setPassword(jdbc.getPassword());
        return dataSource;
    }
}

重新启动，调用之前的测试方法，即可

 

前面说的这么多，感觉还是很繁琐对吧，接下来，我们就见识一下springboor的自动注入的魅力：

之前的配置方式全部抛弃掉，只需要这样一段代码即可完成Java配置方式的注入：

package com.springboot.config;

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 JdbcConfig {
    @Bean
    @ConfigurationProperties(prefix = "jdbc")
    // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
    public DataSource dataSource() {
        //@ConfigurationProperties(prefix = "jdbc")声明在需要使用的@Bean的方法上，然后SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。
        // 使用的前提是：该类必须有对应属性的set方法！
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

用@Configuration声明一个配置类，在方法上 使用@ConfigurationProperties(prefix = "")注解，prefix声明属性注入的前缀，springboot就会自动帮我们把对应的属性注入到Bean里面。

四、springboot总结

SpringBoot为我们提供了默认配置，而默认配置生效的条件一般有两个：

• 引入了相关依赖
• 自己没有配置

启动器

如果不想配置，只需要引入依赖即可，而依赖版本我们也不用操心，因为只要引入了SpringBoot提供的stater（启动器），就会自动管理依赖及版本了。

          因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器，等下我会给出链接下载参考。

全局配置

SpringBoot的默认配置，都会读取默认属性，而这些属性可以通过自定义application.properties文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。

因此，玩SpringBoot的第二件事情，就是通过application.properties来覆盖默认属性值，形成自定义配置。我们需要知道SpringBoot的默认属性key，非常多，等下也会给出链接下载参考。注：修改tomcat启动的端口号就可以通过修改application.properties文件中定义的端口号即可同步需改。