spring框架进阶

1.BeabFactory和·ApplicationContext接口的区别（考察对spring核心接口类的架构是否了解）

BeanFactory是spring框架最底层接口，定义如何创建获得Bean，主要是面向spring本身的。

ApplicationContext继承BeanFactory接口，对功能进行扩展

spring中实际实现classPathxmlApplicationContext这个类进行具体实现bean的创建和管理

BeanFactory主要是面向spring框架存在的，不支持web和Aop功能，在获取bean时才能创建bean

ApplicationContext支持Aop和web等插件，面向开发层面，在框架创建时就可以创建bean

2.springBean的生命周期

spring中的bean特指的是spring框架所管理的对象，和自己new的不同

spring管理bean的过程：

（1）实例化Instantication   等同于new，反射，xml，bean，class=“com。。。”注解

（2）属性赋值Populate 属性注入值

（3）初始化   这个阶段是根据各种配置进行对象的初始化，例如类具有事务管理系统，在此阶段要生成代理对象

（4）使用

（5）销毁   制定销毁前执行的方法

3.spring中的bean是线程安全的吗

不是线程安全的

线程安全问题指的是在单例bean的情况下，对象只创建了一个，如果拥有成员变量所有的请求是共享的，所以线程不安全

可以使用ThreadLocal为每个请求创建一个变量副本

线程安全这个问题，要从单例与原型 Bean 分别进行说明：

原型bean：对于原型bean，每次创建一个新的对象，并不存在bean共享，自然不会有线程安全问题

单例bean：对于单例bean，所有线程都共享一个单例bean，因此资源是竞争的

Bean又分为

有状态就是有数据存储功能（包含成员变量）

无状态就是不会保存数据

如果单例bean是一个无状态bean，也就是线程操作不会对bean的成员作出迅以外的操作，那么这个单例bean是线程安全的。比如Spring MVC 中的Controller，Service，Dao等，这些bean大多数是无状态的，只关注方法本身

但如果bean是有状态的，那就需要开发人员自己来进行线程安全的验证，最简单的方法就是改变bean的作用域把“singletion”改成“protopyte”，这样每次请求bean就相当于new bean（）这样就可以保证是线程安全了

bean循环依赖

Java中的循环依赖

就是A对象依赖B对象，B对象依赖A对象

问：什么是循环依赖？为什么有循环依赖问题？

答：A类依赖B类，B类又依赖A类。本身是没有任何问题的，创建A类，B类属性是null，但是在spring中有自动注入功能，那么问题就产生了，创建A时（A的Bean）就要注入B，但是B也是一样的，创建时就要注入A

问：spring是如何解决的？

答：三级缓存  把每一级缓存理解为3个不同的Map

一级缓存：保存实例化，属性赋值，初始化的Bean

二级缓存：保存实例化完成的Bean（半成品的Bean）

三级缓存：保存Bean工厂，以便后期添加其他需要的功能，例如事务管理中的代理对象的生成

主要是针对属性注入的

构造方法注入无法解决依赖循环

问：Servlet过滤器与Spring拦截器的区别？

答：

1.实现方式不同

过滤器是请求进入到Servlet前，进行过滤，是纯粹的javaweb规范实现的

拦截器是Spring框架自己实现的

2.实现原理不同

过滤器使用函数回调方式实现

拦截器使用反射方式实现（纯java）

3.使用范围不同

过滤器依赖于服务器，只能适用于web项目

拦截器可以适用于任何java程序

4.触发时机不同

过滤器在使用服务器，进入Servlet前触发

拦截器在到达Spring中的Controller前进行

5.拦截的请求范围不同

过滤器可以拦截所有进入到web的请求

拦截器可以拦截所有进入到控制器中的请求

面向对象的设计原则

在面向对象的设计模式中，需要考虑的是如何提高一个软件系统的可维护性和可复用性

单一职责

尽量减受类的功能，一个类负责某一个事务处理

开闭原则

对修改关闭，对扩展开放，将功能抽象，提取抽象类，接口

