SpringBoot入门篇

一    什么是springboot

Spring官网：http://spring.io/projects

SpringBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品:

Springboot不是什么真正意义上的新框架，就像maven整合了所有的jar包，spring boot整合了所有常用的框架。如果说我们现在用ssm框架是组装一台台式机，

springboot就是直接给你一台品牌机。可以近似地理解为我们现在用的ssm框架去掉xml配置。搭建完springboot框架后，用法几乎和现在完全一样，springmvc的注解，spring的ioc等等。

总结：spring boot最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少xml配置，做到迅速上手，让我们关注于业务而非配置。

二    快速入门

1. 我们直接来建一个springboot项目。

2 添加依赖

2.1添加父工程

SpringBoot提供了一个名为spring-boot-starter-parent的工程，里面对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，

这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标。

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

2.2添加web启动器

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

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

我们不需要在这里指定版本信息。因为SpringBoot的父工程已经对版本进行了管理了。这个时候，我们会发现项目中多出了大量的依赖：

这些都是SpringBoot根据spring-boot-starter-web这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。

2.3管理jdk版本

默认情况下，maven工程的jdk版本是1.5，而我们开发使用的是1.8，因此这里我们需要修改jdk版本，添加以下属性：

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

3 启动类

Springboot项目通过main函数启动：

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

4 controller

@RestController
public class HelloController {
    @GetMapping("hello")
    public String hello(){
        return "hello sb";
    }

}

5 测试

Run application

• 1）监听的端口是8080
• 2）SpringMVC的映射路径是：/
• 3）/hello路径已经映射到了HelloController中的hello()方法
• 4）访问http://localhost:8080/hello
• 

三 配置

上面没有做任何配置，就实现了一个springmvc项目。但是如果要配置一个bean怎么办？

Ssm中配置配置连接池是这样：

1 尝试java配置

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

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

首先引入连接池依赖：

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

创建properties：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/newapp
jdbc.username=root
jdbc.password=admin

配置类：

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

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

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

• @Configuration：声明JdbcConfig是一个配置类
• @PropertySource：指定属性文件的路径是:classpath:jdbc.properties
• 通过@Value为属性注入值
• 通过@Bean将 dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。

然后就可以在任意位置通过@Autowired注入DataSource。

测试：

@RestController
public class HelloController {

    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello() {
        return "hello,sb" + dataSource;
    }
}

2  Springboot的属性注入

1)新建一个类用来属性注入

@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {
    private String url;
    private String driverClassName;
    private String username;
    private String password;
   
    // getters 和 setters
}

• 在类上通过@ConfigurationProperties注解声明当前类为属性读取类
• prefix="jdbc"读取属性文件中，前缀为jdbc的值。
• 在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致
• 这里并没有指定属性文件的地址，所以需要把jdbc.properties名称改为application.properties，这是SpringBoot默认读取的属性文件名：
• ConfigurationProperties需引入依赖:

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

  2）在JdbcConfig中使用这个属性：

• @Configuration
  @EnableConfigurationProperties(JdbcProperties.class)
  public class JdbcConfig {
  
      @Bean
      public DataSource dataSource(JdbcProperties jdbc) {
          DruidDataSource dataSource = new DruidDataSource();
          dataSource.setUrl(jdbc.getUrl());
          dataSource.setDriverClassName(jdbc.getDriverClassName());
          dataSource.setUsername(jdbc.getUsername());
          dataSource.setPassword(jdbc.getPassword());
          return dataSource;
      }
  }

• 通过@EnableConfigurationProperties(JdbcProperties.class)来声明要使用JdbcProperties这个类的对象
• 然后可以通过以下方式注入JdbcProperties：
• a   @Autowired注入：

• @Autowired
  private JdbcProperties prop;

   b  构造函数注入

• private JdbcProperties prop;
  public JdbcConfig(Jdbcproperties prop){
          this.prop = prop;
  }

   c  声明有@Bean的方法参数注入  我们上面用的第三种。

