1.ftp工具类：
/*
* Copyright 2008 Digital Video Networks (Beijing) Co., Ltd. All rights reserved.
*/
package com.dvnchina.itv.advert.utils.ftp;
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.URL;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import org.apache.commons.lang.StringUtils;
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 org.apache.log4j.Logger;
import com.dvnchina.itv.advert.utils.config.ConfigureProperties;
/**
*
* <p>
* Title:FTP 工具类
* </p>
* <p>
* Description:用于上传或下载文件
* </p>
*
* @author lester
* @version 1.0
* @since 2012-03-05
*/
public class FtpUtils {
private static Logger logger = Logger.getLogger(FtpUtils.class);
private static ConfigureProperties configureProperties = ConfigureProperties
.getInstance();
// 二进制模式 此种类型在传输过程中大小不会发生变化
public static final int BINARY_FILE_TYPE = FTP.BINARY_FILE_TYPE;
// ASCII模式 此种类型在传输过程中大小会发生变化
public static final int ASCII_FILE_TYPE = FTP.ASCII_FILE_TYPE;
// 盘符分隔符
private static String SEPARATOR = System.getProperty("file.separator");
// 从配置文件中获取FTP的IP
private String ftpIp = null;
// 从配置文件中读取连接FTP超时信息
private Integer timeout = null;
// ftp用户名
private String ftpUserName = null;
// ftp密码
private String ftpPassWord = null;
// ftp端口
private Integer ftpPort = null;
// 显示执行过程开关
private String showOperationCommandKey = null;
private FTPClient ftpClient = null;
/**
* 初始化一些连接参数
*
* @author lester
*/
public FtpUtils() {
ftpClient = new FTPClient();
// 重新获取配置文件中的参数值
ftpIp = configureProperties.get("ftpIp");
ftpUserName = configureProperties.get("ftpUserName");
ftpPassWord = configureProperties.get("ftpPassWord");
try {
ftpPort = Integer.parseInt(configureProperties.get("ftpPort"));
} catch (Exception e) {
logger.error("从配置文件中获取端口时发生异常，请检查配置", e);
}
try {
timeout = Integer.parseInt(configureProperties.get("ftpTimeout")) * 1000;
} catch (Exception e) {
logger.error("从配置文件中获取超时时间时时发生异常，请检查配置", e);
}
//showOperationCommandKey = getPropertiesFromConfiguration("showOperationCommand");
if (StringUtils.isNotBlank(showOperationCommandKey)
&& showOperationCommandKey.equalsIgnoreCase("yes")) {
// 设置将过程中使用到的命令输出到控制台
/*this.ftpClient.addProtocolCommandListener(new PrintCommandListener(
new PrintWriter(System.out)));*/
}
}
/**
* 构造方法2
* @author lester
* @param ip
* @param port
* @param userName
* @param passWord
* @param timeOut
*/
public FtpUtils(String ip,int port, String userName,String passWord ,int timeOut) {
ftpClient = new FTPClient();
ftpIp = ip;
ftpUserName = userName;
ftpPassWord = passWord;
ftpPort = port;
timeout = timeOut;
}
/**
* 从配置文件中获取相应属性值，适用于参数需要经常修改的情况
*
* @param key
* 待获取属性值的key
* @author lester
*/
@SuppressWarnings("unused")
private String getPropertiesFromConfiguration(String key) {
String localConfigPath = System.getProperty("user.dir") + SEPARATOR
+ "webapp" + SEPARATOR + "WEB-INF" + SEPARATOR + "classes"
+ SEPARATOR + "configuration.properties";
File f = new File(localConfigPath);
Properties properties = null;
FileInputStream fileInputStream = null;
String returnValue = null;
if (StringUtils.isNotBlank(key)) {
try {
fileInputStream = new FileInputStream(f);
properties = new Properties();
properties.load(fileInputStream);
} catch (IOException e) {
logger.error("读取本地" + localConfigPath + "文件失败", e);
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
} catch (IOException e) {
logger.error("读取配置文件时，关闭输出流出现异常", e);
}
}
returnValue = properties.getProperty(key);
} else {
logger.info("传入的参数为空");
}
return returnValue;
}
/**
* 替换路径头尾特殊字符以及分隔符处理
*
* @param path
* @author lester
*/
public String getRegularPath(String path) {
int length;
if (StringUtils.isNotBlank(path)) {
length = path.length();
if (length <= 0)
return path;
char ch = path.charAt(0);
while (ch == '/' || ch == '\\') {
try {
path = path.substring(1, length);
} catch (Exception e) {
logger.error("字符串截取时发生异常", e);
return path;
}
length = path.length();
if (length <= 0)
return path;
try {
ch = path.charAt(0);
} catch (Exception e) {
logger.error("字符串截取时发生异常", e);
return path;
}
}
try {
ch = path.charAt(length - 1);
} catch (Exception e) {
logger.error("字符串截取时发生异常", e);
}
while (ch == '/' || ch == '\\') {
length = path.length();
if (length <= 0) {
return path;
}
try {
path = path.substring(0, length - 1);
ch = path.charAt(length - 2);
} catch (Exception e) {
logger.error("字符串截取时发生异常", e);
return path;
}
}
if (path.contains("\\")) {
path = path.replace("\\", "/");
}
path = path.replaceAll("//", "/");
path = path.replaceAll("///", "/");
path = path.replaceAll("////", "/");
path = path.replaceAll("/////", "/");
}
return path;
}
/**
* 创建FTP连接，创建连接相关参数从配置文件中获取
*
* @author lester
*/
public boolean connectionFtp() {
boolean flag = true;
int reply;
try {
ftpClient.setControlEncoding("GBK");
ftpClient.connect(ftpIp);
ftpClient.login(ftpUserName, ftpPassWord);
ftpClient.setDefaultPort(ftpPort);
ftpClient.setBufferSize(1024);
ftpClient.setFileType(FtpUtils.BINARY_FILE_TYPE);
ftpClient.setDataTimeout(timeout);
reply = ftpClient.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftpClient.disconnect();
flag = false;
logger.warn("FTP 服务拒绝连接");
}
// 设置被动模式
ftpClient.enterLocalPassiveMode();
} catch (Exception e) {
flag = false;
// logger.error("连接FTP时出现异常", e);
logger.info("连接FTP时出现异常,请检查ftp的连接配置");
}
return flag;
}
/**
* 创建FTP连接
*
* @param ftpIp
* FTP ip地址
* @param port
* FTP 端口号
* @param username
* FTP 用户名
* @param password
* FTP 密码
* @param timeout
* FTP 超时时间 单位秒
* @return true- 成功 false-失败
*/
public boolean connectionFtp(String ftpIp, int port, String username,
String password, Integer timeout) {
boolean flag = false;
this.ftpIp = ftpIp;
this.ftpPort = port;
this.ftpUserName = username;
this.ftpPassWord = password;
this.timeout = timeout;
flag = connectionFtp();
if (flag) {
logger.info("FTP连接成功");
} else {
logger.info("FTP连接失败");
}
return flag;
}
/**
* 关闭FTP连接
* @author lester
*/
public void closedFtp() {
if (ftpClient != null && ftpClient.isConnected()) {
try {
ftpClient.logout();
ftpClient.disconnect();
} catch (IOException e) {
logger.error("关闭FTP连接时出现异常", e);
}
}
}
/**
* 进入到服务器的某个目录下
* @param directory
* @author lester
*/
public boolean changeWorkingDirectory(String directory) {
boolean flag = false;
try {
flag = ftpClient.changeWorkingDirectory(directory);
} catch (IOException e) {
logger.error("切换目录失败", e);
}
return flag;
}
/**
* 创建或者切换目录
* @param ftpDirectory
* 远程ftp路径
* @author lester
*/
public boolean changeAndCreateWorkingDirectory(String ftpDirectory) {
String[] remoteDirectory = null;
boolean createFlag = false;
boolean channelFlag = false;
if (StringUtils.isNotBlank(ftpDirectory)) {
ftpDirectory = getRegularPath(ftpDirectory);
if (ftpDirectory.contains("/")) {
remoteDirectory = ftpDirectory.split("/");
}
try {
if (!ftpClient.changeWorkingDirectory(ftpDirectory)) {
if (remoteDirectory != null) {
for (int i = 0; i < remoteDirectory.length; i++) {
if (!ftpClient
.changeWorkingDirectory(remoteDirectory[i])) {
createFlag = ftpClient
.makeDirectory(remoteDirectory[i]);
channelFlag = ftpClient
.changeWorkingDirectory(remoteDirectory[i]);
}
}
} else {
createFlag = ftpClient.makeDirectory(ftpDirectory);
channelFlag = ftpClient
.changeWorkingDirectory(ftpDirectory);
}
if (createFlag) {
logger.warn("创建目录" + ftpDirectory + "成功");
} else {
logger.warn("创建目录" + ftpDirectory + "失败");
}
} else {
channelFlag = true;
}
} catch (Exception e) {
logger.error("创建或者切换目录" + ftpDirectory + "失败", e);
}
} else {
logger.info("所传入的ftp路径为空");
}
return channelFlag;
}
/**
* 上传单个文件
* @param localFilePath
* 待上传本地文件
* @param remoteDirectoryPath
* 远程目录
* @param remoteFileName
* 上传后的文件名称 若没有则取原有文件名称
* @author lester
*/
public boolean uploadSimpleFile(String localFilePath,
String remoteDirectoryPath, String remoteFileName) {
@SuppressWarnings("unused")
Integer flag = null;
File localFile = null;
FileInputStream fis = null;
boolean uploadFlag = false;
boolean renameFlag = false;
String localFileName = null;
// 1、检查传入参数是否为空
if (StringUtils.isNotBlank(localFilePath)) {
localFile = new File(localFilePath);
if (localFile.isFile()) {
try {
localFileName = localFile.getName();
fis = new FileInputStream(localFile);
if (StringUtils.isNotBlank(remoteDirectoryPath)) {
remoteDirectoryPath = getRegularPath(remoteDirectoryPath);
if (!changeAndCreateWorkingDirectory(remoteDirectoryPath)) {
logger.warn("创建或者切换目录失败，请检查ftp用户访问权限");
}
} else {
logger.info("远程目录为空，文件将被传到用户宿主目中");
}
if (StringUtils.isNotBlank(remoteFileName)) {
uploadFlag = ftpClient.storeFile(remoteFileName
+ ".bak", fis);
if (uploadFlag) {
logger.info(remoteFileName + ".bak文件上传成功");
renameFlag = ftpClient.rename(remoteFileName
+ ".bak", remoteFileName);
if (renameFlag) {
logger.info(remoteFileName + "文件重命名成功");
}
}
} else {
uploadFlag = ftpClient.storeFile(
localFileName + ".bak", fis);
if (uploadFlag) {
renameFlag = ftpClient.rename(localFileName
+ ".bak", localFileName);
if (renameFlag) {
logger.info(localFileName + "文件重命名成功");
}
}
}
ftpClient.changeWorkingDirectory("~/");
} catch (Exception e) {
logger.error("读取本地文件失败！", e);
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
logger.error("读取本地文件后，关闭IO时发生异常", e);
}
}
}
} else {
logger.info("传入不合法的本地文件地址");
}
} else {
logger.info("传入的本地文件地址为空");
}
return renameFlag;
}
/**
* 上传远程http文件到ftp指定目录中
* @param remoteFileLinkPath 远程文件链接
* @param remoteDirectory 远程FTP目录
* @author lester
*/
public boolean uploadHttpFile(String remoteFileLinkPath,
String remoteDirectory) {
String fileName = null;
URL url = null;
InputStream inputStream = null;
boolean flag = false;
if (StringUtils.isNotBlank(remoteFileLinkPath)
&& (remoteFileLinkPath.startsWith("http://") || remoteFileLinkPath
.startsWith("HTTP://"))) {
try {
url = new URL(remoteFileLinkPath);
inputStream = url.openStream();
} catch (Exception e) {
logger.error("从" + remoteFileLinkPath + "读取文件失败", e);
}
fileName = remoteFileLinkPath.substring(remoteFileLinkPath
.lastIndexOf("/") + 1);
if (StringUtils.isNotBlank(remoteDirectory)) {
remoteDirectory = getRegularPath(remoteDirectory);
if (!changeAndCreateWorkingDirectory(remoteDirectory)) {
logger.info("创建或者切换目录" + remoteDirectory
+ "失败，请检查ftp用户访问权限");
}
} else {
logger.info("远程目录为空，文件将被传到用户宿主目中");
}
if (inputStream != null) {
try {
flag = ftpClient.storeFile(fileName + ".bak", inputStream);
flag = ftpClient.rename(fileName + ".bak", fileName);
} catch (Exception e) {
flag = false;
logger.error("上传文件失败", e);
}
} else {
logger.info("从连接地址" + remoteFileLinkPath + "获取的输入流为空，文件将不予上传");
}
} else {
logger.info("传入的" + remoteFileLinkPath + "地址有误，将不予上传");
}
return flag;
}
/**
* 上传单个文件夹
*
* @param localDirectoryPath
* 本地文件夹地址
* @param localDirectoryRootPath
* 本地文件夹的主参考地址
* @param remoteFilePath 文件要存放的远程FTP路径
* @author lester
*/
public void uploadSimpleFolder(String localDirectoryPath,
String localDirectoryRootPath, String remoteFilePath) {
logger.debug("uploadSimpleFolder");
File localDirectoryPathFile = null;
String remoteFilePathBackup = null;
String localFilePath = null;
File[] localDirectorylistFile = null;
if (StringUtils.isNotBlank(localDirectoryPath)
&& StringUtils.isNotBlank(localDirectoryRootPath)) {
remoteFilePathBackup = remoteFilePath;
localDirectoryPathFile = new File(localDirectoryPath);
if (localDirectoryPath.contains(localDirectoryRootPath)) {
localDirectorylistFile = localDirectoryPathFile.listFiles();
if (localDirectorylistFile != null
&& localDirectorylistFile.length > 0) {
for (int i = 0; i < localDirectorylistFile.length; i++) {
if (localDirectorylistFile[i].isDirectory()) {
uploadSimpleFolder(localDirectorylistFile[i]
.getAbsolutePath(), localDirectoryRootPath,
remoteFilePath);
} else {
localFilePath = localDirectorylistFile[i]
.getAbsolutePath();
remoteFilePathBackup = localDirectorylistFile[i]
.getAbsolutePath();
remoteFilePathBackup = remoteFilePathBackup
.substring(remoteFilePathBackup
.indexOf(localDirectoryRootPath)
+ localDirectoryRootPath.length()
+ 1);
remoteFilePathBackup = getRegularPath(remoteFilePathBackup);
remoteFilePathBackup = remoteFilePathBackup
.substring(0, remoteFilePathBackup
.lastIndexOf("/"));
remoteFilePathBackup = remoteFilePath + "/"
+ getRegularPath(remoteFilePathBackup);
uploadSimpleFile(localFilePath,
remoteFilePathBackup,
localDirectorylistFile[i].getName());
}
}
}
} else {
logger.info("所给文件夹路径有误或为文件路径");
}
} else {
logger.info("所需【上传本地文件夹地址】或【本地文件夹的主参考地址】为空");
}
logger.debug("uploadSimpleFolder");
}
/**
* 删除一个FTP服务器上的目录（如果为空）
*
* @param path
* 目录路径
* @author lester
*/
public boolean removeDirectory(String path) {
boolean flag = false;
if (ftpClient == null) {
connectionFtp();
}
try {
flag = ftpClient.removeDirectory(path);
} catch (Exception e) {
logger.error("删除目录时出现异常，具体目录路径为：" + path, e);
}
return flag;
}
/**
* 删除一个FTP服务器上的目录
* @param path
* 目录路径
* @param isAll
* 是否递归删除所有子目录和文件 true 递归 false 不递归
* @author lester
*/
public boolean removeDirectory(String path, boolean isAll) {
// 遍历子目录和文件
FTPFile[] ftpFileArr = null;
if (StringUtils.isNotBlank(path)) {
logger.info("递归参数为true，将递归删除文件夹中内容");
path = getRegularPath(path);
if (!isAll) {
return removeDirectory(path);
}
try {
ftpFileArr = ftpClient.listFiles(path);
} catch (Exception e) {
logger.error("获取路径下文件列表时出现异常，具体路径为:" + path, e);
}
if (ftpFileArr == null || ftpFileArr.length == 0) {
return removeDirectory(path);
}
for (int i = 0; i < ftpFileArr.length; i++) {
FTPFile ftpFile = ftpFileArr[i];
if (ftpFile != null) {
String name = ftpFile.getName();
if (ftpFile.isDirectory() && !".".equals(name)
&& !"..".equals(name)) {
removeDirectory(path + "/" + name, true);
} else if (ftpFile.isFile() && !".".equals(name)
&& !"..".equals(name)) {
deleteFile(path + "/" + name);
} else if (ftpFile.isSymbolicLink()) {
} else if (ftpFile.isUnknown()) {
}
}
}
} else {
logger.info("传入的待删除路径为空！");
}
return removeDirectory(path);
}
/**
* 删除一个文件
* @param filename 待删除的文件名称
* @author lester
*/
public boolean deleteFile(String filename) {
boolean flag = true;
try {
flag = ftpClient.deleteFile(filename);
if (flag) {
logger.info("删除文件成功！");
} else {
logger.info("删除文件失败！");
}
} catch (IOException ioe) {
logger.error("", ioe);
}
return flag;
}
/**
* 返回远程FTP给定目录下的文件列表--所有的
* @param path FTP 文件目录
* @param resultList 文件夹树下的所有叶子（文件）
* @author lester
* @return
*/
public List<String> getFileList(String path, List<String> resultList) {
FTPFile[] ftpFiles = null;
List<String> list = null;
try {
if (StringUtils.isNotBlank(path)) {
path = getRegularPath(path);
logger.info("上传到FTP服务的目录：###"+path);
if (changeWorkingDirectory(path)) {
ftpFiles = ftpClient.listFiles();
if (resultList == null) {
list = new LinkedList<String>();
}
if (ftpFiles == null || ftpFiles.length == 0) {
return resultList;
}
for (int i = 0; i < ftpFiles.length; i++) {
FTPFile ftpFile = ftpFiles[i];
if (ftpFile != null && ftpFile.isFile()
&& !".".equals(ftpFile.getName())
&& !"..".equals(ftpFile.getName())) {
if (resultList!=null) {
resultList.add(ftpFile.getName());
}else{
list.add(ftpFile.getName());
}
} else if (ftpFile != null && ftpFile.isDirectory()
&& !".".equals(ftpFile.getName())
&& !"..".equals(ftpFile.getName())) {
changeWorkingDirectory("~/");
if (resultList!=null) {
getFileList(path + SEPARATOR
+ ftpFile.getName(), resultList);
}else{
getFileList(path + SEPARATOR
+ ftpFile.getName(), list);
}
}
}
} else {
logger.info("切换目录失败，请检查路径");
}
} else {
logger.info("所查询的条件为空，将不予查询");
}
} catch (Exception e) {
logger.error("获取路径" + path + "时出现异常！", e);
}
return list;
}
/**
* 下载文件至本地目录中
* @param remoteFileName
* 远程文件名
* @param localFileName
* 本地文件名
* @param remoteDirectory 远程FTP目录
* @param localDirectory 本地目录
* @return 返回操作结果
* @author lester
*/
public boolean download(String remoteFileName, String localFileName,String remoteDirectory,String localDirectory) {
boolean flag = false;
File outfile = null;
OutputStream outputStream = null;
if (StringUtils.isNotBlank(remoteFileName)&&remoteFileName.contains(".")) {
if (StringUtils.isNotBlank(localDirectory)) {
if (StringUtils.isNotBlank(remoteDirectory)) {
remoteDirectory = getRegularPath(remoteDirectory);
if (!changeWorkingDirectory(remoteDirectory)) {
logger.info("切换远程目录失败，请检查所传路径是否正确，具体路径为"
+ remoteDirectory);
return flag;
}
} else {
logger.info("传入的远程路径为空，将在FTP宿主目录中寻找文件");
}
if (StringUtils.isNotBlank(localFileName)) {
outfile = new File(localDirectory+SEPARATOR+localFileName);
} else {
outfile = new File(localDirectory+SEPARATOR+remoteFileName);
}
try {
outputStream = new FileOutputStream(outfile);
flag = ftpClient.retrieveFile(remoteFileName, outputStream);
} catch (IOException e) {
logger.error("下载文件时出现IO异常，远程路劲为：" + remoteFileName, e);
flag = false;
} finally {
try {
if (outputStream != null) {
outputStream.close();
}
} catch (IOException e) {
logger.error("关闭输出流时出现异常！", e);
flag = false;
}
}
}else{
logger.info("传入的本地路径为空，将不予下载");
}
}else{
logger.info("远程文件名为空或者不是文件类型，将不予下载");
}
return flag;
}
public static void main(String[] args) {
FtpUtils ftpUtil = new FtpUtils();
//ftpUtil.connectionFtp();
ftpUtil.connectionFtp("127.0.0.1", 21, "cnd", "cnd", 21000);
// ftpUtil.uploadSimpleFile("E:\\小图片\\upload\\1\\1.txt",
// "1234/123213","3.txt");
// ftpUtil.uploadHttpFile("http://www.google.com.hk/images/nav_logo105.png","uploadHttpFile");
// ftpUtil.uploadHttpFile("http://www.google.com.hk/images/nav_logo105.png","");
// ftpUtil.uploadSimpleFolder("E:\\小图片\\upload\\1","E:\\小图片\\upload","uploadSimpleFolder");
// ftpUtil.deleteFile("/1/01/logo.png");
// ftpUtil.removeDirectory("test",true);
ftpUtil.removeDirectory("/test");
List<String> list = ftpUtil.getFileList("/test",null);
for (String string : list) {
System.out.println(string);
}
// ftpUtil.download("5.txt","22.txt", "start/1/2/3/4/5","J:\\");
ftpUtil.closedFtp();
}
}
2.Freemarker 模版
alert("now in adConfig.js");
var advConfig = true;
var isHD = true ;
if(System.isHDPlatform == 4 || System.isHDPlatform == 3 || System.isHDPlatform == 1 || System.isHDPlatform == false)isHD = false ;
alert("in adConfig.js System.isHDPlatform is " + System.isHDPlatform) ;
var advInfo = [
<#list channelList as channelItem >
{serviceId:${channelItem},locationVar:"locationVar_${channelItem}"}<#if channelItem_has_next>,
<#else> </#if></#list>
];
<#assign index = 0>
<#list channelList as item>
<#assign key = channelList[index]>
<#assign datas = resultMap[key]>
<#assign positionlist = datas> <#-- 通过频道的内广告位列表 -->
var locationVar_${key}=[
<#list datas as posItem>
{position:${posItem.flag?default('')},imgSrc:${posItem.materials?default('')}<#if posItem_has_next>},
<#else>}</#if>
</#list>
];
<#assign index = index+1 >
</#list>
alert("now out adConfig.js");
3.工具类还包括：FTP文件上传、Freemarker、文件操作等等工具类日期类型和String与Long之间的转换、汉字转拼音、解析xml、json字符串的转换、假分页、Freemarker模版的工具类，字符串处理等等.
真是懒得拷贝了 ，还是放到压缩包内吧。