update

some thoughts:

  1. The stack with “things i should post” is definitely to high :-/
    HP w2408h review
    2xAVM 7170 WDS howto
  2. I am now a proud owner of a HP w2408h – great product. Maybe i will do a short review (ref. to 1.).
    It is connected via HDMI to my MacBook
  3. Yeah! Finally our new server (current state: in pieces) is on its way. So stay tuned for a live install session. Our plan is:
    Gentoo basic system with XEN
    some VMs for hosting/playing around.
    This will be fun!
  4. I am just thinking about a smal, energy-efficient NAS-System. Nexenta-Core seems to be a great base for such a system. It hast a around 1GB Harddisk footprint! I am currently undecided between a VIA or an AMD based system, but i found some guy with knowledge and some tutorials on a Sun blog. With the chenbro ES34069 there is finally a perfect case on the market.
    I will collect some infos on the CeBIT next weekend.

Irgendwie bin ich momentan in der seltsamen Situation, viel Zeit zu haben, aber auch kaum den Kopf für andere Dinge frei zu haben, als meine Diplomarbeit abzuschließen. Ich wollte jetzt nur mal wieder das Blog mit Inhalt versorgen, weil ich sonst nur noch Spammer-Comments hier erhalten ^^. Irgendwie sammeln sich hier Ideen für Projekte und letztendlich frage ich mich ehrlich wieso, ich nicht längst mal wieder was geschrieben habe :-/.Ich werd dann mal das Blog updaten (also Software jetzt mal) 😉

mal wieder…. REST

Guten Morgen!
Weil ich grade darüber am schreiben bin, mal wieder was zum Thema:
How I Explained REST to My Wife

Wife: Who is Roy Fielding?
Ryan: Some guy. He's smart.
Wife: Oh? What did he do?
Ryan: He helped write the first web servers and then did a ton of research explaining why the web works the way it does.
      His name is on the specification for the protocol that is used to get pages from servers to your browser.
Wife: How does it work?
Ryan: The web?
Wife: Yeah.
Ryan: Hmm. Well, it's all pretty amazing really. And the funny thing is that it's all very undervalued.
      The protocol I was talking about, HTTP, it's capable of all sorts of neat stuff that people ignore for some reason.
Wife: You mean http like the beginning of what I type into the browser?
Ryan: Yeah. That first part tells the browser what protocol to use.
      That stuff you type in there is one of the most important breakthroughs in the history of computing.
Wife: Why?
Ryan: Because it is capable of describing the location of something anywhere in the world from anywhere in the world.
      It's the foundation of the web. You can think of it like GPS coordinates for knowledge and information.
Wife: For web pages?
Ryan: For anything really. That guy, Roy Fielding, he talks a lot about what those things point to in that research
      I was talking about. The web is built on an architectural style called REST.
      REST provides a definition of a resource, which is what those things point to.
Wife: A web page is a resource?
Ryan: Kind of. A web page is a representation of a resource. Resources are just concepts. URLs--those things that you type into the browser...
Wife: I know what a URL is..
Ryan: Oh, right. Those tell the browser that there's a concept somewhere. A browser can then go ask for a specific representation of the concept.
      Specifically, the browser asks for the web page representation of the concept.
Wife: What other kinds of representations are there?
Ryan: Actually, representations is one of these things that doesn't get used a lot. In most cases, a resource has only a single representation.
      But we're hoping that representations will be used more in the future because there's a bunch of new formats popping up all over the place.
Wife: Like what?
Ryan: Hmm. Well, there's this concept that people are calling Web Services.
      It means a lot of different things to a lot of different people but the basic concept is that machines could use the web just like people do.
Wife: Is this another robot thing?
Ryan: No, not really. I don't mean that machines will be sitting down at the desk and browsing the web.
      But computers can use those same protocols to send messages back and forth to each other.
      We've been doing that for a long time but none of the techniques we use today work well when you need to be able to talk to all of the machines in the entire world.
Wife: Why not?
Ryan: Because they weren't designed to be used like that. When Fielding and his buddies started building the web,
      being able to talk to any machine anywhere in the world was a primary concern. Most of the techniques we use at work to get computers to talk to each other didn't have those requirements. You just needed to talk to a small group of machines.
