文档章节

三大框架Q/A

巍Will
 巍Will
发布于 2017/04/23 15:38
字数 8536
阅读 9
收藏 0

Struts

对Struts的理解

1.struts是一个按MVC模式设计的Web层框架,其实它就是一个大大的servlet,这个Servlet名为ActionServlet,或是ActionServlet的子类。我们可以在web.xml文件中将符合某种特征的所有请求交给这个Servlet处理,这个Servlet再参照一个配置文件(通常为/WEB-INF/struts-config.xml)将各个请求分别分配给不同的action去处理。

一个扩展知识点:struts的配置文件可以有多个,可以按模块配置各自的配置文件,这样可以防止配置文件的过度膨胀;

2.ActionServlet把请求交给action去处理之前,会将请求参数封装成一个formbean对象(就是一个Java类,这个类中的每个属性对应一个请求参数),封装成一个什么样的formbean对象呢?看配置文件。

3.要说明的是, ActionServlet把formbean对象传递给action的execute方法之前,可能会调用formbean的validate方法进行校验,只有校验通过后才将这个formbean对象传递给action的execute方法,否则,它将返回一个错误页面,这个错误页面由input属性指定,(看配置文件)作者为什么将这里命名为input属性,而不是error属性,我们后面结合实际的运行效果进行分析。

4.action执行完后要返回显示的结果视图,这个结果视图是用一个ActionForward对象来表示的,actionforward对象通过struts-config.xml配置文件中的配置关联到某个jsp页面,因为程序中使用的是在struts-config.xml配置文件为jsp页面设置的逻辑名,这样可以实现action程序代码与返回的jsp页面名称的解耦。

自己的话简介Struts2执行流程

Struts 2的工作流程与WebWork框架基本相同,所以说Struts2是WebWork的升级版本。

基本简要流程如下:1、客户端浏览器发出HTTP请求。2、根据web.xml配置,该请求被FilterDispatcher接收。3、根据struts.xml配置,找到需要调用的Action类和方法,并通过IoC方式,将值注入给Aciton。4、Action调用业务逻辑组件处理业务逻辑,这一步包含表单验证。5、Action执行完毕,根据struts.xml中的配置找到对应的返回结果result,并跳转到相应页面。6、返回HTTP响应到客户端浏览器。

Struts2的工作机制

 一个请求在Struts2框架中的处理大概分为以下几个步骤:

1、客户端初始化一个指向Servlet容器(例如Tomcat)的请求;

2、这个请求经过一系列的过滤器(Filter)(这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器,这个过滤器对于Struts2和其他框架的集成很有帮助,例如:SiteMesh Plugin);

3、接着FilterDispatcher被调用,FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action;

4、如果ActionMapper决定需要调用某个Action,FilterDispatcher把请求的处理交给ActionProxy;

5、ActionProxy通过ConfigurationManager询问框架的配置文件,找到需要调用的Action类;

6、ActionProxy创建一个ActionInvocation的实例。

7、ActionInvocation实例使用命名模式来调用,在调用Action的过程前后,涉及到相关拦截器(Intercepter)的调用。

8、一旦Action执行完毕,ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是(但不总是,也可能是另外的一个Action链)一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2框架中继承的标签。在这个过程中需要涉及到ActionMapper。

Struts2的体系结构

Struts 2框架本身大致可以分为3个部分:核心控制器FilterDispatcher、业务控制器Action和用户实现的企业业务逻辑组件。核心控制器 FilterDispatcher是Struts 2框架的基础,包含了框架内部的控制流程和处理机制。业务控制器Action和业务逻辑组件是需要用户来自己实现的。用户在开发Action和业务逻辑组件的同时,还需要编写相关的配置文件,供核心控制器FilterDispatcher来使用。

