Spring Boot

概述

是Spring项目中的一个子工程,与Spring-framework同属于Spring的产品,称为搭建程序的脚手架,就是便捷搭建基于Spring的工程

特点

  • 创建独立的Spring应用,为所有的Spring开发者提供一个非常快速的、广泛结束的入门体验
  • 直接嵌入应用服务器,如Tomcat、jetty、undertow等,不需要部署war包
  • 提供固定的启动器依赖去简化组件配置,实现开箱即用(启动器starter-其实就是Spring Boot提供的一个jar包),通过自己设置参数(.properties或.yml配置文件),即可快速使用
  • 自动的配置Spring和其他有需要的第三方依赖
  • 提供了一些大型项目中常见的非功能性的特性,如内嵌服务器、安全、指标、健康检测、外部化配置
  • 绝对没有代码生成,也没有xml配置

入门

实现步骤:

  • 创建工程

  • 继承父类maven

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
  • 添加依赖(启动器依赖:spring-boot-starter-web)

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
  • 创建启动类

    /*
        springboot 工程都有一个引导类,这是工程入口
        并在引导类上添加 @SpringBootApplication
     */
    @SpringBootApplication
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(Application.class,args);
        }
    }
  • 创建处理器Controller

    /*
     *  @RestController注解相当于@ResponseBody + @Controller合在一起的作用
        返回json数据不需要在方法前面加@ResponseBody注解了,但使用@RestController这个注解,
        就不能返回jsp,html页面,视图解析器无法解析jsp,html页面
    
     *  controller包必须与Application(SpringBoot启动类)放在同级目录否则就会报错
     */
    @RestController
    public class Hello {
        /*
         *  将 HTTP GET 请求映射到特定的处理程序方法。 它是一个组合的注释,用作
            @RequestMapping(method = RequestMethod.GET)的快捷方式。
         */
        @GetMapping("hello")
        public String Hello(){
            return "Hello SpringBoot";
        }
    }
  • 测试

    Run启动类的main方法即可

  • 排错

    Cannot resolve plugin org.apache.maven.plugins:xxx

    pom.xml中的<properties>节点中添加阿里云镜像,等构建完成删掉即可

    <repositories>
        <repository>
            <id>alimaven</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>alimaven</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </pluginRepository>
    </pluginRepositories>

Java代码方式配置

  • 常用注解

    • @Configuration:声明一个类作为配置类,代替xml文件
    • @Bean:声明在方法上,将方法的返回值加入Bean容器,代替<bean>标签
    • @Value:属性注入
    • @PropertySource:指定外部属性文件
  • 配置数据库连接池,并在处理器中注入并使用

    • 添加依赖

    • 创建配置类

    • 配置连接池

      /*
          使用注解@Configuration,则这个类是SpringBoot bean的创建的配置文件类
          @PropertySource 加载指定配置文件
       */
      @Configuration
      @PropertySource("classpath:mysql.properties")
      public class JDBCConfig {
          /*
              使用@Value注解将上面配置文件中的值注入给下面的变量
              不可以注入静态变量(static)
           */
          @Value("${driverClassName}")
          private String driverClassName;
          @Value("${url}")
          private String url;
          @Value("${username}")
          private String username;
          @Value("${password}")
          private String password;
      
          /*
              @Bean可理解为用spring的时候xml里面的bean标签
           */
          @Bean
          public DataSource dataSource(){
              DruidDataSource dataSource = new DruidDataSource();
              dataSource.setDriverClassName(driverClassName);
              dataSource.setUrl(url);
              dataSource.setUsername(username);
              dataSource.setPassword(password);
      
              return dataSource;
          }
      }
    • 改造处理器类注入数据源并使用

      @Autowired
      private DataSource dataSource;

