手撸架构，Spring 面试63问

Posted 夏目 "

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手撸架构，Spring 面试63问相关的知识，希望对你有一定的参考价值。

技术栈传送门
JAVA 基础手撸架构，Java基础面试100问_vincent-CSDN博客
JAVA 集合手撸架构，JAVA集合面试60问_vincent-CSDN博客
JVM 虚拟机手撸架构，JVM面试30问_vincent-CSDN博客
并发编程手撸架构，并发编程面试123问_vincent-CSDN博客
Spring 手撸架构，Spring面试63问_vincent-CSDN博客
Spring cloud 手撸架构，Spring cloud面试45问_vincent-CSDN博客
SpringBoot手撸面试，Spring Boot面试41问_vincent-CSDN博客
Netty 与 RPC手撸架构，Netty 与 RPC面试48问_vincent-CSDN博客
Doubo 手撸架构，Dubbo面试49问_vincent-CSDN博客
Redis手撸架构，Redis面试41问_vincent-CSDN博客
Zookeeper手撸架构，Zookeeper面试27问_vincent-CSDN博客
mysql 手撸架构，Mysql 面试126问_vincent-CSDN博客
MyBatis手撸架构，MyBatis面试42问_vincent-CSDN博客
MongoDB 手撸架构，MongDB 面试50问_vincent-CSDN博客
Elasticsearch手撸架构，Elasticsearch 面试25问_vincent-CSDN博客
RabbitMQ 手撸架构，RabbitMQ 面试49问_vincent-CSDN博客
Kafka 手撸架构，Kafka 面试42问_vincent-CSDN博客
Docker手撸架构，Docker 面试25问_vincent-CSDN博客
nginx手撸架构，Nginx 面试40问_vincent-CSDN博客
算法常用排序算法总结（1）-- 比较排序_vincent-CSDN博客_比较排序
常用排序算法总结（2）-- 非比较排序算法_vincent-CSDN博客_非比较排序的算法有
分布式事务分布式事务解决方案(总览)_vincent-CSDN博客
HTTP太厉害了，终于有人能把TCP/IP 协议讲的明明白白了_vincent-CSDN博客_tcp和ip

Sping原理 

Spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是一个分层的JavaSE/JavaEE full-stack（一站式）轻量级开源框架，为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构，因此Java开发者可以专注于应用程序的开发。

Spring是一个全面的、企业应用开发一站式的解决方案，贯穿表现层、业务层、持久层。但是它仍然可以和其他的框架无缝整合。

Spring 特点

轻量级：组件大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1M多的JAR文件中发布，并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式，典型案例，Spring应用中的对象不依赖于Spring特定的类

控制反转：Spring通过控制反转（IOC）技术实现解耦。一个对象依赖的其他对象会通过被动的方式传递进来，而不需要对象自己创建或者查找依赖。

面向切面：支持切面（AOP）编程，并且吧应用业务逻辑和系统服务区分开。

容器：Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器。可以配置每个bean如何被创建、销毁，bean的作用范围是单例还是每次都生成一个新的实例，以及他们是如何相互关联。

框架集合：将简单的组件配置，组合成为复杂的框架；

                  应用对象被申明式组合；

                  提供许多基础功能（事务管理、持久化框架继承），提供应用逻辑开发接口

Spring 框架优缺点

优点

  1. 方便解耦，简化开发：Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护，交给Spring管理。
  2. AOP编程的支持：Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
  3. 声明式事务的支持：只需要通过配置就可以完成对事务的管理，而无需手动编程。
  4. 方便程序的测试：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
  5. 方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接支持（如：Struts、Hibernate、MyBatis等）。
  6. 降低JavaEE API的使用难度：Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低。

缺点

  1. Spring依赖反射，反射影响性能
  2. 使用门槛升高，入门Spring需要较长时间
     

Spring 框架中都用到了哪些设计模式

Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：

  •  代理模式—在 AOP 和 remoting 中被用的比较多。
  • 单例模式—在 spring 配置文件中定义的 bean 默认为单例模式。
  • 模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTempl
  • ate。
  • 前端控制器—Spring 提供了 DispatcherServlet 来对请求进行分发。
  • 视图帮助(View Helper )—Spring 提供了一系列的 JSP 标签，高效宏来辅助将分散的代码
  • 整合在视图里。
  • 依赖注入—贯穿于 BeanFactory / ApplicationContext 接口的核心理念。
  • 工厂模式—BeanFactory 用来创建对象的实例

