SpringBoot

解解深入人心

已于 2022-08-02 08:47:25 修改

阅读量181

点赞数

文章标签： spring boot spring java

于 2022-07-21 21:02:19 首次发布

本文链接：https://blog.csdn.net/weixin_56162501/article/details/125919273

版权

b 1.什么是Springboot?

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

2.Springboot特点有哪些?

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

3.创建springboot工程

注意：

1.JDK必须为1.8以上

2.spring的jar必须5.0以上

3.maven必须3.3以上

3.1介绍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>

注意：默认springboot扫描的包为主启动类所在的包以及子包。

3.2. 关于SpringBoot的配置文件

第一种：properties属性文件

#设置端口号
server.port=3030

第二种：yml文件

#设置端口号
server:
  port: 3030

不管是哪种，他们的名字必须以application开始。

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

4.读取springboot配置文件中的内容

通过@PropertiesConfiguration或者@Value注解。

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

#设置端口号
server:
  port: 4040
student:
  name: lm
  age: 18
  hobby:
    -sing
    -swing
  map:
    clazz: qy151
    student: 1

#自定义配置信息
student.name=ldh
student.age=18
student.hobby[0]=swing
student.hobby[1]=sing
student.map.clzz=qy151
student.map.student=01

@RestController
public class HelloController {
    @Autowired
  private   Student student;
    //只能读取基本类型和字符串类型
    @Value("${student.name}")
    private String stuName;
    //启动时无法解析
    @Value("${student.map}")
    private Map<String,Object> map;
    @GetMapping("hello")
    public Student student(){
        System.out.println("==========="+stuName);
        return student;
    }
}

5.profiles文件的介绍

开发环境---->测试环境---->线上环境由于环境的不同，那么就会有不同的配置内容。

难道我们不断的修改配置内容。----不会

实际工作中，针对不同的环境配置不同的配置文件，然后再总的配置文件中激活相应的配置文件。

6. Springboot注册web三大组件。

什么是web三大组件

Servlet和Filter以及Linstener监听器。

为什么要注册这三个组件呢?

因为后面springboot有可能要集成第三方框架，而第三方框架的底层可能就依赖于过滤器或者servlet.

配置Servlet

public class Servlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("这是Servlet");
    }
}

public class MyConfig {
    @Bean //配置文件中的Bean
    public ServletRegistrationBean<Servlet> servletServletRegistrationBean(){
        ServletRegistrationBean<Servlet> servletServletRegistrationBean = new ServletRegistrationBean<>();
        servletServletRegistrationBean.setName("my");
        servletServletRegistrationBean.setServlet(new Servlet());
        servletServletRegistrationBean.addUrlMappings("my");
        return servletServletRegistrationBean;
    }
}

配置过滤器Filter

   @Bean
    public FilterRegistrationBean<Filter> filterRegistrationBean(){
        FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>();
        filterRegistrationBean.setName("myFilter");
        filterRegistrationBean.setFilter(((servletRequest, servletResponse, filterChain) -> {
            System.out.println("===============这是过滤器");
        }));
        filterRegistrationBean.addUrlPatterns("/*");
        return filterRegistrationBean;
    }

7.springboot自动装配原理。

什么是自动装配?

无需手动加载某些配置，而由Springboot自动加载进来。

譬如: 自己加载DispatcherServlet.

如何完成自动装配

为什么总的自动装配类由127个。因为这些自动装配类都在某个文件中写死了。

8.springboot整合数据源

数据源:即是：springboot框架连接数据库

1.引入依赖

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

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=root
spring.datasource.password=lzl200038

3.测试

@SpringBootTest
class SpringbootApplicationTests {
    @Autowired
    private DataSource dataSource ;


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

上面默认这个数据源使用的连接池Hikari。如果不想使用默认的连接池，我们可以引入第三方的连接池。

9.集成druid数据源

1.引入依赖

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

2.配置文件

#配置druid
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai
spring.datasource.druid.username=root
spring.datasource.druid.password=lzl200038
#初始化连接池个数
spring.datasource.druid.initial-size=5
#最大活跃数量
spring.datasource.druid.max-active=10
#最大等待时间
spring.datasource.druid.max-wait=3000
#最小限制数量
spring.datasource.druid.min-idle=5

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

3.测试

@SpringBootTest
class SpringbootApplicationTests {
    @Autowired
    private DataSource dataSource ;

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

10.spring整合mybatis

1.引入mybatis启动依赖

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

2.修改配置文件


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

3.在主启动类加上注解

@SpringBootApplication
@MapperScan(basePackages = "com.lzl.dao") //为指定的包下的接口生成代理实现类
public class Qy151SpringbootApplication {

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

}

4.测试

@SpringBootTest
class SpringbootApplicationTests {

    @Autowired
    private StudentDao studentDao;


    @Test
    public void findAll(){

        List<Map> all = studentDao.findAll();

        System.out.println(all);

    }

}

11.springboot整合PageHelper分页插件

1.引入依赖

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

2.测试

public void findAll(){
        PageHelper.startPage(1,3);
        List<Map> all = studentDao.findAll();
        PageInfo pageInfo = new PageInfo(all);
        System.out.println("当前页码:"+pageInfo.getPageNum());
        System.out.println("当前总页码:"+pageInfo.getPages());
        System.out.println("总条数:"+pageInfo.getTotal());
        System.out.println("当前页码的记录:"+pageInfo.getList());

    }

12.springboot整合swagger2.

什么是swagger2.

它是一个接口文档----用来前后端分离的一款文档。

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>

2.创建swagger配置类

@Configuration
public class SwaggerConfig {

