前言

Springboot是现在学习Java开发必备的一个技术点。讲真,这是一个非常简单的东西，只要花一点时间都可以非常愉快的把他用起来。但是现在教程一般都是两种，一种是使用idea直接创建就开始用，导致感觉懂了，但是又有很多细节流失。另一种是先讲大篇原理，半天不入门，让很多初学者摸不到头脑。 所以我想从使用层面入手，但是不丢失细节的方式来带大家入门。

一.认识SpringBoot

• 为简化Spring项目配置而生
• 使用maven的方式对Spring应用开发进行进一步封装和简化
• 为了简化spring应用搭建，开发，部署，监控的开发工具
• 官网：spring.io/projects/sp…

二.Maven的父子项目认识

本节与SpringBoot无关，已经了解Maven父子关系的同学可以忽略本章

咱们刚才说了，SpringBoot是使用maven(注:也可以使用Gradle)的方式对Spring应用开发进行进一步的封装和简化。所以咱们在学习SpringBoot前需要学习Maven，而在练习前咱们会创建多个练习demo,因此，在这里需要先进行Maven父子模块讲解(已经了解Maven父子模块可以忽略本章)

• idea只能创建一个项目，所以咱们会以模块的方式来进行项目的创建
• 咱们会先创建一个父项目，然后在里面创建多个子模块

2.1 创建一个普通Maven项目

• 开发工具使用idea

2.1.1 创建普通的maven项目(父项目)

• 取名springboot-parent

2.1.2 创建子模块项目

• 取名springboot-hello-01

2.2 父子模块分析

主要是分析两个pom.xml中的内容

2.2.1 父模块pom.xml

<?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>
    <!--组id-->
    <groupId>cn.itsource</groupId>
    <!--模块名称-->
    <artifactId>springboot-parent</artifactId>
    <!-- packaging jar === 当前项目打成jar包 war === 当前项目打成war包 pom === 当前项目不写java代码,权代表用于管理jar包 maven-plugin === 当前项目用于开发插件使用(暂时不用管) -->
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <!--父项目中管理的所有子项目模块-->
    <modules>
        <!--管理的子项目模块,注意名称和子模块名称保持一致-->
        <module>springboot-hello-01</module>
    </modules>


</project>

2.2.2 子模块pom.xml

<?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">
    <!-- 当前子模块的pom.xml中没有声音自己的版本与主id 通过parent 引入父模块中的内容(这里是继承关系) -->
    <parent>
        <artifactId>springboot-parent</artifactId>
        <groupId>cn.itsource</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <!--子模块的名称-->
    <artifactId>springboot-hello-01</artifactId>
</project>

三.Hello,SpringBoot

3.1 继承springboot的父依赖

• springboot为咱们准备好了相关依赖jar包(下面代码直接拷备使用即可)
• pom.xml是单继承的结构，所以我们在父pom.xml中继承父依赖
• 父依赖中已经声明了很多现在可用的jar包(大家可看源码分析)
• dependencyManagement：只声明 不引用

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.5.RELEASE</version>
</parent>

3.2 子pom.xml中添加依赖

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

3.3 创建controller

@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/01")
    @ResponseBody
    public String hello01(){
        return "hello springboot";
    }
}

3.4 创建启动类

特别注意:启动类必需在外层

//申明我当前是一个SpringBoot的应用
@SpringBootApplication
public class ApplicationConfig {

    public static void main(String[] args) {
        // 注:这里传入的字段码对象，必需是声明了@SpringBootApplication的类
        //启动SpringBoot程序
        SpringApplication.run(ApplicationConfig.class);
    }
}

3.5 注意事项(疑问)

1. 为什么要继承spring-boot-starter-parent
   • 父项目准备了很多应用的插件与jar包,子项目可以直接引用即可(方便开发)
2. 当前项目引入 spring-boot-starter-web是什么意思？
   • 在引入后就会导入spring运行web项目的所有jar包(如spring,日志,mvc包等等)
   • springboot有组合包的概念,专门用于简化maven的导包
   • springboot提供包的格式: spring-boot-starter-xxx
3. 居然一个主方法启动了tomcat
   • spring-boot-starter-web内嵌了一个tomcat插件
