<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>IT公司面试手册 &#187; Spring</title>
	<atom:link href="http://www.mianwww.com/html/category/it-interview/spring/feed" rel="self" type="application/rss+xml" />
	<link>http://www.mianwww.com</link>
	<description></description>
	<lastBuildDate>Wed, 08 Feb 2012 11:48:28 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.2.1</generator>
		<item>
		<title>spring与ibatis框架整合</title>
		<link>http://www.mianwww.com/html/2012/01/12613.html</link>
		<comments>http://www.mianwww.com/html/2012/01/12613.html#comments</comments>
		<pubDate>Thu, 05 Jan 2012 10:59:48 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=12613</guid>
		<description><![CDATA[Spring和Ibatis框架整合的思路与spring和hibernate框架的整合思路基本一致。 步骤一：新建立一个项目。 步骤二：为该项目添加spring的应用环境。 步骤三：导入Ibatis的必须JAR包以及数据库JAR包。 步骤四：新建实体Bean。如下： package cn.test.entity; import java.io.Serializable; /** * @author Administrator * *学生实体Bean * */ public class Student implements Serializable { /** * */ private static final long serialVersionUID = 1L; private Integer id; private String studentname; private Integer studentage; private String studentaddress; public Integer getId() { return id; } public void setId(Integer [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2012/01/12613.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>spring声明式事务配置</title>
		<link>http://www.mianwww.com/html/2011/12/12542.html</link>
		<comments>http://www.mianwww.com/html/2011/12/12542.html#comments</comments>
		<pubDate>Sun, 25 Dec 2011 03:57:52 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=12542</guid>
		<description><![CDATA[&#60;?xml version=&#8221;1.0&#8243; encoding=&#8221;UTF-8&#8243;?&#62; &#60;beans xmlns=&#8221; http://www.springframework.org/schema/beans &#8221; xmlns:xsi=&#8221; http://www.w3.org/2001/XMLSchema-instance &#8221; xmlns:aop=&#8221; http://www.springframework.org/schema/aop &#8221; xmlns:tx=&#8221; http://www.springframework.org/schema/tx &#8221; xsi:schemaLocation=&#8221; http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans.xsd  http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx.xsd  http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop.xsd &#8220;&#62; 这里省去Datasource 和 sessionFacory &#60;bean id=&#8221;transactionManager&#8221; abstract=&#8221;false&#8221; lazy-init=&#8221;default&#8221; autowire=&#8221;default&#8221; dependency-check=&#8221;default&#8221;&#62; &#60;property name=&#8221;sessionFactory&#8221;&#62; &#60;ref bean=&#8221;sessionFactory&#8221; /&#62; &#60;/property&#62; &#60;/bean&#62; &#60;!&#8211; 声明式事务 &#8211;&#62; &#60;!&#8211; 事务通知 &#8211;&#62; &#60; tx:advice id = &#8220;txAdvice&#8221; transaction-manager = &#8220;transactionManager&#8221; &#62; &#60; tx:attributes &#62; &#60; tx:method name = &#8220;add*&#8221; propagation = [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/12/12542.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Spring_练习题库_面试题汇总_考试复习</title>
		<link>http://www.mianwww.com/html/2011/12/12421.html</link>
		<comments>http://www.mianwww.com/html/2011/12/12421.html#comments</comments>
		<pubDate>Sat, 03 Dec 2011 11:39:29 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=12421</guid>
		<description><![CDATA[一、Spring框架的优点都有什么？ Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分 Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高 依赖注入和IoC使得JDBC操作简单化 Spring是开源的免费的 Spring使得对象管理集中化合简单化 二、描述一下Spring中实现DI（Dependency Injection）的几种方式 方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。 方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去 方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入 Spring的方式 三、简述你对IoC（Inversion of Control）的理解 &#160; 一个类需要用到某个接口的方法，我们需要将类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 &#160; 五、请介绍一下Spring的事务管理 spring提供了几个关于事务处理的类： TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 &#160; 一般事务定义步骤： &#160; TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth transactionManager.commit(ts); } catch(Exception e){transactionManager.rollback(ts);} &#160; [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/12/12421.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>spring面试题 对di , aop概念的理解</title>
		<link>http://www.mianwww.com/html/2011/11/11938.html</link>
		<comments>http://www.mianwww.com/html/2011/11/11938.html#comments</comments>
		<pubDate>Mon, 14 Nov 2011 14:35:08 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=11938</guid>
		<description><![CDATA[什么是AOP？ 面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面 1.面向切面编程提供声明式事务管理 2.spring支持用户自定义的切面 面向切面编程（aop）是对面向对象编程（oop）的补充， 面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。 AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop是静态的抽象，aop是动态的抽象， 是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分。 aop框架具有的两个特征： 1.各个步骤之间的良好隔离性 2.源代码无关性 什么是DI机制？ 依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，具体的讲：当某个角色 需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring中 创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者 因此也称为依赖注入。 spring以动态灵活的方式来管理对象 ， 注入的两种方式，设置注入和构造注入。 设置注入的优点：直观，自然 构造注入的优点：可以在构造器中决定依赖关系的顺序。 spring 的优点都有哪些？ 1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦 2.可以使用容易提供的众多服务，如事务管理，消息服务等 3.容器提供单例模式支持 4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 5.容器提供了众多的辅助类，能加快应用的开发 6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等 7.spring属于低侵入式设计，代码的污染极低 8.独立于各种应用服务器 9.spring的DI机制降低了业务对象替换的复杂性 10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/11/11938.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Java框架面试题</title>
		<link>http://www.mianwww.com/html/2011/11/11764.html</link>
		<comments>http://www.mianwww.com/html/2011/11/11764.html#comments</comments>
		<pubDate>Thu, 10 Nov 2011 11:43:28 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Hibernate]]></category>
		<category><![CDATA[Spring]]></category>
		<category><![CDATA[Struts]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=11764</guid>
		<description><![CDATA[1. 请简述STRUTS架构 Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。 采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能： 一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。 二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。 三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。 2. 在Spring框架中，如何解决Web页面乱码问题？ 可以采用Spring框架自带的过滤器CharacterEncodingFilter，配置方式如下： 在web.xml文件中filter的位置加上如下内容： encodingFilter org.springframework.web.filter.CharacterEncodingFilter encoding UTF-8 forceEncoding true encodingFilter * 3. 在Struts中，如何实现防止表单的重复提交操作？ Struts的Token（令牌）机制能够很好的解决表单重复提交的问题，基本原理是：服务器端在处理到达的请求之前，会将请求中包含的令牌值与保存在当前用户会话中的令牌值进行比较，看是否匹配。在处理完该请求后，且在答复发送给客户端之前，将会产生一个新的令牌，该令牌除传给客户端以外，也会将用户会话中保存的旧的令牌进行替换。这样如果用户回退到刚才的提交页面并再次提交的话，客户端传过来的令牌就和服务器端的令牌不一致，从而有效地防止了重复提交的发生。 4. Struts的入口类？ 答：ActionServlet是Struts的入口类，所有的struts请求都经由该类转发处理 5. 关于hibernate: 1)在hibernate中，在配置文件呈标题一对多，多对多的标签是什么； 2)Hibernate的二级缓存是什么； 3)Hibernate是如何处理事务的； 答：1）一对多的标签为： ；多对多的标签为：； 2）sessionFactory的缓存为hibernate的二级缓存； 3）Hibernate的事务实际上是底层的JDBC Transaction的封装或者是JTA Transaction的封装；默认情况下使用JDBCTransaction。 6. 写出你熟悉的开源框架以及各自的作用。 答：框架：hibernate,spring,struts. Hibernate主要用于数据持久化； Spring 的控制反转能起到解耦合的作用； Struts 主要用于流程控制； 服务器类：Apache Tomcat Jboss等 7. [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/11/11764.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>中兴公司Spring面试题库</title>
		<link>http://www.mianwww.com/html/2011/10/10826.html</link>
		<comments>http://www.mianwww.com/html/2011/10/10826.html#comments</comments>
		<pubDate>Wed, 12 Oct 2011 13:34:45 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>
		<category><![CDATA[中兴]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=10826</guid>
		<description><![CDATA[一、选择题 （每题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描述错误的是：（ ） [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/10/10826.html/feed</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Java SSH面试题集</title>
		<link>http://www.mianwww.com/html/2011/09/10270.html</link>
		<comments>http://www.mianwww.com/html/2011/09/10270.html#comments</comments>
		<pubDate>Thu, 22 Sep 2011 05:23:53 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Hibernate]]></category>
		<category><![CDATA[Java]]></category>
		<category><![CDATA[Spring]]></category>
		<category><![CDATA[Struts]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=10270</guid>
		<description><![CDATA[Java&#8212;SSH(MVC) 1. 谈谈你mvc的理解 MVC是Model—View—Controler的简称。即模型—视图—控制器。MVC是一种设计模式，它强制性的把应用程序的输入、处理和输出分开。 MVC中的模型、视图、控制器它们分别担负着不同的任务。 视图: 视图是用户看到并与之交互的界面。视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业务逻辑处理。 模型: 模型表示业务数据和业务处理。相当于JavaBean。一个模型能为多个视图提供数据。这提高了应用程序的重用性 控制器: 当用户单击Web页面中的提交按钮时,控制器接受请求并调用相应的模型去处理请求。 然后根据处理的结果调用相应的视图来显示处理的结果。 MVC的处理过程：首先控制器接受用户的请求，调用相应的模型来进行业务处理，并返回数据给控制器。控制器调用相应的视图来显示处理的结果。并通过视图呈现给用户。 Struts 1. struts1.2和struts2.0的区别？如何控制两种框架中的单例模式？ struts1.2和struts2.0的对比 a、Action类： struts1.2要求Action类继承一个基类。struts2.0 Action要求继承ActionSupport基类 b、线程模式 struts1.2 Action是单例模式的并且必须是线程安全的,因为仅有一个Action的实例来处理所有的请求。 单例策略限制了Struts1.2 Action能做的事情,并且开发时特别小心。Action资源必须是线程安全的或同步的。 struts2.0 Action为每一个请求产生一个实例,因此没有线程安全问题。 c、Servlet依赖 struts1.2 Action依赖于Servlet API,因为当一个Action被调用时HttpServletRequest和HttpServletResponse被传递给execut方法。 struts2.0 Action不依赖于容器,允许Action脱离容器单独测试。如果需要,Struts2 Action仍然可以访问初始的Request和Response。 但是,其他的元素减少或者消除了直接访问HttpServletRequest和HttpServletResponse的必要性。 d、可测性 测试struts1.2 Action的一个主要问题是execute方法暴露了Servlet API(这使得测试要依赖于容器)。一个第三方扩展：struts TestCase 提供了一套struts1.2的模拟对象来进行测试。 Struts2.0 Action可以通过初始化、设置属性、调用方法来测试,“依赖注入”也使得测试更容易。 2. 项目中为什么使用SSH 1. 使用Struts是因为struts是基于MVC模式的,很好的将应用程序进行了分层，使开发者更关注于业务逻辑的实现；第二，struts有着丰富的taglib,如能灵活运用，则能大大提高开发效率。 2. 使用Hibernate：因为hibernate为Java应用提供了一个易用的、高效率的对象关系映射框架。hibernate是个轻量级的持久性框架，功能丰富。 3. 使用Spring：因为spring基于IoC(Inversion of Control，反向控制)和AOP构架多层j2ee系统的框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块； 采用IoC使得可以很容易的实现bean的装配，提供了简洁的AOP并据此实现事务管理(Transcation Managment),等等 [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/09/10270.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>spring面试题</title>
		<link>http://www.mianwww.com/html/2011/06/9785.html</link>
		<comments>http://www.mianwww.com/html/2011/06/9785.html#comments</comments>
		<pubDate>Tue, 21 Jun 2011 11:15:23 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=9785</guid>
		<description><![CDATA[一、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是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。 四、介绍一下Spring的事务管理： 事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。 这样可以防止出现脏数据，防止数据库数据出现问题。 开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管理，可以通过Spring的注入来完成此功能。 spring提供了几个关于事务处理的类： TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类 AbstractPlatformTransactionManager,我们使用的事务管理类例如 DataSourceTransactionManager等都是这个类的子类。 一般事务定义步骤： [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/06/9785.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>SSH框架面试题</title>
		<link>http://www.mianwww.com/html/2011/06/9770.html</link>
		<comments>http://www.mianwww.com/html/2011/06/9770.html#comments</comments>
		<pubDate>Sun, 19 Jun 2011 05:27:57 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Hibernate]]></category>
		<category><![CDATA[Spring]]></category>
		<category><![CDATA[Struts]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=9770</guid>
		<description><![CDATA[Hibernate工作原理及为什么要用？ 原理： 1. 读取并解析配置文件 2. 读取并解析映射信息，创建SessionFactory 3. 打开Sesssion 4. 创建事务Transation 5. 持久化操作 6. 提交事务 7. 关闭Session 8. 关闭SesstionFactory 为什么要用： * 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。 * Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 * hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。 * hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。 Hibernate是如何延迟加载? * Hibernate2延迟加载实现：a)实体对象 b)集合（Collection） * Hibernate3 提供了属性的延迟加载功能 当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。 Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系) 类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、 说下Hibernate的缓存机制 * 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存 * 二级缓存： a)应用及缓存 b)分布式缓存 条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据 c) 第三方缓存的实现 Hibernate的查询方式 Sql、Criteria,object comptosition Hql： * 属性查询 * [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/06/9770.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Spring面试题库</title>
		<link>http://www.mianwww.com/html/2011/06/9764.html</link>
		<comments>http://www.mianwww.com/html/2011/06/9764.html#comments</comments>
		<pubDate>Sat, 18 Jun 2011 05:18:26 +0000</pubDate>
		<dc:creator>jim.jin</dc:creator>
				<category><![CDATA[Spring]]></category>

		<guid isPermaLink="false">http://www.mianwww.com/?p=9764</guid>
		<description><![CDATA[选择题（15题） 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配置文件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. [...]]]></description>
		<wfw:commentRss>http://www.mianwww.com/html/2011/06/9764.html/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
	</channel>
</rss>

