最新总结Spring知识及常见面试题

最新推荐文章于 2023-03-13 12:56:11 发布

夏至青柠

最新推荐文章于 2023-03-13 12:56:11 发布

阅读量181

点赞数

分类专栏： spring Java面试题文章标签： spring spring总结 spring面试题最新spring面试题 spring配置文件

本文链接：https://blog.csdn.net/qibulemingzi/article/details/109908035

版权

Java面试题同时被 2 个专栏收录

23 篇文章 1 订阅

订阅专栏

spring

8 篇文章 0 订阅

订阅专栏

1. 什么是spring?

Spring是一个开源、分层javaSE/javaEE的一站式轻量级解决方案。[容器框架]

2. 使用Spring框架的好处是什么？

解决业务逻辑层【Service】与web层和数据访问层之间的松耦合问题。

3. Spring由哪些模块组成?

在这里插入图片描述

4. 什么是Spring IOC 容器？

IoC（Inverse of Control 反转控制）：将java对象创建和维护权利交由Spring工厂进行管理和维护。

5. IOC的优点是什么？

java对象创建和维护权利交由Spring工厂进行管理和维护。

6. 什么是BeanFactory ? BeanFactory 实现举例。

BeanFactory接口表示一个Spring工厂对象【Spring容器对象】，包含了实例化好的java类对象。【管理】
BeanFactory接口有一个常用的子接口ApplicationContext接口，我们通常使用ApplicationContext接口充当Spring工厂对象【Spring容器对象】。
1.ClassPathXmlApplicationContext类 – new ClassPathXmlApplicationContext()可以创建出BeanFactory接口对象/ApplicationContext对象
表示：通过查找类路径加载一个Xml文件创建Spring工厂对象
2. FileSystemXmlApplicationContext类 —new FileSystemXmlApplicationContext可以创建出BeanFactory接口对象/ApplicationContext对象
表示：通过在系统文件类路径中加载一个Xml文件创建Spring工厂对象

7. ApplicationContext怎么实现?

1.ClassPathXmlApplicationContext类 – new ClassPathXmlApplicationContext()可以创建出BeanFactory接口对象/ApplicationContext对象
表示：通过查找类路径加载一个Xml文件创建Spring工厂对象
2.FileSystemXmlApplicationContext类 —new FileSystemXmlApplicationContext可以创建出BeanFactory接口对象/ApplicationContext对象
表示：通过在系统文件类路径中加载一个Xml文件创建Spring工厂对象

8. BeanFactory和 Applicationcontexts 有什么区别？

ApplicationContext接口是BeanFactory接口的子接口，都是Spring容器对象。

9. spring配置bean实例化有哪些方式？

(1) 无参数构造方法（开发最常用）
(2) 静态工厂方法实例化bean

//需要创建一个静态工厂
package com.wangxing.spring.bean;
public class StaticFactryMethodClass {
    //创建静态方法
    public  static  Student getStudentObj(){
        return  new Student();
    }
}

(3) 实例工厂方法实例化bean

//需要创建一个实例工厂
package com.wangxing.spring.bean;
public class FactoryMethodClass {
    //创建实例方法
    public    Student getStudentObj(){
        return  new Student();
    }
}

<!-- 实例工厂方法配置 -->
<!-- 1.创建实例工厂对象 -->
<bean id="factoryMethodClass" class="com.wangxing.spring.bean.FactoryMethodClass"></bean>
<!-- 2.配置由实例工厂创建Student对象-->
<bean id="stu" factory-bean="factoryMethodClass" factory-method="getStudentObj"></bean>

(4) FactoryBean接口方式实例化bean

//实现FactoryBean接口的子类
package com.wangxing.spring.bean;
import org.springframework.beans.factory.FactoryBean;
public class FactoryBeanSunClass implements FactoryBean<Student> {
    @Override
    public Student getObject() throws Exception {
        return new Student();
    }
    @Override
    public Class<?> getObjectType() {
        return Student.class;
    }
}

10. BeanFactory和 FactoryBean 有什么区别？

BeanFactory接口 — Spring容器 — 用来保存和维护Spring创建的对象【管理】
FactoryBean接口-------------------用来创建java对象【创建】

11 . Spring的核心类有哪些，各有什么作用？

BeanFactory接口	用来保存和维护Spting创建的对象【Spring容器】
ApplicationContext接口	ApplicationContext接口是BeanFactory接口的子接口
ClassPathXmlApplicationContext类	通过查找classpath[类路径{resources目录}]下的Spring配置文件创建ApplicationContext接口对象/BeanFactory接口对象
FileSystemXmlApplicationContext类	通过查找系统路径[理解成绝对路径]下的Spring配置文件创建 ApplicationContext接口对象/BeanFactory接口对象。【不推荐使用】
FactoryBean接口	用来创建java对象【创建】

12. 解释Spring支持的几种bean的作用域

