J2EE 高级软件工程师面试题集

最新推荐文章于 2024-07-14 22:18:32 发布

6587845888

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量6.1k

点赞数 1

分类专栏： java 文章标签： java ssh ssm

java 专栏收录该内容

93 篇文章 1 订阅

订阅专栏

第一章：基础知识部分…………………………………3

第二章：高级知识部分…………………………………27

第三章：数据库部分……………………………………70

第四章：程序设计部分…………………………………113

第五章：面试技巧部分…………………………………132

第一章：J2EE高级软件工程师面试题集

--JAVA基础部分

1、面向对象的特征有哪些方面
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
2、String是最基本的数据类型吗?
基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
3、int 和 Integer 有什么区别
Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类
boolean     Boolean
char        Character
byte        Byte
short       Short
int         Integer
long        Long
float       Float
double      Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
4、String 和StringBuffer的区别
JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。String str1 = “java”;str1.replace(‘j’,’2’);//此后str1还是java，只是replace可以重新返回一个2ava!
5、运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。级别不一样...
一般异常都是Exception的子类, 运行期异常与System.err平级的
一般异常值得捕获,运行期异常就管部了,无能为力地.

运行时异常与运行时环境有关,一般异常与原代码有关!
6、说出Servlet的生命周期，并说出Servlet和CGI的区别。
Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。
与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
7、说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
8、EJB是基于哪些技术实现的？并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。
    EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。
SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。
对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。
对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。
Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。
9、Collection 和 Collections的区别。
　　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
10、&和&&的区别。
    &是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。
11、HashMap和Hashtable的区别。
    HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
12、final, finally, finalize的区别。
　　final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
13、sleep() 和 wait() 有什么区别?
    sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
14、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
15、error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
    exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。
16、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
17、abstract class和interface有什么区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
18、heap和stack有什么区别。
栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。
堆是栈的一个组成元素

1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。

2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

19、forward 和redirect的区别
forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。
    redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。
20、EJB与JAVA BEAN的区别？
Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat）的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。
21、Static Nested Class 和 Inner Class的不同。
    Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。
22、JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现 <jsp:include page="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>
23、什么时候用assert。
    assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。
24、GC是什么? 为什么要有GC?
　　GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
25、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
    short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）
26、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
    Math.round(11.5)==12
Math.round(-11.5)==-11
round方法返回与参数最接近的长整数，参数加1/2后求其floor.
27、String s = new String("xyz");创建了几个String Object?
    两个
28、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
public class ThreadTest1{
  private int j;
  public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
  private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
  }
  private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
  }
  class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
}
  }
  class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
}
  }
}
29、Java有没有goto?
java中的保留字，现在没有在java中使用。
30、启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

31、EJB包括（SessionBean,EntityBean）说出他们的生命周期，及如何管理事务的？
SessionBean：Stateless Session Bean 的生命周期是由容器决定的，当客户机发出请求要建立一个Bean的实例时，EJB容器不一定要创建一个新的Bean的实例供客户机调用，而是随便找一个现有的实例提供给客户机。当客户机第一次调用一个Stateful Session Bean 时，容器必须立即在服务器中创建一个新的Bean实例，并关联到客户机上，以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例。
EntityBean：Entity Beans能存活相对较长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。
EJB通过以下技术管理实务：对象管理组织（OMG）的OTS），Sun Microsystems的Transaction Service（JTS）、Java Transaction API（JTA），开发组（X/Open）的XA接口。
32、应用服务器有那些？
BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss，Tomcat
33、给我一个你最常见到的runtime exception。
ArithmeticException, ArrayStoreException, BufferOverflowException,

BufferUnderflowException, CannotRedoException, CannotUndoException,

ClassCastException, CMMException, ConcurrentModificationException, DOMException,

EmptyStackException, IllegalArgumentException, IllegalMonitorStateException,

IllegalPathStateException, IllegalStateException, ImagingOpException,

IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException,

NoSuchElementException, NullPointerException, ProfileDataException,

ProviderException, RasterFormatException, SecurityException, SystemException,

UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException
34、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。
35、List, Set, Map是否继承自Collection接口?
    List，Set是，Map不是
36、说出数据连接池的工作机制是什么?
J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。
37、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
    都不能
38、数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。String有有length()这个方法。
39、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
    equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。
40、构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。
41、是否可以继承String类?
String类是final类故不可以继承。
42、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。
43、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。
44、编程题: 用最有效率的方法算出2乘以8等於几?
2 << 3
45、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。
46、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
47、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。
48、编程题: 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
　　    //在自己内部定义自己一个实例，是不是很奇怪？
　　    //注意这是private 只供内部调用
　　    private static Singleton instance = new Singleton();
　　    //这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　    public static Singleton getInstance() {
　　　　    return instance; 　　
　　    }
    }
    第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
49、Java的接口和C++的虚类的相同和不同处。
由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。
50、Java中的异常处理机制的简单原理和应用。
当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。
51、垃圾回收的优点和原理。并考虑2种回收机制。
Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有"作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
52、请说出你所知道的线程同步的方法。
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
53、你所知道的集合类都有哪些？主要方法？
最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。
54、描述一下JVM加载class文件的原理机制?
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。
55、char型变量中能不能存贮一个中文汉字?为什么?
能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
56、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
57、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实例
58、线程的基本概念、线程的基本状态以及状态之间的关系
线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。
Java中的线程有四种状态分别是：运行、就绪、挂起、结束。
59、JSP的常用指令

isErrorPage(是否能使用Exception对象)，isELIgnored(是否忽略表达式)

/" target="_blank">http://......"%>
60、什么情况下调用doGet()和doPost()？
Jsp页面中的form标签里的method属性为get时调用doGet()，为post时调用doPost()。

61、servlet的生命周期
web容器加载servlet，生命周期开始。通过调用servlet的init()方法进行servlet的初始化。通过调用service()方法实现，根据请求的不同调用不同的do***()方法。结束服务，web容器调用servlet的destroy()方法。
62、如何现实servlet的单线程模式
<%@ page isThreadSafe="false"%>
63、页面间对象传递的方法
request，session，application，cookie等
64、JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？
JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。
65、四种会话跟踪技术
会话作用域ServletsJSP 页面描述
page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。
request是是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件（由于 forward 指令和 include 动作的关系）
session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域
66、Request对象的主要方法：
setAttribute(String name,Object)：设置名字为name的request的参数值
getAttribute(String name)：返回由name指定的属性值
getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例
getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组
getCharacterEncoding()：返回请求中的字符编码方式
getContentLength()：返回请求的Body的长度
getHeader(String name)：获得HTTP协议定义的文件头信息
getHeaders(String name)：返回指定名字的request Header的所有值，结果是一个枚举的实例
getHeaderNames()：返回所以request Header的名字，结果是一个枚举的实例
getInputStream()：返回请求的输入流，用于获得请求中的数据
getMethod()：获得客户端向服务器端传送数据的方法
getParameter(String name)：获得客户端传送给服务器端的有name指定的参数值
getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
getParameterValues(String name)：获得有name指定的参数的所有值
getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
getQueryString()：获得查询字符串
getRequestURI()：获取发出请求字符串的客户端地址
getRemoteAddr()：获取客户端的IP地址
getRemoteHost()：获取客户端的名字
getSession([Boolean create])：返回和请求相关Session
getServerName()：获取服务器的名字
getServletPath()：获取客户端所请求的脚本文件的路径
getServerPort()：获取服务器的端口号
removeAttribute(String name)：删除请求中的一个属性
67、J2EE是技术还是平台还是框架？
    J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。
    J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。
68、我们在web应用开发过程中经常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串？
  Public String translate (String str) {
    String tempStr = "";
    try {
      tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");
      tempStr = tempStr.trim();
    }
    catch (Exception e) {
      System.err.println(e.getMessage());
    }
    return tempStr;
  }
69、简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。
区别主要答两点：a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型
b.逻辑操作不会产生短路
70、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？
a: 两种形式 dtd  schema，b: 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)，c:有DOM,SAX,STAX等
    DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问
SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
    STAX:Streaming API for XML (StAX)
71、简述synchronized和java.util.concurrent.locks.Lock的异同？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。
72、EJB的角色和三个对象
一个完整的基于EJB的分布式计算结构由六个角色组成，这六个角色可以由不同的开发商提供，每个角色所作的工作必须遵循Sun公司提供的EJB规范，以保证彼此之间的兼容性。这六个角色分别是EJB组件开发者（Enterprise Bean Provider）、应用组合者（Application Assembler）、部署者（Deployer）、EJB 服务器提供者（EJB Server Provider）、EJB 容器提供者（EJB Container Provider）、系统管理员（System Administrator）
三个对象是Remote（Local）接口、Home（LocalHome）接口，Bean类
73、EJB容器提供的服务
主要提供声明周期管理、代码产生、持续性管理、安全、事务管理、锁和并发行管理等服务。
74、EJB规范规定EJB中禁止的操作有哪些？
    1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)，2.不能操作awt，3.不能实现服务器功能，4.不能对静态属生存取，5.不能使用IO操作直接存取文件系统，6.不能加载本地库.，7.不能将this作为变量和返回，8.不能循环调用。
75、remote接口和home接口主要作用
remote接口定义了业务方法，用于EJB客户端调用业务方法。
home接口是EJB工厂用于创建和移除查找EJB实例
76、bean 实例的生命周期
对于Stateless Session Bean、Entity Bean、Message Driven Bean一般存在缓冲池管理，而对于Entity Bean和Statefull Session Bean存在Cache管理，通常包含创建实例，设置上下文、创建EJB Object（create）、业务方法调用、remove等过程，对于存在缓冲池管理的Bean，在create之后实例并不从内存清除，而是采用缓冲池调度机制不断重用实例，而对于存在Cache管理的Bean则通过激活和去激活机制保持Bean的状态并限制内存中实例数量。
77、EJB的激活机制
以Stateful Session Bean 为例：其Cache大小决定了内存中可以同时存在的Bean实例的数量，根据MRU或NRU算法，实例在激活和去激活状态之间迁移，激活机制是当客户端调用某个EJB实例业务方法时，如果对应EJB Object发现自己没有绑定对应的Bean实例则从其去激活Bean存储中（通过序列化机制存储实例）回复（激活）此实例。状态变迁前会调用对应的ejbActive和ejbPassivate方法。
78、EJB的几种类型
会话（Session）Bean ，实体（Entity）Bean 消息驱动的（Message Driven）Bean
会话Bean又可分为有状态（Stateful）和无状态（Stateless）两种
实体Bean可分为Bean管理的持续性（BMP）和容器管理的持续性（CMP）两种
79、客服端调用EJB对象的几个基本步骤
设置JNDI服务工厂以及JNDI服务地址系统属性，查找Home接口，从Home接口调用Create方法创建Remote接口，通过Remote接口调用其业务方法。
80、如何给weblogic指定大小的内存?
在启动Weblogic的脚本中（位于所在Domian对应服务器目录下的startServerName），增加set MEM_ARGS=-Xms32m -Xmx200m，可以调整最小内存为32M，最大200M
81、如何设定的weblogic的热启动模式(开发模式)与产品发布模式?
可以在管理控制台中修改对应服务器的启动模式为开发或产品模式之一。或者修改服务的启动文件或者commenv文件，增加set PRODUCTION_MODE=true。
82、如何启动时不需输入用户名与密码?
修改服务启动文件，增加 WLS_USER和WLS_PW项。也可以在boot.properties文件中增加加密过的用户名和密码.
83、在weblogic管理制台中对一个应用域(或者说是一个网站,Domain)进行jms及ejb或连接池等相关信息进行配置后,实际保存在什么文件中?
保存在此Domain的config.xml文件中，它是服务器的核心配置文件。
84、说说weblogic中一个Domain的缺省目录结构?比如要将一个简单的helloWorld.jsp放入何目录下,然的在浏览器上就可打入 http://主机:端口号//helloword.jsp就可以看到运行结果了? 又比如这其中用到了一个自己写的javaBean该如何办?
Domain目录服务器目录applications，将应用目录放在此目录下将可以作为应用访问，如果是Web应用，应用目录需要满足Web应用目录要求，jsp文件可以直接放在应用目录中，Javabean需要放在应用目录的WEB-INF目录的classes目录中，设置服务器的缺省应用将可以实现在浏览器上无需输入应用名。
85、在weblogic中发布ejb需涉及到哪些配置文件
不同类型的EJB涉及的配置文件不同，都涉及到的配置文件包括ejb-jar.xml,weblogic-ejb-jar.xmlCMP实体Bean一般还需要weblogic-cmp-rdbms-jar.xml
86、如何在weblogic中进行ssl配置与客户端的认证配置或说说j2ee(标准)进行ssl的配置
缺省安装中使用DemoIdentity.jks和DemoTrust.jks  KeyStore实现SSL，需要配置服务器使用Enable SSL，配置其端口，在产品模式下需要从CA获取私有密钥和数字证书，创建identity和trust keystore，装载获得的密钥和数字证书。可以配置此SSL连接是单向还是双向的。
87、如何查看在weblogic中已经发布的EJB?
可以使用管理控制台，在它的Deployment中可以查看所有已发布的EJB
88、CORBA是什么?用途是什么?
CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture)，由对象管理组织 (Object Management Group，缩写为 OMG)标准化。它的组成是接口定义语言(IDL), 语言绑定(binding:也译为联编)和允许应用程序间互操作的协议。其目的为：用不同的程序设计语言书写在不同的进程中运行，为不同的操作系统开发。
89、说说你所熟悉或听说过的j2ee中的几种常用模式?及对设计模式的一些看法
  Session Facade Pattern：使用SessionBean访问EntityBean
Message Facade Pattern：实现异步调用
EJB Command Pattern：使用Command JavaBeans取代SessionBean，实现轻量级访问
Data Transfer Object Factory：通过DTO Factory简化EntityBean数据提供特性
Generic Attribute Access：通过AttibuteAccess接口简化EntityBean数据提供特性
Business Interface：通过远程（本地）接口和Bean类实现相同接口规范业务逻辑一致性
ＥＪＢ架构的设计好坏将直接影响系统的性能、可扩展性、可维护性、组件可重用性及开发效率。项目越复杂，项目队伍越庞大则越能体现良好设计的重要性。
90、说说在weblogic中开发消息Bean时的persistent与non-persisten的差别
persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来，而non－persistent方式的消息将被丢弃。

java面试笔试题大汇总(4) [转]

91、Servlet执行时一般实现哪几个方法？
public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request,ServletResponse response)
public void destroy()
92、j2ee常用的设计模式？说明工厂模式。
    Java中的23种设计模式：
Factory（工厂模式），      Builder（建造模式），       Factory Method（工厂方法模式），
Prototype（原始模型模式），Singleton（单例模式），    Facade（门面模式），
Adapter（适配器模式），    Bridge（桥梁模式），        Composite（合成模式），
Decorator（装饰模式），    Flyweight（享元模式），     Proxy（代理模式），
Command（命令模式），      Interpreter（解释器模式）， Visitor（访问者模式），
Iterator（迭代子模式），   Mediator（调停者模式），    Memento（备忘录模式），
Observer（观察者模式），   State（状态模式），         Strategy（策略模式），
Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
93、EJB需直接实现它的业务接口或Home接口吗，请简述理由。
远程接口和Home接口不需要直接实现，他们的实现代码是由服务器产生的，程序运行中对应实现类会作为对应接口类型的实例被使用。
94、排序都有哪几种方法？请列举。用JAVA实现一个快速排序。
    排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码。
/ /使用快速排序方法对a[ 0 :n- 1 ]排序
从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e，该元素为支点
把余下的元素分割为两段left 和r i g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点
递归地使用快速排序方法对left 进行排序
递归地使用快速排序方法对right 进行排序
所得结果为l e f t + m i d d l e + r i g h t
95、请对以下在J2EE中常用的名词进行解释(或简单描述)
web容器：给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接更容器中的环境变量接**互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。
EJB容器：Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。
JNDI：（Java Naming & Directory Interface）JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
JMS：（Java Message Service）JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
JTA：（Java Transaction API）JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
JAF：（Java Action FrameWork）JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。
RMI/IIOP:（Remote Method Invocation /internet对象请求中介协议）他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。
96、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。
用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。
throw语句用来明确地抛出一个"异常"。
throws用来标明一个成员函数可能抛出的各种"异常"。
Finally为确保一段代码不管发生什么"异常"都被执行一段代码。
可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。

97、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以。必须只有一个类名与文件名相同。
98、MVC的各个部分都有那些技术来实现?如何实现?
MVC是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
99、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？
有两种实现方法，分别是继承Thread类与实现Runnable接口
用synchronized关键字修饰同步方法
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
100、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。
101、java中会存在内存泄漏吗，请简单描述。
会。如：int i,i2;  return (i-i2);   //when i为足够大的正数,i2为足够大的负数。结果会造成溢位，导致错误。
102、java中实现多态的机制是什么？
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
103、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。
104、静态变量和实例变量的区别？
static i = 10; //常量
   class A a;  a.i =10;//可变
105、什么是java序列化，如何实现java序列化？
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
106、是否可以从一个static方法内部发出对非static方法的调用？
不可以,如果其中包含对象的method()；不能保证对象初始化.
107、写clone()方法时，通常都有一行代码，是什么？
Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。
108、在JAVA中，如何跳出当前的多重嵌套循环？
用break; return 方法。
109、List、Map、Set三个接口，存取元素时，各有什么特点？
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
110、J2EE是什么？
J2EE是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterpriese application model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。
111、UML方面
标准建模语言UML。用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图。
112、说出一些常用的类，包，接口，请各举5个
常用的类：BufferedReader  BufferedWriter  FileReader  FileWirter  String  Integer
常用的包：java.lang  java.awt  java.io  java.util  java.sql
常用的接口：Remote  List  Map  Document  NodeList
113、开发中都用到了那些设计模式?用在什么场合?
每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。主要用到了MVC的设计模式。用来开发JSP/Servlet或者J2EE的相关应用。简单工厂模式等。
114、jsp有哪些动作?作用分别是什么?
JSP共有以下6种基本动作 jsp:include：在页面被请求的时候引入一个文件。 jsp:useBean：寻找或者实例化一个JavaBean。 jsp:setProperty：设置JavaBean的属性。 jsp:getProperty：输出某个JavaBean的属性。 jsp:forward：把请求转到一个新的页面。 jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。
115、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
可以继承其他类或完成其他接口，在swing编程中常用此方式。
116、应用服务器与WEB SERVER的区别？
应用服务器：Weblogic、Tomcat、Jboss
WEB SERVER：IIS、 Apache
117、BS与CS的联系与区别。
C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。
B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。
C/S 与 B/S 区别：
１．硬件环境不同:
　　C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.
　　B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行
２．对安全要求不同
　　C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.
　　B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。
３．对程序架构不同
　　C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.
　　B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.
４．软件重用不同
　　C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.
　　B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子
５．系统维护不同
　　C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统
　　B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.
６．处理问题不同
　　C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统
　　B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.
７．用户接口不同
　　C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高
　　B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.
８．信息流不同
　　C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低
　　B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。
118、LINUX下线程，GDI类的解释。
LINUX实现的就是基于核心轻量级进程的"一对一"线程模型，一个线程实体对应一个核心轻量级进程，而线程之间的管理在核外函数库中实现。
GDI类为图像设备编程接口类库。
119、STRUTS的应用(如STRUTS架构)
Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能：一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。
120、Jdo是什么?
JDO是Java对象持久化的新的规范，为java data object的简称,也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS）JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。
121、内部类可以引用他包含类的成员吗？有没有什么限制？
一个内部类对象可以访问创建它的外部类对象的内容
122、WEB SERVICE名词解释。JSWDL开发包的介绍。JAXP、JAXM的解释。SOAP、UDDI,WSDL解释。
Web ServiceWeb Service是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。
JAXP(Java API for XML Parsing) 定义了在Java中使用DOM, SAX, XSLT的通用的接口。这样在你的程序中你只要使用这些通用的接口，当你需要改变具体的实现时候也不需要修改代码。
JAXM(Java API for XML Messaging) 是为SOAP通信提供访问方法和传输机制的API。
WSDL是一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点（服务）。
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。
UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

123、JSP页面是如何被执行的？JSP执行效率比Servlet低吗？

当客户端向一个JSP页面发出请求时，Web Container将JSP转化成Servlet的源代码(只在第一次请求时)，然后编译转化后的Servlet并加载到内存中执行，执行的结果Response到客户端。
JSP只在第一次执行的时候会转化为Servlet，以后每次执行Web容器都是直接执行编译后的Servlet,所以JSP和Servlet只是在第一次执行的时候不一样，JSP慢一点，以后的执行都是相同的。

124、JSP如何处理运行时异常(run-time)exceptions?

可以使用页面的errorPage属性捕获没有处理的运行时异常，然后自动转向到一个错误处理页面，代码如下：
<%@ page errorPage=”error.jsp” %>
如果在页面请求时出现运行时异常是，以上代码会把页面转向到JSP页面error.jsp，在error.jsp里面，可以通过以下代码定义这个页面是错误处理页:

<%@page isErrorPage=”true” %>

这样描述错误信息的Throwable对象就可以在error.jsp页面里面访问到。

125、如果jsp表单元素的值为空，如何避免null出现在页面上？

可以写一个简单的函数对空值进行处理，判断值是否为空，如果是空就返回空字符串。实例代码如下：
<%!
String blanknull(String s){
return (s == null) ? “” : s;
}
%>
在你的JSP里面，可以使用以上函数输出文本框或者其他页面元素的值，实例代码如下：
<input type=”text” name=”shoesize” value=”<%=blanknull(shoesize)% >”>

126、如何避免JSP页面自动生成session对象？为什么要这么做？

在默认情况下，在对一个JSP页面发出请求时，如果session还没有建立，JSP页面会自动为请求建立一个session对象，但是session是比较消耗资源的，如果没必要保持和使用session，就不应该创建session, 例如一些只是用来宣传产品的网站，往往没必要使用session来保存信息，可以使用jsp页面指令session=”false”来避免JSP页面为每个请求都自动创建session.实例代码如下：

<%@page session=”false”>

127、在servlets和JSP之间能共享session对象吗？

当然可以，
HttpSession session = request.getSession(true);
session.putValue(”variable”,”value”);

128、Servlet都有哪些方法？主要作用是什么？

HttpServlet 类包含 init() 、 destroy() 、 service() 等方法。其中 init() 和 destroy() 方法是继承的。
(1) init() 方法
在 Servlet 的生命期中，仅执行一次 init() 方法。它是在服务器装入 Servlet 时执行的。可以配置服务器，以在启动服务器或客户机首次访问Servlet 时装入 Servlet 。无论有多少客户机访问 Servlet ，都不会重复执行 init() 。
缺省的 init() 方法通常是符合要求的，但也可以用定制init() 方法来覆盖它，典型的是管理服务器端资源。例如，可能编写一个定制 init() 来只用于一次装入 GIF 图像，改进 Servlet 返回 GIF 图像和含有多个客户机请求的性能。另一个示例是初始化数据库连接。缺省的init() 方法设置了 Servlet 的初始化参数，并用它的 ServletConfig 对象参数来启动配置，因此所有覆盖 init() 方法的 Servlet 应调用 super.init() 以确保仍然执行这些任务。在调用 service() 方法之前，应确保已完成了 init() 方法。
(2) service() 方法
service() 方法是 Servlet 的核心。每当一个客户请求一个 HttpServlet 对象，该对象的 service() 方法就要被调用，而且传递给这个方法一个“请求”（ ServletRequest）对象和一个“响应”（ ServletResponse ）对象作为参数。在 HttpServlet 中已存在 service() 方法。缺省的服务功能是调用与 HTTP 请求的方法相应的 do 功能。例如，如果 HTTP 请求方法为 GET ，则缺省情况下就调用 doGet() 。 Servlet 应该为 Servlet 支持的 HTTP 方法覆盖 do 功能。因为HttpServlet.service() 方法会检查请求方法是否调用了适当的处理方法，不必要覆盖service() 方法。只需覆盖相应的 do 方法就可以了。
= 当一个客户通过 HTML 表单发出一个 HTTP POST请求时， doPost （）方法被调用。与 POST 请求相关的参数作为一个单独的 HTTP 请求从浏览器发送到服务器。当需要修改服务器端的数据时，应该使用doPost() 方法。
= 当一个客户通过 HTML 表单发出一个 HTTP GET 请求或直接请求一个 URL 时， doGet() 方法被调用。与 GET 请求相关的参数添加到 URL 的后面，并与这个请求一起发送。当不会修改服务器端的数据时，应该使用 doGet() 方法。
Servlet 的响应可以是下列几种类型：
一个输出流，浏览器根据它的内容类型（如 text/HTML ）进行解释。
一个 HTTP 错误响应 , 重定向到另一个 URL 、 servlet 、 JSP。
(3) destroy() 方法
destroy() 方法仅执行一次，即在服务器停止且卸装 Servlet 时执行该方法。典型的，将 Servlet 作为服务器进程的一部分来关闭。缺省的 destroy() 方法通常是符合要求的，但也可以覆盖它，典型的是管理服务器端资源。例如，如果 Servlet 在运行时会累计统计数据，则可以编写一个 destroy() 方法，该方法用于在未装入 Servlet 时将统计数字保存在文件中。另一个示例是关闭数据库连接。
当服务器卸装 Servlet 时，将在所有 service()方法调用完成后，或在指定的时间间隔过后调用 destroy() 方法。一个 Servlet 在运行 service() 方法时可能会产生其它的线程，因此请确认在调用 destroy() 方法时，这些线程已终止或完成。
(4) GetServletConfig（）方法
GetServletConfig （）方法返回一个 ServletConfig 对象，该对象用来返回初始化参数和 ServletContext 。 ServletContext 接口提供有关 servlet 的环境信息。
(5) GetServletInfo（）方法
GetServletInfo （）方法是一个可选的方法，它提供有关 servlet 的信息，如作者、版本、版权。
当服务器调用 sevlet 的 Service （）、 doGet （）和 doPost （）这三个方法时，均需要 “请求”和“响应”对象作为参数。“请求”对象提供有关请求的信息，而“响应”对象提供了一个将响应信息返回给浏览器的一个通信途径。 javax.servlet 软件包中的相关类为 ServletResponse 和 ServletRequest ，而 javax.servlet.http 软件包中的相关类为 HttpServletRequest 和 HttpServletResponse 。 Servlet 通过这些对象与服务器通信并最终与客户机通信。 Servlet 能通过调用“请求”对象的方法获知客户机环境，服务器环境的信息和所有由客户机提供的信息。 Servlet 可以调用“响应”对象的方法发送响应，该响应是准备发回客户机的。

129、Java Servlet的主要功能和作用是什么？

