Spring Boot

什么是spring boot

Java的大型企业级项目开发繁多的配置、低下的开发效率、复杂的部署流程及第三方技术集成难度大。在上述的环境下，SpringBoot应运而生，
它使用“习惯优先配置”(项目中存在大量的配置，此外还内置一个习惯性的配置，让你无须手动进行配置)的原则。使用它容易创建一个独立运行
（运行jar、内嵌Servlet容器）、准生产级别的基于Spring框架的项目（不用或者只需很少的Spring配置）
SpringBoot是一个快速开发框架，快速的将一些常用的第三方依赖整合（原理：通过Maven子父工程的方式），简化XML配置，全部采用注解形
式，内置Http服务器（Jetty和Tomcat），最终以java应用程序进行执行。

　核心思想: 构建一切、定位一切、连接一切。

Spring Boot的优缺点

优点：
1.快速构建项目     
2.对主流开发框架的无配置集成 
3.项目可独立运行，无须外部依赖Servlet容器 
4.提供运行时的应用监控 
5.极大的提高了开发、部署效率  简化配置 
6.与云计算的天然集成
缺点：
1.从原来的xml配置方式转换到JAVA配置方式变化有点大，不太适应。
2.至少要了解spring，才能很容易上手。

入门案例

设置spring boot的parent

maven父项目中加入

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

导入spring boot的web支持

子项目导入依赖
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
</dependency>

编写Spring Boot应用主程序

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

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

编写控制器

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class DeptController {
    @RequestMapping("/insert")
    @ResponseBody
    public String insert(){
        System.out.println("控制器insert()......");
        return "success";
    }
    /**由于springboot默认不支持jsp，所以有404*/
    @RequestMapping("/update")
    public String update(){
        System.out.println("控制器update()......");
        return "success";
    }
}

启动应用

直接在main方法中执行

测试

打开浏览器，输入地址：
http://localhost:8080/insert
http://localhost:8080/update

SpringBoot核心原理和重点

1.基于SpringMVC无配置文件（纯Java）完全注解化+内置tomcat-embed-core实现SpringBoot框架，Main函数启动。
2. SpringBoot核心快速整合第三方框架原理:Maven继承依赖关系

springBoot框架流程

问题:  springboot没有配置文件，如何进行初始化？
在没有web.xml配置文件的情况，通过java代码操作整个SpringMVC的初始化过程，java代码最终会生成class文件,
内置Tomcat就会加载这些class文件，当所有程序加载完成后，项目就可以访问了。

流程:  先创建Tomcat容器，然后加载class文件，加载过程中如果发现有java代码编写的SpringMVC初始化，就会创建SpringMVC容器。所有程序执行完毕后，项目就可以访问了。

全局配置文件

命名:   application.yml:(注意空格)

内容:  
server:
  port: 8080

logging:
  config: classpath:logback-boot.xml

spring:
  mvc:
    view:
      prefix: /
      suffix: .jsp

加载xml 配置文件

@ImportResource({"classpath:application-Context.xml"})

日志

logback-boot.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- %m输出的信息,%p日志级别,%t线程名,%d日期,%c类的全名,%i索引【从数字0开始递增】-->
    <!-- appender是configuration的子节点，是负责写日志的组件。 -->
    <!-- ConsoleAppender：把日志输出到控制台 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d %p (%file:%line)- %m%n</pattern>
            <!-- 控制台也要使用UTF-8，不要使用GBK，否则会中文乱码 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!-- RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
    <!-- 以下的大概意思是：1.先按日期存日志，日期变了，将前一天的日志文件名重命名为XXX%日期%索引，新的日志仍然是demo.log -->
    <!-- 2.如果日期没有发生变化，但是当前日志的文件大小超过1KB时，对当前日志进行分割 重命名 -->
    <appender name="demolog"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>log/demo.log</File>
        <!-- rollingPolicy:当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名。 -->
        <!-- TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次 -->
            <!-- 文件名：log/demo.2018-12-05.0.log -->
            <fileNamePattern>log/demo.%d.%i.log</fileNamePattern>
            <!-- 每产生一个日志文件，该日志文件的保存期限为30天 -->
            <maxHistory>30</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <!-- maxFileSize:这是活动文件的大小，默认值是10MB，测试时可改成1KB看效果 -->
                <maxFileSize>1KB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <!-- pattern节点，用来设置日志的输入格式 -->
            <pattern>
                %d %p (%file:%line)- %m%n
            </pattern>
            <!-- 记录日志的编码:此处设置字符集 - -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!-- 控制台输出日志级别 -->
    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 指定项目中某个包，当有日志操作行为时的日志记录级别 -->
    <!-- com.alibaba为根包，也就是只要是发生在这个根包下面的所有日志操作行为的权限都是DEBUG -->
    <!-- 级别依次为【从高到低】：FATAL > ERROR > WARN > INFO > DEBUG > TRACE -->

    <logger name="com.alibaba.springboot.controller" level="debug">
        <appender-ref ref="demolog" />
    </logger>
</configuration>

自定义日志
Logger log= LoggerFactory.getLogger(DeptController.class);

log.info("this a first myself log");

单元测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes= {启动类.class})
public class TestApplication {
    @Autowired
public XxxService servcie;
    @Test
    public void testXxx() {
        servcie.insert();
    }
}

配置过滤器

定义过滤器：
package com.offcn.springboot.filter;
import javax.servlet.*;
import java.io.IOException;
public class SellFilter  implements Filter{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init(FilterConfig filterConfig) ");

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

    @Override
    public void destroy() {
        System.out.println("destroy()");
    }
}

配置过滤器：
@Bean
public FilterRegistrationBean filterRegistrationBean() {
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    //指定过滤器
    filterRegistrationBean.setFilter(new SellFilter());
    //过滤器名称
    filterRegistrationBean.setName("RestWebFilter1");
    //设置过滤器拦截路径
    filterRegistrationBean.addUrlPatterns("/*");
    //设置过滤器执行顺序
    filterRegistrationBean.setOrder(1);
    return filterRegistrationBean;

}

配置拦截器

定义拦截器:
package com.offcn.springboot.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class SellInterceptor extends HandlerInterceptorAdapter{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle......");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle......");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion......");
    }
}

配置拦截器：
package com.offcn.springboot.config;
import com.offcn.springboot.interceptor.SellInterceptor;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@SpringBootConfiguration
public class SellInterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SellInterceptor()).addPathPatterns("/logout");
    }
}

配置定时器

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

@SpringBootConfiguration
@EnableScheduling
public class SellSpringBootConfigBean {
    @Scheduled(cron="0/2 * * * * ?")
    public void startDo(){
        System.out.println("定时器......");
    }
}

配置servlet

定义servlet:

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class SellServlet extends HttpServlet{
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("servlet......");
        PrintWriter out = resp.getWriter();
        out.print("{name:admin}");
        out.flush();
        out.close();

    }
}

配置servlet

配置servlet方式一：

@Bean
public ServletRegistrationBean servletRegistrationBean(){
    ServletRegistrationBean servletRegistrationBean=new ServletRegistrationBean(new SellServlet(),"/updateSell");
    return servletRegistrationBean;
}

配置servlet方式二：
需要在主程序加上   @ServletComponentScan(basePackages="cc")  进行全局扫描

@WebServlet("/updateSell")
public class SellServlet extends HttpServlet{
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("servlet......");
        PrintWriter out = resp.getWriter();
        out.print("{name:admin}");
        out.flush();
        out.close();

    }