javasocketc
java编程对于Socket之间的通信过程如下：
服务端往Socket的输出流里面写东西，客户端就可以通过Socket的输入流读取对应的内容。Socket与Socket之间是双向连通的，所以客户端也可以往对应的Socket输出流里面写东西，然后服务端对应的Socket的输入流就可以读出对应的内容。下面来看一些服务端与客户端通信的例子：
publicclassServer{
publicstaticvoidmain(Stringargs[])throwsIOException{
//为了简单起见，所有的异常信息都往外抛
intport=8899;
//定义一个ServerSocket监听在端口8899上
ServerSocketserver=newServerSocket(port);
//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的
Socketsocket=server.accept();
//跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。
Readerreader=newInputStreamReader(socket.getInputStream());
charchars[]=newchar[64];
intlen;
StringBuildersb=newStringBuilder();
while((len=reader.read(chars))!=-1){
sb.append(newString(chars,0,len));
}
System.out.println("fromclient:"+sb);
reader.close();
socket.close();
server.close();
}
}客户端代码
Java代码publicclassClient{
publicstaticvoidmain(Stringargs[])throwsException{
//为了简单起见，所有的异常都直接往外抛
Stringhost="127.0.0.1";//要连接的服务端IP地址
intport=8899;//要连接的服务端对应的监听端口
//与服务端建立连接
Socketclient=newSocket(host,port);
//建立连接后就可以往服务端写数据了
Writerwriter=newOutputStreamWriter(client.getOutputStream());
writer.write("HelloServer.");
writer.flush();//写完后要记得flush
writer.close();
client.close();
}
}
Ⅱ java中的socket是什么意思
所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。x0dx0a以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。x0dx0a重要的Socket API：x0dx0ajava.net.Socket继承于java.lang.Object，有八个构造器，其方法并不闹李多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。x0dx0a. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。x0dx0a. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。x0dx0a. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。x0dx0a注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。x0dx0a2ServerSocket类例子编辑x0dx0ax0dx0apackage com.lanber.socket;x0dx0aimport java.io.DataInputStream;x0dx0aimport java.io.DataOutputStream;x0dx0aimport java.io.IOException;x0dx0aimport java.net.ServerSocket;x0dx0aimport java.net.Socket;x0dx0apublic class ServerDemo {x0dx0a/**x0dx0a* 注意：Socket的发送与接收是需要同步进行的，即客户端发送一条信息，服务器必需先接收这条信息，x0dx0a* 而后才可以碰吵向客户端发送信息，否则将会有运行时出错。x0dx0a* @param argsx0dx0a*/笑弯侍x0dx0apublic static void main(String[] args) {x0dx0aServerSocket ss = null;x0dx0atry {x0dx0ass = new ServerSocket(8888);x0dx0a//服务器接收到客户端的数据后，创建与此客户端对话的Socketx0dx0aSocket socket = ss.accept();x0dx0a//用于向客户端发送数据的输出流x0dx0aDataOutputStream dos = new DataOutputStream(socket.getOutputStream());x0dx0a//用于接收客户端发来的数据的输入流x0dx0aDataInputStream dis = new DataInputStream(socket.getInputStream());x0dx0aSystem.out.println("服务器接收到客户端的连接请求：" + dis.readUTF());x0dx0a//服务器向客户端发送连接成功确认信息x0dx0ados.writeUTF("接受连接请求，连接成功!");x0dx0a//不需要继续使用此连接时，关闭连接x0dx0asocket.close();x0dx0ass.close();x0dx0a} catch (IOException e) {x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0a}x0dx0ax0dx0a3客户端的例子编辑x0dx0apackage com.lanber.socket;x0dx0aimportjava.io.DataInputStream;x0dx0aimport java.io.DataOutputStream;x0dx0aimportjava.io.IOException;x0dx0aimport java.io.OutputStream;x0dx0aimport java.net.Socket;x0dx0aimport java.net.UnknownHostException;x0dx0apublic class ClientDemo {x0dx0a/**x0dx0a* @param argsx0dx0a*/x0dx0apublic static void main(String[] args) {x0dx0aSocket socket = null;x0dx0atry {x0dx0asocket = new Socket("localhost",8888);x0dx0a//获取输出流，用于客户端向服务器端发送数据x0dx0aDataOutputStream dos = new DataOutputStream(socket.getOutputStream());x0dx0a//获取输入流，用于接收服务器端发送来的数据x0dx0aDataInputStream dis = new DataInputStream(socket.getInputStream());x0dx0a//客户端向服务器端发送数据x0dx0ados.writeUTF("我是客户端，请求连接!");x0dx0a//打印出从服务器端接收到的数据x0dx0aSystem.out.println(dis.readUTF());x0dx0a//不需要继续使用此连接时，记得关闭哦x0dx0asocket.close();x0dx0a} catch (UnknownHostException e) {x0dx0ae.printStackTrace();x0dx0a} catch (IOException e) {x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0a}
Ⅲ Java Socket初步详解
网络编程的基本模型就是客户机到服务器模型 简单的说就是两个进程之间相互通讯 然后其中一个必须提供一个固定的位置 而另一个则只需要知道这个固定的位置 并去建立两者之间的联系 然后完成数据的通讯就可以了 这里提供亩悉猜固定位置的通常称为服务器 而建立联系的通常叫做客户端 基于这个简单的模型 就可以进入网络编程啦
Java对这个模型的支持有很多种Api 而这里我只想介绍有关Socket的编程接口 对于Java而言已经简化了Socket的编程接口 首先我们来讨论有关提供固定位置的服务方是如何建立的 Java提供了ServerSocket来对其进行支持 事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你 ServerSocket server=new ServerSocket( );这里稍微要注意的是端口的分配必须是唯一的 因为端口是为了唯一标识每台计算机唯一服务的 另外端口号是从 ~ 之间的 前 个端口已经被Tcp/Ip 作为保留端口 因此你所分配的端口只能是 个之后的 好了 我们有了固定位置 现在所需要的就是一根连接线了 该连接线由客户方首先提出要求 因此Java同样提供了一个Socket对象来对其进行支持 只要客户方创建一个Socket的实例对象进行支持就可以了 Socket client
=new Socket(InetAddress getLocalHost() );客户机必须知道有关服务器的IP地址 对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供 它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法
上面的方法基本可以建立一条连线让两台计算机相互交流了 可是数据是如何传输的呢？事实上I/O操作总是和网络编程息息相关的 因为底层的网络是继续数据的 除非远程调用 处理问题的核心在执行上 否则数据的陆帆交互还是依赖于IO操作的 所以你也必须导入java io这个包 java的IO操作也不复杂 它提供了针对于字节流和Unicode的读者和写者 然后也提供了一个缓冲用于数据的读写
BufferedReader in=new BufferedReader(new InputStreamReader(server getInputStream()));
PrintWriter out=new PrintWriter(server getOutputStream());
上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作 而原始的字节流来源于Socket的两个方法 getInputStream()和getOutputStream()方 分别用来得到输入和输出 那么现在有了基本的模型和基本的操作工具 我们可以做一个简单的Socket例程了
服务方:
import java io *;
import *;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket( );
Socket client=server accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));
迅型PrintWriter out=new PrintWriter(client getOutputStream());
while(true){
String str=in readLine();
System out println(str);
out println( has receive );
out flush();
if(str equals( end ))
break;
}
client close();
}
}
这个程序的主要目的在于服务器不断接收客户机所写入的信息只到 客户机发送 End 字符串就退出程序 并且服务器也会做出 Receive 为回应 告知客户机已接收到消息
客户机代码:
import *;
import java io *;
public class Client{
static Socket server;
public static void main(String[] args)throws Exception{
server=new Socket(InetAddress getLocalHost() );
BufferedReader in=new BufferedReader(new InputStreamReader(server getInputStream()));
PrintWriter out=new PrintWriter(server getOutputStream());
BufferedReader wt=new BufferedReader(new InputStreamReader(System in));
while(true){
String str=wt readLine();
out println(str);
out flush();
if(str equals( end )){
break;
}
System out println(in readLine());
}
server close();
}
}
客户机代码则是接受客户键盘输入 并把该信息输出 然后输出 End 用来做退出标识
这个程序只是简单的两台计算机之间的通讯 如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端 结果是会抛出异常的 那么多个客户端如何实现呢?
其实 简单的分析一下 就可以看出客户和服务通讯的主要通道就是Socket本身 而服务器通过accept方法就是同意和客户建立通讯 这样当客户建立Socket的同时 服务器也会使用这一根连线来先后通讯 那么既然如此只要我们存在多条连线就可以了 那么我们的程序可以变为如下:
服务器:
import java io *;
import *;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket( );
while(true){
Socket client=server accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));
PrintWriter out=new PrintWriter(client getOutputStream());
while(true){
String str=in readLine();
System out println(str);
out println( has receive );
out flush();
if(str equals( end ))
break;
}
client close();
}
}
}
这里仅仅只是加了一个外层的While循环 这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互 这里也就是接受到客户的 End 消息 那么现在就实现了多客户之间的交互了 但是 问题又来了 这样做虽然解决了多客户 可是是排队执行的 也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互 无法做到同时服务 那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了 所以线程是最好的解决方案
那么下面的问题是如何使用线程 首先要做的事情是创建线程并使得其可以和网络连线取得联系 然后由线程来执行刚才的操作 要创建线程要么直接继承Thread要么实现Runnable接口 要建立和Socket的联系只要传递引用就可以了 而要执行线程就必须重写run方法 而run方法所做的事情就是刚才单线程版本main所做的事情 因此我们的程序变成了这样:
import *;
import java io *;
public class MultiUser extends Thread{
private Socket client;
public MultiUser(Socket c){
this client=c;
}
public void run(){
try{
BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));
PrintWriter out=new PrintWriter(client getOutputStream());
//Mutil User but can t parallel
while(true){
String str=in readLine();
System out println(str);
out println( has receive );
out flush();
if(str equals( end ))
break;
}
client close();
}catch(IOException ex){
}finally{
}
}
public static void main(String[] args)throws IOException{
ServerSocket server=new ServerSocket( );
while(true){
//transfer location change Single User or Multi User
MultiUser mu=new MultiUser(server accept());
mu start();
}
}
}
lishixin/Article/program/Java/hx/201311/27013
Ⅳ java socket有什么作用
所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。
重要的Socket API：
java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。
. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。
. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例，。
. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。
注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。
编辑本段ServerSocket类例子
int PORT = 8888; // 侦听端口
// 创建ServerSocket
ServerSocket serverSocket = new ServerSocket(PORT);
// 开始循环
while (true) {
// 等待连接
Socket socket = serverSocket.accept();
// 处理链接的线程类
ServerThread st = new ServerThread(socket);
// 启动线程处理
new Thread(st).start();
}
编辑本段客户端的例子
int PORT = 8888; // 侦听端口
// 建立连接
socket = new Socket(“127.0.0.1”, 8888);
// 输入数据的读取
BufferedReader netIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 写入数据
PrintWriter netOut = new PrintWriter(socket.getOutputStream());
Ⅳ java Socket通信原理
具体如下：
首先socket 通信是基于TCP/IP 网络层上的一种传送方式，我们通常把TCP和UDP称为传输层。其中UDP是一种面向无连接的传输层协议。UDP不关心对端是否真正收到了传送过去的数据。
如果需要检查对端是否收到分组数据包，或者对端是否连接到网络，则需要在应用程序中实现。UDP常用在分组数据较少或多播、广播通信以及视频通信等多媒体领域。
在这里我们不进行详细讨论，这里主要讲解的是基于TCP/IP协议下的socket通信。
socket是基于应用服务与TCP/IP通信之间的一个抽象，他将TCP/IP协议里面复杂的通信逻辑进行分装。
服务端初始化ServerSocket，然后对指定的端口进行绑定，接着对端口及进行监听，通过调用accept方法阻塞。
此时，如果客户端有一个socket连接到服务端，那么服务端通过监听和accept方法可以与客户端进行连接。
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。
Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。
Ⅵ Java Socket 长连接怎么实现
现编这个就是个多线程服务器，只要在client不释放连接，服务器端的run里边写while（TRUE）循环，那么就可以长期连接。
class ConnectionThread extends Thread{
Socket client;
int counter;
public ConnectionThread(Socket cl,int c){
client = cl;
counter= c;
}
@Override
public void run()
{
try{
String destIP=client.getInetAddress().toString();
int destport =client.getPort();
PrintStream outstream=new PrintStream(client.getOutputStream());
DataInputStream instream=new DataInputStream(client.getInputStream());
String inline=instream.readLine();
}//try
catch(IOException e){System.out.println(e);}
}//run
Ⅶ JAVA socket通信
publicclassClient{
publicstaticvoidmain(String[]args){
Strings=null;
Socketmysocket;
DataInputStreamin=null;
DataOutputStreamout=null;
try{
mysocket=newSocket("127.0.0.1",4331);
in=newDataInputStream(mysocket.getInputStream());
out=newDataOutputStream(mysocket.getOutputStream());
for(intk=1;k<100;k=k+2){
out.writeUTF(""+k);
s=in.readUTF();
System.out.println("客户收到"+s);
Thread.sleep(500);
}
}catch(Exceptione){
System.out.println("服务器已断开"+e);
}
}
}
publicclassServer{
publicstaticvoidmain(String[]args){
ServerSocketserver=null;
Socketyou=null;
Strings=null;
DataOutputStreamout=null;
DataInputStreamin=null;
try{
server=newServerSocket(4331);
}catch(Exceptione){
System.out.println(e);
}
try{
System.out.println("等待客户呼叫");
you=server.accept();
out=newDataOutputStream(you.getOutputStream());
in=newDataInputStream(you.getInputStream());
while(true){
s=in.readUTF();
intm=Integer.parseInt(s);
out.writeUTF("你好,我是服务器");
out.writeUTF("你说的数乘2后是:"+2*m);
System.out.println("服务器收到:"+s);
Thread.sleep(500);
}
}catch(Exceptione){
System.out.println("客户端已断开"+e);
}
}
}
很简单的服务器客户端程序
Ⅷ java中如何创建socket连接的过程
这是我写过的一个简单聊天软件客户端 你参考下
importjava.util.*;
importjava.io.*;
importjava.net.*;
importjava.awt.*;
importjavax.swing.*;
importjava.awt.event.*;
{
privateJTextAreajta=newJTextArea();
privateJTextFieldjtf=newJTextField();
privateJComboBox<String>jcb=newJComboBox<String>();
privateJButtonjbsend=newJButton("send");
privateJButtonjbrefresh=newJButton("refresh");
privateInputStreaminput;
privateOutputStreamoutput;
private Socketsocket;
publicstaticStringSERVER_IP="192.168.1.101";
publicstaticintSERVER_PORT=8888;
//Message1->refreshmessage
//Message2->sendmessage
publictestChatClient()
{
initComponents();
try
{
socket=newSocket(SERVER_IP,SERVER_PORT);
input=socket.getInputStream();
output=socket.getOutputStream();
}
catch(IOExceptione)
{
System.err.println(e);
}
jbrefresh.addActionListener(newActionListener()
{
publicvoidactionPerformed(ActionEvente)
{
jta.setText("");
try
{
if(socket==null)
socket=newSocket(SERVER_IP,SERVER_PORT);
output.write(0x31);
}
catch(IOExceptionex)
{
JOptionPane.showConfirmDialog(null,ex);
}
}
});
jbsend.addActionListener(newActionListener()
{
publicvoidactionPerformed(ActionEvente)
{
if(jtf.getText()==null||jtf.getText().equals(""))
return;
if(jtf.getText().length()>=400)
{
JOptionPane.showConfirmDialog(null,"最大字数不能超过400");
return;
}
try
{
Stringdestination=jcb.getSelectedItem().toString();
Stringmessage=jtf.getText();
if(socket==null)
socket=newSocket(SERVER_IP,SERVER_PORT);
byte[]temp=newbyte[3+destination.getBytes().length+message.getBytes().length];
temp[0]=0x32;
temp[1]=(byte)destination.getBytes().length;
inti=2;
for(intj=0;j<destination.getBytes().length;i++,j++)
temp[i]=destination.getBytes()[j];
temp[i++]=(byte)message.getBytes().length;
for(intj=0;j<message.getBytes().length;i++,j++)
{
temp[i]=message.getBytes()[j];
System.out.println();
}
output.write(temp);
jta.append("me: ");
jta.append(jtf.getText());
jta.append(" ");
jtf.setText("");
}
catch(IOExceptionex)
{
System.err.println(ex);
}
}
});
try
{
jbrefresh.doClick();
while(true)
{
byte[]tempBytes=newbyte[1000];
input.read(tempBytes);
intcommand=tempBytes[0]-0x30;
//intreadLength=input.read();
switch(command)
{
case1:
{
intreadLength=tempBytes[1];
String[]temp=newString(tempBytes,2,readLength,"UTF-8").split(";");
jcb.removeAllItems();
if(temp.length==0&&temp[0].equals(""))
return;
for(inti=0;i<temp.length;i++)
{
jcb.addItem(temp[i]);
}
jcb.setSelectedIndex(0);
break;
}
case2:
{
intreadLength1=tempBytes[1];
jta.append(newString(tempBytes,2,readLength1,"UTF-8")+" ");
intreadLength2=tempBytes[2+readLength1];
jta.append(newString(tempBytes,3+readLength1,readLength2,"UTF-8")+" ");
break;
}
}
}
}
catch(IOExceptione)
{
System.err.println(e);
}
}
publicstaticvoidmain(String[]args){
testChatClientframe=newtestChatClient();
}
publicvoidinitComponents()
{
setLayout(newBorderLayout());
JPaneljpNorth=newJPanel();
jpNorth.setLayout(newBorderLayout());
jpNorth.add(jcb,BorderLayout.CENTER);
jpNorth.add(jbrefresh,BorderLayout.EAST);
JPaneljpSouth=newJPanel();
jpSouth.setLayout(newBorderLayout());
jpSouth.add(jtf,BorderLayout.CENTER);
jpSouth.add(jbsend,BorderLayout.EAST);
add(jpNorth,BorderLayout.NORTH);
add(jpSouth,BorderLayout.SOUTH);
add(newJScrollPane(jta),BorderLayout.CENTER);
this.getRootPane().setDefaultButton(jbsend);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(300,600);
setVisible(true);
}
}
Ⅸ java socket发送字符串
java中socket是向某个特定地址的端口发送流（字符串通过getBytes方法转换成流）。
publicstaticvoidmain(String[]args){
Sockets;
try{
s=newSocket("localhost",9091);
DataOutputStreamout=newDataOutputStream(s.getOutputStream());
out.write("aslkjlksjdsad".getBytes());
out.flush();
out.close();
}catch(UnknownHostExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}备注：有发送的话，就需要相应的地址和端口上做一个接收的，来实现交互。
Ⅹ java中的socket编程是作什么的
Socket,又称为套接字，Socket是计算机网络派枝通信的基本的技术之一。如今大多数基于网络的软件，如浏览器，即时通讯工具甚至是P2P下载都是基于Socket实现的。本文仿羡慧会介绍一下基于TCP/IP的Socket编程，并且如何写一个客户端/服务器程序。
方法/步骤
Java中的socket编程 下面的部分将通过一些示例讲解一下如何使用socket编写客户端和服务器端的程序。 注意：在接下来的示例中，我将使用基于TCP/IP协议的socket编程，因为这个协议远远比UDP/IP使用的要广泛。并且所有的socket相关的类都位于java.net包备答下，所以在我们进行socket编程时需要引入这个包。
写入数据 接下来就是写入请求数据，我们从客户端的socket对象中得到OutputStream对象，然后写入数据后。很类似文件IO的处理代码。
打开服务器端的socket
读取数据 通过上面得到的socket对象获取InputStream对象，然后安装文件IO一样读取数据即可。这里我们将内容打印出来。
使用socket实现一个回声服务器，就是服务器会将客户端发送过来的数据传回给客户端。