Servlet 通过创建一个框架来扩展服务器的能力，以提供在 Web 上进行请求和响应服务。当客户机发送请求至服务器时，服务器可以将请求信息发送给Servlet ，并让 Servlet 建立起服务器返回给客户机的响应。当启动 Web 服务器或客户机第一次请求服务时，可以自动装入Servlet 。装入后， Servlet 继续运行直到其它客户机发出请求。 Servlet的功能涉及范围很广。例如， Servlet 可完成如下功能：
(1) 创建并返回一个包含基于客户请求性质的动态内容的完整的 HTML 页面。
(2) 创建可嵌入到现有 HTML 页面中的一部分 HTML 页面（ HTML 片段）。
(3) 与其它服务器资源（包括数据库和基于 Java 的应用程序）进行通信。
(4) 用多个客户机处理连接，接收多个客户机的输入，并将结果广播到多个客户机上。例如，Servlet 可
以是多参与者的游戏服务器。
(5) 当允许在单连接方式下传送数据的情况下，在浏览器上打开服务器至 applet的新连接，并将该连
接保持在打开状态。当允许客户机和服务器简单、高效地执行会话的情况下， applet 也可以启动客户浏览器和服务器之间的连接。可以通过定制协议或标准（如 IIOP ）进行通信。
(6) 对特殊的处理采用 MIME 类型过滤数据，例如图像转换和服务器端包括（ SSI ）。
(7) 将定制的处理提供给所有服务器的标准例行程序。例如，Servlet 可以修改如何认证用户。

130、Request对象的主要方法有哪些？

setAttribute(Stringname,Object)：设置名字为name的request的参数值
getAttribute(String name)：返回由name指定的属性值
getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例
getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组
getCharacterEncoding()：返回请求中的字符编码方式
getContentLength()：返回请求的Body的长度
实例
getInputStream()：返回请求的输入流，用于获得请求中的数据
getMethod()：获得客户端向服务器端传送数据的方法
getParameter(String name)：获得客户端传送给服务器端的有name指定的参数值
getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
getParameterValues(String name)：获得有name指定的参数的所有值
getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
getQueryString()：获得查询字符串
getRequestURI()：获取发出请求字符串的客户端地址
getRemoteAddr()：获取客户端的IP地址
getRemoteHost()：获取客户端的名字
getSession([Boolean create])：返回和请求相关Session
getServerName()：获取服务器的名字
getServletPath()：获取客户端所请求的脚本文件的路径
getServerPort()：获取服务器的端口号
removeAttribute(String name)：删除请求中的一个属性

131、使用JSP连接到数据库连接缓冲池的最好方法是什么？

1.使用JDBC2。0中带有此服务的Driver
2.使用提供有此服务的Application server
3.自己写

132、在JSP中如何写文本文件？

使用PrintWriter对象，如：
<%@ page import=”java.io.*” %>
<%
String str = “print me”;
String nameOfTextFile = “/usr/anil/imp.txt”;
try {
PrintWriter pw = new PrintWriter(new FileOutputStream(nameOfTextFile));
pw.println(str);
pw.close();
} catch(IOException e) {
out.println(e.getMessage());
}
%>

133、JSP的缺点？

1.对JAVA程序进行调试没有好东东
2.因大多数的servlet引擎不支持connectionpooling
3.Servlet引擎没有标准
4.JSP与其它脚本语言的交互

134、在JSP中如何删除一个COOKIE?

<%
Cookie killMyCookie = new Cookie(”mycookie”, null);
killMyCookie.setMaxAge(0);
killMyCookie.setPath(”/”);
response.addCookie(killMyCookie);
%>

135、如何现实servlet的单线程模式？

<%@ pageisThreadSafe=”false”%>

136、说出Servlet和CGI的区别？
与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

137、Servlet的生命周期？

Servlet是一种可以在Servlet容器中运行的组件，那么理所当然就应该有一个从创建到销毁的过程，这个过程我们可以称之为Servlet生命周期。Servlet的生命周期可以分为加载、实例化、初始化、处理客户请求和卸载五个阶段，体现在方法上主要是init（）、service（）和destroy（）三个方法。生命周期的具体说明如下：

· Servlet容器完成加载Servlet类和实例化一个Servlet对象

· init（）方法完成初始化工作，该方法由Servlet容器调用完成

· service（）方法处理客户端请求，并返回响应结果

· destroy（）方法在Servlet容器卸载Servlet之前被调用，释放一些资源

138、介绍一下javax.servlet.Servlet接口及其主要方法？

Servlet接口的主要作用是提供Servlet生命周期的init()、service()和destroy()方法。
servlet接口中的主要方法有：
void init(ServletConfit config)throws ServletException     在servlet被载入后和实施服务前由servlet引擎进行一次性调用。如果init()产生溢出UnavailableException，则 servle退出服务。
ServletConfig getServletConfig()     返回传递到servlet的init()方法的ServletConfig对象
void service(ServletRequest request, ServletResponse response)throwsServletException,IOException     处理request对象中描述的请求，使用response对象返回请求结果
String getServletInfo()         返回描述servlet的一个字符串
void destory()         当servlet将要卸载时由servlet引擎调用，销毁Servlet实例。

139、HttpServlet类中的主要方法都有哪些？各自的作用是什么？

HttpServlet的主要方法有 doGet, doPost, doPut, doDelete, doTrace等等

VoiddoGet(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     由servlet引擎调用用处理一个HTTP GET请求。输入参数、HTTP头标和输入流可从request对象、response头标和response对象的输出流中获得。
Void doPost(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     由servlet引擎调用用处理一个HTTP POST请求。输入参数、HTTP头标和输入流可从request对象、response头标和response对象的输出流中获得。
Void doPut(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     由servlet引擎调用用处理一个HTTP PUT请求。本方法中请求URI指出被载入的文件位置。
Void doDelete(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     由servlet引擎调用用处理一个HTTP DELETE请求。请求URI指出资源被删除。
Void doOptions(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     由servlet引擎调用用处理一个HTTP OPTIONS请求。返回一个Allow响应头标表明此servlet支持的HTTP方法。一个servlet不需要覆盖此方法，因为 HttpServlet方法已经实现规范所需的功能。
Void doTrace(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     由servlet引擎调用用处理一个HTTP TRACE请求。使得请求头标被反馈成响应关标。一个servlet不需要覆盖此方法，因为HttpServlet方法已经实现HTTP规范所需的功能。
Void service(HttpServletRequest request,HttpServletResponse response)throwsServletException,IOException     Service(Requestrequest,Response response)调用的一个立即方法，带有指定HTTP请求和响应。此方法实际上将请求导向doGet()、doPost()等等。不应该覆盖此方法。
Void service(Request request,Response response)throwsServletException,IOException     将请求和响应对象置入其指定的HTTP子类，并调用指定HTTP的service()方法。

140、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？

a: 两种形式 dtd schema，

b: 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)。

c:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问；SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标

签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
STAX:Streaming API for XML (StAX）

141、你在项目中用到了xml技术的哪些方面?如何实现的?

用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。

第二章：J2EE高级软件工程师面试题

----JAVA高级部分

ajax面试题部分

1、介绍一下Prototype的$()函数，$F()函数，$A()函数都是什么作用？

$() 方法是在DOM中使用过于频繁的document.getElementById() 方法的一个便利的简写，就像这个DOM方法一样，这个方法返回参数传入的id的那个元素。

$F()函数是另一个大收欢迎的“快捷键”，它能用于返回任何表单输入控件的值，比如text box,drop-down list。这个方法也能用元素id或元素本身做为参数。

$A()函数能把它接收到的单个的参数转换成一个Array对象。

2、介绍一下XMLHttpRequest对象

通过XMLHttpRequest对象，Web开发人员可以在页面加载以后进行页面的局部更新。

AJAX开始流行始于Google在2005年使用的”Google Suggest”。

“Google Suggest”就是使用XMLHttpRequest对象来创建动态的Web接口：

当用户开始输入google的搜索框，Javascript发送用户输入的字符到服务器，然后服务器返回一个建议列表。

XMLHttpRequest对象在IE5.0+, Safari 1.2, Mozilla 1.0/Firefox, Opera 8+ 和NetScapt7 开始被支持。

3、AJAX应用和传统Web应用有什么不同？

在传统的Javascript编程中，如果想得到服务器端数据库或文件上的信息，或者发送客户端信息到服务器，需要建立一个HTML form然后GET或者POST数据到服务器端。用户需要点击”Submit”按钮来发送或者接受数据信息，然后等待服务器响应请求，页面重新加载。

因为服务器每次都会返回一个新的页面，所以传统的web应用有可能很慢而且用户交互不友好。

使用AJAX技术，就可以使Javascript通过XMLHttpRequest对象直接与服务器进行交互。

通过HTTP Request，一个web页面可以发送一个请求到web服务器并且接受web服务器返回的信息(不用重新加载页面)，展示给用户的还是通一个页面，用户感觉页面刷新，也看不到到Javascript后台进行的发送请求和接受响应。

4、AJAX的全称是什么？介绍一下AJAX？

AJAX的全称是Asynchronous JavaScript And XML.

AJAX是2005年由Google发起并流行起来的编程方法， AJAX不是一个新的编程语言，但是它是一个使用已有标准的新的编程技术。

使用AJAX可以创建更好，更快，更用户界面友好的Web应用。

AJAX技术基于Javascript和HTTP Request.

5、Ajax请求总共有多少种Callback?

Ajax请求总共有八种Callback

onSuccess
onFailure
onUninitialized
onLoading
onLoaded
onInteractive
onComplete
onException

6、Javascript如何发送一个Ajax请求？

代码：

newAjax.Request(’/your_url’),

{

method : ‘get’,

onSuccess :function(transport){

var response =transport.responseText || “no response text”;

alert(”Success!”);

} ,

onFailure :function(){ alert(’failure’)}

});

7、AJAX都有哪些有点和缺点？

1、最大的一点是页面无刷新，用户的体验非常好。
2、使用异步方式与服务器通信，具有更加迅速的响应能力。
3、可以把以前一些服务器负担的工作转嫁到客户端，利用客户端闲置的能力来处理，减轻服务器和带宽的负担，节约空间和宽带租用成本。并且减轻服务器的负担，ajax的原则是“按需取数据”，可以最大程度的减少冗余请求，和响应对服务器造成的负担。
4、基于标准化的并被广泛支持的技术，不需要下载插件或者小程序。
ajax的缺点
1、ajax不支持浏览器back按钮。
2、安全问题 AJAX暴露了与服务器交互的细节。
3、对搜索引擎的支持比较弱。
4、破坏了程序的异常机制。
5、不容易调试。

8、Ajax主要包含了哪些技术？

Ajax（Asynchronous JavaScript + XML）的定义
基于web标准（standards-basedpresentation）XHTML+CSS的表示；
使用 DOM（Document ObjectModel）进行动态显示及交互；
使用 XML 和 XSLT 进行数据交换及相关操作；
使用 XMLHttpRequest 进行异步数据查询、检索；
使用 JavaScript 将所有的东西绑定在一起。英文参见Ajax的提出者Jesse James Garrett的原文,原文题目(Ajax: A New Approach to Web Applications)。
类似于DHTML或LAMP，AJAX不是指一种单一的技术，而是有机地利用了一系列相关的技术。事实上，一些基于AJAX的“派生/合成”式（derivative/composite）的技术正在出现，如“AFLAX”。
AJAX的应用使用支持以上技术的web浏览器作为运行平台。这些浏览器目前包括：Mozilla、Firefox、Internet Explorer、Opera、Konqueror及Safari。但是Opera不支持XSL格式对象，也不支持XSLT。

9、主要的Ajax框架都有什么？

* Dojo（dojotoolkit.org）；
* Prototype和Scriptaculous （www.prototypejs.org和script.aculo.us）；
* Direct Web Reporting （getahead.org/dwr）；
* Yahoo! User Interface Library（developer.yahoo.com/yui）；
* Google Web Toolkit （code.google.com/webtoolkit）。
*JQuery

10、介绍一下XMLHttpRequest对象的常用方法和属性？

open(“method”,”URL”)建立对服务器的调用，第一个参数是HTTP请求    方式可以为GET，POST或任何服务器所支持的您想调用的方式。
第二个参数是请求页面的URL。
send()方法，发送具体请求
abort()方法，停止当前请求
readyState属性   请求的状态有5个可取值 0=未初始化，1=正在加载
2=以加载，3=交互中，4=完成
responseText 属性服务器的响应，表示为一个串
reponseXML 属性服务器的响应，表示为XML
status    服务器的HTTP状态码，200对应ok 400对应notfound

11、XMLHttpRequest对象在IE和Firefox中创建方式有没有不同？

IE中通过new ActiveXObject()得到，Firefox中通过new XMLHttpRequest()得到

12、Ajax是什么及其工作原理是什么？

Ajax 由 HTML、JavaScript™ 技术、DHTML 和 DOM 组成，这一杰出的方法可以将笨拙的 Web 界面转化成交互性的 Ajax 应用程序。
AJAX最核心的一个对象是XMLHttpRequest，所有的Ajax操作都离不开对这个对象的操作
XMLHttpRequest对象相关方法:
打开请求
XMLHttpRequest.open(传递方式,地址,是否异步请求)
准备就绪执行
XMLHttpRequest.onreadystatechange
获取执行结果
XMLHttpRequest.responseText

Struts面试题部分

Struts中DispatchAction和Action类有什么不同？

DispatchAction是Struts包含的另一个能大量节省开发时间的Action类。与其它Action类仅提供单个execute()方法实现单个业务不同，DispatchAction允许你在单个Action类中编写多个与业务相关的方法。这样可以减少Action类的数量，并且把相关的业务方法集合在一起使得维护起来更容易。

要使用DispatchAction的功能，需要自己创建一个类，通过继承抽象的DispatchAction得到。对每个要提供的业务方法必须有特定的方法signature。例如，我们想要提供一个方法来实现对购物车添加商品清单，创建了一个类ShoppingCartDispatchAction提供以下的方法：
public ActionForward addItem(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response){
throws Exception;
}

那么，这个类很可能还需要一个deleteItem()方法从客户的购物车中删除商品清单，还有clearCart()方法清除购物车等等。这时我们就可以把这些方法集合在单个Action类，不用为每个方法都提供一个Action类。

在调用ShoppingCartDispatchAction里的某个方法时，只需在URL中提供方法名作为参数值。就是说，调用addItem()方法的 URL看起来可能类似于：

http://myhost/storefront/action/cart?method=addItem

其中method参数指定ShoppingCartDispatchAction中要调用的方法。参数的名称可以任意配置，这里使用的”method”只是一个例子。参数的名称可以在Struts配置文件中自行设定。

1、 Struts的控制器如何知道什么样的信息转发到什么样的Action类呢？

在struts 中，控制器信息转发的配置映射信息是存储在特定的XML文件（比如struts-config.xml）中的。这些配置信息在系统启动的时候被读入内存，供struts framework在运行期间使用。在内存中，每一个<action>元素都与org.apache.struts.action.ActionMapping类的一个实例对应。当可以通过/logonAction.do（此处假设配置的控制器映射为*.do）提交请求信息的时候，控制器将信息委托com.test.LogonAction处理。调用LogonAction实例的execute()方法。同时将Mapping实例和所对应的LogonForm Bean信息传入。其中name=LogonForm，使用的form-bean元素所声明的ActionForm Bean。

介绍一下Struts的Action类?

ActionServlet把全部提交的请求都被控制器委托到RequestProcessor对象。RequestProcessor使用struts-config.xml文件检查请求URI找到动作Action标示符。
一个Action 类的角色，就像客户请求动作和业务逻辑处理之间的一个适配器（Adaptor），其功能就是将请求与业务逻辑分开。这样的分离，使得客户请求和Action类之间可以有多个点对点的映射。而且Action类通常还提供了其它的辅助功能，比如：认证（authorization）、日志（logging）和数据验证（validation）。
Action最为常用的是execute（）方法当Controller收到客户的请求的时候，在将请求转移到一个Action实例时，如果这个实例不存在，控制器会首先创建，然后会调用这个Action实例的execute（）方法。Struts Framework为应用系统中的每一个Action类只创建一个实例。因为所有的用户都使用这一个实例，所以你必须确定你的Action类运行在一个多线程的环境中。

介绍一下Struts的ActionServlet类?

ActionServlet继承自javax.servlet.http.HttpServlet类，其在Struts framework中扮演的角色是中心控制器。它提供一个中心位置来处理全部的终端请求。控制器ActionServlet主要负责将HTTP的客户请求信息组装后，根据配置文件的指定描述，转发到适当的处理器。
按照Servelt的标准，所有得Servlet必须在web配置文件（web.xml）声明。同样，ActoinServlet必须在Web Application配置文件（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实例。

Struts中最核心的类和包有哪些？

1.org.apache.struts.action
基本上，控制整个struts framework的运行的核心类、组件都在这个包中，比如我们上面提到的控制器ActionServlet。已经Action,ActionForm,ActionMapping等等。struts1.1比1.0多了DynaActionForm 类。增加了动态扩展生成FormBean功能
2. org.apache.struts.actions
这个包是主要作用是提供客户的http请求和业务逻辑处理之间的特定适配器转换功能，而1.0版本中的部分动态增删FromBean的类，也在struts1.1中被Action包的DynaActionForm组件所取代
3. org.apache.struts.config
提供对配置文件struts-config.xml元素的映射。这也是sturts1.1中新增的功能
4. org.apache.struts.util
Strtuts为了更好支持web application的应用，体统了一个些常用服务的支持，比如Connection Pool和Message Source。详细信息请参考
http://jakarta.apache.org/struts/api/org/apache/struts/util/package-summary.html
5. org.apache.struts.taglib
这不是一个包，而是是一个客户标签类的集合。下面包括Bean Tags，HTML Tags，Logic Tags，Nested Tags，Template Tags这几个用于构建用户界面的标签类。
6 . org.apache.struts.validator
Struts1.1 framework中增加了validator framework，用于动态的配置from表单的验证。

如何配置spring+struts?

在struts-config.xml加入一个插件，通过它加载applicationContext.xml
在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxyØ
通过DelegateActionProxy进入一spring的环境。u
在spring的applicationContext.xml加入Ø<bean name=”/login” class=”" singleton=”false”/>

Spring和Struts的区别？

strusts：是一种基于MVC模式的一个web层的处理。
Spring:提供了通用的服务，ioc/di aop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术struts hibernate ibatis ejb remote springJDBC springMVC

如何用Struts实现国际化?

国际化:不用修改代码，就适用于不同的语言国家
本地化:如果要适应一个国家，要修改源代码
实现过程:
在struts-config.xml中用如下标签说明资源文件名，注意其只是文件名，没有语言_国家
   <message-resources parameter=”struts.ApplicationResources”/>
在资源文件对应的目录struts中加入适应不同语言、国家的properties文件
  ApplicationResources_zh_CN.properties 中国
  ApplicationResources_en_US.properties us
如果不是英语要转码
  native2ascii -encoding gb2312 源ApplicationResources_zh_CN.properties
在jsp页面中用
  <bean:message key=”"/>取出信息

如何实现struts的validator框架？

手动:
   public class myForm extends ActionForm Ø
   {Ø
    publicØ ActionErrors validate()
    {Ø
actionErrors.add(ActionErrors.GLOBAL_MESSAGE,new ActionMessage(”properties中的键名”));
    }Ø
   } Ø
   struts-config.xml中修改action的标签validate=trueØ
    input=”错误页面”Ø
   如果validate方法中的ActionErrors不为空且sizeØ>0时
   会回到input页面。Ø
  自动Ø
   publicØ class myForm extends ValidateForm
   {Ø
    不能覆盖validate方法。Ø
    //public voidØ validate()
    //{Ø
Ø
    //}Ø
   } Ø
   在struts-config.xml文件中加入插件Ø
    Ø <plug-inclassName=”org.apache.struts.validator.ValidatorPlugIn”>
    Ø     <set-propertyproperty=”pathnames”value=”/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml” />
   Ø   </plug-in>
修改validation.xml中的内容Ø
  errors.required={0} isØ required.
  errors.minlength={0} can not be less than {1} characters.Ø

  Ø<formset>
   Ø<form name=”loginForm”>
    Ø<field property=”userName” depends=”required”>
     Ø<arg0 key=”userName” />
    Ø</field>
    Ø<field property=”pwd” depends=”required,minlength”>
     Ø<arg0 key=”pwd” />
     Ø<arg1 key=”${var:minlength}” resource=”false”/>
     Ø<var>
      Ø<var-name>minlength</var-name>
      Ø<var-value>6</var-value>
     Ø</var>
    Ø</field>
   Ø</form>
  Ø</formset>
  struts-config.xml中修改action的标签validate=trueØ
    input=”/错误页面”Ø

如何在struts中配置数据源在,什么文件?用什么标签?如何取出DataSource?

Struts-config.xml

<data-sources>
   <data-source key=”data”type=”org.apache.commons.dbcp.BasicDataSource”>
     <set-property property=”driverClassName”  value=”com.microsoft.jdbc.sqlserver.SQLServerDriver” />
      <set-propertyproperty=”url”    value=”jdbc:microsoft:sqlserver://localhost:1433;databaseName=t23″ />
      <set-property property=”username” value=”sa” />
       <set-property property=”password”value=”" />
</data-source>
</data-sources>

DataSourceds=(DataSource)this.getServlet().getServletContext().getAttribute(”data”);
Connection con=ds.getConnection();

谈谈struts2的工作原理：

上图来源于Struts2官方站点，是Struts 2 的整体结构。
一个请求在Struts2框架中的处理大概分为以下几个步骤
1 客户端初始化一个指向Servlet容器（例如Tomcat）的请求
2 这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）
3 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action
4 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy
5 ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类
6 ActionProxy创建一个ActionInvocation的实例。
7 ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper

在上述过程中所有的对象（Action，Results，Interceptors，等）都是通过ObjectFactory来创建的。

struts的工作原理：

1、初始化，读取struts-config.xml、web.xml等配置文件（所有配置文件的初始化）
2、发送HTTP请求,客户端发送以.do结尾的请求
3、填充FormBean（实例化、复位、填充数据、校验、保存）
4、将请求转发到Action（调用Action的execute（）方法）
5、处理业务（可以调用后台类，返回ActionForward对象）
6、返回目标响应对象（从Action返回到ActionServlet）
7、转换Http请求到目标响应对象（查找响应，根据返回的Forwardkeyword）
8、Http响应，返回到Jsp页面

说下Struts的设计模式：

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

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类组件构成：控制器组件、模型组件、视图组件

你对MVC的理解，MVC有什么优缺点？结合Struts，说明在一个Web应用如何去使用？

MVC设计模式（应用观察者模式的框架模式）
M: Model(Business process layer)，模型，操作数据的业务处理层,并独立于表现层(Independent of presentation)。
V: View(Presentation layer)，视图，通过客户端数据类型显示数据,并回显模型层的执行结果。
C: Controller(Control layer)，控制器，也就是视图层和模型层桥梁，控制数据的流向，接受视图层发出的事件，并重绘视图

MVC框架的一种实现模型
模型二(Servlet-centric)：
JSP+Servlet+JavaBean，以控制为核心，JSP只负责显示和收集数据，Sevlet，连接视图和模型，将视图层数据，发送给模型层，JavaBean，分为业务类和数据实体，业务类处理业务数据，数据实体，承载数据，基本上大多数的项目都是使用这种MVC的实现模式。

StrutsMVC框架(Web application frameworks)

Struts是使用MVC的实现模式二来实现的，也就是以控制器为核心。

Struts提供了一些组件使用MVC开发应用程序：
Model：Struts没有提供model类。这个商业逻辑必须由Web应用程序的开发者以JavaBean或EJB的形式提供

View：Struts提供了action form创建form bean, 用于在controller和view间传输数据。此外，Struts提供了自定义JSP标签库，辅助开发者用JSP创建交互式的以表单为基础的应用程序，应用程序资源文件保留了一些文本常量和错误消息，可转变为其它语言，可用于JSP中。

Controller：Struts提供了一个核心的控制器ActionServlet，通过这个核心的控制器来调用其他用户注册了的自定义的控制器Action，自定义Action需要符合Struts的自定义Action规范，还需要在struts-config.xml的特定配置文件中进行配置，接收JSP输入字段形成Action form，然后调用一个Action控制器。Action控制器中提供了model的逻辑接口。

Hibernate面试题部分

Hibernate对象的三种状态是什么？

瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（Value Object）。

瞬时态

由new命令开辟内存空间的java对象，

eg. Person person= new Person(”amigo”, “女”);

如果没有变量对该对象进行引用，它将被java虚拟机回收。

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

持久态

处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。

当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。

持久对象具有如下特点：

1. 和session实例关联；

2. 在数据库中有与之关联的记录。

脱管态

当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。当脱管对象被重新关联到session上时，并再次转变成持久对象。

脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。

脱管对象具有如下特点：

1. 本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；

2. 比瞬时对象多了一个数据库记录标识值。

Detached Object(游离对象)有什么好处？

Detached Object（游离对象）可以传递到任何层直到表现层而不是用任何DTO(Data Transfer Objects). 然后你还可以重新把游离对象赋给另外一个Session.

jdbc、hibernate、ibatis的区别？

jdbc:手动
  手动写sql
  delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。
  select:返回的是一个resultset，要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。
ibatis的特点:半自动化
  sql要手动写
  delete、insert、update:直接传入一个对象
  select:直接返回一个对象
hibernate:全自动
  不写sql,自动封装
  delete、insert、update:直接传入一个对象
  select:直接返回一个对象

Hibernate如何实现数据表映射的继承关系？

1、两个表，子类重复父类的属性。
2、一个表，子类父类共用一个表
    <class name=”Users” table=”users”discriminator-value=”Users”>
   <discriminator column=”DISCRIMINATOR_USERTYPE”type=”string”/>
<subclass name=”admin” discriminator-value=”admin”>
           <propertyname=”adminRemark” column=”admin_remark” type=”string” />
        </subclass>
    </class>
3、两个表，子类引用父类的主键，享用公共的字段或属性。
    <class name=”Users” table=”users”>
        <id name=”userid” column=”USERID”type=”string”>
           <generator class=”assigned”/>
        </id>
        <property name=”pwd” column=”pwd”type=”string” />
<joined-subclass name=”Guest” table=”guest”>
  <key column=”USERID”/>
         <propertyname=”guestRemark” column=”guest_remark” type=”string” />
        </joined-subclass>
</class>
批量删除
Query query=session.createQuery(”update”或”delete”);
query.executeUpdate();

Hibernate中Query对象的使用

1 个或多个属性查询:
Query query=session.createQuery(”select customername,customerid fromCustomer”)
List l=query.list();
For(int i=0;i<l.size();i++)
{
Obejct[] object=(Object[])l.get(i);
Object[0] object[1]
}
}
分组: “select count(*),productname from Product group byproductname order by productname”
取值与属性一样
配置的查询,在*.hbm.xml中
<query name=”sql”>
    <![CDATA[
    from Product where productid=:productid
    ]]>
</query>
Query query=session.getNamedQuery(sql);
联接1
”from Customer as customer join fetch customer.buySet”：将多的放到buySet属性中，得出的结是Customer有一个，Buy有多个
联接2
“from Customer as customer join customer.buySet”:得出的对象,customer与buy是1对1
子查询:
”from Customer as customer where (select count(*) fromcustomer.buySet)>1″

Hibernate中Criteria 和DetachedCriteria的作用是什么？

Criteriac=session.createCriteria(Customer.class);
//设置条件
c.add(Expression.ge(“字段名”,”值对象”))
  ge:>=
  gt:>
  le:<=
  lt:<
  eq:=
//排序
  c.addOrder(Order.asc(“字段名”))
//分页
  c.setFirstResult(1)//从第2行开始提取
  c.setMaxResults(5)//返回5行

DetachedCriteria产生时不需要session
DetachedCriteria dc= DetachedCriteria.forClass(Customer.class)
Criteria c=Dc.getExecutableCriteria(session)

Hibernate中数据表映射关系主要有什么类型？

one-to-many
inverse:主控方，外键的关系有谁控制
  inverse=false 是主控方，外键是由它控制的
  inverse=true 是被控方，外键与它没关系
  要想实现主控方的控制必须将被控方作为主控方的属性
cascade:级联
  主表增从表增
  主表修从表修
  主表删从表删
lazy:延迟
  lazy=false：一下将所有的内容取出，不延时(常用)
  lazy=true：取出部分内容，其余内容动态去取
  通过get可以取出对方的所有内容

hibernate的核心类是什么，它们的相互关系是什么?重要的方法是什么?

Configuration
SessionFactory
  Session如下方法
   Save
   load
   Update
   Delete
      Query q=CreateQuery(“from Customer wherecustomerName=:customerName”)
   beginTransaction
   close
   Transaction
   Commit()

在myeclipse加入hibernate环境的全过程是什么?

1.Db-browers加入配置连接
2.新建工程
3.加入hibernate环境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置

面试中常出现的两个Hibernate面试题及解答

1.在数据库中条件查询速度很慢的时候,如何优化?
1.建索引
2.减少表之间的关联
3.优化sql，尽量让sql很快定位数据，不要让sql做全表查询，应该走索引,把数据量大的表排在前面
4.简化查询字段，没用的字段不要，已经对返回结果的控制，尽量返回少量数据

[2.在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?
解决方案一，按照Object[]数据取出数据，然后自己组bean
解决方案二，对每个表的bean写构造函数，比如表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1 filed1,type2 field2) ，然后在hql里面就可以直接生成这个bean了。具体怎么用请看相关文档，我说的不是很清楚。
session.load()和session.get()的区别
Session.load/get方法均可以根据指定的实体类和id从数据库读取记录，并返回与之对应的实体对象。其区别在于：

如果未能发现符合条件的记录，get方法返回null，而load方法会抛出一个ObjectNotFoundException。
Load方法可返回实体的代理类实例，而get方法永远直接返回实体类。
load方法可以充分利用内部缓存和二级缓存中的现有数据，而get方法则仅仅在内部缓存中进行数据查找，如没有发现对应数据，将越过二级缓存，直接调用SQL完成数据读取。
Session在加载实体对象时，将经过的过程：

首先，Hibernate中维持了两级缓存。第一级缓存由Session实例维护，其中保持了Session当前所有关联实体的数据，也称为内部缓存。而第二级缓存则存在于SessionFactory层次，由当前所有由本 SessionFactory构造的Session实例共享。出于性能考虑，避免无谓的数据库访问，Session在调用数据库查询功能之前，会先在缓存中进行查询。首先在第一级缓存中，通过实体类型和id进行查找，如果第一级缓存查找命中，且数据状态合法，则直接返回。
之后，Session会在当前“NonExists”记录中进行查找，如果“NonExists”记录中存在同样的查询条件，则返回null。 “NonExists”记录了当前Session实例在之前所有查询操作中，未能查询到有效数据的查询条件（相当于一个查询黑名单列表）。如此一来，如果 Session中一个无效的查询条件重复出现，即可迅速作出判断，从而获得最佳的性能表现。
对于load方法而言，如果内部缓存中未发现有效数据，则查询第二级缓存，如果第二级缓存命中，则返回。
如在缓存中未发现有效数据，则发起数据库查询操作（Select SQL），如经过查询未发现对应记录，则将此次查询的信息在“NonExists”中加以记录，并返回null。
根据映射配置和Select SQL得到的ResultSet，创建对应的数据对象。
将其数据对象纳入当前Session实体管理容器（一级缓存）。
执行Interceptor.onLoad方法（如果有对应的Interceptor）。
将数据对象纳入二级缓存。
如果数据对象实现了LifeCycle接口，则调用数据对象的onLoad方法。
返回数据对象。
Hibernate的主键生成机制
1) assigned
主键由外部程序负责生成，无需Hibernate参与。
2) hilo
通过hi/lo 算法实现的主键生成机制，需要额外的数据库表保存主键生成历史状态。
3) seqhilo
与hilo 类似，通过hi/lo 算法实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。
4) increment
主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是：如果当前有多个实例访问同一个数据库，那么由于各个实例各自维护主键状态，不同实例可能生成同样的主键，从而造成主键重复异常。因此，如果同一数据库有多个实例访问，此方式必须避免使用。
5) identity
采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。
6) sequence
采用数据库提供的sequence 机制生成主键。如Oralce中的Sequence。
7) native
由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式。
8) uuid.hex
由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）作为主键。
9) uuid.string
与uuid.hex 类似，只是生成的主键未进行编码（长度16）。在某些数据库中可能出现问题（如PostgreSQL）。
10) foreign
使用外部表的字段作为主键。一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。
这10中生成OID标识符的方法,increment 比较常用,把标识符生成的权力交给Hibernate处理.但是当同时多个Hibernate应用操作同一个数据库,甚至同一张表的时候.就推荐使用identity依赖底层数据库实现,但是数据库必须支持自动增长,当然针对不同的数据库选择不同的方法.如果你不能确定你使用的数据库具体支持什么的情况下.可以选择用native 让Hibernate来帮选择identity,sequence,或hilo.
另外由于常用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们可以在数据库提供的主键生成机制上，采用generator-class=native的主键生成方式。
不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，大量并发insert数据时可能会引起表之间的互锁。数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键，之后再把这个新的最大值更新回内部表中，这样，一次Insert操作可能导致数据库内部多次表读写操作，同时伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。因此，对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成机制

