SpringBoot——整合Web开发（三）

一、配置类与XML配置

SpringBoot推荐使用Java来完成相关的配置工作。在项目中，不建议将所有的配置放在一个配置类中，可以根据不同的需求提供不同的配置类，例如专门处理SpringSecurity的配置类、提供Bean的配置类、SpringMVC相关的配置类。这些配置类上都需要添加@Configuration。@ComponentScan注解在项目入口的@SpringBootApplication注解中已经提供，因此在实际项目中只需要按需提供相关配置类即可。
SpringBoot中并不推荐使用XML配置，建议尽量使用Java配置代替XML配置，本案例都以Java为主。如果需要使用XML配置，只需在resources目录下提供配置文件，然后通过@ImportResource加载配置文件即可。

1. 创建Hello类 如下：

public class Hello {

    public String sayHello(String name) {
        return "hello" + name;
    }
}

2. 在resources目录下新建beans.xml文件配置该类：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="com.example.demo.vo.Hello" id="hello">
</bean>
</beans>

3. 然后创建Beans配置类，导入XML配置

@Configuration
@ImportResource("classpath:beans.xml")
public class Beans {
}

4. 最后在Controller中就可以直接导入Hello类使用了

@RestController
public class HelloController {

    @Autowired
    Hello hello;

    @GetMapping("/getXml")
            public String hello() {
                return hello.sayHello("XML");
            }
}

二、注册拦截器

SpringMVC中提供了AOP风格的拦截器，拥有更加精细的拦截处理能力，SpringBoot中的拦截器的注册更加方便。

1. 添加spring-boot-starter-web依赖
2. 创建拦截器实现HandlerInterceptor接口，代码如下：

package com.example.demo.config;

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

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


public class MyIntercepror1 implements HandlerInterceptor {
    public  boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyIntercepror1>>>preHandler");
        return true;
    }

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

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

拦截器中的方法将preHandle–>Controller–>postHandle–>afterCompletion的顺序执行。注意，只有preHandle方法返回true时后面的方法才会执行。当拦截器链内存存在多个拦截器时，postHandler在拦截器链内的所有拦截器返回成功时才会调用，而afterCompletion只有preHandle返回true才调用，但若拦截器链内的第一个拦截器的preHandle方法返回false，则后面的方法都不会执行。
3. 配置拦截器，定义配置类进行拦截器的配置，代码如下：

@Configuration
public class myWebWvcConfig implements WebMvcConfigurer {
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyIntercepror1())
                .addPathPatterns("/**")
                .excludePathPatterns("/getXml");
    }
}

自定义类实现WebMvcConfigurer接口，实现接口的addInterceptors方法。其中，addPathPatterns表示拦截路径，excludePathPatterns表示排除的路径。
当成功时不需要显示输出内容，不成功时显示拦截内容

三、启动系统任务

有一些特殊的任务需要在系统启动时执行，例如配置文件加载、数据库初始化等操作。如果没有springBoot，这些问题可以在Listener中解决。SpringBoot对此提供了两种解决方案CommandLineRunner和ApplicationRunner。CommandLineRunner和ApplicationRunner基本一致，差别主要体现在参数上。

• CommandLineRunner
  SpringBoot项目在启动时会遍历所有CommandLineRunner的实现类并调用其中的run方法，如果整个系统中有多个CommandLineRunner的实现类，那么可以使用@Order注解对这些实现类的调用顺序进行排序。

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplicationBuilder builder = new SpringApplicationBuilder(DemoApplication.class);
        builder.bannerMode(Banner.Mode.OFF);
        builder.run(args);
      // SpringApplication.run(DemoApplication.class, args);
    }
    @Component
    @Order(2)
    public class MyCommandLineRunner1 implements CommandLineRunner {

        @Override
        public void run(String... args) throws Exception {
            System.out.println("Runner1>>>" + Arrays.toString(args));
        }
    }

    @Component
    @Order(1)
    public class MyCommandLineRunner2 implements CommandLineRunner {

        @Override
        public void run(String... args) throws Exception {
            System.out.println("Runner2>>>" + Arrays.toString(args));
        }
    }
}

代码解释：

1. @Order(1)注解用来描述CommandLineRunner的执行顺序，数字越小越先执行。
2. run方法中是调用的核心逻辑，参数是系统启动时传入的参数，即入口类中main方法的参数（在调用SpringApplication.run方法时被传入SpringBoot项目中）
   在系统启动时，配置传入的参数，IDea配置方式如下
   
   在打开的新页面编辑Program auguments，如果有多个参数，参数之间用空格隔开。
   
   启动项目，启动日志如下：

