springboot的相关内容

Yu_HM

已于 2022-07-23 15:54:49 修改

阅读量230

点赞数

于 2022-07-23 15:46:35 首次发布

本文链接：https://blog.csdn.net/Yu_HM/article/details/125947050

版权

1.什么是Springboot?

springboot可以帮你简化spring的搭建，并且快速创建一个spring的应用程序。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置

1.1 Springboot特点有哪些?

（1）可以创建独立的Spring应用程序，并且基于其Maven或Gradle插件，可以创建可执行的JARs和WARs；
（2）内嵌Tomcat或Jetty等Servlet容器；
（3）提供自动配置的“starter”项目对象模型（POMS）以简化Maven配置；
（4）尽可能自动配置Spring容器；
（5）提供准备好的特性，如指标、健康检查和外部化配置；
（6）绝对没有代码生成，不需要XML配置。

1.2 创建springboot工程

1.JDK必须为1.8以上

2.spring的jar必须5.0以上

3.maven必须3.3以上

1.3 第一个SpringBoot程序

@RestController
public class Hello {

    @RequestMapping("/hello")
    public String getHello(){
        return "Hello SpringBoot";
    }
}

1.4 常见的注解

@SpringBootConfiguration :表示Spring Boot的配置
@Configuration：表是Spring的配置类
@Component：说明这也是一个Spring的组件
@EnableAutoConfiguration：表示自动配置

