Spring Boot

2019-04-09 浏览次数:

一、Spring Boot入门

1.简介

Spring Boot是J2EE开发的一站式框架，简化Spring开发，整合Spring整个技术栈，包含Spring全家桶。

2.Spring Boot优点

1.快速创建独立运行的Spring项目以及与主流框架集成
2.使用嵌入式的Servlet容器，应用无需打成WAR包
3.starters自动依赖与版本控制
4.大量的自动配置，简化开发，也可修改默认值
5.无需配置XML，无代码生成，开箱即用
6.准生产环境的运行时应用监控
7.与云计算的天然集成

3.微服务

(1)单体应用

(2)微服务

所谓的微服务，就是区别于以往的一体式的应用，而是通过把应用的各个功能独立开来，需要的时候自由组合，组成一个完整的应用。

4.Spring Boot HelloWorld

1.新建maven工程
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">
<modelVersion>4.0.0</modelVersion>

<groupId>com.xiaohuzi.test</groupId>
<artifactId>helloworld</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.20.RELEASE</version>
</parent>

<!-- Add typical dependencies for a web application -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<!-- Package as an executable jar -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

</project>

3.编写SpringBoot运行入口

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


//@SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用

@SpringBootApplication
public class HelloWorld {

//运行入口
public static void main(String[] args) {
    SpringApplication.run(HelloWorld.class,args);
}
}

4.编写Controller类

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
//@RestController就是@Controller和 @ResponseBody的结合
@Controller
public class HelloWorldController {
@ResponseBody
@RequestMapping("/hello")
public String hello(){

    return "hello world";
}
}

5.SpringBoot应用打包

5.SpringBoot依赖详解

1.父项目的依赖

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.20.RELEASE</version>
</parent>
spring-boot-starter-parent的父项目
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>1.5.20.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

所以引入spring-boot-starter-parent目的是用来管理SpringBoot中的依赖版本，有了这个之后导包含在内的依赖就可以不用导入版本了。

2.启动器spring-boot-starter

6.Spring Boot主程序类，主入口类

1	@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot 就会运行这个类的main方法来启动SpringBoot应用

下面来一步步说明如何通过@SpringBootApplication一个注解就可以完成那么多的配置的：
(1)@SpringBootApplication内部

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)

也是一些注解
其中
1
①.@SpringBootConfiguration：表示被标注的类是SpringBoot的配置类
②.在@SpringBootConfiguration中有个@Configuration：表明被配置的类是一个配置类
③.在@Configuration中有@Componment：在配置类下面通过组件来完成操作。

2
①.@EnableAutoConfiguration：开启自动配置功能，不需要手动配置，SpringBoot会自动配置。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({EnableAutoConfigurationImportSelector.class})

②.在@EnableAutoConfiguration中有个@AutoConfigurationPackage：自动配置包，定义默认的包扫描规则

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})

③.@Import({Registrar.class})：其中import是Spring底层的注解，功能是给容器导入一个组件，而它导入的组件Registrar.class目的是将@SpringBootApplication标注的类的所在包以及子包都扫描到Spring容器，这也就是为什么@Controller等注解可以被识别。

④.@Import({EnableAutoConfigurationImportSelector.class})：导入组件的选择器，将所需要导入的组件以全类名的方式返回，这些组件就会被添加到容器中。来供程序运行使用。

⑤.SpringFactoriesLoader.loadFactoryNames(EnableAutoConﬁguration.class,classLoader)；：Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConﬁguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；以前我们需要自己配置的东西，自动配置类都帮我们配置；
J2EE的整体整合解决方案和自动配置都在spring-boot-autoconﬁgure-1.5.20.RELEASE.jar；

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

IDEA
1.创建项目

2.项目结构

二、Spring Boot配置

1.配置文件

(1)Spring Boot全局配置文件有两个：

application.xml
application.yml

其作用都是修改Spring Boot自动配置的默认值。
其中我们不熟悉的是application.yml
YAML:以数据为中心，比json、xml更适合做配置文件
很简洁
yml例子：

1 2	server: port: 8081

XML:

1
2
3

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

(2)yml语法
①.yml基本语法
k:(空格)v：表示一对键值对（空格必须有）

1.使用缩进表示层级关系
2.缩进时不允许使用Tab键，只允许使用空格。
3.缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
4.大小写敏感

②.yml支持的三种数据结构

对象：键值对的集合
数组：一组按次序排列的值
字面量：单个的、不可再分的值（数字，字符串，布尔）
文档：多个文档用 - - - 隔开

③.例子
字面量

对象

数组

④.yml配置文件值获取

