讀書筆記--Java核心技術--高級特徵

第一章--流與文件----------------------------------------------

流

讀寫字節

java.io.InputStream 1.0

1. abstractint read()//從數據中讀入一個字節，並返回該字節，在碰到流的結尾時返回-1
2. int read(byte[] b)//讀入一個字節數組，並返回實際讀入的字節數，或者在碰到流的結尾時返回-1
3. int read(byte[] b,int off,int len)//讀入一個字節數組。這個read方法返回實際讀入的字節數，或者在碰到流的結尾時返回-1
4. long skip(long n)//在輸入流中跳過n個字節，返回實際跳過的字節數（若是碰到流的結尾，則可能小於n）
5. int available()//返回在不阻塞的狀況下可用的字節數
6. void close()//關閉這個輸入流
7. void mark(int readLimit)//在輸入流的當前位置打一個標記，若是輸入流中已經讀入的字節多於readLimit個，則這個流容許忽略這個標記
8. void reset()//返回到最後的標記，隨後對read的調用將從新讀入這些字節
9. boolean markSupported()//若是這個流支持打標記，則返回true

java.io.OutputStream 1.0

1. abstractvoid write(int n)//寫出一個字節的數據
2. void write(byte[] b)
3. void write(byte[] b,int off,int len)//寫出全部字節或者某個範圍的字節到數組b中
4. void close()//清空並關閉輸出流
5. void flush()//清空輸出流，也就是將全部緩衝的數據發送到目的地

流家族

InputStream和OutputStream爲基礎

DataInputStream和DataOutputStream能夠以二進制格式讀寫全部的基本Java類型

ZipInputStream和ZipOutputStream能夠以常見的ZIP壓縮格式讀寫文件

 

4個附加接口：Closeable、Flushable、Readable和Appendable

java.io.Closeable 5.0

1. void close()//關閉這個Closeable，可能會拋出IOException

java.io.Flushable 5.0

1. void flush()//清空這個Flushable

java.lang.Readable 5.0

1. int read(CharBuffer cb)//嘗試讀入cb能夠持有的數量的char值。返回讀入的char值的數量

java.lang.Appendable 5.0

1. Appendable append(char c)
2. Appendable append(CharSequence cs)//向這個Appendable中追加給定的碼元或者給定的序列中的全部碼元，返回this

java.lang.CharSequence 1.4

1. char charAt(int index)//返回給定索引處的碼元
2. int length()//返回這個序列中的碼元的數量
3. CharSequence subSequence(int startIndex,int endIndex)//返回由存儲在startIndex到endIndex - 1處的全部碼元構成的CharSequence
4. String toString()//返回這個序列中全部碼元構成的字符串

組合流過濾器

1. FileInputStream fin =newFileInputStream("employee.dat");
2. DataInputStream din =newDataInputStream(fin);
3. double s = din.readDouble();

使用緩衝機制

1. DataInputStream din =newDataInputStream(
2. newBufferedInputStream(
3. newFileInputStream("employee.dat")));

從一個ZIP壓縮文件中讀入數字

1. ZipInputStream zin =newZipInputStream(newFileInputStream("employee.zip"));
2. DataInputStream din =newDataInputStream(zin);

java.io.FileInputStream 1.0

1. FileInputStream(String name)
2. FileInputStream(File file)//使用由name字符串或file對象指定路徑名的文件建立一個新的文件輸入流

java.io.FileOutputStream 1.0

1. FileOutputStream(String name)
2. FileOutputStream(String name,boolean append)
3. FileOutputStream(File file)
4. FileOutputStream(File file,boolean append) //使用由name字符串或file對象指定路徑名的文件建立一個新的文件輸出流

java.io.BufferedInputStream 1.0

1. BufferedInputStream(InputStream in)//建立一個帶緩衝區的流

java.io.BufferdOutputStream 1.0

1. BufferedOutputStream(OutputStream out)//建立一個帶緩衝區的流

java.io.PushbackInputStream 1.0

1. PushbackInputStream(InputStream in)
2. PushbackInputStream(InputStream in,int size)//構建一個能夠預覽一個字節或者具備指定尺寸的回推緩衝區的流
3. void unread(int b)//回推一個字節，它能夠在下次調用read時被再次獲取，b:要再次讀入的字節
    

文本輸入與輸出

1. InputStreamReader in =newInputStreamReader(newFileInputStream("input.txt"),"ISO8859_5");
2. 等價於
3. FileReader in =newFileReader("input.txt"):

以文本格式打印字符串和數字

1. PrintWriter out =newPrintWriter("employee.txt"):
2. 等同於
3. PrintWriter out =newPrintWriter(newFileWriter("employee.txt"));

System.out是PrintStream類，在內部採用與PrintWriter相同的方式將Unicode字符轉換成了默認的主機編碼方式。與PrintWriter不一樣的是，它們容許咱們用write(int)和write(byte[])方法輸出原生字節

 

java.io.PrintWriter 1.1

1. PrintWriter(Writer out)
2. PrintWriter(Writer out,boolean autoFlush)//建立一個新的PrintWriter
3. PrintWriter(OutputStream out)
4. PrintWriter(OutputStream out,boolean autoflush)//經過建立必需的中介OutputStreamWriter，從已有的OutputStream中建立一個新的PrintWriter
5. PrintWriter(String filename)
6. PrintWriter(File file)//經過建立必需的中介FileWriter，建立一個想給定的文件寫出的新的PrintWriter
7. void print(Object obj)//經過打印從toString產生的字符串來打印一個對象
8. void print(String s)//打印一個Unicode字符串
9. void println(String s)//打印一個字符串，後面緊跟一個行終止符
10. void print(char[] s)//打印給定的字符串中的全部Unicode字符
11. void print(char c)//打印一個Unicode字符
12. void print(int i)
13. void print(long l)
14. void print(float f)
15. void print(double d)
16. void print(boolean b)//以文本格式打印給定的值
17. void printf(String format,Object... args)//按照格式化字符串指定的方式打印給定的值
18. boolean checkError()//若是產生格式化或輸出錯誤，返回true

使用Scanner讀入文本輸入

Java SE 5.0以前，處理文本的惟一方式就是BufferedReader類，它擁有一個readLine方法，能夠讀入一行文本

1. BufferedReader in =newBufferedReader(newFileReader("employee.txt"));

 

字符集

1. //編碼Unicode字符串
2. Charset cset =Charset.forName("ISO-8859-1"):
3. String str =...;
4. ByteBuffer buffer = cset.encode(str);
5. byte[] bytes = buffer.array();
6. //解碼字節序列
7. byte[] bytes =...;
8. ByteBuffer bbuf =ByteBuffer.wrap(bytes, offset, length);
9. CharBuffer cbuf = cset.decode(bbuf);
10. String str = cbuf.toString();

java.nio.charset.Charset 1.4

1. staticSortedMap availableCharsets()//獲取這個虛擬機可用的全部字符集。返回一個映射表，它的鍵是字符集的名字，值是字符集
2. staticCharset forName(String name)//獲取給定名字的字符集
3. Set aliases()//返回這個字符集的別名集
4. ByteBuffer encode(String str)//將給定的字符串編碼爲字節序列
5. CharBuffer decode(ByteBuffer buffer)//解碼給定的字節序列，沒法識別的輸入將被轉換成Unicode的「替代字符」（’\uFFFD')

java.nio.ByteBuffer 1.4

1. byte[] array()//返回這個緩衝區所管理的字節數組
2. staticByteBuffer wrap(byte[] bytes)
3. staticByteBuffer wrap(byte[] bytes,int offset,int length)//返回管理給定的字節數組或給定字節數組的某個範圍的字節緩衝區

java.nio.CharBuffer

1. char[] array()//返回這個緩衝區所管理的碼元數組
2. char charAt(int index)//返回給定索引處的碼元
3. String toString()//返回由這個緩衝區所管理的碼元構成的字符串

 

讀寫二進制數據

DataInputStream類實現了DataInput接口

java.io.DataInput 1.0

1. boolean readBoolean()
2. byte readByte()
3. char readChar()
4. double readDouble()
5. float readFloat()
6. int readInt()
7. long readLong()
8. short readShort()//讀入一個給定類型的值
9. void readFully(byte[] b)//將字節讀入到數組b中，其間阻塞直至全部字節都讀入
10. void readFully(byte[] b,int off,int len)//將字節讀入到數組b中，其間阻塞直至全部字節都讀入
11. String readUTF()//讀入由「修訂過的UTF-8」格式的字符構成的字符串
12. int skipBytes(int n)//跳過n個字節，其間阻塞直至全部字節都被跳過

java.io.DataOutput 1.0

1. void writeBoolean(boolean b)
2. void writeByte(int b)
3. void writeChar(int c)
4. void writeDouble(double d)
5. void writeFloat(float f)
6. void writeInt(int i)
7. void writeLong(long l)
8. void writeShort(int s)//寫出一個給定類型的值
9. void writeChars(String s)//寫出字符串中的全部字符
10. void writeUTF(String s)//寫出由「修訂過的UTF-8」格式的字符構成的字符串

隨機訪問文件

RandomAccessFile類能夠在文件中的任何位置查找或寫入數據，經過「r"或"rw"來指定。同時實現了DataInput和DataOutput接口

java.io.RandomAccessFile 1.0

1. RandomAccessFile(String file,String mode)
2. RandomAccessFile(File file,String mode)//file:要打開的文件，mode:"r"表示只讀模式，"rw"表示讀/寫模式
3. long getFilePointer()//返回文件指針的當前位置
4. void seek(long pos)//將文件指針從文件的開始設置到pos個字節處
5. long length()//返回文件按照字節來度量的長度

 

ZIP文檔

