[Java知识库]SpringBoot个人总结

SpringBoot

一 Spring Boot入门

1 简介

2.微服务

一个应用应该是一组小型服务:可以通过HTTP的方式进行互通;

每个功能元素最终都是一个可独立替换和独立升级的软件单元

3. Hello World

①创建Maven 工程(Jar)

② 导入SpringBoot相关 依赖

③编写一个主程序; 启动 Spring Boot 应用

@SpringBootApplication 注解加到类上. 来标注这是一个Spring Boot应用

④ 编写相关的Controller , Service

⑤简化部署

4. Hello World 深究

①父项目

②启动器

③主程序类,主入口类

5. 使用Spring Initializer快速创建Spring Boot 项目

IDEA 都支持使用 Spring的项目创建向导快速创建一个Spring Boot项目;

选择我们需要的模块;向导会联网创建Spring Boot 项目;

默认生成的Spring Boot项目:

*主程序已经生成好了,我们只需要我们自己的逻辑

resources 文件夹中目录结构

? static: 保存所有静态资源: js css images;

? templates: 保存所有的模板页面;(Spring Boot 默认 jar包使用嵌入式的Tomcat,默认不支持JSP页面); 可以使用模板引擎(freemarker, thymeleaf)

? *application. properties: Spring Boot 应用的配置文件; 可以修改一些默认设置;

二.配置文件

1.配置文件

Spring Boot 使用一个全局的配置文件,配置文件名是固定的,

• appliction.properties

• ppliction.yml

配置文件的作用:

修改Spring Boot自动配置的默认值;Spring Boot在底层都给我们自动配置好

配置类型

YAML (YAML Alin’t Markup Language)

? YAML Amarkup Language; 是一个标记语言

? YAML isn’t Markup Language: 不是一个标记语言

配置例子

? YAML:

server:
    port:8081

XML:

<server>
   <port>8081</port>
</server>

2.YAML 语法

①基本语法

k:(空格)v 表示一对键值对(空格必须用);

? 以空格的缩进来控制层级关系; 只要是左对齐的一类数据,都是同一层级的

server:
    port: 8081
    path: /hello

属性和值也是大小写敏感的;

②值的写法

? 字面量:普通值(数字,字符串,布尔)

? k: v 字面直接来写

? 字符串默认不用加上单引号或者双引号

? 对象 Map (属性和值)

k: v 在下一行来写对象的属性和值的关系; 注意缩进

   对象还是 k:  v  的方式
        friends:
            lastName: zhangsan
            age:20

? 行内写法:

friends:{lastName: zhangsan,age:20}

数组(List, Set)

? 用 - 值表示数组中的一个元素

pets:
   -Cat
   -dog
   -pig
   

? 行内写法:

pets:{Cat,dog,pig}

3. 配置文件值注入

配置文件

person:
    lastName: hello
    age: 18
    boss: false
    birth: 2017/02/15
    maps: {k1: v1,k2: 12}
    lists:
      -lisi
      -zhaoliu
    dog:
      name: 小狗
      age: 12
  

javaBean:

/**
*将配置文件中配置的每一个属性值,映射到这个组件中
* @ConfigurationProperties:告诉SpringBoot将本类中所有的属性和配置文件中相关信息的配置进行绑定;
* prefix = "person" 配置文件中哪个下面的所有属性进行---->映射
* 只有这个组件是容器中@Component的组件,才能容器提供的@ConfigurationProperties功能;
*/
@Component
@ConfigurationProperties(prefix="person")
public class Person{
      private String lastName;
      private Integer age;
      private Boolean boss;
      private Date birth;
     
      private Map<String,Object> maps;
      private List<Object> lists;
      private Dog dog;
}

我们可以导入配置文件处理器,以后编写配置就有提示了

<导入配置文件处理器,配置文件进行绑定就会提示>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-configuration-processor</artifactId>
     <optional>true</<optional>>
</dependency>

@Value 获取值和@ConfigurationProperties获取值比较

三 自动配置原理

1. 加载spring.factories

① 在SpringApplication类构建的时候，有这样一段初始化代码：

? ②跟进去往下走

这里发现会通过loadFactoryNames尝试加载一些FactoryName，然后利用createSpringFactoriesInstances将这些加载到的类名进行实例化。 继续跟进loadFactoryNames方法：

? 发现此处会利用类加载器加载一个文件： META-INF/spring.factories 。我们知道，ClassLoader默认是从classpath下读取文件，因此，SpringBoot会在初始化的时候，加载所有classpath:META-INF/spring.factories文件，包括jar包当中的。而在Spring的一个依赖包：spring-boot-autoconfigure中，就有这样的文件：

