spring面试题大全
Spring架构图
组成Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
核心容器：核心容器提供Spring 框架的基本功能。核心容器的主要组件是BeanFactory ，它是工厂模式的实现。BeanFactory 使用控制反转（IOC ）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如JNDI 、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP ：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了Spring 框架中。所以，可以很容易地使Spring 框架管理的任何对象支持AOP 。Spring AOP 模块为基于Spring 的应用程序中的对象提供了事务管理服务。通过使用Spring AOP ，不用依赖EJB 组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO ：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向JDBC 的异常遵从通用的DAO 异常层次结构。
Spring ORM ：Spring 框架插入了若干个ORM 框架，从而提供了ORM 的对象关系工具，其中包括JDO 、Hibernate 和iBatisSQLMap 。所有这些都遵从Spring 的通用事务和DAO 异常层次结构。
* Spring的优点有什么?
1.Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分
2.Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高
3.依赖注入和IoC使得JDBC操作简单化
4.Spring是开源的免费的
5.Spring使得对象管理集中化合简单化
* 描述一下spring中实现DI（dependency injection）的几种方式
方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去
方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入
Spring的方式
* 简单描述下IOC(inversion of control)的理解
一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。
* Spring对很多ORM框架提供了很好支持，描述下在spring使用hibernate的方法
在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor
* 请介绍下spring的事务管理
spring提供了几个关于事务处理的类：
TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。
一般事务定义步骤：
TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
https://www.sodocs.net/doc/1b9544161.html,mit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}
spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。
编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.
void add()
{
transactionTemplate.execute( new TransactionCallback(){
pulic Object doInTransaction(TransactionStatus ts)
{ //do sth}
}
}
声明式：
使用TransactionProxyFactoryBean:
PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly
围绕Poxy的动态代理能够自动的提交和回滚事务
org.springframework.transaction.interceptor.TransactionProxyFactoryBean
PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。
* 如何在spring的applicationContext.xml使用JNDI而不是DataSource
可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：
* 在spring中是如何配置数据库驱动的
org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：
* spring中的applicationContext.xml能不能改为其他名字
ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个
* 在web中如何配置spring
在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：
* 在spring中如何定义hibernate Mapping？
添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：
* 两种依赖注入的类型是什么?
两种依赖注入的类型分别是setter注入和构造方法注入。
setter注入：一般情况下所有的java bean, 我们都会使用setter方法和getter方法去设置和获取属性的值，示例如下：
public class namebean {
String name;
public void setName(String a) {
name = a; }
public String getName() {
return name; }
}
我们会创建一个bean的实例然后设置属性的值，spring的配置文件如下：
Spring会调用setName方法来只是name熟悉为tom
构造方法注入：构造方法注入中，我们使用带参数的构造方法如下：
public class namebean {
String name;
public namebean(String a) {
name = a;
}
}
我们会在创建bean实例的时候以new namebean(”tom”)的方式来设置name属性, Spring配置文件如下：
使用constructor-arg标签来设置构造方法的参数。
* 解释一下Dependency Injection(DI)和IOC（inversion of control）?
参考答案：依赖注入DI是一个程序设计模式和架构模型，一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转
* Spring中BeanFactory和ApplicationContext的作用和区别
作用：
1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：
a. 国际化支持
b. 资源访问：Resource rs = ctx. getResou rce(”classpath:config.properties”),
“file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现
这两种方式都默认配置文件为web-inf/applicationContext.xml，也可使用context-param指定配置文件
* spring的核心是什么，各有什么作用？
BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能
* Spring中aop的关键名词有哪些？各有什么作用?
拦截器: 代理
装备(advice)
目标对象
关切点:条件
连接点:方法、属性
* Spring与struts的区别？
strusts：是一种基于MVC模式的一个web层的处理。
Spring:提供了通用的服务，ioc/di aop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术struts hibernate ibatis ejb remote springJDBC springMVC
* spring中的jdbc与传统的jdbc有什么区别?
Spring的jdbc:节省代码，不管连接(Connection)，不管事务、不管异常、不管关闭(con.close() ps.close )
JdbcTemplate(dataSource):增、删、改、查
TransactionTemplate(transactionManager):进行事务处理
* Spring配置的主要标签有什么?有什么作用?
* 如何在spring中实现国际化?
在applicationContext.xml加载一个bean
class=”org.springframework.context.support.ResourceBundleMessageSource”>
在src目录下建多个properties文件?
对于非英文的要用native2ascii? -encoding gb2312 源目转化文件相关内容
其命名格式是message_语言_国家。?
页面中的中显示提示信息，键名取键值。?
当给定国家，系统会自动加载对应的国家的properties信息。?
通过applictionContext.getMess age(“键名”,”参数”,”区域”)取出相关的信息。?
* 在spring中如何实现事件处理
事件
Extends ApplicationEvent
监听器
Implements ApplicationListener
事件源
Implements ApplicationContextAware
在applicationContext.xml中配置事件源、监听器
先得到事件源，调用事件源的方法，通知监听器。
* Spring如何实现资源管理?
使用
applicationContext.g etResource(“classpath:文件名”):在src根目录下，在类路径下applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目录下的基准往下走。applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。
* Spring的ApplicationContext的作用?
beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理
* 在spring中如何更加高效的使用JDBC
使用Spring框架提供的模板类JdbcTemplete可以是JDBC更加高效
代码如下：JdbcTemplate template = new JdbcTemplate(myDataSource);
DAO类的例子：
public class StudentDaoJdbc implements StudentDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
more..
}
配置文件：
* 请介绍下spring中bean的作用域
在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype），Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。
这里的scope就是用来配置spring bean的作用域，它标识bean的作用域。
在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype），Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。当然，Spring2.0对 Bean的类型的设计进行了重构，并设计出灵活的Bean类型支持，理论上可以有无数多种类型的Bean，用户可以根据自己的需要，增加新的Bean 类型，满足实际应用需求。
1、singleton作用域
当一个bean的作用域设置为singleton，那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean 定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。
配置实例：
或者
2、prototype
prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）都会产生一个新的bean实例，相当于一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个 prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用 bean的后置处理器，该处理器持有要被清除的bean的引用。）
配置实例：
或者
3、request
request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，配置实例：
request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：
如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：
…
…
如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现：
..
…
接着既可以配置bean的作用域了：
4、session
session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session 内有效，配置实例：
配置实例：
和request配置实例的前提一样，配置好web启动文件就可以如下配置：
5、global session
global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么，web会自动当成session类型来使用。
配置实例：
和request配置实例的前提一样，配置好web启动文件就可以如下配置：
6、自定义bean装配作用域
在spring 2.0中作用域是可以任意扩展的，你可以自定义作用域，甚至你也可以重新定义已有的作用域（但是你不能覆盖singleton和 prototype），spring的作用域由接口
org.springframework.beans.factory.config.Scope来定义，自定义自己的作用域只要实现该接口即可，下面给个实例：
我们建立一个线程的scope，该scope在表示一个线程中有效，代码如下：
publicclass MyScope implements Scope …{
privatefinal ThreadLocal threadScope = new ThreadLocal() …{
protected Object initialValu e() …{
returnnew HashMap();
}
};
public Object get(String name, ObjectFactory objectFactory) …{
Map scope = (Map) threadScope.get();
Object object = scope.get(name);
if(object==null) …{
object = objectFactory.getObject();
scope.put(name, object);
}
return object;
}
public Object remove(String name) …{
Map scope = (Map) threadScope.get();
return scope.remove(name);
}
publicvoid registerDestructionCallback(String name, Runnable callback) …{
}
public String getConversationId() …{
// TODO Auto-generated method stub
returnnull;
}
}
* 请介绍一下spring的bean的生命周期
一、Bean的定义
Spring通常通过配置文件定义Bean。如：
xmlns:xsi=”https://www.sodocs.net/doc/1b9544161.html,/2001/XMLSchema-instance” xsi:schemaLocation=”htt p://https://www.sodocs.net/doc/1b9544161.html,/schema/beans https://www.sodocs.net/doc/1b9544161.html,/schema/beans/spring-beans-2.0.xsd”>
这个配置文件就定义了一个标识为 HelloWorld 的Bean。在一个配置文档中可以定义多个Bean。
二、Bean的初始化
有两种方式初始化Bean。
1、在配置文档中通过指定init-method 属性来完成
在Bean的类中实现一个初始化Bean属性的方法，如init()，如：
public class HelloWorld{
public String msg=null;
public Date date=null;
public void init() {
msg=”HelloWorld”;
date=new Date();
}
……
}
然后，在配置文件中设置init-mothod属性：
2、实现 org.springframwork.beans.factory.InitializingBean接口
Bean实现InitializingBean接口，并且增加 afterPropertiesSet() 方法：
public class HelloWorld implement InitializingBean {
public String msg=null;
public Date date=null;
public void afterPropertiesSet() {
msg=”向全世界问好！”;
date=new Date();
}
……
}
那么，当这个Bean的所有属性被Spring的BeanFactory设置完后，会自动调用afterPropertiesSet()方法对Bean进行初始化，于是，配置文件就不用指定 init-method属性了。
三、Bean的调用
有三种方式可以得到Bean并进行调用：
1、使用BeanWrapper
HelloWorld hw=new HelloWorld();
BeanWrapper bw=new BeanWrapperImpl(hw);
bw.setPropertyvalue(”msg”,”HelloWorld”);
system.out.println(bw.getPropertyCalue(”msg”));
2、使用BeanFactory
InputStream is=new FileInputStream(”config.xml”);
XmlBeanFactory factory=new XmlBeanFactory(is);
HelloWorld hw=(HelloWorld) factory.getBean(”HelloWorld”);
system.out.println(hw.getMsg());
3、使用ApplicationConttext
ApplicationContext actx=new FleSystemXmlApplicationContext(”config.xml”);
Hello World hw=(HelloWorld) actx.getBean(”HelloWorld”);
System.out.println(hw.getMsg());
四、Bean的销毁
1、使用配置文件中的 destory-method 属性
与初始化属性 init-methods类似，在Bean的类中实现一个撤销Bean的方法，然后在配置文件中通过destory-method指定，那么当bean销毁时，Spring将自动调用指定的销毁方法。
2、实现 org.springframwork.bean.factory.DisposebleBean接口
如果实现了DisposebleBean接口，那么Spring将自动调用bean中的Destory方法进行销毁，所以，Bean 中必须提供Destory方法。
* Spring中如何获取bean
通过xml配置文件
bean配置在xml里面，spring提供多种方式读取配置文件得到ApplicationContext.
第一种方式：FileSystemXmlApplicationContext
通过程序在初始化的时候，导入Bean配置文件，然后得到Bean实例:
ApplicationContext ac = new FileSystemXmlApplicationContext(”applicationContext.xml”)
ac.getBean(”beanName”);
第二种方式：WebApplicationContextUtil
在B/S系统中,通常在web.xml初始化bean的配置文件，然后由WebAppliCationContextUtil得到ApplicationContext.例如：
ApplicationContext ctx =
WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc); ApplicationContext ctx
= WebApplicationContextUtils.getWebApplicationContext(ServletContext sc);
其中 servletContext sc 可以具体换成 servlet.getServletContext()或者 this.getServletContext() 或者 request.getSession().getServletContext();
另外，由于spring是注入的对象放在ServletContext中的，所以可以直接在ServletContext取出WebApplicationContext 对象：
WebApplicationContext webApplicationContext = (WebApplicationContext)
servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
* Spring框架有哪几部分组成?
Spring框架有七个模块组成组成，这7个模块(或组件)均可以单独存在，也可以与其它一个或多个模块联合使用，主要功能表现如下：
? Spring 核心容器（Core）：提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，她是工厂模式的实现。BeanFactory使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。
? Spring AOP：通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。
? Spring ORM：Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。
? Spring DAO：JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低了需要编写的异常代码数量（例如，打开和关系连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。
? Spring WEB：Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求及将请求参数绑定到域对象的工作。
? Spring上下文（Context）：Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。
? Spring MVC：Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC 框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol
* 使用spring有什么好处?
◆Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。
◆Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。
◆Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。
◆Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。
◆Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。
◆使用Spring构建的应用程序易于单元测试。
◆Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs 来实现业务接口，却不会影响调用代码。
◆Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。
■Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。
Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。
总结起来，Spring有如下优点：
◆低侵入式设计，代码污染极低
◆ 独立于各种应用服务器，可以真正实现Write Once,Run Anywhere的承诺
◆Spring的DI机制降低了业务对象替换的复杂性
◆Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部
* 什么是spring，它有什么特点?
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI 相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
springboot常见22个面试题及答案
问题一 什么是Spring Boot？ 多年来，随着新功能的增加，spring 变得越来越复杂。只需访问https://spring.io/projects 页面，我们就会看到可以在我们的应用程序中使用的所有Spring 项目的不同功能。 Spring Boot 是解决这个问题的方法。Spring Boot 已经建立在现有spring 框架之上。使用spring 启动，我们避免了之前我们必须做的所有样板代码和配置。因此，Spring Boot 可以帮助我们以最少的工作量，更加健壮地使用现有的Spring 功能。 如果必须启动一个新的Spring 项目，我们必须添加构建路径或添加Maven 依赖关系，配置应用程序服务器，添加spring 配置。因此，开始一个新的spring 项目需要很多努力，因为我们现在必须从头开始做所有事情。 问题二 Spring Boot 有哪些优点？Spring Boot 的优点有： 减少开发，测试时间和努力。 使用JavaConfig 有助于避免使用XML。 避免大量的Maven 导入和各种版本冲突。 提供意见发展方法。 通过提供默认值快速开始开发。
没有单独的Web 服务器需要。这意味着你不再需要启动Tomcat，Glassfish 或其他任何东西。 需要更少的配置因为没有web.xml 文件。只需添加用@ Configuration 注释的类，然后添加用@Bean 注释的方法，Spring 将自动加载对象并像以前一样对其进行管理。您甚至可以将 @Autowired 添加到bean 方法中，以使Spring 自动装入需要的依赖关系中。 基于环境的配置 使用这些属性，您可以将您正在使用的环境传递到应用程序：- Dspring.profiles.active = {enviornment}。在加载主应用程序属性文件后，Spring 将在（application{environment} .properties）中加载后续的应用程序属性文件。 问题三 什么是JavaConfig？ Spring JavaConfig 是Spring 社区的产品，它提供了配置Spring IoC 容器的纯Java 方法。因此它有助于避免使用XML 配置。使用JavaConfig 的优点在于： 面向对象的配置。由于配置被定义为JavaConfig 中的类，因此用户可以充分利用Java 中的面向对象功能。一个配置类可以继承另一个，重写它的@Bean 方法等。 减少或消除XML 配置。基于依赖注入原则的外化配置的好处已被证明。但是，许多开发人员不希望在XML 和Java 之间来回切换。
Java工程师面试题(三大框架)
Java工程师（程序员）面试题 Struts,Spring,Hibernate三大框架的面试 1.Hibernate工作原理及为什么要用？ 原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作6.提交事务7.关闭Session 8.关闭SesstionFactory 为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 2．Hibernate是如何延迟加载? 1. Hibernate2延迟加载实现：a)实体对象b)集合（Collection） 2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many 4.Struts1流程： 1、客户端浏览器发出HTTP请求。 2、根据web.xml配置，该请求被ActionServlet接收。 3、根据struts-config.xml配置，ActionServlet先将请求中的参数填充到ActionForm中，然后ActionServlet再将请求发送到Action 进行处理。 4、是否验证，需要验证则调用ActionForm 的validate方法，验证失败则跳转到input，成功则继续。 5、Action从ActionForm获得数据，调用javabean 中的业务方法处理数据。 6、Action返回ActionForward对象，跳转到相应JSP 页面或Action。 7、返回HTTP响应到客户端浏览器。 MVC设计模式：modal：“模型”也称业务逻辑，是正真完成任务的代码,相当与JavaBeanview：视图，其实就是显示界面，相当于JSPcontroller：控制器，他控制模型和视图的交互过程，相当于servletstruts1是基于MVC设计模式hibernate是基于ORM对象关系映射 5.struts是什么？ struts1是基于JSP和servlet的一个开源的Web应用框架，使用的是MVC的设计模式struts2是基于webwork技术的框架，是sun和webwork公司联手开发的一个功能非常齐全的框架，struts2和struts1没有任何关系，是一个全新的框架 6.spring是什么？ spring是一个集成了许多第三方框架的大杂烩，其核心技术是IOC（控制反转，也称依赖注
Java-常见spring面试题
1、什么是spring? Spring是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。 2、使用Spring框架的好处是什么？ 轻量：Spring是轻量的，基本的版本大约2MB。 控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。 面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。 容器：Spring包含并管理应用中对象的生命周期和配置。 MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。 事务管理：Spring提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。 异常处理：Spring提供方便的API把具体技术相关的异常（比如由JDBC，HibernateorJDO 抛出的）转化为一致的unchecked异常。 3、Spring由哪些模块组成? 以下是Spring框架的基本模块： Coremodule Beanmodule Contextmodule ExpressionLanguagemodule JDBCmodule ORMmodule OXMmodule JavaMessagingService(JMS)module Transactionmodule Webmodule Web-Servletmodule Web-Strutsmodule Web-Portletmodule 4、核心容器（应用上下文)模块。 这是基本的Spring模块，提供spring框架的基础功能，BeanFactory是任何以spring为基础
spring 面试题之-第二题 Exception Error区别
第二题 Exception 和 Error 有什么区别 笔记本：Java面试题 创建时间：2018/9/8 星期六 15:57更新时间：2018/9/9 星期日 19:24 作者：这个名字其实还是很长很长的 请对比Exception和Error,另外,运行时异常与一般异常有什么区别? 典型回答: Exception和Error都是继承了Throwable类,在Java中只有Throwable类型的实例才可以被抛出或者捕获,它是异常处理机制的基本组成类型。Exceptoin 和Error体现了Java平台设计者对于不同异常情况的分类。Exception是程序正常运行中,可以预料的意外情况,可以并且应该被捕获,进行相应处理。Error是指在正常情况下,不大可能出现的情况,绝大部分的Error都会导致处于非正常的不可恢复状态。既然是非正常情况,所以不便于也不需要捕获,常见的比如OutofMemoryError之类,都是Error的子类。 Exceptoin又分为可检查异常和不检查异常,可检查异常在代码里必须显示地进行捕获处理,这是编译器检查的一部分。不检查异常就是所谓的运行时异常,类似于NullPointerException ArrayIndexOutofBoundsException之类,通常是可以编码避免的逻辑错误,具体根据需要来进行判断是否需要捕获,并不会在编译期强制要求。 知识扩展: 在开发中尽量不要捕获类似Exceptio这样的通用异常,而是应该捕获特定异常.这是因为我们在日常的开发和合作中,我们读代码的机会往往超过写代码,软件工程是门协作的艺术,所以我们有义务让自己的代码能够直接地体现出尽量多的信息,而泛泛的Exception之类,恰恰隐藏了我们的目的。另外,我们也要保证程序不会捕获到我们不希望捕获的异常。比如,你可能更希望RuntimeException 被扩散出来,而不是被捕获。 在开发中不要生吞异常。这是异常处理中要特别注意的事情,因为很可能会导致非常难以诊断的诡异情况。生吞异常,往往是基于假设这段代码可能不会发生,或者感觉忽略异常是无所谓的,但是千万不要在产品代码做这种假设！如果我们不把异常抛出来,或者也没有输出日志之类,程序可能在后续代码以不可控的方式结束。没有人能够轻易判断究竟是哪里出了异常,以及是什么原因产生了异常。 在开发中不要输出标准错误（STERR）,因为有时候你很难判断出到底输出到哪里去了。尤其是分布式系统,如果发生异常,但是无法找到堆栈轨迹,这纯属是为诊断设置障碍。所以最好使用产品日志,详细地输出到日志系统里。 Throw early,catch late。在开发中可能会出现各种情况,比如获取配置失败之类的。在发现问题的时候,第一时间抛出,能够更加清晰地反映问题,这是Throw early。catch late就是我们经常烦恼的问题,捕获异常后,需要怎么处理?最差的方式,就是我们前面提到的"生吞异常",本质上就是掩盖问题。如果实在不知道如何处理,可以选择保留原有异常的cause 信息,直接再抛出或者构建
JAVA框架面试题汇总
1.SpringMVC Framework的理解： 1、它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件。并且和Spring提供的其他基础结构紧密集成 2、不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的) 3、可以任意使用各种视图技术,而不仅仅局限于JSP 4、支持各种请求资源的映射策略 5、它应是易于扩展的 2.简单的谈一下SpringMVC的工作流程？ 流程? 1、用户发送请求至前端控制器DispatcherServlet? 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。? 3、处理器映射器找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。? 4、DispatcherServlet调用HandlerAdapter处理器适配器? 5、HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。? 6、Controller执行完成返回ModelAndView? 7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet? 8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器? 9、ViewReslover解析后返回具体View? 10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。? 11、DispatcherServlet响应用户 3.如何解决POST请求中文乱码问题，GET的又如何处理呢？ 在web.xml中加入： .
2020年java程序员Spring所有面试题总结
1、Spring框架的好处？ 轻量 控制反转：spring通过控制反转实现了松散耦合，对象们给出他们的依赖而不是创建或查找依赖的对象们。 面向切面的编程：spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。 容器：spring包含并管理应用中对象的生命周期和配置 Mvc框架：spring的web框架是个很好的框架 事务管理：spring提供一个持续的事务管理接口，可以扩展到本地事务到全局事务 异常处理：spring提供方面的api把具体技术相关的异常转化为一致的unchecked 异常。 2、spring由哪些模块组成？ Spring core:框架最基础部分，提供ioc和依赖注入特性 Spring context：构建与core封装宝基础上的context封装包，提供了一种框架式的对象访问方法。 Spring dao：dao层提供了JDBC的抽象层 Spring aop：提供了面向切面的编程实现，可以自定义拦截器，切点等 Spring web：提供了针对web开发的集成特性，比如文件上传，利用servlet listeners进行ioc容器初始化和针对web的applicationcontext Spring web mvc：spring中mvc封装包提供了web应用的mvc实现 3、核心容器（应用上下文）模块？
基本的spring模块，提供spring框架的基础功能，beanfactory是任何以spring 为基础的应用的核心。Spring框架建立在此模块之上，它使spring称为一个容器。 4、beanfacotry-beanfactory实现举例？ Bean工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从真正的应用代码中分离。 最常用的beanFactory实现是xmlbeanFactory类 5、xmlbeanfacotry 最常用的beanfactory实现。它根据xml文件中的定义加载beans，从xml文件读取配置元数据并用它去创建一个完全配置的系统或应用。 6、解释aop模块 Aop模块用于发给我们的spring应用做面向切面的开发，很多支持有aop联盟提供，确保了spring和其他aop框架的共同性，这个模块将元数据编程引入spring 7、解释jdbc抽象和dao模块 通过使用jdbc抽象和dao模块，保证数据库代码的简洁，并能避免数据库资源错误关闭导致的问题，它在各种不同的数据库的错误信息之上提供了一个统一的异常访问层，还利用spring的aop模块给spring应用中的对象提供事务管理服务 8、解释对象关系映射集成模块 Spring通过提供ORM模块，支持我们在直接jdbc之上使用一个对象关系映射工具，spring支持集成主流的ORM框架，如hibernate、MyBatis等。Spring的
Spring面试题
一、spring工作原理： 1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。 2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller. 3.DispatcherServlet请请求提交到目标Controller 4.Controller进行业务逻辑处理后，会返回一个ModelAndView 5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 6.视图对象负责渲染返回给客户端。 二、为什么要用spring: AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务（比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词倒置所表明的，IOC 就像反过来的JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。 三、请你谈谈SSH整合： SSH： Struts（表示层）+Spring（业务层）+Hibernate（持久层） Struts： Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。 在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：
2019蚂蚁金服Java必问面试题及答案
一面 1、自我介绍、自己做的项目和技术领域 开放题 2、项目中的监控：那个监控指标常见的有哪些？ 答：CPU、内存、IO 等等。建议下载个nmon 工具，里面有各个指标。 数据库：Mysql （缓存命中、索引、单条SQL 性能、数据库线程数、数据池连接数） 中间件： 1.消息2、负载均衡 3 、缓存（包括线程数、连接数、日志）。 网络：吞吐量、吞吐率 应用：jvm 内存、日志、Full GC 频率 3、微服务涉及到的技术以及需要注意的问题有哪些？ 4、注册中心你了解了哪些？ 答：Consul 、Eureka 、ZooKeeper 5、consul 的可靠性你了解吗？ 6、consul 的机制你有没有具体深入过？有没有和其他的注册中心对比过？ 7、项目用Spring 比较多，有没有了解Spring 的原理？AOP 和IOC 的原
答：(1). IoC (Inversion of Control )是指容器控制程序对象之间的关系，而不 是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。对于Spring 而言，就是由Spring 来控制对象的生命周期和对象之间的关系；IoC 还有另外一个名字——“依赖注入(Dependency Injection )”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。(2) . 在Spring 的工作方式中，所有的类都会在spring 容器中登记，告诉spring 这是个什么东西，你需要什么东西，然后spring 会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由spring 来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring 。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring 控制，所以这叫控制反转。 (3) . 在系统运行中，动态的向某个对象提供它所需要的其他对象。 (4) . 依赖注入的思想是通过反射机制实现的，在实例化一个类时，它通过反射调用类中set 方法将事先保存在HashMap 中的类属性注入到类中。总而言之，在传统的对象创建方式中，通常由调用者来创建被调用者的实例，而在Spring 中创建被调用者的工作由Spring 来完成，然后注入调用者，即所谓的依赖注入or 控制反转。注入方式有两种：依赖注入和设置注入；IoC 的优点：降低了组件之间的耦合，降低了业务对象之间替换的复杂性，使之能够灵活的管AOP (Aspect Oriented Programming )
springMvc经典面试题
spring面试题 一、spring工作原理： 1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。 2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller. 3.DispatcherServlet请请求提交到目标Controller 4.Controller进行业务逻辑处理后，会返回一个ModelAndView 5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 6.视图对象负责渲染返回给客户端。 二、为什么要用spring: AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用AOP 后，公共服务（比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词倒置所表明的，IOC 就像反过来的JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring即使一个AOP框架，也是一IOC容器。Spring 最好的地方是它有助于您替换对象。有了Spring，只要用JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。 三、请你谈谈SSH整合： SSH： Struts（表示层）+Spring（业务层）+Hibernate（持久层） Struts： Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。 在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿
Java面试题整理大全-SpringMVC面试专题及答案
1、什么是SpringMvc？ 答：SpringMvc是spring的一个模块，基于MVC的一个框架，无需中间整合层来整合。2、Spring MVC的优点： 答： 1）它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java 组件.并且和Spring提供的其他基础结构紧密集成. 2）不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的) 3）可以任意使用各种视图技术,而不仅仅局限于JSP 4）支持各种请求资源的映射策略 5）它应是易于扩展的 3、SpringMVC工作原理？ 答： 1）客户端发送请求到DispatcherServlet 2）DispatcherServlet查询handlerMapping找到处理请求的Controller 3）Controller调用业务逻辑后，返回ModelAndView 4）DispatcherServlet查询ModelAndView，找到指定视图 5）视图将结果返回到客户端 4、SpringMVC流程？ 答： 1）用户发送请求至前端控制器DispatcherServlet。 2）DispatcherServlet收到请求调用HandlerMapping处理器映射器。 3）处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 4）DispatcherServlet调用HandlerAdapter处理器适配器。 5）HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。 6）Controller执行完成返回ModelAndView。
spring面试题
1.Spring框架的优点都有什么？ Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分 Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高依赖注入和IoC 使得JDBC操作简单化 Spring是开源的免费的 Spring使得对象管理集中化合简单化 2.描述一下Spring中实现DI（Dependency Injection）的几种方式 方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。 方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去 方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入Spring的方式 3.简述你对IoC（Inversion of Control）的理解 一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。 4.Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法。 在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。 5.请介绍一下Spring的事务管理 6.如何在Spring的applicationContext.xml里面使用JNDI而不是datasource? 可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：
【2020最新Java面试题资料】20道顶尖的Spring Boot面试题
面试了一些人，简历上都说自己熟悉Spring Boot, 或者说正在学习Spring Boot，一问他们时，都只停留在简单的使用阶段，很多东西都不清楚，也让我对面试者大失所望。 下面，我给大家总结下有哪些Spring Boot 的面试题，这是我经常拿来问面试者的，希望对你有帮助。 1、什么是Spring Boot？ Spring Boot 是Spring 开源组织下的子项目，是Spring 组件一站式解决方案，主要是简化了使用Spring 的难度，简省了繁重的配置，提供了各种启动器，开发者能快速上手。 Spring Boot 详细介绍请看这篇文章《什么是Spring Boot?》。 2、为什么要用Spring Boot？ Spring Boot 优点非常多，如： ?独立运行 ?简化配置 ?自动配置 ?无代码生成和XML配置 ?应用监控 ?上手容易
?... Spring Boot 集这么多优点于一身，还有理由不使用它呢？ 3Spring Boot 的核心配置文件有哪几个？它们的区别是什么？ Spring Boot 的核心配置文件是application 和bootstrap 配置文件。 application 配置文件这个容易理解，主要用于Spring Boot 项目的自动化配置。bootstrap 配置文件有以下几个应用场景。 ?使用Spring Cloud Config 配置中心时，这时需要在bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息； ?一些固定的不能被覆盖的属性； ?一些加密/解密的场景； 具体请看这篇文章《Spring Boot 核心配置文件详解》。 4Spring Boot 的配置文件有哪几种格式？它们有什么区别？ .properties 和.yml，它们的区别主要是书写格式不同。 1).properties https://www.sodocs.net/doc/1b9544161.html,=javastack
中兴公司Spring面试题库
中兴公司Spring面试题库 一、选择题（每题2分共20分） 1、关于spring说法错误的A.spring是一个轻量级JAVA EE的框架集合B.spring包含一个“依赖注入”模式的实现C.使用spring 可以实现声明事务D.spring提供了AOP方式的日志系统 2、依赖注入说法正确的A.依赖注入的目标是在代码之外管理程序组建间的依赖关系 B.依赖注入即是“面向接口”的编程 C.依赖注入是面向对象技术的替代品 D.依赖注入的使用会增大程序的规模 3、关于AOP错误的A. AOP将散落在系统中的“方面”代码集中实现B. AOP有助于提高系统可维护性C. AOP已经表现出将要替代面向对象的趋势D. AOP是一种设计模式，Spring提供了一种实现 4、关于spring AOP错误的A.首先要编写方面代码，实现MethodBeforeAdvice接口B.AOP采取拦截方法调用方式实现，可以在调用方法前，后，抛出异常时拦截C.AOP采取代理的方式实现，常用代理对象的类别为org.springframework.aop.framework.ProxyFactoryBean D.AOP 可以在对目标（target）不做任何修改的情况下增加程序功能 5、下面关于spring描述错误的是：（）
A. Spring支持可插入的事务管理器，使事务划分更轻松，同时无需处理底层的问题。 B. Spring事务管理的通用抽象层还包括JTA策略和一个JDBC DataSource。 C. 与JTA或EJB CMT一样，Spring的事务支持依赖于Java EE 环境。 D. Spring事务语义通过AOP应用于POJO通过XML或Java SE 5注释进行配置。 6、下面选项哪个不是Spring中接口注入的方式（） A .接口注入 B .构造子注入 C .设值注入 D .指针注入 7、下列关于Spring特性中IoC描述错误的是：（） A .IoC就是指程序之间的关系由程序代码直接操控。 B .所谓“控制反转”,是指控制权由应用代码转到外部容器，控制权的转移， C.IoC将控制创建的职责搬进了框架中；并把它从应用代码脱离开来 D .当使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC容器会根据XML配置数据提供给它。 8、下列说法错误的是：（） A．Spring的BeanFactory只能产生一个新的实例 B．Spring的BeanFactory可以产生一个的实例 C．Spring的BeanFactory可以产生两个的实例
spring mvc面试用参考题
SpringMvc面试题 2016-07-18 20:04 1117人阅读评论(0) 收藏举报 分类： f-sm-1. 讲下SpringMvc和Struts1,Struts2的比较的优势 f-sm-2. 讲下SpringMvc的核心入口类是什么,Struts1,Struts2的分别是什么 f-sm-3. SpringMvc的控制器是不是单例模式,如果是,有什么问题,怎么解决 f-sm-4. SpingMvc中的控制器的注解一般用那个,有没有别的注解可以替代 f-sm-5. @RequestMapping注解用在类上面有什么作用 emp/select.action dept/select.action 1、解决命名的冲突 2、便于拦截
f-sm-6. 怎么样把某个请求映射到特定的方法上面 f-sm-7. 如果在拦截请求中,我想拦截get方式提交的方法,怎么配置 f-sm-8. 如果在拦截请求中,我想拦截提交参数中包含"type=test"字符串,怎么配置 f-sm-9. 我想在拦截的方法里面得到从前台传入的参数,怎么得到 f-sm-10. 如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象 f-sm-11. 怎么样在方法里面得到Request,或者Session f-sm-12. SpringMvc中函数的返回值是什么. f-sm-13. SpringMvc怎么处理返回值的
f-sm-14. SpringMVC怎么样设定重定向和转发的 1、forward:request范围内的值还在，redirect: request范围内的值不存在 2、地址栏显示的地址不一样， 3、重定向可以定向项目外的地址 f-sm-15. SpringMvc用什么对象从后台向前台传递数据的 f-sm-16. SpringMvc中有个类把视图和数据都合并的一起的,叫什么 f-sm-17. 怎么样把ModelMap里面的数据放入Session里面 f-sm-18. SpringMvc怎么和AJAX相互调用的
spring面试题大全
* Spring的优点有什么? 1.Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分 2.Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高 3.依赖注入和IoC使得JDBC操作简单化 4.Spring是开源的免费的 5.Spring使得对象管理集中化合简单化 * 描述一下spring中实现DI（dependency injection）的几种方式 方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。 方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去 方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入 Spring的方式 * 简单描述下IOC(inversion of control)的理解 一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。 * Spring对很多ORM框架提供了很好支持，描述下在spring使用hibernate的方法 在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor * 请介绍下spring的事务管理 spring提供了几个关于事务处理的类： TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 一般事务定义步骤： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth
spring面试题
spring面试题 文章分类:Java编程 一、spring工作原理： 1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责对请求进行真正的处理工作。 2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller. 3.DispatcherServlet请请求提交到目标Controller 4.Controller进行业务逻辑处理后，会返回一个ModelAndView 5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 6.视图对象负责渲染返回给客户端。 二、为什么要用spring: AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务（比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。 IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词倒置所表明的，IOC 就像反过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。 Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。 三、请你谈谈SSH整合： SSH： Struts（表示层）+Spring（业务层）+Hibernate（持久层） Struts： Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。 在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action） Hibernate： Hibernate是一个持久层框架，它只负责与关系数据库的操作。
Spring面试题库
Spring面试题库 2、关于依赖注入说法正确的是（） A.依赖注入的目标是在代码之外管理程序组建间的依赖关系 B.依赖注入即是“面向接口”的编程 C.依赖注入是面向对象技术的替代品 D.依赖注入的使用会增大程序的规模 3、关于AOP错误的是（） A.AOP将散落在系统中的“方面”代码集中实现 B.AOP有助于提高系统可维护性 C.AOP已经表现出将要替代面向对象的趋势 D.AOP是一种设计模式，Spring提供了一种实现 4、关于spring AOP错误的是（） A.首先要编写方面代码，实现MethodBeforeAdvice接口 B.AOP采取拦截方法调用方式实现，可以在调用方法前，后，抛出异常时拦截 C.AOP采取代理的方式实现，常用代理对象的类别为org.springframework.aop.framework.ProxyFactoryBean D.AOP可以在对目标（target）不做任何修改的情况下增加程序功能 5、在Spring配置文件di.xml中包含下面的配置代码，可以推
断（）。（选1项） A.下列语句运行时无异常 ApplicationContext context=new ClassPathXmlApplicationContext(“di.xml”); A a=(A)content.getBean(“a”); B.A是抽象类 C.A是接口 D.类A中定义了getM()方法 6、关于Struts+Spring+Hibernate集成框架，下列说法正确的是（）。（选1项） A.使用SSH框架开发项目，由于增加了大量配置工作，从而会降低开发的效率 B.三个框架可以用多种方式进行集成 C.使用SSH框架开发不利于实现复杂的业务逻辑 D.使用SSH框架开发不利于构造复杂的页面和交互流程 7、对于Sping和Struts的集成，下列说法错误的是（）。（选1项） A.Action Bean的实例可以由Spring创建 B.在Struts配置文件中，Action Bean的配置可以如下所示： type= “org.springframework.web.struts.DelegatingActionProxy”>
Spring面试题
###1.Spring的aop你怎样实现? 用动态代理和cglib实现,有接口的用动态代理,无接口的用cglib ###2.Spring在SSH起什么作用 为大部分框架提供模版,常见的核心类提供初始化,并且整合三层框架 ###3.Spring容器内部怎么实现的 内部用Map实现,或者说HashMap ###4.怎么样理解IOC与AOP IOC是一种控制反转的思想,降低了对象的耦合度,AOP是面向切面编程,非侵入式编程,实现了非业务性编程(公共功能),譬如日志,权限,事务等等 ###5.Spring的事务，事务的作用。 Spring里面的事务分为编程式事务和声明式事务,一般用声明式事务,用来控制数据操作的完整性,一致性 ###6.Spring的IOC和AOP你在项目中是怎么使用的？ IOC主要来解决对象之间的依赖问题,把所有的bean的依赖关系通过配置文件或者注解关联起来,降低了耦合度,AOP一般用来整合框架时候都可以用得到, 事务用的最多,还有个别日志,权限功能也可以用到 ###7Spring主要使用了什么模式？ 工厂模式-->每个Bean的创建通过方法 单例模式-->默认的每个Bean的作用域都是单例 代理模式-->关于AOP的实现是通过代理,体现代理模式 ###8.Spring bean的作用域. Scope作用域有4种,常见的有单例或者多例,默认是单例 ###9.Spring的事务是如何配置的？ 1.先配置事务管理器TransactionManager,不同的框架有不同属性
2.再配置事务通知和属性,通过tx:advice 3.配置
相关文档
- 2020面试题总结Spring篇_一目斋
- Spring面试专题及答案
- 中兴公司Spring面试题库
- 个经典Spring面试题和答案
- springMVC基础面试题
- Java工程师面试题(三大框架)
- spring面试大全
- springMvc经典面试题
- Spring面试题
- Spring常见面试题总结
- Java面试题之spring真题解析
- 2020年java程序员Spring所有面试题总结
- 【黑马程序员】关于spring的面试和笔试题(一)
- spring mvc面试用参考题
- Spring面试题和答案
- java常见面试题及三大框架面试
- spring面试题大全
- 2019蚂蚁金服Java必问面试题及答案
- spring面试题
- spring面试题