ssh总结

一、Struts

在没有学习SSH框架前，我们一般采用Jsp+java

bean+servlet开发，这里就是MVC架构。而Struts其实就是替代了Servlet，我们知道Servlet在一般的开发中做控制页面跳转，同时调用系统的业务逻辑层。现在想想Struts是不是做一样的是？只是它能够更加的提高开发速度。我们Servlet开发时，是要创建一个Servlet其实就是继承了HttpServlet这个类。而现在Struts里面的Action也要集成一个ActionSupport类。这里可以看到其实Struts基本上和Servlet差不多，但是其中也各有不同。下面就介绍一下其中的差异：首先从接收参数上，Struts可以避免我们重复的调用

request.getParameter("pName")这个方法，Struts可以貌似可以是用四种方式

1.使用ModelDriven

在创建Action 的时候，发现Action 实现了ModelDriven 接口，去调用接口的getModel()方法，取到了相关对象。

相应提交方式可以用get 和post，如：testAction? name=admin view plain

1. public class TestAction extends BaseAction implements ModelDriven<ResBananRc>{

2. private static final long serialVersionUID = -7463970150000893325L;

3. private ResBananRc resBananRc = new ResBananRc();//这里要手动的New下

4. public ResBananRc getModel() {

5. return resBananRc;

6. }

7. public void execeute() {

8. System.out.println("姓名：" + resBananRc.getName());

9. }

10. }

2.用Action 的属性

在action中定义要接收的参数，并创建getter，setter方法，参数变量名要和传递过来的参数名一样，并不用做数据类型的转换。相应提交方式可以用get 和post，如：testAction? name=admin view plain

1. public class TestAction extends BaseAction{

2. private static final long serialVersionUID = -7463970150000893325L;

3. private String name;

4. public void execeute() {

5. System.out.println(name +" : " + name);

6. } public String getName() {

7. return name;

8. }

9. public void setName(String name) {

10. this.name = name;

11. }

12. }

3。使用Domain Model

在Action 里面不存很多的属性，而是用Model 层用到的模型，保存它的一个对象。相应提交方式可以用get 和post，如：testAction? resBananRc.name=admin（这是比较常用的）

view plain

第二篇：ssh面试题总结

SSH面试题总结

题目1：Hibernate工作原理及为什么要用？

原理：

hibernate，通过对jdbc进行封装，对 java类和关系数据库进行mapping，实现了对关系数据库的面向对象方式的操作，改变了传统的jdbc + sql操作数据的方式，从而使开发人员可以话更多精力进行对象方面的开发

ssh面试题总结

1.读取并解析配置文件

2.读取并解析映射信息，创建SessionFactory

3.打开Sesssion

4.创建事务Transation

5.持久化操作

6.提交事务

7.关闭Session

8.关闭SesstionFactory

为什么要用：

1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

3. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

题目2：什么是Hibernate延迟加载?

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

题目3：Hibernate中类之间的关联关系有几种?(如：一对多、多对多的关系) many-to-one、one-to-many、many-to-many、 one-to-one

题目4：说下Hibernate的缓存机制

一、hibernate一级缓存

（1）hibernate支持两个级别的缓存，默认只支持一级缓存；

（2）每个Session内部自带一个一级缓存；

（3）某个Session被关闭时，其对应的一级缓存自动清除；

二、hibernate二级缓存

(1) 二级缓存独立于session，默认不开启；

题目5： Hibernate的查询方式

本地SQL查询、Criteria、Hql

题目6：如何优化Hibernate？

1.使用双向一对多关联，不使用单向一对多

2.不用一对一，用多对一取代

3.配置对象缓存，不使用集合缓存

题目7： Struts工作机制？为什么要使用Struts？

工作机制：

Struts的工作流程:

在web应用启动时就会加载初始化ActionServlet,ActionServlet从

struts-config.xml文件中读取配置信息,把它们存放到各种配置对象

ssh面试题总结

当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组件生成动态网页,返回给客户;

为什么要用：

1. JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用

这些技术构建的系统非常的繁乱。

2. 基于Struts开发的应用:

不用再考虑公共问题

专心在业务实现上

结构统一，易于学习、维护

新手也可写出好程序

题目10：为什么要用spring?

Spring是一个轻量级的IOC和AOP框架。

IOC（控制反转）意味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这称为控制反转

AOP（面向切面），它将那些影响多个类的行为封装到可重用的模块中，面向对象是把问题从同类事物中抽象出来，面向切面是把问题从不同类问题中抽象出来。

1. hibernate中get()与load()区别

请注意如果没有匹配的数据库记录，load()方法可能抛出无法恢复的异常(unrecoverable exception)。如果类的映射使用了代理(proxy)，load()方法会返回一个未初始化的代理，直到你调用该代理的某方法时才会去访问数据库。若你希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上的了。如果为相应类映射关系设置了batch-size，那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象的数据）。如果你不确定是否有匹配的行存在，应该使用get()方法，它会立刻访问数据库，如果没有对应的行，会返回null。

17. [Hibernate题目]判断题：使用save/persist一个对象时，便立即向数据库发送执

行insert sql语句？

1) persist把一个瞬态的实例持久化，但是并"不保证"标识符被立刻填入到持久

化实例中，标识符的填入可能被推迟到flush的时间。

2) persist"保证"当它在一个transaction外部被调用的时候并不触发一个Sql

Insert，这个功能是很有用的。

3) save会立即执行Sql insert，不管是不是在transaction内部还是外部.

18.[Hibernate题目]：指出一下代码哪里错误使用了Hibernate。

