Spring Boot总结一

一、Spring Boot介绍

Spring Boot是为了简化Spring应用的创建、运行、调试、部署等而出现的，使用它可以做到专注于Spring应用的开发，而无需过多关注XML的配置。是一个能让你在5分钟内创建一个产品级的spring应用的开发框架。
简单来说，它提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题—习惯大于约定。

Spring Boot默认使用tomcat作为服务器，使用logback提供日志记录。
Spring Boot提供了一系列的依赖包，所以需要构建工具的支持：maven 或 gradle。

二、创建springboot应用的三种方法

1、通过start.spring.io

输入信息之后点击 Generate Project，就能把项目下载下来，之后解压导入到eclipse即可。

2、通过IDE（IDEA、STS）快速创建

安装STS插件
首先如果eclipse没有STS插件要先安装STS插件：
点击Help -> Eclipse Marketplace

搜索STS

点击Install安装
创建springboot项目
new创建项目，在spring Boot下选择Spring Starter Project

点击next，输入项目相关信息

继续点击next，找到要在pom.xml引入的相关包

finish完成创建

3、完全手动创建

新建普通Java maven工厂
新建maven project，然后点next


选择maven-archetype-quickstart,点击next，然后就是填项目信息


Group Id:是公司名，Artifact Id:项目名，package:包名。
引入maven依赖

<?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>
	<!-- Springboot父工程依赖 -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.3.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.lgy</groupId>
	<artifactId>lgyProject</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>lgyProject</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web-services</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.0.0</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

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

</project>

编写启动类

package com.lgy.test;

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

@SpringBootApplication
public class Lgypplication {

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

}

三、Springboot注解

1、@SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中
@ComponentScan让spring Boot扫描到Configuration类并把它加入到程序上下文。
@Configuration 等同于spring的XML配置文件；使用Java代码可以检查类型安全。
@EnableAutoConfiguration 自动配置。
@ComponentScan 组件扫描，可自动发现和装配一些Bean。
@Component可配合CommandLineRunner使用，在程序启动后执行一些基础任务。

补充：
bean扫描的basePackage默认为启动类所在包

2、@RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器。在返回值类型前加上@ResponseBody表示返回结果是json的格式，不会是页面。
3、@EnableAutoConfiguration：Spring Boot自动配置（auto-configuration）：尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库”。你可以将@EnableAutoConfiguration或者@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。

这个注释告诉SpringBoot“猜”你将如何想配置Spring,基于你已经添加jar依赖项。如果spring-boot-starter-web已经添加Tomcat和Spring MVC,这个注释自动将假设您正在开发一个web应用程序并添加相应的spring设置。
　　自动配置被设计用来和“Starters”一起更好的工作,但这两个概念并不直接相关。您可以自由挑选starter依赖项以外的jar包，springboot仍将尽力自动配置您的应用程序。
4、@Bean:相当于XML中的bean,放在方法的上面，而不是类，意思是产生一个bean,并交给spring管理。
5、@RequestMapping：@RequestMapping(value = {"/", “/index”})value值为“/”表示根目录，“/index”表示访问路径后面为index，方法如果直接返回字符串，框架默认会去 spring.view.prefix 目录下的 （index拼接spring.view.suffix）页面；如果返回类型为ModelAndView，则是返回页面，页面由返回的ModelAndView对象确定。

@RequestMapping(value = {"/", "/index"})
    public String index(Map<String, Object> model) {
        // 直接返回字符串，框架默认会去 spring.view.prefix 目录下的 （index拼接spring.view.suffix）页面
        // 本例为 /WEB-INF/jsp/index.jsp
        model.put("time", new Date());
        model.put("message", this.hello);
        return "index";
    }
    
    @RequestMapping("/page")
    public ModelAndView page() {
        ModelAndView model = new ModelAndView();
        model.setViewName("index");
        model.addObject("time", new Date());
        model.addObject("message", this.hello);
        return model;
    }

6、其他
@Autowired自动导入。
@PathVariable获取参数。
@JsonBackReference解决嵌套外链问题。
@RepositoryRestResourcepublic配合spring-boot-starter-data-rest使用。