Spring Boot属性注入方式

  • 需求:将配置文件中的配置项读取到一个对象中

  • 实现:使用SpringBoot提供的注解@ConfigurationProperties,该注解可以将SpringBoot的配置文件中的配置项读取到一个对象中

  • 配置文件要求:

    • 名字必须为application
    • 类型必须为propertiesyml
  • 实现步骤:

    • 创建配置项类并添加注解@ConfigurationProperties

      /*
          @ConfigurationProperties:从application配置文件中读取配置项
              prefix:表示配置项的前缀,配置文件中为jdbc.url,在实体类中直接写url即可
              配置项中的变量名必须要与前缀之后的配置项名称保持一致
       */
      @ConfigurationProperties(prefix = "jdbc")
      public class JdbcProperties {
          private String driverClassName;
          private String url;
          private String username;
          private String password;
      
          public String getDriverClassName() {
              return driverClassName;
          }
      
          public void setDriverClassName(String driverClassName) {
              this.driverClassName = driverClassName;
          }
      
          public String getUrl() {
              return url;
          }
      
          public void setUrl(String url) {
              this.url = url;
          }
      
          public String getUsername() {
              return username;
          }
      
          public void setUsername(String username) {
              this.username = username;
          }
      
          public String getPassword() {
              return password;
          }
      
          public void setPassword(String password) {
              this.password = password;
          }
      }
      
    • mysql.properties修改为application.properties

    • 注入

      /*
          使用注解@Configuration,则这个类是SpringBoot bean的创建的配置文件类
          @EnableConfigurationProperties(JdbcProperties.class)该注解是用
          来开启对@ConfigurationProperties注解配置Bean的支持
       */
      @Configuration
      @EnableConfigurationProperties(JdbcProperties.class)
      public class JDBCConfig {
          /*
              @Bean可理解为用spring的时候xml里面的bean标签
           */
          @Bean
          public DataSource dataSource(JdbcProperties jdbcProperties){
              DruidDataSource dataSource = new DruidDataSource();
              dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
              dataSource.setUrl(jdbcProperties.getUrl());
              dataSource.setUsername(jdbcProperties.getUsername());
              dataSource.setPassword(jdbcProperties.getPassword());
              return dataSource;
          }
      }
  • 更优雅的注入

    • 如果一段属性只有一个Bean需要使用,我们无需将其注入到一个类,而是直接在需要的地方声明

      /*
          使用注解@Configuration,则这个类是SpringBoot bean的创建的配置文件类
       */
      @Configuration
      public class JDBCConfig {
          /*
              @Bean可理解为用spring的时候xml里面的bean标签
           */
          @Bean
          /*
              声明要注入的属性前缀,Spring Boot会自动把相关属性通过Set方法注入到DateSource中
              配置文件中的属性名自动匹配DataSource中的属性
           */
          @ConfigurationProperties(prefix = "jdbc")
          public DataSource dataSource(){
              return new DruidDataSource();
          }
      }
  • 排错:

    • @ConfigurationProperties报错

      • pom.xml中添加依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <!--不传递依赖-->
            <optional>true</optional>
        </dependency>

多个yml文件配置

  • 目标:将多个yml文件在application.yml文件中配置激活

  • yml配置文件的特征

    • 树状层级结构展示配置项
    • 配置项间有关系需要分行空两格
    • 配置项如果有值的话需要在:后空一格在写配置项值
  • application.properties改为application.yml

    jdbc:
      driverClassName: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/login?serverTimezone=Asia/Shanghai&characterEncoding=utf8
      username: login_root
      password: yy947599
  • 多个yml配置文件,在SpringBoot中是允许的,这些配置文件的名称必须为application-***.yml,并且这些配置文件必须要在application.yml配置文件中激活才可以使用

    #激活配置文件,需指定其他配置文件的名称'-'后面的内容
    spring:
      profiles:
        active: abc,def
  • 注意:如果properties和yml配置文件同时存在spring boot项目中,那么这两类配置文件都有效,在两个配置文件中,如果存在同名的配置项的话,会以properties文件的为主

