java高级编程技术实验指导书

实验一 使用套接字读取服务器端对象

【实验目的】

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

【实验要求】

客户端将服务器端的文本区对象读取到客户端，并添加到窗口中。首先将服务器端的程序编译通过，并运行，等待客户呼叫。 【程序模版】

请按照模版要求，将【代码】替换为程序代码 客户端模板：Client.java

import java.net.*; import java.io.*; import java.awt.*; import java.awt.event.*;

class Client extends Frame implements Runnable,ActionListener { Button connection; Socket socket=null;

ObjectInputStream in=null; ObjectOutputStream out=null; Thread thread; public Client()

{ socket=new Socket();

connection=new Button(\"连接服务器,读取文本区对象\"); add(connection,BorderLayout.NORTH); connection.addActionListener(this); thread = new Thread(this); setBounds(100,100,360,310); setVisible(true);

addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e) { System.exit(0); } } ); }

public void run() { while(true)

{ try{ TextArea text=(TextArea)in.readObject(); add(text,BorderLayout.CENTER); validate(); }

catch(Exception e) { break;

} } }

public void actionPerformed(ActionEvent e) { if(e.getSource()==connection) { try

{ if(socket.isConnected()) { } else

{ InetAddress address=InetAddress.getByName(\"127.0.0.1\");

InetSocketAddress socketAddress=【代码1】//创建端口为4331、地址为 //address的socketAddress 【代码2】 //socket建立和socketAddress的连接呼叫。 in =new ObjectInputStream(【代码3】); //socket返回输入流 out = new ObjectOutputStream(【代码4】); //socket返回输出流 thread.start(); } }

catch (Exception ee){} } }

public static void main(String args[]) { Client win=new Client(); } }

服务器端模板：Server.java

import java.io.*; import java.net.*; import java.util.*; import java.awt.*; public class Server

{ public static void main(String args[]) { ServerSocket server=null; ServerThread thread; Socket you=null; while(true)

{ try{ server=【代码1】//创建在端口4331上负责监听的 ServerSocket对象 }

catch(IOException e1)

{ System.out.println(\"正在监听\"); }

try{ you=【代码2】 // server返回和客户端相连接的Socket对象 System.out.println(\"客户的地址:\"+you.getInetAddress());

}

catch (IOException e)

{ System.out.println(\"正在等待客户\"); }

if(you!=null)

{ new ServerThread(you).start(); }

else{ continue; } } } }

class ServerThread extends Thread { Socket socket;

ObjectInputStream in=null; ObjectOutputStream out=null; String s=null;

ServerThread(Socket t) { socket=t;

try { out=new ObjectOutputStream(【代码3】); //socket返回输出流。 in=new ObjectInputStream(【代码4】); //socket返回输入流。 }

catch (IOException e) {} }

public void run()

{ TextArea text=new TextArea(\"你好,我是服务器\ try{ out.writeObject(text); }

catch (IOException e)

{ System.out.println(\"客户离开\"); } } }

实验二DeitelMessager聊天系统的服务器和客户端

【实验目的】

使用Socket进行互联，掌握DatagramPacket和MulticastSocket、多线程和Swing GUI的用法。 【实验要求】

聊天室提供了一个聚会场所，用户可以在此通过简短的文本消息互相聊天。一个聊天室的每个参与者可以看到其他用户发布的消息，并且每个用户都可以在聊天室中公布信息。阅读程序，调试成功。（程序参见程序文件夹实验2） 程序模板（服务器端程序）：

ackage com.deitel.messenger.sockets.server;

import java.util.*; import java.net.*; import java.io.*;

import com.deitel.messenger.*;

import com.deitel.messenger.sockets.*;

public class DeitelMessengerServer implements MessageListener {

// start chat server public void startServer() {

// create server and manage new clients try {

// create ServerSocket for incoming connections ServerSocket serverSocket = new ServerSocket( SocketMessengerConstants.SERVER_PORT, 100 );

System.out.println( \"Server listening on port \" + SocketMessengerConstants.SERVER_PORT + \" ...\" );

// listen for clients constantly while ( true ) {

// accept new client connection

Socket clientSocket = serverSocket.accept();

// create new ReceivingThread for receiving // messages from client

new ReceivingThread( this, clientSocket ).start();

// print connection information

System.out.println( \"Connection received from: \" + clientSocket.getInetAddress() );

} // end while

} // end try

// handle exception creating server and connecting clients catch ( IOException ioException ) {

ioException.printStackTrace(); }

} // end method startServer

// when new message is received, broadcast message to clients public void messageReceived( String from, String message ) {

// create String containing entire message String completeMessage = from +

SocketMessengerConstants.MESSAGE_SEPARATOR + message;

// create and start MulticastSendingThread to broadcast // new messages to all clients

new MulticastSendingThread( completeMessage.getBytes() ).start(); }

public static void main ( String args[] ) {

new DeitelMessengerServer().startServer(); }

} // end class DeitelMessengerServer

package com.deitel.messenger.sockets.server;

import java.io.*; import java.net.*;

import java.util.StringTokenizer;

import com.deitel.messenger.*;

import com.deitel.messenger.sockets.*;

public class ReceivingThread extends Thread {

private BufferedReader input;

private MessageListener messageListener; private boolean keepListening = true;

// ReceivingThread constructor

public ReceivingThread( MessageListener listener, Socket clientSocket ) {

// invoke superclass constructor to name Thread super( \"ReceivingThread: \" + clientSocket );

// set listener to which new messages should be sent messageListener = listener;

// set timeout for reading from clientSocket and create // BufferedReader for reading incoming messages try {

clientSocket.setSoTimeout( 5000 );

input = new BufferedReader( new InputStreamReader( clientSocket.getInputStream() ) ); }

// handle exception creating BufferedReader catch ( IOException ioException ) { ioException.printStackTrace(); }

} // end ReceivingThread constructor

// listen for new messages and deliver them to MessageListener public void run() {

String message;

// listen for messages until stopped while ( keepListening ) {

// read message from BufferedReader try {

message = input.readLine(); }

// handle exception if read times out

catch ( InterruptedIOException interruptedIOException ) {

// continue to next iteration to keep listening continue; }

// handle exception reading message catch ( IOException ioException ) {

ioException.printStackTrace(); break; }

// ensure non-null message if ( message != null ) {

// tokenize message to retrieve user name and message body StringTokenizer tokenizer = new StringTokenizer(

message, SocketMessengerConstants.MESSAGE_SEPARATOR );

// ignore messages that do not contain a user // name and message body if ( tokenizer.countTokens() == 2 )

// send message to MessageListener messageListener.messageReceived( tokenizer.nextToken(), // user name tokenizer.nextToken() ); // message body

else

// if disconnect message received, stop listening if ( message.equalsIgnoreCase(

SocketMessengerConstants.MESSAGE_SEPARATOR + SocketMessengerConstants.DISCONNECT_STRING ) ) stopListening();

} // end if

} // end while

// close BufferedReader (also closes Socket) try {

input.close(); }

// handle exception closing BufferedReader catch ( IOException ioException ) { ioException.printStackTrace(); }

} // end method run

// stop listening for incoming messages public void stopListening() {

keepListening = false; }

} // end class ReceivingThread

