spring分析与总结（详细）

spring

​ Spring是分层的Java SE/EE应用 full-stack轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

1.spring的优势

​ 1：方便解耦，简化开发 （工厂模式）
​ 2：AOP编程的支持 （jdk动态代理、cglib动态代理）。
​ 3：方便程序的测试（和Junit整合）
​ 4：方便集成各种优秀框架
​ 5：降低JavaEE API的使用难度 （SSM整合）

Spring 框架中用到的设计模式

​ 工厂设计模式 : Spring使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
​ 代理设计模式 : Spring AOP 功能的实现。
​ 单例设计模式 : Spring 中的 Bean 默认都是单例的。
​ 模板方法模式 : Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。
​ 包装器设计模式 : 我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源。
​ 观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
​ 适配器模式 :Spring AOP 的增强或通知(Advice)使用到了适配器模式、spring MVC 中也是用到了适配器模式适配Controller。
​ 装饰者模式:在不改变原代码的基础上增加一些新的功能

1.工厂设计模式

​ Spring使用工厂模式可以通过 BeanFactory 或 ApplicationContext 创建 bean 对象。

​ 两者对比：
​ BeanFactory ：延迟注入(使用到某个 bean 的时候才会注入),相比于BeanFactory 来说会占用更少的内存，程序启动速度更快。
​ ApplicationContext ：容器启动的时候，不管你用没用到，一次性创建所有 bean 。BeanFactory 仅提供了最基本的依赖注入支持，ApplicationContext 扩展了 BeanFactory ,除了有BeanFactory的功能还有额外更多功能，所以一般开发人员使用ApplicationContext会更多。

​ ApplicationContext的三个实现类：
​ ClassPathXmlApplication：把上下文文件当成类路径资源。
​ FileSystemXmlApplication：从文件系统中的 XML 文件载入上下文定义信息。
​ XmlWebApplicationContext：从Web系统中的XML文件载入上下文定义信息。

2.单例设计模式

​ 在我们的系统中，有一些对象其实我们只需要一个，比如说：线程池、缓存、对话框、注册表、日志对象、充当打印机、显卡等设备驱动程序的对象。事实上，这一类对象只能有一个实例，如果制造出多个实例就可能会导致一些问题的产生，比如：程序的行为异常、资源使用过量、或者不一致性的结果。

​ 使用单例模式的好处:
​ 对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。Spring 中 bean 的默认作用域就是 singleton(单例)的。

​ Spring 实现单例的方式：
​ xml :
​ 注解：@Scope(value = “singleton”)

3.代理设计模式

​ 代理模式在 AOP 中的应用
​ AOP(Aspect-Oriented Programming:面向切面编程)能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。
​ Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候Spring AOP会使用Cglib ，这时候Spring AOP会使用 Cglib 生成一个被代理对象的子类来作为代理，如下图所示：

4.模板方法

​ 模板方法模式是一种行为设计模式，它定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。 模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤的实现方式。

public abstract class Template {
    //这是我们的模板方法
    public final void TemplateMethod(){
        PrimitiveOperation1();  
        PrimitiveOperation2();
        PrimitiveOperation3();
    }

    protected void  PrimitiveOperation1(){
        //当前类实现
    }
    
    //被子类实现的方法
    protected abstract void PrimitiveOperation2();
    protected abstract void PrimitiveOperation3();

}
public class TemplateImpl extends Template {

    @Override
    public void PrimitiveOperation2() {
        //当前类实现
    }
    
    @Override
    public void PrimitiveOperation3() {
        //当前类实现
    }
}

​ Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。一般情况下，我们都是使用继承的方式来实现模板模式，但是 Spring 并没有使用这种方式，而是使用Callback(回调) 模式与模板方法模式配合，既达到了代码复用的效果，同时增加了灵活性。

5.观测者模式

