1.Spring Boot简介

spring生态圈

1.1 什么是Spring Boot

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。使用springboot以后，搭建一个spring应用和开发变得很简单
该框架使用了特定的方式（继承starter，约定优先于配置）来进行配置，从而是开发人员不再需要定义样板的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者
Spring Boot并不是一个框架，从根本上将，它就是一些maven库的集合，maven或者gradle项目导入相应依赖即可使用Spring Boot，而且无需自行管理这些库的版本
SpringBoot就是一些写好了maven的模块，我们在使用Spring就不需要以传统的方式来用，只需要以maven导入相应的springboot模块，就能完成一大堆操作。简单的说，它使用maven的方式对Spring应用开发进行进一步封装和简化

1.2 为什么要使用Spring Boot

Spring Boot是为简化Spring项目配置而生，使用它使得jar依赖管理以及应用编译和部署更为简单。Spring Boot提供自动化配置，使用Spring Boot，你只需编写必要的代码和配置必须得属性
使用Spring Boot，只需20行左右的代码即可生成一个基本的Spring Web应用，并且内置了tomcat，构建的fat Jar包通过Java -jar就可以直接运行
如上特性使用Spring Boot非常契合微服务的概念，可以结合Spring Boot与Spring Cloud和Docker技术来构建微服务并部署到云端
一个可执行jar即为一个独立服务很容易加载到容器，每个服务可以在自己的容器（例如docker）中运行
通过一个脚本就可以实现配置与部署，很适合运毒那部署，并且自动扩展也很容易
简单而言，即Spring Boot使编码更简单，使配置更简单，使部署更简单，使监控更简单
SpringBoot就是为了简化spring应用搭建，开发，部署，监控的开发工具

1.3 Spring Boot提供哪些功能

就是一些maven模块，我们需要知道有哪些模块，什么时候该导入什么模块

1.3.1 无需手动管理依赖jar包的版本

Spring Boot通过spring boot starter项目管理其提供的所有依赖的版本，当升级spring boot时，这些依赖的版本也会随之升级。个人无需指定版本号
但是也可以自定义版本号覆盖springboot的默认值。每个版本的boot都有对应的base spring version，不建议明确地指定spring版本。
例如，使用maven使，只需简单的在pom中包含spring-boot-starter-web即引入了Spring MVC和Tomcat的依赖
下面是Spring Boot在org.springframework.boot组下提供的一些Starters：

名称	描述
spring-boot-starter	核心Spring Boot starter，包括自动配置支持，日志和YAML
spring-boot-starter-actuator	生产准备的特性，用于帮你监控和管理应用
spring-boot-starter-web	对全栈web开发的支持，包括Tomcat和spring-webmvc
spring-boot-starter-aop	对面向切面编程的支持，包括spring-aop和AspectJ
spring-boot-starter-data-jpa	对“Java持久化API”的支持，包括spring-data-jpa,spring-orm和Hibernate
spring-boot-starter-jdbc	对JDBC数据库的支持
spring-boot-starter-security	对spring-security的支持

spring-boot-starter-web:web支持，其实就是springmvc简化使用
Spring-boot-starter-jdbc:springboot对jdbc支持
Spring-boot-starter-data jpa:springboot对data jpa支持
Spring-boot-starter-mybatis:springboot对mybatis支持
Spring-boot-starter-test：springboot对test支持
总之springboot就是简化spring应用开发，对web，service，dao层都支持

2.Spring Boot入门

2.1 环境要求

开发环境JDK1.8
项目管理工具（Maven）
开发工具（Eclipse/idea）

2.2 入门

2.2.1 创建Maven项目

2.2.2 导入Spring Boot依赖

<!-- 
	spring boot 父节点依赖,引入这个之后相关的引入就不需要添加version配置，spring boot会自动选择最合适的版本进行添加。
 -->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.8.RELEASE</version>
</parent>
<properties>
	<java.version>1.8</java.version>
</properties>

<!--
	添加spring-boot-starter-web依赖(在01_hello模块中)
-->
<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
</dependency>

2.2.3 编译测试

新建一个Controller类

@Controller
@RequestMapping("/hello")
public class HelloController {
	@RequestMapping("/hi1")
	@ResponseBody //直接作为字符串返回而不是页面地址
	public String sayHello(String name) {
		return name + "多对多   say hello 嘎嘎1和返回和返回哈哈发挥发挥!";
	}
	@RequestMapping("/hi2")
    @ResponseBody //直接作为字符串返回而不是页面地址
    public String sayHello2(String name){
        return name +" 多对多   say hello 嘎嘎1和返回和返回哈哈发挥发挥!";
    }
}

