java网络编程代码

1. 我要一份用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); //出错，则打印出错信息
}
}
}

2. java网络编程，怎样在客户端和服务器间实现通信。

写个简单点的服务器跟客服端就行了我写了个很简单的，只能在一个客户端跟一个服务器通信，在控制台输入下面这个是服务器import java.io.*;
import java.net.*;
import java.util.Scanner;public class Server
{
public static void main(String[] args)
{
try {
ServerSocket server=new ServerSocket(8888);//定义客户端的端口号
Socket client=server.accept();//定义一个Socket对象

InputStream is=client.getInputStream();//服务器接受信息输入流，也就是接受从服务器段发送过来的消息
BufferedReader br=new BufferedReader(new InputStreamReader(is));//用bufferedreader包装下输入流

OutputStream os=client.getOutputStream();//这是用来给服务器发送消息的输出流
PrintStream ps=new PrintStream(os);
Scanner scanner=new Scanner(System.in);//从键盘输入字符串

boolean flag=true;//定义一个死循环，让服务器不停的接受从客户端发送来的字符串
while(flag)
{
String s=br.readLine();//s是从客户端接受到得字符串
System.out.println(s);

String s2=scanner.nextLine();//s2是写给客户端的字符串
ps.println(s2); //给客户端发送你写的东西
}
client.close();
} catch (IOException e) {//try 跟catch你不用管，这是用来处理异常的，就是固定格式

e.printStackTrace();
}
}
} 下面是客户端import java.io.*;
import java.net.*;
import java.util.Scanner;public class Client
{ public static void main(String[] args)
{
try
{
Socket client=new Socket("192.168.--.--",8888);//IP地址是个字符串，端口号是个整数，这个端口号要跟前面你写的那个一样，还有IP地址，写你的机器的IP地址

InputStream is=client.getInputStream();//这边的两个流跟上面服务器的差不多的作用
BufferedReader bf=new BufferedReader(new InputStreamReader(is));

OutputStream os=client.getOutputStream();
PrintStream ps=new PrintStream(os);
Scanner scanner=new Scanner(System.in);
boolean flag=true;
while(flag)//这句话可以让客户端不停的说话
{
String s2=scanner.nextLine();
ps.println(s2);

String s=bf.readLine();
System.out.println(s); }

client.close();

}
catch (UnknownHostException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
} }}

3. 浅谈Java中如何利用socket进行网络编程（一）

Socket是网络上运行的两个程序间双向通讯的一端，它既可以接受请求，也可以发送请求，利用它可以较为方便的编写网络上的数据的传递。在java中，有专门的socket类来处理用户的请求和响应。利用SOCKET类的方法，就可以实现两台计算机之间的通讯。这里就介绍一下在JAVA中如何利用socket进行网络编程。 在Java中Socket可以理解为客户端或者服务器端的一个特殊的对象，这个对象有两个关键的方法，一个是getInputStream方法，另一个是getOutputStream方法。getInputStream方法可以得到一个输入流，客户端的Socket对象上的getInputStream方法得到的输入流其实就是从服务器端发回的数据流。GetOutputStream方法得到一个输出流，客户端Socket对象上的getOutputStream方法返回的输出流就是将要发送到服务器端的数据流，（其实是一个缓冲区，暂时存储将要发送过去的数据）。 程序可以对这些数据流根据需要进行进一步的封装。本文的例子就对这些数据流进行了一定的封装（关于封装可以参考Java中流的实现部分）。 一、建立服务器类 Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket，可以用服务器需要使用的端口号作为参数来创建服务器对象。ServerSocket server = new ServerSocket(9998) 这条语句创建了一个服务器对象，这个服务器使用9998号端口。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。Socket incoming = server.accept() 进而得到输入流和输出流，并进行封装BufferedReader in = new BufferedReader(new InputStreamReader(incoming.getInputStream())); PrintWriter out = new PrintWriter(incoming.getOutputStream(),true); 随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。

