Verifying data

Question

I have a 3 step process.
1. pars file to db
2. send db data to 3rd party crm.
I'd like to have some sort of checksum on the data.
I'm thinking pull a few lines from the raw files and save it, then query the db and the crm for those records.
Any suggestions?

Answer 1

This should help you get started. IoHelper is just a separate class that closes an I/O stream and logs any exceptions it encounters.
public final class DigestHelper extends Object
    /** Default one-way hash algorithm. */
    private static final String ALGORITHM = "SHA-256";
    /** Default hash buffer size. */
    private static final int BUFFER_SIZE = 2048;
    /** Maximum in-memory hash (2 megabytes). */
    private static final int MAX_LENGTH = 2 * 1056 * 1056;
     * Private constructor.  Class is stateless.
    private DigestHelper()
        super();
     * Calculates the one-way hash (digest) on a given input stream of any length.
     * The algorithm used with be SHA-256.  This method will invoke <code>close()#</code>
     * on the input stream passed in.
     * @param   target                      Input stream to hash
     * @return  byte[]                      One-way hash
     * @throws  IOException
    public static final byte[] computeOneWayHash(final InputStream target)
        throws IOException
        assert (target != null) : "Missing input stream";
        byte[] buffer = new byte[BUFFER_SIZE];
        DigestInputStream in = null;
        try
            in = new DigestInputStream(target, getMessageDigest());
            int bytesRead = in.read(buffer);
            while (bytesRead >= 0)
                bytesRead = in.read(buffer);
            return in.getMessageDigest().digest();
        finally
            IoHelper.close(target);
     * Calculates the one-way hash (digest) on a given string.
     * The algorithm used with be SHA-256
     * @param   target                      String to hash
     * @return  byte[]                      One-way hash
    public static final byte[] computeOneWayHash(final String target)
        return computeOneWayHash(target.getBytes());
     * Calculates the one-way hash (digest) on a given byte array.
     * The algorithm used with be SHA-256
     * @param   target                      Binary to hash
     * @return  byte[]                      One-way hash
    public static final byte[] computeOneWayHash(final byte[] target)
        assert (target != null) : "Missing byte array";
        assert (target.length < MAX_LENGTH) : "Target exceeds maximum allowable in memory size";
        return getMessageDigest().digest(target);
     * Helper method to create a message digest to calculate one-way hashes.
     * @return  MessageDigest    Digester
    private static MessageDigest getMessageDigest()
        try
            return MessageDigest.getInstance(ALGORITHM);
        catch (NoSuchAlgorithmException e)
            throw new ConfigurationError("Unable to create " + ALGORITHM + " one-way hash", e);
}- Saish