精华内容
下载资源
问答
  • ServerSocket对象相关的信息有两个:绑定端口和绑定IP地址。绑定端口可以通过getLocalPort方法获得。绑定IP地址可以通过getInetAddress方法获得。  一、getLocalPort方法  getLocalPort方法的返回值可分为...

      与ServerSocket对象相关的信息有两个:绑定端口和绑定IP地址。绑定端口可以通过getLocalPort方法获得。绑定IP地址可以通过getInetAddress方法获得。

        一、getLocalPort方法

        getLocalPort方法的返回值可分为以下三种情况:

        1. ServerSocket对象未绑定端口,getLocalPort方法的返回值为-1.

        2. ServerSocket对象绑定了一个固定的端口,getLocalPort方法返回这个固定端口。

        3. ServerSocket对象的绑定端口为0,getLocalPort方法返回一个随机的端口(这类端口被称为匿名端口)。

        getLocalPort方法的定义如下:

    public int getLocalPort()

        getLocalPort方法主要是为这些匿名端口而准备的。下面的代码演示了ServerSocket对象产生随机端口的过程:

    package server;

    import java.net.*;

    public class RandomPort
    {
        
    public static void main(String[] args) throws Exception
        {
            
    for (int i = 1; i <= 5; i++)
            {
                System.out.print(
    "Random Port" + i + "");
                System.out.println(
    new ServerSocket(0).getLocalPort());
            }
        }
    }

        运行结果:

        1. 主动模式

        在主动模式中,FTP服务器绑定了两个端口:21和20 (这两个端口是默认值,可以设成别的端口)。其中21端口负责客户端和服务器之间的命令传送。一开始,由客户端主动连接服务端的21端口,并且向服务器发送相应的FTP命令。另外一个端口20是负责客户端和服务端的数据传送。但要注意,并不是客户端主动连接服务端的20端口,而是在客户端创建一个使用匿名端口的服务端连接(在Java中就是创建一个ServerSocket对象,并且绑定端口是0)。然后客户端通过21端口将这个匿名端口通知服务端。最后,服务端主动连接客户端的这个匿名端口(所以这种模式叫主动模式,就是服务器主动连接客户端)。图1描述主动模式的工作原理。


    图1  主动模式的工作原理

        从图1可以看出,在主动模式中,在传送命令和数据时,建立连接的过程是相反的。也就是说,在传送命令时,由客户端主动连接服务器的21端口。而传送数据时,由服务器主动连接客户端的匿名端口。这种方式是FTP服务器最初的工作模式,但这种模式有很大的局限性。如客户端通过代理上网,而且未做端口映射。在这种情况下,服务端是无法主动和客户端建立连接的。因此,这就产生的另一种模式:被动模式。

        2. 被动模式

        被动模式和主动模式在传送命令的方式上是一样的。它们的区别就在于数据的传输上。被动模式在建立命令传输通道后,服务端建立一个绑定到匿名端口的ServerSocket对象。并通过命令传输通道将这个匿名端口通知客户端,然后由客户端主动连接服务端的这个匿名端口。这对于服务端就是被动的,因此,这种模式叫被动模式。图2描述了被动模式的工作原理。


    图2  被动模式的工作原理

        现在的大多数FTP客户端软件的默认工作模式都是被动模式。因此,这种模式可以克服防火墙等的限制,并且客户端不需要有固定IP.但这种模式也有它的缺点,这就是在服务端要为客户开大量的端口(大多数FTP服务器开的端口范围是1024 ~ 5000,但有的服务器的范围达到1024 ~ 65535)。这对于服务器来说存在着一定的安全隐患。因此,如果可能的话,最好还是采用主动模式。

     二、getInetAddress方法

        getInetAddress可以得到ServerSocket对象绑定的IP地址。如果ServerSocket对象未绑定IP地址,返回0.0.0.0.getInetAddress方法的定义如下:

    public InetAddress getInetAddress()

        下面的代码演示了getInetAddress的使用方法:

    ServerSocket serverSocket = new ServerSocket();
    serverSocket.bind(
    new InetSocketAddress("192.168.18.100"0));    
    System.out.println(serverSocket.getInetAddress().getHostAddress());   

        运行结果:

    192.168.18.100

        三、getLocalSocketAddress方法

        这个方法其实是将getLocalPort和getInetAddress方法的功能集成到了一起。也就是说,使用getLocalSocketAddress方法可以同时得到绑定端口和绑定IP地址。这个方法返回了一个SocketAddress对象。SocketAddress类是一个抽象类,要想分别得到端口和IP地址,必须将SocketAddress对象转换成InetSocketAddress对象(InetSocketAddress类是从SocketAddress类继承的)。getLocalSocketAddress方法的定义如下:

    public SocketAddress getLocalSocketAddress()

        下面的代码演示了getLocalSocketAddress的使用方法。

    ServerSocket serverSocket = new ServerSocket();
    serverSocket.bind(
    new InetSocketAddress("192.168.18.100"1234));
    System.out.println(serverSocket.getLocalSocketAddress());
    InetSocketAddress nsa 
    = (InetSocketAddress)serverSocket.getLocalSocketAddress();
    System.out.println( nsa.getAddress().getHostAddress());
    System.out.println( nsa.getPort());

        运行结果:

    /192.168.18.100:1234
    192.168.18.100
    1234

    展开全文
  • ServerSocket server = new ServerSocket(8090); while (true) {//循环 final Socket socket = server.accept();//获取数据 System.out.println("ClientSocket:" + client.getPort()); new Thread(new ...

    示例:

    创建ServerSocker过程:

    //创建ServerSocket并注册端口号8090
    		ServerSocket server = new ServerSocket(8090);
    		while (true) {//循环
    			final Socket socket = server.accept();//获取数据
    System.out.println("ClientSocket:" + client.getPort());
    			new Thread(new Runnable() {//如果获取到数据则开辟一个线程去处理
    				
    				@Override
    				public void run() {
    					try {
    						InputStream inputStream = socket.getInputStream();
    						BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    						String text = null;
    						while ((text = bufferedReader.readLine()) != null) {
    							System.out.println(text);
    						}
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    					
    				}
    			}).start();
    		}
    
    展开全文
  • 这时候说Socket和ServerSocket感觉有点老调重弹感觉,相信很多人早就知道如何使用了,而且利用这个通信原理可能已经开发出很多优秀的通信软件吧,但是我感觉这个对于刚接触java网络编程的人来说,学会Socket通信实现...

    聊天,QQ,微信,陌陌很多的即时通讯的软件,不管是桌面端还是移动端,在当今社交的时代都是不可或缺的一部分。这时候说Socket和ServerSocket感觉有点老调重弹感觉,相信很多人早就知道如何使用了,而且利用这个通信原理可能已经开发出很多优秀的通信软件吧,但是我感觉这个对于刚接触java网络编程的人来说,学会Socket通信实现聊天软件,是必须的一步,了解其中的原理更是非常重要的一步,对,很多人可能觉得对着视频敲出一个软件很容易,但是你能学到什么???盲目地崇拜大神吗??,我认为需要花更多的时间去弄懂其实现的原理,然后总结一些属于自己的东西出来。本人菜鸟,但是喜欢分享一些自己的东西,希望能帮助需要帮助的人,不说废话,直接上...

    为了照顾一下初学者下面就大概说下Socket的介绍:

    1、Scoket又称“套接字”,应用程序通常通过“套接字”向网络发出请求或者应答网络请求
    在 java中Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端
    Socket是建立网络连接时使用的,在连接成功时,应用程序两端都会产生一个Socket实例
    操作这个实例,完成所需的会话。对于一个网络连接来说,套接字是平等的,并没有差别
    不因为在服务器端或在客户端而产生不同的级别,不管是Socket还是ServerSocket他们的
    工作都是通过Socket类和其子类来完成的
    2、建立Socket链接可分三个步骤:
             1.服务器监听
             2.客户端发出请求
             3.建立链接
             4.通信
    3、Socket特点:
              1.基于TCP链接,数据传输有保障
              2.适用于建立长时间的链接,不像HTTP那样会随机关闭
              3.Socket编程应用于即时通讯

    4、ServerSocket的建立和使用:

    public class ServerSocket_Test {

     public static void main(String[] args) {
      //port参数表示服务器监听的端口号,从1-65535
      try {
       
       ServerSocket serverSocket =new ServerSocket(12345);
         
       //block,当没有客户端连接时,改主线程会一直阻塞等待连接,一直监听,直到有客户端连接才会执行
      Socket socket= serverSocket.accept();//侦听事务的连接,accept是一个阻塞的方法,会阻塞当前的main线程,并且返回的是一个Socket类型
      //建立连接,表示serverSocket在监听,如果监听到有客户端连接则会调用accept方法,然后返回一个Socket,最后建立连接
      JOptionPane.showMessageDialog(null, "有客户端连接到了本机的12345端口");
      //然后测试在浏览器中输入http://127.0.0.1:12345则会弹出相应有客户端连接的提示框,然后原来阻塞在accept方法那里就会往下执行
      } catch (IOException e) {
       e.printStackTrace();
      }
     }
    注意:但是以上的这种方法不推荐,因为这个里面有线程阻塞,会阻塞主线程,所以推荐一种更好的方法是就是单独开启一个线程去实现服务器监听客户端的连接

    5、ServerSocketListener(单独的线程实现服务器的监听)

    public class ServerListener extends Thread {
     @Override
     public void run() {
      //port参数表示服务器监听的端口号,从1-65535
      try {

       ServerSocket serverSocket =new ServerSocket(12345);

       while (true) {   //由于可能当有多个客户端连接时,accept方法就会产生多个Socket对象,需加一个while循环监听来自客户端的连接
        //block,当没有客户端连接时,改主线程会一直阻塞等待连接,一直监听,直到有客户端连接才会执行
        Socket socket= serverSocket.accept();//侦听事务的连接,accept是一个阻塞的方法,会阻塞当前的main线程,并且返回的是一个Socket类型
        //建立连接,表示serverSocket在监听,如果监听到有客户端连接则会调用accept方法,然后返回一个Socket,最后建立连接
        JOptionPane.showMessageDialog(null, "有客户端连接到了本机的12345端口");
        //然后测试在浏览器中输入http://127.0.0.1:12345则会弹出相应有客户端连接的提示框,然后原来阻塞在accept方法那里就会往下执行
       
        //将socket传递给另起的一个新的线程,即是socket通信的线程
        new ChatSocket(socket).start();
       
       }
       
      } catch (IOException e) {
       e.printStackTrace();
      }
     }

    然后在主方法去开启这个线程即可:

    public class ServerSocket_Test {

     public static void main(String[] args) {
      new ServerListener().start();
     }

    }

    用浏览器打开运行结果(表示此时已经有客户端连接到服务器了,监听到客户端后就会弹出提示框,此时的浏览器就相当于客户端):

     

    那么接下来就讲解一下聊天服务器端(ServerSocket)的是实现:

    主要实现原理:因为一个客户端就相当于开启一个Socket线程,然而要实现多人聊天,就相当于开启多个Socket线程(即多个客户端),然后把这些线程加入到Vector集合中去,当客户端(Socket)发送一条信息时,也就相当于服务器(ServerSocket)读入信息,而对于客户端是向服务器输入,实现输入流Socket.InputStream,然后利用BufferReader缓冲流读入服务器,然后在服务器(ServerSocket)中的去遍历这个线程集合,如果不是当前客户端对象就发送信息,这样就是实现了把当前客户端信息转发给其他的客户端使用Socket.OutputStream,即服务器向客户端输出流,并用PrintWriter流写入客户端。

    具体见图:

    ServerSocket代码:

    1、ServerSocket.java:

    public class ServerSocket {

     public static void main(String[] args) {
      new ServerListener().start();
      //运行的方法在command命令下输入:"telnet localhost 12345",每建立一个就是一个客户端,而且每个客户端享受不同的线程,等级是平等的
     }

    2.ServerListener.java

    public class ServerListener extends Thread {
     @Override
     public void run() {
      //port参数表示服务器监听的端口号,从1-65535
      try {

       ServerSocket serverSocket =new ServerSocket(12345);
       while (true) {//由于可能当有多个客户端连接时,accept方法就会产生多个Socket对象,需加一个while循环监听来自客户端的连接
        Socket socket= serverSocket.accept();//侦听事务的连接,accept是一个阻塞的方法,会阻塞当前的main线程,并且返回的是一个Socket类型
        //建立连接,表示serverSocket在监听,如果监听到有客户端连接则会调用accept方法,然后返回一个Socket,最后建立连接
        JOptionPane.showMessageDialog(null, "有客户端连接到了本机的12345端口");
        
        ChatSocket cs= new ChatSocket(socket);
            cs.start();//开启ChatSocket线程
            ChatManager.getchaChatManager().add(cs);
       }
       
      } catch (IOException e) {
       e.printStackTrace();
      }
     }
    }
    3.ChatSocket.java

    public class ChatSocket extends Thread {
    //创建一个Socket对象来接收SocketListener传来的Socket对象
     Socket socket;
     public ChatSocket(Socket s) {
              this.socket=s;
    }
     public void out(String out){
      try {
       socket.getOutputStream().write((out+"\n").getBytes("UTF-8"));//接收来自服务器端的数据
      }catch (UnsupportedEncodingException e) {
       e.printStackTrace();
      }
      catch (IOException e) {
       System.out.println("断开了一个客户端链接");
       ChatManager.getchaChatManager().remove(this);
       e.printStackTrace();
      }
     }
     @Override
      public void run() {
         out("您已经连接到服务器");
        try {
      
      BufferedReader br=new BufferedReader(
        new InputStreamReader(
          socket.getInputStream(),"UTF-8"));//当前服务器会不断读取当前客户端的数据
      String line=null;
         while ((line=br.readLine())!=null) {//客户端发送给服务器的数据
        //然后服务器再将所有的信息转发给每一个客户端,调用publish方法
         
          ChatManager.getchaChatManager().publish(this, line);
       }
         br.close();
         System.out.println("断开了一个客户端链接");
       ChatManager.getchaChatManager().remove(this);
     } catch (IOException e) {
      System.out.println("断开了一个客户端链接");
      ChatManager.getchaChatManager().remove(this);
      e.printStackTrace();
     }
        
     }

    4、ChatManager.java

    public class ChatManager {
          //因为一个聊天服务器只有一个ChatManager所以需要创建一个单例
     
     private ChatManager(){}
     private static final ChatManager cm= new ChatManager();
     public static  ChatManager getchaChatManager(){
      return cm;
     }
     
     Vector<ChatSocket> vector=new Vector<ChatSocket>();
     public void add(ChatSocket cs){
          vector.add(cs);//将每一个线程加入集合中
     }
     public void remove(ChatSocket cs) {
      vector.remove(cs);
     }
     public  void publish(ChatSocket cs,String chatinfo){//表示当前的线程给集合中的每一个线程发送的信息,也即当前的客户端给每一个客户端发送信息
      //要给集合中所有的线程发送信息就必须遍历这个集合
      for (int i = 0; i < vector.size(); i++) {
       ChatSocket csChatSocket=vector.get(i);
       if(!csChatSocket.equals(cs)){//则需要判断不许给当前客户端发送信息,也即不给自己发送信息
        csChatSocket.out(chatinfo);//发送信息给其他的客户端
       }
      }
     }
    }

     

    到现在其实我们就可以测试聊天和多人聊天的功能:

    运行的方法:我们打开Command命令,输入telnet localhost 12345,然后回车,就会建立起一个多人聊天室:

    运行结果:

    那接下来讲解聊天客户端的实现:

    客户端的实现主要是有两部分,第一是GUI的实现,这个在这就不多讲了这是GUI(Swing)界面编程的知识,第二个就是客户端的逻辑的实现,因为客户端既要发送信息

    又要接收信息,发送信息给服务器则需要Socket.getInputStream字节流,转换成InputStreamReader字符流,转换成BufferReader缓冲流,read到服务器;接收信息,从服务器中接收信息,则需要Socket.OutputStream字节流,转换成OutputStream转换成PrintWriter流,write到客户端。

    代码:

    ChatManager:

    public class ChatManager {
      private ChatManager(){}
      private static final ChatManager instance =new ChatManager();
      public static ChatManager getChatManager(){
       return instance;
      }
      MainWindow window;
      String IP;
      Socket socket;
      BufferedReader br;
      PrintWriter pw;
      public void setWindow(MainWindow window) {
     this.window = window;
     window.appendText("文本框已经和Manage绑定了");
    }
      public void connect(String ip){
       this.IP=ip;
       new Thread(){

      @Override
      public void run() {
          try {
           socket=new Socket(IP, 12345);//创建客户端,连接的端口是ServerSocket的端口
           pw=new PrintWriter(
             new OutputStreamWriter(
               socket.getOutputStream(),"UTF-8") );
           br=new BufferedReader(
             new InputStreamReader(
               socket.getInputStream(),"UTF-8"));
           String line;
          
           while ((line=br.readLine())!=null) {
        window.appendText("收到:"+line);
       }
           br.close();
          pw.close();
          pw=null;
          br=null;
      

          }catch (UnknownHostException e) {
        e.printStackTrace();
       }
          catch (IOException e) {
       e.printStackTrace();
      }
      }
       }.start();
      }
      public void send(String out){
       if(pw!=null){
        pw.write(out+"\n");
        pw.flush();
       }else{
      window.appendText("已中断与服务器的连接"); 
       }
      }
    }

    StartClient.java:

    public class StartClient {

     public static void main(String[] args) {
      EventQueue.invokeLater(new Runnable() {
       public void run() {
        try {
         MainWindow frame = new MainWindow();
         frame.setVisible(true);
         ChatManager.getChatManager().setWindow(frame);
        } catch (Exception e) {
         e.printStackTrace();
        }
       }
      });
     }

    }

     

    GUI界面代码:

    package com.zhongqihong.client.view;

    import java.awt.BorderLayout;
    import java.awt.EventQueue;

    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.border.EmptyBorder;
    import javax.swing.JTextArea;
    import javax.swing.GroupLayout;
    import javax.swing.GroupLayout.Alignment;
    import javax.swing.JTextField;
    import javax.swing.JButton;
    import javax.swing.LayoutStyle.ComponentPlacement;

    import com.zhongqihong.client.ChatManager;

    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;

    public class MainWindow extends JFrame {

     private static final long serialVersionUID = 1L;
     private JPanel contentPane;
     JTextArea txt;
     private JTextField ip;
     private JTextField send;
     /**
      * Create the frame.
      */
     public MainWindow() {
      setAlwaysOnTop(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      setBounds(100, 100, 450, 300);
      contentPane = new JPanel();
      contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
      setContentPane(contentPane);
      
      txt = new JTextArea();
      txt.setText("Ready...");
      
      ip = new JTextField();
      ip.setText("127.0.0.1:808");
      ip.setColumns(10);
      
      JButton button = new JButton("\u8FDE\u63A5\u5230\u670D\u52A1\u5668");
      button.addMouseListener(new MouseAdapter() {
       @Override
       public void mouseClicked(MouseEvent e) {
        ChatManager.getChatManager().connect(ip.getText());
       }
      });
      
      send = new JTextField();
      send.setText("\u60A8\u597D");
      send.setColumns(10);
      
      JButton button_1 = new JButton("\u53D1\u9001");
      button_1.addMouseListener(new MouseAdapter() {
       @Override
       public void mouseClicked(MouseEvent e) {
        ChatManager.getChatManager().send(send.getText());
         appendText("我说:"+send.getText());
            send.setText("");
       }
      });
      GroupLayout gl_contentPane = new GroupLayout(contentPane);
      gl_contentPane.setHorizontalGroup(
       gl_contentPane.createParallelGroup(Alignment.LEADING)
        .addGroup(Alignment.TRAILING, gl_contentPane.createSequentialGroup()
         .addComponent(ip, GroupLayout.DEFAULT_SIZE, 277, Short.MAX_VALUE)
         .addGap(18)
         .addComponent(button, GroupLayout.PREFERRED_SIZE, 119, GroupLayout.PREFERRED_SIZE)
         .addContainerGap())
        .addGroup(Alignment.TRAILING, gl_contentPane.createSequentialGroup()
         .addComponent(send, GroupLayout.DEFAULT_SIZE, 251, Short.MAX_VALUE)
         .addGap(18)
         .addComponent(button_1, GroupLayout.PREFERRED_SIZE, 135, GroupLayout.PREFERRED_SIZE)
         .addGap(20))
        .addComponent(txt, GroupLayout.DEFAULT_SIZE, 424, Short.MAX_VALUE)
      );
      gl_contentPane.setVerticalGroup(
       gl_contentPane.createParallelGroup(Alignment.LEADING)
        .addGroup(gl_contentPane.createSequentialGroup()
         .addContainerGap()
         .addGroup(gl_contentPane.createParallelGroup(Alignment.BASELINE)
          .addComponent(ip, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
          .addComponent(button))
         .addPreferredGap(ComponentPlacement.RELATED)
         .addComponent(txt, GroupLayout.DEFAULT_SIZE, 174, Short.MAX_VALUE)
         .addPreferredGap(ComponentPlacement.RELATED)
         .addGroup(gl_contentPane.createParallelGroup(Alignment.BASELINE)
          .addComponent(send, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
          .addComponent(button_1))
         .addContainerGap())
      );
      contentPane.setLayout(gl_contentPane);
     }
    public void appendText(String in){
     txt.append("\n"+in);
    }
    }

    public class ServerSocket_Test {

     public static void main(String[] args) {
      new ServerListener().start();
      //运行的方法在command命令下输入:"telnet localhost 12345",每建立一个就是一个客户端,而且每个客户端享受不同的线程,等级是平等的
     }

    }

     }
     }

    运行代码:

    两人私聊:

    多人群聊:

    到这里,我们的多人聊天的客户端就成功实现了,其实一步一步来,把复杂的问题分解成一个个小问题来解决就可以了。

    PS:这里是Demo的源码:http://pan.baidu.com/s/1qWQikMC

     

     

    展开全文
  • 实例小项目为Chat聊天室。在com.sknomy.chat包下创建两个类,服务端Server,客户端Client。演示客户端怎样与服务端相连,并将用户输入的信息传递到服务端。... import java.io.BufferedReader; import java.io.InputSt
  • 所谓“接收”客户的套接字请求,就是accept()方法会返回一个 Socket 对象 实战举例: public class Server { public static void main(String[] args) throws IOException { ServerSocket serverSocket=new ...
  • Socket笔记之ServerSocket

    2019-05-02 14:17:03
    文章目录ServerSocketbacklog关闭Socket关闭的原理判断对端Socket是否关闭ServerSocket选项SO_TIMEOUTSO_REUSEADDRSO_RCVBUF设定连接时间、延迟和带宽的相对重要性阻塞缓冲区与队列写超时 ServerSocket ...
  • 创建ServerSocket对象

    2015-01-28 11:44:31
    ServerSocket类的构造方法有四种重载形式,它们的定义如下: public ServerSocket() throws IOException public ServerSocket(int port) throws IOException public ServerSocket(int port,...
  • import java.io.*; import java.net.*; class MyIE { public static void main(String[] args) throws Exception { Socket s = new Socket("192.168.43.237",9090);... PrintWriter out = new PrintWriter(s....
  • ServerSocket对象相关的信息有两个:绑定端口和绑定IP地址。绑定端口可以通过getLocalPort方法获得。绑定IP地址可以通过getInetAddress方法获得。 一、getLocalPort方法 getLocalPort方法的返回值可分为以下三...
  • Socket和ServerSocket

    2017-04-03 18:12:30
    主要分异常类型、交互原理、Socket、ServerSocket、多线程这几个方面阐述。   异常类型 在了解Socket的内容之前,先要了解一下涉及到的一些异常类型。以下四种类型都是继承于IOException,所以很多之后...
  • * 利用IO流实现数据的传输 * * 客户端 输出流-->输入流 服务端 OutputStream --> InputStraem * 客户端 输入流输出流 服务端 InputStream * * 详细步骤(通讯原理) * 服务器创建ServerSocket,在指定端口监听并处理...
  • 这节我们先关注TCP套接字的服务器端socket,Java中ServerSocket类与之相对应,这个类主要用于如何在服务器端创建一个套接字服务,建立一个通信终端,被动地等待客户端的连接,一旦有数据进入被监听的端口,这个类将...
  • java.net.ServerSocket 解析

    千次阅读 2017-08-15 10:41:15
    public ServerSocket() 构造一个ServerSocket,但不绑定任何端口,所以也不能接受任何的请求连接。以后可以通过bing()方法来进行绑定。 public ServerSocket(int port) 通过一个端口来构造一个ServerSocket对象。 ...
  • Java_创建ServerSocket对象

    千次阅读 2014-01-19 12:15:55
    ServerSocket类的构造方法有四种重载形式,它们的定义如下: public ServerSocket() throws IOException public ServerSocket(int port) throws IOException public ServerSocket(int port, int ...
  • Socket 与ServerSocket区别

    2013-04-17 09:54:44
    ServerSocket用于绑定端点,提供服务,并接受连接请求,如果写服务器一定要用到的Socket就是普通的连接套接字,做客户端要用到,设计服务器的时候也要用到。服务套接字accept之后返回的是Socket对象 所谓socket
  • ServerSocket实现简单的广播系统

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,209
精华内容 6,883
关键字:

serversocket原理