SpringBoot

1.入门程序

入门程序相当简单,只要三步

1. 创建一个普通工程
2. 引入依赖
3. 编写controller

一、创建一个普通工程

二、引入依赖

<?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.itcast.springboot</groupId><artifactId>itcast-springboot</artifactId><version>1.0-SNAPSHOT</version><!-- 所有的springboot的工程都以spring父工程为父工程 --><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.6.RELEASE</version></parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>
</project>

三、编写controller

@RestController
@EnableAutoConfiguration
public class HelloController {@GetMapping("show")public String test(){return "hello Spring Boot!";}public static void main(String[] args) {SpringApplication.run(HelloController.class, args);}
}

1.1 spring-boot-starter-parent

  所有SpringBoot项目要继承的项目，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的

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

  它的作用是对常用的依赖进行版本管理,以便引入依赖时可以省略版本号，需要注意: spring-boot-starter-parent（2.5.0）与 spring-boot-starter-parent（2.4.6）共计57处坐标版本不同

---

1.2 启动器

  Springboot包含许多启动项目并快速运行所需的依赖项，并且具有一组受支持的被管理的传递性依赖项，所有的正式starter都遵循类似的命名模式spring-boot-starter-*。

  starter启动器是一组方便的依赖项描述符，可以在pom中引入其依赖，免去了自己需要引用很多依赖类，并且SpringBoot会自动进行类的自动配置。

例如我们引入spring-boot-starter-web(web启动器)

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

实际上我们可以看到这一个启动器中就包含了这么多的依赖

想了解更多的启动器,可以参考:Spring Boot启动器

---

1.3 @EnableAutoConfiguration(重要)

  之前我们如果要访问一个Controller,是比较麻烦的.要配置DispatchServlet,还要去初始化SpringMvc容器,后期到了Spring3.0版本后,我们有了注解配置,但依旧需要配置不少东西

官网翻译

开启spring应用程序的自动配置，SpringBoot基于你所添加的依赖和你自己定义的bean，试图去猜测并配置你想要的配置。比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

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

---

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

• 这些默认配置是怎么配置的，在哪里配置的呢？
• 为何依赖引入就会触发配置呢？
• 这些默认配置的属性来自哪里呢？

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

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

打开WebMvcAutoConfiguration：

我们看到这个类上的4个注解：

@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的类，那么这个默认配置就会失效！

接着，我们查看该类中定义了什么：

视图解析器：

处理器适配器（HandlerAdapter）：

另外，这些默认配置的属性来自哪里呢？

我们看到，这里通过@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和ResourceProperties。

我们查看这两个属性类：

找到了内部资源视图解析器的prefix和suffix属性。
ResourceProperties中主要定义了静态资源（.js,.html,.css等)的路径：

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

---

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

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

一、启动器
  之所以，我们如果不想配置，只需要引入依赖即可，而依赖版本我们也不用操心，因为只要引入了SpringBoot提供的stater（启动器），就会自动管理依赖及版本了。
  因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器，参考课前资料中提供的《SpringBoot启动器.txt》

二、全局配置
  另外，SpringBoot的默认配置，都会读取默认属性，而这些属性可以通过自定义application.properties文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。
  因此，玩SpringBoot的第二件事情，就是通过application.properties来覆盖默认属性值，形成自定义配置。我们需要知道SpringBoot的默认属性key，非常多，参考课前资料提供的：《SpringBoot全局属性.md》

---

1.4 如何注册多个Controller?

  如果我们有另一个controller,应该怎么访问呢?难道要在每一个Controller中都添加一个main方法和@EnableAutoConfiguration注解，这样启动一个springboot程序也太麻烦了。
  也无法同时启动多个Controller，因为每个main方法都监听8080端口。所以，一个springboot程序应该只有一个springboot的main方法。

  所以，springboot程序引入了一个全局的引导类。

---

1.5 引导类

  通常请求下，我们在一个springboot工程中都会在基包下创建一个引导类，一些springboot的全局注解（@EnableAutoConfiguration注解）以及springboot程序的入口main方法都放在该类中。

一、在根目录下, 创建引导类
  我们还需要添加@ComponentScan来扫描

