Spring Boot的概念和功能介绍

本篇内容介绍了“Spring Boot的概念和功能介绍”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

Spring Boot学习笔记

一、Spring Boot 概述

1.Spring Boot的诞生

Spring Boot的目的就是对spring的缺点进行改善和优化，基于约定、优于配置的思想使得开发人员不必在配置和业务逻辑之间进行思维切换，全身心投入到业务逻辑的代码编写当中，从而大大提高开发效率，缩短项目周期。

2.Spring Boot的特点

• 基于spring的开发提供更快捷的入门体验

• 开箱即用，没有代码生成，也无需XML配置。可以通过修改默认配置来满足特定需求

• 提供了一些大型项目中的常见的非功能型特性，入嵌入式服务器、安全、指标、健全监测、外部配置等

• Spring Boot不是对spring功能上的增强，而是提供了一种快速使用spring的方式

3.Spring Boot的核心功能

• 起步依赖

  本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其它库的传递依赖，这些东西加在一起，即可支持某项能。
  简单地说，就是将具备某些功能的坐标打包到一起，并提供一些默认的功能。

  
  

• 自动配置

  本质上是应用程序启动的过程中，考虑了众多因素，才决定spring配置应该用哪一个，该过程是spring自动完成的。

  
  

二、Spring Boot快速入门

(1).环境搭建

方式1：

1.创建一个普通的Maven工程

2.在pom.xml中导入起步依赖：springboot的起步依赖和web的启动依赖

<!--1 springboot项目都要继承springboot的起步依赖-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
</parent>

<!--2 SpringBoot要集成SpringMVC进行Controller的开发，所以项目要导入web的启步依赖-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3.编写应用程序的引导类

要通过springboot的引导类启动springboot项目才可以在浏览器进行访问。

package com.wsc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * springboot的引导类，程序的入口
 */
@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class);
    }
}

4.编写controller

在springboot的引导类MySpringBootApplication的同级包或者子包中创建controller

package com.wsc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * springmvc的控制器
 */
@Controller
public class QuickStartController {

    @RequestMapping("/quick")
    @ResponseBody
    public String quickStart(){
        return "spring boot 启动了。。。";
    }
}

5.测试

启动引导类，然后在浏览器中访问http://localhost:8080/quick

测试成功后显示如下

方式2：

idea创建maven工程-->选择Spring Initializr-->点击next-->修改Project Matadata的参数-->next-->
选择对应依赖以及springboot的版本-->next检查项目名-->finish

(2).入门程序代码解析

• @SpringBootApplication：标注该类为SpringBoot的启动类，该注解具备多种功能

• SpringApplication.run(MySpringBootApplication.class) 代表运行SpringBoot的启动类，参数为SpringBoot 启动类的字节码对象

(3).设置springboot热部署

1.热部署的概念

在idea中设置springboot的热部署，使得我们在开发程序的过程中，如果修改了类、页面等资源，不用重启服务器，代码也能生效。

2.实现方式

在 pom.xml 中添加如下配置 即可

<!--热部署配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

注意：IDEA进行SpringBoot热部署失败原因 出现这种情况，并不是热部署配置问题，其根本原因是因为Intellij IEDA默认情况下不会自动编译，需要对IDEA进 行自动编译的设置，如下：

首先进入file->setting

然后 Shift+Ctrl+Alt+/，选择Registry

三、Spring Boot原理分析

• 起步依赖：点开起步依赖的jar包，查看源码解析，里面有许多的jar包的依赖

• 自动配置：查看@SpringBootApplication的源码，里面整合了许多spring的配置

四、Spring Boot的配置文件

(1).Spring Boot配置文件的类型

springboot是基于约定的，所有有很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。

springboot默认会从Resources目录下加载application.properties或application.yml（application.yaml）文件

1. application.properties

#修改服务器的端口号
server.port=8081
#修改web应用的名称
server.servlet.context-path=/demo

2.application.yml(等同于application.yaml)