@AutoConfigurationPackage：自动配置包
@Import(AutoConfigurationPackageRegistrar.class）：自动配置包注册
@Import（AutoConfigurationImportSelector.class）:自动导入选择

@SpringBootApplication:注解可以让当前类成为一个配置类，自动扫描用户的包，以及最重要的一个功能:开启springboot的自动配置功能

SpringBoot所有自动配置都是在启动的时候扫描并加载，Spring.factories所有的自动配置类都在这里面，但是不一定失效，要判断条件四否成立，只要导入对应的start，就有对应的启动器了，有了启动器，我们自动装配就会生效。然后就是配置成功！

springBoot在启动的时候，从类路径下/META-INF/spring.factories获取指定值；
将这些自动配置的类导入容器，自动配置就会生效，帮我们进行自动配置
spring boot现在将自动配置文件
整合jaavEE，解决方案和自动配置的东西都在spring-boot-autorconfigure-2.20.RELEASE.jar这个包下
他会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器
容器中也会存在非常多的xxxautoConfiguration的文件，就是这些类给容器中导入这个场景所需要的组件并进行自动的配置，@Configuration ，javaConfig！
有了自动配置类，免去了手动编写配置文件的工作

2.自动装配：

2.1 自动装配的原理：

1.SpringBoot启动会加载大量的自动加载类
2.我们看我们需要的功能有没有在SpringBoot中默认写好的自动配置类当中
3.我们再来看这个的自动配置类中到底配置了那些组件（只要我们要用的组件存在其中，我们就不需要在手动配置了）
4.给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，。我们只需要在配置文件中指定这些属性即可
5.xxxAutoConfiguration：自动配置类；给容器添加组件
6.xxxxProperties:封装配置文件中的相关的属性

run()方法，其所作的事情
- 推断应用的类型是普通的项目还是web项目
- 查找并加载所有可用的初始化器，设置到initializers属性中
- 找出所有的应用程序监听器，设置到listeners属性中
- 推断并设置main方法的定义类，找到运行的主类

3.属性赋值

3.1 .properties 和 yml配置文件

1．properties 和 yml，它们的区别主要是书写格式不同。

2. yml 格式不⽀持@PropertySource 注解导⼊配置。

3.properties 和 yml 中包含相同属性时，properties 文件优先级高于 yml 文件。

SpringBoot使用一个全局的配置文件，配置文件名称是固定的。不管是哪种，他们的名字必须以application开始。

如果两个配置文件同时存在，而且有些内容一样。按照properties的优先级高。如果有些不一样，两个配置文件不一样的会合并在一起。

(1) . application.properties
语法结构：

# 修改springboot中tomcat端口号.
server.port=0705

(2) .application.yml
语法结构：

server:
port: 0712

yaml与properties的比较：

5620a577f16f517112059d36575ba675.png (832×262)

yaml概述

YAML是 “YAML Ain’t a Markup Language” （YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）。这种语言以数据作为中心，而不是以标记语言为重点！

什么是yaml？

YAML 是一种人类可读的数据序列化语言。它通常用于配置文件。与属性文件相比，如果我们想要在配置文件中添加复杂的属性，YAML文件就更加结构化，而且更少混淆。可以看出 YAML 具有分层配置数据。

yaml基本语法：

注意：yaml的语法要求十分严格，必须按照其中的规范进行编写

1.空格不能省略

2.以缩进来控制层级关系，只要是左边对齐的一列数据都是同一个级层的

3.属性和值的大小写都是十分的敏感的

例如：

server:
	port: 8081

yaml文件的强大在于，它可以给我们的实体类直接注入匹配的值

配置文件的作用：

修改SpringBoot自动配置的默认值，因为SpringBoot在底层都给我们自动配置好了；

比如我们可以在配置文件中修改Tomcat 默认启动的端口号！测试一下！

4. profiles文件的介绍：

5. Spring boot的配置

1.yaml可以直接给实体类进行赋值

2.报红的解决方法

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

6. springboot整合数据源

数据源: 指的是数据源。即是: springboot框架连接数据库。

6.1 引入依赖：

 <!--加入数据源的启动依赖: springboot启动时会加载对应的自动装配类。-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

6.2 配置数据源信息---application.properties

# 配置数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.username=你的数据库名字
spring.datasource.password=你的数据库密码

6.3 测试

@SpringBootTest(classes = SpringbootApplication.class)
class SpringbootApplicationTests {

    @Autowired
    private DataSource dataSource;


    @Test
    public void test01() throws SQLException {
        //验证了springboot可以帮你完成数据源的自动装配功能
        System.out.println(dataSource.getConnection());
    }

}

7. 集成druid数据源

7.1 依赖

 <!--引入数据库连接池druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

7.2 配置文件

spring.datasource.druid.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.username=root
spring.datasource.druid.password=070512

#初始化的个数
spring.datasource.druid.initial-size=5
# 最大活跃数
spring.datasource.druid.max-active=10
# 最大等待时间
spring.datasource.druid.max-wait=3000
# 最小的闲置个数
spring.datasource.druid.min-idle=5

7.3 测试

@Test
    public void test01() throws SQLException {
        //验证了springboot可以帮你完成数据源的自动装配功能
        System.out.println(dataSource);
        System.out.println(dataSource.getConnection());
    }

8. springboot整合mybatis：

8.1 引入mybatis启动依赖类

        <!--引入mybatis的启动依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

8.2 修改配置文件

#指定映射文件的路径
mybatis.mapper-locations=classpath:mapper/*.xml

8.3 再主启动类加上注解

@SpringBootApplication
//为指定的包下的接口生成代理实现类
@MapperScan(basePackages = "com.yhm.dao")
//开启swagger注解
@EnableSwagger2
public class SpringbootApplication {

    public static void main(String[] args) {
//加载那含有@SpringBootApplication注解的类,它的特殊之处就是该类使用了@SpringBootApplication ，它是一个复合组件。
        //@EnableAutoConfiguration
        SpringApplication.run(SpringbootApplication.class, args);
    }


}

8.4 测试

@Autowired
    private DeptMapper deptMapper;

 //根据id查询
    @Test
    public void test02(){
        System.out.println(deptMapper.findById(1));
    }
}

修改端口:

在全局配置文件（application.properties）中进行修改:server.port=8081

#自定义的配置信息

#自定义的配置信息
student.name=yhm
student.age=28
student.hobby[0]=drawing
student.hobby[1]=reading

@Data
@Component //该类对象的创建和销毁都有spring容器来管理
@ConfigurationProperties(prefix = "student")    //读取springboot中的配置内容
public class Student {
    private String name;
    private Integer age;
    private String[] hobby;
}

@Autowired  //spring容器帮你注入该对象
    private Student student;
    @GetMapping("/index")
    public Student index(){

        return student;
    }

9. springboot整合PageHelper分页插件

9.1 引入依赖

  <!--pageHelper的启动依赖 自动装配拦截器-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.2</version>
        </dependency>

9.2 测试：

 @Test
    public void test03(){
        Page<Object> page = PageHelper.startPage(1, 5);
        List<Dept> list = deptMapper.findAll();
        PageInfo<Dept> pageInfo=new PageInfo<>(list);
        System.out.println("当前页码:"+pageInfo.getPageNum());
        System.out.println("当前总页码:"+pageInfo.getPages());
        System.out.println("总条数:"+pageInfo.getTotal());
        System.out.println("当前页码的记录:"+pageInfo.getList());
    }

10. springboot整合swagger2.

10.1 引入swagger依赖


        <dependency>
            <groupId>com.spring4all</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
            <version>1.9.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.7.8</version>
        </dependency>

10.2 创建swagger配置类

package com.yhm.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.VendorExtension;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

import java.util.ArrayList;

@Configuration
public class SwaggerConfig {

    @Bean //swagger中所有的功能都封装再Docket类中。
    public Docket docket() {
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                 //设置api文档信息
                .apiInfo(apiInfo())
                .select()
                //指定为哪些包下的类生成接口文档。
                .apis(RequestHandlerSelectors.basePackage("com.yhm.controller"))
                .build()
                ;

        return docket;
    }

    //定义自己接口文档的信息
    private ApiInfo apiInfo() {
        Contact DEFAULT_CONTACT = new Contact("梁又年", "http://www.baidu.com", "2714599870@qq.com");
        ApiInfo apiInfo = new ApiInfo("Lyn在线文档", "这个文档很厉害", "V1.0", "http://www.jd.com",
                DEFAULT_CONTACT, "海城科技大学", "http://www.taobao.com", new ArrayList<VendorExtension>());

        return apiInfo;
    }

}

10.3 开启swagger注解

package com.yhm;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
//为指定的包下的接口生成代理实现类
@MapperScan(basePackages = "com.yhm.dao")
//开启swagger注解
@EnableSwagger2
public class SpringbootApplication {

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




}

11. SpringBoot中常用的pom文件：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--parent: 继承
           如果你的maven项目想成为springboot工程必须继承SpringBoot父依赖
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ykq</groupId>
    <artifactId>qy151-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>qy151-springboot</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--web的启动依赖 把spring中常见的jar都集成到该依赖中,集成了springmvc的启动配置类 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>