Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter）

我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

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

添加父工程的坐标：

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

这个父工程里面已经对依赖进行了一个管理，只要我们引入了这个父工程，就可以不许要操心依赖的问题
也不需要担心依赖的问题

添加web启动器：

为了让springboot可以帮我们完成自动配置，所以引入一个依赖名为自动配置依赖，也叫作启动器
因为是web项目所以引入web启动器

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 </dependencies>
需要注意的是，我们并没有在这里指定版本信息。因为SpringBoot的父工程已经对版本进行了管理了。

然后我们点开lib发现所有需要用到的依赖都已经导入了，并且控制了版本，所以不需要担心版本冲突的问题

启动类：
springboot项目是通过main函数来启动的，所以需要一个启动类
编写main函数

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

编写一个controller测试

@Controller
public class HelloController{

@GetMapping("hello")
@ResponseBody
public String hello(){
    return "hello springboot!"
}

}

或者：

@RestController
public class HelloController{
@GetMapping("hello")

public String hello(){
    return "hello springboot!"
}

}

问题：如果在springboot中都是默认的配置，那么我们需要配置一个数据库的连接，怎么办呢？

 例如：<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
       </bean>
解决方案：1.脱离xml配置的java配置方案

java配置就是通过java类来定义这些配置，不在需要xml配置文件了

使用Java配置的时候需要用到的注解：

@Configuration 申明一个类为配置类，代替xml
@Bean：申明在方法上，将方法的返回值会注入到spingbean的容器中，代替了古老的bean标签
@Value:属性注入
@PropertySource :指定外部文件

实现步骤：

     首先准备一个配置类，然后在类上使用@Configuration注解
     在配置类中定义一个方法，方法的返回值类型就是注入到bean中的类型
     然后在方法上使用注解@bean 作用就是把该方法的返回值注入到bean中
     如果这个方法中需要使用到一些参数例如 driverclassName url等，
     可以使用@value注解注入，如果在这个配置类中需要使用到一些外部定义的
     参数可以使用@PropertySource来指定外部文件！
     最后注入到bean中对象，可以使用@Autrowind来注入到程序中使用！
     
实现：/*在这个配置的类上指定配置文件，代替xml*/
@Configuration //说明这个是一个配置类，代替xml

/*通过propertySource注解来引入外部文件*/
@PropertySource("classpath:jdbc.properties")
public class jdbcConfig {

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




    //定义一个方法，方法的返回值是需要注入到springbean容器中的对象
    //添加一个注解bean表示把方法的返回值加入到bean容器中
    @Bean
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverclassname);
        return dataSource;
    }

}

以上只是原始的java配置，但是在springboot中的java配置对这个java配置进行了一个升级！

对上面的做法进行升级：

步骤：1.定义一个配置文件是数据库的连接信息

     application.properties
     
            jdbc.driverClassName=com.mysql.jdbc.Driver
        jdbc.url=jdbc:mysql://localhost:3306/leyou
        jdbc.userName=root
        jdbc.password=root
        
        
    2.定义一个属性配置类jdbcProperties，专门为jdbc的配置类提供属性
    //定义一个属性配置类，专门为jdbc配置类提供属性的

例如：

//使用注解来说明这个是一个属性配置类
@ConfigurationProperties(prefix = "jdbc")

/* 这个configurationProperties注解的作用就是把默认jdbc.properties配置文件中的配置注入到类中
   所以需要加一个前缀区分！
 */
public class jdbcProperties {

    //首先定义属性
    private String driverClassName;
    private String userName;
    private String password;
    private String url;

    //生成get set方法，


    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;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}
  3.然后在配置类中使用注解开启属性配置

例如：

      /*在这个配置的类上指定配置文件，代替xml*/
@Configuration //说明这个是一个配置类，代替xml

//启用属性配置
@EnableConfigurationProperties(jdbcProperties.class)
public class jdbcConfig {

    //定义一个方法，方法的返回值是需要注入到springbean容器中的对象
    //添加一个注解bean表示把方法的返回值加入到bean容器中
    @Bean
    public DataSource getDataSource(jdbcProperties jdbc){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(jdbc.getUrl());
        dataSource.setUsername(jdbc.getUserName());
        dataSource.setPassword(jdbc.getPassword());
        dataSource.setDriverClassName(jdbc.getDriverClassName());
        return dataSource;
    }

}

 4.这样做以后，就把对象注入到spring的applicationContext容器中了！

最后一种springboot的解决方法，也是终极方案，非常的优雅！

步骤：
1.定义springboot的默认的配置文件 application.properties 定义好属性
2.然后定义一个配置类,例如jdbcConfig类，在类上使用@Configuration注解表示为配置认为
3.在类中定义方法，在方法上添加两个注解，一个是@Bean注解，就是把方法的返回值注入到容器中
  还有一个就是@ConfigurationProperties(prefix ="jdbc") 方法体就是直接new一个datasource返回
  这样就可以了！为什么呢？因为spring扫描到这个方法的@configurationProperties注解的时候，
  会自动把这个属性注入到方法中，提供给datasoruce!