通讀ZIP文件代碼：

1. ZipInputStream zin =newZipInputStream(newFileInputStream(zipname));
2. ZipEntry entry;
3. while((entry = zin.getNextEntry())!=null)
4. {
5. analyze entry;
6. read the contents of zin;
7. zin.closeEntry();
8. }
9. zin.close();

寫出ZIP文件代碼：

1. FileOutputStream fout =newFileOutputStream("test.zip");
2. ZipOutputStream zout =newZipOutputStream(fout);
3. for all files
4. {
5. ZipEntry ze =newZipEntry(filename);
6. zout.putNextEntry(ze);
7. send data to zout;
8. zout.closeEntry();
9. }
10. zout.close();

java.util.zip.ZipInputStream 1.1

1. ZipInputStream(InputStream in)//建立一個ZipInputStream
2. ZipEntry getNextEntry()//爲下一項返回ZipEntry對象，不然沒有更多的項時返回null
3. void closeEntry()//關閉這個ZIP文件中當前打開的項

java.util.zip.ZipOutputStream 1.1

1. ZipOutputStream(OutputStream out)//建立一個將壓縮數據寫出到指定的OutputStream的ZipOutputStream
2. void putNextEntry(ZipEntry ze)//將給定的ZipEntry中的信息寫出到流中，並定爲用於寫出數據的流，而後這些數據能夠經過write()寫出到這個流中
3. void closeEntry()//關閉這個ZIP文件中當前打開的項
4. void setLevel(int level)//設置後續的各個DEFAULTED項的默認壓縮級別。
5. void setMethod(int method)//設置用於這個ZipOutputStream的默認壓縮方法，壓縮方法：DEFLATED或STORED

java.util.zip.ZipEntry 1.1

1. ZipEntry(String name)//這一項的名字
2. long getCrc()//返回用於這個ZipEntry的CRC32校驗和的值
3. String getName()//返回這一項的名字
4. long getSize()//返回這一項不被壓縮的大小
5. boolean isDirectory()//當這一項是目錄時返回true
6. void setSize(long size)//設置這一項的大小，當壓縮方法是STORED時才必需
7. void setCrc(long crc)//給這一項設置CRC32校驗和，這個校驗和是使用CRC32類計算的，STORED時必需

java.util.zip.ZipFile 1.1

1. ZipFile(String name)
2. ZipFile(File file)//建立一個ZipFile，用於從給定的字符串或File對象中讀入數據
3. Enumeration entries()//返回一個Enumeration對象，它枚舉了描述這個ZipFile中各個項的ZipEntry對象
4. ZipEntry getEntry(String name)//返回給定名字所對應的項，或者在沒有對應項的時候返回null
5. InputStream getInputStream(ZipEntry ze)//返回用於給定項的InputStream
6. String getName()//返回這個ZIP文件的路徑

 

對象流與序列化

對象序列化（object serialization)

ObjectInputStream和ObjectOutputStream類，readObject和writeObject方法

在對象流中存儲或恢復的全部類都須要實現Serializable接口

java.io.ObjectOutputStream 1.1

1. ObjectOutputStream(OutputStream out)//建立一個ObjectOutputStream使得你能夠將對象寫出到指定的OutputStream
2. void writeObject(Object obj)//寫出指定的對象到ObjectOutputStream，這個方法將存儲指定對象的類、類的簽名以及這個類及其超類中全部非靜態和非瞬時的域的值

java.io.ObjectInputStream 1.1

1. ObjectInputStream(InputStream in)//建立一個ObjectInputStream用於從指定的InputSream中讀回對象信息
2. Object readObject()//從ObjectInputStream中讀入一個對象

對象流輸出中包含全部對象的類型和數據域

每一個對象都被賦予一個序列號

相同對象的重複出現將被存儲爲對這個對象的序列號的引用

 

修改默認的序列化機制

防止不該該被序列化的域被序列化，標記成transient

可序列化的類能夠定義下列方法：

1. privatevoid readObject(ObjectInputStream in)throwsIOException,ClassNotFoundException;
2. privatevoid writeObject(ObjectOutputStream out)throwsIOException;

以後，數據域就再也不自動序列化，而是調用這些方法

 

類還能夠定義它本身的機制，必須實現Externalizable接口，定義兩個方法：

1. publicvoid readExternal(ObjectInputStream in)throwsIOException,ClassNotFoundException;
2. publicvoid writeExternal(ObjectOutputStream out)throwsIOException;

 

序列化單例和類型安全的枚舉

請記住向遺留代碼中全部類型安全的枚舉以及向全部支持單例設計模式的類中添加readResolve方法

 

版本管理

運行JDK中的單機程序serialver

serialver Employee

這個類的全部版本都須要定義

public static final long serialVersionUID = -184528436328947893L;

 

文件管理

File類

能夠用FileNameFilter對象做爲list方法的參數來減少列表長度，一個實現FileNameFilter接口的類須要定義accept方法

使用File類中存儲在名爲separator的靜態實例域中的有關當前目錄分隔符的信息能夠獲得系統恰當的分隔符

java.io.File 1.0

1. boolean canRead()
2. boolean canWrite()
3. boolean canExecute()//代表文件是否可讀、可寫或可執行
4. boolean setReadable(boolean state,boolean ownerOnly)
5. boolean setWritable(boolean state,boolean ownerOnly)
6. boolean setExecutable(boolean state,boolean ownerOnly)//設置這個文件的可讀、可寫或可執行狀態。若是ownerOnly爲true，狀態設置只對文件擁有者有效，不然，對全部人有效。這些方法在設置狀態成功後返回true
7. staticboolean createTempFile(String prefix,String suffix)
8. staticboolean createTempFile(String prefix,String suffix,File directory)//在系統的默認臨時目錄或給定目錄中建立一個臨時文件，並使用給定的前綴或後綴來生成文件名
9. booleandelete()//嘗試刪除這個文件
10. void deleteOnExit()//請求在虛擬機關閉時將文件刪除
11. boolean exists()//若是目錄存在則返回true
12. String getAbsolutePath()//返回包含絕對路徑名的字符串，應該用getCanonicalPath代替它
13. File getCanonicalFile()//返回包含這個文件的規範路徑名的File對象
14. String getCanonicalPath()//返回包含這個文件的規範路徑名的字符串
15. String getName()//返回包含這個File對象的文件名的字符串（不包含路徑）
16. String getParent()//返回這個File對象的父親名字的字符串
17. File getParentFile()//返回這個File目錄的父目錄的File對象
18. String getPath()//返回包含這個文件的路徑名的字符串
19. boolean isDirectory()//若是這個File對象表示一個文件而不是一個目錄或一個設備，則返回true
20. boolean isFile()//若是這個File對象表示一個文件而不是一個目錄或一個設備，則返回true
21. boolean isHidden()//若是這個File對象表示的是一個隱藏文件或目錄，則返回true
22. long lastModified()//返回這個文件最後被修改的時間（毫秒數）
23. String[] list()
24. String[] list(FilenameFilter filter)//返回由這個File對象包含的知足過濾器條件的文件名和目錄名構成的字符串數組
25. File[] listFiles()
26. File[] listFiles(FilenameFilter filter)//返回由這個File對象包含的文件和目錄所對應的File對象構成的數組
27. staticFile[] listRoots()//返回由全部可得到的文件根對應的File對象構成的數組
28. boolean createNewFile()//自動建立一個由File對象給定名字的新文件
29. boolean mkdir()//建立一個由這個File對象給定名字的子目錄
30. boolean mkdirs()//與mkdir不一樣，這個方法在必要時將建立父目錄
31. boolean renameTo(File newName)//若是文件名被修改，則返回true
32. boolean setLastModified(long time)//設置這個文件的最後修改時間
33. boolean setReadOnly()//將這個文件設置成只讀
34. URL toURL()//將這個File對象轉換成一個文件的URL
35. long getTotalSpace()
36. long getFreeSpace()
37. long getUsableSpace()//得到由File對象所描述的分區的總大小、未分配字節的數量和可用字節的數量

java.io.FilenameFilter 1.0

1. boolean accept(File dir,String name)//應該定義爲在文件可以匹配過濾器標準時返回true

 

新IO

內存映射文件

java.io.FileInputStream 1.0

1. FileChannel getChannel()//返回用於訪問這個流的通道

java.io.FileOutputStream 1.0

1. FileChannel getChannel()//返回用於訪問這個流的通道

java.io.RandomAccessFile 1.0

1. FileChannel getChannel()//返回用於訪問這個流的通道

java.nio.channels.FileChannel 1.4

1. MappedByteBuffer map(FileChannel.MapMode mode,long position,long size)//將文件的一個區域映射到內存中

java.nio.Buffer 1.4

1. boolean hasRemaining()//若是當前的緩衝區位置沒有達到這個緩衝區的界限位置則返回true
2. int limit()//返回這個緩衝區的界限位置

java.nio.ByteBuffer 1.4

1. byte get()//從當前位置得到一個字節，並將當前位置推到下一個字節
2. byte get(int index)//從指定索引處得到一個字節
3. ByteBuffer put(byte b)//向當前位置推入一個字節，並將當前位置推到下一個字節，返回對這個緩衝區的引用
4. ByteBuffer put(int index,byte b)//向指定索引處推入一個字節，返回對這個緩衝區的引用
5. ByteBuffer get(byte[] destination)
6. ByteBuffer get(byte[] destination,int offset,int length)//用緩衝區的字節來填充字節數組，或者字節數組的某個區域，並將當前位置向前推讀入的字節數個位置，若是緩衝區不夠，不會讀入任何字節，並拋出BufferUnderflowException
7. ByteBuffer put(byte[] source)
8. ByteBuffer put(byte[] source,int offset,int length)//將字節數組中的全部字節或者給定區域的字節都推入緩衝區，並將當前位置向前推寫出的字節數個位置
9. Xxx getXxx()
10. Xxx getXxx(int index)
11. ByteBuffer putXxx(xxx value)
12. ByteBuffer putXxx(int index, xxx value)//得到或放置一個二進制數
13. ByteBuffer order(ByteOrder order)
14. ByteOrder order()//設置或得到字節順序，order的值是ByteOrder類的常量BIG_ENDIAN或LITTLE_ENDIAN中的一個