四、Springboot支持jsp

1、配置application.properties

	# 页面默认前缀目录
	spring.mvc.view.prefix=/WEB-INF/jsp/
	# 响应页面默认后缀
	spring.mvc.view.suffix=.jsp

2、加入依赖

<dependency> 
<groupId>org.apache.tomcat.embed</groupId> 
<artifactId>tomcat-embed-jasper</artifactId> 
<scope>provided</scope> 
</dependency> 
<dependency>
 <groupId>javax.servlet</groupId> 
<artifactId>jstl</artifactId> 
</dependency>

3、使用方法结合@RequestMapping的用法。

五、Springboot支持freemarker

1、配置application.properties

spring.freemarker.allow-request-override=false
spring.freemarker.cache=true
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

2、加入依赖

	<!-- 引入freeMarker的依赖包. -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>	

control代码：

@RequestMapping("/freemarker")
    public String freemarker(Map<String, Object> map) {
        map.put("name", "[Angel -- 守护天使]");
        map.put("gender", 1);//gender:性别，1：男；0：女；  
        
        List<Map<String, Object>> friends = new ArrayList<Map<String, Object>>();
        Map<String, Object> friend = new HashMap<String, Object>();
        friend.put("name", "jack");
        friend.put("age", 30);
        friends.add(friend);
        friend = new HashMap<String, Object>();
        friend.put("name", "jeff");
        friend.put("age", 36);
        friends.add(friend);
        map.put("friends", friends);
        return "freemarker";
    }

freemarker.ftl

<!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>  
       <p>  
           welcome ${name}  to freemarker!  
       </p>        
        
        
       <p>性别：  
           <#if gender==0>  
              女  
           <#elseif gender==1>  
              男  
           <#else>  
              保密     
           </#if>  
        </p>  
        
        
       <h4>我的好友：</h4>  
       <#list friends as item>  
           姓名：${item.name} , 年龄${item.age}  
           <br>  
       </#list>  
        
    </body>  
</html>  

六、Springboot Servlet注册

Springboot中有两种方式可以添加 Servlet、Filter、Listener

1、代码注册通过ServletRegistrationBean、 FilterRegistrationBean 和 ServletListenerRegistrationBean 获得控制，并且要在方法前加上@Bean注解。
SpringBoot启动类上添加代码：

@Bean 
public ServletRegistrationBean servletRegistrationBean() { 
return new ServletRegistrationBean(new JackServlet(), "/xs/*");}

单请求url为xs时，就会调用JackServlet。
对应的JackServlet代码：

package com.dongnao.jack.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class JackServlet extends HttpServlet {
    
    private static final long serialVersionUID = -8685285401859800066L;
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // TODO Auto-generated method stub
        this.doPost(req, resp);
    }
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // TODO Auto-generated method stub
        System.out.println("this is jackServlet doposet method");
        PrintWriter pw = resp.getWriter();
        pw.write("hello springboot servlet register by JackServlet");
        pw.flush();
        pw.close();
    }
    
    @Override
    public void init() throws ServletException {
        // TODO Auto-generated method stub
        super.init();
    }
    
}

2、在 SpringBootApplication 上使用@ServletComponentScan 注解后，Servlet、Filter、Listener 可以直接通过 @WebServlet、@WebFilter、@WebListener 注解自动注册，无需其他代码。
SpringBoot启动类上添加注解：

//扫描工程中的Servlet、Filter、Listener
@ServletComponentScan(basePackages = {"com.dongnao.jack"})

servlet类添加@WebFilter（要加上urlPatterns访问路径）就可以访问了，相应的servlet类：

package com.dongnao.jack.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/** 
 * @Description 带 @WebServlet注解的Servlet注册需要@ServletComponentScan注解的扫描
 * @ClassName   JeffServlet 
 * @Date        2017年8月28日 下午2:17:01 
 * @Author      动脑学院-jack
 */