Wife: And now you need to talk to all the machines?
Ryan: Yes - and more. We need to be able to talk to all machines about all the stuff that's on all the other machines.
      So we need some way of having one machine tell another machine about a resource that might be on yet another machine.
Wife: What?
Ryan: Let's say you're talking to your sister and she wants to borrow the sweeper or something. But you don't have it - your Mom has it.
      So you tell your sister to get it from your Mom instead. This happens all the time in real life and it happens all the time when machines start talking too.
Wife: So how do the machines tell each other where things are?
Ryan: The URL, of course. If everything that machines need to talk about has a corresponding URL, you've created the machine equivalent of a noun.
      That you and I and the rest of the world have agreed on talking about nouns in a certain way is pretty important, eh?
Wife: Yeah.
Ryan: Machines don't have a universal noun - that's why they suck. Every programming language, database, or other kind of system has a different way of talking about nouns.
      That's why the URL is so important. It let's all of these systems tell each other about each other's nouns.
Wife: But when I'm looking at a web page, I don't think of it like that.
Ryan: Nobody does. Except Fielding and handful of other people. That's why machines still suck.
Wife: What about verbs and pronouns and adjectives?
Ryan: Funny you asked because that's another big aspect of REST. Well, verbs are anyway.
Wife: I was just joking.
Ryan: It was a funny joke but it's actually not a joke at all. Verbs are important. There's a powerful concept in programming and CS theory called polymorphism. That's a geeky way of saying that different nouns can have the same verb applied to them.
Wife: I don't get it.
Ryan: Well.. Look at the coffee table. What are the nouns? Cup, tray, newspaper, remote. Now, what are some things you can do to all of these things?
Wife: I don't get it...
Ryan: You can get them, right? You can pick them up. You can knock them over. You can burn them. You can apply those same exact verbs to any of the objects sitting there.
Wife: Okay... so?
Ryan: Well, that's important. What if instead of me being able to say to you, "get the cup," and "get the newspaper," and "get the remote"; what if instead we needed to come up with different verbs for each of the nouns? I couldn't use the word "get" universally, but instead had to think up a new word for each verb/noun combination.
Wife: Wow! That's weird.
Ryan: Yes, it is. Our brains are somehow smart enough to know that the same verbs can be applied to many different nouns. Some verbs are more specific than others and apply only to a small set of nouns. For instance, I can't drive a cup and I can't drink a car. But some verbs are almost universal like GET, PUT, and DELETE.
Wife: You can't DELETE a cup.
Ryan: Well, okay, but you can throw it away. That was another joke, right?
Wife: Yeah.
Ryan: So anyway, HTTP--this protocol Fielding and his friends created--is all about applying verbs to nouns. For instance, when you go to a web page, the browser does an HTTP GET on the URL you type in and back comes a web page.
Web pages usually have images, right? Those are separate resources. The web page just specifies the URLs to the images and the browser goes and does more HTTP GETs on them until all the resources are obtained and the web page is displayed. But the important thing here is that very different kinds of nouns can be treated the same. Whether the noun is an image, text, video, an mp3, a slideshow, whatever. I can GET all of those things the same way given a URL.
Wife: Sounds like GET is a pretty important verb.
Ryan: It is. Especially when you're using a web browser because browsers pretty much just GET stuff. They don't do a lot of other types of interaction with resources. This is a problem because it has led many people to assume that HTTP is just for GETing. But HTTP is actually a general purpose protocol for applying verbs to nouns.
Wife: Cool. But I still don't see how this changes anything. What kinds of nouns and verbs do you want?
Ryan: Well the nouns are there but not in the right format.
Think about when you're browsing around amazon.com looking for things to buy me for Christmas. Imagine each of the products as being nouns. Now, if they were available in a representation that a machine could understand, you could do a lot of neat things.
Wife: Why can't a machine understand a normal web page?
Ryan: Because web pages are designed to be understood by people. A machine doesn't care about layout and styling. Machines basically just need the data. Ideally, every URL would have a human readable and a machine readable representation. When a machine GETs the resource, it will ask for the machine readable one. When a browser GETs a resource for a human, it will ask for the human readable one.
Wife: So people would have to make machine formats for all their pages?
Ryan: If it were valuable.
Look, we've been talking about this with a lot of abstraction. How about we take a real example. You're a teacher - at school I bet you have a big computer system, or three or four computer systems more likely, that let you manage students: what classes they're in, what grades they're getting, emergency contacts, information about the books you teach out of, etc. If the systems are web-based, then there's probably a URL for each of the nouns involved here: student, teacher, class, book, room, etc. Right now, getting the URL through the browser gives you a web page. If there were a machine readable representation for each URL, then it would be trivial to latch new tools onto the system because all of that information would be consumable in a standard way. It would also make it quite a bit easier for each of the systems to talk to each other. Or, you could build a state or country-wide system that was able to talk to each of the individual school systems to collect testing scores. The possibilities are endless.
Each of the systems would get information from each other using a simple HTTP GET. If one system needs to add something to another system, it would use an HTTP POST. If a system wants to update something in another system, it uses an HTTP PUT. The only thing left to figure out is what the data should look like.
Wife: So this is what you and all the computer people are working on now? Deciding what the data should look like?
Ryan: Sadly, no. Instead, the large majority are busy writing layers of complex specifications for doing this stuff in a different way that isn't nearly as useful or eloquent. Nouns aren't universal and verbs aren't polymorphic. We're throwing out decades of real field usage and proven technique and starting over with something that looks a lot like other systems that have failed in the past. We're using HTTP but only because it helps us talk to our network and security people less. We're trading simplicity for flashy tools and wizards.
Wife: Why?
Ryan: I have no idea.
Wife: Why don't you say something?
Ryan: Maybe I will.

