SSH面试题-问答-阿里云开发者社区-阿里云

开发者社区> 问答> 正文

SSH面试题

琴瑟 2017-04-06 22:19:44 3891
1.什么是struts2?struts的工作原理?
struts2:
1)经典的  mvc (Model  View  Controller) 框架                            
  Controller : 核心控制器+Action
  *Struts2的核心控制器是StrutsPrepareAndExecuteFilter
  View:struts2标签库 + ognl
  *ognl:对象图形导航语言。
2)strut2一个基于MVC设计模式的Web应用框架,它本质上相当于一个servlet,在MVC设计模式中,Struts2作为控制器(Controller)来建立模型与视图的数据交互。
3)核心控制器StrutsPrepareAndExecuteFilter、业务控制器Action和用户实现的企业业务逻辑组件。
a.核心控制器StrutsPrepareAndExecuteFilter是Struts 2框架的基础,包含了框架内部的控制流程和处理机制。(2.1前 FilterDispatcher   2.1后  StrutsPrepareAndExecuteFilter)
b.业务控制器Action和业务逻辑组件是需要用户来自己实现的。
c.用户在开发Action和业务逻辑组件的同时,还需要编写相关的配置文件,供核心控制器StrutsPrepareAndExecuteFilter来使用。
工作原理:
   1)浏览器发送请求;
   2)核心控制器StrutsPrepareAndExecuteFilter根据请求决定调用合适的Action;
   3)WebWork的拦截器链自动对请求进行处理;
   4)回调Action的execute方法,该execute方法先获取用户请求参数,然后执行某种数据库操作。
   5)Action的execute方法处理结果信息将被输出到浏览器中。
工作流程:
  1、客户端浏览器发出HTTP请求。
2、根据web.xml配置,该请求被StrutsPrepareAndExecuteFilter接收。
3、根据struts.xml配置,找到需要调用的Action类和方法, 并通过IoC方式,将值注入给Aciton。
4、Action调用业务逻辑组件处理业务逻辑,这一步包含表单验证。
5、Action执行完毕,根据struts.xml中的配置找到对应的返回结果result,并跳转到相应页面。
6、返回HTTP响应到客户端浏览器。
简述 Struts2 的工作流程?
1)请求发送给 StrutsPrepareAndExecuteFilter;
2)StrutsPrepareAndExecuteFilter 判定该请求是否是一个 Struts2 请
求;
3)若该请求是一个 Struts2 请求,则 StrutsPrepareAndExecuteFilter
把请求的处理交给 ActionProxy;
4)ActionProxy 创建一个 ActionInvocation 的实例,并进行初始化;
5)ActionInvocation 实例在调用 Action 的过程前后,涉及到相关拦截
器(Intercepter)的调用;
6) Action 执行完毕,ActionInvocation 负责根据 struts.xml 中的配置;找到对应的返回结果。调用结果的 execute 方法,渲染结果;
7)执行各个拦截器 invocation.invoke() 之后的代码;
8)把结果发送到客户端。
2.struts2的作用?
1)struts2包含一个controller servlet,能将用户的请求发送到相应的Action对象;
2)struts2有JSP自由tag库,并且在controller servlet中提供关联支持,帮助开发员创建交互式表单应用;
3)struts2提供了一系列实用对象:XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息 。
3.struts2的优缺点?
优点:
1) 实现MVC模式,结构清晰;
2) 有丰富的tag可以用 ,Struts的标记库(Taglib),如能灵活动用,则能大大提高开发效率;
3) 使用 OGNL: OGNL 可以快捷的访问值栈中的数据、调用值栈中对象的方
法;
4) 拦截器: Struts2 的拦截器是一个 Action 级别的 AOP, Struts2 中的许多特性都是通过拦截器来实现的, 例如异常处理,文件上传,验证等;
  缺点:
1)转到展示层时,需要配置forward,当转到展示层比较多时,就需要配置多个struts文件,比较麻烦。
2)Struts 的Action必需是线程安全同步方式,它仅仅允许一个实例去处理所有的请求。
3)测试不方便.
4)对Servlet的依赖性过强.
5)对Action执行的控制困难.
6)大量标签书写起来比较复杂。
4.struts2获取表单数据的方法有哪些?
1)通过(字段驱动)属性驱动方式:直接在Action里定义各种Java基本类型的字段(属性),使这些字段与表单数据相对应,并利用这些字段进行数据传递。
   Action直接通过get、set获取;