singleton: 单例模式【在一个spring容器中，对象只有一个实例。（默认值）】
prototype：多例模式/原型模式【在一个spring容器中，存在多个实例，每次getBean 返回一个新的实例。】
request：该属性仅对HTTP请求产生作用，使用该属性定义Bean时，每次HTTP请求都会创建一个新的Bean，适用于WebApplicationContext环境。【一次请求一个对象】
session：该属性仅用于HTTP Session，同一个Session共享一个Bean实例。不同Session使用不同的实例。【同一次回话中的对象都是相同的】
global session：该属性仅用于HTTP Session，同session作用域不同的是，所有的Session共享一个Bean实例。【多个session共享一个对象】

利用bean中scope属性

13. 哪些是重要的bean生命周期方法？能重载它们吗？

Spring工厂对象【Spring容器对象】负责创建对象，初始化对象，销毁对象。

<!-- 无参数构造方法实例化bean的配置 -->
	<!-- id:对象名称 -->
	<!-- class:被创建对象的java类的包名+类名 -->
	<!-- init-method:配置对象的初始化方法 -->
<!-- destroy-method:配置对象的销毁方法 -->
<bean id="student" class="com.click369.javabean.StudentBean" init-method="initStudentBean"  destroy-method="destroyStudentBean"></bean>

不能重载，因为xml文件中生命周期属性使用的是生命周期方法名称

14. 什么是Spring的依赖注入？

依赖注入–在调用者类中将被调用者类的对象添加到调用者类中的过程就称为依赖注入。
在这个过程中被调用者类的对象就是调用者类的依赖对象。