@WebServlet(urlPatterns = "/jeff/*")
public class JeffServlet extends HttpServlet {
    private static final long serialVersionUID = -8685285401859800067L;
    
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        // TODO Auto-generated method stub
        this.doPost(req, resp);
    }
    
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        System.out.println("this is JeffServlet doposet method");
        PrintWriter pw = resp.getWriter();
        pw.write("hello springboot servlet register by JeffServlet");
        pw.flush();
        pw.close();
    }
    
    @Override
    public void init() throws ServletException {
        // TODO Auto-generated method stub
        super.init();
    }
    
}

七、拦截器和过滤器

Springboot 拦截器

1、创建我们自己的拦截器类并实现 HandlerInterceptor 接口。其中preHandle方法返回true就是放行，false就是拦截。

package com.dongnao.jack.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class JackInterceptor implements HandlerInterceptor {
    
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {
        System.out.println(this.getClass().getName() + "<------>preHandle");
        return true;//返回true就是放行，false就是拦截
    }
    
    public void postHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        System.out.println(this.getClass().getName() + "<------>postHandle");
        
    }
    
    public void afterCompletion(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        System.out.println(this.getClass().getName()
                + "<------>afterCompletion");
        
    }
    
}

2、创建一个Java类继承WebMvcConfigurerAdapter，并重写 addInterceptors 方法，并且需要添加@Configuration注解，让启动器找能够找到。
3、实例化我们自定义的拦截器，然后将对像手动添加到拦截器链中（在addInterceptors方法中添加）。

package com.dongnao.jack.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import com.dongnao.jack.interceptor.JackInterceptor;
import com.dongnao.jack.interceptor.JeffInterceptor;

@Configuration
public class SpringInterceptorRegister extends WebMvcConfigurerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(SpringInterceptorRegister.class);
    
    /* 
     * 添加spring中的拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JackInterceptor()).addPathPatterns("/**");//添加拦截路径
        registry.addInterceptor(new JeffInterceptor())
                .addPathPatterns("/freemarker/**");
        super.addInterceptors(registry);
    }
}

过滤器

package com.dongnao.jack.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

/** 
 * @Description 自定义的Serlvlet过滤器 
 * @ClassName   JackFilter 
 * @Date        2017年8月28日 下午2:29:50 
 * @Author      动脑学院-jack
 */
@WebFilter(filterName = "jackFilter", urlPatterns = "/*")
public class JackFilter implements Filter {
    
    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO Auto-generated method stub
        
    }
    
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest)request;
        System.out.println(req.getRequestURL() + "------>doFilter");
        chain.doFilter(request, response);
    }
    
    public void destroy() {
        // TODO Auto-generated method stub
        
    }
    
}

补充：把@WebFilter换成@Configuration或者@Component表示默认过滤所有路径

拦截器和过滤器的区别

过滤器可以获取到原始的HTTP请求和响应信息，但是拿不到handler处理类和方法，也不能获取handler方法（也就是controller方法）参数，返回true就是放行，false就是拦截。
拦截器可以获取原始HTTP请求和响应的信息，也能拿到请求处理方法handler的信息，但是获取不到handler方法（也就是controller方法）参数的值，通过 chain.doFilter(request, response); 把请求传给下一个拦截器和handler方法。

八、Springboot 静态资源处理

1、Spring Boot 的默认资源映射
其中默认配置的 /映射到 /static （或/public、/resources、/META-INF/resources）
其中默认配置的 /webjars/ 映射到 classpath:/META-INF/resources/webjars/ 上面的 static、public、resources 等目录都在 classpath: 下面（如 src/main/resources/static）。

2、自定义资源映射
继承 WebMvcConfigurerAdapter 并重写方法 addResourceHandlers
registry.addResourceHandler("/image/").addResourceLocations(“file:H:/image/”);
registry.addResourceHandler(“/image1/”).addResourceLocations(“classpath:/img1/”)

package com.dongnao.jack.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import com.dongnao.jack.interceptor.JackInterceptor;
import com.dongnao.jack.interceptor.JeffInterceptor;

