Monthly Archives: November 2019

original source : https://www.geeksforgeeks.org/socket-programming-in-java/

Socket Programming in Java

This article describes a very basic one-way Client and Server setup where a Client connects, sends messages to server and the server shows them using socket connection. There’s a lot of low-level stuff that needs to happen for these things to work but the Java API networking package (java.net) takes care of all of that, making network programming very easy for programmers.

Client Side Programming

Establish a Socket Connection

To connect to other machine we need a socket connection. A socket connection means the two machines have information about each other’s network location (IP Address) and TCP port.The java.net.Socket class represents a Socket. To open a socket:

Socket socket = new Socket(“127.0.0.1”, 5000)

• First argument – IP address of Server. ( 127.0.0.1  is the IP address of localhost, where code will run on single stand-alone machine).
• Second argument – TCP Port. (Just a number representing which application to run on a server. For example, HTTP runs on port 80. Port number can be from 0 to 65535)

Communication

To communicate over a socket connection, streams are used to both input and output the data.

Closing the connection

The socket connection is closed explicitly once the message to server is sent.

In the program, Client keeps reading input from user and sends to the server until “Over” is typed.

Java Implementation

// A Java program for a Client
import java.net.*;
import java.io.*;

public class Client
{
// initialize socket and input output streams
private Socket socket = null;
private DataInputStream input = null;
private DataOutputStream out = null;

// constructor to put ip address and port
public Client(String address, int port)
{
// establish a connection
try
{
socket = new Socket(address, port);
System.out.println(“Connected”);

// takes input from terminal
input = new DataInputStream(System.in);

// sends output to the socket
out = new DataOutputStream(socket.getOutputStream());
}
catch(UnknownHostException u)
{
System.out.println(u);
}
catch(IOException i)
{
System.out.println(i);
}

// string to read message from input
String line = “”;

// keep reading until “Over” is input
while (!line.equals(“Over”))
{
try
{
line = input.readLine();
out.writeUTF(line);
}
catch(IOException i)
{
System.out.println(i);
}
}

// close the connection
try
{
input.close();
out.close();
socket.close();
}
catch(IOException i)
{
System.out.println(i);
}
}

public static void main(String args[])
{
Client client = new Client(“127.0.0.1”, 5000);
}
}

Server Programming

Establish a Socket Connection

To write a server application two sockets are needed.

• A ServerSocket which waits for the client requests (when a client makes a new Socket())
• A plain old Socket socket to use for communication with the client.

Communication

getOutputStream() method is used to send the output through the socket.

Close the Connection

After finishing,  it is important to close the connection by closing the socket as well as input/output streams.

// A Java program for a Server
import java.net.*;
import java.io.*;

public class Server
{
//initialize socket and input stream
private Socket socket = null;
private ServerSocket server = null;
private DataInputStream in = null;

// constructor with port
public Server(int port)
{
// starts server and waits for a connection
try
{
server = new ServerSocket(port);
System.out.println(“Server started”);

System.out.println(“Waiting for a client …”);

socket = server.accept();
System.out.println(“Client accepted”);

// takes input from the client socket
in = new DataInputStream(
new BufferedInputStream(socket.getInputStream()));

String line = “”;

// reads message from client until “Over” is sent
while (!line.equals(“Over”))
{
try
{
line = in.readUTF();
System.out.println(line);

}
catch(IOException i)
{
System.out.println(i);
}
}
System.out.println(“Closing connection”);

// close connection
socket.close();
in.close();
}
catch(IOException i)
{
System.out.println(i);
}
}

public static void main(String args[])
{
Server server = new Server(5000);
}
}

Important Points

• Server application makes a ServerSocket on a specific port which is 5000. This starts our Server listening for client requests coming in for port 5000.
• Then Server makes a new Socket to communicate with the client.

socket = server.accept()

• The accept() method blocks(just sits there) until a client connects to the server.
• Then we take input from the socket using getInputStream() method. Our Server keeps receiving messages until the Client sends “Over”.
• After we’re done we close the connection by closing the socket and the input stream.
• To run the Client and Server application on your machine, compile both of them. Then first run the server application and then run the Client application.

To run on Terminal or Command Prompt

Open two windows one for Server and another for Client

1. First run the Server application as ,

$ java Server

Server started
Waiting for a client …

2. Then run the Client application on another terminal as,

$ java Client

It will show – Connected and the server accepts the client and shows,

Client accepted

3. Then you can start typing messages in the Client window. Here is a sample input to the Client

Hello
I made my first socket connection
Over

Which the Server simultaneously receives and shows,

Hello
I made my first socket connection
Over
Closing connection

Notice that sending “Over” closes the connection between the Client and the Server just like said before.

If you’re using Eclipse or likes of such-

1. Compile both of them on two different terminals or tabs
2. Run the Server program first
3. Then run the Client program
4. Type messages in the Client Window which will be received and showed by the Server Window simultaneously.
5. Type Over to end.

This article is contributed by Souradeep Barua. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

