shh

1. 谈谈你对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属性指定，（看配置文件）。

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

2. 谈谈你对Hibernate的理解

    （1）面向对象设计的软件内部运行过程可以理解成就是在不断创建各种新对象、建立对象之间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，不管程序运行的过程和操作怎么样，本质上就是要得到一个结果，程序上一个时刻和下一个时刻的运行结果的差异就表现在内存中的对象状态发生了变化。

    （2）为了在关机和内存空间不够的状况下，保持程序的运行状态，需要将内存中的对象状态保存到持久化设备和从持久化设备中恢复出对象的状态，通常都是保存到关系数据库来保存大量对象信息。从java程序的运行功能来讲，保存对象状态的功能相比系统运行的其他功能来说，应该是一个很不起眼的附属功能，java采用了jdbc来实现这个功能，这个不起眼的功能却要编写大量的代码，而做的事情仅仅是保存对象和恢复对象，并且那些大量的jdbc代码并没有什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活和重复性工作。

    （3）通过数据库保存java程序运行时产生的对象和恢复对象，其实就是实现了java对象与关系数据库记录的映射关系，成为ORM（即Object Relation Mapping），人们可以通过封装JDBC代码来实现这种功能，封装出来的产品称之为ORM框架，Hibernate就是其中的一种流行的ORM框架。使用Hibernate框架，不用写JDBC代码，仅仅是调用一个save方法，就可以将对象保存到关系数据库中，仅仅是调用一个get方法，就可以从数据库中加载一个对象。

     （4）使用Hibernate的基本流程是：配置Configuration对象，产生SessionFactory、创建session对象，启动事务，完成CRUD操作，提交事务，关闭session。

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

3. AOP的作用

    AOP是面向切面的编程。它可以通过预编译方式和运行期动态代理实现在不修改源码的情况下给程序动态统一添加功能的一种技术。

4. Spring的理解

     （1）Spring实现了工厂模式的工厂类，这个类名为BeanFactory（实际上是一个接口），在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类，在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。

      （2）Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），什么叫依赖注入？

        譬如，Class Programmer

        {

              Computer computer=null;

              public void code()

             {

                //Computer computer=new IBMComputer();

               // Computer computer=beanfactory.getComputer();

                   computer.write();

              }

               public void setComputer(Computer computer){

                    this.computer=computer;

               }

 

         }

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

     <bean id="computer" class="cn.itcast.Computer"></bean>

     <bean id="programmer" class="cn.itcast.interview.Programmer">

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

      </bean>

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

    <bean id="proxy" type="org.spring.framework.aop.ProxyBeanFactory">

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

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

    </bean>

5. 谈谈Struts中的Action servlet

     Struts的控制器有：ActionServlet、RequestProcessor，还有就是具体的Action

     Struts最重要的类ActionServlet继承于HttpServlet，struts是一个servlet。

     ActionServlet是struts中最核心的部分，相当于中央控制器。

     ActionServlet的工作原理：ActionServlet它负责接收所有的request，并且产生相对应的response到请求的页面。struts-config.xml文件包括resource文件、如何到达下一个页面、下一个页面是什么、页面的校验规则、怎样显示错误信息的定义。

6. Struts的优缺点：

    优点：

     1.实现MVC模式，结构清晰，是开发者只关注业务逻辑的实现。

     2.有丰富的tag可以用，struts的标记库（Taglib），如能灵活使用，则能大大提高开发效率。

     3.页面导航

              使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接受这个项目时，这种优势体现得更加明显。

     4.提供Exception处理机制

     5.数据库连接池管理

     6.支持I18N

   缺点：

      1.转到展示层时，需要配置forward，如果有十个展示层的jsp，需要配置十次struts，而且还不包括有时候目录文件变更，需要重新修改forward，注意，每次修改配置后，要求重新部署整个项目，而tomcat这样的服务器，还必须重新启动服务器。

      2.struts的Action必需是thread-safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必须统一同步。这个就引起了线程安全问题。

      3.测试不方便。Struts的每个Action都通web层耦合在一起，这样它的测试依赖于web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。

      4.类型的转换。Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。

      5.对servlet的依赖性过强，Struts处理Action时必须要依赖ServletRequest和ServletResponse，所以它摆脱不了Servlet容器。

      6.前段表达式语言方面。Struts集成了JSTL，所以主要使用JSTL的表达是语言来获取数据。可是JSTL的表达是语言在Collection和索引属性方面处理显得很弱。

      7.对Action执行的控制困难。Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写servlet来实现这个功能需求。

      8.对Action执行前和后的处理。Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。

      9.对事件支持不够。在struts中，实际是一个表单Form对应一个Action类（或DispatchAction），换一句话来说：在struts中实际是一个表单只能对应一个事件，struts这种事件方式成为application event, application event和component event相比是一种粗粒度的事件。