@ConfigurationProperties(prefix = “person”）：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；prefix = “person”：配置文件中哪个下面的所有属性进行一一映射
@Component ：将组件加入容器中，只有这样才可以用@ConfigurationProperties

对实体属性的设置，通过@ConfigurationProperties和@Component 进行配置文件和实体的关联。即属性注入。

⑤.为了编写有提示，可以在pom.xml中配置

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

⑥.properties配置文件编写

防止properties输出乱码

2.@Value与@ConfigurationProperties区别

二者都是对属性注入值的注解

不管是yml还是properties文件都可以获取值。
(1)具体使用

(2)用法
如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value
如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConﬁgurationProperties

3.@PropertySource、@ImportResource、@Bean、@Validated

 @PropertySource：加载指定的properties配置文件,非默认的配置文件
 @ImportResource：加载springboot不包含的外部的配置文件，比如.xml
 @Bean：：产生一个bean对象，交给spring管理，将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名  

1.#####################################
/**
 *  @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；
 *  @PropertySource(value = {"classpath:person.properties"})从配置文件中获取值
 */
@PropertySource(value = {"classpath:person.properties"})
@Component
//@ConfigurationProperties(prefix = "person")

public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;
  
2.#######################################
在主入口类上加，就可以将配置文件里的内容注入到容器中
@ImportResource(locations = {"classpath:beans.xml"})
xml
<bean id="helloService" class="com.atguigu.springboot.service.HelloService"></bean>

SpringBoot推荐使用全注解的方式，结合@Bean和@Configuration的配置类，来实现配置的属性注入和值的获取

 // @Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件
 //在配置文件中用<bean><bean/>标签添加组件

@Configuration
public class MyAppConfig {

//将方法的返回值添加到容器中；容器中这个组件默认的id就是方法名
@Bean
public HelloService helloService(){
    System.out.println("配置类@Bean给容器中添加组件了...");
    return new HelloService();
}

}

有了这个配置类，在启动程序后，配置的组件就会自动加入到容器中。

4.SpringBoot占位符的使用

5.SpringBoot Profiles

通过不同的配置文件来进行不同阶段的执行、测试等等。
1.多个profile文件
我们在编写主配置文件的时候，文件名可以是application-{profile}.properties/yml
比如：application-dev.properties
默认使用的是application.properties的配置
2.yml支持多文档块方式

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

3.激活指定proﬁle

(1)在配置文件application.properties中指定 spring.proﬁles.active=dev
(2)命令行：
java -jar spring-boot-02-conﬁg-0.0.1-SNAPSHOT.jar –spring.proﬁles.active=dev；
可以直接在测试的时候，配置传入命令行参数
(3)虚拟机参数；
-Dspring.proﬁles.active=dev

6.配置文件的加载位置

7.外部配置文件的加载顺序

8.SpringBoot自动配置

1.可配置的属性参考
参考[https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#common-application-properties]
2.自动配制原理

xxxxAutoConﬁgurartion：自动配置类
给容器中添加组件
xxxxProperties:封装配置文件中相关属性

在不配置的时候会启用默认配置，配置时会通过自动配置注解扫描到配置，通过反射来获取并执行配置
3.细节

我们可以在配置文件中配置debug=true来看控制台启用了那些自动配置组件。

三、Spring Boot与日志

Spring Boot选用SLF4和logback作为日志框架来收集日志信息

1.SLF4

https://www.slf4j.org
在开发的时候，日志记录方法不应该直接调用日志的实现类，而是调用日志抽象层里面的方法。给系统里面导入slf4j的jar和 logback的实现jar

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory;  

 public class HelloWorld {   
 public static void main(String[] args) {     
 Logger logger = LoggerFactory.getLogger(HelloWorld.class);     
 logger.info("Hello World");  
  }

 }

每一个日志的实现框架都有自己的配置文件。使用slf4j以后，配置文件还是做成日志实现框架自己本身的配置文件；

2.如何统一不同框架中的日志框架到slf4j

1、将系统中其他日志框架先排除出去
2、用中间包来替换原有的日志框架
3、导入slf4j其他的实现所需jar

3.SpringBoot日志关系

首先都依赖于

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

SpringBoot使用它，来做日志

<dependency>      
    <groupId>org.springframework.boot</groupId>              
    <artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

其底层依赖关系

可以看出

1.SpringBoot底层使用slf4j+logback来进行日志处理
2.SpringBoot把其他的日志替换成了slf4j
3.中间替换包：包名和原框架一样，但内容变了

注意：在引入其他框架时要去掉原有的日志配置将其替换成slf4j，SpringBoot中就取代了Spring原有的日志

4.SpringBoot日志使用

1.默认配置

2.在配置文件中修改默认配置

3.日志输出格式

5.自定义配置日志文件

给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了

logback.xml：直接就被日志框架识别了；
logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，此时就可以使用SpringBoot 的高级Proﬁle功能，比如

6.日志框架切换

去掉原有的日志配置，在pom.xml中增加新配置。

四、Spring Boot与web开发

1.需要

(1)创建项目，导入开发所需的模块，比如web,MySQL等等
(2)熟悉自动配置原理，完成一些简单的配置
包括修改、扩展原有配置。
spring-boot-autoconfigure-1.5.20.RELEASE.jar下找
XxxxAutoConfiguration
XxxxProperties
(3)编写业务逻辑

2.SpringBoot静态资源映射规则

(1)引入依赖的方式
所有 /webjars/ ，都去 classpath:/META-INF/resources/webjars/ 找资源 webjars：以jar包的方式引入静态资源**
https://www.webjars.org/

<dependency>
<groupId>org.webjars</groupId>
<artifactId>jquery</artifactId>
<version>3.3.1-2</version>
</dependency>

之后就可以通过路径：localhost:8080/webjars/jquery/3.3.1-2/jquery.js 来访问

(2)项目目录下创建静态资源文件夹的方式

如果localhost:8080/zx.jsp 在上面的那种方式找不到就去静态资源文件夹里面找zx.jsp

(3)关于欢迎页面
欢迎页面，会找静态资源文件夹下的所有index.html页面；被”/“映射；
当然也可以自己设置 localhost:8080/ 找index页面**

(4)页面图标
所有的 **/favicon.ico 都是在静态资源文件下找，会自动找，只要放进去。

3.SpringBoot模板引擎

1.模板引擎原理

2.SpringBoot推荐的模板引擎Thymeleaf
(1)引入Thymeleaf

<dependency>          
<groupId>org.springframework.boot</groupId>              
<artifactId>spring‐boot‐starter‐thymeleaf</artifactId>                         
</dependency>        
  切换thymeleaf版本 
  <properties> 
  <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>        
<!‐‐ 布局功能的支持程序  thymeleaf3主程序  layout2以上版本 ‐‐>          
<!‐‐ thymeleaf2   layout1‐‐>         
 <thymeleaf‐layout‐dialect.version>2.2.2</thymeleaf‐layout‐dialect.version>            
  </properties>

(2)Thymeleaf使用

只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染

①.导入thymeleaf名称空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

②.使用thymeleaf语法

放在标签中使用

③.语法规则
th:text；改变当前元素里面的文本内容；
th：覆盖任意html属性；来替换标签的原生属性的值

④.表达式

⑤.例子

==小结：thymeleaf就是通过在标签中嵌入自己的标签来覆盖原有的标签，从而在html页面获取值的方法==

4.SpringBoot中SpringMVC自动配置

https://docs.spring.io/spring-boot/docs/1.5.10.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications

5.自定义SpringMVC配置

我们这里的自定义既可以是对原有自动配置的扩展，也可以使原有的自动配置失效。
(1)扩展

(2)失效—-全面接管SpringBoot中SpringMVC的配置
需要在配置类上添加注解@EnableWebMvc，当类上有这个注解后，由于SpringMVC自动配置类会有检测，当检测到了@EnableWebMvc后就不会自动配置

原理：

6.如何修改SpringBoot默认配置

7.SpringBoot—-CRUD

0.创建SpringBoot项目，配置pom以及静态页面的引入，导入实体以及dao
在页面中用模板

1.首页跳转
在config下编写配置类MyMvcConfig

@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {
//所有的WebMvcConfigurerAdapter组件都会一起起作用
@Bean //将组件注册在容器
public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
    WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
        @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/").setViewName("login");
            registry.addViewController("/index.html").setViewName("login");
            registry.addViewController("/main.html").setViewName("dashboard");
        }
    };
    return adapter;
}
}