4. 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 a>0&&b>0&&c>0&&a+b>c&&b+c>a&&a+c>b;
}
}

//=================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

5. Java网络编程从入门到精通（5）：使用InetAddress类的getHostName方法获得域

该方法可以得到远程主机的域名 也可以得到本机名 getHostName方法的定义如下

publicStringgetHostName()

下面是三种创建InetAddress对象的方式 在这三种方式中 getHostName返回的值是不同的

使用getLocalHost方法创建InetAddress对象

如果InetAddress对象是用getLocalHost方法创建的 getHostName返回的是本机名 如下面的代码所示

InetAddressaddress=InetAddress getLocalHost();System out println(address getHostName());//输出本机名

使用域名创建InetAddress对象

用域名作为getByName和getAllByName方法的参数调用这两个方法后 系统会自动记住这个域名 当调用getHostName方法时 就无需再访问DNS服务器 而是直接将这个域名返回 如下面的代码所示

InetAddressaddress=InetAddress getByName( );System out println(address getHostName());//无需访问DNS服务器 直接返回域名

使用IP地址创建InetAddress对象

使用IP地址创建InetAddress对象时（getByName getAllByName和getByAddress方法都可以通过IP地址创建InetAddress对象） 并不需要访问DNS服务器 因此 通过DNS服务器查找域名的工作就由getHostName方法来完成 如果这个IP地址不存在或DNS服务器不允许进行IP地址和域名的映射 getHostName方法就直接返回这个IP地址 如下面的代码所示

InetAddressaddress=InetAddress getByName( );System out println(address getHostName());//需要访问DNS服务器才能得到域名InetAddressaddress=InetAddress getByName( );//IP地址不存在System out println(address getHostName());//直接返回IP地址

从上面的三种情况可以看出 只有通过使用IP地址创建的InetAddress对象调用getHostName方法时才访问DNS服务器 在其他情况 getHostName方法并不会访问DNS服务器 而是直接将域名或本机名返回 下面的代码演示了在不同情况下如何使用getHostName方法 并计算了各种情况所需的毫秒数

