Appeler une fonction qui est dans une Java Class à partir d'un fichier JFrame Fo
mimi1255
Messages postés87Date d'inscriptionmardi 22 janvier 2008StatutMembreDernière intervention14 mars 2024
-
6 mars 2008 à 21:09
mimi1255
Messages postés87Date d'inscriptionmardi 22 janvier 2008StatutMembreDernière intervention14 mars 2024
-
10 mars 2008 à 20:41
Bonjour, je souhaiterai faire appel à mon code qui se trouve dans la fonction main de mon fichier "TestFTP" à partir de mon fichier JFrame "Affichage". En cliquant sur le bouton 'Passage du badge', je voudrais donc faire appel au code qui se trouve dans mon fichier "TestFTP".
Mais je n'y arrive pas.
Voici mes codes:
1ère fichier: "TestFTP"
/* <!-- in case someone opens this in a browser... --> */
package Test;
import java.io.*;
import java.util.*;
/* This program/class is meant to test the functionality
* of the FTPConnection class.
*/
class TestFTP
{
public static void main (String[] args)
{
String serverName;
FTPConnection ftp = null;
try
{
if (args.length == 0)
{
serverName = "localhost";
//serverName = getStringFromUser("Enter the server you would like to connect to: ");
if (serverName.length() == 0) { return; }
} else {
serverName = args[0];
}
// set the FTPConnection parameter to true if you want to
// see debug output in your console window
ftp = new FTPConnection(false);
System.out.println("Connection à " + serverName);
ftp.connect(serverName);
if (ftp.login("GARDIEN", "admin"))
{
System.out.println("Authentification réussie!");
System.out.println("Le type de système est: " + ftp.getSystemType());
System.out.println("Le répertoire courant est: " + ftp.getCurrentDirectory());
String files = ftp.listFiles();
String subDirs = ftp.listSubdirectories();
System.out.println("Fichiers dans le répertoire:\n" + files);
System.out.println("Sous-répertoires:\n" + subDirs);
// try to change to the first subdirectory
StringTokenizer st = new StringTokenizer(subDirs, ftp.lineTerm);
String sdName = "//";
if (st.hasMoreTokens()) { sdName = st.nextToken(); }
if (sdName.length() > 0)
{
System.out.println("Changement de répertoire " + sdName);
if (ftp.changeDirectory(sdName))
{
// just for kicks, try to download the first 3 files in the directory
files = ftp.listFiles();
st = new StringTokenizer(files, ftp.lineTerm);
String fileName;
int count = 1;
while ((st.hasMoreTokens()) && (count < 3)) {
fileName = st.nextToken();
System.out.println("Téléchargement " + fileName + " de C:\");
try
{
if (ftp.downloadFile(fileName, "C:\\Documents and Settings\\Jérémy GRESLON\\Mes documents\\Photos_telechargees\" + fileName))
{
System.out.println("Téléchargement réussi!");
} else {
System.out.println("Erreur de téléchargement " + fileName);
}
} catch(Exception de) {
System.out.println("ERREUR: " + de.getMessage());
}
count++;
}
}
} else {
System.out.println("Il n'y a pas de sous répertoires!");
}
ftp.logout();
ftp.disconnect();
System.out.println("Déconnecté et déloggé.");
} else {
System.out.println("Désolé, impossible de se connecter au serveur.");
}
} catch(Exception e) {
e.printStackTrace();
try { ftp.disconnect(); } catch(Exception e2) {}
}
}
// private function that gets console input from the user
private static String getStringFromUser(String prompt) throws IOException
{
System.out.print(prompt);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
return br.readLine();
}
}
mon 2ème fichier: "FTPConnection"
package Test;
import java.io.*;
import java.net.*;
import java.util.*;
public class FTPConnection extends Object {
/**
* If this flag is on, we print out debugging information to stdout during
* execution. Useful for debugging the FTP class and seeing the server's
* responses directly.
*/
private static boolean PRINT_DEBUG_INFO = false;
/**
* The socket through which we are connected to the FTP server.
*/
private Socket connectionSocket = null;
/**
* The socket output stream.
*/
private PrintStream outputStream = null;
/**
* The socket input stream.
*/
private BufferedReader inputStream = null;
/**
* The offset at which we resume a file transfer.
*/
private long restartPoint = 0L;
/**
* Added by Julian: If this flag is on, we're currently logged in to something.
*/
private boolean loggedIn = false;
/**
* Added by Julian: This is the line terminator to use for multi-line responses.
*/
public String lineTerm = "\n";
/**
* Added by Julian: This is the size of the data blocks we use for transferring
* files.
*/
private static int BLOCK_SIZE = 4096;
/**
* Added by Julian: After you create an FTPConnection object, you will call the
* connect() and login() methods to access your server. Please don't forget to
* logout() and disconnect() when you're done (it's only polite...).
*/
public FTPConnection ()
{
// default constructor (obviously) -- this is just good to have...
}
/**
* Added by Julian: Allows you to specify if you want to send debug output to
* the console (true if you do, false if you don't).
*/
public FTPConnection (boolean debugOut)
{
PRINT_DEBUG_INFO = debugOut;
}
/**
* Prints debugging information to stdout if the private flag
* <code>PRINT_DEBUG_INFO
is turned on.
*/
private void debugPrint(String message) {
if (PRINT_DEBUG_INFO) System.err.println(message);
}
/**
* Connects to the given FTP host on port 21, the default FTP port.
*/
public boolean connect(String host)
throws UnknownHostException, IOException
{
return connect(host, 21);
}
/**
* Connects to the given FTP host on the given port.
*/
public boolean connect(String host, int port)
throws UnknownHostException, IOException
{
connectionSocket = new Socket(host, port);
outputStream = new PrintStream(connectionSocket.getOutputStream());
inputStream = new BufferedReader(new
InputStreamReader(connectionSocket.getInputStream()));
if (!isPositiveCompleteResponse(getServerReply())){
disconnect();
return false;
}
return true;
}
/**
* Disconnects from the host to which we are currently connected.
*/
public void disconnect()
{
if (outputStream != null) {
try {
if (loggedIn) { logout(); };
outputStream.close();
inputStream.close();
connectionSocket.close();
} catch (IOException e) {}
/**
* Added by Julian: Logout before you disconnect (this is good form).
*/
public boolean logout()
throws IOException
{
int response = executeCommand("quit");
loggedIn = !isPositiveCompleteResponse(response);
return !loggedIn;
}
/**
* Wrapper for the command
cwd [directory]
.
*/
public boolean changeDirectory(String directory)
throws IOException
{
int response = executeCommand("cwd " + directory);
return isPositiveCompleteResponse(response);
}
.
*/
public boolean makeDirectory(String directory)
throws IOException
{
int response = executeCommand("mkd " + directory);
return isPositiveCompleteResponse(response);
}
/**
* Wrapper for the command
rmd [directory]
.
*/
public boolean removeDirectory(String directory)
throws IOException
{
int response = executeCommand("rmd " + directory);
return isPositiveCompleteResponse(response);
}
/**
* Wrapper for the command
cdup
.
*/
public boolean parentDirectory()
throws IOException
{
int response = executeCommand("cdup");
return isPositiveCompleteResponse(response);
}
/**
* Wrapper for the command
dele [fileName]
.
*/
public boolean deleteFile(String fileName)
throws IOException
{
int response = executeCommand("dele " + fileName);
return isPositiveCompleteResponse(response);
}
/**
* Wrapper for the command
pwd
.
*/
public String getCurrentDirectory()
throws IOException
{
String response = getExecutionResponse("pwd");
StringTokenizer strtok = new StringTokenizer(response);
// Get rid of the first token, which is the return code
if (strtok.countTokens() < 2) return null;
strtok.nextToken();
String directoryName = strtok.nextToken();
// Most servers surround the directory name with quotation marks
int strlen = directoryName.length();
if (strlen == 0) return null;
if (directoryName.charAt(0) == '"') {
directoryName = directoryName.substring(1);
strlen--;
}
if (directoryName.charAt(strlen - 1) == '"')
return directoryName.substring(0, strlen - 1);
return directoryName;
}
/**
* Set the restart point for the next download or upload operation. This
* lets clients resume interrupted uploads or downloads.
*/
public void setRestartPoint(int point)
{
restartPoint = point;
debugPrint("Restart noted");
}
/**
* Gets server reply code from the control port after an ftp command has
* been executed. It knows the last line of the response because it begins
* with a 3 digit number and a space, (a dash instead of a space would be a
* continuation).
*/
private int getServerReply()
throws IOException
{
return Integer.parseInt(getFullServerReply().substring(0, 3));
}
/**
* Gets server reply string from the control port after an ftp command has
* been executed. This consists only of the last line of the response,
* and only the part after the response code.
*/
private String getFullServerReply()
throws IOException
{
String reply;
/**
* Added by Julian: Returns the last line of the server reply, but also
* returns the full multi-line reply in a StringBuffer parameter.
*/
private String getFullServerReply(StringBuffer fullReply)
throws IOException
{
String reply;
fullReply.setLength(0);
// remove any trailing line terminators from the fullReply
if (fullReply.length() > 0)
{
fullReply.setLength(fullReply.length() - lineTerm.length());
}
return reply;
}
/**
* Added by Julian: Gets a list of files in the current directory.
*/
public String listFiles()
throws IOException
{
return listFiles("");
}
/**
* Added by Julian: Gets a list of files in either the current
* directory, or one specified as a parameter. The 'params' parameter
* can be either a directory name, a file mask, or both (such as
* '/DirName/*.txt').
*/
public String listFiles(String params)
throws IOException
{
StringBuffer files = new StringBuffer();
StringBuffer dirs = new StringBuffer();
if (!getAndParseDirList(params, files, dirs))
{
debugPrint("Error getting file list");
}
return files.toString();
}
/**
* Added by Julian: Gets a list of subdirectories in the current directory.
*/
public String listSubdirectories()
throws IOException
{
return listSubdirectories("");
}
/**
* Added by Julian: Gets a list of subdirectories in either the current
* directory, or one specified as a parameter. The 'params' parameter
* can be either a directory name, a name mask, or both (such as
* '/DirName/Sub*').
*/
public String listSubdirectories(String params)
throws IOException
{
StringBuffer files = new StringBuffer();
StringBuffer dirs = new StringBuffer();
if (!getAndParseDirList(params, files, dirs))
{
debugPrint("Error getting dir list");
}
return dirs.toString();
}
/**
* Added by Julian: Sends and gets the results of a file list command,
* like LIST or NLST.
*/
private String processFileListCommand(String command)
throws IOException
{
StringBuffer reply = new StringBuffer();
String replyString;
// file listings require you to issue a PORT command,
// like a file transfer
boolean success = executeDataCommand(command, reply);
if (!success)
{
return "";
}
replyString = reply.toString();
// strip the trailing line terminator from the reply
if (reply.length() > 0)
{
return replyString.substring(0, reply.length() - 1);
} else {
return replyString;
}
}
/**
* Added by Julian: Gets a directory list from the server and parses
* the elements into a list of files and a list of subdirectories.
*/
private boolean getAndParseDirList(String params, StringBuffer files, StringBuffer dirs)
throws IOException
{
// reset the return variables (we're using StringBuffers instead of
// Strings because you can't change a String value and pass it back
// to the calling routine -- changing a String creates a new object)
files.setLength(0);
dirs.setLength(0);
// get the NLST and the LIST -- don't worry if the commands
// don't work, because we'll just end up sending nothing back
// if that's the case
String shortList = processFileListCommand("nlst " + params);
String longList = processFileListCommand("list " + params);
// tokenize the lists we got, using a newline as a separator
StringTokenizer sList = new StringTokenizer(shortList, "\n");
StringTokenizer lList = new StringTokenizer(longList, "\n");
// other variables we'll need
String sString;
String lString;
// assume that both lists have the same number of elements
while ((sList.hasMoreTokens()) && (lList.hasMoreTokens())) {
sString = sList.nextToken();
lString = lList.nextToken();
if (lString.length() > 0)
{
if (lString.startsWith("d"))
{
dirs.append(sString.trim() + lineTerm);
debugPrint("Dir: " + sString);
} else if (lString.startsWith("-")) {
files.append(sString.trim() + lineTerm);
debugPrint("File: " + sString);
} else {
// actually, symbolic links will start with an "l"
// (lowercase L), but we're not going to mess with
// those
debugPrint("Unknown: " + lString);
}
}
}
// strip off any trailing line terminators and return the values
if (files.length() > 0) { files.setLength(files.length() - lineTerm.length()); }
if (dirs.length() > 0) { dirs.setLength(dirs.length() - lineTerm.length()); }
return true;
}
/**
* Executes the given FTP command on our current connection, returning the
* three digit response code from the server. This method only works for
* commands that do not require an additional data port.
*/
public int executeCommand(String command)
throws IOException
{
outputStream.println(command);
return getServerReply();
}
/**
* Executes the given FTP command on our current connection, returning the
* last line of the server's response. Useful for commands that return
* one line of information.
*/
public String getExecutionResponse(String command)
throws IOException
{
outputStream.println(command);
return getFullServerReply();
}
/**
* Executes the given ftpd command on the server and writes the results
* returned on the data port to the file with the given name, returning true
* if the server indicates that the operation was successful.
*/
public boolean readDataToFile(String command, String fileName)
throws IOException
{
// Open the local file
RandomAccessFile outfile = new RandomAccessFile(fileName, "rw");
// Do restart if desired
if (restartPoint != 0) {
debugPrint("Seeking to " + restartPoint);
outfile.seek(restartPoint);
}
// Convert the RandomAccessFile to an OutputStream
FileOutputStream fileStream = new FileOutputStream(outfile.getFD());
boolean success = executeDataCommand(command, fileStream);
outfile.close();
return success;
}
/**
* Executes the given ftpd command on the server and writes the contents
* of the given file to the server on an opened data port, returning true
* if the server indicates that the operation was successful.
*/
public boolean writeDataFromFile(String command, String fileName)
throws IOException
{
// Open the local file
RandomAccessFile infile = new RandomAccessFile(fileName, "r");
// Do restart if desired
if (restartPoint != 0) {
debugPrint("Seeking to " + restartPoint);
infile.seek(restartPoint);
}
// Convert the RandomAccessFile to an InputStream
FileInputStream fileStream = new FileInputStream(infile.getFD());
boolean success = executeDataCommand(command, fileStream);
infile.close();
return success;
}
/**
* Executes the given ftpd command on the server and writes the results
* returned on the data port to the given OutputStream, returning true
* if the server indicates that the operation was successful.
*/
public boolean executeDataCommand(String command, OutputStream out)
throws IOException
{
// Open a data socket on this computer
ServerSocket serverSocket = new ServerSocket(0);
if (!setupDataPort(command, serverSocket)) return false;
Socket clientSocket = serverSocket.accept();
// Transfer the data
InputStream in = clientSocket.getInputStream();
transferData(in, out);
// Clean up the data structures
in.close();
clientSocket.close();
serverSocket.close();
/**
* Executes the given ftpd command on the server and writes the contents
* of the given InputStream to the server on an opened data port, returning
* true if the server indicates that the operation was successful.
*/
public boolean executeDataCommand(String command, InputStream in)
throws IOException
{
// Open a data socket on this computer
ServerSocket serverSocket = new ServerSocket(0);
if (!setupDataPort(command, serverSocket)) return false;
Socket clientSocket = serverSocket.accept();
// Transfer the data
OutputStream out = clientSocket.getOutputStream();
transferData(in, out);
// Clean up the data structures
out.close();
clientSocket.close();
serverSocket.close();
/**
* Added by Julian: Executes the given ftpd command on the server
* and writes the results returned on the data port to the given
* StringBuffer, returning true if the server indicates that the
* operation was successful.
*/
public boolean executeDataCommand(String command, StringBuffer sb)
throws IOException
{
// Open a data socket on this computer
ServerSocket serverSocket = new ServerSocket(0);
if (!setupDataPort(command, serverSocket)) return false;
Socket clientSocket = serverSocket.accept();
// Transfer the data
InputStream in = clientSocket.getInputStream();
transferData(in, sb);
// Clean up the data structures
in.close();
clientSocket.close();
serverSocket.close();
/**
* Transfers the data from the given input stream to the given output
* stream until we reach the end of the stream.
*/
private void transferData(InputStream in, OutputStream out)
throws IOException
{
byte b[] = new byte[BLOCK_SIZE];
int amount;
// Read the data into the file
while ((amount = in.read(b)) > 0) {
out.write(b, 0, amount);
}
}
/**
* Added by Julian: Transfers the data from the given input stream
* to the given StringBuffer until we reach the end of the stream.
*/
private void transferData(InputStream in, StringBuffer sb)
throws IOException
{
byte b[] = new byte[BLOCK_SIZE];
int amount;
// Read the data into the StringBuffer
while ((amount = in.read(b)) > 0) {
sb.append(new String(b, 0, amount));
}
}
/**
* Executes the given ftpd command on the server and writes the results
* returned on the data port to the given FilterOutputStream, returning true
* if the server indicates that the operation was successful.
*/
private boolean setupDataPort(String command, ServerSocket serverSocket)
throws IOException
{
// Send our local data port to the server
if (!openPort(serverSocket)) return false;
// Set binary type transfer
outputStream.println("type i");
if (!isPositiveCompleteResponse(getServerReply())) {
debugPrint("Could not set transfer type");
return false;
}
// If we have a restart point, send that information
if (restartPoint != 0) {
outputStream.println("rest " + restartPoint);
restartPoint = 0;
// TODO: Interpret server response here
getServerReply();
}
// Send the command
outputStream.println(command);
/**
* Get IP address and port number from serverSocket and send them via the
*
port
command to the ftp server, returning true if we get a
* valid response from the server, returning true if the server indicates
* that the operation was successful.
*/
private boolean openPort(ServerSocket serverSocket)
throws IOException
{
int localport = serverSocket.getLocalPort();
// get local ip address
InetAddress inetaddress = serverSocket.getInetAddress();
InetAddress localip;
try {
localip = inetaddress.getLocalHost();
} catch(UnknownHostException e) {
debugPrint("Can't get local host");
return false;
}
// get ip address in high byte order
byte[] addrbytes = localip.getAddress();
// tell server what port we are listening on
short addrshorts[] = new short[4];
// problem: bytes greater than 127 are printed as negative numbers
for(int i = 0; i <= 3; i++) {
addrshorts[i] = addrbytes[i];
if (addrshorts[i] < 0)
addrshorts[i] += 256;
}
/**
* True if the given response code is in the 100-199 range.
*/
private boolean isPositivePreliminaryResponse(int response)
{
return (response >= 100 && response < 200);
}
/**
* True if the given response code is in the 300-399 range.
*/
private boolean isPositiveIntermediateResponse(int response)
{
return (response >= 300 && response < 400);
}
/**
* True if the given response code is in the 200-299 range.
*/
private boolean isPositiveCompleteResponse(int response)
{
return (response >= 200 && response < 300);
}
/**
* True if the given response code is in the 400-499 range.
*/
private boolean isTransientNegativeResponse(int response)
{
return (response >= 400 && response < 500);
}
/**
* True if the given response code is in the 500-599 range.
*/
private boolean isPermanentNegativeResponse(int response)
{
return (response >= 500 && response < 600);
}
/**
* Eliminates the response code at the beginning of the response string.
*/
private String excludeCode(String response)
{
if (response.length() < 5) return response;
return response.substring(4);
}
}
</code>
3ème fichier: "Affichage" (fichier JFrame Form)
/*
* Affichage.java
*
* Created on 6 mars 2008, 20:57
*/
package Test;
import javax.swing.*;
/**
*
* @author Jérémy GRESLON
*/
public class Affichage extends javax.swing.JFrame {
/** Creates new form Affichage */
public Affichage() {
initComponents();
}
/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jPanelPhoto = new javax.swing.JPanel();
jButtonBadge = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
jPanelPhoto.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
javax.swing.GroupLayout jPanelPhotoLayout = new javax.swing.GroupLayout(jPanelPhoto);
jPanelPhoto.setLayout(jPanelPhotoLayout);
jPanelPhotoLayout.setHorizontalGroup(
jPanelPhotoLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 363, Short.MAX_VALUE)
);
jPanelPhotoLayout.setVerticalGroup(
jPanelPhotoLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 353, Short.MAX_VALUE)
);
jButtonBadge.setText("Passage du badge");
jButtonBadge.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButtonBadgeActionPerformed(evt);
}
});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap(116, Short.MAX_VALUE)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addComponent(jPanelPhoto, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(105, 105, 105))
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addComponent(jButtonBadge)
.addGap(229, 229, 229))))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(22, 22, 22)
.addComponent(jPanelPhoto, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(jButtonBadge)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
pack();
}// </editor-fold>
private void jButtonBadgeActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
//Affichage de la photo dans le panel
ImageIcon icone = new ImageIcon("C:\\Documents and Settings\\Jérémy GRESLON\\Mes documents\\Photos_telechargees\\25.jpg");
JLabel image = new JLabel(icone);
image.setSize(jPanelPhoto.getWidth(), jPanelPhoto.getHeight());
jPanelPhoto.add(image);
jPanelPhoto.repaint();
}
/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Affichage().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButtonBadge;
private javax.swing.JPanel jPanelPhoto;
// End of variables declaration
}
Pourriez-vous me modifier mon code ?
Merci beaucoup d'avance.
A voir également:
Appeler une fonction qui est dans une Java Class à partir d'un fichier JFrame Fo