Hibernate工作原理

1. 读取并解析配置文件

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

3. 打开Sesssion

4. 创建事务Transation

5. 持久化操作

6. 提交事务

7. 关闭Session

8. 关闭SesstionFactory

Hibernate有什么好处：

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

Hibernate是如何延迟加载的：

· Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

· Hibernate3 提供了属性的延迟加载功能

Hibernate的查询方式：

Sql、Criteria,object comptosition
Hql：

属性查询
参数查询、命名参数查询
关联查询
分页查询
统计函数

说下Hibernate的缓存机制：

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

· 灵活使用单向一对多关联

· 不用一对一，用多对一取代

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

· 一对多集合使用Bag,多对多集合使用Set

· 继承类使用显式多态

· 表字段要少，表关联不要怕多，有二级缓存撑腰

内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
二级缓存：

如何优化Hibernate:

a)应用及缓存
b)分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据
c) 第三方缓存的实现

Spring面试题部分

请介绍一下Spring的事务管理？

spring提供了几个关于事务处理的类：
TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：

TransactionDefinitiontd = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
transactionManager.commit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}

spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.
void add()
{
transactionTemplate.execute( new TransactionCallback(){
pulic Object doInTransaction(TransactionStatus ts)
{ //do sth}
}
}

声明式：

使用TransactionProxyFactoryBean:

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

围绕Poxy的动态代理能够自动的提交和回滚事务
org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

1、如何在Spring的applicationContext.xml里面使用JNDI而不是datasource?

可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：
<bean id=”dataSource”>
    <property name=”jndiName”>
       <value>java:comp/env/jdbc/appfuse</value>
    </property>
</bean>

Spring里面如何配置数据库驱动？

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：
<bean id=”dataSource”>
    <property name=”driverClassName”>
       <value>org.hsqldb.jdbcDriver</value>
    </property>
    <property name=”url”>
        <value>jdbc:hsqldb:db/appfuse</value>
    </property>
    <propertyname=”username”><value>sa</value></property>
    <propertyname=”password”><value></value></property>
</bean>

2、 Spring里面applicationContext.xml文件能不能改成其他文件名？

ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个<context-param>元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener

    <context-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>/WEB-INF/xyz.xml</param-value>
    </context-param>

</listener-class>
</listener>

如何在web应用里面配置spring?

在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Spring里面如何定义hibernate mapping？

添加hibernatemapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：
<property name=”mappingResources”>
    <list>
       <value>org/appfuse/model/User.hbm.xml</value>
    </list>
</property>

两种依赖注入的类型都是什么？

两种依赖注入的类型分别是setter注入和构造方法注入。

setter注入：一般情况下所有的java bean, 我们都会使用setter方法和getter方法去设置和获取属性的值，示例如下：
public class namebean {
     String      name;
     public void setName(String a) {
        name = a; }
     public String getName() {
        return name; }
    }
我们会创建一个bean的实例然后设置属性的值，spring的配置文件如下：
<bean id=”bean1″  >
   <property   name=”name” >
       <value>tom</value>
   </property>
</bean>
Spring会调用setName方法来只是name熟悉为tom
构造方法注入：构造方法注入中，我们使用带参数的构造方法如下：
public class namebean {
     String name;
     public namebean(String a) {
        name = a;
     }
}
我们会在创建bean实例的时候以newnamebean(”tom”)的方式来设置name属性,Spring配置文件如下：
<bean id=”bean1″ >
    <constructor-arg>
       <value>My Bean Value</value>
   </constructor-arg>
</bean>
使用constructor-arg标签来设置构造方法的参数。

解释一下Dependency injection(DI,依赖注入)和IOC(Inversion of control,控制反转)?

参考答案：依赖注入DI是一个程序设计模式和架构模型，一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

3、 spring中的BeanFactory与ApplicationContext的作用和区别？

作用：

1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：

a. 国际化支持
b. 资源访问：Resource rs = ctx.getResource(”classpath:config.properties”), “file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件
WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
这两种方式都默认配置文件为web-inf/applicationContext.xml，也可使用context-param指定配置文件
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/myApplicationContext.xml</param-value>
</context-param>

如何在web环境中配置applicationContext.xml文件?

<listener>
  <listener-class>
   org.springframework.web.context.ContextLoaderListener
  </listener-class>
</listener>
或：
<servlet>
  <servlet-name>context</servlet-name>
   <servlet-class>
    org.springframework.web.context.ContextLoaderServlet
   </servlet-class>
  <load-on-startup>1</load-on-startup>
</servlet>
通过如下方法取出applicationContext实例:
ApplicationContextac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);

spring+hibernate的配置文件中的主要类有那些?如何配置?

在myeclipse中先加入spring环境再加入hibernate环境。
如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否   正确?
spring+hibernate的配置文件中的主要类有那些?如何配置?
  dataSource
  sessionFactory:hibernate.cfg.xml
  transactionManager
  userDao (extends HibernateDaoSupport)
   sessionFactory
  facade
  proxy
   sessionFactory
   transactionManager
   facade

如何配置spring+struts?

在spring中如何配容器的事务管理，相关的类有那些?

Datasouce
   transactionManager
   userDao要注入
    Datasouce
   Proxy代理
    Target:userDao：代理对象(目标对象)
    transactionAttributes(那些方法需要事务处理)
    transactionManager(事务处理服务)

spring中有几种事务管理，分别是什么?

代码管理的事务处理
TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用。
public void make()
{
TransactionTemplate jtm=newTransactionTemplate(this.getTransactionManager());
jtm.execute(new myClass1());
}
public class myClass1 implements TransactionCallback
{

  publicObject doInTransaction(TransactionStatus trans)
  {
   JdbcTemplate jdbc=new JdbcTemplate(dataSource);
   jdbc.execute(”insert into customer(customerName)values(’b')”);
   jdbc.execute(”insert into customer(customerName)values(’b')”);
   return null;
  }
}
   容器管理的事务处理

spring的jdbc与传统的jdbc有什么区别，其核心类有那些?

Spring的jdbc:节省代码，不管连接(Connection)，不管事务、不管异常、不管关闭(con.close() ps.close )

JdbcTemplate(dataSource):增、删、改、查
TransactionTemplate(transactionManager):进行事务处理

spring与ejb2.0的事务管理比较的优缺点?

测试:
   Spring:pojo
   Ejb:二个接口一个类,一堆配置文件
事务类型
   Spring:jdbc jta hibernate
   Ejb:jta
成本
     Spring:普通容器(tomcat jboss)
     Ejb:weblogic jboss
开发的周期:
   Spring远比ejb快.

spring的配置的主要标签是什么?有什么作用?

如何在spring中实现国际化?

在applicationContext.xml加载一个bean
<bean

id=”messageSource”class=”org.springframework.context.support.ResourceBundleMessageSource”>
  <property name=”basename”>
   <value>message</value>
  </property>
</bean>
在src目录下建多个properties文件Ø
对于非英文的要用native2asciiØ -encoding gb2312 源目转化文件相关内容
其命名格式是message_语言_国家。Ø
页面中的中显示提示信息，键名取键值。Ø
当给定国家，系统会自动加载对应的国家的properties信息。Ø
通过applictionContext.getMessage(“键名”,”参数”,”区域”)取出相关的信息。Ø

如何加入Spring到web框架中？

在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
通过如下类得到ApplicationContext实例
WebApplicationContextUtils.getWebApplicationContext

Spring如何实现资源管理?

使用
applicationContext.getResource(“classpath:文件名”):在src根目录下，在类路径下
applicationContext.getResource(“classpath:/chap01/文件名”):以src根目录下的基准往下走。
applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。

Spring中ApplicationContext的作用是什么？

beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理

spring中的核心类有那些，各有什么作用?

BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

aop中的关键名词有些那些，相互关系是什么?

拦截器: 代理
装备(advice)
目标对象
关切点:条件
连接点:方法、属性

一些Spring和Hibernate的面试题

1、简述你对IoC（Inversion of Control）的理解，描述一下Spring中实现DI（DependencyInjection）的几种方式。

2、 Spring的Bean有多种作用域，包括：

singleton、prototype、request、session、global session、application、自定义

3、简单描述Spring framework与Struts的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？

4、 Hibernate中的update()和saveOrUpdate()的区别

5、 Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理。

答案：

1、IoC将创建的职责从应用程序代码搬到了框架中。Spring对Setter注入和构造方法注入提供支持。（详见http://martinfowler.com/articles/injection.html，以及http://www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators）

2、除application（详见Spring framework2.0 Reference的3.4节bean的作用域）

3、 Spring是完整的一站式框架，而Struts仅是MVC框架，且着重于MVC中的C。Spring有三种方式整合Struts：使用 Spring 的 ActionSupport 类整合 Struts；使用 Spring 的DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor；将 Struts Action 管理委托给 Spring 框架，动作委托最好。（详见使用Spring 更好地处理Struts 动作）

Spring 2.0新增一种方式：AutowiringRequestProcessor。（详见http://www.javaeye.com/topic/24239）

4、 saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：

如果对象在该session中已经被持久化，不进行操作；

对象的标识符属性(identifierproperty)在数据库中不存在或者是个暂时的值，调用save()方法保存它；

如果session中的另一个对象有相同的标识符抛出一个异常；

以上皆不符合则调用update()更新之。

5、在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。

在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。（详见Spring framework 2.0 Reference的12.2节Hibernate）

声明式事务需声明事务管理器，在context中设置指定属性，用确定和。

请你谈谈SSH整合？

SSH：
Struts（表示层）+Spring（业务层）+Hibernate（持久层）
Struts：
Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。
在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）
Hibernate：
Hibernate是一个持久层框架，它只负责与关系数据库的操作。
Spring：
Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

EJB面试题部分

介绍一下JMS 编程步骤？

第一步:
<一>配置管理对象
1>.配置连接工厂(ConnectionFactory)
ConnectionFactory: 在应用服务器中配置的一个对象,用来获得建立消息中间件连接对象.
2>.配置目的地
第二步:
<二>分别编写消息的发送和接收程序
1>.获取连接工厂对象(JNDI 方式查找)
2>.建立连接(Connection)
3>.创建会话(Session)
4>.获取目的地对象(JNDI)
5>.分别创建生产者对象和消费者对象
6>.使用生产者对象发送消息,使用消费者对象来接收(消费)消息
7>.关闭资源: +发送对象/接收对象+Session +Connection
2>.建立连接(Connection)
3>.创建会话(Session)

几个常见的消息中间件(MOM)？

IBM WebSphere MQ
BEA tuxedo/Q
Tibco Rendezvous
Microsoft MSMQ

异步传递消息系统的作用是什么?

异步编程,客户端发送请求给消息的接收方,不用等待接收方的反馈,可以继续执行.
解耦,消息发送方只负责发送消息,并不关心由谁来消费.
可靠性,消息的服务器能够保证一定会被发送给消息的消费者.当消息的发送方发送消息时不
要求接收方一定在运行.
支持多个消息的发送方和接收方.

实体的生命周期

1>.暂态(瞬态)
没有纳入持久化上下文,无主健值,数据库中无对应的记录.
2>.受管状态(持久化状态)
纳入了持久化上下文,有主健值,数据库中有对应的记录.
3>.游离态
没纳入持久化上下文,有主健值,有无记录不确定.
4>.删除状态
调用EntityManager.remove()方法时,实体并没被删除,而是处于这种状态.
纳入了持久化上下文,数据库中会删除记录,当调用persist()方法可以重新恢复受管状态.
persist() 或find() 或remove()clear() 或close()
暂态———————————————->受管状态———————————->游离态
merge() remove()
游离态—————–>受管状态———————>删除状态
refresh()将受管状态的对象同步到数据库
flush()将数据库里同步的记录更新受管状态的对象

EntityManager都有哪些方法

persist(Objectobj) 相当于Session 的save()
refresh(Object entity) 相当于Session 的flush()
remove(Object entity) 相当于Session 的update()
find(Class<T> entityClass, Object primaryKey) 例:find(Acount.class,aid)
contains() 判断受管对象是否存在
setFlushMode()/getFlushMode() 设置/获得刷新模式

如何获得EntityManager ?

1.在容器内部使用,使用@PersistenceContext 来注入.
@PersistenceContext
private EntityManager em;
TAG
============================================================
注入:
让容器来负责构建一个实体管理器,并且将该实体管理器注入到Bean中.
============================================================
2.在容器外部使用
Persistence 构造一个EntityManagerFactory , 然后再构造EntityManager.
Code:
EntityManagerFactory emf = Persistence.createEntityManagerFactory();
EntityManager em = emf.createEntityManager();
写persistence.xml
<persistence-unit name=”firstejb”>
持久化单元名,在一个persistence.xml 中可以有多个持久化单元,用名字来区分.
如果只有一个就可以省略不写.
<provider>: 告诉容器持久化提供者是哪一个
<jta-data-source>: 数据源的位置(JNDI 名称)
<properties>: 表的生成策略

JPA的特点

A>.JPA 提供了一套标准的持久化API 和查询语言, O/R mapping产品作为”持久化提供者”在
底层支持JPA.
B>.JPA 可以在容器中运行,也可以脱离容器运行.
C>.JPA 的持久化不倚赖于具体的持久化提供者.

EJB3推出JPA的原因？

(1).EJB2.0/2.1: 实体Bean,是一种EJB,作用是负责持久化操作.
缺点: 性能低,开发复杂度大,对O/R mapping 支持不够高,不能脱离EJB 容器运行.
(2).O/R mapping 产品: Hibernate, JDO, 持久化API.操作起来各不相同,不利于维护

EJB发布WEB 服务一般步骤？

1.编写EJB(无状态会话Bean)
2.给EJB 添加WEB 服务相关的标注(@WebService,@WebMethod)
3.部署(容器生成WSDL)
4.测试WEB 服务(利用工具,如终端管理工具)

如何将无状态会话Bean 发布为WEB 服务,只有无状态会话Bean 可以发布为WEB 服务?

1.两种方式编程
(1).先写Java 类,让容器生成WSDL.
(2).先写WSDL,再用WSDL 生成Java 类.
2.编程步骤
@WebService
标注该会话Bean 发布为Web 服务.
serviceName : 标注服务的名称.
@WebMethod
标注该方法应该发布到Web 服务描述文件之中.如果所有方法都没加该标注,则所有的方法
都会发布到Web 服务描述文件中.

解释一下钝化(Swap out)？

有状态会话Bean 的实例保存有客户端状态,当容器需要使用该实例为其他客户服务时,需要
将客户端状态保存到持久化设备(硬盘).
容器按照LRU(最近最少被使用)算法将Bean 以前的状态钝化

会话Bean的种类有哪些？

1.无状态会话Bean.
1).一次方法(单方法)完成一个相对完整的业务处理.
2).不保存客户端的状态.(可以有属性,但属性不保存(维护)客户端的状态)
3).无状态会话Bean 可以非常方便的构造pooling(池)
4).无状态会话Bean 的生命周期分两个阶段: 不存在状态和就绪状态.
1>.调用缺省的构造器构造一个实例
2>.如果有一来流入则注入相应的资源
3>.如果有@PostConstruct 标注的方法,则完成初始化.
4>.EJB 实例处于就绪状态可以接收调用.
5>.当容器删除实例之前如果有@PreDestroy 标注的方法则执行.(完成资源的释放)
2.有状态会话Bean.
1).多次方法调用完成一个相对完整的业务处理过程.
2).必需保存客户端的状态.
例: ShoppingCart Bean
3).有状态会话Bean 不方便构造Pooling, 需要处理状态的钝化和激活.

什么是会话Bean

1.用来建模业务流程的EJB 中的一种类型.
2.会话Bean 的生命周期很短(存在时间),主要取决于客户端与会话Bean 的调用的时间长度.

为什么要用EJB

EJB 能为我们提供中间件服务
Remote Method Invocations(RMI) 远程方法调用(跨越JVM,网络,实现一个对象调用另一个对
象的方法)
Load Balancing 负载均衡(如多个Tomcat 组成一个Server 集群)

什么是组件架构?

企业级程序: 基础服务+ 应用逻辑
企业级程序概念:
1>.围绕商业目的2>.表示层,基于网络连接在一起,分层,分布
应用逻辑: 业务流程
基础服务: 事务,安全,并发,缓存,持久化,公用的服务
基础服务+ 应用逻辑
| |
容器(服务器开发商) 组件(开发人员)
组件架构: 协议,接口(Sun 提供),实现容器和组件接合到一起
容器提供基础服务,组件负责业务逻辑处理,组件在容器中运行,容器依照相关配置文件或标
准来调用组件,并为组件提供中间件服务.

介绍一下EJB的分类及其各自的功能及应用？

在EJB2.0中定义了三种不同类别的EJB：Session Bean（会话Bean）、Entity Bean（实体Bean）和Message-DrivenBean（消息驱动Bean）[2]。

1 会话Bean
会话Bean是商务过程对象，执行商务逻辑、规则和工作流程。会话Bean之所以被称为会话Bean，是因为它代表的是一个动作、是一个过程，它的生存期就是调用它的客户端与它进行会话的过程。

会话Bean根据其是否保存客户的状态，又分为状态会话Bean和无状态会话Bean。状态会话Bean是一种保持会话状态的服务，每个实例都与特定的客户机相关联，在与客户机的方法调用之间维持对话状态。与之相反，无状态会话Bean不保存与特定客户的对话状态。因此状态会话Bean比无状态会话Bean具有更多的功能，而无状态会话Bean实例可以通过 EJB容器自由地在客户机之间交换，从而少量的会话Bean就可以服务于大量的客户机。

2 实体Bean

实体Bean代表商务上的实体，比如商务数据，应该包含与数据相关的逻辑。实体Bean是对应到数据库中的一个视图，一个实体Bean实例和底层数据库完全是一回事[2]。因此，一个简单的实体bean实例代表一个特殊的记录。更复杂的实体bean可以代表数据库表间关联视图[3]。

实体Bean有两种操作类型：BMP（Bean管理持久性）和CMP（容器管理持久性）。BMP是指由Bean自己来实现实体Bean的持久性，即在Bean中实现数据库操作。而CMP则是由容器实现Bean的持久性，使我们不需要在Bean内再编写数据库操作的代码。

3 消息驱动Bean

消息驱动Bean是EJB2.0新引入的一种Bean类型。它的主要目的是，通过允许容器去聚合并且管理消息驱动Bean实例，以此来提供传入JMS消息的并发处理[4]。

4 会话Bean与实体Bean的区别和联系

会话Bean执行应用逻辑，它们隐含地使用实体Bean作为它们操作的数据。在EJB分布式对象体系结构中，会话Bean被用做代表实际商务过程的高层接口来屏蔽底层实体Bean子系统。实体Bean是实际恒定商务实体的模型，因此它通常比会话Bean具有更高层次的重复使用。

5 EJB的应用

接下来，通过分析电子购物环节的业务逻辑层的对象模型来说明各种EJB在业务逻辑层中的不同应用。

业务逻辑层包含了一系列EJB组件。首先我们将其抽象成若干个对象模型，如图所示：

图：对象模型图

本图首先反映了电子商务中各EJB组件之间的静态关系。

由多个购物篮条目（CartLine Item）组成的一个购物篮（Cart）为一个顾客(Customer)存储产品的临时选择；由多个订单条目（Order line Item）组成的一个订单（Order）为一个顾客存储产品的永久选择。购物篮能将自身转换为订单。

一个购物篮条目代表一个产品（Product）的临时选择，一个订单条目代表一个产品的永久选择。

估价器（Pricer）在顾客查看购物篮时计算购物篮的价格，并且在顾客最终生成订单时计算订单的价格。

订单处理器（OrderProcessor）为订单验证信用卡，发送E-mail确认，并标识为永久。

同时从本图中也可以了解一个电子购物的过程：首先，在购物时顾客把自己感兴趣的产品放入购物篮中，同时由估价器对购物篮进行及时估价。然后，顾客在确认购买后，购物篮能自动生成订单。再由估价器计算出订单的价格。接着，由订单处理器验证顾客信用卡的合法性，在交易完成后为顾客发送E-mail确认交易成功，并将本交易标识为永久。

顾客、订单、产品、订单条目这几个对象是永久性、持续性对象，例如，顾客信息、产品信息都需要存入数据库，并且在适当的时候从数据库中读取。所以，这几项都需要用实体Bean来实现。

购物篮和购物篮条目只在顾客购物的过程中起作用，所以不是永久性的，而且每一个购物篮都对应于一个特定的顾客，对应于若干条特定的购物车条目，因此购物篮和购物篮条目用状态会话Bean来充当最合适不过。

估价器的作用是计算出购物篮和订单的价格，它并没有和特定的顾客绑定，可以作用于任意的购物篮，而且也不是永久对象，因此估价器可以用一个无状态会话Bean来充当。

订单处理器是一个特殊的对象，它通过顾客所要求的不同的付款方式产生不同的订单，也就是说，它是由不同的付款方式来驱动的。所以在这里用消息驱动Bean是最恰当的。

通过上面的分析，我们清楚的了解到不同类型的EJB在实际应用中如何发挥自己的作用。

比较一下entity bean和session bean