Struts2的体系与Struts1体系的差别非常大,因为Struts2使用了WebWork的设计核心,而不是Struts1的设计核心。Struts2中大量使用拦截器来处理用户的请求,从而允许用户的业务逻辑控制器与Servlet API分离。

  Struts2框架的大概处理流程如下:

  1、加载类(FilterDispatcher)

  2、读取配置(struts配置文件中的Action)

    3、派发请求(客户端发送请求)

  4、调用Action(FilterDispatcher从struts配置文件中读取与之相对应的Action)

  5、启用拦截器(WebWork拦截器链自动对请求应用通用功能,如验证)

  6、处理业务(回调Action的execute()方法)

  7、返回响应(通过execute方法将信息返回到FilterDispatcher)

  8、查找响应(FilterDispatcher根据配置查找响应的是什么信息如:SUCCESS、ERROR,将跳转到哪个jsp页面)

    9、响应用户(jsp--->客户浏览器端显示)

   10、struts2标签库(相比struts1的标签库,struts2是大大加强了,对数据的操作功能很强大)

在Struts2中怎样把请求分发给方法去处理

 在struts.xml中就只需要配置一个action,在一个Action类中分发Action请求调用不同的方法。

介绍一下Struts的ActionServlet类

ActionServlet继承自javax.servlet.http.HttpServlet类,其在Strutsframework中扮演的角色是中心控制器。它提供一个中心位置来处理全部的终端请求。控制器ActionServlet主要负责将HTTP的客户请求信息组装后,根据配置文件的指定描述,转发到适当的处理器。
按照Servelt的标准,所有得Servlet必须在web配置文件(web.xml)声明。同样,ActoinServlet必须在WebApplication配置文件(web.xml)中描述,有关配置信息如下。
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
</servlet>
全部的请求URI以*.do的模式存在并映射到这个servlet,其配置如下:
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
一个该模式的请求URI符合如下格式:http://www.my_site_name.com/mycontext/actionName.do

当用户向服务器端提交请求的时候,实际上信息是首先发送到控制器ActionServlet,一旦控制器获得了请求,其就会将请求信息传交给一些辅助类(help classes)处理。这些辅助类知道如何去处理与请求信息所对应的业务操作。在Struts中,这个辅助类就是org.apache.struts.action.Action。通常开发者需要自己继承Aciton类,从而实现自己的Action实例。

Struts2中常见的拦截器有哪些

上传,重复提交,数字转换,表单认证,国际化,等等

请简述Struts2中自定义拦截器的步骤

1.首先要实现Interceptor(拦截器)接口  2.在配置文件中定义自己的拦截器。  3.最后还要把系统提供的默认拦截器加上,否则系统默认拦截器不起作用

怎样实现Struts2自定义转换器

实现TypeCoverter接口,或者继承DefaultTypeConverter实现类(该类实现了TypeCoverter接口),通过继承该实现类来实现自己的类型转换器。重写convertValue方法即可。

说说struts1与struts2的区别

1.都是MVC的WEB框架,

2struts1的老牌框架,应用很广泛,有很好的群众基础,使用它开发风险很小,成本更低!struts2虽然基于这个框架,但是应用群众并多,相对不成熟,未知的风险和变化很多,开发人员相对不好招,使用它开发项目的风险系数更大,用人成本更高!

3.struts2毕竟是站在前辈的基础设计出来,它会改善和完善struts1中的一些缺陷,struts1中一些悬而未决问题在struts2得到了解决。

4.struts1的前端控制器是一个Servlet,名称为ActionServlet,struts2的前端控制器是一个filter,在struts2.0中叫FilterDispatcher,在struts2.1中叫StrutsPrepareAndExecuteFilter。

5.struts1的action需要继承Action类,struts2的action可以不继承任何类;struts1对同一个路径的所有请求共享一个Action实例,struts2对同一个路径的每个请求分别使用一个独立Action实例对象,所有对于struts2的Action不用考虑线程安全问题。

6.在struts1中使用formbean封装请求参数,在struts2中直接使用action的属性来封装请求参数。

7.struts1中的多个业务方法放在一个Action中时(即继承DispatchAction时),要么都校验,要么都不校验;对于struts2,可以指定只对某个方法进行校验,当一个Action继承了ActionSupport且在这个类中只编写了validateXxx()方法,那么则只对Xxx()方法进行校验。

(一个请求来了的执行流程进行分析,struts2是自动支持分模块开发,并可以不同模块设置不同的url前缀,这是通过package的namespace来实现的;struts2是支持多种类型的视图;struts2的视图地址可以是动态的,即视图的名称是支持变量方式的,举例,论坛发帖失败后回来还要传递boardid。视图内容显示方面:它的标签用ognl,要el强大很多,在国际化方面支持分模块管理,两个模块用到同样的key,对应不同的消息;)

