1.课程介绍
1. Spring Boot简介;（了解）
2. Spring Boot入门;（了解）
3. Spring Boot简介web;（掌握）
4. Spring Boot测试;（掌握）
5. Spring Boot三层架构;（掌握）
6. Spring Boot 持久化;（掌握）
7. Spring boot模块化开发;（掌握）
2.Spring Boot简介
2.1.什么是Spring Boot
Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。
该框架使用了特定的方式(继承starter，约定优先于配置)来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application development）成为领导者。
Spring Boot并不是一个框架，从根本上讲，它就是一些库的集合，maven或者gradle项目导入相应依赖即可使用Spring Boot，而且无需自行管理这些库的版本。。

Spring Boot就是一些开发好了maven模块,只需导入对应模块就能做对应事情，目的是简化spring环境的配置和开发.
只需要springboot提供了哪些模块,每个模块是干嘛的.最终使用时判断要做那个功能,选择对应模块就ok.

2.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(dubbo)和Docker技术来构建微服务并部署到云端：
一个可执行jar即为一个独立服务很容易加载到容器，每个服务可以在自己的容器（例如docker）中运行
通过一个脚本就可以实现配置与部署，很适合云端部署，并且自动扩展也更容易

Springboot是为了简化Spring开发的.
简单而言，即Spring Boot使编码更简单，使配置更简单，使部署更简单，使监控更简单,使生活变得更美好。！
2.3.Spring Boot提供哪些功能
2.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就是一些开发好了maven模块,只需导入对应模块就能做对应事情.
springmvc
spring jdbc
data jpa
spring-boot-start-mybatis mybatis
spring-security
事务管理 service
spring-boot-start-test 测试
等等

Springboot没有引入新技术，就是把原来spring相关技术，进行maven模块封装，让我们使用起来更加简单。

3.Spring boot入门
3.1.环境要求
springboot就是用来简化我们的spring环境的搭建和开发。
开发环境JDK 1.8
项目管理工具（ Maven ）
开发工具(Eclipse)

3.2.入门
3.2.1.创建Maven项目

简单maven项目
3.2.2.导入Spring Boot依赖


org.springframework.boot spring-boot-starter-parent 1.4.1.RELEASE

添加spring-boot-starter-web依赖

org.springframework.boot
spring-boot-starter-web

3.2.3.编码测试
新建一个Controller类

新建启动类(App – Main方法)

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

org.springframework.boot
spring-boot-devtools
true
true

添加spring-boot-maven-plugin：



org.springframework.boot
spring-boot-maven-plugin


true

3.3.小结
本节主要是SpringBoot的基本引入及热部署的集成
4.Spring boot web
4.1.引入
前面我们使用Spring Boot能往浏览器中输出一个字符串！实际上我们需要的是跳转到一个页面或者获取一个Json数据。那怎么实现呢？
4.2.跳转Jsp
步骤：
创建Maven web project
引入依赖
配置application.properties对jsp支持
编写并启springboot应用
编写测试Controller
返回页面JSP
返回json
4.2.1.创建Maven Web Project

使用Eclipse新建一个Maven Web Project ，项目取名为：spring-boot-jsp

4.2.2.导入Maven依赖

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.4.1.RELEASE</version>
</parent>
<java.version>1.8</java.version>
<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>

<!-- tomcat 的支持. -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-tomcat</artifactId>
	<scope>provided</scope>
</dependency>
<dependency>
	<groupId>org.apache.tomcat.embed</groupId>
	<artifactId>tomcat-embed-jasper</artifactId>
	<scope>provided</scope>
</dependency>

4.2.3.搭建一个springboot应用
app main

4.2.3.1跳转页面
1)配置application.properties对jsp支持
添加src/main/resources/application.properties：

页面默认前缀目录

spring.mvc.view.prefix=/WEB-INF/jsp/

响应页面默认后缀

spring.mvc.view.suffix=.jsp

自定义属性，可以在Controller中读取

application.hello=Hello Angel From application

2)编写测试Controller

import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.RequestMapping;@Controller
 public class HelloController {
 @RequestMapping("/hello")
 public String helloJsp(Model model){
 System.out.println(“HelloController.helloJsp().hello=hello”);
 model.addAttribute(“hello”, “你好”);
 return “hello”;
 }
 }
 3)JSP在 src/main 下面创建 webapp/WEB-INF/jsp 目录用来存放我们的jsp页面：helloJsp.jsp:
<%@ page language=“java” contentType=“text/html; charset=UTF-8”
 pageEncoding=“UTF-8”%> 
Insert title here helloJsp

${hello}

