-
Notifications
You must be signed in to change notification settings - Fork 6
/
DirList.java
177 lines (149 loc) · 6.08 KB
/
DirList.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/*
* Copyright 2012 jMethods, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.myjavaworld.ftp.examples;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
import com.myjavaworld.ftp.ConnectionException;
import com.myjavaworld.ftp.ControlConnectionEvent;
import com.myjavaworld.ftp.ControlConnectionListener;
import com.myjavaworld.ftp.FTPClient;
import com.myjavaworld.ftp.FTPConnectionEvent;
import com.myjavaworld.ftp.FTPConnectionListener;
import com.myjavaworld.ftp.FTPException;
import com.myjavaworld.ftp.ListParser;
import com.myjavaworld.ftp.RemoteFile;
/**
* This example demonstrates how to connect to an FTP site and list the contents
* of a directory.
*
* @author Sai Pullabhotla, psai [at] jMethods [dot] com
* @version 1.0
*/
public class DirList {
/**
* A date format object format last modified date of remote files.
*/
private static final DateFormat dateFormat = DateFormat
.getDateTimeInstance();
/**
* @param args
* command line arguments.
* @throws InstantiationException
* propogated
* @throws ClassNotFoundException
* propogated
* @throws IllegalAccessException
* propogated
* @throws FTPException
* propogated
* @throws ConnectionException
* propogated
* @throws ParseException
* propogated
*/
public static void main(String[] args) throws InstantiationException,
ClassNotFoundException, IllegalAccessException, FTPException,
ParseException, ConnectionException {
// Determine the FTPClient implementation that you would like to use.
// For most FTP servers, the DefaultFTPClient should work. There is
// another implementation for working with AS/400 (iSeries) FTP servers.
// The class name for it is com.myjavaworld.ftp.AS400FTPClient.
// And, of course, you can always write your own implementation either
// by implementing the FTPClient interface or by extending one of the
// exsting implementations.
String ftpClientClassName = "com.myjavaworld.ftp.DefaultFTPClient";
// String ftpClientClassName = "com.myjavaworld.ftp.AS400FTPClient";
// Determine the directory list parser that we would like to use in this
// session. For most FTP servers, the default implementatiom should work
// fine. There is another implementation provided for handling
// MS-DOS directory list format. The class name is
// com.myjavaworld.ftp.DosListPareser. You can always write one of your
// own implementation if you want to work with an FTP server that uses a
// list format other than UNIX or DOS. This can be done implementing the
// com.myjavaworld.ftp.ListParser interface.
String listParserClassName = "com.myjavaworld.ftp.DefaultListParser";
// String listParserClassName = "com.myjavaworld.ftp.DosListParser";
// Use reflection to find the FTP Client class and obtain an instance
// of FTPClient.
FTPClient client = (FTPClient) Class.forName(ftpClientClassName)
.newInstance();
// Use reflection to find the list parser class and obtain an instance
// of the list parser.
ListParser parser = (ListParser) Class.forName(listParserClassName)
.newInstance();
// Set the list parser to use with this FTP client.
client.setListParser(parser);
// Listen for connection events. This is optional.
client.addFTPConnectionListener(new FTPConnectionListener() {
public void connectionOpened(FTPConnectionEvent evt) {
System.out.println(evt.getMessage());
}
public void connectionClosed(FTPConnectionEvent evt) {
System.out.println(evt.getMessage());
}
});
// Listen for various commands that are sent to the server and the
// replies received. This is optional.
client.addControlConnectionListener(new ControlConnectionListener() {
public void commandSent(ControlConnectionEvent evt) {
System.out.println(evt.getMessage());
}
public void replyReceived(ControlConnectionEvent evt) {
System.out.println(evt.getMessage());
}
});
client.setPassive(true);
// Set proxy
// client.setProxy(new Proxy(Type.SOCKS, new InetSocketAddress(
// "localhost", 1080)));
// Connect to the FTP server.
client.connect("ftp.netscape.com");
// Login to the FTP server.
client.login("anonymous", "you@yourcompany.com");
// Findout the current working directory on the FTP server.
RemoteFile workingDirectory = client.getWorkingDirectory();
// print the dir listing.
list(client);
// Change the working directory to a different directory. Make sure that
// this dir exists on the FTP server.
client.setWorkingDirectory(parser.createRemoteFile(workingDirectory,
"pub", true));
// Print the dir list of the new working directory.
list(client);
// Close the connection.
client.disconnect();
}
private static void list(FTPClient client) throws FTPException,
ParseException, ConnectionException {
RemoteFile[] children = client.list();
// For each file in the list, print out the attributes, whether the file
// is a directory or a regular file, the size of the file, the date and
// the name of the file.
for (int i = 0; i < children.length; i++) {
System.out
.println(children[i].getAttributes()
+ "\t"
+ (children[i].isDirectory() ? "<DIR>" : "<FILE>")
+ "\t"
+ children[i].getSize()
+ "\t"
+ dateFormat.format(new Date(children[i]
.getLastModified())) + "\t"
+ children[i].getName());
}
}
}