精华内容
下载资源
问答
  • 一,FTP文件服务器  FTP 服务器就是支持 FTP 协议的服务器。我们可以在电脑中安装FTP工具负责将电脑中的数据传输到服务器当中,这是服务器就称为FTP服务器,而我们的电脑称为客户端。对于FTP服务器,用户可通过FTP...

    一,FTP文件服务器
     FTP 服务器就是支持 FTP 协议的服务器。我们可以在电脑中安装FTP工具负责将电脑中的数据传输到服务器当中,这是服务器就称为FTP服务器,而我们的电脑称为客户端。对于FTP服务器,用户可通过FTP软件和服务器建立连接,进行文件上传、删除、修改权限等操作。FTP 服务器一般分为两类:Windows FTP服务器和 Linux FTP 服务器。
    二,SpringBoot 集成 FTP文件服务器
    1.maven依赖

    <!--ftp文件上传-->
            <dependency>
                <groupId>commons-net</groupId>
                <artifactId>commons-net</artifactId>
                <version>3.3</version>
            </dependency>
    

    2.application.properties 配置文件 配置

    #ftp use
    ftp.server=39.97.98.252
    ftp.port=65501
    ftp.userName=hopsonftp
    ftp.userPassword=hopsonSGgs12344321
    ftp.bastPath=/hopson
    ftp.imageBaseUrl=http://39.97.98.252:11018/hopson/image/
    ftp.removeUrl=/hopson/image
    

    3.创建 FTP文件服务器 工具类(使用时先在使用的地方注入==> @Autowired ==> private FtpUtil ftpUtil;)

    /**
     * @program: hopson
     * @Date: 2019/8/4 11:23
     * @Author: wangmx
     * 
     * @Description:
     */
    @Component
    public class FtpUtil {
    
        Logger logger = LoggerFactory.getLogger(getClass());
        private String LOCAL_CHARSET = "GBK";
    
        //ftp服务器地址
        @Value("${ftp.server}")
        private String hostname;
    
        //ftp服务器端口
        @Value("${ftp.port}")
        private int port;
    
        //ftp登录账号
        @Value("${ftp.userName}")
        private String username;
    
        //ftp登录密码
        @Value("${ftp.userPassword}")
        private String password;
    
        //ftp保存目录
        @Value("${ftp.bastPath}")
        private String basePath;
    
    
        /**
         * 初始化ftp服务器
         */
        public FTPClient getFtpClient() {
            FTPClient ftpClient = new FTPClient();
            ftpClient.setControlEncoding("utf-8");
    
            try {
                ftpClient.setDataTimeout(1000 * 120);//设置连接超时时间
                logger.info("connecting...ftp服务器:" + hostname + ":" + port);
                ftpClient.connect(hostname,port); // 连接ftp服务器
                ftpClient.login(username, password); // 登录ftp服务器
                int replyCode = ftpClient.getReplyCode(); // 是否成功登录服务器
                if (FTPReply.isPositiveCompletion(ftpClient.sendCommand(
                        "OPTS UTF8", "ON"))) {      // 开启服务器对UTF-8的支持,如果服务器支持就用UTF-8编码,否则就使用本地编码(GBK).
                    LOCAL_CHARSET = "UTF-8";
                }
                if (!FTPReply.isPositiveCompletion(replyCode)) {
                    logger.error("connect failed...ftp服务器:" + hostname + ":" + port);
                }
                logger.info("connect successfu...ftp服务器:" + hostname + ":" + port);
            } catch (MalformedURLException e) {
                logger.error(e.getMessage(), e);
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }
            return ftpClient;
        }
    
    
        /**
         * 上传文件
         *
         * @param targetDir    ftp服务保存地址
         * @param fileName    上传到ftp的文件名
         * @param inputStream 输入文件流
         * @return
         */
        public boolean uploadFileToFtp(String targetDir, String fileName, InputStream inputStream) {
            boolean isSuccess = false;
            String servicePath = String.format("%s%s%s", basePath, "/", targetDir);
            FTPClient ftpClient = getFtpClient();
            try {
                if (ftpClient.isConnected()) {
                    logger.info("开始上传文件到FTP,文件名称:" + fileName);
                    ftpClient.setFileType(FTP.BINARY_FILE_TYPE);//设置上传文件类型为二进制,否则将无法打开文件
                    ftpClient.makeDirectory(servicePath);
                    ftpClient.changeWorkingDirectory(servicePath);
                    //设置为被动模式(如上传文件夹成功,不能上传文件,注释这行,否则报错refused:connect  )
                    ftpClient.enterLocalPassiveMode();//设置被动模式,文件传输端口设置
                    ftpClient.storeFile(fileName, inputStream);
                    inputStream.close();
                    ftpClient.logout();
                    isSuccess = true;
                    logger.info(fileName + "文件上传到FTP成功");
                } else {
                    logger.error("FTP连接建立失败");
                }
            } catch (Exception e) {
                logger.error(fileName + "文件上传到FTP出现异常");
                logger.error(e.getMessage(), e);
            } finally {
                closeFtpClient(ftpClient);
                closeStream(inputStream);
            }
            return isSuccess;
        }
    
        public void closeStream(Closeable closeable) {
            if (null != closeable) {
                try {
                    closeable.close();
                } catch (IOException e) {
                    logger.error(e.getMessage(), e);
                }
            }
        }
    
        //改变目录路径
        public boolean changeWorkingDirectory(FTPClient ftpClient, String directory) {
            boolean flag = true;
            try {
                flag = ftpClient.changeWorkingDirectory(directory);
                if (flag) {
                    logger.info("进入文件夹" + directory + " 成功!");
    
                } else {
                    logger.info("进入文件夹" + directory + " 失败!开始创建文件夹");
                }
            } catch (IOException e) {
                logger.error(e.getMessage(), e);
            }
            return flag;
        }
    
        //创建多层目录文件,如果有ftp服务器已存在该文件,则不创建,如果无,则创建
        public boolean CreateDirecroty(FTPClient ftpClient, String remote) throws IOException {
            boolean success = true;
    
            String directory = remote;
            if (!remote.endsWith(File.separator)) {
                directory = directory + File.separator;
            }
            // 如果远程目录不存在,则递归创建远程服务器目录
            if (!directory.equalsIgnoreCase(File.separator) && !changeWorkingDirectory(ftpClient, new String(directory))) {
                int start = 0;
                int end = 0;
                if (directory.startsWith(File.separator)) {
                    start = 1;
                } else {
                    start = 0;
                }
                end = directory.indexOf(File.separator, start);
                String path = "";
                String paths = "";
                while (true) {
                    String subDirectory = new String(remote.substring(start, end).getBytes("GBK"), "iso-8859-1");
                    path = path + File.separator + subDirectory;
                    if (!existFile(ftpClient, path)) {
                        if (makeDirectory(ftpClient, subDirectory)) {
                            changeWorkingDirectory(ftpClient, subDirectory);
                        } else {
                            logger.error("创建目录[" + subDirectory + "]失败");
                            changeWorkingDirectory(ftpClient, subDirectory);
                        }
                    } else {
                        changeWorkingDirectory(ftpClient, subDirectory);
                    }
    
                    paths = paths + File.separator + subDirectory;
                    start = end + 1;
                    end = directory.indexOf(File.separator, start);
                    // 检查所有目录是否创建完毕
                    if (end <= start) {
                        break;
                    }
                }
            }
            return success;
        }
    
        //判断ftp服务器文件是否存在
        public boolean existFile(FTPClient ftpClient, String path) throws IOException {
            boolean flag = false;
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);
            if (ftpFileArr.length > 0) {
                flag = true;
            }
            return flag;
        }
    
        //创建目录
        public boolean makeDirectory(FTPClient ftpClient, String dir) {
            boolean flag = true;
            try {
                flag = ftpClient.makeDirectory(dir);
                if (flag) {
                    logger.info("创建文件夹" + dir + " 成功!");
    
                } else {
                    logger.info("创建文件夹" + dir + " 失败!");
                }
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
            return flag;
        }
    
        /**
         * 下载文件 *
         *
         * @param pathName FTP服务器文件目录 *
         * @param pathName 下载文件的条件*
         * @return
         */
        public boolean downloadFile(FTPClient ftpClient, String pathName, String targetFileName, String localPath) {
            boolean flag = false;
            OutputStream os = null;
            try {
                System.out.println("开始下载文件");
                //切换FTP目录
                ftpClient.changeWorkingDirectory(pathName);
                ftpClient.enterLocalPassiveMode();
                FTPFile[] ftpFiles = ftpClient.listFiles();
                for (FTPFile file : ftpFiles) {
                    String ftpFileName = file.getName();
                    if (targetFileName.equalsIgnoreCase(ftpFileName.substring(0, ftpFileName.indexOf(".")))) {
                        File localFile = new File(localPath);
                        os = new FileOutputStream(localFile);
                        ftpClient.retrieveFile(file.getName(), os);
                        os.close();
                    }
                }
                ftpClient.logout();
                flag = true;
                logger.info("下载文件成功");
            } catch (Exception e) {
                logger.error("下载文件失败");
                logger.error(e.getMessage(), e);
            } finally {
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        logger.error(e.getMessage(), e);
                    }
                }
                if (null != os) {
                    try {
                        os.close();
                    } catch (IOException e) {
                        logger.error(e.getMessage(), e);
                    }
                }
            }
            return flag;
        }
    
        /*下载文件*/
        public InputStream download(String ftpFile, FTPClient ftpClient) throws IOException {
            String servicePath = String.format("%s%s%s", basePath, "/", ftpFile);
            logger.info("【从文件服务器获取文件流】ftpFile : " + ftpFile);
            if (StringUtils.isBlank(servicePath)) {
                throw new RuntimeException("【参数ftpFile为空】");
            }
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            ftpClient.enterLocalPassiveMode();
            ftpFile = new String(servicePath.getBytes("utf-8"), "iso-8859-1");
            return ftpClient.retrieveFileStream(ftpFile);
        }
    
        /**
         * 删除文件 *
         *
         * @param pathname FTP服务器保存目录 *
         * @param filename 要删除的文件名称 *
         * @return
         */
        public boolean deleteFile(String pathname, String filename) {
            boolean flag = false;
            FTPClient ftpClient = getFtpClient();
            try {
                logger.info("开始删除文件");
                if (ftpClient.isConnected()) {
                    //切换FTP目录
                    ftpClient.changeWorkingDirectory(pathname);
                    ftpClient.enterLocalPassiveMode();
                    ftpClient.dele(filename);
                    ftpClient.logout();
                    flag = true;
                    logger.info("删除文件成功");
                } else {
                    logger.info("删除文件失败");
    
                }
            } catch (Exception e) {
                logger.error("删除文件失败");
                logger.error(e.getMessage(), e);
            } finally {
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        logger.error(e.getMessage(), e);
                    }
                }
            }
            return flag;
        }
    
        public void closeFtpClient(FTPClient ftpClient) {
            if (ftpClient.isConnected()) {
                try {
                    ftpClient.disconnect();
                } catch (IOException e) {
                    logger.error(e.getMessage(), e);
                }
            }
        }
    
        public InputStream downloadFile(FTPClient ftpClient, String pathname, String filename) {
            InputStream inputStream = null;
            try {
                System.out.println("开始下载文件");
                //切换FTP目录
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.enterLocalPassiveMode();
                FTPFile[] ftpFiles = ftpClient.listFiles();
                for (FTPFile file : ftpFiles) {
                    if (filename.equalsIgnoreCase(file.getName())) {
                        inputStream = ftpClient.retrieveFileStream(file.getName());
                        break;
                    }
                }
                ftpClient.logout();
                logger.info("下载文件成功");
            } catch (Exception e) {
                logger.error("下载文件失败");
                logger.error(e.getMessage(), e);
            } finally {
                if (ftpClient.isConnected()) {
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        logger.error(e.getMessage(), e);
                    }
                }
            }
            return inputStream;
        }
    }
    
    

    4.Controller 案例代码

    @RequestMapping(value = "/add/photo",method = RequestMethod.POST)
        public R upload(MultipartFile file){
            String s = dkPhotoService.updatePhoto(file);
            return R.ok();
        }
    

    5.service 层代码

    //图片上传
    String updatePhoto(MultipartFile file);
    

    6.serviceImpl 案例层代码

    /**
         * 图片上传
         * @param file
         * @return
         */
        @Override
        public String updatePhoto(MultipartFile file) {
        	//给图片起一个新的名称,防止在图片名称重复
            String newname=new String();
            
            if(file!=null){
            	//生成新的图片名称
                newname = System.currentTimeMillis()+file.getOriginalFilename();
                try {
                	//图片上传,调用ftp工具类 image 上传的文件夹名称,newname 图片名称,inputStream
                    boolean hopson = ftpUtil.uploadFileToFtp("image", newname, file.getInputStream());
                    if(hopson) {
                    	// 把图片信息存入到数据库中
                        DkPhoto dkPhoto = new DkPhoto();
                        dkPhoto.setName(newname);
                        dkPhoto.setMassifId(massifId);
                        dkPhoto.setPhoto(path + newname);
                        this.insert(dkPhoto);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    return "error";
                }
            }
            return "sucess";
        }
    

    三,出现上传失败
    先检查配置 是否正确,如果出现 java.net.SocketException 说明连接不上 FTP 文件服务器 请检查 文件服务器地址 和 用户名 以及密码,以及 FTP 文件服务器是否搭建正确

    展开全文
  • ftpusers:该文件用来指定哪些用户不能访问ftp服务器; user_list :该文件用来指示的默认账户在默认情况下也不能访问ftp; vsftpd.conf :vsftpd的主配置文件 ) 2 启动ftp,命令如下 servic...

    1 先安装vsftpd,命令如下

    yum install vsftpd -y

    (安装完成后,会有一个/etc/vsftpd目录,里面有一些配置文件

    ftpusers:该文件用来指定哪些用户不能访问ftp服务器;

    user_list :该文件用来指示的默认账户在默认情况下也不能访问ftp;

    vsftpd.conf :vsftpd的主配置文件

    2 启动ftp,命令如下

    service vsftpd start

    (

    停止ftp命令:service vsftpd stop

    重启ftp命令:service vsftpd restart

    )

    3 默认情况下,匿名用户无法向ftp服务器上传和写文件

    可以通过配置

    anon_upload_enable=YES

    anon_mkdir_write_enable=YES

    此时匿名用户既可以登录上传、下载文件。

    4 vsftpd服务与系统用户是相互关联的,可以使用系统用户直接登录ftp服务器

    useradd gmftp (创建一个账号gmftp)

    passwd gmftp (为gmftp账号设置密码)

    5 ftp服务器挂载

    5.1 先安装curlftpfs,命令如下:

    yum install curlftpfs -y

    5.2 curlftpfs ftp://username:password@ip /mnt/ftp

    其中username为系统用户名

    password为系统密码

    ip地址为ftp文件服务器ip

    /mnt/ftp 为本地挂载路径

    5.3 挂载成功后,在ftp文件服务器上的/home目录下会新建一个系统用户名为文件名的目录

    展开全文
  • java连接Ftp文件服务器

    千次阅读 2018-03-07 20:51:37
    Ftp是一种常见的文件存储服务器,在很多的项目中都有使用,方便存储各种格式的文件,使用java连接ftp文件服务器也是常用的工具类。 下面是使用连接ftp文件服务器的步骤: 下载jar包 使用的是maven来管理jar...

    Ftp是一种常见的文件存储服务器,在很多的项目中都有使用,方便存储各种格式的文件,使用java连接ftp文件服务器也是常用的工具类。

    下面是使用连接ftp文件服务器的步骤:

    下载jar包

    使用的是maven来管理jar包,下面试用的Apache的common-net包
    <dependency>
        <groupId>commons-net</groupId>
        <artifactId>commons-net</artifactId>
        <version>3.4</version>
    </dependency>

    实现代码

    
    import org.apache.commons.net.PrintCommandListener;
    import org.apache.commons.net.ftp.FTP;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPFile;
    import org.apache.commons.net.ftp.FTPReply;
    
    import java.io.*;
    
    public class FtpUtil {
        public FTPClient ftpClient = new FTPClient();
    
        public FtpUtil() {
            // 设置将过程中使用到的命令输出到控制台
            this.ftpClient.addProtocolCommandListener(new PrintCommandListener(
                    new PrintWriter(System.out)));
        }
    
        public enum UploadStatus {
            Create_Directory_Fail,      //远程服务器相应目录创建失败
            Create_Directory_Success,   //远程服务器创建目录成功
            Upload_New_File_Success,    //上传新文件成功
            Upload_New_File_Failed,     //上传新文件失败
            File_Exits,                 //文件已经存在
            Remote_Bigger_Local,        //远程文件大于本地文件
            Upload_From_Break_Success,  //断点续传成功
            Upload_From_Break_Failed,   //断点续传失败
            Delete_Remote_Faild;        //删除远程文件失败
        }
    
        /**
         * 连接到FTP服务器
         *
         * @param hostname 主机名
         * @param port     端口
         * @param username 用户名
         * @param password 密码
         * @return 是否连接成功
         * @throws IOException
         */
        public boolean connect(String hostname, int port, String username,
                               String password) throws IOException {
            ftpClient.connect(hostname, port);
            ftpClient.enterLocalPassiveMode();
            if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                if (ftpClient.login(username, password)) {
                    return true;
                }
            }
            disconnect();
            return false;
        }
    
        /**
         * 断开与远程服务器的连接
         *
         * @throws IOException
         */
        public void disconnect() throws IOException {
            if (ftpClient.isConnected()) {
                ftpClient.disconnect();
            }
        }
    
        /**
         * 上传文件到FTP服务器,支持断点续传
         *
         * @param local  本地文件名称,绝对路径
         * @param remote 远程文件路径,使用/home/directory1/subdirectory/file.ext
         *               按照Linux上的路径指定方式,支持多级目录嵌套,支持递归创建不存在的目录结构
         * @return 上传结果
         * @throws IOException
         */
        public UploadStatus upload(String local, String remote) throws IOException {
            remote = new String(remote.getBytes("GBK"), "iso-8859-1");
            // 设置PassiveMode传输
            ftpClient.enterLocalPassiveMode();
            // 设置以二进制流的方式传输
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            ftpClient.setRemoteVerificationEnabled(false);
            ftpClient.setControlEncoding("utf-8");
            UploadStatus result = null;
            // 对远程目录的处理
            String remoteFileName = remote;
            if (remote.contains("/")) {
                remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
                String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
                if (!directory.equalsIgnoreCase("/")
                        && !ftpClient.changeWorkingDirectory(directory)) {
                    // 如果远程目录不存在,则递归创建远程服务器目录
                    int start = 0;
                    int end = 0;
                    if (directory.startsWith("/")) {
                        start = 1;
                    } else {
                        start = 0;
                    }
                    end = directory.indexOf("/", start);
                    while (true) {
                        String subDirectory = remote.substring(start, end);
                        if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                            if (ftpClient.makeDirectory(subDirectory)) {
                                ftpClient.changeWorkingDirectory(subDirectory);
                            } else {
                                System.out.println("创建目录失败");
                                return UploadStatus.Create_Directory_Fail;
                            }
                        }
                        start = end + 1;
                        end = directory.indexOf("/", start);
    
                        // 检查所有目录是否创建完毕
                        if (end <= start) {
                            break;
                        }
                    }
                }
            }
    
            // 检查远程是否存在文件
            FTPFile[] files = ftpClient.listFiles(remoteFileName);
            if (files.length == 1) {
                if (!ftpClient.deleteFile(remoteFileName)) {
                    return UploadStatus.Delete_Remote_Faild;
                }
            }
    
            File f = new File(local);
            long remoteSize = 0;
            long localSize = f.length();
            if (remoteSize == localSize) {
                return UploadStatus.File_Exits;
            } else if (remoteSize > localSize) {
                return UploadStatus.Remote_Bigger_Local;
            }
    
            // 尝试移动文件内读取指针,实现断点续传
            InputStream is = new FileInputStream(f);
            ftpClient.storeFile(remoteFileName, is);
    
            if (is.skip(remoteSize) == remoteSize) {
                ftpClient.setRestartOffset(remoteSize);
                if (ftpClient.storeFile(remote, is)) {
                    return UploadStatus.Upload_From_Break_Success;
                }
            }
            // 如果断点续传没有成功,则删除服务器上文件,重新上传
            if (!ftpClient.deleteFile(remoteFileName)) {
                return UploadStatus.Delete_Remote_Faild;
            }
            if (ftpClient.storeFile(remoteFileName, is)) {
                result = UploadStatus.Upload_New_File_Success;
            } else {
                result = UploadStatus.Upload_New_File_Failed;
            }
            is.close();
            return result;
        }
    }
    
    
    展开全文
  • Centos7 搭建FTP文件服务器

    千次阅读 2020-01-03 21:40:27
    最近公司项目中需要搭建FTP文件服务器,主要是用来解决大文件上传问题。 注:以下命令都是在已经关闭防火墙的前提下进行的 1、安装vsftpd $ yum install vsftpd -y 2、开启服务 $ systemctl start vsftpd $ ...

    最近公司项目中需要搭建FTP文件服务器,主要是用来解决大文件上传问题。

    注:以下命令都是在已经关闭防火墙的前提下进行的

    1、安装vsftpd

        $ yum install vsftpd -y

    2、开启服务

    $ systemctl start vsftpd
    $ systemctl enable vsftpd

    3、修改配置文件

    打开vsftpd的配置文件,配置文件所在目录: /etc/vsftpd/vsftpd.conf ,目录内容如下所示:

    在配置文件中分别放开或者添加以下配置:

    # Example config file /etc/vsftpd/vsftpd.conf
    #
    # The default compiled in settings are fairly paranoid. This sample file
    # loosens things up a bit, to make the ftp daemon more usable.
    # Please see vsftpd.conf.5 for all compiled in defaults.
    #
    # READ THIS: This example file is NOT an exhaustive list of vsftpd options.
    # Please read the vsftpd.conf.5 manual page to get a full idea of vsftpd's
    # capabilities.
    #
    # Allow anonymous FTP? (Beware - allowed by default if you comment this out).
    anonymous_enable=NO
    #
    # Uncomment this to allow local users to log in.
    # When SELinux is enforcing check for SE bool ftp_home_dir
    local_enable=YES
    #
    # Uncomment this to enable any form of FTP write command.
    write_enable=YES
    #
    # Default umask for local users is 077. You may wish to change this to 022,
    # if your users expect that (022 is used by most other ftpd's)
    local_umask=022
    #
    # Uncomment this to allow the anonymous FTP user to upload files. This only
    # has an effect if the above global write enable is activated. Also, you will
    # obviously need to create a directory writable by the FTP user.
    # When SELinux is enforcing check for SE bool allow_ftpd_anon_write, allow_ftpd_full_access
    #anon_upload_enable=YES
    #
    # Uncomment this if you want the anonymous FTP user to be able to create
    # new directories.
    #anon_mkdir_write_enable=YES
    #
    # Activate directory messages - messages given to remote users when they
    # go into a certain directory.
    dirmessage_enable=YES
    #
    # Activate logging of uploads/downloads.
    xferlog_enable=YES
    #
    # Make sure PORT transfer connections originate from port 20 (ftp-data).
    connect_from_port_20=YES
    #
    # If you want, you can arrange for uploaded anonymous files to be owned by
    # a different user. Note! Using "root" for uploaded files is not
    # recommended!
    #chown_uploads=YES
    #chown_username=whoever
    #
    # You may override where the log file goes if you like. The default is shown
    # below.
    xferlog_file=/var/log/xferlog
    #
    # If you want, you can have your log file in standard ftpd xferlog format.
    # Note that the default log file location is /var/log/xferlog in this case.
    xferlog_std_format=YES
    #
    # You may change the default value for timing out an idle session.
    #idle_session_timeout=600
    #
    # You may change the default value for timing out a data connection.
    #data_connection_timeout=120
    #
    # It is recommended that you define on your system a unique user which the
    # ftp server can use as a totally isolated and unprivileged user.
    #nopriv_user=ftpsecure
    #
    # Enable this and the server will recognise asynchronous ABOR requests. Not
    # recommended for security (the code is non-trivial). Not enabling it,
    # however, may confuse older FTP clients.
    #async_abor_enable=YES
    #
    # By default the server will pretend to allow ASCII mode but in fact ignore
    # the request. Turn on the below options to have the server actually do ASCII
    # mangling on files when in ASCII mode. The vsftpd.conf(5) man page explains
    # the behaviour when these options are disabled.
    # Beware that on some FTP servers, ASCII support allows a denial of service
    # attack (DoS) via the command "SIZE /big/file" in ASCII mode. vsftpd
    # predicted this attack and has always been safe, reporting the size of the
    # raw file.
    # ASCII mangling is a horrible feature of the protocol.
    ascii_upload_enable=YES
    ascii_download_enable=YES
    #
    # You may fully customise the login banner string:
    ftpd_banner=Welcome to blah FTP service.
    #
    # You may specify a file of disallowed anonymous e-mail addresses. Apparently
    # useful for combatting certain DoS attacks.
    #deny_email_enable=YES
    # (default follows)
    #banned_email_file=/etc/vsftpd/banned_emails
    #
    # You may specify an explicit list of local users to chroot() to their home
    # directory. If chroot_local_user is YES, then this list becomes a list of
    # users to NOT chroot().
    # (Warning! chroot'ing can be very dangerous. If using chroot, make sure that
    # the user does not have write access to the top level directory within the
    # chroot)
    chroot_local_user=YES
    chroot_list_enable=YES
    # (default follows)
    chroot_list_file=/etc/vsftpd/chroot_list
    #
    # You may activate the "-R" option to the builtin ls. This is disabled by
    # default to avoid remote users being able to cause excessive I/O on large
    # sites. However, some broken FTP clients such as "ncftp" and "mirror" assume
    # the presence of the "-R" option, so there is a strong case for enabling it.
    #ls_recurse_enable=YES
    #
    # When "listen" directive is enabled, vsftpd runs in standalone mode and
    # listens on IPv4 sockets. This directive cannot be used in conjunction
    # with the listen_ipv6 directive.
    listen=YES
    #
    # This directive enables listening on IPv6 sockets. By default, listening
    # on the IPv6 "any" address (::) will accept connections from both IPv6
    # and IPv4 clients. It is not necessary to listen on *both* IPv4 and IPv6
    # sockets. If you want that (perhaps because you want to listen on specific
    # addresses) then you must run two copies of vsftpd with two configuration
    # files.
    # Make sure, that one of the listen options is commented !!
    listen_ipv6=NO
    
    pam_service_name=vsftpd
    userlist_enable=NO
    allow_writeable_chroot=YES
    tcp_wrappers=YES
    guest_enable=YES
    guest_username=ftp
    user_config_dir=/etc/vsftpd/config
    max_clients=300
    pasv_enable=YES
    pasv_min_port=9001
    pasv_max_port=9001
    port_enable=YES

    修改用户的配置文件,配置文件所在路径: /etc/vsftpd/config/ftp,内容如下所示:

    local_root=/home/ftp
    write_enable=YES
    anon_umask=022
    # cmds_denied=PASV,PORT,TYPE
    # anon_world_readable_only=NO
    # anon_upload_enable=YES
    # anon_mkdir_write_enable=YES
    # anon_other_write_enable=YES
    guest_username=ftp
    # nopriv_user=ftp
    # pam_service_name=vsftpd
    # guest_enable=YES
    virtual_use_local_privs=YES
    allow_writeable_chroot=YES
    chroot_local_user=YES
    chroot_list_enable=YES
    chroot_list_file=/etc/vsftpd/chroot_list
    # cmds_allowed=PWD,LIST,PORT,TYPE,DELE,CWD
    cmds_denied=

    建立虚拟用户文件,命令如下:

    #创建编辑用户文件
    vim /etc/vsftpd/virtusers
    
    #第一行为用户名,第二行为密码。不能使用root作为用户名
    ftp
    123456789

    生成虚拟用户数据文件,命令如下:

    #设定PAM验证文件,并指定对虚拟用户数据库文件进行读取
    $ db_load -T -t hash -f /etc/vsftpd/virtusers /etc/vsftpd/virtusers.db
    $ chmod 600 /etc/vsftpd/virtusers.db

    修改完后保存配置文件,执行以下命令让配置生效:

        $ systemctl restart vsftpd

    4、安装vsftpd客户端

    我们为了能更方便的调试vsftpd服务端安装是否成功,所以我们把客户端也顺便安装一波,命令如下:

        $ yum install lftp -y

    5、创建ftp用户

    首先创建用户目录,命令如下:

    $ mkdir -p /home/ftp
    $ chmod 777 /home/ftp
    

    然后创建用户组、用户,命令如下:

    $ groupadd ftp
    $ useradd -g ftp -d /home/ftp ftp
    $ usermod -s /sbin/login ftp

    查看用户是否创建成功,命令如下:

        $ cat /etc/passwd

    6、验证

    我们通过之前安装的ftp客户端命令来进行验证,首先登陆ftp服务端,命令如下:

        $ lftp 192.168.65.128 -u ftp

    登陆成功后我们就可以看到 ftp 这个用户被限制在他自己的用户目录下,其他目录是不可以到达的,我们通过xftp工具用 ftp 这个账号登录FTP文件服务器,图示如下:

    发现当前用户同样被限制在自己所在用户目录中。

    到此FTP文件服务器搭建完成。

    展开全文
  • 阿里云服务器ECS 第一篇:FTP文件服务器搭建

    千次阅读 热门讨论 2017-12-08 16:51:41
    云服务器ECS 第一篇:FTP文件服务器搭建 目前打算将项目部署到云服务器上,并配置系统运行环境,搭建FTP服务器是系统部署的第一步,从这里开始!!! 关于FTP: FTP 是File Transfer Protocol(文件传输协议)的...
  • Thinkphp5.1-实现FTP文件服务器

    千次阅读 2018-12-19 13:08:00
    实现FTP文件服务器 环境搭建 配置服务 详情地址:https://github.com/victor24680/linux-ftp-tp5
  • window10上简单搭建ftp文件服务器

    千次阅读 2019-04-07 16:12:39
    window10上简单搭建ftp文件服务器 打开控制面板 点击程序与功能 启用或关闭windows功能,选择Internet information services,把ftp服务器和web管理工具都勾选上,如下图: 点击确定,电脑系统正常情况下是安装...
  • 基于windows server 2008 R2 搭建FTP文件服务器 时间:2019-07-03 14:48:55来源:作者: 一、FTP角色安装 1、系统环境:windowsserver 2008 R2 正在上传…重新上传取消 2、在新的服务器系统中,打开...
  • CentOS下6.5 FTP 文件服务器搭建

    千次阅读 2016-07-04 08:54:24
    CentOS下6.5 FTP 文件服务器搭建 1.在root权限下,通过如下命令安装Vsftp(以centos 系统为例)。 # yum install vsftpd 2. 在启动vsftpd服务之前,需要登录云服务器修改配置文件,将匿名登录禁用掉。打开...
  • 公司原来有个ftp文件服务器,用来存平时共用的一些数据文档。然后有很多数据报表的excel文件中,单元格是直接引用这个文件服务器上的。 现在文件服务器要换地址,想问下这个事情可以如何解决呢?
  • 搭建ftp文件服务器

    千次阅读 2017-11-12 19:19:38
    一搭建ftp服务器: (一) 切换到root用户:su root centos开桥接模式。输入密码:xxxxx (二):修改/etc/vsftpd/vsftpd.conf文件下的属性(三):YES/NO 分别表示允许或是不允许匿名访问(四) : 添加用户与设置密码,登陆...
  • FTP 文件服务器 批量删除文件

    千次阅读 2019-06-20 20:32:21
    本文是从OneNote迁移过来的,所以是图片为主
  • centos7部署ftp文件服务器

    千次阅读 2017-11-20 22:16:56
    FTP服务器(File Transfer Protocol Server)是在互联网上提供文件存储和访问服务的计算机,它们依照FTP协议提供服务。 FTP是File Transfer Protocol(文件传输协议)。
  • CentOS 7 安装 FTP文件服务器

    千次阅读 2018-07-23 16:21:36
    1. 搭建FTP服务器 登录Linux,输入yum -y install vsftpd,安装vsftpd软件 显示如下,即代表安装完成 配置vsftpd 输入vi /etc/vsftpd/vsftpd.conf,修改配置文件 anonymous_enable=YES改为NO,禁止匿名...
  • 说明:在CentOs虚拟机下进行网络配置和vsftpd的ftp文件服务器配置前言:最近需要在CentOs虚拟机下搭建文件服务器进行文件管理,但是在配置vsftpd服务的时候出现了很多坑,特别在此记录下从CentOs安装完成—>网络配置...
  • springboot 将文件上传到ftp文件服务器

    千次阅读 2020-03-12 21:56:18
    到这里就完成了从前端到tomcat的文件传输过程 文件从tomcat到ftp服务器的传输 首先我让自己的电脑变成ftp服务器: 这样的话浏览器输入,ftp:我的ip 就可访问到这个共享目录文件夹 可以从cmd命令ipconfig看到主机ip...
  • 通过nginx实现http访问ftp文件服务器

    千次阅读 2019-05-20 17:36:20
    1.ftp服务器搭建参考博客https://blog.csdn.net/weixin_42424359/article/details/90232929 2.Nginx搭建参考博客https://www.cnblogs.com/wanghuaijun/p/5480554.html 具体实现: 1.进入nginx配置文件下 2.配置nginx...
  • XP搭建FTP文件服务器

    千次阅读 2017-03-17 16:57:05
    第一步 ... ...点击确认,下一步,出现下面界面,说明你已经成功安装了Windows向导,这个阶段可能需要你选择安装i386的...,然后就可以看见你的E盘下面的文件啦 成功搭建,Win7下面类似 github地址
  • ftp文件服务器与web项目结合

    千次阅读 2016-06-14 18:42:51
    首先搭建FTP服务器,以C:/ftp/public为FPT上传图片、文件等路径 安装tomcat,并在tomcat的conf/Catalina/localhost目录下配置项目路径新建一个xml文件,命名随性,例如public.xml 内容如下:  privileged=...
  • 教研室 ftp 文件服务器使用教程

    千次阅读 2016-01-29 21:00:05
    一 网页下载模式 二 Window 客户端 ... 网页下载模式在浏览器上键入以下网址即可ftp://10.6.3.43然后单击选择你想要进入的目录,并下载你所需的软件即可,就是不能参加新目录和上传新文件。下载压缩包 FileZil
  • 项目需要做文件的上传下载,由后台定时生成word,pdf文件上传到ftp服务器,然后供客户端下载。聊聊其中遇到的坑 在文件上传的时候,遇到坑之一,编码问题,因为ftp编码是iso-8859-1,所以在上传的时候必须进行转码...
  •  1、设计:使用多线程并发的TCP传输模式,实现客户端获取文件列表、上传文件、下载文件。  2、计划实施:今天完成项目  3、文档确认  使用方法:命令行方法获取文件目录、文件上传、文档下载  代码架构:  ...
  • Serv-U FTP文件服务器端口映射

    千次阅读 2015-07-30 12:04:32
    映口映射的功能主要就是实际互联网可以访问当前进行映射的电脑,首先我们要进行路由器的端口映射,常见的开放端口有80,21,3389等,80是网站常用端口,21是FTP服务器常用端口,3389是远程桌面连接端口。下面为大家...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,608
精华内容 11,443
关键字:

ftp文件服务器