4. 为什么主方法运行后，应用程序就启动了
   • 初始化运行程序中的所有bean对象(只有扫描它所有的包及其子包的java对象)
   • 自动装配springmvc的相关代码与配置(有默认的配置,我们以后可以修改)
   • 初始化spring容器
   • 把当前应用打成一个jar包放到tomcat中运行

四.SpringBoot三种运行方式

4.1 直接在工具中运行main方法

最简单，咱们平时开发时也就这样直接运行

4.2 插件运行

1. 引入插件

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2. 运行项目
   

   

4.3 打包运行

注:打包运行必需要引入插件 咱们以后开发项目放到服务器中运行，就可以使用这种方式

• 当前位置打开cmd,并且输入java -jar springboot-hello-01-1.0-SNAPSHOT.jar

五.热部署方案

• 在pom.xml中加上热部署插件(代码如下)
• 修改代码后按 ctrl+f9 进行编译

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
   <scope>true</scope>
</dependency>	

六.SpringBoot配置文件

6.1 springboot配置文件认识

• 默认配置文件会在resources中
• 配置文件有两种(我们任选一种即可)
  • application.properties
  • application.yml

6.2 application.properties

properties的配置咱们以前都已经学过，这里简单看一下端口修改的配置即可

server.port=80
server.servlet.path=/haha

6.3 application.yml的配置

yml是一种更加优雅的配置方式(有层次结构)，之后咱们都直接使用yml的方式来做配置

6.3.1 基本用法

• 以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的
• k:(空格)v：表示一对键值对(空格必须有)
• 属性和值也是大小写敏感

server:
  port: 8088
  servlet:
    path: /haha

6.3.2 字符串的字面量

• 字符串不需要加引号
• 双引号不会对串中转义字符进行转义
  • name: "zhangsan \n lisi"：输出；zhangsan 换行 lisi
• 单引号转义特殊字符
  • name: "zhangsan \n lisi"：输出；zhangsan \n lisi

注:以后配置文件中可能还会写数组，集合等，后面的课程涉及到会单独讲解，大家也可以自行在网上进行查找

6.4 多环境支持方案

咱们以后可能会遇到一个项目多个环境(开发，测试，上线等)，为不同的环境会写一些不同的配置，那么就需要咱们做相应的环境之间的切换

6.4.1 多文档块模式

• 使用三个框(---)来区分
• 可调用不同的方式

# 确定哪一个模块为活动模块
spring:
  profiles:
    active: pro

---
#开发模块
server:
  port: 8088
spring:
  profiles: dev

---
#测试模块
server:
  port: 8089
spring:
  profiles: test

---
#在线模块
server:
  port: 8099
spring:
  profiles: pro

6.4.2 多profile文件模式

• 创建多个yml文件，注意名称都是 applicaton-xxx.yml命名(如下截图)

七.SpringBoot的测试功能

1. 在咱们父模块下新建一个子模块 springboot-test
2. 引入springboot的测试starter
3. SpringBoot的启动类
4. 准备一个bean让Spring管理
5. 完成测试(看是否可以注入使用这个bean)

7.1 最近创建好的结构

7.2 引入测试依赖(starter)

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

7.3 准备启动类

@SpringBootApplication //声明这是一个springboot应用
public class ApplicationConfig {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationConfig.class,args);
    }
}

7.4 准备一个MyBean让Spring管理

//创建一个bean
@Component
public class MyBean {
}

7.5 功能测试

@RunWith(SpringRunner.class)
//代表这是一个SpringBoot的测试
// classes对应的类必需是经过SpringBootApplication修饰的类
@SpringBootTest(classes=ApplicationConfig.class)
public class MyBeanTest {
    @Autowired
    private MyBean myBean;

    @Test
    public void test01(){
        System.out.println(myBean);
    }
}

七.RestController注解方式

• 在大量返回json的Controller中使用(以后用得比较多)
• RestController是一个组合注解 它等于 (@Controller+@ResponseBody)

咱们创建一个新的模块进行测试,下面为核心代码(基础代码此处省略)

@RestController
@RequestMapping("/json")
public class JsonController {


