面试笔记

1.使用Ajax的好处：
    可以通过JavaScript发送请求到服务器，并或得返回的结果，在必要的时候需要更新页面的一部分，而不要整个页面都刷新，也称为：“无刷新”技术  提供连续的用户体验，而不被刷新中断

2.什么是Ajax
  它是Asynchronous(异步的)，JavaScript And Xml的简写；

3.Ajax的工作原理：
        1. 首先向服务器发送一个异步请求(在Action中创建相应的方法---)
       2. 创建 实例,设置回调函数
       3. 初始化XmlHttpRequest实例,发送请求 
        4. XmlHttpRequest实例.send(null)
       5. 对状态进行判段
       6. 读取xml文件获取文本值

4. hibernate实现的原理？(Hibernate的目标:是用来保存数据(持久化数据))
 1，读取并解析配置文件；
 2, 读取并解析映射信息，创建sessionFactory;
 3，打开session；
 4, 创建事务transation；
 5, 持久化操作；
 6. 提交事物commit;
 7, 操作失败rollback;
 8，关闭session;
 
5. hibernate 的优点和缺点?
  1.    对JDBC访问数据库的代码做了封装，大大简化     了数据访问层繁琐的重复性代码。

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

 3.    hibernate使用Java反射机制，而不是字节码  增强程序来实现透明性。

 4.    hibernate的性能非常好，因为它是个轻量级  框架。映射的灵活性很出色。它支持各  种关系数据库，从一对一到多对多的各  种复杂关系。
       缺点:限制了实体对象，一个实体对象不能映射成 多个表
 2.    不能对数据库操作进行优化
 3.    不适用于对数据的批量操作
 4.    不适用于对象关系不明确的操作

6． Struts工作机制？为什么要使用Struts？
 工作机制：
     在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象,当 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组件生成动态网页,返回给客户;

8.为什么要用：
    JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。
  基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件

6.Spring的部署环境？(目标：与业务相关(处理业务数据))
  1、spring依赖库
 * SPRING_HOME/dist/spring.jar
 * SPRING_HOME/lib/jakarta-commons/commons-logging.jar
 * SPRING_HOME/lib/log4j/log4j-1.2.14.jar
     --->拷贝spring，log4j配置文件到src下
    --> 在业务层的实现类中提供构造函数或setter方法，spring将实例化好的持久层实现注入给我们
     让spring管理我们的对象创建和依赖，必须在spring配置中进行定义 --->编写客户端
    

7.什么是框架?
      框架是提供可重用的公共结构的一个半成品，它集成了优秀的程序架构和前人的经验总结，使用框架可以帮助我们更快写出优秀，结构统一的程序；

8.struts中的标签：
     1.使用html标签"绑定"数据；
        使用过html标签进行页面编码；
     2.使用logic标签实现判断逻辑
         使用logic:notEmpty判断Bean值是否存在或非空
          使用logic:equal判断Bean值是否相等
         使用logic:iterate显示列表数据（负责集合数据的循环处理）
      3.使用bean对Bean值进行相关处理
           使用bean:write格式化输出(支持对数字和日期格式化)
           使用bean:define定义页面变量 可以简化取出Bean再定义为脚本 变量的过程和新的Bean
           使用bean:size得到集合数据记录数，它不会输出任何内容，只是取得值，并重新定义，方便其他标签或EL表达式应用，最终采用bean:write标签或EL表达式输出

9.Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现 同时是一个“对象-关系映射”框架，它能很大
      程度地简化DAO层编码工作

10.为什么使用HQL?
      HQL是Hibernate提供的一种面向对象的查询语言，支持：属性查询、参数查询、关联查询、分页查询、统计函数      使用它避免使用JDBC查询的一些弊端，不要再些繁琐的SQl语句
      我们只要针对实体类及其属性进行查询，查询的结果直接放到List中的对象，不需要再次封装，对不同的数据库根        据方言自动生成不同的SQl语句
      步骤：得到Session，  编写HQL语句  ，创建Query对象(封装了设置参数，执行查询，设置返回数据的开始位置和      总的返回条数 )，  执行查询，得到结果
    

