toString() and Comparable<T> on a JAXB generated entity class

[Nicklas Jepsen]

Hello,

I'm trying to create a distributed system and therefore I have all my entity classes present in my Java EE app and hosted as a web service. The Swing frontend app autogenerate the entity classes for use in the presentation.
I'm having some trouble using the Collections.sort() since a generated entity cannot implement an interface, does anyone have a hint to how i can solve this issue?
Also, I need to override the toString() so that I can put an entity directly in a eg. JCombobox and it is presented with the return of my custom toString() but if I override the toString() in my original entity in my backend app, then this method is not generated in my frontend app.

Thanks in advance!

Nicklas

[Ivan Krizsan]

Hi!
Do you mean that the Swing frontend generates the entity classes on the fly - that is when the program is running?

Both of you problems can be solved by either:
- Repacking the entities received by the client in classes that implement Comparable and that have toString methods.
- Creating wrapper classes for each entity class that implement Comparable, implements a toString method and delegates data retrieval etc to the wrapped entity class.

Regarding classes generated by JAXB: My advice is to see them as helpers in conveying the state of, in your case, entities going over the wire from a server to a client. Such classes will help you marshal and unmarshal data, but not much more. This is not serialization and the data passed from client to server only describes the state of objects, the object itself is not transferred.
Best wishes!

[Nicklas Jepsen]

Thanks for your reply!

However, I'm not sure I perfectly understand your solution.

Do you mean that the Swing frontend generates the entity classes on the fly - that is when the program is running?

No, that is not what happens.
The classes are generated when i build the app. The WSDL is downloaded and the classes are generated.

Repacking the entities received by the client in classes that implement Comparable and that have toString methods.

Could you please explain what you mean by repacking the entities?
Do you mean that I should create classes in the frontend app identical to the ones in my backend/web service?

Again, thank you for your help on this topic which I really has been stucked on for a while now

[Ivan Krizsan]

Nicklas Jepsen wrote:

Repacking the entities received by the client in classes that implement Comparable and that have toString methods.

Could you please explain what you mean by repacking the entities?
Do you mean that I should create classes in the frontend app identical to the ones in my backend/web service?

Creating identical classes is of little use, the point is to create classes that have the additional functionality etc that you want to use in the client.

Lets say you have a JAXB-generated class named EntytyA, which contains the properties propertyOne and propertyTwo.
- If you want to repack, you create another class, lets call it RepackedEntityA.
This class will have the same properties as EntityA and implement any interface(s) you want it to implement, as well as have any extra methods you want it to have.
When receiving an EntityA instance as a result of a request to the service, you use getter and setter methods to transfer the data in the EntityA instance to an instance of RepackedEntityA.
The instance of RepackedEntityA is the used throughout the client.
- If you want to wrap, you create another class, lets call it EntityAWrapper.
This class will not contain propertyOne or propertyTwo, but instead an instance of EntityA. It can implement any additional interface(s) etc etc.
When calling the getter method to retrieve, for instance, propertyOne, from an instance of EntityAWrapper, the instance delegates the retrieval of the property to the contained instance of EntityA.
Hope things are more clear!

[Nicklas Jepsen]

Thanks for your quick reply!

That did clear things up for me, but just to be sure that I really understand what you are saying lets say I have the following:
class EntityA with a list og EntityB
When i call getAllA() on the webservice, then I would need to iterate throu all EntityA and EntityB an repack them to my RepackedEntityA and RepackedEntityB classes and then have my method in my frontend app to, say, return List<RepackedEntityA> and not just return List<EntityA>?

Hope it makes sence, otherwise let me know, and I will try and post some source.

[Ivan Krizsan]

Hi!

Nicklas Jepsen wrote:
When i call getAllA() on the webservice, then I would need to iterate throu all EntityA and EntityB an repack them to my RepackedEntityA and RepackedEntityB classes and then have my method in my frontend app to, say, return List<RepackedEntityA> and not just return List<EntityA>?

Right!
Do also take a look at the JAXB guide, especially chapter 3: https://jaxb.dev.java.net/guide/
I am thinking that if you create a subclass of a generated class, there may be a way to make JAXB create instances of that class instead of the originally generated class.
https://jaxb.dev.java.net/guide/
I was first under the impression that you had a more dynamic scenario, but it seems it is not as dynamic as I first thought, so perhaps this is a viable approach.
Best wishes!

[Nicklas Jepsen]

Thank you very much for your help. I think I will go on with the "repack solution" since I already have been reading alot on the JAXB guide you linked to.

If anyone knows a quick way on having JAXB to map the generated classes to my own implementations, then I would like to know.

But thanks Ivan, your help is much appreciated

[Ivan Krizsan]