緩衝區數據結構

java.nio.Buffer 1.4

1. Buffer clear()//經過將位置復位到0，並將界限復位到容量，使這個緩衝區爲寫出作好準備。返回this
2. Buffer flip()//經過將界限設置爲位置，並將位置復位到0，使這個緩衝區爲讀入作好準備，返回this
3. Buffer rewind()//經過將讀寫位置復位到0，並保持極限不變，使這個緩衝區爲從新讀入相同的值作好準備，返回this
4. Buffer mark()//將這個緩衝區的標記設置到讀寫位置，返回this
5. Buffer reset()//將這個緩衝區的位置設置到標記，從而容許被標記的部分能夠再次被讀入或寫出，返回this
6. int remaining()//返回剩餘可讀入或可寫出的值的數量，即界限與位置之間的差別
7. int position()//返回這個緩衝區的位置
8. int capacity()//返回這個緩衝區的容量

java.nio.CharBuffer 1.4

1. char get()
2. CharBuffer get(char[] destination)
3. CharBuffer get(char[] destination,int offset,int length)//從這個緩衝區的位置處開始，得到一個char值，或者某個範圍的char值，而後將位置向前推過所讀入的字符，最後兩個方法返回this
4. CharBuffer put(char c)
5. CharBuffer put(char[] source)
6. CharBuffer put(char[] source,int offset,int length)
7. CharBuffer put(String source)
8. CharBuffer put(CharBuffer source)//從這個緩衝區的位置處開始，推入一個char值，或者某個範圍的char值，而後將位置向前推過所寫出的字符
9. CharBuffer read(CharBuffer destination)//從這個緩衝區中得到char值，而後將它們推入目標緩衝區，直至達到目標緩衝區的界限

 

文件加鎖機制

文件加鎖機制是依賴於操做系統的

文件鎖是由整個Java虛擬機持有的。若是有兩個程序是由同一個虛擬機啓動的，那麼它們不可能每個都得到一個在同一個文件上的鎖，當調用lock和tryLock方法時，若是虛擬機已經在同一個文件上持有了另外一個重疊的鎖，那麼這兩個方法將拋出OverlappingFileLockException

java.nio.channels.FileChannel 1.4

1. FileLock lock()//在整個文件上得到一個獨佔的鎖，這個方法將阻塞直至得到鎖
2. FileLock tryLock()//在整個文件上得到一個獨佔的鎖，或者在沒法得到鎖的狀況下返回null
3. FileLock lock(long position,long size,boolean shared)
4. FileLock tryLock(long position,long size,boolean shared)//在文件的一個區域上得到鎖

 

java.nio.channels.FileLock 1.4

1. void release()//釋放這個鎖

 

正則表達式

語法

1. String patternString ="<a\\s+href\\s*=\\s*(\"[^\"]*\"|[^\\s>]*)\\s*>"

用法

1. Pattern pattern =Pattern.compile(patternString);
2. Matcher matcher = pattern.matcher(input);
3. if(matcher.matches())...

java.util.regex.Pattern 1.4

1. staticPattern compile(String expression)
2. staticPattern compile(String expression,int flags)//把正則表達式字符串編譯到一個用於快速處理匹配的模式對象中
3. Matcher matcher(CharSequence input)//返回一個matcher對象，能夠用它在輸入定位模式的匹配
4. String[] split(CharSequence input)
5. String[] split(CharSequence input,int limit)//將輸入分割成標號，其中模式指定了分隔符的形式

java.util.regex.Matcher 1.4

1. boolean matches()//若是輸入匹配模式，則返回true
2. boolean lookingAt()//若是輸入的開頭匹配模式，則返回true
3. boolean find()
4. boolean find(int start)//嘗試查找下一個匹配，找到返回true
5. int start()
6. int end()//返回當前匹配的開始索引和結尾以後的索引
7. String group()//返回當前的匹配
8. int groupCount()//返回輸入模式中的羣組數量
9. int start(int groupIndex)
10. int end(int groupIndex)//返回當前匹配中給定羣組的開始和結尾以後的位置
11. String group(int groupIndex)//返回匹配給定羣組的字符串
12. String replaceAll(String replacement)
13. String replaceFirst(String replacement)//返回從匹配器輸入得到的經過將全部匹配或第一個匹配用替換字符串替換以後的字符串
14. Matcher reset()
15. Matcher reset(CharSequence input)//復位匹配器的狀態。第二個方法將使匹配器做用於另外一個不一樣的輸入，兩個方法都返回this

 

第二章--XML----------------------------------------------

XML文檔

文檔頭

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

 

文檔類型定義（DTD，Document Type Definition）

1. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http:java.sun.com/j2ee/dtds/web-app_2_2.dtd">

 

一般屬性只應該在修改值的解釋時使用，而不是在指定值時使用

字符引用：&#233 （十進制）; &#xD9（十六進制）

實體引用：

< 小於

> 大於

& &

" 引號

' 省略號

CDATA部分: 用<![CDATA[和]]>來限定其界限，可用來包含含有<、>、&之類字符的字符串

處理指令：用<?和?>限定界限

註釋：用<!-和-->限定界限

 

解析XML文檔

DOM（Document Object Model，文檔對象模型）解析器：樹型解析器

用於XML的簡單API（Simple API for XML, SAX)解析器：流機制解析器

讀入一個XML文檔

1. DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();
2. DocumentBuilder builder = factory.newDocumentBuilder();
3. File f =...
4. Document doc = builder.parse(f);

javax.xml.parsers.DocumentBuilderFactory 1.4

1. staticDocumentBuilderFactory newInstance()//返回DocumentBuilderFactory類的一個實例
2. DocumentBuilder newDocumentBuilder()//返回DocumentBuilder類的一個實例

javax.xml.parsers.DocumentBuilder 1.4

1. Document parse(File f)
2. Document parse(String url)
3. Document parse(InputStream in)//解析來自給定文件、URL或輸入流的XML文檔，返回解析後的文檔

org.w3c.dom.Document 1.4

1. Element getDocumentElement()//返回文檔的根元素

org.w3c.dom.Element 1.4

1. String getTagName()//返回元素的名字
2. String getAttribute(String name)//返回給定名字的屬性值，沒有該屬性時返回空字符串

org.w3c.dom.Node 1.4

1. NodeList getChildNodes()//返回包含全部子元素節點的節點列表
2. Node getFirstChild()
3. Node getLastChild()//獲取該節點的第一個或最後一個子節點，在該節點沒有子節點時返回null
4. Node getNextSibling()
5. Node getPreviousSibling()//獲取該節點的下一個或上一個兄弟節點，在該節點沒有兄弟節點時返回null
6. Node getParentNode()//獲取該節點的父結點，在該節點是文檔節點時返回null
7. NamedNodeMap getAttributes()//返回含有描述該節點全部屬性的Attr節點的映射表
8. String getNodeName()//返回該節點的名字，當該結點是Attr節點時，該名字就是屬性名
9. String getNodeValue()//返回該節點的值，當該節點是Attr節點時，該值就是屬性值

org.w3c.dom.CharacterData 1.4

1. String getData()//返回存儲在節點中的文本

org.w3c.dom.NodeList 1.4

1. int getLength()//返回列表中的節點數
2. Node item(int index)//返回給定索引號的節點

org.w3c.dom.NamedNodeMap 1.4

1. int getLength()//返回該節點映射表中的節點數
2. Node item(int index)//返回給定索引號的節點

 

驗證XML文檔

DTD

1. <!ELEMENT font (name,size)>

XML Schema （xsd文件）

1. <xsd:elementname="font">
2. <xsd:sequence>
3. <xsd:elementname="name"type="xsd:string"/>
4. <xsd:elementname="size"type="xsd:int"/>
5. </xsd:sequence>
6. </xsd:element>

文檔類型定義：

將DTD歸入XML文檔中

1. <?xml version="1.0"?>
2. <!DOCTYPE configuration [
3. <!ELEMENT configuration ...>
4. more rules
5. ...
6. ]>
7. <configuration>
8. ...
9. </configuration>

將DTD存儲在外面

1. <!DOCTYPE configuration SYSTEM "config.dtd">
2. 或者
3. <!DOCTYPE configuration SYSTEM "http://myserver.com/config.dtd">

若是使用DTD的相對URL（好比"config.dtd"），須要給解析器一個文件或URL對象，而不是InputStream，若是必須從一個輸入流來解析，請提供一個實體渲染器

來源於SGML的用於識別「衆所周知的」DTD的機制，如

1. <!DOCTYPE web-app
2. PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

若是使用的是DOM解析器，想要支持公共標識符，須要調用DocumentBuilder類的setEntityResolver方法來安裝EntityResolver接口的某個實現類的一個對象，該接口只有一個方法：resolveEntity

ELEMENT規則

