黑马程序员技术交流社区

标题: 自己写的模拟网盘客户端及服务器端 [打印本页]

作者: 蔡锐    时间: 2015-8-29 20:59
标题: 自己写的模拟网盘客户端及服务器端
最近终于自学完了网络编程,结合网络编程,IO,和多线程写了个模拟网盘,感觉写的挺笨的,但初步实现了上传下载功能,我就献丑把代码贴上来了,希望大家给点修改建议客户端代码

  1. import java.io.BufferedInputStream;
  2. import java.io.BufferedOutputStream;
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.InputStreamReader;
  10. import java.io.OutputStream;
  11. import java.net.Socket;
  12. import java.net.UnknownHostException;

  13. /**
  14. * 模拟网盘客户端,支持上传下载
  15. *
  16. * @author CR
  17. * @version 1.1
  18. */
  19. public class NetDiskClient {
  20.         public static String defaultServerIP = "192.168.1.41";// 默认服务器IP,自行修改
  21.         public static int defaultServerPort = 15678;// 默认服务器端口
  22.         public static File defaultPath = new File("D:\\MyNetDiskDownload");// 默认下载路径

  23.         public static void main(String[] args) throws IOException {
  24.                 while (true) {
  25.                         System.out.println("------欢迎使用模拟网盘客户端------");
  26.                         System.out.println("1.设置服务器IP");
  27.                         System.out.println("2.设置服务器端口");
  28.                         System.out.println("3.开始上传");
  29.                         System.out.println("4.开始下载");
  30.                         System.out.println("5.设置下载路径");
  31.                         System.out.println("6.退出");
  32.                         System.out.println("请选择;");
  33.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  34.                                         System.in));
  35.                         String line = br.readLine();
  36.                         switch (line) {
  37.                         case "1":
  38.                                 System.out.println("当前默认的服务器IP为:" + defaultServerIP
  39.                                                 + ",请输入你要设置的IP:");
  40.                                 String newIP = br.readLine();
  41.                                 defaultServerIP = newIP;
  42.                                 System.out.println("设置成功!");
  43.                                 break;
  44.                         case "2":
  45.                                 System.out.println("当前默认的服务器端口为:" + defaultServerPort
  46.                                                 + ",请输入你要设置的端口:");
  47.                                 String newPort = br.readLine();
  48.                                 defaultServerPort = Integer.parseInt(newPort);
  49.                                 System.out.println("设置成功!");
  50.                                 break;
  51.                         case "3":
  52.                                 uploadFile();
  53.                                 break;
  54.                         case "4":
  55.                                 downloadFile();
  56.                                 break;
  57.                         case "5":
  58.                                 System.out.println("当前下载目录为:" + defaultPath.getAbsolutePath()
  59.                                                 + "请输入你要设置的下载目录:");
  60.                                 System.out.println("路径需要用双\\\\或者/,如:H:\\\\test 或者 H:/test");
  61.                                 String newPath = br.readLine();
  62.                                 defaultPath = new File(newPath);// 路径需要用双\\或者/,如:H:\\test 或者
  63.                                                                                                 // H:/test
  64.                                 System.out.println("设置完成!");
  65.                                 break;
  66.                         case "6":
  67.                         default:
  68.                                 System.out.println("谢谢使用,再见!");
  69.                                 System.exit(0);
  70.                         }
  71.                 }
  72.         }

  73.         private static void uploadFile() throws UnknownHostException, IOException {
  74.                 // TODO Auto-generated method stub
  75.                 Socket socket = new Socket(defaultServerIP, defaultServerPort);
  76.                 InputStream is = socket.getInputStream();
  77.                 OutputStream os = socket.getOutputStream();
  78.                 byte[] bys = new byte[1024];
  79.                 int len;
  80.                 os.write("upload".getBytes());
  81.                 while (true) {
  82.                         System.out.println("请输入要上传的文件的全路径:");
  83.                         System.out
  84.                                         .println("路径需要用双\\\\或者/,如:H:\\\\test\\\\test.txt 或者 H:/test/test.txt");
  85.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  86.                                         System.in));
  87.                         String filePath = br.readLine();
  88.                         File file = new File(filePath);// 将文件路径封装进File
  89.                         if (!file.isFile()) {
  90.                                 System.out.println("文件名非法,请重新输入!");// 只允许上传文件
  91.                                 continue;
  92.                         }
  93.                         String fileName = file.getName();
  94.                         os.write(fileName.getBytes());// 获取文件名传给服务器
  95.                         len = is.read(bys);
  96.                         String message = new String(bys, 0, len);
  97.                         if (message.equals("文件名存在,请重新输入!")) {
  98.                                 // 读取服务器信息进行判断
  99.                                 System.out.println(message);
  100.                                 continue;
  101.                         } else {
  102.                                 System.out.println(message);
  103.                                 String order = br.readLine();
  104.                                 // 继续给指令
  105.                                 os.write(order.getBytes());
  106.                                 len = is.read(bys);
  107.                                 message = new String(bys, 0, len);// 读取指令进行判断
  108.                                 if (message.equals("开始上传")) {
  109.                                         System.out.println(message);
  110.                                         long start = System.currentTimeMillis();
  111.                                         BufferedInputStream bis = new BufferedInputStream(
  112.                                                         new FileInputStream(file));
  113.                                         while ((len = bis.read(bys)) != -1) {
  114.                                                 os.write(bys, 0, len);
  115.                                         }
  116.                                         socket.shutdownOutput();
  117.                                         long end = System.currentTimeMillis();
  118.                                         message = "上传成功,共耗时" + (end - start) + "毫秒";
  119.                                         System.out.println(message);
  120.                                         bis.close();
  121.                                         socket.close();
  122.                                         break;
  123.                                 } else {
  124.                                         System.out.println(message);
  125.                                         System.exit(0);
  126.                                 }
  127.                         }
  128.                 }
  129.         }

  130.         public static void downloadFile() throws UnknownHostException, IOException {
  131.                 Socket socket = new Socket(defaultServerIP, defaultServerPort);
  132.                 InputStream is = socket.getInputStream();
  133.                 OutputStream os = socket.getOutputStream();
  134.                 byte[] bys = new byte[1024];
  135.                 int len;
  136.                 os.write("download".getBytes());
  137.                 if (!defaultPath.exists()) {
  138.                         defaultPath.mkdir();
  139.                 }
  140.                 if (!defaultPath.isDirectory()) {
  141.                         System.out.println("下载路径有误,请返回重新设置!");
  142.                         socket.close();
  143.                         return;
  144.                 }
  145.                 while (true) {
  146.                         String msg = "";
  147.                         System.out.println("你存储的文件如下:");
  148.                         while ((len = is.read(bys)) != -1) {
  149.                                 msg = new String(bys, 0, len);
  150.                                 System.out.println(msg);
  151.                                 if (msg.endsWith("请输入编号:")) {
  152.                                         break;
  153.                                 }
  154.                                 if (msg.equals("你还没有在服务器中上传过文件!")
  155.                                                 || msg.equals("你在服务器的文件目录中没有文件!")) {
  156.                                         socket.close();
  157.                                         return;
  158.                                 }
  159.                         }
  160.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  161.                                         System.in));
  162.                         msg = br.readLine();
  163.                         os.write(msg.getBytes());
  164.                         len = is.read(bys);
  165.                         msg = new String(bys, 0, len);
  166.                         if (msg.equals("请输入正确的编号!")) {
  167.                                 System.out.println(msg);
  168.                                 continue;
  169.                         } else {
  170.                                 len = is.read(bys);
  171.                                 String name = new String(bys, 0, len);
  172.                                 System.out.println("是否下载" + name + "?(是/否)");
  173.                                 msg = br.readLine();
  174.                                 os.write(msg.getBytes());
  175.                                 len = is.read(bys);
  176.                                 msg = new String(bys, 0, len);
  177.                                 if (msg.equals("开始下载")) {
  178.                                         System.out.println("正在下载,文件存储在" + defaultPath);
  179.                                         long start = System.currentTimeMillis();
  180.                                         BufferedOutputStream bos = new BufferedOutputStream(
  181.                                                         new FileOutputStream(new File(defaultPath, name)));
  182.                                         while ((len = is.read(bys)) != -1) {
  183.                                                 bos.write(bys, 0, len);
  184.                                         }
  185.                                         socket.shutdownInput();
  186.                                         long end = System.currentTimeMillis();
  187.                                         msg = "下载成功,共耗时" + (end - start) + "毫秒";
  188.                                         System.out.println(msg);
  189.                                         bos.close();
  190.                                         socket.close();
  191.                                         break;
  192.                                 } else {
  193.                                         System.out.println(msg);
  194.                                         socket.close();
  195.                                         break;
  196.                                 }
  197.                         }
  198.                 }
  199.         }
  200. }
