{"id":55351,"date":"2010-10-14T14:47:00","date_gmt":"2010-10-14T18:47:00","guid":{"rendered":"https:\/\/spin.aa8q45el-liquidwebsites.com\/2010\/10\/14\/toolsmithing-java-with-jruby"},"modified":"2018-03-13T13:37:55","modified_gmt":"2018-03-13T17:37:55","slug":"toolsmithing-java-with-jruby","status":"publish","type":"post","link":"https:\/\/spin.atomicobject.com\/toolsmithing-java-with-jruby\/","title":{"rendered":"Toolsmithing Java with JRuby"},"content":{"rendered":"

\"Perfect<\/a>JRuby<\/a> is my favorite Java tool. It lets me wield the power of Java libraries while building tools and abstractions to speed development.<\/p>\n

On a current project, I\u2019m using JAXB2<\/span><\/a> to bind a large set of deeply-nested XML<\/span> Schemas into Java classes. I have a Rake task to create the classes from the xsd files and bundle them into a jar. From there, I import the classes into JRuby where the software uses them to interact with other systems via XML<\/span> marshaling.<\/p>\n

Ruby on its own doesn\u2019t have this power. Integrating with existing J2EE<\/span> systems, marshaling complex XML<\/span> files based on multi-layered schema definitions: this is the definition of \u201cheavy-lifting.\u201d So I let Java do that for me. Then I can orchestrate from the podium of JRuby. Now I have tools for language-building, leading-edge testing libraries, and breezy syntax to get work done easier. The power comes from being able to build on the foundation of existing Java tools in JRuby.<\/p>\n

For instance, accessing useful bits of info from these JAXB2<\/span>-generated classes means using complex chains of object properties. In my case, I get over 350 classes that are inter-composed and contain only simple getters and setters. I need to wrangle them easily for my RSpec specifications and my Cucumber features, as well as to make my actual code as simple and expressive as possible.<\/p>\n

A common use case for these classes involves reading some property using a deeply-nested getter. In Java, this would look like this:<\/p>\n\n\n\n
\n
\r\n<\/tt><\/pre>\n<\/td>\n
\n
String<\/span> name = customerResponse.getTransaction().getPerson().getName().getFirstName();<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
in JRuby, it could look like this:<\/p>\n\n\n\n
\n
\r\n<\/tt><\/pre>\n<\/td>\n
\n
name = customer_response.transaction.person.name.first_name<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
This is already a small improvement, but what about when I need to set that value? Since much of my XML<\/span> structure is optional, the intermediate objects are frequently not present. With Java, this is where things get messy:<\/p>\n\n\n\n
\n
1\r\n<\/tt>2\r\n<\/tt>3\r\n<\/tt>4\r\n<\/tt>5\r\n<\/tt>6\r\n<\/tt>7\r\n<\/tt>8\r\n<\/tt><\/pre>\n<\/td>\n
\n
Transaction transaction = new Transaction();\r\n<\/tt>Person person = new Person();\r\n<\/tt>Name name = new Name();\r\n<\/tt>String<\/span> firstName = \"<\/span>Marshal<\/span>\"<\/span><\/span>;\r\n<\/tt>name.setFirstName(firstName);\r\n<\/tt>person.setName(name);\r\n<\/tt>transaction.setPerson(person);\r\n<\/tt>customerResponse.setTransaction(transaction);<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Ugh. I feel less alive for having typed all that. Luckily JRuby offers some help out of the box:<\/p>\n\n\n\n
\n
1\r\n<\/tt>2\r\n<\/tt>3\r\n<\/tt>4\r\n<\/tt><\/pre>\n<\/td>\n
\n
customer_response.transaction = Transaction<\/span>.new\r\n<\/tt>customer_response.transaction.person = Person<\/span>.new\r\n<\/tt>customer_response.transaction.person.name = Name<\/span>.new\r\n<\/tt>customer_response.transaction.person.name.first_name = '<\/span>Marshal<\/span>'<\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Still not very DRY<\/span>. So here\u2019s where I can put on my toolsmith<\/a> hat. I wrote a utility that makes this sort of chained access easier. Here\u2019s what the above code looks like now:<\/p>\n\n\n\n
\n
\r\n<\/tt><\/pre>\n<\/td>\n
\n
customer_response.set_chain [:transaction<\/span>, :person<\/span>, :name<\/span>, :first_name<\/span>], [Transaction<\/span>.new, Person<\/span>.new, Name<\/span>.new, '<\/span>Marshal<\/span>'<\/span><\/span>]<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Here\u2019s the utility that makes that possible: set_chain<\/a><\/p>\n