Spring的IOC、Aop和Spring框架面试相关问题

ㅤㅤㅤ。。。

已于 2023-04-06 19:56:24 修改

阅读量106

点赞数

文章标签： spring 面试 java

于 2023-04-03 19:48:41 首次发布

本文链接：https://blog.csdn.net/qq_64272127/article/details/129936440

版权

一、 Spring的概括

Spring 是完全面向接口的设计，降低程序耦合性，主要是事务控制并创建bean实例对象。在ssh整合时，充当黏合剂的作用。IOC(Inversion of Control) 控制反转/依赖注入，又称DI(Dependency Injection) (依赖注入)

为了降低Java开发复杂性，Spring采用了一下4种关键策略

基于POJO的轻重量和最小入侵性编程
通过依赖注入和面向接口实现松耦合
基于切面和惯例进行声明式编程；
通过切面和模板减少样板式代码

1.1 Spring框架的优缺点

1、优点

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

2、缺点

Spring明明一个很轻量级的框架，却给人感觉大而全
Spring依赖反射，反射影响性能
使用门槛升高，入门Spring需要较长时间

1.2 Spring的作用

方便解耦,简化开发，AOP编程支持，声明式事务支持，集成Junit更加方便的进行分层测试，方便集成各种优秀框架

pring框架的设计目标，设计理念，和核心是什么？

Spring设计目标：
Spring为开发者提供一个一站式轻量级应用开发平台；
Spring设计理念：
在JavaEE开发中，支持POJO和JavaBean开发方式，使应用面向接口开发，充分支持OO（面向对象）设计方法；Spring通过IoC容器实现对象耦合关系的管理，并实现依赖反转，将对象之间的依赖关系交给IoC容器，实现解耦；
Spring框架的核心：
IoC容器和AOP模块。通过IoC容器管理POJO对象以及他们之间的耦合关系；通过AOP以动态非侵入的方式增强服务

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

工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例
单例模式：Bean默认为单例模式
代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术
模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate
观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。

1.4 Spring框架中有哪些不同类型的事件？

Spring 提供了以下5种标准的事件：

上下文更新事件（ContextRefreshedEvent）：
在调用ConfigurableApplicationContext 接口中的refresh()方法时被触发。
上下文开始事件（ContextStartedEvent）：
当容器调用ConfigurableApplicationContext的Start()方法开始/重新开始容器时触发该事件。
上下文停止事件（ContextStoppedEvent）：
当容器调用ConfigurableApplicationContext的Stop()方法停止容器时触发该事件。
上下文关闭事件（ContextClosedEvent）：
当ApplicationContext被关闭时触发该事件。容器被关闭时，其管理的所有单例Bean都被销毁。
请求处理事件（RequestHandledEvent）：
在Web应用中，当一个http请求（request）结束触发该事件。如果一个bean实现了ApplicationListener接口，当一个ApplicationEvent 被发布以后，bean会自动被通知。
1.5 Spring Framework 中有多少个模块，它们分别是什么？
Spring 总共大约有 20 个模块，由 1300 多个不同的文件构成。而这些组件被分别整合在核心容器（Core Container）、 AOP（Aspect Oriented Programming）和设备支持（Instrmentation）、数据访问与集成（Data Access/Integeration）、 Web、消息（Messaging）、 Test等几个模块中。以下是 Spring 5 的模块结构图：
Spring 核心容器
提供了框架的基本组成部分，包括控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）功能。它包含以下模块：

Spring Core
Spring Bean
SpEL (Spring Expression Language)
Spring Context

1.6. Spring通知有哪些类型？

在AOP术语中，切面的工作被称为通知，实际上是程序执行时要通过SpringAOP框架触发的代码段。

Spring切面可以应用5种类型的通知：

前置通知（Before）：在目标方法被调用之前调用通知功能；
后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；
返回通知（After-returning ）：在目标方法成功执行之后调用通知；
异常通知（After-throwing）：在目标方法抛出异常后调用通知；
环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

二、什么是DI

控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

Spring IOC 负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期

三、、IOC

3.1 什么是IOC

IOC就是控制反转,把创建对象的权利交给spring

3.2 IOC的作用

管理对象的创建和依赖关系的维护。对象的创建并不是一件简单的事，在对象关系比较复杂时，如果依赖关系需要程序猿来维护的话，那是相当头疼的
解耦，由容器去维护具体的对象
托管了类的产生过程，比如我们需要在类的产生过程中做一些处理，最直接的例子就是代理，如果有容器程序可以把这部分处理交给容器，应用程序则无需去关心类是如何完成代理的

3.3 IOC的注入

通过属性进行注入
通过构造函数进行注入
注入对象组、List集合、Map集合、Properties类型

3.4 IOC自动绑定模式

可以设置autowire按一下方式进行绑定

按byType只要类型一致就会自动寻找
按byName自动按属性名称进行自动查找匹配

3.5 SpringIOC控制反转

原来需要我们自己进行bean的创建以及注入，而现在交给

spring容器去完成bean的创建以及注入。

所谓的“控制反转”就是对象控制权的转移，

从程序代码本身转移到了外部容器。

官方解释:

控制反转即IoC (Inversion of Control)，

它把传统上由程序代码直接操控的对象的调用权交给容器，

通过容器来实现对象组件的装配和管理。

所谓的“控制反转”概念就是对组件对象控制权的转移，

从程序代码本身转移到了外部容器。

3.6 Spring IOC的实现机制

Spring 中的IOC的实现原理就是工厂模式加反射机制。

例：

interface Fruit {
  public abstract void eat();
}
 