15. 有哪些不同类型的DI(依赖注入）方式？

1.基于XML的依赖注入
构造方法注入

		   <!--constructor-arg构造方法注入元素-->
           <!-- index="0":构造方法参数的索引值-->
           <!-- ref="stu"：指定被注入的具体数据值-->
           <constructor-arg index="0" ref="stu"></constructor-arg>

Set方法注入

		   <!--property:set方法注入需要使用的元素-->
           <!--name="person":调用者类中定义的依赖对象的名称-->
           <!--ref="per"：指定被注入的具体数据值-->
           <property name="person" ref="per"></property>

2.自动注入[自动装配策略]

<bean id="personService" class="com.wangxing.spring.byname.PersonService" autowire="byName"></bean>

3.基于注解注入

@Component
@Repository 标注数据访问接口实现类，其功能与 @Component 相同。
@Service标注业务访问接口实现类，其功能与 @Component 相同。
@Controller标注控制层实现类，其功能与 @Component 相同。
@Autowired 完成 Bean 的自动注入工作。默认按照bytype。
@Resource 完成 Bean 的自动注入工作。默认按照byname。

16. Spring的自动装配策略？

byName	根据成员变量的 name 自动装配，如果一个 Bean 的 name 和另一个 Bean 中的 Property 的 name 相同，则自动装配这个 Bean 到 Property 中。
byType	根据 Property 的数据类型（Type）自动装配，如果一个 Bean 的数据类型兼容另一个 Bean 中 Property 的数据类型，则自动装配。
constructor	根据构造方法的参数的数据类型，进行 byType 模式的自动装配。
autodetect	如果发现默认的构造方法，则用 constructor 模式，否则用 byType 模式。被标记为过时方法，在Spring3.0之后已经不再支持。
no	默认情况下，不使用自动装配，Bean 依赖必须通过 ref 元素定义。

17. Spring注解@Resource和@Autowired区别对比

1、共同点
两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。
2、不同点
（1）@Autowired
@Autowired为Spring提供的注解，只按照byType注入，需要导入包org.springframework.beans.factory.annotation.Autowired;

（2）@Resource

@Resource()	默认按照ByName自动注入，有两个重要的属性：name和type；
@Resource(“name”)	按照ByName自动注入
@Resource(“type”)	按照byType自动注入。

18. 在 Spring中如何注入一个java集合？

<!-- 创建StudentBean对象，并通过set方式为集合型成员变量赋初始值-->
	<bean id="student" class="com.click369.javabean.StudentBean">
	  <!-- 数组 -->
	  <property name="stringArray">
	     <array>
	        <value>zhangsan</value>
	        <value>lisi</value>
	        <value>wangwu</value>
	     </array>
	  </property>
	  <!-- list -->
	  <property name="stringList">
	     <list>
	        <value>西安</value>
	        <value>北京</value>
	        <value>上海</value>
	     </list>
	  </property>
	  <!-- set -->
	  <property name="stringSet">
	     <set>
	        <value>javaSE</value>
	        <value>javaEE</value>
	        <value>javaME</value>
	     </set>
	  </property>
	  <!-- Map -->
	  <!-- key属性的值不能是key -->
	  <!-- value属性的值不能是value -->
	  <property name="stringMap">
	     <map>
	       <entry key="age">
	            <value>23</value>
	       </entry>
	       <entry key="height" value="167.5"></entry>
	       <entry key="sex" value="男"></entry>
	     </map>
	  </property>
	  <!-- properties -->
	  <property name="myProperties">
	      <props>
	         <prop key="mydirver">com.mysql.jdbc.Driver</prop>
	         <prop key="myusername">root</prop>
	         <prop key="mypassword">123456</prop>
	      </props>
	  </property>
	</bean>
</beans>

19. 怎样开启Spring注解装配？

<!-- 开启注解功能 -->
<context:annotation-config/> 
<!-- 配置Spring自动扫描包 -->
<context:component-scan base-package="com.click369.javabean"></context:component-scan>

20. IoC 和 DI的区别？

IoC（Inverse of Control 反转控制）：将java对象创建和维护权利交由Spring工厂进行管理和维护。
依赖注入–在调用者类中将被调用者类的对象，添加到调用者类中这个过程就是依赖注入。
在这个过程中被调用者类的对象就是调用者类的依赖对象。
依赖注入是基于IoC（Inverse of Control 反转控制）。

21. Spring面向切面编程（AOP）

AOP (Aspect Oriented Programing) 称为：面向切面编程，是一种编程思想。
AOP 思想：基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，通过代理对象，调用增强功能的代码【系统需求方法】，从而对原有业务方法进行增强。
AOP的底层是动态代理机制【CGLIB动态代理】。
基于两种动态代理机制： JDK动态代理和CGLIB动态代理。
JDK动态代理：基于接口的代理，会生成目标对象的接口的子对象【实现接口的类】
CGLIB动态代理：基于类的代理，会生成目标对象的子对象。【无论是继承父类还是实现接口所产生的类】
基于XML文件的AOP实现

	<aop:config>
		<aop:pointcut expression="execution(* com.click369.service.impl.UserServiceImpl.insertService(..))" 
					  id="point1"/>
		<aop:pointcut expression="execution(* com.click369.service.impl.UserServiceImpl.updateService(..))" 
					  id="point2"/>
		<aop:pointcut expression="execution(* com.click369.service.impl.UserServiceImpl.deleteService(..))" 
					  id="point3"/>		  
		<aop:aspect ref="myAvice">
			<aop:before method="savaLog" pointcut-ref="point1"/>
			<aop:after-returning method="savaLog" pointcut-ref="point2"/>
			<aop:around method="around" pointcut-ref="point3"/>
		</aop:aspect>
	</aop:config>

基于注解的Aop实现

@Aspect//@Aspect，表示这个系统需求类是一个切面
@Before("execution(* com.click369.service.impl.UserServiceImpl.insertService(..))")
@AfterReturning("execution(* com.click369.service.impl.UserServiceImpl.updateService(..))")
@Around("execution(* com.click369.service.impl.UserServiceImpl.deleteService(..))")

<!-- 开启aop注解  -->
<aop:aspectj-autoproxy />

22. 在Spring AOP 中，连接点和切入点的区别是什么？

joinpoint（连接点）：指那些被拦截到的点。在spring中指的可以被代理（增强）的方法。【业务类中的业务需求方法】
poingcut（切入点）：对哪些连接点进行拦截的定义。在Spring中指的真正需要被代理（增强）的方法。

23. Spring支持的事务管理类型

1.编程式事务管理—手动编写大量的java代码实现事务管理
2.声明式事务管理—就是在Spring的配置文件中通过配置实现事务管理
2.1基于xml配置文件
2.2基于注解

24. Spring里面applicationContext.xml文件能不能改成其他文件名？

可以，在web.xml 配置

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*:/applicationContext*.xml <!-- spring bean文件所在路径 -->
</param-value>
</context-param>

25. Spring配置文件?

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
 
    <!--扫描属性上面的注解-->
    <!--<context:annotation-config></context:annotation-config>-->
 
    <!--开启注解扫描-->
    <!--到包里面扫描类型、属性、方法上面的注解-->
    <context:component-scan base-package="com"></context:component-scan>
 
    <!--开启aop操作-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
 
    <!--配置c3p0的连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/customer_service_system"></property>
        <property name="user" value="root"></property>
        <property name="password" value="dadan123"></property>
    </bean>
 
    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
 
    <!--配置hibernateTemplate事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
 
    <!--事务驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
 
    <!--使用spring sessionFactory-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
    </bean>
 
    <!--创建hibernateTemplate对象-->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

<!--spring mvc注解驱动-->
<mvc:annotation-driven></mvc:annotation-driven>

夏至青柠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最新总结Spring知识及常见面试题

1. 什么是spring? Spring是一个开源的分层的javaSE/javaEE的一站式的轻量级的解决方案。[容器框架]2. 使用Spring框架的好处是什么？作用：解决业务逻辑层【Service】与web层和数据访问层之间的松耦合问题。3. Spring由哪些模块组成?4. 什么是BeanFactory ? BeanFactory 实现举例。 BeanFactory接口表示一个Spring工厂对象【Spring容器对象】，包含了实例化好的java类对象。【管理】 B
复制链接

扫一扫