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();
}
}