package com.deitel.messenger.sockets.server;

import java.io.*; import java.net.*;

import com.deitel.messenger.sockets.*;

public class MulticastSendingThread extends Thread {

// message data

private byte[] messageBytes;

// MulticastSendingThread constructor

public MulticastSendingThread( byte[] bytes ) {

// invoke superclass constructor to name Thread super( \"MulticastSendingThread\" );

messageBytes = bytes; }

// deliver message to MULTICAST_ADDRESS over DatagramSocket public void run() {

// deliver message try {

// create DatagramSocket for sending message DatagramSocket socket = new DatagramSocket(

SocketMessengerConstants.MULTICAST_SENDING_PORT );

// use InetAddress reserved for multicast group InetAddress group = InetAddress.getByName( SocketMessengerConstants.MULTICAST_ADDRESS );

// create DatagramPacket containing message

DatagramPacket packet = new DatagramPacket( messageBytes, messageBytes.length, group,

SocketMessengerConstants.MULTICAST_LISTENING_PORT );

// send packet to multicast group and close socket socket.send( packet ); socket.close(); }

// handle exception delivering message catch ( IOException ioException ) { ioException.printStackTrace(); }

} // end method run

} // end class MulticastSendingThread

实验三 无阻塞的I/O聊天程序

【实验目的】

掌握ServerSocketChannel、Selector、 Charset、ByteBuffer等类的用法。 【实验要求】

用新的I/O API创建一个单线程、无阻塞的服务器。给出程序代码，阅读程序，完成无阻塞的I/O聊天程序调试。（程序参见程序文件夹实验3） 程序模板（服务器端程序部分代码）：