@EnableAutoConfiguration
@ComponentScan
public class TestApplication {public static void main(String[] args) {SpringApplication.run(TestApplication.class, args);}
}

官网描述:

配置组件扫描的指令。提供了类似与context:component-scan标签的作用
通过basePackageClasses或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包

  而我们的@ComponentScan注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。一般启动类会放在一个比较浅的包目录中。

二、并修改HelloController

@RestController
public class HelloController {@GetMapping("show")public String test(){return "hello Spring Boot!";}
}

---

2.完整的SpringBoot项目

2.1 启动类

2.1.1 创建一个启动类

启动类上添加@SpringBootApplication

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

@SpringBootApplication = @EnableAutoConfiguration + @ComponentScan + @SpringBootConfiguration

• @EnableAutoConfiguration：开启自动配置
• @ComponentScan：开启注解扫描
• @SpringBootConfiguration ???

2.1.2 扩展: @SpringBootConfiguration

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

---

2.2 使用配置类定义组件

  springboot的默认配置方式和我们之前玩的配置方式不太一样，没有任何的xml, 例如数据库连接池,之前是这么配的

<!-- 配置连接池 -->
<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>

现在我们可以使用更优雅的java配置方式

一、引入依赖

<dependency><groupId>com.github.drtrang</groupId><artifactId>druid-spring-boot2-starter</artifactId><version>1.1.10</version>
</dependency>

二、添加jdbc.properties

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

三、配置数据源
  之前配置的@ComponentScan此时就可以通过@Configuration注解扫描到此配置类

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfiguration {@Value("${jdbc.url}")String url;@Value("${jdbc.driverClassName}")String driverClassName;@Value("${jdbc.username}")String username;@Value("${jdbc.password}")String password;@Beanpublic DataSource dataSource() {DruidDataSource dataSource = new DruidDataSource();dataSource.setUrl(url);dataSource.setDriverClassName(driverClassName);dataSource.setUsername(username);dataSource.setPassword(password);return dataSource;}
}

• @Configuration:声明为配置类
  • 配置类的作用就是替代application.xml,我们使用配置类来定位bean,交给容器管理
• @PropertySource:引入属性文件
  • 通过@Value + ${}可以在Spring容器的所有位置(配置类、bean)中注入值
• @Bean:相当于以前的bean标签
  • Spring会自动调用该方法，将方法的返回值加入Spring容器中
  • @Bean支持直接在传参中注入对象(按类型注入)

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

---

2.3 SpringBoot的属性注入

  上面案例中,我们注入属性使用了@Value注解,这种方式不够强大,在SpringBoot中,提供了一种新的属性注入方式,支持java基本类型以及复杂类型注入

1. 创建属性读取类
2. 在配置类(在JdbcConfiguratio)中使用这个属性

一、创建属性读取类

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

• @ConfigurationProperties 注解声明当前类为属性读取类
  • prefix="jdbc"读取属性文件中，前缀为jdbc的值。
  • 在类上定义各个属性，名称必须与属性文件中jdbc.后面部分一致，并且必须具有getter和setter方法

二、在配置类(在JdbcConfiguratio)中使用这个属性

@Configuration
@PropertySource("classpath:jdbc.properties")
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {@Autowiredprivate JdbcProperties jdbcProperties;@Beanpublic DataSource dataSource() {DruidDataSource dataSource = new DruidDataSource();dataSource.setUrl(jdbcProperties.getDriverClassName());dataSource.setDriverClassName(jdbcProperties.getUrl());dataSource.setUsername(jdbcProperties.getUsername());dataSource.setPassword(jdbcProperties.getPassword());return dataSource;}
}

• @EnableConfigurationProperties 声明要使用指定属性读取类

三、@Bean方法的参数注入(更推荐)

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfiguration {@Beanpublic DataSource dataSource(JdbcProperties jdbcProperties) {dataSource.setUrl(jdbcProperties.getDriverClassName());dataSource.setDriverClassName(jdbcProperties.getUrl());dataSource.setUsername(jdbcProperties.getUsername());dataSource.setPassword(jdbcProperties.getPassword());return dataSource;}
}

