语源科技BlogJava-sblig

跟我学Spring3 学习笔记七初始化与销毁

李凡 — Thu, 18 Oct 2012 08:45:00 GMT

最后遗留一个问题，继续探索中....

跟我学Spring3 学习笔记一

统一接口：

public interface HelloApi {
	public void sayHello();  
}

一、延迟初始化：

/**
 * 延迟初始化Bean
 *     延迟初始化也叫做惰性初始化，指不提前初始化Bean，而是只有在真正使用时才创建及初始化Bean。
 *     配置方式很简单只需在标签上指定 “lazy-init” 属性值为“true”即可延迟初始化Bean。
 */
public class DiLazyInit implements HelloApi{

	public void sayHello() {
		System.out.println("say DiInitDestory");
	}
	
	public DiLazyInit(){
		System.out.println("初始化 DiInitDestory");
	}
}

配置延迟初始化：

junit 进行测试：

@Test
	public void testLazyInit(){
		ApplicationContext context = new ClassPathXmlApplicationContext("initdepends.xml");
		HelloApi lazyInit = context.getBean("lazyinitDi",HelloApi.class);
		lazyInit.sayHello();
		System.out.println("");
	}

注意这个时候的输出结果：

初始化 DiLazyInit

say DiLazyInit

二、可以指定初始化和销毁的顺序

/* 使用depends-on 是指 指定Bean初始化及销毁时的顺序，使用depends-on属性指定的Bean要先初始化完毕
*     后才初始化当前Bean，由于只有“singleton”Bean能被Spring管理销毁，所以当指定的Bean都是“singleton”
*     时，使用depends-on属性指定的Bean要在指定的Bean之后销毁。
*     “decorator”指定了“depends-on”属性为“lazyinitDi”，所以在“decorator”Bean初始化之前要先初
*     始化“lazyinitDi”，而在销毁“lazyinitDi”之前先要销毁“decorator”，大家注意一下销毁顺序，与文档上的不符。
*     “depends-on”属性可以指定多个Bean，若指定多个Bean可以用“;”、“,”、空格分割。
*     
*  那“depends-on”有什么好处呢？
*     主要是给出明确的初始化及销毁顺序，比如要初始化“decorator”时要确保“lazyinitDi”Bean的资源准备好了，
*     否则使用“decorator”时会看不到准备的资源；而在销毁时要先在“decorator”Bean的把对“helloApi”资源的引用释
*     放掉才能销毁“lazyinitDi”，否则可能销毁 “lazyinitDi”时而“decorator”还保持着资源访问，造成资源不能释放或释放错误。
*/
public class ApiDecorator implements HelloApi{

	private HelloApi helloApi;
	
	public ApiDecorator(){
		System.out.println("初始化 ApiDecorator");
	}
	
	public void sayHello() {
		System.out.println("say ApiDecorator");
		helloApi.sayHello();
		
	}

	public HelloApi getHelloApi() {
		return helloApi;
	}

	public void setHelloApi(HelloApi helloApi) {
		this.helloApi = helloApi;
	}
}

配置xml指定初始化和销毁顺序：

junit 进行测试：

@Test
	public void testLazyInit(){
		ApplicationContext context = new ClassPathXmlApplicationContext("initdepends.xml");
		HelloApi lazyInit = context.getBean("lazyinitDi",HelloApi.class);
		lazyInit.sayHello();
		System.out.println("");
	}
	
	@Test
	public void testDependsOn(){
		ApplicationContext context= new ClassPathXmlApplicationContext("initdepends.xml");
		HelloApi depends = context.getBean("decorator",HelloApi.class);
		depends.sayHello();
	}

注意这个时候的输出结果：

初始化 DiLazyInit

初始化 ApiDecorator //也是上面同样的测试函数 testLazyInit()，同样的配置这句是多打印出来的

say DiLazyInit

初始化 DiLazyInit

初始化 ApiDecorator

say ApiDecorator

say DiLazyInit

这突然多出来的打印结果，说明进行了ApiDecorator的对象的创建，

但是在第一个配置中也没涉及到 ApiDecorator 类的加载，注入。

什么原因造成的呢？是一种隐藏的注入？继续探索中....

已有 1 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-10-18 16:45 发表评论

跟我学Spring3 学习笔记六注入

李凡 — Thu, 18 Oct 2012 06:32:00 GMT

引用其它Bean

一、构造器注入方式：

（1）通过” ”标签的ref属性来引用其他Bean

（2）通过” ”标签的子标签来引用其他Bean，使用bean属性来指定引用的Bean

二、setter注入方式：

（1）通过” ”标签的ref属性来引用其他Bean

（2）通过” ”标签的子标签来引用其他Bean，使用bean属性来指定引用的Bean

public class HelloDiBean implements HelloApi{

	private HelloApi helloApi;
	private HelloApi helloApi2;
	

	public HelloDiBean(HelloApi helloApi){
		this.helloApi = helloApi;
	}
	
	public void sayHello() {
		helloApi.sayHello();
		helloApi2.sayHello();
	}
	

	public HelloApi getHelloApi2() {
		return helloApi2;
	}

	public void setHelloApi2(HelloApi helloApi2) {
		this.helloApi2 = helloApi2;
	}
}

配置注入引用其他的bean

其他引用bean 的高级用法：