Spring核心组件

Spring 总共大约有 20 个模块， 由 1300 多个不同的文件构成。 而这些组件被分别整合在核心容器（Core Container） 、 AOP（Aspect Oriented Programming）和设备支持（Instrmentation） 、数据访问与集成（Data Access/Integeration） 、 Web、 消息（Messaging） 、 Test等 6 个模块中。 以下是 Spring 5 的模块结构图：

spring core：提供了框架的基本组成部分，包括控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）功能。
spring beans：提供了BeanFactory，是工厂模式的一个经典实现，Spring将管理对象称为Bean。
spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。
spring jdbc：提供了一个JDBC的抽象层，消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析， 用于简化JDBC。
spring aop：提供了面向切面的编程实现，让你可以自定义拦截器、切点等。
spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。
spring test：主要为测试提供支持的，支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。

Spring 控制反转（IOC）

控制反转（IOC）概念

控制反转即IOC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。

Spring 通过一个配置文件描述 Bean 及 Bean 之间的依赖关系，利用 Java 语言的反射功能(依赖注入DI)实例化 Bean 并建立 Bean 之间的依赖关系。 Spring 的 IoC 容器在完成这些底层工作的基础上，还提供 了 Bean 实例缓存、生命周期管理、 Bean 实例代理、事件发布、资源装载等高级服务。

Spring 容器高层视图

Spring 启动时读取应用程序提供的 Bean 配置信息，并在 Spring 容器中生成一份相应的 Bean 配

置注册表，然后根据这张注册表实例化 Bean，装配好 Bean 之间的依赖关系，为上层应用提供准

备就绪的运行环境。其中 Bean 缓存池为 HashMap 实现

 IOC 容器实现

BeanFactory-框架基础设施

BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；

ApplicationContext 面向使用Spring 框架的开发者，几乎所有的应用场合我们都直接使用 ApplicationContext 而非底层的 BeanFactory。

  • BeanDefinitionRegistry 注册表：Spring 配置文件中每一个节点元素在 Spring 容器里都通过一个 BeanDefinition 对象表示，它描述了 Bean 的配置信息。而 BeanDefinitionRegistry 接口提供了向容器手工注册BeanDefinition 对象的方法。
  • BeanFactory 顶层接口：位于类结构树的顶端 ，它最主要的方法就是 getBean(String beanName)，该方法从容器中返回特定名称的 Bean，BeanFactory 的功能通过其他的接口得到不断扩展：
  • ListableBeanFactory：该接口定义了访问容器中 Bean 基本信息的若干方法，如查看 Bean 的个数、获取某一类型Bean 的配置名、查看容器中是否包括某一 Bean 等方法；
  • HierarchicalBeanFactory 父子级：父子级联 IoC 容器的接口，子容器可以通过接口方法访问父容器； 通过HierarchicalBeanFactory 接口， Spring 的 IoC 容器可以建立父子层级关联的容器体系，子容器可以访问父容器中的 Bean，但父容器不能访问子容器的 Bean。Spring 使用父子容器实现了很多功能，比如在 Spring MVC 中，展现层 Bean 位于一个子容器中，而业务层和持久层的 Bean 位于父容器中。这样，展现层 Bean 就可以引用业务层和持久层的 Bean，而业务层和持久层的 Bean 则看不到展现层的 Bean。
  • ConfigurableBeanFactory：是一个重要的接口，增强了 IoC 容器的可定制性，它定义了设置类装载器、属性编辑器、容器初始化后置处理器等方法；
  • AutowireCapableBeanFactory 自动装配：定义了将容器中的 Bean 按某种规则（如按名字匹配、按类型匹配等）进行自动装配的方法；
  • SingletonBeanRegistry 运行期间注册单例 Bean：定义了允许在运行期间向容器注册单实例 Bean 的方法；对于单实例（ singleton）的 Bean 来说，BeanFactory 会缓存 Bean 实例，所以第二次使用 getBean() 获取 Bean 时将直接从IoC 容器的缓存中获取 Bean 实例。Spring 在 DefaultSingletonBeanRegistry 类中提供了一个用于缓存单实例 Bean 的缓存器，它是一个用 HashMap 实现的缓存器，单实例的 Bean 以beanName 为键保存在这个 HashMap 中。
  • 依赖日志框架：在初始化 BeanFactory 时，必须为其提供一种日志框架，比如使用 Log4J， 即在类路径下提供 Log4J 配置文件，这样启动 Spring 容器才不会报错。