• ApplicationRunner
  ApplicationRunner的用法和CommandLineRunner基本一致，区别主要体现在run方法的参数上。

package com.example.demo;

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.applet.AppletContext;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplicationBuilder builder = new SpringApplicationBuilder(DemoApplication.class);
        builder.bannerMode(Banner.Mode.OFF);
        builder.run(args);
        // SpringApplication.run(DemoApplication.class, args);
    }

    @Component
    @Order(2)
    public class myApplicationRunner1 implements ApplicationRunner {

        @Override
        public void run(ApplicationArguments args) throws Exception {
            List list = args.getNonOptionArgs();
            System.out.println("list222>>>" + list);
            Set<String> optionNames = args.getOptionNames();
            for (String optionName: optionNames) {
                System.out.println("2-key:" + optionName + ";value:" + args.getOptionValues(optionName));
            }
        }
    }

    @Component
    @Order(1)
    public class myApplicationRunner2 implements ApplicationRunner {

        @Override
        public void run(ApplicationArguments args) throws Exception {
            List list = args.getNonOptionArgs();
            System.out.println("list11111>>>" + list);
            Set<String> optionNames = args.getOptionNames();
            for (String optionName: optionNames) {
                System.out.println("1-key:" + optionName + ";value:" + args.getOptionValues(optionName));
            }
        }
    }
}

1. @Order(1)注解用来描述执行顺序，数字越小越先执行。
2. 不同于CommandLineRunner中run方法的String数组参数，这里run方法的参数是一个ApplicationArguments对象，如果想从ApplicationArguments对象中获取入口类中的main方法接收的参数，调用ApplicationArguments中的getNonOptionArgs方法即可。ApplicationArguments中的getOptionNames方法来获取项目中的启动命令行中参数的key。

四、整合Servlet、Filter和Listener

一般情况下，使用Spring、SpringMVC这些框架之后，基本上就告别Servlet、Filter以及Listener了，但是有时在整合一些第三方框架时，可能还是不得不使用Servlet，比如在整合某报表插件时就需要使用Servlet。SpringBoot中对于整合这些基本的Web组件也提供了很好的支持。

• Filter

package com.example.springboot05.config;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter
public class myFilter implements Filter {
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("MyFilter>>>init");
    }

    public void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException {
        System.out.println("MyFilter>>>doFilter");
        var3.doFilter(var1, var2);
    }

    public void destroy() {
    }
}

• Servlet

package com.example.springboot05.config;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebListener;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/my")
public class myServlet extends HttpServlet {


    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("namedoGet>>" + req.getParameter("name"));
        this.doPost(req, resp);
    }

    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("name>>" + req.getParameter("name"));
    }
}

• Listener

package com.example.springboot05.config;

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class myListener implements ServletRequestListener {
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("MyListener>>>> requestDDestroyed");
    }

    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("MyListener>>>requestInitialized");
    }
}

• @ServletComponentScan注解

@SpringBootApplication
@ServletComponentScan
public class Springboot05Application {

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

}

结果：

五、路径映射

如果只是完成简单的跳转，可以直接配置路径映射

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/hello").setViewName("hello");
    }
}

六、配置AOP和IOC

• IOC

1. 什么是 IoC？
   Ioc (inversion of control) 控制反转/反转控制。它是一种思想不是一种技术实现。描述的是：Java开发领域对象的创建以及管理的问题
   例如：现有类A依赖类B

• 传统的开发方式：往往是在类A中手动通过new关键字来new一个B的对象出来。
• 使用IOC思想的开发方式：不通过new关键字来创建对象，而是通过Ioc容器（Spring框架）来帮助我们实例化对象，我们需要哪个对象，直接从Ioc容器里面过去即可。
• 从以上两种开发方式的对比来看：我们“丧失了一个权力”（创建、管理对象的权力），从而也得到了一个好处（不用在考虑对象的创建、管理等一系列的事情）
• 为什么叫控制反转？
  控制：指的是对象创建（实例化、管理）的权力
  反转：控制权交给外部环境（spring框架、Ioc容器）
  

2. IoC 解决了什么问题？
   IoC思想就是两方之间不互相依赖，由第三方容器来管理相关资源，这样有什么好处呢？
   1. 对象之间的耦合度或者说依赖程度降低
   2. 资源变的容易管理；比如用spring容器提供的话很容易就可以实现一个单例。
   例如：现有一个针对User的操作，利用Service和Dao两层结构进行开发
   在没有使用 IoC 思想的情况下，Service 层想要使用 Dao 层的具体实现的话，需要通过 new 关键字在UserServiceImpl 中手动 new 出 IUserDao 的具体实现类 UserDaoImpl（不能直接 new 接口类）。
   
   很完美，这种方式也是可以实现的，但是我们想象一下如下场景：
   开发过程中突然接到一个新的需求，针对对IUserDao 接口开发出另一个具体实现类。因为 Server 层依赖了IUserDao的具体实现，所以我们需要修改UserServiceImpl中 new 的对象。如果只有一个类引用了IUserDao的具体实现，可能觉得还好，修改起来也不是很费力气，但是如果有许许多多的地方都引用了IUserDao的具体实现的话，一旦需要更换IUserDao 的实现方式，那修改起来将会非常的头疼。

