SpringBoot

1.什么是 Spring Boot?

Spring Boot设计目的是用来简化新 Spring 应用的初始搭建以及开发过程，是为了让开发人员尽可能快的创建并允许Spring 应用程序，尽可能减少项目的配置文件。

从最根本上来讲，Spring Boot 就是一些库的集合，它能够被任意项目的构建系统所使用。它使用 “习惯优于配置” （项目中存在大量的配置，此外还内置一个习惯性的配置）的理念让你的项目快速运行起来。所以 spring boot 其实不是什么新的框架，它默认配置了很多框架的使用方式，就像 maven 整合了所有的 jar 包，spring boot 整合了所有的框架。

总结起来就是：

（1）为所有 Spring 开发提供一个更快更广泛的入门体验。

（2）零配置。无冗余代码生成和XML 强制配置，遵循“约定大于配置” 。

（3）集成了大量常用的第三方库的配置， Spring Boot 应用为这些第三方库提供了几乎可以零配置的开箱即用的能力。

（4）提供一系列大型项目常用的非功能性特征，如嵌入式服务器、安全性、度量、运行状况检查、外部化配置等。

（5）Spring Boot 不是Spring 的替代者，Spring 框架是通过 IOC 机制来管理 Bean 的。Spring Boot 依赖 Spring 框架来管理对象的依赖。Spring Boot 并不是Spring 的精简版本，而是为使用 Spring 做好各种产品级准备。

2. 为什么学习Spring Boot

我们打开 Spring 的官方网站 ,我们可以看到图中官方对 Spring Boot 的定位：Build Anything， Build任何东西。Spring Boot旨在尽可能快地启动和运行，并且只需最少的 Spring 前期配置。 同时我们也来看一下官方对后面两个的定位：

SpringCloud：Coordinate Anything，协调任何事情； SpringCloud Data Flow：Connect everything，连接任何东西。

仔细品味一下，Spring 官网对 Spring Boot、SpringCloud 和 SpringCloud Data Flow三者定位的措辞非常有味道，同时也可以看出，Spring 官方对这三个技术非常重视，是现在以及今后学习的重点（SpringCloud 相关达人课课程届时也会上线）。

SpringBoot核心功能

1、独立运行Spring项目 Spring boot 可以以jar包形式独立运行，运行一个Spring Boot项目只需要通过java -jar xx.jar来运行。 2、内嵌servlet容器 Spring Boot可以选择内嵌Tomcat、jetty或者Undertow,这样我们无须以war包形式部署项目。 3、提供starter简化Maven配置 spring提供了一系列的start pom来简化Maven的依赖加载，例如，当你使用了spring-boot-starter-web，会自动加入依赖包。 4、自动装配Spring SpringBoot会根据在类路径中的jar包，类、为jar包里面的类自动配置Bean，这样会极大地减少我们要使用的配置。当然，SpringBoot只考虑大多数的开发场景，并不是所有的场景，若在实际开发中我们需要配置Bean，而SpringBoot灭有提供支持，则可以自定义自动配置。 5、准生产的应用监控 SpringBoot提供基于http ssh telnet对运行时的项目进行监控。 6、无代码生产和xml配置　　

SpringBoot不是借助与代码生成来实现的，而是通过条件注解来实现的，这是Spring4.x提供的新特性。

SpringBoot优缺点

优点：

1、快速构建项目。 2、对主流开发框架的无配置集成。 3、项目可独立运行，无须外部依赖Servlet容器。 4、提供运行时的应用监控。 5、极大的提高了开发、部署效率。 6、与云计算的天然集成。

缺点：

1、如果你不认同spring框架，也许这就是缺点。 2、SpringBoot特性 3、创建独立的Spring项目 4、内置Tomcat和Jetty容器 5、提供一个starter POMs来简化Maven配置 6、提供了一系列大型项目中常见的非功能性特性，如安全、指标，健康检测、外部配置等 7、完全没有代码生成和xml配置文件

SpringBoot几个常用的注解