四、扩展内容:默认读取的资源文件(之后会改为.yml文件)
以我们把jdbc.properties名称改为application.properties, 此时我们不用指定属性文件

五、最优雅的方式
  随着Spring容器初始化Bean后, SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。

  使用前提:该类(此处是DataSource)必须有对应属性的set方法！

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfiguration {@Bean// 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中@ConfigurationProperties(prefix = "jdbc")public DataSource dataSource() {DruidDataSource dataSource = new DruidDataSource();return dataSource;}
}

3.整合SpirngMvc

3.1 注册DispatcherServlet(了解)

只要有SpringMvc的依赖后,SpringBoot会自动帮我们定义和注册Dispatcher

一、Spring2.0 回顾XML配置
在Spring2.0时代,我们使用XML的配置方式,在web.xml中配置DispatcherServlet,当web应用启动时,会解析这个文件

<servlet><!-- 在web应用中注册这个Servlet --><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- 指定读取SpringMvc配置文件的地址 --><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc-servlet.xml</param-value></init-param><!-- 标记容器是否在启动的时候就加载这个servlet --><load-on-startup>1</load-on-startup>
</servlet><!-- 设置拦截路径 -->
<servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern>
</servlet-mapping>

二、Spring 3.0 java配置
第一步:SpringMvc配置类

@Configuration
@ComponentScan("com.itheima.controller")
// 用来开启支持SpringMvc的一些配置,常配置实现WebMvcConfigurer接口使用,底层是继承了WebMvcConfigurationSupport
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {}

第二步:继承AbstractAnnotationConfigDispatcherServletInitializer

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {// 初始化Spring容器protected Class<?>[] getRootConfigClasses() {return new Class[]{SpringConfig.class};}// 初始化SpringMvc容器protected Class<?>[] getServletConfigClasses() {return new Class[]{SpringMvcConfig.class};}protected String[] getServletMappings() {return new String[]{"/"};}
}

原理:

• AbstractAnnotationConfigDispatcherServletInitializer是WebApplicationInitializer的子孙类,当web应用启动时,会调用onStartup方法
• 在AbstractDispatcherServletInitializer(父类)中不仅执行onStartup,还执行了registerDispatcherServlet,在这个方法中,我们注册了DispatchServlet
  

三、SpringBoot DispatcherServlet的注册

• 1.当我们开启@EnableAutoConfiguration(自动装配)后,会根据扫描到的Configuration来判断是否能自动装备(依赖是否引入依赖)

• 2.WebMvcAutoConfiguration作为一个Configuration,我们运行启动类后会被扫描到,它是基于DispatcherServletAutoConfiguration的装配完成后执行
  

• 3.DispatcherServletAutoConfiguration中定义了DispatcherServlet
  

• 4.完成了Dispatcher的定义后,在此处将注册到了web容器中
  

3.1.1 配置DispatcherServlet映射路径

一、SpringBoot编程式

@Bean
public ServletRegistrationBean dispatherRegistration(DispatcherServlet dispatcherServlet) {return new ServletRegistrationBean(dispatcherServlet, "/api/*");
}

二、SpringBoot配置文件