里氏替换原则

本质就是多态，用父类的引用调用子类的对象，可以用任意子类代替父类

依赖倒置

上层应该尽量设计为抽象

接口隔离

将接口粒度减小，不要把根多功能放到一个接口中

迪米特原则

一个对象尽可能减少对其他对对象的了解（代理思想）

Java设计模式

问：什么是设计模式？

答：前辈们在长久开发中，为了解决反复出现的某些问题，经过长久时间的开发，代码结构优化，最终确定的一套解决方案

问：为什么学习设计结构？

答：对程序设计是有帮助的，提高代码的复用率，扩展性，可靠性，可维护性等等，提高程序员编码能力，设计出标准型代码

*问：设计模式共有几种？

*答：23种​​​​gtai

         3大类

         创建型模式：如何创建对象（单例模式，工厂模式）

         结构型模式：类和类如何组合，组织出更大的结构（代理模式）

         行为型模式：类各类如何协作

单例：在一个程序中，一个类只能创建一个对象

          实现:1.构建方式私有化，在其他类中不能new对象

                   2.在单例类中，向外界提供一个公共的静态方法来获取单例对象，在类的内部方便控制

          分为：1.饿汉式单例：在类中关联自己，为静态，当类加载时创建单类对象，调用方法时直接返回即可，类只加载一次所以只创建一个对象，且没有线程安全问题

                     2.饱汉式单例：在类加载时，并没有创建单例对象，在第一次访问时创建，容易出现安全问题

*volatile修饰保证有序性可见性*

*主要为了实现有序性，创建对象并引用赋值这个过程底层可以分为三个步骤*

*1.new在内存中申请空间（不会重排）*

*2.调用构造方法初始化对象*

*3.对象把地址赋给引用变量（有可能将第三步放到第二步执行，造成引用变量执行的是一个半成品对象）*

问：为什么会出现线程安全问题？怎么解决？

答：双层探索+volatile

工厂：创建型模式，批量创建对象，创建对象与使用对象相分离（参考框架理解，配置类，注                   解），简单工厂为例说明工厂模式大致作用，实现思路

代理：AOP的底层实现使用的就是动态代理

         代理设计思想：想完成某件事情，可以不通过直接访问目标，通过访问中介实现目的

         代理优点：保护目标对象，对访问者提供额外操作，降低访问者和目标的耦合度

         动态代理类：代理不需要实现与目标类相同的接口，这样就可以代理任意的目标类，但是是                                有要求的，目标类必须实现接口

         静态代理类：代理类必须实现与目标类相同的接口（目标类必须实现接口），这样拓展度就                                 降低了

         动态代理：核心思想就是动态性，怎样实现动态性？通过反射机制实现，动态获取目标类信                             息，动态生成代理对象。目标类也必须是一个接口。而代理类不需要实现和目标                             类一样的接口实现InvocationHandler接口

Cglib处理

首先目标不需要接口，采用动态字节码技术，可以为目标类动态生成父类，采用方法拦截技术实现

注解

注解标记，可以标记包，类，方法，属性，参数

相当于定义了一个规则，例如作用在那个元素上，什么时候生效，以及自己需要的功能

元注解

用来标记自定义注解的注解

对象克隆

把一个对象进行复制，复制出一个新对象

问：为什么要复制？

答：克隆的对象已经包含了一些修改过的属性，而new出来的对象的属性还是初始化的值，所以需要一个新的对象来保存当前对象的“状态”就靠clone方法了

问：运用场景？

答：接受前端数据，dao搜索数据，后端向前端反映数据

克隆又分为深克隆与浅克隆

浅克隆：在克隆嵌套时，克隆对象时，只将关联对象的引用地址复制一份

深客隆：在克隆嵌套时，克隆对象时，不仅克隆当前对象，还将关联的对象也进行创建

问：如何实现深克隆？

答：

1.在关联对象中继续重写克隆方法，嵌套克隆

2.对象序列化，反序列化时创建新的对象

3.使用一些第三方工具进行新的克隆