package com.deitel.messenger.sockets.server; import java.io.*; import java.nio.*;

import java.nio.channels.*; import java.nio.channels.spi.*; import java.nio.charset.*; import java.net.*; import java.util.*; import java.awt.event.*; import javax.swing.*;

public class DeitelMessengerNonBlockingServer extends JFrame { private ServerSocketChannel serverSocketChannel; private Selector selector;

private Vector sockets = new Vector(); private int counter = 0; private JTextArea displayArea; private Charset charSet; private ByteBuffer writeBuffer;

private ByteBuffer readBuffer = ByteBuffer.allocate( 512 );

public DeitelMessengerNonBlockingServer() {

super( \"DeitelMessenger Server\" );

displayArea = new JTextArea();

getContentPane().add( new JScrollPane( displayArea ) );

setSize( 200, 300 ); setVisible( true );

// close server socket channel and selector when closing window addWindowListener(

new WindowAdapter() {

public void windowClosing( WindowEvent windowEvent ) {

// close server socket channel and selector try {

serverSocketChannel.close(); selector.close(); }

catch( IOException ioException ) { ioException.printStackTrace(); }

finally {

System.exit( 0 ); } }

} // end inner class WindowAdapter

); // end addWindowListener

} // end constructor

// set up and run server public void runServer() {

// set up server to receive connections; process connections try {

// specify the char set used to encode/decode messages charSet = Charset.forName( \"UTF-8\" );

// create a ServerSocketChannel.

serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind( new InetSocketAddress( 12345 ) );

serverSocketChannel.configureBlocking( false );

// wait for a connection. getConnection();

} // end try

// process problems with I/O catch ( Exception ioException ) { ioException.printStackTrace(); }

} // end method runServer

// wait for connection to arrive, then display connection info private void getConnection() throws Exception {

// Selector for incoming requests

selector = SelectorProvider.provider().openSelector(); serverSocketChannel.register(

selector, SelectionKey.OP_ACCEPT, null );

// process incoming requests while ( selector.select() > 0 ) {

// get channels ready for i/o

Set readyKeys = selector.selectedKeys(); Iterator iterator = readyKeys.iterator();

// for each ready channel, process request while ( iterator.hasNext() ) {

if ( key.isAcceptable() ) { // ready for connection

// create connection

ServerSocketChannel nextReady =

( ServerSocketChannel ) key.channel();

SocketChannel socketChannel = nextReady.accept();

SelectionKey key = ( SelectionKey )iterator.next(); iterator.remove();

if ( socketChannel != null ) {

socketChannel.configureBlocking( false ); sockets.add( socketChannel.socket() ); counter++;

SwingUtilities.invokeLater(

new Runnable() {

public void run() {

displayArea.append(

\"\\nConnection with Client \" + counter ); } }

// register read operation to socketChannel SelectionKey readKey = socketChannel.register( selector, SelectionKey.OP_READ, null );

} // end if socketChannel != null

} // end if key.isAcceptable

else if ( key.isReadable() ) { // ready for read

// get socketChannel ready for read SocketChannel socketChannel = ( SocketChannel ) key.channel();

readMessage( socketChannel ); }

} // end processing each channel

} // end processing incoming requests

} // end method getConnection

// send message to client

private void writeMessage( String message ) throws IOException {

Socket socket;

);

SocketChannel socketChannel;

// echo message back to all connected clients for ( int i = 0; i < sockets.size(); i++ ) { socket = ( Socket ) sockets.elementAt( i ); socketChannel = socket.getChannel();

// send message to client try {

// convert message to bytes in charSet writeBuffer = charSet.encode( message );

// write message to socketChannel socketChannel.write( writeBuffer ); }

// process problems sending object catch ( IOException ioException ) { ioException.printStackTrace(); socketChannel.close(); sockets.remove( socket ); }

} // end for

} // end method writeMessage

// read message from client

private void readMessage( SocketChannel socketChannel ) throws IOException {

// read message try {

if ( socketChannel.isOpen() ) { readBuffer.clear();

socketChannel.read( readBuffer ); readBuffer.flip();

CharBuffer charMessage = charSet.decode( readBuffer ); String message = charMessage.toString().trim();

// remove and close the connection when client disconnects if ( message.indexOf( \"Disconnect\" ) >= 0 ) {

sockets.remove( socketChannel.socket() ); socketChannel.close(); } else

writeMessage( message );

} // end if

} // end try