与Struts1不同,Struts2对用户的每一次请求都会创建一个Action,所以Struts2中的Action是线程安全的。

给我印象最深刻的是:struts配置文件中的redirect视图的url不能接受参数,而struts2配置文件中的redirect视图可以接受参数。

Struts2怎样整合spring

    1.使用向导添加struts2的组件;

    2.使用向导添加spring2.5的组件;   

    struts.properties             --指定有Struts2的action由spring容器管理

    web.xml                       --指定spring容器配置文件  

    globalMessages.properties     --非必须有   

    struts.xml                    --class属性配置改成spring容器内bean的ID

    applicationContext.xml        --action的作用域需要是原型

Spring是什么

spring是一个集成了许多第三方框架的大杂烩,其核心技术是IOC(控制反转,也称依赖注入)和AOP(面向切面编程)

你对Spring的理解

1.Spring实现了工厂模式的工厂类(在这里有必要解释清楚什么是工厂模式),这个类名为BeanFactory(实际上是一个接口),在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类,在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。

2.Spring提供了对IOC(控制反转)良好支持,IOC是一种编程思想,是一种架构艺术,利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI(Depency Injection),什么叫依赖注入呢?

譬如,Class Programmer

{

Computercomputer = null;

publicvoid code()

{

//Computercomputer = new IBMComputer();

//Computercomputer = beanfacotry.getComputer();

computer.write();

}

publicvoid setComputer(Computer computer)

{

this.computer= computer;

}

}
另外两种方式都由依赖,第一个直接依赖于目标类,第二个把依赖转移到工厂上,第三个彻底与目标和工厂解耦了。在spring的配置文件中配置片段如下:

<beanid=”computer” class=”cn.itcast.interview.Computer”>

</bean>

<beanid=”programmer” class=”cn.itcast.interview.Programmer”>

<propertyname=”computer”  ref=”computer”></property>

</bean>

3. Spring提供了对AOP技术的良好封装, AOP称为面向切面编程,就是系统中有很多各不相干的类的方法,在这些众多方法中要加入某种系统功能的代码,例如,加入日志,加入权限判断,加入异常处理,这种应用称为AOP。实现AOP功能采用的是代理技术,客户端程序不再调用目标,而调用代理类,代理类与目标类对外具有相同的方法声明,有两种方式可以实现相同的方法声明,一是实现相同的接口,二是作为目标的子类在,JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类,如果要为某个类生成子类,则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法,系统功能的代理以Advice对象进行提供,显然要创建出代理对象,至少需要目标类和Advice类。spring提供了这种支持,只需要在spring配置文件中配置这两个元素即可实现代理和aop功能

Spring流程

请求的分发

请求首先到达DispatcherServlet,应用服务器会根据Web应用中web.xml文件定义的url映射将相应的请求分发到DispatcherServlet中

请求的处理

DispatcherServlet会查找相应的HandlerMapping接口的实现类,调用其中的方法:HandlerExecutionChaingetHandler(HttpServletRequest request) throws Exception,该方法会返回一个HandlerExecutionChain。返回的HandlerExecutionChain中包含了零个或者是多个Interceptor和一个处理请求的Handler。DispatcherServlet会调用Interceptor中的preHandle() 方法。然后处理Handler,这个Handler相当于Struts中Action,在SpringMVC中默认的实现是Controller接口,是具体处理请求的代码所驻留的地方。事实上HandlerExecutionChain中的getHandler()返回的是一个Object类型。DispatcherServlet不会直接调用getHandler()返回对象中的方法,DispatcherServlet会查找相应的HandlerAdapter,然后具体通过HandlerAdapter来调用getHandler()返回的handler对象中的方法。就是说我们可以实现自己的HandlerAdapter然后通过IoC注入到DispatcherServlet中,从而可以实现一套自定义的控制器。随后DispatcherServlet会调用Interceptor中的postHandle()方法。

Spring容器基本的接口是什么

beanfactory(容器),applicationContext(应用上下文)

什么是Spring的AOP,它的功能是什么