entity bean（譬如说）代表底层数据库的一行，entity bean实例和数据库记录间就是一对一的关系。因为多个客户端必须访问底层记录，这意味着，不同于session bean，客户端必须共享entitybean。因为是共享的，所以entity bean不允许保存每个客户端的信息。session bean允许保存客户端的状态信息，客户端和session bean实例间是一对一的。entity bean允许保存记录的信息，entity bean实例和记录间是一对一的。一个理想的情况是客户端通过session bean连接服务器，然后session bean通过entity bean访问数据库。这使得既可以保存客户端的信息又可以保存数据库记录的信息。同时session bean也不能提供在相同或不同的EJB类调用间进行全局的事务控制。没有session bean，应用程序开发者（客户端开发者）就必须理解EJB类的事务要
求，并使用客户端的事务划分来提供事务控制。EJB的主要好处就是应用开发者不需知道EJB类的事务需求。一个session bean可以代表一个商业操作，进行事务控制，不需要客户端进行事务划分

分别介绍一下Session Bean和 Entity Bean

Session beans:

　　Session beans 是一种作为单个的client执行的对象。作为对远程的任务请求的相应，容器产生一个Sessionbeans 的实例。一个Session beans有一个client.从某种程度上来说，一个Session bean 对于服务器来说就代表了它的那个client.Sessionbeans 也能用于事务，它能够更新共享的数据，但它不直接描绘这些共享的数据。

　　Session beans 的生命周期是相对较短的。典型的是，只有当client保持会话的时候，Session beans 才是活着的。一旦client退出了，Session beans 就不再与client相联系了。Session beans被看成是瞬时的，因为如果容器崩溃了，那么client必须重新建立一个新的Session对象来继续会话。

　　一个Session bean典型的声明了与client的互操作或者会话。也就是说，Session bean了在客户会话期间，通过方法的调用，掌握Client的信息。一个具有状态的Session bean称为有状态的Session bean.当client终止与Session beans互操作的时候.会话终止了，而且，bean 也不再拥有状态值。

　　一个Session bean也可能是一个无状态的 session bean.无状态的Session beans并不掌握它的客户的信息或者状态。Client能够调用beans的方法来完成一些操作。但是，beans只是在方法调用的时候才知道client的参数变量。当方法调用完成以后，beans并不继续保持这些参数变量。这样，所有的无状态的session beans的实例都是相同的，除非它正在方法调用期间。这样，无状态的Session beans就能够支持多个client.容器能够声明一个无状态的Session beans.能够将任何Session beans指定给任何client.

Entity Beans:

　　Entity Beans对数据库中的数据提供了一种对象的视图。例如：一个Entity bean能够模拟数据库表中一行相关的数据。多个client能够共享访问同一个Entity bean.多个client也能够同时的访问同一个Entity bean.Entity beans通过事务的上下文来访问或更新下层的数据。这样，数据的完整性就能够被保证。

　　Entity Beans能存活相对教长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。如果由容器控制着保证 Entity beans持续的issus。如果由Beans自己管理，就必须写Entity beans的代码，包括访问数据库的调用。

　　Entity Beans是由主键（primary key 一种唯一的对象标识符）标识的。通常，主键与标识数据库中的一块数据，例如一个表中的一行，的主键是相同的。主键是client能够定位特定的数据块。

介绍一下EJB的体系结构

EJB的上层的分布式应用程序是基于对象组件模型的，低层的事务服务用了API技术。EJB技术简化了用JAVA语言编写的企业应用系统的开发，配置，和执行。EJB的体系结构的规范由Sun Microsystems公司制定。Inprise的EJB容器是基于1.1版的规范。

　　EJB技术定义了一组可重用的组件：Enterprise Beans。你可以利用这些组件，象搭积木一样的建立你的分布式应用程序。当你把代码写好之后，这些组件就被组合到特定的文件中去。每个文件有一个或多个Enterprise Beans，在加上一些配置参数。最后，这些EnterpriseBeans被配置到一个装了EJB容器的平台上。客户能够通过这些Beans的home接口，定位到某个beans，并产生这个beans的一个实例。这样，客户就能够调用Beans的应用方法和远程接口。

　　EJB服务器作为容器和低层平台的桥梁管理着EJB容器和函数。它向EJB容器提供了访问系统服务的能力。例如：数据库的管理和事务的管理，或者对于其它的Enterprise的应用服务器。

　　所有的EJB 实例都运行在EJB容器中。容器提供了系统级的服务，控制了EJB的生命周期。因为容器掌握了绝大多数系统级的issues(呵呵，不知道怎么翻译)。EnterpriseBeans 的开发者不需要应用逻辑考虑进来。通常来说，EJB容器掌握了以下的系统级issues.

　　1、Security–配置描述器（The Deployment descriptor）定义了客户能够访问的不同的应用函数。容器通过只允许授权的客户访问这些函数来达到这个效果。

　　2、Remote Connectivity–容器为远程链接管理着低层的通信issues，而且对Enterprise Beas的开发者和客户都隐藏了通信issues.EnterpriseBeans的开发者在编写应用方法的时候，就象是在条用本地的平台一样的。客户也不清楚他们调用的方法可能是在远程被处理的。

　　3、Life Cycle managment–客户简单的创建一个Enterprisebeans的实例，并通常取消一个实例。而容器管理着Enterprise Beans的实例，使Enterprise Beans实现最大的效能和内存利用率。容器能够这样来激活和去活EnterpriseBeans，保持众多客户共享的实例池。等等。

　　4、Trasction management—配置描述器定义了Enterprisebeans 的事务处理的需求。容器管理着那些管理分布式事务处理的复杂的issues。这些事务可能要在不同的平台之间更新数据库。容器使这些事务之间互相独立，互不干扰。保证所有的更新数据库都是成功发生的，否者，就回滚到事务处理之前的状态

如果Session Bean得Remove方法一直都不被调用会怎么样？

如果Session Bean是无状态Bean的话，调用不调用Remove方法都没有什么关系

如果是有状态Bean的话，那么这个Bean会一直保存到Cache里面，知道SessionTimeout或者Remove方法被调用。

EJB timer的种类？

从EJB容器的定时服务建立的Timer对象， Single Action Timer和Interval Timer, Single Action Timer是相对与间隔循环型Timer来讲的， Single Action Timer只有一次timeout。Single-Action time和Interval Timer第一次启动都各有两种方法：绝对时间启动和相对时间启动。

所以总共有四种EJB timer

1. 以绝对时间启动的Single Action Timer

你可以指定一个绝对时间，但时间到达（timeout）时，这可以调用TimerService的方法来建立这个Timer:

Timer createTimer（Date expirationDate, Serializable info）

2. 以相对时间启动的Single Action Timer

你可以指定一个相对于Timer简历的时间，当这个相对时间到达时，会调用Timeout方法一次，这个调用可以通过TimerService的一下方法来建立这个Timer:

TimercreateTimer(long duration, Serializable info)

3. 绝对时间的Interval Timer

你可以指定一个初始的绝对时间(initialExpiration),当这个时间到达时，会调用Timeout方法，之后每个一段指定的时间(intervalDuration)就会重新调用Timeout方法一次，建立这种Timer的方法：

TimercreateTimer(Date initialExpiration，longintervalDuration, Serializable info)

4. 相对时间的Interval Timer

你可以指定一个相对与Timer建立的时间(initialDuration), 当时间到达时就会调用Timerout方法，之后每隔一段指定的时间(intervalDuration)就会重新调用Timeout方法一次，以下是建立这种方法的例子：

TimercreateTimer(long initialDuration, long intervalDuration, Serializable info)

这四个createTimer()方法的最后一个Serializable参数，可以设定给Timer对象， Timeout的调用方法中必须接受Timer对象最为参数，你可以用它的getInfo()方法来取得传入的Serializable对象，当多个Timer与Bean关联时，必须识别Timer时间是来之于哪个Timer,也可以根据传入的Serializable对象来判断。

EJB2.0和EJB3.0之间的区别？

1. EJB2.0使用EntityBeans来访问数据库，EJB3.0是使用JPA（Java Persistance API）来访问数据库。

2. EJB2.0 有部署脚本(Deployment descriptiors),EJB3.0没有。

3. EJB3.0不需要Home接口，EJB2.0需要。

4. EJB3.0简化了开发，引入了元数据。

提高EJB性能都有哪些技巧？

1.用一个Session Bean封装多个Entity Bean，将原来的多个Entity Bean的Remote调用和Local调用封装在一个Session Bean中。所以建立一个ServerFacade，它为多个对象提供统一获取EJB Home和获取对象的接口。ServerFacade为程序要用到的所有EJB的home handle提供缓存，提高访问JNDI Name的时间，达到提高访问效率的目的。以后查找JNDI Name的方法都应写在接口里，调用时直接从接口调用。

2.在EJB的Remote接口中使用粗粒度的方法，不推荐使用细粒度方法。

3.如果EJB的Remote接口获取成功，应不再使用Remote接口，而是将Remote接口构造成一个一般的Java对象，通过调用一般的JAVA对象的方法来达到减少对网络的访问。

4.如果你部署EJB客户端和EJB在相同的JVM上，建设使用EJB2.0规范的Local接口代替Remote接口。

5.用”transient”关键字声明不必要的数据变量，替代以前的”public”、”private”等，避免不必要的数据变量占用网络资源。示例：

public classDemoCMP implements EntityBean {
transient EntityContext entCtx;
transient InitialContext initCtx;
public String id;
public String description;
…
}

6.在ejb-jar.XML部署文件中，对Session Bean中非事务的方法，将trans-attribute属性赋为”NotSupported”或”Never”

<ejb-jar>
…
<assembly-descriptor>
<container-transaction>
<method>
<ejb-name>abookesessionBean</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>NotSupported</trans-attribute>
</container-transaction>
</assembly-descriptor>
</ejb-jar>

7. 设置事务的超时时间，在JBoss中，要修改${jboss.home}/server/${jboss.configuration}/conf/jboss-service.xml，如下所示：

8.当事务锁定数据库的行记录时，事务应跨越可能的最小的时间。

9.调整EJB 服务器的各种参数，如线程数、EJB池大小、连接池参数等。以在JBoss修改连接池参数为示例，进行说明。如果JBoss和MySQL相连，配置${jboss.home}/server/${jboss.configuration}/deploy/mysql-service.xml，来修改连接池参数，包括MinSize、MaxSize、BlockingTimeoutMillis、IdleTimeoutMinutes、 Criteria等，各参数的含义如下所示：

i.MinSize ：连接池保持的最小连接数。

ii. MaxSize ：连接池保持的最大连接数。

iii.BlockingTimeoutMillis ：抛出异常前最大的等待连接时间。

iv.IdleTimeoutMinutes ：关闭连接前连接空闲的最大时间。

v. Criteria ：有ByContainerAndApplication、ByContainer、ByApplication和ByNothing等值。

下面是一个例子：

<dependsoptional-attribute-name=”ManagedConnectionPool”>
<!–embedded mbean–>
<mbeancode=”org.jboss.resource.connectionmanager.JBossManagedConnectionPool”
name=”jboss.jca:service=LocalTxPool,name=MySqlDS”>
<attribute name=”MinSize”>0</attribute>
<attribute name=”MaxSize”>50</attribute>
<attribute name=”BlockingTimeoutMillis”>5000</attribute>
<attribute name=”IdleTimeoutMinutes”>15</attribute>
<attribute name=”Criteria”>ByContainer</attribute>
</mbean>
</depends>

10.对于数据库事务，应选择较低成本的事务等级，避免造成坏数据。递增成本的事务等级包括：

TRANSACTION_READ_UNCOMMITED,
TRANSACTION_READ_COMMITED,
TRANSACTION_REPEATABLE_READ,
TRANSACTION_SERIALIZABLE

EJB包括（SessionBean,EntityBean）说出他们的生命周期，及如何管理事务的？

SessionBean：StatelessSession Bean 的生命周期是由容器决定的，当客户机发出请求要建立一个Bean的实例时，EJB容器不一定要创建一个新的Bean的实例供客户机调用，而是随便找一个现有的实例提供给客户机。当客户机第一次调用一个Stateful Session Bean 时，容器必须立即在服务器中创建一个新的Bean实例，并关联到客户机上，以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例。
EntityBean：Entity Beans能存活相对较长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。EntityBeans生命周期能够被容器或者 Beans自己管理。
EJB通过以下技术管理实务：对象管理组织（OMG）的对象实务服务（OTS），Sun Microsystems的TransactionService（JTS）、JavaTransaction API（JTA），开发组（X/Open）的XA接口

EJB的基本架构？

一个EJB包括三个部分:
Remote Interface 接口的代码
package Beans;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface Add extends EJBObject
{
//some method declare
}
Home Interface 接口的代码
package Beans;
import java.rmi.RemoteException;
import jaax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface AddHome extends EJBHome
{
//some method declare
}
EJB类的代码
package Beans;
import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javx.ejb.SessionContext;
public class AddBean Implements SessionBean
{
//some method declare
}

1、 EJB需直接实现它的业务接口或Home接口吗，请简述理由

远程接口和Home接口不需要直接实现，他们的实现代码是由服务器产生的，程序运行中对应实现类会作为对应接口类型的实例被使用。

说说在weblogic中开发消息Bean时的persistent与non-persisten的差别

persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来，而non－persistent方式的消息将被丢弃。

在weblogic中发布ejb需涉及到哪些配置文件

不同类型的EJB涉及的配置文件不同，都涉及到的配置文件包括ejb-jar.xml,weblogic-ejb-jar.xmlCMP实体Bean一般还需要weblogic-cmp-rdbms-jar.xml

客服端调用EJB对象的几个基本步骤

设置JNDI服务工厂以及JNDI服务地址系统属性，查找Home接口，从Home接口调用Create方法创建Remote接口，通过Remote接口调用其业务方法。

EJB的几种类型

会话（Session）Bean ，实体（Entity）Bean 消息驱动的（MessageDriven）Bean
会话Bean又可分为有状态（Stateful）和无状态（Stateless）两种
实体Bean可分为Bean管理的持续性（BMP）和容器管理的持续性（CMP）两种

EJB的激活机制

以Stateful Session Bean 为例：其Cache大小决定了内存中可以同时存在的Bean实例的数量，根据MRU或NRU算法，实例在激活和去激活状态之间迁移，激活机制是当客户端调用某个EJB实例业务方法时，如果对应EJBObject发现自己没有绑定对应的Bean实例则从其去激活Bean存储中（通过序列化机制存储实例）回复（激活）此实例。状态变迁前会调用对应的ejbActive和ejbPassivate方法。

EJB实例的生命周期

对于StatelessSession Bean、Entity Bean、MessageDriven Bean一般存在缓冲池管理，而对于Entity Bean和Statefull Session Bean存在Cache管理，通常包含创建实例，设置上下文、创建EJB Object（create）、业务方法调用、remove等过程，对于存在缓冲池管理的Bean，在create之后实例并不从内存清除，而是采用缓冲池调度机制不断重用实例，而对于存在Cache管理的Bean则通过激活和去激活机制保持Bean的状态并限制内存中实例数量。

remote接口和home接口主要作用

remote接口定义了业务方法，用于EJB客户端调用业务方法。
home接口是EJB工厂用于创建和移除查找EJB实例

EJB规范规定EJB中禁止的操作有哪些？

1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)，2.不能操作awt，3.不能实现服务器功能，4.不能对静态属生存取，

5.不能使用IO操作直接存取文件系统，6.不能加载本地库.，7.不能将this作为变量和返回，8.不能循环调用。

EJB的角色和三个对象

一个完整的基于EJB的分布式计算结构由六个角色组成，这六个角色可以由不同的开发商提供，每个角色所作的工作必须遵循Sun公司提供的EJB规范，以保证彼此之间的兼容性。这六个角色分别是EJB组件开发者（EnterpriseBean Provider）、应用组合者（Application Assembler）、部署者（Deployer）、EJB 服务器提供者（EJB Server Provider）、EJB 容器提供者（EJB Container Provider）、系统管理员（SystemAdministrator）
三个对象是Remote（Local）接口、Home（LocalHome）接口，Bean类

EJB与JAVA BEAN的区别？

Java Bean 是可复用的组件，对JavaBean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat）的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理，EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

JSP和EJB可以共享HttpSession么？EJB里面可以改变session里面的内容么？

如果session里面所有的对象都是序列化的，应该可以把HttpSession作为一个参数传到EJB的方法，这样的话就是值传递，相当于这个 HttpSession是自读的，如果在EJB里面改变session的值，不会影响到Servlet容器里面的HttpSession，但是因为EJB 的远程接口之间是使用远程引用，也就是引用传递，所以把HttpSession作为参数传到EJB对象是可能的，但是这样是有违面向对象的原则的，因为这样的话就在EJB和前端的HttpSession 之间创建了一个不必要的依赖关系，而且这样的话EJB对基于Http的客户端也产生了依赖（EJB也有可能给非Http的客户端服务的），其实与其传一整个HttpSession对象到EJB, 还不如另外创建一个类似结构的对象过去，然后在EJB进行处理以后然后在返回客户端。

SOA面试题部分

1、 web services是SOA吗？

SOA是一种思想，它是一种架构的理念，Web Service是一种来实现这理念的技术方法， Web Service是实现SOA的推荐标准。
在SOA中，所有的服务之间要松耦合，web servcie之间的通信是通过SOAP协议进行的，SOAP协议是基于XML实现的松耦合的协议。
SOA服务需要对他们自己的服务本身进行描述，WSDL就是用来描述如何访问到SOA的服务。
SOA服务存在于一个目录中，UDDI就是用来描述从那里得到SOA服务的，只需要完成SOA的注册就可以了。

2、解释一下什么是BPEL？

BPEL：全称为BusinessProcess Execution Language,即业务处理执行语言，是一种使用XML编写的编程语言。用于自动化业务流程，也曾经被称作WSBPEL和 BPEL4WS。广泛使用于Web服务相关的项目开发中，优点为具有可移植性和有效保护了投资。
　　BPEL是一门用于自动化业务流程的形式规约语言。用XML文档写入BPEL中的流程能在Web 服务之间以标准化的交互方式得到精心组织。这些流程能够在任何一个符合BPEL规范的平台或产品上执行。所以，通过允许顾客们在各种各样的创作工具和执行平台之间移动这些流程，BPEL使得他们保护了他们在流程自动化上的投资。尽管以前想使业务流程定义标准化，但BPEL已经引起了史无前例的兴趣，而且它最早在软件供应商中获得大量认可。

3、什么是WEB 服务 Web Service?

<1>.程序间以一种标准的方式进行通讯(与程序的开发语言,运行的操作系统,硬件平台,网络
关系无关)
<2>.用SOAP,WSDL 等协议通讯,以XML 文档方式进行数据交换的网络应用程序.

4、介绍一下SOA和SOA的基本特征？

什么是SOA
SOA:面向服务的体系结构（Service-OrientedArchitecture，SOA，也叫面向服务架构）, SOA是指为了解决在Internet环境下业务集成的需要，通过连接能完成特定任务的独立功能实体实现的一种软件系统架构。
SOA 是一个组件模型，它将应用程序的不同功能单元（称为服务）通过这些服务之间定义良好的接口和契约联系起来。接口是采用中立的方式进行定义的，它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种这样的系统中的服务可以以一种统一和通用的方式进行交互。