ApplicationContext 面向开发应用

ApplicationContext 由 BeanFactory 派生而来，提供了更多面向实际应用的功能。

ApplicationContext 继承了 HierarchicalBeanFactory 和 ListableBeanFactory 接口，在此基础

上，还通过多个其他的接口扩展了 BeanFactory 的功能：

  • ClassPathXmlApplicationContext：默认从类路径加载配置文件
  • FileSystemXmlApplicationContext：默认从文件系统中装载配置文件
  • ApplicationEventPublisher：让容器拥有发布应用上下文事件的功能，包括容器启动事
  • 件、关闭事件等。
  • MessageSource：为应用提供 i18n 国际化消息访问的功能；
  • ResourcePatternResolver ： 所有 ApplicationContext 实现类都实现了类似于
  • PathMatchingResourcePatternResolver： 通过带前缀的 Ant 风格的资源文件路径装载 Spring 的配置文件。
  • LifeCycle：该接口是 Spring 2.0 加入的，该接口提供了 start()和 stop()两个方法，主要用于控制异步处理过程。在具体使用时，该接口同时被 ApplicationContext 实现及具体Bean 实现， ApplicationContext 会将 start/stop 的信息传递给容器中所有实现了该接口的 Bean，以达到管理和控制 JMX、任务调度等目的。
  • ConfigurableApplicationContext ：扩展于 ApplicationContext，它新增加了两个主要的方法： refresh()和 close()，让 ApplicationContext 具有启动、刷新和关闭应用上下文的能力。在应用上下文关闭的情况下调用 refresh()即可启动应用上下文，在已经启动的状态下，调用 refresh()则清除缓存并重新装载配置信息，而调用 close()则可关闭应用上下文。

BeanFactory 和 ApplicationContext有什么区别？

BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。

依赖关系

BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系。

ApplicationContext：接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：

  • 继承MessageSource，因此支持国际化。
  • 统一的资源文件访问方式。
  • 提供在监听器中注册bean的事件。
  • 同时加载多个配置文件。
  • 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层。

加载方式

BeanFactroy：采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调getBean())，才对该Bean进行加载实例化。这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。

ApplicationContext：它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。 ApplicationContext启动后预载入所有的单实例Bean，通过预载入单实例bean ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。

相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。

创建方式

BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

注册方式

BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用，但两者之间的区别是：BeanFactory需要手动注册，而ApplicationContext则是自动注册。
 

 ApplicationContext通常的实现

  • FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
  • ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
  • WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。

Spring的依赖注入

其主要实现方式有两种：依赖注入和依赖查找。

依赖注入：相对于IoC而言，依赖注入(DI)更加准确地描述了IoC的设计理念。所谓依赖注入（Dependency Injection），即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。

依赖注入的基本原则

应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由IoC容器负责，“查找资源”的逻辑应该从应用组件的代码中抽取出来，交给IoC容器负责。容器全权负责组件的装配，它会把符合依赖关系的对象通过属性（JavaBean中的setter）或者是构造器传递给需要的对象。

依赖注入优势

依赖注入之所以更流行是因为它是一种更可取的方式：让容器全权负责依赖查询，受管组件只需要暴露JavaBean的setter方法或者带参数的构造器或者接口，使容器可以在初始化时组装对象的依赖关系。其与依赖查找方式相比，主要优势为：

  • 查找定位操作与应用代码完全无关
  • 不依赖于容器的API，可以很容易地在任何容器以外使用应用对象
  • 不需要特殊的接口，绝大多数对象可以做到完全不必依赖容器


依赖注入实现方式

依赖注入是时下最流行的IoC实现方式，依赖注入分为接口注入（Interface Injection），Setter方法注入（Setter Injection）和构造器注入（Constructor Injection）三种方式。其中接口注入由于在灵活性和易用性比较差，现在从Spring4开始已被废弃。

  • 构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖
  • Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入

构造器依赖注入和 Setter方法注入的区别

构造函数注入setter 注入
没有部分注入有部分注入
不会覆盖 setter 属性会覆盖 setter 属性
任意修改都会创建一个新实例任意修改不会创建一个新实例
适用于设置很多属性适用于设置少量属性


两种依赖方式都可以使用，构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。

WebApplication 体系架构