7. Struts的应用（如struts架构）

    Struts是采用Java Serlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。采用 Struts能开发出基于MVC（Model-View-Controller）设计模式的应用构架。Struts有如下的主要功能：一、包含一个controller servlet，能将用户的请求发送到相应的Action对象。二、JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发人员创建交互式表单应用。三、提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

8. Struts1和Struts 2的区别：

    （1）都是MVC的WEB框架

    （2）struts 1是老牌框架，应用很广泛，有很好的群众基础，使用它开发风险很小，成本更低。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视图可以接收参数。

9.Hibernate中的update()和saveOrUpdate()的区别：

   update()更新，没有主键会报错

   saveOrUpdate()保存或更新，没有主键就执行插入

   Update:是对暂态（transient）或是只是脱管（detached）的更新操作，对于暂态对象的更新操作通常不产生效果，对于脱管对象时做了同步的操作，即数据库的数据发生变化并且对象状态也称为托管对象。

   SaveOrUpdate：也是对暂态或是托管的进行操作，至于是插入还是更新，则要根据id中指定的一些具体条件来分析，但是个人认为在明显只会发生插入操作的情况还是尽量避免用SaveOrUpdate而直接使用save即可。

10. Hibernate中session的load（）和get（）的区别：

      session.load/get方法均可以根据指定的实体类和id从数据库读取记录，并返回与之对应的实体对象。区别在于：

      （1）当数据库不存在对应的ID数据时，调用load()方法将会抛出ObjectNotFoundException异常，get（）方法将返回null。

       (2)当对象.hbm.xml配置文件<class>元素的lazy属性设置为true时，调用load（）方法时则返回持久对象的代理类实例，此时的代理类实例是由运行时动态生成的类，该代理类实例包括元目标对象的所有属性和方法，该代理实例的属性除了ID不为null外，所有的属性为null值，查看日志并没有hibernate sql输出，说明没有执行查询操作，当代理类实例通过getXXX()方法获取属性值时，hibernate才真正执行数据库查询操作。当对象.hbm.xml配置文件<class>元素的lazy属性设置为false时，调用load()方法则是立即执行数据库并直接返回实体类，并不返回代理类。而调用get()方法时不管lazy为何值，都直接返回实体类。

       （3）load（）和get()都会先从session缓存中查找，如果没有找到对应的对象，则查询hibernate二级缓存，再找不到该对象，则发送一条SQL语句查询。

 11.简述hibernate和JDBC的优缺点：

      JDBC与hibernate在性能上相比，JDBC灵活性有优势。而hibernate在易学性，易用性上有些优势。当用到很多复杂的多表联查和复杂的数据库操作时，JDBC有优势。

      相同点：

      a.两者都是java的数据库操作中间件。

      b.两者对于数据库进行直接操作的对象都不是线程安全的，都需要及时关闭。

      c.两者都可以对数据库的更新操作进行显示的事务处理。

      不同点：

      a.使用sql语言不同：JDBC使用的是基于关系数据库的标准SQL语言，hibernate使用的是HQL（Hibernate query language）语言

      b.操作的对象不同：JDBC操作的是数据，将数据通过SQL语句直接传送到数据库中执行，hibernate操作的是持久化对象，由底层持久化对象的数据更新到数据库中。

      c.数据状态不同：JDBC操作的数据是“瞬时”的，变量的值无法与数据库中的值保持一致，而hibernate操作的数据是可持久的，即持久化对象的数据属性的值是可以跟数据库中的值保持一致的。

   hibernate与JDBC读取性能：

   a.JDBC仍然是最快的访问方式，不论是create还是read操作，都是JDBC快。

   b.hibernate使用uuid.hex构造主键，性能稍微有点损失，但是不大。

   c.create操作，JDBC在使用批处理方式下速度比hibernate快，使用批处理方式耗用JVM内存比不使用批处理方式要多得多。

   d.读取数据，hibernate的Iterator速度非常缓慢，因为他是每次next的时候才去数据库取数据

   e.读取数据，hibernate的List熟读很快，因为他是一次性把数据读完

   f.JDBC读取数据的方式和hibernate的list方式一样

  g.hibernate的Iterator方式并非一无是处，它适合从大的结果集中选取少量的数据，即不需要占用很多内存，又可以迅速得到结果。