我们引入的任何第三方启动器，只要实现自动配置，也都会有类似文件。

2 读取自动配置类

? 我们打开spring.factories文件

可以发现以EnableAutoConfiguration接口为key的一系列配置，key所对应的值，就是所有的自动配置类，可以在当前的jar包中找到这些自动配置类：

? 几乎涵盖了现在主流的开源框架 , 我们来看一个我们熟悉的，例如SpringMVC，查看mvc 的自动配置类：

**打开WebMvcAutoConfiguration**

3 默认属性配置

配置类我们找到了 , 那么这些默认配置的属性来自哪里呢？

例如 : 我们配置视图解析器的时候需要配置前缀和后缀 , 那么这些配置在哪配置的呢 ?

通过源码发现, 这个配置是从this.mvcProperties.getView()中读取的 ,this.mvcProperties又是什么呢 ? 我们继续跟踪,发现其实就是定义的一个变量

这个变量中又有一个View类型的变量 , 这个变量中配置的就是前缀和后缀

View中的源码如下

可以看到, 默认读取就是这里的前缀和后缀变量的值 , 默认就是null .

4 覆盖默认属性配置

如果我们想自己指定视图的前缀和后缀该如何去做呢 ?

我们再看WebMvcAutoConfiguration这个类的声明, 发现这个类身上有这么一个注解, 我们之前也使用过 , 引入了二个配置对象 , 所以我们知道下面成员位置的WebMvcProperties这个成员变量 , 就是从这里来的

我们再进去看看这两个配置类 , 配置类身上使用ConfigurationProperties读取配置,前缀是spring.mvc , 所以如果我们在配置文件中配置spring.mvc前缀开头的配置 , 是不是就可以将自己配置的数据注入到这个对象的属性中 !

所以如果想要自己设置视图前缀和后缀就可以这么配置

激活配置文件

spring:
  mvc:
    view:
      prefix: /WEB-INF/
      suffix: .jsp

修改服务器端口 :

server:
  port: 10000

四. SpringBoot综合案例(应用)

1. 环境搭建

1.1 数据库准备

create database springboot character set utf8 ;

use springboot ; 