catch ( IOException ioException ) { ioException.printStackTrace();

sockets.remove( socketChannel.socket() ); socketChannel.close(); }

} // end method readMessage

public static void main( String args[] ) {

DeitelMessengerNonBlockingServer application = new DeitelMessengerNonBlockingServer(); application.runServer(); }

} // end class DeitelMessengerNonBlockingServer

实验四 读取服务器端文件

【实验目的】

学会使用URL对象 【实验要求】

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

【程序模版】

请按照模版要求，将【代码】替换为程序代码。 ReadFile.java

import java.awt.*; import java.awt.event.*; import java.net.*; import java.io.*;

public class ReadURLSource

{ public static void main(String args[]) { new NetWin(); } }

class NetWin extends Frame implements ActionListener,Runnable { Button button; URL url; TextField text; TextArea area;

byte b[]=new byte[118]; Thread thread; NetWin()

{ text=new TextField(20); area=new TextArea(12,12); button=new Button(“确定”); button.addActionListener(this); thread=new Thread(this); Panel p=new Panel();

p.add(new Label(“输入网址:”)); p.add(text); p.add(button);

add(area,BorderLayout.CENTER); add(p,BorderLayout.NORTH); setBounds(60,60,360,300); setVisible(true); validate();

addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e) { System.exit(0); } }); }

public void actionPerformed(ActionEvent e) {

if(!(thread.isAlive())) thread=new Thread(this); try{

thread.start(); }

catch(Exception ee)

{ text.setText(“我正在读取”+url); } }

public void run() { try { int n=-1;

area.setText(null);

String name=text.getText().trim();

【代码1】 //使用字符串name创建url对象 String hostName=【代码2】 //url调用getHost() int urlPortNumber=【代码3】 //url调用getPort() String fileName=【代码4】 //url调用getFile() InputStream in=【代码5】 //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) { text.setText(“”+e1); return; }

catch(IOException e1)

{ text.setText(“”+e1); return; } }

实验五读取Web服务器上的文件

【实验目的】

掌握JEditorPane类的使用 【实验要求】

使用组件JEditorPane显示Web服务器上的文件内容。用户在窗户顶部的JtextFeild中输入URL，程序在JeditorPane中显示相应的文档。用户单击HTML文件的一个超级链接时处理HyperlinkEvent。 【程序模板】

请按照模版要求，将【代码】替换为程序代码。

// Use a JEditorPane to display the contents of a file on a Web server. import java.awt.*; import java.awt.event.*; import java.net.*; import java.io.*; import javax.swing.*; import javax.swing.event.*;

public class ReadServerFile extends JFrame { private JTextField enterField; private JEditorPane contentsArea;

// set up GUI

public ReadServerFile() {

super( \"Simple Web Browser\" );

Container container = getContentPane();

// create enterField and register its listener enterField = new JTextField( \"Enter file URL here\" ); enterField.addActionListener( new ActionListener() {

public void actionPerformed( ActionEvent event ) {

getThePage( event.getActionCommand() );【代码1】 // get document specified by user

}

} // end inner class

); // end call to addActionListener

container.add( enterField, BorderLayout.NORTH );

// create contentsArea and register HyperlinkEvent listener contentsArea = new JEditorPane(); contentsArea.setEditable( false ); contentsArea.addHyperlinkListener( new HyperlinkListener() {

public void hyperlinkUpdate( HyperlinkEvent event ) {

if ( event.getEventType() ==

HyperlinkEvent.EventType.ACTIVATED )

getThePage( event.getURL().toString() );【代码2】 } // if user clicked hyperlink, go to specified page

} // end inner class

); // end call to addHyperlinkListener

container.add( new JScrollPane( contentsArea ),

BorderLayout.CENTER ); setSize( 400, 300 ); setVisible( true );

} // end constructor ReadServerFile

// load document