server.servlet.path=/api/*

3.1.2 设置端口号

# 映射端口
server.port=80

3.1.3 访问静态资源

回顾我们上面看的源码，有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径：

默认的静态资源路径为：

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

只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。

我们习惯会把静态资源放在classpath:/static/目录下。我们创建目录，并且添加一些静态资源：

---

3.2 添加拦截器

1. 定义拦截器类
2. 注册拦截器

一、定义拦截器类

@Component
public class MyInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("preHandle method is running!");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("postHandle method is running!");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("afterCompletion method is running!");}
}

回顾:XML的配置 Spring2.0时代

<!-- 注册自定义拦截器 -->
<mvc:interceptors><mvc:interceptor><!-- 拦截所有请求 --><mvc:mapping path="/**"/><!-- <mvc:mapping path="/hello/"/> --><!-- 自定义拦截器的全路径 --><bean class="cn.itcast.springmvc.interceptors.MyInterceptor"/></mvc:interceptor>
</mvc:interceptors>

回顾:java的配置 Spring3.0时代

• 第一步:在SpringMvc的配置类上添加@EnableWebMvc注解同时实现WebMvcConfigurer接口
• 第二步:复写addInterceptors方法

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {// 注入拦截器@Autowiredprivate HandlerInterceptor myInterceptor;// 设置拦截器(如果是拦截器链则按顺序执行),一个拦截器可配置多个拦截路径@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(myInterceptor).addPathPatterns("/books/**","/books");}
}

但是随着SpringBoot的到来,SpringBoot不需要我们自定义SpringMvc配置类,它的内部帮我们提供了默认的SpringMvc配置类,只需要我们有对应的依赖

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

1. 保留@Configuration注解,让引导类可以读取到
2. 删除@ComponentScan,不需要通过SpringMvcConfig来扫描了
3. 删除@EnableWebMvc,会跟SpringBoot的功能冲突
4. 保留WebMvcConfigurer ,实现Mvc特征

@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {@Autowiredprivate HandlerInterceptor myInterceptor;/*** 重写接口中的addInterceptors方法，添加自定义拦截器* @param registry*/@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(myInterceptor).addPathPatterns("/**");}
}

4.整合连接池

两者二选一即可

• HikariCP连接池
• Druid连接池

SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区，或在MySQL数据库端配置时区解决此问题

jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC

4.1 HikariCP连接池

HikariCP连接池是jdbc的默认使用的连接池,只有引入jdbc的依赖即可

<!--jdbc的启动器，默认使用HikariCP连接池-->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId>
</dependency><!--不要忘记数据库驱动，因为springboot不知道我们使用的什么数据库，这里选择mysql-->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId>
</dependency>

# 连接四大参数
spring.datasource.url=jdbc:mysql://localhost:3306/heima
spring.datasource.username=root
spring.datasource.password=root
# 可省略，SpringBoot自动推断
spring.datasource.driverClassName=com.mysql.jdbc.Driverspring.datasource.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.minimum-idle=10

4.2 Druid连接池

<!-- Druid连接池 -->
<dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId><version>1.1.6</version>
</dependency><!--不要忘记数据库驱动，因为springboot不知道我们使用的什么数据库，这里选择mysql-->
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId>
</dependency>

# 连接四大参数
spring.datasource.url=jdbc:mysql://localhost:3306/heima
spring.datasource.username=root
spring.datasource.password=root
# 可省略，SpringBoot自动推断
spring.datasource.driverClassName=com.mysql.jdbc.Driver#初始化连接数
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

---

5.整合Mybatis

5.1 mybatis

