上机实验-11 网络编程

实验1 读取服务器端的文件

一、实验目的

学会使用URL对象

二、实验内容

创建一个URL对象，然后让URL对象返回输入流，通过该输入流读取URL所包含的资源文件。

import java.awt.*; 
import java.awt.event.*; 
import java.net.*; 
import java.io.*; 
import javax.swing.*; 
public class ReadURLSource { 
public static void main(String args[]) { 
new NetWin(); 
} 
} 
class NetWin extends JFrame implements ActionListener,Runnable { 
private static final long serialVersionUID = 1L; 
JButton button; 
URL url; 
JTextField inputURLText; //输入 URL 
JTextArea area; 
byte b[]=new byte[118]; 
Thread thread; 
NetWin() { 
inputURLText=new JTextField(20); 
area=new JTextArea(12,12); 
button=new JButton("确定"); 
button.addActionListener(this); 
thread=new Thread(this); 
JPanel p=new JPanel(); 
p.add(new JLabel("输入网址:")); 
p.add(inputURLText); 
p.add(button); 
add(area,BorderLayout.CENTER); 
add(p,BorderLayout.NORTH); 
setBounds(60,60,560,300); 
setVisible(true); 
validate(); 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
} 
public void actionPerformed(ActionEvent e) { 
if(!(thread.isAlive())) 
thread=new Thread(this); 
try{ thread.start(); 
} 
catch(Exception ee) { 
inputURLText.setText("我正在读取"+url); 
} } 
public void run() { 
try { int n=-1; 
area.setText(null); 
String name=inputURLText.getText().trim(); 
url = new URL(name);//【代码 1】使用字符串 name 创建 url 对象 
String hostName = url.getHost();//【代码 2】url 调用 getHost() 
int urlPortNumber = url.getPort(); 
String fileName=url.getFile(); 
InputStream in = url.openStream();//url 调用方法返回一 
个输入流 
area.append("\n 主机:"+hostName+"端口:"+urlPortNumber+ 
"包含的文件名字:"+fileName); 
area.append("\n 文件的内容如下:"); 
while((n=in.read(b))!=-1) { 
String s=new String(b,0,n); 
area.append(s); 
} 
} 
catch(MalformedURLException e1) { 
inputURLText.setText(""+e1); 
return; 
} 
catch(IOException e1) { 
inputURLText.setText(""+e1); 
return; 
} 
} 
} 

实验2 会结帐的服务器

一、实验目的

学会使用套接字读取服务器端的对象

二、实验内容

客户端和服务器建立套接字连接后，客户将如下的账单发送给服务器：

房租：2189元 水费：112.9元 电费：569元 物业费：832元

服务器返回客户端的信息是：

您的账单

房租：2189元 水费：112.9元 电费：569元 物业费：832元

总计：3699.9元

客户端

ClientItem

import java.io.*; 
import java.net.*; 
import java.util.*; 
public class ClientItem { 
public static void main(String args[]) { 
@SuppressWarnings("resource") 
Scanner scanner = new Scanner(System.in); 
Socket clientSocket=null; 
DataInputStream inData=null; 
DataOutputStream outData=null; 
Thread thread ; 
Read read=null; 
try{ clientSocket=new Socket(); 
read = new Read(); thread = new Thread(read); //负责读取信息的线程 
System.out.print("输入服务器的 IP:"); 
String IP = scanner.nextLine(); 
System.out.print("输入端口号:"); 
int port = scanner.nextInt(); 
//String enter=scanner.nextLine(); //消耗回车 
if(clientSocket.isConnected()){} 
else{ 
InetAddress address=InetAddress.getByName(IP); 
InetSocketAddress socketAddress=new 
InetSocketAddress(address,port); 
clientSocket.connect(socketAddress); 
InputStream in= clientSocket.getInputStream();// 
clientSocket 调用 getInputStream()返回该套接字的输入流 
OutputStream out= clientSocket.getOutputStream();//
clientSocket 调用 getOutputStream()返回该套接字的输出流 
inData =new DataInputStream(in); 
outData = new DataOutputStream(out); 
read.setDataInputStream(inData); 
read.setDataOutputStream(outData); 
thread.start(); //启动负责读信息的线程 
} 
} 
catch(Exception e) { 
System.out.println("服务器已断开"+e); 
} 
} 
} 

