Java는 파일을 업로드 할 수있는 서버 및 클라이언트를 작성합니다. 특정 내용은 다음과 같습니다
서버 측
Class Server {public static void main (String [] args)은 예외를 발생시킵니다 {// 서버 소켓 생성 서버 스톱 ss = new Serversocket (10005); // 클라이언트 소켓 수신 fileloadersocket = ss.accept (); // 연결 정보 문자열 인쇄 IP = FILELOADERSOCKE.GETINETADDRESS (). GETHOSTADDRESS (); System.out.println (ip + "... connceed"); // 파일을 받고 inputStream을 저장 in = fileloadersocket.getInputStream (); // 객체 파일을 인스턴스화하여 outputStream filesave = new FileOutputStream ( "e : //3.mp3"); // 배열 BUF 바이트 생성 [] buf = new Byte [1024]; int len = 0; // 파일의 끝이 읽는지 ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // filesave.flush (); } // 파일 복사 정보 복사 BufferedWriter out = new BufferedWriter (new OutputStreamWriter (fileloadersocket.getOutputStream ())); out.write ( "파일 업로드 성공"); // refresh Out.flush (); // resource close ss.close (); fileloadersocket.close (); filesave.close (); }}고객:
클래스 클라이언트 {public static void main (String [] args)은 예외를 던집니다 {// 소켓 서비스 소켓 생성 fileloadersocket = new Socket ( "168.168.168.94", 10005); // 클라이언트에서 로컬로 파일을 읽고 소켓의 출력 스트림 outputStream out = fileloadersocket.getOutputStream ()에 씁니다. // 객체 FilereAder InputStream fileread를 인스턴스화합니다. // 배열 바이트 생성 [] buf = new Byte [1024]; int len = 0; // 파일의 끝이 읽는지 여부를 판단합니다 ((len = fileread.read (buf))! = -1) {out.write (buf, 0, len); } // 파일이 전송되었다고 서버에게 알려줍니다. fileloadersocket.shutdownoutput (); // 서버 bufferedReader in = new bufferedReader (new inputStreamReader (fileloadersocket.getInputStream ()))에서 정보 피드백을 가져옵니다. 문자열 서버 백 = in.Readline (); System.out.println (Serverback); // resource close fileloadersocket.close (); fileread.close (); }}다음 프로그램은 학습 참조를 위해 다른 곳에서 직접 복사됩니다.
자바 소켓 프로그래밍
Java 소켓 프로그래밍의 경우 두 가지 개념이 있으며, 하나는 서버 소켓이고 다른 하나는 소켓입니다. 서버와 클라이언트는 소켓을 통해 연결된 다음 통신 할 수 있습니다. 먼저 Serversocket은 서버의 포트를 듣습니다. 클라이언트가 소켓에 연결하려는 소켓이 있음을 발견하면 소켓의 연결 요청이 수락되며 동시에 서버에 해당 소켓을 설정하여 통신합니다. 이런 식으로, 클라이언트와 서버에 하나는 두 개의 소켓이 있습니다.
소켓 간의 통신은 실제로 매우 간단합니다. 서버가 소켓 출력 스트림에 무언가를 쓸 때 클라이언트는 소켓 입력 스트림을 통해 해당 콘텐츠를 읽을 수 있습니다. 소켓과 소켓은 두 방향으로 연결되므로 클라이언트는 해당 소켓 출력 스트림에 물건을 쓸 수 있으며 서버의 해당 소켓 입력 스트림이 해당 콘텐츠를 읽을 수 있습니다. 다음은 클라이언트와의 서버 측 통신의 몇 가지 예입니다.
1. 클라이언트 쓰기 및 서버 읽기
서버 Java 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); // 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 클라이언트와의 연결을 설정 한 후 소켓의 입력 스트림을 얻고 클라이언트가 보낸 정보를 읽을 수 있습니다. reader reader = new inputStreamReader (socket.getInputStream ()); char chars [] = 새로운 char [64]; int len; StringBuilder sb = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } system.out.println ( "클라이언트에서 :" + sb); reader.close (); socket.close (); Server.Close (); }}소켓의 입력 스트림에서 데이터를 읽는 서버의 작동도 차단되고 있습니다. 입력 스트림에서 데이터를 읽지 않으면 클라이언트가 소켓의 출력 스트림에 데이터를 작성하거나 소켓의 출력 스트림을 닫을 때까지 프로그램이 남아 있습니다. 물론 클라이언트 소켓에 대해서도 마찬가지입니다. 작업이 완료되면 전체 프로그램이 완료되기 전에 해당 리소스를 닫아야합니다. 즉, 해당 IO 스트림 및 소켓을 닫으십시오.
클라이언트 Java 코드
public class client {public static void main (String args [])은 예외 {// 단순성을 위해 모든 예외가 직접적으로 묶여 있습니다. // 연결할 서버의 IP 주소는 int port = 8899입니다. // 연결할 서버의 해당 청취 포트 // 연결은 서버 소켓 클라이언트 = 새 소켓 (호스트, 포트)으로 설정됩니다. // 연결을 설정 한 후 서버 Writer writer = new OutputStreamWriter (client.getOutputStream ())에 데이터를 쓸 수 있습니다. Writer.write ( "Hello Server."); writer.flush (); // Flush Writer.close ()를 기억합니다. client.close (); }}소켓 출력 스트림에 데이터를 작성할 때는 한 가지에주의를 기울여야합니다. 프로그램이 쓰기 작업 후 출력 스트림의 종료에 해당하지 않지만 다른 차단 작업 (예 : 입력 스트림에서 데이터를 읽는 것과 같은)을 수행하는 경우 플러시해야합니다. 이런 식으로 만 서버는 클라이언트가 보낸 데이터를받을 수 있습니다. 그렇지 않으면 서로를 기다리는 무제한이 발생할 수 있습니다. 이 문제는 나중에 클라이언트 및 서버 읽기 및 쓰기에 대해 동시에 이야기 할 때 언급됩니다.
2. 클라이언트와 서버는 동시에 읽고 쓰기
앞에서 언급했듯이 소켓은 양방향 방식으로 통신하여 데이터를 수신하고 데이터를 보낼 수 있습니다.
서버 Java 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); // 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 클라이언트와의 연결을 설정 한 후 소켓의 입력 스트림을 얻고 클라이언트가 보낸 정보를 읽을 수 있습니다. reader reader = new inputStreamReader (socket.getInputStream ()); char chars [] = 새로운 char [64]; int len; StringBuilder sb = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } system.out.println ( "클라이언트에서 :" + sb); // 읽은 후 문장을 작성합니다. 작가 writer = new outputStreamWriter (socket.getOutputStream ()); Writer.write ( "Hello Client."); Writer.flush (); Writer.close (); reader.close (); socket.close (); Server.Close (); }}위의 코드에서는 먼저 입력 스트림에서 클라이언트가 보낸 데이터를 읽은 다음 데이터를 클라이언트에 출력 스트림에 기록한 다음 해당 리소스 파일을 닫습니다. 실제로, 입력 스트림의 데이터를 읽는 것이 차단 작업이기 때문에 위의 코드는 미리 가정 한 방식으로 실행되지 않을 수 있습니다. 위의 while 루프에서 데이터를 읽으면 루프 본체가 실행되며, 그렇지 않으면 차단되므로 후속 쓰기 작업이 실행되지 않습니다. 클라이언트의 해당 소켓이 닫히고 차단되지 않으면 while 루프가 중지됩니다. 이 상황에 대한 해결책은 결코 실행되지 않을 수 있습니다. 위의 코드를 살펴보면 변경하는 유일한 것은 길이 Len과 읽는 데이터입니다. Len은 더 이상 사용할 수 없으며 사용할 수있는 유일한 것은 읽는 데이터입니다. 이 경우 일반적으로 엔드 태그에 동의합니다. 클라이언트가 전송하는 데이터에 특정 엔드 태그가 포함되어 있으면 현재 데이터가 전송되었으며 현재로서는 루프를 제거 할 수 있습니다. 개선 된 코드는 다음과 같습니다.
자바 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); // 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 클라이언트와의 연결을 설정 한 후 소켓의 입력 스트림을 얻고 클라이언트가 보낸 정보를 읽을 수 있습니다. reader reader = new inputStreamReader (socket.getInputStream ()); char chars [] = 새로운 char [64]; int len; StringBuilder sb = new StringBuilder (); 문자열 온도; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ( "eof"))! = -1) {// eof가 sb.append (temp.substring (0, index))이 발생하면 리셉션이 종료됩니다. 부서지다; } sb.append (temp); } system.out.println ( "클라이언트에서 :" + sb); // Writer Writer를 읽은 후 문장을 작성합니다. Writer.write ( "Hello Client."); Writer.flush (); Writer.close (); reader.close (); socket.close (); Server.Close (); }}위 코드에서 서버가 클라이언트가 보낸 엔드 마크, 즉 "EOF"를 읽으면 데이터 수신이 종료되고 루프가 종료되어 후속 코드가 계속 될 수 있습니다.
클라이언트 Java 코드
public class client {public static void main (String args [])은 예외 {// 단순성을 위해 모든 예외가 직접적으로 묶여 있습니다. // 연결할 서버의 IP 주소는 int port = 8899; // 연결할 서버의 해당 청취 포트 // 연결은 서버 소켓 클라이언트 = 새 소켓 (호스트, 포트)으로 설정됩니다. // 연결을 설정 한 후 서버 Writer writer = new OutputStreamWriter (client.getOutputStream ())에 데이터를 쓸 수 있습니다. Writer.write ( "Hello Server."); Writer.flush (); // Reader Reader를 작성한 후 읽습니다. char chars [] = 새로운 char [64]; int len; StringBuffer sb = new StringBuffer (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } system.out.println ( "서버에서 :" + sb); Writer.close (); reader.close (); client.close (); }}위의 코드에서 먼저 데이터 조각을 서버로 보낸 다음 서버에서 반환 한 데이터를 읽습니다. 이전 서버와 마찬가지로 프로그램이 항상 거기에 매달려서 while 루프에서 벗어나지 않을 수 있습니다. 이 코드는 서버의 첫 번째 코드와 결합되며 서버가 항상 데이터를 수신 할 것이며 while 루프에서 벗어나지 않을 것이므로 클라이언트에 데이터를 반환 할 후속 서버가 없으며 클라이언트가 서버에서 반환 한 데이터를 수신 할 수 없습니다. 솔루션은 서버의 두 번째 코드에 표시됩니다. 클라이언트가 데이터를 전송 한 후에는 엔드 마크를 출력 스트림에 기록하여 서버에 데이터가 전송되었음을 알리십시오. 서버는 또한 데이터가 반환 된 후 클라이언트를 알려주는 마크를 보냅니다. 그러면 수정 된 클라이언트 코드는 다음과 같습니다.
자바 코드
public class client {public static void main (String args [])은 예외 {// 단순성을 위해 모든 예외가 직접적으로 묶여 있습니다. // 연결할 서버의 IP 주소는 int port = 8899입니다. // 연결할 서버의 해당 청취 포트 // 연결은 서버 소켓 클라이언트 = 새 소켓 (호스트, 포트)으로 설정됩니다. // 연결을 설정 한 후 서버 Writer writer = new OutputStreamWriter (client.getOutputStream ())에 데이터를 쓸 수 있습니다. Writer.write ( "Hello Server."); Writer.write ( "eof"); Writer.flush (); // Reader Reader를 작성한 후 읽습니다. char chars [] = 새로운 char [64]; int len; StringBuffer sb = new StringBuffer (); 문자열 온도; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ( "eof"))! = -1) {sb.append (temp.substring (0, index)); 부서지다; } sb.append (새 문자열 (chars, 0, len)); } system.out.println ( "서버에서 :" + sb); Writer.close (); reader.close (); client.close (); }}우리가 일상 생활에서 사용하는 가장 일반적인 형태는 클라이언트가 데이터를 서버로 전송하고 서버가 데이터를 수신하고 해당 결과를 클라이언트에 반환한다는 것입니다. 그러나 더 이상 클라이언트와 서버 간에는 일대일 관계가 없지만 여러 클라이언트가 아래에 언급 된 것과 동일한 서버에 해당하는 상황이 있습니다.
3. 여러 클라이언트가 동일한 서버에 연결합니다
위에서 언급 한 두 가지 예의 경우 서버는 클라이언트의 요청을 수신 한 후 종료되며 다른 클라이언트로부터 요청을받을 수 없으며, 종종 요구 사항을 충족시킬 수 없습니다. 보통 우리는 이것을합니다 :
자바 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); while (true) {// 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 클라이언트와의 연결을 설정 한 후 소켓의 입력 스트림을 얻고 클라이언트가 보낸 정보를 읽을 수 있습니다. reader reader = new inputStreamReader (socket.getInputStream ()); char chars [] = 새로운 char [64]; int len; StringBuilder sb = new StringBuilder (); 문자열 온도; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ( "eof"))! = -1) {// eof가 sb.append (temp.substring (0, index))이 발생하면 리셉션이 종료됩니다. 부서지다; } sb.append (temp); } system.out.println ( "클라이언트에서 :" + sb); // Writer Writer를 읽은 후 문장을 작성합니다. Writer.write ( "Hello Client."); Writer.flush (); Writer.close (); reader.close (); socket.close (); }}} 위의 코드에서는 Dead Loop을 사용하여 서버 소켓이 수락 방법을 호출하여 클라이언트로부터 연결 요청을 수신하려고합니다. 요청이 수신되지 않으면 프로그램은 클라이언트로부터 연결 요청을받을 때까지 여기에서 차단 한 다음 연결을 설정 한 클라이언트와 통신합니다. 그런 다음 루프 본체를 실행하고 새로운 연결 요청을 다시 받으려고합니다. 이와 같은 방식으로 서버 소켓은 모든 클라이언트로부터 연결 요청을 수신하고 이와 통신 할 수 있습니다. 이는 한 서버의 여러 클라이언트와의 간단한 통신 모드를 구현합니다.
위의 예에서는 하나의 서버가 여러 클라이언트와 통신하기 위해 구현되지만 여전히 문제가 있습니다. 위의 예에서는 서버가 클라이언트의 연결 요청을 동시에 처리합니다. 클라이언트로부터 연결 요청을받을 때마다 다음 연결 요청을 처리하기 전에 먼저 현재 클라이언트와 통신해야합니다. 동시성이 더 많을 때 프로그램의 성능에 심각한 영향을 미칩니다. 이러한 이유로, 우리는이를 클라이언트와의 커뮤니케이션의 다음 비동기 처리로 변경할 수 있습니다.
자바 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); while (true) {// 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 소켓이 수신 될 때마다 새 스레드를 처리하기 위해 새 스레드가 설정됩니다 (새 작업 (Socket)). start (); }} / ** * * / 정적 클래스 작업 구현 실행 가능 {개인 소켓 소켓; 공개 작업 (소켓 소켓) {this.socket = 소켓; } public void run () {try {handlesocket (); } catch (예외 e) {e.printstacktrace (); }} / *** 클라이언트 소켓과 통신* @Throws Exception* / private void handlesocket ()는 예외를 던지려면 {reader = new inputStreamReader (socket.getInputStream ()); char chars [] = 새로운 char [64]; int len; StringBuilder sb = new StringBuilder (); 문자열 온도; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ( "eof"))! = -1) {// eof가 sb.append (temp.substring (0, index))이 발생하면 리셉션이 종료됩니다. 부서지다; } sb.append (temp); } system.out.println ( "클라이언트에서 :" + sb); // Writer Writer를 읽은 후 문장을 작성합니다. Writer.write ( "Hello Client."); Writer.flush (); Writer.close (); reader.close (); socket.close (); }}} 위의 코드에서, Serversocket이 새로운 소켓 연결 요청을 수신 할 때마다, 현재 소켓과 통신하기 위해 새 스레드가 생성되어 클라이언트 소켓과의 통신의 비동기 처리를 달성합니다.
Socket의 입력 스트림에서 데이터를 수신 할 때 위와 같은 부분을 읽는 것이 너무 복잡합니다. 때로는 BufferedReader를 사용하여 다음과 같은 한 줄 씩 읽습니다.
자바 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); while (true) {// 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 소켓이 수신 될 때마다 새 스레드를 처리하기 위해 새 스레드가 설정됩니다 (새 작업 (Socket)). start (); }} / ** * * / 정적 클래스 작업 구현 실행 가능 {개인 소켓 소켓; 공개 작업 (소켓 소켓) {this.socket = 소켓; } public void run () {try {handlesocket (); } catch (예외 e) {e.printstacktrace (); }} / *** 클라이언트 소켓과 통신* @Throws Exception* / private void handlesocket ()은 예외를 던지려면 {bufferedReader br = new bufferedReader (new inputStreamReader (socket.getInputStream ()); StringBuilder sb = new StringBuilder (); 문자열 온도; int index; while ((temp = br.readline ())! = null) {system.out.println (temp); if ((index = temp.indexof ( "eof"))! = -1) {// eof가 sb.append (temp.substring (0, index))이 발생하면 수신을 종료합니다. 부서지다; } sb.append (temp); } system.out.println ( "클라이언트에서 :" + sb); // Writer Writer를 읽은 후 문장을 작성합니다. Writer.write ( "Hello Client."); Writer.write ( "EOF/N"); Writer.flush (); Writer.close (); br.close (); socket.close (); }}}현재 BufferedReader의 Readline 방법은 한 번에 한 줄을 읽습니다. 이 방법은 차단됩니다. 프로그램은 한 줄의 데이터를 읽을 때까지 계속 실행되지 않습니다. 그렇다면 언제 읽기 라인이 줄을 읽을까요? Readline 메소드는 프로그램이 해당 스트림의 Newline 또는 결말 문자가 발생할 때까지 라인을 읽었다고 생각하지 않습니다. 그것은 막힘을 끝내고 프로그램이 계속 실행되도록합니다. 따라서 BufferedReader의 readline을 사용하여 데이터를 읽을 때 해당 출력 스트림에 라인 브레이크를 쓰는 것을 기억해야합니다 (스트림이 끝난 후에는 자동으로 표시되고 읽기 라인을 인식 할 수 있음). 라인 브레이크를 작성한 후에는 출력 스트림이 즉시 닫히지 않으면 플러시해야하므로 데이터가 버퍼에서 진정으로 작성되도록해야합니다. 위의 코드에 해당하는 클라이언트 프로그램은 다음과 같이 작성해야합니다.
자바 코드
public class client {public static void main (String args [])은 예외 {// 단순성을 위해 모든 예외가 직접적으로 묶여 있습니다. // 연결할 서버의 IP 주소는 int port = 8899입니다. // 연결할 서버의 해당 청취 포트 // 연결은 서버 소켓 클라이언트 = 새 소켓 (호스트, 포트)으로 설정됩니다. // 연결을 설정 한 후 서버 Writer writer = new OutputStreamWriter (client.getOutputStream ())에 데이터를 쓸 수 있습니다. Writer.write ( "Hello Server."); Writer.write ( "EOF/N"); Writer.flush (); // bufferedReader를 작성한 후 읽습니다. StringBuffer sb = new StringBuffer (); 문자열 온도; int index; while ((temp = br.readline ())! = null) {if ((index = temp.indexof ( "eof"))! = -1) {sb.append (temp.substring (0, index)); 부서지다; } sb.append (temp); } system.out.println ( "서버에서 :" + sb); Writer.close (); br.close (); client.close (); }}4. 시간 초과 시간을 설정하십시오
클라이언트가 소켓을 통해 서버에서 XX 정보를 얻은 다음 페이지의 사용자에게 표시 해야하는 요구 사항이 있다고 가정합니다. 데이터를 읽을 때 소켓이 차단되고 있으며 데이터를 읽지 않으면 프로그램이 계속 차단됩니다. 요청을 동기화 할 때 그러한 상황이 발생하지 않아야합니다. 이를 위해서는 요청이 특정 시간에 도달 한 후 프로그램이 계속 실행될 수 있도록 차단 인터럽트를 제어해야합니다. Socket은 수신 데이터의 시간 초과 시간을 밀리 초로 설정하기위한 setSotimeout () 메소드를 제공합니다. 설정 타임 아웃 시간이 0보다 크고이 시간이 지나면 소켓이 반환 된 데이터를 수신하지 않으면 소켓에 소음이 발생합니다.
데이터를 읽기 시작한 후 10 초 동안 데이터를 읽기 전에 고객을 방해하고 차단할 수 있도록 고객을 제어해야한다고 가정 해 봅시다.
자바 코드
public class client {public static void main (String args [])은 예외 {// 단순성을 위해 모든 예외가 직접적으로 묶여 있습니다. // 연결할 서버의 IP 주소는 int port = 8899입니다. // 연결할 서버의 해당 청취 포트 // 연결은 서버 소켓 클라이언트 = 새 소켓 (호스트, 포트)으로 설정됩니다. // 연결을 설정 한 후 서버 Writer writer = new OutputStreamWriter (client.getOutputStream ())에 데이터를 쓸 수 있습니다. Writer.write ( "Hello Server."); Writer.write ( "EOF/N"); Writer.flush (); // bufferedReader를 작성한 후 읽습니다. // 시간 초과를 10 초로 설정하면 Client.SetSotimeout (10*1000); StringBuffer sb = new StringBuffer (); 문자열 온도; int index; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ( "eof"))! = -1) {sb.append (temp.substring (0, index)); 부서지다; } sb.append (temp); }} catch (SockettimeOutException e) {System.out.println ( "데이터 읽기 시간 초과"); } system.out.println ( "서버에서 :" + sb); Writer.close (); br.close (); client.close (); }}5. 데이터 garbled 코드를받습니다
서버 또는 클라이언트가 중국어 코드를 수신하는 경우 일반적으로 데이터가 전송 될 때 사용되는 인코딩이 데이터를 수신 할 때 사용되는 인코딩과 일치하지 않기 때문입니다. 예를 들어, 다음과 같은 서버 코드가 있습니다.
자바 코드
public class server {public static void main (String args [])은 ioexception {// 단순화를 위해 모든 예외 정보를 int port = 8899로 던져집니다. // 포트 8899에서 청취하는 서버 소켓 정의 Serversocket Server = 새 서버 소켓 (PORT); while (true) {// 서버는 다른 소켓에서 연결 요청을 받으려고합니다. 서버의 허용 메소드는 블록 소켓 소켓 = Server.Accept ()입니다. // 소켓이 수신 될 때마다 새 스레드를 처리하기 위해 새 스레드가 설정됩니다 (새 작업 (Socket)). start (); }} / ** * * / 정적 클래스 작업 구현 실행 가능 {개인 소켓 소켓; 공개 작업 (소켓 소켓) {this.socket = 소켓; } public void run () {try {handlesocket (); } catch (예외 e) {e.printstacktrace (); }} / *** 클라이언트 소켓과 통신* @Throws Exception* / private void handlesocket () 예외 {bufferedReader br = new bufferedReader (new inputStreamReader (socket.getInputStream (), "gbk"); StringBuilder sb = new StringBuilder (); 문자열 온도; int index; while ((temp = br.readline ())! = null) {system.out.println (temp); if ((index = temp.indexof ( "eof"))! = -1) {// eof가 발생할 때 sb.append (temp.substring (0, index)); 부서지다; } sb.append (temp); } system.out.println ( "클라이언트 :" + sb); // 읽기 Writer Writer = New OutputStreamWriter (socket.getOutputStream (), "UTF-8")를 읽은 후 문장을 작성합니다. Writer.write ( "안녕하세요, 클라이언트."); Writer.write ( "EOF/N"); Writer.flush (); Writer.close (); br.close (); socket.close (); }}}테스트를 위해 여기에서 사용할 때 약간 혼란 스러워요. 위의 서버 코드에서 입력 스트림을 정의 할 때 데이터를 읽기 위해 GBK 인코딩의 사용을 명확하게 정의하고 출력 스트림을 정의 할 때 데이터를 보내기 위해 UTF-8 인코딩을 사용하도록 명확하게 지정합니다. 클라이언트가 클라이언트에서 데이터를 보낼 때 클라이언트가 GBK 인코딩에서 데이터를 전송하지 않으면 서버가받은 데이터가 차량화 될 수 있습니다. 마찬가지로, 클라이언트가 서버에서 데이터를 보낼 때 데이터 인코딩을 보내지 않으면, 즉 UTF-8 인코딩 데이터를 수신하기 위해 데이터가 발생할 가능성도 매우 높습니다. 따라서 위의 서버 코드의 경우 프로그램이 차량 코드없이 상대방이 보낸 데이터를 읽을 수 있도록 클라이언트가 다음과 같아야합니다.
자바 코드
public class client {public static void main (String args [])은 예외 {// 단순성을 위해 모든 예외가 직접적으로 묶여 있습니다. // 연결할 서버의 IP 주소는 int port = 8899; // 연결할 서버의 해당 청취 포트 // 연결은 서버 소켓 클라이언트 = 새 소켓 (호스트, 포트)으로 설정됩니다. // 연결을 설정 한 후 서버 Writer writer = new OutputStreamWriter (client.getOutputStream (), "gbk")에 데이터를 쓸 수 있습니다. Writer.write ( "Hello, Server."); Writer.write ( "EOF/N"); Writer.flush (); // bufferedReader를 작성한 후 읽습니다. br = new bufferedReader (new inputStreamReader (client.getInputStream (), "utf-8")); // 시간 초과를 10 초로 설정하면 Client.SetSotimeout (10*1000); StringBuffer sb = new StringBuffer (); 문자열 온도; int index; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ( "eof"))! = -1) {sb.append (temp.substring (0, index)); 부서지다; } sb.append (temp); }} catch (SockettimeOutException e) {System.out.println ( "데이터 읽기 시간 초과"); } system.out.println ( "서버 :" + sb); Writer.close (); br.close (); client.close (); }}이 기사는 "Java 업로드 작업 기술의 요약"으로 편집되었으며 모든 사람들은 배우고 읽을 수 있습니다.
위는이 기사의 모든 내용입니다. 모든 사람의 학습에 도움이되기를 바랍니다. 모든 사람이 wulin.com을 더 지원하기를 바랍니다.