        @Bean //swagger中所有的功能都封装在Docket类中
    public Docket docket() {
            Docket docket1 = new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())//设置api文档信息
                    .select()
                    //指定为哪些包下的类生成接口文档。
                    .apis(RequestHandlerSelectors.basePackage("com.lzl.controller"))
                    .build();
            return docket1;
        }
         //定义自己接口文档信息
        public  ApiInfo apiInfo (){
            Contact DEFAULT_CONTACT = new Contact("梁某人", "http://www.baidu.com", "171620711@qq.com");
            ApiInfo apiInfo = new ApiInfo("lzl的在线文档", "这是最牛文档", "1.0", "http://www.jd.com",
                    DEFAULT_CONTACT, "志远科技", "http://www.taobao.com", new ArrayList<VendorExtension>());
            return apiInfo;
        }

}

3.开启注解

package com.lzl;

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.lzl.dao")
@EnableSwagger2
public class SpringbootApplication {

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


}

4.使用swagger注解

@Api  接口类的注解---接口类上 tag属性
@ApiOperation  接口方法的注解---接口方法上 value:
@ApiImplicitParams( 接口参数的说明
    {
      ApiImplicitParam() //单个参数的说明
    }
)

@ApiModel---- 实体类接口注解
@ApiModelProperty---->实体类属性的说明

实例：

@RestController
@Api(tags = "这是hello的接口类")
public class HelloController {
    @Autowired
  private   Student student;
    @Autowired
    private StudentDao studentDao;
    //只能读取基本类型和字符串类型
    @Value("${student.name}")
    private String stuName;
    @GetMapping("hello")
    @ApiOperation(value = "这是个这个方法加的")
    public Student student(){
        System.out.println("==========="+stuName);
        return student;
    }

    @GetMapping("insert")
    @ApiOperation(value = "这是添加的接口")
    @ApiImplicitParams(
            {
                    @ApiImplicitParam(value = "添加的id",name = "id"),
                    @ApiImplicitParam(value = "添加的姓名",name = "name"),
                    @ApiImplicitParam(value = "添加的年龄",name = "age"),
                    @ApiImplicitParam(value = "添加的地址",name = "address")
            }
    )
    public CommonRrsult insert(Student1 student1){
        student1.setName("麦麦");
        student1.setAge(18);
        student1.setAddress("我家");
        int insert = studentDao.insert(student1);

        return new CommonRrsult(2000,"添加成功",null);
    }
    @ApiOperation("这是删除的接口")
    @GetMapping("delete")
    @ApiImplicitParams(
            @ApiImplicitParam(value = "删除的Id",name = "id",required = true)
    )
    public CommonRrsult delete(Integer id){
        studentDao.delete(id);
        return new CommonRrsult(2000,"删除成功",null);
    }
    @ApiOperation("这是查询单个的接口")
    @GetMapping("findById")
    @ApiImplicitParams(
            @ApiImplicitParam(value = "查询的编号",name = "id",required = true)
    )
    public CommonRrsult findById(Integer id){
        Map byId = studentDao.findById(id);
        return new CommonRrsult(2000,"查询成功",byId);
    }
    @ApiOperation("这是修改接口")
    @GetMapping("update")
    @ApiImplicitParams(
            {
                    @ApiImplicitParam(value = "需要修改的编号",name = "id",required = true),
                    @ApiImplicitParam(value = "修改后的姓名",name = "name",required = true),
                    @ApiImplicitParam(value = "修改后的年龄",name = "age",required = true),
                    @ApiImplicitParam(value = "修改后的地址",name = "address",required = true),

            }
    )
    public CommonRrsult updata(Student1 student1){
        int update = studentDao.update(student1);
        return new CommonRrsult(2000,"修改成功",null);
    }
}

package com.lzl.util;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.models.auth.In;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @create 2022-07-23
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "统一流的json数据")
public class CommonRrsult {
    @ApiModelProperty("状态码：2000代表成功，5000代表失败")
    Integer code;
    @ApiModelProperty("响应的信息")
    String mag;
    @ApiModelProperty("响应的数据")
    Object data;
}

5.访问

第一种: http://localhost:4041/swagger-ui.html

第二种: http://localhost4041/doc.html

13.springBoot整合定时器

1.什么是定时器

在指定的时间，执行相应的业务代码。

2.为什么使用定时器

比如: OSS文件系统服务器，会产生大量冗余文件。定时删除冗余文件【凌晨2~3点】。

比如: 下单后半个未支付--取消订单。

3.如何使用定时器

（1）引入定时器依赖

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

（2）编写任务代码

public class QuartzTask {


    //任务代码cron:定义定时任务的规则 https://www.pppet.net/
    @Scheduled(cron = "0/1 * * * * ?")
    public void task01(){
        System.out.println("业务代码");
    }
}

（3）开启定时任务的注解