使用 IoC 的思想，我们将对象的控制权（创建、管理）交有 IoC 容器去管理，我们在使用的时候直接向 IoC 容器 “要” 就可以了

3. IoC 和 DI 的区别？
   IoC（Inverse of Control:控制反转）是一种设计思想 或者说是某种模式。这个设计思想就是 将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理。 IoC 在其他语言中也有应用，并非 Spring 特有。IoC 容器是 Spring 用来实现 IoC 的载体， IoC 容器实际上就是个 Map（key，value）,Map 中存放的是各种对象。
   IoC 最常见以及最合理的实现方式叫做依赖注入（Dependency Injection，简称 DI）。
   并且，老马（Martin Fowler）在一篇文章中提到将 IoC 改名为 DI，原文如下，原文地址：https://martinfowler.com/articles/injection.html 。
   

老马的大概意思是 IoC 太普遍并且不表意，很多人会因此而迷惑，所以，使用 DI 来精确指名这个模式比较好。

• 什么是 AOP？

1. 对AOP的初印象
   首先先给出一段比较专业的术语（来自百度）：

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方
式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个
热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑
的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
了开发的效率。

然后我们举一个比较容易理解的例子（来自：Spring 之 AOP）：

要理解切面编程，就需要先理解什么是切面。用刀把一个西瓜分成两瓣，切开的切口就是切面；炒菜，锅与炉子共同来完成炒菜，锅与炉子就是切面。web层级设计中，web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面。

我们一般做活动的时候，一般对每一个接口都会做活动的有效性校验（是否开始、是否结束等等）、以及这个接口是不是需要用户登录。
按照正常的逻辑，我们可以这么做。

这有个问题就是，有多少接口，就要多少次代码copy。对于一个“懒人”，这是不可容忍的。好，提出一个公共方法，每个接口都来调用这个接口。这里有点切面的味道了。

同样有个问题，我虽然不用每次都copy代码了，但是，每个接口总得要调用这个方法吧。于是就有了切面的概念，我将方法注入到接口调用的某个地方（切点）。

这样接口只需要关心具体的业务，而不需要关注其他非该接口关注的逻辑或处理。
红框处，就是面向切面编程。

2. AOP中的相关概念
   看过了上面的例子，我想大家脑中对AOP已经有了一个大致的雏形，但是又对上面提到的切面之类的术语有一些模糊的地方，接下来就来讲解一下AOP中的相关概念，了解了AOP中的概念，才能真正的掌握AOP的精髓。
   这里还是先给出一个比较专业的概念定义：

• Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
• Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
• Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
• Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
• Target（目标对象）：织入 Advice 的目标对象.。
• Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程
  然后举一个容易理解的例子：
  看完了上面的理论部分知识, 我相信还是会有不少朋友感觉到 AOP 的概念还是很模糊, 对 AOP 中的各种概念理解的还不是很透彻. 其实这很正常, 因为 AOP 中的概念是在是太多了, 我当时也是花了老大劲才梳理清楚的.
  下面我以一个简单的例子来比喻一下 AOP 中 Aspect, Joint point, Pointcut 与 Advice之间的关系.
  让我们来假设一下, 从前有一个叫爪哇的小县城, 在一个月黑风高的晚上, 这个县城中发生了命案. 作案的凶手十分狡猾, 现场没有留下什么有价值的线索. 不过万幸的是, 刚从隔壁回来的老王恰好在这时候无意中发现了凶手行凶的过程, 但是由于天色已晚, 加上凶手蒙着面, 老王并没有看清凶手的面目, 只知道凶手是个男性, 身高约七尺五寸. 爪哇县的县令根据老王的描述, 对守门的士兵下命令说: 凡是发现有身高七尺五寸的男性, 都要抓过来审问. 士兵当然不敢违背县令的命令, 只好把进出城的所有符合条件的人都抓了起来.