SOA与传统服务的区别
传统的Web（HTML/HTTP）技术有效的解决了人与信息系统的交互和沟通问题，极大的促进了B2C模式的发展。WEB服务(XML/SOAP /WSDL）技术则是要有效的解决信息系统之间的交互和沟通问题，促进B2B/EAI/CB2C的发展。SOA则是采用面向服务的商业建模技术和WEB服务技术，实现系统之间的松耦合，实现系统之间的整合与协同。WEB服务和SOA的本质思路在于使得信息系统个体在能够沟通的基础上形成协同工作。

解释下列WebService名词：WSDL、SOAP、UDDI

WSDL是一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点（服务）。
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。
UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

介绍一下你对SOA的认识

这个问题可以从WHY SOA和SOA面临的挑战入手回答
1. WHY SOA? SOA的好处在哪里？
减低IT成本：重用现有的系统，而且SOA系统本身也可以被后来的应用重用; 减少维护费用，对现有系统造成很少的改动。
增加IT收入：快速的适应新的需求，快速的实现，提高性能，实现云计算如 Google, Amazon等等
2. SOA面临的挑战有哪些？
更多的系统参与到SOA中，更多的人参与到SOA中，需要更多的交流沟通
在安全控制方面特别是在EAI（enterpriseapplication integration）的MOM（MessageOriented Middleware）中的安全控制更加复杂
需要更高更新的技术参与进来，需要更多的有经验的人员。

主要的开源ESB产品有哪些？各有什么特点？

主要的开源ESB有Mule，Apache ServiceMix,Open ESB, Jboss ESB,Apache Synapse 等等

Mule

它是一个轻量级的消息框架和整合平台，基于EIP（Enterprise Integeration Patterns,由Hohpe和Woolf编写的一本书）而实现的。
Mule的核心组件是UMO(Universal Message Objects，从Mule2.0开始UMO这一概念已经被组件Componse所代替)，UMO实现整合逻辑。

Apache ServiceMix

它是JBI规范的一种实现。它包涵了许多JBI组件，这些组件支持多种协议，比如JMS,HTTP,FTP,FILE等。同时也实现了EIP，规则和调度。

Open ESB是由SUN发起，现在作为Java.net的子项目。所有Open ESB的开发人员都来自SUN。
如同Apache ServiceMix一样，Open ESB也实现了JBI规范。Open ESB可运行在由SUN支持的Glassfish应用服务中。同时SUN的Netbeans IDE为Open ESB提供了拖拉式的开发工具，这是其他开源ESB不可匹敌的

Apache Synapse具备一些ESB所必备的功能，但是从本质上而言Synapse更是一个web服务仲裁框架，它是构建在Apache Axis2之上的。Synapse的关注点是路由，转换，消息验证以及基于web服务和xml标准的注册。它支持HTTP, SOAP, SMTP, JMS,FTP,MTOM/XOPPOP3/IMAP/SMTP 等传输协议，还支持多种web服务规范(WS-*)，比如WS-Addressing,WS-Security,WS-Policy以及WS- Reliable Messaging。在它的最新版本1.2中加入了对FIX(Financial Information eXchange,金融信息交换协议) 和 Hessian 的支持。同时它还支持多种流行语言，比如Java, JavaScript, Ruby, Groovy等。JBoss ESB是基于JBoss公司的ESB产品Rosetta的。Jboss ESB将JbossMQ作为其消息层，将JBoss rules为其提供路由功能，
将jBPM为其提供服务编排功能。

什么是ESB？请介绍一下ESB?

ESB的全称是Enterprise Service Bus （企业服务总线）。它是一个ielinghuode用于集成各种企业应用即服务的连接基础架构，企业服务总线能够通过简化企业应用及服务之间的链接数量，接口大小以及接口复杂度使企业的面向服务体系SOA更加强大。

Enterprise ServiceBus 主要提供一下几方面的功能：

1. 在服务于服务之间或者应用于应用之间路由消息；

2. 在服务请求者与服务提供者之间转换传输协议；

3. 在服务请求者与服务提供者之间转换消息格式；

4. 处理来自于各种已购源的业务事件；

企业服务总线使企业可以更主要的关于企业的核心业务而不用在关注与连接各种应用的IT基础架构，它还可以让企业在增加新的服务及对已有服务进行修改时，可以对原有系统及服务不产生影响或者只有微小的影响。

介绍一下Axis2?

Apache Axis2是一个基于Java的Web Service实现，它提供了完整的对象模型和模块化的架构。
Axis2可以让你轻易的完成如下工作：
1. 发送SOAP消息
2. 接受和处理SOAP消息
3. 从一个纯Java类生成一个Web Service
4. 使用WSDL来创建服务端和客户端的实现类
5. 非常容易的从一个service来获取WSDL
6. 发送和接受带有附件的SOAP消息
7. 创建和使用REST的Web Service
8. 创建和使用带有WS-Security, WS-ReliableMessaging,WS-Addressing, WS-Coordination和WS-AtomicTransaction的Web Service.
9. 使用Axis2的模块化结构来容易的添加新的支持

SOA的常见陷阱或者误解是什么？

最经常出现的陷阱是开发人员只注意在构建一个SOA解决方案而不是解决一个特定的业务问题，这样就会在不同的IT系统之间造成复杂的，不易管理的和不必要的联系。

如何在SOA中实现松耦合？

实现松耦合的一个策略是使用serviceinterface（如果是SOAP web service的话就是指WSDL）来限制它的依赖性，对消费者隐藏服务的实现。实现松耦合需要更好的包装服务和功能以降低对service接口的改变。

top-down和bottom-up这两种实现SOA的流程哪种更鼓励重用和维护？

因为top-down流程是业务驱动的(business-driven), 所以它能实际的拆分业务和IT之间的不同关注点，提供一个通用的对两个都合适的解决方案。所以在大部分情况下，如果你想在中期和长期提高重用和ROL，top-down都是最合适的

如何定义一个可复用的服务？

可复用的服务是一个自主的，可复用的，显式的，无状态的功能。它拥有一定的粒度，可是是一个组合应用和组合服务的一部分。

可复用的服务必须由服务规范(ServiceSpecifications)描述的业务活动所认可。

一个服务的约束，包括安全，QoS, SLA, 使用策略可能被多个运行时契约(Contracts), 多个接口(SOAP web service的WSDL)和多种实现(代码)所定义。

一个可复用的服务需在它的整个生命周期的管理都需要时企业级的。在设计时一直到运行时，它的重用都需要通过规定的流程来保证，而且重用也是需要评估的。

WSDL的操作类型主要有几种？

request-response类型是最常见的操作类型，但是WSDL总共有四种操作类型。

Type	定义
One-way	这个操作会接受消息但是不会返回一个响应
Request-response	这个操作会接受一个请求而且返回一个响应
Solicit-response	这个操作会发送一个请求然后等待响应
Notification	这个操作会发送一个消息而且不等待响应。

介绍一下WSDL Ports

<portType>元素是最重要的WSDL元素。

它用来描述一个webservice, web service进行的操作和web service包含的消息。

<portType>元素类似与传统编程语言中的一个功能类。

请介绍一下WSDL的文档结构

WSDL文档的主要元素有：

元素	定义
<types>	web service使用的数据类型
<message>	web service使用的消息
<portType>	web service进行的操作(方法)
<binding>	web service使用的通信协议

请简单介绍一下WSDL

1. WSDL stands forWeb Services Description Language, WSDL的全称是Web Service Description Lanaguage.

2. WSDL是XML格式的, WSDL就是一个XML文档。

3. WSDL是用来描述Web Service的。

4. WSDL也用来定位Web Service。

5. WSDL是W3C推荐的。

第三章：J2EE高级软件工程师面试题

--------数据库面试题部分

为数据库创建索引都需要注意些什么？

1. 索引能提高速度的关键就是索引所占的空间要比表小得多
2. 注意索引的大小，有一些表可以建成索引组织表
3. 索引的列不要太多，要选择一些selective比较低的列建B-tree索引，选择selective高的列建bitmap索引(在更新比较多的表不不要建bitmap索引)
4. 将selective较低的列放在前面
5. 在更新不多的表上建索引时，可以考虑用compress选择，以节约索引的空间

第一范式（1NF）、第二范式（2NF）和第三范式（3NF）之间的区别是什么？

构造数据库必须遵循一定的规则。在关系数据库中，这种规则就是范式。范式是符合某一种级别的关系模式的集合。关系数据库中的关系必须满足一定的要求，即满足不同的范式。目前关系数据库有六种范式：第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、第四范式（4NF）、第五范式（5NF）和第六范式（6NF）。满足最低要求的范式是第一范式（1NF）。在第一范式的基础上进一步满足更多要求的称为第二范式（2NF），其余范式以次类推。一般说来，数据库只需满足第三范式（3NF）就行了。下面我们举例介绍第一范式（1NF）、第二范式（2NF）和第三范式（3NF）。

3.4.1 第一范式（1NF）
在任何一个关系数据库中，第一范式（1NF）是对关系模式的基本要求，不满足第一范式（1NF）的数据库就不是关系数据库。
所谓第一范式（1NF）是指数据库表的每一列都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性，就可能需要定义一个新的实体，新的实体由重复的属性构成，新实体与原实体之间为一对多关系。在第一范式（1NF）中表的每一行只包含一个实例的信息。例如，对于图3-2 中的员工信息表，不能将员工信息都放在一列中显示，也不能将其中的两列或多列在一列中显示；员工信息表的每一行只表示一个员工的信息，一个员工的信息在表中只出现一次。简而言之，第一范式就是无重复的列。

3.4.2 第二范式（2NF）
第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。第二范式（2NF）要求数据库表中的每个实例或行必须可以被惟一地区分。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。如
图3-2 员工信息表中加上了员工编号（emp_id）列，因为每个员工的员工编号是惟一的，因此每个员工可以被惟一区分。这个惟一属性列被称为主关键字或主键、主码。
第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。

3.4.3 第三范式（3NF）
    满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。例如，存在一个部门信息表，其中每个部门有部门编号（dept_id）、部门名称、部门简介等信息。那么在图3-2
的员工信息表中列出部门编号后就不能再将部门名称、部门简介等与部门有关的信息再加入员工信息表中。如果不存在部门信息表，则根据第三范式（3NF）也应该构建它，否则就会有大量的数据冗余。简而言之，第三范式就是属性不依赖于其它非主属性。
所谓范式就是符合某一种级别的关系模式的集合。通过分解把属于低级范式的关系模式转换为几个属于高级范式的关系模式的集合。这一过程称为规范化。

1、   第一范式（1NF）：一个关系模式R的所有属性都是不可分的基本数据项。
2、   第二范式（2NF）：关系模式R属于第一范式，且每个非主属性都完全函数依赖于键码。
3、   第三范式（3NF）：关系模式R属于第一范式，且每个非主属性都不伟递领带于键码。
4、   BC范式（BCNF）：关系模式R属于第一范式，且每个属性都不传递依赖于键码。

一组SQL面试题

1. 在表A中有数据
ID   MO
1   Y
2   N
请用一个SELECT 语句写出，如果MO的值为“Y”，返回“YES”，为N返回“NO”
效果如下:
ID   MO
1   YES
2   NO
SELECT ID,MO=CASE
WHEN MO=’Y’ THEN ‘YES’
WHEN MO=’N’ THEN ‘NO’
END
FROM Az
2. 在表A中查询出自动增长列中31到40之间的数据(注意可能不是连续的)
select * from A where id between 31 and 40
3. 有一个表table中有一个自动增长字段ID,如果在存储过程中向这个表插入一条记录后,如何获得新记录的ID.(写出获取新记录ID的函数即可)
CREATE FUNCTION c_currentId()
RETURNS int
AS
BEGIN
declare @lastId int
select @lastId=max(cid) from c
RETURN (@lastId)
END
select tempdb.dbo.c_currentId() as ‘当前C表中最新的编号’
4. having的用法, 是用来做什么的   having用来对group by 分组后的记录进行过滤。
5. sql中的什么函数可以转换为时间   selectconvert(datetime,’2000/01/01′)   select cast(’2001/02/02′ asdatetime)
6. 查询数据放入一张临时表   select * into #A fromTest   select * from #A

存储过程的优缺点是什么？

优点：
1.由于应用程序随着时间推移会不断更改，增删功能，T－SQL过程代码会变得更复杂，StoredProcedure为封装此代码提供了一个替换位置。

2.执行计划（存储过程在首次运行时将被编译，这将产生一个执行计划－－实际上是 Microsoft SQLServer为在存储过程中获取由 T-SQL 指定的结果而必须采取的步骤的记录。）缓存改善性能。
……..但sql server新版本，执行计划已针对所有T-SQL 批处理进行了缓存，而不管它们是否在存储过程中，所以没比较优势了。

3.存储过程可以用于降低网络流量，存储过程代码直接存储于数据库中，所以不会产生大量T-sql语句的代码流量。

4.使用存储过程使您能够增强对执行计划的重复使用，由此可以通过使用远程过程调用 (RPC) 处理服务器上的存储过程而提高性能。RPC 封装参数和调用服务器端过程的方式使引擎能够轻松地找到匹配的执行计划，并只需插入更新的参数值。

5.可维护性高，更新存储过程通常比更改、测试以及重新部署程序集需要较少的时间和精力。

6.代码精简一致，一个存储过程可以用于应用程序代码的不同位置。

7.更好的版本控制，通过使用 Microsoft Visual SourceSafe 或某个其他源代码控制工具，您可以轻松地恢复到或引用旧版本的存储过程。

8.增强安全性：
a、通过向用户授予对存储过程（而不是基于表）的访问权限，它们可以提供对特定数据的访问；
b、提高代码安全，防止 SQL注入（但未彻底解决，例如，将数据操作语言－－DML，附加到输入参数）；
c、SqlParameter 类指定存储过程参数的数据类型，作为深层次防御性策略的一部分，可以验证用户提供的值类型（但也不是万无一失，还是应该传递至数据库前得到附加验证）。

缺点：

1.如果更改范围大到需要对输入存储过程的参数进行更改，或者要更改由其返回的数据，则您仍需要更新程序集中的代码以添加参数、更新 GetValue() 调用，等等，这时候估计比较繁琐了。

2.可移植性差

由于存储过程将应用程序绑定到SQL Server，因此使用存储过程封装业务逻辑将限制应用程序的可移植性。如果应用程序的可移植性在您的环境中非常重要，则将业务逻辑封装在不特定于 RDBMS 的中间层中可能是一个更佳的选择。

如何用SQL语句进行模糊查找？

LIKE条件一般用在指定搜索某字段的时候, 通过”% _” 通配符的作用实现模糊查找功能，通配符可以在前面也可以在后面或前后都有。

搜索以mian开头：
SELECT * FROM teble WHERE title LIKE ‘mian%’

搜索以mian结束：
SELECT * FROM teble WHERE title LIKE ‘%mian’

搜索包含mian：
SELECT * FROM teble WHERE title LIKE ‘%mian%’
注释：%表示0个或多个字符构成的字符串
_表示单个字符

介绍一下内联、左联、右联

一.先看一些最简单的例子

例子

Table A
aid adate
1 a1
2 a2
3 a3

TableB

bid bdate
1 b1
2 b2
4 b4
两个表a,b相连接,要取出id相同的字段
select * from a inner join b on a.aid = b.bid这是仅取出匹配的数据.
此时的取出的是:
1 a1 b1
2 a2 b2

那么left join 指:
select * from a left join b on a.aid = b.bid
首先取出a表中所有数据,然后再加上与a,b匹配的的数据
此时的取出的是:
1 a1 b1
2 a2 b2
3 a3 空字符

同样的也有right join
指的是首先取出b表中所有数据,然后再加上与a,b匹配的的数据
此时的取出的是:
1 a1 b1
2 a2 b2
4 空字符 b4

LEFT JOIN 或 LEFT OUTER JOIN。
左向外联接的结果集包括 LEFT OUTER 子句中指定的左表的所有行，而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行，则在相关联的结果集行中右表的所有选择列表列均为空值

二. leftjoin/right join/inner join操作演示

表A记录如下：
aID aNum
1 a20050111
2 a20050112
3 a20050113
4 a20050114
5 a20050115

表B记录如下:
bID bName
1 2006032401
2 2006032402
3 2006032403
4 2006032404
8 2006032408

实验如下:
1. left join
sql语句如下:

SELECT * FROM A
LEFT JOIN B
ON A.aID = B.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
5 a20050115 NULL NULL
（所影响的行数为 5 行）

结果说明:
left join是以A表的记录为基础的,A可以看成左表,B可以看成右表,left join是以左表为准的.
换句话说,左表(A)的记录将会全部表示出来,而右表(B)只会显示符合搜索条件的记录(例子中为: A.aID = B.bID).
B表记录不足的地方均为NULL.

2. right join
sql语句如下:

SELECT * FROM A
RIGHT JOIN B
ON A.aID = B.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
NULL NULL 8 2006032408
（所影响的行数为 5 行）

结果说明:
仔细观察一下,就会发现,和left join的结果刚好相反,这次是以右表(B)为基础的,A表不足的地方用NULL填充.

3.inner join
sql语句如下:

SELECT * FROM A
INNERJOIN B
ON A.aID = B.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404

结果说明:
很明显,这里只显示出了 A.aID = B.bID的记录.这说明inner join并不以谁为基础,它只显示符合条件的记录.

－－－－－－－－－－－－－－－－－［以下为网上的一点资料］－－－－－－－－－－－－－－－－－－
LEFT JOIN操作用于在任何的 FROM 子句中，组合来源表的记录。使用 LEFT JOIN 运算来创建一个左边外部联接。左边外部联接将包含了从第一个（左边）开始的两个表中的全部记录，即使在第二个（右边）表中并没有相符值的记录。

语法：
FROM table1 LEFT JOIN table2 ON table1.field1 compopr table2.field2

说明：
①　table1, table2参数用于指定要将记录组合的表的名称。
②　field1, field2参数指定被联接的字段的名称。且这些字段必须有相同的数据类型及包含相同类型的数据，但它们不需要有相同的名称。
③　compopr参数指定关系比较运算符：”=”， “<"， ">“， “<="， ">=” 或 “<>“。
④　如果在INNER JOIN操作中要联接包含Memo 数据类型或 OLE Object 数据类型数据的字段，将会发生错误。

说一下mysql, oracle等常见数据库的分页实现方案？

1.Oracle:
select * from ( select row_.*, rownum rownum_ from ( query_SQL ) row_ whererownum =< max) where rownum_ >= min
2.SQL Server:
select top @pagesize * from tablename where id not in (select top @pagesize*(@page-1)id from tablename order by id) order by id

3.MySQL
select * from tablename limit position, counter

4.DB2
select * from (select *,rownumber() as ROW_NEXT from tablename) where ROW_NEXTbetween min and max

——————————————————————————————–
1.分页方案一：(利用NotIn和SELECT TOP分页)效率次之
语句形式：
SELECT TOP 10 * FROM TestTable
WHERE(ID NOT IN (SELECT TOP 20 id FROM TestTable ORDERBY id)) ORDERBYID
SELECT TOP 页大小 * FROM TestTable
WHERE( ID NOT IN　(SELECT TOP 每页大小-1*待查询页数-1 id FROM 表　ORDERBY id)) ORDERBYID
思路:先查询出待查询页之前的全部条数的id,查询ID不在这些ID中的指定数量条数

2.分页方案二：(利用ID大于多少和SELECT TOP分页)效率最高
语句形式：
SELECT TOP 10 * FROM TestTable
WHERE(ID>(SELECT MAX(id) FROM(SELECT TOP20 id FROM TestTableORDERBYid)AS T))ORDERBY ID
SELECT TOP 页大小* FROM TestTable
WHERE(ID>(SELECT MAX(id) FROM(SELECT TOP 每页大小*待查询页数-1 id FROM 表 ORDERBY id)AS T))ORDERBY ID
思路:先获得待查询页的之前全部条数id,获得它们当中最大的ID号,以此最大ID号为标志,查找比这个ID号大的指定条数

3.分页方案三：
SELECT TOP PageSize * FROM(SELECT TOP nPage*PageSize * from YOURTABLE order byid)as a order by id desc
SELECT TOP 每页条数 * FROM (SELECT TOP 待查询页*每页条数) * from YOURTABLE order by id)as aorder by id desc
思路:先正排序查询出待查询页之前(包括当前页)的全部条数,然后将其倒排序,取指定条数

几个SQL的面试题

1. 解释一下SQL里面的null
答案：null代表一个unknown的值或者一个不存在的值
2. 如何用SQL判断一个值是不是null?
答案：可以用is null来判断一个值是不是null
3. 所有包含null的计算表达式的返回结果都是null, 这句话正确吗？比如5+ null返回null
答案：正确
4. 所有与null得比较运算都返回unknown正确吗？
答案：正确
5. (unknown or true) = true正确吗？
答案：正确
6. (unknown or false) = unknown正确吗？
答案：正确
7. (unknown or unknown) = unknown正确吗？
答案：正确
8. (true and unknown) = unknown正确吗？
答案：正确
9. (false and unknown) = false正确吗？
答案：正确
10. (unknown and unknown) = unknown正确吗？
答案：正确
11. (not unknown) = unknown 正确吗？
答案：正确

介绍一下游标？

游标是从数据表中提取出来的数据，以临时表的形式存放在内存中，在游标中有一个数据指针，在初始状态下指向的是首记录，利用fetch语句可以移动该指针，从而对游标中的数据进行各种操作，然后将操作结果写回数据表中。

由 SELECT 语句返回的行集包括所有满足该语句 WHERE 子句中条件的行。由语句所返回的这一完整的行集被称为结果集。应用程序，特别是交互式联机应用程序，并不总能将整个结果集作为一个单元来有效地处理。这些应用程序需要一种机制以便每次处理一行或一部分行。游标就是提供这种机制的结果集扩展。

游标通过以下方式扩展结果处理：

l 允许定位在结果集的特定行。

l 从结果集的当前位置检索一行或多行。

l 支持对结果集中当前位置的行进行数据修改。

l 为由其他用户对显示在结果集中的数据库数据所做的更改提供不同级别的可见性支持。

l 提供脚本、存储过程和触发器中使用的访问结果集中的数据的 Transact-SQL语句。

存储过程的优点有哪些？

l 更快的执行速度：存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度；

l 与事务的结合，提供更好的解决方案：当对数据库进行复杂操作时(如对多个表进行Update、Insert、Query和Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用；

l 支持代码重用：存储过程可以重复使用,可减少数据库开发人员的工作量；

l 安全性高：可设定只有某此用户才具有对指定存储过程的使用权。

介绍一下SQL Server的全文索引？

全文索引可以对存储在SQLServer数据库中的文本数据执行快速检索功能。同LIKE谓词不同，全文索引只对字符模式进行操作，对字和语句执行搜索功能。全文索引对于查询非结构化数据非常有效。一般情况下，可以对char、varchar和nvarchar数据类型的列创建全文索引，同时，还可以对二进制格式的列创建索引，如image和varbinary数据类型列。对于这些二进制数据，无法使用LIKE谓词。

为了对表创建全文索引，表必须包含单个、唯一、非空列。当执行全文检索的时候，SQL Server搜索引擎返回匹配搜索条件的行的键值。一般情况，使用sqlserver中的全文索引，经过大体4个步骤：

l 安装全文索引服务；

l 为数据表建立全文索引目录；

l 使全文索引与数据表内容同步；

l 使用全文索引进行查询。

SQL Server里面什么样的视图才能创建索引？

在为视图创建索引前，视图本身必须满足以下条件：

l 视图以及视图中引用的所有表都必须在同一数据库中，并具有同一个所有者。

l 索引视图无需包含要供优化器使用的查询中引用的所有表。

l 必须先为视图创建唯一群集索引，然后才可以创建其它索引。

l 创建基表、视图和索引以及修改基表和视图中的数据时，必须正确设置某些 SET 选项（在本文档的后文中讨论）。另外，如果这些 SET 选项正确，查询优化器将不考虑索引视图。

l 视图必须使用架构绑定创建，视图中引用的任何用户定义的函数必须使用 SCHEMABINDING选项创建。

l 另外，还要求有一定的磁盘空间来存放由索引视图定义的数据。

介绍一下SQL Server里面的索引视图？

复杂报表的场景经常会在数据仓储应用程序中遇到，它在查询过程中会对数据库服务器产生大量请求。当这些查询访问视图时，因为数据库将建立视图结果集所需的逻辑合并到从基本表数据建立完整查询结果集所需的逻辑中，所以性能将会下降。这一操作的开销可能会比较大，尤其当视图涉及到复杂的大量行处理–如大量数据聚合或多表联结时。因为结果集并不永久存放在数据库（标准视图）中，以后对该视图的访问可能导致在每次执行查询时建立结果集的代价。

SQL Server允许为视图创建独特的聚集索引，从而让访问此类视图的查询的性能得到极大地改善。在创建了这样一个索引后，视图将被执行，结果集将被存放在数据库中，存放的方式与带有聚集索引的表的存放方式相同。这就在数据库中有效地实现了查询结果。对于那些在FROM子句中不直接指定视图名的查询，SQL Server查询优化器将使用视图索引。现有查询将受益于从索引视图检索数据而无需重新编写程序原码的高效率。对于某些特定类型的视图，甚至可以获得指数级的性能改善。

如果在视图上创建索引，那么视图中的数据会被立即存储在数据库中，对索引视图进行修改，那么这些修改会立即反映到基础表中。同理，对基础表所进行的数据修改也会反映到索引视图那里。索引的惟一性大大提高了SQL Server 查找那些被修改的数据行。

维护索引视图比维护基础表的索引更为复杂。所以，如果认为值得以因数据修改而增加系统负担为代价来提高数据检索的速度，那么应该在视图上创建索引。

什么是唯一索引？

唯一索引可以确保索引列不包含重复的值。在多列唯一索引的情况下，该索引可以确保索引列中每个值组合都是唯一的。例如，如果在 last_name、first_name 和 middle_initial 列的组合上创建了唯一索引 full_name，则该表中任何两个人都不可以具有相同的全名。

聚集索引和非聚集索引都可以是唯一的。因此，只要列中的数据是唯一的，就可以在同一个表上创建一个唯一的聚集索引和多个唯一的非聚集索引。

只有当唯一性是数据本身的特征时，指定唯一索引才有意义。如果必须实施唯一性以确保数据的完整性，则应在列上创建 UNIQUE 或 PRIMARY KEY 约束，而不要创建唯一索引。例如，如果打算经常查询雇员表（主键为 emp_id）中的社会安全号码 (ssn) 列，并希望确保社会安全号码的唯一性，则在 ssn 列上创建 UNIQUE 约束。如果用户为一个以上的雇员输入了同一个社会安全号码，则会显示错误。

什么是聚集索引和非聚集索引？分布介绍一下

（1）非聚集索引

非聚集索引与课本中的索引类似。数据存储在一个地方，索引存储在另一个地方，索引带有指针指向数据的存储位置。索引中的项目按索引键值的顺序存储，而表中的信息按另一种顺序存储（这可以由聚集索引规定）。如果在表中未创建聚集索引，则无法保证这些行具有任何特定的顺序。

典型的桌面数据库使用的是非聚集索引。在这类索引中，索引键值是有序的，而每个索引节点所指向的数据行是无序的。一个SQL Server表最多可以拥有255个非聚集索引。

非聚集索引与聚集索引一样有 B-树结构，但是有两个重大差别：

l 数据行不按非聚集索引键的顺序排序和存储。

l 非聚集索引的叶层不包含数据页。

相反，叶节点包含索引行。每个索引行包含非聚集键值以及一个或多个行定位器，这些行定位器指向有该键值的数据行（如果索引不唯一，则可能是多行）。非聚集索引可以在有聚集索引的表、堆集或索引视图上定义。在 SQL Server中，非聚集索引中的行定位器有两种形式：

l 如果表是堆集（没有聚集索引），行定位器就是指向行的指针。该指针用文件标识符(ID)、页码和页上的行数生成。整个指针称为行 ID。

由于非聚集索引将聚集索引键作为其行指针存储，因此使聚集索引键尽可能小很重要。如果表还有非聚集索引，请不要选择大的列作为聚集索引的键。

在创建非聚集索引之前，应先了解您的数据是如何被访问的。可考虑将非聚集索引用于：

l 包含大量非重复值的列，如姓氏和名字的组合（如果聚集索引用于其它列）。如果只有很少的非重复值，如只有 1 和 0，则大多数查询将不使用索引，因为此时表扫描通常更有效。

l 不返回大型结果集的查询。

l 返回精确匹配的查询的搜索条件（WHERE 子句）中经常使用的列。

l 经常需要联接和分组的决策支持系统应用程序。应在联接和分组操作中使用的列上创建多个非聚集索引，在任何外键列上创建一个聚集索引。

l 在特定的查询中覆盖一个表中的所有列。这将完全消除对表或聚集索引的访问。

（2）聚集索引

聚集索引确定表中数据的物理顺序。聚集索引类似于电话簿，后者按姓氏排列数据。由于聚集索引规定数据在表中的物理存储顺序，因此一个表只能包含一个聚集索引。但该索引可以包含多个列（组合索引），就像电话簿按姓氏和名字进行组织一样。

聚集索引在系统数据库表sysindexes内有一行，其 indid = 1。数据链内的页和其内的行按聚集索引键值排序。所有插入都在所插入行中的键值与排序顺序相匹配时执行。

SQL Server将索引组织为B-树。索引内的每一页包含一个页首，页首后面跟着索引行。每个索引行都包含一个键值以及一个指向较低级页或数据行的指针。索引的每个页称为索引节点。B-树的顶端节点称为根节点。索引的底层节点称为叶节点。每级索引中的页链接在双向链接列表中。在聚集索引内数据页组成叶节点。根和叶之间的任何索引级统称为中间级。

对于聚集索引，sysindexes.root指向它的顶端。SQL Server 沿着聚集索引浏览以找到聚集索引键对应的行。为找到键的范围，SQL Server 浏览索引以找到这个范围的起始键值，然后用向前或向后指针扫描数据页。为找到数据页链的首页，SQL Server 从索引的根节点开始沿最左边的指针进行扫描.

聚集索引对于那些经常要搜索范围值的列特别有效。使用聚集索引找到包含第一个值的行后，便可以确保包含后续索引值的行在物理相邻。例如，如果应用程序执行的一个查询经常检索某一日期范围内的记录，则使用聚集索引可以迅速找到包含开始日期的行，然后检索表中所有相邻的行，直到到达结束日期。这样有助于提高此类查询的性能。同样，如果对从表中检索的数据进行排序时经常要用到某一列，则可以将该表在该列上聚集（物理排序），避免每次查询该列时都进行排序，从而节省成本。

对于聚集索引，人们往往有一些错误的认识。其中，最常见的错误有：

l 聚集索引会降低insert操作的速度，因为必须要向后移动一半的数据来为新插入的行腾出空间。这种认识是错误的，因为可以利用填充因子控制填充的百分比，从而在索引页上为新插入的数据保留空间。如果索引页填满了，SQL Server将会进行页拆分，在这种情况下只有第一个页才会受到影响。

l 在使用标识列的主键上创建聚集索引是一种好的设计方法，它可以使对表的操作达到最快速度。这种认识是错误的，它浪费了创建其它更有效的聚集索引的机会。并且，使用这种方法会把每个新插入的记录行都存储到表尾部的同一个的数据页中，这将导致数据库的热点和锁争用。笔者曾经见过采用这种方法设计的数据库，对于每一个新订单，客户服务人员都不得不等待数分钟来加以确认。

l 聚集索引是具有魔力的。如果哪个查询的速度不够快，那么就在该列上创建聚集索引，对于表的操作速度一定会得到提高。这种认识也是错误的，聚集索引只是比非聚集索引稍稍快了那么一点点。因为在每个表上只能创建一个聚集索引，所以它也是一种宝贵的性能资源，只有在那些经常作为条件查询一组记录行的列上才应该建立聚集索引。

在创建聚集索引之前，应先了解数据是如何被访问的。可考虑将聚集索引用于：

l 包含大量非重复值的列。

l 使用下列运算符返回一个范围值的查询：BETWEEN、>、>=、< 和 <=。

l 被连续访问的列。

l 返回大型结果集的查询。

l 经常被使用联接或 GROUP BY 子句的查询访问的列；一般来说，这些是外键列。对 ORDER BY 或 GROUP BY 子句中指定的列进行索引，可以使 SQL Server 不必对数据进行排序，因为这些行已经排序。这样可以提高查询性能。

l OLTP 类型的应用程序，这些程序要求进行非常快速的单行查找（一般通过主键）。应在主键上创建聚集索引。

注意，聚集索引不适用于：

l 频繁更改的列，这将导致整行移动（因为 SQL Server 必须按物理顺序保留行中的数据值）。这一点要特别注意，因为在大数据量事务处理系统中数据是易失的。

l 宽键，来自聚集索引的键值由所有非聚集索引作为查找键使用，因此存储在每个非聚集索引的叶条目内。

SQL Server提供的3种恢复模型都是什么？有什么区别？

SQL Server提供了3种恢复模型，分别是：

l 简单恢复，允许将数据库恢复到最新的备份。

l 完全恢复，允许将数据库恢复到故障点状态。

l 大容量日志记录恢复，允许大容量日志记录操作。

这些模型中的每个都是针对不同的性能、磁盘和磁带空间以及保护数据丢失的需要。例如，当选择恢复模型时，必须考虑下列业务要求之间的权衡：

l 大规模操作的性能（如创建索引或大容量装载）。

l 数据丢失表现（如已提交的事务丢失）。

l 事务日志空间损耗

l 备份和恢复过程的简化。

根据正在执行的操作，可以有多个适合的模型。选择了恢复模型后，设计所需的备份和恢复过程。表6提供了三种恢复模型的优点和含义的概述。

表 6备份模型之间的比较

恢复模型	优点	工作损失表现	能否恢复到即时点？
简单	允许高性能大容量复制操作。收回日志空间以使空间要求最小。	必须重做自最新的数据库或差异备份后所发生的更改。	可以恢复到任何备份的结尾处。随后必须重做更改。
完全	数据文件丢失或损坏不会导致工作损失。可以恢复到任意即时点（例如，应用程序或用户错误之前）。	正常情况下没有。如果日志损坏，则必须重做自最新的日志备份后所发生的更改。	可以恢复到任何即时点。
大容量日志记录的	允许高性能大容量复制操作。大容量操作使用最少的日志空间。	如果日志损坏，或者自最新的日志备份后发生了大容量操作，则必须重做自上次备份后所做的更改。否则不丢失任何工作。	可以恢复到任何备份的结尾处。随后必须重做更改。

简单恢复所需的管理最少。在简单恢复模型中，数据只能恢复到最新的完整数据库备份或差异备份的状态。不使用事务日志备份，而使用最小事务日志空间。一旦不再需要日志空间从服务器故障中恢复，日志空间便可重新使用。与完整模型或大容量日志记录模型相比，简单恢复模型更容易管理，但如果数据文件损坏，则数据损失表现会更高。

完全恢复和大容量日志记录恢复模型为数据提供了最大的保护性。这些模型依靠事务日志提供完全的可恢复性，并防止最大范围的故障情形所造成的工作损失。完全恢复模型提供最大的灵活性，可将数据库恢复到更早的即时点。

大容量日志记录模型为某些大规模操作（如创建索引或大容量复制）提供了更高的性能和更低的日志空间损耗。不过这将牺牲时点恢复的某些灵活性。很多数据库都要经历大容量装载或索引创建的阶段，因此可能希望在大容量日志记录模型和完全恢复模型之间进行切换。

SQL Server的固定数据库角色都有哪些？对应的服务器权限有哪些？

固定服务器角色	对应的服务器级权限
bulkadmin	授予的权限： ADMINISTER BULK OPERATIONS
dbcreator	授予的权限： CREATE DATABASE
diskadmin	授予的权限： ALTER RESOURCES
processadmin	授予的权限： ALTER SERVER STATE
processadmin	授予的权限： ALTER ANY CONNECTION
securityadmin	授予的权限： ALTER ANY LOGIN
serveradmin	授予的权限： ALTER SETTINGS
serveradmin	授予的权限： SHUTDOWN
serveradmin	授予的权限： CREATE ENDPOINT
serveradmin	授予的权限： ALTER SERVER STATE
serveradmin	授予的权限： ALTER ANY ENDPOINT
serveradmin	授予的权限： ALTER RESOURCES
setupadmin	授予的权限： ALTER ANY LINKED SERVER
sysadmin	带GRANT 选项授予的权限：CONTROL SERVER

在SQL Server中创建数据库主要有那种方式？

在SQL Server中创建数据库主要有两种方法，第一种是在SQL Server Management Studio中使用向导创建数据库；第二种是执行Transact-SQL语句创建数据库。下面我们分别进行介绍。

（1）使用SQL ServerManagement Studio创建数据库

在SQL ServerManagement Studio中，可以使用向导创建数据库，步骤如下：

1．打开SQL Server ManagementStudio。

2. 右击“数据库”对象，在弹出式菜单中选择“新建数据库”菜单项，打开“新建数据库”对话框

3．在“常规”页，可以定义数据库的名称为EAMS、数据库文件、数据库的所有者、排序规则、恢复模型，以及是否使用全文索引。

4. 在“选项”页，可以定义数据库的一些选项，包括自动选项、游标选项、混杂选项、恢复选项、行级版本选项和状态选项

5. 在“文件组”页，显示文件组和文件的统计信息，同时还可以设置是否采用默认值

6．在“扩展属性”页，可以定义数据库的一些扩展属性，如图5所示。

7．当完成各个选项的定义之后，单击【OK】按钮，SQL Server数据库引擎会创建所定义的数据库。

（2）使用Transact-SQL创建数据库

Transact-SQL提供了创建数据库的语句：CREATE DATABASE，其语法格式如下：

CREATE DATABASEdatabase_name

[ ON

[ <filespec>[ ,...n ] ]

[ ,<filegroup> [ ,...n ] ]

]

[

[ LOG ON {<filespec> [ ,...n ] } ]

[ COLLATEcollation_name ]

[ FOR { ATTACH [WITH <service_broker_option> ]

|ATTACH_REBUILD_LOG } ]

[ WITH<external_access_option> ]

]

[;]

<filespec>::=

[ PRIMARY ]

(

[ NAME =logical_file_name , ]

FILENAME =‘os_file_name’

[ , SIZE = size [KB | MB | GB | TB ] ]

[ , MAXSIZE = {max_size [ KB | MB | GB | TB ] | UNLIMITED } ]

[ , FILEGROWTH =growth_increment [ KB | MB | % ] ]

) [ ,...n ]

<filegroup>::=

FILEGROUPfilegroup_name

<filespec> [,...n ]

<external_access_option>::=

DB_CHAINING { ON |OFF }

| TRUSTWORTHY { ON| OFF }

<service_broker_option>::=

ENABLE_BROKER

| NEW_BROKER

|ERROR_BROKER_CONVERSATIONS

Create a DatabaseSnapshot

CREATE DATABASEdatabase_snapshot_name

(

NAME =logical_file_name,

FILENAME =‘os_file_name’

) [ ,...n ]

AS SNAPSHOT OFsource_database_name

[;]

参数说明如下：

l database_name，新数据库的名称。数据库名称在服务器中必须唯一，并且符合标识符的规则。database_name最多可以包含 128 个字符，除非没有为日志指定逻辑名。如果没有指定日志文件的逻辑名，则SQL Server会通过向 database_name 追加后缀来生成逻辑名。该操作要求 database_name 在 123 个字符之内，以便生成的日志文件逻辑名少于 128 个字符。

l ON，指定显式定义用来存储数据库数据部分的磁盘文件（数据文件）。该关键字后跟以逗号分隔的 <filespec> 项列表，<filespec> 项用以定义主文件组的数据文件。主文件组的文件列表后可跟以逗号分隔的 <filegroup> 项列表（可选），<filegroup>项用以定义用户文件组及其文件。

l N，占位符，表示可以为新数据库指定多个文件。

l LOG ON，指定显式定义用来存储数据库日志的磁盘文件（日志文件）。该关键字后跟以逗号分隔的 <filespec> 项列表，<filespec> 项用以定义日志文件。如果没有指定 LOG ON，将自动创建一个日志文件，该文件使用系统生成的名称，大小为数据库中所有数据文件总大小的 25%。

l FOR LOAD，支持该子句是为了与早期版本的 SQL Server 兼容。数据库在打开 dbo use only 数据库选项的情况下创建，并且将其状态设置为正在装载。

l FOR ATTACH，指定从现有的一组操作系统文件中附加数据库。必须有指定第一个主文件的<filespec> 条目。至于其它 <filespec> 条目，只需要与第一次创建数据库或上一次附加数据库时路径不同的文件的那些条目。必须为这些文件指定 <filespec> 条目。附加的数据库必须使用与 SQL Server 相同的代码页和排序次序创建。应使用 sp_attach_db 系统存储过程，而不要直接使用 CREATE DATABASEFOR ATTACH。只有必须指定 16 个以上的<filespec> 项目时，才需要使用 CREATE DATABASE FOR ATTACH。如果将数据库附加到的服务器不是该数据库从中分离的服务器，并且启用了分离的数据库以进行复制，则应该运行sp_removedbreplication 从数据库删除复制。

l collation_name，指定数据库的默认排序规则。排序规则名称既可以是 Windows 排序规则名称，也可以是 SQL 排序规则名称。如果没有指定排序规则，则将 SQL Server 实例的默认排序规则指派为数据库的排序规则。

l PRIMARY，指定关联的 <filespec> 列表定义主文件。主文件组包含所有数据库系统表。还包含所有未指派给用户文件组的对象。主文件组的第一个 <filespec> 条目成为主文件，该文件包含数据库的逻辑起点及其系统表。一个数据库只能有一个主文件。如果没有指定 PRIMARY，那么 CREATE DATABASE 语句中列出的第一个文件将成为主文件。

l NAME，为由 <filespec> 定义的文件指定逻辑名称。如果指定了 FOR ATTACH，则不需要指定 NAME 参数。

l logical_file_name，用来在创建数据库后执行的Transact-SQL 语句中引用文件的名称。logical_file_name 在数据库中必须唯一，并且符合标识符的规则。该名称可以是字符或 Unicode 常量，也可以是常规标识符或定界标识符。

l FILENAME，为 <filespec> 定义的文件指定操作系统文件名。

l os_file_name，操作系统创建 <filespec> 定义的物理文件时使用的路径名和文件名。os_file_name 中的路径必须指定 SQL Server 实例上的目录。os_file_name 不能指定压缩文件系统中的目录。如果文件在原始分区上创建，则os_file_name 必须只指定现有原始分区的驱动器字母。每个原始分区上只能创建一个文件。原始分区上的文件不会自动增长；因此，os_file_name 指定原始分区时，不需要指定 MAXSIZE 和 FILEGROWTH 参数。

l SIZE，指定 <filespec> 中定义的文件的大小。如果主文件的 <filespec> 中没有提供 SIZE 参数，那么 SQL Server 将使用 model 数据库中的主文件大小。如果次要文件或日志文件的 <filespec> 中没有指定 SIZE 参数，则 SQL Server 将使文件大小为 1 MB。

l Size，<filespec> 中定义的文件的初始大小。可以使用千字节 (KB)、兆字节 (MB)、千兆字节(GB) 或兆兆字节 (TB) 后缀。默认值为 MB。指定一个整数，不要包含小数位。size 的最小值为 512 KB。如果没有指定 size，则默认值为 1 MB。为主文件指定的大小至少应与 model 数据库的主文件大小相同。

l MAXSIZE，指定 <filespec> 中定义的文件可以增长到的最大大小。

l max_size，<filespec> 中定义的文件可以增长到的最大大小。可以使用千字节 (KB)、兆字节 (MB)、千兆字节(GB) 或兆兆字节 (TB) 后缀。默认值为 MB。指定一个整数，不要包含小数位。如果没有指定 max_size，那么文件将增长到磁盘变满为止。

l UNLIMITED，指定 <filespec> 中定义的文件将增长到磁盘变满为止。

l FILEGROWTH，指定 <filespec> 中定义的文件的增长增量。文件的 FILEGROWTH 设置不能超过 MAXSIZE 设置。

l growth_increment，每次需要新的空间时为文件添加的空间大小。指定一个整数，不要包含小数位。0值表示不增长。该值可以 MB、KB、GB、TB 或百分比 (%) 为单位指定。如果未在数量后面指定 MB、KB 或 %，则默认值为 MB。如果指定 %，则增量大小为发生增长时文件大小的指定百分比。如果没有指定 FILEGROWTH，则默认值为 10%，最小值为 64 KB。指定的大小舍入为最接近的 64 KB 的倍数。

l <filegroup>，控制文件组的属性。文件组不能在数据库快照上定义。

l FILEGROUP，定义文件组的逻辑名。

l filegroup_name，表示在创建数据库之后，在Transact-SQL语句中引用文件组的名称。filegroup_name在数据库中必须唯一，不能是系统提供的名称，如PRIMARY和PRIMARY_LOG。名称必须同标识符的规则保持一致。

l default，定义文件组为特定文件组类型的默认数据库文件组。

l DB_CHAINING { ON | OFF }，当设置为ON的时候，数据库可以为交叉数据库所有者关系链中的源或者目标。当设置为OFF的时候，数据库不能参与交叉数据库所有者关系链，对于用户数据库，可以修改这个选项，但是不能修改系统数据库的该选项。默认值为OFF。

l TRUSTWORTHY { ON | OFF }，当设置为ON的时候，数据库模块（如视图、用户自定义函数或者存储过程）允许访问数据库外的资源。当设置为OFF的时候，数据库模块不能访问数据库之外的资源。默认值为OFF。

l <service_broker_options> ，当授予FORATTACH子句的时候，才能设置Service Broker选项。

l ENABLE_BROKER，定义数据库是否启用Service Broker。

l NEW_BROKER，在sys数据库中和恢复数据库中创建新的service_broker_guid。

l ERROR_BROKER_CONVERSATIONS，终止所有发生错误的会话。

l database_snapshot_name，定义新数据库的快照名。

l ON (NAME =logical_file_name, FILENAME =’os_file_name’) [ ,... n ] ，对于创建一个数据库快照，在源数据库中定义文件列表。

l AS SNAPSHOT OF source_database_name，定义创建的数据库为一个源数据库的数据库快照。

几道数据库的面试题或笔试题难度适中

1.张表,学生表S,课程C,学生课程表SC,学生可以选修多门课程,一门课程可以被多个学生选修,通过SC表关联；(SQL)
1)写出建表语句；
答：建表语句如下（mysql数据库）：
create table s(id integer primary key, name varchar(20));
create table c(id integer primary key, name varchar(20));
create table sc(
sid integer references s(id),
cid integer references c(id),
primary key(sid,cid)
);
2)写出SQL语句,查询选修了所有选修课程的学生；
答：SQL语句如下：
select stu.id, stu.name from s stu
where (select count(*) from sc where sid=stu.id) =
(select count(*) from c);
3)写出SQL语句,查询选修了至少5门以上的课程的学生。
答：SQL语句如下：
select stu.id, stu.name from s stu
where (select count(*) from sc where sid=stu.id)>=5;