2)通过模型驱动方式:使用单独的JavaBean(对象)模型进行数据传递。
   必须实现ModelDriven接口,Action必须实现getModel()方法;
5. Struts2提供了几个标签库?都是什么标签库?
  1)html、bean、logic、template和nested
2)html标签: 用来创建能够和Struts 框架和其他相应的HTML 标签交互的HTML;
Bean标签:在访问JavaBeans 及其属性,以及定义一个新的bean;
Logic标签:管理条件产生的输出和对象集产生的循环;
Template标签
Nested标签:增强对其他的Struts 标签的嵌套使用的能力。
6. strust的Action是不是线程安全的?如果不是有什么方式可以保证Action的线程安全?
答:不是线程安全的,只要不申明类变量就可以保证线程安全。因为只存在一个Action类实例,所有线程会共享类变量。
7. update()和saveOrUpdate()的区别?
1)update()和saveOrUpdate()是用来对跨Session的PO进行状态管理的。
2)update()方法操作的对象必须是持久化了的对象。
saveOrUpdate()方法操作的对象既可以是持久化了的,也可以是没有持久化的对象。如果是持久化了的对象调用saveOrUpdate()则会更新数据库中的对象;如果是未持久化的对象使用此方法,则save到数据库中。
8.拦截器的默认引用规则?
1)首先自动引用本包默认的拦截器(栈);
2)本包未定义默认的拦截器(栈),将引用父包的默认拦截器(栈);
3)如果父包也未定义默认拦截器(栈),则不引用任何拦截器(栈)
9.struts2的默认结果类型?
  1)dispatcher:默认结果类型,用来呈现JSP页面;
2)chain:将action和另外一个action链接起来;
3)freemarker:呈现Freemarker模板;
4)httpheader:返回一个已配置好的HTTP头信息响应;
5)redirect:将用户重定向到一个已配置好的URL;
6)redirectAction:将用户重定向到一个已定义好的action;
7)stream:将原始数据作为流传递回浏览器端;
8)velocity:呈现Velocity模板;
9)xslt:呈现XML到浏览器;
10)plaintext:返回普通文本内容。
10.struts2的拦截器?
  a.exception
  b.fileUpload
  c.il8n
  d.modelDriven
  e.params
  f.prepare
  g.token
  h.tokenSession
  i.validation
11.struts2产生表单重复提交的原因?struts2如何防止表单重复提交?
  原因:
  1)服务器处理时间久.
  2)forward跳转引起的重复提交.
  措施:
  1)使用struts2中的token拦截器或者tokenSession拦截器;
  2) 服务器内部使用重定向,配置文件中result标签的type值设为redirectAction。
12. Struts2 拦截器 和 过滤器 的区别?
  1)过滤器依赖于Servlet 容器;拦截器不依赖于Servlet 容器。
  2)Struts2 拦截器只能对 Action 请求起作用;过滤器则可以对几乎所
有请求起作用。
  3)拦截器可以访问 Action 上下文(ActionContext)、值栈里的对象
(ValueStack),而过滤器不能.
  4)在 Action 的生命周期中,拦截器可以多次调用;过滤器只能在容器
初始化时被调用一次.
13. Struts2 中的默认包 struts-default 有什么作用?
  1)struts-default 包是 struts2 内置的,它定义了 struts2 内部的众多拦截器和 Result 类型,而 Struts2 很多核心的功能都是通过这些内置的拦截器实现. 如:从请求中把请求参数封装到action、文件上传和数据验证等等都是通过拦截器实现的。当包继承了struts-default 包才能使struts2 为我们提供的这些功能。
2).struts-default 包是在 struts-default.xml 中定义,struts-default.xml 也是 Struts2 默认配置文件。 Struts2 每次都会自动加载 struts-default.xml 文件。
3)通常每个自定义拦截器包都应该继承 struts-default 包。
14. 如何在 Struts2 中使用 Ajax 功能?
  1)json plugin
2)dojo plugin
3)dwr plugin
4)使用 Stream 结果类型.
15. 拦截器的生命周期与工作过程?
  每个拦截器都是需要实现 Interceptor 接口  