AOP是面向切面,相当于拦截器,可以在需要的地方插入逻辑,所谓的面向方面就是把相同的功能抽象出来。

AOP中的术语

1.通知(Advice):

通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。

2.连接点(Joinpoint):

程序能够应用通知的一个“时机”,这些“时机”就是连接点,例如方法被调用时、异常被抛出时等等。

3.切入点(Pointcut)

通知定义了切面要发生的“故事”和时间,那么切入点就定义了“故事”发生的地点,例如某个类或方法的名称,Spring中允许我们方便的用正则表达式来指定

4.切面(Aspect)

通知和切入点共同组成了切面:时间、地点和要发生的“故事”

5.引入(Introduction)

引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能)

6.目标(Target)

即被通知的对象,如果没有AOP,那么它的逻辑将要交叉别的事务逻辑,有了AOP之后它可以只关注自己要做的事(AOP让他做爱做的事)

7.代理(proxy)

应用通知的对象,详细内容参见设计模式里面的代理模式

8.织入(Weaving)

把切面应用到目标对象来创建新的代理对象的过程,织入一般发生在如下几个时机:

(1)编译时:当一个类文件被编译时进行织入,这需要特殊的编译器才可以做的到,例如AspectJ的织入编译器

(2)类加载时:使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码

(3)运行时:切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的,原理应该是使用了JDK的动态代理技术

请阐述Spring的IOC,有几种类型

       1有setter注入(即类中设置一个全局属性,并对属性有setter方法,以供容器注入),

       2接口注入

       3构造器注入

Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写

依赖注入是Spring IOC的主要作用,依赖就是指属性,意思就是说将属性利用Spring注入到程序中,而非new。
<bean id="message" class="message所在类的路径名">
   <property name="message" value="Hello"$amp;>amp;$lt;/property>
</bean>

Spring管理事务有哪几种方式

有两种方式:基于XML配置文件的方式;另一个是在业务方法上进行@Transactional注解,将事务规则应用到业务逻辑中。

Spring的作用域有哪些

singleton(单例) ,prototype(原型) ,request,session,globalsession

Hibernate

Hibernate工作原理流程

1.读取并解析配置文件 2.读取并解析映射信息,创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory

为什么要用Hibernate

为什么要用: 1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。 2. hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM(对象关系映射)实现。他很大程度的简化DAO层的编码工作 3. hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。 4. hibernate的性能非常好,因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库,从一对一到多对多的各种复杂关系。

使用Hibernate之前要配置什么

使用Hibernate时,先要配置hibernate.cfg.xml文件,其中配置数据库连接信息和方言等,还要为每个实体配置相应的hbm.xml文件,hibernate.cfg.xml文件中需要登记每个hbm.xml文件。

使用Hibernate的基本流程是

配置Configuration对象、产生SessionFactory、创建session对象,启动事务,完成CRUD操作,提交事务,关闭session。

相对于SQL,HQL查询语言有什么特点,什么是方言

sql是关系数据库查询语言,面对的数据库;而hql是Hibernate这样的数据库持久化框架提供的内置查询语言,虽然他们的目的都是为了从数据库查询需要的数据,但sql操作的是数据库表和字段,而作为面向对象的hql操作的则是持久化类及其属性,

Hibernate架构,对象有三种状态,分别是什么,怎样区分 

Hibernate三种状态的区分,以及save,update,saveOrUpdHibernate的对象有3种状态,

分别为:瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。

1.瞬时对象在内存孤立存在,它是携带信息的载体,不和数据库的数据有任何关联关系,在Hibernate中,可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联,并将数据对应的插入数据库中,此时该瞬时对象转变成持久化对象。 

2.持久对象具有如下特点: 1. 和session实例关联; 2. 在数据库中有与之关联的记录。 3. 比瞬时对象多了一个数据库记录标识值。

3.托管态,也叫游离态等,持久化对象脱离了Session的对象。如Session缓存被清空的对象。特点:已经持久化,但不在Session缓存中。处于此状态的对象叫游离对象。

乐观锁,悲观锁

多用户环境中,在同一时间可能会有多个用户更新相同的记录,这会产生冲突。这就是并发性冲突问题。