2.数据库表(Test)结构如下：(SQL)
IDNAMEAGEMANAGER(所属主管人ID)
106A30104
109B19104
104C20111
107D35109
112E25120
119F45NULL
要求:列出所有年龄比所属主管年龄大的人的ID和名字?
答：SQL语句如下：
select employee.name from test employee where employee.age>
(select manager.age from test manager where manager.id=employee.manager);

3.有3个表（15分钟）：(SQL)
Student 学生表 (学号，姓名，性别，年龄，组织部门)
Course 课程表 (编号，课程名称)
Sc 选课表 (学号，课程编号，成绩)
表结构如下：

1)写一个SQL语句，查询选修了’计算机原理’的学生学号和姓名（3分钟）
答：SQL语句如下：
select stu.sno, stu.sname from Student stu
where (select count(*) from sc where sno=stu.sno and cno =
(select cno from Course where cname=’计算机原理’)) != 0;
2)写一个SQL语句，查询’周星驰’同学选修了的课程名字（3分钟）
答：SQL语句如下：
select cname from Course where cno in (select cno from sc where sno=(select snofrom Student where sname=’周星驰’));
3)写一个SQL语句，查询选修了5门课程的学生学号和姓名（9分钟）
答：SQL语句如下：
select stu.sno, stu.sname from student stu
where (select count(*) from sc where sno=stu.sno) = 5;

ORACLE面试测试题目

1．解释FUNCTION，PROCEDURE和PACKAGE区别
答：function 和procedure是PL/SQL代码的集合，通常为了完成一个任务。procedure 不需要返回任何值而function将返回一个值在另一方面，Package是为了完成一个商业功能的一组function和procedure的集合。

2．取某个序列的当前值的PL/SQL语句怎么写？
答：SELECT 序列名.CURRVAL FROM DUAL；

3．说明ORACLE数据库实例与ORACLE用户的关系？
答：实例可以包含多个用户，一个用户只能在一个实例下

4．创建数据库时，自动建立的tablespace名称？
答：SYSTEM tablespace

5．创建用户时，需要赋予新用户什么权限才能使它连上数据库？
答：CONNECT

6． IMPORT和SQL*LOADER这2个工具的不同点？
答：这两个ORACLE工具都是用来将数据导入数据库的。
区别是：IMPORT工具只能处理由另一个ORACLE工具EXPORT生成的数据。而SQL*LOADER可以导入不同的ASCII格式的数据源。

7．解释冷备份和热备份的不同点以及各自的优点？
答：热备份针对归档模式的数据库，在数据库仍旧处于工作状态时进行备份。而冷备份指在数据库关闭后，进行备份，适用于所有模式的数据库。热备份的优点在于当备份时，数据库仍旧可以被使用并且可以将数据库恢复到任意一个时间点。冷备份的优点在于它的备份和恢复操作相当简单，并且由于冷备份的数据库可以工作在非归档模式下,数据库性能会比归档模式稍好。（因为不必将archive log写入硬盘）

8．比较truncate和delete命令？
答：两者都可以用来删除表中所有的记录。区别在于：truncate是DDL（data defining language数据定义语言），它移动HWK，不需要rollback segment（处理事务回滚操作）而Delete是DML（datamanufacturing language数据操作语言）操作，需要rollback segment（处理事务回滚操作）且花费较长时间。

9．给出数据的相关约束类型？
答：主键约束，外键约束，非空约束，唯一约束，检查约束。

10．说明索引的类型与作用？
答：索引类型上分为聚集索引，非聚集索引其作用是加快查询速度。

11．解释归档和非归档模式之间的不同和它们各自的优缺点
答：归档模式是指你可以备份所有的数据库 transactions并恢复到任意一个时间点。非归档模式则相反，不能恢复到任意一个时间点。但是非归档模式可以带来数据库性能上的少许提高。

12．解释$ORACLE_HOME和$ORACLE_BASE的区别？
答：ORACLE_BASE是oracle的根目录，ORACLE_HOME是oracle产品的目录。

13．获取某个字符字段的最后3个字符的函数是什么？
答：select substr (字段,(length(字段)-3)) from 表

14．取当前系统时间点日期（不包括年月）的SQL写法是怎样的？
答：Select substr(to_char(sysdate,’YYYYMMDDh24hh:MM:SS’),5) from dual;

15．返回大于等于N的最小整数值？
答：select ceil(N) from dual;

16．将根据字符查询转换后结果，规则为：’A’转换为’男’，’B’转换为’女’，其他字符转换为’未知’，请用一个SQL语句写出。
答：select decode(字符,’A’,’男’,’B’,’女’,’未知’) fromdual;

17．如何搜索出前N条记录？
答：select * from 表 where Rownum <= N;

18．如何搜索出第N～M条记录？
答：select * from 表 where Rownum<= M
Minus
select * from 表 where Rownum <= N;

19．有一个数据表（TEST），字段如下：
ID      number
PARENT_ID      number
NAME      Varchar(20)
请使用PL/SQL来按父子层次关系查询出该表的所有数据
答：Select * from test a, test b Where a.parent_id =b.id;

20．怎样用SQL语句实现查找一列中的第N大值？
答：select * from (select * from 表 order by 列名 Desc) where Rownum <= N
Minus
select * from (select * from 表 order by 列名 Desc) where Rownum <= N-1;

腾讯公司的一个sql题

小小+霸霸+王王=小霸王
小=?,霸=?,王=?
用sql求证

参考答案:

declare @dataint,@i int,@j int,@l int
set @data=100
while (@data<=999)
begin
   set @i=@data/100
   set @j=@data/10 % 10
   set @l=@data % 10
   if((@i+@j+@l)*11=@data)
   begin
      Select @data data,@i i,@j j,@l l
      break
   end
   set @data=@data+1
end;
分析：
II+JJ+LL=IJL
I*10+I +J*10+J+L*10+L   =   I*100+J*10+L
(I+J+L)*11

1、一套Oracle面试题笔试题

完成下列操作，写出相应的SQL语句

1. 创建表空间neuspace，数据文件命名为neudata.dbf，存放在d:\data目录下，文件大小为200MB，设为自动增长，增量5MB，文件最大为500MB。(8分)

答：createtablespace neuspace datafile ‘d:\data\neudata.dbf’ size 200m auto extend onnext 5m maxsize 500m;

2. 假设表空间neuspace已用尽500MB空间，现要求增加一个数据文件，存放在e:\appdata目录下，文件名为appneudata，大小为500MB，不自动增长。（5分）

答：altertablespace neuspace add datafile ‘e:\appdata\appneudata.dbf’ size 500m;

3. 以系统管理员身份登录，创建账号tom，设置tom的默认表空间为neuspace。为tom分配connect和resource系统角色，获取基本的系统权限。然后为tom分配对用户scott的表emp的select权限和对SALARY, MGR属性的update权限。(8分)

答：create usertom identified by jack default tablespace neuspace;

Grant connect,resource to tom;

Grant select,update(salary, mgr) on scott.emp to tom;

4. 按如下要求创建表class和student。（15分）

属性	类型(长度)	默认值	约束	含义
CLASSNO	数值 (2)	无	主键	班级编号
CNAME	变长字符 (10)	无	非空	班级名称

属性	类型(长度)	默认值	约束	含义
STUNO	数值 (8)	无	主键	学号
SNAME	变长字符 (12)	无	非空	姓名
SEX	字符 (2)	男	无	性别
BIRTHDAY	日期	无	无	生日
EMAIL	变长字符 (20)	无	唯一	电子邮件
SCORE	数值 (5, 2)	无	检查	成绩
CLASSNO	数值 (2)	无	外键，关联到表CLASS的CLASSNO主键	班级编号

答：create tableclass

(classno number(2)constraint class_classno_pk primary key,

cname varchar2(10)not null);

create tablestudent

(stuno number(8)constraint student_stuno_pk primary key,

sname varchar2(12)not null,

sex char(2)default ‘男’,

birthday date,

email varchar2(20)constraint student_email_uk unique,

score number(5,2)constraint student_score_ck check(score>=0 and score<=100),

classno number(2)constraint student_classno_fk references class(classno)

);

5. 在表student的SNAME属性上创建索引student_sname_idx（5分）

答：create indexstudent_sname_idx on student(sname);

6. 创建序列stuseq，要求初值为20050001，增量为1，最大值为20059999。（6分）

答：createsequence stuseq increment by 1 start with 20050001 maxvalue 20059999 nocachenocycle;

7. 向表student中插入如下2行。（5分）

STUNO	SNAME	SEX	BIRTHDAY	EMAIL	SCORE	CLASSNO
从stuseq取值	tom	男	1979-2-3 14:30:25	tom@163.net	89.50	1
从stuseq取值	jerry	默认值	空	空	空	2

答：insert intostudent values(stuseq.nextval, ’tom’, ’男’,to_date(‘1979-2-3

14:30:25’,’yyyy-mm-dd fmhh24:mi:ss’), ’tom@163.net’, 89.50, 1);

insert intostudent (stuno, sname, classno) values(stuseq.nextval, ’jerry’, 2);

8. 修改表student的数据，将所有一班的学生成绩加10分。（4分）

答：update studentset score=score+10 where classno=1;

9. 删除表student的数据，将所有3班出生日期小于1981年5月12日的记录删除。（4分）

答：delete fromstudent where classno=3 and birthday > ’12-5月-81’;

10. 完成以下SQL语句。(40分)

(1) 按班级升序排序，成绩降序排序，查询student表的所有记录。

答：select * fromstudent order by classno, score desc;

(2) 查询student表中所有二班的成绩大于85.50分且出生日期大于1982-10-31日的男生的记录。

答：select * fromstudent where classno=2 and score>85.50 and birthday < ’31-10月-82’ and sex=’男’;

(3) 查询student表中所有三班成绩为空的学生记录。

答：select * fromstudent where classno=3 and score is null;

(4) 表student与class联合查询，要求查询所有学生的学号，姓名，成绩，班级名称。（使用oracle与SQL 99两种格式）

答：selects.stuno, s.sname, s.score, c.cname from student s, class c wheres.classno=c.classno;

(5) 按班级编号分组统计每个班的人数，最高分，最低分，平均分，并按平均分降序排序。

答：selectclassno, count(*), max(score), min(score), avg(score) from student group byclassno order by avg(score) desc;

(6) 查询一班学生记录中所有成绩高于本班学生平均分的记录。

答：select * fromstudent where classno=1 and score > (select avg(score) from student whereclassno=1);

(7) 统计二班学生中所有成绩大于所有班级平均分的人数。

答：selectcount(*) from student where classno=2 and score > all (select avg(socre)from student group by classno);

(8) 查询平均分最高的班级编号与分数。

答：selectclassno, avg(score) from student group by classno having avg(score) = (selectmax(avg(score)) from student group by classno);

(9) 查询所有学生记录中成绩前十名的学生的学号、姓名、成绩、班级编号。

答：select stuno,sname, score, classno from (select * from student order by score desc) whererownum<=10;

(10) 创建视图stuvu，要求视图中包含student表中所有一班学生的stuno, sname, score, classno四个属性，并具有withcheck option限制。

答：create viewstuvu

select stuno,sname,score,classno from student where classno=1 with check option;

2、一道Oracle笔试题

表结构说明：
create table employee(
id number(10) not null, — 员工工号
salary number(10,2) default 0 not null, — 薪水
name varchar2(24) not null — 姓名
);
1.创建序列seq_employee，该序列每次取的时候它会自动增加，从1开始计数，不设最大值，并且一直累加，不循环。（10分）
2.写一个PL/SQL块，插入表user.employee中100条数据。插入该表中字段id用序列seq_employee实现，薪水和姓名字段可以任意填写。（15分）

6.写一个匿名语句块，用于执行函数f_employee，并打印执行该函数的结果。（8分）
7.创建存储过程p_create_emp，用于判断表employee是否存在，如果存在则删除该表。（15分）
8.写一个匿名语句块，用于执行存储过程p_create_emp。（7分）
答案如下：
SQL> create table employee(
2 id number(10) not null, — 员工工号
3 salary number(10,2) default 0 not null, — 薪水
4 name varchar2(24) not null — 姓名
5 );
表已创建。
—第一题答案：
SQL> Create sequence seq_employee increment by 1 start with 1 nomaxvaluenocycle;
序列已创建。
—第二题答案：
SQL> declare i number;
2 begin
3 for i in 1 .. 100
4 loop
5 insert into employee
6 values(seq_employee.nextval,1950+i,’王明’||to_char(i));
7 commit;
8 end loop;
9 end;
10 /
PL/SQL 过程已成功完成。
SQL> select * from employee where rownum<11;
ID SALARY NAME
———- ———- ————————
1 1951 王明1
2 1952 王明2
3 1953 王明3
4 1954 王明4
5 1955 王明5
6 1956 王明6
7 1957 王明7
8 1958 王明8
9 1959 王明9
10 1960 王明10
已选择10行。
3.写一个语句块，在语句块中定义一个显式游标，按id升序排列，打印表employee中前十条数据。（15分）
——-第三题答案：
SQL> declare
2 cursor c is select id,salary,name from(select * from employee order by id)where rownum<11;
3 v_record c%rowtype;
4 begin
5 open c;
6 loop
7 fetch c into v_record;
8 exit when c%notfound;
9dbms_output.put_line(to_char(v_record.id)||’,'||to_char(v_record.salary)||’,'||v_record.name);
10 end loop;
11 close c;
12 end;
13 /
1,1951,王明1
2,1952,王明2
3,1953,王明3
4,1954,王明4
5,1955,王明5
6,1956,王明6
7,1957,王明7
8,1958,王明8
9,1959,王明9
10,1960,王明10
PL/SQL 过程已成功完成。
4.创建存储过程p_employee，输入员工薪水范围，返回员工工号、姓名、薪水结果集，结果集按员工薪水升序排列。（15分）
——-第四题答案
SQL> create or replace procedure p_employee
2 (iminsalary in number,
3 imaxsalary in number)
4 is
5 begin
6 for x in(select id,salary,name from(select * from employee where salarybetween iminsalary and imaxsalary) order by salary)
7 loop
8 dbms_output.put_line(to_char(x.id)||to_char(x.salary)||x.name);
9 end loop;
10 end;
11 /
过程已创建。
SQL> exec p_employee(2000,2007);
502000王明50
512001王明51
522002王明52
532003王明53
542004王明54
552005王明55
562006王明56
572007王明57
PL/SQL 过程已成功完成。
5.创建函数f_employee实现更新员工薪水的功能，将薪水低于2000且姓wang的员工薪水加5%，其他不变，更新成功则返回0，否则返回1。（15分）
———第五题答案
SQL> create or replace function f_employee return number
is
begin
update employee set salary=salary+salary*0.05 where salary<2000 and namelike ‘王%’;
commit;
if sql%rowcount=0 then
return 1;
else
return 0;
end if;
end;
/
函数已创建。
—–第六题答案
SQL> declare a number;
2 begin
3 a:=f_employee();
4 dbms_output.put_line(to_char(a));
5 end;
6 /
0
PL/SQL 过程已成功完成。
SQL> select * from employee where salary<2000 and name like ‘王%’;
未选定行
SQL> select * from employee where rownum<50;
ID SALARY NAME
———- ———- ————————
1 2048.55 王明1
2 2049.6 王明2
3 2050.65 王明3
4 2051.7 王明4
5 2052.75 王明5
6 2053.8 王明6
7 2054.85 王明7
8 2055.9 王明8
9 2056.95 王明9
10 2058 王明10
11 2059.05 王明11
ID SALARY NAME
———- ———- ————————
12 2060.1 王明12
13 2061.15 王明13
14 2062.2 王明14
15 2063.25 王明15
16 2064.3 王明16
17 2065.35 王明17
18 2066.4 王明18
19 2067.45 王明19
20 2068.5 王明20
21 2069.55 王明21
22 2070.6 王明22
ID SALARY NAME
———- ———- ————————
23 2071.65 王明23
24 2072.7 王明24
25 2073.75 王明25
26 2074.8 王明26
27 2075.85 王明27
28 2076.9 王明28
29 2077.95 王明29
30 2079 王明30
31 2080.05 王明31
32 2081.1 王明32
33 2082.15 王明33
ID SALARY NAME
———- ———- ————————
34 2083.2 王明34
35 2084.25 王明35
36 2085.3 王明36
37 2086.35 王明37
38 2087.4 王明38
39 2088.45 王明39
40 2089.5 王明40
41 2090.55 王明41
42 2091.6 王明42
43 2092.65 王明43
44 2093.7 王明44
ID SALARY NAME
———- ———- ————————
45 2094.75 王明45
46 2095.8 王明46
47 2096.85 王明47
48 2097.9 王明48
49 2098.95 王明49
已选择49行。
—–第七题答案
SQL> create or replace procedure p_create_emp
2 is
3 v_count number;
4 begin
5 select count(*) into v_count from user_tables where table_name=’EMPLOYEE’;
6 if v_count=0 then
7 return;
8 else
9 execute immediate ‘drop table employee’;
10 end if;
11 end;
12 /
过程已创建。