1) init():在拦截器被创建后立即被调用一次;
2)intercept(ActionInvocation invocation):每拦截一个动作请求,
该方法就会被调用一次;
3)destroy:该方法将在拦截器被销毁之前被调用一次。
16. Action接口定义的5个标准字符串常量?
a.success
b.none
c.error
d.input
e.login
f.1个execute()方法。
这5个常量就是在日常开发中字符串,可以简化和标准化execute方法的返回值。
17.struts2中,Action继承ActionSupport类的好处?
1)ActionSupport类所实现的接口主要有: Action, LocaleProvider, TextProvider, Validateable, ValidationAware ,这些接口中提供了一些方法可以实现数据校验功能、国际化等功能。
2)a.读取国际化信息
b.处理验证错误
c.处理类型转换错误
18. Struts2 如何访问 HttpServletRequest、HttpSession、ServletContext三个域对象 ?
1)与 Servlet API 解耦的访问方式
a. 通过 ActionContext 访问域对象对应的 Map 对象;
b.通过实现 Aware 接口使 Struts2 注入对应的 Map 对象;
2)与 Servlet API 耦合的访问方式
a.通过 ServletActionContext 直接获取 Servlet API 对象;
b.通过实现 ServletXxxAware 接口的方式使 Struts2 注入对应的对象.







































Hibernate面试题
1.什么是Hibernate?
1) Hibernate是一个面向Java环境的对象/关系数据库映射工具;
2) Hibernate不仅仅管理Java类到数据库表的映射,还提供数据查询和获取数据的方法;
3) Hibernate的目标是对于开发者通常的数据持久化相关的编程任务.
Hibernate是采用ORM模式实现数据持久层的一个优秀的JAVA组件,它提供了强大,高效的对JAVA对象进行持久化操作的服务。
2.Hibernate工作原理及为什么要用?
工作原理:
a.读取并解析配置文件
b.读取并解析映射信息,创建SessionFactory
c.打开Session
d.创建事务Transation
e.持久化操作
f.提交事务
g.关闭Session
h.关闭SesstionFactory
工作原理:
  1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件;
2.由hibernate.cfg.xml中的
<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息;
3.通过config.buildSessionFactory();//创建SessionFactory
4.sessionFactory.openSession();//打开Sesssion
5.session.beginTransaction();//创建事务Transation
6.persistent operate //持久化操作
7.session.getTransaction().commit();//提交事务
8.关闭Session  
9.关闭SesstionFactory
工作流程:
1.导包
2.配置SessionFactory  hibernate.cfg.xml
3.编写对应的javabean 以及映射文件 Xxx.hbm.xml
4.编写dao层
5.测试
  a.获取sessionFactory
  b.获取session
  c.开始事务
  d.执行业务操作(增删该查)
  e.提交事务
  f.回滚事务
  g.关闭session
  h.关闭sessionFactory
为什么要用:
1). Hibernate对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。
2). Hibernate是一个基于JDBC的主流数据持久化框架,是一个优秀的ORM实现,简化DAO层的编码工作 。
3). hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。
4). hibernate的性能非常好,因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库,从一对一到多对多的各种复杂关系。
5)缓存机制,提供了一级缓存和二级缓存。
3.hibernate的优缺点?
优点:
1)对 JDBC 访问数据库的代码做了封装,简化了数据访问层繁琐的重复
性代码;
2)映射的灵活性, 它支持各种关系数据库;
3)非侵入性、移植性会好;
4)缓存机制: 提供一级缓存和二级缓存;
5)简洁的HQL编程。
缺点:
1)无法对 SQL 进行优化;
2)框架中使用 ORM 原则, 导致配置过于复杂。
3)Hibernate在批量数据处理时有弱势;
4)针对单一对象简单的增删查改,适合于Hibernate,而对于批量的修改,删除,不适合用Hibernate。
3.Hibernate是如何延迟加载?
1) Hibernate延迟加载实现:a.实体对象 b.集合(Collection)
2) Hibernate 提供了属性的延迟加载功能。
当Hibernate在查询数据的时候,数据并没有存在与内存中,当程序真正对数据的操作时,对象才存在与内存中,就实现了延迟加载,它节省了服务器的内存开销,从而提高了服务器的性能。  
4.hibernate的关系映射包括哪些?Hibernate中怎样实现类之间的关系?(如:一对多、多对多的关系)
  1)a.一对一:单向一对一关联中的外键字段具有唯一性约束
b.一对多
     c.多对一
     d.多对多
2)类与类之间的关系主要体现在表与表之间的关系进行操作,它们都是对对象进行操作。在程序中把所有的表与类都映射在一起,它们通过配置文件中的many-to-one、one-to-many、many-to-many 进行实现。
5.什么是ORM?
1)ORM(Object/Relational Mapping):对象关系数据映射.
2)O: Object(对象)在业务逻辑层和表示层将各参与实体进行面向对象封装;
   R: Rational(关系型数据)
   M:mapping(映射)