class Apple implements Fruit {
  public void eat(){
    System.out.println("Apple");
  }
}
class Orange implements Fruit {
  public void eat(){
    System.out.println("Orange");
  }
}
class Factory {
  public static Fruit getInstance(String ClassName) { 
    Fruit f=null;
    try {
      f=(Fruit)Class.forName(ClassName).newInstance(); } catch (Exception e) {
    e.printStackTrace();
    }
    return f;
  }
}
 
class Client {
  public static void main(String[] a) {
    Fruit f=Factory.getInstance("com.xxx.xxx.Apple");
    if(f!=null){
      f.eat();
    } 
  }
}

3.7 构造器依赖注入和Setter方法注入有什么区别？

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

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

3.8 set方式注入

依赖注入：Set注入！

依赖：bean对象的创建依赖于容器！

注入：bean对象中的所有属性，由容器来注入！

【环境依赖】

1、复杂类型

public class Address {
   private  String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

2.真实测试环境

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private Properties info;
    private String wife;

3.beans.xml

 <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.xing.pojo.Student">
        <!--1.普通注入-->
     <property name="name" value="abc"></property>
        <!--2.-->

    </bean>
</beans>

4.测试类

 public class MyTests {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext ("beans.xml");
        Student student =(Student) context.getBean("student");
        System.out.println(student.getName());


    }
}

5.完善信息注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="com.xing.pojo.Student">
        <!--1.普通注入-->
     <property name="name" value="abc"></property>
        <!---->
     <property name="address" ref="address">
     </property>
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演绎</value>
            </array>
        </property>
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>敲代码</value>
                <value>看电影</value>
            </list>
        </property>
        <!--map注入-->
        <property name="card">
            <map>
                <entry key="身份证" value="12312312321"></entry>
                <entry key="银行卡" value="45645645645"></entry>
            </map>
            <!--set注入-->
        </property>
        <property name="games">
            <set>
                <value>lol</value>
                <value>coc</value>
                <value>bob</value>
            </set>
        </property>
        <!--空值或空串-->
        <property name="wife">
            <null></null>
        </property>
        <!--Properties-->
        <property name="info">
            <props>
                <prop key="root">root</prop>
                <prop key="url">url</prop>
                <prop key="password">password</prop>
            </props>
        </property>
    </bean>
    <!--2.bean注入，ref-->
    <bean id="address" class="com.xing.pojo.Address">
        <property name="address" value="北京"></property>
    </bean>

</beans>

四、AOP

4.1 什么是AOP

在软件业,AOP为Aspect Oriented Programming的缩写,意味:面向切面编程.通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术,AOP是OOP的延续.将一些共性的内容进行抽取，在需要用到的地方，以动态代理的方式进行插入.在不修改源码的基础上，还能对源码进行前后增强。

AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面(切面)编程。

注：OOP(Object-Oriented Programming ) 面向对象编程

AOP 主要应用于日志记录，性能统计，安全控制,事务处理（项目中使用的）等方面。

4.2 Spring中的AOP技术

在Spring中可以通过代理模式来实现AOP

代理模式分为：

静态代理：一个接口，分别有一个真实实现和一个代理实现。
动态代理：通过代理类的代理，接口和实现类之间可以不直接发生联系，而可以在运行（Runtme）实现动态关联。
动态代理有两种实现方式
可以通过jdk的动态代理实现也可以通过cglib来实现而AOP默认是通过.3.jdk的动态代理来实现的。
jdk的动态代理必须要有接口的支持，而cglib不需要，它是基于类的

4.3 AOP术语
前置通知：比如我要执行add，方法之前执行

后置通知：方法之后执行

环绕通知：方法之前和之后都会执行

异常通知：发生异常执行

最终：相当于finally

切面：把通知应用到切入点guocheng。比如在登录过程中加一个权限判断

AOP操作（准备）
1、Spring框架一般都是基于AspectJ实现AOP操作
（1）什么是AspectJ
AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进
行AOP操作
2、基于AspectJ实现AOP操作
（1）基于xml配置文件实现
（2）基于注解方式实现（使用）
3.在项目中引入aop所需要的jar包

4.切入点表达式
（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构：
execution（[权限修饰符[返回类型[类全路径][方法名称[参数列表D）

权限修饰符可以具体，*代表任一修饰符

返回类型可以省略

五、Spring框架
5.1 什么是Spring框架
spring是一个开放源代码的设计层面框架,它解决的是业务逻辑层和其他各层的松耦合问题,是一个分层的javaEE一站式轻量级开源框架
5.2 ring支持的几种bean的作用

singleton：bean在每一个Spring IOC容器中只有一个实例。
prototype：一个bean的定义可以有多个实例。
request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
缺省的Spring bean 的作用域是Singleton.

5.3 什么是通知有哪五种类型的通知

通知是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码段。Spring切面可以应用五种类型的通知

1）before：前置通知，在一个方法执行前被调用。

2）after: 在方法执行之后调用的通知，无论方法执行是否成功。

3）after-returning: 仅当方法成功完成后执行的通知。

4）after-throwing: 在方法抛出异常退出时执行的通知。

5）around: 在方法执行之前和之后调用的通知

ㅤㅤㅤ。。。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring的IOC、Aop和Spring框架面试相关问题

IOC就是控制反转,把创建对象的权利交给spring在软件业,AOP为Aspect Oriented Programming的缩写,意味:面向切面编程.通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术,AOP是OOP的延续.将一些共性的内容进行抽取，在需要用到的地方，以动态代理的方式进行插入.在不修改源码的基础上，还能对源码进行前后增强。AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面(切面)编程。
复制链接

扫一扫