java 远程ftp建立文件夹

  1. import java.io.BufferedInputStream;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.net.SocketException;
  8. import java.text.SimpleDateFormat;
  9. import java.util.Properties;
  10. import org.apache.commons.logging.Log;
  11. import org.apache.commons.net.ftp.FTP;
  12. import org.apache.commons.net.ftp.FTPClient;
  13. import org.apache.commons.net.ftp.FTPClientConfig;
  14. import org.apache.commons.net.ftp.FTPReply;
  15. /**
  16. * 实现FTP 客户端的各种操作
  17. *
  18. * 其实JDK里面也有支持FTP操作的包【jre/lib下的rt.jar】，但是SUN的DOC里面并没有提供相应文档，
  19. * 因为这里面的包，不被官方支持，建议不要使用。我们可以使用第三方提供的包apache.commons。 apache.commons的包，都有文档，方便使用
  20. * 另外IBM也有提供一个ftp包，我没有用过，有兴趣的可以去研究一下
  21. *
  22. * @commons-net：http://apache.mirror.phpchina.com/commons/net/binaries/commons-net-1.4.1.zip
  23. * @jakarta-oro：http://mirror.vmmatrix.net/apache/jakarta/oro/source/jakarta-oro-2.0.8.zip
  24. * @commons-io：http://apache.mirror.phpchina.com/commons/io/binaries/commons-io-1.3.2-bin.zip
  25. *
  26. * @author
  27. * @version 2008-06-10 Ftp.java
  28. *
  29. */
  30. public class Ftp {
  31. private static Log logger;
  32. /**
  33. * FTP 登录用户名
  34. */
  35. private static String UserName;
  36. /**
  37. * FTP 登录密码
  38. */
  39. private static String Password;
  40. /**
  41. * FTP 服务器地址IP地址
  42. */
  43. private static String Ip;
  44. /**
  45. * FTP 端口
  46. */
  47. private static int Port;
  48. /**
  49. * 属性集
  50. */
  51. private static Properties Property = null;
  52. /**
  53. * 配置文件的路径名
  54. */
  55. private static String ConfigFile = "src/com/wwkj/cms/test/ftp/ftpconfig.properties";
  56. /**
  57. * FTP 客户端代理
  58. */
  59. private static FTPClient FtpClient = null;
  60. /**
  61. * 时间格式化
  62. */
  63. private static SimpleDateFormat dateFormat = new SimpleDateFormat(
  64. "yyyy-MM-dd hh:mm");
  65. /**
  66. * FTP
  67. */
  68. private static final String[] FILE_TYPES = { "文件", "目录", "符号链接", "未知类型" };
  69. /**
  70. * 传输模式为二进制文件.
  71. */
  72. public static final int BINARY_FILE_TYPE = FTP.BINARY_FILE_TYPE;
  73. /**
  74. * 传输模式为ASCII，默认为ASCII
  75. */
  76. public static final int ASCII_FILE_TYPE = FTP.ASCII_FILE_TYPE;
  77. public  static int  i=1;
  78. public static void main(String[] args) {
  79. // setConfigFile("ftpconfig.properties");// 设置配置文件路径
  80. connectServer();
  81. // makeDirectory("eeee");
  82. // changeWorkingDirectory("webroot");//进入文件夹webroot
  83. // listRemoteFiles("*.jsp");//列出webroot目录下所有jsp文件
  84. setFileType(FTP.BINARY_FILE_TYPE);// 设置传输二进制文件
  85. //uploadFile("G:/临时文件/万维公司员工交通通讯报销标准（2008修订版）.doc",
  86. //        "中国人也/万维公司员工交通通讯报销标准（2008修订版）.doc");//
  87. // 上传文件woxingwosu.xml，重新命名为myfile.xml
  88. // renameFile("viewDetail.jsp",
  89. // "newName.jsp");//将文件viewDetail.jsp改名为newName.jsp
  90. //        uploadManyFile("G:/临时文件/staxmem", "dirdirdir/");
  91. // deleteFile("/testtest/");//删除一个文件UpdateData.class
  92. // deleteEmptyDirectory("dfd");//
  93. // loadFile("jakarta-oro-2.0.8.jar", "E:/tmp/00000000000000001.jpg");//
  94. // 01.jpg，并且重新命名为G:/临时文件/00000000000000001.jpg
  95. // uploadFile("G:/临时文件");
  96. // listRemoteFiles("eeee");// 列出所有文件和目录
  97. // listRemoteFiles("58-20166.jpg");// 列出指定的文件和目录
  98. closeConnect();// 关闭连接
  99. }
  100. /**
  101. * 上传单个文件，并重命名
  102. *
  103. * @param localFilePath--本地文件路径
  104. * @param newFileName--新的文件名,可以命名为空""
  105. * @return true 上传成功，false 上传失败
  106. */
  107. public static boolean uploadFile(String localFile, String newFileName) {
  108. boolean flag = true;
  109. try {
  110. connectServer();
  111. FtpClient.setFileType(BINARY_FILE_TYPE);
  112. // ftp.setFileType(FTP.ASCII_FILE_TYPE);
  113. FtpClient.enterLocalPassiveMode();
  114. // ftp.changeWorkingDirectory(remoteDir);
  115. FtpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
  116. File file = new File(localFile);
  117. File newFile = new File(newFileName);
  118. String dir = newFile.getParentFile().getPath();
  119. if (!FtpClient.changeWorkingDirectory(dir)) {// 如果不能进入dir下，说明此目录不存在！
  120. if (!makeDirectory(newFile.getParentFile().getPath())) {
  121. System.out.println("创建文件目录【"+dir+"】 失败！");
  122. }
  123. }
  124. changeWorkingDirectory("/");// 回到FTP根目录
  125. InputStream input = new FileInputStream(file);
  126. if (input == null) {
  127. System.out.println("本地文件不存在");
  128. logger.debug("本地文件不存在,请重新选择！");
  129. }
  130. if (newFileName.trim().equals("")) {
  131. newFileName = file.getName();
  132. }
  133. flag = FtpClient.storeFile(newFileName, input);
  134. if (flag) {
  135. System.out.println("upload File succeed");
  136. } else {
  137. System.out.println("upload File false");
  138. }
  139. input.close();
  140. } catch (IOException e) {
  141. e.printStackTrace();
  142. logger.debug("本地文件上传失败！", e);
  143. // TODO: handle exception
  144. } catch (Exception e) {
  145. e.printStackTrace();
  146. // logger.debug("本地文件上传失败！", e);
  147. // TODO: handle exception
  148. }
  149. return flag;
  150. }
  151. //    /**
  152. //     * 上传多个文件
  153. //     *
  154. //     * @param localFilePath--本地文件夹路径
  155. //     * @return true 上传成功，false 上传失败
  156. //     */
  157. //    public static String uploadManyFile(String localFile) {
  158. //        boolean flag = true;
  159. //        StringBuffer strBuf = new StringBuffer();
  160. //        int n = 0;
  161. //        try {
  162. //            connectServer();
  163. //            File file = new File(localFile);// 在此目录中找文件
  164. //
  165. //            File file2[] = file.listFiles();
  166. //
  167. //            for (int i = 0; i < file2.length; i ) {
  168. //
  169. //                File file1 = new File(file2[i].getAbsolutePath());
  170. //                if (file1.isDirectory()) {// 文件夹中还有文件夹
  171. //                    uploadManyFile(file2[i].getAbsolutePath());
  172. //                } else {
  173. //                    flag = uploadFile(file2[i].getAbsolutePath(), "");
  174. //                }
  175. //                if (!flag) {
  176. //                    n ;
  177. //                    strBuf.append(file2[i].getName() "\r\n");
  178. //
  179. //                }
  180. //            }
  181. //            if (n > 0) {
  182. //
  183. //                strBuf.insert(0, "共有" n "上传失败，分别为\r\n");
  184. //            }
  185. //            System.out.println(strBuf.toString());
  186. //        } catch (NullPointerException e) {
  187. //            e.printStackTrace();
  188. //            // logger.debug("本地文件上传失败！找不到上传文件！", e);
  189. //            // TODO: handle exception
  190. //        } catch (Exception e) {
  191. //            e.printStackTrace();
  192. //            logger.debug("本地文件上传失败！", e);
  193. //            // TODO: handle exception
  194. //        }
  195. //        return strBuf.toString();
  196. //    }
  197. //
  198. //    /**
  199. //     * 上传多个文件
  200. //     *
  201. //     * @param localFilePath--本地文件夹路径
  202. //     * @param newFileName--目标路径
  203. //     * @return true 上传成功，false 上传失败
  204. //     */
  205. //    public static String uploadManyFile(String localFile, String newFileName) {
  206. //        boolean flag = true;
  207. //        StringBuffer strBuf = new StringBuffer();
  208. //        int n = 0;
  209. //        try {
  210. //            connectServer();
  211. //            File file = new File(localFile);// 在此目录中找文件
  212. //
  213. //            File file2[] = file.listFiles();
  214. //
  215. //            for (int i = 0; i < file2.length; i ) {
  216. //
  217. //                File file1 = new File(file2[i].getAbsolutePath());
  218. //                System.out.println(file1.isFile());
  219. //                if (file1.isDirectory()) {// 文件夹中还有文件夹
  220. //
  221. //                    uploadManyFile(file2[i].getAbsolutePath(), newFileName);
  222. //                } else {
  223. //                    String tmpNewFileName = "";
  224. //                    if (newFileName.substring(newFileName.length() - 1).equals(
  225. //                            "/")) {
  226. //
  227. //                        tmpNewFileName = newFileName file2[i].getName();
  228. //                    } else {
  229. //
  230. //                        tmpNewFileName = newFileName "/" file2[i].getName();
  231. //                    }
  232. //                    System.out.println(tmpNewFileName);
  233. //                    flag = uploadFile(file2[i].getAbsolutePath(),
  234. //                            tmpNewFileName);
  235. //                }
  236. //                if (!flag) {
  237. //                    n ;
  238. //                    strBuf.append(file2[i].getName() "\r\n");
  239. //
  240. //                }
  241. //            }
  242. //            if (n > 0) {
  243. //
  244. //                strBuf.insert(0, "共有" n "上传失败，分别为\r\n");
  245. //            }
  246. //            System.out.println(strBuf.toString());
  247. //        } catch (NullPointerException e) {
  248. //            e.printStackTrace();
  249. //            logger.debug("本地文件上传失败！找不到上传文件！", e);
  250. //            // TODO: handle exception
  251. //        } catch (Exception e) {
  252. //            e.printStackTrace();
  253. //            logger.debug("本地文件上传失败！", e);
  254. //            // TODO: handle exception
  255. //        }
  256. //        return strBuf.toString();
  257. //    }
  258. //
  259. //    /**
  260. //     * 下载文件
  261. //     *
  262. //     * @param remoteFileName
  263. //     *            --服务器上的文件名
  264. //     * @param localFileName--本地文件名
  265. //     * @return true 下载成功，false 下载失败
  266. //     *
  267. //     */
  268. //    public static boolean loadFile(String remoteFileName, String localFileName) {
  269. //        boolean flag = true;
  270. //        connectServer();
  271. //        // 下载文件
  272. //        BufferedOutputStream buffOut = null;
  273. //        try {
  274. //            buffOut = new BufferedOutputStream(new FileOutputStream(
  275. //                    localFileName));
  276. //            flag = FtpClient.retrieveFile(remoteFileName, buffOut);
  277. //        } catch (Exception e) {
  278. //            e.printStackTrace();
  279. //            logger.debug("本地文件下载失败！", e);
  280. //        } finally {
  281. //            try {
  282. //                if (buffOut != null)
  283. //                    buffOut.close();
  284. //            } catch (Exception e) {
  285. //                e.printStackTrace();
  286. //
  287. //            }
  288. //        }
  289. //        return flag;
  290. //    }
  291. //
  292. //    /**
  293. //     * 删除一个文件
  294. //     */
  295. //    public static boolean deleteFile(String filename) {
  296. //        boolean flag = true;
  297. //        try {
  298. //            connectServer();
  299. //
  300. //            flag = FtpClient.deleteFile(filename);
  301. //            if (flag) {
  302. //                System.out.println("delete  File succeed");
  303. //
  304. //            } else {
  305. //                System.out.println("delete File false");
  306. //
  307. //            }
  308. //        } catch (IOException ioe) {
  309. //            ioe.printStackTrace();
  310. //        }
  311. //        return flag;
  312. //    }
  313. //
  314. //    /**
  315. //     * 删除目录
  316. //     */
  317. //    public static void deleteDirectory(String pathname) {
  318. //        try {
  319. //            connectServer();
  320. //            File file = new File(pathname);
  321. //            if (file.isDirectory()) {
  322. //                File file2[] = file.listFiles();
  323. //            } else {
  324. //                deleteFile(pathname);
  325. //
  326. //            }
  327. //            FtpClient.removeDirectory(pathname);
  328. //        } catch (IOException ioe) {
  329. //            ioe.printStackTrace();
  330. //        }
  331. //    }
  332. //
  333. //    /**
  334. //     * 删除空目录
  335. //     */
  336. //    public static void deleteEmptyDirectory(String pathname) {
  337. //        try {
  338. //            connectServer();
  339. //            FtpClient.removeDirectory(pathname);
  340. //        } catch (IOException ioe) {
  341. //            ioe.printStackTrace();
  342. //        }
  343. //    }
  344. //    /**
  345. //     * 列出服务器上文件和目录
  346. //     *
  347. //     * @param regStr
  348. //     *            --匹配的正则表达式
  349. //     */
  350. //    @SuppressWarnings("unchecked")
  351. //    public static void listRemoteFiles(String regStr) {
  352. //        connectServer();
  353. //        try {
  354. //            // FtpClient.changeWorkingDirectory(regStr);
  355. //            String files[] = FtpClient.listNames(regStr);
  356. //            if (files == null || files.length == 0)
  357. //                System.out.println("There has not any file!");
  358. //            else {
  359. //                for (int i = 0; i < files.length; i ) {
  360. //                    System.out.println(files[i]);
  361. //
  362. //                }
  363. //
  364. //            }
  365. //        } catch (Exception e) {
  366. //            e.printStackTrace();
  367. //        }
  368. //    }
  369. //
  370. //    /**
  371. //     * 列出Ftp服务器上的所有文件和目录
  372. //     *
  373. //     */
  374. //    public static void listRemoteAllFiles() {
  375. //        connectServer();
  376. //        try {
  377. //            String[] names = FtpClient.listNames();
  378. //            for (int i = 0; i < names.length; i ) {
  379. //                System.out.println(names[i]);
  380. //            }
  381. //
  382. //        } catch (Exception e) {
  383. //            e.printStackTrace();
  384. //        }
  385. //    }
  386. /**
  387. * 关闭连接
  388. */
  389. public static void closeConnect() {
  390. try {
  391. if (FtpClient != null) {
  392. FtpClient.logout();
  393. FtpClient.disconnect();
  394. }
  395. } catch (Exception e) {
  396. e.printStackTrace();
  397. }
  398. }
  399. /**
  400. * 设置配置文件
  401. *
  402. * @param configFile
  403. */
  404. public static void setConfigFile(String configFile) {
  405. Ftp.ConfigFile = configFile;
  406. }
  407. /**
  408. * 设置传输文件的类型[文本文件或者二进制文件]
  409. *
  410. * @param fileType--BINARY_FILE_TYPE、ASCII_FILE_TYPE
  411. */
  412. public static void setFileType(int fileType) {
  413. try {
  414. connectServer();
  415. FtpClient.setFileType(fileType);
  416. } catch (Exception e) {
  417. e.printStackTrace();
  418. }
  419. }
  420. /**
  421. * 扩展使用
  422. *
  423. * @return
  424. */
  425. protected static FTPClient getFtpClient() {
  426. connectServer();
  427. return FtpClient;
  428. }
  429. /**
  430. * 设置参数
  431. *
  432. * @param configFile
  433. *            --参数的配置文件
  434. */
  435. private static void setArg(String configFile) {
  436. Property = new Properties();
  437. BufferedInputStream inBuff = null;
  438. try {
  439. File file = new File(configFile);
  440. inBuff = new BufferedInputStream(new FileInputStream(file));
  441. Property.load(inBuff);
  442. UserName = Property.getProperty("username");
  443. Password = Property.getProperty("password");
  444. Ip = Property.getProperty("ip");
  445. Port = Integer.parseInt(Property.getProperty("port"));
  446. } catch (FileNotFoundException e1) {
  447. System.out.println("配置文件 【" +configFile +"】不存在！");
  448. e1.printStackTrace();
  449. } catch (IOException e) {
  450. System.out.println("配置文件 【" +configFile+ "】无法读取！");
  451. e.printStackTrace();
  452. }
  453. /*
  454. * } catch (Exception e) { e.printStackTrace(); } finally { try { if
  455. * (inBuff != null) inBuff.close(); } catch (Exception e) {
  456. * e.printStackTrace(); } }
  457. */
  458. }
  459. /**
  460. * 连接到服务器
  461. *
  462. * @return true 连接服务器成功，false 连接服务器失败
  463. */
  464. public static boolean connectServer() {
  465. boolean flag = true;
  466. if (FtpClient == null) {
  467. int reply;
  468. try {
  469. setArg(ConfigFile);
  470. FtpClient = new FTPClient();
  471. FtpClient.setControlEncoding("GBK");
  472. FtpClient.setDefaultPort(Port);
  473. FtpClient.configure(getFtpConfig());
  474. FtpClient.connect(Ip);
  475. FtpClient.login(UserName, Password);
  476. FtpClient.setDefaultPort(Port);
  477. //System.out.print(FtpClient.getReplyString());
  478. reply = FtpClient.getReplyCode();
  479. FtpClient.setDataTimeout(120000);
  480. if (!FTPReply.isPositiveCompletion(reply)) {
  481. FtpClient.disconnect();
  482. System.err.println("FTP server refused connection.");
  483. // logger.debug("FTP 服务拒绝连接！");
  484. flag = false;
  485. }
  486. //                System.out.println(i);
  487. //                i ;
  488. } catch (SocketException e) {
  489. flag = false;
  490. e.printStackTrace();
  491. System.err.println("登录ftp服务器【" +Ip+ "】失败,连接超时！");
  492. // logger.debug("登录ftp服务器【" Ip "】失败");
  493. } catch (IOException e) {
  494. flag = false;
  495. e.printStackTrace();
  496. System.err.println("登录ftp服务器【"+ Ip +"】失败，FTP服务器无法打开！");
  497. // logger.debug("登录ftp服务器【" Ip "】失败");
  498. }
  499. }
  500. return flag;
  501. }
  502. /**
  503. * 进入到服务器的某个目录下
  504. *
  505. * @param directory
  506. */
  507. public static void changeWorkingDirectory(String directory) {
  508. try {
  509. connectServer();
  510. FtpClient.changeWorkingDirectory(directory);
  511. } catch (IOException ioe) {
  512. ioe.printStackTrace();
  513. }
  514. }
  515. //    /**
  516. //     * 返回到上一层目录
  517. //     */
  518. //    public static void changeToParentDirectory() {
  519. //        try {
  520. //            connectServer();
  521. //            FtpClient.changeToParentDirectory();
  522. //        } catch (IOException ioe) {
  523. //            ioe.printStackTrace();
  524. //        }
  525. //    }
  526. /**
  527. * 重命名文件
  528. *
  529. * @param oldFileName
  530. *            --原文件名
  531. * @param newFileName
  532. *            --新文件名
  533. */
  534. public static void renameFile(String oldFileName, String newFileName) {
  535. try {
  536. connectServer();
  537. FtpClient.rename(oldFileName, newFileName);
  538. } catch (IOException ioe) {
  539. ioe.printStackTrace();
  540. }
  541. }
  542. /**
  543. * 设置FTP客服端的配置--一般可以不设置
  544. *
  545. * @return
  546. */
  547. private static FTPClientConfig getFtpConfig() {
  548. FTPClientConfig ftpConfig = new FTPClientConfig(
  549. FTPClientConfig.SYST_UNIX);
  550. ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING);
  551. return ftpConfig;
  552. }
  553. /**
  554. * 转码[ISO-8859-1 -> GBK] 不同的平台需要不同的转码
  555. *
  556. * @param obj
  557. * @return
  558. */
  559. private static String iso8859togbk(Object obj) {
  560. try {
  561. if (obj == null)
  562. return "";
  563. else
  564. return new String(obj.toString().getBytes("iso-8859-1"), "GBK");
  565. } catch (Exception e) {
  566. return "";
  567. }
  568. }
  569. /**
  570. * 在服务器上创建一个文件夹
  571. *
  572. * @param dir
  573. *            文件夹名称，不能含有特殊字符，如 \ 、/ 、: 、* 、?、 "、 <、>...
  574. */
  575. public static boolean makeDirectory(String dir) {
  576. connectServer();
  577. boolean flag = true;
  578. try {
  579. // System.out.println("dir=======" dir);
  580. flag = FtpClient.makeDirectory(dir);
  581. if (flag) {
  582. System.out.println("make Directory " +dir +" succeed");
  583. } else {
  584. System.out.println("make Directory " +dir+ " false");
  585. }
  586. } catch (Exception e) {
  587. e.printStackTrace();
  588. }
  589. return flag;
  590. }
  591. public static Log getLogger() {
  592. return logger;
  593. }
  594. public static void setLogger(Log logger) {
  595. Ftp.logger = logger;
  596. }
  597. }