6. mybatis和hibernate优化哪个比较好?mybatis优缺点?
优点:
1)mybatis更容易进行SQL的优化。
2) mybatis可以进行细粒度的优化。在一个表中,如果需要更新一条记录时,hibernate需要现把对象select 出来,然后再做 update;mybatis只需要一条 update 的SQL就可以进行多数据的更新。
3)mybatis可维护性比较好。mybatis 中SQL都保存到单独的xml文件中;hibernate在 java 代码中保存sql/hql。
4)在不考虑 cache 的情况下,mybatis会比Hibernate快。
5)hibernate是全自动,而mybatis是半自动;
缺点:
  1)不同数据库类型的支持不好。
  2)缺省的 cache 支持不好。
7.Hibernate与mybatis的区别?
1)hibernate是全自动,而mybatis是半自动。
hibernate完全可以通过对象关系模型实现对数据库的操作,拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。而mybatis仅有基本的字段映射,对象数据以及对象实际关系仍然需要通过手写sql来实现和管理.
2)hibernate数据库移植性远大于mybatis。
hibernate通过它强大的映射结构和hql语言,大大降低了对象与数据库(oracle、mysql等)的耦合性,而mybatis由于需要手写sql,因此与数据库的耦合性直接取决于程序员写sql的方法.
3)hibernate拥有完整的日志系统,mybatis则欠缺一些。
hibernate日志系统非常健全,涉及广泛,包括:sql记录、关系异常、优化警告、缓存提示、脏数据警告等;而mybatis则除了基本记录功能外,功能薄弱很多。
4)mybatis相比hibernate需要关心很多细节。
hibernate配置要比mybatis复杂的多,学习成本也比mybatis高。
5)sql直接优化上,mybatis要比hibernate方便很多。
mybatis的sql都是写在xml里,因此优化sql比hibernate方便很多。而hibernate的sql很多都是自动生成的,在java程序中,无法直接维护sql;
7.1.Hibernate与MyBatis区别?
1)Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory,然后由SessionFactory 生成Session,最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider,SessionFactory,Session的生命周期都是差不多的。
2)Hibernate和MyBatis都支持JDBC和JTA事务处理。
Mybatis优势:
1)MyBatis可以进行更为细致的SQL优化,可以减少查询字段。
2)MyBatis容易掌握,而Hibernate门槛较高。
Hibernate优势:
1)Hibernate的DAO层开发比MyBatis简单,Mybatis需要维护SQL和结果映射。
2)Hibernate对对象的维护和缓存要比MyBatis好,对增删改查的对象的维护要方便。
3)Hibernate数据库移植性很好,MyBatis的数据库移植性不好,不同的数据库需要写不同SQL。
4)Hibernate有更好的二级缓存机制,可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。
8.sessionFactory是用来干什么的?
创建session
9. mybates常用的paramerType都有啥?
  string、int、byte
10.hibernate中get和load的区别?
  1)get: 采用即刻加载, get查询不到的时候得到null;
     load: 默认采用延迟加载,查询不到的时候抛出异常;
2)get()方法:get 先查询一级缓存,再查询二级缓存最后查询数据库,如果没有数据则出现null。
load()方法:查询数据时会先找Hibernate的一级缓存,如果没有就生成一个代理对象,在后面用它的非主属性的时候再查询二级缓存,还没有找到数据就查询数据库,若还没有找到就抛出异常。
11.Hibernate的缓存范围?
1)事务范围: 一级缓存属于事务范围
  a.Session级别的缓存;
  b. 轻量级的,和实际的业务相关联;
  c. 这一级别的缓存由hibernate管理的,一般情况下无需进行干预。
2)应用范围: 二级缓存属于应用范围
  a. SessionFactory级别的缓存;
  b. 重量级组件,管理session;
  c. 这一级别的缓存可以进行配置和更改,并且可以动态加载和卸载。
3)集群范围
12.什么是pojo? Hibernate实体对象生命周期的三种状态以及它们之间的相互转换?
  Pojo(plain oid java object):hibernate操作的java对象。
  1) 瞬时态 (临时态transient):不在session的管理之中,数据库中也没有oid;
  2) 持久态(persistent): 在session的管理之中;
  3) 脱管态(游离态detached):不在session的管理之中,数据库中有oid。
转换:
a.瞬时态-->持久态:save()
     在Session里存了一份,也就是它的缓存里放了一份,然后,又到数据库里存了一份。
