tanke.txt

线程应用

package TankBattle; 

import javax.swing.UIManager; 
import java.awt.*; 

/** 
* <p>Title: Tank Game</p> 
* <p>Description: SDIA csc829</p> 
* <p>Copyright: Copyright (c) 2002</p> 
* <p>Company: Uni. Of Newcastle</p> 
* @author David.Li 
* @version 1.0 
*/ 

// generate by jbuilder, if not understand, please don′t change 
// using for test, like chat room 
public class Client { 
private boolean packFrame = false; 

//Construct the application 
public Client() { 
ClientFrame frame = new ClientFrame(); 
//Validate frames that have preset sizes 
//Pack frames that have useful preferred size info, e.g. from their layout 
if (packFrame) { 
frame.pack(); 
} 
else { 
frame.validate(); 
} 
//Center the window 
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 
Dimension frameSize = frame.getSize(); 
if (frameSize.height > screenSize.height) { 
frameSize.height = screenSize.height; 
} 
if (frameSize.width > screenSize.width) { 
frameSize.width = screenSize.width; 
} 
frame.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2); 
frame.setVisible(true); 
} 
//Main method 
public static void main(String[] args) { 
try { 
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); 
} 
catch(Exception e) { 
e.printStackTrace(); 
} 
new Client(); 
} 
} 


package TankBattle; 

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

/** 
* <p>Title: Tank Game</p> 
* <p>Description: SDIA csc829</p> 
* <p>Copyright: Copyright (c) 2002</p> 
* <p>Company: Uni. Of Newcastle</p> 
* @author David.Li 
* @version 1.0 
*/ 

// generate by jbuilder, if not understand, please don′t change. 
// using for test, like chat room 
public class ClientFrame extends JFrame { 
private JPanel contentPane; 
static JTextField sendMessage = new JTextField(); 
private JButton jButton1 = new JButton(); 
private JScrollPane jScrollPane1 = new JScrollPane(); 
private JLabel jLabel1 = new JLabel(); 
static JTextArea receiveMessage = new JTextArea(); 

private NetworkClient nClient = new NetworkClient(); 
private Socket temp; 

//Construct the frame 
public ClientFrame() { 
enableEvents(AWTEvent.WINDOW_EVENT_MASK); 
try { 
jbInit(); 
} 
catch(Exception e) { 
e.printStackTrace(); 
} 
} 
//Component initialization 
private void jbInit() throws Exception { 
//setIconImage(Toolkit.getDefaultToolkit().createImage(ClientFrame.class.getResource("[Your Icon]"))); 
contentPane = (JPanel) this.getContentPane(); 
sendMessage.setBounds(new Rectangle(32, 26, 189, 22)); 
contentPane.setLayout(null); 
this.setSize(new Dimension(400, 300)); 
this.setTitle("Frame Title"); 
jButton1.setBounds(new Rectangle(247, 28, 97, 23)); 
jButton1.setText("send"); 
jButton1.addActionListener(new java.awt.event.ActionListener() { 
public void actionPerformed(ActionEvent e) { 
jButton1_actionPerformed(e); 
} 
}); 
jScrollPane1.setBounds(new Rectangle(28, 86, 330, 148)); 
jLabel1.setText("Received:"); 
jLabel1.setBounds(new Rectangle(31, 57, 81, 22)); 
contentPane.add(jScrollPane1, null); 
jScrollPane1.getViewport().add(receiveMessage, null); 
contentPane.add(jButton1, null); 
contentPane.add(sendMessage, null); 
contentPane.add(jLabel1, null); 

// by myself 
new NetworkClientReceiveThread(new NetworkClient()).start(); 
temp = nClient.initConnectServer(); 

} 
//Overridden so we can exit when window is closed 
protected void processWindowEvent(WindowEvent e) { 
super.processWindowEvent(e); 
if (e.getID() == WindowEvent.WINDOW_CLOSING) { 
System.exit(0); 
} 
} 

void jButton1_actionPerformed(ActionEvent e) { 
try{ 
nClient.sendMessage(temp,sendMessage.getText()); 
} catch (IOException ioe){ 
ioe.printStackTrace(); 
} 
} 
} 


package TankBattle; 

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

/** 
* <p>Title: Tank Game</p> 
* <p>Description: SDIA csc829</p> 
* <p>Copyright: Copyright (c) 2002</p> 
* <p>Company: Uni. Of Newcastle</p> 
* @author David.Li 
* @version 1.0 
*/ 