时间： 2024-11-10 10:29:40

java 远程ftp建立文件夹的相关文章

基于commons-net实现ftp创建文件夹、上传、下载功能

原文:http://www.open-open.com/code/view/1420774470187 package com.demo.ftp; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintWriter

遍历远程服务器某个文件夹下的文件

遍历远程文件夹下的文件,您可以考虑使用FTP的方式,具体的请参考下述代码:private string GetFileNames(string URI){WebClient wClient = new WebClient();FtpWebRequest FtpClient;Uri uri = new Uri(URI);FtpClient = (FtpWebRequest)WebRequest.Create(uri); FtpClient.Credentials.GetCredential(uri

Android 建立文件夹、生成文件并写入文本文件内容

一.首先添加权限 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission> 二.建立文件夹.生成文件并写入文本文件内容代码 private void initData() { String filePath = "/sdcard/Test/"; String fileName = "log.txt"

Java学习-010-创建文件夹源代码

此文源码主要为应用 Java 创建文件目录的源码.若有不足之处,敬请大神指正,不胜感激! 创建文件夹源代码如下所示: 1 /** 2 * @function 文件操作:创建文件夹.若文件夹不存在,则级联创建文件夹:若存在则不创建. 3 * 4 * @author Aaron.ffp 5 * @version V1.0.0: autoUISelenium main.java.aaron.java.tools FileUtils.java createPath, 2015-2-2 21:03:31

使用VS2010开发Qt程序的4点经验（QT4到QT5的升级，更改sln文件，切换工程使用的Qt库，在VS的Solution Explorer视图中建立文件夹）

导读 相比于Qt Creator,我更喜欢用VS2010来进行开发.虽然启动时间相对较慢,但是VS下强大的快捷键和丰富的插件,以及使用多年的经验,都让我觉得在开发过程中得心应手.其中最重要的一点是,有时候Qt Creator报的错误莫名其妙.要根据提示找到错误根源显得无从下手.而VS的一般错误说明都比较人性化,即便在某些时候无从解决,也可以通过搜索引擎大致定位出错误的源头.下面是在调试网上的一些源代码的时候,积累下来的一点经验,记下来一来备忘,二来也可供后来人参考. The system can

java批量修改指定文件夹下所有后缀名的文件为另外后缀名的代码

原文:java批量修改指定文件夹下所有后缀名的文件为另外后缀名的代码 源代码下载地址:http://www.zuidaima.com/share/1550463660264448.htm 今天有个需求,想把某个文件夹下所有后缀名为jsp的更改为ftl,本来想用bat实现对bat的高级语法也不太了解,后来发现还需要递归遍历所有的子文件夹,所以用java实现了一个功能一样的代码,有需要的牛人可以下载修改为自己想要的. 这样可以兼容windows和linux. package com.zuidaima

Windows下Java File对象创建文件夹时的一个"坑"

import java.io.File; import java.io.IOException; public class DirCreate { public static void main(String[] args) throws IOException { // TODO Auto-generated method stub String dirStr="D:"; File dir=new File(dirStr); System.out.println("====

FTP下文件夹权限的设置755，766，777，644代表什么意思

一般情况下,为了网站更安全,我们需要给文件或文件夹设置权限,在采用FTP登录的方式下,经常会用到755,766,777,644等设置. 具体这些数字都代表什么意思呢? 这三个数字分别表示:不同用户或用户组的权限. 第一个数字 表示文件所有者的权限 第二个数字 表示与文件所有者同属一个用户组的其他用户的权限 第三个数字 表示其它用户组的权限. 权限分为三种: 读(r=4),写(w=2),执行(x=1). 综合起来还有可读可执行5(rx=5=4+1).可读可写6(rw=6=4+2).可读可写可执行7

乌班图的世界——建立文件夹和空文件

1.建立文件夹mkdir=make directory 命令组成:mkdir + (自定义命名) 例如:mkdir 123(中间有空格) 建立后在当前目录下用ls -l 查看结果 2.建立空文件touch 命令组成:touch +(自定义命名) 注意所在的目录位置例如:touch 123(中间有空格) 原文地址:http://blog.51cto.com/shujuliu/2171121