WebApplicationContext 是专门为 Web 应用准备的，它允许从相对于 Web 根目录的路径中装载配置文件完成初始化工作。从 WebApplicationContext 中可以获得ServletContext 的引用，整个 Web 应用上下文对象将作为属性放置到 ServletContext 中，以便 Web 应用环境可以访问 Spring 应用上下文。

 

 Spring Bean 定义

一个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。

Spring元数据配置方式

XML配置文件
基于注解的配置
基于java的配置
 

Spring Bean 作用域

Spring 3 中为 Bean 定义了 5 中作用域，分别为 singleton（单例）、prototype（原型）、request、session 和 global session，5 种作用域说明如下：

  • singleton：单例模式（多线程下不安全）。Spring IoC 容器中只会存在一个共享的 Bean 实例，无论有多少个Bean 引用它，始终指向同一对象。该模式在多线程下是不安全的。Singleton 作用域是Spring 中的缺省作用域，也可以显示的将 Bean 定义为 singleton 模式，配置为：
  • prototype:原型模式每次使用时创建。每次通过 Spring 容器获取 prototype 定义的 bean 时，容器都将创建一个新的 Bean 实例，每个 Bean 实例都有自己的属性和状态，而 singleton 全局只有一个对象。根据经验，对有状态的bean使用prototype作用域，而对无状态的bean使用singleton
  • 作用域。
  • Request：一次 request 一个实例。在一次 Http 请求中，容器会返回该 Bean 的同一实例。而对不同的 Http 请求则会产生新的 Bean，而且该 bean 仅在当前 Http Request 内有效,当前 Http 请求结束，该 bean实例也将会被销毁。
  • session：在一次 Http Session 中，容器会返回该 Bean 的同一实例。而对不同的 Session 请求则会创建新的实例，该 bean 实例仅在当前 Session 内有效。同 Http 请求相同，每一次session 请求创建新的实例，而不同的实例之间不共享属性，且实例仅在自己的 session 请求内有效，请求结束，则实例将被销毁。
  • global Session：在一个全局的 Http Session 中，容器会返回该 Bean 的同一个实例，仅在使用 portlet context 时有效。

Spring处理线程并发问题

在一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域，因为Spring对一些Bean中非线程安全状态采用ThreadLocal进行处理，解决线程安全问题。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。同步机制采用了“时间换空间”的方式，仅提供一份变量，不同的线程在访问前需要获取锁，没获得锁的线程则需要排队。而ThreadLocal采用了“空间换时间”的方式。

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

Spring Bean 生命周期

 

实例化

1. 实例化一个 Bean，也就是我们常说的 new。

IOC 依赖注入

2. 按照 Spring 上下文对实例化的 Bean 进行配置，也就是 IOC 注入。

setBeanName 实现

3. 如果这个 Bean 已经实现了 BeanNameAware 接口，会调用它实现的 setBeanName(String)

方法，此处传递的就是 Spring 配置文件中 Bean 的 id 值

BeanFactoryAware 实现

4. 如果这个 Bean 已经实现了 BeanFactoryAware 接口，会调用它实现的 setBeanFactory，

setBeanFactory(BeanFactory)传递的是 Spring 工厂自身（可以用这个方式来获取其它 Bean，

只需在 Spring 配置文件中配置一个普通的 Bean 就可以）。

ApplicationContextAware 实现

5. 如果这个 Bean 已经实现了 ApplicationContextAware 接口，会调用

setApplicationContext(ApplicationContext)方法，传入 Spring 上下文（同样这个方式也

可以实现步骤 4 的内容，但比 4 更好，因为 ApplicationContext 是 BeanFactory 的子接

口，有更多的实现方法）

postProcessBeforeInitialization 接口实现-初始化预处理

6. 如果这个 Bean 关联了 BeanPostProcessor 接口，将会调用

postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor 经常被用

作是 Bean 内容的更改，并且由于这个是在 Bean 初始化结束时调用那个的方法，也可以被应

用于内存或缓存技术。

init-method

7. 如果 Bean 在 Spring 配置文件中配置了 init-method 属性会自动调用其配置的初始化方法。

postProcessAfterInitialization

8. 如果这个 Bean 关联了 BeanPostProcessor 接口，将会调用

postProcessAfterInitialization(Object obj, String s)方法。

注：以上工作完成以后就可以应用这个 Bean 了，那这个 Bean 是一个 Singleton 的，所以一

般情况下我们调用同一个 id 的 Bean 会是在内容地址相同的实例，当然在 Spring 配置文件中