总结：似乎更麻烦了，不过value只支持基本类型数据注入，而这种springboot推荐的方式，不严格要求属性文件中的属性名与成员变量名一致。支持驼峰，中划线，下划线等等转换，甚至支持对象引导。

比如：user.office.name：代表的是user对象中的office属性中的name属性，显然office也是对象。

3 更优雅的注入

如果一段属性，只有一个bean使用，不需要先注入到一个properties类中，可以直接在需要的地方声明：

@Configuration
public class JdbcConfig {
    
    @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方法。

4 自动配置的原理

我们看启动类：

 4.1SpringBootApplication注解

查看源码 又有三个注解：

4.1.1 SpringBootConfiguration

@Configuration标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中，并且实例名就是方法名。

@SpringBootConfiguration继承自@Configuration，二者功能也类似，是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

4.1.2  @EnableAutoConfiguration

官网说明：The second class-level annotation is @EnableAutoConfiguration. This annotationtells Spring Boot to “guess” how you want to configure Spring, based on the jardependencies t

hat you have added. Since spring-boot-starter-web added Tomcatand Spring MVC, the auto-configuration assumes that you are developing a webapplication and sets up Spring accordingly.

翻译：@EnableAutoConfiguration的作用启动自动的配置。该标签告诉SpringBoot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了spring-boot-starter-web，而这个启动器

中帮我们添加了tomcat、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了。

总结，SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效。

所以，我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了。除非你不希望使用SpringBoot的默认配置，它也提供了自定义配置的入口。

4.1.3 @ConponentScan

@ComponentScan，扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的<context:component-scan>（以前使用在xml中使用的标签，用来扫描包配置的平行支持）。

通过basePackageClasses和basePackages属性来扫描指定的包，如果没有属性值，将从声明这个注解的类所在的包开始，扫描包和子包。而@SpringBootApplication注解声明

的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中

4.2 默认配置的原理

4.2.1默认配置类

刚才说@EnableAutoConfiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置。那么问题是：

1）这些默认配置是在哪里定义的呢？

2）为何依赖引入就会触发配置呢？

其实刚才的项目中，已经引入了一个依赖：spring-boot-autoconfigure，其中定义了大量自动配置类：

非常多，几乎涵盖了现在主流的开源框架，例如：

• redis
• jms
• amqp
• jdbc
• jackson
• mongodb
• jpa
• solr
• elasticsearch

我们来看一个熟悉的，例如SpringMVC，查看mvc 的自动配置类：

进入WebMvcAutoConfiguration：

• @Configuration：声明这个类是一个配置类

• @ConditionalOnWebApplication(type = Type.SERVLET)

　　　　ConditionalOn，就是在某个条件下，此处就是满足项目的类是是Type.SERVLET类型，也就是一个普通web工程

　　   @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })

　　   这里的条件是OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中Servlet只要引入了tomcat依赖自然会有，后两个需要

　　   引入SpringMVC才会有。这里就是判断你是否引入了相关依赖，引入依赖后该条件成立，当前类的配置才会生效。

• @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

　　这个条件与上面不同，OnMissingBean，是说环境中没有指定的Bean这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个WebMVCConfigurationSupport的类，那么这个默认配置就会失效。

看一下类中定义的属性：

视图解析器：

处理器适配器：

4.2.2默认配置属性

默认配置的属性来自哪里：看这个静态内部类

这里通过@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和ResourceProperties。这也就是刚才说的SpringBoot的属性注入。

看看两个属性类：

WebMvcProperties里有内部资源视图解析器的prefix和suffix属性。

ResourceProperties中主要定义了静态资源（.js,.html,.css等)的路径。

如果我们要覆盖这些默认属性，只需要在application.properties中定义与其前缀prefix和字段名一致的属性即可。

5 总结

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

        a 引入相关依赖

        b 自己没有配置bean

1）启动器

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

2）全局配置

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

3）属性文件支持两种格式，application.properties和application.yml

推荐yml：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/xx
  username: root
  password: 123

server:
  port: 80

四   SpringBoot实践