Quelle: Ryan Tomayko’s Blog: How I Explained REST to My Wife
und hier mal ein Ausblick wie das ganze bei mir aussieht:

und weil es so schön war: noch einmal auf Deutsch :-)

Nach meinen – zugegebenermaßen recht knappen – englischen Wünschen für das neue Jahr, hier noch einmal eine längere, deutsche Version:Ich habe vor ein paar Jahren bei einem Essen zum Jahreswechsel ein Geschichte überreicht bekommen. Lange Zeit lag sie in meinen Unterlagen (seltsamerweise behält man so etwas dann ja doch irgendwie, auch wenn man nie ganz genau weiß warum 🙂 ). Ich wollte die Geschichte immer mal weitergeben, war aber bislang zu bequem, den Text ab zu schreiben. So ergab es sich, dass sich eben diese Geschichte online fand. Da ich sicherlich ein oder anderen vergessen würde, und eigentlich alle Leute, die mich kennen die URL zu meiner Homepage haben, nehme ich mal einfach Abstand davon, das ganze per Email zu schicken und poste es einfach hier: 

Die Kupfermünze

Einmal habe ich eine Zeit lang in China gelebt. Ich war im Frühling in Shanghai angekommen, und die Hitze war mörderisch. Die Kanäle stanken zum Himmel, und immer war der ranzige, üble Geruch von Sojabohnenöl in der Luft. Ich konnte und konnte mich nicht eingewöhnen. Neben Wolkenkratzern lagen Lehmhütten, vor denen nackte Kinder im Schmutz spielten. Nachts zirpten die Zikaden im Garten und ließen mich nicht schlafen.Im Herbst kam der Taifun, und der Regen stand wie eine gläserne Wand vor den Fenstern. Ich hatte Heimweh nach Europa. Da war niemand, mit dem ich befreundet war und der sich darum kümmerte, wie mir zumute war. Ich kam mir ganz verloren vor in diesem Meer von fremden Gesichtern.Und dann kam Weihnachten. Ich wohnte bei Europäern, die chinesische Diener hatten.Der oberste von ihnen war der Koch; Ta-tse-fu, der große Herr der Küche. Er radebrechte deutsch und war der Dolmetsch zwischen mir und dem Zimmer-Kuli, dem Ofen-Kuli, dem Wäsche-Kuli und was es da sonst noch an Dienerschaft im Haus gab.Am Heiligen Abend, und ich saß wieder einmal verheult in meinem Zimmer, überreichte mir Ta-tse-fu ein Geschenk. Es war eine chinesische Kupfermünze mit einem Loch in der Mitte, und durch das Loch waren viele bunte Wollfäden gezogen und dann zu einem Zopf zusammengeflochten. “Ein sehr altes Münze”, sagte der Koch feierlich.”Und die Wollfäden gehört auch dir. Wollfäden sind von mir und mein Frau und von Zimmer-Kuli und sein Schwestern und von Eltern und Brüder von Ofen-Kuli – von uns allen sind die Wollfäden.”Ich bedankte mich sehr. Es war ein merkwürdiges Geschenk – und noch viel merkwürdiger, als ich zuerst dachte. Denn als ich die Münze mit ihrem bunten Wollzopf einem Bekannten zeigte, der seit Jahrzehnten in China lebte, erklärte er mir, was es damit für eine Bewandtnis hatte:Jeder Wollfaden war eine Stunde des Glücks.Der Koch war zu seinen Freunden gegangen und hatte sie gefragt: “Willst du von dem Glück, das dir für dein Leben vorausbestimmt ist, eine Stunde des Glücks abtreten?” Und Ofen-Kuli und Zimmer-Kuli und Wäsche-Kuli und ihre Verwandten hatten für mich, für die fremde Europäerin, einen Wollfaden gegeben als Zeichen, dass sie mir von ihrem eigenen Glück eine Stunde des Glücks schenkten.Es war ein großes Opfer, das sie brachten. Denn wenn sie auch bereit waren, auf eine Stunde ihres Glücks zu meinen Gunsten zu verzichten – es lag nicht in ihrer Macht, zu bestimmen, welche Stunde aus ihrem Leben es sein würde. Das Schicksal würde entscheiden, ob sie die Glücksstunde abtraten, in der ihnen ein reicher Verwandter sein Hab und Gut verschrieben hätte, oder ob es nur eine der vielen Stunden sein würde, in der sie glücklich beim Reiswein saßen; ob sie die Glücksstunde wegschenkten, in der das Auto, das sie sonst überfahren hätte, noch rechtzeitig bremste, oder die Stunde, in der das junge Mädchen vermählt worden wäre. Blindlings und doch mit weit offenen Augen machten sie mir, der Fremden, einen Teil ihres Lebens zum Geschenk.Nun ja – viele Chinesen sind abergläubisch. Aber ich habe nie wieder ein Weihnachtsgeschenk bekommen, das sich mit diesem hätte vergleichen lassen. Von diesem Tag an habe ich mich in China zu Hause gefühlt.Und die Münze mit dem bunten Wollzopf hat mich jahrelang begleitet. Ich habe sie nicht mehr. Eines Tages lernte ich jemanden kennen, der war noch übler dran als ich damals in Shanghai. Und da habe ich einen Wollfaden genommen, ihn zu den anderen Fäden dazugeknüpft – und habe die Münze weitergegeben.

