Spring框架

最新推荐文章于 2023-07-16 15:21:11 发布

一条小咸鱼i

最新推荐文章于 2023-07-16 15:21:11 发布

阅读量380

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/Crush_kylin/article/details/100547914

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

1、什么是设计模式？你用过或者了解哪些设计模式？

设计模式：是指在软件开发中，经过验证的，用于解决在特定环境下、重复出现的、特定问题的解决方案。
设计模式详解

2、什么是单例模式？单例模式实现的方式有哪些？【不下7种】饿汉模式和懒汉模式实现方式有什么区别？单例模式的定义与特点

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

单例模式有 3 个特点：

单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点；

单例模式的结构与实现
单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

下面来分析其基本结构和实现方法。

单例模式的结构
单例模式的主要角色如下。

单例类：包含一个实例且能自行创建这个实例的类。
访问类：使用单例的类。
其结构如图 1 所示。
在这里插入图片描述 2. 单例模式的实现
Singleton 模式通常有两种实现形式。
第 1 种：懒汉式单例
该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。代码如下：

   public class LazySingleton
 {
     private static volatile LazySingleton instance=null;    //保证 instance 在所有线程中同步
     private LazySingleton(){}    //private 避免类在外部被实例化
     public static synchronized LazySingleton getInstance()
     {
         //getInstance 方法前加同步
         if(instance==null)
         {
             instance=new LazySingleton();
         }
         return instance;
     }
 }

注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
第 2 种：饿汉式单例
该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

public class HungrySingleton
{
    private static final HungrySingleton instance=new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance()
    {
        return instance;
    }
}

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

3、单例模式如何保证线程安全？

方法一：在MyFactory 中加入了一个私有静态内部类instanceHolder ，对外提供的接口是 getInstance()方法，也就是只有在MyFactory.getInstance()的时候，instance对象才会被创建，，没有使用同步。保证了只有一个实例，还同时具有了Lazy的特性

public class MyFactory {
        private static class instanceHolder {   
            public static MyFactory instance = new MyFactory();   
        }   
      
        public static MyFactory getInstance() {   
            return MyFactory.instanceHolder.instance;   
        }   
}

方式二：（懒汉式）

这种方式也没有使用同步，并且确保了调用static getInstance()方法时才创建MyFactory的引用，

  private static MyFactory instance = new MyFactory();

  public static MyFactory getInstance() {
    　　return instance;
  }

方式三：使用synchronized ，通常会锁定整个方法的是比较耗费资源的，实际会产生多线程访问问题的是这一句代码instance = new MyFactory();

为了减少资源的消耗，只锁这一句就行了，两个线程并发地进入第一次判断instance是否为空的if 语句内部，一个线程获得了锁执行new操作，另一个线程被阻塞，

当第一个线程执行完毕之后，第二个线程如果直接进行new操作也是不安全的。为了避免第二次new操作，添加第二次条件判断，既二次检查

private static MyFactory instance;
public static MyFactory getInstance(){
    if(instance == null){
        synchronized (MyFactory.class) {
            if(instance == null){
                instance = new MyFactory();
            }
        }
    }
    return instance;
}

4、你用过volatile关键字，它的是如何实现的？【涉及一些底层硬件的实现机制】

1.保证线程间变量的可见性

线程对volatile变量进行修改之后，要立刻回写到主内存。
线程对volatile变量读取的时候，要从主内存中读，而不是从工作内存。（关于主内存和工作内存的概念是在Java内存模型[JMM, Java Memory Model]中定义的）

我们知道CPU的处理速度和主存的读写速度不是一个量级的，为了平衡这种巨大的差距，每个CPU都会有缓存。因此，共享变量会先放在主存中，每个线程都有属于自己的工作内存，并且会把位于主存中的共享变量拷贝到自己的工作内存，之后的读写操作均使用位于工作内存的变量副本，并在某个时刻将工作内存的变量副本写回到主存中去。JMM就从抽象层次定义了这种方式，并且JMM决定了一个线程对共享变量的写入何时对其他线程是可见的。

JMM示意图如下：
在这里插入图片描述

image.png

线程A和线程B之间要完成通信的话，要经历如下两步：

线程A从主内存中将共享变量读入线程A的工作内存后并进行操作，之后将数据重新写回到主内存中；
线程B从主存中读取最新的共享变量

从横向去看看，线程A和线程B就好像通过共享变量在进行隐式通信。这其中有很有意思的问题，如果线程A更新后数据并没有及时写回到主存，而此时线程B读到的是过期的数据，这就出现了“脏读”现象。可以通过同步机制（控制不同线程间操作发生的相对顺序）来解决或者通过volatile关键字使得每次volatile变量都能够强制刷新到主存，从而对每个线程都是可见的

5、工厂模式？如何实现？

工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式
工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。

模式的结构
工厂方法模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。

模式的结构
抽象工厂模式的主要角色如下。

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