2.2.4 新建启动类(App - Main方法)

@SpringBootApplication//标识该应用为springboot的应用
public class HelloApplication {
	//一 传统开发springweb项目怎么干的?
    // 1 启动外部tomcat
    // 2 根据web.xml中配置信息初始化一个spring容器(applicationContext)
    // 3 做了一些常规配置后还会根据扫描包路径扫描一些bean(dao,service,controller)
    public static void main(String[] args) {
		//启动springboot应用
        // 1 启动了一个内置tomcat
        // 2 初始化一个spring容器
        // 3 自动配置(springmvc),扫描加了@SpringBootApplication类的当前包及其子子孙孙里面所有spring注解(@Repository @service @controller)
        //并且把扫描到的类纳入Spring管理
        SpringApplication.run(HelloApplication.class);
	}
}

2.2.5 热部署

即使修改了输出内容也要重启APP，非常麻烦！可以使用spring-boot-devtools来实现热部署
（1）介绍
spring-boot-devtools 是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。
其深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类（自己写的），称为 restart ClassLoader
,这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内）
（2）使用
添加依赖包

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

添加spring-boot-maven-plugin到boot_web中：

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

在idea中需要手动编译一下,ctrl+F9最好用下面这种方式解决热部署

3.Spring Boot Web

3.1 引入

前面我们使用Spring Boot能往浏览器中输出一个字符串！实际上我们需要的是跳转到一个页面或者获取一个Json数据。那怎么实现呢？

3.2 Freemaker支持

3.2.1 基本环境搭建

maven项目(web-app)
导入jar

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

3.2.2 配置application.properties

# FreeeMarker 模板引擎配置
spring.freemarker.allow-request-override=false
spring.freemarker.cache=false
spring.freemarker.check-template-location=true
spring.freemarker.charset=UTF-8
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=false
spring.freemarker.expose-session-attributes=false
spring.freemarker.expose-spring-macro-helpers=false

3.2.3 Controller

@Controller
public class IndexController {
    @RequestMapping("/index")
    public String index(Model model){
        model.addAttribute("message", "呵呵!");
        return "index";
    }
}

3.2.4 模块

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org"
             xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
	<head>
		<title>Hello World!</title>
	</head>
	<body>
		<h1>Hello，${message}</h1>
	</body>
</html>

3.3 获取Json数据

3.3.1 导入依赖包

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

 <!-- servlet 依赖. -->
<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
	<scope>provided</scope>
</dependency>
<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>jstl</artifactId>
</dependency>

3.3.2 建立domain里的实体类

public class Person {
	private Long id;
	private String name;
	private Date birthDay;
	
	public Long getId()	{
		return id;
	}
	public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
	
	@JsonFormat(pattern = "yyyy-MM-dd hh:mm:ss",timezone = "GMT+8")
    public Date getBirthDay() {
        return birthDay;
    }

    public void setBirthDay(Date birthDay) {
        this.birthDay = birthDay;
    }

	public Person(Long id, String name, Date birthDay) {
        this.id = id;
        this.name = name;
        this.birthDay = birthDay;
     }
}

3.3.3 编写测试类控制器

package cn.itsource.springboot.controller;

import cn.itsource.springboot.domain.Person;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Arrays;
import java.util.Date;
import java.util.List;

@Controller
@RequestMapping("/json1")
public class JsonController {
	//字符串
    @RequestMapping("/str")
    @ResponseBody
    public String json1(){
        return "yhptest";
    }
    //对象-日期
    @RequestMapping("/obj")
    @ResponseBody
    public Person json2(){
        return new Person(1L,"yhptest",new Date());
    }
    //数组
    @RequestMapping("/array")
    @ResponseBody
    public List<Person> json3(){
        return Arrays.asList(new Person(1L,"yhptest",new Date())
                ,new Person(2L,"yaohuaipeng",new Date()));
    }
}

4.SpringBoot配置

4.1 YAML

Springboot除了支持properties的配置，还支持yaml，而且企业中也是用的最多的

4.1.1 YAML是什么