也可以配置非 Singleton。

Destroy 过期自动清理阶段

9. 当 Bean 不再需要时，会经过清理阶段，如果 Bean 实现了 DisposableBean 这个接口，会调

用那个其实现的 destroy()方法；

destroy-method 自配置清理

10. 最后，如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的

销毁方法。

bean生命周期方法

bean 标签有两个重要的属性（init-method 和 destroy-method）。用它们你可以自己定制

初始化和注销方法。它们也有相应的注解（@PostConstruct 和@PreDestroy）。

<bean id="" class="" init-method="初始化方法" destroy-method="销毁方法">

什么是Spring的内部bean？什么是Spring inner beans？

在Spring框架中，当一个bean仅被用作另一个bean的属性时，它能被声明为一个内部bean。

内部bean可以用setter注入“属性”和构造方法注入“构造参数”的方式来实现，内部bean通常是匿名的，它们的Scope一般是prototype。
 

Spring 依赖注入四种方式构造器注入

/*带参数，方便利用构造器进行注入*/

 public CatDaoImpl(String message)

 this. message = message;

 
<bean id="CatDaoImpl" class="com.CatDaoImpl">

<constructor-arg value=" message "></constructor-arg>

</bean>

setter 方法注入

 public class Id 

 private int id;

 public int getId()  return id; 

 public void setId(int id)  this.id = id; 




<bean id="id" class="com.id "> <property name="id" value="123"></property> </bean>

静态工厂注入

静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让 spring 管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，而是依然通过 spring 注入的形式获取：

public class DaoFactory  //静态工厂

 public static final FactoryDao getStaticFactoryDaoImpl()

 return new StaticFacotryDaoImpl();

 



public class SpringAction 

 private FactoryDao staticFactoryDao; //注入对象

 //注入对象的 set 方法

 public void setStaticFactoryDao(FactoryDao staticFactoryDao) 

 this.staticFactoryDao = staticFactoryDao;

 


//factory-method="getStaticFactoryDaoImpl"指定调用哪个工厂方法

 <bean name="springAction" class=" SpringAction" >

 <!--使用静态工厂的方法注入对象,对应下面的配置文件-->

 <property name="staticFactoryDao" ref="staticFactoryDao"></property>

 </bean>

 <!--此处获取对象的方式是从工厂类中获取静态方法-->

<bean name="staticFactoryDao" class="DaoFactory"

factory-method="getStaticFactoryDaoImpl"></bean>

实例工厂

实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先 new 工厂类，再调用普通的实例方法：

 public class DaoFactory  //实例工厂

 public FactoryDao getFactoryDaoImpl()

 return new FactoryDaoImpl();

13/04/2018 Page 128 of 283

 



public class SpringAction 

 private FactoryDao factoryDao; //注入对象

 public void setFactoryDao(FactoryDao factoryDao) 

 this.factoryDao = factoryDao;

 


 <bean name="springAction" class="SpringAction">

 <!--使用实例工厂的方法注入对象,对应下面的配置文件-->

 <property name="factoryDao" ref="factoryDao"></property>

 </bean>

 <!--此处获取对象的方式是从工厂类中获取实例方法-->

<bean name="daoFactory" class="com.DaoFactory"></bean>

<bean name="factoryDao" factory-bean="daoFactory"

factory-method="getFactoryDaoImpl"></bean>

5 种不同方式的自动装配

Spring 装配包括手动装配和自动装配，手动装配是有基于 xml 装配、构造方法、setter 方法等自动装配有五种自动装配的方式，可以用来指导 Spring 容器用自动装配方式来进行依赖注入。

  • no：默认的方式是不进行自动装配，通过显式设置 ref 属性来进行装配。
  • byName：通过参数名 自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byName，之后容器试图匹配、装配和该 bean 的属性具有相同名字的 bean。
  • byType：通过参数类型自动装配，Spring 容器在配置文件中发现 bean 的 autowire 属性被设置成 byType，之后容器试图匹配、装配和该 bean 的属性具有相同类型的 bean。如果有多个 bean 符合条件，则抛出错误。
  • constructor：这个方式类似于 byType， 但是要提供给构造器参数，如果没有确定的带参数的构造器参数类型，将会抛出异常。
  • autodetect：首先尝试使用 constructor 来自动装配，如果无法工作，则使用 byType 方式。

 Spring 中注入一个 Java Collection