（1）@RestController和@Controller指定一个类，作为控制器的注解 ，并说明其区别 （2）@RequestMapping方法级别的映射注解，这一个用过Spring MVC的小伙伴相信都很熟悉 （3）@EnableAutoConfiguration和@SpringBootApplication是类级别的注解，根据maven依赖的jar来自动猜测完成正确的spring的对应配置，只要引入了spring-boot-starter-web的依赖，默认会自动配置Spring MVC和tomcat容器 （4）@Configuration类级别的注解，一般这个注解，我们用来标识main方法所在的类,完成元数据bean的初始化。 （5）@ComponentScan类级别的注解，自动扫描加载所有的Spring组件包括Bean注入，一般用在main方法所在的类上 （6）@ImportResource类级别注解，当我们必须使用一个xml的配置时，使用@ImportResource和@Configuration来标识这个文件资源的类。 （7）@Autowired注解，一般结合@ComponentScan注解，来自动注入一个Service或Dao级别的Bean （8）@Component类级别注解，用来标识一个组件，比如我自定了一个filter，则需要此注解标识之后，Spring Boot才会正确识别。

SpringBoot CLI

SpringBoot CLI 是SpringBoot提供的控制台命令工具。

springboot是如何管理事务的？

直接写@transactional注解就行，在方法就是方法事务，类上就是类事务

SpringBoot maven 构建项目

spring-boot-starter-parent：是一个特殊Start，它用来提供相关的Maven依赖项，使用它之后，常用的包依赖可以省去version标签。

入门

首先创建好一个maven项目，然后在pom.xml中加入依赖

<!-- 指定SpringBoot的版本 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
    </parent>
<!-- 导入SpringBoot的Jar包-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

然后编写一个Controller类

package com.ifueen.hello;

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.ifueen.hello;

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

/**

 * SpingBoot的引导类
   */
     @SpringBootApplication
     public class HelloSpringBoot {
   public static void main(String[] args){
       //加载这个控制器
       SpringApplication.run(HelloSpringBoot.class);
   }
     }

启动这个配置类，然后在浏览器中输入localhost:8080/hello就可以看到效果了

项目结构

一个SpingBoot的基本项目结构如下

src

        --main

                 --java --resources

                                        --static //静态资源目录

                                        --templates //模板页面目录，如：jsp ,ftl

                                        --application.properties/application.yml //默认配置文件

打包

pom.xml中导入打包插件

<build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

打包完成后在cmd中运行命令

java -jar xxx.jar

SpringBoot读取配置

使用@Value标签

配置文件

设置端口

server.port=5050

绑定配置的对象

//读取端口 @Value("${server.port}") private String port;

使用@ConfigurationProperties 配置文件

#配置数据库
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql:///rpms?useUnicode=true&characterEncoding=utf-8
db.username=root
db.password=123456

新建一个类来存放读取的配置

package com.ifueen.hello.read_properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
/**

 * 读取配置文件的类
   */
   @Component
   @ConfigurationProperties(prefix = "db")
   public class DbProperties {
   private String driverClassName;
   private String url;
   private String username;
   private String password;

@Override
public String toString() {
    return "DbProperties{" +
            "driverClassName='" + driverClassName + '\'' +
            ", url='" + url + '\'' +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
}

public String getDriverClassName() {
    return driverClassName;
}

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

public String getUrl() {
    return url;
}

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

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

多环境切换

方式一

spring:
  profiles:

#####     active: test	#激活(选择)环境test

spring:
  profiles: dev		#指定环境名字dev
server:

#####   port: 9999

spring:
  profiles: test	#指定环境名字test
server:
  port: 8888

方式二

通过配置文件的名字来识别环境

application-dev.yml

server: port: 9999

application-test.yml

server: port: 8888

application.yml

spring: profiles: active: test #根据文件名字配置 application-dev.properties

日志使用

基本使用

//日志 private static Logger log = LoggerFactory.getLogger(HelloController.class);

	log.debug(connection.toString());
    log.error("错误信息s");
    log.warn("警告信息");
    log.info("详细信息");

配置日志

logging.level.root=info
logging.level.com.ifueen.hello=trace
logging.file=mylog.log
logging.pattern.console=%white(%d{yyyy-MM-dd HH:mm:ss}) %highlight(%lsn) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{10}) - %cyan(%msg%n)
logging.pattern.file=%white(%d{yyyy-MM-dd HH:mm:ss}) %highlight(%lsn) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{10}) - %cyan(%msg%n)