Hi!
On my way to work, I came to think of another solution:
You can use AOP, specifically AspectJ, to make your existing classes implement the Comparable interface and also introduce any additional methods, such as toString. This way you do not have to write any additional classes and can use the generated classes.
If you want to know more about this solution, let me know.
Best wishes!

[Nicklas Jepsen]

If you want to know more about this solution, let me know.

If it is a solution not to hard to implement, then I would love to hear more about AspejtJ. But if it takes a lot of time to set up, then I think I'll stick to the "wrapper solution".
But AOP definetely sounds interesting, my only concern is that I'm on a tight schedule and therefor I do not have the time to do a heavy refactoring at the moment.

Anyway, thank you for letting me know about AOP and AspectJ.

[Ivan Krizsan]

Hi again!
I have created a small sample program that mimics your conditions. In it there is one single entity class that, originally, does not implement the Comparable interface and does not have a toString method. Using AspectJ, I add the Comparable interface to the parents of the class and add the toString and compareTo methods to the class.
Development was done in Eclipse with the latest version of the ADT plugin installed.
First, the entity class:

package com.ivan;

/**
 * This is an entity class that do not implement any particular interface
 * nor does it contain a toString() method.
 * 
 * @author Ivan A Krizsan
 */
public class MyEntity
{
    /* Instance variable(s): */
    private String mFirstName;
    private String mLastName;
    
    public String getFirstName()
    {
        return mFirstName;
    }
    
    public void setFirstName(final String inFirstName)
    {
        mFirstName = inFirstName;
    }
    
    public String getLastName()
    {
        return mLastName;
    }
    
    public void setLastName(final String inLastName)
    {
        mLastName = inLastName;
    }
}

Second, the main program:

package com.ivan;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 *
 * @author Ivan A Krizsan
 */
public class InterfaceMethodIntroductionMain
{
    /* Constant(s): */
    private final static String[] NAMES =
    {
        "John Lennon", "Janis Joplin", "Jimmy Hendrix"
    };
    
    public static void main(String[] args)
    {
        List<MyEntity> theEntities = new ArrayList<MyEntity>();
        
        for (int i = 0; i < NAMES.length; i++)
        {
            MyEntity theNewEntity = new MyEntity();
            String[] theFirstLastNames = NAMES[i].split(" ");
            theNewEntity.setFirstName(theFirstLastNames[0]);
            theNewEntity.setLastName(theFirstLastNames[1]);
            
            theEntities.add(theNewEntity);
            
            System.out.println("Added entity: " + theNewEntity);
        }
        
        MyEntity theEntity1 = theEntities.get(0);
        MyEntity theEntity2 = theEntities.get(1);
        int theResult = theEntity1.compareTo(theEntity2);
        
        System.out.println("The compare result: " + theResult);
        
        System.out.println("The list before sorting: " + theEntities);
        
        Collections.sort(theEntities);
        
        System.out.println("The list after sorting: " + theEntities);
    }
}

Finally, the aspect:

package com.ivan;

/**
 * This aspect declares:
 * - The toString method on the entity class MyEntity.
 * - That the entity class MyEntity implements the Comparable interface.
 * - The compareTo method on the entity class MyEntity.
 * 
 * Note that in this aspect, the new methods and the parent declaration
 * are for one single class only. These things can be modified so that,
 * for instance, methods and parent declaration applies to all classes
 * in a certain package.
 * 
 * @author Ivan A Krizsan
 */
public aspect EntityModificationAspect
{
    /* Constant(s): */

    /* Instance variable(s): */

    /**
     * Add the toString method to the MyEntity class, so that printing
     * an instance of MyEntity yields a nice, readable, result.
     */
    public String MyEntity.toString()
    {
        return this.getFirstName() + " " + this.getLastName();
    }

    /**
     * Adds the cmpareTo method to the MyEntity class, in order for
     * collections of entities to be sortable.
     * Sorting will be done considering the last name first and,
     * if last names are equals, the first name.
     * 
     * @param inObject Object to be compared.
     * @return A negative integer, zero, or a positive integer
     * as this object is less than, equal to, or greater than the
     * supplied object. 
     */
    public int MyEntity.compareTo(Object inObject)
    {
        int theCompareResult;
        MyEntity theOtherEntity = (MyEntity)inObject;
        
        theCompareResult = this.getLastName().compareTo(
            theOtherEntity.getLastName());
        if (theCompareResult == 0)
        {
            theCompareResult = this.getFirstName().compareTo(
                theOtherEntity.getFirstName());
        }
        
        return theCompareResult;
    }
    
    /*
     * Make the entity class MyEntity implement the Comparable interface.
     */
    declare parents : MyEntity implements Comparable;
}

Best wishes!