/**
 * Spring还提供了另外两种更高级的配置方式，和：
 * （1）配置方式：用于引用通过方式中通过id属性指定的Bean，
 * 		它能利用XML解析器的验证功能在读取配置文件时来验证引用的Bean是否存在。
 * 		因此如果在当前配置文件中有相互引用的Bean可以采用方式从而如果配置错误能在开发调试时就发现错误。
 * （2）配置方式：用于引用父容器中的Bean，不会引用当前容器中的Bean，
 *       当然父容器中的Bean和当前容器的Bean是可以重名的，获取顺序是直接到父容器找。
 */
public class HelloHigh implements HelloApi{
	
	private HelloApi helloApi;
	private HelloApi helloApi2;
	

	public HelloHigh(HelloApi helloApi){
		this.helloApi = helloApi;
	}
	
	public void sayHello() {
		helloApi.sayHello();
		System.out.println("");
		helloApi2.sayHello();
	}
	

	public HelloApi getHelloApi2() {
		return helloApi2;
	}

	public void setHelloApi2(HelloApi helloApi2) {
		this.helloApi2 = helloApi2;
	}

}

helloworld.xml：

helloworldParent.xml：

调用处利用加载父容器的方式，注入父容器中的Bean：

@Test
	public void testDiBeanHigh() {
		// 以classes为根目录算起
		// 读取配置文件实例化一个Ioc容器

		// 初始化父容器
		ApplicationContext parentContext = new ClassPathXmlApplicationContext(
				"helloworldParent.xml");

		// 初始化当前容器
		ApplicationContext context = new ClassPathXmlApplicationContext(
				new String[] { "helloworld.xml" }, parentContext);

		// 构造 + setter注入 引用其他的bean注入
		HelloApi helloApi = context.getBean("helloHigh", HelloApi.class);
		helloApi.sayHello();

	}

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-10-18 14:32 发表评论

JavaScript 学习笔记汇总

李凡 — Wed, 17 Oct 2012 08:14:00 GMT

已有 1 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-10-17 16:14 发表评论

动态生成class

李凡 — Tue, 16 Oct 2012 03:18:00 GMT

ASM 进行动态生成class

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