背景简介：Board是一个实体类，id是它的主键，name和description是他的两个属性。BoardDao是Board实体的数据访问对象，BoardBo是业务对象，用户提交变更Board对象的请求，由Struts的BoardAction接收，调用BoardBo处理。HibernateUtil.currentSession()用于返回当前请求的Session对象。

1. //数据访问层代码：BoardDao.java

2. public Board loadBoard(Long id) {

3. Session session = HibernateUtil.currentSession();

4. return session.load(Board.class, id);

5. }

6. public void updateBoard(Board board) {

7. Session session = HibernateUtil.currentSession();

8. session.update(board);

9. }

10.

11. //业务对象层代码：BoardBo.java

12. private BoardDao boardDao;

13. public void updateBoard(Long id, String name, String description) {

14. Board board = boardDao.loadBoard(id);

15. board.setName(name);

16. board.setDescription(description);

17. boardDao.updateBoard(board);

18. }

19.

20. //Web控制器代码：BoardAction.java

21. private BoardBo BoardBo;

22. public ActionForward execute(

23.ActionMapping mapping,

24.ActionForm form,

25.HttpServletRequest request,

26.HttpServletResponse response) throws Exception {

27. String id = request.getParameter("id");

28. String name = request.getParameter("name");

29. String description = request.getParameter("description");

30. boardBo.updateBoard(id, name, description);

31. return mapping.findForward("update-success");

32. }

6. public void updateBoard(Board board) {

7. Session session = HibernateUtil.currentSession();

Transaction t=session.beginTransaction();

8. session.update(board);

t.commit();

9. }

简单叙述一下Spring中BeanFactory与ApplicationContext的差别

使用BeanFactory从xml配置文件加载bean: import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.core.io.FileSystemResource;

public class XmlConfigWithBeanFactory {

public static void main(String[] args) {

XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource( "build/beans.xml"));

}

使用ApplicationConText从xml配置文件加载bean:

public class XmlConfigWithApplication{

public static void main(String[] args){

ApplicationContext application = new ClassPathXmlApplicationContext(beans.xml"));

application.getBean("BeanName");

}

简而言之，BeanFactory提供了配置框架和基本的功能，而

ApplicationContext为它增加了更强的功能，这些功能中的一些或许更加接近

J2EE并且围绕企业级应用。一般来说，ApplicationContext是 BeanFactory的完全超集，任何BeanFactory功能和行为的描述也同样被认为适用于ApplicationContext

相对于BeanFactory而言,ApplicationContext 提供了以下扩展功能. (a) 国际化支持 (b) 资源访问

2. 写一段程序，使用springAPI读取classpath下的一个xml文件，并解析

(1)Resource resource=new ClassPathResource("appcontext.xml");

BeanFactory factory=new XmlBeanFactory(resource);

(2)ClassPathXmlApplicationContext appcontext=new

ClassPathXmlApplicationContext("appcontext.xml");

BeanFactory factory=(BeanFactory)appcontext;

4. 说说在hibernate中使用Integer做映射和使用int做映射之间有什么差别

Integer code和int code;的区别:

Integer是对象. code = null; 对象可以为空.

int 是普通类型, 不可能 = null.

根据你的数据库code是可以空的, 故应该映射成Integer.

你没理由hbm.xml里写Integer, 类里却写int

(1)使用Spring如何简化了Hibernate编码？

通过org.springframework.orm.hibernate3.support.HibernateDaoSupport类支持数据库操作,且封装了事务.

public class AccountDAO extends HibernateDaoSupport implements IAccountDAO{

(2)Spring如何与Struts集成？

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts

Configuration 1.2//EN" "/dtds/struts-config_1_2.dtd">

<struts-config>

<data-sources />

<form-beans >

<form-bean name="regForm" type="demo.form.RegForm" />

</form-beans>

<global-exceptions />

<global-forwards />

<action-mappings >

<action

attribute="regForm"

name="regForm"

path="/reg"

scope="request"

type="org.springframework.web.struts.DelegatingActionProxy">

</action>

</action-mappings>

<message-resources parameter="demo.ApplicationResources" />

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

<set-property property="contextConfigLocation"

value="/WEB-INF/classes/applicationContext.xml" />

</plug-in>

</struts-config>

(3)如何使用Spring2.0实现声明式事务？

<bean id="TransactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" />

</bean>

<tx:advice id="txAdvice" transaction-manager="TransactionManager">

<tx:attributes>

<tx:method name="get*" propagation="SUPPORTS"

read-only="true" />

<tx:method name="load*" propagation="SUPPORTS"

read-only="true" />

<tx:method name="search*" propagation="SUPPORTS"

read-only="true" />

<tx:method name="*" propagation="REQUIRED" />

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="bizMethods" expression="execution(* demo.*.*(..))" />

<aop:advisor advice-ref="txAdvice" pointcut-ref="bizMethods" /> </aop:config>

(4)依赖注入的好处是？

程序可扩展性更强;

利于并行开发；

(5)Spring怎么实现依赖注入？

<?xml version="1.0" encoding="UTF-8"?>

<beans

xmlns="/schema/beans"

xmlns:xsi="/2001/XMLSchema-instance"

xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.0.xsd">

</bean>

</beans>

(6)“面向方面编程”的好处是？

将程序中涉及的公共问题集中解决

(7)和SQL相比，HQL有哪些特点？

HQL是面向对象的查询语言。select Fw表示查询Fw对象

(8)如何配置单向多对一关联？

</id>

<many-to-one name="qx" class="Qx" column="qxid" />

</class>

(9)如何配置单向一对多关联？

</id>

<one-to-many class="Jd" />

</set>

</class>

(10)如何配置双向一对多关联？

</id>

</id>

<one-to-many class="Jd" />

</set>

</class>

相关推荐

ssh总结

第二篇：ssh面试题总结

专栏推荐