HYPERLINK\l"_Toc111630911"16、文件读写PAGEREF_Toc111630911\h17、指出下面程序的运行结果。PAGEREF_Toc111630912\h16
Java面试题整理
This（）：当前类的对象,super父类对象。
Super（）：在子类访问父类的成员和行为,必须受类继承规则的约束
而this他代表当前对象,当然所有的资源都可以访问.
在构造函数中,如果第一行没有写super(),编译器会自动插入.但是如果父类没有不带参数的构造函数,或这个函数被私有化了(用private修饰).此时你必须加入对父类的实例化构造.而this就没有这个要求,因为它本身就进行实例化的构造.而在方法中super和this使用的方法就差不多了.只不过super要考虑是否能访问其父类的资源.
Public:不同包、同一包、类内都可用
Private：类内
Protected:不同包的子类、同一包、类内都可用
不写时:同一包内、类内
*****
****
***
**
*
代码如下：
publicclassPrint{
publicstaticvoidmain(String[]args){
for(inti=0;i<5;i++){
for(intj=5;j>i;j--){
System.out.print("*");
}
System.out.println();
java事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件。一旦事件被接受，监听器将处理这个事件，然后返回。
垃圾回收机制垃圾收集是将分配给对象但不再使用的内存回收或释放的过程。如果一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收
用break;return方法。
序列化:
处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：
将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implementsSerializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Objectobj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
可以。如果这个类的修饰符是public，其类名与文件名必须相同。
排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码。
方法的
重写Override，子类覆盖父类的方法，将子类传与父类的引用调用的还是子类的方法。
重载Overloading一个类多个方法，名称相同，参数个数类型不同。
两者都是Java多态性的不同表现。
Overloaded的方法是可以改变返回值的类型。
1，publicclassCtest()
{
Publicstaticvoidmain()
System.out.prinln(8+8+”88”+8+8);
168888
属性常量
方法不可以overridding
类不可以继承
答:父类：
packagetest;
publicclassFatherClass
publicFatherClass()
System.out.println("FatherClassCreate");
子类:
importtest.FatherClass;
publicclassChildClassextendsFatherClass
publicChildClass()
System.out.println("ChildClassCreate");
publicstaticvoidmain(String[]args)
FatherClassfc=newFatherClass();
ChildClasscc=newChildClass();
输出结果：
C:>javatest.ChildClass
FatherClassCreate
ChildClassCreate
答：示例代码如下：
publicclassOuterClass
privateclassInterClass
PublicInterlass()
System.out.println("InterClassCreate");
publicOuterClass()
InterClassic=newInterClass();
System.out.println("OuterClassCreate");
OuterClassoc=newOuterClass();
输出结果:
C:>javatest/OuterClass
InterClassCreate
OuterClassCreate
importjava.util.*;
classInsertSort
ArrayListal;
publicInsertSort(intnum,intmod)
al=newArrayList(num);
Randomrand=newRandom();
System.out.println("TheArrayListSortBefore:");
for(inti=0;i al.add(newInteger(Math.abs(rand.nextInt())%mod+1)); System.out.println("al["+i+"]="+al.get(i)); publicvoidSortIt() IntegertempInt; intMaxSize=1; for(inti=1;i tempInt=(Integer)al.remove(i); if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue()) al.add(MaxSize,tempInt); MaxSize++; System.out.println(al.toString()); }else{ for(intj=0;j if (((Integer)al.get(j)).intValue()>=tempInt.intValue()) al.add(j,tempInt); break; System.out.println("TheArrayListSortAfter:"); for(inti=0;i InsertSortis=newInsertSort(10,100); is.SortIt(); JAVA类实现序例化的方法是实现java.io.Serializable接口 Collection框架中实现比较要实现Comparable接口和Comparator接口 答：代码如下： publicstaticvoidsplit(Stringsource,intnum)throwsException intk=0; Stringtemp=""; for(inti=0;i byte[]b=(source.charAt(i)+"").getBytes(); k=k+b.length; if(k>num) temp=temp+source.charAt(i); System.out.println(temp); publicclassYesterdayCurrent{ publicvoidmain(String[]args){ Calendarcal=Calendar.getInstance(); cal.add(Calendar.DATE,-1); System.out.println(cal.getTime()); publicintgetNum(){ inti=-1; try{ Stringstri=""; BufferedReaderin=newBufferedReader(newFileReader(f)); while((stri=in.readLine())!=null){ i=Integer.parseInt(stri.trim()); in.close(); }catch(Exceptione){ e.printStackTrace(); returni; publicvoidsetNum(){ inti=getNum(); i++; PrintWriterout=newPrintWriter(newBufferedWriter(newFileWriter(f,false))); out.write(String.valueOf(i));//可能是编码的原因，如果直接写入int的话，将出现java编码和windows编码的混乱，因此此处写入的是String out.close(); classA{ static{ System.out.print("1"); publicA(){ System.out.print("2"); classBextendsA{ System.out.print("a"); publicB(){ System.out.print("b"); publicclassHello{ publicstaticvoidmain(String[]ars){ Aab=newB();//执行到此处,结果:1a2b ab=newB();//执行到此处,结果:1a2b2b 注:类的static代码段,可以看作是类首次加载(被虚拟机加载)执行的代码,而对于类的加载,首先要执行其基类的构造,再执行其本身的构造 (1)接口可以被多重implements,抽象类只能被单一extends (2)接口只有定义,抽象类可以有定义和实现 (3)接口的字段定义默认为:publicstaticfinal,抽象类字段默认是"friendly"(本包可见) 当功能需要累积时用抽象类，不需要累积时用接口。 通过类(Class对象)，可以得出当前类的fields、method、construtor、interface、superClass、modified等，同是可以通过类实例化一个实例、设置属性、唤醒方法。Spring中一切都是返射、struts、hibernate都是通过类的返射进行开发的。 ujava.lang.Class ujava.lang.refrection.Method ujava.lang.refrection.Field ujava.lang.refrection.Constructor ujava.lang.refrection.Modifier ujava.lang.refrection.Interface 对象.getClass() 类.class或Integer.type(int)Integer.class(java.lang.Integer) Class.forName(); 产生一个Class数组，说明方法的参数 通过Class对象及方法参数得到Method 通过method.invoke(实例,参数值数组)唤醒方法 Integer.parseInt(“1234”) Double.parseDouble(“123.2”) 1+”” 1.0+”” doubled=1256.22d; d=d/100; System.out.println(Math.round(d)*100); Calendarc=Calendar.getInstance(); c.set(Calendar.YEAR,2004); c.set(Calendar.MONTH,0); c.set(Calendar.DAY_OF_MONTH,31); System.out.println(c.get(Calendar.YEAR)+""+(c.get(Calendar.MONTH)+1)+""+c.get(Calendar.DAY_OF_MONTH)); Java.util.Datedat=newDate(); longnow=dat.getTime(); 当前日期加一天，若当前日期与结果的月份不相同，就是最后一天。 取下一个月的第一天，下一个月的第一天-1 c.set(Calendar.DAY_OF_MONTH,30); Calendarc1=(Calendar)c.clone(); c.add(Calendar.DAY_OF_MONTH,1); if(c.get(Calendar.MONTH)!=c1.get(Calendar.MONTH)) System.out.println("是最后一天"); else System.out.println("不是取后一天"); Importjava.text.SimpleDateFormat; SimpleDateFormatsdf=newSimpleDateFormat("yyyy-MM-ddhh:mm:ss"); Datedat=newDate(); //把日期转化为字符串 Stringstr=sdf.format(dat); System.out.println(str); //将字符串转化为日期 Java.util.Dated1=sdf.parse(“yyyy-mm-dd”); Stringa=newString("中".getBytes("gb2312"),"iso-8859-1"); Stringa=newString("中".getBytes("iso-8859-1")); New了一个,”XYZ”本来又是一个 两个 报错，应当是floatf=3.4f 如果是floatf=3(整数)正确 常用的类：BufferedReaderBufferedWriterFileReaderFileWirterStringInteger 常用的包：java.langjava.awtjava.iojava.utiljava.sqljavax.xmljavax.sevletjavax.ejb.java.netjavax.faces 常用的接口：ListMapDocumentNodeListEjbObjectEjbHomeSessionBeanEntityBean 会。如：inti,i2;return(i-i2);//wheni为足够大的正数,i2为足够大的负数。结果会造成溢位，导致错误。 静态的多态:方法名相同，参数个数或类型不相同。(overloading) 动态的多态: 子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法 实现接口的实例传与接口的引用调用的实现类的方法。 动态内存 存放类实例 静态内存 类本身 垃圾收集主要针对的是动态内存，一般当内存不够用时会进行垃圾收集。 或通过System.gc()手动收集，但不保证一定执行。 statici=10;//常量 classAa;a.i=10;//可变 静态方法可以调用静态变量。 实现方法可以调用静态变量、实例变量 不可以,如果其中包含对象的method()；不能保证对象初始化. Clone有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。 Try:执行部分，产生异常 Catch:捕捉异常 Finally:不管有没有异常都执行 Throw:抛出一个异常 自定义异常要继承于Exception或Exception的子类 //相邻两个数比较，将最小或最大的放到后面，最后面数的不参与比较 publicclassBubbleSort{ privatestaticintal[]=newint[10]; publicBubbleSort(){ al[0]=2; al[1]=3; al[2]=23; al[3]=45; al[4]=1; al[5]=67; al[6]=23; al[7]=80; al[8]=35; al[9]=72; BubbleSortbs=newBubbleSort(); System.out.println("排序前："); display(al); for(inti=0;i for(intj=0;j if(al[j]>al[j+1]){ swap(j,j+1); System.out.println("排序后："); privatestaticvoiddisplay(int[]al2){ for(inti=0;i System.out.print(al2[i]+""); privatestaticvoidswap(inti,intj){ inttemp=al[i]; al[i]=al[j]; al[j]=temp; String:长度给定不可变，当多个字符串联合时要先转为StringBuffer，再联合，速度慢。 StringBuffer:长度可变,可以将多个字符串值直接联合，效率高 publicclassStack{ int[]data; intmaxSize; inttop; publicStack(intmaxSize){ this.maxSize=maxSize; data=newint[maxSize]; top=-1; /** *依次加入数据 *@paramdata要加入的数据 *@return添加是否成功 */ publicbooleanpush(intdata){ if(top+1==maxSize){ System.out.println("栈已满!"); returnfalse; this.data[++top]=data; returntrue; *从栈中取出数据 *@return取出的数据 publicintpop()throwsException{ if(top==-1){ thrownewException("栈已空!"); returnthis.data[top--]; publicstaticvoidmain(String[]args)throwsException{ Stackstack=newStack(1000); stack.push(1); stack.push(2); stack.push(3); stack.push(4); stack.push(5); while(stack.top>=0) System.out.println(stack.pop()); 数据的传送增、删、改、查、constainsAll，可以存放不同类型的对象。 集合List的遍历方法有： Iterator: Enumeration For Get set Collection的通用方法有： Iterator() Add() Clear(); remove() ArrayListVector:以数组的方式存储，增、删慢，查、改快 ArrayList:线程不安全，速度快 Vector:线程安全，速度慢(synchoronized) LikedList:以单链表的方式存储，增、删快，查、改慢 HashMap与Hashtable都实现的Map接口,HashTable线程安全，HashMap线程不安全。 Collection是集合的根接口，其下有set及list Collections是集合的算法。 在比较时先调用hashCode方法，如果不相同，证明不相等。 如果相同，再调用equals方法，如果equals方法相同，证明相等，不相同，证明不相等。 ==:主要用在基本数据类型及引用 Equals:主要是对象或对象引用的比较。 集合中是否包含某一个元素用contains来判断。 List,set继承于Collection Map没有继承于Collection，其相对是独立的。 属于Collection类型的对象，可以通过构造函数将一个集合构造成另外一个集合。 1.抽象： 找共性，将共有的属性、方法放到父类中 2.继承： 子类继承于父类，具有父类的所有属性与方法，可以重用，也可以覆盖。 3.封装： 一个类包括多个属性及方法。 4.多态性： 动态: 静态: 基本数据类型包括byte、int、char、long、float、double、boolean和short。 java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类 Int是基本数据类型，不是对象，占一个内存空间，没有方法。与其同类的有long,char,doble Integer是封装类，具有方法及属性。与其同类的有Long,Double.Float 运行时异常:javaJVM抛出的异常，代码中不用处理。 &:与:左边若为false右边还执行。 &&:短路与,左边若为false右边不执行。 finally是异常处理语句结构的一部分，表示总是执行。 finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。 算符可以用来决定某对象的类是否实现了接口。 栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。 堆是栈的一个组成元素 assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。 GC是垃圾收集的意思（GabageCollection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。 shorts1=1;s1=s1+1;（s1+1运算结果是int型，需要强制转换类型）shorts1=1;s1+=1;（可以正确编译） Math.round(11.5)==12Math.round(-11.5)==-11round方法返回与参数最接近的长整数，参数加1/2后求其floor. java中的保留字，现在没有在java中使用。 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 一般异常: IOException FileNotFoundException SqlException 接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。任何抽象类都是实际类Object的子类。 都不能 数组没有length()这个方法,有length这个属性 String有length()这个方法. 构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。 String类是final类故不可以继承。 switch（expr1）中，expr1是一个整数表达式。因此传递给switch和case语句的参数应该是int、short、char或者byte。long,string都不能作用于swtich。 会执行，在return前执行。 2<<3 不对，有相同的hashcode。 是引用传递 基本数据类型:值 对象:引用 Cookie Session Hidden url重写 Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。 一般Singleton模式通常有几种种形式: 第一种形式:定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。 publicclassSingleton{ privateSingleton(){} //在自己内部定义自己一个实例，是不是很奇怪？ //注意这是private只供内部调用 privatestaticSingletoninstance=newSingleton(); //这里提供了一个供外部访问本class的静态方法，可以直接访问 publicstaticSingletongetInstance(){ returninstance; 第二种形式: privatestaticSingletoninstance=null; publicstaticsynchronizedSingletongetInstance(){ //这个方法比上面有所改进，不用每次都进行生成对象，只是第一次 //使用时生成实例，提高了效率！ if(instance==null) instance＝newSingleton(); returninstance;} 其他形式: 定义一个类，它的构造函数为private的，所有方法为static的。 一般认为第一种形式要更加安全些 原理 有错直接转到异常处理部分或向上抛出。 应用: 优点: 程序员不用管内存，jvm自动完成，开发方便。运行优先非常低，程序无法清楚实例什么时候被消毁。 JVM中类的装载是由ClassLoader和它的子类来实现的,JavaClassLoader是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。 能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的 字节流，字符流。字节流继承于InputStreamOutputStream，字符流继承于ReaderWriter。在java.io包中还有许多其他的流，低层流与调层流，高层流主要是为了提高性能和使用方便。 启动一个线程是调用start()方法，启动线程并调用run方法。 线程是进程内的并发，没有自已内存空间，共享进程的，线程间的通信成本较低。 Java中的线程有四种状态分别是：运行、就绪、挂起、结束。 ExtendsThread ImplementsRunnable 同步 Publicsynchronizedaa() Publicvoidcc(objectaa) synchronized(aa) 用synchoronized修饰同步方法。 答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口 同步的实现方面有两种，分别是synchronized,wait与notify 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。 CollectionMap ListsetHashMap ArrayListlinkedListHashSetTreeSet publicclassTestThread privateintj; publicsynchronizedvoidinc() j++; System.out.println(Thread.currentThread().getName()+"-inc:"+j); publicsynchronizedvoiddec() j--; System.out.println(Thread.currentThread().getName()+"-dec:"+j); TestThreadt=newTestThread(); for(inti=0;i<2;i++) Threadinc=newThread(newInc(t)); Threaddec=newThread(newDec(t)); inc.start(); dec.start(); classIncimplementsRunnable privateTestThreadobj; publicInc(TestThreadobj) this.obj=obj; publicvoidrun() //for(inti=0;i<100;i++) //{ this.obj.inc(); //} classDecimplementsRunnable publicDec(TestThreadobj) this.obj.dec(); 同步：上一段代码没的完成，下一段必须等到上一段代码完成后才可以执行。如买票排队 异步：上一段代码没的完成，下一段不必等到上一段代码完成就可以执行。如手机发送短信。 如只其它方法是同步方法，不可以进入。如果不是可以进入。 在java使用流的机制进行数据的传送，从文件到内存是输入流，从内存到文件是输出流，输入流可以通过read读取，输出流以write或print写入，对于流可以是分为高层流和低层流，低层以一个字节或字符为单位进行处理，高层流以一批数据为单位进行处理。 FileInputStream（System.in）至InputSteamReader至BufferReader OutputSteam(System.out)至printStream FileReader至BufferedReader FileWriter至PrintWriter或bufferWriter 分类: 字节(二进制) FileInputStream(低层输入流) FileOutputStream(低层输出流) PrintStream(高层流)System.out.println() 字符(一个char) FileReader FileWriter importjava.io.FileWriter; importjava.io.InputStream; importjava.io.BufferedWriter; importjava.io.InputStreamReader; importjava.io.BufferedReader; importjava.io.FileReader; publicclassUntitled1{ publicstaticvoidwriteFileChar()throwsException{ FileWriterf=newFileWriter("c:\\aa.txt"); InputStreamis=System.in; intc=is.read(); while(((char)c)!='x'){ f.write(c); c=is.read(); f.close(); is.close(); publicstaticvoidwriteFileString()throwsException{ BufferedWriterbwr=newBufferedWriter(f); BufferedReaderbf=newBufferedReader(newInputStreamReader(System.in)); Stringc=bf.readLine(); while(!c.equals("stop")){ bwr.write(c+"\r\n"); c=bf.readLine(); bwr.close(); bf.close(); publicstaticvoidreadFileChar()throwsException{ FileReaderf=newFileReader("c:\\aa.txt"); intc=f.read(); while(c!=-1){ System.out.print((char)c); c=f.read(); publicstaticvoidreadFileString()throwsException{ BufferedReaderbf=newBufferedReader(newFileReader("c:\\aa.txt")); while(c!=null) System.out.println(c); readFileString(); Importjava.io.File; Filef=newFile("C:\\"); File[]f1=f.listFiles(); for(inti=0;i if(f1[i].isDirectory()) System.out.println("dirctoryis"+f1[i].getName()); System.out.println("fileis"+f1[i].getName()); 如何列出某个目录下的所有子目录 publicstaticvoidmain(String[]args)throwsException getFile(newFile("C:\\entityBean"),"\t"); publicstaticvoidgetFile(Filef,Stringsem)throwsException System.out.println(sem+f.getName()); Filefl[]=f.listFiles(); if(fl.length>=1) for(inti=0;i if(fl[i].isDirectory()) getFile(fl[i],sem+"\t"); 判断一个文件或目录是否存在 Filef=newFile("C:\\entityBean"); if(f.exists()) System.out.println("exist"); System.out.println("notexist"); Socket publicclassServerSocket_1 throwsException ServerSocketss=newServerSocket(4001); Sockets=ss.accept(); BufferedReaderbr=newBufferedReader(newInputStreamReader(s. getInputStream())); PrintStreamps=newPrintStream(s.getOutputStream()); Stringtemp=br.readLine(); while(true) System.out.println("客户端:"+temp); ps.println(temp); if(temp.equals("stop")) temp=br.readLine(); br.close(); ps.close(); ss.close(); publicclassClientSocket Sockets=newSocket("localhost",4001); BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in)); BufferedReaderbr_server=newBufferedReader(newInputStreamReader(s. temp=br_server.readLine(); System.out.println("服务器的信息:"+temp); s.close(); br_server.close(); 答：CollectionFrameWork如下： Collection ├List │├LinkedList │├ArrayList │└Vector │└Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements） Map提供key到value的映射 HashTable中的put,get,remove Con.setAutoCommit(false) Con.commit(); Con.rollback(); preparedStatement,callableStatement,statement,Connection,ResultSet statement用于执行静态SQL语句并返回它所生成结果的对象，在执行时确定sql。 PreparedStatement表示预编译的SQL语句的对象。SQL语句被预编译并且存储在PreparedStatement对象中。然后可以使用此对象高效地多次执行该语句，可以传参数，在得到PreparedStatement对象时确定sql. CallableStatement用于执行SQL存储过程的接口。如果有输出参数要注册说明是输出参数。 1连接Oracle数据库 Class.forName(“oracle.jdbc.driver.OracleDriver”); Connectioncon=DriverManager.openConnection(“jdbc:oracle:thin:@localhost:1521:DataBase”,”UserName”,”Password”) 1.利用JDBC检索出表中的数据 Class.forName(“”); Connectioncon=DriverManager.openConnection(“”,””,””) preparedStatmentps=Con.preparedStatment(“select*from［table］”); ResultSetrs=ps.executeQuery(); While(rs.next) Rs.getString(1)或rs.getString(“字段名”) DriverManager DriverManager.openConnection(“”,”sa”,””) Connection PreparedStatement(Statement) ResultSetrs=executeQuery()dql While(rs.next()) executeUpdate()dmlddl CallableStatementc=con.prepareCall("{callgetCustomerName(,)}"); c.setString(1,"1"); c.registerOutParameter(2,java.sql.Types.VARCHAR); c.execute(); c.getString(2); Class.forName("oracle.jdbc.driver.OracleDriver"); Connectioncon=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:accp","system","system"); 注册一个数据库驱动，将驱动加载到当前的JVM中。 createorreplacepackagemyPack is typec_typeisrefcursor; proceduregetPage(v_sqlvarchar2,pageSizenumber,pageIndexnumber,coutc_type); end; createorreplacepackagebodymyPack proceduregetPage(v_sqlvarchar2,pageSizenumber,pageIndexnumber,coutc_type) pageTotalint:=0; pageFirstRowint:=0; pageLastRowint:=0; rowTotalint:=0; begin executeimmediate'selectcount(*)from('||v_sql||')'intorowTotal; pageTotal:=ceil(rowTotal/pageSize); if(pageIndex<1)then raise_application_error(-20001,'页数不能小于1'); endif; if(pageIndex>pageTotal)then raise_application_error(-20001,'页数太大，不能读取'); pageFirstRow:=(pageIndex-1)*pageIndex+1; pageLastRow:=pageFirstRow+pageSize; opencfor'select*from'||v_sql||'whererownum<'|| pageLastRow||'minusselect*from'||v_sql ||'whererownum<'||pageFirstRow; JAVA_HOME=JDK的根目录 CATALINA_HOME=tomcat的根目录 CATALINA-HOME\conf\server.xml:可以配置tomcat的端口，可以配置tomcat中下连接池。 CATALINA-HOME\common\lib:存放公用的类包 在Myeclipse中如何配置tomcat 在eclipse中,选择windows->preference->MyEclipse->ApplicationServer->Tomcat 选择Tomcat的安装目录，并选择TomCat所需的jdk，选择enable,确定即可。 jsp:include:在运行时调用另一个页面，变量是可以重复的。 forward:转发，在下一个页面中,request保留上一个页面中的request的所有值 redirect:跳转，不传递request对象。 Servlet GenericServlet HttpServlet 自定义 extendsHttpServlet并覆盖doPost或doGet方法 在web.xml中进行部署 Init 多次执行doGet或doPost destroy 对 脚本 <%%><%=%><%!%><%----%> 指令 <%@pagecontentType=”text/html;charset=utf-8”language=”java”import=””%> <%@includefile=””%> <%@tagliburi=””prefix=””%> 动作: Requestrequest表示HttpServletRequest对象。取客户端表单域信息及cookie,header,和session responseresponse表示HttpServletResponse对象，对客户端的响应返回文本、写cookies。 outout向客户端打印html文本. pageContext:当前jsp页面的上下文环境，可以得到session、request、application等内置对象，在自定义标签中使用的很多。 applicationapplicaton表示一个javax.servle.ServletContext对象。存放容器级的变量。 configconfig表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。 pagepage表示从该页面产生的一个servlet实例 exception:异常，当iserrorpage=true 页面需要保存以下参数：(数据库的分页及比较) 总行数：根据sql语句得到总行数 每页显示行数：设定值 当前页数：请求参数 页面根据当前页数和每页行数计算出当前页第一行行数，定位结果集到此行，对结果集取出每页显示行数的行即可。 数据库: Sqlserver: SELECTTOP页大小* FROMTestTable WHERE(IDNOTIN (SELECTTOP页大小*(页数-1)id FROM表 ORDERBYid)) ORDERBYID --pageSize=5页大小 --pageIndex=2所要的页 --如果有主键可以，没以及键不行 selecttop5* fromaawherea1notin (selecttop5a1fromaaorderbya1) orderbya1; oracle: select*from'||v_sql||'whererownum<'|| 先取出数据中的所有信息封装到对象并保存在session中，转发到jsp页面做如下处理。 <% Listl=(List)session.getAttribute("as"); //一页显示多少行 intpageSize=3; //总页数 intpageCount=0; intcurrentPage=1; if(l!=null&&l.size()>0) pageCount=(l.size()/pageSize)+(l.size()%pageSize==00:1); if(request.getParameter("page")!=null) currentPage=Integer.parseInt(request.getParameter("page")); if(currentPage<1) currentPage=1; if(currentPage>pageCount) currentPage=pageCount; for(inti=(currentPage-1)*pageSize;i<(currentPage-1)*pageSize+pageSize;i++) if(i>=l.size()) Aaaa=(Aa)l.get(i); %> if(currentPage!=1) if(currentPage!=pageCount) <@includefile>:在将jsp生成servlet类前将两个文件和在一起，生成一个java类，一起运行的。所以是一家子，当中的变量名不能重名。 转发:保留上次的request actionMapping.findForWard(“”); pageContext.forward(); request.getRequestDispacher(“a.jsp”).forward(request,response) 跳转:不保留上次的request Response.setRedirect(“”) Jsp主要在于页面的显示动态生成页面，可以与html标记一起使用，其还是要生成为一个servlet。 Servlet：主要是控制的处理，如调用业务层，跳转不同的jsp页面。 Mvc: Jsp:v Servlet:c Request.getparameter(“”) <%=application.getRealPath("aa.jsp")%> Cookie:主要用在保存客户端，其值在客户端与服务端之间传送，不安全，存储的数据量有限。 Session:保存在服务端，每一个session在服务端有一个sessionID作一个标识。存储的数据量大，安全性高。占用服务端的内存资源。 正常页面中 %@pageerropage=”error.jsp”% 错误页面 <%@pageiserrorpage=”true”%> 有一内置对象:exception New类(); 做一个标记处理类extendsTagSupport 通过tld说明标记处理的类的前缀及后缀 在web.xml中说明tld文件 在jsp页面是引用tld<%@tagliburi=””prefix=””%> ServletContext：容器，放置全局变量 setAtribute() getAttribute() ServletConfig：一个servlet的配置 getInitParameter(”名称”) HttpServletRequest：封装的所有的请求 getParameterValue(”名称”) getParameterValues(”称”) getSession(); getAttribute(”名称”); getRequestDispatch(”a.jsp”).forward(request,response) HttpServletResponse：响应 getOut(); sendRedirect(””) HttpSession：一个用户多个页面共享同一变量 setAttribute(””,””) Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。 与cgi的区别在于servlet处理服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。 Jsp页面中的form标签里的method属性为get时调用doGet()，为post时调用doPost()。 在doGet及doPost方法前加入synchoronized JSP: <%@pageisThreadSafe="true"%> setAttribute(Stringname,Object)：设置名字为name的request的参数值 getAttribute(Stringname)：返回由name指定的属性值 getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例 getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组 getCharacterEncoding()：返回请求中的字符编码方式 getContentLength()：返回请求的Body的长度 实例 getInputStream()：返回请求的输入流，用于获得请求中的数据 getMethod()：获得客户端向服务器端传送数据的方法 getParameter(Stringname)：获得客户端传送给服务器端的有name指定的参数值 getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例 getParameterValues(Stringname)：获得有name指定的参数的所有值 getProtocol()：获取客户端向服务器端传送数据所依据的协议名称 getQueryString()：获得查询字符串 getRequestURI()：获取发出请求字符串的客户端地址 getRemoteAddr()：获取客户端的IP地址 getRemoteHost()：获取客户端的名字 getServerName()：获取服务器的名字 getServletPath()：获取客户端所请求的脚本文件的路径 getServerPort()：获取服务器的端口号 removeAttribute(Stringname)：删除请求中的一个属性 PublicStringtranslate(Stringstr){ StringtempStr=""; tempStr=newString(str.getBytes("ISO-8859-1"),"GBK"); tempStr=tempStr.trim(); catch(Exceptione){ System.err.println(e.getMessage()); returntempStr; publicvoidinit(ServletConfigconfig) publicServletConfiggetServletConfig() publicStringgetServletInfo() publicvoidservice(ServletRequestrequest,ServletResponseresponse) publicvoiddestroy() Db-browers加入配置连接 新建工程 加入hibernate环境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置 *.hbm.xml:具体的o/rmapping说明 Configuration SessionFactory Session如下方法 Save load Update Delete Queryq=CreateQuery(“fromCustomerwherecustomerName=:customerName”) beginTransaction close Transaction Commit() one-to-many inverse:主控方，外键的关系有谁控制 inverse=false是主控方，外键是由它控制的 inverse=true是被控方，外键与它没关系 要想实现主控方的控制必须将被控方作为主控方的属性 cascade:级联 主表增从表增 主表修从表修 主表删从表删 lazy:延迟 lazy=false：一下将所有的内容取出，不延时(常用) lazy=true：取出部分内容，其余内容动态去取 通过get可以取出对方的所有内容 主控方在many这边，不及连删除 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行 产生时不需要session DetachedCriteriadc=DetachedCriteria.forClass(Customer.class) Criteriac=Dc.getExecutableCriteria(session) 1个或多个属性查询: Queryquery=session.createQuery(”selectcustomername,customeridfromCustomer”) Listl=query.list(); For(inti=0;i Obejct[]object=(Object[])l.get(i); Object[0]object[1] 分组:"selectcount(*),productnamefromProductgroupbyproductnameorderbyproductname" 取值与属性一样 配置的查询,在*.hbm.xml中 fromProductwhereproductid=:productid ]]> Queryquery=session.getNamedQuery(sql); 联接1 "fromCustomerascustomerjoinfetchcustomer.buySet"：将多的放到buySet属性中，得出的结是Customer有一个，Buy有多个 联接2 "fromCustomerascustomerjoincustomer.buySet":得出的对象,customer与buy是1对1 子查询: "fromCustomerascustomerwhere(selectcount(*)fromcustomer.buySet)>1" 1、两个表，子类重复父类的属性。 2、一个表，子类父类共用一个表 3、两个表，子类引用父类的主键，享用公共的字段或属性。 批量删除 Queryquery=session.createQuery("update"或"delete"); query.executeUpdate(); 6.1、在tomcat-5.0\conf\server.xml中前面加入如下内容 6.2、将sql-server包拷贝到C:\tomcat-5\common\lib 6.3、jdbc测试代码 ContextinitCtx=newInitialContext(); ContextenvCtx=(Context)initCtx.lookup("java:comp/env"); ds=(DataSource)envCtx.lookup("jdbc/sa"); Connectionconn=ds.getConnection(); 6.4、hibernate通过连接池实现连接 自由(transient) 与session无关 持久(persistent) 由session来管理 在持久状态中通过get方法取出对方 游离(detached) 被session抛弃 用最新版本的hibernate 制定合理的缓存策略 采用合理的session管理机制 尽量使用延迟加载 many 大文本、大文件 设定合理的批处理参数(batch-size) 如有可能，选用uuid作为主键生成器 如有可能，选用基于version的乐观锁替代悲观锁 开发过程中，打开hibernate的SQl日志输出(hibernate.show_sql=true)，通过观察hibernate生成的sql语句进一步了解其实现原理，从而指事实上更好的实现策略。 只对开发团队提供几条SelectSQL（或存储过程）以获取所需数据，具体的表结构不予公开。 开发规范中要求，所有牵涉到业务逻辑部分的数据库操作，必须在数据库层由存储过程实现 系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句 （或存储过程）才能达到系统性能设计指标。 jdbc:手动 手动写sql delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。 select:返回的是一个resultset，要从ResultSet中一行一行、一个字段一个字段的取出，然后封装到一个对象中，不直接返回一个对象。 ibatis的特点:半自动化 sql要手动写 delete、insert、update:直接传入一个对象 select:直接返回一个对象 hibernate:全自动 不写sql,自动封装 sqlmapBuy.xml:具体的o/rmapping映射(*.hbm.xml) 四大标记: select update delete insert procedure SqlMapClientBuilder:加载配置文件，返回一个会话。 SqlMapClient:具体的会话 Listlist=queryForList("标签名",object); Objectobj=queryForObject("标签名",object); delete("标签名",object) update("标签名",object) insert("标签名",object) 工程的使用: 将ibatisfactory拷贝到工程目录下 将ms的3个包及ibatis的三个包拷贝到/WEB-INF/lib下 修改ibatisfactory中的abatorConfig.xml文件 进入ibatisfactory目录运行java-jarabator.jarabatorConfig.xmltrue 将sql标记、select、update、insert、delete的副本删除 spring&ibatis: dataSource sqlMapClient:SqlMapClientFactoryBean configLocation classpath:sqlMapClient.xml /WEB-INF/sqlMapClient.xml transactionManager:DataSourceTransactionManager customerDaoextendsSqlMapClientDaoSupport sqlMapClient buyDao Facade customerDao abstractProxy:TransactionProxyFactoryBean transactionManager transactionAttributes facadeProxy target:faade 1、MVC 2、标签库 3、校验框架 4、国际化 5、tiles C ActionServlet RequestProcessor Action actionMapping(struts-config.xml) actionFormard V ActionForm Jsp M Dao Manager(facade) url->ActionServlet(process)->RequestProcessor(process)->实例化form->填充form值->进行校验->实例化action->调用execute 配置文件是struts-config.xml 让v与M强制解耦，提高可重用性（旅馆的服务员(C)） Action: 1)基本的 DispatchAction: 2)存在多个方法，根据页面传入的表单域的值调用不同的方法，表单域的名称在 LookupDispatchAction 3)多个按钮用同一个action的不同方法。实现getMap方法,说明每一个按钮在*.properties中的键名及键值，在struts-config.xml通过parameter说明按钮的名称，按钮的值对应*.properties的值，通过值找键名，通过键名找Map中的键名找到值就是相应的方法。 MappingDispatchAction:未知 forwordAction:直接跳转到不同页面不执行逻辑() n类所在的包:org.apache.struts.actions.ForwardAction Bean: Logic: Html: Struts-config.xml DataSourceds=(DataSource)this.getServlet().getServletContext().getAttribute("data"); Connectioncon=ds.getConnection(); 工程 建一个ActionForm 建一个Action 修改struts-config.xml文件 手动: publicclassmyFormextendsActionForm publicActionErrorsvalidate() actionErrors.add(ActionErrors.GLOBAL_MESSAGE,newActionMessage("properties中的键名")); struts-config.xml中修改action的标签validate=true input="错误页面" 如果validate方法中的ActionErrors不为空且size>0时 会回到input页面。 自动 publicclassmyFormextendsValidateForm 不能覆盖validate方法。 //publicvoidvalidate() 在struts-config.xml文件中加入插件 修改validation.xml中的内容 errors.required={0}isrequired. errors.minlength={0}cannotbelessthan{1}characters. input="/错误页面" 国际化:不用修改代码，就适用于不同的语言国家 本地化:如果要适应一个国家，要修改源代码 实现过程: 在struts-config.xml中用如下标签说明资源文件名，注意其只是文件名，没有语言_国家 在资源文件对应的目录struts中加入适应不同语言、国家的properties文件 ApplicationResources_zh_CN.properties中国 ApplicationResources_en_US.propertiesus 如果不是英语要转码 native2ascii-encodinggb2312源ApplicationResources_zh_CN.properties 在jsp页面中用 核心类 FacesServlet LiftCycleFacesContext 恢复视图->应用请求值->校验->更新模型->调用应用程序->呈现响应 UI组件、事件监听、显示、类型转换、验证 importjavax.faces.model.DataModel; importjavax.faces.model.ListDataModel; DataModel:代表一个表格，其可以从客户端传上来。 实例化: DataModeldm=newListDataModel(); 将一个list值放入到DataModel中. dm.setWrappedData(list) 将客户端当前行取出 (LogsVO)dm.getRowData() 对于多条的查询及增删改在模型中加入了如下属性: 模型的名称是bean，其下的属性是 DataModeldm:代表返有的行数据 VOvo:代表一行数据。 取一行: vo=(VO)dm.getRowData(); 通#{bean.vo.属性名}，如果修改对应信息自动修改。 增加一行: this.vo=newVO(); 通#{bean.vo.属性名}，显示肯定无值，但客户输入值提交后会将值勤写入 核心:f 校验 转化 选择框: html:h 选择控件: 表格: Spring:提供了通用的服务，ioc/diaop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术strutshibernateibatisejbremotespringJDBCspringMVC Oop：纵向的业务 拦截器:代理 装备(advice) 目标对象 关切点:条件 连接点:方法、属性 Setter Interface constructor BeanFactory：产生一个新的实例，可以实现单例模式 BeanWrapper：提供统一的get及set方法 ApplicationContext:提供框架的实现，包括BeanFactory的所有功能 beanFactory 国际化(getMesage) 资源管理:可以直接读取一个文件的内容(getResource) 加入web框架中(加入一个servlet或监听器) 事件处理 使用 applicationContext.getResource(“classpath:文件名”):在src根目录下，在类路径下 applicationContext.getResource(“classpath:/chap01/文件名”):以src根目录下的基准往下走。 applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。 在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。 org.springframework.web.context.ContextLoaderServlet 通过如下类得到ApplicationContext实例 WebApplicationContextUtils.getWebApplicationContext 事件 ExtendsApplicationEvent 监听器 ImplementsApplicationListener 事件源 ImplementsApplicationContextAware 在applicationContext.xml中配置事件源、监听器 先得到事件源，调用事件源的方法，通知监听器。 Ioc:程序在运行过程中，根据配置文件动态加载所依赖的配置类 在applicationContext.xml加载一个bean 在src目录下建多个properties文件 其命名格式是message_语言_国家。 页面中的中显示提示信息，键名取键值。 当给定国家，系统会自动加载对应的国家的properties信息。 测试: Spring:pojo Ejb:二个接口一个类,一堆配置文件 事务类型 Spring:jdbcjtahibernate Ejb:jta 成本 Spring:普通容器(tomcatjboss) Ejb:weblogicjboss 开发的周期: Spring远比ejb快. Spring的jdbc:节省代码，不管连接(Connection)，不管事务、不管异常、不管关闭(con.close()ps.close) JdbcTemplate(dataSource):增、删、改、查 TransactionTemplate(transactionManager):进行事务处理 代码管理的事务处理 TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用。 publicvoidmake() TransactionTemplatejtm=newTransactionTemplate(this.getTransactionManager()); jtm.execute(newmyClass1()); publicclassmyClass1implementsTransactionCallback publicObjectdoInTransaction(TransactionStatustrans) JdbcTemplatejdbc=newJdbcTemplate(dataSource); jdbc.execute("insertintocustomer(customerName)values('b')"); returnnull; 容器管理的事务处理 Datasouce userDao要注入 通过如下类实现 TransactionTemplate JdbcTemplate Proxy代理 Target:userDao：代理对象(目标对象) transactionAttributes(那些方法需要事务处理) transactionManager(事务处理服务) 不需要 在myeclipse中先加入spring环境再加入hibernate环境。 如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否正确 spring+hibernate的配置文件中的主要类有那些如何配置 sessionFactory:hibernate.cfg.xml userDao(extendsHibernateDaoSupport) sessionFactory facade proxy extendsHibernateDaoSupport，可以节省代码。 在struts-config.xml加入一个插件，通过它加载applicationContext.xml 在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxy u通过DelegateActionProxy进入一spring的环境。 在spring的applicationContext.xml加入 org.springframework.web.context.ContextLoaderListener 或： 通过如下方法取出applicationContext实例: ApplicationContextac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext); 将ear、jar、war拷到C:\bea\user_projects\domains\mydomain\applications目录 weblogic会自动发布 通过jbuilder将ear或jar或war部署到服务器上。 1、在many中的将外键字段属性删除 2、在删除many中的值时要将Collection转化为ArrayList， 并反向遍历ArrayList，先删除ArrayList中值，根据 ArrayList删除反回的对象转化为many的远程接口，通过 远程接口将many删除 Jndi：javanamingdirectoryinferface Rmi：remotemethodinvoke 两个接口一个类 extendsEJBHome 通过jndi得到home接口 create方法调用服务端的ejbCreate方法，在服务端产生一个EntityBean或SessionBean实例，向客户端返回一个远程接口。 通过find方法在从服务端找到一个EntityBean实例，向客户端返回一个远程接口。 extendsEJBObject 在客户端通过rmi调用远程服务端方法。 通过remove方法调用服务端的ejbRemove方法，将EnityBean删除 implementsSessionBean 在服务端实现真正的处理，实现核心业务 ejb-jar.xml：说明ejb的两个接口一个类的。 weblogic-ejb-jar.xml:说明ejb的JNDI名 weblogic-rdbms-ejb.xml:o-rMapping实现数据库表、字段与ejb属性对应的关系。 ejb2.0的开发 1、用jbuilder集成环境 2、可以用eclipse开发，用源代码注释说明，用ant执行xdoclet，xdoclet通 *@stateLess *@remote sessionBean stateless:方法间不保留(1..1) statefull:方法间保留(1..n) entityBean:持久化 cmp:增删改容器 bmp:增删改手动jdbc messagedriverbean 异处的消息处理 EJBHome(在不同的进程或主机间调用,即不同的jvm) EJBObjet EJBLocalHome(在同一进程，同是jvm中) EJBLocalObject 会话 url factory 通过jndi得到一个home实例 在客户端通过home实例在服务端产生一个sessionBean，客户端返回一个接口 客户端通过远程接口调用方法。 不存在 setSessionContext create--->ejbcreate 就绪:可以调用remove方法将sessionBean删除、可以调用服务端的任何方法。 ejbPassivate(从就绪到挂起) ejbActivate(从挂起到就绪) 挂起 如果超时自动删除 remove-->ejbremove 就绪 setEntityContext 入池 空房子，没加载数据 ejbActivate ejbPassivate remove-->ejbRemove 加载了数据库的数据 远程接口和Home接口不需要直接实现， 他们的实现代码是由服务器产生的， 程序运行中通过接口调用服务端产生的实例。 以StatefulSessionBean为例：其Cache大小决定了内存中可以同时存在的Bean实例的数量，根据MRU或NRU算法，实例在就绪和挂起状态之间迁移。 就绪:从文件到内存，调用ejbActivate方法 挂起:从内存到文件，调用ejbPassivate方法 EJB包括SessionBean、EntityBean、MessageDrivenBean，基于JNDI、RMI、JTA等技术实现. SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作。例如访问数据库、调用其他EJB组件. EntityBean被用来代表应用系统中用到的数据.对于客户机， SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑; EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体. SessionBean还可以再细分为StatefulSessionBean与StatelessSessionBean.这两种的SessionBean都可以将系统逻辑放在method之中执行，不同的是StatefulSessionBean可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的StatefulSessionBean的实体.StatelessSessionBean虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫StatelessSessionBean的时候，EJBContainer并不会找寻特定的StatelessSessionBean的实体来执行这个method.换言之，很可能数个使用者在执行某个StatelessSessionBean的methods时，会是同一个Bean的Instance在执行.从内存方面来看，StatefulSessionBean与StatelessSessionBean比较，StatefulSessionBean会消耗J2EEServer较多的内存，然而StatefulSessionBean的优势却在于他可以维持使用者的状态. sessionBean:主机重起消失 Stateless:不记忆 StateFull:一个用户多个操作可记忆 EntityBean:持久的数据库中 Cmp：容器通过o/rmapping实现数据的持久化，不写sql，实现方便，在速度慢。 Bmp:通过jdbc实现持久化,实现复杂，速度快 messageBean：提供异步处理。 EJB部署时需要三个文件： nEjb-jar.xml: u将二个接口一个类打包在一起，给EJB一个名称。 u说明当前的sessionBean的事务是由容器处理的。 u其在所有的服务器上是通用的。 nWeblogic-ejb-jar.xml： u将一个EJB名称，对应一个JNDI，在仅对weblogic服务器 nWeblogic-rdbms-jar.xml： u实现o/rmapping的说明,相当于*.hbm.xml sessionBean：是一个过程 entityBean：是持久化，代表的是一个业务实体，有主键。 Struts+sessionBean+entityBean EJB2.0加入的本地接口及本地home EJB1.1中只有远程接口及远程home JavaBean是可复用的组件，任何一个Java类都可以是一个Bean。但通常情况下，JavaBean是被容器所创建（如Tomcat）的，所以JavaBean具有如下特点: 一个无参的构造器 实现Serializable接口 私有属性 公有getset方法 EnterpriseJavaBean是一个分布式组件，其特点是 基于（RMI）技术的，可以被远程访问（跨进程、跨计算机）。 EJB必须被布署在Webspere、WebLogic容器中，不能直接访问ejb，而是通过容器访问ejb,容器是ejb访问的一个代理。 六个角色组成，分别是 EJB组件开发者（EnterpriseBeanProvider）:sun 应用组合者（ApplicationAssembler）真正的开发商 部署者（Deployer）: EJB服务器提供者（EJBServerProvider）:sunibm小机 EJB容器提供者（EJBContainerProvider）:weblogicjboss 系统管理员（SystemAdministrator）:维护员 三个对象是Remote（Local）接口、Home（LocalHome）接口，Bean类 主要提供 安全 事务管理 分布式 jts 代码产生 持续性管理 锁和并发行管理等服务。 1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)， 2.不能操作awt， 3.不能实现服务器功能， 4.不能对静态属生存取， 5.不能使用IO操作直接存取文件系统， 6.不能加载本地库.， 7.不能将this作为变量和返回， 8.不能循环调用。 答:一个EJB包括三个部分: RemoteInterface接口的代码 packageBeans; importjavax.ejb.EJBObject; importjava.rmi.RemoteException; publicinterfaceAddextendsEJBObject //somemethoddeclare HomeInterface接口的代码 importjaax.ejb.CreateException; importjavax.ejb.EJBHome; publicinterfaceAddHomeextendsEJBHome EJB类的代码 importjavax.ejb.SessionBean; importjavx.ejb.SessionContext; publicclassAddBeanImplementsSessionBean 缺省安装中使用DemoIdentity.jks和DemoTrust.jksKeyStore实现SSL，需要配置服务器使用EnableSSL，配置其端口，在产品模式下需要从CA获取私有密钥和数字证书，创建identity和trustkeystore，装载获得的密钥和数字证书。可以配置此SSL连接是单向还是双向的。 可以使用管理控制台，在它的Deployment中可以查看所有已发布的EJB WebService就是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 使用的技术: HTTP、XML、SOAP（简单对象访问协议）、WSDL 跨平台、跨语言、跨系统 SOAP协议: SOAP协议（SimpleObjectAccessProtocal,简单对象访问协议） 缺点： (1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。 实现J2EE规范中web协议的应用.该协议定义了web程序的运行时环境,包括:并发性,安全性,生命周期管理等等. 就是在tomcat、weblogic下运行jsp、servlet、struts BEAWebLogicServer，IBMWebSphereApplicationServer，Oracle9iApplicationServer，jBoss，Tomcat 在启动Weblogic的脚本中（位于所在Domian对应服务器目录下的startServerName），增加setMEM_ARGS=-Xms32m-Xmx200m，可以调整最小内存为32M，最大200M 可以在管理控制台中修改对应服务器的启动模式为开发或产品模式之一。或者修改服务的启动文件或者commenv文件，增加setPRODUCTION_MODE=true。 修改服务启动文件，增加WLS_USER和WLS_PW项。也可以在boot.properties文件中增加加密过的用户名和密码. 保存在此Domain的config.xml文件中，它是服务器的核心配置文件。 Domain目录服务器目录applications，将应用目录放在此目录下将可以作为应用访问，如果是Web应用，应用目录需要满足Web应用目录要求，jsp文件可以直接放在应用目录中，Javabean需要放在应用目录的WEB-INF目录的classes目录中，设置服务器的缺省应用将可以实现在浏览器上无需输入应用名。 CORBA标准是公共对象请求代理结构(CommonObjectRequestBrokerArchitecture)，由对象管理组织(ObjectManagementGroup，缩写为OMG)标准化。它的组成是接口定义语言(IDL),语言绑定(binding:也译为联编)和允许应用程序间互操作的协议。其目的为：用不同的程序设计语言书写在不同的进程中运行，为不同的操作系统开发。 persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来，而non－persistent方式的消息将被丢弃。 WebServiceWebService是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得WebService能与其他兼容的组件进行互操作。 JAXP(JavaAPIforXMLParsing)定义了在Java中使用DOM,SAX,XSLT的通用的接口。这样在你的程序中你只要使用这些通用的接口，当你需要改变具体的实现时候也不需要修改代码。 JAXM(JavaAPIforXMLMessaging)是为SOAP通信提供访问方法和传输机制的API。 SOAP即简单对象访问协议(SimpleObjectAccessProtocol)，它是用于交换XML编码信息的轻量级协议。 UDDI的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为WebService提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的WebService注册，以使别的企业能够发现的访问协议的实现标准。 Java中的23种设计模式： Factory（工厂模式），Builder（建造模式），FactoryMethod（工厂方法模式）， Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式）， Adapter（适配器模式），Bridge（桥梁模式），Composite（合成模式）， Decorator（装饰模式），Flyweight（享元模式），Proxy（代理模式）， Command（命令模式），Interpreter（解释器模式），Visitor（访问者模式）， Iterator（迭代子模式），Mediator（调停者模式），Memento（备忘录模式）， Observer（观察者模式），State（状态模式），Strategy（策略模式）， TemplateMethod（模板方法模式），ChainOfResponsibleity（责任链模式） 工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。 SessionFacadePattern：使用SessionBean访问EntityBean MessageFacadePattern：实现异步调用 EJBCommandPattern：使用CommandJavaBeans取代SessionBean，实现轻量级访问 DataTransferObjectFactory：通过DTOFactory简化EntityBean数据提供特性 GenericAttributeAccess：通过AttibuteAccess接口简化EntityBean数据提供特性 BusinessInterface：通过远程（本地）接口和Bean类实现相同接口规范业务逻辑一致性 ejb架构的设计好坏将直接影响系统的性能、可扩展性、可维护性、组件可重用性及开发效率。项目越复杂，项目队伍越庞大则越能体现良好设计的重要性。 (1)JNDI:JavaNaming&DirectoryInterface,JAVA命名目录服务.主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能. (2)JMS：JavaMessageService,JAVA消息服务.主要实现各个应用程序之间的通讯.包括点对点和广播. (3)JTA：JavaTransactionAPI,JAVA事务服务.提供各种分布式事务服务.应用程序只需调用其提供的接口即可. (4)JAF:JavaActionFrameWork,JAVA安全认证框架.提供一些安全控制方面的框架.让开发者通过各种部署和自定义实现自己的个性安全控制策略. (5)RMI:RemoteMethodInterface,远程方法调用 J2ee：企业级，主要的applicationserver的web及应用服务 J2se：标准版,没有applicationserver J2me：手机、pda的嵌入式开发 J2EE是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterprieseapplicationmodel).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietntier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。 J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。 J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。 DOM：文档对象模型(documentobjectmodel) SAX packagess; importjavax.xml.parsers.DocumentBuilderFactory; importjavax.xml.parsers.DocumentBuilder; importorg.w3c.dom.Document; importorg.w3c.dom.Element; importorg.w3c.dom.Node; importorg.w3c.dom.Attr; importorg.w3c.dom.NodeList; importjavax.xml.transform.TransformerFactory; importjavax.xml.transform.Transformer; importjavax.xml.transform.dom.DOMSource; importjavax.xml.transform.stream.StreamResult; publicclassXmlParser xmlwriter(); publicstaticvoidxmlparser() DocumentBuilderFactoryxdf=DocumentBuilderFactory.newInstance(); DocumentBuilderdb=xdf.newDocumentBuilder(); Documentd=db.parse("C:\\A1\\customer.xml"); NodeListnl=d.getElementsByTagName("customer"); for(inti=0;i Elemente=(Element)nl.item(i); Attra=e.getAttributeNode("customerID"); System.out.println(a.getNodeValue()); NodeListnl1=e.getElementsByTagName("customerName"); System.out.println(nl1.item(0).getFirstChild().getNodeValue()); publicstaticvoidxmlwriter()throwsException DocumentBuilderFactorydbf=DocumentBuilderFactory.newInstance(); DocumentBuilderdb=dbf.newDocumentBuilder(); NodeListnl=d.getElementsByTagName("customerName"); System.out.println(e.getFirstChild().getNodeValue()); e.getFirstChild().setNodeValue(e.getFirstChild().getNodeValue()+"111111111111111"); TransformerFactorytff=TransformerFactory.newInstance(); Transformertf=tff.newTransformer(); tf.transform(newDOMSource(d),newStreamResult("c:\\aa.xml")); DocumentBuilderFactory DocumentBuilerdb Documentd=db.parse(“具体文件路径”); NodeListnl=d.getElementsByTagName(“节点名”) importorg.xml.sax.helpers.DefaultHandler; importorg.xml.sax.SAXException; importorg.xml.sax.Attributes; importjavax.xml.parsers.SAXParser; importjavax.xml.parsers.SAXParserFactory; publicclassSaxParserextendsDefaultHandler publicvoidcharacters(char[]ch,intstart,intlength) throwsSAXException Stringtemp=newString(ch,start,length); publicvoidendDocument() System.out.println("正在开始一个文档"); publicvoidendElement(StringnamespaceURI,StringlocalName,StringqName) System.out.println("结束元素"+qName); publicvoidstartDocument() System.out.println("开始文档"); publicvoidstartElement(StringnamespaceURI,StringlocalName, StringqName,Attributesatts) System.out.println("开始元素"+qName); SAXParserFactoryspf=SAXParserFactory.newInstance(); SAXParsersp=spf.newSAXParser(); sp.parse("C:\\A1\\customer.xml",newSaxParser()); DOM可以访问任何一个节点，要将所有资源全部加载，比较耗内存,可以修改。 SAX只能顺序读，不可随意访问，不可写，但速度快。 1.Dom中的核心接口有那些 Node TextNode Element Arr NodeList Document TransformerFactory Transformer通过如下方法进行处理 Transformer(DOMSource(Documentd),ResultStream(OutputStreamo)) 类文件是utf-8，xml文件头也应是utf-8如 a:两种形式dtdschema， b:本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)， c:有DOM,SAX,STAX等 DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问 SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问 STAX:StreamingAPIforXML(StAX) 静态图 用例图、类图、对象图、构件、部署, 动态图(行为图) 活动图,协作图,状态、时序 C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或SQLServer。客户端需要安装专用的客户端软件。 B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如NetscapeNavigator或InternetExplorer，服务器安装Oracle、Sybase、Informix或SQLServer等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过ＷebServer同数据库进行数据交互。 C/S与B/S区别： １．硬件环境不同: C/S一般建立在专用的网络上,小范围里的网络环境,局域网之间再通过专门服务器提供连接和数据交换服务. ２．对安全要求不同 C/S一般面向相对固定的用户群,对信息安全的控制能力很强.一般高度机密的信息系统采用C/S结构适宜.可以通过B/S发布部分可公开信息. B/S建立在广域网之上,对安全的控制能力相对弱,可能面向不可知的用户。 ３．对程序架构不同 C/S程序可以更加注重流程,可以对权限多层次校验,对系统运行速度可以较少考虑. B/S对安全以及访问速度的多重的考虑,建立在需要更加优化的基础之上.比C/S有更高的要求B/S结构的程序架构是发展的趋势,从MS的.Net系列的BizTalk2000Exchange2000等,全面支持网络的构件搭建的系统.SUN和IBM推的JavaBean构件技术等,使B/S更加成熟. ４．软件重用不同 C/S程序可以不可避免的整体性考虑,构件的重用性不如在B/S要求下的构件的重用性好. B/S对的多重结构,要求构件相对独立的功能.能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子 ５．系统维护不同 C/S程序由于整体性,必须整体考察,处理出现的问题以及系统升级.升级难.可能是再做一个全新的系统 B/S构件组成,方面构件个别的更换,实现系统的无缝升级.系统维护开销减到最小.用户从网上自己下载安装就可以实现升级. ６．处理问题不同 B/S建立在广域网上,面向不同的用户群,分散地域,这是C/S无法作到的.与操作系统平台关系最小. ７．用户接口不同 C/S多是建立的Window平台上,表现方法有限,对程序员普遍要求较高 B/S建立在浏览器上,有更加丰富和生动的表现方式与用户交流.并且大部分难度减低,减低开发成本. ８．信息流不同 C/S程序一般是典型的中央集权的机械式处理,交互性相对低 B/S信息流向可变化,B-BB-CB-G等信息、流向的变化,更像交易中心。 Uml：统一建模语言 工具:RationalRose 类图 继承 关联:(1..nn..1n..n) 依赖 实现接口 聚集 组成 类图的生命周期(开发的所有阶段都使用) 总体设计 详细设计 开发：以类图进行开发 测试 Use-case图 兓系 用例与用例 包含(inclu$E:必须调用 扩展(extends):可以调用也可以不调用 角色与角色的关系 泛化 用例与角色的关系: 用例与角色：通痥 角色与用例：调用 元素 用例 角色 粻统边界 USe-case图的生命周期 需求 整体设计 测试(单元测试、集成测试、系统测试用户验收) 时序 横坐标：寙象 作用 找类 找方法 验证系统的正确 生命周期 活动(流程图) 分析业务 构件图 作用:说明组件与组件之间的关系，依赖关系 部署 作用:说明安装软件的主机之间的关系，系统运行时的性能的主要影响者。a1 a2 <%=aa.getA1()%> <%=aa.getA2()%>