java网络编程

package senssic.demo;

import java.io.InputStream;
import java.net.InetAddress;
import java.net.URL;
import java.net.URLConnection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

class Info {
	private InetAddress iAddress = null;
	private URL url = null;
	private URLConnection uConnection = null;

	public Info() {
		try {
			AddressInfo("www.baidu.com/index.php");
			URLInfo("http://www.csdn.net");
			URLConnectionInfo();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void AddressInfo(String host) throws Exception {
		iAddress = InetAddress.getByName(host);
		System.out.println("主机的ip：" + iAddress.getHostAddress());
	}

	public void URLInfo(String urlpath) throws Exception {
		url = new URL(urlpath);
		System.out.println("此url的授权部分为：" + url.getAuthority()
				+ "\t此url协议默认的端口号：" + url.getDefaultPort() + "\t此url的主机名："
				+ url.getHost() + "\t此url的协议：" + url.getProtocol());

	}

	public void URLConnectionInfo() throws Exception {
		uConnection = url.openConnection();
		InputStream iStream = uConnection.getInputStream();
		System.out.println("网页头编码:" + uConnection.getContentEncoding()
				+ "\t网页头类型：" + uConnection.getContentType());
		Map<String, List<String>> map = uConnection.getHeaderFields();
		for (Map.Entry<String, List<String>> mEntry : map.entrySet()) {
			List<String> list = mEntry.getValue();
			String string = null;
			for (Iterator iterator = list.iterator(); iterator.hasNext();) {
				string = "\t" + (String) iterator.next();
			}
			System.out.println(mEntry.getKey() + "--->" + string);
		}
		Scanner scanner = new Scanner(iStream);
		scanner.useDelimiter("\n");
		while (scanner.hasNext()) {
			System.out.println(scanner.next());

		}
	}
}

public class NetClass {

	public static void main(String[] args) throws Exception {
		Info info = new Info();

	}

}

运行结果：

主机的ip：120.209.131.70
此url的授权部分为：www.csdn.net 此url协议默认的端口号：80此url的主机名：www.csdn.net此url的协议：http
网页头编码:null 网页头类型：text/html; charset=utf-8
null---> HTTP/1.0 200 OK
Switch---> FSCS
Age---> 45539
Vary---> Accept-Encoding
Date---> Sun, 25 Aug 2013 07:09:11 GMT
Content-Length---> 86617
Expires---> Mon, 26 Aug 2013 07:09:11 GMT
Last-Modified---> Sun, 25 Aug 2013 07:00:01 GMT
Accept-Ranges---> bytes
Content-Type---> text/html; charset=utf-8
Server---> nginx

udp：

服务端：

import java.net.DatagramPacket ;
import java.net.DatagramSocket ;
import java.net.InetAddress ;

public class UDPServer{
	public static void main(String args[]) throws Exception{	// 所有异常抛出
		DatagramSocket ds = null ;		// 定义发送数据报的对象
		DatagramPacket dp = null ;		// 声明DatagramPacket对象
		ds = new DatagramSocket(3000) ;	// 服务端在3000端口上等待服务器发送信息\
		String str = "hello World!!!" ;
		dp = new DatagramPacket(str.getBytes(),str.length(),InetAddress.getByName("localhost"),9000) ; // 所有的信息使用buf保存
		System.out.println("发送信息。") ;
		ds.send(dp);	// 发送信息出去
		ds.close() ;
	}
};

客户端：

import java.net.DatagramPacket ;
import java.net.DatagramSocket ;

public class UDPClient{
	public static void main(String args[]) throws Exception{	// 所有异常抛出
		DatagramSocket ds = null ;		// 定义接收数据报的对象
		byte[] buf = new byte[1024] ;	// 开辟空间，以接收数据
		DatagramPacket dp = null ;		// 声明DatagramPacket对象
		ds = new DatagramSocket(9000) ;	// 客户端在9000端口上等待服务器发送信息
		dp = new DatagramPacket(buf,1024) ; // 所有的信息使用buf保存
		ds.receive(dp)  ;	// 接收数据
		String str = new String(dp.getData(),0,dp.getLength()) + "from " + 
			dp.getAddress().getHostAddress() + "：" + dp.getPort() ;
		System.out.println(str) ;	// 输出内容
	}
};

tcp：

服务端：

package senssic;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
 
public class SocketServer {
    public static void main(String[] args) {
        try {
            /** 创建ServerSocket*/
            // 创建一个ServerSocket在端口2013监听客户请求
            ServerSocket serverSocket =new ServerSocket(2013);
            while (true) {
                // 侦听并接受到此Socket的连接,请求到来则产生一个Socket对象，并继续执行
                Socket socket = serverSocket.accept();
 
                /** 获取客户端传来的信息 */
                // 由Socket对象得到输入流，并构造相应的BufferedReader对象
                BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
                // 获取从客户端读入的字符串
                String result = bufferedReader.readLine();
                System.out.println("Client say : " + result);
 
                /** 发送服务端准备传输的 */
                // 由Socket对象得到输出流，并构造PrintWriter对象
                PrintWriter printWriter =new PrintWriter(socket.getOutputStream());
                printWriter.print("hello Client, I am Server!");
                printWriter.flush();
 
                /** 关闭Socket*/
                printWriter.close();
                bufferedReader.close();
                socket.close();
            }
        }catch (Exception e) {
            System.out.println("Exception:" + e);
        }finally{
//          serverSocket.close();
        }
    }
}

客户端：

package senssic;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
 
public class SocketClient {
    public static void main(String[] args) {
        try {
            /** 创建Socket*/
            // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号(本处是本机)
            Socket socket =new Socket("127.0.0.1",2013);
            // 60s超时
            socket.setSoTimeout(60000);
 
            /** 发送客户端准备传输的信息 */
            // 由Socket对象得到输出流，并构造PrintWriter对象
            PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);
            // 将输入读入的字符串输出到Server
            BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
            printWriter.println(sysBuff.readLine());
            // 刷新输出流，使Server马上收到该字符串
            printWriter.flush();
 
            /** 用于获取服务端传输来的信息 */
            // 由Socket对象得到输入流，并构造相应的BufferedReader对象
            BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 输入读入一字符串
            String result = bufferedReader.readLine();
            System.out.println("Server say : " + result);
 
            /** 关闭Socket*/
            printWriter.close();
            bufferedReader.close();
            socket.close();
        }catch (Exception e) {
            System.out.println("Exception:" + e);
        }
    }
}

多线程服务tcp：

服务端：

package senssic.demo;

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

public class Server {
	private static final int SERVER_PORT = 2013;

