SpringBoot学习

最新推荐文章于 2024-01-06 08:57:46 发布

IT__LS

最新推荐文章于 2024-01-06 08:57:46 发布

阅读量195

点赞数

分类专栏： SpringBoot

本文链接：https://blog.csdn.net/it__ls/article/details/119248619

版权

SpringBoot 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.概述

一般把Spring Boot称为搭建程序的脚手架或者说是便捷搭建基于Spring的工程脚手架。其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注业务而非配置。

2.依赖配置

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>SpringBootdemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--1. 添加父工程坐标  里面已经对各种常用依赖（并非全部）的版本进行了管理-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
    </parent>


    <!--2. 添加web启动器  为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因 为我们是web项目，这里我们引入web启动器-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>

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

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

        <!--整合jdbc和事务-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

        <!--mybatis -->
<!--        <dependency>-->
<!--            <groupId>org.mybatis.spring.boot</groupId>-->
<!--            <artifactId>mybatis-spring-boot-starter</artifactId>-->
<!--            <version>2.0.1</version>-->
<!--        </dependency>-->

        <!-- 通用mapper -->
        <!-- 注意：一旦引入了通用Mapper的启动器，会覆盖Mybatis官方启动器的功能，因此需要移除对官方Mybatis启动器 的依赖。-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

        <!--Junit测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <!--整合Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>



    </dependencies>

    <!--3. 管理jdk版本-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <!--添加项目的pom.xml插件；在pom.xml要显式的加入插件spring-boot-maven-plugin，否则无法产生 jar 清单 文件，导致打出来的 jar 无法使用命令运行；-->
    <build>
        <plugins>
            <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.注入

package com.xxx.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;


/**
 * @Configuration：声明一个类作为配置类，代替xml文件
 * @Bean：声明在方法上，将方法的返回值加入Bean容器，代替<bean>标签
 * @Value：属性注入
 * @PropertySource：指定外部属性文件，
 *
 * 解读：
 * @Configuration：声明我们JdbcConfig是一个配置类
 * @PropertySource：指定属性文件的路径是: classpath:jdbc.properties
 * @Value为属性注入值
 * @Bean将 dataSource()方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值 加入Spring容器中。
 *
 * 然后我们就可以在任意位置通过@Autowired注入DataSource了！
 */

//@Configuration
//@PropertySource("classpath:jdbc.properties")


/**
 * @Configuration
 * @EnableConfigurationProperties(JdbcProperties.class)
 * 通过@EnableConfigurationProperties(JdbcProperties.class)
 * 来声明要使用JdbcProperties这个类的 对象
 *
 * @Autowired注入
 * @Bean的方法参数注入
 */
@Configuration
public class JdbcConfig {

    /**
    @Value("${jdbc.url}")
    String url;
    @Value("${jdbc.driverClassName}")
    String driverClassName;
    @Value("${jdbc.username}")
    String username;
    @Value("${jdbc.password}")
    String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
    */

    /**
    @Bean // 声明要注入的属性前缀，Spring Boot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")

     * 我们直接把@ConfigurationProperties(prefix = "jdbc")声明在需要使用的@Bean的方法上，
     * 然后Spring Boot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。
     * 使用的前提是：该类必须有对应属性的set方法！

    public DataSource dataSource() {
        return new DruidDataSource();
    }
     */
}

4.Yaml配置文件

#jdbc:
#  driverClassName: com.mysql.jdbc.Driver
#  url: jdbc:mysql://localhost:3306/springboot_test?useUnicode=true&characterEncoding=utf8
#  username: root
#  password: 123456


spring:
  profiles:
    active: abc,def

  #把JdbcConfig 类中的druid的配置删除或注释
  #在刚才引入jdbc启动器的时候，SpringBoot已经自动帮我们引入了一个连接池,HikariCP应该是目前速度最快的连接池
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot_test?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456

  redis:
    host: localhost
    port: 6379
    timeout: 10000


logging:
  level:
    com.xxx: debug
    org.springframework: info

# 映射端口
server:
  port: 80


## mybatis配置
#mybatis:
#  # 实体类别名包路径
#  type-aliases-package: com.xxx.pojo
#  # 映射文件路径
#  # mapper-locations: classpath:mappers/*.xml
#  configuration:
#    # 控制台输出执行sql
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

5.自动配置原理

package com.xxx;

//import org.mybatis.spring.annotation.MapperScan;
import tk.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 启动类
 * @Description TODO
 * @Version 1.0
 **/