Red

class Read implements Runnable { 
Scanner scanner = new Scanner(System.in); 
DataInputStream in; 
DataOutputStream out; 
public void setDataInputStream(DataInputStream in) { 
this.in = in; 
} 
public void setDataOutputStream(DataOutputStream out) { 
this.out = out; 
} 
public void run() { 
System.out.println("输入账单:"); 
String content = scanner.nextLine(); 
try{ out.writeUTF("账单"+content); 
String str = in.readUTF(); 
System.out.println(str); str = in.readUTF(); 
System.out.println(str); 
str = in.readUTF(); 
System.out.println(str); 
} 
catch(Exception e) {} 
} 
} 

服务器端

ServerItem

import java.io.*; 
import java.net.*; 
import java.util.*; 
public class ServerItem { 
public static void main(String args[]) throws IOException { 
ServerSocket server=null; 
//ServerThread thread; 
Socket you=null; 
while(true) { 
try{ server= new ServerSocket(4331);//创建在端口 4331 
上负责监听的 ServerSocket 对象 
} 
catch(IOException e1) { 
System.out.println("正在监听"); 
} 
try{ System.out.println("正在等待客户"); 
you= server.accept();//server 调用 accept()返回和客 
户端相连接的 Socket 对象 
System.out.println("客户的地址:"+you.getInetAddress()); 
} 
catch (IOException e) { 
System.out.println(""+e); 
} 
if(you!=null) { 
new ServerThread(you).start(); 
} 
server.close(); 
} 
} 
} 

ServerThread

class ServerThread extends Thread { 
Socket socket; 
DataInputStream in=null; 
DataOutputStream out=null; 
ServerThread(Socket t) { socket=t; 
try { out=new DataOutputStream(socket.getOutputStream()); 
in=new DataInputStream(socket.getInputStream()); 
} 
catch (IOException e) {} 
} 
public void run() { 
try{ 
String item = in.readUTF(); 
Scanner scanner = new Scanner(item); 
scanner.useDelimiter("[^0123456789.]+"); 
if(item.startsWith("账单")) { 
double sum=0; 
while(scanner.hasNext()){ 
try{ double price = scanner.nextDouble(); 
sum = sum+price; 
System.out.println(price); 
} 
catch(InputMismatchException exp){ 
//String t = scanner.next(); 
} 
} 
out.writeUTF("您的账单:"); 
out.writeUTF(item); 
out.writeUTF("总额:"+sum+"元"); 
scanner.close(); 
} 
} 
catch(Exception exp){} 
} 
} 

实验3 TCP网络通信

一、实验目的

掌握TCP网络通信的相关类的使用

二、实验内容

1、编写服务器端程序:

（1）创建一个服务器套接字(ServerSocket)，绑定到指定端口;

（2）调用accept方法，侦听来自客户端的请求，如果客户发出请求，则接受连接，返回通信套接字(Socket);

（3）创建线程来处理客户机:

1. 在线程中调用getOutputStream方法，获得输入/输出流;
2. 每连上一个客户端，就主动给客户端发送一句“欢迎光临!”
3. 使用Arraylist存放连上服务端的所有客户端
4. 当接收到客户端发送来的消息的时候，将这条消息转发给是有连上服务端的所有客户端
5. 关闭通信套接字，

（4）关闭服务器套接字。

2、编写客户端程序:

（1）创建一个套接字(Socket)， 向服务器的侦听端口发出请求;

（2）与服务器正确连接后，调用Socket的getlnputStream和getOutputStream方法，获得输入/输出流，启动线程开始网络数据的接收和发送；在命令行给服务端发送消息；当接收到服务端发来的消息的时候，将内容显示在控制台上

（3）关闭通信套接字

客户端