2.国际化
1.首先编写国际化配置文件/resources/i18n/

2.在login.html中使用模板配置国际化

3.编写国际化配置类
在component文件加下写一个获取Local的类

/**
 * 可以在连接上携带区域信息,配置国际化，获取页面的Locale信息
 */
public class MyLocaleResolver implements LocaleResolver {
    
    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        String l = request.getParameter("l");
        Locale locale = Locale.getDefault();
        if(!StringUtils.isEmpty(l)){
            String[] split = l.split("_");
            locale = new Locale(split[0],split[1]);
        }
        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {

    }
}

4.将配置类注入到容器中
在SpringMvc的配置类(MyMvcConfig)注入

@Bean
 public LocaleResolver localeResolver(){

     return new MyLocaleResolver();
 }

5.编写login.html
通过模板配置获取的属性

6.编写配置文件application.properties

7.原理
通过SpringBoot自动配置中有对国际化进行的配置，我们来通过编写配置类和配置文件来覆盖原有的配置。

3.登陆和拦截器
1.实时编写程序的技巧
在application.properties中配置禁用缓存

1	spring.thymeleaf.cache=false

Ctrl + F9重新编译

2.在登陆的时候获取登陆信息进行数据的校验以及错误提示
编写登陆的Controller类,其中session为了获取信息，在拦截器中进行页面重定向的

@Controller
public class LoginController {

//    @DeleteMapping
//    @PutMapping
//    @GetMapping

    //@RequestMapping(value = "/user/login",method = RequestMethod.POST)
    @PostMapping(value = "/user/login")
    public String login(@RequestParam("username") String username,
                        @RequestParam("password") String password,
                        Map<String,Object> map, HttpSession session){
        if(!StringUtils.isEmpty(username) && "123456".equals(password)){
            //登陆成功，防止表单重复提交，可以重定向到主页
            session.setAttribute("loginUser",username);
            return "redirect:/main.html";
        }else{
            //登陆失败

            map.put("msg","用户名密码错误");
            return  "login";
        }

    }
}

在页面配置从map中获取的错误信息

1	<p style="color: red" th:text="${msg}" th:if="${not #strings.isEmpty(msg)}"></p>

编写拦截器

/**
 * 登陆检查，
 */
public class LoginHandlerInterceptor implements HandlerInterceptor {
    //目标方法执行之前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object user = request.getSession().getAttribute("loginUser");//从session中获取信息
        if(user == null){
            //未登陆，返回登陆页面
            request.setAttribute("msg","没有权限请先登陆");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{
            //已登陆，放行请求
            return true;
        }

    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

注册拦截器，在MyMvcConfig中

@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {



    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        // super.addViewControllers(registry);
        //浏览器发送 /atguigu 请求来到 success
        registry.addViewController("/atguigu").setViewName("success");
    }

    //所有的WebMvcConfigurerAdapter组件都会一起起作用
    @Bean //将组件注册在容器
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
                registry.addViewController("/main.html").setViewName("dashboard");
            }

            //注册拦截器
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                //super.addInterceptors(registry);
                //静态资源；  *.css , *.js
                //SpringBoot已经做好了静态资源映射,所以不需要拦截
//                registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
//                        .excludePathPatterns("/index.html","/","/user/login");
            }
        };
        return adapter;
    }

    @Bean
    public LocaleResolver localeResolver(){

        return new MyLocaleResolver();
    }

}