b.持久态--> 游离态:Close()
     它的缓存也都关闭了,整个Session也就失效了,这个时候,这个对象变成了游离状态(Detached),但数据库中还是存在的。
c.游离态-->持久态:update()
d.持久态-->瞬时态:delete()
  数据库中没有与之对应的记录。
13. Hibernate有哪几种查询数据的方式?
   1)HQL查询
2)QBC查询
3)SQL查询
14. Hibernate的核心接口?
1)Configuration: Configuration接口负责配置并启动Hibernate,创建SessionFactory对象。
2)SessionFactory: SessionFactroy接口负责初始化Hibernate。
3)Session: Session接口负责执行被持久化对象的CRUD操作。
4)Transaction: Transaction接口负责事务相关的操作。
5)Query: Query接口负责执行各种数据库查询。
15.mybates管理数据操作的方式及特点?
  1)SqlSessionTemplate:这个需要写配置文件,在实现类中注入sqlSession,再使用sqlSession,是细颗粒控制。
  2)SqlSessionDaoSupport:这个只需要在实现类中继承特殊类就可以使用sqlSession。
  3) MapperFactoryBean:这个要写配置文件,把对应的所有接口在配置文件中引用即可,无需写实现类。
  4)MapperScannerConfigurer: 这个要写配置文件,只要给出接口所在包即可,会自动把包口中的接口引入,无需写实现类。
16.hibernate生成主键的方式?
  1)Assigned:由程序生成主键值,并且要在save()之前指定否则会抛出异常;
特点:主键的生成值完全由用户决定,与底层数据库无关。
  2)Hilo: 使用高低位算法生成主键。
   特点:需要额外的数据库表的支持,能保证同一个数据库中主键的唯一性,但不能保证多个数据库之间主键的唯一性。
  3)Increment:采取自动增长的方式生成新的主键值,但要求底层数据库的支持Sequence。
     特点:由Hibernate本身维护,适用于所有的数据库,不适合多进程并发更新数据库,适合单一进程访问数据库。
   4)Identity:用于MySql数据库。
      特点:递增.
  5)Sequence:用于Oracle数据库;
      特点:需要底层数据库的支持序列。
  6)Native:主键生成方式会根据不同的底层数据库自动选择Identity、Sequence、Hilo主键生成方式。
      特点:根据不同的底层数据库采用不同的主键生成方式。
7)uuid:使用128位UUID算法生成主键。
      特点:能够保证数据库中的主键唯一性。
  8)Foreign guid:用于一对一关系共享主健时,两id值一样。  
17.hibernate中获取session时,opensession()和getCurrentSession()的区别?
1)getCurrentSession() 它会先查看当前线程中是否绑定了 Session,
如果有则直接返回, 如果没有再创建;
openSession() 则是直接 new 一个新的 Session 并返回。
2)使用 ThreadLocal 来实现线程 Session 的隔离。
3)getCurrentSession() 在事务提交的时候会自动关闭 Session;
openSession() 需要手动关闭.
18. Hibernate的检索方式?
   1)导航对象图检索
   2)Oid检索
   3)Hql检索
   4)Qbc检索
   5)本地Sql检索
19.Hql和sql的区别?
1)hql 面向对象查询;
sql 面向数据库表查询。
2)hql:from 后面跟的 类名+类对象 where 后用对象的属性做条件查询;
Sql:from 后面跟的是表名 where 后 用表中字段做条件查询。
20.hibernate的事务通知有哪些?
   1)前置通知:指在连接点之前,先执行通知中的代码。
   2)后置通知:指在连接点之后,再执行通知中的代码。
   3)最终通知:指在最终执行通知中的代码。
   4)异常通知:指在出现异常的时候执行通知中的代码。
   5)环绕通知:指在程序运行期间随时可以执行通知中的代码。
















spring面试题
1.什么是spring?
Spring是一个开源的,轻量级的Ioc和AOP容器框架。
Spring框架的核心是IOC容器(DI,控制反转容器)和Aop,目的是提供一个高扩展性、组件化以及无侵入代码的应用开发框架。
2.spring的工作原理?
  