4.2.3.2返回Json
要把Java对象转换为Json框架，使用的是JackSon，maven依赖的jar也有

@RequestMapping("/json")
 @ResponseBody
 public Person json(){
 return new Person(1L,“文兵”);
 }

4.2.4.启动App并测试
4.3.小结
SpringBoot搭建web项目非常简单，和原SpringMVC的使用方式类似，但启动方式和配置方式有区别。
5.SpringBoot测试
5.1 导入spring-boot-starter-test
在原有基础上面导入spring-boot-starter-test

org.springframework.boot
 spring-boot-starter-web



 org.springframework.boot
 spring-boot-starter-test



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
3) 真实实现:持久化实现
事务
每个框架 jdbc mybatis data jpa

7.Spring boot 持久化
7.1.引入
Spring Boot就数据库持久化支持，支持原生Jdbc，也支持Mybatis和data JPA。
7.2.Spring boot JdbcTemplate
引入spring-boot-starter-jdbc
那么只需要在需要使用的类中加入：
@Resource
private JdbcTemplate jdbcTemplate;

前台：表

7.2.1.引入Maven依赖-mysql，jdbc

mysql mysql-connector-java org.springframework.boot spring-boot-starter-jdbc 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，引入JdbcTemplate public Demo getById(long id){ String sql = "select *from Demo where id=?"; RowMapper rowMapper = new BeanPropertyRowMapper(Demo.class); return jdbcTemplate.queryForObject(sql, rowMapper,id); } 2)Service 声明为：@Service 引入dao @Resource private DemoDao demoDao; 
public void getById(Long id){
 demoDao.getById(id);
 }
 3)Controller
 @Resource
 private DemoService demoService;@RequestMapping("/getById")
 public Demo getById(long id){
 return demoService.getById(id);
 }


页面访问测试

事务使用的是注解事务,并且配置已经自动配置,只需打注解就ol.

2.1 声明式-xml版本
①配置事务管理器-transactionManager
②配置通知
③配置切入点





<tx:advice id=“txAdvice” transaction-manager=“transactionManager”>
 tx:attributes
 <tx:method name=“find*” 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”/>
 </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>
 2.2 注解版本(Springboot)
 ①配置事务管理器-transactionManager
 ②在需要处理事务Service上面打@Transational
 ③开启注解事务 tx:annotation-driven/
 7.3.Spring boot-spring data Jpa


7.3.1.Spring data jpa简介
1)Spring data
Spring Data是一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得数据库的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。此外，它还支持基于关系型数据库的数据服务，如Oracle RAC等。对于拥有海量数据的项目，可以用Spring Data来简化项目的开发，就如Spring Framework对JDBC、ORM的支持一样，Spring Data会让数据的访问变得更加方便。
2)Jpa
“规范”： 所谓的规范意指明文规定或约定俗成的标准。如：道德规范、技术规范，公司管理规范。那么“持久化规范”就是Sun针对持久化这一层操作指定的规范，如果没有指定JPA规范，那么新起的框架就随意按照自己的标准来了，那我们开发人员就没法把我们的经历全部集中在我们的业务层上，而是在想如何进行兼容，这种情况有点像Android开发，Android本身有官方的SDK,但是由于SDK过于开源了，结果导致很多厂商基于SDK二次开发，但是兼容性就不是很好，最好的例子就是Android的头像上传，就是一件很烦人的事情。好了，JPA就介绍到这里。
3)Hibernate
JPA是一种规范，而Hibernate是它的一种实现。除了Hibernate，还有EclipseLink(曾经的 toplink)，OpenJPA等可供选择，所以使用Jpa的一个好处是，可以更换实现而不必改动太多代码。
4)Spring data Jpa
Spring Data JPA能干什么
可以极大的简化JPA的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能。
首先我们需要清楚的是Spring Data是一个开源框架，在这个框架中Spring Data JPA只是这个框架中的一个模块，所以名称才叫Spring Data JPA。如果单独使用JPA开发，你会发现这个代码量和使用JDBC开发一样有点烦人，所以Spring Data JPA的出现就是为了简化JPA的写法，让你只需要编写一个接口继承一个类就能实现CRUD操作了

5)Spirng data jpa常用接口或类

Spring Data 的一个核心接口为我们提供了常用的接口
Repository 接口是 Spring Data 的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法 ：

public interface Repository<T, ID extends Serializable> { }

  1. Repository是一个空接口，即是一个标记接口；
  2. 若我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean纳入到IOC容器中，进而可以在该接口中定义满足一定规范的方法。
  3. 实际上也可以通过@RepositoryDefinition,注解来替代继承Repository接口。
  4. 查询方法以find | read | get开头；
  5. 涉及查询条件时，条件的属性用条件关键字连接，要注意的是条件属性以首字母大写。
    6.使用@Query注解可以自定义JPQL语句实现更灵活的查询。
