SpringBoot

1.入门程序

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

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

一、创建一个普通工程

二、引入依赖

<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.0modelVersion>

    <groupId>cn.itcast.springbootgroupId>
    <artifactId>itcast-springbootartifactId>
    <version>1.0-SNAPSHOTversion>

    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.0.6.RELEASEversion>
    parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        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.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.0.6.RELEASEversion>
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.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
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.drtranggroupId>
    <artifactId>druid-spring-boot2-starterartifactId>
    <version>1.1.10version>
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;

    @Bean
    public 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 {

    @Autowired
    private JdbcProperties jdbcProperties;

    @Bean
    public 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 {

    @Bean
    public 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>
	
    <servlet-name>springmvcservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
    
    <init-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:springmvc-servlet.xmlparam-value>
    init-param>
    
    
    <load-on-startup>1load-on-startup>
servlet>


<servlet-mapping>
    <servlet-name>springmvcservlet-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 {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle method is running!");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle method is running!");
    }

    @Override
    public 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="/**"/>
		
		
		<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 {
	
	// 注入拦截器
    @Autowired
    private HandlerInterceptor myInterceptor;
	
	// 设置拦截器(如果是拦截器链则按顺序执行),一个拦截器可配置多个拦截路径
    @Override
    public 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 {

    @Autowired
    private HandlerInterceptor myInterceptor;

    /**
     * 重写接口中的addInterceptors方法，添加自定义拦截器
     * @param registry
     */
    @Override
    public 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的依赖即可

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-jdbcartifactId>
dependency>


<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
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.hikari.idle-timeout=60000
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.minimum-idle=10

4.2 Druid连接池

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druid-spring-boot-starterartifactId>
    <version>1.1.6version>
dependency>


<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
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官方自己实现了：

<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>1.3.2version>
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的作者也为自己的插件编写了启动器，我们直接引入即可：

<dependency>
    <groupId>tk.mybatisgroupId>
    <artifactId>mapper-spring-boot-starterartifactId>
    <version>2.0.2version>
dependency>

不需要做任何配置就可以使用了。

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

---

6.整合事务

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

• xml时代

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

 
 <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 {

    @Autowired
    private UserMapper userMapper;

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

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

---

7.SpringBoot项目快速启动

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

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        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.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
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中设置多环境属性

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

<profiles>
	
    <profile>
        <id>dev_envid>
        <properties>
            <profile.active>devprofile.active>
        properties>
        <activation>
            <activeByDefault>trueactiveByDefault>
        activation>
    profile>
    
    
    <profile>
        <id>test_envid>
        <properties>
            <profile.active>testprofile.active>
        properties>
    profile>
profiles>

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

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

解析${}占位符

<build>
    <plugins>
        <plugin>
            <artifactId>maven-resources-pluginartifactId>
            <configuration>
                <encoding>utf-8encoding>
                <useDefaultDelimiters>trueuseDefaultDelimiters>
            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.bootgroupId>
    <artifactId>spring-boot-starter-testartifactId>
    <scope>testscope>
dependency>

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

@SpringBootTest
class Springboot07JunitApplicationTests {
    @Autowired
    private BookService bookService;

    @Test
    public void testSave() {
        bookService.save();
    }
}