3. 说说AOP和IOC的概念、作用?
1)Ioc(反向控制): 由对象自身创建自己的关联或者依赖对象,改变为由外部容器将关联或依赖对象注入。实现bean的装配(以前是由对象自己new自己,现在改变为由web容器注入)
a.IoC就是通过依赖注入实现的。
b.DI的注入方式有两种:setter注入和构造器注入。
Spring的IOC容器通过配置文件、Java反射机制等手段管理维护Bean的创建以及Bean之间的依赖关系。
作用:Spring通过使用反向控制(Ioc)来实现组件之间的解耦合。
2)Aop(面向切面): 横切一个关注点,将一个关注点模块化成一个切面。实现声明式事务管理(关注事物的相同点,把相同点集合在一起统一进行管理,让程序员只进行关注自己的业务处理)
作用:Spring通过面向切面编程轻松实现系统级的横跨多个组件的功能模块化、独立化;
目的:解耦合
4.项目中如何体现AOP面向切面编程?
  1)面向切面编程:主要是横切一个关注点,将一个关注点模块化成一个切面。在切面上声明一个通知和切入点。
  2) 项目中用到的Spring中的切面编程最多的地方:声明式事务管理。
在applicationContext.xml中进行如下配置:
a、定义一个事务管理器
b、配置事务特性(相当于声明通知。一般在业务层的类的一些方法上定义事务)
c、配置哪些类的哪些方法需要配置事务切入点(相当于切入点。一般是业务类的方法上)
功能:日志记录,性能统计,安全控制,事务处理,异常处理。
a. 将日志记录,性能统计,安全控制,事务处理,异常处理等代码从业务逻辑代码进行隔离出来,让程序员只关注业务逻辑的处理。
b.动态植入
5.项目中如何体现ioc控制反转?
  1) 创建一个beans.properties文件,用于存放bean的具体实现;
2) 创建一个制造bean的工厂,通过反射来创造写在配置文件里面的那些bean;
3) 创建一个InitBeanFactoryServlet,该servlet在web.xml里面不需要配置对应的map,因为只有在初始化的时候会用到,但是需要设置启动项为0,让他最先初始化;
4) 创建一个BaseServelt,所有别的servlet都继承自他,他的子类会先调用他的service方法,通过反射查看子类里面有没有bean的set方法,如果有就在ServletContext里面获取对应的bean。
以前是由对象自己new自己,现在改变为由web容器注入,不需要new对象。
6. IOC 容器对 Bean 的生命周期?
  Bean的定义、Bean的初始化、Bean的使用、Bean的销毁
1)通过构造器或工厂方法创建 Bean 实例
2)为 Bean 的属性设置值和对其他 Bean 的引用(set、get、无参构造函数)
3)将 Bean 实例传递给 Bean 后置处理器的postProcessBeforeInitialization 方法
4)调用 Bean 的初始化方法(init-method)
5)将 Bean 实例传递给 Bean 后置处理器的postProcessAfterInitialization 方法
6)Bean 可以使用了
7)当容器关闭时, 调用 Bean 的销毁方法(destroy-method)
7.spring的优点?
  1)使用Spring的IOC容器,将对象之间的依赖关系交给Spring,降低组件之间的耦合性;
2)可以提供众多服务,事务管理,WS等;
3)AOP面向切面编程;
4) 对主流的框架提供了很好的集成支持;
5) Spring DI机制降低了业务对象替换的复杂性;
6) Spring属于低侵入性,代码污染极低;
7)Spring的高度可开放性,并不强制依赖于Spring,开发者可以自由选择Spring部分或全部。
8.Spring的两种容器?
  Spring容器是一个Java对象,它封装了配置文件的信息,容纳JavaBean的实例对象,它使用IoC管理所有组成应用系统的组件。