CrudRepository 接口提供了最基本的对实体类的添删改查操作
 –T save(T entity);//保存单个实体   
 –Iterable save(Iterable<? extends T> entities);//保存集合         
 –T findOne(ID id);//根据id查找实体          
 –boolean exists(ID id);//根据id判断实体是否存在          
 –Iterable findAll();//查询所有实体,不用或慎用!          
 –long count();//查询实体数量          
 –void delete(ID id);//根据Id删除实体          
 –void delete(T entity);//删除一个实体   
 –void delete(Iterable<? extends T> entities);//删除一个实体的集合          
 –void deleteAll();//删除所有实体,不用或慎用!

PagingAndSortingRepository接口
该接口提供了分页与排序功能
–Iterable findAll(Sort sort); //排序
–Page findAll(Pageable pageable); //分页查询（含排序功能）

JpaRepository：查找所有实体，排序、查找所有实体，执行缓存与数据库同步

JpaSpecificationExecutor：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法，封装 JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象。

自定义 Repository：可以自己定义一个MyRepository接口。

jpa：规范，hibernate：具体的一个实现；
原生的jpa：
spring-data-jpa:简化原生的jpa的使用；
在springboot中：使用spring-data-jpa:
再简化(spring-data-jpa:简化原生的jpa的使用；)的使用

7.3.2.引入Maven依赖-mysql,springdatajpa

mysql
 mysql-connector-java org.springframework.boot spring-boot-starter-data-jpa 7.3.3.配置jdbc spring data jpa 在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

########################################################

Java Persistence Api

########################################################

Specify the DBMS

spring.jpa.database = MYSQL

Show or not log for each sql query

spring.jpa.show-sql = true

Hibernate ddl auto (create, create-drop, update)

spring.jpa.hibernate.ddl-auto = update

Naming strategy

#[org.hibernate.cfg.ImprovedNamingStrategy #org.hibernate.cfg.DefaultNamingStrategy]
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy

stripped before adding them to the entity manager)

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

7.3.4.编写代码测试
(1) 创建实体类。
(2) 创建接口继承JpaRepository操作持久化(JpaRepository)。
(3) 创建service类。
(4) 创建controller请求类。
(5) 测试;

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

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>

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

########################################################
 ###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别名:mybatis.type-aliases-package=
 cn.itsource.springboot.ssm.domain（4）创建启动类App.java
 @SpringBootApplication
 @MapperScan(“cn.itsource.springboot.mybatis.mapper”)
 public class App {
 public static void main(String[] args) {
 SpringApplication.run(App.class, args);
 }
 }//这里和以往不一样的地方就是MapperScan的注解，这个是会扫描该包下的接口
 注解版
 （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);

}

XML
 （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);
}

}

//运行访问：http://127.0.0.1:8080/likeName?name=张三 就可以看到返回的数据了
一:加上Mapper扫描路径
@MapperScan(“cn.itsource.springboot.mapper”)
二 映射
注解版本:
打注解
xml版本
1)配置Mapper的xml文件
2)导入映射文件地址

别名:mybatis.type-aliases-package=
cn.itsource.springboot.ssm.domain
映射文件路径:
① 默认在接口同包同名映射配置文件

7.4.2.使用PageHelper分页

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>4.1.0</version>
</dependency>

@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;
}
}
 @Override
 public List list() {
 PageHelper.startPage(1, 2);
 PageHelper.orderBy(“id asc”);
 return userDao.loadAll();
 }

7.4.3.获取自增Id
xml:

<insert id="save" parameterType="User"
  useGeneratedKeys="true"
  keyProperty="id"
  keyColumn="id"
>
	insert into t_user(name) values(#{name})
</insert>

注解:

@Options(useGeneratedKeys = true, keyProperty = “id”, keyColumn = “id”)
 @Insert(“insert into Demo(name,password) values(#{name},#{password})”)
 public long save(Demo name);//对象上面也有

7.4.4.模块化开发

7.5.总结

8.课程总结
8.1.重点
1.Spring Boot入门
2.Spring Boot Web
3.Spring Boot 持久化
4.Spring Boot SSM
8.2.难点
1.Spring Boot Web
2.Spring Boot 持久化
3.Spring Boot SSM
8.3.如何掌握？
1.勤加练习…
2.学会看说明手册
8.4.排错技巧（技巧）