    //返回普通数据
    @RequestMapping("/01")
    public String json01(){
        return "hello json";
    }
    //返回对象
    @RequestMapping("/02")
    public Employee json02(){
        return new Employee(1L,"小春风");
    }
    //返回集合
    @RequestMapping("/03")
    public List<Employee> json03(){
        return Arrays.asList(
                new Employee(1L,"令狐兄"),
                new Employee(2L,"不群兄"),
                new Employee(3L,"我行兄")
        );
    }

    //返回map
    @RequestMapping("/04")
    public Map json04(){
       Map map = new HashMap();
       map.put("name","小飞侠");
       map.put("age",24);
       map.put("sex",false);
       return map;
    }

}

八.Thymeleaf

• Thymeleaf是一个模板技术
  • 其它的模板技术:freemarker,velocity,jsp等
  • jsp现在用得很少,因为它必需依赖servlet容器才能运行,并且编译的效率低下
• springboot推荐使用Thymeleaf
• 详细语法:fanlychie.github.io/post/thymel…

8.1 引入thymeleaf的支持包

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--引入thymeleaf的支持-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
</dependencies>

8.2 完成thymeleaf的配置

• 该步骤可以省略,默认前缀classpath:/templates/,后缀.html

spring:
  thymeleaf:
    prefix: classpath:/templates/
    suffix: .html

8.3 controller完成跳转传参

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String index(Model model){
        model.addAttribute("msg","hello,Springboot");
        return "index";
    }
}

8.4 页面展示

注:加上xmlns:th="http://www.thymeleaf.org"则会支持thymeleaf的提示

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
        <!--使用语法th:text 可以设置里面的文本内容 -->
        <div th:text="${msg}">你好啊！兄弟！！！</div>
</body>
</html>

九.框架集成

注: 练习前先准备相应的数据库与表数据

9.1 导包

导入:数据库驱动包,springboot与jdbc集成包,mybatis与springboot集成包,springboot的web支持包

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--springboot与jdbc集成包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mybatis提供的与springboot集成包 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
    </dependencies>

9.2 准备代码结构

9.3 yml配置文件

spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql:///mytest
    driver-class-name: com.mysql.jdbc.Driver
##mybatis的配置
mybatis:
  # 扫描相应的映射文件
  mapper-locations: classpath:cn/itsource/mapper/*.xml
  # 该包下的对象取别名
  type-aliases-package: cn.itsource.domain
##日志级别的打印(需要看日志的可以直接拷备使用:特别注意它的层级)
logging:
  level:
    cn:
      itsource: trace
  root: error

9.4 进行mapper接口的扫描

@SpringBootApplication
//进行相应的映射接口扫描
@MapperScan("cn.itsource.mapper")
public class ApplicationConfig {

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

9.4 mapper层功能

1. mapper的接口功能

public interface UserMapper {
    List<User> findAll();
    void save(User user);
}

2. mapper的xml文件(注:写在resource中对应的位置)

<?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="cn.itsource.mapper.UserMapper">

    <select id="findAll" resultType="User">
        select * from user
    </select>

    <insert id="save" parameterType="User">
        insert into user (username) values (#{username})
    </insert>
</mapper>

3. 完成功能测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ApplicationConfig.class)
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void mytest(){
        userMapper.findAll().forEach(user -> {
            System.out.println(user);
        });
    }
}

9.5 service层功能

注:Springboot已经集成事务，咱们可以直接使用

1.IUserService代码

public interface IUserService {
    List<User> findAll();
    void save(User user);
}

2.UserServiceImpl功能实现

@Service
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public class UserServiceImpl implements IUserService {

    @Autowired
    private UserMapper mapper;

    @Override
    public List<User> findAll() {
        return mapper.findAll();
    }

    @Override
    @Transactional
    public void save(User user) {
        mapper.save(user);
        int i = 1/0;
    }
}

3.测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ApplicationConfig.class)
public class UserServiceTest {
    @Autowired
    private IUserService userService;
    @Test
    public void save(){
        User user = new User();
        user.setUsername("虎子xx");
        userService.save(user);
    }
    @Test
    public void findAll(){
        userService.findAll().forEach(user -> {
            System.out.println(user);
        });
    }
}

9.6 controller层功能

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private IUserService userService;

    @RequestMapping("/findAll")
    public List<User> findAll(){
        return userService.findAll();
    }
}