配置动作

==注意：从国际化配置文件中获取值#{属性名 }，从一般属性获取值${属性名 }==
==从域对象中获取值${ 域对象.属性名}==

4.Restful风格
何谓Restful，就是以简洁的uri的形式访问页面。
URI: /资源名称/资源标识符使用HTTP请求方式来区分对资源的CRUD操作

请求架构

5.员工列表查询
1.修改页面的跳转链接为Restful风格

2.创建Controller类来进行跳转

@Controller
public class EmployeeController {
    @Autowired
    EmployeeDao employeeDao;

    @Autowired
    DepartmentDao departmentDao;

    //查询所有员工返回列表页面
    @GetMapping("/emps")
    public String  list(Model model){
        Collection<Employee> employees = employeeDao.getAll();

        //放在请求域中
        model.addAttribute("emps",employees);
        // thymeleaf默认就会拼串
        // classpath:/templates/xxxx.html
        return "emp/list";
    }
}

3.修改页面公共部分的bar
如何修改

进行修改，找到公共的部分

修改其他页公共的部分，去掉原有的添加

使用第二种方式来截取公共片段

4.抽取公共的bar到commons/bar.html
在需要引入的页面，按如下配置

1 2	<div th:replace="commons/bar::topbar"></div> <div th:replace="commons/bar::#sidebar"></div>

5.侧边栏选中的高亮设置

再举个例子，根据跳转的页面设置

6.list页面员工查询列表编写

7.员工添加编写
1.添加跳转到添加页面的链接

2.编写Controller中的方法

//来到员工添加页面
@GetMapping("/emp")
public String toAddPage(Model model){
    //来到添加页面,查出所有的部门，在页面显示
    Collection<Department> departments = departmentDao.getDepartments();
    model.addAttribute("depts",departments);
    return "emp/add";
}
//员工添加
//SpringMVC自动将请求参数和入参对象的属性进行一一绑定；要求请求参数的名字和javaBean入参的对象里面的属性名是一样的
@PostMapping("/emp")
public String addEmp(Employee employee){
    //来到员工列表页面

    System.out.println("保存的员工信息："+employee);
    //保存员工
    employeeDao.save(employee);
    // redirect: 表示重定向到一个地址  /代表当前项目路径
    // forward: 表示转发到一个地址
    return "redirect:/emps";
}

3.编写add页面

8.员工修改
1.页面的跳转链接

<a class="btn btn-sm btn-primary" th:href="@{/emp/}+${emp.id}">编辑</a>

2.controller代码

//来到修改页面，查出当前员工，在页面回显
  @GetMapping("/emp/{id}")
  public String toEditPage(@PathVariable("id") Integer id,Model model){
      Employee employee = employeeDao.get(id);
      model.addAttribute("emp",employee);

      //页面要显示所有的部门列表
      Collection<Department> departments = departmentDao.getDepartments();
      model.addAttribute("depts",departments);
      //回到修改页面(add是一个修改添加二合一的页面);
      return "emp/add";
  }

  //员工修改；需要提交员工id；
  @PutMapping("/emp")
  public String updateEmployee(Employee employee){
      System.out.println("修改的员工数据："+employee);
      employeeDao.save(employee);
      return "redirect:/emps";
  }

3.页面

通过Controller传的emp值是否为空来区分是添加还是修改

9.删除员工
1.添加删除的链接

<button th:attr="del_uri=@{/emp/}+${emp.id}" class="btn btn-sm btn-danger deleteBtn">删除</button>

<form id="deleteEmpForm"  method="post">
<input type="hidden" name="_method" value="delete"/>
</form>

<script>
         $(".deleteBtn").click(function(){
         //删除当前员工的
         $("#deleteEmpForm").attr("action",$(this).attr("del_uri")).submit();
         return false;
            });
</script>

2.Controller类

//员工删除
  @DeleteMapping("/emp/{id}")
  public String deleteEmployee(@PathVariable("id") Integer id){
      employeeDao.delete(id);
      return "redirect:/emps";
  }

==小结：SpringBoot有自动配置功能，使得我们可以修改少量配置就可完成程序搭建。只需要编写自己的业务逻辑代码。==
==1.自动扫包：只要是在主程序入口的同级包或子包就可以自动扫描，不用配置文件进行配置==
==2.thymeleaf模板需要在页面引入头，以th:的方式在标签中使用，或[[]] [( )]方式在标签外使用，功能很强大==
==3.在进行web项目开发的时候，当我们要修改默认的自动配置，就可以创建自己的自动配置类@Configuration，他会与原有的自动配置配合使用，也就是对配置的增强。比如这里的首页设置，国际化，过滤器。核心是@Bean注入到IOC容器中我们才可以使用。==
==4.Controller中的所有路劲都是由thymeleaf控制解析的，所以只需要写名称，路径和后缀都会自动加上。==
==5.SpringBoot就是快速的注解模式开发，所用的注解与spring有很大的相同之处，当然也有功能更强大注解，在SpringBoot中和spring原理都是一样的要想使用，都必须注入到容器中。==
==6.对于整体的web架构不变，还是不同层之间的访问，注入是关键，配置也是关键==
==7.从页面获取值只要实体和页面的属性一样，就会自动绑定值，可以直接使用。在页面使用thymeleaf语法取。在后台直接实体名取。==
==8.页面整合与截取：th:fragment截取，th:repleace/insert等替换==
==9.上面只是简单的controller控制页面跳转以及一些常用的配置细节，还未用到service层，dao层也是简单模拟==
==10.SpringBoot的访问路径：thymeleaf会自动解析到classpath:templates/….xxx.html,静态资源路径classpath:static。springBoot都有自己的配置，我们可以找到配置位置来修改属性，使用自己的配置。==

