Neo's Programming

C#과 그냥 동일한 형태이다. 단 다음 예제는 객체를 던진다.

즉, Sirializable 된 데이터를 넘겨준다. 물론 C#에도 있다. 메모리 스트림을 이용하여 넘겼었던가 그럴 것이다.

서버 측 코드는 다음과 같다.

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server_Object
{
  public static void main(String[] args) throws IOException
  {
  
     ServerSocket ServerSocket = null;  
     Socket AcceptSocket = null;      
 
         try
         {
             ServerSocket = new ServerSocket( 8520, 2000 );                                      
   
             while(true)
             {
                 AcceptSocket = ServerSocket.accept();
                 ThreadClass service = new ThreadClass(AcceptSocket);
                 service.run();
             }
         }
         catch(Exception ex)
         {
          System.out.println("error" + ex.getMessage());
         }
         finally
         {
             ServerSocket.close();           
         }
  }
}

class ThreadClass extends Thread
{
    private Socket s_socket;
   
    public ThreadClass(Socket Sock)
    {       
        s_socket = Sock;
    }

    public void run()
    {
        try
        {
   ObjectInputStream in = new ObjectInputStream(s_socket.getInputStream());
   
   Student data = (Student)in.readObject();
   
   out.writeObject(data);
        }
        catch(Exception e)
        {
         System.out.println("error" + e.getMessage());
        }
        finally
        {                  
         try
         {
          s_socket.close();
         }
         catch(IOException ioex)
         {          
         }
        }
    }
}

크게 다른 것은 없다

소켓을 생성하여 거기에 대한 접근 소켓을 따로 처리 해 주면서 Stream을 통하여 처리를 한다. 문자열을 보내고 싶다면

BufferedWriter와 BufferedReader, StreamReader 쪽을 찾아서 처리를 하면 된다.

스트림을 받을 땐 명시적으로 반드시 해당하는 형에 따른 변환을 하여서 처리를 해야한다.

그리고 서버 소켓 쪽에 살펴보면 2000 이라고 명시 된 부분이 있는데 이는 C#에서 Listen 과 같은 역할을 한다.

클라이언트 쪽은 다음과 같다.

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

public class Client_Object {
 
 public static void main(String[] Args) throws IOException
 {
  Socket c_socket = null;
    
  try
  {   
   c_socket = new Socket("127.0.0.1",5425);
   
   ObjectOutputStream out = new ObjectOutputStream(c_socket.getOutputStream()
         Student data = new Student();
         data.setName("홍길동");
         data.setAdd("경북");
         
            out.writeObject(data);
  }
  catch(Exception ex)
  {
   System.out.println("error" + ex.getMessage());
  }
  finally
  {
   c_socket.close();
  }
 }
}
역시나 마찮가지로 소켓을 하나 생성한 후 ObjectOutputStream을 이용하여 날려 보내면 된다.

바이트로 데잍를 전송 시킬 경우는 다음과 같다.

일단 먼저 서버이다.

try
                {
                   byte[] buff = new byte[1024];                  
                   in.read(buff);                       
                   String sData= new String(buff);
                  
                   System.out.println(sData);
                  
                   out.write("S->C".getBytes());   
                }
                catch(Exception e)
                {
                 System.out.println("error" + e.getMessage());
                 s_socket.close();
                    break;
                }
                finally
                {                  
                }

InputStream을 이용하여 buffer에 쌓인 데이터를 받아  원하는 형태로 바꿔주고

전송 할 경우 getBytes()를 이용한다. 이는 C#에 Encoding.Defalt.GetBytes() 와 동일한 역할을 한다.

클라이언트 측도 위 내용과 동일한 형태이다. InputStream과 OutputStream을 이용하면 손쉽게 작성 가능하다.

문득 생각나서 한번 작성해 본 코드이다.

.NET 에서 제공하는 리스너가 아닌 소켓만으로 작성한 예이다.

일반적으로 코드 내용은 같다.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;

namespace Server
{
    public partial class Form1 : Form
    {

        IPEndPoint _ip_end_point;
        Socket _server;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                this._ip_end_point = new IPEndPoint(IPAddress.Any, 10000);
                this._server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);               
                this._server.Bind(this._ip_end_point);
                this._server.Listen(100);

