框架和中间件（Spring BootSpringSpringMVC）

Posted 2021-08-30 Zephyr丶J

框架和中间件

Spring Boot

AutoConfiguration 自动配置类，启动核心

导入的类是注解实现的关键

Spring

依赖对象的获得被反转了
例如，要获得一个Person对象，朴素的方法是取new 一个Person对象
而在控制反转，把创建对象的权利交给了别人，别人给你一个对象，直接拿来用就可以了（不是所有的对象都不用自己创建了，而是核心的，能够复用的对象由别人创建）
在编程中，有很多对象需要共用，之间有耦合、依赖关系，如果自己去维护，可能会出现问题，有可能业务发生变化的时候，会很麻烦；如果有了依赖注入，交给别人去管理，可以帮我们解决

框架的开发者，用BeanFcatory，本质上是工厂，用来生产bean的
框架的使用者，用ApplicationContext

装载bean，bean未必来源于磁盘上，jar包，也可能来源于内存，网络，数据库，动态代理创建bean
bean的获取需要有人来完成，resourceLoader加载resource，从哪里加载resource接口有不同的实现，resourceLoader从不同的渠道把所要的bean信息加载到内存中，然后把信息读到以后，封装到beanDefinition里，于是就得到了抽象的bean

可以清晰的看到这里接口里面的方法，是判断资源的类型，是对资源访问的定义，可见，它代表的是一类资源

ResourceLoader用来加载resource
用这两个接口就可以把资源加载到内存里

BeanDefinition是对所有bean的一个抽象

BeanDefinition抽象的实现AbstractBeanDefiniton

构造器，初始化bean的过程

初始化完以后，由BeanDefinitionRegistry注册到容器里，其实就是通过容器的方法，装到HashMap里
存放和删除的方法：

刚刚是bean初始化和放到容器里面
但是bean之间还有依赖关系，依赖注入是重中之重
从左到右调用

BeanFactory和FactoryBean有什么关系？在这里体现
缓存中没有，从当前工厂找，找不到，从父亲里找
mdb就是beanDefinition

FactoryBean不是简单的bean，它能修饰别的bean，能产生别的bean

例子：
首先一个普通的类AlphaObject，没有任何注解，启动的时候当然是不会放到spring容器里，

package com.nowcoder.seckill;

public class AlphaObject {

    private String info;

    public AlphaObject(String info) {
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "AlphaObject{" +
                "info='" + info + '\\'' +
                '}';
    }

}

实现了FactoryBean接口，实际要产生的对象是AlphaObject这种类型的
现在有了这个注解，实现了这个接口，spring不会把AlphaObjectFactoryBean装到容器里，而是把接口所产生的对象装到容器里，装的是第一个方法返回的对象

所以FactoryBean的作用是装载一个特殊的对象，而不是这个对象本身

但是为什么不直接在那个类上加注解，放到容器里呢。这是因为有时候那个类可能不是自己写的，不能改，所以写这样一个类，由这个类来实现装到容器里；或者AOP底层是由动态代理实现的，如果动态代理现生成一个对象，可以用这种方式来处理
FactoryBean是为了装载比较复杂的，不好创建的目标bean

package com.nowcoder.seckill;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

@Component("alphaObject")
public class AlphaObjectFactoryBean implements FactoryBean<AlphaObject> {

    @Override
    public AlphaObject getObject() throws Exception {
        System.out.println("初始化AlphaObject...");
        return new AlphaObject("alpha");
    }

    @Override
    public Class<?> getObjectType() {
        return AlphaObject.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    @Override
    public String toString() {
        return "AlphaObjectFactoryBean{}";
    }
}

测试类

package com.nowcoder.seckill;

import org.junit.jupiter.api.Test;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

@SpringBootTest
public class AlphaObjectFactoryBeanTest implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Autowired
    private AlphaObject alphaObject;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Test
    public void test1() {
        // alphaObject由AlphaObjectFactoryBean产生
        System.out.println(alphaObject);
        // 通过name取到的是目标Bean
        System.out.println(applicationContext.getBean("alphaObject"));
        // 通过&name取到的是FactoryBean本身
        System.out.println(applicationContext.getBean("&alphaObject"));
    }

}

例如，要在很多方法开始的时候记录日志，我们可以把这个分散的关注点分离出来，封装一下，不在每一个地方分散的调用了
切面就是分散的关注点

被代理的对象：就是分散的对象，有共同需求的分散的对象
连接点：被拦截对象的方法
切面：解决问题的类，在统一的类中编程，这个位置就叫做切面

无接口的bean用CGLIB动态代理

例子：

package example;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyDemo {

    public static void main(String[] args) {
        Vehicle v = new Car();
        //创建一个代理对象，传入对象的类加载器和接口，还有这个对象
        Vehicle p = (Vehicle) Proxy.newProxyInstance(
                v.getClass().getClassLoader(), v.getClass().getInterfaces(), new VehicleProxy(v));
        p.run(100);
    }

}

interface Vehicle {

    void run(int speed);

}

class Car implements Vehicle {

    @Override
    public void run(int speed) {
        System.out.println("The car is running at " + speed + " km/h.");
    }

}

class VehicleProxy implements InvocationHandler {

    private Object target;

    public VehicleProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 代理对象
        System.out.println(proxy.getClass().getName());
        // 代理方法
        System.out.println(method.getName());
        // 方法参数
        System.out.println(args == null ? null : args[0]);

        System.out.println("before ... ");
        Object obj = method.invoke(target, args);
        System.out.println("after  ...");

        return obj;
    }

}

输出：

Spring MVC

Spring最终要执行的是Controller，执行的过程中会受到拦截器的拦截Interceptor
拦截器和Controller有什么关系，Controller由谁来调用，涉及到哪些组件呢

中间的DispathcherServlet是分发请求的，所有请求进来提交给DispathcherServlet，根据请求的路径url把请求分发给不同Controller的不同方法，是SpringMVC的核心

这个过程有4步：
第一步，遍历HandlerMapping，里面封装了URL和控制器的映射关系。SpringMVC也有自动配置类，自动配置类触发带有Controller注解的扫描，扫描到以后就会存到这里map里面。请求来了，就去找和当前路径匹配的HandlerMapping，里面不止有方法，还有拦截器
然后封装成一个chain，就知道先调谁后调谁

第二步：根据信息，实例化HandlerAdapter，也就是Controller，在控制器前后，可能有拦截器拦截，在这之前，调用拦截器的preHandler方法。调用完成以后，返回ModelAndView对象，里面封装了数据和模板路径

第三步：现在知道了视图在哪里，模板在哪里，数据是什么，然后调用ViewResolver，把信息给它，装到模板里去，然后调用view返回给客户端

第四步：在finally里面，调用afterComletion()方法