river-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Gregg Wonderly <ge...@cox.net>
Subject Re: Jini, JavaSpaces, JEE, some questions, and some other development issues and ideas.
Date Thu, 04 Sep 2008 12:41:22 GMT
Wade Chandler wrote:
> public class Person {
>  private String firstName;
>  private String lastName;
>  public String getFirstName(){
>    return firstName;
>  }
>  //..getter here
> //lastname setter
> //lastname getter
> }
> 
>and then to have some type of meta-data as annotations or some type of a descriptor
>which would come from the entry level for a Person field used by JavaSpaces to
 >store it as needed. The benefit comes to the programmer who doesn't have to create
 >any other TO object just to use the held data within this bean just to use it in
 >an Entry and match the current entry pattern of use. This doesn't have to change
 >so much the way the server works or what data is stored other than on the 
JavaSpaces
 >client side and how that data is described to the remote JavaSpaces client which
 >will be requesting and pushing to a server. So instead of:
> 
> public class PersonTO {
>  public String firstName;
>  public String lastName;
> }
> 
>and having to move data in between the bean above and the TO, the developer 
 >simply annotates, or in the case of pre annotations, provides a descriptor at
 >the entry level for a given entries fields, and the logic in JavaSpaces can
 >then do what it does now with the data...

Okay, this seems like a clear question.  I'm sorry that we got off track, I was 
not understanding the question at all it seems.

So, it seems to me, that there are two things here.  One, is the use of meta 
data to designate which "fields" are keys.  The second, is creating something 
that can go down to the JavaSpace and work.

To try something out with the River project, one could change 
com.sun.jini.outrigger.EntryRep to do the work that is needed.  It could look 
for an interface on the class, it could look for a class resource, or it could 
look for annotations, or something else to find the meta-data.  It would then 
create the packaging needed for use in the JavaSpace.

That would be the easy thing to do.

I'm not sure whether Dan Creswell has any comments on this concept.  As an 
author of another JavaSpaces implementation, he might have some insight into 
whether this seems like an intersting, or a hard thing to do.

Gregg Wonderly

Mime
View raw message