典型的冲突有:

  • 丢失更新:一个事务的更新覆盖了其它事务的更新结果,就是所谓的更新丢失。例如:用户A把值从6改为2,用户B把值从2改为6,则用户A丢失了他的更新。

  • 脏读:当一个事务读取其它完成一半事务的记录时,就会发生脏读取。例如:用户A,B看到的值都是6,用户B把值改为2,用户A读到的值仍为6。

为了解决这些并发带来的问题。 我们需要引入并发控制机制。

       悲观锁:假定会发生并发冲突屏蔽一切可能违反数据完整性的操作。正如其名,它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度,因此,在整个数据处理过程中,将数据处于锁定状态。悲观锁的实现,往往依靠数据库提供的锁机制(也只有数据库层提供的锁机制才能真正保证数据访问的排他性,否则,即使在本系统中实现了加锁机制,也无法保证外部系统不会修改数据)

  乐观锁:假设不会发生并发冲突只在提交操作时检查是否违反数据完整性。( 乐观锁不能解决脏读的问题)。相对悲观锁而言,乐观锁假设认为数据一般情况下不会造成冲突,所以在数据进行提交更新的时候,才会正式对数据的冲突与否进行检测,如果发现冲突了,则让返回用户错误的信息,让用户决定如何去做。

Hibernate中什么是延迟加载,延迟的作用是什么

延迟加载,也叫懒加载,它是Hibernate为提高程序执行效率而提供的一种机制,即只有真正使用该对象的数据时才会创建。

Hibernate中主要是通过代理(proxy)机制来实现延迟加载。它的具体过程:Hibernate丛数据库获取某一个对象数据时、获取某一个对象的集合属性值时,或获取某一个对象所关联的另一个对象时,由于没有使用该对象的数据,hibernate并不是数据库加载真正的数据,而只是为该对象创建一个代理对象来代表这个对象,这个对象上的所有属性都是默认值;只有在真正需要使用该对象的数据时才创建这个真实对象,真正从数据库中加载它的数据,这样在某些情况下,就可以提高查询效率。

延迟加载机制是为了避免一些无谓的性能开销而提出来的,所谓延迟加载就是当在真正需要数据的时候,才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载,另外在Hibernate3中还提供了对属性的延迟加载。

hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决

解决方案一,按照Object[]数据取出数据,然后自己组bean

解决方案二,对每个表的bean写构造函数,比如表一要查出field1,field2两个字段,那么有一个构造函数就是Bean(type1filed1,type2

field2),然后在hql里面就可以直接生成这个bean了。

第一个:查询出来的list 转换为一个数组   
也就是说 Object[]  objects=(Object[]) list    --  你查询出来的list 集合
for(object  item :objects  ){}进行自行封装处理 
第二个说白了就是写个构造函数让他自己封装省了自己处理过程了 
但是如果是查询出来的多张表数据  还是得按第一种方式自己处理的。。。

介绍一下Hibernate的二级缓存

(1)缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中(一个数据结构中),这个数据结构通常是或类似Hashmap,当以后要使用某个对象时,先查询缓存中是否有这个对象,如果有则使用缓存中的对象,如果没有则去查询数据库,并将查询出来的对象保存在缓存中,以便下次使用。

(2)Hibernate的Session就是一种缓存,我们通常将之称为Hibernate的一级缓存,当想使用session从数据库中查询出一个对象时,Session也是先从自己内部查看是否存在这个对象,存在则直接返回,不存在才去访问数据库,并将查询的结果保存在自己内部。由于Session代表一次会话过程,一个Session与一个数据库连接相关连,所以Session最好不要长时间保持打开,通常仅用于一个事务当中,在事务结束时就应关闭。并且Session是线程不安全的,被多个线程共享时容易出现问题。通常只有那种全局意义上的缓存才是真正的缓存应用,才有较大的缓存价值,因此,Hibernate的Session这一级缓存的缓存作用并不明显,应用价值不大。Hibernate的二级缓存就是要为Hibernate配置一种全局缓存,让多个线程和多个事务都可以共享这个缓存。我们希望的是一个人使用过,其他人也可以使用,session没有这种效果。

