ssm实战（4，5）------分类管理，商品管理

package com.eshop.service.impl;

import com.eshop.service.IFileService;
import com.eshop.util.FTPUtil;
import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;
@Service("iFileService")
public class FileServiceImpl implements IFileService {
    private static Logger logger= LoggerFactory.getLogger(FileServiceImpl.class);

    @Override
    public String upload (MultipartFile file, String path){
        //文件名
        String fileName=file.getOriginalFilename();
        //扩展名  abc.jpg ----> jpg
        String fileExtensionName=fileName.substring(fileName.lastIndexOf(".")+1);
        //要上传的文件名
        String uploadFileName= UUID.randomUUID().toString()+"."+fileExtensionName;
        logger.info("开始上传文件,上传的文件夹名：{}，上传路径：{}，新文件夹名：{}",fileName,path,uploadFileName);
        //判断有没有该文件夹，没有就创建
        File fileDir=new File(path);
        if(!fileDir.exists()){
            //创建文件夹前，要打开 可写的权限 ，防止tomcat没有开权限
            fileDir.setWritable(true);
            fileDir.mkdirs();
        }
        //创建一个完全的文件
        File targetFile=new File(path,uploadFileName);
        try {
            file.transferTo(targetFile);
            //文件上传已完成

            //将targetFile上传到FTP服务器上面
            FTPUtil.uploadFile(Lists.newArrayList(targetFile));
            //上传完后，把targetFile删除
            targetFile.delete();
        } catch (IOException e) {
            logger.error("上传文件异常",e);
            return null;
        }
        return targetFile.getName();
    }
}

package com.eshop.util;

import org.apache.commons.net.ftp.FTPClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;

public class FTPUtil {
    private static Logger logger= LoggerFactory.getLogger(FTPUtil.class);
    private static String ftpIp =PropertiesUtil.getProperty("ftp.server.ip");
    private static String ftpUser =PropertiesUtil.getProperty("ftp.user");
    private static String ftpPass =PropertiesUtil.getProperty("ftp.pass");

    private String ip;
    private int port;
    private String user;
    private String pwd;
    private FTPClient ftpClient;

    /**
     *
     * @param ip
     * @param port 端口
     * @param user
     * @param pwd
     */
    public FTPUtil(String ip, int port, String user, String pwd) {
        this.ip = ip;
        this.port = port;
        this.user = user;
        this.pwd = pwd;
    }

    /**
     * 开发出去的上传文件的静态方法
     * @param fileList
     * @return
     */
    public static boolean uploadFile(List<File> fileList) throws IOException {
        FTPUtil ftpUtil=new FTPUtil(ftpIp,21,ftpUser,ftpPass);
        logger.info("开始连接FTP服务器");
        boolean result= ftpUtil.uploadFile("img",fileList);
        logger.info("连接服务器结束，上传结果为：{}",result);
        return result;
    }

    /**
     * 上传文件的具体逻辑
     * @param remotePath 远程路径：Linux里边的FTP服务器是一个文件夹，如果要上传的是到这个文件夹下边的文件夹，就要使用remotePath
     * @param fileList
     * @return
     */
    private boolean uploadFile(String  remotePath, List<File> fileList) throws IOException {
        boolean uploaded=true;
        FileInputStream fis=null;
        //连接ftp服务器
        if(connectServer(this.ip,this.port,this.user,this.pwd)){
            try {
                //切换工作目录
                ftpClient.changeWorkingDirectory(remotePath);
                //设置缓冲区
                ftpClient.setBufferSize(1024);
                //设置编码方式
                ftpClient.setControlEncoding("UTP-8");
                //文件类型设置为二进制的文件类型
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                //切换工作模式
                ftpClient.enterLocalPassiveMode();
                /* 开始上传文件到ftp ！！！*/
                for(File fileItem:fileList){
                    fis=new FileInputStream(fileItem);
                    ftpClient.storeFile(fileItem.getName(),fis);
                }
            } catch (IOException e) {
                logger.error("上传文件异常",e);
                uploaded=false;
            }finally {
                //关闭资源
                fis.close();
                ftpClient.disconnect();
            }
        }
        return uploaded;
    }