​ 观察者模式是一种对象行为型模式。它表示的是一种对象与对象之间具有依赖关系，当一个对象发生改变的时候，这个对象所依赖的对象也会做出反应。Spring 事件驱动模型就是观察者模式很经典的一个应用。Spring 事件驱动模型非常有用，在很多场景都可以解耦我们的代码。比如我们每次添加商品的时候都需要重新更新商品索引，这个时候就可以利用观察者模式来解决这个问题。
​ Spring 事件驱动模型中的三种角色
​ 事件角色
​ ApplicationEvent (org.springframework.context包下)充当事件的角色,这是一个抽象类，它继承了java.util.EventObject并实现了 java.io.Serializable接口。
Spring 中默认存在以下事件，他们都是对 ApplicationContextEvent 的实现(继承自ApplicationContextEvent)：
​ ContextStartedEvent：ApplicationContext 启动后触发的事件;
​ ContextStoppedEvent：ApplicationContext 停止后触发的事件;
​ ContextRefreshedEvent：ApplicationContext 初始化或刷新完成后触发的事件;
​ ContextClosedEvent：ApplicationContext 关闭后触发的事件。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JLV4Esfu-1571678601155)(images/监听者.png)]
事件监听者角色
​ ApplicationListener 充当了事件监听者角色，它是一个接口，里面只定义了一个 onApplicationEvent（）方法来处理ApplicationEvent。ApplicationListener接口类源码如下，可以看出接口定义看出接口中的事件只要实现了ApplicationEvent就可以了。所以，在 Spring中我们只要实现 ApplicationListener 接口实现 onApplicationEvent() 方法即可完成监听事件

package org.springframework.context;
import java.util.EventListener;
@FunctionalInterface
public interface ApplicationListener extends EventListener {
    void onApplicationEvent(E var1);
}

事件发布者角色
​ ApplicationEventPublisher 充当了事件的发布者，它也是一个接口。

@FunctionalInterface
public interface ApplicationEventPublisher {
    default void publishEvent(ApplicationEvent event) {
        this.publishEvent((Object)event);
    }

    void publishEvent(Object var1);
}

​ ApplicationEventPublisher 接口的publishEvent（）这个方法在AbstractApplicationContext类中被实现，阅读这个方法的实现，你会发现实际上事件真正是通过ApplicationEventMulticaster来广播出去的。

​ Spring 的事件流程总结
​ 定义一个事件: 实现一个继承自 ApplicationEvent，并且写相应的构造函数；
​ 定义一个事件监听者：实现 ApplicationListener 接口，重写 onApplicationEvent() 方法；
​ 使用事件发布者发布消息: 可以通过 ApplicationEventPublisher 的 publishEvent() 方法发布消息。

// 定义一个事件,继承自ApplicationEvent并且写相应的构造函数
public class DemoEvent extends ApplicationEvent{
    private static final long serialVersionUID = 1L;

    private String message;

    public DemoEvent(Object source,String message){
        super(source);
        this.message = message;
    }

    public String getMessage() {
         return message;
          }

    
// 定义一个事件监听者,实现ApplicationListener接口，重写 onApplicationEvent() 方法；
@Component
public class DemoListener implements ApplicationListener{

    //使用onApplicationEvent接收消息
    @Override
    public void onApplicationEvent(DemoEvent event) {
        String msg = event.getMessage();
        System.out.println("接收到的信息是："+msg);
    }

}
// 发布事件，可以通过ApplicationEventPublisher  的 publishEvent() 方法发布消息。
@Component
public class DemoPublisher {

    @Autowired
    ApplicationContext applicationContext;

