[Java] 求救，急急急。

Murphye

使用TCP协议完成一个客户端一个服务器。客户端从键盘输入读取一个字符串，发送到服务器。

服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。

求大神帮忙完成，最好写上注释，我快崩溃了。

Murphye · Murphye

本帖最后由 Murphye 于 2015-12-8 22:25 编辑

import java.io.*;
import java.net.*;
/*
需求：使用TCP协议完成一个客户端一个服务器。客户端从键盘输入读取一个字符串，发送到服务器。
服务器接收客户端发送的字符串，反转之后发回客户端。客户端接收并打印。
*/
/*
客户端：
1. 需要先有socket端点。
2. 客户端的数据源：键盘。
3. 客户端的目的：socket。
4. 接收服务端的数据，源：socket。
5. 将数据显示再打印出来。目的：控制台。
6. 在这些流中操作的数据，都是文本数据。
*/
class MyClient {
public static void main(String[] args)throws Exception{
//创建客户端Socket服务
Socket s = new Socket("127.0.0.1",10010);
//获取键盘录入
BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
//socket输出流
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
//socket输入流，读取服务端返回的反转数据
BufferedReader bfrIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
//把键盘获取的数据发送出去，输入over时结束客户端
String line = null;
while((line=bfr.readLine())!=null){
if("over".equals(line))
break;
out.println(line);
//读取服务器端返回的数据
String turn = bfrIn.readLine();
System.out.println(turn);
}
s.close();
}
}
/*
转换服务器
分析：
1. serversocket服务。
2. 获取socket对象。
3. 源：socket，读取客户端发过来需要转换的数据。
4. 目的：显示在控制台上。
5. 将数据转换顺序发给客户端。
*/
class TransServer {
public static void main(String[] args)throws Exception {
//创建ServerSocket
ServerSocket ss = new ServerSocket(10010);
//获取socket对象
Socket s = ss.accept();
//获取客户端的ip，有客户端连接进来时提示
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....is connected");
//获取socket读取流，并用BufferedReader装饰
BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
//获取socket的输出流，用PrintWriter装饰，方便刷新数据
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.readLine())!=null){
System.out.println(line);
//创建StringBuffer容器，使用它里面的reverse反转方法
StringBuffer sb = new StringBuffer(line);
out.println(sb.reverse());
}
s.close();
ss.close();
}
}

复制代码

毕老师视频里面有讲到类似的题目哟

ios学者 · ios学者

* 客户端*/

import java.io.*;

import java.net.*;

