Brett,
Thanks for your reply. The short answer, is the 'MyObejct' class has
about 10 properties in it. It is a social networking application,
with many 'social objects'. Each object inherits properties from the
main object, so I don't think an interface would do.
On Jul 6, 12:20 am, "brett.wooldridge" <brett.wooldri...@gmail.com>
wrote:
> Are these classes truly sub-classes, or are you using MyObject as a
> generic "Object" (in the Java Object class sense) that is
> serializable?
> Meaning, does MyObject have a bunch of state that is also shared by
> MyObject1..50? Or is MyObject pretty much empty with all of the
> state in the individual sub-classes?
>
> If that is the case, what is the purpose? So you can pass MyObject1..
> MyObject50 type objects through the same RPC method?
>
> I'm asking because it's hard to imagine (in Object Oriented terms) a
> reasonable scenario in which there is a base class with truly shared
> state across 50 subclasses. Sure, such cases exist (witness Java
> Object or a UIObject type class), but they are relatively rare in
> typical
> domain modeling.
>
> It seems a mistake to have something like:
>
> class MyObject {
> protected int id;
>
> }
>
> class MyObject1 extends MyObject {
> // more state
>
> }
>
> yada yada...
>
> class MyObject50 extends MyObject {
> // more state
>
> }
>
> If you can provide some context around your modeling domain,
> it will be easier to answer your question. But on the surface, it
> sounds like you need to rethink your object model.
>
> If MyObject is empty or fairly empty of state, you might dodge the
> bullet (without solving the modeling issue) by making it an interface.
> By doing so you can still have one RPC method that takes the
> MyObject interface without having truly polymorphic subclasses.
>
> -Brett
>
> On Jul 4, 11:46 am, Joshb <joshblin...@gmail.com> wrote:
>
>
>
> > We are currently working on a very complex project that has:
>
> > * A very large set of Data Objects which all extend from a Single
> > Super Class ( eg. MyObject, MyObject1 extends MyObject, MyObject2
> > extends MyObject ... MyObject50 extends MyObject)
> > * each of these objects have 10-30 properties, often consisting of my
> > varients of MyObjects
>
> > As a result, when I try and bind a RPC service ( GWT.create
> > ( MyObjectService.class ); ), it is taking 10+ seconds to bind.
> > Running in debug hosted mode using -extra indicates that, in fact, the
> > log output of the RPC binding is over 17,000 LINES!!!!
>
> > I have broken up my application into several separate GWT modules, and
> > roughly each one has its own RPC service. Each time it is called and
> > bound using deferred binding, there is this 10+ second delay. This is
> > obviously slowing down development/testing, and probably doing a lot
> > of other bad things at the same time. I'm sure there must be a better
> > way.
>
> > I am very curious (anxious) to know others thoughts on how to avoid
> > this situation when dealing with large, intertwined models.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Google Web Toolkit" group.
To post to this group, send email to Google-Web-Toolkit@googlegroups.com
To unsubscribe from this group, send email to
google-web-toolkit+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/Google-Web-Toolkit?hl=en
-~----------~----~----~----~------~----~------~--~---