YAML是YAML Ain’t Markup Language递归缩写，是YAML不是标记语言的意思，读音“yamel”（或者“雅梅尔”）。YAML是便于人阅读基于unicode编码的各种语言的序列号标准。它的用途广泛，用于配置文件，日志文件，跨语言数据共享，对象持久化，复杂的数据结构

4.1.2 原则与语法

原则：
1.大小写敏感
2.使用缩进表示层级关系
3.缩进长度没有限制，只要元素对齐就表示这些元素属于一个层级
4.使用#表示注释
5.字符串可以不用引号标注
语法：
1.map，散列表
使用冒号（:）表示键值对，同一缩进的所有键值对属于一个map，示例：

# YAML表示
age : 12
name : huang

# 对应的Json表示
{'age':12,'name':'huang'}

2.list，数组
使用连字符（-）表示

# YAML表示
- a
- b
- 12

# 对应Json表示
['a','b',12]

3.相互嵌套

-
	id : 1
	name : huang
-
	id : 2
	name : liao

# 对应Json表示
[{ id : 1,name : 'huang' },{ id : 2,name : liao' }]

4.1.3 案例实战

server:
	port: 9000
spring:
	freemarker:
		allow-request-override: false
		cache: false
		check-template-location: true
		charset: utf-8
		content-type: text/html
		expose-request-attributes: false
		expose-spring-macro-helpers: false
		expose-session-attributes: false

4.2 SpringBoot运行方式

4.2.1 在idea中直接通过main函数启动

开发时候

4.2.2 jar运行

项目上线java-jar xxx.jar 只依赖jdk
打包：

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

cmd窗口
mvn clean package spring-boot:repackage
运行:
java -jar xxx.jar

4.3 Spring Profiles多环境支持

4.3.1 是什么

Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只在特定的环境下生效

测试
…
开发
…
产品
…
配置多个环境
运行时执行特定环境

4.3.2 实现

（1）多环境
我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml
默认使用application.properties/yml的配置

server:
	port: 8081
spring:
	profiles:
		active: prod
---
server:
	port: 8083
spring:
	profiles: dev
---
server:
	port: 8084
spring:
	profiles: prod #指定属于哪个环境

（2）激活指定profile
1.在配置文件中指定 spring.profiles.active=dev
2.2、命令行：java -jar -Dspring.profiles.active=dev
spring-boot-02-config-0.0.1-SNAPSHOT.jar

5.SpringBoot测试

5.1 导入spring-boot-starter-test

在原有基础上面导入spring-boot-starter-test

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- web支持: 1、web mvc; 2、restful; 3、jackjson支持; 4、aop ........ -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
</dependency>

5.2 创建一个SpringBoot应用，并在下面创建一个Bean

@SpringBootApplication
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class,args);
	}
}

5.3 写SpringBoot测试从Springboot中获取bean就ok

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class) //这事一个Spring测试，要告诉它在哪儿加载Spring配置文件，其实告诉它应用类型就ok
public class SpringbootTest {
	@Autowired
	private TestService testService;
	@Test
	public void test() throws Exception {
		System.out.println(testService);
		testService.test();
	}
}

6.集成三层结构

Service :Spring来做事务管理
Web:Spring MVC
DAO:各种持久化技术-jdbc,mybatis.spring data jpa
Spring集中集中管理
1).搭建三层结构-不要考虑持久化层，打印即可,当然暂时不要事务
2). dao+service+junit+controller+jsp/js/css

7.Spring Boot持久化

7.1 引入

Spring Boot就数据库持久化支持，支持原生Jdbc，也支持Mybatis和JPA

7.2 Spring Boot JdbcTemplate

引入spring-boot-starter-jdbc
那么只需要在需要使用的类中加入：
@Resource
private JdbcTemplate jdbcTemplate;

7.2.1 引入Maven依赖mysql,jdbc

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

7.2.2 数据库信息配置

在application.properties文件中配置mysql连接配置文件
###datasource
spring.datasource.url = jdbc:mysql://localhost:3306/test
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

7.2.3 编写代码测试

（1）.Dao

@Repository
public class UserDaoImpl implements IUserDao {
	@Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void save(User user)	{
		//添加
        jdbcTemplate.update("insert into user(username,password) values(?,?)",user.getName(),user.getPassword());
	}
}

（2）.Service

@Service
@Transactional(propagation = Propagation.SUPPORTS,readOnly = true)//类级别是只读事务
public class UserServiceImpl implements IUserService {
	@Autowired
    private IUserDao userDao;
    @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
    //@Transactional 后两个配置是默认值
    @Override
    public void add(User user) {
        userDao.save(user);
       // int i = 1/0;
    }
}

