SpringBoot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid applicationdevelopment) 成为领导者。

SpringBoot是由Pivotal团队在2013年开始研发、2014年4月发布第一个版本的全新开源的轻量级框架。它基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。

SpringBoot所具备的特征有：

（1）可以创建独立的 Spring 应用程序，并且基于其 Maven 或 Gradle 插件，可以创建可执行的 JARs 和 WARs；

（2）内嵌 Tomcat 或 Jetty 等 Servlet 容器；

（3）提供自动配置的 “starter” 项目对象模型（ POMS ）以简化 Maven 配置；

（4）尽可能自动配置 Spring 容器；

（5）提供准备好的特性，如指标、健康检查和外部化配置；

（6）绝对没有代码生成，不需要 XML 配置

2.SpringBoot项目构建

2.1 idea创建

我们通过基本的 Maven 项目来手动配置一个 SpringBoot

2.1.1 创建MAVEN项目

创建一个普通的 Maven 项目即可

2.1.2 依赖

springboot的版本太高会可能和其他依赖不兼容，而且文件太大需要maven进行下载，我这里使用的是老版本

2.2 在线构建

我们也可以通过 SpringBoot 提供的在线地址创建我们的 SpringBoot 项目 : https://start.spring.io/

在线生成我们的SpringBoot项目，解压后可以直接导入

3. SpringBoot基本使用

3.1 自定义控制器

我们创建的是一个基于 SpringBoot 的 WEB 项目，那么怎么处理客户端提交的请求呢？这时我们可

以直接在启动器所在的子目录下创建对应的 Controller 即可

@RestController 
public class HelloController { 
        @RequestMapping("/hello") 
        public String hello(){ 
                System.out.println("hello ..."); 
                return "Hello ..."; 
    } 
}

为什么能够扫描到这个 @Controller 注解，根本原因是在我们的启动器中@SpringBootApplication注解，这个注解本身是一个组合注解

注解说明

@SpringBootConfiguration

也是一个组合注解，包含@Configuriation，标注当前注解的类是一个配置类

@EnableAutoConfiguration

完成依赖的自动配置的一个注解，是自动装配的核心注解

@ComponentScan

指定扫描路径的注解，如果不去指定默认会将当前类所在的目录及其子目录作为扫描路径

3.2属性文件

在 resource 目录下的 application.properties 文件

3.2.1 默认设置

我们可以通过 application.properties 文件来修改系统默认的属性，比如修改 Tomcat 相关配置信息

有两种格式的配置文件:

修改springboot中tomcat端口号.

第一种： properties属性文件
server.port=8888
server.servlet.context-path=/springboot
第二种: yml文件
server:
  port: 6666
不管是哪种，他们的名字必须以application开始。

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

OSS文件上传

密钥和bucket名称等---密钥和bucket都写死在java代码中。如果后期修改密钥和bucket的值，你必须修改源码代码。我们要写在配置文件。然后通过代码在读取配置文件中的密钥和bucket.

如何读取springboot配置文件的内容呢?

通过@PropertiesConfiguration或者@Value注解。

@PropertiesConfiguration该注解使用在类上。

#自定义的配置信息
student.name=ldh
student.age=15
student.hobby[0]=sing
student.hobby[1]=swing

@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;
    }

3.3 Servlet操作

我们在项目开发过程中可以要碰到直接操作 Servlet 的情况，这时我们应该怎么去实现

3.3.1Servlet

第一种方式 定义Servlet

@WebServlet(name="firstServlet",urlPatterns = "/first") 
public class FirstServlet extends HttpServlet { 
    @Override 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
     System.out.println("--firstServlet -- doGet 方法");
     PrintWriter writer = resp.getWriter(); 
    writer.write("success");
     writer.flush(); 
    writer.close(); 
    } 
}

启动类中添加扫描的注解

@SpringBootApplication // 在SpringBoot项目启动的时候会扫描 
@WebServlet注解
 @ServletComponentScan 
public class SpringbootDemo06Application { 
        public static void main(String[] args) {        
        SpringApplication.run(SpringbootDemo06Application.class, args);
     } 
}

第二种方式

创建 Servlet, 不用添加 WebServlet 注解

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("--secondServlet -- doGet 方法");
        PrintWriter writer = resp.getWriter();
        writer.write("success");
        writer.flush();
        writer.close();
    }