yaml配置文件

yaml配置文件，我们可以把上面的application.properties配置文件修改为application.yaml配置文件，
yaml配置文件，更加的灵活，可以配置对象类型，而且对象类型中还可以有集合类型等等
在配置文件中如果有application.properties 又有application.yaml这个两个配置文件，那么spring就会采取
这个两个配置文件的并集，如果有冲突，就会默认采用application.properties配置为准！

对spingboot的启动器中@springbootApplication注解进行讲解！

    @springbootConfiguration：这个注解的作用就是声明当前类是一个配置类，
    然后Spring会自动扫描到添加了@Configuration的类，并且读取其中的配置信息。
    而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。
    所以一般我们无需自己添加。

    @EnableAutoConfiguration：自动配置的意思就是spring会根据我们引入的依赖来猜测，你所需要的配置
    比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖。
    此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！
    
    @componentScan :自动扫描包(扫描的是该配置启动器类所在的包！)所以一般启动类都会放在一个比较靠前的包目录中！
  源码：
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
     public @interface SpringBootApplication {
spring中的lombok的插件的使用

1.首先在ide工具的额plugs插件中搜索lombok插件，然后install
2.在pom文件中配置依赖org.projectlombok
3.然后就可以在pojo中使用了，
  @Data:表示自动提供getter和setter方法 hashcode方法 equals方法，toString方法
  @Getter
  @Getter
  @Slf4j 提供log变量，其实用的是slf4j的日志功能！
spring中的日志记录：
 1.在application.yml的配置文件中配置日志的策略，debug 还是info等其他级别
    logging:
      level:
        com.leyou=debug 
        
 2.然后通过slf4j注解，或者通过工厂 private Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
   获取到log变量，最后，打印日志
  log.debug("日志打印了！") 
spring中的拦截器定义方式：
 1.首先在需要定义一个包 cn.xiangbaba.Intercepter ，定义一个类MyIntercepter写拦截器，这个类实现HanleInterecepter
 2.实现几个方法 preHandle  postHandle afterCompletion
 3.最后定义配置类mvcConfig 实现WebMvcConfigurer,在类中注册拦截器到spring容器中，重写接口的addInterceptors方法
    @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("/**");
    }
}

springboot的和其他组件的整合：

1.整合jdbc以及事务：

springboot和jdbc是不需要整合的我们就只要找到Springboot提供启动器就可以了，
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

当然还有数据库，
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

至于事务是通过注解来控制的，就是我们熟知的@Transactional注解
    @Transactional
    public void deleteById(Long id){
        System.out.println("删除了： " + id);
    }
2.整合连接池

  刚才，我们引入jdbc启动器的时候，就已经发现了，springboot就已经帮我们引入了一个连接池 hikaricp连接池
  因此我们就只需要在application.yml中配置连接池的连接信息即可
   spring:
     datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mydb01
    username: root
    password: 123
3.整合mybatis

  springboot官方没有提供启动器，是mybatis官方实现的
  <!--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=cn.itcast.pojo
  # mapper.xml文件位置,如果没有映射文件，请注释掉
    mapper-locations=classpath:mappers/*.xml   
    
    
4.通用mapper使用
  通过mapper解决了spring中单标操作的问题，多表不可以用
  依赖：
   <!-- 通用mapper -->
   <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.0.3</version>
   </dependency>
  使用步骤：
  1.首先定义一个包cn.xiangbaba.Mapper 代替了cn.xiangbaba.dao
  2.在Mapper中定义一个接口UserMapper 然后继承Mapper<User>接口
  3.在这个mapper接口上添加一个@Mapper注解或者在springboot入口文件中添加要给MapperScan("cn.xiangbaba.Mapper")
    目的是为了让spring扫描到mapper接口文件
  4.在实体类pojo中加上JPA注解 例如：@Table(name="tb_user") 是为了把实体类的类名和数据库表名配对起来
    @Id：放在字段上表明这个是一个主键 
    @KeySql(useGeneratedKeys = true)  开启自增主键回显功能
  5.然后就可以把接口注入到其他类中使用了！
  注意：一旦引入了，这个mapper的依赖，就可以去掉mybatis依赖和jdbc的依赖了，因为mapper依赖中已经引入了这两个依赖
  5.springboot中的controller的写法：
  
  @RestController                      //RestController表示这是一个Controller
  public class HelloController {

    @Autowired
    private UserService userService;   //注入Service层

    @GetMapping("/user/{id}")          //定义映射路径 /user/{id}  使用{}来接受参数值
    public User hello(@PathVariable("id") Long id) {    //在方法的参数列表中使用@pathVarible来注入参数的值到形式参数中！
        User user = this.userService.queryById(id);
        return user;
    }
}