package mynet;import *;publicclass DomainName{publicstaticvoidmain(String[]args)throwsException{longtime= ;//得到本机名InetAddressaddress =InetAddress getLocalHost();System out println( 本机名 +address getHostName());//直接返回域名InetAddressaddress =InetAddress getByName( );time=System currentTimeMillis();System out print( 直接得到域名 +address getHostName());System out println( 所用时间 +String valueOf(System currentTimeMillis() time)+ 毫秒 );//通过DNS查找域名InetAddressaddress =InetAddress getByName( ); System out println( address : +address );//域名为空time=System currentTimeMillis();System out print( 通过DNS查找域名 +address getHostName());System out println( 所用时间 +String valueOf(System currentTimeMillis() time)+ 毫秒 ); System out println( address : +address );//同时输出域名和IP地址}}

运行结果

本机名 ComputerName直接得到域名 所用时间 毫秒address :/ 通过DNS查找域名 bigip o所用时间 毫秒address :bigip o/

6. Java 网络编程

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

public class Sendserver
{
public static int port = 3333;
public static void main(String[] args) throws IOException
{
ServerSocket s = new ServerSocket(port);
Socket d= s.accept();
System.out.println("客户端连接成功");

DataInputStream input = new DataInputStream(d.getInputStream());
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(
new BufferedOutputStream(new FileOutputStream(
"2.mp3"))));
while (true)
{
int read = 0;
if (input != null)
read = input.read(buf);

if (read == -1)
break;

byte[] temp=new byte[read];
for(int i=0;i<read;i++)
temp[i]=buf[i];
fileOut.write(temp);
}
fileOut.close();
System.out.println("传送完毕");

}
}

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

public class SendClient
{

public static void main(String[] args) throws UnknownHostException, IOException
{
try{
DataInputStream iinput = new DataInputStream(new BufferedInputStream(
new FileInputStream("1.mp3")));

InetAddress addr = InetAddress.getByName("localhost");
Socket f= new Socket(addr,3333);
OutputStream output=f.getOutputStream();

int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
while (true)
{
int read = 0;
if (iinput != null)
read = iinput.read(buf);

if (read == -1)
break;

byte[] temp=new byte[read];
for(int i=0;i<read;i++)
temp[i]=buf[i];
output.write(temp);
output.flush();
}

iinput.close();
output.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

改动相当大，你自己看看吧。

7. java网络技术编程

一、 客户端网络编程步骤
客户端(Client)是指网络编程中首先发起连接的程序，客户端一般实现程序界面和基本逻辑实现，在进行实际的客户端编程时，无论客户端复杂还是简单，以及客户端实现的方式，客户端的编程主要由三个步骤实现：
1、 建立网络连接
客户端网络编程的第一步都是建立网络连接。在建立网络连接时需要指定连接到的服务器的IP地址和端口号，建立完成以后，会形成一条虚拟的连接，后续的操作就可以通过该连接实现数据交换了。
2、 交换数据
连接建立以后，就可以通过这个连接交换数据了。交换数据严格按照请求响应模型进行，由客户端发送一个请求数据到服务器，服务器反馈一个响应数据给客户端，如果客户端不发送请求则服务器端就不响应。
根据逻辑需要，可以多次交换数据，但是还是必须遵循请求响应模型。
3、 关闭网络连接
在数据交换完成以后，关闭网络连接，释放程序占用的端口、内存等系统资源，结束网络编程。
最基本的步骤一般都是这三个步骤，在实际实现时，步骤2会出现重复，在进行代码组织时，由于网络编程是比较耗时的操作，所以一般开启专门的现场进行网络通讯。

二、服务器端网络编程步骤
服务器端(Server)是指在网络编程中被动等待连接的程序，服务器端一般实现程序的核心逻辑以及数据存储等核心功能。服务器端的编程步骤和客户端不同，是由四个步骤实现，依次是：
1、 监听端口
服务器端属于被动等待连接，所以服务器端启动以后，不需要发起连接，而只需要监听本地计算机的某个固定端口即可。
这个端口就是服务器端开放给客户端的端口，服务器端程序运行的本地计算机的IP地址就是服务器端程序的IP地址。
2、 获得连接
当客户端连接到服务器端时，服务器端就可以获得一个连接，这个连接包含客户端的信息，例如客户端IP地址等等，服务器端和客户端也通过该连接进行数据交换。
一般在服务器端编程中，当获得连接时，需要开启专门的线程处理该连接，每个连接都由独立的线程实现。
3、 交换数据
服务器端通过获得的连接进行数据交换。服务器端的数据交换步骤是首先接收客户端发送过来的数据，然后进行逻辑处理，再把处理以后的结果数据发送给客户端。简单来说，就是先接收再发送，这个和客户端的数据交换数序不同。
其实，服务器端获得的连接和客户端连接是一样的，只是数据交换的步骤不同。
当然，服务器端的数据交换也是可以多次进行的。
在数据交换完成以后，关闭和客户端的连接。
4、 关闭连接
当服务器程序关闭时，需要关闭服务器端，通过关闭服务器端使得服务器监听的端口以及占用的内存可以释放出来，实现了连接的关闭。
其实服务器端编程的模型和呼叫中心的实现是类似的，例如移动的客服电话10086就是典型的呼叫中心，当一个用户拨打10086时，转接给一个专门的客服人员，由该客服实现和该用户的问题解决，当另外一个用户拨打10086时，则转接给另一个客服，实现问题解决，依次类推。
在服务器端编程时，10086这个电话号码就类似于服务器端的端口号码，每个用户就相当于一个客户端程序，每个客服人员就相当于服务器端启动的专门和客户端连接的线程，每个线程都是独立进行交互的。
这就是服务器端编程的模型，只是TCP方式是需要建立连接的，对于服务器端的压力比较大，而UDP是不需要建立连接的，对于服务器端的压力比较小罢了。