browser.java

Java项目案例导航源代码

import javax.naming.*;
import java.io.*;
import java.util.*;

/**
 * Interactive directory structure browser.
 */
public class Browser {

	/**
	 * Main() is just a wrapper that starts the directory browsing.
	 */
        public static void main (String[] args) {
		try {
			new Browser().browse();
		}
		catch (Exception e) {
			System.err.println(e);
			e.printStackTrace();
		}
	}

	// Initial Context
	protected Context ctx;

	// This JNDI Name object is used to track the current
	// context (folder) we're in as we traverse the directory tree
	protected Name currName;

	// We use a NameParser to generate Name objects for us.
	// A NameParser knows how to construct a Name using
	// a proprietary service provider syntax, such as
	// "c:\winnt" for the File System service provider, or
	// "cn=Ed Roman, ou=People, o=Airius.com" for the LDAP
	// service provider.
	protected NameParser parser;

	/*
	 * Constructor called from main().  Initializes things.
	 */
	public Browser() throws Exception {
	 	/*
		 * 1) Create the initial context.  Parameters are
	 	 *    supplied in the System properties.
		 */
		ctx = new InitialContext(System.getProperties());
	 
		/*
	 	 * 2) Get the NameParser from the service provider.
		 */
		parser = ctx.getNameParser("");
	 
		/*
		 * 3) Use the NameParser to create the initial location
		 *    of where we are in the directory structure.  Since
		 *    the NameParser is service provider specific, the
		 *    resulting Name object will be formatted to a
		 *    specific directory syntax.
		 */
		currName = parser.parse("");
	}

	/**
	 * Call to begin browsing the file system directory structure.
	 * This method isn't important, it just interacts with the user.
	 */
	public void browse() {
	
		/*
		 * Start reading input from standard input
		 */	
		String line = null, command = null, args = null;
		StringTokenizer tokens = null;
                BufferedReader reader =
		 new BufferedReader(new InputStreamReader(System.in));

                while (true) {

			/*
			 * Print prompt, read next input line,
			 * and get command
			 */
			try {
				System.out.println();
				System.out.print(currName + "> ");
                        	line = reader.readLine();
				System.out.println();
                        	tokens =
				 new StringTokenizer(line, " ", false);
                       		
				// Get command.  e.g. "cd" in "cd .."
				command = tokens.nextToken();

				// Get arguments.  e.g. ".." in "cd .."
				if (tokens.hasMoreElements()) {
					args = line.substring(
					 command.length()+1,
					 line.length());
				}
			}
			catch (Exception e) {
				continue;
			}
		
			/*
			 * Do case analysis based upon command.  Call
			 * the corresponding JNDI function.
			 */
			try {
				if (command.equals("ls")) {
					ls();
				}
				else if (command.equals("mv")) {
					/*
					 * Figure out the name of the
					 * context the user is trying
					 * to rename (mv)
					 */
					String oldStr = null,
					       newStr = null;
					try {
						StringTokenizer argtokens = new StringTokenizer(args, " ", false);
						oldStr = argtokens.nextToken();
						newStr = argtokens.nextToken();
					}
					catch (Exception e) {
						throw new Exception("Syntax: mv <old context> <new context>");
					}

					mv(oldStr, newStr);
				}
				else if (command.equals("cd")) {
					cd(args);
				}
				else if (command.equals("mkdir")) {
					mkdir(args);
				}
				else if (command.equals("rmdir")) {
					rmdir(args);
				}
				else if (command.equals("cat")) {
					cat(args);
				}
				else if (command.equals("quit")) {
					System.exit(0);
				}
				else {
					System.out.println("Syntax: [ls|mv|cd|mkdir|rmdir|cat|quit] [args...]");
				}
			}
			catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Lists the contents of the current context (folder)
	 */
	private void ls() throws Exception {
		// Get an enumeration of Names bound to this context
		NamingEnumeration e = ctx.list(currName);

		// Each enumeration element is a NameClassPair.
		// Print the Name part.
		while (e.hasMore()) {
			NameClassPair p = (NameClassPair) e.next();
			System.out.println(p.getName());
		}
	}
	
	/**
	 * Navigate the directory structure
	 */
	private void cd(String newLoc) throws Exception {
		if (newLoc == null) {
			throw new Exception("You must specify a folder");
		}
	
		// Save the old Name, in case the user tries to cd
		// into a bad folder.
		Name oldName = (Name) currName.clone();
	
		try {
			/*
			 * If the user typed "cd ..", pop up one
			 * directory by removing the last element from
			 * the Name.
			 */
			if (newLoc.equals("..")) {
				if (currName.size() > 0) {
					currName.remove(currName.size()-1);
				}
				else {
					System.out.println(
					 "Already at top level.");
				}
			}

			/*
			 * Otherwise, the user typed "cd <folder>".  Go
			 * deeper into the directory structure.
			 *
			 * Note that we use "addAll()" which will add every
			 * atomic folder name into the total name.  This means
			 * when we type "cd .." later, we will only traverse
			 * down one folder.
			 */
			else {
				currName.addAll(parser.parse(newLoc));
			}

			/*
			 * Confirm our traversal by trying to do a lookup()
			 * operation after we've popped out a directory.  If
			 * lookup() fails, we need to restore the directory
			 * Name to what it was, and throw an exception.
			 */
			ctx.lookup(currName);
		}
		catch (Exception e) {
			currName = oldName;
			throw new Exception("Cannot traverse to desired directory: " + e.toString());
		}
	}
	
	/**
	 * Renames (moves) one context to a new name.
	 *
	 * @param oldStr the old context
	 * @param newStr the new context
	 */
	private void mv(String oldStr, String newStr) throws Exception {

		/*
		 * Navigate to the current context (folder)
		 */	
		Context currCtx = (Context) ctx.lookup(currName);

		/*
		 * Rename the subcontext
		 */
		currCtx.rename(oldStr, newStr);
	}
	
	/**
	 * Makes a subfolder (subcontext)
	 */
	private void mkdir(String str) throws Exception {
		Context currCtx = (Context) ctx.lookup(currName);
		currCtx.createSubcontext(str);
	}
	
	/**
	 * Removes a subfolder (subcontext)
	 */
	private void rmdir(String str) throws Exception {
		Context currCtx = (Context) ctx.lookup(currName);
		currCtx.destroySubcontext(str);
	}

	/**
	 * displays a file (specific to File System service provider)
	 */
	private void cat(String fileStr) throws Exception {
	
		/*
		 * Append the filename to the folder string
		 */	
		Name fileName = (Name) currName.clone();
		fileName.addAll(parser.parse(fileStr));	
	
		/*
		 * Use JNDI to get a File Object reference
		 */	
		File f = (File) ctx.lookup(fileName);

		/*
		 * Print out file contents
		 */
        	FileReader fin = new FileReader(f);
        	Writer out = new PrintWriter(System.out);
        	char[] buf = new char[512];
        	int howmany;
        	while ((howmany = fin.read(buf)) >= 0) {
        		out.write(buf, 0, howmany);
		}			
		out.flush();
		fin.close();
	}
}