11.为什么使用Criteria查询？
     Criteria查处(又称为对象查询) 采用面向对象的方式(主要是Criteria对象)封装查询条件，并提供Restrictions等类别    做辅助，可以是编写查询代码更方便
     步骤 ：得到Session，  创建Criteria对象（需要传入对应实体类的类型对象）  ，使用Restrictions对象的静态方法构造查询条件并添加进Criteria对象中；

12. 使用Spring好处？
      充当了粘合剂和润滑剂的角色，它对Struts，Hibernate等技术都提供了良好的支持，能够把现有的java系统柔顺的
       整合起来，同时自身还提供了声明式事物等企业开发不可或缺的功能

13.什么是依赖注入？
      就是明确的定义组建接口，独立开发各个组建，然后根据组件间的依赖关系组装运行的设计开发模式

14.什么是AOP
        从系统中分离出方面，然后集中实现，从而可以编写业务逻辑代码和方面代码，在系统运行的时候再将方面代码       “织入”到系统中

15.  Hibernate工作原理及为什么要用？
   原理：
   1.读取并解析配置文件
   2.读取并解析映射信息，创建SessionFactory
   3.打开Sesssion
   4.创建事务Transation
   5.持久化操作
   6.提交事务
   7.关闭Session
   8.关闭SesstionFactory

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

17． Hibernate是如何延迟加载?
   1.  Hibernate2延迟加载实现：a)实体对象 b)集合 （Collection）
   2. Hibernate3 提供了属性的延迟加载功能
   当Hibernate在查询数据的时候，数据并没有存在 与内存中，当程序真正对数据的操作时，对象才存 在与内存中，就实现 了延迟加载，他节省了服务器 的内存开销，从而提高了服务器的性能。

18．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
   类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，  它们通过配 置文件中的many-to-one、one-to-many、many-to-many、

   优缺点： 1.    对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
    2.    Hibernate是一个基于JDBC的主流 持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作 V
    3.    hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
    4.    hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复  杂关系。
   缺点：
    一个实体不能映射成多个表
    不能对数据库操作进行优化
    不适用于对数据进行批量操作
4． 说下Hibernate的缓存机制
    1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
    2. 二级缓存：
    a) 应用及缓存
    b) 分布式缓存
    条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据
    c) 第三方缓存的实现

5． Hibernate的查询方式
    Sql、Criteria,object comptosition
    Hql：
    1、 属性查询
    2、 参数查询、命名参数查询
    3、 关联查询
    4、 分页查询
    5、 统计函数
 
6． 如何优化Hibernate？
    1.使用双向一对多关联，不使用单向一对多
    2.灵活使用单向一对多关联
    3.不用一对一，用多对一取代
    4.配置对象缓存，不使用集合缓存
    5.一对多集合使用Bag,多对多集合使用Set
    6. 继承类使用显式多态
    7. 表字段要少，表关联不要怕多，有二级缓存撑腰

7． Struts工作机制？为什么要使用Struts？
    工作机制：
    Struts的工作流程:
    在web应用启动时就会加载初始化ActionServlet,ActionServlet从
    struts-config.xml文件中读取配置信息,把它们存放到各种配置对象
    当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组件生成动态网页,返回给客户;

为什么要用：
   JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。

   基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件

   8． Struts的validate框架是如何验证的？
   在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

9． 说下Struts的设计模式
   MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

10． spring工作机制及为什么要用?
    1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
    2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
    3.DispatcherServlet请请求提交到目标Controller
    4.Controller进行业务逻辑处理后，会返回一个ModelAndView
    5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
    6.视图对象负责渲染返回给客户端。

11.为什么用：
    {AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务  （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。
        IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。
    Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。}

ssh----------->

11.  常用的Struts标签.迭代是用什么标签
    <logic:iterate>