    public void publish(String message){
        //发布事件
        applicationContext.publishEvent(new DemoEvent(this, message));
    }
}

​ 当调用 DemoPublisher 的 publish() 方法的时候，比如 demoPublisher.publish(“你好”) ，控制台就会打印出:接收到的信息是：你好 。

5.适配器模式

​ 适配器模式(Adapter Pattern) 将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。
​ spring AOP中的适配器模式
​ 我们知道 Spring AOP 的实现是基于代理模式，但是 Spring AOP 的增强或通知(Advice)使用到了适配器模式，与之相关的接口是AdvisorAdapter 。Advice 常用的类型有：BeforeAdvice（目标方法调用前,前置通知）、AfterAdvice（目标方法调用后,后置通知）、AfterReturningAdvice(目标方法执行结束后，return之前)等等。每个类型Advice（通知）都有对应的拦截器:MethodBeforeAdviceInterceptor、AfterReturningAdviceAdapter、AfterReturningAdviceInterceptor。Spring预定义的通知要通过对应的适配器，适配成 MethodInterceptor接口(方法拦截器)类型的对象（如：MethodBeforeAdviceInterceptor 负责适配 MethodBeforeAdvice）。
​ spring MVC中的适配器模式
​ 在Spring MVC中，DispatcherServlet 根据请求信息调用 HandlerMapping，解析请求对应的 Handler。解析到对应的 Handler（也就是我们平常说的 Controller 控制器）后，开始由HandlerAdapter 适配器处理。HandlerAdapter 作为期望接口，具体的适配器实现类用于对目标类进行适配，Controller 作为需要适配的类。
​ Spring MVC 中的 Controller 种类众多，不同类型的 Controller 通过不同的方法来对请求进行处理。如果不利用适配器模式的话，DispatcherServlet 直接获取对应类型的 Controller，需要的自行来判断，像下面这段代码一样：

if(mappedHandler.getHandler() instanceof MultiActionController){  
   ((MultiActionController)mappedHandler.getHandler()).xxx  
}else if(mappedHandler.getHandler() instanceof XXX){  
​    ...  
}else if(...){  
   ...  
}  

​ 假如我们再增加一个 Controller类型就要在上面代码中再加入一行 判断语句，这种形式就使得程序难以维护，也违反了设计模式中的开闭原则 – 对扩展开放，对修改关闭。

6.装饰者模式

​ 装饰者模式可以动态地给对象添加一些额外的属性或行为。相比于使用继承，装饰者模式更加灵活。简单点儿说就是当我们需要修改原有的功能，但我们又不愿直接去修改原有的代码时，设计一个Decorator套在原有代码外面。其实在 JDK 中就有很多地方用到了装饰者模式，比如 InputStream家族，InputStream 类下有 FileInputStream (读取文件)、BufferedInputStream (增加缓存,使读取文件速度大大提升)等子类都在不修改InputStream 代码的情况下扩展了它的功能。

​ Spring 中配置 DataSource 的时候，DataSource 可能是不同的数据库和数据源。我们能否根据客户的需求在少修改原有类的代码下动态切换不同的数据源？这个时候就要用到装饰者模式。Spring 中用到的包装器模式在类名上含有 Wrapper或者 Decorator。这些类基本上都是动态地给一个对象添加一些额外的职责

控制反转(IoC)和依赖注入(DI)

​ IoC(Inversion of Control,控制翻转) 是Spring 中一个非常非常重要的概念，它不是什么技术，而是一种解耦的设计思想。它的主要目的是借助于“第三方”(Spring 中的 IOC 容器) 实现具有依赖关系的对象之间的解耦(IOC容易管理对象，你只管使用即可)，从而降低代码之间的耦合度。IOC 是一个原则，而不是一个模式
​ 控制翻转怎么理解呢? 举个例子："对象a 依赖了对象 b，当对象 a 需要使用 对象 b的时候必须自己去创建。但是当系统引入了 IOC 容器后， 当对象 a 需要使用 对象 b的时候， 我们可以指定 IOC 容器去创建一个对象b给对象 a "。 对象 a 获得依赖对象 b 的过程,由主动行为变为了被动行为，控制权翻转，这就是控制反转名字的由来。
​ DI(Dependecy Inject,依赖注入)是实现控制反转的一种设计模式，依赖注入就是将实例变量传入到一个对象中去。

Spring AOP

​ AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。
​ AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（应用场景：例如性能监视、事务管理、安全检查、缓存、日志记录等）。

1.AOP的作用

​ 权限校验
​ 日志记录
​ 性能检测
​ 缓存技术
​ 事务管理

2.AOP相关术语

​ Joinpoint(连接点): （方法）
​ 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。
​ Pointcut(切入点): （方法）
​ 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。
​ Advice(通知/增强): （方法）
​ 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。
​ 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
​ Target(目标对象):
​ 代理的目标对象。
​ Weaving(织入): （了解）
​ 是指把增强应用到目标对象来创建新的代理对象的过程。
​ spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
​ Proxy（代理）:
​ 一个类被AOP织入增强后，就产生一个结果代理类。
​ Aspect(切面): （类）
​ 是切入点和通知（引介）的结合。
​ Introduction(引介): （不了解）
​ 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field。

3.切入点表达式的写法

​ 关键字：execution(表达式)
​ 表达式：
​ 参数一：访问修饰符（非必填）
​ 参数二：返回值（必填）
​ 参数三：包名.类名（非必填）
​ 参数四：方法名（参数）（必填）
​ 参数五：异常（非必填）
访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)
​ 标准的表达式写法：
​ public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
​ 访问修饰符可以省略
​ void com.itheima.service.impl.AccountServiceImpl.saveAccount()
​ 返回值可以使用通配符（*:表示任意），表示任意返回值
​ com.itheima.service.impl.AccountServiceImpl.saveAccount()
​ 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
​ * *.*.*.*.AccountServiceImpl.saveAccount())
​ 包名可以使用…表示当前包及其子包
​ * *..AccountServiceImpl.saveAccount()
​ 类名和方法名都可以使用来实现通配
​ * *..*.*() == * *()
​ 参数列表：
​ 可以直接写数据类型：
​ 基本类型直接写名称 int
​ 引用类型写包名.类名的方式 java.lang.String
​ 可以使用通配符表示任意类型，但是必须有参数
​ 可以使用…表示有无参数均可，有参数可以是任意类型
​ 全通配写法：* *..*.*(..)
​ 实际开发中切入点表达式的通常写法：切到业务层实现类下的所有方法：* com.itheima.service..*.*(..)

