java IO学习笔记[2]

 

我昨天在写java网络编程的时候想到这样几个问题，现在总结一下。

 

一：TCP编程是面向字节流的

      我用socket编程，是基于TCP/IP的，而TCP协议是传输层的协议，它是面向连接的，与UDP很大的不同在于前者是面向字节流的协议，而后者是用户数据报协议（User Datagram Protocol ），面向字节流有一个很大的好处，那就是可以进行拥塞控制，进行流量控制，进行差错控制。

       为什么UDP不行呢？是因为UDP应用层给传输层什么数据报，传输层就发送什么数据报，根本不管它有多少个字节，传输太多是不是会造成阻塞。而TCP就不一样了，应用层让传输层传输数据的时候，传输层并不会直接发送，而是从缓冲区一个字节一个字节的拿出来，TCP发送端是有发送窗口的，这个窗口就是TCP进行流量控制，差错控制的核心。而接收端又是有接收窗口的，总之通过窗口直接的滑动（或者快了，或者顺序乱了，或者帧丢失了），来进行以上的控制。

       那么java在进行socket编程的时候只能使用字节流了？答案并不是这样

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.InputStream;

public class Server1 {
/**服务器端*/
	public static void main(String[] args) throws IOException{
		ServerSocket ss = new ServerSocket(5678);
		
		Socket socket = ss.accept();
		
		PrintWriter out = new PrintWriter(socket.getOutputStream());
		
		BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream()));  
		
		while(true)
		{
			String str=in.readLine();  
			System.out.println(str);
			out.println("hello world");
			out.flush();
			
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * socket编程的客户端
 * */
public class Client1 
public static void main(String[] args)throws Exception{  
	Socket server=new Socket("localhost",5678);  
	BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream()));  
	PrintWriter out=new PrintWriter(server.getOutputStream());  
	BufferedReader wt=new BufferedReader(new InputStreamReader(System.in));  
	while(true){  
		String str=wt.readLine();  
		out.println(str);  
		out.flush();  
		if(str.equals("end")){  
			break;  
			}  
		System.out.println(in.readLine());  
		}  
	server.close();  
	}  
}

以上的代码给人一种使用了面向字符流的假象，其实我们可以看到这里的字符流其实是对字节流进行了封装，这里应该是适配器模式，把一个字节流转化成了一个字符流 ，server.getInputStream()方法的源码是，可以看到它实际返回的是字节流。

public InputStream getInputStream() throws IOException

 

二：print和println的区别到底是什么

 

在socket编程中，如果使用PrintWriter类作为输出流，那么为什么一定要println(String str)，而不是print()。

       在我的印象中println只是在print的后面加上一个换行符，估计大部分人跟我的想法一样，可是，看了一下源码发现

/**
     * Prints a String and then terminate the line.  This method behaves as
     * though it invokes <code>{@link #print(String)}</code> and then
     * <code>{@link #println()}</code>.
     *
     * @param x  The <code>String</code> to be printed.
     */
    public void println(String x) {
	synchronized (this) {
	    print(x);
	    newLine();
	}
    }

 public void print(String s) {
	if (s == null) {
	    s = "null";
	}
	write(s);
    }

 

 从上面的两个方法至少可以看到两点1：println方法是线程安全的:2：多了一个newLine()方法。

那么newLine()是个什么方法呢？

   /**
    private BufferedWriter textOut;
    */
	
	private void newLine() {
	try {
	    synchronized (this) {
		ensureOpen();
		textOut.newLine();
		//在BufferedWriter类中 newLine方法只是写一个换行符
		 /**
		 * Writes a line separator.  The line separator string is defined by the
		 * system property <tt>line.separator</tt>, and is not necessarily a single
		 * newline ('\n') character.
		 *
		 * @exception  IOException  If an I/O error occurs
		 *
			 public void newLine() throws IOException {
			 write(lineSeparator);
			 }
		*/
		/**
		 * Flushes the output buffer to the underlying character stream, without
		 * flushing the stream itself.  This method is non-private only so that it
		 * may be invoked by PrintStream.
		   这里的意思是说刷新输出流到存在下面的字符流，而不需要刷新这个流本身
		   
        */
		textOut.flushBuffer();
		/*
		   那么这里到底做了什么呢？
		*/
		charOut.flushBuffer();
		if (autoFlush)
		    out.flush();
	    }
	}
	catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	}
	catch (IOException x) {
	    trouble = true;
	}
    }

  也就是说println方法比print做的事情多得多。它有终止改行，刷新缓冲区的功能，而print却没有，当使用print输出的时候，没有刷新，也没有终止，而只是单独的写入进去。

 

那么，刷新一个缓冲区到底在底层是做了什么呢。