E*	0或多個E
E+	1或多個E
E？	0或1個E
E1|E2|...|En	E1, E2, ..., En中的一個
E1, E2, ..., En	E1隨後是E2，...，En
#PCDATA	文本
(#PCDATA|E1|E2|...|En)*	0或多個任意順序的文本和E1，E2，...，En（混合式內容）
ANY	容許任意子元素
EMPTY	不容許有子元素

 元素的規範能夠包含嵌套的和複雜的正則表達式，如

<!ELEMENT chapter (intro, (heading, (para | image | table | note)+)+)

描述合法元素屬性的語法規則：

<!ATTLIST element attribute type default>

兩個屬性規範範例：

<!ATTLIST font style (plain|bold|italic|bold-italic) "plain">

<!ATTLIST size unit CDATA #IMPLIED>

 

使用DTD驗證輸入

1. factory.setValidating(true);
2. factory.setIgnoringElementContentWhitespace(true);

在驗證時，應該安裝一個錯誤處理器，即一個實現了ErrorHandler接口的對象

javax.xml.parsers.DocumentBuilder 1.4

1. void setEntityResolver(EntityResolver resolver)//設置解析器，來定位要分析的XML文檔中引用的實體
2. void setErrorHandler(ErrorHandler handler)//設置報告解析過程當中出現的錯誤和警告的處理器

org.xml.sax.EntityResolver 1.4

1. publicInputSource resolveEntity(String publicID,String systemID)//返回包含被指定ID引用數據的一個輸入源，或者，當解析器不知道如何解析某個特定名字時，返回null。若是沒有提供公共ID，那麼參數publicID能夠爲null

org.xml.sax.InputSource 1.4

1. InputSource(InputStream in)
2. InputSource(Reader in)
3. InputSource(String systemID)//根據流、讀入器、或系統ID（一般是相對或絕對URL）構建輸入源

org.xml.sax.ErrorHandler 1.4

1. void fatalError(SAXParseException exception)
2. void error(SAXParseException exception)
3. void warning(SAXParseException exception)//覆蓋這些方法以提供處理器，對致命錯誤、非致命錯誤和警告進行處理

org.xml.sax.SAXParseException 1.4

1. int getLineNumber()
2. int getColumnNumber()//返回引發異常的已處理的輸入信息末尾的行號和列號

javax.xml.parsers.DocumentBuilderFactory 1.4

1. boolean isValidating()
2. void setValidating(boolean value)//獲取和設置工廠的validating屬性，當設爲true時，工廠生成的解析器會驗證它們的輸入信息
3. boolean isIgnoringElementContentWhiteSpace(boolean value)//獲取和設置工廠的ignoringElementContentWhiteSpace屬性，當設爲true時，工廠生成的解析器會忽略沒有混合內容（即元素與#PCDATA混合）的元素節點之間的空白

 

XML Schema

若是要在文檔中引用Schema文件，須要在根元素中加上屬性

1. <?xml version="1.0"?>
2. <configurationxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:noNamespaceSchemaLocation="config.xsd">
4. ...
5. </configuration>

解析帶有Schema的XML文件和解析帶有DTD的文件類似，但有3點差異：

1. //必須打開對命名空間的支持
2. factory.setNamespaceAware(true);
3. //必須執行以下步驟
4. finalString JAXP_SCHEMA_LANGUAGE ="http://java.sun.com/xml/jaxp/properties/schemaLanguage";
5. finalString W3C_XML_SCHEMA ="http://www.w3.org/2001/XMLSchema";
6. factory.setAttribute(JAXP_SCHEMA_LANGUAGE, W3C_XML_SCHEMA);

 

使用XPath來定位信息

XPath表達式/configuration/database/username

使用@操做符能夠獲得屬性值，如

/gridbag/row[1]/cell[1]/@anchor

javax.xml.xpath.XPathFactory 5.0

1. staticXPathFactory newInstance()//返回XPathFactory實例來建立XPath對象
2. XPath newXpath()//構建XPath對象來計算XPath表達式

javax.xml.xpath.XPath 5.0

1. String evaluate(String expression,Object startingPoint)/從給定的起點計算表達式，起點能夠是一個節點或節點列表，若是結果是一個節點或節點集，則返回的字符串包含全部文本節點子元素的數據
2. Object evaluate(String expression,Object startingPoint,QName resultType)//從給定的起點計算表達式，起點能夠是一個節點或節點列表。ResultType是XPathConstants類的常量STRING, NODE, NODESET, NUMBER或BOOLEAN之一

使用命名空間（URI）

HTTP URL格式最經常使用

xmlns:alias="namespaceURI" 用於定義命名空間和別名

打開命名空間處理特性

1. factory.setNamespaceAware(true);

由getNodeName和getTagName等方法返回帶有別名前綴的限定名

 

org.w3c.dom.Node 1.4

1. String getLocalName()//返回本地名（不帶別名前綴），或者在解析器不支持命名空間時返回null
2. String getNamespaceURI()//返回命名空間URI，或者在解析器不支持命名空間時返回null

javax.xml.parsers.DocumentBuilderFactory 1.4

1. boolean isNamespaceAware()
2. void setNamespaceAware(boolean value)//獲取或設置工廠的namespaceAware屬性

 

流機制解析器

使用SAX解析器（事件回調）

在使用SAX解析器時，須要一個處理器來定義不一樣的解析器事件的事件動做，ContentHandler接口定義了若干個回調方法，如startElement, endElement, characters, startDocument和endDocument

1. SAXParserFactory factory =SAXParserFactory.newInstance();
2. SAXParser parser = factory.newSAXParser();
3. parser.parse(source, handler);

處理器屬於DefaultHandler的一個子類，DefaultHandler類爲4個接口定義了空的方法：ContentHandler, DTDHandler, EntityResolver, ErrorHandler

javax.xml.parsers.SAXParserFactory 1.4

1. staticSAXParserFactory newInstance()//返回SAXParserFactory類的一個實例
2. SAXParser newSAXParser()//返回SAXParser類的一個實例
3. boolean isNamespaceAware()
4. void setNamespaceAware(boolean value)//獲取和設置工廠的namespaceAware屬性
5. boolean isValidating()
6. void setValidating(boolean value)//獲取和設置工廠的validating屬性

javax.xml.parsers.SAXParser 1.4

1. void parse(File f,DefaultHandler handler)
2. void parse(String url,DefaultHandler handler)
3. void parse(InputStream in,DefaultHandler handler)//解析來自給定文件、URL或輸入流的XML文檔，並把解析事件報告給指定的處理器

org.xml.sax.ContentHandler 1.4

1. void startDocument()
2. void endDocument()
3. void startElement(String uri,String lname,String qname,Attributes attr)
4. void endElement(String uri,String lname,String qname)//在元素的起始或結束時被調用
5. void characters(char[] data,int start,int length)//解析器報告字符數據時被調用

org.xml.sax.Attributes 1.4

1. int getLength()//返回存儲在該屬性集合中屬性數量
2. String getLocalName(int index)//返回給定索引的屬性的本地名（無別名前綴），或當不支持命名空間特性時返回空字符串
3. String getURI(int index)//返回給定索引的屬性的命名空間URI
4. String getQName(int index)//返回給定索引的屬性的限定名
5. String getValue(int index)
6. String getValue(String qname)
7. String getValue(String uri,String lname)//根據給定索引、限定名或命名空間URI+本地名，返回屬性值，該值不存在時返回null

使用StAX解析器（ 提供解析事件的迭代器）

1. InputStream in = url.openStream();
2. XMLInputFactory factory =XMLInputFactory.newInstance();
3. XMLStreamReader parser = factory.createXMLStreamReader(in);
4. while(parser.hasNext()){
5. int event = parser.next();
6. Call parser methods to obtain event details
7. }

javax.xml.stream.XMLInputFactory 6

1. staticXMLInputFactory newInstance()//返回XMLInputFactory類的一個實例
2. void setProperty(String name,Object value)//設置這個工廠的屬性，或者在要設置的屬性不支持設置成給定值時，拋出IllegalArgumentException
3. XMLStreamReader createXMLStreamReader(InputStream in)
4. XMLStreamReader createXMLStreamReader(InputStream in,String characterEncoding)
5. XMLStreamReader createXMLStreamReader(Reader in)
6. XMLStreamReader createXMLStreamReader(Source in)//建立一個從給定的流、閱讀器或JAXP源讀入的解析器

javax.xml.stream.XMLStreamReader 6

1. boolean hasNext()//若是有另外一個解析事件則返回true
2. int next()//將解析器的狀態設置爲下一個解析事件，並返回下列常量之一：START_ELEMENT、CHARACTERS、START_DOCUMENT、END_DOCUMENT、CDATA、COMMENT、SPACE（可忽略的空白字符）、PROCESSING_INSTRUCTION、ENTITY_REFERENCE、DTD
3. boolean isStartElement()
4. boolean isEndElement()
5. boolean isCharacters()
6. boolean isWhiteSpace()//若是當前事件是一個開始元素、結束元素、字符數據或空白字符，返回true
7. QName getName()
8. String getLocalName()//獲取在START_ELEMENT或END_ELEMENT事件中的元素的名字
9. String getText()//返回一個CHARACTERS、COMMENT或CDATA事件，或一個ENTITY_REFERENCE的替換值，或者一個DTD的內部子集所對應的字符
10. int getAttributeCount()
11. QName getAttributeName(int index)
12. String getAttributeLocalName(int index)
13. String getAttributeValue(int index)
14. String getAttributeValue(String namespaceURI,String name)//只要當前事件是START_ELEMENT，則獲取給定屬性的值，若是namespaceURI爲null，則不檢查名字空間

生成XML文檔

用文檔的內容構建一棵DOM樹

1. Document doc = builder.newDocument();
2. Element rootElement = doc.createElement(rootName);
3. Element childElement = doc.createElement(childName);
4. Text textNode = doc.createTextNode(textContents);
5. doc.appendChild(rootElement);
6. rootElement.appendChild(childElement);
7. childElement.appendChild(textNode);
8. rootElement.setAttribute(name, value);

可是DOM API目前還不支持DOM樹寫到輸出流，須要使用可擴展的格式頁轉換（XSLT) API