———第八题答案
SQL> exec p_create_emp;
PL/SQL 过程已成功完成。
SQL> select * from employee;
select * from employee
*
ERROR 位于第 1 行:
ORA-00942: 表或视图不存在

如何查询Oracle数据库中已经创建的索引？

查询数据字典user_indexes和user_ind_columns

例子:

SQL> SELECTic.index_name, ic.column_name,

2 ic.column_position col_pos,ix.uniqueness

3 FROM user_indexes ix, user_ind_columns ic

4 WHERE ic.index_name = ix.index_name

5 ANDic.table_name = ‘S_EMP’;

注意: 数据字典里存放的字符都是大写的.

哪些情况下不应该使用索引？

1. 表很小的情况下，没有必要使用索引

2. 不经常在Where后使用的比较字段

3. 如果表数据需要频繁修改，不建议使用索引

4. 如果查询返回记录很多，不建议使用索引

5. 如果where后含IS NULL /IS NOT NULL/like ‘%输入符%’等条件，不建议使用索引。

SQL里面如何插入自动增长序列号字段？

INSERT时如果要用到从1开始自动增长的数字做唯一关键字, 应该先建立一个序列号.

CREATE SEQUENCE 序列号的名称 (最好是表名+序列号标记) INCREMENT BY 1 START WITH 1 MAXVALUE 99999 NOCYCLE NOCACHE;

其中最大的值按字段的长度来定,比如定义的自动增长的序列NUMBER(6) , 最大值为999999

INSERT 语句插入这个字段值为: 序列号的名称.NEXTVAL

例子: SQL>insert into s_dept(id, name, region_id) values (s_dept_id.nextval, ‘finance’,2);

1 row created.

只有运行了序列号的名称.nextval后序列号的名称. currval 才有效才有值.

不用游标的SQL语句有哪些？

1. 说明性语句
2. 数据定义语句
3. 数据控制语句
4. 查询结果为单记录的SELECT语句
5. 非CURRENT形式的UPDATE语句
6. 非CURRENT形式的DELETE语句
7. INSERT语句
所有的说明性语句及数据定义与控制语句都不需要使用游标，他们是嵌入式SQL中最简单的一类语句，不需要返回结果数据，也不需要使用主变量。在主语言中嵌入说明性语句及数据定义与控制语句，只要给语句加上前缀EXEC SQL 和预计结束符即可。
INSERT语句也不需要使用游标，但通常需要使用主变量
SELECT语句，UPDATE语句，DELETE语句则要复杂些。

必须要使用游标的SQL语句有那些？

必须要使用游标的SQL语句有：
1. 查询结果为多结果的SELECT语句
2. CURRENT形式的UPDATE语句
3. CURRENT形式的DELETE语句

查询优化的一般准则有哪些？

1. 选择运算应尽可能先做。这是优化策略中最重要最基本的一条
2. 在执行连接前对关系适当的预处理，方法有两种：在连接属性上建立索引和对关系排序，然后执行连接，第一种称为索引连接方法，第二种称为排序合并连接方法
3. 把投影运算和选择运算同时进行。
4. 把投影同其前或者其后的双目运算结合起来，没有必要为了去掉某些字段而扫描一下关系
5. 把某些选择同它前面要执行的笛卡尔积结合起来成为一个连接运算，连接特别是等值连接运算要比同样关系上的笛卡尔积节省很多时间
6. 找出公共子表达式，先计算出公共子表达式的值才参与运算。

ORACLE二十问

1. Oracle安裝完成后的初始口令?　

　　internal/oracle
　　 sys/change_on_install
　　　　system/manager
　　　　scott/tiger
　　　　sysman/oem_temp　　

　　2. ORACLE9IASWEB CACHE的初始默认用户和密码？　　

　　administrator/administrator　

　　3. oracle8.0.5怎么创建数据库?　　

　　用orainst。如果有motif界面，可以用orainst /m　

　　4. oracle8.1.7怎么创建数据库?

　　 dbassist　

　　5. oracle 9i 怎么创建数据库?　

　　 dbca　　

　　6. oracle中的裸设备指的是什么?　　

　　裸设备就是绕过文件系统直接访问的储存空间　

　　7. oracle如何区分 64-bit/32bit 版本？？？　

　　$ sqlplus ‘/AS SYSDBA’
　　SQL*Plus: Release 9.0.1.0.0 – Production on Mon Jul14 17:01:09 2003
　　(c) Copyright 2001 Oracle Corporation. All rightsreserved.
　　Connected to:
　　Oracle9i Enterprise Edition Release 9.0.1.0.0 –Production
　　With the Partitioning option
　　JServer Release 9.0.1.0.0 – Production
　　SQL> select * from v$version;
　　BANNER
　　Oracle9i Enterprise Edition Release 9.0.1.0.0 –Production
　　PL/SQL Release 9.0.1.0.0 – Production
　　CORE 9.0.1.0.0 Production
　　TNS for Solaris: Version 9.0.1.0.0 – Production
　　NLSRTL Version 9.0.1.0.0 – Production
　　SQL>　　

　　8. SVRMGR什么意思？　

　　svrmgrl，Server Manager.

　　9i下没有，已经改为用SQLPLUS了

　　sqlplus /nolog
　　变为归档日志型的　

　　9. 请问如何分辨某个用户是从哪台机器登陆ORACLE的?

　　SELECT machine, terminal FROM V$SESSION;　　

　　10. 用什么语句查询字段呢？　

　　desc table_name可以查询表的结构
　　select field_name,… from … 可以查询字段的值
　　select * from all_tables where table_name like ‘%’
　　select * from all_tab_columns where table_name=’??’　　

　　11. 怎样得到触发器、过程、函数的创建脚本？　

　　descuser_source
　　user_triggers 　　

　　12. 怎样计算一个表占用的空间的大小？　

selectowner,table_name,
　　NUM_ROWS,
　　BLOCKS*AAA/1024/1024 “Size M”,
　　EMPTY_BLOCKS,
　　LAST_ANALYZED
　　from dba_tables
　　where table_name=’XXX’;
　　Here: AAA is the value of db_block_size ;
　　XXX is the table name you want to check　

　14. 如何查看系统被锁的事务时间？
　　select * from v$locked_object ;

　　15. 如何以archivelog的方式运行oracle。
　　init.ora
　　log_archive_start = true
　　RESTART DATABASE
　　16. 怎么获取有哪些用户在使用数据库
　　select username from v$session;

　　17. 数据表中的字段最大数是多少?

　　表或视图中的最大列数为1000　　

　　18. 怎样查得数据库的SID ?

　　select namefrom v$database;

　　也可以直接查看init.ora文件

　　19. 如何在Oracle服务器上通过SQLPLUS查看本机IP地址 ?

　　selectsys_context(’userenv’,'ip_address’) from dual;

　　如果是登陆本机数据库，只能返回127.0.0.1，呵呵　　

　　20. unix 下怎么调整数据库的时间？

　　su -root

　　date -u08010000

如何高效率的查找一个月以内的数据？

进行时间比较要尽量避免用sysdate.比如：如果使用select * from eventtable whereeventdate>sysdate-30进行查找,当数据量小的时候看不出来，数据量大一些就会发现执行很慢，但日期型字段上也是有索引的，为什么会慢呢？原来是Oracle在进行查找的时候不断地去取sysdate这个不断变化的值，而不是我们想象中的一次产生一个条件语句然后进行查找。为了加快速度，我们可以先把当天的日期取出来，然后转成字符串后再用如下语句查，select * from eventtable where eventdate >to_date(’2001-12-1′,’yyyy-mm-dd’)。速度相差几十倍。

Oracle怎样计算一个表占用的空间的大小？

可以使用一下语句来进行计算：

select owner ,
table_name,
NUM_ROWS,
BLOCKS*AAA/1024/1024 “Size M”,
EMPTY_BLOCKS,
LAST_ANALYZED
from dba_tables
where table_name= XXX ;
AAA 是指 db_block_size的值 ;
XXX 是你要查询的表名

如何在Oracle中查看各个表、表空间占用空间的大小？

使用以下语句查看当前用户每个表占用空间的大小：
Select Segment_Name,Sum(bytes)/1024/1024 From User_Extents Group BySegment_Name

使用一下语句查看每个表空间占用空间的大小：
Select Tablespace_Name,Sum(bytes)/1024/1024 From Dba_Segments Group ByTablespace_Name

介绍一下Oracle的操作符优化？

IN ：

IN写出来的SQL比较容易写及清晰易懂但是性能总是比较低的，从ORACLE执行的步骤来分析用IN的SQL与不用IN的SQL有以下区别：

ORACLE 试图将IN转换成多个表的连接，如果转换不成功会先执行IN里面的子查询，再查询外层的表记录，如果转换成功，则直接采用多个表的连接方式查询。所以用 IN的SQL至少多了一个转换的过程。一般的SQL都可以转换成功，但对于含有分组统计等方面的SQL就不能转换了。

推荐方法：在业务密集的SQL当中尽量不要采用IN操作符。

NOT IN：

不推荐使用，因为NOT IN不能应用表的索引。

推荐方案：用NOT EXISTS或（外连接+判断为空）

<> 操作符（不等于）

不等于操作符不会用到索引的，对它的处理只会产生全表扫描。

推荐方案：用其它相同功能的操作运算代替，如 a<>0 改为 a>0 or a<0 a<>’’改为 a>’’

IS NULL 或IS NOT NULL操作（判断字段是否为空）

判断字段是否为空一般不会应用索引，因为B树索引是不索引空值的。

推荐方案：

用其它相同功能的操作运算代替，如a is not null 改为 a>0 或a>’’等。

不允许字段为空，而用一个缺省值代替空值，如业扩申请中状态字段不允许为空，缺省为申请。

建立位图索引（有分区的表不能建，位图索引比较难控制，如字段值太多索引会使性能下降，多人更新操作会增加数据块锁的现象）。

> 及 < 操作符（大于或小于操作符）

大于或小于操作符一般不用调整，因为它有索引就会采用索引查找，但有的情况下可以对它进行优化，如一个表有100万记录，一个数值型字段A， 30万记录的A=0，30万记录的A=1，39万记录的A=2，1万记录的A=3。那么执行A>2与A>=3的效果就有很大的区别了，因为 A>2时ORACLE会先找出为2的记录索引再进行比较，而A>=3时ORACLE则直接找到=3的记录索引。

LIKE：

LIKE 操作符可以应用通配符查询，里面的通配符组合可能达到几乎是任意的查询，但是如果用得不好则会产生性能上的问题，如LIKE‘%5400%’ 这种查询不会引用索引，而LIKE ‘X5400%’则会引用范围索引。一个实际例子：用YW_YHJBQK表中营业编号后面的户标识号可来查询营业编号 YY_BH LIKE‘%5400%’ 这个条件会产生全表扫描，如果改成YY_BH LIKE ’X5400%’ OR YY_BHLIKE ’B5400%’ 则会利用YY_BH的索引进行两个范围的查询，性能肯定大大提高。

Oracle如何查询登陆客户端的机器名？

可以用一下语句查询登陆客户端的机器名：

select machine,terminal from V$SESSION

如何提高MySql的安全性？

1.如果MYSQL客户端和服务器端的连接需要跨越并通过不可信任的网络，那么需要使用ssh隧道来加密该连接的通信。

2.使用set password语句来修改用户的密码，先“mysql-u root”登陆数据库系统，然后“mysql> update mysql.user setpassword=password(’newpwd’)”，最后执行“flush privileges”就可以了。

3.Mysql需要提防的攻击有，防偷听、篡改、回放、拒绝服务等，不涉及可用性和容错方面。对所有的连接、查询、其他操作使用基于acl即访问控制列表的安全措施来完成。也有一些对ssl连接的支持。

4.设置除了root用户外的其他任何用户不允许访问mysql主数据库中的user表;

加密后存放在user表中的加密后的用户密码一旦泄露，其他人可以随意用该用户名/密码相应的数据库;

5.使用grant和revoke语句来进行用户访问控制的工作;

6.不要使用明文密码，而是使用md5()和sha1()等单向的哈系函数来设置密码;

7.不要选用字典中的字来做密码;

8.采用防火墙可以去掉50%的外部危险，让数据库系统躲在防火墙后面工作，或放置在dmz区域中;

9.从因特网上用nmap来扫描3306端口，也可用telnet server_host 3306的方法测试，不允许从非信任网络中访问数据库服务器的3306号tcp端口，需要在防火墙或路由器上做设定;

10.为了防止被恶意传入非法参数，例如where id=234，别人却输入where id=234 or 1=1导致全部显示，所以在web的表单中使用”或”"来用字符串，在动态url中加入%22代表双引号、%23代表井号、%27代表单引号;传递未检查过的值给mysql数据库是非常危险的;

11.在传递数据给mysql时检查一下大小;

12.应用程序需要连接到数据库应该使用一般的用户帐号，开放少数必要的权限给该用户;

$page_devide$

13.在各编程接口(c c++ php perl java jdbc等)中使用特定‘逃脱字符’函数;

在因特网上使用mysql数据库时一定少用传输明文的数据，而用ssl和ssh的加密方式数据来传输;

14.学会使用tcpdump和strings工具来查看传输数据的安全性，例如tcpdump -l -i eth0 -w -src or dst port 3306 strings。以普通用户来启动mysql数据库服务;

15.不使用到表的联结符号，选用的参数 –skip-symbolic-links;

16.确信在mysql目录中只有启动数据库服务的用户才可以对文件有读和写的权限;

17.不许将process或super权限付给非管理用户，该mysqladmin processlist可以列举出当前执行的查询文本;super权限可用于切断客户端连接、改变服务器运行参数状态、控制拷贝复制数据库的服务器;

18.file权限不付给管理员以外的用户，防止出现load data ‘/etc/passwd’到表中再用select 显示出来的问题;

19.如果不相信dns服务公司的服务，可以在主机名称允许表中只设置ip数字地址;

20.使用max_user_connections变量来使mysqld服务进程，对一个指定帐户限定连接数;

21.grant语句也支持资源控制选项;

22.启动mysqld服务进程的安全选项开关，–local-infile=0或1 若是0则客户端程序就无法使用localload data了，赋权的一个例子grant insert(user) on mysql.user to‘user_name’@'host_name’;若使用–skip-grant-tables系统将对任何用户的访问不做任何访问控制，但可以用 mysqladmin flush-privileges或mysqladminreload来开启访问控制;默认情况是showdatabases语句对所有用户开放，可以用–skip-show-databases来关闭掉。

23.碰到error 1045(28000) access denied for user‘root’@'localhost’ (using password:no)错误时，你需要重新设置密码，具体方法是:先用–skip-grant-tables参数启动mysqld，然后执行 mysql -u rootmysql,mysql>update user set password=password(’newpassword’) whereuser=’root’;mysql>flush privileges;，最后重新启动mysql就可以了。

什么是ddl dml和dcl？

DDL :数据定义语言，用于定义和管理 SQL 数据库中的所有对象的语言
1.CREATE – to create objects in the database   创建数据库对象
2.ALTER – alters the structure of the database   修改数据库对象
3.DROP – delete objects from the database   删除数据库对象
4.TRUNCATE – remove all records from a table, including all spaces allocatedfor the records are removed
TRUNCATE TABLE [Table Name]。
下面是对Truncate语句在MSSQLServer2000中用法和原理的说明：
Truncate table 表名速度快,而且效率高,因为:
TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同：二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少。
DELETE 语句每次删除一行，并在事务日志中为所删除的每行记录一项。TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放。
TRUNCATE TABLE 删除表中的所有行，但表结构及其列、约束、索引等保持不变。新行标识所用的计数值重置为该列的种子。如果想保留标识计数值，请改用 DELETE。如果要删除表定义及其数据，请使用 DROP TABLE 语句。
对于由 FOREIGN KEY 约束引用的表，不能使用TRUNCATE TABLE，而应使用不带 WHERE 子句的DELETE 语句。由于 TRUNCATE TABLE 不记录在日志中，所以它不能激活触发器。
TRUNCATE TABLE 不能用于参与了索引视图的表。
5.COMMENT – add comments to the data dictionary 注释
6.GRANT – gives user’s access privileges to database 授权
7.REVOKE – withdraw access privileges given with the GRANT command   收回已经授予的权限

DML:数据操作语言，SQL中处理数据等操作统称为数据操纵语言
1.SELECT – retrieve data from the adatabase           查询数据
2.INSERT – insert data into atable                   添加数据
3.UPDATE – updates existing data within a table    更新数据
4.DELETE – deletes all records from a table, the space for the recordsremain   删除
5.CALL – call a PL/SQL or Java subprogram
6.EXPLAIN PLAN – explain access path to data
Oracle RDBMS执行每一条SQL语句，都必须经过Oracle优化器的评估。所以，了解优化器是如何选择(搜索)路径以及索引是如何被使用的，对优化SQL语句有很大的帮助。Explain可以用来迅速方便地查出对于给定SQL语句中的查询数据是如何得到的即搜索路径(我们通常称为Access Path)。从而使我们选择最优的查询方式达到最大的优化效果。
7.LOCK TABLE – control concurrency 锁，用于控制并发

DCL:数据控制语言，用来授予或回收访问数据库的某种特权，并控制数据库操纵事务发生的时间及效果，对数据库实行监视等
COMMIT – save work done 提交
SAVEPOINT – identify a point in a transaction to which you can later roll back 保存点
ROLLBACK – restore database to original since the last COMMIT 回滚
SET TRANSACTION – Change transaction options like what rollback segment touse 设置当前事务的特性，它对后面的事务没有影响．

什么是数据库的约束？

数据库约束是防止非法记录的规则，约束保存在数据字典(data dictionary)中，约束可以被定义在列级或者表级。

Oracle中包括一下集中约束：

1. Not Null – 明确一列数据不能包含null值

2. Unique – 强制所有数据行不能有重复值

3. Primary Key – 每一行数据的唯一标示

4. Foreign Key – 强制一列数据与引用表的外键约束关系

5. Check – 检查，明确规定一个必须为true的condition

Oracle数据库架构中包括几层？每层都有什么元素？

Oracle数据库包括一个逻辑层和物理层，物理层包括Oracle磁盘上的文件,逻辑层用来映射数据和物理层的文件。

逻辑层包括一下元素：

一个或者多个表空间。

数据库Schema: 包括表，集群，索引，视图，存储过程，数据库触发器和sequences.

介绍一下SQL中union, intersect 和 minus

Union用来返回多个查询的结果的总和去掉重复的结果

语法：
SELECT column1, column2 FROM tablename1
UNION
SELECT column1, column2 FROM tablename2;

Intersect 用来返回多个查询中共同的结果，intersect会忽略null值

语法：

SELECT column1,column2 FROM tablename1
INTERSECT
SELECT column1, column2 FROM tablename2;

MUNUS返回出现在第一个查询结果中但是不出现在第二个查询结果的结果集。

语法：

SELECT column1,column2 FROM tablename1
MINUS
SELECT column1, column2 FROM tablename2;

主键(Primary Key)约束和唯一性(UNIQUE)约束有什么区别？

一个表只能由一个主键，一个表可以有很多个唯一键(UNIQUE Key)

主键不允许有null值，UNIQUE允许null值

Oracle中delete, truncate 和 drop的区别？

Delete命令用来删除表的全部或者一部分数据行，执行delete之后，用户需要提交(commmit)或者回滚(rollback) transaction 来执行删除或者撤销删除， delete命令会触发这个表上所有的delete触发器。

Truncate删除表中的所有数据，这个操作不能回滚，也不会触发这个表上的触发器，TRUNCATE比delete更快，占用的空间更小。

Drop命令从数据库中删除表，所有的数据行，索引和权限也会被删除，所有的DML触发器也不会被触发，这个命令也不能回滚。

rowid和rownum有什么不同？

RowId是一个数据库内部的概念，表示表的一行，用来快速的访问某行数据

Rownum是结果集的一个功能，例如select * from Student where rownum = 2 就是得到结果集的第二行。

视图的作用是什么？

数据库视图的作用只要有：

1. 数据库视图隐藏了数据的复杂性。

2. 数据库视图有利于控制用户对表中某些列的访问。

3. 数据库视图使用户查询变得简单。

视图是一个虚拟表，其内容由查询定义。同真实的表一样，视图包含一系列带有名称的列和行数据。但是，视图并不在数据库中以存储的数据值集形式存在。行和列数据来自由定义视图的查询所引用的表，并且在引用视图时动态生成。

对其中所引用的基础表来说，视图的作用类似于筛选。定义视图的筛选可以来自当前或其它数据库的一个或多个表，或者其它视图。分布式查询也可用于定义使用多个异类源数据的视图。如果有几台不同的服务器分别存储组织中不同地区的数据，而您需要将这些服务器上相似结构的数据组合起来，这种方式就很有用。

通过视图进行查询没有任何限制，通过它们进行数据修改时的限制也很少。

什么是Oracle的同义词(synonym)? 如何创建synonym?

同义词是相当于别名，是为了简化一些表名或者数据对象。当我们以一个用户登陆而要去访问另一个用户创建的数据对象时，我们需要使用用户名.对象名的方法来使用，这样造成对象名难记，麻烦，使用同义词可以解决这个问题。

假定我们现在以system的身份的登陆进去，我们需要访问scott用户下面的一个表emp;

常规的写法是:select *from scott.emp;

现在我们可以先建立一个同义词:
create synonym my_syn for scott.emp;

然后我们这样来访问这个表了:
select * from my_syn;

什么是数据库锁？Oracle中都有哪些类型的锁？

锁是用来在多个用户同时访问同一个表的时候保护数据的。它是Oracle的一种并发控制技术。锁使数据库最大并发的情况下保证数据的完整性。Oracle会在需要的时候自动的提供锁的功能。

锁的种类：

共享锁：这个锁是数据在被viewed的时候放置的。

排他锁：这种锁在Insert,Update, Delete命令执行的时候放置的，每一条记录同一时间只能有一个排他锁。

触发器(trigger)的功能都有哪些？写出一个触发器的例子

触发器是数据库中由一个时间触发的特殊的存储过程，他不是由程序条用也不是手工启动的。触发器的执行可以由对一个表的insert,delete, update等操作来触发，触发器经常用于加强数据的完整性约束和业务规则等等。

触发器的功能主要有一下六种：

1、允许/限制对表的修改

2、自动生成派生列，比如自增字段

3、强制数据一致性

4、提供审计和日志记录

5、防止无效的事务处理

6、启用复杂的业务逻辑

Create table foo(a number);
Create trigger biud_foo
Before insert or update or delete
On foo
Begin
If user not in (‘DONNY’) then
Raise_application_error(-20001, ‘You don’t have access to modify this table.’);
End if;
End;

如何杀掉ORACLE里面长期没有释放的锁？

如果一个数据库insertupdate delete操作很长时间没有反应，就可能出现了没有正常释放的锁。

可以用以下SQL语句杀掉没有正常释放的锁：

alter system killsession ’sid,serial#’;

如何查看当前ORACLE数据库里面锁的情况？

查看数据库锁的情况必须要有DBA权限，可以使用一下SQL 语句：

selectobject_id,session_id,locked_mode from v$locked_object;

selectt2.username,t2.sid,t2.serial#,t2.logon_time

from v$locked_objectt1,v$session t2

wheret1.session_id=t2.sid order by t2.logon_time;

长时间出现的锁可能是没有正常释放的锁。

Oracle的锁有几种模式？

Oracle里面的锁共有一下几种模式：

0: none

1: null 空

2：Row-S 行共享(Row Share RS): 共享表锁

3：Row-X 行专用(RX): 用于行数据的修改

4：Share 共享锁(S): 阻止其他DML操作

5：S/Row-X 共享行专用(SRX): 阻止其他事务操作

6：exclusive 专用(X): 独立访问使用

以上可以看出，数字越大的锁影响的操作越多，锁的级别越高。

一般的查询语句是小于2的锁，如select * from *

select … from …for update 是2的锁，这时候返回集的数据行都将处于行级(Row-X)独占式锁定，其他对象只能对这些数据进行查询，而不能进行更新或者selectfor update操作。

insert/update/delete是3的锁，在这些操作没有commit之前插入同样的记录会没有反应，因为3的锁必须要等到前一个3的锁执行释放掉以后才能继续。创建索引的时候也会产生3,4级别的锁。

locked_mod为2,3,4的锁，不影响DML（insert,delete,update,select）操作，但是DDL（alter,drop）等修改表结构的操作会提示ora-00054错误。

当有主外键约束时执行update/delete操作可能会产生4,5的锁。

DDL语句时是6的锁。

第四章：J2EE高级软件工程师面试题

-----程序设计题部分

常用排序算法

package com.sort;

importjava.util.Random;

public classNo1Maopao {
    public static void main(String[] args) {
        Random rd = new Random();
//生成随即数组
        int [] src = new int[10];
        for(int i=0;i<10;i++){
           src[i]=rd.nextInt(100);
        }
//排序前打印数组所有元素
        for(int i:src)
           System.out.println(i);
       System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
//排序后打印数组所有元素
        for(int i:src)
           System.out.println(i);
    }

   public static int[] sort(int [] src){
        for (int i = 0; i < src.length;i++) {
            for(intj=i;j<src.length;j++){
               if(src[j]<src[i]){
                   int temp = src[j];
                   src[j]=src[i];
                   src[i]=temp;
               }
            }
        }
        return src;
    }
}
二、选择排序：
package com.sort;

importjava.util.Random;

public classNo2XuanZhe {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] =rd.nextInt(100);
        }
        for (int i : src)
            System.out.println(i);
       System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
        for (int i : src)
           System.out.println(i);
    }

   public static int[] sort(int[] src) {
        int min;
        for (int i = 0; i < src.length;i++) {
            min =src[i];
            for (int j =i + 1; j < src.length; j++) {
               if (src[j] < min) {
                   min = src[j];
                   int temp = src[i];
                   src[i] = src[j];
                   src[j] = temp;
               }
            }
        }
        return src;
    }
}
三、插入排序：
package com.sort;