(3)二级缓存是独立于Hibernate的软件部件,属于第三方的产品,多个厂商和组织都提供有缓存产品,例如,EHCache和OSCache等等。在Hibernate中使用二级缓存,首先就要在hibernate.cfg.xml配置文件中配置使用哪个厂家的缓存产品,接着需要配置该缓存产品自己的配置文件,最后要配置Hibernate中的哪些实体对象要纳入到二级缓存的管理中。明白了二级缓存原理和有了这个思路后,很容易配置起Hibernate的二级缓存。扩展知识:一个SessionFactory可以关联一个二级缓存,也即一个二级缓存只能负责缓存一个数据库中的数据,当使用Hibernate的二级缓存后,注意不要有其他的应用或SessionFactory来更改当前数据库中的数据,这样缓存的数据就会与数据库中的实际数据不一致。

简述 Hibernate 和 JDBC 的优缺点? 如何书写一个 one to many 配置文件

Hibernate就是封装了JDBC,他可以写一条hql语句,可以再不同数据库中使用,不用修改hql语句,但是关联查询效率低。
JDBC是基础的链接数据库的框架,效率高,但是mysql、oracle、sql service等不同的数据库要写不同的sql语句。
one to many比如Class和Student吧就是一个班级对应多个学生

在Class类中追加集合属性 Set<Student> students;
在Class的配置文件中追加(Class.hbm.xml)
<!-- 追加集合属性的配置 -->
                               <!-- 设置集合属性 -->
                               <set name="students" lazy="false" fetch="join" cascade="all" inverse="true">
                                              <!-- 设置关联字段 -->
                                              <key column="classId" />
                                              <!-- 设置关联关系 -->
                                              <one-to-many class="Studnet" />
                               </set>
将Studnet中的classId属性去掉换成 Class class;
在Student的配置文件中(Student.hbm.xml)
<many-to-one name="class" column="classId" lazy="false" fetch="join"
                                              class="Class">
                               </many-to-one>

三大框架各起的作用 

struts 在 SSH 框架中起控制的作用 , 其核心是 (控制器)Controller, 即ActionServlet, 而 ActionServlet 的核心就是 Struts-config.xml. 主要控制逻辑关系的处理 .    hibernate 是数据持久化层 , 是一种新的对象、关系的映射工具 , 提供了从 Java 类到数据表的映射,也提供了数据查询和恢复等机制 , 大大减少数据访问的复杂度。把对数据库的直接操作 , 转换为对持久对象的操作 .   

spring 是一个轻量级的控制反转 (IoC) 和面向切面 (AOP) 的容器框架 , 面向接口的编程 , 由容器控制程序之间的(依赖)关系,而非传统实现中,由程序代码直接操控。这也就是所谓“ 控制反转 ” 的概念所在:(依赖)控制权由应用代码中转到了外部容器,控制权的转移,是所谓反转。依赖注入,即组件之间的依赖关系由容器在运行期决定,形象的来说,即由容器动态的将某种依赖关系注入到组件之中  起到的主要作用是解耦

整合SSH

把hibernate的配置写到spring的配置中,用spring管理和调用hibernate的工厂和session等。

struts的话,通常有2中。一种是用spring中的一个工厂类代替struts的工厂类去生成action,并且用spring管理。 另一种是,struts 用自己的工厂生成action,但是由spring管理。这样耦合低一些。

大概就是这样,hibernate负责它最擅长的数据库管理。 struts页面的请求处理调用相应的底层数据库等。spring负责管理他们两个。

整合SSH的三种方法

方法一:直接获得ApplicationContext对象

这种方法通过spring获取与Hibernate相关联的对象。

关键是在Action类中获得ApplicationContext对象,然后通过getBean方法获得JavaBean对象。

(1)在hibernate.cfg.xml文件中配置session-factory

   <session-factory>

      <property name="connection.url">

          jdbc:MySQL://localhost/test?characterEncoding=UTF8

      </property>

      <property name="dialect">

          org.hibernate.dialect.MySQLDialect

      </property>

      <propertyname="connection.username">root</property>

      <propertyname="connection.password">123</property>

      <property name="show_sql">true</property>

      <propertyname="hibernate.hbm2ddl.auto">update</property>

      <property name="connection.driver_class">

          com.mysql.jdbc.Driver

       </property>     

 <!—数据库的实体类映射文件-->

       <mapping resource="User.hbm.xml" />

   </session-factory>

