- 浏览: 57592 次
- 来自: 北京
最新评论
-
泛泛evil:
总结的很好,谢谢分享
JavaScript -
wanxkl:
哇!总结的太好了。。凤哥哥,你好强大啊。。请问您跟凤姐什么关系 ...
css应用
c) 第三方缓存的实现
Hibernate的查询方式
Sql、Criteria,object comptosition
Hql:
* 属性查询
* 参数查询、命名参数查询
* 关联查询
* 分页查询
* 统计函数
如何优化Hibernate?
* 使用双向一对多关联,不使用单向一对多
* 灵活使用单向一对多关联
* 不用一对一,用多对一取代
* 配置对象缓存,不使用集合缓存
* 一对多集合使用Bag,多对多集合使用Set
* 继承类使用显式多态
* 表字段要少,表关联不要怕多,有二级缓存撑腰
Struts工作机制?为什么要使用Struts?
工作机制:
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.
(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;
(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;
为什么要用:
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱,所以在此之上,我们需要一个规则、一个把这些技术组织起来的规则,这就是框架,Struts便应运而生。
基于Struts开发的应用由3类组件构成:控制器组件、模型组件、视图组件
Struts的validate框架是如何验证的?
在struts配置文件中配置具体的错误提示,再在FormBean中的validate()方法具体调用。
说下Struts的设计模式
MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时,一个配置好的ActionForm对象被创建,并被填入表单相应的数据,ActionServler根据Struts-config.xml 文件配置好的设置决定是否需要表单验证,如果需要就调用ActionForm的Validate()验证后选择将请求发送到哪个Action,如果 Action不存在,ActionServlet会先创建这个对象,然后调用Action的execute()方法。Execute()从 ActionForm对象中获取数据,完成业务逻辑,返回一个ActionForward对象,ActionServlet再把客户请求转发给 ActionForward对象指定的jsp组件,ActionForward对象指定的jsp生成动态的网页,返回给客户。
单例模式
Factory(工厂模式):
定义一个基类===》实现基类方法(子类通过不同的方法)===》定义一个工厂类(生成子类实例)
===》开发人员调用基类方法
Proxy(代理模式)
spring工作机制及为什么要用?
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后,会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。
为什么用:
AOP 让开发人员可以创建非行为性的关注点,称为横切关注点,并将它们插入到应用程序代码中。使用 AOP 后,公共服务 (比 如日志、持久性、事务等)就可以分解成方面并应用到域对象上,同时不会增加域对象的对象模型的复杂性。
IOC 允许创建一个可以构造对象的应用环境,然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的,IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素(singleton)和直接构造(straight construction),每一个对象都是用 其协作对象构造的。因此是由容器管理协作对象(collaborator)。
Spring即使一个AOP框架,也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring,只要用 JavaBean 属性和配置文件加入依赖性(协作对象)。然后可以很容易地在需要时替换具有类似接口的协作对象。
* 一些spring与hibernate的面试题
52、 简述你对IoC(Inversion of Control)的理解,描述一下Spring中实现DI(Dependency Injection)的几种方式。
答:IoC将创建的职责从应用程序代码搬到了框架中。Spring对Setter注入和构造方法注入提供支持。(详见http://martinfowler.com/articles/injection.html,以及http: //www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators)
53、 Spring的Bean有多种作用域,包括:
singleton、prototype、request、session、global session、application、自定义
54、 简单描述Spring framework与Struts的不同之处,整合Spring与Struts有哪些方法,哪种最好,为什么?
Spring是完整的一站式框架,而Struts仅是MVC框架,且着重于MVC中的C。Spring有三种方式整合Struts:使用 Spring 的 ActionSupport 类整合 Struts;使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor;将 Struts Action 管理委托给 Spring 框架,动作委托最好。(详见使用Spring 更好地处理Struts 动作)
Spring 2.0新增一种方式:AutowiringRequestProcessor。
55、 Hibernate中的update()和saveOrUpdate()的区别
saveOrUpdate()方法可以实现update()的功能,但会多些步骤,具体如下:
如果对象在该session中已经被持久化,不进行操作;
对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值,调用save()方法保存它;
如果session中的另一个对象有相同的标识符抛出一个异常;
以上皆不符合则调用update()更新之。
56、spring对多种ORM框架提供了很好的支持,简单描述在Spring中使用Hibernate的方法,并结合事务管理。
在context中定义DataSource,创建SessionFactoy,设置参数;DAO类继承HibernateDaoSupport,实现具体接口,从中获得HibernateTemplate进行具体操作。
在使用中如果遇到OpenSessionInView的问题,可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。(详见Spring framework 2.0 Reference的12.2节Hibernate)
声明式事务需声明事务管理器,在context中设置指定属性,用确定和。
57* 在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..
}
配置文件:
<bean id=”jdbcTemplate” class=”org.springframework.jdbc.core.JdbcTemplate”>
<property name=”dataSource”>
<ref bean=”dataSource”/>
</property>
</bean>
<bean id=”studentDao” class=”StudentDaoJdbc”>
<property name=”jdbcTemplate”>
<ref bean=”jdbcTemplate”/>
</property>
</bean>
<bean id=”courseDao” class=”CourseDaoJdbc”>
<property name=”jdbcTemplate”>
<ref bean=”jdbcTemplate”/>
</property>
</bean>
58* 在spring如何创建一个数据连接池
<bean id=”dataSource” class=”org.apache.commons.dbcp.BasicDataSource”>
<property name=”driver”>
<value>${db.driver}</value>
</property>
<property name=”url”>
<value>${db.url}</value>
</property>
<property name=”username”>
<value>${db.username}</value>
</property>
<property name=”password”>
<value>${db.password}</value>
</property>
</bean>
59* 在spring中如何配置一个bean来从JNDI到dataSource
<bean id=”dataSource” class=”org.springframework.jndi.JndiObjectFactoryBean”>
<property name=”jndiName”> <value>java:comp/env/jdbc/myDatasource</value>
</property>
</bean>
60* 请介绍下spring中bean的作用域
在spring2.0之前bean只有2种作用域即:singleton(单例)、non-singleton(也称 prototype),Spring2.0以后,增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此,默认情况下Spring2.0现在有五种类型的Bean。
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”singleton”/>
这里的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。
配置实例:
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”singleton”/>
或者
<bean id=”role” class=”spring.chapter2.maryGame.Role” singleton=”true”/>
2、prototype
prototype作用域部署的bean,每一次请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)都会产生一个新的bean实例,相当于一个new的操作,对于prototype作用域的bean,有一点非常重要,那就是Spring不能对一个 prototype bean的整个生命周期负责,容器在初始化、配置、装饰或者是装配完一个prototype实例后,将它交给客户端,随后就对该prototype实例不闻不问了。不管何种作用域,容器都会调用所有对象的初始化生命周期回调方法,而对prototype而言,任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源,都是客户端代码的职责。(让Spring容器释放被singleton作用域bean占用资源的一种可行方式是,通过使用 bean的后置处理器,该处理器持有要被清除的bean的引用。)
配置实例:
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”prototype”/>
或者
<beanid=”role” class=”spring.chapter2.maryGame.Role” singleton=”false”/>
3、request
request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效,配置实例:
request、session、global session使用的时候,首先要在初始化web的web.xml中做如下配置:
如果你使用的是Servlet 2.4及以上的web容器,那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可:
<web-app>
…
<listener>
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
</listener>
…
</web-app>
如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现:
<web-app>
..
<filter>
<filter-name>requestContextFilter</filter-name>
<filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>requestContextFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
…
</web-app>
接着既可以配置bean的作用域了:
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”request”/>
4、session
session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP session内有效,配置实例:
配置实例:
和request配置实例的前提一样,配置好web启动文件就可以如下配置:
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”session”/>
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启动文件就可以如下配置:
<bean id=”role” class=”spring.chapter2.maryGame.Role” scope=”global session”/>
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 initialValue() …{
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;
}
}
61* 请介绍 一下spring的bean的生命周期
一、Bean的定义
Spring通常通过配置文件定义Bean。如:
<?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-2.0.xsd”>
<bean id=”HelloWorld” class=”com.pqf.beans.HelloWorld”>
<property name=”msg”>
<value>HelloWorld</value>
</property>
</bean>
</beans>
这个配置文件就定义了一个标识为 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属性:
<bean id=”HelloWorld” class=”com.pqf.beans.HelloWorld” init-mothod=”init” >
</bean>
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”);
HelloWorld 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方法。
62* 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);
63* 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
64* 使用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框架的部分或全部
65* 什么是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也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。
66. spring与ejb的事务管理比较的优缺点?
测试:
Spring:pojo
Ejb:二个接口一个类,一堆配置文件
事务类型
Spring:jdbc jta hibernate
Ejb:jta
成本
Spring:普通容器(tomcat jboss)
Ejb:weblogic jboss
开发的周期:
Spring远比ejb快.
67. spring的jdbc与传统的jdbc有什么区别,其核心类有那些?
Spring的jdbc:节省代码
JdbcTemplate(增、删、改、查)
68. 在spring中有几种事务管理,分别是什么?
代码管理的事务处理
容器管理的事务处理
69. 在spring中如何配代码的事务管理?
Datasouce transactionManager
userDao要注入
Datasouce
transactionManager
代码的事务管理在代码中怎样写?
通过如下类实现
TransactionTemplate
JdbcTemplate
70. spring工作机制
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后,会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。
71.spring为什么用:
{AOP 让开发人员可以创建非行为性的关注点,称为横切关注点,并将它们插入到应用程序代码中。使用 AOP 后,公共服务 (比 如日志、持久性、事务等)就可以分解成方面并应用到域对象上,同时不会增加域对象的对象模型的复杂性。
IOC 允许创建一个可以构造对象的应用环境,然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的,IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素(singleton)和直接构造(straight construction),每一个对象都是用其协作对象构造的。因此是由容器管理协作对象(collaborator)。
Spring即使一个AOP框架,也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring,只要用 JavaBean 属性和配置文件加入依赖性(协作对象)。然后可以很容易地在需要时替换具有类似接口的协作对象。}
72、Spring对多种ORM框架提供了很好的支持,简单描述在Spring中使用Hibernate的方法,并结合事务管理。
在context中定义DataSource,创建SessionFactoy,设置参数;DAO类继承HibernateDaoSupport,实现具体接口,从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题,可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。(声明式事务需声明事务管理器,在context中设置<tx:advice>指定属性,用<aop:config>确定<aop:advisor>和<aop:pointcut>。
73、Jsf和spring的区别? 70
是一种基于MVC模式的一个web层的处理,粒度较struts较细。
Spring:提供了通用的服务,ioc/di aop,关心的不仅仅web层,应当j2ee整体的一个服务,可以很容易融合不同的技术struts hibernate ibatis ejb remote springJDBC springMVC
74、ApplicationContext的作用
beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理
75、如何实现资源管理
使用
applicationContext.getResource(“classpath:文件名”):在src根目录下,在类路径下
applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目录下的基准往下走。
applicationContext.getResource(“file:c:/a.properties”):在系统文件目录下。
76、spring的配置的主要标签是什么?有什么作用?
<beans>
<bean id=”” class=”” init=”” destroy=”” singleton=””>
<property name=””>
<value></value>
</property>
<property name=””>
<ref local></ref>
</property>
</bean>
</beans>
77、如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否正确?
不需要
78、依赖注入的方式有几种,各是什么?
Setter
Interface
constructor
79、请你谈谈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是一个业务层框架,是一个整合的框架,能够很好地黏合表示层与持久层。
80、为什么要用spring:
AOP 让开发人员可以创建非行为性的关注点,称为横切关注点,并将它们插入到应用程序代码中。使用 AOP 后,公共服务 (比如日志、持久性、事务等)就可以分解成方面并应用到域对象上,同时不会增加域对象的对象模型的复杂性。
IOC 允许创建一个可以构造对象的应用环境,然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的,IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素(singleton)和直接构造(straight construction),每一个对象都是用 其协作对象构造的。因此是由容器管理协作对象(collaborator)。
Spring即使一个AOP框架,也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring,只要用 JavaBean 属性和配置文件加入依赖性(协作对象)。然后可以很容易地在需要时替换具有类似接口的协作对象。
选择题:
1. 下面关于spring描述错误的是:( )
A Spring支持可插入的事务管理器,使事务划分更轻松,同时无需处理底层的问题。
B Spring事务管理的通用抽象层还包括JTA策略和一个JDBC DataSource。
C 与JTA或EJB CMT一样,Spring的事务支持依赖于Java EE环境。
D Spring事务语义通过AOP应用于 POJO,通过XML或Java SE 5注释进行配置。
参考答案:C
2. 下面选项哪个不是Spring中接口注入的方式?( )
A 接口注入
B 构造子注入
C 设值注入
D 指针注入
参考答案:D
3. 下列关于Spring特性中IoC描述错误的是:()
A IoC就是指程序之间的关系由程序代码直接操控。
B 所谓“控制反转”,是指控制权由应用代码转到外部容器,控制权的转移,
C IoC将控制创建的职责搬进了框架中;并把它从应用代码脱离开来
D 当使用Spring的IoC容器时只需指出组件需要的对象,在运行时Spring的IoC容器会根据XML配置数据提供给它。
参考答案:A
4下面关于Spring的说法中错误的是()。
A、Spring是一系列轻量级Java EE框架的集合
B、Spring中包含一个“依赖注入”模式的实现
C、使用Spring可以实现声明式事务
D、Spring提供了AOP方式的日志系统
分析:
A:正确。
B:正确。
C:正确。
D:错误。Spring并没有为我们提供日志系统,我们需要使用AOP(面向方面编程)的方式,借助Spring与日志系统log4j实现我们自己的日志系统。
5、下面关于AOP的说法错误的是()。
A、AOP将散落在系统中的“方面”代码集中实现
B、AOP有助于提高系统的可维护性
C、AOP已经表现出了将要替代面向对象的趋势
D、AOP是一种设计模式,Spring提供了一种实现
分析:
A:正确。
B:正确。
C:错误。
D:正确。
6、某业务方法materielApply(UserEntity user, List materiels)需要对其进行事务控制,下面的声明方式不能起到效果的是()。
A、将查询方法声明为只读事务,其他方法声明为REQUIRED
B、声明do开头的方法为REQUIRED,并修改方法名为doMaterielApply
C、<tx:method name="*Apply" propagation="REQUIRED" />
D、事务的propagation属性声明为SUPPORTS
分析:
A:此声明方式能起到效果。
B:此声明方式能起到效果。
C:此声明方式能起到效果。
D:此声明方式不能起到效果。因为:SUPPORTS的意思是:当前方法不需要事务处理环境,但如果有一个事务正在运行的话,此方法也可以运行在这个事务里。
答案:D
7、spring:依赖注入,事务管理,JDBC数据访问,spring中使用hibernate试题
选择
使用下面的Connection的哪个方法可以建立一个PreparedStatement接口( )
A、 createPrepareStatement()
B、 prepareStatement()
C、 createPreparedStatement()
D、 preparedStatement()
考点: 考察JDBC的api (B)
8、在Jdbc中可以调用数据库的存储过程的接口是( )
A、 Statement
B、 PreparedStatement
C、 CallableStatement
D、 PrepareStatement 考点:考察JDBC的api (C)
9、下面的描述正确的是( )
A、 PreparedStatement继承自Statement
B、 Statement继承自PreparedStatement
C、 ResultSet继承自Statement
D、 CallableStatement继承自PreparedStatement
考点:考察JDBC的api (A)
10、下面的描述错误的是( )
A 、Statement的executeQuery()方法会返回一个结果集
B、 Statement的executeUpdate()方法会返回是否更新成功的boolean值
C、使用ResultSet中的getString()可以获得一个对应于数据库中char类型的值
D、 ResultSet中的next()方法会使结果集中的下一行成为当前行
考点:返回更新记录的id (B)
11.关于Spring配置数据连接池的描述,错误的是?
A、spring可以用org.apache.commons.dbcp.BasicDataSource类配置数据源。
B、在org.apache.commons.dbcp.BasicDataSource类中有driver,url,username,password属性。
C、在用dbcp时,需要拷贝commons-dbcp的jar包到类路径下。
D、配置spring数据源时,必须引入Hibernate的SessionFactory。
考点:考察Spring的数据连接池的配置 (D)
12下列关于Spring的配置文件说法不正确的是:
A、Spring默认是读取/WEB-INF/applicationContext.xml配置文件。
B、Spring的配置文件可以配置在类路径下,并可以重命名,但是需要在web.xml中指 定。
C、把applicationContext.xml文件放到src下,Spring也可以读到。
D、可以通过在web.xml中的<context-param><param-name>和<param-value>进行指定 spring的配置文件。
考点:考察Spring配置文件 (C)
13下列关于Spring与Hibernate的集成,说法错误的是:
A、Spring与Hibernate的集成后,Hibernate的SessionFactory可以让Spring进行管理。
B、Hibernate中的配置文件也可以移到Spring的配置文件中配置。
C、使用Spring的事务管理,会认Hibernate事务处理变得简单。
D、Hibernate的映射文件的路路径(如com/ufinity/project/model/User.hbm.xml),不能在Spring中定义。
考点:考察Spring与Hibernate的集成 (D)
14关于Spring的事务的说明错误的是:
A、PROPAGATION_REQUIRED–支持当前事务,如果当前没有事务,就新建一个事务。
B、PROPAGATION_SUPPORTS–支持当前事务,如果当前没有事务,就以非事务方式执行。
C、PROPAGATION_MANDATORY–支持当前事务,如果当前没有事务,就抛出异常。
D、PROPAGATION_NOT_SUPPORTED以非事务方式执行操作,如果当前存在事务,则抛出异常。
考点:考察事务的传播特性(D)
15关于Spring的装配模式(default-autowire)描述不正确的是:
A、Spring中,至少有两种装配模式,按“类型”和“名字”。
B、Spring中默认是按名字进行装配。
C、可以用default-autowire="byType"配置按类型装配。
D、一旦在一个Spring的配置文件中配置了default-autowire="byType",其它的配置文件也是按此种装配方式。
考点:考察Spring的装配方式(D)
16下面关于Spring中的bean的作用域,描述错误的是:
A、Spring中的bean的作用域可以通过scope属性进行配置。
B、Spring中的bean的作用域默认是"prototype"。
C、当一个bean的scope设为"singleton"时,可以被多个线程同时访问。
D、一个bean的scope只对它自己起作用,与其它bean无关。
考点:考察Spring中的bean的作用域(B)
发表评论
-
lucene3.0 例一
2012-09-11 20:18 657package com.lucene;import java. ... -
lucene3.0
2012-09-11 20:15 873全文搜索 核心:创建索引——查询索引--分词器 索引引擎: ... -
分布式存储(转载)
2012-06-05 15:42 1208L1、HTML静态化其实大家都知道,效率最高、消耗最小的 ... -
java设计原则
2012-04-05 16:50 833原则1:DRY(Don't repeat ... -
java静态、动态代理
2012-04-04 18:51 852JAVA的动态代理 代理模式 代理模式是常用的java设计模式 ... -
Hibernate声明事务
2011-09-17 16:25 899事务处理 第一种方式: 首先配置datasoure: ... -
javascript应用3
2011-09-10 15:14 956打开一个新页面:{ <script t ... -
javascript应用2
2011-09-10 15:09 899日期插件的应用:{ <script type=& ... -
javascript应用1
2011-09-10 15:00 976javascript {<!-- 1.j ... -
css应用
2011-09-10 14:59 903CSS 本章目标 1、CSS的定义、优势 2、css的基 ... -
Html
2011-09-10 14:56 928HTML 超链接:{ <a href=”http:/ ... -
jsp、el、jstl.doc
2011-09-10 14:53 1346serlvet和jsp区别和联系 jsp从本质上讲也是s ... -
Jdbc
2011-09-10 14:49 934jdbc操作数据库插入、更新、删除、查找 mysql数据 ... -
文件上传步骤
2011-09-10 14:47 768文件上传的简单方法:(原理性的实验) 1. <b ... -
中文乱码问题解决
2011-09-10 14:43 7551. post方式提交的数据 采用request.setCha ... -
事务传播特性与隔离级别
2011-09-10 14:38 805事务传播特性了解事务的几种传播特性 ... -
监听器
2011-09-10 14:36 900监听器概述 1.Listener是Servlet的监听器 ... -
过滤器
2011-09-10 14:35 12521. Servlet过滤器基础 Servlet过滤器是Se ... -
web编程常用配置2
2011-09-10 14:35 720c3p0.jar:C3PO是一个数据库连接池,Hibern ... -
web编程常用配置1
2011-09-10 14:33 987mysql数据库jdbc驱动 jdbcDriver = co ...
相关推荐
### 《精通Spring2.X企业应用开发详解》第五章知识点详解 #### 5.1 Spring容器技术内幕 ##### 5.1.1 内部工作机制 Spring容器作为一款设计精妙且功能强大的框架核心,其内部机制对于理解和掌握Spring的工作原理至...
spring2所必需的jar包: aspectjweaver.jar; cglib-nodep-2.1_3.jar; common-annotations.jar; commons-logging.jar; spring.jar
精通Spring 2.x 企业应用开发详解
精通Spring2.x企业应用开发详解.rar精通Spring2.x企业应用开发详解.rar精通Spring2.x企业应用开发详解.rar精通Spring2.x企业应用开发详解.rar
精通Spring2.x企业应用开发详解全书源码+大量电子书+jar包(1)精通Spring2.x企业应用开发详解全书源码+大量电子书+jar包(1)
spring2_1_.0中文开发参考手册spring2_1_.0中文开发参考手册spring2_1_.0中文开发参考手册spring2_1_.0中文开发参考手册spring2_1_.0中文开发参考手册spring2_1_.0中文开发参考手册spring2_1_.0中文开发参考手册...
Build a three-tier enterprise Java applicaiton using the lastes the Spring Framework 2.x has to offer.
======================================================================== <br>第1篇 概述 第1章 Spring概述 第2章 快速入门 第2篇 Spring核心技术 第3章 IoC容器概述 第4章 在IoC容器中...
《构建Spring 2企业级应用》一书是Interface21公司、Bram Smeets与Seth Ladd共同编写的,于2007年出版,主要针对的是使用Java Spring框架进行企业级应用开发的技术人员。Spring框架自2004年由Rod Johnson创建以来,...
spring.jar spring-agent.jar spring-aop.jar spring-aspects.jar spring-beans.jar spring-context.jar spring-context-support.jar spring-core.jar spring-jdbc.jar spring-jms.jar spring-orm.jar spring-test....
spring2+struts1+ibatis2spring2+struts1+ibatis2spring2+struts1+ibatis2spring2+struts1+ibatis2spring2+struts1+ibatis2spring2+struts1+ibatis2spring2+struts1+ibatis2
struts2 + spring2 +hibernate3 struts2 + spring2 +hibernate3 struts2 + spring2 +hibernate3 struts2 + spring2 +hibernate3 struts2 + spring2 +hibernate3
spring2架构图
strut2 + spring2所需的jar文件,commons-fileupload-1.2.1,commons-logging-1.0.4,freemarker-2.3.13,ognl-2.6.11,spring,spring-aspects,struts2-core-2.1.6,struts2-spring-plugin-2.1.6,xwork-2.1.2
2. **注解驱动的配置**:Spring 3.0大力推广了基于注解的配置,例如`@Component`、`@Service`、`@Repository`和`@Controller`等,使得XML配置文件大大减少,提高了代码的可读性和可维护性。 3. **JSR-303/JSR-349 ...
spring2+springmvc+hibernate3 门户网站 spring2+springmvc+hibernate3 门户网站 spring2+springmvc+hibernate3 门户网站 spring2+springmvc+hibernate3 门户网站
ssh集成(Struts2+Hibernate3+spring2) ssh集成(Struts2+Hibernate3+spring2)ssh集成(Struts2+Hibernate3+spring2)ssh集成(Struts2+Hibernate3+spring2)ssh集成(Struts2+Hibernate3+spring2)
spring2完整版 jar包
罗时飞 精通spring 2 第二部分
abaqus批量建立非线性弹簧,轨道弹簧施加;土弹簧,接地弹簧,spring1,spring2,springA弹簧,弹簧代施加,可用于轨道交通,abaqus车轨耦合模型。