8.错误消息处理

1.SpringBoot处理错误的步骤
一旦系统出现4xx或5xx(4xx是服务器错误，5xx是客户端错误)，ErrorPageCustomizer就会生效，来定制错误的响应规则，然后来到/error请求，这个请求就会被BasicErrorController处理，看以什么方式返回错误页面。然后具体去哪个页面又是由DefaultErrorViewResolver解析得到的。
2.流程具体代码
(1)ErrorPageCustomizer

(2)BasicErrorController

(3)DefaultErrorViewResolver

3.定制错误响应

4.定制错误的json格式
有异常类，在异常类的基础上配置返回的异常信息，并通过重写类或者方法来传自定义的数据。
(1)编写运行时异常类


public class UserNotExistException extends RuntimeException {

    public UserNotExistException() {
        super("用户不存在");
    }
}

(2)自定义异常处理和返回定制的json数据

@ControllerAdvice
public class MyExceptionHandler {

    //1、浏览器客户端返回的都是json
    @ResponseBody
    @ExceptionHandler(UserNotExistException.class)
   public Map<String,Object> handleException(Exception e){
       Map<String,Object> map = new HashMap<>();
        map.put("code","user.notexist");
        map.put("message",e.getMessage());
        return map;
   }
   }

(3)转发到/error进行自适应响应效果处理，具体返回json还是html

@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(UserNotExistException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        //传入我们自己的错误状态码  4xx 5xx
        /**
         * Integer statusCode = (Integer) request
         .getAttribute("javax.servlet.error.status_code");
         */
        request.setAttribute("javax.servlet.error.status_code",500);
        map.put("code","user.notexist");
        map.put("message","用户出错啦");

        request.setAttribute("ext",map);
        //转发到/error
        return "forward:/error";
    }
}

(4)将自定义的信息带出去

出现错误以后，会来到/error请求，会被BasicErrorController处理，响应出去可以获取的数据是由 getErrorAttributes得到的（是AbstractErrorController（ErrorController）规定的方法）；
1、完全来编写一个ErrorController的实现类【或者是编写AbstractErrorController的子类】，放在容器中；

2、页面上能用的数据，或者是json返回能用的数据都是通过errorAttributes.getErrorAttributes得到；
容器中DefaultErrorAttributes.getErrorAttributes()；是默认进行数据处理的；
自定义ErrorAttributes

//给容器中加入我们自己定义的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

    //返回值的map就是页面和json能获取的所有字段
    @Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
        Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
        map.put("company","atguigu");

        //我们的异常处理器携带的数据
        Map<String,Object> ext = (Map<String, Object>) requestAttributes.getAttribute("ext", 0);
        map.put("ext",ext);
        return map;
    }
}

这些类之所以可以应用并联系起来是应为SpringBoot的自动配置。
SpringBoot之所以好用，是应为它几乎涵盖了所有功能，我们使用只是编写逻辑代码，具体的块都已经封装好了，并且为了丰富开发的灵活性，我们可以覆盖它原有的方法，要是我们编写了相应的方法，就可以只调用我们自己的方法。当然也可以两边结合。

9.配置嵌入式Servlet

1.配置和修改Servlet
(1)在application.properties中修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；

(2)在配置类中(config)只要用@Configuration注解的类，编写一个EmbeddedServletContainerCustomizer：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置

2.注册Servlet三大组件（Servlet、Filter、Listener）
由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。
所以我们可以编写代码注入这三大组件，具体做法就是先编写相应的组件类，然后在配置问价中注入。
ServletRegistrationBean、FilterRegistrationBean、ServletListenerRegistrationBean
(1)ServletRegistrationBean
Servlet类

public class MyServlet extends HttpServlet {

    //处理get请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Hello MyServlet");
    }
}

注入类

@Configuration
public class MyServerConfig {

    //注册三大组件
    @Bean
    public ServletRegistrationBean myServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
        registrationBean.setLoadOnStartup(1);
        return registrationBean;
    }

}

(2)FilterRegistrationBean
Filter类

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("MyFilter process...");
        chain.doFilter(request,response);

    }

    @Override
    public void destroy() {

    }
}

注入类

@Configuration
public class MyServerConfig {

    @Bean
    public FilterRegistrationBean myFilter(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(new MyFilter());
        registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
        return registrationBean;
    }

}

(3)ServletListenerRegistrationBean
Listener

public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized...web应用启动");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed...当前web项目销毁");
    }
}

注入类

@Configuration
public class MyServerConfig {

   
    @Bean
    public ServletListenerRegistrationBean myListener(){
        ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
        return registrationBean;
    }


}

10.其他嵌入式Serlvet容器

11.嵌入式Servlet容器的自动配置原理

(1)SpringBoot根据导入的依赖情况，给容器中添加相应的 EmbeddedServletContainerFactory【比如TomcatEmbeddedServletContainerFactory】
(2)容器中某个组件要创建对象就会启动后置处理器，EmbeddedServletContainerCustomizerBeanPostProcessor；只要是嵌入式的Servlet容器工厂，后置处理器就工作；
(3)后置处理器，从容器中获取所有的EmbeddedServletContainerCustomizer，调用定制器的定制方法。