Spring 提供了以下四种集合类的配置元素：

  • <list> : 该标签用来装配可重复的 list 值。
  •  <set> : 该标签用来装配没有重复的 set 值。
  • <map>: 该标签可用来注入键和值可以为任何类型的键值对。
  • <props> : 该标签支持注入键和值都是字符串类型的键值对。
<beans> 
 <!-- Definition for javaCollection --> 
 <bean id="javaCollection" class="com.howtodoinjava.JavaCollection"> 
 <!-- java.util.List --> 
 <property name="customList"> 
 <list> 
 <value>INDIA</value> 
 <value>Pakistan</value> 
 <value>USA</value> 
 <value>UK</value> 
 </list> 
 </property> 
 
 <!-- java.util.Set --> 
 <property name="customSet"> 
 <set> 
 <value>INDIA</value> 
 <value>Pakistan</value> 
 <value>USA</value> 
 <value>UK</value> 
 </set> 
 </property> 
 
 <!-- java.util.Map --> 
 <property name="customMap"> 
 <map> 
 <entry key="1" value="INDIA"/> 
 <entry key="2" value="Pakistan"/> 
 <entry key="3" value="USA"/> 
 <entry key="4" value="UK"/> 
 </map> 
 </property> 
 
 <!-- java.util.Properties --> 
 <property name="customProperies"> 
 <props> 
 <prop key="admin">admin@nospam.com</prop> 
 <prop key="support">support@nospam.com</prop> 
 </props> 
 </property> 
 
 </bean> 
</beans>

使用@Autowired注解自动装配的过程

在使用@Autowired注解之前需要在Spring配置文件进行配置，<context:annotation-config />。

在启动spring IoC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowied、@Resource或@Inject时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性。在使用@Autowired时，首先在容器中查询对应类型的bean：

  • 如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据；
  • 如果查询的结果不止一个，那么@Autowired会根据名称来查找；
  • 如果上述查找的结果为空，那么会抛出异常。解决方法时，使用required=false。

Spring AOP 

AOP原理

OOP(Object-Oriented Programming)面向对象编程，允许开发者定义纵向的关系，但并适用于定义横向的关系，导致了大量代码的重复，而不利于各个模块的重用。

AOP(Aspect-Oriented Programming)，一般称为面向切面编程，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。

AOP 主要应用场景有

  1. Authentication 权限
  2. Caching 缓存
  3. Context passing 内容传递
  4. Error handling 错误处理
  5. Lazy loading 懒加载
  6. Debugging 调试
  7. logging, tracing, profiling and monitoring 记录跟踪 优化 校准
  8. Performance optimization 性能优化
  9. Persistence 持久化
  10. Resource pooling 资源池
  11. Synchronization 同步
  12. Transactions 事务

 AOP 核心概念

  • 切面（aspect）：类是对物体特征的抽象，切面就是对横切关注点的抽象
  • 横切关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点
  • 连接点（joinpoint）：被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
  • 切入点（pointcut）：对连接点进行拦截的定义
  • 通知（advice）：所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类
  • 目标对象：代理的目标对象
  • 织入（weave）：将切面应用到目标对象并导致代理对象创建的过程
  1. 编译期：切面在目标类编译时被织入。AspectJ的织入编译器是以这种方式织入切面的；
  2. 类加载期：切面在目标类加载到JVM时被织入。需要特殊的类加载器，它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入就支持以这种方式织入切面；
  3. 运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面。
  • 引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法
  • 或字段

 Spring 中的代理

将 Advice 应用于目标对象后创建的对象称为代理。在客户端对象的情况下，目标对象和代理对象是相同的。

Advice + Target Object = Proxy

AOP 实现方式

AOP实现的关键在于代理模式，AOP代理主要分为静态代理和动态代理。

  • AspectJ 静态代理的增强，所谓静态代理，就是AOP框架会在编译阶段生成AOP代理类，因此也称为编译时增强，他会在编译阶段将AspectJ(切面)织入到Java字节码中，运行的时候就是增强之后的AOP对象。
  • Spring AOP使用的动态代理，所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

以上是关于手撸架构，Spring 面试63问的主要内容，如果未能解决你的问题，请参考以下文章

那一天，被Redis主从架构支配的恐惧

手撸golang spring ioc/aop 之2

手撸golang spring ioc/aop 之1

手撸golang 仿spring ioc/aop 之3

Java精选面试Spring全家桶：带你手撸红黑树

面试官一口气问了MySQL事务锁和MVCC，我