开源框架专栏
1.TOMCAT性能优化整理
2.JVM性能优化整理
3.MYSQL性能优化整理
4.并发编程整理(1)
5.并发编程整理(2)
6.spring整理(1)
7.spring整理(2)
文章目录
- 开源框架专栏
- spring
- 1、什么是Spring 框架?Spring框架有哪些主要模块?
- 2、使用Spring框架能带来哪些好处?
- 3、什么是控制反转(IOC)?什么是依赖注入?
- 4、请解释下Spring框架中的lOC?
- 5、BeanFactory 和ApplicationContext有什么区别?
- 6、Spring 有几种配置方式?
- 7、如何用基于XML配置的方式配置Spring?
- 8、如何用基于Java配置的方式配置Spring?
- 9、怎样用注解的方式配置Spring?
- 10、请解释Spring Bean的生命周期?
- 11、Spring Bean的作用域之间有什么区别?
- 12、什么是Spring inner beans?
- 13、Spring 框架中的单例Beans是线程安全的么?
- 14、请举例说明如何在Spring中注入一个Java Collection?
- 15、如何向Spring Bean中注入一个Java.util.Properties?
- 16、请解释Spring Bean的自动装配?
- 17、请解释自动装配模式的区别?
- 18、如何开启基于注解的自动装配?
- 19、请举例解释@Required 注解?
- 20、请举例解释@Autowired注解?
- 21、请举例说明@Qualifier注解?
- 22、构造方法注入和设值注入有什么区别?请注意以下明显的区别:
spring
1、什么是Spring 框架?Spring框架有哪些主要模块?
Spring框架是一个为 Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring 帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境
中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。Spring框架至今已集成了20多个模块。这些模块主要被分为核心容器、数据访问/集成、Web、AOP(面向切面编程)、 工具、消息和测试模块。
2、使用Spring框架能带来哪些好处?
下面列举了-些使用Spring框架带来的主要好处:
- Dependency Injection(DI)方法使得构造器和JavaBean properties文件中的依赖关系一目了然。
- 与EJB容器相比较,lOC容器更加趋向于轻量级。这样一来lOC容器在有限的内存和CPU资源的情况下进行应用程序的开发和发布就变得十分有利。
- Spring并没有闭门造车,Spring 利用了已有的技术比如ORM框架、logging框架、J2EE、 Quartz和JDK Timer,以及其他视图技术。
- Spring框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块,开发者仅仅需要选用他们需要的模块即可。
- 要测试一项用Spring开发的应用程序十分简单,因为测试相关的环境代码都已经囊括在框架中了。更加简单的是,利用JavaBean形式的POJO类,可以很方便的利用依赖注入来写入测试数据。
- Spring的Web框架亦是一个精心设计的Web
MVC框架,为开发者们在web框架的选择上提供了一个除了主流框架比如Struts、过度设计的、不流行web框架的以外的有力选项。 - Spring提供了一个便捷的事务管理接口,适用于小型的本地事物处理(比如在单DB的环境下)和复杂的共同事物处理(此如利用JTA的复杂DB环境)。
3、什么是控制反转(IOC)?什么是依赖注入?
控制反转是应用于软件工程领域中的,在运行时被装配器对象来绑定耦合对象的一种编程技巧,对象之间耦合关系在编译时通常是未知的。在传统的编程方式中,业务逻辑的流程是由应用程序中的早已被设定好关联关系的对象来决定的。在使用控制反转的情况下,业务逻辑的流程是由对象关系图来决定的,该对象关系图由装配器负责实例化,这种实现方式还可以将对象之间的关联关系的定义抽象化。而绑定的过程是通过“依赖注入“实现的。
控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式,并在我们的实际工作中起到了有效的作用。依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下,将其他对象所依赖的功能对象实例化的模式。这就需要一种机制用来激活相应的组件以提供特定的功能,所以依赖注入是控制反转的基础。否则如果在组件不受框架控制的情况下,框架又怎么知道要创建哪个组件?
在Java中依然注入有以下三种实现方式:
- 构造器注入
- Setter方法注入
- 接口注入
4、请解释下Spring框架中的lOC?
Spring 中的org.springframework.beans包和org.springlramework.context包构成了Spring 框架lOC容器的基础。
BeanFactory接口提供了一个先进的配置机制,使得任何类型的对象的配置成为可能。ApplicationContex 接口对BeanFactory(是一个子接口)进行了扩展,在BeanFactory的基础上添加了其他功能,比如与Spring的AOP更容易集成,也提供了处理message resource的机制用于国际化)、事件传播以及应用层的特别配置,比如针对Web应用的WebApplicationContext.
org.springframework.beans.factory.BeanFactory 是Spring loC容器的具体实现,用来包装和管理前面提到的各种bean。BeanFactory 接口是SpringloC容器的核心接口
IoC:把对象的创建、初始化、销毁交给spring 来管理,而不是由开发者控制,实现控制反转。
5、BeanFactory 和ApplicationContext有什么区别?
BeanFactory可以理解为含有bean集合的工厂类。BeanFactory 包含了种bean的定义,以便在接收到客户端请求时将对应的bean实例化。
BeanFactory还能在实例化对象的时生成协作类之间的关系。此举将bean自身与bean客户端的配置中解放出来。BeanFactory 还包含了bean生命周期的控制,调用客户端的初始化方法(nitialization methods)和销毁方法(destruction methods)。
从表面上看,application context如同beanfactory一样具有bean定义、bean关联关系的设置,根据请求分发bean的功能。但applicationcontext在此基础上还提供了其他的功能。
- 提供了支持国际化的文本消息
- 统一的资源文件读取方式
- 已在监听器中注册的bean的事件
以下是三种较常见的ApplicationContext实现方式:
1. ClassPathXmlApplicationContext:从 classpath的XML配置文件中读取
上下文并生成上下文定义, 应用程序上下文从程序变量中
ApplicationContext context = new ClassPathXmlApplicationContext(“bean.xml”);
- 从 FilSystemXmlApplicationContext :有文件系统中的xml配置文件读取上下文。
ApplicationContext context = new FileSystemXmlApplicationContext(“bean.xml”);
- XmlWebApplicationContext:由web应用的xml文件读取上下文。
AnnotationConfigApplicationContext( 基于java配置启动容器)
6、Spring 有几种配置方式?
将Spring配置到应用开发中有以下三种方式:
- 基于XML的配置
- 基于注解的配置
- 基于Java的配置
7、如何用基于XML配置的方式配置Spring?
在Spring框架中,依赖和服务需要在专门的配置文件来实现,我常用的XML格式的配置文件。这些配置文件的格式通常用 开头,然后一系列的bean定义和专门的应用配置选项组成。SpringXML配置的主要目的时候是使所有的Spring组件都可以用xml文
件的形式来进行配置。这意味着不会出现其他的Spring配置类型(此如声明的方式或基于Java Class的配置方式)Spring的XML配置方式是使用被Spring命名空间的所支持的一系列的XML标签来实现的。Spring 有以下主要的命名空间:context、beans、jdbc、tx、 aop、mvc 和aso。如:
8、如何用基于Java配置的方式配置Spring?
spring对Java配置的支持是由@Configuration注解和@Bean注解来实现的。由@Bean注解的方法将会实例化、配置和初始化-个新对象,这个对象将由Spring的loC容器来管理。@Bean 声明所起到的作用与元素类似。被@Configuration所注解的类则表示这个类的主要目的是作为bean定义的资源。被@Configuration声明的类可以通过在同一个类的内部调用@bean方法来设置嵌入bean的依赖关系。
最简单的@Configuration声明类请参考下面的代码:
@Configuration
public class Appconfig{
@Bean
public Myservice getMyservice(){
return new MyserviceImpl();
}
}
对于上面@Bean配置文件相同的XML配置文件如下:
<beans>
<bean id="myService" class="com.somnus.services.MyServiceImpl"/>
</beans>
上述配置方式的实例化方式如下:利用annotationConfigApplicationContext类进行实例化
public static void main(String args[]){
ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
MyService myservice = ctx.getBean(MyService.class);
myservice.doStuff();
}
要使用组件组建扫描,仅需要@Configuration进行注解即可:
@Configuration
@ComponentScan(basePackages="com.somus")
public class AppConfig{
....
}
在上面的例子上,com.somus包首先会被扫描到,然后容器再查找呗@ComponentScan声明的类,找到这些类之后按照spring bean定义进行注册。
如果你要在你的web应用程序开发中选择上述的配置方式,需要用AnnotationConfigApplicationContext类来读取配置文件,可以用来配置spring的servlet监听器ContextLoaderListener或者spring mvc的 DispatcherServlet;
<web-app>
<!-- Configure ContextLoaderListener to use
AnnotationConfigWebApplicationContext
instead of the default XmlWebApplicationContext -->
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
</param-value>
</context-param>
<!-- Configuration locations must consist of one or more comma or space-delimited fully-qualified @Configuration classes. Fully-qualified packages may also be specified for component-scanning -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.howtodoinjava.AppConfig</param-value>
</context-param>
<!-- Bootstrap the root application context as usual using
ContextLoaderListener -->
<web-app>
<!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
<context-param>
<param-name>contextClass</param-name>
<param-value>
org.springframework.web.context.support.AnnotationConfigWebApp
licatio
nContext
</param-value>
</context-param>
<!-- Configuration locations must consist of one or more comma
- or space-delimited fully-qualified @Configuration classes. Fully-qualified packages may also be specified for component-scanning -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.howtodoinjava.AppConfig</param-value>
</context-param>
<!-- Bootstrap the root application context as usual using
ContextLoaderListener -->
9、怎样用注解的方式配置Spring?
Spring在2.5版本以后开始支持用注解的方式来配置依赖注入。可以用注解的方式来替代XML方式的bean描述,可以将bean描述转移到组件类的内部,只需要在相关类上、方法上或者字段声明上使用注解即可。注解注入将会被容器在XML注入之前被处理,所以后者会覆盖掉前者对于同一个属性的处理结果。注解装配在Spring中是默认关闭的。所以需要在Spring文件中配置一下
才能使用基于注解的装配模式。如果你想要在你的应用程序中使用关于注解的方法的话,请参考如下的配置。
<beans>
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>
在<context: annotation-config/>标签配置完成以后,就可以用注解的方式在Spring中向属性、方法和构造方法中自动装配变量。
下面是几种比较重要的注解类型:
- @Required:该注解应用于设值方法。
- @Autowired:该注解应用于有值设值方法、非设值方法、构造方法和变量。
- @Qualifier:该注解和@Autowired注解搭配使用,用于消除特定bean自动装配的歧义。
- JSR-250 Annotations:Spring支持基于JSR-250注解的以下注解,
@Resource、@PostConstruct 和@PreDestroy.
10、请解释Spring Bean的生命周期?
Spring Bean的生命周期简单易懂。在一个bean实例被初始化时,需要执行一系列的初始化操作以达到可用的状态。同样的,当一个bean不在被调用时需要进行相关的析构操作,并从bean容器中移除。Spring beanfactory负责管理在spring容器中被创建的bean的生命周期。Bean 的生命周期由两组回调(call back)方法组成。
- 初始化之后调用的回调方法。
- 销毁之前调用的回调方法。
Spring框架提供了以下四种方式来管理bean的生命周期事件:
- InitializingBean和DisposableBean回调接口
- 针对特殊行为的其他Aware接口
- Bean配置文件中的Custom init()方法和destroy0方法
- @PostConstruct和@PreDestroy注解方式
使用customlnit()和customDestroy()方法管理bean生命周期的代码样例如下:
<beans>
<bean id="demoBean" class="com.somnus.task.DemoBean" init-method="customInit" destroy-method="customDestroy"></bean>
</beans>
11、Spring Bean的作用域之间有什么区别?
Spring容器中的bean可以分为5个范围。所有范围的名称都是自说明
的,但是为了避免混淆,还是让我们来解释一下:
- singleton:这种bean范围是默认的,这种范围确保不管接受到多少个请求,每个容器中只有一个bean的实例,单例的模式由bean factory自身来维护。
- prototype:原形范围与单例范围相反,为每一个bean请求提供一个实例。
- request:在请求bean范围内会每一个来自客户端的网络请求创建一个实例,在请求完成以后,bean 会失效并被垃圾回收器回收。
- Session:与请求范围类似,确保每个session中有一个bean的实例,在session过期后,bean 会随之失效。
- global- session:global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时,它包含很多portlet。 如果你想要声明让所有的portlet共用全局的存储变量的话,那么这全局变量需要存储在global-session中。
全局作用域与Servlet 中的session作用域效果相同。
12、什么是Spring inner beans?
在Spring框架中,无论何时bean被使用时,当仅被调用了一个属性。一个明智的做法是将这个bean声明为内部bean。内部bean可以用setter注入“属性"和构造方法注入“构造参数”的方式来实现。
比如,在我们的应用程序中,一个Customer类引用了一个Person类,我们的要做的是创建一个Person的实例,然后在Customer内部使用。
public class Customer{
private Person person;
//Setters and Getters
}
public class Person{
private String name;
private String address;
private int age;
//Setters and Getters
}
内部bean的声明方式如下:
<bean id="CustomerBean" class="com.somnus.common.Customer">
<property name="person">
<!-- This is inner bean -->
<bean class="com.howtodoinjava.common.Person">
<property name="name" value="lokesh" />
<property name="address" value="India" />
<property name="age" value="34" />
</bean>
</property>
</bean>
13、Spring 框架中的单例Beans是线程安全的么?
Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上,大部分的Spring bean并没有可变的状态(此如Serview类和DAO类),所以在某种程度.上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话(此如View Model对象),就需要自行保证线程安全。
最浅显的解决办法就是将多态bean的作用域由"singleton"变更为"prototype”。
14、请举例说明如何在Spring中注入一个Java Collection?
Spring提供了以下四种集合类的配置元素:
<list> :该标签用来装配可重复的list 值。
<set>:该标签用来装配没有重复的set值。
<map>:该标签可用来注入键和值可以为任何类型的键值对。
<props> :该标签支持注入键和值都是字符串类型的键值对。
下面看一下具体的例子:
<beans>
<!-- Definition for javaCollection -->
<bean id="javaCollection" class="com.howtodoinjava.JavaCollect
ion">
<!-- java.util.List -->
<property name="customList">
<list>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>UK</value>
</list>
</property>
<!-- java.util.Set -->
<property name="customSet">
<set>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>UK</value>
</set>
</property>
<!-- java.util.Map -->
<property name="customMap">
<map>
<entry key="1" value="INDIA"/>
<entry key="2" value="Pakistan"/>
<entry key="3" value="USA"/>
<entry key="4" value="UK"/>
</map>
</property>
<!-- java.util.Properties -->
<property name="customProperies">
<props>
<prop key="admin">admin@nospam.com</prop>
<prop key="support">support@nospam.com</prop>
</props>
</property>
</bean>
</beans>
15、如何向Spring Bean中注入一个Java.util.Properties?
第一种方法是使用如”下面代码所示的标签:
<bean id=" adminUser" C lass=" com. somnus. common。Cust omer'">
<!-- java.util.Properties -->
<property name="emails">
<props>
<prop key="admin"> adminanos@pam.com</prop>
<prop key="support">support@nospam.com</prop>
</props>
</property>
</bean>
也可用"util:”命名空间来从properties文件中创建出一个propertiesbean,然后利用setter方法注入bean的引用。
16、请解释Spring Bean的自动装配?
在Spring框架中,在配置文件中设定bean的依赖关系是一个很好的机制,Spring 容器还可以自动装配合作关系bean之间的关联关系。这意味着Spring可以通过向Bean Factory中注入的方式自动搞定bean之间的依赖关系。自动装配可以设置在每个bean上,也可以设定在特定的bean上。
下面的XML配置文件表明了如何根据名称将一个bean设置为自动装配:
<bean id="employeeDAO" class="com.howtodoinjava.EmployeeDAOImpl" autowire="byName" />
除了bean配置文件中提供的自动装配模式,还可以使用@Autowired注解来自动装配指定的bean。在使用@Autowired注解之前需要在按照如下的配置方式在Spring配置文件进行配置才可以使用。
<context:annotation-config />
也可以通过在配置文件中配置AutowiredAnnotationBeanPostProcessor达到相同的效果。
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
配置好以后就可以使用@Autowired来标注了。
@Autowired
public EmployeeDAOImpl (EmployeeManager manager){
this.manager = manager ;
}
17、请解释自动装配模式的区别?
在Spring框架中共有5种自动装配,让我们逐一分析。
- no:这是Spring框架的默认设置,在该设置下自动装配是关闭的,开发者需要自行在bean定义中用标签明确的设置依赖关系。
- byName:该选项可以根据bean名称设置依赖关系。当向一个bean中自动装配一个属性时,容器将根据bean的名称自动在在配置文件中查询一个匹配的bean。如果找到的话,就装配这个属性,如果没找到的话就报错。
- byType:该选项可以根据bean类型设置依赖关系。当向-个bean中自动装配一个属性时,容器将根据bean的类型自动在在配置文件中查询一个匹配的bean。如果找到的话,就装配这个属性,如果没找到的话就报错。
- constructor:造器的自动装配和byType模式类似,但是仅仅适用于与有构造器相同参数的bean,如果在容器中没有找到与构造器参数类型-致的bean,那么将会抛出异常。
- autodetect:该模式自动探测使用构造器自动装配或者byType自动装配。首先,首先会尝试找合适的带参数的构造器,如果找到的话就是用构造器自动装配,如果在bean内部没有找到相应的构造器或者是无参构造器,容器就会自动选择byTpe的自动装配方式。
18、如何开启基于注解的自动装配?
要使用@Autowired,需要注册AutowiredAnnotationBeanPostProcessor,可以.
有以下两种方式来实现: .
1、引入配置文件中的< bean>下引入 <context: annotation-config>
<beans>
<context:annotation-config />
</beans>
2、在 bean 配置文件中直接引入AutowiredAnnotationBeanPostProcessor
<beans>
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
</beans>
19、请举例解释@Required 注解?
在产品级别的应用中,loC 容器可能声明了数十万了bean, bean 与bean之间有着复杂的依赖关系。设值注解方法的短板之一就是验证所有的属性是否被注解是-项十分困难的操作。可以通过在 < bean> 中设置"dependency-check"来解决这个问题。在应用程序的生命周期中,你可能不大愿意花时间在验证所有bean的属性是否按照上下文件正确配置。或者你宁可验证某个bean的特定属性是否被正确的设置。即使是用"dependency- check’属性也不能很好的解决这个问题,在这种情况下,你需要使用@Required注解。
需要用如下的方式使用来标明bean的设值方法。
public class EmployeeFactoryBean extends AbstractFactoryBean<Object>{
private String designation;
public String getDesignation() {
return designation;
}
@Required
public void setDesignation(String designation) {
this.designation = designation;
}
//more code here
}
RequiredAnnotationBeanPostProcessor是Spring中的后置处理用来验证被@Required注解的bean属性是否被正确的设置了。在使用.RequiredAnnotationBeanPostProcesso来验证bean属性之前,首先要在loC容器中对其进行注册:
<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
但是如果没有属性被用@Required注解过的话,后置处理器会抛出一个BeanitializationException异常。
20、请举例解释@Autowired注解?
@Autowired注解对自动装配何时何处被实现提供了更多细粒度的控制。
@Autowired注解可以像@Required注解、构造器一样被用于在 bean的设值方法上自动装配bean的属性,一个 参数或者带有任意名称或带有多个参数的方法。比如,可以在设值方法上使用@Autowired注解来替代配置
文件中的 <property>
元素。当Spring容器在setter 方法上找到@Autowired注解时,会尝试用byType自动装配。
当然我们也可以在构造方法上使用@Autowired注解。带有@Autowired注解的构造方法意味着在创建一个bean时将会被自动装配,即便在配置文件中使用元素。
public class TextEditor {
private SpellChecker spellChecker;
@Autowired
public TextEditor(SpellChecker spellChecker){
System.out.println("Inside TextEditor constructor." );
this.spellChecker = spellChecker;
}
public void spellCheck(){
spellChecker.checkSpelling();
}
}
下面是没有构造参数的配置方式:
<beans>
<context:annotation-config/>
<!-- Definition for textEditor bean without constructor-arg-->
<bean id="textEditor" class="com.howtodoinjava.TextEditor"/>
<!-- Definition for spellChecker bean -->
<bean id="spellChecker" class="com.howtodoinjava.SpellChecker"/>
</beans>
21、请举例说明@Qualifier注解?
@Qualifer注解意味着可以在被标注bean的字段上可以自动装配。
Qualifier注解可以用来取消Spring不能取消的bean应用。
下面的示例将会在Customer的person属性中自动装配person的值。
public class Customer{
@Autowired
private Person person;
}
下面我们要在配置文件中来配置Person类。
<bean id="customer" class="com.somnus.common.Customer" />
<bean id="personA" class="com.somnus.common.Person" >
<property name="name" value="lokesh" />
</bean>
<bean id="personB" class="com.somnus.common.Person" >
<property name="name" value="alex" />
</bean>
Spring会知道要自动装配哪个person bean么?不会的,但是运行上面的示例时,会抛出下面的异常:
Caused by:
org.springframework.beans.factory.NoSuchBeanDefinitionException:
No unique bean of type [com.howtodoinjava.common.Person] is de
fined: expected single matching bean but found 2: [personA, pe
rsonB]
要解决.上面的问题,需要使用@Quanlifier 注解来告诉Spring容器要装配哪个bean:
public class Customer{
@Autowired
@Qualifier("personA")
private Person person;
}
22、构造方法注入和设值注入有什么区别?请注意以下明显的区别:
- 在设值注入方法支持大部分的依赖注入,如果我们仅需要注入int. string和long型的变量,我们不要用设值的方法注入。对于基本类型,如果我们没有注入的话,可以为基本类型设置默认值。在构造方法注入不支持大部分的依赖注入,因为在调用构造方法中必须传入正确的构造参数,否则的话为报错。
- 设值注入不会重写构造方法的值。如果我们对同- -个变量同时使用了构造方法注入又使用了设置方法注入的话,那么构造方法将不能覆盖由设值方法注入的值。很明显,因为构造方法尽在对象被创建时调用。
- 在使用设值注入时有可能还不能保证某种依赖是否已经被注入,也就是说这时对象的依赖关系有可能是不完整的。而在另-种情况下,构造器注入则不允许生成依赖关系不完整的对象。
- 在设值注入时如果对象A和对象B互相依赖,在创建对象A时Spring会抛出sObjectCurrentlyInCreationException异常,因为在B对象被创建之前A对象是不能被创建的,反之亦然。所以Spring用设值注入的方法解决了循环依赖的问题,因对象的设值方法是在对象被创建之前被调用的。