12.嵌入式Servlet容器启动原理

1）、SpringBoot应用启动运行run方法
2）、refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】；如果是web应用创建AnnotationConﬁgEmbeddedWebApplicationContext，否则： AnnotationConﬁgApplicationContext
3）、refresh(context);刷新刚才创建好的ioc容器；
4）、 onRefresh(); web的ioc容器重写了onRefresh方法
5）、webioc容器会创建嵌入式的Servlet容器；createEmbeddedServletContainer();
6）、获取嵌入式的Servlet容器工厂：
EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();
从ioc容器中获取EmbeddedServletContainerFactory 组件；TomcatEmbeddedServletContainerFactory创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制Servlet容器的相关配置；
7）、使用容器工厂获取嵌入式的Servlet容器：this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());
8）、嵌入式的Servlet容器创建对象并启动Servlet容器；先启动嵌入式的Servlet容器，再将ioc容器中剩下没有创建出的对象获取出来；
IOC容器启动创建嵌入式的Servlet容器

13.使用外置的Servlet容器

(1)嵌入式Servlet容器：其应用是打成可执行的jar包
优点：简单，便携。
缺点：默认不支持JSP、优化定制比较复杂。

(2)外置的Servlet容器：应用是打包成war包的方式，需要引入外部的tomcat。

外置步骤：
1.创建war项目，在main下创建好web项目的目录结构：main/webapp/WEB-INF/web.xml
2.别忘了将嵌入式的Tomcat指定为provided

<dependency>    
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐tomcat</artifactId>    
<scope>provided</scope> 
</dependency>

3.还要再入口类的地方编写SpringBootServletInitializer的子类，并调用configure方法，这样应用才可以跑起来。

public class ServletInitializer extends SpringBootServletInitializer {     
 @Override    
 protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {      
   //传入SpringBoot应用的主程序      
    return application.sources(SpringBoot04WebJspApplication.class);   
     }

}

外置运行原理
0.启动tomcat
1.根据Servlet3.0标准ServletContainerInitializer扫描所有jar包中META-INF/services/javax.servlet.ServletContainerInitializer文件指定的类并加载
2.找到
org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\METAINF\services\javax.servlet.
ServletContainerInitializer：加载spring web包下的SpringServletContainerInitializer
3.扫描@HandleType(WebApplicationInitializer) ，加载感兴趣的类
4.加载SpringBootServletInitializer并运行onStartup方法
5.加载@SpringBootApplication主类，启动容器等

五、Spring Boot与Docker

1.Docker简介

Docker 是一个开源的应用容器引擎，基于 Go 语言并遵从Apache2.0协议开源。 Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。 容器是完全使用沙箱机制，相互之间不会有任何接口,更重要的是容器性能开销极低。

Docker支持将软件编译成一个镜像；然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像。运行中的这个镜像称为容器，容器启动是非常快速的。

2.Docker核心概念

docker主机(Host)：安装了Docker程序的机器（Docker直接安装在操作系统之上）
docker客户端(Client)：客户端通过命令行或者其他工具使用 Docker API
(https://docs.docker.com/reference/api/docker_remote_api) 与Docker 的守护进程通信
docker仓库(Registry)：用来保存各种打包好的软件镜像，Docker Hub(https://hub.docker.com) 提供了庞大的镜像集合供使用。
docker镜像(Images)：软件打包好的镜像；放在docker仓库中
docker容器(Container)：镜像启动后的实例称为一个容器，容器是独立运行的一个或一组应用

使用Docker的步骤：
1）、安装Docker
2）、去Docker仓库找到相应程序对应的镜像，比如mysql
3）、使用Docker运行这个镜像，这个镜像就会生成一个Docker容器
4）、对容器的启动停止就是对软件的启动停止

3.安装Docker

1.安装虚拟机
(1)安装VMWare或者VirtualBox(一路next)
(2)导入虚拟机文件centos7.ova；
(3)启动linux虚拟机，使用用户名和密码登陆
(4)设置虚拟机网络
设置为桥接模式
选好网卡，有线连接和无线连接的网卡选项不一样
然后选择接入网线
(5)重启虚拟机
(6)查看虚拟机的ip

ip addr

(7)根据ip配置客户端，用户名密码和虚拟机一样。配置好确定(前提是已经下载好了客户端)

这之后就可以使用客户端来操作虚拟机了

2.安装Docker

4.Docker使用

1.镜像使用

查看docker版本tag等：https://hub.docker.com
2.容器使用

一个镜像可以启动多个容器

https://docs.docker.com/engine/reference/commandline/docker/
3.安装mysql

六、Spring Boot与数据访问

1.简介

对于数据访问层，无论是SQL还是NOSQL，Spring Boot默认采用整合 Spring Data的方式进行统一处理，添加大量自动配置，屏蔽了很多设置。引入各种xxxTemplate，xxxRepository来简化我们对数据访问层的操作。对我们来说只需要进行简单的设置即可。

2.SpringBoot整合jdbc

1.引入依赖

<dependency> <groupId>org.springframework.boot</groupId>              
<artifactId>spring‐boot‐starter‐jdbc</artifactId>              
</dependency>          
<dependency>          
<groupId>mysql</groupId>              
<artifactId>mysql‐connector‐java</artifactId>              
<scope>runtime</scope>              
</dependency>

2.配置数据源，在配置文件中配置

spring:   
datasource:     
username: root     
password: 123456    
 url: jdbc:mysql://192.168.15.22:3306/jdbc     
 driver‐class‐name: com.mysql.jdbc.Driver

默认是用org.apache.tomcat.jdbc.pool.DataSource作为数据源；
并且数据源的相关配置都在DataSourceProperties里面，我们可以通过自动配置来找到要用的默认配置。

3.自动配置原理
org.springframework.boot.autoconﬁgure.jdbc：

SpringBoot可以自动扫描到创建表的文件，并运行，之后就可以直接使用了。

3.使用Druid数据源

1.引入依赖

<!--引入druid数据源-->
	<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.1.8</version>
	</dependency>

2.编写配置文件

spring:
  datasource:
#   数据源基本配置
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_crud
    type: com.alibaba.druid.pool.DruidDataSource
#   数据源其他配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
#   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙  
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true  
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

3.编写配置类

@Configuration
public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){
       return  new DruidDataSource();
    }

    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        Map<String,String> initParams = new HashMap<>();

        initParams.put("loginUsername","admin");
        initParams.put("loginPassword","123456");
        initParams.put("allow","");//默认就是允许所有访问
        initParams.put("deny","192.168.15.21");

        bean.setInitParameters(initParams);
        return bean;
    }


    //2、配置一个web监控的filter
    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");

        bean.setInitParameters(initParams);

        bean.setUrlPatterns(Arrays.asList("/*"));

        return  bean;
    }
}