1. //construct the "do nothing" transformation
2. Transformer t =TransformerFactory.newInstance().newTransformer();
3. //set output properties to get a DOCTYPE node
4. t.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, systemIdentifier);
5. t.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, publicIdentifier);
6. //set indentation
7. t.setOutputProperty(OutputKeys.INDENT,"yes");
8. t.setOutputProperty(OutputKeys.METHOD,"xml");
9. //apply the "do nothing" transformation and send the output to a file
10. t.transform(newDOMSource(doc),newStreamResult(newFileOutputStream(file)));

javax.xml.parsers.DocumentBuilder 1.4

1. Document newDocument()//返回一個空文檔

org.w3c.dom.Document 1.4

1. Element createElement(String name)//返回具備給定名字的元素
2. Text createTextNode(String data)//返回具備給定數據的文本節點

org.w3c.dom.Node 1.4

1. Node appendChild(Node child)//將一個節點附加到該節點的子節點列表，返回該節點

org.w3c.dom.Element 1.4

1. void setAttribute(String name,String value)//將有給定名字的屬性設置爲指定的值
2. void setAttributeNS(String uri,String qname,String value)//將帶有給定命名空間URI和限定名的屬性設置爲指定的值

javax.xml.transform.TransformerFactory 1.4

1. staticTransformerFactory newInstance()//返回TransformerFactory類的一個實例
2. transformer newTransformer()//返回Transformer類的一個實例，帶有標識符或「無操做」的轉換

javax.xml.transform.Transformer 1.4

1. void setOutputProperty(String name,String value)//設置輸出屬性
2. void transform(Source from,Result to)//轉換一個XML文檔

javax.xml.transform.dom.DOMSource 1.4

1. DOMSource(Node n)//根據指定的節點構建一個源。一般，n是文檔節點

javax.xml.transform.stream.StreamResult 1.4

1. StreamResult(File f)
2. StreamResult(OutputStream out)
3. StreamResult(Writer out)
4. StreamResult(String systemID)根據文件、流、寫入程序或系統ID（一般是相對或絕對URL）來構建數據流結果

使用StAX寫XML文檔

1. XMLOutputFactory factory =XMLOutputFactory.newInstance();
2. XMLStreamWriter writer = factory.createXMLStreamWriter(out);
3. writer.writeStartDocument();
4. writer.writeStartElement(name);
5. writer.writeAttribute(name, value);
6. writer.writeCharacters(text);
7. writer.writeEndElement();
8. writer.writeEmptyElement(name);
9. writer.writeEndDocument();

javax.xml.stream.XMLOutputFactory 6.

1. staticXMLOutputFactory newInstance()//返回這個XMLOutputFactory類的一個實例
2. XMLStreamWriter createXMLStreamWriter(OutputStream in)
3. XMLStreamWriter createXMLStreamWriter(OutputStream in,String characterEncoding)
4. XMLStreamWriter createXMLStreamWriter(Writer in)
5. XMLStreamWriter createXMLStreamWriter(Result in)//建立寫入給定流、寫出器和JAXP結果的寫出器

javax.xml.stream.XMLStreamWriter 6

1. void writeStartDocument()
2. void writeStartDocument(String xmlVersion)
3. void writeStartDocument(String encoding,String xmlVersion)//在文檔的頂部寫入XML處理指令
4. void setDefaultNamespace(String namespaceURI)
5. void setPrefix(String prefix,String namespaceURI)
6. 設置默認的命名空間，或具備前綴的命名空間，做用域僅爲當前元素
7. void writeStartElement(String localName)
8. void writeStartElement(String namespaceURI,String localName)//寫出一個開始標籤，其中namespaceURI將用相關聯的前綴來代替
9. void writeEndElement()//關閉當前元素
10. void writeEndDocument()//關閉全部打開的元素
11. void writeEmptyElement(String localName)
12. void writeEmptyElement(String namespaceURI,String localName)//寫出一個自閉合的標籤
13. void writeAttribute(String localName,String value)
14. void writeAttribute(String namespaceURI,String localName,String value)//寫出一個用於當前元素的屬性
15. void writeCharacters(String text)//寫出字符數據
16. void writeCData(String text)//寫出CDATA塊
17. void writeDTD(String dtd)//寫出dtd字符串，該字串須要包含一個DOCTYPE聲明
18. void writeComment(String comment)//寫出一個註釋
19. void close()//關閉這個寫出器

 

XSL轉換（XSLT）

典型模板：

1. <xsl:templatematch="/staff/employee">
2. <tr><xsl:apply-templates/></tr>
3. </xsl:template>

處理屬性值：

1. <xsl:templatematch="/staff/employee/hiredate">
2. <td><xsl:value-ofselect="@year"/>-<xsl:value-ofselect="@month"/>-<xsl:value-ofselect="@day"/></td>
3. </xsl:template>

實現XML轉換

1. File styleSheet =newFile(filename);
2. StreamSource styleSource =newStreamSource(styleSheet);
3. Transformer t =TransformerFactory.newInstance().newTransformer(styleSource);
4. t.transform(source, result);

Source接口有3個實現類：DOMSource, SAXSource, StreamSource

Result接口有3個實現類：DOMResult，SAXResult，StreamResult

 

javax.xml.transform.TransformerFactory 1.4

1. transformer newTransformer(Source stylesheet)//返回一個transformer類的實例，用來從指定的源中讀取樣式表

javax.xml.transform.stream.StreamSource 1.4

1. StreamSource(File f)
2. StreamSource(InputStream in)
3. StreamSource(Reader in)
4. StreamSource(String stystemID)//根據一個文件、流、閱讀器或系統ID（一般是相對或絕對URL）來構建一個數據流源

javax.xml.transform.sax.SAXSource 1.4

1. SAXSource(XMLReader reader,InputSource source)//構建一個SAX數據源，以便從給定輸入源獲取數據，並使用給定的閱讀器來解析輸入數據

org.xml.sax.XMLReader 1.4

1. void setContentHandler(ContentHandler handler)//設置在輸入被解析時會被告知解析事件的處理器
2. void parse(InputSource source)//根據給定輸入源解析輸入數據，並將解析事件發送到內容處理器

javax.xml.transform.dom.DOMResult 1.4

1. DOMResult(Node n)//根據給定結點構建一個數據源，一般n是一個新文檔節點

org.xml.sax.helpers.AttributesImpl 1.4

1. void addAtrribute(String uri,String lname,String qname,String type,String value)//將一個屬性添加到該屬性集合
2. void clear()//刪除屬性集合中的全部屬性

 

第三章--網絡----------------------------------------------

套接字Socket

套接字超時設置

java.net.Socket 1.0

1. Socket(String host,int port)//構建一個套接字，用來鏈接給定的主機和端口
2. InputStream getInputStream()
3. OutputStream getOutputStream()//獲取能夠從套接字中讀取數據的流，以及能夠向套接字寫出數據的流
4. Socket()//建立一個還未被鏈接的套接字
5. void connect(SocketAddress address)//將該套接字鏈接到給定的地址
6. void connect(SocketAddress address,int timeoutInMilliSeconds)//將套接字鏈接到給定的地址，若是在給定的時間內沒有響應，則返回
7. void setSoTimeout(int timeoutInMilliseconds)//設置該套接字上讀請求的阻塞時間，若是超出時間，則拋出一個InterruptedIOException異常
8. boolean isConnected()//若是該套接字已被鏈接，則返回true
9. boolean isClosed()//若是該套接字已被關閉，返回true

因特網地址

1. InetAddress address =InetAddress.getByName("time-A.timefreq.bldrdoc.gov");
2. byte[] addressBytes = address.getAddress();

java.net.InetAddress 1.0

1. staticInetAddress getByName(String host)
2. staticInetAddress[] getAllByName(String host)//爲給定的主機名，建立一個InetAddress對象，或者一個包含了該主機名所對應的全部因特網地址的數組
3. staticInetAddress getLocalHost()//爲本地主機建立一個InetAddress對象
4. byte[] getAddress()//返回一個包含數字型地址的字節數組
5. String getHostAddress()//返回一個由十進制數組成的字符串，各數字間用圓點符號隔開
6. String getHostName()//返回主機名

 

實現服務器

1. ServerSocket s =newServerSocket(8189);
2. Socket incoming = s.accept();
3. InputStream inStream = incoming.getInputStream();
4. OutputStream outStream = incoming.getOutputStream();
5. Scanner in =newScanner(inStream);
6. PrintWriter out =newPrintWriter(outStream,true/* autoFlush */);
7. out.println("Hello!Enter BYE to exit.「);
8. String line = in.nextLine();
9. out.println("Echo:"+ line);
10. if(line.trim().equals("BYE")) done =true;
11. incoming.close();

java.net.ServerSocket 1.0

1. ServerSocket(int port)//建立一個監控端口的服務器套接字
2. Socket accept()//等待鏈接，阻塞當前線程直到創建鏈接爲止
3. void close()//關閉服務器套接字

爲多個客戶端服務

1. while(true){
2. Socket incoming = s.accept();
3. Runnable r =newThreadedEchoHandler(incoming);
4. Thread t =newThread(r);
5. t.start();
6. }

半關閉

java.net.Socket 1.0

1. void shutdownOutput()//將輸出流設爲「流結束」
2. void shutdownInput()//將輸入流設爲「流結束」
3. boolean isOutputShutdown()//若是輸出已被關閉返回true
4. boolean isInputShutdown()//若是輸入已被關閉，返回true

 

可中斷套接字

java.nio包的特性：SocketChannel類，通道（channel)沒有相關聯的流，須要調用Buffer對象來實現ReadableByteChannel和WritableByteChannel接口聲明的read和write方法