importjava.util.Random;

public classNo3ChaRu {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] =rd.nextInt(100);
        }
        for (int i : src)
           System.out.println(i);
       System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
        for (int i : src)
           System.out.println(i);
    }

   public static int[] sort(int[] src) {
        int in, out;
        for (in = 1; in < src.length;in++) {
            int temp =src[in];
            out = in;
            while (out> 0 && src[out - 1] >= temp) {
               src[out] = src[out - 1];
               --out;
            }
            src[out] =temp;
        }
        return src;
    }
}
四、希尔排序：
package com.sort;

importjava.util.Random;

public classNo4Xier {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] =rd.nextInt(100);
        }
        for (int i : src)
            System.out.println(i);
       System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
        for (int i : src)
           System.out.println(i);
    }

   public static int[] sort(int[] src) {
        int len = src.length;
        int temp, i, j;
        int h = 1;
        while (h <= len / 3)
            h = h * 3 +1;
        while (h > 0) {
            for (i = h;i < len; i++) {
               temp = src[i];
               j = i;
               while (j > h - 1 && src[j - h] >= temp) {
                   src[j] = src[j - h];
                   j -= h;
               }
               src[j] = temp;
            }
            h = (h - 1)/ 3;
        }
        return src;
    }
}
五、快速排序：
public class No5Kuaisu {

   public static void quickSort(int[] array) {
        quickSort(array, 0, array.length -1);
    }

   private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int p =partition(array, low, high);
            quickSort(array,low, p - 1);
           quickSort(array, p + 1, high);
        }

}

   private static int partition(int[] array, int low, int high) {
        int s = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++){
            if (array[j]< s) {
               i++;
               swap(array, i, j);
            }
        }
        swap(array, ++i, high);
        return i;
    }

   private static void swap(int[] array, int i, int j) {
        int temp;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

   public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] =rd.nextInt(100);
        }
        for (int i : src)
           System.out.println(i);
       System.out.println("---------------可爱的分割线-------------------");
        quickSort(src);
        for (int i : src)
           System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
    }
}

常见算法题目

本题的splitStringByComma(String)方法纯属多余，可以用String的split方法一句话代替，且可读性也更强，下面的一段话源自JDK1.6API，StringTokenizer类已不再提倡使用，保留仅为旧代码。

StringTokenizer是出于兼容性的原因而被保留的遗留类（虽然在新代码中并不鼓励使用它）。建议所有寻求此功能的人使用String的 split方法或 java.util.regex 包。

importjava.util.*;

public classbycomma{

public static String[] splitStringByComma(String source){

if(source==null||source.trim().equals(""))

return null;

StringTokenizer commaToker = new StringTokenizer(source,",");

String[] result = new String[commaToker.countTokens()];

int i=0;

while(commaToker.hasMoreTokens()){

result[i] = commaToker.nextToken();

i++;

}

return result;

}

public static void main(String args[]){

String[] s = splitStringByComma("5,8,7,4,3,9,1");

int[] ii = new int[s.length];

for(int i = 0; i<ii.length;i++){

ii[i] =Integer.parseInt(s[i]);

}

Arrays.sort(ii);

//asc

for(int i=0;i<ii.length;i++ ){

System.out.println(ii[i]);

}

//desc

for(int i=(s.length-1);i>=0;i--){

System.out.println(ii[i]);

}

2.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"，6，应该输出为"我ABC"而不是"我ABC+汉的半个"。

代码：

public staticboolean isLetter(char c){

int k=0X80;

returnc/k==0?true:false;

}

public static intlengths(String strSrc){

if (strSrc==null){

return 0;

}

int len=0;

char[]strChar=strSrc.toCharArray();

for (inti=0;i<strChar.length;i++){

len++;

if(!isLetter(strChar[i])) len++;

}

return len;

}

public staticString subString(String origin,int len){

if (origin==null|| origin.equals("")|| len<1){

return"";

}

if(len>lengths(origin)){

return origin;

}

byte[] strByte=newbyte[len];

System.arraycopy(origin.getBytes(),0,strByte,0,len);

int count=0;

for (inti=0;i<len;i++){

intvalue=(int)strByte[i];

if (value<0)count++;

}

if (count % 2!=0){

//len=(len==1)?++len:--len;

--len;

}

return newString(strByte,0,len);

}

public static voidmain(String[] args) {

System.out.println(""+subString("我ABC汉DEF",6));

}

3、排序都有哪几种方法？请列举。用JAVA实现一个快速排序。

排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）

快速排序的伪代码。

/ /使用快速排序方法对a[ 0 :n- 1 ]排序从a[ 0 :n-1 ]中选择一个元素作为m I d d l e，该元素为支点把余下的元素分割为两段left 和r I g h t，使得le f t中的元素都小于等于支点，而right 中的元素都大于等于支点递归地使用快速排序方法对left 进行排序递归地使用快速排序方法对right 进行排序所得结果为l e f t + m I d d l e + r I g h t

//以下为java程序实现的快速排序算法：

public static voidsort(int[] data) {

quickSort(data,0,data.length-1);

}

public static voidquickSort(int[] data,int low,int high){

intpivotIndex=(low+high)/2;

swap(data,pivotIndex,high);

intk=partition(data,low-1,high,data[high]);

swap(data,k,high);

if ((k-low)>1)partition(data,low,k-1);

if ((high-k)>1)partition(data,k+1,high);

}

public static intpartition(int[] data int low,int high, int pivot ){

do {

while(data[++low]<pivot) ;

while(high!=0 && data[--high]>pivot);

swap(data,low,high);

}

while(low<high) ;

swap(data,low,high);

return low;

}

public static voidswap(int[] data int low,int high){

int tmp=data[low];

data[low]=data[high];

data[high]=tmp;

}

public static voidmain(String[] args){

int[] data = newint[]{89,32,425,32,78,1,53,92};

sort(data);

}

4.试用递归的方法写一下计算菲波那契数列的通项f(n),已知f1=1,f2=1,以后每项都是前两项的和。

..............

public static longfibonacci(long m){

if (m==0 || m==1)return m;

else returnfibonacci(m-1)+fibonacci(m-2);

}

5. 写一个Singleton出来。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

我的评论：第一种形式是饿汉式单例类，第二种是懒汉式单例类；可以如此速记，饿汉式太饿了，所以迫不及待在内部new出一个实例，而懒汉式太懒了，所以知道应用时才检查有没有实例存在，如不存在才new一个实例出来。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

Public classSingleton {

privateSingleton(){}

//在自己内部定义自己一个实例，是不是很奇怪？

//注意这是private 只供内部调用

private staticSingleton instance = new Singleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问

public staticSingleton getInstance() {

return instance;

}

第二种形式:

public classSingleton {

private staticSingleton instance = null;

public staticsynchronized Singleton getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

if(instance==null)

instance＝new Singleton();

return instance;

}

其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

6、创建一个静态方法，给它传入一个对象，请循环的打印出该对象所在类的类名和所实现的方法名（华为笔试最后一道编程）

importjava.lang.reflect.*;

public class Test{

public static voidtest(Object obj){

Classclazz=obj.getClass();

//System.out.println("类名:"+clazz.getName());

Method[]ms=clazz.getDeclaredMethods();

longlen=Array.getLength(ms);

for(inti=0;i<len;i++){

System.out.println("类名:"+clazz.getName()+"方法名:"+ms[i].getName());

}

class A{

public void b(){}

public void c(){}

public void d(){}

public void e(){}

}

public static voidmain(String[] args){

Test t=new Test();

Test.A a=t.newA();

test(a);

}

7、假设字符串类似这样的aba和aab就相等，现在随便给你二组字符串，请编程比较他们看是否相等

BufferedReader br= new BufferedReader(new InputStreamReader(System.in));

String s = null;

try {

s = br.readLine();

} catch(IOException e) {

e.printStackTrace();

}

StringTokenizer st= new StringTokenizer(s);

String s1 =st.nextToken();

String s2 =st.nextToken();

byte[] sa1 =s1.getBytes();

byte[] sb2 =s2.getBytes();

Arrays.sort(sa1);

Arrays.sort(sb2);

String ss1 = newString(sa1);

String ss2 = newString(sb2);

if(ss1.equals(ss2))

System.out.println("equal");

else

System.out.println("notequal");

8、给你一组字符串如：iu7i8hy4jnb2，让你编程输出里面的数字：7842

用正规表达式："iu7i8hy4jnb2".replaceAll("[^\\d]","");

9、给你一组字符串让你把它倒叙输出

public staticString flashBack(String origin) {

String result ="";

for (int i =origin.length(); i > 0; i--) {

String tmp =origin.substring(i - 1, i);

result += tmp;

}

return result;

}

10、给你一组字符如{1，3，4，7，2，1，1，5，2}，让你输出里面出现次数最多且数值最大的一个，出现几次

public void fun4(){

int[] a = { 4, 1,2, 4, 5, 1, 1, 1, 5, 1, 3, 4, 5 };

Arrays.sort(a);

for (int i = 0; i< a.length; i++) {

System.out.print(a[i]+ " ");

}

System.out.println();

int maxNumber =a[a.length - 1], maxCount = 1;

int curNumber =a[a.length - 1], curCount = 1;

for (int i =a.length - 1; i > 0; i--) {

curNumber = a[i];

if (a[i] == a[i -1]) {

curCount++;

} else {

System.out.println("i="+ i + ",curCount=" + curCount+ ",maxCount=" + maxCount +",maxNumber=" + maxNumber);

if (curCount >maxCount) {

maxCount =curCount;

maxNumber =curNumber;

}

curCount = 1;

}

if (curCount >maxCount) {

maxCount =curCount;

//maxNumber =curNumber;

}

System.out.println("curCount="+ curCount + ",maxCount=" + maxCount + ",maxNumber=" +maxNumber);

}

11、求两个数的公约数，M，N

int divisor =1;

for (int i = 2; i<= b; i++) {

if(a%i==0&& b%i==0){

divisor = i;

}

System.out.println(a+"和"+b+"的最大公约数是:"+divisor);

}

12、实现数组复制

我的理解：这是深复制，数组a，b不再有关联

public voidfun8(){

int[] a ={1,2,3,4,56,7,8};

int[] b =(int[])a.clone();

Conica.print(a);

Conica.print(b);

b[0]=100;

Conica.print(a);

Conica.print(b);

}

13、冒泡排序的实现

public voidfun9(){

int[] a ={1,5,2,6,8,74,1,25,69,8};

Conica.print(a);

for(int i=0;i<a.length-1; i++){

for(int j=0;j<a.length-i-1;j++){

if(a[j]>a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

Conica.print(a);

}

14、编程显示某一文件目录下的文件名

public voidfun10(){

File file = newFile("G:\\03月份");

if(file.exists()){

if(file.isDirectory()){

String[] files =file.list();

Conica.println(files);

}

15、从键盘输入4个十进制数字字符，将其转换为4位时间之数并显示出来

16、编程实现统计文本文件中某个单词的出现频率，并输出统计结果

用HashMap来解决

假设单词不存在跨行的,每个单词用,. ;分割

public static voidcountNum() throws IOException {

BufferedReader br= null;

try {

br = newBufferedReader(new FileReader("c://file.txt"));

Map map = newHashMap();

for (String s =br.readLine(); s != null; s = br.readLine()) {

StringTokenizer st= new StringTokenizer(s, ",. ;");

while(st.hasMoreTokens()) {

String temp =st.nextToken();

if(map.containsKey(temp)) {

map.put(temp, newInteger((Integer)map.get(temp) + 1));

} else {

map.put(temp, newInteger(1));

}

for (Iterator it =map.entrySet().iterator(); it.hasNext();) {

Map.Entry entry =(Map.Entry) it.next();

System.out.println(entry.getKey()+ "-->" + entry.getValue()

+"times");

}

} finally {

br.close();

}

17、编程模仿DOS下的dir命令，列出某个目录下的内容

18、编程说明String和StringBuffer字符串的区别

19、编程计算N!的程序，一个使用递归方法，一个不用递归方法

递归 :

long fuction(intn){

if (n==0) return1;

else

return n*fuction(n-1);

}

不递 :

long s=1;

for(inti=2;i<=n;i++)

{

s*=i;

}

20、编程实现ASCII码和Unicode码之间的转换

21.用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求： "4 "不能在第三位， "3 "与 "5 "不能相连.

import java.util.*;
public class test {
       static int count=0;
public static void main(String[] arg) {
Scanner r=new Scanner(System.in);
String s=r.nextLine();
Pailie(s, "");
System.out.println("Total: "+count);
   }
     static void Pailie(String s,String p) {
if(s.length() <1) {
System.out.println(p);//字符串长度小于1，换行
count++;
}
else {
int index[]=new int[s.length()];
for(int i=0; i <s.length(); i++)

//该循环将所有字符的第一次出现的位置记录在数组index中
index[i]=s.indexOf(s.charAt(i));
for(int i=0; i <s.length(); i++) {
if(i==index[i])

//只有当循环数与第一次记录数相等时才递归，保证相同字符中的第一个调用
Pailie(s.substring(1),p+s.substring(0,1));//递归，打印其它字符
s=s.substring(1)+s.substring(0,1);//循环移位
}
}
}
}

22。一个字符串中可能包含a~z中的多个字符，如有重复，如Stringdata="aavzcadfdsfsdhshgWasdfasdf"，求出现次数最多的那个字母及次数，如有多个重复的则都求出。〔金山公司面试题〕

importjava.util.ArrayList;

importjava.util.Collections;

importjava.util.Iterator;

import java.util.TreeSet;

public classFindRepeatChar {

public static voiddoString(String strInput) {

char[] chars =strInput.toCharArray();

ArrayList lists =new ArrayList();

TreeSet set = newTreeSet();

for (int i = 0; i< chars.length; i++) {

lists.add(String.valueOf(chars[i]));

set.add(String.valueOf(chars[i]));

}

System.out.println(set);

Collections.sort(lists);

System.out.println(lists);

StringBuffer sb =new StringBuffer();

for (int i = 0; i< lists.size(); i++) {

sb.append(lists.get(i));

}

strInput = sb.toString();

System.out.println(strInput);

int max = 0;

String maxString ="";

ArrayList maxList= new ArrayList();

for (Iterator its= set.iterator(); its.hasNext();) {

String os =(String) its.next();

int begin =strInput.indexOf(os);

int end =strInput.lastIndexOf(os);

int value = end -begin + 1;

if (value > max&& value > 1) {

max = value;

maxString = os;

maxList.add(os);

} else if (value== max) {

maxList.add(os);

}

int index = 0;

for (int i = 0; i< maxList.size(); i++) {

if(maxList.get(i).equals(maxString)) {

index = i;

break;

}

System.out.println("出现最多的字符为：");

for (int i = 0; i< maxList.size(); i++) {

System.out.println(maxList.get(i)+ "");

}

System.out.println();

System.out.println("出现最多的次数为：" + max);

}

public static voidmain(String[] args) {

String strInput =new String("aavzcadfdsfsdhshgWasdfasdf");

doString(strInput);

}

第四章：J2EE高级软件工程师面试题

-----面试技巧篇

面试技巧
一、面试的准备
面试准备主要是克服怯场的心理状态。
面试中应注意以下几点：
1、要坚持平常的心态、平静的心情
2、不要把面试的成败看得太重
3、要增强自信心
4、不要把考官看得过于神秘
5、要保持愉快的心理状态（愉快的心情能更好地发挥主动性）
二、影响面试的因素
（一）积极因素
1、信心
2、诚实
3、让主试者相信你对该部门十分有利，是一个有用的必要人物
4、礼貌（避免让人反感）
（二）消极因素
1、迟到
2、好高婺远、眼高手低
3、满不在乎、粗鲁无理的态度
三、面试技巧
（一）面试的着装技巧（着装技巧法）
1、灵活多样、随机应变
2、突出自我、展示特色
3、不求时髦注意服装必须反映自己的气质、个性性格、教育及内涵等
4、协调服装打扮及仪态要符合所在单位的习惯、节奏和风格
5、忌讳尽量避免暴露及挑逗性的服饰
6、整洁最为重要
（二）面试的回答技巧
1、礼貌用语
2、言语要形象生动、富有情趣
3、沉着冷静（琢磨对方的问题动机、防止冷不防提出的问题）
4、表达简洁清楚
（三）面试的聆听技巧
1、耐心----就是自己心情平静安定，以认真的态度听对方讲话。即使是很普通的问题、或者自己已经知道的问题也要认真听。
2、专心----就是在面试当中，一定要专心，一是讲礼貌的基本要求，二是满足人尊重需要的要求。还要注意注视对方，善于用表情如微笑、眼神等来表达自己形形色色的心理内涵。在必要的时候还要注意作好笔记。
3、细心----因为面试是一个综合考察一个人的能力、知识、素质的过程，所以要求应试者要有敏锐的观察能力，就是细心。
关于提问：
外资企业面试时考官最爱提的十个问题
1.请介绍一下你自己。

　　这是外企常问的问题。一般人回答这个问题过于平常，只说姓名、年龄、爱好、工作经验，这些在简历上都有，其实，外企最希望知道的是求职者能否胜任工作，包括：最强的技能、最深入研究的知识领域、个性中最积极的部分、做过的最成功的事，主要的成就等，这些都可以和学习无关，也可以和学习有关，但要突出积极的个性和做事的能力，说得合情

　　合理外企才会相信。外企很重视一个人的礼貌，求职者要尊重考官，在回答每个问题之后都说一句“谢谢 ”。外企喜欢有礼貌的求职者。　　2.在学校你最不喜欢的课程是什么？为什么？　　这个问题外企不希望求职者直接回答“数学”、“体育”之类的具体课程，如果直接回答还说明了理由，不仅代表求职者对这个学科不感兴趣，可能还代表将来也会对要完成的某些工作没有兴趣。这个问题外企招聘者最想从求职者口里听到：我可能对个别科目不是特别感兴趣，但是正因为这样，我会花更多的时间去学习这门课程，通过学习对原本不感兴趣的科目也开始有了兴趣，对于本来就有兴趣的科目我自然学习得更认真，所以各门课的成绩较为平衡。通过这样的问题，外企可以找到对任何事情都很感兴趣的求职者。

　　3.说说你最大的优缺点？　　这个问题外企问的概率很大，通常不希望听到直接回答的缺点是什么等，如果求职者说自己小心眼、爱忌妒人、非常懒、脾气大、工作效率低，外企肯定不会录用你。外企喜欢求职者从自己的优点说起，中间加一些小缺点，最后再把问题转回到优点上，突出优点的部分。外企喜欢聪明的求职者。

　　4. 你认为你在学校属于好学生吗？　　外企的招聘者很精明，问这个问题可以试探出很多问题：如果求职者学习成绩好，就会说：“是的，我的成绩很好，所有的成绩都很优异。当然，判断一个学生是不是好学生有很多标准，在学校期间我认为成绩是重要的，其他方面包括思想道德、实践经验、团队精神、沟通能力也都是很重要的，我在这些方面也做得很好，应该说我是一个全面发展的学生。”如果求职者成绩不尽理想，便会说：“我认为是不是一个好学生的标准是多元化的，我的学习成绩还可以，在其他方面我的表现也很突出，比如我去很多地方实习过，我很喜欢在快节奏和压力下工作，我在学生会组织过××活动，锻炼了我的团队合作精神和组织能力。” 有经验的招聘者一听就会明白，外企喜欢诚实的求职者。

　　5.说说你的家庭。　　外企面试时询问家庭问题不是非要知道求职者家庭的情况，探究隐私，外企不喜欢探究个人隐私，而是要了解家庭背景对求职者的塑造和影响。外企希望听到的重点也在于家庭对求职者的积极影响。外企最喜欢听到的是：我很爱我的家庭！我的家庭一向很和睦，虽然我的父亲和母亲都是普通人，但是从小，我就看到我父亲起早贪黑，每天工作特别勤劳，他的行动无形中培养了我认真负责的态度和勤劳的精神。我母亲为人善良，对人热情，特别乐于助人，所以在单位人缘很好，她的一言一行也一直在教导我做人的道理。外企相信，和睦的家庭关系对一个人的成长有潜移默化的影响。

　　6.说说你对行业、技术发展趋势的看法？　　外企对这个问题很感兴趣，只有有备而来的求职者能够过关。求职者可以直接在网上查找对你所申请的行业部门的信息，只有深入了解才能产生独特的见解。外企认为最聪明的求职者是对所面试的公司预先了解很多，包括公司各个部门，发展情况，在面试回答问题的时候可以提到所了解的情况，外企欢迎进入企业的人是“ 知己”，而不是“盲人”。

　　7.就你申请的这个职位，你认为你还欠缺什么？　　外企喜欢问求职者弱点，但精明的求职者一般不直接回答。他们希望看到这样的求职者：继续重复自己的优势，然后说：“对于这个职位和我的能力来说，我相信自己是可以胜任的，只是缺乏经验，这个问题我想我可以进入公司以后以最短的时间来解决，我的学习能力很强，我相信可以很快融入公司的企业文化，进入工作状态。”外企喜欢能够巧妙地躲过难题的求职者。

　　8.你期望的工资是多少？　　外企的工资水平是很灵活的，何种能力拿何种工资。外企喜欢直率的人，但这个问题却不能正面回答，外企希望听到：“以我的能力和我的优势，我完全可以胜任这个职位，我相信我可以做得很好。但是贵公司对这个职位的描述不是很具体，我想还可以延后再讨论”。外企欢迎求职者给其定薪的自由度，而不是咬准一个价码。

　　9.你能给公司带来什么？　　外企很想知道未来的员工能为企业做什么，求职者应再次重复自己的优势，然后说：“就我的能力，我可以做一个优秀的员工在组织中发挥能力，给组织带来高效率和更多的收益”。外企喜欢求职者就申请的职位表明自己的能力，比如申请营销之类的职位，可以说：“我可以开发大量的新客户，同时，对老客户做更全面周到的服务，开发老客户的新需求和消费。”等等。

　　10.你还有什么问题吗？

　　外企的这个问题看上去可有可无，其实很关键，外企不喜欢说“没有问题”的人，因为其很注重员工的个性和创新能力。外企不喜欢求职者问个人福利之类的问题，如果有人这样问：贵公司对新入公司的员工有没有什么培训项目，我可以参加吗？或者说贵公司的晋升机制是什么样的？外企将很欢迎，因为体现出你对学习的热情和对公司的忠诚度以及你的上进心。

2009面试的十大禁忌

禁忌一：恶意缺席

    接到面试通知，如果不能或不想出席，都应该在前一至三天用电话婉转地通知对方。许多求职者可能会认为，反正我已决定不去这家公司上班，何必和对方有所接触？这绝对是错误的观念，留下恶意缺席的印象，对你日后要在这个行业中发展，一定有所影响。

禁忌二：不守时

    面试时的守时十分重要，迟到是绝对不可原谅的行为，代表你对这家公司根本不重视。太早到也不好，面试官可能有别的事情，还要应付你的突然出现。

禁忌三：穿着邋遢

    不管你应征何种类型的工作，穿着是给别人留下第一印象的机会。即使是所谓创意型的人员，邋遢、不修边幅的着装，还是不易令人亲近。是不是西装革履其实并不重要，要把握干净、整洁的原则，才能留下好印象。

禁忌四：没有准备

    就算你是一个毫无经验的社会新鲜人，对于应征职务的工作性质、内容，也应该有一些基本的认识与了解。企业当然可以容忍新鲜人缺乏经验，但是没有准备、一问三不知的人，似乎也意味着将来在工作上缺乏责任感。更现实的说法，企业可能要花两、三倍的时间才能让你达到工作的要求。

禁忌五：欺骗

    没有一家企业会录用不诚实的新人，在面试的过程中，诚实是最好的应对之策。尤其是履历表、自传中所写的个人背景资料，不要夸大自己的能力，或是谈话内容和履历表所写不符。即使面试时未被发觉，日后也会被检验。

禁忌六：言行轻浮

    面试代表的是一种对个人性格的主观判断，轻浮的言行、夸张的肢体动作，会令人有不信任的感觉。面试官最讨厌的是一副无所谓、可有可无的态度，如果你对这家公司没有兴趣，又何必来应征呢？

禁忌七：没有自信，或流露骄傲

    自信和骄傲有时就在一线之间，尺寸的拿捏要小心掌握。没有自信的人会让人有学习力差、推诿搪塞的联想，肯定不受企业欢迎；骄傲的人则令人生厌，没有团队合作的概念、不合群，企业可不想用一个单打独斗的独行侠。

禁忌八：天马行空

    说话的逻辑概念，代表的是一个人的组织能力。天马行空可能是一种创意，却也代表着“只会说不会做”的言行失衡。企业应征社会新鲜人，多半是希望做好基层的执行工作，有创意当然是额外的红利，只动嘴不动手可不是新人该做的事。

禁忌九：喜好批评却无创见

    没有一个主管喜欢爱批评却无创见的员工，面试官也一样。即使批评的是和工作无关的事，像是政治、经济、社会的现况，对于求职者来说，并没有任何加分的效果，可能还会因为你的言语不当，引起面试官的不快。

禁忌十：不知行情乱开价

    谈到薪水多半代表你有很大的机会被录取，可是你却来个狮子大开口，企业怎么敢用一个漫天要价的人？如果你不想吃亏，面试前应多打听相关行情，否则就采取“依公司规定”的保守策略。不知行情胡乱开价，绝对让你的面试倒扣200分

3、好的自我介绍

怎样做好面试准备，汇总多为招聘专家的意见，我们给出在面试在自我介绍环节中，应该掌握的几点基本技巧：

开门见山，简明扼要，不要超过三分钟（最好准备1、2、3分钟分别的的介绍内容，以应对不同的要求，即使在没有时间限制的情况下，个人建议在2分钟以内比较好）

实事求是，适当夸张（我们可以稍微、适当的吹嘘一下自己，但是切忌，不要吹过了头，因为诚实很重要）

突出长处，但也不隐瞒短处。（面试官了解了你长处的同时，当然也想知道你的短处，因为优点和缺点的平衡也是很大的一个考核标准，你也不会招聘一个缺点大于等于优点的员工吧？）

所突出的长处要与申请的职位有关。（如果你是狙击手，让你跟一个原始人拼长矛，你觉得你的长处能派上用场吗？）

善于用具体事例来证明自己，说明问题，（一件事例，往往比你说一堆道理更能证明自己）

以上技巧需要广大求职者，特别是应届生面试者在自我介绍环节中一定要特别注意，因为刚刚毕业缺乏面试经验，一不小心讲自我介绍弄成详细的个人情况，世界观，哲学观等等的介绍。

6587845888

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
J2EE 高级软件工程师面试题集

目录第一章：基础知识部分…………………………………3第二章：高级知识部分…………………………………27第三章：数据库部分……………………………………70第四章：程序设计部分…………………………………113第五章：面试技巧部分…………………………………132 第一章：J2EE高级软件工程师面试题集--JAVA基础部分 1、面向对象的特征有哪些方面 1.抽象：抽象...
复制链接

扫一扫