（3）.Controller

@Resource
private DemoService demoService;
@RequestMapping("/getById")
public Demo getById(long id){
	return demoService.getById(id);
}

7.2.4 Spring Boot注解事务

声明式(xml): 配置事务管理器 配置通知 配置切面（切入后要应用通知）

<!-- 配置事物管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource" />
</bean>
<!-- aop应用事务管理 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
		<tx:method name="get*" read-only="true"/>
		<tx:method name="select*" read-only="true"/>
		<tx:method name="search*" read-only="true"/>
		<tx:method name="query*" read-only="true"/>
		<tx:method name="*" propagation="REQUIRED" read-only="true"/>
	<tx:attributes>
</tx:advice>
<aop:config>
	<aop:pointcut expression="execution(*cn.itsource.eloan.core.service..*.*(..))" id="coreServicePointcut"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="coreServicePointcut"/>
</aop:config>

原来实现：
1）事务管理器
2）开启注解，就是能够识别@Transactional
3）在要控制事务的Service的或方法上面加上@Transactional
建议：类级别为只读事务，需要写事务的方法上面加写事务
SpringBoot：注解式事务
所有配置springboot都已经实现了，只需打注解即可

7.3 Spring Boot-mybatis

7.3.1 集成Mybatis

（1）新建maven project;
新建一个maven project,取名为：spring-boot-mybatis
（2）在pom.xml文件中引入相关依赖；
2.1 基本依赖，jdk版本号；
2.2 mysql驱动，mybatis依赖包，mysql分页PageHelper：

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

<!-- mysql 数据库驱动. -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>

<!-- 	
		spring-boot mybatis依赖：
		请不要使用1.0.0版本，因为还不支持拦截器插件，
		1.1.1 是博主写帖子时候的版本，大家使用最新版本即可
-->
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>1.1.1</version>
</dependency>

<!-- 
    	MyBatis提供了拦截器接口，我们可以实现自己的拦截器，
    	将其作为一个plugin装入到SqlSessionFactory中。 
		Github上有位开发者写了一个分页插件，我觉得使用起来还可以，挺方便的。 
		Github项目地址： https://github.com/pagehelper/Mybatis-PageHelper
 -->
 <dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>4.1.0</version>
</dependency>

（3）。创建启动类App.java

@SpringBootApplication
@MapperScan("cn.itsource.springboot.mybatis.mapper")
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
	//这里和以往不一样的地方就是MapperScan的注解，这个是会扫描该包下的接口
}

（4）.在application.properties添加配置文件

spring.datasource.url = jdbc:mysql://localhost:3306/test
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

（5）.编写Demo测试类

public class Demo {
	private long id;
	private String name;
    //省略getter and setter…
}

（6）.编写DemoMapper

public interface DemoMappper {
	@Select("select *from Demo where name = #{name}")
	public List<Demo> likeName(String name);
	
	@Select("select *from Demo where id = #{id}")
	public Demo getById(long id);
	
	@Select("select name from Demo where id = #{id}")
	public String getNameById(long id);
}

（7）.编写DemoService

@Service
public class DemoService {
	@Autowired
	private DemoMappper demoMappper;
	
    public List<Demo> likeName(String name){
        return demoMappper.likeName(name);
    }
}

（8）.编写DemoController

@RestController
public class DemoController {
	@Autowired
	private DemoService demoService;
	
	@RequestMapping("/likeName")
	public List<Demo> likeName(String name){
		return demoService.likeName(name);
	}
}

7.3.2 使用PageHelper分页

PageHelper是mybatis一个插件,可以用它完成分页

@Configuration
public class MyBatisConfiguration {
	@Bean
    public PageHelper pageHelper() {
		System.out.println("MyBatisConfiguration.pageHelper()");
        PageHelper pageHelper = new PageHelper();
        Properties p = new Properties();
        p.setProperty("offsetAsPageNum", "true");
        p.setProperty("rowBoundsWithCount", "true");
        p.setProperty("reasonable", "true");
        pageHelper.setProperties(p);
        return pageHelper;
    }
}

测试

@RequestMapping("/likeName")
public List<Demo> likeName(String name){
		 PageHelper.startPage(1,1);
	     return demoService.likeName(name);
}