Splitting And Joining A Binary File In ColdFusion : Kinky Solutions : A Student's Perspective by Ben Nadel

Splitting And Joining A Binary File In ColdFusion

Posted October 31, 2007 at 11:46 AM

I was just reading over on CF-Talk that Shane Trahan was trying to split a binary file, write both parts to disk, and then later read them in and re-join them. I have never done anything like this, so I thought I would give it a try.

At first, I was going to use a few ColdFusion arrays, but that didn't seem to work. For one, ColdFusion arrays are not really arrays, they are Java Collections. Additionally, I think there were some data type conversions taking place that I was not away of. I don't know enough about Java to full understand all the data type stuff.

After a little bit of Googling, I found the Java ByteBuffer. This finally solved the problem! The ByteBuffer does all the heavy lifting for splitting and then joining the underlying byte arrays of the binary file. Check out my solution below:

Launch code in new window » Download code as text file »

<cffile
action="readbinary"
file="#ExpandPath( './sexy.jpg' )#"
variable="binFile"
/>
<cfset intLength = ArrayLen( binFile ) />
<!---
Get the mid point of the byte array. We are goint
to use this as the split point for our two future
binary files.
--->
<cfset intMid = Ceiling( intLength / 2 ) />
<!---
Now, we are going to use the Java ByteBuffer to do the
heavy lifting for us. We can't use ColdFusion arrays
directly for manipulation since they are not really
arrays, but rather Collections (and there's probably
other complications). The Java ByteBuffer will take
care of splitting and then later joining our files.
Create an instance of the static ByteBuffer class so
that we can refer to it multiple times.
--->
<cfset objByteBuffer = CreateObject(
"java",
"java.nio.ByteBuffer"
) />
<!---
Using the ByteBuffer class, create two byte buffer
instances for our two file parts. Because we are
splitting the original file, we only need to allocate
space equal to half of the original file (since we
used Ceiling() in our split).
--->
<cfset objBufferA = objByteBuffer.Allocate(
JavaCast( "int", intMid )
) />
<cfset objBufferB = objByteBuffer.Allocate(
JavaCast( "int", intMid )
) />
<!---
Now that we have our two ByteBuffer instance, we are
going to store half of the original binary byte array
into each.
--->
<cfset objBufferA.Put(
binFile,
JavaCast( "int", 0 ),
JavaCast( "int", intMid )
) />
<cfset objBufferB.Put(
binFile,
JavaCast( "int", intMid ),
JavaCast( "int", (intLength - intMid) )
) />
<!---
Now, all we have to do is write the two byte arrays to
disk. In order to get the byte arrays from the ByteBuffer,
we just need to call its underlying Array() method.
--->
<cffile
action="write"
file="#ExpandPath( './sexy_a.jpg' )#"
output="#objBufferA.Array()#"
/>
<cffile
action="write"
file="#ExpandPath( './sexy_b.jpg' )#"
output="#objBufferB.Array()#"
/>
<!---
ASSERT: At this point, we have taken our original binary
file and split it up into two parts that have been written
back to disk. Now, we can go about testing this by reading
them in again, joinging the individual byte arrays, and
then streaming to the client.
--->
<cffile
action="readbinary"
file="#ExpandPath( './sexy_a.jpg' )#"
variable="binFileA"
/>
<cffile
action="readbinary"
file="#ExpandPath( './sexy_b.jpg' )#"
variable="binFileB"
/>
<!---
Again, we are going to create a Java ByteBuffer to do the
heavy lifting for us. This time, we need to allocate space
for the resultant byte array which will be equal to the
length of both binary files.
--->
<cfset arrBinFull = objByteBuffer.Allocate(
JavaCast(
"int",
(ArrayLen( binFileA ) + ArrayLen( binFileB ) )
)
) />
<!---
Add the entire first file's byte array to the byte buffer
using a zero offset and full length.
--->
<cfset arrBinFull.Put(
binFileA,
JavaCast( "int", 0 ),
JavaCast( "int", ArrayLen( binFileA ) )
) />
<!---
Add the entire second file's byte array to the byte buffer
using a zero offset and full length.
--->
<cfset arrBinFull.Put(
binFileB,
JavaCast( "int", 0 ),
JavaCast( "int", ArrayLen( binFileA ) )
) />
<!---
At this point, our Java ByteBuffer should now contain
the entire byte array the we had in our original file.
To prove this, we are going to get the underlying byte
array and stream it to the client.
--->
<cfcontent
type="image/jpeg"
variable="#arrBinFull.Array()#"
/>

Now, I am not sure if this is a good way to do it, but the code seems fairly straight forward.

Download Code Snippet ZIP File

XPath Support Expanded In ColdFusion 8

Happy Halloween From Kinky Solutions

Adobe ColdFusion 8.0.1 Update - Helping Programmers To Be Signifanctly Less Girlie - Download ColdFusion 8 Update 8.0.1 Now.

Reader Comments

I'm assuming the file splitting is for BLOBs?

Posted by Todd Rafferty on Oct 31, 2007 at 3:25 PM

@Todd,

To be honest, I am not sure what the original intent was. However, I assume that it all shows up as a byte array in one form or another, so I guess whether it's a BLOB or binary file read, the same algorithm (or slightly modified) can be used.

Posted by Ben Nadel on Oct 31, 2007 at 3:28 PM

Another excellent example of ColdFusion and Java rocking like it's 1999. Much obliged!

Splitting and joining binary files is quite useful when you're uploading or downloading files. You can also build a file one byte at a time with classes like BufferedInputStream, but that's a whole other story. :)

You used ArrayLen to get the size of the binary file. Any idea on how exactly this works?

Posted by David Stamm on Nov 1, 2007 at 2:11 PM

I just noticed: your comment for the first CreateObject call says: "Create an instance of the static ByteBuffer class so that we can refer to it multiple times."

I think it's more accurate to say you are loading the ByteBuffer class so that you can call its static methods.

Static methods are the closest that Java comes to global functions. The methods are not called on a particular ByteBuffer object (or instance) - they're just there.

Posted by David Stamm on Nov 1, 2007 at 2:14 PM

@Dave,

ArrayLen() works because I think the binary file is loaded as a proper Java array of the bytes. I say "proper" array because it's not a ColdFusion array (Collection), it's a real byte array as in Byte[] ... I think :)

This is all just guess work for me, though. I defer to you for the better Java explanation as your Java experience eclipses mine.

Posted by Ben Nadel on Nov 2, 2007 at 7:23 AM

@Ben,

I just took a binary variable created with <cffile action="readbinary"> and looked under the hood with my handy getClassInfo() reflection function. The variable is an instance of this Java class:

WTF? Anyone know what a [B is? Some sort of pointer? The class implements the Serializable and Cloneable interfaces, if that is any help.

Posted by David Stamm on Nov 2, 2007 at 10:19 AM

@Dave,

I believe the "[" indicates an array and whatever comes after it is the type of array. Like sometimes, I think I get "[String" which is an array of strings.

Posted by Ben Nadel on Nov 2, 2007 at 10:27 AM

Post Comment | Ask Ben

Splitting And Joining A Binary File In ColdFusion : Kinky Solutions : A Student's Perspective by Ben Nadel