其他不变，运行程序

4.整合Mybatis

1.添加依赖

<dependency>       
  <artifactId>mybatis‐spring‐boot‐starter</artifactId>              
  <version>1.3.1</version>              
  </dependency>

2.添加数据源（duird）
引入依赖、编写配置文件、编写配置类 见上面
3.创建数据库表
引入建表文件、编写配置文件、执行后注释掉配置文件

1
2
3

schema:
  - classpath:sql/department.sql
  - classpath:sql/employee.sql

4.编写实体
5.具体操作
(1)注解的方式：
创建mapper包添加mapper接口类，@Mapper，里面有实现的具体方法声明以及以注解方式的执行语句。
//指定这是一个操作数据库的mapper

@Mapper
public interface DepartmentMapper {

    @Select("select * from department where id=#{id}")
    public Department getDeptById(Integer id);

    @Delete("delete from department where id=#{id}")
    public int deleteDeptById(Integer id);

    @Options(useGeneratedKeys = true,keyProperty = "id")
    @Insert("insert into department(department_name) values(#{departmentName})")
    public int insertDept(Department department);

    @Update("update department set department_name=#{departmentName} where id=#{id}")
    public int updateDept(Department department);
}

编写Controller类来访问数据

@RestController
public class DeptController {

    @Autowired
    DepartmentMapper departmentMapper;

    @Autowired
    EmployeeMapper employeeMapper;


    @GetMapping("/dept/{id}")
    public Department getDepartment(@PathVariable("id") Integer id){
        return departmentMapper.getDeptById(id);
    }

    @GetMapping("/dept")
    public Department insertDept(Department department){
        departmentMapper.insertDept(department);
        return department;
    }

    @GetMapping("/emp/{id}")
    public Employee getEmp(@PathVariable("id") Integer id){
       return employeeMapper.getEmpById(id);
    }


}

自定义MyBatis的配置规则；给容器中添加一个ConﬁgurationCustomizer；(可有可无)

@org.springframework.context.annotation.Configuration
public class MyBatisConfig {