public class Test10_Client {

public static void main(String[] args) throws Exception {

Socket s = new Socket("192.168.0.103", 8080);// 创建Socket对象；

BufferedReader buf = new BufferedReader(

new InputStreamReader(System.in));// 从键盘获取输入流到缓冲区；

BufferedWriter bufout=new BufferedWriter(newOutputStreamWriter(s.getOutputStream())

);// 创建一个输出流

BufferedReader bufIn = new BufferedReader(new InputStreamReader(

s.getInputStream()));// 获取输入流……；

String line = null;

while ((line = buf.readLine()) != null) {

if ("over".equals(line))

break;

bufout.write(line);

bufout.newLine();

bufout.flush();

Stringstr=bufIn.readLine();

System.out.print("server:"+str);

}

s.close();

}

/**服务器端

*/import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

public class Test10_Server {

public static void main(String []agrs)throws Exception

{

ServerSocket ss=new ServerSocket(8080);

Socket s= ss.accept();

String ip=s.getInetAddress().getHostAddress();

System.out.println(ip+"we are connected!");

BufferedReader buf =new BufferedReader(newInputStreamReader(s.getInputStream()));

BufferedWriter bufout=newBufferedWriter(newOutputStreamWriter(s.getOutputStream())

);// 创建一个输出流

// bufout.write(ip+"we are connected!");

String line=null;

while((line=buf.readLine())!=null){

System.out.println(line);

StringBuffer re=new StringBuffer(line);//字符串反转处理

Stringstr=re.reverse().toString();

System.out.println(re+"++ ++"+str);//服务器本地输出

bufout.write(str);//将字符反转并输出到客户端

bufout.newLine();

bufout.flush();

}

s.close();

}

744919632

ios学者发表于 2015-12-8 11:44
* 客户端*/import java.io.*;import java.net.*; public class Test10_Client { public static void mai ...

全是报错，我修改了一下，还有一个，public class Test10_Server报错的。

744919632

ios学者发表于 2015-12-8 11:44
* 客户端*/import java.io.*;import java.net.*; public class Test10_Client { public static void mai ...

/**服务器端
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class Test10_Cilent {
public static void main(String[] args) throws Exception {
      Socket s = new Socket("192.168.0.103", 8080);// 创建Socket对象；
      BufferedReader buf = new BufferedReader(
            new InputStreamReader(System.in));// 从键盘获取输入流到缓冲区；
      BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream())
            );// 创建一个输出流
      BufferedReader bufIn = new BufferedReader(new InputStreamReader(
            s.getInputStream()));// 获取输入流……；
      String line = null;
      while ((line = buf.readLine()) != null) {
         if ("over".equals(line))
            break;
            bufout.write(line);
            bufout.newLine();
            bufout.flush();
            String str=bufIn.readLine();
            System.out.print("server:"+str);
      }
      s.close();
   }
}
   class Test10_Server {
   public static void main(String []agrs)throws Exception
   {
      ServerSocket ss=new ServerSocket(8080);
         Socket s= ss.accept();
         String ip=s.getInetAddress().getHostAddress();
         System.out.println(ip+"we are connected!");
         BufferedReader buf =new BufferedReader(new InputStreamReader(s.getInputStream()));
         BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream())
            );// 创建一个输出流
      // bufout.write(ip+"we are connected!");
         String line=null;
         while((line=buf.readLine())!=null){
            System.out.println(line);
            StringBuffer re=new StringBuffer(line);//字符串反转处理
            String str=re.reverse().toString();
            System.out.println(re+"++ ++"+str);//服务器本地输出
            bufout.write(str);//将字符反转并输出到客户端
            bufout.newLine();
            bufout.flush();
         }
      s.close();

   }

}

运行时候报错了。

ios学者 · ios学者

思路：
步骤：

*/
import java.io.*;
import java.net.*;
import java.util.Scanner;
class TcpServer//服务端
{
      public static void main(String[] args)throws Exception
      {
            Socket s=null;
            try{
                     while(true)
                     {
                              @SuppressWarnings("resource")
ServerSocket serverSocket=new ServerSocket(10001);
                              s=serverSocket.accept();
                              BufferedReader server_buf=new BufferedReader(new InputStreamReader(s.getInputStream()));
                              String str=server_buf.readLine();
                              System.out.println("服务端接受到数据...");
                              Thread.sleep(10000);
                              PrintStream pri=new PrintStream(s.getOutputStream());
                              System.out.println("服务端将字符串反转后发送给客户端...");
                              pri.println(new StringBuffer(str).reverse());//将反转后的字符串打印到客户端屏幕上
                     }
            }
            catch(Exception e)
            {
                     e.printStackTrace();
            }
            finally{
                     if(s!=null){
                              try{
                                    s.close();
                              }
                              catch(Exception e)
                              {
                                    e.printStackTrace();
                              }
                     }
            }
      }
}

class TcpClient//客户端
{
      public static void main(String[] args)throws Exception
      {
            Socket s=null;
            try
            {
                     s=new Socket(InetAddress.getLocalHost(),10001);
                     while(true){
                              BufferedReader client_buf=new BufferedReader(new InputStreamReader(s.getInputStream()));
                              PrintStream pri=new PrintStream(s.getOutputStream());
                              Scanner sc=new Scanner(System.in);
                              System.out.println("请输入一个字符串:");
                              String str=sc.nextLine();
                              System.out.println("正在向服务器发送数据...");
                              pri.println(str);
                              System.out.println("接受来自服务器反转的字符串...");
                              System.out.println(client_buf.readLine());
                              sc.close();
                     }
            }
            catch(Exception e)
            {
                              e.printStackTrace();
            }
            finally{
                     if(s!=null){
                              try{
                                    s.close();
                              }
                              catch(Exception e)
                              {
                                    e.printStackTrace();
                              }
                     }
            }
      }
}

ios学者 · ios学者

思路：
步骤：

*/
import java.io.*;
import java.net.*;
import java.util.Scanner;
class TcpServer//服务端
{
      public static void main(String[] args)throws Exception
      {
            Socket s=null;
            try{
                     while(true)
                     {
                              @SuppressWarnings("resource")
ServerSocket serverSocket=new ServerSocket(10001);
                              s=serverSocket.accept();
                              BufferedReader server_buf=new BufferedReader(new InputStreamReader(s.getInputStream()));
                              String str=server_buf.readLine();
                              System.out.println("服务端接受到数据...");
                              Thread.sleep(10000);
                              PrintStream pri=new PrintStream(s.getOutputStream());
                              System.out.println("服务端将字符串反转后发送给客户端...");
                              pri.println(new StringBuffer(str).reverse());//将反转后的字符串打印到客户端屏幕上
                     }
            }
            catch(Exception e)
            {
                     e.printStackTrace();
            }
            finally{
                     if(s!=null){
                              try{
                                    s.close();
                              }
                              catch(Exception e)
                              {
                                    e.printStackTrace();
                              }
                     }
            }
      }
}

class TcpClient//客户端
{
      public static void main(String[] args)throws Exception
      {
            Socket s=null;
            try
            {
                     s=new Socket(InetAddress.getLocalHost(),10001);
                     while(true){
                              BufferedReader client_buf=new BufferedReader(new InputStreamReader(s.getInputStream()));
                              PrintStream pri=new PrintStream(s.getOutputStream());
                              Scanner sc=new Scanner(System.in);
                              System.out.println("请输入一个字符串:");
                              String str=sc.nextLine();
                              System.out.println("正在向服务器发送数据...");
                              pri.println(str);
                              System.out.println("接受来自服务器反转的字符串...");
                              System.out.println(client_buf.readLine());
                              sc.close();
                     }
            }
            catch(Exception e)
            {
                              e.printStackTrace();
            }
            finally{
                     if(s!=null){
                              try{
                                    s.close();
                              }
                              catch(Exception e)
                              {
                                    e.printStackTrace();
                              }
                     }
            }
      }
}

744919632

ios学者发表于 2015-12-8 12:13
思路：
步骤：

大哥，这代码你直接粘过来的吧，我看过了，也是错。

萧未然 · 萧未然

/**
* 步骤：第一步：创建客户端--(得到键盘输入-发送数据-获得服务端反馈-输出结果)
* 第二步：创建服务端---通过服务端accept()方法，获得输入输出流，进行数据操作(获得-反转-输出)
* 因为只需要读取一个字符串，客户端只读一次就关闭流，只输出一次就关闭客户端输出流
* @author Administrator
*---测试类
*/
import java.net.*;
import java.io.*;
import java.util.*;
public class ReverseString{
//主线程
public static void main(String[] args) {
new Thread(new TcpServer()).start();//对于TCP协议，首先建立服务端线程
new Thread(new TcpClient()).start();//其次建立客户端线程
}
}
/**
* 客户端
* @author Administrator
*
*/
class TcpClient implements Runnable{
public void run(){//客户端线程run方法
Socket s=null;
BufferedReader isw=null;
try {
isw=new BufferedReader(new InputStreamReader(System.in));//键盘输入流
String str=isw.readLine();//获得键盘录入
s=new Socket(InetAddress.getLocalHost(),11112);//客户端
BufferedWriter bufw=//客户端输出流
new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bufw.write(str);
bufw.flush();//输出并刷新流
s.shutdownOutput();//关闭输出流
BufferedReader bufr=//客户端输入流，读取服务端反馈的信息
new BufferedReader(new InputStreamReader(s.getInputStream()));
String backInfo=bufr.readLine();
System.out.println("客户端:反转后为:"+backInfo);//输出反馈信息
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
System.out.println("主机有误");
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("流读写异常");
}finally{//关闭资源
if(s!=null&&isw!=null)
try {
s.close();
isw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("客户端关闭失败");
}
}
}
}
/**
* TCP服务端
* @author Administrator
*
*/
class TcpServer implements Runnable{
public void run(){//服务端线程run方法
ServerSocket ss=null;
Socket s=null;
try {
ss=new ServerSocket(11112);//监听的应用程序--端口
s=ss.accept();//从服务端获得该服务端监听的客户端
BufferedReader bufr=//服务端输入流
new BufferedReader(new InputStreamReader(s.getInputStream()));
String getInfo=bufr.readLine();
if(getInfo!=null){//如果获得的客户端数据不为null，则反转该字符串
StringBuilder sb=new StringBuilder(getInfo);
getInfo=sb.reverse().toString();//反转
}
if(getInfo==null)//如果为空
getInfo="什么都没有呀";
PrintWriter pw=new PrintWriter(s.getOutputStream());//服务端输出流
pw.println(getInfo);//换行输出，客户端才能接收数据
pw.flush();//刷新
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("服务端错误！");
}finally{//关闭资源
if(ss!=null&&s!=null){
try {
s.close();
ss.close();
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("服务端关闭失败");
}
}
}
}
}

复制代码

毕老师视频里面说的也很详细

744919632

Murphye 发表于 2015-12-8 22:14
毕老师视频里面有讲到类似的题目哟

OK 好的，完美解决。

帐号		自动登录	找回密码
密码			加入黑马

[Java] 求救，急急急。

最佳答案

9 个回复