(2)在applicationContext.xml文件中对hibernate相关联的对象使用依赖注入,使用Spring的HibernateTemplate类来对Hibernate的Session进行操作

<bean id="sessionFactory"       class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

      <property name="configLocation"value="classpath:hibernate.cfg.xml">

      </property>

   </bean>

<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">

      <property name="sessionFactory"ref="sessionFactory" />

   </bean>

   <!-- 事务拦截器bean需要依赖注入一个事务管理器 -->

   <bean id="transactionManager"

      class="org.springframework.orm.hibernate3.HibernateTransactionManager">

      <property name="sessionFactory">

          <ref bean="sessionFactory" />

      </property>

   </bean>

   <!-- 设置事务传播特性,对应于AOP中的 <tx:advice />  -->

   <bean id="transactionInterceptor"

      class="org.springframework.transaction.interceptor.TransactionInterceptor">

      <property name="transactionManager">

          <ref bean="transactionManager" />

      </property>

      <property name="transactionAttributes">

          <props>

              <propkey="get*">PROPAGATION_REQUIRED, readOnly

              </prop>

              <propkey="*">PROPAGATION_REQUIRED</prop>

          </props>

      </property>

   </bean>  

    <!-- 定义BeanNameAutoProxyCreator,配置哪些类和哪些方法使用事务对应于AOP中的        <aop:pointcut/> -->  

   <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

      <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

    <property name="beanNames">

          <!-- 下面是所有需要自动创建事务代理的bean-->  

          <list>

              <value>userDAO</value>            

          </list>

          <!-- 此处可增加其他需要自动创建事务代理的bean-->

    </property>

    <property name="interceptorNames">

          <!--  下面定义BeanNameAutoProxyCreator所需的事务拦截器-->  

          <list>

             <value>transactionInterceptor</value>

               <!-- 此处可增加其他新的Interceptor-->

          </list>

      </property>

   </bean>  

   <!--配置数据访问层对象-->

   <bean id="userDAO"class="com.dao.UserDAOImpl">

      <constructor-arg>

          <ref bean="hibernateTemplate" />

      </constructor-arg>

   </bean>

   <!--配置业务逻辑层对象-->

   <bean id="userService"class="com.service.UserServiceImpl">

      <constructor-arg>

          <ref bean="userDAO" />

      </constructor-arg>

   </bean>

(3)配置struts.xml文件

      <action name="loginAction"class="com.test.LoginAction">

          <result name="result">/WEB-INF/result.jsp

          </result>       

      </action>

(4)在Action中获取userService并使用

ApplicationContext applicationContext= WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());

 UserService userService = (UserServiceImpl) applicationContext.getBean("userService");

 userService.addUser(user);

第一种方法的缺点:将Action类鱼Spring的装配JavaBean绑定的过紧,增加了其耦合度,不适合装配文件有变化的情况。

方法二:由Spring创建Action类的对象

在方法一的基础之上需要做如下几步修改

(1)在Action方法中增加setUserService的方法,把UserService交给spring处理

private UserService userService;

public void setUserService(UserServiceuserService) {

   this.userService = userService;

}

(2)在application.xml文件中对action进行配置

<bean id=”loginAction”class=”com.test.LoginAction” scope=”prototype”>

   <property name=” userService”>

       <ref bean=” userService”>

   </property>

</bean>

(3)在struts.xml文件中配置action

<action name=”LoginAction”class=”loginAction”/>

<!—注意这里class指向的是上面配置的bean对象-->

第二种方法的缺点:虽然使用了Spring的IOC特性,对Action和ApplicationContext对象进行了解耦,但配置一个Action需要同时维护两份文件:struts.xml和application.xml,比较难维护。

 方法三:直接使用Spring的自动装配JavaBean的特性进行整合

 在方法一的配置基础上进行如下修改

(1)编写UserAction类,在UserAction中添加setUserService方法,让spring自动装配

private UserService userService;

public void setUserService(UserServiceuserService) {

   this.userService = userService;

}

(2)直接在Struts中配置LoginAction

<action name=”LoginAction”class=”com.test.LoginAction”/>