Spring的事务管理机制和隔离级别

​ Spring声明式事务让我们从复杂的事务处理中得到解脱。使得我们再也无需要去处理获得连接、关闭连接、事务提交和回滚等这些操作。再也无需要我们在与事务相关的方法中处理大量的try…catch…finally代码。我们在使用Spring声明式事务时，有一个非常重要的概念就是事务属性。事务属性通常由事务的传播行为，事务的隔离级别，事务的超时值和事务只读标志组成。我们在进行事务划分时，需要进行事务定义，也就是配置事务的属性。

​ 下面分别详细讲解，事务的四种属性：
​ Spring在TransactionDefinition接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是spring事务管理的核心接口。

public interface TransactionDefinition {
int getPropagationBehavior();//返回事务的传播行为。
int getIsolationLevel();//返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。
int getTimeout();//返回事务必须在多少秒内完成。
boolean isReadOnly();//事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。
}

1. TransactionDefinition接口中定义五个隔离级别：

​ ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应；

​ ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。

​ ISOLATION_READ_COMMITTED 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。

​ ISOLATION_REPEATABLE_READ 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。

​ ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。

​ 1： Dirty reads（脏读）。也就是说，比如事务A的未提交（还依然缓存）的数据被事务B读走，如果事务A失败回滚，会导致事务B所读取的的数据是错误的。
​ 2： non-repeatable reads（数据不可重复读）。比如事务A中两处读取数据-total-的值。在第一读的时候，total是100，然后事务B就把total的数据改成 200，事务A再读一次，结果就发现，total竟然就变成200了，造成事务A数据混乱。
​ 3： phantom reads（幻象读数据），这个和non-repeatable reads相似，也是同一个事务中多次读不一致的问题。但是non-repeatable reads的不一致是因为他所要取的数据集被改变了（比如total的数据），但是phantom reads所要读的数据的不一致却不是他所要读的数据集改变，而是他的条件数据集改变。比如Select account.id where account.name=“ppgogo*”,第一次读去了6个符合条件的id，第二次读取的时候，由于事务b把一个帐号的名字由"dd"改成"ppgogo1"，结果取出来了7个数据。

2. 在TransactionDefinition接口中定义了七个事务传播行为：
Propagation.REQUIRED：如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。

​ Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行。

​ Propagation.MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。

​ Propagation.REQUIRES_NEW：重新创建一个新的事务，如果当前存在事务，延缓当前的事务。

​ Propagation.NOT_SUPPORTED：以非事务的方式运行，如果当前存在事务，暂停当前的事务。

​ Propagation.NEVER：以非事务的方式运行，如果当前存在事务，则抛出异常。

​ Propagation.NESTED：如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。所谓嵌套事务，大意就是，外围事务回滚，内嵌事务一定回滚，而内嵌事务可以单独回滚而不影响外围主事务和其他子事务。

SpringMVC

1.什么是springmvc

​ Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。

2.springmvc优势