1. SocketChannel channel =SocketChannel.open(newInetSocketAddress(host, port));
2. Scanner in =newScanner(channel);
3. OutputStream outStream =Channels.newOutputStream(channel);

若是線程發生中斷，不會阻塞，而是會拋出異常

java.net.InetSocketAddress 1.4

1. InetSocketAddress(String hostname,int port)//經過主機和端口參數建立一個地址對象，並在建立過程當中解析主機名，若是主機名不能被解析，那麼該地址對象的unresolved屬性被設爲true
2. boolean isUnresolved()//若是不能解析該地址對象，返回true

java.nio.channels.SocketChannel 1.4

1. staticSocketChannel open(SocketAddress address)//打開一個套接字通道，並將其鏈接到遠程地址

java.nio.channels.Channels 1.4

1. staticInputStream newInputStream(ReadableByteChannel channel)//建立一個輸入流，用以從指定的通道讀取數據
2. staticOutputStream newOutputStream(WritableByteChannel channel)//建立一個輸出流，用以向指定的通道寫入數據

 

發送E-mail

1. Socket s =newSocket("mail.yourserver.com",25);
2. PrintWriter out =newPrintWriter(s.getOutputStream));

信息規範：

HELO sending host

MAIL FROM: <sender e-mail address>

RCPT TO: <recipient e-mail address>

DATA

mail message

(any number of lines)

.

QUIT

SMTP規範規定，每一行都要以\r再緊跟一個\n來結尾

 

建議URL鏈接

URL和URI

1. URL url =new URL(urlString);
2. InputStream inStream = url.openStream();
3. Scanner in =newScanner(inStream);

URI句法：