private void getThePage( String location ) {

try {

contentsArea.setPage( location );

enterField.setText( location );【代码3】// load document and display location }

catch ( IOException ioException ) { JOptionPane.showMessageDialog( this,

\"Error retrieving specified URL\ JOptionPane.ERROR_MESSAGE ); }

} // end method getThePage

public static void main( String args[] ) {

ReadServerFile application = new ReadServerFile();

application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); }

} // end class ReadServerFile

实验六 基于UDP的图像传输

【实验目的】

掌握DatagramSocket类的使用

【实验要求】

编写客户/服务器程序，客户端使用DatagramSocket对象将数据包发送到服务器，请求获取服务器端的图像。服务器端将图像文件包装成数据包，并使用DatagramSocket对象将该数据包发送到客户端。首先将服务器端的程序编译通过，并运行起来，等待客户的请求。 【程序模版】

请按照模版要求，将【代码】替换为程序代码 客户端模板：Client.java

import java.net.*; import java.awt.*; import java.awt.event.*; import java.io.*;

class ImageCanvas extends Canvas { Image image=null; public ImageCanvas() { setSize(200,200); }

public void paint(Graphics g) { if(image!=null)

g.drawImage(image,0,0,this); }

public void setImage(Image image) { this.image=image; } }

class Client extends Frame implements Runnable,ActionListener { Button b=new Button(\"获取图像\"); ImageCanvas canvas; Client()

{ super(\"I am a client\"); setSize(320,200); setVisible(true);

b.addActionListener(this); add(b,BorderLayout.NORTH); canvas=new ImageCanvas(); add(canvas,BorderLayout.CENTER); Thread thread=new Thread(this); validate();

addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e) { System.exit(0); } } );

thread.start(); }

public void actionPerformed(ActionEvent event) { byte b[]=\"请发图像\".trim().getBytes();

try{ InetAddress address=InetAddress.getByName(\"127.0.0.1\");

DatagramPacket data=【代码1】 //创建数据包，该数据包的目标地址和端口分别是

//address和1234，其中的数据为数组b中的全部字节。 DatagramSocket mailSend=【代码2】 //创建负责发送数据的DatagramSocket对象。 【代码3】 // mailSend发送数据data。 }

catch(Exception e){} }

public void run() { DatagramPacket pack=null; DatagramSocket mailReceive=null; byte b[]=new byte[8192];

ByteArrayOutputStream out=new ByteArrayOutputStream(); try{ pack=new DatagramPacket(b,b.length);

【代码4】 //创建在端口5678负责收取数据包的DatagramSocket对象。 }

catch(Exception e){} try{ while(true)

{ mailReceive.receive(pack);

String message=new String(pack.getData(),0,pack.getLength()); if(message.startsWith(\"end\")) { break; }

out.write(pack.getData(),0,pack.getLength()); }

byte imagebyte[]=out.toByteArray(); out.close();

Toolkit tool=getToolkit();

Image image=tool.createImage(imagebyte); canvas.setImage(image); canvas.repaint(); validate(); }

catch(IOException e){} }

public static void main(String args[]) { new Client(); } }

服务器端模板：Server.java

import java.net.*; import java.io.*; public class Server {

public static void main(String args[]) { DatagramPacket pack=null;

DatagramSocket mailReceive=null; ServerThread thread; byte b[]=new byte[8192]; InetAddress address=null;

pack=new DatagramPacket(b,b.length); while(true)

{ try{ mailReceive=【代码1】//创建在端口1234负责收取数据包的 //DatagramSocket对象。 }

catch(IOException e1)

{ System.out.println(\"正在等待\"); }

try{ mailReceive.receive(pack);

address=【代码2】 //pack返回InetAddress对象。 System.out.println(\"客户的地址:\"+address); }

catch (IOException e) { } if(address!=null)

{ new ServerThread(address).start(); } else

{ continue; } } } }

class ServerThread extends Thread { InetAddress address; DataOutputStream out=null; DataInputStream in=null; String s=null;

ServerThread(InetAddress address) { this.address=address; }

public void run() { FileInputStream in; byte b[]=new byte[8192];

try{ in=new FileInputStream (\"a.jpg\"); int n=-1;

while((n=in.read(b))!=-1)

{ DatagramPacket data=【代码3】 //创建数据包，目标地址和端口分别是 //address和5678，其中的数据为数组b中的前n个字节 DatagramSocket mailSend=【代码4】 //创建发送数据的DatagramSocket对象 【代码5】 // mailSend发送数据data

}

in.close();

byte end[]=\"end\".getBytes();

DatagramPacket data=【代码6】 //创建数据包，目标地址和端口分别是

//address和5678，其中的数据为数组end中的全部字节 DatagramSocket mailSend=【代码7】 //创建负责发送数据的DatagramSocket对象 【代码8】 // mailSend发送数据data }

catch(Exception e){} } }