• springboot基础

    目录

    一、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)

    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

     

     

    生成完成后一个springboot完成项目结构   

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

    1. @RestController
    2. @RequestMapping("/student")
    3. public class SutdentController {
    4.  
    5.     @RequestMapping("/getId")
    6.     public String getUserId(){
    7.         System.out.println("springboot is running...");
    8.         return "springboot is running...";
    9.     }
    10. }

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

    2.1.2、spring程序与springboot程序对比

     

    三、springboot启动原理

     

    • parent

    • starter

    • 引导类

    • 内嵌tomcat

     

    3.1、parent

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

    3.2、starter

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

    3.3、引导类

    注解@SpringBootApplication

    1. @SpringBootApplication
    2. public class TestApplication {
    3.  
    4.     public static void main(String[] args) {
    5.         SpringApplication.run(TestApplication.class, args);
    6.     }
    7. }

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

    第一个：@SpringBootConfiguration

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

    • 它只是@Configuration注解的派生注解

    • 它与@Configuration注解的功能一致

    • 只不过@SpringBootConfiguration是springboot的注解，而@Configuration是spring的注

    1. import lombok.Data;
    2. @Data
    3. public class User {
    4.  
    5.     private String username;
    6.     private Integer pwd;
    7.     
    8. }
    1.  
    2. @Configuration
    3. public class ConfigurationTest {
    4.  
    5.     public ConfigurationTest() {
    6.         System.out.println("容器初始化。。。");
    7.     }
    8.     
    9.     @Bean
    10.     public User getUser(){
    11.         User u = new User();
    12.         u.setUsername("张三");
    13.         return  u;
    14.     }
    15.  
    16.     public static void main(String[] args) {
    17.         ApplicationContext applicationContext =new             AnnotationConfigApplicationContext(ConfigurationTest.class);
    18.         User user = (User)applicationContext.getBean("getUser");
    19.         System.out.println(user);
    20.  
    21.     }
    22. }

      

      
    第二个：@ComponentScan：开启注解扫描：默认扫描@SpringBootApplication所在类的同级目录以及它的子目录
      
    image-20211012200517692
      

      
      ```java
      大概的意思：
      配置组件扫描的指令。提供了类似与标签的作用
      通过basePackageClassets或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包

     

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

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

    1.   @Target({ElementType.TYPE})
    2.   @Retention(RetentionPolicy.RUNTIME)
    3.   @Documented
    4.   @Inherited
    5.   @AutoConfigurationPackage
    6.   @Import({AutoConfigurationImportSelector.class})
    7.   public @interface EnableAutoConfiguration {
    8.       String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    9.   
    10.       Class[] exclude() default {};
    11.   
    12.       String[] excludeName() default {};
    13.   }

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

    1.    protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    2.           List configurations = 	                     SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
    3.           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.");
    4.           return configurations;
    5.       }

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

    3.4、内嵌tomcat

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

    1. <dependency>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-starter-webartifactId>
    4.     
    5.     <exclusions>
    6.         <exclusion>
    7.             <groupId>org.springframework.bootgroupId>
    8.             <artifactId>spring-boot-starter-tomcatartifactId>
    9.         exclusion>
    10.     exclusions>
    11. dependency>
    13. <dependency>
    14.     <groupId>org.springframework.bootgroupId>
    15.     <artifactId>spring-boot-starter-jettyartifactId>
    16. dependency>

    四、SpringBoot配置文件

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

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

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

     

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

    引入lombok 依赖

    1.  <dependency>
    2.        <groupId>org.projectlombokgroupId>
    3.        <artifactId>lombokartifactId>
    4.    dependency>

    编写controller类例如

    1. @RestController
    2. @RequestMapping("/user")
    3. public class UserController {
    4.     
    5.     // 可以引入lombok 用@Slf4j 替换这行代码
    6. 	private static Logger logger= LoggerFactory.getLogger(UserController.class);
    7.     @Autowired
    8.     private UserService userService;
    9.     
    10.     @RequestMapping("/getuser")
    11.     public User getuser(){
    12.         log.info("logback output console ... ");
    13.         return  userService.getuser();
    14.     }
    15.  
    16. }

    使用@Slf4j最好在idea中安装lombok插件  

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

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

    五、springboot属性注入

    1、Spring 配置类注解回顾

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

    常用注解说明
    @Configuration声明一个类作为配置类，代替 .xml 文件 代替 标签
    @Bean声明在方法上，将方法的返回值加入Bean容器，代替 标签
    @Value属性注入 获取属性值：@Value("${port}")
    @PropertySource指定外部属性文件

    2、SpringBoot的属性注入

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

    1. <dependency>
    2.       <groupId>mysqlgroupId>
    3.       <artifactId>mysql-connector-javaartifactId>
    4. dependency>
    5.  
    7. <dependency>
    8.     <groupId>org.springframework.bootgroupId>
    9.     <artifactId>spring-boot-starter-jdbcartifactId>
    10. dependency>
    11.  
    12. <dependency>
    13.     <groupId>com.alibabagroupId>
    14.     <artifactId>druid-spring-boot-starterartifactId>
    15.     <version>1.1.10version>
    16. dependency>
    17.  
    19. <dependency>
    20.     <groupId>org.springframework.bootgroupId>
    21.     <artifactId>spring-boot-configuration-processorartifactId>
    22.     <optional>trueoptional>
    23. dependency>

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

    • 编写application.properties配置文件
    1. myconfig.no=com.mysql.cj.jdbc.Driver
    2. myconfig.name=tom
    3. myconfig.age=12
    • 创建实体类  
    1. @Data
    2. @Component
    3. @ConfigurationProperties(prefix = "myconfig")
    4. public class Myconfig {
    5.    
    6.     private String name;
    7.     private String age;
    8.     private String no;
    9. }
    • 测试类  
    1. @SpringBootApplication
    2. public class DemoApplication {
    3.     public static void main(String[] args) {
    4.         ConfigurableApplicationContext run = SpringApplication.run(DemoApplication.class, args);
    5.         Myconfig myconfig = (Myconfig) run.getBean(Myconfig.class);
    6.         System.out.println(myconfig);
    7.     }
    8.  
    9. }

    b、@ConfigurationProperties普通注入

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

    • 编写application.properties配置文件  
    1. jdbc.driverClassName=com.mysql.cj.jdbc.Driver
    2. jdbc.url=jdbc:mysql://127.0.0.1:3306/mall_db?serverTimezone=UTC
    3. jdbc.username=root
    4. jdbc.password=123
    • 创建属性类：JdbcProperties  
    1. @Component
    2. @ConfigurationProperties(prefix = "jdbc")//根据前缀去springboot配置文件找对应的属性值
    3. @Data
    4. public class JdbcProperties {
    5.     //属性必须有get和set方法
    6.     private String url;
    7.     private String driverClassName;
    8.     private String username;
    9.     private String password;
    10. }

    1. 在类上通过@ConfigurationProperties注解声明当前类为属性读取类

    2. @Component创建该类的对象

    3. prefix="jdbc" 读取属性⽂件中，前缀为jdbc的值。

    4. 在类上定义各个属性，名称必须与属性⽂件中 jdbc. 后⾯部分⼀致，并且必须具有getter和setter⽅法

    • 编写配置类  
    1. @Configuration
    2. public class JdbcSourceConfig {
    3.     @Autowired
    4.     private JdbcProperties jdbcProperties;
    5.  
    6.     // 引入阿里连接池用DruidDataSource
    7.     @Bean
    8.     public DruidDataSource dataSource() {
    9.         DruidDataSource dataSource = new DruidDataSource();
    10.         dataSource.setUrl(jdbcProperties.getUrl());
    11.         dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
    12.         dataSource.setUsername(jdbcProperties.getUsername());
    13.         dataSource.setPassword(jdbcProperties.getPassword());
    14.         
    15.         System.out.println(jdbcProperties.getUrl());
    16.         return dataSource;
    17.     }
    18.     
    19.     // 引入 HikariCP 连接池用HikariDataSource
    20.     @Bean
    21.     public HikariDataSource dataSource() {
    22.         HikariDataSource dataSource = new HikariDataSource();
    23.         dataSource.setJdbcUrl(jdbcProperties.getUrl());
    24.         dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
    25.         dataSource.setUsername(jdbcProperties.getUsername());
    26.         dataSource.setPassword(jdbcProperties.getPassword());
    27.  
    28.         System.out.println(jdbcProperties);
    29.         return dataSource;
    30.     }
    31. }

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

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

    若使用DruidDataSource 需添加依赖

    1. <dependency>
    2.     <groupId>org.springframeworkgroupId>
    3.     <artifactId>spring-jdbcartifactId>
    4.     <version>5.3.9version>
    5. dependency>
    • 编写application.properties配置文件  
    1. jdbc.driverClassName=com.mysql.cj.jdbc.Driver
    2. jdbc.url=jdbc:mysql://127.0.0.1:3306/mall_db?serverTimezone=UTC
    3. jdbc.username=root
    4. jdbc.password=123
    • 编写配置类  
    1. /**
    2.  * 读取数据库连接信息配置类
    3.  */
    4. @Configuration
    5. public class DataSourceConfig {
    6.     /*
    7.     prefix:声明要注入的属性前缀，SpringBoot调用该方法创建对象时
    8.     根据前缀去application配置文件中找对应的属性，然后把属性的值注入给对象的同名属性
    9.     */
    10.     @Bean
    11.     @ConfigurationProperties(prefix = "jdbc")
    12.     public DataSource dataSource() {
    13.         HikariDataSource dataSource = new HikariDataSource();
    14.         return dataSource;
    15.     }
    16. }
    • 编写测试方法  
    1.  
    2. @SpringBootApplication
    3. public class ConfigurationpropertiesApplication {
    4.  
    5.     public static void main(String[] args)
    6.     {
    7.         ConfigurableApplicationContext run = SpringApplication.run(ConfigurationpropertiesApplication.class, args);
    8.         HikariDataSource dataSource = (HikariDataSource)run.getBean("dataSource"); //此处跟@Bean 注解的方法名一样
    9.         System.out.println(dataSource.getUsername());
    10.     }
    11.  
    12. }

     

     

     

     

     

     

     

     

     

     

     

     

     

  • 相关阅读:
    使用Docker+Jenkin自动化流水线
    C语言：如何给全局变量起一个别名？
    1341. 电影评分
    Java-HashMap中put()方法是如何实现的，内含详细流程图
    SpringBoot+Vue实现前后端分离的网吧管理系统
    Spring Boot：整合框架
    优秀程序员是怎么思考的？
    吴恩达深度学习deeplearning.ai——第一门课：神经网络与深度学习——第二节：神经网络基础（上）
    pg 时间操作方法
    移动端视频剪辑架构设计一
  • 原文地址：https://blog.csdn.net/magic_818/article/details/128202529