Lombok应用

  • 目标:使用lombok注解实现pojo的简化

  • 功能:lombok是一个插件工具包,提供了一些注解@Data、@Getter等注解去简化实体类中的构造方法、get/set方法的编写

  • 步骤:

    • 在IDEA中按照Lombok插件

    • 添加依赖到项目的pom.xml文件

    • 改造实体类

      /*
          在编译阶段会根据注解自动生成方法
          @Data:包含get/set/hashCode/equals/toString方法
          @Getter:自动提供get方法
          @Setter:自动提供set方法
          @Slf4j:自动在bean中配置log变量,就是slf4j的日志功能
       */
      @Data
      @Getter
      @Setter
      @Slf4j
      public class User {
          private Long id;
          private String username;
          private String password;
          private String name;
          private Integer age;
          private Integer sex;
          private Date birthday;
          private String note;
          private Date created;
          private Date updated;
      }

整合SpringMVC端口和静态资源

  • 目标:修改tomcat端口和访问项目中的静态资源

  • 修改tomcat端口

    • 查询**properties,设置配置项(前缀+类变量名)到application配置文件中

      #修改tomcat端口
      server:
        port: 80
  • 访问项目中的静态资源

    • 静态资源放置的位置:resources/static
  • 日志配置

    • 使用Lombok的@Slf4j

    • 配置文件

      logging:
        level:
          springboot: debug
          org.springframework: info

整合SpringMVC拦截器

  • 目标:配置自定义拦截器

  • 步骤:

    • 编写拦截器(实现HandlerInterceptor)

      @Slf4j
      public class MyInterceptor implements HandlerInterceptor {
          @Override
          public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
              log.debug("这是preHandle方法");
              return true;
          }
      }
    • 编写配置类实现WebMvcConfigurer,在该类中添加各种组件

      @Configuration
      public class MvcConfig implements WebMvcConfigurer {
          //注册拦截器
          @Bean
          public MyInterceptor myInterceptor(){
              return new MyInterceptor();
          }
          //添加拦截器到拦截器链
          @Override
          public void addInterceptors(InterceptorRegistry registry) {
              /*
                  addInterceptor:拦截器
                  addPathPatterns:拦截路径
               */
              registry.addInterceptor(myInterceptor()).addPathPatterns("/*");
          }
      }

整合事务和连接池

  • 事务配置

    • 添加数据库相关依赖
    • 编写业务类UserService使用事务注解@Transactional
  • 数据库连接池hikari配置

    • 只要在application中添加hikari相关参数即可使用

      spring:
        datasource:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/login?serverTimezone=Asia/Shanghai&characterEncoding=utf8
          username: login_root
          password: yy947599

整合MyBatis

  • 添加启动器依赖

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
  • 配置MyBatis:实体类别名、日志、映射文件

    mybatis:
      #实体类别名
      type-aliases-package: springboot
      #映射文件
      #mapper-locations:
      configuration:
        #日志
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  • 配置MapperScan扫描

    在启动类中添加注解

    //扫描mybatis所有业务的mapper接口
    @MapperScan("mapper")

整合通用Mapper

  • 可以实现自动拼接SQL语句,所有的mapper都不需要编写任何方法也就是不用编写sql语句,可以提高效率

    • 添加启动器依赖

      <dependency>
          <groupId>tk.mybatis</groupId>
          <artifactId>mapper-spring-boot-starter</artifactId>
          <version>2.1.5</version>
      </dependency>
    • 改造UserMapper继承通用Mapper\;

      public interface UserMapper extends Mapper<User> {
      }
    • 修改启动引导类的Mapper扫描注解

      //使用tk.mybatis下的
      @MapperScan("mapper")
    • 修改User实体类添加jap注解

      @Data
      /*
          @Table:数据库表名
       */
      @Table(name = "tb_user")
      public class User {
          /*
              @Id:主键
              @KeySql:主键回填,在添加数据时,会返回给user一个id
           */
          @Id
          @KeySql(useGeneratedKeys = true)
          private Long id;
      
          /*
              @Column:将数据库字段与属性绑定
              在数据库字段名与属性名相同或属性名为驼峰式可以不加此注解
           */
          @Column(name = "username")
          private String username;
          private String password;
          private String name;
          private Integer age;
          private Integer sex;
          private Date birthday;
          private String note;
          private Date created;
          private Date updated;
      }
    • 改造UserService实现业务功能

      @Service
      public class UserService {
      
          /*
              required:当AutoWired注入时
                  true:bean必须存在
                  false:bean可以不存在
           */
          @Autowired(required = false)
          private UserMapper userMapper;
      
          public User findById(Long id){
              /*
                  selectByPrimaryKey:根据id进行select
               */
              return userMapper.selectByPrimaryKey(id);
          }
          @Transactional
          public void save(User user){
              /*
               * 选择性新增,如果属性为空则该属性不会出现在insert语句上
               */
              userMapper.insertSelective(user);
          }
      }