(Joe Lederer, Von der Freundlichkeit der Menschen, München 1964)

Ich wünsche Euch allen

das Beste für das Jahr 2008!

Irgendwie ging 2007 viel zu schnell vorbei und eh man es sich versieht war das neue Jahr da! Ich hoffe, dass ich doch Zeit finden werde, den einen oder anderen mal wieder persönlich zu treffen – das hat sich ja im letzten Jahr nicht wirklich ergeben.  

Zum Jahresende

Moin…
bevor das Jahr zu Ende geht, und es so scheint, als würde ich nichts tun:
Ich bin momentan dabei nach Patchwork Manie meine Texte zusammen zu schreiben – denke aber, dass ich da mal ein paar Tage konzentriert dran sitzen sollte, um mal eine Grundstruktur zu finden.
Weiterhin bin ich momentan dabei, mir einen Javascript Client zu bauen. Wie vielleicht einiger wissen, benutze ich da das YUI Framework. Dennoch ist es z.B. notwendig, die Entities, welche auf Serverseite (u.a. die JPA POJOs) existieren, auch auf Client-Seite abzubilden. Ich bin also momentan dabei, mir mein User.Task und Group Objekt, nebst Abhängigkeiten aufzubauen. Da ich nicht wegen jeder Abhängigkeit einen neuen HTTPRequest senden möchte, speichere ich mir die Objekte in separate Arrays zwischen und lade die Daten dann nur nach Bedarf nach. Das  klappt auch soweit ganz gut, aber letztendlich fehlt es mir irgendwie an den JS Eigenheiten in Bezug auf OOP Programmierung :-D.
Sobald mein Client mit den Grundfunktionen steht, werde ich mich wieder dem Thema Autorisierung/Authentifizierung über HTTP-AUTH und SSL befassen.
Ist irgendwie ein Riesenbereich und meine bisherigen Erfahrungen sagen mir, dass man es entweder ganz oder gar nicht machen sollte :-).