#普通数据的配置
name: zhansan

#对象的配置
person:
  name: lisi
  age: 18
  addr: beijing
#行内对象的配置
#person: {name: zhansan,age: 18,addr: beijing}

#配置数组、collection集合（普通字符串）
city:
  - beijing
  - tianjiang
  - shanghai
  - shenzhen
city2: [beijing,tianjing,shanhai,shenzhen]

#配置数组、collection集合(对象数据)
student:
  - name: zhansan
    age: 12
    addr: beijing
  -name: lisi
   age: 13
   addr: shenzhen
student2: [{name: zhangsan,age: 12,addr: beijing},{name: lisi,age: 14,addr: shenzhen}]


#配置map集合
map:
  key1: value1
  key2: value2

server:
  port: 8082

(2).配置文件与配置类的映射关系

如何从配置文件中拿出属性的值注入到配置类中对应的成员上。

1.使用注解@Value

@Controller
public class QuickController2 {
    @Value("${name}") //直接在成员上添加@Value注解，无需get、set方法
    private String name;
    @Value("${person.addr}")
    private String addr;

    @RequestMapping("/quick2")
    @ResponseBody
    public String quick2(){

        return "name:"+name+",addr:"+addr;
    }
}

2.使用注解@ConfigurationProperties

@Controller
@ConfigurationProperties(prefix = "person")//在配置类上添加@ConfigurationProperties
public class QuickController3 {

    private String name;
    private String addr;

    //必须添加属性对应的get、set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @RequestMapping("/quick3")
    @ResponseBody
    public String quick3(){

        return "name:"+name+",addr:"+addr;
    }
}

五、Spring Boot整合其他技术

(1).Spring Boot整合Spring MVC

在pom.xml中添加web功能的起步依赖即可，底层传递了springmvc的依赖

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

(2).Spring Boot整合 Spring

springboot并没有增强spring的功能，只是提供了一种快速使用spring的方式

springboot的父工程的起步依赖，已经整合了spring，并对spring的配置进行了默认配置优化

(3).Spring Boot整合Mybatis

整合步骤如下：

1.添加mybatis的起步依赖（pom.xml）

    <!--mybatis的起步依赖-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.0.0</version>
    </dependency>		

2.添加数据库驱动坐标（pom.xml）

<!-- MySQL连接驱动  不用添加版本 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

3.添加数据库连接信息（resources/application.properties）

#DB Configuration:
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

4.创建用户表

在test数据库中创建user表

-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`username` VARCHAR(50) DEFAULT NULL,
`password` VARCHAR(50) DEFAULT NULL,
`name` VARCHAR(50) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

5.添加实体类Bean

package com.wsc.domain;

import org.springframework.web.bind.annotation.InitBinder;

public class User {

    private Integer id;
    private String username;
    private String password;
    private String name;

    //getter setter.....

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

6.编写Mapper(等同于Dao)

package com.wsc.mapper;

import com.wsc.domain.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
@Mapper //@Mapper标记该类是一个mybatis的mapper接口，可以被spring boot自动扫描到spring上下文中
public interface UserMapper {