12.iBatis与Hibernate有什么不同？

     相同点：屏蔽jdbc api的底层访问细节，使我们不用与jdbc api打交道，就可以访问数据。jdbc api编程流程固定，还将sql语句与java代码混杂在了一起，经常需要拼凑sql语句，细节很繁琐。

     ibatid的好处： 屏蔽jdbc api的底层访问细节；将sql语句与java代码进行分离；提供了将结果集自动封装成为实体对象和对象的集合的功能，queryForList返回对象集合，用queryForObject返回单个对象；提供了自动将实体对象的属性传递给sql语句的参数。

     Hibernate是一个全自动的orm映射工具，它可以自动生成sql语句，ibatis需要我们在xml配置文件中写sql语句，hibernate要比ibatis功能负责和强大很多。因为hibernate自动生成sql语句，我们无法控制该语句，我们就无法去写特定的高效率的sql。对于一些不太负责的sql查询，hibernate可以很好帮我们完成，但是，对于特别复杂的查询，hibernate就很难适应了，这时候用ibatis是不错的选择，因为ibatis还是由我们自己写sql语句。

13.hibernate的inverse属性的作用：

     hibernate中的inverse在表关系映射中经常使用。

     inverse的作用：在hibernate中是通过inverse的设置来决定是由谁来维护表与表之间的关系的。指定关联的控制方。

     inverse属性默认是false，若为false，则关联由自己控制，若为true，则关联由对方控制。

14. DAO中如何体现DAO设计模式

      DAO是Data Access Object数据访问接口.

      DAO设计模式实际上是两个模式的组合，即Data Accessor模式和Active Domain Object模式。其中Data Accessor模式实现了数据访问和业务逻辑的分离，即将数据访问的实现机制加以封装，与数据的使用代码相分离，从外部来看，提供黑盒式的数据存取接口。而Active Domain Obejct模式实现了业务数据的对象化封装，提供了对所面向领域的对象的封装。

     DAO模式通过对业务层提供数据抽象层接口，实现了以下几个目标：数据存储逻辑的分离；数据访问底层实现的分离；资源管理和调度的分离；数据抽象。

     DAO模式的实现：

     （1）创建一个抽象工厂类，它包含两个重要的部分：第一部分是一些抽象方法，这些抽象方法是所有实现该抽象工厂的具体工厂类所必须的

     （2）然后，分别创建各个类型数据源的工厂类，在这个工厂类中里面也有两个重要组成部分

     （3）定义具体DAO类的接口，并在接口中定义所有的业务方法，和数据操作方法。

     （4）定义具体的DAO类，在这个类中才是实际的业务方法，和数据操作的实现。

     （5）定义数据传输对象，它是用来在客户端和DAO之间传递数据的，它其实就是javabean

     （6）完成以上5步后我们就可以在数据客户端使用以上由DAO设计模式定义好的各个类了。