6、什么是代理模式？代理模式有哪几种实现方式？动态代理的实现方式（jdk、cglib），这两种实现方式各有什么不同？

代理模式详解

7、什么spring框架？用过spring框架么？

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

特点：
1.方便解耦，简化开发
通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2.AOP编程的支持
通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
3.声明事物的支持
在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
4.方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
5.方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。
6.降低Java EE API的使用难度
Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。
7.Java 源码是经典学习范例
Spring的源码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。
简单理解

一.概念：

spring是开源的轻量级框架

2 spring核心主要两部分：

（1）aop：面向切面编程，扩展功能不修改源代码实现,详解【http://www.cnblogs.com/landeanfen/p/4782370.html】

（2）ioc：控制反转

比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象，把对象的创建不是通过new方式实现，而是交给spring配置创建类对象。

8、什么是IOC和DI？说说你对IOC和DI的理解？

1、IOC是什么

IOC—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IOC是有专门一个容器来创建这些对象，即由IOc容器来控制对象的创建而不再显式地使用new；谁控制谁？当然是IOC容器控制了对象；控制什么？那就是主要控制了外部资源获取和生命周期（不只是对象也包括文件等）。
为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。
用图例说明一下，传统程序设计如图1，都是主动去创建相关对象然后再组合起来：

图1 传统应用程序结构图
在这里插入图片描述

当有了IOC的容器后，在客户端类中不再主动去创建这些对象了，程序的结构图变成如图2所示：

图2 有IOC容器后的程序结构图
在这里插入图片描述

2、IoC能做什么
IOC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IOC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IOC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IOC/DI思想中，应用程序就变成被动的了，被动的等待IOC容器来创建并注入它所需要的资源了。

IOC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IOC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

3、IOC和DI

DI—Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

谁依赖于谁：当然是应用程序依赖于IOC容器；
为什么需要依赖：应用程序需要IOC容器来提供对象需要的外部资源；
谁注入谁：很明显是IOC容器注入应用程序某个对象，应用程序依赖的对象；
注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。
IOC和DI有什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IOC 而言，“依赖注入”明确描述了“被注入对象依赖IOC容器配置依赖对象”。

9、适配器模式和装饰模式，区别？

装饰模式和适配器模式都有一个别名叫包装模式，但包装的形式是不一样的。

定义上：

装饰模式：对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。使用原来被装饰的类的一个子类的实例，把客户端的调用委派到被装饰类。

适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

从定义上看装饰模式是对核心对象或者功能的扩展，适配器模式是把对象或者功能放到一个新对象中引用。举个例子，现在书城卖道德经的书，有线装版，有精装版，有日文版，有英文版，其中线装版和精装版就是装饰模式，日文版和英文版就是适配器模式，各种版本都是为迎合不同消费者的不同需求。为什么呢？因为线装版和精装版的道德经虽然包装不同，但内容相同，日文版和英文版就不同，这两个版本的内容就可能和原版的不同，文化差异嘛，翻译的内容虽来自道德经，但根据不同国家的文化，思维逻辑什么的就可能改变一些想法。

使用条件：

装饰模式一般在下列情况使用：需要扩展一个类的功能或者给你个类增加附加责任；需要动态的给一个对象增加功能，这些功能可以再动态的撤销；需要增加有一些基本功能的排列组合而产生非常大量的功能，从而使得继承关系变得不现实。

适配器模式一般使用的情况包括：系统需要使用现有的类，但此类已经不符合系统的需要；

想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的的类一起工作。适配器模式在系统升级的时候使用的频率很高，对旧系统的一些功能方法在新系统中引用。

装饰模式java中的I/O文件的操作中都有体现。

Java的IO库中处理流的类有FIleInputStream，FileOutputStream，DataInputStream，DataOutputStream类等。在InputStream，OutputStream,Reader,Writer结构的内部，有一些流处理器可以对另一些流处理器起到装饰作用，形成新的，改善的流处理器。这就体现了装饰模式的作用。同时在一些流处理器的内部有对其他流处理器的功能的适配引用，这体现了适配器模式的优点。

模式概念的出现，完善到合理应用是前辈们在实际的应用中不断总结的结晶。对于不同的需求合理的使用模式能起到事半功倍的效果，但是模式不是放之四海而皆准的，况且模式也不是一成不变死板的，随着技术的发展，工程师的智慧总结，可能会有新的模式出现和旧的模式的消亡，模式就是为实际需要而生，没必要上升到哲学这种高度。

一条小咸鱼i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架

文章目录1、什么是设计模式？你用过或者了解哪些设计模式？2、什么是单例模式？单例模式实现的方式有哪些？【不下7种】饿汉模式和懒汉模式实现方式有什么区别？3、单例模式如何保证线程安全？4、你用过volatile关键字，它的是如何实现的？【涉及一些底层硬件的实现机制】5、工厂模式？如何实现？6、什么是代理模式？代理模式有哪几种实现方式？动态代理的实现方式（jdk、cglib），这两种实现方式各有什...
复制链接

扫一扫