                while (true)
                {
                    Application.DoEvents();
                    Socket client = this._server.Accept();

                    int recv_total = 0;
                    int recv_size = 0;
                    int left_data = 0;
                    int recv_data = 0;

                    byte[] size = new byte[4];
                    recv_data = client.Receive(size, 0, 4, SocketFlags.None);
                    recv_size = BitConverter.ToInt32(size, 0);
                    left_data = recv_size;

                    byte[] data = new byte[recv_size];

                    while (recv_total < recv_size)
                    {
                        Application.DoEvents();
                        recv_data = client.Receive(data, recv_total, left_data, 0);
                        if (recv_data == 0)
                        {
                            this.Text = "Zero Data";
                            break;
                        }
                        else
                        {
                            this.Text = "No Zero Data";
                            recv_total += recv_data;
                            left_data -= recv_data;
                        }
                    }
                    client.Close();
                    MessageBox.Show(Encoding.Default.GetString(data, 0, recv_size));
                }
            }
            catch
            {
            }
            finally
            {
                this._server.Close();
            }
        }
    }
}
코드에서 보면 알겠지만 엔드 포인트를 잡아주고 그것을 바인드 한 형태이다.

하나 의문인게 Listen 처리를 하지 않으면 안될까.. 고민 하다가 한번 빼 보고 했는데 바로 오류가 났다.

한 소켓에 접근하는 수를 제어하는 것인데 여러 수천, 수만명이 접근 할 때는 어떻게 되는 것인가 의문이 든다.

한번 연구 해 볼 만한 가치는 있는 듯 하다.(경력에 비해 해 본 것이 없는 것 같아 슬프다.)

나머지는 대략 접속한 소켓을 생성하고 그 내용을 바이트 처리 하여 하는 것이다. 여기까지가 서버 코드이다.

다음은 클라이언트 코드이다.

try
            {
                IPEndPoint ip_end_point = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 10000);
                Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                server.Connect(ip_end_point);

                int send_total = 0;
                int data_size = 0;
                int left_data = 0;
                int send_data = 0;

                EventHandler();

                byte[] data = new byte[data_size];
                data = Encoding.Default.GetBytes("TCP/IP Connect Test");
                data_size = data.Length;
                left_data = data_size;

                byte[] size = new byte[4];
                size = BitConverter.GetBytes(data_size);

                server.Send(size);

                while (send_total < data_size)
                {
                    send_data = server.Send(data, send_total, left_data, SocketFlags.None);
                    send_total += send_data;
                    left_data -= send_data;
                }
            }
            catch
            {
            }
            finally
            {
                server.Close();
            }
최초의 작업은 서버 측과 동일하다. 엔드 포인트를 잡아주고 소켓을 생성해서 서버와 접속을 한다.

물론 데이터 처리는 서버와 동일하게 하기 위해서 바이트 처리를 하게 해봤다.

이것 말고도 네트워크 스트림을 이용하여 스트림을 이용해서 문자열들을 보내는 통신 또한 가능하다.

각기 해당하는 스트림을 생성하여 Flash() 처리를 해 주면 된다.

그렇게 작업 할 경우 반드시 스트림 처리엔 Flash() 처리를 해 줘야한다. 아닐 경우 버퍼에 쌓인 데이터 문제도 있을 뿐더러

통신 결과가 원할하지 않거나 문제가 발생하는 것을 확인 할 수가 있을 것이다.

흠냐.. -_- 그냥 간단한 형식으로 만들었다

테스팅만 되게..

근데 -_- 근데!! 왜!!

-_- WrteLine만 해서 보낼 경우는 데이터가 왜 안가지 -_-;;

Flush()는 스트림을 비우는게 아닌감 -_-

난 그렇게 알고 있었는데...

뭐 암튼지간 -_- 여기 저기 기웃거림 뭔가 알겠지 -_-;;

******TCP/IP + DataBase Server Code 1:1

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.IO;
using System.Data.SqlClient;