在启动类中注入 ServletRegistrationBean 对象

@ServletComponentScan
public class SpringbootDemo06Application {

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

    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new SecondServlet());
        bean.addUrlMappings("/second");
        return bean;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean = new FilterRegistrationBean(new SecondFilter());
        bean.addUrlPatterns("/second");
        return bean;
    }
    @Bean
    public ServletListenerRegistrationBean servletListenerRegistrationBean(){
        return new ServletListenerRegistrationBean(new SecondListener());
    }

3.3.2 Filter

@WebFilter(urlPatterns = "/first")
public class FirstFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("FirstFilter before");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("FirstFilter end");
    }
}

4.springboot自动装配原理。

什么是自动装配?

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

譬如: 自己加载DispatcherServlet.

如何完成自动装配?

在编写SpringBoot项目时，@SpringBootApplication是最常见的注解了，我们可以看一下里面的源代码：

在这里插入图片描述

这里面包含了：

@SpringBootConfiguration
- 我们点进去通过源码得知他是一个@Configuration，所以也就是对spring原生注解的封装
@EnableAutoConfiguration
@ComponentScan
- 默认扫描的是与该类同级的类或者同级包下的所有类，是spring的原生注解之一

@EnableAutoConfiguration（重头戏——自动装配核心）

一旦加上此注解，那么将会开启自动装配功能，容易点讲，Spring会试图在自己的classpath（类路径）下找到所有配置的Bean然后进行装配。
装配Bean时，会根据若干个(Conditional)定制规则来进行初始化。我们看一下它的源码：

在这里插入图片描述

该接口主要是为了导入@Configuration的配置项，而DeferredImportSelector是延期导入，当所有的@Configuration都处理过后才会执行。
回过头来我们看一下AutoConfigurationImportSelector的自动配备核心方法 selectImport

//自动装配的方法@Overridepublic String[] selectImports(AnnotationMetadata annotationMetadata) { if (!isEnabled(annotationMetadata)) { //判断是否自动装配 return NO_IMPORTS; } AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata); return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) { if (!isEnabled(annotationMetadata)) { return EMPTY_ENTRY; } //获取所有元数据信息 AnnotationAttributes attributes = getAttributes(annotationMetadata); //获取所有加载bean的条件配置 List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes); //过滤并删除掉重复的bean configurations = removeDuplicates(configurations); Set<String> exclusions = getExclusions(annotationMetadata, attributes); checkExcludedClasses(configurations, exclusions); configurations.removeAll(exclusions); configurations = getConfigurationClassFilter().filter(configurations); fireAutoConfigurationImportEvents(configurations, exclusions); return new AutoConfigurationEntry(configurations, exclusions);}

该方法刚开始会先判断是否进行自动装配，而后会从META-INF/spring-autoconfigure-metadata.properties读取元数据与元数据的相关属性，紧接着会调用getCandidateConfigurations方法：

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

在这里又遇到我们的老熟人了–SpringFactoryiesLoader, 它会读取META-INF/spring.factories下的EnableAutoConfiguration的配置，紧接着在进行排除与过滤，进而得到需要装配的类。最后让所有配置在META-INF/spring.factories下的AutoConfigurationImportListener执行AutoConfigurationImportEvent事件，代码如下：

private void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) { List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners(); if (!listeners.isEmpty()) { AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions); for (AutoConfigurationImportListener listener : listeners) { invokeAwareMethods(listener); listener.onAutoConfigurationImportEvent(event); } } } protected List<AutoConfigurationImportListener> getAutoConfigurationImportListeners() { return SpringFactoriesLoader.loadFactories(AutoConfigurationImportListener.class, this.beanClassLoader); }

总结：

自动装配还是利用了SpringFactoriesLoader来加载META-INF/spring.factoires文件里所有配置的EnableAutoConfgruation，它会经过exclude和filter等操作，最终确定要装配的类

5.springboot整合数据源

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

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

（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=123456

（3）测试

@SpringBootTest(classes = Qy151SpringbootApplication.class)
class Qy151SpringbootApplicationTests {


    @Autowired
    private DataSource dataSource;

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

}

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

6.集成druid数据源

（1）依赖

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