1.方法中定义的变量？
    *不能有访问修饰符;
    *必须赋初始值;
    *修饰符为final的表示变量的生命
            周期与实例一样，且在方法体中不能改变它的值，
            否则方法调用完就就销毁；

2.final?
    *final修饰的类不能有子类;
    *final修饰的方法在子类中不能重写;
    *类中的成员属性用final修饰必须赋初始值;

3.方法的说明符
    *方法的访问说明符：
       public
       protected(不加访问说明符时)
       default
       private
   
     *方法的其它修饰符
       static
       final
       abstract
       native
       synchronized

4.内部类（当一个类继承的父类，与实现的接口中有相同的方法和成员属性时）
        *可以定义在方法中，语句中，类中；
        *static内部类只能访问外部类中的static成员属性,成员方法；
        *内部类访问外部类中的成员属性，要加： 外部类的名称 + this + 成员属性;
        *内部类要能访问方法中定义的变量(注意方法中定义的变量一定要赋初始值)，
          则方法中定义的变量前要加final(final,为常量定义，改变了变量的生命周期);
        *内部类中有一个默认的成员属性，
             名称为:外部类的名称.this,引用外部类的实例；
          获得内部类的实例：
             1.在外部类中定义方法,该方法的返回值类型内部类；
             2.通过外部类的实例.new 内部类(),就可以得到内部类的实例;

5.集合：
        List,set,Map;
        set中的数据不能重复，list中装的数据可以重复;
        集合中装的数据只能为对象类型，
        且在集合中的值为对象的引用；
        List,set的父类是Collection;
        Collection与Collections区别；
           Collections该类中有很多的静态方法，用来操作集合；
             例子：
                List<Integer> ll = new ArrayList<Integer>();
  ll.add(5);
  ll.add(4);
  ll.add(3);
  System.out.println(ll.get(0));//5
  
  Collections.sort(ll);
  System.out.println(ll.get(0));//3
               
           Collection 是list,set的父类;
        集合的长度是size();
        字符串的长度：length();
        数组的长度为length;
        NodeList的长度为getLength();
        如何把数据增加到集合中去:
          list.add();
          set.add();
          map.put(键，值);
        如何把值从list,set,map中取出来:
           1.list可以用get(),也可以把其转化为iterator,再取值;
           2.set可以Iterator;
           3.map先把它的键转化为set,
             再itertor遍历set,得到键,由map.get()可以得到值;

6.线程的程序：
                 *运行main方法，jre开启一个后台线程；
                    a.Thread.currentThread().getName()
                      获得的当前运行该程序的线程的名称;
                    b.单线程的程序：第一条语句执行完后，
                                    再执行第二条语句；
                                    ............等
                    c.
                 *线程的定义：
                             第一种方式：
                                a.类名 extends Thread
                                重写run()方法；
                 *如何开启线程
                          Thread的实例.start();
                          一个Thread的实例对应一个线程;
                          不是调用Thread的实例的一次start()方法，
                          就开启一个线程;
                 *后台线程：
                           Thread的实例.start()是前台线程；
                           前台变为后台：
                                Thread tt =new TestThread();
                  tt.setDaemon(true);
                  如果所有线程都为后台，则程序会自动退出；   
                                如果后台线程已运行完，前台线程还会继续执行；
                 *线程的优先级：
                 *线程同步(synchronized)：
                            同步代码块：
                                       重新在类中定义一个成员属性，
                                       用来做线程同步的监视器变量；
                                             
                            同步方法：
                                    监视器变量为（this）:
                                       当线程执行到同步方法时，
                                       jre虚拟机马上在this所对应的方法上锁定，
                                       其他线程不能调用该同步方法；