namespace server
{
    public partial class Form1 : Form
    {
        TcpListener server;
        TcpClient client;
        NetworkStream Stream = null;
        StreamReader reader;
        StreamWriter writer;
        Thread reciive;
        bool connect;
        private delegate void MBox();

        public Form1()
        {
            InitializeComponent();
        }    
      
        private void Check()
        {
            try
            {               
                client = server.AcceptTcpClient();
                connect = true;
                Stream = client.GetStream();
                reader = new StreamReader(Stream);
                writer = new StreamWriter(Stream);
                reciive = new Thread(new ThreadStart(Recieve));
                reciive.Start();
            }
            catch (Exception ex) { }
        }

        private void Recieve()
        {
            try
            {
                while (connect)
                {
                    Thread.Sleep(1);
                    if (Stream.CanRead)
                    {
                        Thread.Sleep(1);
                        if (Stream.CanRead)
                        {
                            string temp = reader.ReadLine();
                            if (temp.Length > 0)
                            {
                                Search();
                            }
                        }
                    }
                }
            }
            catch (Exception ex) { }
        }

        private void Search()
        {
            string tests = @"User Id=sa; Password=cjstkd; Server =192.168.1.209; Initial Catalog = test";
            SqlConnection conn;
            SqlCommand cmd;
            SqlDataReader dr;
            try
            {
                conn = new SqlConnection(tests);
                conn.Open();
                cmd = new SqlCommand("select id from ID_PW", conn);
                cmd.CommandType = CommandType.Text;
                dr = cmd.ExecuteReader();
                while (dr.Read())
                {
                    writer.WriteLine(dr.GetString(0));
                    writer.Flush();
                }
                dr.Close();
                conn.Close();
            }
            catch (Exception ex) { }
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            Thread checkThread = new Thread(new ThreadStart(Check));
            checkThread.Start();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            connect = false;
            if (reader != null)
                reader.Close();
            if (writer != null)
                writer.Close();
            if (server != null)
                server.Stop();
            if (client != null)
                client.Close();
            if (reciive != null)
                reciive.Abort();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            IPAddress addr = new IPAddress(0);
            int port = 5425;
            server = new TcpListener(addr, port);
            server.Start();
            Check();
            button2.Text="Start";
        }
    }
}

*****TCP/IP Client

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace client
{
    public partial class Form1 : Form
    {
        TcpClient client;
        StreamReader reader;
        StreamWriter writer;
        NetworkStream Stream;
        Thread receive;
        bool connect;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try{
                client = new TcpClient();
                client.Connect("192.168.1.209",5425);
                Stream = client.GetStream();
                connect = true;
                reader = new StreamReader(Stream);
                writer = new StreamWriter(Stream);
                receive = new Thread(new ThreadStart(Recieve));
                receive.Start();
            }
            catch(Exception ex){}
        }
                   
        private void Recieve(){
            try{
                while(connect)
                {
                    Thread.Sleep(1);
                    if (Stream.CanRead)
                    {
                        string temp = reader.ReadLine();
                        if (temp.Length > 0)
                            MessageBox.Show(temp);
                    }
                }
            }
            catch(Exception e){}
        }

        private void button2_Click(object sender, EventArgs e)
        {
            writer.WriteLine("search");
            writer.Flush();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            connect = false;
            if (reader != null)
                reader.Close();
            if (writer != null)
                writer.Close();
            if (client != null)
                client.Close();
            if (receive != null)
                receive.Abort();
        }                   
    }
}

*********************************************************************************
1:다 Server
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.IO;
using System.Data.SqlClient;

namespace server
{
    public partial class Form1 : Form
    {
        TcpListener server;
        TcpClient client = null;
        NetworkStream Stream = null;
        StreamReader reader = null;
        StreamWriter writer = null;
        Thread reciive=null;
        Thread checkThread = null;
        bool connect=false;

        public Form1()
        {
            InitializeComponent();
        }    
      
        private void Check()
        { 
            string temp=null;
            try
            {
                while (true)
                {
                    temp = null;
                    client = server.AcceptTcpClient();
                    connect = true;

                    Stream = client.GetStream();
                    reader = new StreamReader(Stream);
                    writer = new StreamWriter(Stream);
                    temp = reader.ReadLine();
                    if (temp.Equals("search"))
                    {
                        Search();                    
                    }
                    else if (temp.Equals("search1"))
                    {
                        Search1();
                    }
                    temp = null;               
                }
            }
            catch (Exception ex) { }
        }

