「java简单网络编程案例」Windows网络编程案例教程
今天给各位分享java简单网络编程案例的知识，其中也会对Windows网络编程案例教程进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、求java nio网络编程的小例子，要求客户端一直与服务器保持连接
- 2、Java网络编程从入门到精通（18）：Socket类的getter和setter方法（2）
- 3、java socket网络编程
- 4、java网络编程问题
- 5、我要一份用java网络编程写的点对点的两人聊天程序(TCP和UDP)?
- 6、一个最简单的java网络编程
求java nio网络编程的小例子，要求客户端一直与服务器保持连接
import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.net.*;
import java.io.*;
public class chatClient extends Frame {
/**
* @param args
*/
TextField tfTxT=new TextField();
TextArea taContent=new TextArea();
Socket s=null;
DataOutputStream dos=null;
DataInputStream dis=null;
private boolean bConnected =false;
public static void main(String[] args) {
new chatClient().lunachFrame();
}
private class RecvThread implements Runnable{
public void run() {
try{
while(bConnected){
String str=dis.readUTF();
taContent.setText(taContent.getText()+str+'\n');
}
}catch(IOException e){
e.printStackTrace();
}
}
}
public void lunachFrame(){
this.setLocation(400, 300);
this.setSize(300,300);
//this.setLayout(new FlowLayout());
this.add(tfTxT,"South");
this.add(taContent,"North");
pack();
tfTxT.addActionListener(new TFListener());
this.addWindowListener(new WindowClose());
this.setVisible(true);
connect();
new Thread(new RecvThread()).start();
}
public void connect(){
try {
s= new Socket("127.0.0.1",8888);
dos =new DataOutputStream(s.getOutputStream());
dis =new DataInputStream(s.getInputStream());
System.out.println("connected!");
bConnected=true;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public void disconnect(){
try {
dos.close();
s.close();
} catch (Exception e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
class WindowClose extends WindowAdapter{
@Override
public void windowClosing(WindowEvent e) {
// TODO 自动生成方法存根
System.exit(0);
disconnect();
}
}
private class TFListener implements ActionListener{
public void actionPerformed(ActionEvent e) {
String str=tfTxT.getText().trim();//trim去掉两边空格
//taContent.setText(str);
tfTxT.setText("");
try {
dos.writeUTF(str);
dos.flush();
//dos.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
======================================
import java.io.IOException;
import java.net.*;
import java.io.*;
import java.util.*;
public class ChatServer {
ListClient clients=new ArrayListClient();
Client c=null;
public static void main(String[] args){
new ChatServer().start();
}
public void start(){
boolean started=false;
ServerSocket ss=null;
DataInputStream dis=null;
try{
ss=new ServerSocket(8888);
started =true;
}catch(Exception e)
{
e.printStackTrace();
}
try{
while(started){
Socket s=ss.accept();
c=new Client(s);//启动线程,实行run()方法
System.out.println("a client connected!");
new Thread(c).start();//启动start方法,循环.start是Thread中的方法与这上面的start无关
clients.add(c);
//dis.close();
}
} catch (Exception e) {
//e.printStackTrace();
}
finally{
try {
ss.close();
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
}
class Client implements Runnable{
private Socket s;
private DataInputStream dis =null;
private boolean bConnected =false;
private DataOutputStream dos=null;
public Client(Socket s){
this.s=s;
try {
dis=new DataInputStream(s.getInputStream());
dos =new DataOutputStream(s.getOutputStream());
bConnected =true;
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
public void send(String str)throws Exception{
dos.writeUTF(str);
}
public void run() {
try{
while(bConnected){
String str = dis.readUTF();
System.out.println(str);
for(int i=0;iclients.size();i++){
c=clients.get(i);
c.send(str);
}
/*for(IteratorClient it=clients.iterator();it.hasNext();){
Client c=it.next();
c.send(str);
}*/
}
}catch(SocketException e){
clients.remove(this);
System.out.println("客户下线了");
}
catch(EOFException e){
System.out.println("Client closed");
}
catch (Exception e){
//e.printStackTrace();
}
finally{
try {
if(dis !=null) dis.close();
if(dos !=null) dos.close();
if(s!=null) s.close();
} catch (Exception e1) {
// TODO 自动生成 catch 块
//e1.printStackTrace();
}
}
}
}
}
第一个是客户端,
第二个是server端
Java网络编程从入门到精通（18）：Socket类的getter和setter方法（2）
二 用于获得和设置Socket选项的getter和setter方法
Socket选择可以指定Socket类发送和接受数据的方式 在JDK *** 有 个Socket选择可以设置 这 个选项都定义在 SocketOptions接口中 定义如下
public final static int TCP_NODELAY = x ; public final static int SO_REUSEADDR = x ; public final static int SO_LINGER = x ; public final static int SO_TIMEOUT = x ; public final static int SO_SNDBUF = x ; public final static int SO_RCVBUF = x ; public final static int SO_KEEPALIVE = x ; public final static int SO_OOBINLINE = x ;
有趣的是 这 个选项除了第一个没在SO前缀外 其他 个选项都以SO作为前缀 其实这个SO就是Socket Option的缩写 因此 在Java中约定所有以SO为前缀的常量都表示Socket选项 当然 也有例外 如TCP_NODELAY 在Socket类中为每一个选项提供了一对get和set方法 分别用来获得和设置这些选项
TCP_NODELAY
public boolean getTcpNoDelay() throws SocketExceptionpublic void setTcpNoDelay(boolean on) throws SocketException
在默认情况下 客户端向服务器发送数据时 会根据数据包的大小决定是否立即发送 当数据包中的数据很少时 如只有 个字节 而数据包的头却有几十个字节（IP头+TCP头）时 系统会在发送之前先将较小的包合并到软大的包后 一起将数据发送出去 在发送下一个数据包时 系统会等待服务器对前一个数据包的响应 当收到服务器的响应后 再发送下一个数据包 这就是所谓的Nagle算法 在默认情况下 Nagle算法是开启的
这种算法虽然可以有效地改善网络传输的效率 但对于网络速度比较慢 而且对实现性的要求比较高的情况下（如游戏 Telnet等） 使用这种方式传输数据会使得客户端有明显的停顿现象 因此 最好的解决方案就是需要Nagle算法时就使用它 不需要时就关闭它 而使用setTcpToDelay正好可以满足这个需求 当使用setTcpNoDelay（true）将Nagle算法关闭后 客户端每发送一次数据 无论数据包的大小都会将这些数据发送出去
SO_REUSEADDR
public boolean getReuseAddress() throws SocketException public void setReuseAddress(boolean on) throws SocketException
通过这个选项 可以使多个Socket对象绑定在同一个端口上 其实这样做并没有多大意义 但当使用close方法关闭Socket连接后 Socket对象所绑定的端口并不一定马上释放 系统有时在Socket连接关闭才会再确认一下是否有因为延迟面未到达的数据包 这完全是在底层处理的 也就是说对用户是透明的 因此 在使用Socket类时完全不会感觉到
这种处理机制对于随机绑定端口的Socket对象没有什么影响 但对于绑定在固定端口的Socket对象就可能会抛出 Address already in use JVM_Bind 例外 因此 使用这个选项可以避免个例外的发生
package mynet;import *;import java io *;public class Test{ public static void main(String[] args) { Socket socket = new Socket(); Socket socket = new Socket(); try { socket setReuseAddress(true); socket bind(new InetSocketAddress( )); System out println( socket getReuseAddress(): + socket getReuseAddress()); socket bind(new InetSocketAddress( )); } catch (Exception e) { System out println( error: + e getMessage()); try { socket setReuseAddress(true); socket bind(new InetSocketAddress( )); System out println( socket getReuseAddress(): + socket getReuseAddress()); System out println( 端口 第二次绑定成功! ); } catch (Exception e ) { System out println(e getMessage()); } } }}
上面的代码的运行结果如下
socket getReuseAddress():trueerror:Address already in use: JVM_Bindsocket getReuseAddress():true端口 第二次绑定成功!
使用SO_REUSEADDR选项时有两点需要注意
必须在调用bind方法之前使用setReuseAddress方法来打开SO_REUSEADDR选项 因此 要想使用SO_REUSEADDR选项 就不能通过Socket类的构造方法来绑定端口
必须将绑定同一个端口的所有的Socket对象的SO_REUSEADDR选项都打开才能起作用 如在例程 中 socket 和socket 都使用了setReuseAddress方法打开了各自的SO_REUSEADDR选项
SO_LINGER
public int getSoLinger() throws SocketExceptionpublic void setSoLinger(boolean on int linger) throws SocketException
这个Socket选项可以影响close方法的行为 在默认情况下 当调用close方法后 将立即返回 如果这时仍然有未被送出的数据包 那么这些数据包将被丢弃 如果将linger参数设为一个正整数n时（n的值最大是 ） 在调用close方法后 将最多被阻塞n秒 在这n秒内 系统将尽量将未送出的数据包发送出去 如果超过了n秒 如果还有未发送的数据包 这些数据包将全部被丢弃 而close方法会立即返回 如果将linger设为 和关闭SO_LINGER选项的作用是一样的
如果底层的Socket实现不支持SO_LINGER都会抛出SocketException例外 当给linger参数传递负数值时 setSoLinger还会抛出一个IllegalArgumentException例外 可以通过getSoLinger方法得到延迟关闭的时间 如果返回 则表明SO_LINGER是关闭的 例如 下面的代码将延迟关闭的时间设为 分钟
if(socket getSoLinger() == ) socket setSoLinger(true );
SO_TIMEOUT
public int getSoTimeout() throws SocketExceptionpublic void setSoTimeout(int timeout) throws SocketException
这个Socket选项在前面已经讨论过 可以通过这个选项来设置读取数据超时 当输入流的read方法被阻塞时 如果设置timeout（timeout的单位是毫秒） 那么系统在等待了timeout毫秒后会抛出一个InterruptedIOException例外 在抛出例外后 输入流并未关闭 你可以继续通过read方法读取数据
如果将timeout设为 就意味着read将会无限等待下去 直到服务端程序关闭这个Socket 这也是timeout的默认值 如下面的语句将读取数据超时设为 秒
socket setSoTimeout( * );
当底层的Socket实现不支持SO_TIMEOUT选项时 这两个方法将抛出SocketException例外 不能将timeout设为负数 否则setSoTimeout方法将抛出IllegalArgumentException例外
SO_SNDBUF
public int getSendBufferSize() throws SocketExceptionpublic void setSendBufferSize(int size) throws SocketException
在默认情况下 输出流的发送缓冲区是 个字节（ K） 这个值是Java所建议的输出缓冲区的大小 如果这个默认值不能满足要求 可以用setSendBufferSize方法来重新设置缓冲区的大小 但最好不要将输出缓冲区设得太小 否则会导致传输数据过于频繁 从而降低网络传输的效率
如果底层的Socket实现不支持SO_SENDBUF选项 这两个方法将会抛出SocketException例外 必须将size设为正整数 否则setSendBufferedSize方法将抛出IllegalArgumentException例外
SO_RCVBUF
public int getReceiveBufferSize() throws SocketExceptionpublic void setReceiveBufferSize(int size) throws SocketException
在默认情况下 输入流的接收缓冲区是 个字节（ K） 这个值是Java所建议的输入缓冲区的大小 如果这个默认值不能满足要求 可以用setReceiveBufferSize方法来重新设置缓冲区的大小 但最好不要将输入缓冲区设得太小 否则会导致传输数据过于频繁 从而降低网络传输的效率
如果底层的Socket实现不支持SO_RCVBUF选项 这两个方法将会抛出SocketException例外 必须将size设为正整数 否则setReceiveBufferSize方法将抛出IllegalArgumentException例外
SO_KEEPALIVE
public boolean getKeepAlive() throws SocketExceptionpublic void setKeepAlive(boolean on) throws SocketException
如果将这个Socket选项打开 客户端Socket每隔段的时间（大约两个小时）就会利用空闲的连接向服务器发送一个数据包 这个数据包并没有其它的作用 只是为了检测一下服务器是否仍处于活动状态 如果服务器未响应这个数据包 在大约 分钟后 客户端Socket再发送一个数据包 如果在 分钟内 服务器还没响应 那么客户端Socket将关闭 如果将Socket选项关闭 客户端Socket在服务器无效的情况下可能会长时间不会关闭 SO_KEEPALIVE选项在默认情况下是关闭的 可以使用如下的语句将这个SO_KEEPALIVE选项打开
socket setKeepAlive(true);
SO_OOBINLINE
public boolean getOOBInline() throws SocketException public void setOOBInline(boolean on) throws SocketException
如果这个Socket选项打开 可以通过Socket类的sendUrgentData方法向服务器发送一个单字节的数据 这个单字节数据并不经过输出缓冲区 而是立即发出 虽然在客户端并不是使用OutputStream向服务器发送数据 但在服务端程序中这个单字节的数据是和其它的普通数据混在一起的 因此 在服务端程序中并不知道由客户端发过来的数据是由OutputStream还是由sendUrgentData发过来的 下面是sendUrgentData方法的声明
public void sendUrgentData(int data) throws IOException
虽然sendUrgentData的参数data是int类型 但只有这个int类型的低字节被发送 其它的三个字节被忽略 下面的代码演示了如何使用SO_OOBINLINE选项来发送单字节数据
package mynet;import *;import java io *;class Server{ public static void main(String[] args) throws Exception { ServerSocket serverSocket = new ServerSocket( ); System out println( 服务器已经启动 端口号 ); while (true) { Socket socket = serverSocket accept(); socket setOOBInline(true); InputStream in = socket getInputStream(); InputStreamReader inReader = new InputStreamReader(in); BufferedReader bReader = new BufferedReader(inReader); System out println(bReader readLine()); System out println(bReader readLine()); socket close(); } }}public class Client{ public static void main(String[] args) throws Exception { Socket socket = new Socket( ); socket setOOBInline(true); OutputStream out = socket getOutputStream(); OutputStreamWriter outWriter = new OutputStreamWriter(out); outWriter write( ); // 向服务器发送字符 C outWriter write( hello world\r\n ); socket sendUrgentData( ); // 向服务器发送字符 A socket sendUrgentData( ); // 向服务器发送字符 B outWriter flush(); socket sendUrgentData( ); // 向服务器发送汉字 中 socket sendUrgentData( ); socket sendUrgentData( ); // 向服务器发送汉字 国 socket sendUrgentData( ); socket close(); }}
由于运行上面的代码需要一个服务器类 因此 在加了一个类名为Server的服务器类 关于服务端套接字的使用方法将会在后面的文章中详细讨论 在类Server类中只使用了ServerSocket类的accept方法接收客户端的请求 并从客户端传来的数据中读取两行字符串 并显示在控制台上
测试
由于本例使用了 因Server和Client类必须在同一台机器上运行
运行Server
java mynet Server
运行Client
java mynet Client
在服务端控制台的输出结果
服务器已经启动 端口号 ABChello world中国
在ClienT类中使用了sendUrgentData方法向服务器发送了字符 A （ ）和 B （ ） 但发送 B 时实际发送的是 由于sendUrgentData只发送整型数的低字节 因此 实际发送的是 十进制整型 的二进制形式如图 所示
图 十进制整型 的二进制形式
从图 可以看出 虽然 分布在了两个字节上 但它的低字节仍然是
在Client类中使用flush将缓冲区中的数据发送到服务器 我们可以从输出结果发现一个问题 在Client类中先后向服务器发送了 C hello world r n A B 而在服务端程序的控制台上显示的却是ABChello world 这种现象说明使用sendUrgentData方法发送数据后 系统会立即将这些数据发送出去 而使用write发送数据 必须要使用flush方法才会真正发送数据
在Client类中向服务器发送 中国 字符串 由于 中 是由 和 两个字节组成的 而 国 是由 和 两个字节组成的 因此 可分别发送这四个字节来传送 中国 字符串
lishixinzhi/Article/program/Java/hx/201311/26387
java socket网络编程
//==============Server.java=================//
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket s = new ServerSocket(12345);
System.out.println("服务器就绪,请启动客户端.");
Socket so = s.accept();
byte[] buff = new byte[1024];
int read = so.getInputStream().read(buff);
String[] abc=new String(buff,0,read).split("\\D+");
int a = Integer.parseInt(abc[0]);
int b = Integer.parseInt(abc[1]);
int c = Integer.parseInt(abc[2]);
if(!cbt(a,b,c))
so.getOutputStream().write("输入的数据无法组成三角形.".getBytes());
else
so.getOutputStream().write(getArea(a,b,c).getBytes());
so.getOutputStream().flush();
so.close();
s.close();
}
private static String getArea(int a, int b, int c) {
float s = (a+b+c)/2f;
return "面积: "+Math.sqrt(s*(s-a)*(s-b)*(s-c));
}
private static boolean cbt(int a, int b, int c) {
return a0b0c0a+bcb+caa+cb;
}
}
//=================Client.java======================//
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
System.out.println("输入三角形的三边并用逗号隔开,如: (3,4,5) ");
byte[] buff=new byte[64];
int r = System.in.read(buff);
String ipaddr = "localhost";//根据情况改变,在本机调试就不改了
Socket so = new Socket(ipaddr,12345);
so.getOutputStream().write(new String(buff,0,r).getBytes());
r = so.getInputStream().read(buff);
so.close();
String rs = new String(buff,0,r);
System.out.println(rs);
}
}
//先启动Server,再启动Client
java网络编程问题
1.每个客户端上线的时候都会把自己的IP传给服务器，服务器会维护一个QQ号码与对应IP的列表。
2.
A如果想给B发消息，首先要去服务器上通过B的QQ号查询B的IP，然后与B建立P2P的通信，不怎能是每次通讯都经过服务器的，那样服务器的负载就太重了，肯定没法即时响应。
我要一份用java网络编程写的点对点的两人聊天程序(TCP和UDP)?
Server端：
import java.io.*;
import java.net.*;
import java.applet.Applet;
public class TalkServer{
public static void main(String args[]) {
try{
ServerSocket server=null;
try{
server=new ServerSocket(4700);
}catch(Exception e) {
System.out.println("can not listen to:"+e);
}
Socket socket=null;
try{
socket=server.accept();
}catch(Exception e) {
System.out.println("Error."+e);
}
String line;
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter os=new PrintWriter(socket.getOutputStream());
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Client:"+is.readLine());
line=sin.readLine();
while(!line.equals("bye")){
os.println(line);
os.flush();
System.out.println("Server:"+line);
System.out.println("Client:"+is.readLine());
line=sin.readLine();
}
os.close();
is.close();
socket.close();
server.close();
}catch(Exception e){
System.out.println("Error:"+e);
}
}
}
Client端：
import java.io.*;
import java.net.*;
public class TalkClient {
public static void main(String args[]) {
try{
Socket socket=new Socket("127.0.0.1",4700);
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
PrintWriter os=new PrintWriter(socket.getOutputStream());
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String readline;
readline=sin.readLine(); //从系统标准输入读入一字符串
while(!readline.equals("bye")){
os.println(readline);
os.flush();
System.out.println("Client:"+readline);
System.out.println("Server:"+is.readLine());
readline=sin.readLine(); //从系统标准输入读入一字符串
}
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
}catch(Exception e) {
System.out.println("Error"+e); //出错，则打印出错信息
}
}
}
一个最简单的java网络编程
你好：Socket s = new Socket("localhost", 6660);//14行
这个的话，你的没通， 去黑窗口输入 tenlet 127.0.0.1 6660;看看是否有结果输出，再就是你别用localhost了，换成实际的127.0.0.1的地址，
关于java简单网络编程案例和Windows网络编程案例教程的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。