@Configuration
public class SpringInterceptorRegister extends WebMvcConfigurerAdapter {
    private static final Logger logger = LoggerFactory.getLogger(SpringInterceptorRegister.class);    
    /* 
     * 注册静态文件的自定义映射路径
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
		 //image/**  这个是url请求路径
        //classpath:/image/ 去这个路径下寻找静态文件
        registry.addResourceHandler("/image/**")
                .addResourceLocations("classpath:/image/");
        registry.addResourceHandler("/picture/**")
                .addResourceLocations("file:D:/picture/");
        super.addResourceHandlers(registry);
    }
}

3、通过配置文件映射
使用 spring.mvc.static-path-pattern 可以重新定义pattern，如修改为 /image/**
使用 spring.resources.static-locations 可以重新定义 pattern 所指向的路径，支持 classpath: 和 file: 注意 spring.mvc.static-path-pattern 只可以定义一个，目前不支持多个逗号分割的方式。
默认值为 spring.mvc.static-path-pattern= /image/**
默认值为 classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/
spring.resources.static-locations=classpath:/image/

九、Springboot 启动加载数据

实际应用中，我们会有在项目服务启动的时候就去加载一些数据或做一些事情这样的需求。为了解决这样的问题，spring Boot 为我们提供了一个方法，通过实现接口 CommandLineRunner或者ApplicationRunner 来实现，两个接口是一样的，没有区别。

package com.dongnao.jack.runner;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/** 
 * @Description 启动加载数据 
 * @ClassName   StartUp1 
 * @Date        2017年8月28日 下午4:01:38 
 * @Author      动脑学院-jack
 */

@Component
@Order(value = 1)//value值越小越先加载
public class StartUp1 implements CommandLineRunner {
    
    private static final Logger logger = LoggerFactory.getLogger(StartUp1.class);
    
    public void run(String... args) throws Exception {
        //        System.out.println(this.getClass().getName() + "启动加载数据" + args);
        logger.info(this.getClass().getName() + "启动加载数据" + args);
    }
}

十、Springboot JDBC

1、属性配置文件（application.properties）

spring.datasource.url=jdbc:mysql://localhost:3306/test 
spring.datasource.username=root 
spring.datasource.password=123456 
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

2、pom.xml 配置maven依赖

<!-- MYSQL --> 
<dependency> 
<groupId>mysql</groupId> 
<artifactId>mysql-connector-java</artifactId> 
</dependency> 
<!-- Spring Boot JDBC --> 
<dependency> 
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId> </dependency>

实例代码：

package com.dongnao.jack.service;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;

import com.dongnao.jack.bean.ConsultContent;
import com.dongnao.jack.bean.ConsultContract;
import com.dongnao.jack.dao.IConsultContract;

@Service
public class CommonServiceImpl implements CommonService {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    private IConsultContract iConsultContract;
    
    public List<ConsultContent> queryContent(Map map) {
        String sql = "select * from consult_content a where a.state = 0 and a.type = 1 order by a.itemindex";
        return jdbcTemplate.query(sql, new RowMapper<ConsultContent>() {
            
            public ConsultContent mapRow(ResultSet rs, int rowNum)
                    throws SQLException {
                ConsultContent cc = new ConsultContent();
                cc.setContent(rs.getString("content"));
                cc.setId(rs.getInt("id"));
                cc.setItemIndex(rs.getInt("itemIndex"));
                cc.setState(rs.getInt("state"));
                cc.setType(rs.getString("type"));
                return cc;
            }
        });
    }
    
    //    public int updateConsultContract(String psptId, int id) {
    //        return iConsultContract.
    //    }
    
    public List<ConsultContract> queryConsultContract() {
        return iConsultContract.findAll();
    }
    
}

control代码：

@RequestMapping("/queryContent")
    public @ResponseBody List<ConsultContent> queryContent() {
        logger.info("查询开始！");
        List<ConsultContent> consults = commonService.queryContent(new HashMap());
        logger.info("查询结束！");
        return consults;
    }

十一、Springboot Mybatis

1、pom.xml 配置maven依赖

<dependency> 
<groupId>org.mybatis.spring.boot</groupId
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.0.0</version> 
</dependency>

2、一定要在启动的地方加上@MapperScan(“com.dongnao.jack.dao”)
3、配置文件中加上配置

mybatis.typeAliasesPackage=com.dongnao.jack.bean
mybatis.mapperLocations=classpath:com/dongnao/jack/xml/*Mapper.xml