        private void Recieve()
        {
            try
            {
                while (connect)
                {
                    Thread.Sleep(1);
                    if (Stream.CanRead)
                    {
                        Thread.Sleep(1);
                        if (Stream.CanRead)
                        {
                            string temp = reader.ReadLine();
                            if (temp.Length > 0)
                            {
                                if (temp.Equals("search"))
                                {
                                    MessageBox.Show(temp);
                                    Search();
                                    temp = null;
                                }
                                else if (temp.Equals("search1"))
                                {
                                    MessageBox.Show(temp);
                                    Search1();
                                    temp = null;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex) { }
        }

        private void Search()
        {
            string tests = @"User Id=sa; Password=cjstkd; Server =192.168.1.209; Initial Catalog = test";
            SqlConnection conn;
            SqlCommand cmd;
            SqlDataReader dr;
            try
            {
                conn = new SqlConnection(tests);
                conn.Open();
                cmd = new SqlCommand("select id from ID_PW", conn);
                cmd.CommandType = CommandType.Text;
                dr = cmd.ExecuteReader();
                while (dr.Read())
                {
                    writer.WriteLine(dr.GetString(0));
                    writer.Flush();
                }
                dr.Close();
                conn.Close();
            }
            catch (Exception ex) { }
        }
        private void Search1()
        {
            string tests = @"User Id=sa; Password=cjstkd; Server =192.168.1.209; Initial Catalog = test";
            SqlConnection conn;
            SqlCommand cmd;
            SqlDataReader dr;
            try
            {
                conn = new SqlConnection(tests);
                conn.Open();
                cmd = new SqlCommand("select pw from ID_PW", conn);
                cmd.CommandType = CommandType.Text;
                dr = cmd.ExecuteReader();
                while (dr.Read())
                {
                    writer.WriteLine(dr.GetString(0));
                    writer.Flush();
                }
                dr.Close();
                conn.Close();
            }
            catch (Exception ex) { }
        }
        private void Form1_Load(object sender, EventArgs e)
        {
           
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            connect = false;
            if (reader != null)
                reader.Close();
            if (writer != null)
                writer.Close();
            if (server != null)
                server.Stop();
            if (client != null)
                client.Close();             
            if (reciive != null)
                reciive.Abort();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            IPAddress addr = new IPAddress(0);
            int port = 5425;
            server = new TcpListener(addr, port);
           
            server.Start(); 
                     
                checkThread = new Thread(new ThreadStart(Check));
               
                checkThread.IsBackground = true;
                checkThread.Start();
            button2.Text="Start";
        }
    }
}
*********************************************************************************
1:다 Client
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace client
{
    public partial class Form1 : Form
    {
        TcpClient client;
        StreamReader reader;
        StreamWriter writer;
        NetworkStream Stream;
        Thread receive;
        bool connect;

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try{
                client = new TcpClient();
                client.Connect("localhost",5425);
                Stream = client.GetStream();
                connect = true;
                reader = new StreamReader(Stream);
                writer = new StreamWriter(Stream);
                receive = new Thread(new ThreadStart(Recieve));               
                receive.Start();             
            }
            catch(Exception ex){}
        }
                   
        private void Recieve(){
            try{
                while (connect)
                {
                    Thread.Sleep(1);
                    if (Stream.CanRead)
                    {
                        string temp = reader.ReadLine();
                        if (temp.Length > 0)
                            MessageBox.Show(temp);
                    }
                }
            }
            catch(Exception e){}
        }

        private void button2_Click(object sender, EventArgs e)
        {
            writer.WriteLine("search");
            writer.Flush();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            connect = false;
            if (reader != null)
                reader.Close();
            if (writer != null)
                writer.Close();
            if (client != null)
                client.Close();
            if (receive != null)
                receive.Abort();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            writer.WriteLine("search1");
            writer.Flush();
        }                   
    }
}