	public Server() throws IOException {

		ServerSocket serverSocket = new ServerSocket(SERVER_PORT);
		try {
			while (true) {
				Socket socket = serverSocket.accept();
				new CreateServerThread(socket);// 当有请求时，启一个线程处理
			}
		} catch (IOException e) {
		} finally {
			serverSocket.close();
		}
	}

	// 线程类
	class CreateServerThread extends Thread {
		private final Socket client;
		private final BufferedReader bufferedReader;
		private final PrintWriter printWriter;

		public CreateServerThread(Socket s) throws IOException {
			client = s;

			bufferedReader = new BufferedReader(new InputStreamReader(
					client.getInputStream()));

			printWriter = new PrintWriter(client.getOutputStream(), true);
			System.out.println("Client(" + getName() + ") come in...");

			start();
		}

		@Override
		public void run() {
			try {
				String line = bufferedReader.readLine();

				while (!line.equals("bye")) {
					printWriter.println("continue, Client(" + getName() + ")!");
					line = bufferedReader.readLine();
					System.out
							.println("Client(" + getName() + ") say: " + line);
				}
				printWriter.println("bye, Client(" + getName() + ")!");

				System.out.println("Client(" + getName() + ") exit!");
				printWriter.close();
				bufferedReader.close();
				client.close();
			} catch (IOException e) {
			}
		}
	}