15.介绍一下hibernate的二级缓存：

   按照以下思路来回答：（1）首先说清楚什么是缓存（2）再说有了hibernate的session就是一级缓存，即有了一级缓存，为什么还要有二级缓存（3）最后再说如何配置hibernate的二级缓存

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

    引出hibernate的第二级缓存，用下面的伪代码分析了Cache的实现原理：

     Dao

     {

        HashMap map=new Map();

        User getUser(integer id){

           User user=map.get(id);

           if(user==null){

                user=session.get(id);

                map.put(id,user);

            }

              return user;

          }

      }

     Dao{

         Cache cache=null;

         setCache(Cache cache){

             this.cache=cache;

          }

          User getUser(int id){

              if(cache!=null){

                user=session.get(id);

                cache.put(id,user);

            }

             return user;

            }

            return session.get(id);

     }

 (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来更改当前数据库中的数据，这样缓存的数据就会与数据库中的实际数据不一致。

16. Jdo是什么：

      JDO是Java对象持久化的新规范，为java data object的简称，也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，是开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库，JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库等，使得应用可移植性更强。

17.什么是Spring的IOC AOP

     IOC这个概念其实是从我们平常new一个对象的对立面来说的，我们平常使用对象的时候，一般都是直接使用关键字new一个对象，那这样有什么坏处？其实是很显然的，使用new那么就表示当前模块已经不知不觉的和new的对象耦合了，而我们通常都是更高层次的抽象模块调用底层的实现模块，这样也就产生了模块依赖于具体的实现，这样与我们java中提倡的面向接口面向抽象编程时相冲突的，而且这样做也带来系统的模块架构问题。

     IOC就是DAO接口的实现不再是业务逻辑层调用工厂类来获取，而是通过容器（比如Spring）来自动的为我们 的业务层设置DAO的实现类。这样整个过程就反过来，以前是我们业务层主动去获取DAO，而现在是DAO主动被设置到业务逻辑层中来，这也就是反转控制的由来。通过IOD，我们就可以在不修改任何代码的情况下，无缝的实现数据库的换库迁移。IOC带来了模块的松耦合和应用的便利性。

     IOC说白了就是由我们平常的new转成了使用反射来获取类的实例。

     AOP：

     面向切面编程基础：通常，系统由很多组件组成，每个组件负责一部分功能，然而，这些组件也经常带有一些除了核心功能之外的附带功能。系统服务如日志、事务管理和安全经常融入到一些其他功能模块中。这些系统服务通常叫做交叉业务，这是因为它们总是分布在系统的很多组件中。通过将这些业务分布在多个组件中，给我们得代码引入了双重复杂性。被容器中创建的类，看起来执行一个普通的函数调用，因为被容器预处理，而会在方法执行前/后进行一些其他的、可配置的操作。

18. Struts的工作流程：

      struts的目标：分离web程序的表示层、控制层和模型层，即MVC模式

      流程：

      发布struts web服务时，根据web.xml初始化ActionServlet，ActionContext等内容。

      在接到一个HttpRequest请求后，ActionServlet根据struts-config.xml中的配置内容，将请求的参数传到对应的formbean中，并设置session.然后根据请求中的Action参数，在struts-config.xml中查找指定的Action，根据ActionMapping实例包含的映射信息决定将请求转发给哪个Action，然后调用Action的execute方法。根据execute方法返回的ActionForward对象，ActionServlet再把请求转发给ActionForward对象指向的JSP组件。ActionForward指向的JSP组件生成动态网页，返回给用户。

19.Spring和EJB的区别：

     这两个框架有一个共同的核心设计理念：它们的目标是为松耦合的POJO类提供中间件服务。框架通过在运行时截取执行环境，或将服务对象注射给POJO类的方式，将应用服务和POJO类连接起来。POJO类本身并不关注如何连接，而且也很少依赖于框架。这样，开发者可以将注意力集中在业务逻辑上。

     EJB组件是重量级组件容器，该组件具有远程接口具有远程调用，具有负载均衡，具有分布式的事物，ejb组件必须放在ejb容器里。EJB主要是为分布式应用服务。

     Spring是轻量级组件容器，一般做web开发。