1)Bean工厂(BeanFactory父类):是最简单的容器,提供了基础的依赖注入支持。
2)应用上下文(ApplicationContext子类): Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息,扩展了Bean工厂,提供了系统构架服务,功能更强大。
9. Spring实现了那几种模式?  
答: 工厂模式 和 单例模式
10.spring中对象的创建模式?
1)单例模式scope="singleton"
2)原型模式scope="prototype"
11.什么是事务传播机制?spring事务传播机制分为哪几种?
事务传播机制:同一个对象在不同业务下的一个状态。
1)required,这个是默认的属性:如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。
2) mandatory:支持当前事务,如果当前没有事务,就抛出异常。
3)never:以非事务方式执行,如果当前存在事务,则抛出异常。
4)not_supported:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。?
5)requires_new:新建事务,如果当前存在事务,把当前事务挂起。
6)supports:支持当前事务,如果当前没有事务,就以非事务方式执行。
7)nested:支持当前事务,新增Savepoint点,与当前事务同步提交或回滚。
12.事务隔离级别都有哪些?
1)default: 默认的隔离级别,使用数据库默认的事务隔离级别。
2)read_committed:保证一个事务修改的数据提交后才能被另外一个事务读取。
3) read_uncommitted:事务最低的隔离级别,它充许别外一个事务可以看到这个事务未提交的数据。
4) repeatable:这种事务隔离级别可以防止脏读,不可重复读。
5) repeatable_read:最可靠的事务隔离级别。
13. 事务并发引起哪三种情况?
1)脏读
2)不可重复读
3)幻像读
14. Spring两种事务管理方式?
  1)声明式: 使用TransactionTemplate和直接使用PlatformTransactionManager直接管理事务。
        TransactionTemplate:它使用回调方法,把应用程序从处理取得和释放资源中解脱出来TransactionTemplate是线程安全的 ;
        PlatformTransactionManager  : 通过一个bean引用给你的bean传递一个你使用的 PlatformTransaction对象。然后,使用TransactionDefinition和TransactionStatus对象就可以发起、回滚、提交事务。
  2)编程式:通过AOP实现的。
15. spring配置文件中的ref元素的作用是什么?它的两个基本属性是什么?
1)用于指定属性值为spring容器中的其它bean.
2)两个基本属性是bean和local
16.clear和evcit的区别?
  1)clear:完整的清除session。
  2)evcit(obj):把某个持久化对象从session的缓存中清空。
17.session的清理和清空的区别?
  1)a.清理缓存:调用session.flush()方法
     b.清空缓存:调用session.clear()方法
  2)a.清理缓存:指按照缓存中对象的状态的变化来同步更新数据库,但不清空缓存。
     b.清空缓存:把session的缓存清空,但不同步更新数据库。
18.简单介绍一下spring?
Spring是一个开源框架,是一个轻量级的Ioc和AOP容器框架。
1) 核心容器(beanFactory): 核心容器定义了创建、配置和管理 bean 的方式, 主要是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转 (IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
2)Spring 上下文(applicationContext):Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。
3)Spring AOP:通过面向切面编程轻松实现系统级的横跨多个组件的功能模块化、独立化;只关注业务逻辑的处理。
  4)Spring Dao: JDBC DAO 抽象层提供了有意义的异常层次结构,通过该结构可以管理异常处理和不同数据库供应商抛出的错误消息。
  5)Spring ORM:提供ORM 的对象关系映射工具,可以对数据的基本操作。
6)Spring Web :Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文,Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
7)Spring MVC 框架:MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现.
Ioc控制反转:由对象创建自己的关联或依赖注入,改变为由外部容器将关联或依赖注入。
Aop 面向切面:横切一个关注点,将一个关注点模块化成一个切面。(关注事物的相同点,把相同点集合在一起统一进行管理,让程序员只进行关注自己的业务处理。)
19. 开发中主要使用 Spring 的什么技术 ?
1)IOC 容器管理各层的组件
2)使用 AOP 配置声明式事务
3)整合其他框架.
20. 在 Spring 中如何配置 Bean ?
1)通过全类名(反射)
2)通过工厂方法(静态工厂方法 & 实例工厂方法)
3)FactoryBean
21. Spring 如何整合 Struts2 ?
  整合 Struts2, 即由 IOC 容器管理 Struts2 的 Action。
  1)安装 Spring 插件: 把 struts2-spring-plugin-2.2.1.jar 复制到当前 WEB 应用的 WEB-INF/lib 目录下;
  2)在 Spring 的配置文件中配置 Struts2 的 Action 实例;
  3)在 Struts 配置文件中配置 action, 但其 class 属性不再指向该
Action 的实现类, 而是指向 Spring 容器中 Action 实例的 ID。
22. spring如何整合hibernate?
   整合 Hibernate, 即由 IOC 容器生成 SessionFactory 对象, 并使用
Spring 的声明式事务管理。
   1)利用 LocalSessionFactoryBean 工厂 Bean, 声明一个使用 XML 映
射文件的 SessionFactory 实例;
   2)利用 HibernateTransactionManager 配置 Hibernate 的事务管理器。
23. 开发中主要使用 Spring 的什么技术 ?
1)IOC 容器管理各层的组件
2)使用 AOP 配置声明式事务
3)整合其他框架.
24.springMVC和struts2的区别?
  1)Spring MVC 的入口是 Servlet;Struts2 是 Filter。
  2)Spring MVC 会稍微比 Struts2 快些. Spring MVC 是基于方法设;Sturts2 是基于类, 每次发一次请求都会实例一个 Action.
  3)Spring MVC 使用更加简洁, 开发效率Spring MVC 确实比struts2 高:
