精华内容
下载资源
问答
  • javaSocket

    2013-01-09 14:07:38
    javaSocket 博客分类: socket SocketJava编程多线程.net 事实上网络编程简单的理解就是两台计算机相互通讯数据而已.对于程序员而言,去掌握一种编程接口并使用一种编程模型相对就会显得简单的多了.Java ...

    链接地址:http://wdbk123.iteye.com/blog/686634

    javaSocket

    博客分类: socket

    事实上网络编程简单的理解就是两台计算机相互通讯数据而已.对于程序员而言,去掌握一种编程接口并使用一种编程模型相对就会显得简单的多了.Java SDK提供一些相对简单的Api来完成这些工作.Socket就是其中之一.对于Java而言.这些Api存在与java.net 这个包里面.因此只要导入这个包就可以准备网络编程了.
    网络编程的基本模型就是客户机到服务器模型.简单的说就是两个进程之间相互通讯,然后其中一个必须提供一个固定的位置,而另一个则只需要知道这个固定的位置.并去建立两者之间的联系..然后完成数据的通讯就可以了.这里提供固定位置的通常称为服务器,而建立联系的通常叫做客户端.基于这个简单的模型,就可以进入网络编程啦.
    Java对这个模型的支持有很多种Api.而这里我只想介绍有关Socket的编程接口.对于Java而言已经简化了Socket的编程接口.首先我们来讨论有关提供固定位置的服务方是如何建立的.Java提供了ServerSocket来对其进行支持.事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你.
    Java代码
    ServerSocket server=new ServerSocket(6789);

    ServerSocket server=new ServerSocket(6789);这里稍微要注意的是端口的分配必须是唯一的.因为端口是为了唯一标识每台计算机唯一服务的.另外端口号是从0~65535之间的,前1024个端口已经被Tcp/Ip 作为保留端口,因此你所分配的端口只能是1024个之后的.好了.我们有了固定位置.现在所需要的就是一根连接线了.该连接线由客户方首先提出要求.因此Java同样提供了一个Socket对象来对其进行支持.只要客户方创建一个Socket的实例对象进行支持就可以了.
    Java代码
    Socket client=new Socket(InetAddress.getLocalHost(),5678);

    Socket client=new Socket(InetAddress.getLocalHost(),5678);
    客户机必须知道有关服务器的IP地址.对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供.它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法.
    好了.上面的方法基本可以建立一条连线让两台计算机相互交流了.可是数据是如何传输的呢?事实上I/O操作总是和网络编程息息相关的.因为底层的网络是继续数据的.除非远程调用,处理问题的核心在执行上.否则数据的交互还是依赖于IO操作的.所以你也必须导入java.io这个包.java的IO操作也不复杂.它提供了针对于字节流和Unicode的读者和写者,然后也提供了一个缓冲用于数据的读写.
    Java代码
    BufferedReader in=
    new BufferedReader(new InputStreamReader(server.getInputStream()));
    PrintWriter out=new PrintWriter(server.getOutputStream());

    BufferedReader in=
    new BufferedReader(new InputStreamReader(server.getInputStream()));
    PrintWriter out=new PrintWriter(server.getOutputStream());
    上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作.而原始的字节流来源于Socket的两个方法.getInputStream()和getOutputStream()方.分别用来得到输入和输出.那么现在有了基本的模型和基本的操作工具.我们可以做一个简单的Socket例程了.
    服务方:
    Java代码
    import java.io.*;
    import java.net.*;

    public class MyServer {
    public static void main(String[] args) throws IOException{
    ServerSocket server=new ServerSocket(5678);
    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();
    }
    }

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

    public class MyServer {
    public static void main(String[] args) throws IOException{
    ServerSocket server=new ServerSocket(5678);
    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"为回应.告知客户机已接收到消息.

    客户机代码:
    Java代码
    import java.net.*;
    import java.io.*;

    public class Client{
    static Socket server;

    public static void main(String[] args)throws Exception{
    server=new Socket(InetAddress.getLocalHost(),5678);
    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();
    }
    }

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

    public class Client{
    static Socket server;

    public static void main(String[] args)throws Exception{
    server=new Socket(InetAddress.getLocalHost(),5678);
    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的同时.服务器也会使用这一根连线来先后通讯.那么既然如此只要我们存在多条连线就可以了.那么我们的程序可以变为如下:

    服务器:

    Java代码
    import java.io.*;
    import java.net.*;

    public class MyServer {
    public static void main(String[] args) throws IOException{
    ServerSocket server=new ServerSocket(5678);
    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();
    }
    }
    }

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

    public class MyServer {
    public static void main(String[] args) throws IOException{
    ServerSocket server=new ServerSocket(5678);
    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所做的事情.因此我们的程序变成了这样:
    Java代码
    import java.net.*;
    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(5678);
    while(true){
    //transfer location change Single User or Multi User
    MultiUser mu=new MultiUser(server.accept());
    mu.start();
    }
    }
    }

    import java.net.*;
    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(5678);
    while(true){
    //transfer location change Single User or Multi User
    MultiUser mu=new MultiUser(server.accept());
    mu.start();
    }
    }
    }
    我的类直接从Thread类继承了下来.并且通过构造函数传递引用和客户Socket建立了联系.这样每个线程就有了.一个通讯管道.同样我们可以填写run方法.把之前的操作交给线程来完成.这样多客户并行的Socket就建立起来了.

    展开全文
  • JavaSocket

    2020-03-14 22:07:58
    服务器端ServerSocket –创建对象: –ServerSocket(int port)创建绑定到特定端口的服务器套接字。 –常用方法: –Socket accept()侦听并接受到此套接字的连接。...–void close()关闭此套接字。...

    服务器端ServerSocket

    • –创建对象:

      -ServerSocket(int port)创建绑定到特定端口的服务器套接字。
      
    • –常用方法:

      --Socket accept()侦听并接受到此套接字的连接。 
      --void close()关闭此套接字。 
      

    客户端Socket

    • –创建对象:

      --Socket(String host, int port)创建一个流套接字并将其连接到指定主机上的指定端口号。
      
    • -常用方法:

      --void close()关闭此套接字。
      --InputStream getInputStream()返回此套接字的输入流。 			
      --OutputStream getOutputStream() 返回此套接字的输出流。
      

    入门案例

    服务器端:
    //这个类表示Socket通信的服务器端
    public class Server {
    				public static void main(String[] args) {
    					try {
    						//1,在8000端口开启服务,等待客户端的连接  ServerSocket(int port)
    						//端口号:0~65535,其中0~1024被系统占用!!
    						ServerSocket server = new ServerSocket(8000);
    						//2,接收客户端的请求Socket accept()侦听并接受到此套接字的连接
    						Socket socket = server.accept();
    						//3,读取 客户端发来的数据
    						InputStream in = socket.getInputStream();
    						for (int i = 0; i < 5; i++) {//循环获取客户端的hello
    							char c = (char)in.read();//一个字节一个字节读取
    							System.out.print(c);//同行展示
    						}
    						//4、服务器把数据响应回客户端
    						OutputStream out = socket.getOutputStream();
    						out.write("java".getBytes());
    						out.flush();
    						
    					} catch (IOException e) {
    						e.printStackTrace();
    					}
    				}
    			}
    
    客户端:
    //这个类表示Socket通信的客户端
    			public class Client {
    				public static void main(String[] args) {
    					try {
    						//1,连接指定的服务器Socket(String host, int port)
    						//127.0.0.1 是本机的ip地址,实际工作中,要指定你想要访问的服务器的ip
    						Socket socket = new Socket("127.0.0.1",8000);
    						
    						//2,写出数据 发给服务器hello
    						OutputStream out = socket.getOutputStream();
    						out.write("hello".getBytes());//getBytes()把字符串转byte[]
    						out.flush();//刷新数据
    					
    						//3、解析服务器发回来的数据
    						InputStream in = socket.getInputStream();
    						for (int i = 0; i < 4; i++) {
    							char c = (char)in.read();//一个字节一个字节读取服务的数据
    							System.out.print(c);//同行展示
    						}
    						
    					} catch (IOException e) {
    						e.printStackTrace();
    					}
    					
    				}
    			}
    
    展开全文
  • javaSocket聊天室

    2017-04-11 10:37:14
    javaSocket聊天室
  • JAVASocket编程资料汇总

    2019-07-22 15:24:06
    资源名称:JAVA Socket编程资料汇总资源目录:【】Java Socket 编程模拟Ftp【】Java Socket多人在线考试系统源程序【】JavaSocket线程实现多客户的机制以及获取ip地址【】JavaSocket通讯例程【】三步学会JavaSocket...
  • javaSocket多线程服务器,可以传输对象,支持多个Client连接,新手入门 超级简单
  • javaSocket带界面聊天室

    2016-06-18 15:45:02
    javaSocket带界面聊天室
  • JavaSocket的API应用

    千次阅读 2017-03-27 19:35:46
    JavaSocket API

    Java中的网络支持

    针对网络通信的不同层次,Java提供的网络功能有四类

    1. InetAddress:用于标识网络上的硬件资源
    2. URL:统一资源定位符,通过URL可以直接读取或写入网络上的数据
    3. Sockets:使用TCP协议实现网络通信的Socket相关的类
    4. Datagram:使用UDP协议,将数据保存在数据报中,通过网络进行通信

    InetAddress的使用

    //获取本机的InetAddress实例
    InetAddress address = InetAddress.getLocalHost();
    System.out.println("本机名:"+address.getHostName());
    System.out.println("IP地址:"+address.getHostAddress());
    
    //获取IP地址字节数组的形式
    byte[] bytes = address.getAddress();
    System.out.println("字节数组IP:"+bytes.toString());
    //直接输出InetAddress对象(本机名+IP)
    System.out.println(address);
    
    //根据主机名获取InetAddress实例
    InetAddress address1=InetAddress.getByName("USER-20170104RF");
    //根据IP地址获取InetAddress实例
    InetAddress address1=InetAddress.getByName("192.168.0.1");

    URL的使用

    url由两部分组成,协议名称和资源名称

    //创建一个URL实例
    URL i = new URL("http://www.baidu.com");
    //根据上一个实例创建一个新实例,?后表示参数,#表示锚点
    URL url = new URL(i,"/index.html?username=tom#test");
    
    System.out.println("协议:"+url.getProtocol());
    System.out.println("主机:"+url.getHost());
    System.out.println("端口:"+url.getPort());
    System.out.println("文件路径:"+url.getPath());
    System.out.println("文件名:"+url.getFile());
    System.out.println("相对路径:"+url.getRef());
    System.out.println("查询字符串 :"+url.getQuery());

    使用URL读取网页内容

    通过URL对象的openStream()方法可以得到指定资源的输入流

            //创建一个URL实例
            URL url=new URL("http://www.baidu.com");
            //通过URL的openStream方法获取URL对象所表示的资源的字节输入流
            InputStream is=url.openStream();
            //字节输入流转化为字符输入流
            InputStreamReader isr=new InputStreamReader(is,"utf-8");
            //为字符输入流添加缓冲,提高效率
            BufferedReader br=new BufferedReader(isr);
    
            //读取数据
            String data=br.readLine();
            while(data != null){
                System.out.println(data);
                data=br.readLine();
            }
            br.close();
            isr.close();
            is.close();
    展开全文
  • JAVASocket实现聊天室

    2020-04-25 11:36:22
    JAVASocket实现聊天室 文章目录JAVASocket实现聊天室Sokcet是什么JAVA SOCKET编程中的两个重要对象ServerSocket构造方法acceptbindcloseSocket构造方法getInputStream,getOutputStreamclose聊天室实现服务端实现...

    JAVASocket实现聊天室

    在这里插入图片描述

    Sokcet是什么

    socket本质上是两个端点之间的通信桥梁,两个端点相互连接,并且打开远程之间的网络IO,从而可以像对本地文件读写一样,JAVA对socket编程有着友好的支持,并且针对客户端和服务端抽象了不同的服务对象

    JAVA SOCKET编程中的两个重要对象

    JDK对Socket编程抽象了两个类ServerSocketSocket,分别封装了客户端和服务端的基本通信API

    ServerSocket

    JDK提供的服务端实现,主要用于监听服务端口,并且接受来自该端口的客户端请求,并且生成来自客户端的Socket对象。

    几个重要的方法:

    构造方法

    • ServerSocket()
    • ServerSocket(int port)
    • ServerSocket(int port,int backlog)
    • ServerSocket(int port,int backlog,InnetAddress bindAddr)

    上述构造方法设计到大致三个参数,port(端口),backlog请求客户端队列最大长度,bindAddr,将要绑定的IP实现,如果不指定默认本地IP。

    accept

    public Socket accept() throws IOException
    

    accept方法主要是在开启端口监听之后接受一个客户端的连接请求,如果没有请求进来,那么accept方法会一直阻塞,直到一个客户端的请求进入,accept方法在接受一个客户端的请求之后,会生成一个客户端的Socket对象,这个对象封装了客户端的IO请求。

    Socket client = serverSocket.accept();
    //对客户端的输入输出流
    OutputStream outputStream= client.getOutputStream();
    InputStream  inputStream = client.getInputStream();
    

    服务端可通过这个Socket对象获取对客户端的输入流和输出流,这样服务端就可以读取到客户端发送来的的消息,并且可以向客户端发送消息

    bind

    bind方法是真正实现socket套接字绑定IP和端口的实现,默认在ServerSocket的构造方法中会进行调用。

    public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException {
            ...
            try {
                bind(new InetSocketAddress(bindAddr, port), backlog);
            } catch(SecurityException e) {
                close();
                throw e;
            } catch(IOException e) {
                close();
                throw e;
            }
    }
           
    

    close

    当主动调用close方法后,服务器会释放当前绑定的端口,并且自动断开和所有客户端之间的连接,只有主动执行了ServerSocket的close()方法,isClosed()方法才返回true;否则,即使ServerSocket还没有和特定端口绑定,isClosed()方法也会返回false,这是因为服务端内部维护了一个closed变量,初始化为false,只有在调用了close方法才会将closed变量置为true

    Socket

    JDK提供的Socket套接字实现类,主要封装了端的IO操作,通过Socket对象我们可以实现对客户端及服务端的读写操作

    构造方法

    Socket(InetAddressaddress, int port);
    Socket(InetAddress address,int port, boolean stream);
    Socket(String host, intprot);
    Socket(String host, intprot, boolean stream);
    Socket(SocketImpl impl)
    Socket(String host, intport, InetAddress localAddr, Socket(InetAddress address,int port, InetAddress localAddr, int localPort)
    ServerSocket(int port);
    ServerSocket(int port, intbacklog);
    ServerSocket(int port, intbacklog, InetAddress bindAddr)
    

    其中address、host和port分别是双向连接中另一方的IP地址、 主机名和端口号,stream指明socket是流socket还是数据报 socket,localPort表示本地主机的端口号,localAddr和bindAddr是本地机器的地址(ServerSocket的主机地 址),impl是socket的父类,既可以用来创建serverSocket又可以用来创建Socket。count则表示服务端所能支持的最大连接数。

    Socket(String host, intprot)

    常用的构造方法默认指定host和port,表示要建立的远程连接的服务端IP和端口,在服务端开启端口监听之后,客户端可以得到一个连接到服务端的Socket对象,同时服务端也会得到一个连接到客户端的Socket对象,这样双方可基于Socket实现双向通信,发送并且接受消息

    getInputStream,getOutputStream

    获取对应端的输入输出流,当双方建立连接后,双方互相持有封装了对方IO操作的Sokcet对象,通过Socket对象获取对应的输入输出流实现双向通信。

    close

    当客户端的Socket关闭连接时,服务端与客户端的连接自动关闭,但是服务端会继续监听端口,等待新的连接进来。

    当服务端的Sokcet关闭连接时,服务端与所有客户端的连接将全部断开,并且释放对应监听接口

    聊天室实现

    服务端实现

    监听端口,调用accept方法等待客户端请求,另外新起两个线程分别针对客户端的读写进行处理

    public class Server {
    
        public static final Integer port =80;
    
        public static void main(String[] args) throws IOException {
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("服务端监听 "+port+" 端口成功!,等待客户端连接");
            while (true){
                Socket client = serverSocket.accept();
                System.out.println("一个新的客户端进来了");
                new WriteHelper(client.getOutputStream(),"连接客户端成功!,可以畅所欲言了").start();
                new PrintHelper(client.getInputStream(),"服务端").start();
            }
        }
    
    
    }
    

    客户端实现

    绑定ip和端口,并且启动两个线程分别处理来自服务端的读写

    public class Client {
    
        public static void main(String[] args) throws IOException, InterruptedException {
            Socket socket = new Socket("127.0.0.1", 80);
            new WriteHelper(socket.getOutputStream(),"连接服务端成功!,可以畅所欲言了").start();
            new PrintHelper(socket.getInputStream(),"客户端").start();
        }
    }
    

    针对Socket的输入输出流实现单独线程处理,读写不互相收影响

    读线程实现

    主要针对Sokcet对象的输入流进行单独处理

    public class PrintHelper extends Thread{
    
        private InputStream inputStream;
        private String type;
    
        public PrintHelper(InputStream inputStream,String type) {
            this.inputStream=inputStream;
            this.type=type;
        }
    
        public void run() {
            byte[] bytes = new byte[1024];
            int length;
            try {
                while (true){
                    if (((length=inputStream.read(bytes))>1)){
                        String s = new String(bytes, 0, length);
                        LocalDateTime nowLocalDate = LocalDateTime.now();
                        String time = nowLocalDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                        System.out.println("     "+time+"       "+type+" : "+s);
                        System.out.println("____________________________________________");
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }
    

    写线程实现

    主要针对Socket对象的输出流进行单独处理,

    public class WriteHelper extends Thread{
    
            private OutputStream outputStream;
    
            public WriteHelper(OutputStream outputStream,String message) {
                System.out.println(message);
                System.out.println("============================");
                this.outputStream=outputStream;
            }
    
            public void run() {
                Scanner scanner = new Scanner(System.in);
                while(true){
                    String next = scanner.next();
                    try {
                        outputStream.write(next.getBytes());
                        outputStream.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    }
    

    运行结果

    需要先启动服务端,开启端口监听,再启动客户端,实现IP加端口的连接

    启动服务端

    在这里插入图片描述

    客户端连接

    在这里插入图片描述

    在这里插入图片描述

    客户端发送消息

    在这里插入图片描述

    服务端收到消息

    在这里插入图片描述

    服务端回复消息

    在这里插入图片描述

    客户端收到消息

    在这里插入图片描述

    展开全文
  • javaSocket编程TCP

    2013-01-09 13:21:53
    主题为:javaSocket编程TCP 原地址:http://www.iteye.com/topic/630748   关于JAVA线程的数据转发(游戏项目中间层)java多线程控制台聊天室java Socket通信的学习笔记三 推荐群组: D语言 更多相关推荐 ...
  • 《比手速》是一款比图形变化速度的游戏。通过两台机器即两个玩家分别运行代码建立连接后,两台机器可用键盘控制界面里的圆圈使其变大,两边的圆圈是独立的,当...详情可阅读本博主博客“基于JavaSocket类的课程设计”。
  • Javasocket应用实例用于本地群聊的小程序:客户端:import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.net.Socket;...
  • javaSocket笔记

    2018-04-02 22:31:00
    1、查看电脑当前开放链接的端口号 使用netstat命令 netstat -nao 可以查看PID进程号 netstat -nab 获取进程的详细信息 ...2、类创建的不同对象,引用是不同的。也就是说同一个类创建的不同对象,对象中存储的...
  • Java | JavaSocket编程开发多人聊天室实现内容运行结果部分代码完整代码 实现内容 用Java图形用户界面编写聊天室服务器端和客户端, 支持多个客户端连接到一个服务器。每个客户端能够输入账号。 可以实现群聊(聊天...
  • JavaSocket编程开发聊天室 服务器端部分
  • JavaSocket编程开发聊天室
  • Silverlight使用JavaSocket连接jabber服务器一、开发环境Vs2010,Sl4,jdk6,MyEclipse8.5二、Silverlightsocket使用注意事项1、SilverlightSocket数据交换端口必须在4502-4534范围2、必须创建一个Socket监听943端口...
  • 之前发了一个JavaSocket全双工通信的随笔,今天又看了一边之后发现了很多问题,于是决定重新写一下 写的途中遇到了个问题客户端在等待键盘写入的时候如果服务器下发了下线指令(exit),只有客户端键入回车后客户端...
  • Java | 结合JavaSocket编程开发文本处理程序要求部分代码完整代码 要求 1、20万字以上长篇小说存到服务器中,格式自定,一般存储为文本文档。 2、该程序支持从服务器载入小说,对小说中的文本进行分析。 3、首先运行...
  • Javasocket1

    2016-09-16 13:52:00
    java socket编程 一,网络编程中两个主要的问题 一个是如何准确的定位网络上一台或多台主机,另一个就是找到主机后如何可靠高效的进行数据传输。 ...在TCP/IP协议中IP层主要负责网络主机的定位,数据传输的路由,...
  • JavaSocket编程开发聊天室 大二下册的JavaWeb课程设计,使用的是eclipse。 一、实现功能 登录:用Java图形用户界面编写聊天室服务器端和客户端,支持多个客户端连接到一个服务器。每个客户端能够输入账号。 ...
  • JavaSocket通信

    2015-08-06 14:38:29
    子曰:“温故而知新,可以为师矣。”网络基础知识两台计算机通过网络进行通信的必备条件: 1、两台计算机要有唯一的标识—IP地址 2、协议 3、相应的端口号。不同的应用程序间的通信,我们需要使用端口号来区分...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 347
精华内容 138
关键字:

javasocket

java 订阅