|By York Davis||
|August 5, 2004 12:00 AM EDT||
Those familiar with the java.util.Comparator interface of the Java API realize its capabilities for sorting a collection of objects based on an attribute of the objects in the collection. This works well when there is only a single field in which sorting is required. When more complex sorting is necessary, the limitations of sorting on a single field become obvious. What about the situation in which a user desires the functionality to sort selectively on any field in object collection? This article describes an implementation of the Comparator interface that along with the reflection API allows an object to be sorted dynamically on any of its publicly accessible fields.
Let's describe the problem a bit more specifically. A collection of employee Transfer Objects (EmployeeTO class) exists. (For a description of the Transfer Object design pattern consult a software design pattern book.) Each EmployeeTO in the collection is a data container object for a single employee's information. For this example, our simplified EmployeeTO object contains only three pieces of data - employee ID, last name, and salary.
A Human Resources application also exists that uses this collection to display a list of all employee data to HR application users. The users of this system have the following requirements:
- Allow sorting on any field on the report
- Allow control of the sort order
Before delving into our dynamic sorting solution that allows sorting on any attribute, let's first look at a simple solution that supports sorting on a single attribute only. This will demonstrate the basic behaviors of Comparator and from this we'll be able to glean the improvements we wish to make. This solution utilizes the more common use of the Comparator interface. There are two classes required to implement this.
EmployeeTO - Simple Version
First, our EmployeeTO can be made sortable by implementing the Comparator interface as shown in Listing 1. In addition to the getters and setters for ID, last name, and salary, EmployeeTO must implement the compare() and equals() methods in order to meet the Comparator's requirements. These methods define how EmployeeTO is to be sorted. The compare() method takes two parameters, both of type Object. Note that compare() returns an int. This return value tells the sort engine the collating sequence equality of two attribute values from each of the object parameters passed to compare(), respectively. We need to write the code that performs this evaluation. The first step in compare() is to cast the two parameters' objects to EmployeeTO objects and extract the employee IDs by calling the getId() method on each object in turn. Now we can compare the values. There are really only three possible outcomes that can result from this comparison. Table 1 describes the results based on these outcomes.
The other method we must code is the equals() method. Although this method is not used for sorting, it must be implemented in order to meet the contract of the Comparator interface.
Sorting the Collection - Simple Version
The SimpleTest class in Listing 2 adds three EmployeeTO objects to a List, then performs a sort on that Collection. (Listings 2-5 can be downloaded from www.sys-con.com/java/sourcec.cfm.) Line 30 of SimpleTest calls the static sort() method of the Collections class to actually perform the sort as follows.
Collections.sort(elements, new EmployeeTO());
The first parameter passed to sort() is the collection object we wish to have sorted. The second parameter is an object of type Comparator that contains the customized sorting logic - in this case EmployeeTO, which implements the Comparator interface. We certainly could have passed any instance of EmployeeTO as the second parameter to the above method call. However, instead of reusing one of the three values initially added to the collection, I chose to pass a new instance of the class for purposes of clarity.
A quick note on encapsulation and responsibility assigning seems to be in order here. In this case, it makes sense to encapsulate the specific compare() method sorting logic within EmployeeTO. With the information we have thus far, EmployeeTO is the only class that requires the knowledge of how it should be sorted. Later, as a dynamic sorting solution is provided, we'll see this sorting logic moved out of the Transfer Object class as the sorting logic becomes less specific to any one particular Transfer Object implementation.
This implementation will run but falls short when it comes to meeting the user's requirements. Remember, we need to be able to sort on any one of the three fields in EmployeeTO based on a user's choice. And let's not forget about the ability to control the sort order.
Let's think about the options that are available to improve what we have and meet the requirements. One option is to code nested if/else statements in our compare() method to allow for sorting on any field in the object based on some field name parameter passed to EmployeeTO. The problem with this solution is that it's difficult to maintain and the code could get rather lengthy as well. If new fields are added to EmployeeTO, we must update compare() appropriately.
What we would really like to do is invoke any given getter method of our Transfer Object at runtime without having to specifically hard code each possible method call in the compare() method. If we could do this, we could use the results of those method calls to dynamically determine equality. In addition, it would be desirable if this dynamic sorting could be reused for any Transfer Object. The good news is that this functionality can be achieved by leveraging the reflection API and the flexibility of the Collections.sort() method.
The java.lang.reflect.Method class provides the ability to invoke a method of a given object based on the value of a string. For example, using a string containing the value "getId", the method getId() of EmployeeTO can be dynamically invoked at runtime. This string value can then be changed as we wish to cause any of the methods of EmployeeTO to be called.
The reflection API provides a variety of interesting features including the ability to pass parameters to methods and the ability to determine method return types. (For a complete list of these capabilities, consult the Java API Javadoc.) We will need the latter capability as the three getter methods of EmployeeTO return different types and it will thus be necessary to be aware of which type we have when doing the comparison in the compare() method. For example, we'll need to code a different sort of equality test on an int return value as opposed to a string.
A dynamic solution will also need to take advantage of the flexibility of the Collections.sort() method. Recall that in our simple sorting solution we passed an instance of an object that implemented the Comparator interface as the second parameter to Collections.sort(). In that case, it was the EmployeeTO object that contained the sorting logic. This worked great for what we needed it to do. Now, however, we want something a bit more sophisticated and flexible. What if we were to create a class that implemented Comparator, which was separate from each Transfer Object? In it we could place our dynamic sorting code and simply pass an instance of this new class as the second parameter to Collections.sort().
Doing this would cause several desirable results. First, we'll have completely decoupled any sorting logic from our Transfer Objects. This is highly desirable as it decreases not only the size of each Transfer Object by essentially eliminating the need for sorting code, but also removes the need for coding individual field comparison logic. Second, we'll have created a reusable utility class that can be used in many different situations where sorting is required. While reusability is not a specifically stated user requirement for our design, it is certainly desirable.
Figure 1 is a UML diagram (with attribute and method details omitted) that shows how the components of both the simple and the dynamic sorting solutions fit together. Really, the only portion that has changed since our simple solution is where the Comparator interface gets implemented. In the first example, EmployeeTO implemented Comparator directly. Now DynamicComparator implements Comparator and contains an intelligent implementation of the compare() method that can be used by any class that requires a collection of objects to be sorted.
Listing 3 shows the completed code listing for DynamicComparator. There are a number of interesting things about this class. First, note the class signature. The class implements two interfaces - Comparator and Serializable. Comparator should come as no surprise since that interface is the essence of the sorting capabilities we desire. Also, although not a requirement, the API docs recommend that any class implementing Comparator implement Serializable as well.
Second, look at the static sort() method. Classes wishing to utilize DynamicComparator will call this method rather than Collections.sort(). I've decided to make sort() static to mimic the Collections.sort() method. Although the DynamicComparator.sort() method is called statically, internally DynamicComparator creates an instance of itself. This is necessary in order for it to provide access to the nonstatic compare() and equals() methods of the Comparator interface that it supports. Next note how this method takes three parameters. The first is the collection object to be sorted. The second is a string that defines the field of each object in the collection on which sorting should be performed. The last parameter is a Boolean specifying the sort order. These three parameters are used as arguments to create a new instance of DynamicComparator that is the second parameter passed to the Collections.sort() method.
Third, take a look at the compare() method. This is where the reflection code really kicks in. One of the first things we need to obtain is a reference to a method object at line 43. We'll use this reference to call methods dynamically. This task is done using the getMethod() helper method, which obtains this value via reflection. Next, we need to determine the return type of the methods we are about to call. Remember that we will need to compare the attribute values of the two objects passed into compare(). If the return type is an int, for instance, we'll certainly have to write different code to do the comparison than if the return type is a string. Once we have the return type, we examine it and, based on its value, dynamically perform the actual method invocation and resulting comparison of the two values.
Note that currently there are three separate "if" test blocks - one each for string, int, and double. The implementation requires comparison logic for any method return type we expect to encounter. For the range of return types in our EmployeeTO example, these three are sufficient. However, additional code would need to be added to DynamicComparator if comparisons of other types are required - short, java.util.Date, java.math.BigDecimal, etc. Coding for each specific return type here is unavoidable as there is no way to dynamically cast Java objects. Similarly, Java-supplied nonobject data types like int, long, and double use entirely different comparison operators than do first-class object types like String or Date.
There are some other important points about this code. First, DynamicComparator fully supports null values. If either or both of the arguments passed to compare() are null, this method knows how to handle the situation accordingly. Second, look at each return statement within compare(). Remember the requirement that the user be able to control not only the sort field but also the sort order? This code supports the latter by essentially reversing the default sort order with a call to getSortOrder(). This is done if the user has decided to sort the result in descending order based on the Boolean value passed into the constructor from the sort() method. Third, the constructMethodName() method converts a Transfer Object attribute name string into a method name by prepending a "get" string and capitalizing the first character of the passed value. For instance, constructMethodName() would convert "salary" to "getSalary".
Last, the equals() method is needed to complete the interface requirements.
EmployeeTO - Enhanced Version
Listing 4 shows the enhanced version of EmployeeTO. The most obvious change is that EmployeeTO is now even simpler than before. Now that all of the sorting logic has been moved to DynamicComparator and the class no longer implements Comparator, we don't need to implement the compare() and equals() methods.
Sorting the Collection - Dynamic Version
Listing 5 is the code for DynamicTest. The only change between this class and SimpleTest is how the sort is called. Here we pass the three parameters to DynamicComparator.sort() (Collection Object, the decapitalized attribute name, and sort ascending flag) and let the DynamicComparator do the rest.
DynamicTest could just as easily have sorted on last name by passing "lastName" or on employee ID by passing "id" as the second parameter on line 29.
Building a class such as DynamicComparator has many benefits in an application that requires robust sorting capabilities. In this design, we have created a reusable, loosely coupled API that can be used to sort a collection of objects based on getter methods. The sort field is easily configurable and also allows control over the sort order.
This design, however, is not without trade-offs. Although using the reflection API allows us to do lots of cool things, using reflection can slow performance. This is particularly true in applications using pre-1.4 versions of Java. In addition, it's possible that applications wishing to sort very large collections may find DynamicComparator too slow.
Other inadequacies of DynamicComparator might become evident as well. Although it allows sorting on any one attribute of a collection of objects in an easily configurable manner, DynamicComparator does not address the potential need to sort by multiple fields - primary and secondary field sorts like that occur automatically with the ORDER BY clause in Structured Query Language (SQL).
This article introduced a reusable implementation of the Comparator interface that utilizes Java reflection to dynamically sort a collection of objects on any one of any number of fields within that object.
If your application or framework has a need for this specific functionality, perhaps this design will fit your needs.
SYS-CON Events announced today that SOA Software, an API management leader, will exhibit at SYS-CON's 15th International Cloud Expo®, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. SOA Software is a leading provider of API Management and SOA Governance products that equip business to deliver APIs and SOA together to drive their company to meet its business strategy quickly and effectively. SOA Software’s technology helps businesses to accelerate their digital channels with APIs, drive partner adoption, monetize their assets, and achieve a...
Oct. 31, 2014 07:15 PM EDT Reads: 2,117
SYS-CON Events announced today that Aria Systems, the recurring revenue expert, has been named "Bronze Sponsor" of SYS-CON's 15th International Cloud Expo®, which will take place on November 4-6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. Aria Systems helps leading businesses connect their customers with the products and services they love. Industry leaders like Pitney Bowes, Experian, AAA NCNU, VMware, HootSuite and many others choose Aria to power their recurring revenue business and deliver exceptional experiences to their customers.
Oct. 31, 2014 06:30 PM EDT Reads: 2,192
SYS-CON Events announced today that AgilePoint, the leading provider of Microsoft-centric Business Process Management software, will exhibit at SYS-CON's 2nd International @ThingsExpo which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. AgilePoint is the leading provider of Microsoft-based Business Process Management (BPM) software products, has 1,300+ on-premise and cloud deployments in 25+ countries and provides the same advanced BPM feature set as J2EE vendors like IBM and Appian for the Microsoft .NET native environment. AgilePoint customer...
Oct. 31, 2014 05:00 PM EDT Reads: 1,337
The Internet of Things (IoT) promises to evolve the way the world does business; however, understanding how to apply it to your company can be a mystery. Most people struggle with understanding the potential business uses or tend to get caught up in the technology, resulting in solutions that fail to meet even minimum business goals. In his session at Internet of @ThingsExpo, Jesse Shiah, CEO / President / Co-Founder of AgilePoint Inc., will show what is needed to leverage the IoT to transform your business. He will discuss opportunities and challenges ahead for the IoT from a market and tec...
Oct. 31, 2014 04:00 PM EDT Reads: 1,624
SYS-CON Events announced today that Utimaco will exhibit at SYS-CON's 15th International Cloud Expo®, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. Utimaco is a leading manufacturer of hardware based security solutions that provide the root of trust to keep cryptographic keys safe, secure critical digital infrastructures and protect high value data assets. Only Utimaco delivers a general-purpose hardware security module (HSM) as a customizable platform to easily integrate into existing software solutions, embed business logic and build s...
Oct. 31, 2014 03:00 PM EDT Reads: 1,978
One of the biggest challenges when developing connected devices is identifying user value and delivering it through successful user experiences. In his session at Internet of @ThingsExpo, Mike Kuniavsky, Principal Scientist, Innovation Services at PARC, will describe an IoT-specific approach to user experience design that combines approaches from interaction design, industrial design and service design to create experiences that go beyond simple connected gadgets to create lasting, multi-device experiences grounded in people’s real needs and desires.
Oct. 31, 2014 02:00 PM EDT Reads: 1,845
Samsung VP Jacopo Lenzi, who headed the company's recent SmartThings acquisition under the auspices of Samsung's Open Innovaction Center (OIC), answered a few questions we had about the deal. This interview was in conjunction with our interview with SmartThings CEO Alex Hawkinson. IoT Journal: SmartThings was developed in an open, standards-agnostic platform, and will now be part of Samsung's Open Innovation Center. Can you elaborate on your commitment to keep the platform open? Jacopo Lenzi: Samsung recognizes that true, accelerated innovation cannot be driven from one source, but requires a...
Oct. 31, 2014 09:00 AM EDT Reads: 3,393
The Internet of Things will greatly expand the opportunities for data collection and new business models driven off of that data. In her session at Internet of @ThingsExpo, Esmeralda Swartz, CMO of MetraTech, will discuss how for this to be effective you not only need to have infrastructure and operational models capable of utilizing this new phenomenon, but increasingly service providers will need to convince a skeptical public to participate. Get ready to show them the money! Speaker Bio: Esmeralda Swartz, CMO of MetraTech, has spent 16 years as a marketing, product management, and busin...
Oct. 31, 2014 09:00 AM EDT Reads: 2,350
SYS-CON Events announced today that TeleStax, the main sponsor of Mobicents, will exhibit at Internet of @ThingsExpo, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. TeleStax provides Open Source Communications software and services that facilitate the shift from legacy SS7 based IN networks to IP based LTE and IMS networks hosted on private (on-premise), hybrid or public clouds. TeleStax products include Restcomm, JSLEE, SMSC Gateway, USSD Gateway, SS7 Resource Adaptors, SIP Servlets, Rich Multimedia Services, Presence Services/RCS, Diame...
Oct. 31, 2014 09:00 AM EDT Reads: 1,714
Things are being built upon cloud foundations to transform organizations. This CEO Power Panel at 15th Cloud Expo, moderated by Roger Strukhoff, Cloud Expo and @ThingsExpo conference chair, will address the big issues involving these technologies and, more important, the results they will achieve. How important are public, private, and hybrid cloud to the enterprise? How does one define Big Data? And how is the IoT tying all this together?
Oct. 31, 2014 08:45 AM EDT Reads: 2,017
We certainly live in interesting technological times. And no more interesting than the current competing IoT standards for connectivity. Various standards bodies, approaches, and ecosystems are vying for mindshare and positioning for a competitive edge. It is clear that when the dust settles, we will have new protocols, evolved protocols, that will change the way we interact with devices and infrastructure. We will also have evolved web protocols, like HTTP/2, that will be changing the very core of our infrastructures. At the same time, we have old approaches made new again like micro-services...
Oct. 31, 2014 07:00 AM EDT Reads: 1,680
The only place to be June 9-11 is Cloud Expo & @ThingsExpo 2015 East at the Javits Center in New York City. Join us there as delegates from all over the world come to listen to and engage with speakers & sponsors from the leading Cloud Computing, IoT & Big Data companies. Cloud Expo & @ThingsExpo are the leading events covering the booming market of Cloud Computing, IoT & Big Data for the enterprise. Speakers from all over the world will be hand-picked for their ability to explore the economic strategies that utility/cloud computing provides. Whether public, private, or in a hybrid form, clo...
Oct. 30, 2014 05:30 PM EDT Reads: 1,496
SYS-CON Events announces a new pavilion on the Cloud Expo floor where WebRTC converges with the Internet of Things. Pavilion will showcase WebRTC and the Internet of Things. The Internet of Things (IoT) is the most profound change in personal and enterprise IT since the creation of the Worldwide Web more than 20 years ago. All major researchers estimate there will be tens of billions devices--computers, smartphones, tablets, and sensors – connected to the Internet by 2020. This number will continue to grow at a rapid pace for the next several decades.
Oct. 30, 2014 05:30 PM EDT Reads: 2,227
SYS-CON Events announced today that Gridstore™, the leader in software-defined storage (SDS) purpose-built for Windows Servers and Hyper-V, will exhibit at SYS-CON's 15th International Cloud Expo®, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. Gridstore™ is the leader in software-defined storage purpose built for virtualization that is designed to accelerate applications in virtualized environments. Using its patented Server-Side Virtual Controller™ Technology (SVCT) to eliminate the I/O blender effect and accelerate applications Gridsto...
Oct. 30, 2014 02:00 PM EDT Reads: 2,629
SYS-CON Events announced today that Red Hat, the world's leading provider of open source solutions, will exhibit at Internet of @ThingsExpo, which will take place on November 4–6, 2014, at the Santa Clara Convention Center in Santa Clara, CA. Red Hat is the world's leading provider of open source software solutions, using a community-powered approach to reliable and high-performing cloud, Linux, middleware, storage and virtualization technologies. Red Hat also offers award-winning support, training, and consulting services. As the connective hub in a global network of enterprises, partners, a...
Oct. 30, 2014 12:15 PM EDT Reads: 2,092
As the Internet of Things unfolds, mobile and wearable devices are blurring the line between physical and digital, integrating ever more closely with our interests, our routines, our daily lives. Contextual computing and smart, sensor-equipped spaces bring the potential to walk through a world that recognizes us and responds accordingly. We become continuous transmitters and receivers of data. In his session at Internet of @ThingsExpo, Andrew Bolwell, Director of Innovation for HP’s Printing and Personal Systems Group, will discuss how key attributes of mobile technology – touch input, senso...
Oct. 30, 2014 12:00 PM EDT Reads: 1,789
The Internet of Things (IoT) is making everything it touches smarter – smart devices, smart cars and smart cities. And lucky us, we’re just beginning to reap the benefits as we work toward a networked society. However, this technology-driven innovation is impacting more than just individuals. The IoT has an environmental impact as well, which brings us to the theme of this month’s #IoTuesday Twitter chat. The ability to remove inefficiencies through connected objects is driving change throughout every sector, including waste management. BigBelly Solar, located just outside of Boston, is trans...
Oct. 30, 2014 11:00 AM EDT Reads: 2,206
Connected devices and the Internet of Things are getting significant momentum in 2014. In his session at Internet of @ThingsExpo, Jim Hunter, Chief Scientist & Technology Evangelist at Greenwave Systems, will examine three key elements that together will drive mass adoption of the IoT before the end of 2015. The first element is the recent advent of robust open source protocols (like AllJoyn and WebRTC) that facilitate M2M communication. The second is broad availability of flexible, cost-effective storage designed to handle the massive surge in back-end data in a world where timely analytics...
Oct. 30, 2014 08:00 AM EDT Reads: 1,651
Internet of @ThingsExpo Silicon Valley announced on Thursday its first 12 all-star speakers and sessions for its upcoming event, which will take place November 4-6, 2014, at the Santa Clara Convention Center in California. @ThingsExpo, the first and largest IoT event in the world, debuted at the Javits Center in New York City in June 10-12, 2014 with over 6,000 delegates attending the conference. Among the first 12 announced world class speakers, IBM will present two highly popular IoT sessions, which will take place November 4-6, 2014 at the Santa Clara Convention Center in Santa Clara, Calif...
Oct. 30, 2014 07:30 AM EDT Reads: 2,320
From a software development perspective IoT is about programming "things," about connecting them with each other or integrating them with existing applications. In his session at @ThingsExpo, Yakov Fain, co-founder of Farata Systems and SuranceBay, will show you how small IoT-enabled devices from multiple manufacturers can be integrated into the workflow of an enterprise application. This is a practical demo of building a framework and components in HTML/Java/Mobile technologies to serve as a platform that can integrate new devices as they become available on the market.
Oct. 29, 2014 02:15 PM EDT Reads: 2,090