TCPClient

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.OutputStreamWriter; 
import java.net.Socket; 
import java.net.UnknownHostException; 
import java.util.Scanner; 
public class TCPClient { 
public static void main(String[] args) { 
try { 
//创建一个套接字（Socket） ，向服务器的侦听端口发出请求 
Socket socket = new Socket("localhost", 54321); 
//启动读取数据线程，接收服务器发送过来的消息 
new Cread(socket).start(); 
//启动发送数据线程，给服务器发送消息 
new Csend(socket).start(); 
} catch (UnknownHostException e) { 
e.printStackTrace(); 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 

Cread

//读取数据线程，接收服务器发送过来的消息 
class Cread extends Thread { 
private Socket r; 
public Cread(Socket r) { 
this.r = r; 
} 
public void run() { 
try { 
while (true) { 
//获取输入流 
InputStreamReader is = new 
InputStreamReader(r.getInputStream()); 
BufferedReader br = new BufferedReader(is); 
//按行读取从服务器发来的数据消息 
String content = br.readLine(); 
System.out.println("服务端发来" + content); 
} 
} catch (UnknownHostException e) { 
e.printStackTrace(); 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 

Csend

//发送数据线程，给服务器发送消息 
class Csend extends Thread { 
private Socket c; 
public Csend(Socket c) { 
this.c = c; 
} 
public void run() { 
try { 
//获取输出流 
OutputStreamWriter osw = new 
OutputStreamWriter(c.getOutputStream()); 
BufferedWriter bw = new BufferedWriter(osw); 
//从键盘写入数据 
@SuppressWarnings("resource") 
Scanner sc = new Scanner(System.in); 
while (true) { 
//将键盘写入的数据按行写入发送给服务器 
String msg = sc.nextLine() + "\n"; 
bw.write(msg); 
System.out.println("给服务器发送" + msg); 
//刷新流 
bw.flush(); 
} 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
}

服务器端

TCPServer

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.net.ServerSocket; 
import java.net.Socket; 
import java.util.ArrayList; 
public class TCPServer { 
//使用 ArrayList 存放连上服务端的所有客户端 
public static ArrayList<Socket> sockets = new ArrayList<Socket>(); 
public static void main(String[] args) { 
try { 
//创建一个服务器套接字,绑定到 54321 端口 
@SuppressWarnings("resource") 
ServerSocket server = new ServerSocket(54321); 
System.out.println("服务器已启动，正在等待连接"); 
while (true) { 
//调用 accept 方法，侦听来自客户端的请求 
Socket socket = server.accept(); 
//将客户端发送过来的通信套接字添加到 sockets 动态数组中 
sockets.add(socket); 
//输出在线的客户端个数 
System.out.println("有" + sockets.size() + "个客户连接 
上"); 
//启动发送线程，给客户端发送一句“欢迎光临！” 
new getOutputStream(socket).start(); 
//启动接收线程，读取从客户端发来的消息 
new getInputStream(socket).start(); 
} 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 

getOutputStream

//发送线程负责给客户端发送一句“欢迎光临！” 
class getOutputStream extends Thread{ 
private Socket s; 
public getOutputStream(Socket s) { 
this.s=s; 
} 
@Override 
public void run() { 
try { 
//获取输出流 
OutputStream ops= s.getOutputStream(); 
String msg="欢迎光临！\n"; 
//将 msg 写入流 
ops.write(msg.getBytes()); 
//刷新流 
ops.flush(); 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
}

getInputStream

//接收线程，读取从客户端发来的消息 
class getInputStream extends Thread { 
private Socket r; 
public getInputStream(Socket r) { 
this.r = r; 
} 
public void run() { 
try { 
//获取输入流 
InputStreamReader is = new 
InputStreamReader(r.getInputStream()); 
BufferedReader br = new BufferedReader(is); 
while (true) { 
//读取客户端发送过来的消息 
String msg = br.readLine(); 
System.out.println("客户端发来" + msg); 
//读取客户端发送过来的消息后转发给所有在线的客户端 
for (Socket socket : TCPServer.sockets) { 
OutputStreamWriter osw = new OutputStreamWriter( 
socket.getOutputStream()); 
BufferedWriter bw = new BufferedWriter(osw); 
bw.write(msg + "\n"); 
//刷新流 
bw.flush(); 
} 
} 
} catch (Exception e) { 
e.printStackTrace(); 
} 
} 
}