Alleine das Thema Rollenverteilung kann ja schon Bücher füllen. Ich hadere noch ein wenig damit, eine geeignete Lösung zu finden, um alle Request, die nach “/” gehen an ein Formular weiterzuleiten, welches dann über SSL eine Anmeldung realisiert. Weiterhin denke ich, dass ich zumindest alle Anfragen durch eine eigene EJB schleusen müsste, um jeweils User-Daten auf Serverseite anhand der SSL Session zu finden.
Neben dem eBook EJB in Action fand ich u.a. hier weitere Informationen zum Thema. Wie ich bisher ja schon geschildert habe, realisiere ich den notwendigen realm für die User-Daten meines Java Application Servers über Views in der Datenbank. Letzendlich bleiben aber auch hier noch Fragen offen:

  1. Gibt es eine Möglichkeit, alle notwendigen Einstellungen ohne Admin Konsole zu erstellen (also quasi über eine Build Script, welches dem Server dann einen Sec Realm darbietet)
  2. Ist das ganze Server unabhängig (also z.B. auf Tomcat und Glassfish beidermaßen gleich lauffähig)
  3. (zählt auch eher zu 2) welche der vielen Config Dateien gilt es jetzt zu erweitern ( neben einer web.xml gibt es diverse sun-*.xml)

Ist also noch viel zu tun – nur schön, dass es sich mal wieder herausgestellt hat, dass der JS Anteil relativ leicht von der Hand geht. Es muckt zwar hier und da noch ein wenig auf, aber das bekommt man dann auch recht schnell in den Griff.
Ich wünsche allen ein erfolgreiches 2008 und verweise dann hiermit noch mal auf meinen Post in meinem privaten Blog. (ich kann mir nicht helfen, aber letztendlich muss ich am Schriftbild da noch mal arbeiten :-D)

Prepared for the new Year!

Hello, just right for the new year, i decided to update my Blogging-Software and to use a new Theme (called “Space”). Just to underline the “all new” message :-).I just read some news about gadgets, to come in the news year.First of all there are some news concerning the virtualization of MacOs: Alexander Graf patched the qemu source to use the open-source emulator for the virtualization of MacOS.You may find background information and some screenshots on his homepage. Another interesting  thing is the announcement of the Art.Lebedev Optimus Tactus.After the luxurious Optimus Maximus, the famous russian Design Studio publishes another innovative idea for an new input device.It is somehow a good start for a Star Trek like LCARS system.   optimus tactus keyboard 

I wish everyone the best for 2008! 

Sicherheit über JAAS mit einer MySQL Datenbank

Ich gebe zu, ich habe es lang vor mir her geschoben:

Neben all der schönen REST-fähigen Implementierung, ist Sicherheit ein Bereich, der bisher ein wenig zu kurz kam. Zwar habe ich schon eine schöne Möglichkeit gefunden, wie man mit YUI eine Anmeldung über HTTP AUTH hin bekommt, aber letztendlich fehlt(e) bisher die komplette Serverseite.

Ich habe jetzt einiger Zeit gesucht und bin zu dem Ergebnis gekommen, dass mir der Java Application Server (sei es Tomcat, Glassfish o.a.) bereits mehrere JAAS basierte Module zur Verfügung stellt.
Diese Entscheidung traf ich (da es hierbei sicherlich auch Einschränkungen einzugehen gilt) u.a. nach dem Lesen dieses Artikels.

Darin wird einem abgeraten, eine Logion/Session Verwaltung in Eigenregie zu erstellen, da hierdurch teilweise ein Sicherheitsrisiko eingegangen wird.

Nach weitere Suche kam ich zu einem interessanten Artikel von Shing Wai Chan, in dem er die Einrichtung eines JDBCRealm auf einem GlassFish Server beschreibt. Bis auf das die Standard digest-Algorithmen auf den verschiedenen Application Servern unterschiedlich sind, sollte dies unter den verschiedenen Systemen lauffähig sein.