指定配置文件配置logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration  scan="true" scanPeriod="5 seconds" debug="false">

    <!-- 定义输出日志的格式和位置 -->
    <property name="SpringBoot_Log" value="%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n" />


    <!--输出到控制台-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${SpringBoot_Log}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    
    <!--输出到文件-->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>logs/springboot.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/springboot-%d{yyyyMMdd}-%i.log.gz</fileNamePattern>
            <!-- 单个文件最大值 -->
            <maxFileSize>5KB</maxFileSize>
            <!-- 保留历史 -->
            <maxHistory>30</maxHistory>
            <!-- 总文件大小 -->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>${SpringBoot_Log}</pattern>
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!-- 输出级别 -->
    <root level="info">
        <appender-ref ref="console" />
        <appender-ref ref="file" />
    </root>


    <logger name="com.ifueen" level="trace" additivity="false">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
    </logger>

</configuration>

SpringBoot集成Thymeleaf

导入依赖

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


创建模板 resources/templates/hello.html

Controller配置 @RequestMapping("/hello") public String home(Model model){ model.addAttribute("msg","我们不能失去信仰"); return "hello"; }

Thymeleaf的自动配置原理

@EnableAutoConfiguration 开启自动配置功能，通过一个AutoConfigurationImportSelector导入选择器去扫描 spring-boot-autoconfigure-2.0.5.RELEASE.jar 自动配置包下面的 spring.factories 文件中的很多很多的自动配置的类
而：ThymeleafAutoConfiguration 是的Thymeleaf的自动配置 ，在这个自动配置类里面通过一个ThymeleafProperties去读取配置文件中的配置(也有默认配置) ，来自动配置Thymeleaf，比如Thymeleaf的视图解析器的自动配置如下：
@Bean
@ConditionalOnMissingBean(name = "thymeleafViewResolver")
public ThymeleafViewResolver thymeleafViewResolver() {
	ThymeleafViewResolver resolver = new ThymeleafViewResolver();
	...
	return resolver;
}

静态资源

1.静态资源目录 resource/static

2.webjars 导入jquery依赖 （ WebJars - Web Libraries in Jars）

<dependency> <groupId>org.webjars</groupId> <artifactId>jquery</artifactId> <version>3.4.1</version> </dependency>

导入jquery的js

<script sr

SpringBoot中的MVC配置

1.配置拦截器

定义拦截器

注册拦截器

package com.ifueen.hello;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**

 * SpringMVC的配置
   */
   @Configuration
   public class MyMvcConfig implements WebMvcConfigurer {
   @Autowired
   private LoginCheckInterceptor loginCheckInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
       //拦截所有
       registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");
   }

   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
       registry.addViewController("/xx").setViewName("xx.html");
   }

}

package com.ifueen.hello;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**

 * 拦截器
   */
   @Component
   public class LoginCheckInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       System.out.println("拦截");
       return true;
   }
   }

 

2.添加视图控制器

@Override public void addViewControllers(ViewControllerRegistry registry) { registry.addViewController("/xx").setViewName("hello2.html"); } 当访问/xx 定位到 templates/hello2.html

集成DataSource(连接池)

1.导入依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
        <!-- mysql 数据库驱动. -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>

手动配置方式

手动配置四个属性

db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql:///rpms?useUnicode=true&characterEncoding=utf-8
db.username=root
db.password=123456


​    @Bean
​    @ConfigurationProperties(prefix = "db")
​    public DataSource dataSource(){
​        DruidDataSource dataSource = new DruidDataSource();
​        return dataSource ;
​    }

自动配置方式 (重点)

配置datasource -- 自动配置

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql:///rpms?useUnicode=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=123456

SpringBoot项目大概分为四层：

（1）DAO层：包括XxxMapper.java(数据库访问接口类)，XxxMapper.xml(数据库链接实现)；（这个命名，有人喜欢用Dao命名，有人喜欢用Mapper，看个人习惯了吧）

（2）Bean层：也叫model层，模型层，entity层，实体层，就是数据库表的映射实体类，存放POJO对象；

（3）Service层：也叫服务层，业务层，包括XxxService.java(业务接口类)，XxxServiceImpl.java（业务实现类）；（可以在service文件夹下新建impl文件放业务实现类，也可以把业务实现类单独放一个文件夹下，更清晰）

（4）Web层：就是Controller层，实现与web前端的交互。