7.servlet的生命周期:
       每调用一次servlet的url，
       是不是产生一个新的servlet实例?
      
       servlet的生命周期：
                  实例化:
                  init:
                  service:
                  destory:
                 
        servlet的实例化的方式：
            1.调用的时候，如表单,RequestDispatcher.forword();
            2.在web容器启动的时候：
                在<servlet>元素中增加一个子元素：
                <load-on-startup>1</load-on-startup>
                 load-on-startup的文本节点的值大于等于零,
                 则在web容器启动的时候，实例化servlet的实例；
                 小于零，则不实例化；
                 若有多个servlet，配置了<load-on-startup>
                 且他们的值不一样，值越小，容器先实例化；
                 他们的值一样，则在web.xml文件中,越在后面的先实例化
             3. init只执行一次；

8.servlet的路劲问题：
   ./   : 表示当前的路径；
   ../  ：表示回到上一级路径；
  
   以上路径以当前页面为基准点，再定义到其它页面；
   request.getScheme()的值为：http
   request.getServerName()的值为:主机的ip地址或主机机器的名称；
   request.getServerPort()的值为:端口号；
   request.getContextPath()的值为:/ + 站点名；
  
   另一种方式：
         以站点名为统一的基准点，
         使用该种方式：必须在head中增加以下：
        
            <base href="<%=basePath%>">
             basePath:
             <%
        String path = request.getContextPath();
        String basePath = request.getScheme() + "://"
      + request.getServerName() + ":" + request.getServerPort()
      + path + "/";
            %>   
  
 页面转化：
        RequestDispatcher disaptcher =request.getRequestDispatcher("ServletTest2");
      //disaptcher.include(request, response);该为页面包含；
       disaptcher.forward(request, response);
       url的地址不变，同用同一个request对象；
      
  页面重定向：
        response.sendRedirect("ServletTest2");
         url的地址变，不同用同一个request对象；

9.cookie:
       *服务器可以向客户端写内容；
       *只能是文本内容；
       *客户端可以阻止服务器写入；
       *只能拿自己的webapp写入的东西；
       *以‘名--值’对的形式出现；
       *.Cookie分为两种
            属于窗口/子窗口
            属于文本
       *一个servlet/jsp设置的Cookie能够被
         同一个路径下面或者子路径下面的servlet/jsp读到 
         (路径=url,路径!=真实的路径)   
       *可以使用Cookie的setXXX()方法来设定一些相应的值
              a.setName(String name) /getName();
              b.setValue(String value)/getValue();
              c.setMaxAge(int age)/getMaxAge();
              d.利用HttpServletResponse的addCookie(Cookie cookie)方法将它设置到客户端，
              e.利用HttpServletRequest的getCookie()方法来读取客户端的所有Cookie,返回一个Cookie数组；
       *设置cookie:
            见程序：SetCookies.java
       *读取Cookie
            见程序：ShowCookies.java
       * 设置了生命周期的cookie才能写入浏览器的cookie中;

10.Session的实现机制：
      *通过Cookie实现；
           如果浏览器支持Cookie，创建Session的时候会把SessionId保存在Cookie中；
           向服务器发送第一次请求的时候，
                 a.服务器马上产生一个Session，放在在服务器中;
                 b.把session的sessionId放在brower的cookie中；
                 c.之后在调用jsp或servlet的doGet()或doPost()方法，
                   同时把表单中的值及sessionId一起传给服务器；
                  
                  
      *通过url实现；
           如果不支持Cookie,必须自己编程使用URL重写的方式实现Session,
             Jsp中： response.encodeURL("url");
              servlet中：response.sendRedirect(
        response.encodeRedirectURL("uri"));
                  转码;
                  URL后面加入SessionId;
                 
                 
      *Session不象Cookie拥有路径访问的问题
          同一个application下的servlet/jsp可以共享同一个Session，前提是同一个客户端窗口
      *Session在用户第一向服务器产生的 ,
        为了跟踪当前用户；
        每打开一个浏览器客户端窗口,输入url,发送请求，
        就会产生一个Session实例；