또 다른 socket programming in java 설명

original source : https://www.javatpoint.com/socket-programming

Java Socket Programming

Java Socket programming is used for communication between the applications running on different JRE.

Java Socket programming can be connection-oriented or connection-less.

Socket and ServerSocket classes are used for connection-oriented socket programming and DatagramSocket and DatagramPacket classes are used for connection-less socket programming.

The client in socket programming must know two information:

1. IP Address of Server, and
2. Port number.

Here, we are going to make one-way client and server communication. In this application, client sends a message to the server, server reads the message and prints it. Here, two classes are being used: Socket and ServerSocket. The Socket class is used to communicate client and server. Through this class, we can read and write message. The ServerSocket class is used at server-side. The accept() method of ServerSocket class blocks the console until the client is connected. After the successful connection of client, it returns the instance of Socket at server-side.

Socket class

A socket is simply an endpoint for communications between the machines. The Socket class can be used to create a socket.

Important methodsMethodDescription

1) public InputStream getInputStream()

          returns the InputStream attached with this socket.

2) public OutputStream getOutputStream()

          returns the OutputStream attached with this socket.

3) public synchronized void close()

          closes this socket

ServerSocket class

The ServerSocket class can be used to create a server socket. This object is used to establish communication with the clients.

Important methodsMethodDescription

1) public Socket accept()

          returns the socket and establish a connection between server and client.

2) public synchronized void close()

          closes the server socket.

Example of Java Socket Programming

Creating Server:

To create the server application, we need to create the instance of ServerSocket class. Here, we are using 6666 port number for the communication between the client and server. You may also choose any other port number. The accept() method waits for the client. If clients connects with the given port number, it returns an instance of Socket.

1. ServerSocket ss=new ServerSocket(6666);  
2. Socket s=ss.accept();//establishes connection and waits for the client  

Creating Client:

To create the client application, we need to create the instance of Socket class. Here, we need to pass the IP address or hostname of the Server and a port number. Here, we are using “localhost” because our server is running on same system.

1. Socket s=new Socket(“localhost”,6666);  

Let’s see a simple of Java socket programming where client sends a text and server receives and prints it.

File: MyServer.java

1. import java.io.*;  
2. import java.net.*;  
3. public class MyServer {  
4. public static void main(String[] args){  
5. try{  
6. ServerSocket ss=new ServerSocket(6666);  
7. Socket s=ss.accept();//establishes connection  
8. DataInputStream dis=new DataInputStream(s.getInputStream());  
9. String  str=(String)dis.readUTF();  
10. System.out.println(“message= ”+str);  
11. ss.close();  
12. }catch(Exception e){System.out.println(e);}  
13. }  
14. }  

File: MyClient.java

1. import java.io.*;  
2. import java.net.*;  
3. public class MyClient {  
4. public static void main(String[] args) {  
5. try{      
6. Socket s=new Socket(“localhost”,6666);  
7. DataOutputStream dout=new DataOutputStream(s.getOutputStream());  
8. dout.writeUTF(“Hello Server”);  
9. dout.flush();  
10. dout.close();  
11. s.close();  
12. }catch(Exception e){System.out.println(e);}  
13. }  
14. }  

download this example

To execute this program open two command prompts and execute each program at each command prompt as displayed in the below figure.

After running the client application, a message will be displayed on the server console.

Example of Java Socket Programming (Read-Write both side)

In this example, client will write first to the server then server will receive and print the text. Then server will write to the client and client will receive and print the text. The step goes on.

File: MyServer.java

1. import java.net.*;  
2. import java.io.*;  
3. class MyServer{  
4. public static void main(String args[])throws Exception{  
5. ServerSocket ss=new ServerSocket(3333);  
6. Socket s=ss.accept();  
7. DataInputStream din=new DataInputStream(s.getInputStream());  
8. DataOutputStream dout=new DataOutputStream(s.getOutputStream());  
9. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
10.  
11. String str=“”,str2=“”;  
12. while(!str.equals(“stop”)){  
13. str=din.readUTF();  
14. System.out.println(“client says: ”+str);  
15. str2=br.readLine();  
16. dout.writeUTF(str2);  
17. dout.flush();  
18. }  
19. din.close();  
20. s.close();  
21. ss.close();  
22. }}  

File: MyClient.java

1. import java.net.*;  
2. import java.io.*;  
3. class MyClient{  
4. public static void main(String args[])throws Exception{  
5. Socket s=new Socket(“localhost”,3333);  
6. DataInputStream din=new DataInputStream(s.getInputStream());  
7. DataOutputStream dout=new DataOutputStream(s.getOutputStream());  
8. BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
9.  
10. String str=“”,str2=“”;  
11. while(!str.equals(“stop”)){  
12. str=br.readLine();  
13. dout.writeUTF(str);  
14. dout.flush();  
15. str2=din.readUTF();  
16. System.out.println(“Server says: ”+str2);  
17. }  
18.  
19. dout.close();  
20. s.close();  
21. }}