Aufgrund der Übersichtlichkeit und da ich ungern Systeme in meinen Datentabellen herumfuhrwerken lasse, habe ich mir für die entsprechend benötigten Tabellen 2 Views angelegt:

CREATE ALGORITHM = TEMPTABLE VIEW usertable AS
SELECT u.email AS userid, u.password
FROM Users u
CREATE  ALGORITHM = TEMPTABLE VIEW grouptable AS
SELECT u.email AS userid, g.name
FROM Groups g, Users u, UsersGroups us
WHERE us.user_id = u.user_id
AND g.group_id = us.group_id

Damit kann ich weiterhin sicher sein, dass der Server auch tatsächlich auf die Standard-Variablen zugreifen kann. Natürlich bin ich damit den Nachteil eingegangen, dass ein Benutzer hier nur in einer Gruppe sein kann.
Ich denke aber, dass dies zu verkraften ist, da es sich hierbei nur um den Login handelt und hierbei eigentlich nur interessant ist, ob der Benutzer als Admin oder als User angemeldet wird.
Als Standardgruppen sind in der Datenbank admins und users gesetzt.
So habe ich in meiner Config-Datei (sun-web.xml) folgende Zeilen eingefügt:

<security-role-mapping>
    <role-name>cotodo-admin-login</role-name>
    <principal-name class-name="Users">admin</principal-name>
    <group-name>admins</group-name>
</security-role-mapping>
<security-role-mapping>
    <role-name>cotodo-user-login</role-name>
    <principal-name class-name="Users">admin</principal-name>
    <group-name>users</group-name>
</security-role-mapping>