11. 如何把map中装的值转化为成员属性所对应的数据类型；
                        a.通过获得成员属性的数据类型，
                          用相应的if语句进行转换：
                        b.转化器：
                            参数说明：
                                1. Class class1：要转化到数据类型
                                2. Object obj：要转化其他数据类型的值
                             
                            public abstract Object convert(Class class1, Object obj)

12.怎样创建监听器：(监听器类在容器一启动的时候就进行实例化)
 import javax.servlet.http.HttpSessionListener;
 public SessionListener(){
 System.out.println("---> session is constr");
 }
   public class SessionListener implements HttpSessionListener{
     public void sessionCreate(){
      htrtpsessionevet.getSession();
      System.out.println("---> session is Create");
     }
  
   }

13.怎样实现线程安全？
      *<第一种方案>
      用监听器

      *<第二种方案>
       把applicationContext作为类的成员属性要注意线程安全问题
       struts 的action的成员属性则必须有
       spring容器来钞，且 <bean>的属性必须为name ,且要把scope="prototype"  ，所请求必须有代理类来抄

      *<第三种方案>
      自己做回调类，从上下文取得ioc容器实列

14.类的说明符：
     类的访问说明符
       public
       default(不加访问说明符时):
              a.类的名称可以与类的文件名称不一样；
              b.java 加类名；
              c.类名第一字母要打写；
              d.public 类型的类必须与文件名一样;
             
     类的其它修饰符
       final
       abstract

15.jsp隐试对象？
    request :表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
    response :表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
    out :对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
    pageContext :表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。
    session :表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
    applicaton :表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
    config :表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
    page :表示从该页面产生的一个servlet实例

16.el表达式 隐式对象：  获取getAttribute(String name)属性的值
    a. pageContext 
  可以访问ServletContext, Request, Response 和 Session 等对象
  ${pageContext.ServletContext.serverInfo}
  ${pageContext. Request.requestURL}
  ${pageContext.Response.characterEncoding}
  ${pageContext.session.creationTime}
 b. pageScope:
         类型是java.util.Map , 将页面范围内的属性名和它的值进行映射.主要用于获取页面范围内的属性的值. ${pageScope.user}
       c. requestScope:  ---  HttpServletRequest
        类型是java.util.Map , 将请求范围内的属性名和它的值进行映射.主要用于获
   请求范围内的属性值.  ${requestScope.user.age}
       d. sessionScope  --- HttpSession
    类型是java.util.Map , 将会话范围内的属性名和它的值进行映射.主要用于获
           会话范围内的属性的值. ${sessionScope.user.education}
       e. applicationScope:  --- ServletContext
      类型是java.util.Map , 将应用程序范围内的属性名和它的值进行映射.主要用于获取应用程序范围内的属性的值. ${applicationScope.user.education}
f. param  ----  getParameter( String name)
     类型是java.util.Map , 将请求中的参数的名字和单个参数值进行映射.主要用于获取请求的参数值(表单中的值和请求地址的值). ${ param.name }
g. paramValues  ---- getParameterValues(String name)
     类型是java.util.Map , 将请求中的参数的名字和该参数所有对应的值进行映射.主要用于获取请求的参数值.(表单中同名元素的值: 单选按纽, 复选按纽的值) ${ paramValues.sex } 等同于 ServletRequest.getParameterValues(String name);
h. header:     ---  ServletRequest.getHeader(String  name)
    类型是java.util.Map, 主要用于请求报头的值 ServletRequest.getHeader(String name)
    ${header[“User-Agent”]}  这里只能用”[]” 不能用 “.”
i. headerValues  ---  ServletRequests(String name)
   类型是java.util.Map, 主要用于请求报头的值ServletRequest.getHeaders(String name)  ${header[“User-Agent”]}  这里只能用”[]” 不能用 “.”
j. cookie
    类型是java.util.Map, 主要用于获取Cookie对象, 等同HttpServletRequest.getCookie() 从返回的Cookie数组中找到匹配名字的第一
          个Cookie对象 ${cookie.userinfo.name}