​ 清晰的角色划分：
​ 前端控制器（DispatcherServlet）
​ 请求到处理器映射（HandlerMapping）
​ 处理器适配器（HandlerAdapter）
​ 视图解析器（ViewResolver）
​ 处理器或页面控制器（Controller）
​ 验证器（ Validator）
​ 命令对象（Command 请求参数绑定到的对象就叫命令对象）
​ 表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）
​ 分工明确而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要；
​ 无需继承API直接命令操作
​ 由于命令对象就是一个POJO，无需继承框架特定API，可以使用命令对象直接作为业务对象；
​ 与spring无缝衔接
​ 和Spring 其他框架无缝集成，是其它Web框架所不具备的；
​ 适配任意类作为处理器
​ 可适配，通过HandlerAdapter可以支持任意的类作为处理器；
​ 支持简单定制
​ 可定制性，HandlerMapping、ViewResolver等能够非常简单的定制；
​ 功能强大
​ 功能强大的数据验证、格式化、绑定机制；
​ 灵活的单元测试
​ 利用Spring提供的Mock对象能够非常简单的进行Web层单元测试；
​ 更容易的主题与国际化
​ 本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。
​ 强大的jsp标签库
​ 强大的JSP标签库，使JSP编写更容易。
​ 还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等。

3.SpringMVC运行原理

​ 1.一个请求匹配前端控制器 DispatcherServlet 的请求映射路径(在 web.xml中指定), WEB 容器将该请求转交给 DispatcherServlet 处理
​ 2.DispatcherServlet 接收到请求后, 将根据 请求信息 交给 处理器映射器 （HandlerMapping）
​ 3.HandlerMapping 根据用户的url(如/user)请求 查找匹配该url的 Handler，并返回一个执行链
​ 4.DispatcherServlet 再请求 处理器适配器(HandlerAdapter) 调用相应的 Handler (controller编写的方法)进行处理并返回 ModelAndView 给 DispatcherServlet
​ 5.DispatcherServlet 将 ModelAndView 请求 ViewReslover（视图解析器）解析，返回具体 View
​ 6.DispatcherServlet 对 View 进行渲染视图（即将模型数据填充至视图中）
​ 7.DispatcherServlet 将页面响应给用户

组件说明：
DispatcherServlet：前端控制器
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心， 由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

​ HandlerMapping：处理器映射器
​ HandlerMapping负责根据用户请求url找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式， 例如：配置文件方式，实现接口方式，注解方式等。

​ Handler：处理器
​ Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。由于Handler涉及到具体的用户业务请求，所以一般情况需要程序员根据业务需求开发Handler。

​ HandlAdapter：处理器适配器
​ 通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

​ ViewResolver：视图解析器
​ View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

4.springmvc与struts2不同

springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。
springmvc是基于方法开发(一个url对应一个方法)，请求参数传递到方法的形参，可以设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是通过类的属性，只能设计为多例。
Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数解析器是将request请求内容解析，并给方法形参赋值，将数据和视图封装成ModelAndView对象，最后又将ModelAndView中的模型数据通过reques域传输到页面。Jsp视图解析器默认使用jstl。

springmvc与struts2有什么区别?
1.springmvc入口是一个servlet前端控制器(DispatcherServlet),struts2入口是一filter过滤器(StrutsPrepareAndExecuteFilter).
2.struts2通过在action类中定义成员变量接收参数,(属性驱动和模型驱动),它只能使用多例模式管理action.
springmvc通过在coontroller方法中定义形参接收参数,springmvc可以使用单例模式管理controller.
3.springmvc是基于方法开发的,注解开发中使用requestMapping将url和方法进行 映射,如果根据url找到controller类的方法生成一个handler处理器对象(只包括一个method).
struts2是基于类开发的,每个请求过来创建一个action实例,实例对象中有若干个方法.
开发中建议使用springmvc,springmvc方法更类似service业务方法.
4.struts2采用值栈存储请求和相应的数据,通过OGNL存取数据,springmvc通过参数绑定期将request请求内容解析,并给方法形参赋值.
5.Struts2是类级别的拦截，每次请求对应实例一个新的Action，需要加载所有的属性值注入，SpringMVC实现了零配置，由于SpringMVC基于方法的拦截，有加载一次单例模式bean注入。所以，SpringMVC开发效率和性能高于Struts2。

5. SpringMVC参数绑定