    @Bean
    public ConfigurationCustomizer configurationCustomizer(){
        return new ConfigurationCustomizer(){

            @Override
            public void customize(Configuration configuration) {
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}

使用MapperScan批量扫描所有的Mapper接口，value=”包名” 在主入口类上注解

(2)配置文件的方式：
1.创建实体
employee.class……
2.创建接口

public interface EmployeeMapper {

    public Employee getEmpById(Integer id);

    public void insertEmp(Employee employee);
}

3.创建mybatis全局的配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

4.创建接口映射配置文件

<?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.xiaohuzi.springboot.mapper.EmployeeMapper">
   <!--    public Employee getEmpById(Integer id);

    public void insertEmp(Employee employee);-->
    <select id="getEmpById" resultType="com.xiaohuzi.springboot.bean.Employee">
        SELECT * FROM employee WHERE id=#{id}
    </select>

    <insert id="insertEmp">
        INSERT INTO employee(lastName,email,gender,d_id) VALUES (#{lastName},#{email},#{gender},#{dId})
    </insert>
</mapper>

5.编写SpringBoot配置文件，加载mybatis配置文件

mybatis:
  # 指定全局配置文件位置
  config-location: classpath:mybatis/mybatis-config.xml
  # 指定sql映射文件位置
  mapper-locations: classpath:mybatis/mapper/*.xml

6.编写Controller类

@GetMapping("/dept")
 public Department insertDept(Department department){
     departmentMapper.insertDept(department);
     return department;
 }

 @GetMapping("/emp/{id}")
 public Employee getEmp(@PathVariable("id") Integer id){
    return employeeMapper.getEmpById(id);
 }

5.整合SpringData JPA

1.SpringData简介
Spring Data 项目的目的是为了简化构建基于 Spring 框架应用的数据访问技术，包括非关系数据库、 Map-Reduce 框架、云数据服务等等；另外也包含对关系数据库的访问支持。

(1)SpringData特点
SpringData为我们提供使用统一的API来对数据访问层进行操作；这主要是Spring Data Commons项目来实现的。Spring Data Commons让我们在使用关系型或者非关系型数据访问技术时都基于Spring提供的统一标准，标准包含了CRUD（创建、获取、更新、删除）、查询、排序和分页的相关操作。

(2)统一的Repository接口
Repository<T, ID extends Serializable>：统一接口 RevisionRepository<T, ID extends Serializable, N extends Number & Comparable< N>>：基于乐观锁机制
CrudRepository<T, ID extends Serializable>：基本CRUD操作
PagingAndSortingRepository<T, ID extends Serializable>：基本CRUD及分页

(3)提供数据访问模板类 xxxTemplate
如：MongoTemplate、RedisTemplate等

(4)JPA与Spring Data

2.整合JPA
0.导入jpa依赖

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

1.创建实体类并为其标上jpa注解

//使用JPA注解配置映射关系
@Entity //告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "tbl_user") //@Table来指定和哪个数据表对应;如果省略默认表名就是user；
public class User {

    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;

    @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
    private String lastName;
    @Column //省略默认列名就是属性名
    private String email;

    public Integer getId() {
        return id;
    }

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

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

2.编写一个Dao接口来操作实体类对应的数据表（Repository）,来实现相应的操作

1
2
3

//继承JpaRepository来完成对数据库的操作
public interface UserRepository extends JpaRepository<User,Integer> {
}

3.在配置文件中编写一些基本的配置

spring:
  datasource:
    url: jdbc:mysql://192.168.15.22/jpa
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
  jpa:
    hibernate:
#     更新或者创建数据表结构
      ddl-auto: update
#    控制台显示SQL
    show-sql: true

4.在Controller执行操作

@RestController
public class UserController {

    @Autowired
    UserRepository userRepository;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Integer id){
        User user = userRepository.findOne(id);
        return user;
    }

    @GetMapping("/user")
    public User insertUser(User user){
        User save = userRepository.save(user);
        return save;
    }

}

七、Spring Boot启动配置原理

1.启动原理

(1)创建SpringApplication对象

具体细节

(2)运行run方法

具体细节

2.事件监听机制

八、Spring Boot自定义starter

1.编写自动配置

2.编写自定义starter

1.启动器模块

2.自动配置模块

3.编写自动配置类

//属性绑定
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "atguigu.hello")
public class HelloProperties {

    private String prefix;
    private String suffix;

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}

//具体功能
public class HelloService {

    HelloProperties helloProperties;

    public HelloProperties getHelloProperties() {
        return helloProperties;
    }

    public void setHelloProperties(HelloProperties helloProperties) {
        this.helloProperties = helloProperties;
    }

    public String sayHellAtguigu(String name){
        return helloProperties.getPrefix()+"-" +name + helloProperties.getSuffix();
    }
}

//自动配置类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnWebApplication //web应用才生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {

    @Autowired
    HelloProperties helloProperties;
    @Bean
    public HelloService helloService(){
        HelloService service = new HelloService();
        service.setHelloProperties(helloProperties);
        return service;
    }
}

4.META‐INF/spring.factories

1 2	org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.atguigu.starter.HelloServiceAutoConfiguration

5.在测试程序中引入包含自动配置的那个starter,编写Controller和application.propertion配置文件来测试

@RestController
public class HelloController {

    @Autowired
    HelloService helloService;

    @GetMapping("/hello")
    public String hello(){
        return helloService.sayHellAtguigu("haha");
    }
}

application.properties

atguigu.hello.prefix=ATGUIGU
atguigu.hello.suffix=HELLO WORLD

都和上面的类对应
其他整合：https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples

一、Spring Boot入门

1.简介

2.Spring Boot优点

3.微服务

4.Spring Boot HelloWorld

5.SpringBoot依赖详解

6.Spring Boot主程序类，主入口类

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

二、Spring Boot配置

1.配置文件

2.@Value与@ConfigurationProperties区别

3.@PropertySource、@ImportResource、@Bean、@Validated

4.SpringBoot占位符的使用

5.SpringBoot Profiles

6.配置文件的加载位置

7.外部配置文件的加载顺序

8.SpringBoot自动配置

三、Spring Boot与日志

1.SLF4

2.如何统一不同框架中的日志框架到slf4j

3.SpringBoot日志关系

4.SpringBoot日志使用

5.自定义配置日志文件

6.日志框架切换

四、Spring Boot与web开发

1.需要

2.SpringBoot静态资源映射规则

3.SpringBoot模板引擎

4.SpringBoot中SpringMVC自动配置

5.自定义SpringMVC配置

6.如何修改SpringBoot默认配置

7.SpringBoot—-CRUD

8.错误消息处理

9.配置嵌入式Servlet

10.其他嵌入式Serlvet容器

11.嵌入式Servlet容器的自动配置原理

12.嵌入式Servlet容器启动原理

13.使用外置的Servlet容器

五、Spring Boot与Docker

1.Docker简介

2.Docker核心概念

3.安装Docker

4.Docker使用

六、Spring Boot与数据访问

1.简介

2.SpringBoot整合jdbc

3.使用Druid数据源

4.整合Mybatis

5.整合SpringData JPA

七、Spring Boot启动配置原理

1.启动原理

2.事件监听机制

八、Spring Boot自定义starter

1.编写自动配置

2.编写自定义starter

九、Spring Boot与缓存

十、Spring Boot与消息

十一、Spring Boot与检索

十二、Spring Boot与任务

十三、Spring Boot与安全

十四、Spring Boot与分布式

十五、Spring Boot与开发热部署

十六、Spring Boot与监控管理