public class NetworkClient { 

protected String receiveData; 
protected String sendData; 
protected boolean newReceiveData; 

private String TCPServerAddress; 
private String UDPServerAddress; 
private int TCPServerPort; 
private int UDPServerPort; 

private Socket cSocket; 
private MulticastSocket mSocket; 
private InetAddress mAddress; 

private boolean cStart = true; 

public NetworkClient(){ 

Parameter parameter = new Parameter(); 

TCPServerAddress = parameter.TCPServerAddress; 
TCPServerPort = parameter.TCPServerPort; 
UDPServerAddress = parameter.UDPServerAddress; 
UDPServerPort = parameter.UDPServerPort; 
} 

/** 
* init connect with server 
* @return Scoket if success connect 
*/ 
public Socket initConnectServer() { 
try{ 

cSocket = new Socket(TCPServerAddress,TCPServerPort); 

SocketUtil socketUtil = new SocketUtil(cSocket); 

String tAddress = new SocketFileOperate().getLocalIPAddress(); 

// change username to real username 
socketUtil.getPrintStream().println("start"+"||"+"username"+"||"+tAddress); 

}catch (UnknownHostException e){ 
System.out.println("UnknownHost of Server"); 
} 
catch (IOException e){ 
System.out.println("Fail init"); 
e.printStackTrace(); 
} 
return cSocket; 
} 

/** 
* send message to service 
* @param cSocket - already init socket 
* @param cMessage - string of need message 
* @throws IOException 
*/ 
public void sendMessage (Socket cSocket, String cMessage) throws IOException{ 

SocketUtil socketUtil = new SocketUtil(cSocket); 
socketUtil.getPrintStream().println(cMessage); 

} 

/** 
* init Multi receiver 
*/ 
public void initMulticast () { 
try{ 

mSocket = new MulticastSocket(UDPServerPort); 
mAddress = InetAddress.getByName(UDPServerAddress); 
mSocket.joinGroup(mAddress); 

receiveMessage(mSocket, mAddress); 
}catch(IOException e){ 
System.out.println("Fail init Multicast Receiver"); 
e.printStackTrace(); 
} 
} 

/** 
* receive multicast message 
* @param UDPPort - multi port socket 
* @param UDPServer - inetaddress of server 
* @throws IOException 
*/ 
public void receiveMessage (MulticastSocket UDPPort, 
InetAddress UDPServer ) throws IOException{ 
DatagramPacket packet; 

while (cStart){ 
byte[] buf = new byte[500]; 
packet = new DatagramPacket(buf, buf.length); 
UDPPort.receive(packet); 

receiveData = new String(packet.getData()); 
newReceiveData = true; 
// change following part to pain 
// ClientFrame.receiveMessage.append(receiveData+"\n"); 
} 
} 

/** 
* if client exit then level group of multicast 
* @param UDPport - socket of multicast 
* @param UDPServer - inetaddress of multicast 
*/ 
public void leaveUDPServer(MulticastSocket UDPport, InetAddress UDPServer){ 
try{ 
UDPport.leaveGroup(UDPServer); 
}catch (IOException e){ 
e.printStackTrace(); 
} 
} 

public String getReceiveData(){ 
newReceiveData = false; 
return receiveData; 
} 

public boolean getStateOfData(){ 
return newReceiveData; 
} 

public String getTCPServerAddress (){ 
return TCPServerAddress; 
} 

public String getUDPServerAddress (){ 
return UDPServerAddress; 
} 

public int getTCPServerPort (){ 
return TCPServerPort; 
} 

public int getUDPServerPort (){ 
return UDPServerPort; 
} 
} 



package TankBattle; 

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

/** 
* <p>Title: Tank Game</p> 
* <p>Description: SDIA csc829</p> 
* <p>Copyright: Copyright (c) 2002</p> 
* <p>Company: Uni. Of Newcastle</p> 
* @author David.Li 
* @version 1.0 
*/ 

public class NetworkClientReceiveThread extends Thread { 
private NetworkClient nClient; 
private Thread cReceive; 

public NetworkClientReceiveThread( NetworkClient nClient) { 
this.nClient = nClient; 
} 

/** 
* init thread of receive thread 
*/ 
public void start(){ 
this.cReceive = new Thread(this); 
cReceive.start(); 
} 

/** 
* prepare to receive 
*/ 
public void run() { 
nClient.initMulticast(); 
} 

/** 
* stop thread 
*/ 
public void finilize(){ 
cReceive = null; 
} 
} 


package TankBattle; 

import java.io.*; 
import java.net.*; 
import java.util.*; 
import java.lang.*; 
import javax.swing.*; 

/** 
* <p>Title: Tank Game</p> 
* <p>Description: SDIA csc829</p> 
* <p>Copyright: Copyright (c) 2002</p> 
* <p>Company: Uni. Of Newcastle</p> 
* @author David.Li 
* @version 1.0 
*/ 

public class NetworkServer extends Exception { 

private String UDPServerAddress; 
private int TCPServerPort; 
private int UDPServerPort; 

protected boolean startServer = true; 

private MulticastSocket UDPPort; 
private InetAddress UDPServer; 
protected ServerSocket serverSocket; 

private String inputMessage; 
private Vector theClient; 
private ServerSubThread sClient; 
private Socket sSocket; 

public NetworkServer(){ 
Parameter parameter = new Parameter(); 

TCPServerPort = parameter.TCPServerPort; 
UDPServerAddress = parameter.UDPServerAddress; 
UDPServerPort = parameter.UDPServerPort; 

// start init UDP 
try{ 
ServerControlFrame.outputInformation.setText("Start init Server UDP Port.....\n"); 

UDPPort = new MulticastSocket(UDPServerPort); 
UDPServer = InetAddress.getByName(UDPServerAddress); 
UDPPort.joinGroup(UDPServer); 

ServerControlFrame.outputInformation.append("Finish init Server UDP port\n"); 

}catch (IOException ioe){ 
ServerControlFrame.outputInformation.append("Fail init Server UDP port"); 
ServerControlFrame.outputInformation.append(ioe.toString()); 
} 

// Start init TCP 
try{ 
ServerControlFrame.outputInformation.append("Start Init Server TCP Port......\n"); 
serverSocket = new ServerSocket(TCPServerPort); 
ServerControlFrame.outputInformation.append("Finish init Server TCP Port\n"); 

ServerControlFrame.outputInformation.append 
("Server successful initialized, waiting for connection...\n"); 

theClient = new Vector(); 

}catch (IOException ioe){ 
ioe.printStackTrace(); 
ServerControlFrame.outputInformation.append("Fail init Server TCP port"); 
ServerControlFrame.outputInformation.append(ioe.toString()); 
} 
} 

/** 
* process with client connection 
*/ 
public void handleConnect (){ 
try{