k. initParam.
   类型是 java.util.Map 主要用于获取Web应用程序初始化参数的值,等价于
   ServletContext.getInitParameter(String name), 在web.xml 文件中, 使用 <context-param>元素配置了一个driver参数

12.  Struts是否线程安全的,不是怎么处理使它安全.
不安全.
解决方法:
1.      采用单线程方式
在JSP文件中加上,使它以单线程方式执行,这时仍然只有一个实例,所有客户端的请求以串行方式执行.这样会降低系统的性能.
2.      对函数加synchronized进行线程同步,JSP仍然以多线程方式执行,但是也会降低系统性能.
3.      采用局部变量代替实例变量

13.  Struts中文乱码怎么处理
1、  所有HTML/JSP页面全部采用UTF-8编码
2、  客户端浏览器完全支持UTF-8编码

14.  Hibernate最常遇到一种异常
是空指针(ObjectNotFoundException).

15.  Hibernate session 的 get()和load()有什么区别
1. 如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException
2. Load方法可返回实体的代理类实例，而get方法永远直接返回实体类.
3. load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。

16.  Hibernate延长加载
1. 实体对象的延迟加载
在set中指定lazy=true
这样只有实际加载与对象相关联的集合对象的时候，再通过session从数据库中加载实际的数据集
2. 属性延迟加载
在property节点中声明lazy=true,而且还需要借助Hibernate类增强器对POJO类的二进制Class文件进行强化处理.

17.  Hibernate中事务怎么处理
Hibernate有三种事务
1. JDBC 2. JTA事务 3. CMT事务
在这三种事务中，JDBC事务是默认的。这就意味着如果未设置hibernate.properties文件中的hibernate.transaction_factory的键值，beginTransaction将返回一个JDBC事务。
    虽然一个会话中可以包含多个事务，但并不需要人为地对这些事务进行分割，而是由会话中的一些方法对多个事务进行管理的。下面将详细描述这些方法：
commit()方法是结束事务的两个方法。在这方法在内部调用了会话对象的save()方法。当调用这个方法时，如果这个事务已经被初始化，那么这个事务将成功提交。

18.  说说Spring AOP和IOC
AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程,面向切面编程(事物和权限管理形成一个切面，相当于一个过滤器(把共有的信息放到里面来)调用方法时就要先经过这个切面，什么是切点，什么时切面？) AOP非常适合开发J2EE容器服务器.
IoC就是Inversion of Control，控制反转。在Java开发中，IoC意味着将你设计好的类交给系统去控制，而不是在你的类内部控制。这称为控制反转. 管理对象依赖注入

19.struts和Spring是怎么的继承
   每个控制那一个IOC实例
   每个表对应一控制
   方法：自己重写ContextLoaderLIstener方法，在Web容器中配置，一开启的时候就调用方法
   重写XMlWebApplicationContext将配置文件放到上下文中；
20.注入SessionFactory的时候？
    注入的是：LocalSessionFactoryBean类型的，而我们需要的是SessionFactory类型的(成员属性或子类不同)
              解决的原因：因为实现了FacotryBean接口
              要实现接口中山个方法：
              在spring配置文件中配置
              <bean class="包名+类名" id="localsessionfactorybean" >
              </bean>
              通过ApplicationContext  app= new ClassPathxmlApplicationcontext("配置文件的Id值");
        FactoryBean放回的类型要看getObject()此方法是重写父类中的）放回的值
            
  IOC造对象的范围：
     有五种：Request,session,prototype,singleon,globalsession
 
struts1.x的缺陷？
   1.它是一个轻量级的框架
   2.值提供整个表单提交，不能当数据提交
   3.页面是能是jsp页面
hibernate是怎么实现延时加载的？
   在web容器中配置一个过滤器org.springframewrok.orm.hibernate3.support.OpenSessionInViewFilter
   <filter>
    <filter-name>opensession</filter-name>
    <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
   </filter>