CREATE TABLE `tb_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `gender` varchar(5) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `address` varchar(32) DEFAULT NULL,
  `qq` varchar(20) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  `username` varchar(20) NOT NULL,
  `phone` varchar(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `user_username_uindex` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

INSERT INTO `tb_user` VALUES (1,'黄蓉','女',38,'桃花岛','212223390222','huangrong222@qq.com','huangrong','15600003333'),(2,'黄老邪','男',58,'湖北省武汉市','212223390','huanglaoxie@qq.com','huanglaoxie','15872320405'),(3,'小龙女','男',18,'湖北省荆门市','212223390','xiaolongnv@qq.com','xiaolongnv','15600004444'),(7,'杨过','男',30,'扬州','212223390','yangguo@qq.com','yangguo','15600005555');

1.2 创建项目及包结构

创建项目 springboot_demo

1.3 导入依赖

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

    <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.6.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<dependencies>
    <!--单元测试启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <!--通用mapper启动器依赖-->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.1.5</version>
    </dependency>
    <!--JDBC启动器依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <!--mysql驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--web启动器依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--编码工具包-->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>

    <!--springboot整合redis启动器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!--自动配置连接池-->
    <!--<dependency>-->
    <!--<groupId>com.alibaba</groupId>-->
    <!--<artifactId>druid</artifactId>-->
    <!--<version>1.1.12</version>-->
    <!--</dependency>-->

</dependencies>

<build>
    <plugins>
        <!--spring boot maven插件 , 可以将项目运行依赖的jar包打到我们的项目中-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

1. 4 创建启动类

package com.atguigu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.dao")
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

2.数据访问层

1 编写配置文件application.yml

server:
  port: 10001
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///springboot
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  type-aliases-package: com.atguigu.pojo

2 编写实体类User

package com.atguigu.pojo;

import java.io.Serializable;

@Entity
@Table(name = "tb_user")
public class User implements Serializable {
    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String address;
    private String qq;
    private String email;
    private String username;
    private String phone;

3 Mapper接口和映射配置

package com.atguigu.dao;

import com.atguigu.pojo.User;
import tk.mybatis.mapper.common.Mapper;
import java.util.List;

public interface UserMapper extends Mapper<User> {
}

4 编写测试代码

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper ;

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

3. 业务层

1 . 编写接口

public interface UserService {

    /**
     * 查询所有用户信息
     * @return
     */
    public List<User> findAll();
}

2 编写实现类

package com.atguigu.service.impl;

import com.atguigu.dao.UserMapper;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
private UserMapper userMapper;

@Override
@Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        return userMapper.selectAll();
    }
}

3 编写测试代码

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void findAll() {
        List<User> users = userService.findAll();
        System.out.println(users);
    }
}

Spring Boot整合单元测试 , 需要在测试类上添加二个注解

\1. @RunWith(SpringRunner.class)指定Junit核心运行类

\2. @SpringBootTest 指定这是一个Spring Boot的测试类, 运行时会自动加载Spring Boot运行环境

4. 表现层

1 引入起步依赖

<!--Web起步依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--编码工具包-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>

2 新建工具类

package com.atguigu.utils;
import java.io.Serializable;
public class Result implements Serializable {
    private boolean status ; //响应状态  true  false
    private String msg ;  // 响应信息
    private Object data ;  //处理成功的响应数据

    public static Result ok(Object data){
        Result result = new Result();
        result.setStatus(true);
        result.setData(data);
        return  result ;
    
    public static Result error(String msg){
        Result result = new Result();
        result.setStatus(false);
        result.setMsg(msg);
        return  result ;
    }  
    // 生成set get tostring方法    
}  

3 编写表现层代码

@Controller
@RequestMapping(path = "/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查询所有用户信息
     * @return
     */
    @RequestMapping(path = "/findAll")
    @ResponseBody
    public Result findAll() {
        List<User> users = userService.findAll();
        return Result.ok(users);
    }
}

4 代码测试

使用postman进行测试

5. 页面展示

在resources目录下创建static目录 , 将提供的页面复制进来 , 修改即可 :

• 页面异步请求的端口和服务器端口一致
• 页面异步请求访问的路径和对应的表现层控制方法路径要致
• 页面异步请求参数名称和和对应的表现层控制方法参数一致

修改之后, 访问页面即可 : localhost:10001/list.html

6. 缓存优化

引入起步依赖

<!--springboot整合redis启动器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

编写配置文件

spring:
  redis: # 配置redis
    host: localhost
    port: 6379

修改业务层实现类代码

package com.atguigu.service.impl;

import com.atguigu.mapper.UserMapper;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper ;
    @Autowired
    private RedisTemplate redisTemplate ;

    @Override
    @Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        //从缓存中查询数据  规定存储用户信息使用string类型进行存储, 存储的key就是userList
        List<User> userList = (List<User>) redisTemplate.boundValueOps("userList").get();
        //如果缓存中没有数据, 查询数据库 , 将查询到的数据放入缓存
        if(userList==null){
            userList = userMapper.findAll();
            redisTemplate.boundValueOps("userList").set(userList);
            System.out.println("从数据库中查询...");
        }else {
            System.out.println("从缓存中查询.....");
        }

        //如果缓存中有数据, 直接返回
        return userList ;
    }
}

五 Spring Boot项目打包部署(应用)

1. 项目打包

1. 在`pom.xml`中配置Spring Boot项目的maven插件
   

<build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2. `运行`maven的打包命令 : package
   

3） 打包之前我们需要跳过测试 , 如果不跳过测试那么我们编写的测试类都会被maven自动执行, 可能会出现错误,导致打包不成功

4）执行之后可以在控制台看到打包的日志信息, 其中有生成的包的位置

打开指定目录就可以发现有一个jar包存在 , 仔细观察其实我们会发现 , 在target目录下其实会存在二个jar包 , 一个是springboot_02-1.0-SNAPSHOT.jar一个是springboot_02-1.0-SNAPSHOT.jar.original , 那么这两个jar包有什么区别呢?

我们如果是普通项目打包那么就只会得到一个jar包 , 这个jar包中不包含项目的一些依赖jar包

但是我们现在是一个Spring Boot项目 , 我们希望打完的包能够直接运行, 所以项目中就必须包含他的依赖jar包 , 我们之前在pom.xml中配置一个Spring Boot的maven插件可以在普通包的基础上将我们项目的一些运行及依赖信息打进jar包里面 , 打完包之后将原来的普通包改名为xxx.jar.original , 新打的包为xxx.jar .

5. ==简单总结一下== :
   

    .jar.original 是普通jar包，不包含依赖
?	.jar 是可执行jar包，包含了pom中的所有依赖，可以直接用java -jar 命令执行
?	如果是部署，就用.jar , 如果是给别的项目用，就要给.jar.original这个包

· 项目运行

打开命令行运行打出来的包；使用命令：java –jar ``包全名

java -jar springboot_02-1.0-SNAPSHOT.jar