现在我们用sb来实践ssm。

4.1 整合springmvc

默认配置已经可以使用springMvc，不过有时候需要自定义配置。

4.1.1 修改端口

server.port=80

4.1.2访问静态资源

项目是个jar项目，没有webapp，静态资源放哪儿？

在刚才ResourceProperties类中定义了默认静态资源默认查找路径：

• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public

我们习惯用第三种，尝试一下。

4.1.3添加拦截器

在SpringBoot官方文档中：

如果你想要保持Spring Boot 的一些默认MVC特征，同时又想自定义一些MVC配置（包括：拦截器，格式化器, 视图控制器、消息转换器 等等），你应该让一个类实现WebMvcConfigurer，并且添加@Configuration注解，但是千万不要加@EnableWebMvc注解。如果你想要自定义HandlerMapping、HandlerAdapter、ExceptionResolver等组件，你可以创建一个WebMvcRegistrationsAdapter实例 来提供以上组件。

如果你想要完全自定义SpringMVC，不保留SpringBoot提供的一切特征，你可以自己定义类并且添加@Configuration注解和@EnableWebMvc注解

也就是说：通过实现WebMvcConfigurer并添加@Configuration注解来实现自定义部分SpringMvc配置。

1）定义拦截器：

public class LoginInterceptor implements HandlerInterceptor {

    private Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        logger.debug("执行preHandle ");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        logger.debug("执行postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        logger.debug("执行afterCompletion ");
    }
}

2）定义配置类注册拦截器：

@Configuration
public class MvcConfig implements WebMvcConfigurer{
    /**
     * 通过@Bean注解，将我们定义的拦截器注册到Spring容器
     * @return
     */
    @Bean
    public LoginInterceptor loginInterceptor(){
        return new LoginInterceptor();
    }

    /**
     * 重写接口中的addInterceptors方法，添加自定义拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通过registry来注册拦截器，通过addPathPatterns来添加拦截路径
        registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");
    }
}

3）将日志级别从默认的info改为dubug：logging.level.com.wdit=debug

4.2整合jdbc和事务

添加jdbc启动器和数据库驱动：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

SpringBoot中通过注解来控制事务。就是在service方法中添加@Transacational

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}

4.3整合连接池

添加启动器：

<!-- Druid连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.9</version>
</dependency>

配置属性：

#初始化连接数
spring.datasource.druid.initial-size=1
#最小空闲连接
spring.datasource.druid.min-idle=1
#最大活动连接
spring.datasource.druid.max-active=20
#获取连接时测试是否可用
spring.datasource.druid.test-on-borrow=true
#监控页面启动
spring.datasource.druid.stat-view-servlet.allow=true

4.4 整合mybatis

4.2.1mybatis

添加启动器：

<!--mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>

配置属性：

# mybatis 别名扫描
mybatis.type-aliases-package=com.wdit.domain
# mapper.xml文件位置,如果没有映射文件，请注释掉
mybatis.mapper-locations=classpath:mappers/*.xml

这里没有配置mapper接口扫描包，因此需要给每一个Mapper接口添加@Mapper注解，才能被识别。

@Mapper
public interface UserMapper {
}

或者，我们也可以不加注解，而是在启动类上添加扫描包注解：

@SpringBootApplication
@MapperScan("com.wdit.demo.mapper")
public class Application {
    public static void main(String[] args) {
        // 启动代码
        SpringApplication.run(Application.class, args);
    }
}

4.2.2 通用mapper

添加启动器：

<!-- 通用mapper -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</dependency>

使用：

@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}

4.5 测试

数据库中新建表user，新建三个类：

domain

package com.wdit.domain;


public class User {
    private Long id;
    private String name;
    private String password;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

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

mapper：

public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}

service：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        User user=new User();
        user.setId(id);
        return this.userMapper.selectOne(user);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }
}

controller:

@RestController
public class HelloController {

    @Autowired
    private UserService userService;

    @GetMapping("/hello")
    public User hello() {
        User user = this.userService.queryById(8L);
        return user;
    }
}