复制代码
网盘v1.1.zip (4.12 KB, 下载次数: 51)



作者: 蔡锐    时间: 2015-8-29 21:00
贴不下了 服务器代码贴这里了

  1. /**
  2. * 模拟网盘服务器端,支持上传和下载
  3. * @author CR
  4. * @version V1.1
  5. */
  6. import java.io.BufferedInputStream;
  7. import java.io.BufferedOutputStream;
  8. import java.io.BufferedReader;
  9. import java.io.File;
  10. import java.io.FileInputStream;
  11. import java.io.FileOutputStream;
  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.io.InputStreamReader;
  15. import java.io.OutputStream;
  16. import java.net.ServerSocket;
  17. import java.net.Socket;

  18. public class NetDiskServer {
  19.         public static String defaultAddress = "D:\\MyNetDisk";
  20.         public static int defalutPort = 15678;

  21.         public static void main(String[] args) throws IOException {
  22.                 while (true) {
  23.                         System.out.println("------欢迎使用模拟网盘服务器端------");
  24.                         System.out.println("1.设置默认存储位置");
  25.                         System.out.println("2.设置默认端口");
  26.                         System.out.println("3.开启服务器");
  27.                         System.out.println("4.退出");
  28.                         System.out.println("请选择:");
  29.                         BufferedReader br = new BufferedReader(new InputStreamReader(
  30.                                         System.in));
  31.                         String line = br.readLine();
  32.                         switch (line) {
  33.                         case "1":
  34.                                 System.out.println("当前服务器存储位置:" + defaultAddress
  35.                                                 + ",请输入你要设置 目录:");
  36.                                 String address = br.readLine();
  37.                                 defaultAddress = address;
  38.                                 System.out.println("设置成功!");
  39.                                 break;
  40.                         case "2":
  41.                                 System.out.println("当前服务器端口为:" + defalutPort + ",请输入你要设置的端口:");
  42.                                 String newPort = br.readLine();
  43.                                 defalutPort = Integer.parseInt(newPort);
  44.                                 System.out.println("设置成功!");
  45.                                 break;
  46.                         case "3":
  47.                                 ServerSocket serverSocket = new ServerSocket(defalutPort);
  48.                                 while (true) {
  49.                                         Socket socket = serverSocket.accept();
  50.                                         new Thread(new NetDiskServerThread(socket, defaultAddress))
  51.                                                         .start();
  52.                                 }
  53.                         case "4":
  54.                         default:
  55.                                 System.out.println("谢谢使用!再见");
  56.                                 System.exit(0);
  57.                         }

  58.                 }
  59.         }

  60. }

  61. class NetDiskServerThread implements Runnable {
  62.         private Socket socket;// 存储传入的socket
  63.         private String serverDiskAddress;// 用来存储服务器的存储目录
  64.         byte[] buf = new byte[1024];
  65.         int len;

  66.         public String getServerDiskAddress() {
  67.                 return serverDiskAddress;
  68.         }

  69.         public void setServerDiskAddress(String serverDiskAddress) {
  70.                 this.serverDiskAddress = serverDiskAddress;
  71.         }

  72.         public Socket getSocket() {
  73.                 return socket;
  74.         }

  75.         public NetDiskServerThread(Socket socket, String serverDiskAddress) {
  76.                 this.socket = socket;
  77.                 this.serverDiskAddress = serverDiskAddress;
  78.         }

  79.         @Override
  80.         public void run() {
  81.                 // TODO Auto-generated method stub
  82.                 try {
  83.                         InputStream is0 = socket.getInputStream();
  84.                         len = is0.read(buf);
  85.                         String msg = new String(buf, 0, len);
  86.                         if (msg.equals("upload")) {
  87.                                 update();
  88.                         } else {
  89.                                 download();
  90.                         }
  91.                 } catch (IOException e) {
  92.                         // TODO Auto-generated catch block
  93.                         e.printStackTrace();
  94.                 }

  95.         }

  96.         public void update() {
  97.                 String ip = socket.getInetAddress().getHostAddress();
  98.                 String hostName = socket.getInetAddress().getHostName();// 获取客户端的主机名
  99.                 try {
  100.                         System.out.println("ip为" + ip + "主机名:" + hostName + "连接服务器!");
  101.                         File parent = new File(serverDiskAddress + "\\" + ip);// 每个主机拥有一个独立的目录
  102.                         while (true) {
  103.                                 InputStream is = socket.getInputStream();
  104.                                 OutputStream os = socket.getOutputStream();
  105.                                 len = is.read(buf);
  106.                                 String fileName = new String(buf, 0, len);// 读取上传的文件名
  107.                                 File file = new File(parent, fileName);
  108.                                 if (file.exists()) {
  109.                                         os.write("文件名存在,请重新输入!".getBytes());// 判断文件名是否重复
  110.                                         continue;
  111.                                 } else {
  112.                                         // 不重复提示是否上传
  113.                                         os.write("文件可以上传,确认上传?(是/否)".getBytes());
  114.                                         len = is.read(buf);
  115.                                         if (new String(buf, 0, len).equals("否")) {
  116.                                                 // 否认上传就结束咯
  117.                                                 os.write("谢谢使用,再见!".getBytes());
  118.                                                 socket.close();
  119.                                                 break;
  120.                                         } else if (new String(buf, 0, len).equals("是")) {
  121.                                                 // 确认上传给提示,开始上传
  122.                                                 os.write("开始上传".getBytes());

  123.                                                 System.out
  124.                                                                 .println("正在接收来自" + ip + "的" + file.getName());
  125.                                                 if (!parent.exists()) {
  126.                                                         parent.mkdirs();// 如果目录不存在就创建
  127.                                                 }
  128.                                                 BufferedOutputStream bos = new BufferedOutputStream(
  129.                                                                 new FileOutputStream(file));
  130.                                                 while ((len = is.read(buf)) != -1) {
  131.                                                         bos.write(buf, 0, len);
  132.                                                 }
  133.                                                 System.out.println(hostName + "上传完成");
  134.                                                 bos.close();
  135.                                                 socket.close();
  136.                                                 break;
  137.                                         } else {
  138.                                                 // 指令不对也结束
  139.                                                 os.write("不要乱给指令哇,重来吧!".getBytes());
  140.                                                 socket.close();
  141.                                                 break;
  142.                                         }
  143.                                 }
  144.                         }
  145.                 } catch (Exception e) {
  146.                         // TODO: handle exception
  147.                         throw new RuntimeException(e);
  148.                         // e.printStackTrace();
  149.                 }
  150.         }

  151.         public void download() {
  152.                 String ip = socket.getInetAddress().getHostAddress();
  153.                 String hostName = socket.getInetAddress().getHostName();// 获取客户端的主机名
  154.                 int fileCount = 0;
  155.                 try {
  156.                         System.out.println("ip为" + ip + "主机名:" + hostName + "连接服务器!");
  157.                         File parent = new File(serverDiskAddress + "\\" + ip);// 每个主机拥有一个独立的目录
  158.                         OutputStream os = socket.getOutputStream();
  159.                         InputStream is = socket.getInputStream();
  160.                         if (!parent.exists()) {
  161.                                 os.write("你还没有在服务器中上传过文件!".getBytes());// 如果没找到目录则结束下载
  162.                                 socket.close();
  163.                                 return;
  164.                         } else {
  165.                                 String[] list = parent.list();
  166.                                 if (list.length == 0) {
  167.                                         os.write("你在服务器的文件目录中没有文件!".getBytes());// 如果没找到目录则结束下载
  168.                                         socket.close();
  169.                                         return;
  170.                                 } else {
  171.                                         while (true) {
  172.                                                 for (String string : list) {
  173.                                                         os.write((++fileCount + ":" + string).getBytes());
  174.                                                 }
  175.                                                 os.write("\r\n请输入编号:".getBytes());
  176.                                                 len = is.read(buf);
  177.                                                 fileCount = Integer.parseInt(new String(buf, 0, len));
  178.                                                 if (fileCount > list.length || fileCount < 1) {
  179.                                                         os.write("请输入正确的编号!".getBytes());
  180.                                                         continue;
  181.                                                 } else {
  182.                                                         os.write("准备下载".getBytes());
  183.                                                         File file = new File(parent, list[fileCount - 1]);
  184.                                                         os.write(file.getName().getBytes());
  185.                                                         len = is.read(buf);
  186.                                                         if (new String(buf, 0, len).equals("是")) {
  187.                                                                 os.write("开始下载".getBytes());
  188.                                                                 System.out.println("主机" + hostName + "正在下载"
  189.                                                                                 + list[fileCount - 1]);
  190.                                                                 BufferedInputStream bis = new BufferedInputStream(
  191.                                                                                 new FileInputStream(file));
  192.                                                                 while ((len = bis.read(buf)) != -1) {
  193.                                                                         os.write(buf, 0, len);
  194.                                                                 }
  195.                                                                 System.out.println(hostName + "下载成功");
  196.                                                                 bis.close();
  197.                                                                 socket.close();
  198.                                                                 break;
  199.                                                         } else {
  200.                                                                 os.write("谢谢使用,再见!".getBytes());
  201.                                                                 socket.close();
  202.                                                                 break;
  203.                                                         }
  204.                                                 }
  205.                                         }
  206.                                 }
  207.                         }
  208.                 } catch (Exception e) {
  209.                         // TODO: handle exception
  210.                         e.printStackTrace();
  211.                 }
  212.         }
  213. }
复制代码








欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2