来让我们看一下上面的一个小故事和 AOP 到底有什么对应关系.
首先我们知道, 在 Spring AOP 中 Joint point指代的是所有方法的执行点, 而 point cut 是一个描述信息, 它修饰的是 Joint point, 通过 point cut, 我们就可以确定哪些 Joint point 可以被织入 Advice. 对应到我们在上面举的例子, 我们可以做一个简单的类比,Joint point就相当于 爪哇的小县城里的百姓,pointcut 就相当于 老王所做的指控, 即凶手是个男性, 身高约七尺五寸, 而 Advice 则是施加在符合老王所描述的嫌疑人的动作: 抓过来审问 .
为什么可以这样类比呢?

• Joint point： 爪哇的小县城里的百姓: 因为根据定义, Joint point 是所有可能被织入Advice 的候选的点, 在 Spring AOP中, 则可以认为所有方法执行点都是 Joint point. 而在我们上面的例子中, 命案发生在小县城中, 按理说在此县城中的所有人都有可能是嫌疑人.

• Pointcut````：男性, 身高约七尺五寸: 我们知道, 所有的方法(joint point) 都可以织入 Advice, 但是我们并不希望在所有方法上都织入 Advice, 而 Pointcut 的作用就是提供一组规则来匹配joinpoint, 给满足规则的 joinpoint添加Advice. 同理, 对于县令来说, 他再昏庸, 也知道不能把县城中的所有百姓都抓起来审问, 而是根据凶手是个男性, 身高约七尺五寸, 把符合条件的人抓起来. 在这里 凶手是个男性, 身高约七尺五寸 就是一个修饰谓语, 它限定了凶手的范围, 满足此修饰规则的百姓都是嫌疑人, 都需要抓起来审问.

• Advice ：抓过来审问, Advice ```是一个动作, 即一段 Java 代码, 这段 Java 代码是作用于 point cut 所限定的那些Joint point`` 上的. 同理, 对比到我们的例子中, 抓过来审问 这个动作就是对作用于那些满足 男性, 身高约七尺五寸 的爪哇的小县城里的百姓.

• Aspect：Aspect是 point cut 与Advice 的组合, 因此在这里我们就可以类比: “根据老王的线索, 凡是发现有身高七尺五寸的男性, 都要抓过来审问” 这一整个动作可以被认为是一个 Aspect.

最后是一个描述这些概念之间关系的图：

3. 其他的一些内容
   AOP中的Joinpoint可以有多种类型：构造方法调用，字段的设置和获取，方法的调用，方法的执行，异常的处理执行，类的初始化。也就是说在AOP的概念中我们可以在上面的这些Joinpoint上织入我们自定义的Advice，但是在Spring中却没有实现上面所有的joinpoint，确切的说，Spring只支持方法执行类型的Joinpoint。

Advice 的类型

• before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)

• after return advice, 在一个 join point 正常返回后执行的 advice

• after throwing advice, 当一个 join point 抛出异常后执行的 advice

• after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice.

• around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice.

• introduction，introduction可以为原有的对象增加新的属性和方法。
  在Spring中，通过动态代理和动态字节码技术实现了AOP，这些内容，我们将在以后进行讲解。

七、其他

• 自定义欢迎页
  SpringBoot项目启动后，首先会去静态资源路径下查找index.html作为首页文件，若查找不到，则会去查找动态的index文件作为首页文件。
  例如：如果想使用静态的index.html页面作为项目首页，那么只需在resources/static目录下创建index.html文件即可。若想使用动态页面作为项目首页，则需在resources/template目录下创建index.html(Thymeleaf模板)或者index.ftl(Freemarker模板),然后在Controller中返回逻辑视图名。

• 自定义favicon
  favicon.ico是浏览器左上角的图标，可以放在静态资源路径下或者类路径下，静态资源路径下的favicon.ico优先级高于类路径下的favicon.ico。
  可以使用在线转换网站https://jinaconvert.com/cn/convert-to-ico.php 或者https://www.bitbug.net/,然后进行替换。最后复制到resources/static目录下。
  

• 除去某个自动配置
  Springboot中提供了大量的自动化配置类，例如ErroMvcAutoConfiguration、ThymeleafAutoConfiguration、FreeMarkerAutoConfiguration、MultipartAutoConfiguration等，这些自动化配置可以减少相应的操作的配置达到开箱即用的效果。在SpringBoot中的入口类有一个@SpringBootApplication注解。该注解是一个组合注解，由@SpringBootConfiguration、@EnableAutoConfiguration以及@ComponentScan组成，其中@EnableAuotConfiguration注解开启自动化配置，相关的自动化配置类就会使用。如果开发者不想使用某个自动化配置，按如下方式除去相关配置即可：
  下面可能是版本的不同写法如下

@SpringBootApplication(exclude = {ErrorMvcAutoConfiguration.class})
@ServletComponentScan
public class Springboot05Application {

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

}

未配置之前：

配置后：

或者使用application.properties文件进行配置

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration