[toc]

SpringBoot入门

  • 其实人们把Spring Boot称为**搭建程序的脚手架**。其最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让我们关注于业务而非配置。
  • 我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。
  • 解决java复杂的配置和混乱的依赖管理

1. springboot项目中引入依赖

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

  • 需要使用什么模块，需要引入什么启动器！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?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>cn.itbuild</groupId>
    <artifactId>spring-boot</artifactId>
    <version>1.0-SNAPSHOT</version>


    <!--所有的springboot的工程都以spring父工程为父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <!--点进去，有定义的依赖，依赖里面的<artifactId>spring-boot-dependencies</artifactId>
            定义了各种依赖的版本和启动器
			-->
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>

    
    <!--引入依赖-->
    <dependencies>
        <!--
			为了让SpringBoot帮我们完成各种自动配置，我们必须引入SpringBoot提供的自动配置依赖，
			我们称为`启动器`。spring-boot-starter-parent工程将依赖关系声明为一个或者多个启动器，
			我们可以根据项目需求引入相应的启动器，因为我们是web项目，这里我们引入web启动器：
			-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <!--同名的也有个Alibaba的-->
            <groupId>com.github.drtrang</groupId>
            <artifactId>druid-spring-boot2-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

    </dependencies>
    
</project>

2. springboot入门体验

2.1 SpringMVC环境的搭建

HelloSpingBoot.java

  • @GetMapping == @RequestMapping(value = "/show",method=RequestMethod.GET)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/**
 * 如果不添加
 * @EnableAutoConfiguration会报错
 * Unable to start ServletWebServerApplicationContext due to
 * missing ServletWebServerFactory bean.
 * 开启spring应用程序的自动配置，SpringBoot基于你所添加的依赖
 * 和你自己定义的bean，试图去猜测并配置你想要的配置。比如我们
 * 引入了`spring-boot-starter-web`，而这个启动器中帮我们添加了
 * `tomcat`、`SpringMVC`的依赖。此时自动配置就知道你是要开发一
 * 个web应用，所以就帮你完成了web及SpringMVC的默认配置了！
 *
 *这里没有添加时因为TestApplication.java（在上一目录下）中已经有（这里复制的是多个SpringMVC模块下的代码）
 *  @SpringBootApplication
 *   ||
 * @ComponentScan("指定扫描目录")
 *	  +
 * @EnableAutoConfiguration
 *
* */

@RestController
@RequestMapping("/hello")
public class HelloSpringBoot {

    @Autowired
    private DataSource dataSource;

    /**
     * @GetMapping == @RequestMapping(value = "/show",method=RequestMethod.GET)
     */
    @GetMapping("/show")
    public String show(){
        return "hello itbuild";
    }

    // 仅仅测试
    public static void main(String[] args) {
        SpringApplication.run(HelloSpringBoot.class,args);
    }

}

2.2 多个SpringMVC模块情况下

  • 难道要在每一个Controller中都添加一个main方法和**@EnableAutoConfiguration**注解，这样启动一个springboot程序也太麻烦了。也无法同时启动多个Controller，因为每个main方法都监听8080端口。所以，一个springboot程序应该只有一个springboot的main方法。

  • 所以，springboot程序引入了一个全局的引导类—TestApplication.java

  • @ComponentScan去扫描controller，==如果不指定BasePackage,那么他就会大扫描当前的启动类同级以及子目录下的所有类。==
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * @ComponentScan去扫描controller
 * 如果不指定BasePackage,那么他就会大扫描当前的启动类同级以及子目录下的所有类
 * @ComponentScan组件扫描器
 *
 * @ComponentScan("指定扫描目录")
 * @EnableAutoConfiguration
 *				||
 * 两个可以整合成@SpringBootApplication，其包含了组件扫描和自动配置
 *
 * */

@SpringBootApplication
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class,args);
    }
}
/*
*添加过引导类之后，HelloSpingBoot.java中的main方法就可以删除
*了
**/

@SpringBootApplication组合注解，其实就是以下三个注解的总和

  • @Configuration： 用于定义一个配置类，相当于配置文件
  • @EnableAutoConfiguration ：Spring Boot会自动根据你jar包的依赖来自动配置项目。
  • @ComponentScan： 告诉Spring 哪个packages 的用注解标识的类 会被spring自动扫描并且装入ioc容器。

3. 连接配置数据库

回顾Spring2.0时代的

  • Spring-dao.xml
  • properties.properties
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
">

    <context:property-placeholder location="classpath:application.properties"></context:property-placeholder>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClassName" value="${jdbc.driverClassName}"></property>
    </bean>
</beans>

3.1 Spring3.0-SpringBoot

1. 在pom.xml中，引入Druid连接池依赖

1
2
3
4
5
6
<dependency>
    <!--同名的也有个Alibaba的-->
    <groupId>com.github.drtrang</groupId>
    <artifactId>druid-spring-boot2-starter</artifactId>
    <version>1.1.10</version>
</dependency>

2. 添加application.properties

1
2
3
4
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://cdb-o6r75r3g.bj.tencentcdb.com:10015/springboot
jdbc.username=root
jdbc.password=********(此处密码用*代替)

3. 配置数据源 JdbcConfiguration.java

  • @PropertySource("classpath:application.properties")
  • 通过@Value将外部的值动态注入到Bean中。
3.1 @Value属性注入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
 * @Configuration标志着当前类是配置类
 *
 *   <context:property-placeholder location="classpath:application.properties"></context:property-placeholder>
 *          ||
 *   @PropertySource("classpath:application.properties")
 *
 * */


@Configuration
@PropertySource("classpath:application.properties")
public class JdbcConfiguration {

    @Value("${jdbc.url}")
    String url;

    @Value("${jdbc.username}")
    String username;

    @Value("${jdbc.password}")
    String password;

    @Value("${jdbc.driverClassName}")
    String driverClassName;


    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        return dataSource;
    }
}
3.2 配置类注入–JdbcProperties.java

@ConfigurationProperties 当前注解 会直接从resources目录下读取application.properties配置文件

  • 无法指定配置文件的名称
  • 在类上通过@ConfigurationProperties注解声明当前类为属性读取类
  • prefix="jdbc"读取属性文件中，前缀为jdbc的值。
  • **@EnableConfigurationProperties(JdbcProperties.class) **
1
2
3
4
5
6
7
8
9
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
    // ... 略
    // getters 和 setters
}
3.2.1 @Autowired注入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {

    @Autowired
    private JdbcProperties jdbcProperties;

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbcProperties.getUrl());
        dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
        dataSource.setUsername(jdbcProperties.getUsername());
        dataSource.setPassword(jdbcProperties.getPassword());
        return dataSource;
    }

}
3.2.2 构造函数注入
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {

    private JdbcProperties jdbcProperties;

    public JdbcConfiguration(JdbcProperties jdbcProperties){
        this.jdbcProperties = jdbcProperties;
    }

    @Bean
    public DataSource dataSource() {
        // 略
    }

}
3.2.3 @Bean方法的参数注入

@Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {

    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbcProperties.getUrl());
        dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
        dataSource.setUsername(jdbcProperties.getUsername());
        dataSource.setPassword(jdbcProperties.getPassword());
        return dataSource;
    }
}
3.3 更优雅的注入

事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties）中。而是直接在需要的地方声明即可：

1
2
3
4
5
6
7
8
9
10
11
@Configuration
public class JdbcConfiguration {
    
    @Bean
    // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

我们直接把@ConfigurationProperties(prefix = "jdbc")声明在需要使用的@Bean的方法上，然后SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：该类必须有对应属性的set方法！

☆☆