can anyone write a coding for this problem please ? Write an application or appl
ID: 3644288 • Letter: C
Question
can anyone write a coding for this problem please ?Write an application or applet that implements a simple text editor. Use a text field and a button to get the file. Read the entire file as characters and display it in the JTextArea. The user will then be able to make changes in the text area. Use a Save button to get the contents of the text area and write that over the original file. Create an Exit button to exit the application.
Technical Details: Read each line from the file and then display the line in the text area using the method append (aString). The method getText will return all of the text in the text area in a string that then can be written to the file. The following statement will make the text referenced by editorTextArea scrollable:
JScrollPane scrollPane = new JScrollPane(editorTextArea);
Then add scrollPane to your GUI, just as you would add any other component. The text area editorTextArea does not need to be added to the GUI, but it can be used.
it would be nice if you sent me the coding to my email please!!!!! javasteve3@gmail.com as text format..... thanks a lot
Explanation / Answer
import java.io.*; import java.net.*; import java.util.ArrayList; /** * A BuddyChatServer keeps a list of available BuddyChat users and makes that list * available to each user that has registered itself on the list. The list is a list * of users who are willing to "chat" with other users. Each user provides a port * on which it can be contacted; an ip address for the user is taken from the user's * connection to the server. The user also specifies a "handle", which is the name * under which the user will appear in the buddy lists. The server creates a "secret" * for each user, which is a password that must be sent by other users who wish to * connect to that user. When the user connects to the server, the server sends a * list of all users that are connected to the server. Whenever a user is added to * or deleted from the list, that change is sent to all connected users so that * they can keep their buddy lists updated. *The protocol for establishing a connection from a client to the server is: * (1) server sends string "BuddyChatServer"; (2) client sends string "BuddyChatClient"; * (3) client sends its handle; (4) client sends its port; (5) server creates a * secret for the client and sends it to the client. All messages are terminated * by line feeds. *
Once a connection is established, the server sends a list of connected users * to the client. (This list does not inlude the client itself.) The format for * a list of users is (1) the word "clients" on a line by itself; (2) one line of infor * for each client; (3) the word "endclients" on a line by itself. The client * info consits of pieces of information: the client's handle, ip address, port * number, and secret. These are separated by "~" characters. There are no spaces * or "~" characters in the info (the user's handle is modified to make this true, * if necessary). *
The connection between server and client remains open until the client * closes it (or the server goes down). The client can send the following two * messages to the server: (1) "ping" (and the server responds by sending * "pingresponse" -- this is a way of checking that the connection is still in * place); (2) "refresh" (and the server responds by sending the complete list * of connected clients, omitting the client who sent the "refresh" command). * The server sends the following additional messages, with no response expected * from the client. (1) "ping"; (2) "addclient" followed on the next line by * the info string for the newly added client; (3) "removeclient" followed on * the next line by the info string of the client who has been removed. *
In addition to this, the server can be shut down gracefully by connecting * to the server, receciving the message "BuddyChatServer", sending "BuddyChatClient", * then sending the shutdown string as a message. The shutdown string is a * random-looking string that is not likely to be used as a handle. It is stored, * if possible, in a file named ".BuddyChatServer_shutdown_string_port" in the home * directory of the user who runs the server, where "port" is replaced by the * port number on which the server is listening. If it is not possilbe to save the * shutdown string, a default string is used. The file is deleted when the server * shuts down. *
The server listens for client connections on a default port number, but a * different listening port can be specified on the command line. */ public class BuddyChatServer { private static final int DEFAULT_PORT = 12001; private static final String DEFAULT_SHUTDOWN_MESSAGE ="skRl@(Gjfd908.89d&*hgfd"; private static String shutdownString; // The actual shutdown string. private static int listeningPort; private static ServerSocket listener; private static ClientList clients; // Connected clients; ClientList is a nested class. private volatile static boolean isShutDown; /** * Main routine starts a listener and listens for connections until the * server is shut down or an error occurs. * @param args an alternative listening port can be specified on the command line. */ public static void main(String[] args) { listeningPort = DEFAULT_PORT; if (args.length > 0) { try { int p = Integer.parseInt(args[0]); if (p 65535) throw new NumberFormatException(); listeningPort = p; } catch (NumberFormatException e) { } } try { listener = new ServerSocket(listeningPort); } catch (Exception e) { System.out.println("Can't create listening socket on port " + listeningPort); System.exit(1); } System.out.println("Listening on port " + listeningPort); clients = new ClientList(); getShutdownString(); try { while (true) { // Listen until error occurs or socket is closed. Socket socket = listener.accept(); clients.add( socket ); } } catch (Throwable e) { if (!isShutDown) { // Don't report an error after normal shutdown. System.out.println("Server closed with error:"); System.out.println(e); } } finally { System.out.println("Shutting down."); clients.shutDown(); } } /** * Tries to create a unique shutdown string and write it to a file, * so that it can be used by the BuddyChatServerShutdown program. */ private static void getShutdownString() { File file = new File(System.getProperty("user.home"), ".BuddyChatServer_shutdown_string_" + listeningPort); shutdownString = DEFAULT_SHUTDOWN_MESSAGE + Math.random(); try { if (file.createNewFile()) { file.deleteOnExit(); PrintWriter out = new PrintWriter(new FileWriter(file)); out.println(shutdownString); out.close(); } else { BufferedReader in = new BufferedReader(new FileReader(file)); String line = in.readLine(); if (line.startsWith(DEFAULT_SHUTDOWN_MESSAGE)) shutdownString = line; } } catch (Exception e) { shutdownString = DEFAULT_SHUTDOWN_MESSAGE; } } /** * Utility routine for converting the ip address of an InetAddress * to its usual string form. */ private static String convertAddress(InetAddress ip) { byte[] bytes = ip.getAddress(); if (bytes.length == 4) { String addr = "" + ( (int)bytes[0] & 0xFF ); for (int i = 1; i < 4; i++) addr += "." + ( (int)bytes[i] & 0xFF ); return addr; } else if (bytes.length == 16) { String[] hex = new String[16]; for (int i = 0; i < 16; i++) hex[i] = Integer.toHexString( (int)bytes[i] & 0xFF ); String addr = "" + hex[0] + hex[1]; for (int i = 2; i < 16; i += 2) addr += ":" + hex[i] + hex[i+1]; return addr; } else throw new IllegalArgumentException("Unknown IP address type"); } /** * A list of all the currently connected clients, with some routines for * adding and removing clients. The routines are synchronized, since * they can be called from multiple client threads. */ private static class ClientList { ArrayList clientList = new ArrayList(); // The clients. /** * Add a new client, already connected through the socket. No information * has been exchanged over the socket, so the identity of the client is * unknown. When the client thread has obtained client info, it will * call the announceConnection() method. Clients that are not yet fully * connected have c.info == null; such clients are not part of the client * lists that have been sent to other clients. */ synchronized void add(Socket socket) { Client c = new Client(socket); System.out.println("Client " + c.clientNumber + " created."); clientList.add(c); } /** * Remove a client. This is called by the client thread when the connection * to the client closes. If the client was fully connected (client.info != null), * then a report is sent to other clients. However, no messages are sent * if the server is shutting down. */ synchronized void remove(Client client) { System.out.println("Client " + client.clientNumber + " removed."); if (!isShutDown && clientList.remove(client) && client.info != null) { for (Client c : clientList) c.clientRemoved(client); } } /** * This is called when info about a client has been obtained. It sends * a report of the newly added client to all connected clients. */ synchronized void announceConnection(Client newlyConnectedClient) { System.out.println("Client " + newlyConnectedClient.clientNumber + " connection established with info " + newlyConnectedClient.info); for (Client c : clientList) c.clientAdded(newlyConnectedClient); } /** * Return a copy of the ArrayLisit of clients. (The copy won't be * modified asynchronously like the original list can be.) */ synchronized ArrayList copy() { ArrayList c = new ArrayList(); for (Client client : clientList) c.add(client); return c; } /** * This is called by the main program to shut down connections to all * the clients when the server is shutting down. This will allow all * the client threads to die, so that the program can end. */ synchronized void shutDown() { for (Client client : clientList) client.shutDown(); } } // end nested class ClientList /** * Each connected client is represented by an object of type Client. * Each client has a connected socket and TWO threads, one for reading from * the socket and one for writing to it. The writing thread is the * main thread, which is also responsible for setting up the connection. */ private static class Client { static int clientsCreated; // How many clients have been created. int clientNumber; // Clients are numbered 1, 2, ... as they are created. volatile String info; // Info string that contains all important info about // this client, of the form handle~ip~port~secret; // this is the info string that is sent to other clients. // It is constructed by the main client thread. String messageOut = ""; // Message waiting to be sent by writer thread. // Note that access to messageOut is synchronized on // this Client object. Whenever a message is added // to this string, notify() is used to wake the writer // thread so that it can send the message. It is // possible that several messages might be added to // the string before it gets sent. ClientThread clientThread; // Writer thread, also sets up connection. ReaderThread readerThread; String secret; Socket socket; volatile boolean connected; volatile boolean closed; /** * Construct a client; make its "secret" string, and create its main thread. */ Client(Socket socket) { clientsCreated++; clientNumber = clientsCreated; secret = clientNumber + "!" + Math.random(); this.socket = socket; clientThread = new ClientThread(); clientThread.start(); } /** * Called by the ClientList when a client is removed. * Sends an announce of the removed client to this client. */ void clientRemoved(Client c) { if (c != this) { send("removeclient " + c.info + ' '); } } /** * Called by the ClientList when a new client (with its info string) * becomes available. Sends an announce of the new client to this client. */ void clientAdded(Client c) { if (c != this) { send("addclient " + c.info + ' '); } } /** * Called by ClientList when the server is shutting down; * Closes this client's socket (which terminates the reader thread) * and wakes up the writer thread so it can terminate. */ synchronized void shutDown() { if (! closed) { closed = true; try { socket.close(); } catch (Exception e) { } synchronized(this) { notify(); // Notifies writer thread. } } } /** * Called when either the reader or writer thread shuts down. This * can happen because of an error or because the connection is closed * from the other side. (It will also be called during server shutdown.) * If connection is already closed, nothing is done. */ synchronized void close() { if (!closed) { closed = true; try { socket.close(); } catch (Exception e) { } notify(); clients.remove(this); } } /** * Schedule a message to be sent by the writer thread. This method does * NOT actually send the message, so it does not block. (Note: NO line * feed is added to the message!) */ synchronized void send(String message) { messageOut += message; // Add message onto the waiting outgoing string. notify(); // Wake up writer thread so it can send the message. } /** * Schedule the client list to be sent by the writer thread. This method * does not actually send the list, so it does not block. */ synchronized void sendClientList() { ArrayList c = clients.copy(); messageOut += "clients "; for (Client client : c) if (client != this) messageOut += client.info + ' '; // Add info to outgoing string. messageOut += "endclients "; notify(); // Wake up writer thread so it can send the message. } /** * Defines the main client thread, which is responsible for setting up * the connection, starting the reader thread, and then writing all messages * to the client. */ class ClientThread extends Thread { public void run() { try { String ip = convertAddress(socket.getInetAddress()); PrintWriter out; BufferedReader in; out = new PrintWriter(socket.getOutputStream()); in = new BufferedReader(new InputStreamReader(socket.getInputStream())); out.println("BuddyChatServer"); out.flush(); if (out.checkError()) throw new Exception("Error while trying to send handshake to client"); String handshake = in.readLine(); if (! "BuddyChatClient".equals(handshake)) throw new Exception("Client did not properly identify itself."); String handle = in.readLine(); if (handle.equals(shutdownString)) { out.println("shutting down"); out.flush(); isShutDown = true; listener.close(); return; } handle = handle.replaceAll("~","-"); // Make sure handle contains no "~" String portString = in.readLine(); int port; try { port = Integer.parseInt(portString); } catch (NumberFormatException e) { throw new Exception("Did not receive port number from client."); } if (port 65535) throw new Exception("Illegal port number received from client."); out.println(secret); out.flush(); if (out.checkError()) throw new Exception("Error while sending initial data to client."); info = handle + "~" + ip + "~" + port + "~" + secret; info = info.replaceAll(" ","_"); // Make sure info contains no spaces. connected = true; clients.announceConnection(Client.this); // Connection has been set up. readerThread = new ReaderThread(in); readerThread.start(); sendClientList(); // First message will be the client list. while (!closed && !isShutDown) { String messageToSend; synchronized(Client.this) { // Get the message; don't synchronize the actual send. messageToSend = messageOut; messageOut = ""; } if (closed || isShutDown) break; if (messageToSend.length() == 0) messageToSend = "ping "; // if there is no message, send a "ping" out.print(messageToSend); out.flush(); if (out.checkError()) throw new Exception("Error while sending to client."); synchronized(Client.this) { if (!closed && !isShutDown && messageOut.length() == 0) { try { // sleep for about 10 minutes or until notified of a new message. Client.this.wait(10*(50+(int)(15*Math.random()))*1000); } catch (InterruptedException e) { } } } } } catch (Exception e) { if (!closed && ! isShutDown) System.out.println("Client " + clientNumber + " error: " + e); } finally { close(); } } } /** * Defines a relatively simple thread that reads messages from the client * and responds to them. This will end when the client closes the connection, * or when the socket is closed on this side (for example, when server is shutting * down). */ class ReaderThread extends Thread { BufferedReader in; ReaderThread(BufferedReader in) { this.in = in; } public void run() { try { while (true) { String messageIn = in.readLine(); if (messageIn == null) break; // connection closed from other side else if (messageIn.equals("ping")) send("pingresponse "); else if (messageIn.equals("refresh")) sendClientList(); else throw new Exception("Illegal data received from client"); } } catch (Exception e) { if (!closed && !isShutDown) System.out.println("Client " + clientNumber + " error: " + e); } finally { close(); } } } } // end nested class Client }
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.