[scheme:]schemeSpecificPart[#fragment]

一個分層URI的schemeSpecificPart具備如下結構：

[//authority][path][?query]

對基於服務器的URI，authority部分採用如下形式：

[user-info@]host[:port]

1. relative = base.relativize(combined);
2. combined = base.resolve(relative);

使用URLConnection獲取信息

1. 調用URL類中的openConnection方法得到URLConnection對象

1. URLConnection connection = url.openConnection()

2. 使用如下方法來設置任意的請求屬性

1. setDoInput
2. setDoOutput
3. setIfModifiedSince
4. setUseCaches
5. setAllowUserInteraction
6. setRequestProperty
7. setConnectTimeout
8. setReadTimeout

3. 調用connect方法鏈接遠程資源

1. connection.connect();

4. 創建鏈接後，能夠查詢頭信息

1. getContentType
2. getContentLength
3. getContentEncoding
4. getDate
5. getExpiration
6. getLastModified

5. 訪問資源數據

1. getInputStream

setRequestProperty方法，設置「名-值」對

1. String input = username +":"+ password;
2. String encoding = base64Encode(input);
3. connection.setRequestProperty("Authorization","Basic "+ encoding);

java.net.URL 1.0

1. InputStream openStream()//打開一個用於讀取資源數據的輸入流
2. URLConnection openConnection()//返回一個URLConnection對象，該對象負責管理與資源之間的鏈接

java.net.URLConnection 1.0

1. void setDoInput()//若是doInput爲true，那麼用戶能夠接收來自該URLConnection的輸入
2. void setDoOutput(boolean doOutput)
3. boolean getDoOutput(boolean doOutput)//若是doOutput爲true，那麼用戶能夠將輸出發送到該URLConnection
4. void setIfModifiedSince(long time)
5. long getIfModifiedSince()//屬性ifModifiedSince用於配置URLConnection對象，使它只獲取那些自從某個給定時間以來被修改過的數據
6. void setUseCaches(boolean useCaches)
7. boolean getUseCaches()//若是useCaches爲true，那麼數據能夠從本地緩存中獲得，URLConnection自己並不維護這個緩存，緩存必須由瀏覽器之類的外部程序提供
8. void setAllowUserInteraction(boolean allowUserInteraction)
9. boolean getAllowUserInteraction()//若是爲true，那麼能夠查詢用戶的口令
10. void setConnectTimeout(int timeout)
11. int getConnectionTimeout()//設置或獲得鏈接超時時限
12. void setRequestProperty(String key,String value)//設置請求頭的一個字段
13. Map<String,List<String>> getRequestProperties()//返回請求頭屬性的一個映射表，相同的鍵對應的全部值被放置在同一個映射表中
14. void connect()//鏈接遠程資源並獲取響應頭信息
15. Map<String,List<String>>Map getHeaderFields()//返回響應的一個映射表，相同的鍵對應的全部值被放置在同一個映射表中
16. String getHeaderFieldKey(int n)//獲得響應頭第n個字段的鍵，若是n等於0或大於響應頭字段的總數返回null值
17. String getHeaderField(int n)//獲得響應頭第n個字段的值
18. int getContentLength()//若是知道內容長度，則返回該長度值，不然返回-1
19. String getContentType()//獲取內容的類型，好比text/plain或image/gif
20. String getContentEncoding()//獲取內容的編碼，好比gzip
21. long getDate()
22. long getExpiration()
23. long getLastModified()//獲取建立日期、過時日以及最後一次被修改的日期
24. InputStream getInputStream()
25. OutputStream getOutputStream()//返回從資源讀取信息或向資源寫入信息的流
26. Object getContent()//選擇適當的內容處理器，以便讀取資源數據並將它轉換成對象。該方法不能用於讀取諸如text/plain或image/gif之類的標準內容類型，除非安裝了本身的內容處理器

提交表單數據

GET和POST命令，向Web服務器發送信息

URL編碼模式編碼，參數規則：

保留字符A-Z、a-z、0-9以及 . - * _

用+字符替換全部的空格

將其餘全部字符編碼爲UTF-8，並將每一個字節都編碼爲%後面緊跟一個兩位的十六進制數字

使用POST命令的方法：

1. URL url =new URL("http://host/script");
2. URLConnection connection = url.openConnection();
3. connection.setDoOutput(true);
4. PrintWriter out =newPrintWriter(connection.getOutputStream());
5. out.print(name1 +"="+URLEncoder.encode(value1,"UTF-8")+"&");
6. out.print(name2 +"="+URLEncoder.encode(value2,"UTF-8"));
7. out.close();

java.net.HttpURLConnection 1.0

1. InputStream getErrorStream()//返回一個流，經過這個流能夠讀取Web服務器的錯誤信息

java.net.URLEncoder 1.0

1. staticString encode(String s,String encoding)//採用指定的字符編碼模式對字符串s進行編碼，並返回它的URL編碼形式

java.net.URLDecoder 1.2

1. staticString decode(String s,String encoding)//採用指定編碼模式對已編碼字符串s進行解碼，並返回結果

 

第三章--數據庫編程----------------------------------------------

JDBC的典型用法

客戶端（可視化表示） ---HTTP、RMI---> 中間層（業務邏輯） ---JDBC-數據庫協議->數據庫服務器 

 

JDBC URL通常語法：

jdbc:subprotocol:other stuff

 

註冊驅動器類

Class.forName("org.postgresql.Driver");

或者

java -Djdbc.drivers=org.postgresql.Driver ProgramName

或者

System.setProperty("jdbc.drivers", "org.postgresql.Driver");

 

鏈接到數據庫

1. String url ="jdbc:postgresql:COREJAVA";
2. String username ="dbuser";
3. String password ="scret";
4. Connection conn =DriverManager.getConnection(url, username, password);

java.sql.DriverManager 1.1

1. staticConnection getConnection(String url,String user,String password)//創建一個到指定數據庫的鏈接，並返回一個Connection對象

 

執行SQL語句

java.sql.Connection 1.1

1. Statement createStatement()//建立一個Statement對象，用以執行不帶參數的SQL查詢和更新
2. void close()//用於當即關閉當前的鏈接以及釋放由它所建立的JDBC資源

java.sql.Statement 1.1

1. ResultSet executeQuery(String sqlQuery)//執行給定字符串中的SQL語句，並返回一個用於查看查詢結果的ResultSet對象
2. int executeUpdate(String sqlStatement)//執行字符串中指定的INSERT、UPDATE或DELETE等SQL語句，也能夠執行CREATE TABLE等語句，返回受影響的記錄總數
3. boolean execute(String sqlStatement)//執行字符串中指定的SQL語句，可能會產生多個結果集和更新數。若是第一個執行結果是結果集，則返回true，反之返回false。調用getResultSet或getUpdateCount方法能夠獲得第一個執行結果
4. ResultSet getResultSet()//返回前一條查詢語句的結果集，若是前一條語句未產生結果集則返回null值，對於每一條執行過的語句，該方法只能被調用一次
5. void close()//關閉Statement對象以及它所對應的結果集
6. boolean isClosed()//若是語句被關閉返回true

java.sql.ResultSet 1.1

1. boolean next()//將結果集中的當前行向前移動一行。若是已經到達最後一行的後面，返回false，注意初始狀況必須調用該方法才能轉到第一行
2. Xxx getXxx(int columnNumber)
3. Xxx getXxx(String columnName)//用給定的列序號或列標籤返回該列的值，並將之轉換成指定類型
4. int findColumn(String columnName)//根據給定的列名，返回該列的序號
5. void close()//當即關閉當前的結果集
6. boolean isClosed()//若是語句被關閉，則返回true

 

管理鏈接、語句和結果集

分析SQL異常

每一個SQLException都有一個由多個SQLException對象構成的鏈，這些對象能夠經過getNextException方法獲取

java.sql.SQLException 1.1

1. SQLException getNextException()//返回連接到該SQL異常的下一個SQL異常，或者在到達鏈尾時返回null
2. Iterator<Throwable> iterator()//獲取迭代器，能夠迭代連接的SQL異常和它們的成因
3. String getSQLState()//獲取「SQL狀態」，即標準化的錯誤代碼
4. int getErrorCode()//獲取提供商相關的錯誤代碼

java.sql.Warning 1.1

1. SQLWarning getNextWarning()//返回連接到該警告的下一個警告，或者在到達鏈尾時返回null

java.sql.Connection 1.1

java.sql.Statement 1.1

java.sql.ResultSet 1.1

1. QLWarning getWarnings()
2. SQLWarning getWarnings()//返回未處理警告中的第一個，或者在沒有未處理警告時返回null

java.sql.DataTruncation 1.1

1. boolean getParameter()//若是在參數上進行了數據截斷，則返回true，若是在列上進行了數據截斷返回false
2. int getIndex()//返回被截斷的參數和列的索引
3. int getDataSize()//返回應該被傳輸的字節數量，或者在該值未知的狀況下返回-1
4. int getTransferSize()//返回實際被傳輸的字節數量，或者在該值未知的狀況下返回-1

元數據

1. ResultSet result = stat.getResultSet();
2. ResultSetMetaData metaData = result.getMetaData();
3. int columnCount = metaData.getColumnCount();
4. metaData.getColumnLabel(i);

預備語句

佔位符?

 

1. PreparedStatementPublisherQueryStat= conn.prepareStatement(publisherQuery);
2. publisherQueryStat.setString(1, publisher);
3. ResultSet rs = publisherQueryStat.executeQuery();

java.sql.Connection 1.1

1. PreparedStatement prepareStatement(String sql)//返回一個含預編譯語句的PreparedStatement對象

java.sql.PreparedStatement 1.1

1. void setXxx(int n,Xxx x)//設置第n個參數值爲x
2. void clearParameters()//清除預備語句中的全部當前參數
3. ResultSet executeQuery()//執行預備SQL查詢，並返回一個ResultSet對象
4. int executeUpdate()//執行預備SQL語句INSERT UPDATE或DELETE，返回受影響的記錄數，若是執行CREATE TABLE,返回0

讀寫LOB

二進制大對象稱爲BLOB，字符型大對象稱爲CLOB

獲取一張圖像：

1. PreparedStatement stat = conn.preapareStatement("SELECT Cover FROM BookCovers WHERE ISBN=?");
2. stat.set(1, isbn);
3. ResultSet result = stat.executeQuery();
4. if(result.next()){
5. Blob coverBlob = result.getBlob(1);
6. Image coverImage =ImageIO.read(coverBlob.getInputstream());
7. }

 

存儲一張圖像：

1. Blob coverBlob = connection.createBlob();
2. int offset =0;
3. OutputStream out = coverBlob.setBinaryStream(offset);
4. ImageIO.write(coverImage,"PNG", out);
5. PreparedStatement stat = conn.prepareStatement("INSET INTO Cover VALUES (?, ?)");
6. stat.set(1, isbn);
7. stat.set(2, coverBlob);
8. stat.executeUpdate();

java.sql.ResultSet 1.1

1. Blob getBlob(int columnIndex)
2. Blob getBlob(String columnLabel)
3. Clob getClob(int columnIndex)
4. Clob getClob(String columnLabel)//獲取給定列的BLOB或CLOB

java.sql.Blob 1.2

1. long length()//獲取該BLOB的長度
2. byte[] getBytes(long startPosition,long length)//獲取該BLOB中給定範圍的數據
3. InputStream getBinaryStream()
4. InputStream getBinaryStream(long startPosition,long length)//返回一個輸入流，用於讀取該BLOB中所有或給定範圍的數據
5. OutputStream setBinaryStream(long startPosition)//返回一個輸出流，用於從給定位置開始寫入該BLOB

java.sql.Clob 1.4

1. long length()//獲取該CLOB中的字符總數
2. String getSubString(long startPosition,long length)//獲取該CLOB中給定範圍的字符
3. Reader getCharacterStream()
4. Reader getCharacterStream(long startPosition,long length)//返回一個讀入器（而不是流），用於讀取CLOB中所有或給定範圍的數據
5. Writer setCharacterStream(long startPosition)//返回一個寫出器（而不是流），用於從給定位置開始寫入該CLOB

java.sql.Connection 1.1

1. Blob createBlob()
2. Clob createClob()//建立一個空的BLOB或CLOB

 

SQL轉義

轉義主要用於下列特性：

日期和時間字面常量

調用標量函數

調用存儲過程

外鏈接

在LIKE子句中的轉義字符

 

多結果集

遍歷execute全部結果：

1. boolean done =false;
2. boolean isResult = stmt.execute(command);
3. while(!done){
4. if(isResult){
5. ResultSet result = stmt.getResultSet();
6. do something with result
7. }else{
8. int updateCount = stmt.getUpdateCount();
9. if(updateCount >=0)
10. do something with updateCount
11. else
12. done =true;
13. }
14. isResult = stmt.getMoreResults();
15. }

java.sql.Statement 1.1

1. boolean getMoreResults()//獲取該語句的下一個結果集，若是存在返回true

 

獲取自動生成鍵

1. stmt.executeUpdate(insertStatement,Statement.RETURN_GENERATED_KEYS);
2. ResultSet rs = stmt.getGeneratedKeys();
3. if(rs.next()){
4. int key = rs.getInt(1);
5. ...
6. }

java.sql.Statement 1.1

1. boolean execute(String statement,int autogenerated)
2. int executeUpdate(String statement,int autogenerated)//若是autogenerated被設置爲Statement.RETURN_GENERATED_KEYS，而且該語句是一條INSERT語句，那麼第一列中就是自動生成的鍵

 

可滾動和可更新的結果集

1. Statement stat = conn.createStatement(type, concurrency);
2. PreparedStatement stat = conn.prepareStatement(command, type, concurrency);

ResultSet類的type值

TYPE_FORWARD_ONLY	結果集不能滾動
TYPE_SCROLL_INSENSITIVE	結果集能夠滾動，但對數據庫變化不敏感
TYPE_SCROLL_SENSITIVE	結果集能夠滾動，且對數據庫變化敏感

ResultSet類的Concurrency值

CONCUR_READ_ONLY	結果集不能用於更新數據庫
CONCUR_UPDATE	結果集能夠用於更新數據庫

須要用getType和getConcurrency方法先檢查結果集的功能再使用，不然可能拋出SQLException異常

在結果集上的滾動

1. if(rs.previous())...

將遊標向後或向前移動多行

1. rs.relative(n);

將遊標設置到指定的行號上

1. rs.absolute(n);
2. int currentRow = rs.getRow();

得到可更新的結果集

1. Statement stat = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);

迭代遍歷全部結果並更新相關內容

1. String query ="SELECT * FROM Books";
2. ResultSet rs = stat.executeQuery(query);
3. while(rs.next()){
4. if(...){
5. double increase =...
6. double price = rs.getDouble("Price");
7. rs.updateDouble("Price", price + increase);
8. rs.updateRow();
9. }
10. }

添加新行

1. rs.moveToInsertRow();
2. rs.updateString("Title", title);
3. rs.updateString("ISBN", isbn);
4. rs.updateString("Publisher_Id", pubid);
5. rs.updateDouble("Price", price);
6. rs.insertRow();
7. rs.moveToCurrentRow();

刪除行

1. rs.deleteRow();

java.sql.Connection 1.1

1. Statement createStatement(int type,int concurrency)
2. PreparedStatement prepareStatement(String command,int type,int concurrency)//建立一個語句或預備語句，且該語句能夠產生指定類型和併發模式的結果集

java.sql.ResultSet 1.1

1. int getType()//返回結果集的類型
2. int getConcurrency()//返回結果集的併發設置
3. boolean previous()//把光標移動到前一行
4. int getRow()//獲得當前行的序號
5. boolean absolute(int r)//移動光標到第r行
6. boolean relative(int d)//將光標移動d行，若是d爲負數，則光標向後移動，若是光標位於某一行上，返回true
7. boolean first()
8. boolean last()//移動光標到第一行或最後一行
9. void beforeFirst()
10. void afterLast()//移動光標到第一行以前或最後一行以後的位置
11. boolean isFirst()
12. boolean isLast()//測試光標是否在第一行或最後一行
13. boolean isBeforeFirst()
14. boolean isAfterLast()//測試光標是否在第一行以前或最後一行以後的位置
15. void moveToInsertRow()//移動光標到插入行
16. void moveToCurrentRow()//將光標從插入行移回到調用moveToInsertRow以前所在那一行
17. void insertRow()//將插入行上的內容插入到數據庫和結果集中
18. void deleteRow()//從數據庫和結果集中刪除當前行
19. void updateXxx(int column,Xxx data)
20. void updateXxx(String columnName,Xxx data)//更新結果中當前行上的某個字段值
21. void updateRow()//將當前行的更新信息發送到數據庫
22. void cancelRowUpdates()//撤銷對當前行的更新

java.sql.DatabaseMetaData 1.1

1. boolean supportsResultSetType(int type)//若是數據庫支持給定類型的結果集，則返回true
2. boolean supportsResultSetConcurrency(int type,int concurrency)//若是數據庫支持給定類型和併發模式的結果集，則返回true

 

行集

CachedRowSet

WebRowSet

FilteredRowSet

JoinRowSet

JdbcRowSet

 

被緩存的行集

使用一個結果集來填充CachedRowSet對象

1. ResultSet result =...;
2. CachedRowSet crs =new com.sun.rowset.CachedRowSetImpl();
3. crs.populate(result);
4. conn.close();

或者可讓CachedRowSet對象自動建立一個數據庫鏈接並將查詢結果填充到行集，最後斷開鏈接

1. crs.setURL("jdbc:derby://localhost:1527/COREJAVA");
2. crs.setUsername("dbuser");
3. crs.setPassword("secret");
4. crs.setCommand("SELECT * FROM Books WHERE PUBLISHER = ?");
5. crs.setString(1, publisherName);
6. crs.execute();

指定每一頁尺寸

1. CachedRowSet crs =...;
2. crs.setCommand(command);
3. crs.setPageSize(20);
4. ...
5. crs.execute();
6. crs.nextPage();

將修改寫回到數據庫中

1. crs.acceptChanges(conn);
2. 或
3. crs.acceptChanges();//這個方法只有設置鏈接數據庫所需信息纔有效

javax.sql.RowSet 1.4

1. String getURL()
2. void setURL(String url)//獲取或設置數據庫的URL
3. String getUsername()
4. void setUsername(String username)//獲取或設置鏈接數據庫所需的用戶名
5. String getPassword()
6. void setPassword(String password)//獲取或設置鏈接數據庫所需的密碼
7. String getCommand()
8. void setCommand(String command)//獲取或設置向行集中填充數據時須要執行的命令
9. void execute()//經過執行使用setCommand方法設置的命令集來填充行集。爲了使驅動管理器能夠得到鏈接，必須事先設定URL、用戶名和密碼

javax.sql.rowset.CachedRowSet 5.0

1. void execute(Connection conn)//經過執行使用setCommand方法設置的命令集來填充行集，該方法使用給定的鏈接，並負責關閉它
2. void populate(ResultSet result)//將指定的結果集中的數據填充到被緩存的行集中
3. String getTableName()
4. void setTableName(String tableName)//獲取或設置數據庫表名稱，填充被緩存的行集時所需的數據來自於該表
5. int getPageSize()
6. void setPageSize(int size)//獲取和設置頁的尺寸
7. boolean nextPage()
8. boolean previousPage()//加載下一頁或上一頁，若是要加載的頁存在，返回true
9. void acceptChanges()
10. void acceptChanges(Connection conn)//從新鏈接數據庫，並寫回行集中修改過的數據，若是由於數據庫中的數據已經被修改而致使沒法寫回行集中的數據，該方法可能會拋出SyncProviderException異常

 

元數據

描述數據庫或其組成部分的數據稱爲元數據

獲取數據庫全部表名（第三列是表名）

1. DatabaseMetaData meta = conn.getMetaData();
2. ResultSet mrs = meta.getTables(null,null,null,newString[]{"TABLE"});
3. while(mrs.next())
4. tableNames.addItem(mrs.getString(3));

經過ResultSetMetaData提供結果集的相關信息，如每一列的名稱、類型和字段寬度：

1. ResultSet mrs = stat.executeQuery("SELECT * FROM "+ tableName);
2. ResultSetMetaData meta = mrs.getMetaData();
3. for(int i =1; i <= meta.getColumnCount(); i++){
4. String columnName = meta.getColumnLabel(i);
5. int columnWidth = meta.getColumnDisplaySize(i);
6. ...
7. }

java.sql.Connection 1.1

1. DatabaseMetaData getMetaData()//返回一個DatabaseMetaData對象，該對象封裝了有關數據庫鏈接的元數據

java.sql.DatabaseMetaData 1.1

1. ResultSet getTables(String catalog,String schemaPattern,String tableNamePattern,String types[])//返回某個目錄中的全部表的描述，該目錄必須符合給定的模式（schema）、表名字模式以及類型標準
2. int getJDBCMajorVersion()
3. int getJDBCMinorVersion()//返回創建數據庫鏈接的JDBC驅動程序的主版本號和次版本號
4. int getMaxConnections()//返回可同時鏈接到數據庫的最大鏈接數
5. int getMaxStatements()//返回單個數據庫鏈接容許同時打開的最大語句數

java.sql.ResultSet 1.1

1. ResultSetMetaData getMetaData()//返回與當前ResultSet對象中的列相關的元數據

java.sql.ResultSetMetaData 1.1

1. int getColumnCount()//返回當前ResultSet對象中的列數
2. int getColumnDisplaySize(int column)//返回給定列序號的列的最大寬度
3. String getColumnLabel(int column)//返回該列所建議的名稱
4. String getColumnName(int column)//返回指定的列序號所對應的列名

 

事務

回滾（rollback）

默認爲自動提交模式（autocommit mode）

1. conn.setAutoCommit(false);
2. Statement stat = conn.createStatement();
3. stat.executeUpdate(command1);
4. stat.executeUpdate(command2);
5. ...
6. conn.commit();
7. 若是出現錯誤，請調用：
8. conn.rollback();

保存點

1. Statement stat = conn.createStatement();//start transaction; rollback() goes here
2. stat.executeUpdate(command1);
3. Savepoint svpt = conn.setSavepoint();//set savepoint; rollback(svpt) goes here
4. stat.executeUpdate(command2);
5. if(...) conn.rollback(svpt);//undo effect of command2
6. ...
7. conn.commit();
8. conn.releaseSavepoint(svpt);

批量更新

使用DatabaseMetaData類中的supportsBatchUpdates方法能夠獲知數據庫是否支持這種特性

能夠是INSERT、UPDATE、DELETE等操做，也能夠是CREATE TABLE和DROP TABLE，但不能夠是SELECT命令，會拋異常

1. Statement stat = conn.createStatement();
2. String command ="CREATE TABLE ...";
3. stat.addBatch(command);
4. while(...){
5. command ="INSERT INTO ... VALUES ("+...+")";
6. stat.addBatch(command);
7. }
8. int[] counts = stat.executeBatch();

java.sql.Connection 1.1

1. boolean getAutoCommit()
2. void setAutoCommit(boolean b)//獲取該鏈接中的自動提交模式，或將其設置爲b
3. void commit()//提交自上次提交以來全部執行過的語句
4. void rollback()//撤銷自上次提交以來全部執行過的語句所產生的影響
5. Savepoint setSavepoint()
6. Savepoint setSavepoint(String name)//設置一個匿名或具名的保存點
7. void rollback(Savepoint svpt)//回滾到給定保存點
8. void releaseSavepoint(Savepoint svpt)//釋放給定的保存點

java.sql.Savepoint 1.4

1. int getSavepointId()//獲取該匿名保存點的ID號，若是有名字則拋出SQLException異常
2. String getSavepointName()//獲取該保存點的名稱，若是爲匿名保存點則拋出SQLException異常

java.sql.Statement 1.1

1. void addBatch(String command)//添加命令到當前批量命令中
2. int[] executeBatch()//執行當前批量更新中的全部命令，返回一個記錄數的數組

java.sql.DatabaseMetaData 1.1

1. boolean supportsBatchUpdates()//若是驅動程序支持批量更新，返回true

 

Web與企業應用中的鏈接管理

經過目錄接口（JNDI）查找

1. Context jndiContext =newInitialContext();
2. DataSource source =(DataSource) jndiContext.lookup("java:comp/env/jdbc/corejava");
3. Connection conn = source.getConnection();

 

LDAP介紹

輕量級目錄訪問協議（Lightweight Directory Access Protocol, LDAP）

通用的LDAP屬性

屬性ID	意義
dc	域構件
cn	通用名
sn	姓
dn	專有名稱
o	組織
ou	組織單元
uid	惟一標識符

訪問LDAP目錄信息

1. Hashtable env =newHashtable();
2. env.put(Context.SECURITY_PRINCIPAL, username);
3. env.put(Context.SECURITY_CREDENTIALS, password);
4. DirContext initial =newInitialDirContext(env);
5. DirContext context =(DirContext) initial.lookup("ldap://localhost:389");

javax.naming.directory.InitialDirContext 1.3

1. InitialDirContext(Hashtable env)//使用給定的環境設置建立一個目錄上下文，散列表包含了Context.SECURITY_PRINCIPAL、Context.SECURITY_CREDENTIALS以及其餘鍵的相關信息

javax.naming.Context 1.3

1. Object lookup(String name)//使用給定的名稱查找對象，返回一般爲一棵子樹或一個葉對象
2. Context createSubcontext(String name)//使用給定的名字建立一個子上下文
3. void destroySubcontext(String name)//根據給定的名稱刪除其對應的子上下文
4. void close()//關閉該上下文

javax.naming.directory.DirContext 1.3

1. Attributes getAttributes(String name)//根據給定的名稱，獲得其對應條目的屬性
2. void modifyAttributes(String name,int flag,Attributes modes)//根據給定的名稱，修改其對應條目的屬性，flag爲如下常量之一：DirContext.ADD_ATTRIBUTE、DirContext.REMOVE_ATTRIBUTE或DirContext.REPLACE_ATTRIBUTE

javax.naming.directory.Attributes 1.3

1. Attribute get(String id)//根據給定的ID，獲得其對應的屬性
2. NamingEnumeration<?extendsAttribute> getAll()//返回一個枚舉對象，用於迭代遍歷該屬性的全部值
3. Attribute put(Attribute attr)
4. Attribute put(String id,Object value)//將一個屬性添加到屬性集合中

javax.naming.directory.BasicAttributes 1.3

1. BasicAttributes(String id,Object value)//使用給定的ID和值，構造一個屬性集合，該集合只包含了單個屬性

javax.naming.directory.Attribute 1.3

1. String getId()//獲取該屬性的ID
2. Object get()//若是值已排好序，則獲取該屬性的第一個值，未排序則返回其中任意一個值
3. NamingEnumeration<?> getAll()//返回一個枚舉對象，用於迭代遍歷該屬性的全部值

javax.naming.NamingEnumeration<T> 1.3

1. boolean hasMore()//若是該對象還包含其餘元素，返回true
2. T next()//返回下一個元素