整合Junit

  • 目标:在Spring Boot项目中使用Junit进行单元测试UserService的方法

  • 步骤:

    • 导入启动器依赖

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-test</artifactId>
      </dependency>
    • 编写测试类,添加@RunWith@SpringBootTest注解

      @RunWith(SpringJUnit4ClassRunner.class)
      @SpringBootTest
      public class UserServiceTest {
      
          @Autowired
          private UserService userService;
      
          @Test
          public void findById() {
              User user = userService.findById(8L);
              System.out.println(user);
          }
      
          @Test
          public void save() {
          }
      }

整合Redis

  • 目标:在SpringBoot使用Junit测试RedisTemplate的使用

  • 步骤:

    • 添加启动器依赖

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
      </dependency>
    • 配置application.yml中redis的连接参数

      redis:
        host: localhost
        port: 6379
    • 编写测试类应用RedisTest,注入RedisTemplate对象操作Redis

      @RunWith(SpringJUnit4ClassRunner.class)
      @SpringBootTest
      public class RedisTest {
          @Autowired
          private RedisTemplate redisTemplate;
          @Test
          public void test(){
              //String字符串
              redisTemplate.opsForValue().set("str","sgee");
              //Hash散列
              redisTemplate.boundHashOps("h_key").put("name","imau");
              redisTemplate.boundHashOps("h_key").put("age",12);
              Set set = redisTemplate.boundHashOps("h_key").keys();
              System.out.println(set);
              List list = redisTemplate.boundHashOps("h_key").values();
              System.out.println(list);
              //List列表
              redisTemplate.boundListOps("l_key").leftPush("C");
              redisTemplate.boundListOps("l_key").leftPush("b");
              redisTemplate.boundListOps("l_key").leftPush("a");
              List key = redisTemplate.boundListOps("l_key").range(0, -1);
              System.out.println(key);
              //Set集合
              redisTemplate.boundSetOps("s_key").add("a","b","c");
              Set s_key = redisTemplate.boundSetOps("s_key").members();
              System.out.println(s_key);
              //sorted set 有序集合
              redisTemplate.boundZSetOps("zs_key").add("a",10);
              redisTemplate.boundZSetOps("zs_key").add("b",20);
              redisTemplate.boundZSetOps("zs_key").add("c",30);
              Set zs_key = redisTemplate.boundZSetOps("zs_key").range(0, -1);
              System.out.println(zs_key);
      
          }
      }

自动配置原理

  • 所有的自动配置类都在spring.factories文件中定义:根据启动器依赖实例化
  • 配置流程
    • 查找spring-boot-autoconfigure-***.jar
    • 查找当前组件对应在上述jar包中的package
    • 查看**Properties配置项类
    • 到spring boot的application.yml配置文件中修改配置项

SpringBoot项目部署

  • 目标:将SpringBoot项目使用maven指令打包成jar包并允许测试

  • 步骤:

    • 添加打包组件间项目中的资源、配置、依赖包打包到一个jar包,可以使用maven的package

      <!--打Jar包如果不配置该插件,打出来的jar包没有清单文件-->
      <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
          <version>2.3.4.RELEASE</version>
      </plugin>
    • 部署:java -jar 包名

Last modification:October 22nd, 2020 at 06:21 pm
如果觉得我的文章对你有用,请随意赞赏