Welcome to my website. I am always posting links to photo albums, art, technology and other creations. Everything that you will see on my numerous personal sites is powered by the formVistaTM Website Management Engine.

icon.linkedin.jpgicon.twitter.jpg

  • Subscribe to this RSS Feed
  • Java: How To Use RandomAccessFile and FileChannel to Write to a Specific Location in a File
    10/06/2011 11:32AM

    If there is ever a need to write bytes to a specific location to an existing file, here is an example of how to use the RandomAccessFile and FileChannel Java classes to do so:

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.RandomAccessFile;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;

    /**
     * Will write bytes to the beginning of an existing file.
     *
     * @author Ryan Chapin
     */
    public class RandomAccessFileTest {

        public static void main(String[] args) {

            // Generate input string and the ByteBuffer for it
            String stringToInsert = "This is a string to insert into a file.";
            byte[] answerByteArray = stringToInsert.getBytes();
            ByteBuffer byteBuffer = ByteBuffer.wrap(answerByteArray);

            File fileToModify = new File("/path/to/file");

            RandomAccessFile randomAccessFile = null;
            try {
                randomAccessFile = new RandomAccessFile(fileToModify, "rw");
            } catch (FileNotFoundException e1) {
                // TODO error handling and logging
            }

            FileChannel outputFileChannel = randomAccessFile.getChannel();

            // Move to the beginning of the file and write out the contents
            // of the byteBuffer.
            try {
                outputFileChannel.position(0);

                while(byteBuffer.hasRemaining()) {
                    outputFileChannel.write(byteBuffer);
                }
            } catch (IOException e) {
                // TODO error handling and logging
            }

            try {
                outputFileChannel.close();
            } catch (IOException e) {
                // TODO error handling and logging
            }

            try {
                randomAccessFile.close();
            } catch (IOException e) {
                // TODO error handling and logging
            }
        }
    }

  • Using a ProcessBuilder to Execute an OS Level Command and Properly Read the Exit Code from a Java Process
    10/06/2011 10:42AM

    There are many a situation where a developer will want to execute an OS level command in another process and read not only the standard out (stdout), and standard error (sterr), but also the exit code returned from the process.

    To do so, utilize the ProcessBuilder class along with a helper class (ProcessWrapper) that will provide the ability to set a timeout for the process and read the exit code in a separate thread.

    Following is an example and the ProcessWrapper class with an explaination:

    import java.io.IOException;

    public class ProcessBuilderTest {

        /**
         * Time in milliseconds that we will wait for the process to complete before
         * timing out and killing it.
         */
        private static final long fTimeout = 10000;

        public static void main(String[] args) {

            String[] commandArray = { "some", "command" };

            ProcessBuilder processBuilder = new ProcessBuilder(commandArray);

            Process process = null;
            try {
                process = processBuilder.start();
            } catch (IOException e) {
                // TODO: Error handling, logging
            }

            // --------------------------------------------------------------------
            // Read the exit code from the fProcess
            ProcessWrapper processWrapper = new ProcessWrapper(process);
            processWrapper.start();

            int exitCode = 0;
            try {
                processWrapper.join(fTimeout);

                // Check for an exit code from the process
                if (processWrapper.getfExitCode() != null) {
                    exitCode = processWrapper.getfExitCode();
                } else {
                    // Set our exit code to 1
                    exitCode = 1;
                    process.destroy();
                }
            } catch (InterruptedException e) {
                processWrapper.interrupt();
                Thread.currentThread().interrupt();
                process.destroy();
            }

            System.out.print("exitCode = " + exitCode);
        }

        public static class ProcessWrapper extends Thread {

            private final Process fProcess;

            private Integer fExitCode;

            public Integer getfExitCode() {
                return fExitCode;
            }

            public ProcessWrapper(Process fProcess) {
                this.fProcess = fProcess;
            }

            public void run() {
                try {
                    fExitCode = fProcess.waitFor();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    In the ProcessBuilderTest main() method the command to be executed is build in the commandArray String[].

    A ProcessBuilder instance is created and passed the command to execute. Then a Process instance providing a reference to the process running on the OS is instantiated via the ProcessBuilder.start() command.

    Here is where the wrapper class that helps us to read the exit code comes in. A ProcessWrapper is instantiated and passed a reference to the process on construction, and then the thread started with the .start() invocation.

    Then processWrapper.join(fTimeout) is invoked telling the current thread to wait for the completion of the processWrapper thread, or interrupt it (timeout) after the value of fTimeout (in this case 10 seconds).

    If the processWrapper thread completes before the timeout the main thread invokes processWrapper.getfExitCode(), to acquire the exit code from the process. If not, the process is killed and we pass an exitCode of 1 to indicate abnormal completion.

    Attached is a .zip of the java classes for reference and testing.

    Attachment: processbuildertest.zip 1308 bytes
  • Dynamically Instantiating Classes in Java
    09/16/2011 11:42AM

    There are a number of cases when you may not know exactly what class you will be instantiating and want to be able to dynamically instatiate specific classes based on a configuration file or a condition during runtime.

    To do so, you will need to define an Interface for your classes and can then use the following code as a guide:

    String className = args[0];
    String qualifiedClassName = null;
    Class instanceClass = null;

    try {
            qualifiedClassName = fClassPackage.getName() + "." + className;
            instanceClass = Class.forName(qualifiedClassName);
    } catch(ClassNotFoundException e) {
            e.printStackTrace();
    }

    Interface dynamicInstance = null;

    try {
            dynamicInstance = (Interface) instanceClass.newInstance();
    } catch(InstantiationException e) {
            e.printStackTrace();
    } catch (IllegalAccessException e) {
            e.printStackTrace();
    }

    // Set fields in new instance
    dynamicInstance.setSomething("foo");


    Keep in mind that dynamically instantiated classes must include a no argument constructor.  As a result, you will need to have mutator methods for each field that requires configuration in your class.


  • Regular Expression Library
    09/16/2011 11:35AM
  • Preserving File Permissions When Copying Files with Ant
    09/16/2011 9:16AM

    If you want to retain the file permissions of a file that you copy with ant you must use the <exec> command instead of? <copy>.

    So, instead of:

    <copy file="${source.file}" tofile="${dest.path}/${dest.file}" overwrite="true"/>

    Use:

    <exec executable="cp">
    ??? <arg value="-pf"/>
    ??? <arg value="${source.file}"/>
    ??? <arg value="${dest.path}/${dest.file}"/>
    </exec>

Advanced Search

Categories

Archives