支持JSR303, 处理 ajax 的请求更方便.
  4)Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些.
25.springMVC的工作原理?
工作原理:
1) spring把所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责对请求进行真正的处理工作;
2) DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller;
3) DispatcherServlet把请求提交到目标Controller;
4) Controller进行业务逻辑处理后,会返回一个ModelAndView;
5) Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象;
6) 视图对象负责渲染返回给客户端。
26. 如何使用 SpringMVC 完成 JSON 操作?
1)配置MappingJacksonHttpMessageConverter
2)使用 @RequestBody 注解或 ResponseEntity 作为返回值
27. 说出 Spring MVC 常用的 5 个注解?
@RequestMapping 、@PathVariable 、@RequestParam .@RequestBoy 、@ResponseBody
28.springMVC的优点?














Ssh面试题
1. 项目中如何使用ssh框架技术?
1)struts2:
a. struts只是专注于实现Web应用程序开发的MVC前端部分,很好的将应用程序进行了分层,使开发者更关注于业务逻辑的实现;
b. struts有着丰富的taglib库,能大大提高开发效率。
2)hibernate:
hibernate为Java应用提供了一个易用的、高效率的对象关系映射框架。hibernate是个轻量级的持久性框架,只是专注于数据持久层的部分。
3)spring:
spring基于IoC(反向控制)和AOP构架多层j2ee系统的框架,整合struts2和hibernate以及管理对象的配置和生命周期.IoC使得可以很容易的实现bean的装配,提供了简洁的AOP并据此实现事务管理。
2.搭建ssh框架时应注意什么?
  1)用MyEclipse搭建SSH环境时,注意jar包的选取
3.ssh框架工作流程?
1)创建web工程;
2)导jar包;
3)在web.xml中配置struts2核心控制器和spring上下文jianting器;
4) 建立struts2配置文件(struts.xml)和建立spring配置文件(applicationContext.xml);
5)在spring配置文件中配置SessionFactory、事务管理器、事务通知、事务切面;
6)建立bean层、dao层、service层、action层;
7)配置struts2-xx.xml ,hibernate.hbm.xml文件;
8)在applicationContext.xml中写dao、bean、service;
9)然后在struts.xml中配置struts由spring管理的<constant name=”struts.objectFactory” value=”spring”>,前台发起请求。
10)Hibernate中的配置的id(sessionFactory)在baseDao中作为它的一个属性出现;
11)spring来集成struts和hibernate,然后struts每个业务的class以前是完全限定的类名,现在变成单个的spring中集成好的bean的id的名字。
12)Spring管理一个hibernate连接数据库,把对应的属性、连接驱动全部引入进去,把struts的bean的属性的库全部管理起来,而hibernate和struts功能不变。
4.Sql大数据如何进行优化?
1)对查询进行优化,应尽量避免全表扫描,首先应考虑在 where 及 order by 涉及的列上建立索引;
2)应尽量避免在 where 子句中对字段进行 null 值判断;
3)应尽量避免在 where子句中使用!=或<>操作符;
4) .应尽量避免在 where 子句中使用 or 来连接条件;
5)in 和 not in 也要慎用;
6)下面的查询也将导致全表扫描:select id from t where name like '%abc%';
7)尽量别在 where 子句中使用参数;
8)应尽量避免在 where 子句中对字段进行表达式操作。
9)应尽量避免在where子句中对字段进行函数操作.
10)不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算。
11)不要写一些没有意义的查询;
12)用 exists 代替 in;
13)尽量使用数字型字段,若只含数值信息的字段尽量不要设计为字符型,这会降低查询和连接的性能,并会增加存储开销。
14)尽可能的使用 varchar/nvarchar 代替 char/nchar;
15)尽量使用表变量来代替临时表;
16)避免频繁创建和删除临时表,以减少系统表资源的消耗;
17)尽量避免使用游标;
18)尽量避免大事务操作,提高系统并发能力;
19)尽量避免向客户端返回大数据量.
                                                                                                                                                                                                                            
SQL 缓存 前端开发 安全 Java 数据库连接 数据库 Spring mybatis 容器
分享到
取消 提交回答
全部回答(0)
数据库
使用钉钉扫一扫加入圈子
+ 订阅

分享数据库前沿,解构实战干货,推动数据库技术变革

推荐文章
相似问题