（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=123456
#初始化的个数
spring.datasource.druid.initial-size=5
# 最大活跃数
spring.datasource.druid.max-active=10
# 最大等待时间
spring.datasource.druid.max-wait=3000
# 最小的闲置个数
spring.datasource.druid.min-idle=5

（3）测试


    @Autowired
    private DataSource dataSource;

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

7. springboot整合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.ykq.dao") //为指定的包下的接口生成代理实现类
public class Qy151SpringbootApplication {

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

}

（4）测试

 @Autowired
    private DeptMapper deptMapper;

    @Test
    public void test02(){
        System.out.println(deptMapper.findById(1));
    }

8. springboot整合PageHelper分页插件

（1）引入依赖

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

（2）测试:

  @Test
    public void test03(){
         PageHelper.startPage(1, 3);
        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());

    }

9.springboot整合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 docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())//设置api文档信息
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.test.demo.controller")) //指定为哪些包下的类生成接口文档。
                .build()
                ;

        return docket;
    }

    //定义自己接口文档信息
    private ApiInfo apiInfo() {
        Contact DEFAULT_CONTACT = new Contact("xxx", "http://www.baidu.com", "1296778290@qq.com");
        ApiInfo apiInfo = new ApiInfo("在线文档", "这个文档是世界上最牛一个文档", "V1.0", "http://www.jd.com",
                DEFAULT_CONTACT, "按时睡觉公司", "http://www.taobao.com", new ArrayList<VendorExtension>());

        return apiInfo;
    }
}

（3）开启swagger注解

package com.test.demo.dao;


import com.test.demo.entity.User;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository
public interface UserDao {
    List<User> userByid(Integer id);
    List<User> userAll();
    int del(Integer id);
    int insert(User user);
    int update(User user);
}

（4）实体类

package com.test.demo.entity;

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

@Data
@NoArgsConstructor
@ApiModel(description = "用户实体类")
public class User {
    @ApiModelProperty(value = "用户编号")
    private Integer id;
    @ApiModelProperty(value = "用户姓名")
    private String name;
    @ApiModelProperty(value = "真实姓名")
    private String realname;

    public User(String name, String realname) {
        this.name = name;
        this.realname = realname;
    }

    public User(Integer id, String name, String realname) {
        this.id = id;
        this.name = name;
        this.realname = realname;
    }
}

（5）增删改查操作

package com.test.demo.controller;

import com.test.demo.entity.User;
import com.test.demo.service.UserService;
import com.test.demo.util.CommonResult;
import io.swagger.annotations.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@Api(tags = "用户")
@RestController
public class UserController {
    @Autowired
    private UserService userService;


    @PostMapping("/list2")
    @ApiOperation(value = "获取用户信息")
    @ApiImplicitParams(value = {
            @ApiImplicitParam(value = "用户编号",name ="id" )
    })
    public CommonResult list2(Integer id) {
        return userService.userByid(id);
    }

    @PostMapping("/list")
    @ApiOperation(value = "获取用户信息")
    public CommonResult list() {
        return userService.userAll();
    }

    @PostMapping("Add")
    @ApiOperation(value = "添加")
   @ApiImplicitParams({

   }
   )
    public CommonResult AddDept(@RequestBody User user){
        int i = userService.insert(user);
        if(i==1){
            return new CommonResult(2000,"添加成功",null);
        }
        return new CommonResult(5000,"添加失败",null);
    }
    @PostMapping("UpDate")
    @ApiOperation(value = "修改")
    public CommonResult UpDateDept(@RequestBody User user){
        int i = userService.update(user);
        if(i==1){
            return new CommonResult(2000,"修改成功",null);
        }
        return new CommonResult(5000,"修改失败",null);
    }
    @PostMapping("/Del")
    @ApiOperation(value = "删除")
    public CommonResult DelDept(Integer id){
        int i = userService.del(id);
        if(i==1){
            return new CommonResult(2000,"修改成功",null);
        }
        return new CommonResult(5000,"修改失败",null);
    }
}

springboot整合定时器。

什么是定时器?

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

为什么使用定时器?

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

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

如何来使用定时器。

（1）引入定时器依赖。

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

（2）编写定义任务代码。

package com.ykq.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component //该类交于spring容器来管理
public class QuartzTask {


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

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