/**
 *      1.这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了@Configuration的类，
 *          并且读取其中的配 置信息。而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，
 *          项目中只能有一个。所以一 般我们无需自己添加。
 *
 *      2.总结，Spring Boot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，
 *          取决于我们是否引 入了对应库所需的依赖，如果有那么默认配置就会生效,也提供了自定义配置的入口.
 *
 *      3.@SpringBootApplication注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子 包。
 *          因此，一般启动类会放在一个比较前的包目录中。
 *
 *
 *
 *
 *
 * SpringBoot为我们提供了默认配置，而默认配置生效的步骤：
 * 1.@EnableAutoConfiguration注解会去寻找META-INF/spring.factories文件，
 *      读取其中以 EnableAutoConfiguration为key的所有类的名称，
 *      这些类就是提前写好的自动配置类
 * 2.这些类都声明了@Configuration注解，并且通过@Bean注解提前配置了我们所需要的一切实例
 * 3.但是，这些配置不一定生效，因为有@ConditionalOn注解，满足一定条件才会生效。比如条件之一：
 *      是一些 相关的类要存在
 * 4.类要存在，我们只需要引入了相关依赖（启动器），依赖有了条件成立，自动配置生效。
 * 5.如果我们自己配置了相关Bean，那么会覆盖默认的自动配置的Bean
 * 6.我们还可以通过配置application.yml文件，来覆盖自动配置中的属性
 * 7.如果properties和yml文件都存在，如果有重叠属性，默认以Properties优先.
 *
 *
 */

@SpringBootApplication
@MapperScan("com.xxx.mapper")
public class Application {
    public static void main(String[] args) {
        // 启动代码
        SpringApplication.run(Application.class,args);
        System.out.println("成功22!");
    }
}

@SpringBootApplication

        @SpringBootConfiguration

        @EnableAutoConfiguration

        @ComponentScan

@SpringBootConfiguration

这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了@Configuration的类，并且读取其中的配置信息。而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

@EnableAutoConfiguration

第二级的注解@EnableAutoConfiguration，告诉Spring Boot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了spring-boot-starter-web，而这个启动器中帮我们添加了tomcat、SpringMVC 的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

@ComponentScan

配置组件扫描的指令。提供了类似与<context:component-scan>标签的作用
通过basePackageClasses或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包.

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

ClassLoader默认是从classpath下读取文件，因此，SpringBoot会在初始化的时候，加载所有classpath:META-INF/spring.factories文件，包括jar包当中的。

@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
这里的条件是OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中 Servlet只要引入了tomcat依赖自然会有，后两个需要引入SpringMVC才会有。这里就是判断你是否引入了相关依赖，引入依赖后该条件成立，当前类的配置才会生效！

@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和 ResourceProperties。

6.Lombok

package com.xxx.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;


/**
 * 1.lombok插件
 * 2.引入依赖
 * 3.Bean上注解使用
 *
 * @Data ：自动提供getter和setter、hashCode、equals、toString等
 * @Getter：自动提供getter方法
 * @Setter：自动提供setter方法
 * @Slf4j：自动在bean中提供log变量，
 * 其实用的是slf4j的日志功能。
 * 例如；在javabean上加@Data，那么就可以省去getter和setter等方法的编写，lombok插件会自动生成。
 *
 */

@Data
@Table(name = "tb_user") //在User实体类上加JPA注解
public class User {
    //  id
    //开启主键自动回填
    @Id  // 相当于http://localhost/user/12   中的12赋值给主键id查询 SELECT id,user_name,password,name,age,sex,birthday,created,updated,note FROM tb_user WHERE id = ?
    // 不加@Id  SELECT id,user_name,password,name,age,sex,birthday,created,updated,note FROM tb_user WHERE id = ? AND user_name = ? AND password = ? AND name = ? AND age = ? AND sex = ? AND birthday = ? AND created = ? AND updated = ? AND note = ?
    @KeySql(useGeneratedKeys = true)
    private Long id;

    //  用户名
    private String userName;
    // 密码
    private String password;
    // 姓名
    private String name;
    // 年龄
    private Integer age;
    // 性别，1男性，2女性
    private Integer sex;
    // 出生日期
    private Date birthday;
    // 创建时间
    private Date created;
    // 更新时间
    private Date updated;
    // 备注
    private String note;

}

7.实践

application.yml文件中配置日志级别控制

访问静态资源

拦截器

通过实现WebMvcConfigurer并添加@Configuration注解来实现自定义部分SpringMvc配置

package com.xxx.config;

import com.xxx.intercepter.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


@Configuration
public class MvcConfig implements WebMvcConfigurer {
    /** * 将拦截器注册到spring ioc容器 * @return myInterceptor */
    @Bean
    public MyInterceptor myInterceptor(){
        return new MyInterceptor();
    }
    /**
     * 重写该方法；往拦截器链添加自定义拦截器
     * @param registry 拦截器链
     */
    @Override public void addInterceptors(InterceptorRegistry registry) {
        //通过registry添加myInterceptor拦截器，并设置拦截器路径为 /*
         registry.addInterceptor(myInterceptor()).addPathPatterns("/*");
    }
}

package com.xxx.intercepter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 *
 * 总结：通过实现WebMvcConfigurer并添加@Configuration注解来实现自定义部分SpringMvc配置
 *
 * @Description TODO
 * @Version 1.0
 **/

@Slf4j
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        log.debug("这是MyInterceptor拦截器的preHandle方法");
        return true;
    }

    @Override public void postHandle(HttpServletRequest request, HttpServletResponse response,
                                     Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("这是MyInterceptor拦截器的postHandle方法");
    }

    @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse
            response, Object handler, Exception ex) throws Exception {
        log.debug("这是MyInterceptor拦截器的afterCompletion方法");
    }

}

整合Mybatis

启动类上添加扫描包注解