SpringBoot官方并没有提供Mybatis的启动器，不过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文件位置,如果没有映射文件，请注释掉
mybatis.mapper-locations=classpath:mappers/*.xml

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

@Mapper
public interface UserMapper {
}

5.2 通用mapper(基础的CRUD操作)

通用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>{
}

---

6.整合事务

一、回顾之前,我们是怎么引入事务的

• xml时代

<!-- druid连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/><property name="url" value="jdbc:mysql://127.0.0.1:3306/my_database"/><property name="username" value="root"/><property name="password" value="root"/></bean><!-- 第一步：定义具体的平台事务管理器（DataSource事务管理器） --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><!-- 注入数据源 --><property name="dataSource" ref="dataSource"/></bean>

• java配置时代

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {// 不同的持久化框架,选择不同的事务管理器DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();transactionManager.setDataSource(dataSource);return transactionManager;
}

二、SpringBoot的事务管理
当我们引入了jdbc或者web的启动器后,就已经引入事务相关的依赖及默认配置了spring-tx

至于添加事务，SpringBoot中通过注解来控制。就是我们熟知的@Transactional

@Service
public class UserService {@Autowiredprivate UserMapper userMapper;public User queryById(Long id){return this.userMapper.selectByPrimaryKey(id);}@Transactionalpublic void deleteById(Long id){this.userMapper.deleteByPrimaryKey(id);}
}

---

7.SpringBoot项目快速启动

一、引入maven插件
jar支持命令行启动需要依赖maven插件支持，请确认打包时是否具有SpringBoot对应的maven插件。

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

二、对SpringBoot项目打包（执行Maven构建指令package）
要先clean后package,打包成功后在target文件夹下

三、执行启动指令
进入target文件夹下,cmd进入命令行界面,输入

java -jar springboot-demo-1.0-SNAPSHOT.jar	# 项目的名称根据实际情况修改

SpringBoot启动成功

---

8.yaml

yml和yaml是同一种格式,只是在运算速度上有区别

SpringBoot配置文件加载顺序（了解）
application.properties > application.yml > application.yaml

---

8.1 语法

1. 大小写敏感
2. 属性层级关系使用多行描述，每行结尾使用冒号结束
3. 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
4. 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
5. 核心规则：数据前面要加空格与冒号隔开

8.1.1 yaml数组数据

8.1.2 yaml数据读取和注入

一、使用@Value读取单个数据
属性名引用方式：${一级属性名.二级属性名……}

二、将数据封装到Environment对象

三、自定义对象封装指定数据(最常用)

public class Enterprise {private String name;private Integer age;private String tel;private String[] subject;//自行添加getter、setter、toString()等方法
}

自定义对象封装数据警告解决方案

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

---

8.2 多环境开发配置

方式一:同一个yaml中配置多环境

在实际开发中，项目的开发环境、测试环境、生产环境的配置信息是否会一致？如何快速切换？

在yaml文件中通过加 --- 来区分多种环境

通过spring.profiles.active来指定环境

---

方式二:不同环境使用单位yaml(了解)

格式:application-环境名称.yml

启动时指定环境名称(不指定环境名称,默认读取application.yml)

---

方式三:共性内容写到主配置中,特性内容写到独立环境中,根据当前需要,在主配置中指向某个环境(常用)

1. 共性内容写在主配置文件(application.yml)中
2. 非共性的内容(例如数据库连接信息、kafka等),我们写到独立的application-环境.yml
3. 在主配置文件中,指向独立环境
   

8.2.1 多环境启动命令格式(运维人员)

一、解决yaml文件中因为存在中文,打包失败的情况

将这几处改为UTF-8

二、多环境启动命令格式

java –jar springboot.jar --spring.profiles.active=test
java –jar springboot.jar --server.port=88
java –jar springboot.jar --server.port=88 --spring.profiles.active=test

8.2.2 Maven与SpringBoot多环境兼容

一、在Maven中设置多环境属性

此处的<profile.active>dev</profile.active>只需要有application-dev.yml即可(不用在application-dev.yml中设置spring.profiles:dev)

<profiles><!-- 环境dev --><profile><id>dev_env</id><properties><profile.active>dev</profile.active></properties><activation><activeByDefault>true</activeByDefault></activation></profile><!-- 环境test --><profile><id>test_env</id><properties><profile.active>test</profile.active></properties></profile>
</profiles>

添加了后,在maven的profiles中会显示配置的环境

二、对资源文件开启默认占位符的解析

解析${}占位符

<build><plugins><plugin><artifactId>maven-resources-plugin</artifactId><configuration><encoding>utf-8</encoding><useDefaultDelimiters>true</useDefaultDelimiters></configuration></plugin></plugins>
</build>

三、SpringBoot中引用Maven属性
在主文件application.yml中引入maven属性

四、勾选对应的环境,启动

五、使用Maven打包
Maven指令执行完毕后，生成了对应的包，其中类参与编译，但是配置文件并没有编译，而是复制到包中，生会根据我们勾选的环境,加载环境

---

8.3 配置文件读取优先级

• SpringBoot中4级配置文件
  • 1级 同级目录: config/application.yml 【最高】
  • 2级 同级目录: application.yml
  • 3级 classpath：config/application.yml
  • 4级 classpath：application.yml 【最低】

同级目录指的是与jar包在同一级目录

同样的配置,会采用等级高的

作用：

• 1级与2级留做系统打包后设置通用属性
• 3级与4级用于系统开发阶段设置通用属性

---

9.SpringBoot整合Junit

一、添加依赖

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

二、编写测试类，默认自动生成了一个

@SpringBootTest
class Springboot07JunitApplicationTests {@Autowiredprivate BookService bookService;@Testpublic void testSave() {bookService.save();}
}