    private boolean connectServer(String ip, int port, String user, String pwd){
        boolean isSuccess=false;
        ftpClient=new FTPClient();
        try {
            ftpClient.connect(ip,port);
            isSuccess=ftpClient.login(user,pwd);
        } catch (IOException e) {
            logger.error("连接FTP服务器异常",e);
        }
        return isSuccess;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    public FTPClient getFtpClient() {
        return ftpClient;
    }

    public void setFtpClient(FTPClient ftpClient) {
        this.ftpClient = ftpClient;
    }
}

    @RequestMapping("upload.do")
    @ResponseBody
    public ServerResponce upload(HttpSession session,@RequestParam(name = "upload_name",required = false) MultipartFile file, HttpServletRequest request){
        User user=(User)session.getAttribute(Const.CURRENT_USER);
        if(user==null){
            //强制用户登录
            return ServerResponce.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(),"用户未登录,请登录");
        }
        if(iUserService.checkAdminRole(user).isSuccess()){
            //填充业务
            String path=request.getSession().getServletContext().getRealPath("upload");
            String targetFileName = iFileService.upload(file, path);
            String url= PropertiesUtil.getProperty("ftp.server.http.prefix")+targetFileName;

            Map fileMap= Maps.newHashMap();
            fileMap.put("uri",targetFileName);
            fileMap.put("url",url);
            return ServerResponce.createBySuccess(fileMap);
        }else {
            return ServerResponce.createByErrorMessage("无权限操作");
        }
    }

package com.eshop.util;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;

public class PropertiesUtil {
    private static Logger logger= LoggerFactory.getLogger(PropertiesUtil.class);

    private static Properties properties;
    /*静态代码块（只执行一次） 优于 普通代码块 优于 构造代码块*/
    static {
        String fileName="eshop.properties";
        properties=new Properties();
        try {
            properties.load(new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName),"UTF-8"));
        } catch (IOException e) {
            logger.error("配置文件读取异常",e);
        }
    }

    /**
     * 得到配置文件里边的值
     * @param key
     * @return
     */
    public static String getProperty(String key){
        //避免key左右有空格，trim（）去掉空格
        String value=properties.getProperty(key.trim());
        if(StringUtils.isBlank(value)){
            return null;
        }
        return value.trim();
    }

    public static String getProperty(String key,String defaultVaule){
        //避免key左右有空格，trim（）去掉空格
        String value=properties.getProperty(key.trim());
        if(StringUtils.isBlank(value)){
            return defaultVaule;
        }
        return value.trim();
    }
}

package com.eshop.util;

import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.Date;

public class DateTimeUtil {
    //使用joda-time对时间进行处理
    //1.string --> date    2.date --> string
    private static String STANDARD_FORMAT="yyyy-MM-dd HH:mm:ss";
    /**
     * 字符串装换时间格式,传入一个事件格式
     * @param dateTimeStr
     * @param formatStr 事件格式
     * @return
     */
    public static Date strToDate(String dateTimeStr,String formatStr){
        DateTimeFormatter dateTimeFormatter= DateTimeFormat.forPattern(formatStr);
        DateTime dateTime=dateTimeFormatter.parseDateTime(dateTimeStr);
        return dateTime.toDate();
    }

    public static String dateToStr(Date date,String formatStr){
        if(date==null){
            return StringUtils.EMPTY;
        }
        DateTime dateTime=new DateTime(date);
        return dateTime.toString(formatStr);
    }

    /**
     * 字符串装换时间格式,默认事件格式
     * @param dateTimeStr
     * @return
     */
    public static Date strToDate(String dateTimeStr){
        DateTimeFormatter dateTimeFormatter= DateTimeFormat.forPattern(STANDARD_FORMAT);
        DateTime dateTime=dateTimeFormatter.parseDateTime(dateTimeStr);
        return dateTime.toDate();
    }

    public static String dateToStr(Date date){
        if(date==null){
            return StringUtils.EMPTY;
        }
        DateTime dateTime=new DateTime(date);
        return dateTime.toString(STANDARD_FORMAT);
    }
}