springboot基础

柔情只为你懂 2023-10-11 20:06 53阅读 0赞

**目录**

一、springboot介绍

1、什么是SpringBoot

二、springboot入门案列

2.1、使用idea自动生成springboot工程

2.1.1、用idea自动生成springboot

2.1.2、spring程序与springboot程序对比

三、springboot启动原理

3.1、parent

3.2、starter

3.3、引导类

3.4、内嵌tomcat

四、SpringBoot配置文件

五、springboot属性注入

1、Spring 配置类注解回顾

2、SpringBoot的属性注入

a，自定义属性注入到实体类

b、@ConfigurationProperties普通注入

c、@ConfigurationProperties更优雅的注入（使用starter-jdbc 连接池）

--------------------

## 一、springboot介绍 ##

Spring Boot 是由 Pivotal 团队提供的基于 Spring 的全新框架，其设计目的是为了简化 Spring 应用的搭建和开发过程。该框架遵循『约定大于配置』原则，采用特定的方式进行配置，从而使开发者无需定义大量的 XML 配置。通过这种方式，Spring Boot 致力于在蓬勃发展的快速应用开发领域成为领导者。

Spring Boot 并不重复造轮子，而且在原有 Spring 的框架基础上封装了一层，并且它集成了一些类库（提供了默认的配置），用于简化开发。简而言之，Spring Boot 就是一个大容器，其中包含了很多类库的默认配置，你只需要在项目中引入这些类库即可使用

spring boot重要性：几乎所有Java互联网项目都用springboot, 是从事Java开发学程序必备技能，没有之一(官网：[Spring | Home][Spring _ Home])

#### 1、什么是SpringBoot ####

SpringBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品，人们把Spring Boot称为搭建程序的『**脚手架**』。其最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让我们关注于业务而非配置。我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

SpringBoot 主要特点和目标是：

*  为所有 Spring 的开发者提供一个非常快速的、广泛接受的入门体验
 *  直接内嵌tomcat、jetty和undertow（不需要打包成war包部署）
 *  提供了固定化的“starter”配置，以简化构建配置（启动器 **starter-\*** 其实就是 Spring Boot 提供的一个 jar 包），但通过自己设置参数（*.properties* 或 *.yml* ），即可快速摆脱这种方式。
 *  提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
 *  绝对没有代码生成，也无需 XML 配置
 *  独立运行的Spring项目：以jar包的形式独立运行，运行一个SpringBoot项目只需通过java -jar xx.jar来运行

## 二、springboot入门案列 ##

### 2.1、使用idea自动生成springboot工程 ###

#### 2.1.1、用idea自动生成springboot ####

![43bddcab82d94e8ba7817b98a7da9e1f.png][]

![4965b7829f0540d68835b0a5ade8dfd9.png][]

![5aef2531e76c430baf0b97c66c2f21c6.png][]

生成完成后一个springboot完成项目结构 ![3f80be3959914788bd86e6a6d30159ec.png][]

接下来的编码工作，就是正常的 Spring MVC 项目的开发过程，写一个Controller 类

@RestController
    @RequestMapping("/student")
    public class SutdentController {
    
        @RequestMapping("/getId")
        public String getUserId(){
            System.out.println("springboot is running...");
            return "springboot is running...";
        }
    }