public class HelloWorld extends ClassLoader implements Opcodes{
	public static void main(String[] args) {
		ClassWriter cw = new ClassWriter(0);
		cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);
		MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null);
		mw.visitVarInsn(ALOAD, 0);
		mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V");
		mw.visitInsn(RETURN);
		mw.visitMaxs(1, 1);
		mw.visitEnd();
		
		mw = cw.visitMethod(ACC_PUBLIC+ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
		mw.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
		mw.visitLdcInsn("Hello World!");
		mw.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
		mw.visitInsn(RETURN);
		mw.visitMaxs(2, 2);
		mw.visitEnd(); 
		
		byte[] code = cw.toByteArray();
		FileOutputStream fos;
		try {
			fos = new FileOutputStream("Example.class");
			fos.write(code);
			fos.close();
			
			HelloWorld loader = new HelloWorld();   
		     Class exampleClass = loader   
		         .defineClass("Example", code, 0, code.length);  
				exampleClass.getMethods()[0].invoke(null, new Object[] { null });
				
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}

cglib 动态生成class 并进行拦截

public class MyClass {
	public void print() {
		System.out.println("I'm in MyClass.print!");
	}
}


import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class Main {

	public static void main(String[] args) {

		Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(MyClass.class);
		enhancer.setCallback((Callback) new MethodInterceptorImpl());
		MyClass my = (MyClass) enhancer.create();
		my.print();
	}

	private static class MethodInterceptorImpl implements MethodInterceptor {

		public Object intercept(Object obj, Method method, Object[] args,
				MethodProxy proxy) throws Throwable {
			// log something
			System.out.println(method + " intercepted!");

			proxy.invokeSuper(obj, args);
			return null;
		}

	}
}

已有 1 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-10-16 11:18 发表评论

FtpUtil ftp工具类过滤文件名

李凡 — Wed, 10 Oct 2012 08:26:00 GMT

工具类：

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

import sun.net.TelnetInputStream;
import sun.net.TelnetOutputStream;
import sun.net.ftp.FtpClient;
import sun.net.ftp.FtpLoginException;

public class FtpUtil {


	/**
	 * @param args
	 */
	public static void main(String[] args) {
		FtpUtil ftp = new FtpUtil();
		ftp.connect("10.16.12.75", 21, "ftpusr", "ftpusr");
		try {
			// 上传目录下文件 并可以递归到子目录
			// ftp.upPathFile(new File("D:\\ALSC"), "ALSC/");
			// 下载目录下多个文件 并可以递归到子目录
			//ftp.downPathFile("/opt/ftp/outgoing/cs/", "D:/outgoing/csvc");
			
			// 切换目录
			ftp.setPath("/opt/ftp/book");
			System.out.println(ftp.getDir());
			for (String file : ftp.getFileNameList()) {
				System.out.println(file);
			}

			// 切换到父级目录
			ftp.up();
			
			// 创建多目录
			// ftp.createDir("aa/bb/cc");
			ftp.setPath("ftpTest");
			
			// 删除文件
			ftp.deleteFile("bbb.bmp");
			System.out.println(ftp.getDir());
			for (String file : ftp.getFileNameList()) {
				System.out.println(file);
			}
			// 上传 下载单个文件
			ftp.uploadFile("c:/aaa.bmp", "bbb.bmp");
			ftp.downloadFile("bbb.bmp", "c:/bbb");

			List list = ftp.getFileList();
			for (String file : list) {
				System.out.println(file);
			}

			ftp.setPath("/opt/ftp/outgoing/cs");
			String patternStr = "^CSGET_[0-9]{4}_0085_"+"20120926"+"_[0-9]{3}";
			// 过滤，获取目录下的文件列表
			list = ftp.getFileList(new CSFilter(patternStr));
			for (String file : list) {
				System.out.println(file);
			}
			
			//下载 过滤后的文件
			ftp.downPathFile("/opt/ftp/outgoing/cs/", "D:/outgoing/csvc",new CSFilter(patternStr));

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		ftp.close();
	}
	
	private FtpClient ftpClient = null;

	/**
	 * 打开连接
	 * 
	 * @param hostname
	 * @param port
	 * @param username
	 * @param passwd
	 * @return
	 */
	public void connect(String hostname, int port, String username,
			String passwd) {
		String msg = "";
		try {
			ftpClient = new FtpClient(hostname, port);
			ftpClient.login(username, passwd);
			ftpClient.binary();
			msg = "连接成功！";
		} catch (FtpLoginException e) {
			msg = "登录主机失败，可能是用户名密码错误！";
			e.printStackTrace();
		} catch (IOException e) {
			msg = "登录主机失败，请检验端品是否正确！";
			e.printStackTrace();
		} catch (SecurityException e) {
			msg = "无权连接主机，主确认是否有权限连接主机！";
			e.printStackTrace();
		}
		System.out.println(msg);
	}

	/**
	 * 关闭连接
	 */
	public void close() {
		if (ftpClient == null) {
			return;
		}
		try {
			ftpClient.closeServer();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 重命名
	 * 
	 * @param oldName
	 * @param newName
	 * @return
	 */
	public boolean renameFile(String oldName, String newName) {
		boolean result = false;
		try {
			this.ftpClient.rename(oldName, newName);
			result = true;
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 取得相对于当前连接目录的某个目录下所有文件列表
	 * 
	 * @param path
	 * @return
	 */
	public List getFileList(String path) {
		List list = new ArrayList();
		DataInputStream dis;
		try {
			dis = new DataInputStream(ftpClient.nameList(this.getDir() + path));
			String filename = "";
			while ((filename = dis.readLine()) != null) {
				list.add(filename);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return list;
	}

	/**
	 * 读取文件列表
	 * 
	 * @return
	 * @throws IOException
	 */
	public List getFileList() throws IOException {
		List fileList = new ArrayList();
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			isr = new InputStreamReader(this.ftpClient.list());
			br = new BufferedReader(isr);
			String fileName = "";
			while (true) {
				fileName = br.readLine();
				if (fileName == null) {
					break;
				}
				fileList.add(fileName);
			}
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (isr != null) {
				try {
					isr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return fileList;
	}

	/**
	 * 读取文件列表
	 * 
	 * @return
	 * @throws IOException
	 */
	public List getFileList(FileFilter filter) throws IOException {
		List fileList = new ArrayList();
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			isr = new InputStreamReader(this.ftpClient.list());
			br = new BufferedReader(isr);
			String fileName = "";
			while (true) {
				fileName = br.readLine();
				if (fileName == null) {
					break;
				}
				if ((filter == null) || filter.accept(new File(fileName)))
					fileList.add(fileName);
			}
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (isr != null) {
				try {
					isr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return fileList;
	}

	/**
	 * 获取文件名列表
	 * 
	 * @return
	 * @throws IOException
	 */
	public List getFileNameList() throws IOException {
		List fileNameList = new ArrayList();
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			isr = new InputStreamReader(this.ftpClient.nameList(this.getDir()));
			br = new BufferedReader(isr);

			String fileName = "";
			while (true) {
				fileName = br.readLine();
				if (fileName == null) {
					break;
				}
				fileNameList.add(fileName);
			}
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (isr != null) {
				try {
					isr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return fileNameList;

	}

	/**
	 * 设置路径 切换目录
	 * 
	 * @param path
	 * @return
	 */
	public boolean setPath(String path) {
		if (this.ftpClient != null) {
			try {
				ftpClient.cd(path);
				return true;
			} catch (IOException e) {
				e.printStackTrace();
				return false;
			}
		} else {
			return false;
		}
	}

	/**
	 * 判断是否为目录
	 * 
	 * @param line
	 * @return
	 */
	public boolean isDir(String line) {
		return line.startsWith("d");
	}

	/**
	 * 检查文件夹在当前目录下是否存在
	 * 
	 * @param dir
	 * @return
	 */
	public boolean isDirExist(String dir) {
		String pwd = "";
		try {
			pwd = ftpClient.pwd();
			ftpClient.cd(dir);
			ftpClient.cd(pwd);
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	/**
	 * 获取当前路径
	 * 
	 * @return
	 * @throws IOException
	 */
	public String getDir() throws IOException {
		return this.ftpClient.pwd();
	}

	/**
	 * 向上 切换到父级目录
	 * 
	 * @throws IOException
	 */
	public void up() throws IOException {
		if ("/".equals(ftpClient.pwd()) || "//".equals(ftpClient.pwd())) {
			return;
		}
		this.ftpClient.cdUp();
	}

	/**
	 * 删除文件
	 * 
	 * @param fileName
	 * @return
	 */
	public void deleteFile(String fileName) {
		ftpClient.sendServer("dele " + fileName + "\r\n");// 这个地方一定要注意 加上 \r\n
		try {
			if (ftpClient.readServerResponse() != 250)
				System.out.println("删除异常");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 在当前目录下创建文件夹
	 * 
	 * @param dir
	 * @return
	 * @throws Exception
	 */
	public boolean createDir(String dir) {
		try {
			ftpClient.ascii();
			StringTokenizer s = new StringTokenizer(dir, "/"); // sign
			s.countTokens();
			String pathName = ftpClient.pwd();
			while (s.hasMoreElements()) {
				pathName = pathName + "/" + (String) s.nextElement();
				try {
					ftpClient.sendServer("MKD " + pathName + "\r\n");
				} catch (Exception e) {
					e = null;
					return false;
				}
				ftpClient.readServerResponse();
			}
			ftpClient.binary();
			return true;
		} catch (IOException e1) {
			e1.printStackTrace();
			return false;
		}
	}

	/**
	 * 上传文件
	 * 
	 * @param localFile
	 * @param targetFileName
	 * @return
	 */
	public boolean uploadFile(String localFile, String targetFileName) {
		boolean result = false;
		if (this.ftpClient == null) {
			return false;
		}
		TelnetOutputStream tos = null;
		RandomAccessFile sendFile = null;
		DataOutputStream dos = null;
		try {
			File file = new File(localFile);
			sendFile = new RandomAccessFile(file, "r");
			sendFile.seek(0);
			tos = this.ftpClient.put(targetFileName);
			dos = new DataOutputStream(tos);
			int ch = 0;
			while (sendFile.getFilePointer() < sendFile.length()) {
				ch = sendFile.read();
				dos.write(ch);
			}
			result = true;
		} catch (Exception ex) {
			result = false;
		} finally {
			if (tos != null) {
				try {
					tos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (dos != null) {
				try {
					dos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (sendFile != null) {
				try {
					sendFile.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 上传文件
	 * 
	 * @param localFile
	 * @param targetFileName
	 * @return
	 */
	public boolean uploadFile(File localFile, String targetFileName) {
		boolean result = false;
		if (this.ftpClient == null) {
			return false;
		}
		TelnetOutputStream tos = null;
		RandomAccessFile sendFile = null;
		DataOutputStream dos = null;
		try {
			sendFile = new RandomAccessFile(localFile, "r");
			sendFile.seek(0);
			tos = this.ftpClient.put(targetFileName);
			dos = new DataOutputStream(tos);
			int ch = 0;
			while (sendFile.getFilePointer() < sendFile.length()) {
				ch = sendFile.read();
				dos.write(ch);
			}
			result = true;
		} catch (Exception ex) {
			result = false;
		} finally {
			if (tos != null) {
				try {
					tos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (dos != null) {
				try {
					dos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (sendFile != null) {
				try {
					sendFile.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 上传本地目录下的所有文件到服务器上
	 * 
	 * @param srcPath
	 * @param tagPath
	 * @param level
	 *            递归的级别
	 * @return
	 * @see [类、类#方法、类#成员]
	 */
	public boolean upPathFile(File srcPathFile, String tagPath) {
		buildList(tagPath.substring(0, tagPath.lastIndexOf("/")));
		boolean result = true;

		try {
			File temp[] = srcPathFile.listFiles();
			for (int i = 0; i < temp.length; i++) {
				if (temp[i].isDirectory()) {
					if (tagPath.lastIndexOf('/') > 0) {
						result = upPathFile(temp[i], tagPath
								+ temp[i].getName() + "/");
					} else {
						result = upPathFile(temp[i], tagPath + "/"
								+ temp[i].getName() + "/");
					}
				} else {
					if (tagPath.lastIndexOf('/') > 0) {
						result = uploadFile(temp[i], tagPath
								+ temp[i].getName());
					} else {
						result = uploadFile(temp[i], tagPath + "/"
								+ temp[i].getName());
					}

				}
			}

		} catch (Exception e) {
			e.printStackTrace();
		}

		return result;
	}

	/**
	 * 下载文件
	 * 
	 * @param srcFileName
	 * @param targetFileName
	 * @return
	 */
	public boolean downloadFile(String srcFileName, String targetFileName) {
		if (this.ftpClient == null) {
			return false;
		}
		TelnetInputStream tis = null;
		RandomAccessFile getFile = null;
		boolean result = true;
		try {
			File file = new File(targetFileName);
			getFile = new RandomAccessFile(file, "rw");
			getFile.seek(0);
			tis = this.ftpClient.get(srcFileName);
			DataInputStream dis = new DataInputStream(tis);
			int ch = 0;
			while (true) {
				ch = dis.read();
				if (ch < 0) {
					break;
				}
				getFile.write(ch);
			}
			getFile.close();
		} catch (IOException e) {
			result = false;
		} finally {
			if (getFile != null) {
				try {
					getFile.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (tis != null) {
				try {
					tis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 下载文件
	 * 
	 * @param srcFileName
	 * @param targetFileName
	 * @return
	 */
	public boolean downloadFile(String srcFileName, File targetFileName) {
		if (this.ftpClient == null) {
			return false;
		}
		TelnetInputStream tis = null;
		RandomAccessFile getFile = null;
		boolean result = true;
		try {
			getFile = new RandomAccessFile(targetFileName, "rw");
			getFile.seek(0);
			tis = this.ftpClient.get(srcFileName);
			DataInputStream dis = new DataInputStream(tis);
			int ch = 0;
			while (true) {
				ch = dis.read();
				if (ch < 0) {
					break;
				}
				getFile.write(ch);
			}
			getFile.close();
		} catch (IOException e) {
			result = false;
		} finally {
			if (getFile != null) {
				try {
					getFile.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (tis != null) {
				try {
					tis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 下载远程目录下的所有文件到本地
	 * 
	 * @param srcPathFile
	 *            远程目录文件
	 * @param tagPath
	 *            本地存放目录
	 * @return
	 * @throws IOException
	 * @see [类、类#方法、类#成员]
	 */
	public boolean downPathFile(String srcPath, String tagPath)
			throws IOException {

		boolean result = true;

		File tagFile = new File(tagPath);
		tagFile.mkdirs();

		setPath(srcPath);
		String tempPath = "";
		List list = getFileList();
		for (int i = 0; i < list.size(); i++) {
			String currPath = list.get(i);
			String fileName = getFileName(currPath);

			String currPathFul = getDir() + "/" + fileName;

			if (tagPath.lastIndexOf('/') > 0) {
				tempPath = tagPath
						+ currPathFul.substring(currPathFul.lastIndexOf("/"),
								currPathFul.length());
			} else {
				tempPath = tagPath
						+ "/"
						+ currPathFul.substring(currPathFul.lastIndexOf("/"),
								currPathFul.length());
			}

			if (isDir(currPath)) {
				srcPath = currPathFul + "/";
				downPathFile(srcPath, tempPath);
			} else {
				srcPath = currPathFul;
				downloadFile(srcPath, tempPath);
			}
		}

		return result;
	}

	/**
	 * 下载远程目录下的所有文件到本地，过滤规则
	 * 
	 * @param srcPathFile
	 *            远程目录文件
	 * @param tagPath
	 *            本地存放目录
	 * @param fileFilter
	 * 			  下载过滤文件
	 * @return
	 * @throws IOException
	 * @see [类、类#方法、类#成员]
	 */
	public boolean downPathFile(String srcPath, String tagPath,
			FileFilter fileFilter) throws IOException {

		boolean result = true;

		File tagFile = new File(tagPath);
		tagFile.mkdirs();

		setPath(srcPath);
		String tempPath = "";
		List list = getFileList(fileFilter);
		for (int i = 0; i < list.size(); i++) {
			String currPath = list.get(i);
			String fileName = getFileName(currPath);

			String currPathFul = getDir() + "/" + fileName;

			if (tagPath.lastIndexOf('/') > 0) {
				tempPath = tagPath
						+ currPathFul.substring(currPathFul.lastIndexOf("/"),
								currPathFul.length());
			} else {
				tempPath = tagPath
						+ "/"
						+ currPathFul.substring(currPathFul.lastIndexOf("/"),
								currPathFul.length());
			}

			if (isDir(currPath)) {
				srcPath = currPathFul + "/";
				downPathFile(srcPath, tempPath, fileFilter);
			} else {
				srcPath = currPathFul;
				downloadFile(srcPath, tempPath);
			}
		}

		return result;
	}

	public String getFileName(String line) {
		int i;
		String filename = (String) parseLine(line).get(8);
		for (i = 9; i < parseLine(line).size(); i++) {
			filename = filename + " " + ((String) parseLine(line).get(i));
		}
		return filename;
	}

	// 处理getFileList取得的行信息
	private ArrayList parseLine(String line) {
		ArrayList s1 = new ArrayList();
		StringTokenizer st = new StringTokenizer(line, " ");
		while (st.hasMoreTokens()) {
			s1.add(st.nextToken());
		}
		return s1;
	}

	/**
	 * 从FTP文件服务器上下载文件SourceFileName，到本地destinationFileName 所有的文件名中都要求包括完整的路径名在内
	 * 
	 * @param SourceFileName
	 *            String
	 * @param destinationFileName
	 *            String
	 * @throws Exception
	 */
	public void downFile(String SourceFileName, String destinationFileName)
			throws Exception {
		ftpClient.binary(); // 一定要使用二进制模式
		TelnetInputStream ftpIn = ftpClient.get(SourceFileName);
		byte[] buf = new byte[204800];
		int bufsize = 0;
		FileOutputStream ftpOut = new FileOutputStream(destinationFileName);
		while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
			ftpOut.write(buf, 0, bufsize);
		}
		ftpOut.close();
		ftpIn.close();
	}

	/**
	 * 从FTP文件服务器上下载文件，输出到字节数组中
	 * 
	 * @param SourceFileName
	 *            String
	 * @return byte[]
	 * @throws Exception
	 */
	public byte[] downFile(String SourceFileName) throws Exception {
		ftpClient.binary(); // 一定要使用二进制模式
		TelnetInputStream ftpIn = ftpClient.get(SourceFileName);
		ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
		byte[] buf = new byte[204800];
		int bufsize = 0;

		while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
			byteOut.write(buf, 0, bufsize);
		}
		byte[] return_arraybyte = byteOut.toByteArray();
		byteOut.close();
		ftpIn.close();
		return return_arraybyte;
	}

	/**
	 * 上传文件到FTP服务器,destination路径以FTP服务器的"/"开始，带文件名、 上传文件只能使用二进制模式，
	 * 当文件存在时再次上传则会覆盖
	 * 
	 * @param source
	 *            String
	 * @param destination
	 *            String
	 * @throws Exception
	 */
	public void upFile(String source, String destination) throws Exception {
		buildList(destination.substring(0, destination.lastIndexOf("/")));
		ftpClient.binary(); // 此行代码必须放在buildList之后
		TelnetOutputStream ftpOut = ftpClient.put(destination);
		TelnetInputStream ftpIn = new TelnetInputStream(new FileInputStream(
				source), true);
		byte[] buf = new byte[204800];
		int bufsize = 0;
		while ((bufsize = ftpIn.read(buf, 0, buf.length)) != -1) {
			ftpOut.write(buf, 0, bufsize);
		}
		ftpIn.close();
		ftpOut.close();
	}

	/**
	 * JSP中的流上传到FTP服务器, 上传文件只能使用二进制模式，当文件存在时再次上传则会覆盖 字节数组做为文件的输入流,
	 * 此方法适用于JSP中通过request输入流来直接上传文件在RequestUpload类中调用了此方法，
	 * destination路径以FTP服务器的"/"开始，带文件名
	 * 
	 * @param sourceData
	 *            byte[]
	 * @param destination
	 *            String
	 * @throws Exception
	 */
	public void upFile(byte[] sourceData, String destination) throws Exception {
		buildList(destination.substring(0, destination.lastIndexOf("/")));
		ftpClient.binary(); // 此行代码必须放在buildList之后
		TelnetOutputStream ftpOut = ftpClient.put(destination);
		ftpOut.write(sourceData, 0, sourceData.length);
		// ftpOut.flush();
		ftpOut.close();
	}

	/**
	 * 在FTP服务器上建立指定的目录,当目录已经存在的情下不会影响目录下的文件,这样用以判断FTP
	 * 上传文件时保证目录的存在目录格式必须以"/"根目录开头
	 * 
	 * @param pathList
	 *            String
	 * @throws Exception
	 */
	public void buildList(String pathList) {
		try {
			ftpClient.ascii();

			StringTokenizer s = new StringTokenizer(pathList, "/"); // sign
			int count = s.countTokens();
			String pathName = "";
			while (s.hasMoreElements()) {
				pathName = pathName + (String) s.nextElement();
				try {
					ftpClient.sendServer("XMKD " + pathName + "\r\n");
				} catch (Exception e) {
					e = null;
				}
				int reply = ftpClient.readServerResponse();
				pathName = pathName + "/";
			}
			ftpClient.binary();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}

}

过滤：

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.regex.Pattern;

public class CSFilter implements FileFilter {

	private String patternStr ;
	
	//"^CSGET_[0-9]{4}_0085_"+"20120926"+"_[0-9]{3}"
	private Pattern pattern ;

	public CSVCFilter(String str){
		this.patternStr = str;
		this.pattern = Pattern.compile(patternStr);
	}
	public boolean accept(File pathname) {
		String strName = pathname.getName();
		if (!isDir(strName)) {
			strName = getFileName(strName);
			System.out.println(strName);
			return pattern.matcher(strName).matches();
		}
		return true;
	}

	public boolean isDir(String strName) {
		return ((String) parseLine(strName).get(0)).indexOf("d") != -1;
	}

	public String getFileName(String line) {
		int i;
		String filename = (String) parseLine(line).get(8);
		for (i = 9; i < parseLine(line).size(); i++) {
			filename = filename + " " + ((String) parseLine(line).get(i));
		}
		return filename;
	}

	// 处理getFileList取得的行信息
	private ArrayList parseLine(String line) {
		ArrayList s1 = new ArrayList();
		StringTokenizer st = new StringTokenizer(line, " ");
		while (st.hasMoreTokens()) {
			s1.add(st.nextToken());
		}
		return s1;
	}

	public String getFileSize(String line) {
		return (String) parseLine(line).get(4);
	}

	public String getFileDate(String line) {
		ArrayList a = parseLine(line);
		return (String) a.get(5) + " " + (String) a.get(6) + " "
				+ (String) a.get(7);
	}

}

下载速度提升

public boolean downloadFile(String srcFileName, File targetFileName)
{
//.....

//下载速度太慢，用如下方式进行提升
                        byte[] recvbuf = new byte[1024];
			while((ch = dis.read(recvbuf)) > 0){
				getFile.write(recvbuf,0,ch);
			}

//			while (true) {
//				ch = dis.read();
//				if (ch < 0) {
//					break;
//				}
//				getFile.write(ch);
//			}



//...

}

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-10-10 16:26 发表评论

java 高性能网络编程 NIO

李凡 — Fri, 28 Sep 2012 08:31:00 GMT

服务器端：

 // 1. 分配一个 ServerSocketChannel 文件描述符
            serverChannel = ServerSocketChannel.open();

            // 2. 从 ServerSocketChannel里获取一个对于的 socket
            serverSocket = serverChannel.socket();

            // 3. 生成一个 Selector
            selector = Selector.open();

            // 4. 把 socket 绑定到端口上
            serverSocket.bind(new InetSocketAddress(iport));

            // 5. serverChannel 未非bolck
            serverChannel.configureBlocking(false);

            // 6. 通过Selector注册ServerSocketChannel: 只能注册 accept
            // 而SocketChannel可以注册CONNENCT,READ,WRITE ; register -> validOps
            // 在各个子类实现不同
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
			try {
				// 获得IO准备就绪的channel数量
				int n = selector.select();

				// 没有channel准备就绪,继续执行
				if (n == 0) {
					continue;
				}

				// 用一个iterator返回Selector的selectedkeys
				Iterator it = selector.selectedKeys().iterator();

				// 处理每一个SelectionKey
				while (it.hasNext()) {
					SelectionKey key = (SelectionKey) it.next();

					// 判断是否有新的连接到达
					if (key.isAcceptable()) {
						
						// 返回SelectionKey的ServerSocketChannel
						ServerSocketChannel server = (ServerSocketChannel) key
								.channel();
						System.out.println("有连接");
						SocketChannel channel = server.accept();
						
						registerChannel(selector, channel, SelectionKey.OP_READ);
						
						doWork(channel);
					}

					// 判断是否有数据在此channel里需要读取
					if (key.isReadable()) {
						processData(key);
					}
				}

				// 删除 selectedkeys
				it.remove();

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

客户端：

  //打开socket通道
		SocketChannel socketChannel = SocketChannel.open();
		//设置非阻塞方式
		socketChannel.configureBlocking(false);
		//打开选择器
		Selector selector = Selector.open();
		//注册连接到服务器socket动作
		socketChannel.register(selector, SelectionKey.OP_CONNECT);
		//连接
		socketChannel.connect( new InetSocketAddress("localhost",9988));
		
		Set selectkeySets;
		SelectionKey selectionKey;
		Iterator iterator;
		
		//与服务器通信通道
		SocketChannel clientChannel ;

	       while(true){
			//选择一组建，其相应的通道已为I/O操作准备就绪
			//此方法执行处于阻塞模式的选择操作
			selector.select(TIME_OUT);
			
			//返回此选择器的已选择键集。
			selectkeySets = selector.selectedKeys();
			iterator = selectkeySets.iterator();
			
			
			while(iterator.hasNext()){
				selectionKey = iterator.next();
				
				if (selectionKey.isConnectable()) {
                                  clientChannel = (SocketChannel)selectionKey.channel();
					// 判断此通道上是否正在进行连接操作。  
                                  // 完成套接字通道的连接过程。  
					if (clientChannel.isConnectionPending()) {//判断此通道上是否正在进行连接操作
						clientChannel.finishConnect();  //完成套接字通道的连接过程
                                   
                                  }
                                  clientChannel.register(selector, SelectionKey.OP_WRITE);
                            }else if (selectionKey.isReadable()) {
					clientChannel = (SocketChannel)selectionKey.channel();
					//将缓冲区清空
					receiveBuffer.clear();
					//读取服务器发送来的数据库到缓冲区
					count = clientChannel.read(receiveBuffer);//count 读取到的字节数
					if (count > 0) {
						clientChannel.register(selector, SelectionKey.OP_WRITE);
					}
                            }else if (selectionKey.isWritable()) {
					sendBuffer.clear();
					clientChannel = (SocketChannel)selectionKey.channel();
					clientChannel.write(sendBuffer);
					System.out.println("客户端向服务器发送数据:"+sendText);
					clientChannel.register(selector, SelectionKey.OP_READ);
                            }
                     }
                 }

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-09-28 16:31 发表评论

java 高性能网络编程 mina

李凡 — Fri, 28 Sep 2012 02:52:00 GMT

服务器端：

// 创建一个非阻塞的server端socket ，用NIO
		SocketAcceptor acceptor = new NioSocketAcceptor();

		// 创建接收数据的过滤器
		DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

		// 设定这个过滤器一行一行(\r\n)的读数据
		chain.addLast("myChin", new ProtocolCodecFilter(
				new TextLineCodecFactory()));

		//设定服务器端的消息处理器,一个SamplMinaServerHandler对象(自己实现)继承IoHandlerAdapter
		acceptor.setHandler(new IoHandlerAdapter(){
			//当一个客端端连结进入时
			@Override
			public void sessionOpened(IoSession session) throws Exception {
				// TODO Auto-generated method stub
				System.out.println("incomming client : "+session.getRemoteAddress());
			}
			
			//当一个客户端关闭时
			@Override
			public void sessionClosed(IoSession session) throws Exception {
				// TODO Auto-generated method stub
				System.out.println("on client disconnect : "+session.getRemoteAddress());
			}

			//当客户端发送的消息到达时
			@Override
			public void messageReceived(IoSession session, Object message)
					throws Exception {
				// TODO Auto-generated method stub
				String s =  (String)message;
				System.out.println("收到客户端发来的消息:"+s);
				//测试将消息回给客户端
				session.write(s+count);
				count ++;
			}
			private int count =0;
		});
		//端口号
		int bindPort= 9988;
		
		//绑定打开，启动服务器
		acceptor.bind(new InetSocketAddress(bindPort));
		
		System.out.println("Mina Server is listing on:="+bindPort);

  客户端：

// create TCP/IP connector
		NioSocketConnector connector = new NioSocketConnector();

		// 创建接收数据的过滤器
		DefaultIoFilterChainBuilder chain = connector.getFilterChain();

		// 设定这个过滤器将一行一行(/r/n)的读取数据
		chain.addLast("myChin", new ProtocolCodecFilter(
				new TextLineCodecFactory()));

		// 设定服务器端的消息处理器:一个SamplMinaServerHandler对象,
		connector.setHandler(new IoHandlerAdapter(){
			@Override
			public void messageReceived(IoSession session, Object message)
					throws Exception {
				// 我们己设定了服务器解析消息的规则是一行一行读取,这里就可转为String:
				String s = (String) message;
				// Write the received data back to remote peer
				System.out.println("服务器发来的收到消息: " + s);
				// 测试将消息回送给客户端
				session.write(s);
			}

			@Override
			public void sessionClosed(IoSession session) throws Exception {
				// TODO Auto-generated method stub
				System.out.println("one Clinet Disconnect !");
			}

			@Override
			public void sessionOpened(IoSession session) throws Exception {
				// TODO Auto-generated method stub
				System.out.println("incomming client  " + session.getRemoteAddress());
				session.write("我来啦........");
			}
		});
		
		// Set connect timeout.
		connector.setConnectTimeout(30);
		
		// 连结到服务器:
		ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",
				9988));
		
		// Wait for the connection attempt to be finished.
		cf.awaitUninterruptibly();
		cf.getSession().getCloseFuture().awaitUninterruptibly();
		connector.dispose();

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-09-28 10:52 发表评论

分表分区

李凡 — Thu, 27 Sep 2012 01:58:00 GMT

分表用用户ID位数取模

分区用时间进行分区

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-09-27 09:58 发表评论

代理下载网页，挖掘数据

李凡 — Tue, 25 Sep 2012 05:52:00 GMT

URL url = new URL("http://blog.csdn.net/mywait_00/article/details/1698627");

//设置代理
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("openproxy.fsfd.com", 8080));
//打开代理
URLConnection coon = url.openConnection(proxy);
//访问的时候需要设置 user-agent
coon.setRequestProperty("User-Agent","Mozila/4.0(compatible;MSIE 5.0;Windows XP;DigExt");

BufferedReader in = new BufferedReader(new InputStreamReader(coon.getInputStream()));

String inputLine; StringBuffer html = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    html.append(inputLine);
}

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-09-25 13:52 发表评论

java nio 编程学习一

李凡 — Fri, 21 Sep 2012 08:08:00 GMT

Java.nio中的主要类
ServerSocketChannel:ServerSocket的替代类.
SocketChannel:Socket的替代类
Selector:为ServerSocketChannel监控接受就绪事件,为SocketChannel监控连接就绪,读就绪和写就绪事件
SelectionKey:代表ServerSocketChannel及SocketChannel向Selector注册事件句柄
向SocketChannel和ServerSocketChannel注册事件:
SelectionKey key=serverSocketChannel.register(selector,op)
Op的可选值
对于ServerSocketChannel只有一个事件:
(1)SelectionKye.OP_ACCEPT:接受连接就绪事件,表示至少有了一个客户连接,服务器可以接受这个连接
SocketChannel可能发生3种事件
(1)SelectionKey.OP_CONNECT:连接就为事件,表示客户与服务器的连接已经成功
(2)SelectionKey.OP_WRITE/OP_READ:写的就绪事件,表示已经可以向输出流写数据了SocketChannel提供了接受和发送的方法
可以使用:read(ByteBuffer)write(ByteBuffer)写入写出

ServerSocketChannel类
方法:(PS继承过SelectableChannel类的方法)
    (1)open()静态方法获取ServerSocketChannel对象.
     (2)accept同ServerSocket,不过获取的是SocketChannel,根据是否阻塞返回null还是阻塞,值得注意的是accept返回的SocketChannel是阻塞模式的使用configureBlocking更改模式
     (3)socket() 返回关联的ServerSocket
SocketChannel类
此类是Socket类的替代类
方法:(PS继承过SelectableChannel类的方法)
(1)open() open(SocketAddress)静态方法用来创建SocketChannel对象,第二个重写还会建立于远程服务器的连接.
(2)socket()返回关联的Socket对象
(3)isConnected()是否建立连接
(4)isConnectionPending判断是否正在进行远程连接
(5)connect() 建立远程连接() 根据是否阻塞而不同
(6)finishConnect() 视图完成远程连接
(7)read()读取数据(这个应该是接数据)
(8)write()写数据(这个是发送数据)

声明：

public static int PORT = 8888;
ServerSocketChannel serverChannel;
ServerSocket serverSocket;
Selector  selector;

初始化：

// 1. 分配一个 ServerSocketChannel 文件描述符
serverChannel = ServerSocketChannel.open();

// 2. 从 ServerSocketChannel里获取一个对于的 socket
serverSocket = serverChannel.socket();

// 3. 生成一个 Selector
selector = Selector.open();

// 4. 把 socket 绑定到端口上
serverSocket.bind(new InetSocketAddress(iport));

// 5. serverChannel 未非bolck
serverChannel.configureBlocking(false);

// 6. 通过Selector注册ServerSocketChannel: 只能注册 accept
// 而SocketChannel可以注册CONNENCT,READ,WRITE ; register -> validOps
// 在各个子类实现不同
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

开启服务：

while (true) {
	try {
			// 获得IO准备就绪的channel数量
			int n = selector.select();
			
			// 没有channel准备就绪,继续执行
			if (n == 0) {
				continue;
			}
			
			// 用一个iterator返回Selector的selectedkeys
			Iterator it = selector.selectedKeys().iterator();
			
			// 处理每一个SelectionKey
			while (it.hasNext()) {
						SelectionKey key = (SelectionKey) it.next();
					
						// 判断是否有新的连接到达
						if (key.isAcceptable()) {
					
							// 返回SelectionKey的ServerSocketChannel
							ServerSocketChannel server = (ServerSocketChannel) key
							.channel();
							System.out.println("有连接");
							SocketChannel channel = server.accept();
							
							registerChannel(selector, channel, SelectionKey.OP_READ);
							
							doWork(channel);
						}
					
						// 判断是否有数据在此channel里需要读取
						if (key.isReadable()) {
							processData(key);
						}
			}
			
			// 删除 selectedkeys
			it.remove();
	
		} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
		}
}

已有 0 人发表留言，猛击->>这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

李凡 2012-09-21 16:08 发表评论

语源科技BlogJava-sblig

跟我学Spring3 学习笔记七 初始化与销毁

跟我学Spring3 学习笔记六 注入

引用其它Bean

JavaScript 学习笔记 汇总

动态生成class

FtpUtil ftp工具类 过滤文件名

java 高性能网络编程 NIO

java 高性能网络编程 mina

分表分区

代理 下载网页，挖掘数据

java nio 编程学习 一

跟我学Spring3 学习笔记七初始化与销毁

跟我学Spring3 学习笔记六注入

JavaScript 学习笔记汇总

FtpUtil ftp工具类过滤文件名

代理下载网页，挖掘数据

java nio 编程学习一