Also Session Methode werde ich mich dann wohl für eine Cookie basierte Session entscheiden, weil eine URL-encodierte Session die schönen REST-URIs verschandeln würde und dadurch auch den Austausch mit YUI erschweren mag.
Meine beiden letzten Punkte auf der Agenda (die ich diese Jahr noch durch bekommen will (!!!), sind folgende:

  1. Wie gehe ich sicher dass ein User umgeleitet wird, wenn er eine ungültige Session hat und sich einen XML-Resource Stream besorgt? (letztendlich wird es da sicherlich entsprechende Methoden geben, welche vor allen anderen Aufrufen prüfen können, ob Autorisierung und Authentisierung korrekt sind.
  2. HTTPS. Es war erstaunlich einfach, dem Server klar zu machen, dass ich gerne HTTPS benutzen möchte (einfach andere URL :-)) .

Allerdings sollte man nun sicher sein dass:

  1. Alle Anfragen auf HTTP geblockt werden (oder noch besser: auf eine Login-Seite umgeleitet werden)
  2. Sicher gestellt wird, dass sich ein User nur über eine SSL Verbindung anmelden kann (sicherlich auch durch eine Weiterleitung möglich)

simple Step by Step JPA-JAXP-REST

Da ich mir ja langsam mal Gedanken machen sollte, wie ich meine Arbeit strukturiere. Habe ich mal angefangen, beispielhaft, die Schritte zu sammeln, welche notwendig sind, um eine DB Table mit Hilfe der Java Möglichkeiten REST fähig zu machen.
Ich gedenke dies in 3 Teile zu tun:

  1. JPA Entity: Wie wird aus einer Datenbank Tabelle ein Java Objekt
  2. JAXP: Wie bekomme ich von meiner JPA Entity möglichst einfach eine Repräsentation in XML (JSON geht auch, aber erstmal reicht mir XML).
  3. JSR311/Jersey: Wie gelingt, es die Ressourcen an bestimmte URIs zu binden?

Hier dann als mal Teil 1:

Als allererstes möchte ich die folgende Datenbank Tabelle als ein einfaches POJO (Plain Old Java Object) abbilden und die Annotations machen, welche notwendig sind, damit JPA auch weiß, wie es mit der Klasse umzugehen hat.
Folgende Tabelle:

TABLE Users
===================================================
[ user_id | email | forename | surname | password ]
===================================================

Die nachfolgende Klasse ist dann das passende POJO dazu:

/*
ne ganze menge imports:
*/
import de.hausswolff.cotodo.tools.Tools;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/*
Leider scheint der JPA Layer verschiedene Schlüsselwörter für sicher selbst in Anspruch zu nehmen. 
"User" gehört scheinbar auch dazu.
Ich musste also diese Klasse hier dann Users nennen und blieb bei den Entitäten nun bei dem Plural.
*/
@Entity
@Table(name = "Users")
public class Users implements Serializable {
    @Id
    @Column(name = "user_id", nullable = false)
    private Integer userId;

    @Column(name = "forename", nullable = false)
    private String forename;

    @Column(name = "surname", nullable = false)
    private String surname;

    @Column(name = "email", nullable = false)
    private String email;

    @Column(name = "password", nullable = false)
    private String password;

    /*
    Hier kommt dann noch eine Reihe von den Beziehungen der Entitäten untereinander. 
    Das lasse ich hier jetzt auch mal weg, weil es zum Thema keine Rolle spielt. 
    Als Beispiel mal eine Beziehung zu der Table Tasks über folgende Tabelle:
    TABLE UsersTasks
    ===============================
    [ task_id | user_id | send_to ]
    ===============================
    Hierbei ist "task_id" die ID des Tasks ;-). user_id ist die ID des Users, welcher den Tasks erstellt hat. 
    send_to enthält die ID des Users, an den der Task als Auftrag geschickt worden ist. 
    Da es n Empfänger seien sollen, muss das ganze natürlich in eine externe Tabelle ausgelagert werden.
    */

    @ManyToMany
    @JoinTable(name="UsersTasks",
    joinColumns=@JoinColumn(name="user_id"),
    inverseJoinColumns=@JoinColumn(name="task_id"))
    private Collection SendTaskCollection;

    @ManyToMany
    @JoinTable(name="UsersTasks",
    joinColumns=@JoinColumn(name="send_to"),
    inverseJoinColumns=@JoinColumn(name="task_id"))
    private Collection ReceivedTaskCollection;

    /*
    als (quasi virtuelle) Attribute erhält jede Users Klasse nun zwei Collections, 
    welche halt nicht direkt in der Users Tabelle gespeichert werden, 
    aber durch die Relationen in der UsersTasks Tabelle abgelegt sind.
    */
    public Users() {

    }
    public Users(Integer userId) {
        this.userId = userId;
    }

    public Users(Integer userId, String forename, String surname, String email, String password) {
        this.userId = userId;
        this.forename = forename;
        this.surname = surname;
        this.email = email;
        this.password = Tools.md5(password);
    }
    /*
    Es folgt nun die übliche Anzahl an gettern/settern. Hierbei habe ich mich entschlossen, 
    nicht stumpfsinnig alle Attribute per set zu öffnen, sondern wirklich nur jene, bei denen es notwendig ist. 
    Die beiden Listen aus den obigen relationen sollten nur lesbar sein. Der Empfänger/Ersteller werden im Task direkt angegeben.
    Als Beispiel hier mal setter/getter für das Passwort:
    */

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = Tools.md5(password);
    }

...

}

Ich habe vieles aus der Klasse weg gelassen, was nicht unbedingt für die Funktion von JPA notwendig ist, aber durchaus der besseren Lesbarkeit dient. Wichtig ist, dass es einen Standard-Konstruktor gibt.
Weiter geht es mit JAXP. Also der Repräsentation von obiger Klasse in XML.

Kann das mal bitte jemand erfinden? – Gedanken zur Produktentwicklung…..

Da ich momentan auf 13,3″ lebe und arbeite und das mir auf Dauer dann auch wirklich zu wenig ist (die Nachteile, wenn man halt ein transportables Notebook haben möchte), plane ich in der nächsten Zeit die Anschaffung eines externen Display. Nach reiflicher Überlegung – und im dem Gedanken, wenn dann auch richtig – soll es nun ein 24″ Display werden. Da ich den finanziellen Rahmen in Grenzen halten möchte, kommen nicht wirklich viele Modelle in dieser Größenordnung in Frage.

  1. Samsung 245B
  2. HP Pavilion w2408h

Obwohl ich mittlerweile einen (glücklichen?) Samsung 245B besitzer kenne, tendiere ich eher zu dem HP. Weil dieser einen eingebauten USB Hub hat, wesentlich natürlichere Farben darstellen soll (sofern man das in dieser Preisklasse überhaupt sagen kann) und zudem in silber ein schöneres Design hat, als der matt-schwarze Samsung.