补充：使用springboot官网（[https://start.spring.io][https_start.spring.io]）创建工程因为是国外的网站有时会很卡，也可以用阿里云创建（[http://start.aliyun.com][http_start.aliyun.com]）

#### 2.1.2、spring程序与springboot程序对比 ####

![6215ffdb0c6f43a6840964d4dfae93a3.png][]

## 三、springboot启动原理 ##

*  parent
 *  starter
 *  引导类
 *  内嵌tomcat

### 3.1、parent ###

提供了springboot统一的依赖管理和插件管理，主要的依赖其实就是继承了spring-boot-dependencies，本质上是继承了它然后扩展了插件配置

### 3.2、starter ###

spring boot中常用的项目名称，定义了当前项目使用的所有依赖坐标，以达到减少配置作用

### 3.3、引导类 ###

注解@SpringBootApplication

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

发现这注解是个复合注解，也有叫组合注解，这里重点的注解有3个：

第一个：@SpringBootConfiguration

可以简单的理解为就是一个@Configuration注解， 从Spring3.0开始，@Configuration用于定义配置类，可替换xml文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplication或AnnotationConfigWebApplication类进行扫描，并用于构建bean定义，初始化Spring容器。

*  它只是@Configuration注解的派生注解
 *  它与@Configuration注解的功能一致
 *  只不过@SpringBootConfiguration是springboot的注解，而@Configuration是spring的注

import lombok.Data;
    @Data
    public class User {
    
        private String username;
        private Integer pwd;
        
    }

@Configuration
    public class ConfigurationTest {
    
        public ConfigurationTest() {
            System.out.println("容器初始化。。。");
        }
        
        @Bean
        public User getUser(){
            User u = new User();
            u.setUsername("张三");
            return  u;
        }
    
        public static void main(String[] args) {
            ApplicationContext applicationContext =new             AnnotationConfigApplicationContext(ConfigurationTest.class);
            User user = (User)applicationContext.getBean("getUser");
            System.out.println(user);
    
        }
    }

>   
> 第二个：**@ComponentScan**：开启注解扫描：默认扫描**@SpringBootApplication**所在类的同级目录以及它的子目录  
>   
> <img src="assets\\image-20211012200517692.png" alt="image-20211012200517692" style="zoom: 80%;" />  
> 
> 
>   
> \`\`\`java  
> 大概的意思：  
> 配置组件扫描的指令。提供了类似与<context:component-scan>标签的作用  
> 通过basePackageClassets或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包

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

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

@Target({ElementType.TYPE})
      @Retention(RetentionPolicy.RUNTIME)
      @Documented
      @Inherited
      @AutoConfigurationPackage
      @Import({AutoConfigurationImportSelector.class})
      public @interface EnableAutoConfiguration {
          String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
      
          Class<?>[] exclude() default {};
      
          String[] excludeName() default {};
      }

该注解引入了AutoConfigurationImportSelector.class这个类，在该类中有如下方法，启动时会调用该方法

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
              List<String> configurations = 	                     SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
              Assert.notEmpty(configurations, "No auto configuration classets found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
              return configurations;
          }

可以看到该方法内部调用了loadFactoryNames（），该方法是获取配置类下的全限定名，它会去spring-boot-autoconfigure:2.3.7里面找META-INF/spring.factories，这个文件里就是大量配置类的全限定名 ![78f79bfd90d54f77bc63d6bfe13cf1c0.png][]

### 3.4、内嵌tomcat ###

springboot内置服务器默认是tomcat，应为引入的spring-boot-starter-web中依赖了spring-boot-starter-tomcat，当然也可以手动关闭依赖使用别的服务器

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>

## 四、SpringBoot配置文件 ##

springboot全局属性有很多，下面以logback日志为例

日志级别：debug > info > warning > error > critical

Spring Boot 直接使用 slf4j ，默认间接使用 logback 日志，因此，它支持直接在 **`.properties`** 和 **`.yml`** 文件(**`.yaml`** 文件)中对日志的相关信息进行配置

logging.level.root=INFO
    logging.level.cn.woniu.dao=DEBUG
    logging.pattern.console='%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n'
    logging.file.path=D:/mylog/log.log

引入lombok 依赖

<dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
       </dependency>

编写controller类例如

@RestController
    @RequestMapping("/user")
    public class UserController {
        
        // 可以引入lombok 用@Slf4j 替换这行代码
    	private static Logger logger= LoggerFactory.getLogger(UserController.class);
        @Autowired
        private UserService userService;
        
        @RequestMapping("/getuser")
        public User getuser(){
            log.info("logback output console ... ");
            return  userService.getuser();
        }
    
    }

使用@Slf4j最好在idea中安装lombok插件 ![8d32efaab5fe4c4f93b25605b2ced6df.png][]

还可以修改spring启动控制台标志

spring.banner.charset=utf-8
    spring.banner.location=classpath:txt/banner.txt

## 五、springboot属性注入 ##

### 1、Spring 配置类注解回顾 ###

从 Spring 3.0 开始，Spring 官方就推荐大家使用 java 代码配置来代替以前的 xml 文件配置。而到了 SpringBoot，Java 代码配置更是成了标配。Java 代码配置主要靠 Java 类和一些注解，比较常用的注解有：

<table> 
 <thead> 
  <tr> 
   <th>常用注解</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Configuration</td> 
   <td>声明一个类作为配置类，代替 <em><code>.xml</code></em> 文件 代替 <em><code>&lt;beans&gt;</code></em> 标签</td> 
  </tr> 
  <tr> 
   <td>@Bean</td> 
   <td>声明在方法上，将方法的返回值加入Bean容器，代替 <em><code>&lt;bean&gt;</code></em> 标签</td> 
  </tr> 
  <tr> 
   <td>@Value</td> 
   <td>属性注入 获取属性值：@Value<code>(</code>"${port}")</td> 
  </tr> 
  <tr> 
   <td>@PropertySource</td> 
   <td>指定外部属性文件</td> 
  </tr> 
 </tbody> 
</table>

### 2、SpringBoot的属性注入 ###

在SpringBoot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

<dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>

#### a，自定义属性注入到实体类 ####

*  编写application.properties配置文件

myconfig.no=com.mysql.cj.jdbc.Driver
    myconfig.name=tom
    myconfig.age=12

*  创建实体类

@Data
    @Component
    @ConfigurationProperties(prefix = "myconfig")
    public class Myconfig {
       
        private String name;
        private String age;
        private String no;
    }

*  测试类

@SpringBootApplication
    public class DemoApplication {
        public static void main(String[] args) {
            ConfigurableApplicationContext run = SpringApplication.run(DemoApplication.class, args);
            Myconfig myconfig = (Myconfig) run.getBean(Myconfig.class);
            System.out.println(myconfig);
        }
    
    }

#### b、@ConfigurationProperties普通注入 ####

该注解为属性注值，**该注解声明当前类为属性读取类**

*  编写application.properties配置文件

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://127.0.0.1:3306/mall_db?serverTimezone=UTC
    jdbc.username=root
    jdbc.password=123

*  创建属性类：JdbcProperties

@Component
    @ConfigurationProperties(prefix = "jdbc")//根据前缀去springboot配置文件找对应的属性值
    @Data
    public class JdbcProperties {
        //属性必须有get和set方法
        private String url;
        private String driverClassName;
        private String username;
        private String password;
    }

1.  在类上通过**@ConfigurationProperties**注解声明当前类为属性读取类
2.  **@Component**创建该类的对象
3.  prefix="jdbc" 读取属性⽂件中，前缀为jdbc的值。
4.  在类上定义各个属性，名称必须与属性⽂件中 jdbc. 后⾯部分⼀致，并且必须具有getter和setter⽅法

*  编写配置类

@Configuration
    public class JdbcSourceConfig {
        @Autowired
        private JdbcProperties jdbcProperties;
    
        // 引入阿里连接池用DruidDataSource
        @Bean
        public DruidDataSource dataSource() {
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setUrl(jdbcProperties.getUrl());
            dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
            dataSource.setUsername(jdbcProperties.getUsername());
            dataSource.setPassword(jdbcProperties.getPassword());
            
            System.out.println(jdbcProperties.getUrl());
            return dataSource;
        }
        
        // 引入 HikariCP 连接池用HikariDataSource
        @Bean
        public HikariDataSource dataSource() {
            HikariDataSource dataSource = new HikariDataSource();
            dataSource.setJdbcUrl(jdbcProperties.getUrl());
            dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
            dataSource.setUsername(jdbcProperties.getUsername());
            dataSource.setPassword(jdbcProperties.getPassword());
    
            System.out.println(jdbcProperties);
            return dataSource;
        }
    }

#### c、@ConfigurationProperties更优雅的注入（使用starter-jdbc 连接池） ####

我们直接把`@ConfigurationProperties(prefix = "jdbc")`声明在需要使用的`@Bean`的方法上，

若使用DruidDataSource 需添加依赖

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.9</version>
    </dependency>

*  编写application.properties配置文件

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://127.0.0.1:3306/mall_db?serverTimezone=UTC
    jdbc.username=root
    jdbc.password=123

*  编写配置类

/**
     * 读取数据库连接信息配置类
     */
    @Configuration
    public class DataSourceConfig {
        /*
        prefix:声明要注入的属性前缀，SpringBoot调用该方法创建对象时
        根据前缀去application配置文件中找对应的属性，然后把属性的值注入给对象的同名属性
        */
        @Bean
        @ConfigurationProperties(prefix = "jdbc")
        public DataSource dataSource() {
            HikariDataSource dataSource = new HikariDataSource();
            return dataSource;
        }
    }

*  编写测试方法

@SpringBootApplication
    public class ConfigurationpropertiesApplication {
    
        public static void main(String[] args)
        {
            ConfigurableApplicationContext run = SpringApplication.run(ConfigurationpropertiesApplication.class, args);
            HikariDataSource dataSource = (HikariDataSource)run.getBean("dataSource"); //此处跟@Bean 注解的方法名一样
            System.out.println(dataSource.getUsername());
        }
    
    }

###  ###

[Spring _ Home]: https://spring.io
[43bddcab82d94e8ba7817b98a7da9e1f.png]: https://img-blog.csdnimg.cn/43bddcab82d94e8ba7817b98a7da9e1f.png
[4965b7829f0540d68835b0a5ade8dfd9.png]: https://img-blog.csdnimg.cn/4965b7829f0540d68835b0a5ade8dfd9.png
[5aef2531e76c430baf0b97c66c2f21c6.png]: https://img-blog.csdnimg.cn/5aef2531e76c430baf0b97c66c2f21c6.png
[3f80be3959914788bd86e6a6d30159ec.png]: https://img-blog.csdnimg.cn/3f80be3959914788bd86e6a6d30159ec.png
[https_start.spring.io]: https://start.spring.io
[http_start.aliyun.com]: http://start.aliyun.com
[6215ffdb0c6f43a6840964d4dfae93a3.png]: https://img-blog.csdnimg.cn/6215ffdb0c6f43a6840964d4dfae93a3.png
[78f79bfd90d54f77bc63d6bfe13cf1c0.png]: https://img-blog.csdnimg.cn/78f79bfd90d54f77bc63d6bfe13cf1c0.png
[8d32efaab5fe4c4f93b25605b2ced6df.png]: https://img-blog.csdnimg.cn/8d32efaab5fe4c4f93b25605b2ced6df.png