由于已经在application.xml文件中装配了userService属性,这样spring就可以自动装配LoginAction中的UserService了。

其他

j2ee常用的设计模式,说明工厂模式

总共23种,分为三大类:创建型,结构型,行为型

我只记得其中常用的6、7种,分别是:

创建型(工厂、工厂方法、抽象工厂、单例)

结构型(包装、适配器,组合,代理)

行为(观察者,模版,策略)

然后再针对你熟悉的模式谈谈你的理解即可。

工厂模式

工厂模式是一种经常被使用到的模式,根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例,通常这一组类有一个公共的抽象父类并且实现了相同的方法,但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类,该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类,工厂类可以根据条件生成不同的子类实例。当得到子类的实例后,开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

单例模式

在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。

© 著作权归作者所有

下一篇: Redis小结
巍Will
粉丝 0
博文 17
码字总数 37695
作品 0
朝阳
程序员
私信 提问
shenzhanwang/S2SH

S2SH Struts2,Hibernate,Spring三大框架的整合总是很麻烦,在此提供一个已经整合好三大框架的包,可以直接下载导入Myeclipse使用,项目基于Maven做依赖管理。 其中包含的内容如下: 1.Struts...

shenzhanwang
2016/11/16
0
0
学习三大框架的问题!(求指点)

三大框架虽然在学,但是却不知道三大框架为我做了什么!特别是spring,我该怎么去了解? HibernateDaoSupport能够帮我们做到什么程度?一点感觉都没有!求指点!

tzjbre
2012/09/14
238
2
想请大神指教下一步的学习路线

我是在实习,但是三大框架都还没有学完全就可开始了我的实习生涯...但是感觉三大框架的大体使用方法掌握差不多,而且没有项目做不知道该向哪方面学习,请过来人指教一下

jmsoldier
2014/08/11
316
4
websocket 三大框架

请问websocket通信机制用三大框架如何实现,前端使用html5的websocket API实现,后台是三大框架做的,应该怎么去写才能实现通信呢??求大神讲解下

gdxz110
2014/03/16
2.5K
2
推荐系统遇上深度学习(十四)--《DRN:A Deep Reinforcement Learning Framework for News Recommendation》

之前学习了强化学习的一些内容以及推荐系统的一些内容,二者能否联系起来呢!今天阅读了一篇论文,题目叫《DRN: A Deep Reinforcement Learning Framework for News Recommendation》。该论文...

石晓文的学习日记
2018/06/12
0
0

没有更多内容

加载失败,请刷新页面

加载更多

默认指定logback日志位置

平常我们在使用logback作为日志框架的时候,如果我们不指定日志的绝对路径,就会在我们的当前目录(user.dir)下面生成日志文件,平常我们在开发阶段只要制定一个log目录就好了,但是如果在生...

seno
27分钟前
0
0
浅谈 Spark 的多语言支持

作者:郑锴,花名铁杰,阿里巴巴高级技术专家,Apache Hadoop PMC,Apache Kerby 创立者。深耕分布式系统开发和开源大数据多年,先后专注在安全,存储和计算领域。之前在 Intel,目前转战阿里...

阿里云官方博客
34分钟前
0
0
Windows 10 文件覆盖的坑

Windows 10 下,文件覆盖的时候,如果文件名大小写不同,但字母相同时,会有问题。 如下图,新文件是大写 S 开头,旧文件是小写开头,覆盖后,仍然是小写开头。 不过文件内容是覆盖过来了的,...

yeyi771
35分钟前
2
0
浅谈 Spark 的多语言支持

作者:郑锴,花名铁杰,阿里巴巴高级技术专家,Apache Hadoop PMC,Apache Kerby 创立者。深耕分布式系统开发和开源大数据多年,先后专注在安全,存储和计算领域。之前在 Intel,目前转战阿里...

阿里云云栖社区
39分钟前
4
0
Linux运维常见的硬件及系统问题

一、服务器常见故障和现象 1、有关服务器无法启动的主要原因 : ①市电或电源线故障(断电或接触不良) ②电源或电源模组故障 ③内存故障(一般伴有报警声) ④CPU故障(一般也会有报警声) ⑤主板故...

寰宇01
47分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部