    public List<User> queryUserList();
}

7.配置Mapper映射配置文件（application.properties相当于主配置文件，需要在其中添加映射配置文件）

在src-->main-->resources下创建目录mapper-->在mapper下创建UserMapper.xml,其内容如下

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.itheima.mapper.UserMapper">
    <select id="queryUserList" resultType="user">
    	select * from user
    </select>
</mapper>

8.在application.properties中添加mybatis信息，添加映射配置文件

目的是将springboot 和 mybatis 产生关联

#spring集成Mybatis环境
#pojo别名扫描包
mybatis.type-aliases-package=com.itheima.domain
#加载Mybatis映射文件
mybatis.mapper-locations=classpath:mapper/*Mapper.xml

9.编写controller

package com.wsc.controller;

import java.util.List;

@Controller
public class MybatisController {
    @Autowired
    private UserMapper userMapper;//userMapper编译期会报错，因为项目没有运行无法自动生成mapper

    @RequestMapping("/query")
    @ResponseBody
    public List<User> queryUserList(){
        return userMapper.queryUserList();
    }

    @RequestMapping("/test")
    @ResponseBody
    public String testMybatis(){
        return "集成mybatis框架";
    }
}

10.测试

访问浏览器 http://localhost:8080/query

(4).SpringBoot整合Junit

1.用idea创建时会自动生成test功能的起步依赖，若没有，则手动在pom.xml中手动导入test功能的起步依赖

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

2.编写测试类

package com.wsc;

import com.wsc.domain.User;
import com.wsc.mapper.UserMapper;

import java.util.List;

/**
 * springbooot单元测试
 */
@RunWith(SpringRunner.class) //用谁运行springboot的引导类
@SpringBootTest(classes = SpringbootMybatisApplication.class)//测试引导类的字节码
public class MybatisTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testQueryUserList() {
        List<User> users = userMapper.queryUserList();
        System.out.println(users);
    }
}

(5).SpringBoot整合Spring Data JPA

1.添加spring data jpa的起步依赖（pom.xml）

<!-- springBoot JPA的起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>		

2.添加数据库驱动坐标（pom.xml）

<!-- MySQL连接驱动  不用添加版本 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

3.添加数据库连接信息（resources/application.properties）

#DB Configuration:
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?serverTimezone=UTC&useSSL=false
spring.datasource.username=root
spring.datasource.password=root

4.创建用户表

在test数据库中创建user表

-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`username` VARCHAR(50) DEFAULT NULL,
`password` VARCHAR(50) DEFAULT NULL,
`name` VARCHAR(50) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

5.添加实体类Bean

package com.wsc.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id//主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    //get set 方法.....

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

6.编写Repository(等同于Dao和Mapper)

package com.wsc.repository;
import com.wsc.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
/**
 * 等价于mapper 和dao
 */
public interface UserRepository extends JpaRepository<User,Long> {
    public List<User> findAll();
}

7.在application.properties中集成spring data jpa信息

#springboot集成springdata jpa
#JPA Configuration:
spring.jpa.database=MySQL
spring.jpa.show-sql=true
spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy

9.编写测试类

package com.wsc;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootDataJpaApplication.class)
public class SpringDataJpaTest {
    @Autowired
    private UserRepository userRepository;

    @Test
    public void testFindAll() {
        List<User> all = userRepository.findAll();
        System.out.println(all);
    }
}

10.单元测试

控制台输出：

注意：jdk9要手动导入依赖

<!--jdk9需要导入如下坐标-->
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.0</version>
</dependency>

(6).SpringBoot整合Spring Cloud

(7).SpringBoot整合Redis

1.添加redis的起步依赖（pom.xml）

<!-- 添加redis的起步依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.在application.properties中配置redis的连接信息

#Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

3.编写测试类

注入RedisTemplate测试redis操作

package com.wsc;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringbootDataJpaApplication.class)
public class RedisTest {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void test() throws JsonProcessingException {
        //1.从redis中查询
        String userListJson = redisTemplate.boundValueOps("user.findAll").get();
        //2.若redis中没有，从数据库中查询
        if (null==userListJson){
            //3.从数据库中查询
            List<User> all = userRepository.findAll();
            //4.将list对象序列化为json字符串  jackson解析引擎
            ObjectMapper objectMapper = new ObjectMapper();
            userListJson = objectMapper.writeValueAsString(all);
            //5.将json字符串存入redis
            redisTemplate.boundValueOps("user.findAll").set(userListJson);
            System.out.println("===从数据库中查询===");
        }else {
            System.out.println("===从redis中查询===");
        }
        System.out.println(userListJson);
    }
}

“Spring Boot的概念和功能介绍”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注亿速云网站，小编将为大家输出更多高质量的实用文章！