	public static void main(String[] args) throws IOException {
		new Server();
	}
}

客户端：

package senssic.demo;

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

public class SocketClient {
	public static void main(String[] args) {
		try {
			Socket socket = new Socket("127.0.0.1", 2013);
			socket.setSoTimeout(60000);

			PrintWriter printWriter = new PrintWriter(socket.getOutputStream(),
					true);
			BufferedReader bufferedReader = new BufferedReader(
					new InputStreamReader(socket.getInputStream()));

			String result = "";
			while (result.indexOf("bye") == -1) {
				BufferedReader sysBuff = new BufferedReader(
						new InputStreamReader(System.in));
				printWriter.println(sysBuff.readLine());
				printWriter.flush();

				result = bufferedReader.readLine();
				System.out.println("Server say : " + result);
			}

			printWriter.close();
			bufferedReader.close();
			socket.close();
		} catch (Exception e) {
			System.out.println("Exception:" + e);
		}
	}
}

通过线程池来处理客户端的请求

注：线程池与多线程的区别--->线程池是有可控大小的多线程！！！(线程池首先可以启动多个服务线程并且不会再变化大小，而是循环利用有限的线程处理业务)

线程池类：

package org.senssic;

import java.util.LinkedList;

public class ThreadPool extends ThreadGroup {

	private boolean isClosed = false; // 线程池是否关闭

	// 将任务放在LinkedList中，LinkedList不支持同步，
	// 所以在添加任务和获取任务的方法声明中必须使用synchronized关键字
	private final LinkedList<Runnable> workQueue;// 表示工作队列

	private static int threadPoolID; // 表示线程池ID

	private int threadID; // 表示工作线程ID

	// 构建一个线程组
	public ThreadPool(int poolSize) { // poolSize是指线程池中工作线程的数目
		super("ThreadPool-" + (threadPoolID++)); // 线程组名
		setDaemon(true);
		workQueue = new LinkedList<Runnable>();// 创建工作队列
		for (int i = 0; i < poolSize; i++)
			new WorkThread().start(); // 创建并启动工作线程（如果工作队列为空，则所有工作线程处于阻塞状态）
	}

	// 向工作队列中添加一个任务，由工作线程去执行该任务
	public synchronized void execute(Runnable task) {
		if (isClosed) { // 线程池关闭则抛出IllegalStateException异常
			throw new IllegalStateException();
		}
		if (task != null) {
			workQueue.add(task);
			notify(); // 唤醒正在getTask()方法中等待任务的工作线程
		}
	}

	// 从工作队列中取出一个任务 ----工作线程会调用此方法
	protected synchronized Runnable getTask() throws InterruptedException {
		while (workQueue.size() == 0) {
			if (isClosed)
				return null;
			wait(); // 如果工作队列没有任务，就等待任务
		}
		return workQueue.removeFirst();
	}

	// 关闭线程池
	public synchronized void close() {
		if (!isClosed) {
			isClosed = true;
			workQueue.clear(); // 清空工作队列
			interrupt();// 中断所有工作线程，该方法继承自ThreadGroup类
		}
	}

	// 等待工作线程把所有任务执行完
	public void join() {
		synchronized (this) {
			isClosed = true;
			notifyAll(); // 唤醒还在getTask()方法中等待任务的工作线程
		}
		// activeCount()方法是ThreadGroup类的，获得线程组中当前所有活着的工作线程数目
		Thread[] threads = new Thread[activeCount()];
		// enumerate方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
		int count = enumerate(threads);
		for (int i = 0; i < count; i++) {// 等待所有工作线程运行结束
			try {
				threads[i].join(); // 等待工作线程运行结束
			} catch (InterruptedException ex) {
				System.out.println("工作线程出错:" + ex);
			}
		}
	}

	// 内部类，工作线程
	private class WorkThread extends Thread {
		public WorkThread() {
			// 加入当前的ThreadPool线程组中
			// Thread(ThreadGroup group, String name)
			super(ThreadPool.this, "WorkThread-" + (threadID++));
		}

		@Override
		public void run() {
			// isInterrupted()方法继承自ThreadGroup类，判断线程是否中断
			while (!isInterrupted()) {
				Runnable task = null;
				try {
					task = getTask(); // 得到任务
				} catch (InterruptedException ex) {
					System.out.println("获得任务异常..." + ex);
				}
				// 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
				if (task == null)
					return;

				try {
					// 运行任务，捕获异常
					task.run(); // 直接调用task的run方法
				} catch (Throwable t) {
					System.out.println("任务执行异常..." + t);
				}
			}// #while end
		}// #run end
	}// # WorkThread class end
}

服务端业务类：

package org.senssic;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Date;

public class ServerHandler implements Runnable {

	private final Socket socket;

