java 生成文字图片并ftp上传

直接上代码吧

package imgtest.src;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.imageio.ImageIO;
import javax.imageio.stream.ImageOutputStream;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

class FTPUtil {	
	public static FTPClient ftpClient = null;
	static BufferedImage image = null;
	
	public static void connect2Server(String url,int port, String userid, String passwd) {
        ftpClient = new FTPClient();
        ftpClient.setControlEncoding("utf-8");
        try {
            ftpClient.connect(url, port); //连接ftp服务器
            ftpClient.login(userid, passwd); //登录ftp服务器
            int replyCode = ftpClient.getReplyCode(); //是否成功登录服务器
            if(!FTPReply.isPositiveCompletion(replyCode)){
            	System.out.println("connect failed...ftp服务器:"+url); 
            }
            System.out.println("connect successfu...ftp服务器:"+url); 
        }catch (MalformedURLException e) { 
        	e.printStackTrace();
        }catch (IOException e) { 
        	e.printStackTrace();
        } 
    }
	
	public static void closeConnect() { 
        try {
            if (ftpClient != null) {
                ftpClient.logout();
                ftpClient.disconnect();
            }
        } catch (Exception e) {
        	e.printStackTrace();;
        }
 
    }

    /**
    * 上传文件
    * @param pathname ftp服务保存地址
    * @param fileName 上传到ftp的文件名
    *  @param originfilename 待上传文件的名称（绝对地址） * 
    * @return
    */
    public static boolean uploadFile( String pathname, String fileName,String originfilename){
        boolean flag = false;
        InputStream inputStream = null;
        try{
            inputStream = new FileInputStream(new File(originfilename));
            ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);
            CreateDirecroty(pathname);
            ftpClient.makeDirectory(pathname);
            ftpClient.changeWorkingDirectory(pathname);
            ftpClient.storeFile(fileName, inputStream);
            inputStream.close();
            ftpClient.logout();
            flag = true;
        }catch (Exception e) {
        	e.printStackTrace();
        }finally{
            if(ftpClient.isConnected()){ 
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                	e.printStackTrace();
                }
            } 
            if(null != inputStream){
                try {
                    inputStream.close();
                } catch (IOException e) {
                	e.printStackTrace();
                } 
            } 
        }
        return true;
    }
    /**
     * 上传文件
     * @param pathname ftp服务保存地址
     * @param fileName 上传到ftp的文件名
     * @param inputStream 输入文件流 
     * @return
     */
    public static boolean uploadFile( String pathname, String fileName,InputStream inputStream){
        boolean flag = false;
        try{
            System.out.println("开始上传文件");
            ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);
            CreateDirecroty(pathname);
            boolean ret = ftpClient.makeDirectory(pathname);
            System.out.println("ret:"+ret);
            ftpClient.changeWorkingDirectory(pathname);
            ftpClient.storeFile(fileName, inputStream);
            inputStream.close();
            ftpClient.logout();
            flag = true;
            System.out.println("上传文件成功");
        }catch (Exception e) {
            System.out.println("上传文件失败");
            e.printStackTrace();
        }finally{
            if(ftpClient.isConnected()){ 
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                    e.printStackTrace();
                }
            } 
            if(null != inputStream){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } 
            } 
        }
        return true;
    }
    //改变目录路径
     public static boolean changeWorkingDirectory(String directory) {
            boolean flag = true;
            try {
                flag = ftpClient.changeWorkingDirectory(directory);
                int returnCode = ftpClient.getReplyCode();
                System.out.println("cwd1:"+returnCode);
                int ret = ftpClient.cwd(directory);

                System.out.println("cwd:"+ret);
                FTPFile file = ftpClient.mdtmFile(directory);
                if (file != null) {
                	System.out.println("is valid:"+file.isValid());
                    System.out.println("is dir:"+file.isDirectory());
                } else {
                	System.out.println("is null");
                }
                
                if (flag) {
                	System.out.println("进入文件夹" + directory + " 成功！");
                } else {
                	System.out.println("进入文件夹" + directory + " 失败！开始创建文件夹");
                }
            } catch (IOException ioe) {
            	ioe.printStackTrace();
            }
            return flag;
        }

    //创建多层目录文件，如果有ftp服务器已存在该文件，则不创建，如果无，则创建
    public static boolean CreateDirecroty(String remote) throws IOException {
        boolean success = true;
        String directory = remote + "/";
        // 如果远程目录不存在，则递归创建远程服务器目录
        if (true) {//!directory.equalsIgnoreCase("/") && !changeWorkingDirectory(new String(directory))) {
            int start = 0;
            int end = 0;
            if (directory.startsWith("/")) {
                start = 1;
            } else {
                start = 0;
            }
            end = directory.indexOf("/", start);
            String path = "";
            String paths = "";
            while (true) {
                String subDirectory = new String(remote.substring(start, end).getBytes("GBK"), "iso-8859-1");
                path = path + "/" + subDirectory;
                
                if (!existFile(path)) {
                    if (makeDirectory(subDirectory)) {
                        changeWorkingDirectory(subDirectory);
                    } else {
                    	System.out.println("创建目录[" + subDirectory + "]失败");
                        changeWorkingDirectory(subDirectory);
                    }
                } else {
                    changeWorkingDirectory(subDirectory);
                }

                paths = paths + "/" + subDirectory;
                start = end + 1;
                end = directory.indexOf("/", start);
                // 检查所有目录是否创建完毕
                if (end <= start) {
                    break;
                }
            }
        }
        return success;
    }

  //判断ftp服务器文件是否存在    
    public static boolean existFile(String path) throws IOException {
            boolean flag = false;
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);
            if (ftpFileArr.length > 0) {
                flag = true;
            }
            return flag;
        }
    //创建目录
    public static boolean makeDirectory(String dir) {
        boolean flag = true;
        try {
            flag = ftpClient.makeDirectory(dir);
            if (flag) {
            	System.out.println("创建文件夹" + dir + " 成功！");
            } else {
            	System.out.println("创建文件夹" + dir + " 失败！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
    
    /** * 下载文件 * 
    * @param pathname FTP服务器文件目录 * 
    * @param filename 文件名称 * 
    * @param localpath 下载后的文件路径 * 
    * @return */
    public  static boolean downloadFile(String pathname, String filename, String localpath){ 
        boolean flag = false; 
        OutputStream os=null;
        try { 
            //切换FTP目录 
            ftpClient.changeWorkingDirectory(pathname); 
            FTPFile[] ftpFiles = ftpClient.listFiles(); 
            for(FTPFile file : ftpFiles){ 
                if(filename.equalsIgnoreCase(file.getName())){ 
                    File localFile = new File(localpath + "/" + file.getName()); 
                    os = new FileOutputStream(localFile); 
                    ftpClient.retrieveFile(file.getName(), os); 
                    os.close(); 
                } 
            } 
            ftpClient.logout(); 
            flag = true; 
        } catch (Exception e) { 
        	e.printStackTrace();
        } finally{ 
            if(ftpClient.isConnected()){ 
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                	e.printStackTrace();
                }
            } 
            if(null != os){
                try {
                    os.close();
                } catch (IOException e) {
                	e.printStackTrace();
                } 
            } 
        } 
        return flag; 
    }
    
    /** * 删除文件 * 
    * @param pathname FTP服务器保存目录 * 
    * @param filename 要删除的文件名称 * 
    * @return */ 
    public boolean deleteFile(String pathname, String filename){ 
        boolean flag = false; 
        try { 
            //切换FTP目录 
            ftpClient.changeWorkingDirectory(pathname); 
            ftpClient.dele(filename); 
            ftpClient.logout();
            flag = true; 
        } catch (Exception e) { 
        	e.printStackTrace();
        } finally {
            if(ftpClient.isConnected()){ 
                try{
                    ftpClient.disconnect();
                }catch(IOException e){
                	e.printStackTrace();
                }
            } 
        }
        return flag; 
    }
    
    public static void generateimage(String vehicle, String channels, String errors) {
    	image = new BufferedImage(300, 200, BufferedImage.TYPE_INT_RGB);
        //设置图片的背景色
        Graphics2D main = image.createGraphics();
        main.setColor(Color.blue);
        main.fillRect(0, 0, 300, 200);
         
        //设置字体颜色，先设置颜色，再填充内容
        main.setColor(Color.white);
        //设置字体
        Font titleFont = new Font("宋体", Font.BOLD, 14);
        main.setFont(titleFont);
        
        //时间
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        main.drawString(sdf.format(date), 5, 15);
        //车号
        main.drawString("vehicle:"+vehicle, 5, 35);
        //通道
        main.drawString("channels:" + channels, 5, 55);
        //错误
        main.drawString("错误:"+ errors, 5, 75);
        
        
        try {
			ImageIO.write(image,"jpg",new File("d:/gray11.jpg"));
		} catch (IOException e) {
			e.printStackTrace();
		} 
    }
    
    public static void main(String[] args) {
    	generateimage("鲁A12345D", "1,2,3,5,31","未知异常");
    	connect2Server("192.168.31.115", 21, "root", "root");
    	ByteArrayOutputStream bs = new ByteArrayOutputStream();
    	ImageOutputStream imOut;
		try {
			imOut = ImageIO.createImageOutputStream(bs);
			ImageIO.write(image, "jpg", imOut);
		} catch (IOException e) {
			e.printStackTrace();
		}
    	
    	InputStream is = new ByteArrayInputStream(bs.toByteArray());
    	uploadFile("/pic/test", "abc.jpg", is);
    }
}

代码不复杂，只是有几个要注意的地方

1. ftp 检测多级目录是否存在，使用changeWorkingDirectory是不可靠的，因为我手头就有一个ftp，哪怕目录不存在，

改变工作目录也是成功的，cwd函数也一样

2. 使用mdtmFile来检测目录是否存在也不可靠，因为部分ftp是不支持mdtm特性的

3. 找了一个笨办法，就是CreateDirecroty中用的方法

4. ftp上传严重依赖网络，因此最好多试几次，连接也可以多试几次，ftp操作最好在线程中运行，减少主线程资源占用

5. 如果ftp一直上传文件失败，检测一下文件名是否有中文，如果是中文的话，可能是编码的问题，如果不是中文，可能是ftp服务器主动被动模式问题，在stroefile之前添加

ftpClient.enterLocalPassiveMode();