​ 在springmvc中，接收页面提交的数据是通过方法形参来接收的。从客户端请求的key/value数据，经过参数绑定，将key/value数据绑定到controller方法的形参上，然后就可以在controller中使用该参数了
默认支持的类型
　springmvc中，有支持的默认类型的绑定。也就是说，直接在controller方法形参上定义默认类型的对象，就可以使用这些对象。
​ HttpServletRequest对象
​ HttpServletResponse对象
​ HttpSession对象
​ Model/ModelMap对象
​ 在参数绑定过程中，如果遇到上面类型就直接进行绑定。也就是说，我们可以在controller的方法的形参中直接定义上面这些类型的参数，springmvc会自动绑定。这里要说明一下的就是Model/ModelMap对象，Model是一个接口，ModelMap是一个接口实现 ，作用是将Model数据填充到request域，跟ModelAndView类似
简单类型的绑定
​ 简单类型的绑定中，方法形参中的参数名要和前台传进来的名一样才能完成参数的绑定，如果使用@RequestParam，不用限制request传入参数名称和controller方法的形参名称一致。通过@RequestParam中的required属性指定参数是否必须要传入，如果设置为true，没有传入参数就会报错。
pojo类型的绑定
​ 对于基本类型，要求页面中input标签的name属性值和controller的pojo形参中的属性名称一致，即可将页面中数据绑定到pojo。也就是说前台页面传进来的name要和要封装的pojo属性名一模一样，然后就可以将该pojo作为形参放到controller的方法中
​ 包装的pojo类型
​ 包装类型pojo指的是pojo中有另一个也是pojo的属性
数组类型,list类型和Map类型的绑定和基础类型类似

6.Spring和SpringMVC中的常用注解

​ @Configuration 指定当前类是一个配置类，如同取代applicationContext.xml中的配置
​ @ComponentScan 用于通过注解指定spring在创建容器时要扫描的包
​ @Bean 用于把当前方法的返回值作为bean对象存入spring的ioc容器中
​ @Import 用于导入其他的配置类
​ @PropertySource 用于指定properties文件的位置
​ @Qualifier注解 如果spring容器中出现了多个数据源类型，使用该注解指定注入的数据源。
​ @Component 在类定义之前添加@Component注解，他会被spring容器识别，并转为bean。
​ @Repository 对Dao实现类进行注解 (特殊的@Component)
​ @Service 用于对业务逻辑层进行注解， (特殊的@Component)
​ @Controller 用于控制层注解 ， (特殊的@Component)
​ @Scope 用于指定是单例还是多例(prototype：多例；singleton：单例)
​ @Transactional 开启事务
​ @RequestMapping 用于处理请求地址映射，可以作用于类和方法上
​ @RequestParam：用于获取传入参数的值
​ @PathViriable：用于定义路径参数值
​ @RequestBody 主要用来接收前端传递给后端的json字符串中的数据的(请求体中的数据的)
​ @ResponseBody：响应json数据
​ @CookieValue：用于获取请求的Cookie值
​ @PathVariable 用于绑定url中的占位符。例如：请求url中 /delete/{id}/{name}，这个{id},{name}就是url占位符

dabbo

1.什么是dabbo

​ dabbo是一个分布式服务框架，致力于提供高性能和透明化的RPC(远程过程调用协议)远程服务调用方案，是阿里巴巴SOA服务化治理方案的核心框架,说白了就是个远程服务调用的分布式框架，说白了就是个远程服务调用的分布式框架
​ 其核心部分包含:
​ 1).远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。
​ 2). 集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。
​ 3). 自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。

2.dabbo执行流程

　　
节点角色说明：
节点 角色名称
Provider 暴露服务的服务提供方
Consumer 调用远程服务的服务消费方
Registry 服务注册与发现的注册中心
Monitor 统计服务的调用次数和调用时间的监控中心
Container 服务运行容器
虚线都是异步访问，实线都是同步访问
蓝色虚线:在启动时完成的功能红色虚线(实线)都是程序运行过程中执行的功能
调用关系说明:
0：服务容器负责启动，加载，运行服务提供者。
1：服务提供者在启动时，向注册中心注册自己提供的服务。
2：服务消费者在启动时，向注册中心订阅自己所需的服务。
3：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4：服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
…(img-K8ax8EnC-1571678601160)]
　　
节点角色说明：
节点 角色名称
Provider 暴露服务的服务提供方
Consumer 调用远程服务的服务消费方
Registry 服务注册与发现的注册中心
Monitor 统计服务的调用次数和调用时间的监控中心
Container 服务运行容器
虚线都是异步访问，实线都是同步访问
蓝色虚线:在启动时完成的功能红色虚线(实线)都是程序运行过程中执行的功能
调用关系说明:
0：服务容器负责启动，加载，运行服务提供者。
1：服务提供者在启动时，向注册中心注册自己提供的服务。
2：服务消费者在启动时，向注册中心订阅自己所需的服务。
3：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
4：服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
5：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。