Um jetzt den Bogen zum Titel zu kriegen: Leider besitzt das HP Display nur einen HDMI-Eingang (neben dem alt-erwürdigem VGA). Das ist eigentlich nicht weiter schlimm, weil HDMI letztendlich eine erweiterte Form von DVI ist. (u.a. wird mit HDMI auch Sound übertragen und nach Spezifikation von HDCP ist auch ein Kopierschutz möglich). In sofern ist das noch nicht wirklich kein Grund, sich aufzuregen ;-).
Was ich nicht nachvollziehen kann ist, dass der (Apple-proprietäre?!?!) Mini-DVI-Anschluss nicht direkt an einen HDMI Eingang angeschlossen werden kann. (Jedenfalls fand sich da kein Adapter).
Es gibt Mini-DVI auf DVI (unverschämt teuer, aber halt leider notwendig 🙁 ) und einen DVI auf HDMI Adapter. Das heißt, statt eines kleinen, dünnen Kabels (welches technisch durchaus möglich ist und aufgrund der Summe der MacBook Verkäufe auch sinnvoll), muss ich mir erst son Klotzt adaptieren, um den dann an wieder auf HDMI zu verkleinern. Irgendwie sinnlos :-).
Nachfolgend dann noch mal zwei Bilder, falls sich jemand fragt, wie die Anschlüsse so aussehen:


Ein HDMI Stecker


Ein Mini-DVI Stecker (hier noch an einem alten 12″ Powerbook)

Gibt es überhaupt noch andere Firmen – außer Apple, die diesen Stecker verbauen? Okay man muss Apple zu Gute halten, dass Sie wenigstens immer einen digitalen Ausgang zur Verfügung stellen. Ich denke mal, dass viele Sub-Notebooks aus Platz- oder Kostengründen noch einfaches VGA nutzen (welches bei größeren Auflösungen – und dazu zähle ich 1920 mal 1200 einfach mal) eher matschige Bilder baut.

Blogged with Flock

Abbilden der Relationen

Nachdem ich alle notwendigen Relationen in der Datenbank abgebildet habe, habe ich jetzt meine Annotations zwischen den Objekten fertig gestellt.
Es gibt ein paar interessante Dinge, so zum Beispiel eine rekursive Relation innerhalb von 2 Tasks (Aufgaben). Das heißt, eine Aufgabe kann n Unteraufgaben haben.


Weiterhin enthält jede Aufgaben ein Array von Empfängern und einen Sender.
Ich sehe grade, dass müsste in dem Fall kein Array sein.
Also ist das eine ManyToOne/OneToMany Beziehung. Werde ich dann noch ändern.

Ich war natürlich wieder einmal vorschnell. Hatte ich ja nicht etwas falsch gemacht
(sowas mache ich ja nicht :D), sondern schlicht etwas vergessen. ich spare mir jetzt
mal, die neuen UMLs hoch zu laden ;-). Letztendlich war die eine ManyToMany
Beziehung zwischen Users und Tasks natürlich die Leute, die Tasks an andere User
weiter delegieren. Das können ja pro Task n sein. Hat alles seine Richtigkeit. Die Welt
steht noch und ich gehe schlafen ^^. Was fehlte war einfach eine
OneToMany/ManyToOne Beziehung zwischen Tasks und Users!
Als letztes kann eine Gruppe (nun habe ich so doch mit rein genommen) 1 bis n Benutzer haben. Genauso kann ein Benutzer in 1 bis n Gruppen sein.
Eine Gruppe wird immer neu erstellt und entsprechender Benutzer hineingepackt, wenn eine Aufgabe mit einem Projekt-Flag (dazu später mehr) zu entsprechendem Benutzer zu geordnet wird. D.h. wenn besagter Benutzer Ersteller oder Verantwortlicher der Aufgabe (und deren Unteraufgaben) ist.
Hier mal das UML der Entitäten:

Wenn Interesse daran besteht, wie man die Abbildung im Einzelnen (im Code) abbildet, kann ich dazu auch noch etwas schreiben.
Und abschließend noch mal eine Übersicht aller Klassen, die ich bislang so habe.
Hierbei steht das E für Entität. Ein S steht für eine Systemklasse. Ein R für eine Klasse für eine einzelne REST Resource und eine R# für eine Resourcenliste.