	public ServerHandler(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {
		try {
			System.out.println("一个新的请求达到并创建  " + socket.getInetAddress() + ":"
					+ socket.getPort());
			InputStream socketIn = socket.getInputStream();
			BufferedReader br = new BufferedReader(new InputStreamReader(
					socketIn));
			OutputStream socketOut = socket.getOutputStream();
			PrintWriter pw = new PrintWriter(socketOut, true);

			String msg = null;
			while ((msg = br.readLine()) != null) {
				System.out.println("服务端受到的信息为：" + msg);
				pw.println(new Date()); // 给客户端响应日期字符串
				if (msg.equals("bye"))
					break;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (socket != null)
					socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

服务端main类：

package org.senssic;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class NetSock {

	private final int PORT = 3015;

	private final ServerSocket serverSocket;

	private final ThreadPool threadPool; // 线程池

	private final int POOL_SIZE = 4; // 单个CPU时线程池中的工作线程个数

	public NetSock() throws IOException {
		serverSocket = new ServerSocket(PORT);
		// 创建线程池
		// Runtime的availableProcessors()方法返回当前系统的CPU格式
		// 系统的CPU越多，线程池中工作线程的数目也越多
		threadPool = new ThreadPool(Runtime.getRuntime().availableProcessors()
				* POOL_SIZE);
		System.out.println("服务端启动....    端口号：" + PORT);
	}

	public void service() {
		while (true) {
			Socket socket = null;
			try {
				socket = serverSocket.accept();
				// 把与客户通信的任务交给线程池
				threadPool.execute(new ServerHandler(socket));
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String args[]) throws IOException {
		new NetSock().service();
	}
}

tcp例子：文件传送

服务端：

package senssic;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
/**
 * 服务器
 */
public class Server extends ServerSocket{
 
    private static final int PORT =2013;
     
    private ServerSocket server;
    private Socket client;
    private DataInputStream dis;
    private FileOutputStream fos;
     
    public Server()throws Exception{
        try {
            try {
                server =new ServerSocket(PORT);
                 
                while(true){
                    client = server.accept();
                     
                    dis =new DataInputStream(client.getInputStream());
                    //文件名和长度
                    String fileName = dis.readUTF();
                    long fileLength = dis.readLong();
                    fos =new FileOutputStream(new File("d:/" + fileName));
                     
                    byte[] sendBytes =new byte[1024];
                    int transLen =0;
                    System.out.println("----开始接收文件<" + fileName +">,文件大小为<" + fileLength +">----");
                    while(true){
                        int read =0;
                        read = dis.read(sendBytes);
                        if(read == -1)
                            break;
                        transLen += read;
                        System.out.println("接收文件进度" +100 * transLen/fileLength +"%...");
                        fos.write(sendBytes,0, read);
                        fos.flush();
                    }
                    System.out.println("----接收文件<" + fileName +">成功-------");
                    client.close();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(dis !=null)
                    dis.close();
                if(fos !=null)
                    fos.close();
                server.close();
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
     
    public static void main(String[] args)throws Exception {
        new Server();
    }
}

客户端：

package senssic;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.Socket;
 
/**
 * 客户端
 */
public class Client extends Socket{
     
    private static final String SERVER_IP ="127.0.0.1";
    private static final int SERVER_PORT =2013;
     
    private Socket client;
    private FileInputStream fis;
    private DataOutputStream dos;
     
    public Client(){
        try {
            try {
                client =new Socket(SERVER_IP, SERVER_PORT);
                //向服务端传送文件
                File file =new File("c:/test.doc");
                fis =new FileInputStream(file);
                dos =new DataOutputStream(client.getOutputStream());
                 
                //文件名和长度
                dos.writeUTF(file.getName());
                dos.flush();
                dos.writeLong(file.length());
                dos.flush();
                 
                //传输文件
                byte[] sendBytes =new byte[1024];
                int length =0;
                while((length = fis.read(sendBytes,0, sendBytes.length)) >0){
                    dos.write(sendBytes,0, length);
                    dos.flush();
                }
            }catch (Exception e) {
                e.printStackTrace();
            }finally{
                if(fis !=null)
                    fis.close();
                if(dos !=null)
                    dos.close();
                client.close();
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
     
    public static void main(String[] args)throws Exception {
        new Client();
    }
}