Showing posts with label Java. Show all posts
Showing posts with label Java. Show all posts

Thursday, April 14, 2011

How to use PrimeFaces with Grails

Here is a short example how to use PrimeFaces 2.2.1 with Grails 1.3.7.

The final result should look like this:



Install Grails

Download and install Grails 1.3.7

Create a grails application

Execute
grails create-app grails-primefaces

Install the JSF2 plugin

In order to use PrimeFaces in your grails application, you need to install the Grails JSF 2 plugin:

Enter the directory "grails-primefaces" created by the "create-app" command and execute
grails install-plugin jsf2

Integrate PrimeFaces dependencies

The PrimeFaces dependencies are added via the maven2 dependency resolution integrated in grails.

  1. Open the file
    grails-app/conf/BuildConfig.groovy
  2. Activate the normal maven repositories by uncommenting the lines "mavenLocal()" and "mavenCentral()"
  3. Add the PrimeFaces repository by adding the line
    mavenRepo "http://repository.prime.com.tr"
    to the "repositories" section
  4. Add the PrimeFaces dependencies by adding the line
    compile 'org.primefaces:primefaces:2.2.1'
    to the dependencies section
Your BuildConfig should now look something like that:
repositories {
        grailsPlugins()
        grailsHome()
        grailsCentral()

        // uncomment the below to enable remote dependency resolution
        // from public Maven repositories
        mavenLocal()
        mavenCentral()
        //mavenRepo "http://snapshots.repository.codehaus.org"
        //mavenRepo "http://repository.codehaus.org"
        //mavenRepo "http://download.java.net/maven/2/"
        //mavenRepo "http://repository.jboss.com/maven2/"
        mavenRepo "http://repository.prime.com.tr"
    }
    dependencies {
        // specify dependencies here under either 'build', 'compile', 'runtime', 'test' or 'provided' scopes eg.

        // runtime 'mysql:mysql-connector-java:5.1.13'
      compile 'org.primefaces:primefaces:2.2.1'
    }

Test the integration

  1. Create a JSF bean named "DummyBean" by executing the command
    grails create-bean Dummy
    .
  2. Open the created file grails-app/beans/DummyBean.groovy and add the following attributes and methods:
    • Attributes:
        def textHi = "hi"
        def textBy = "bye"
        def currentText = textHi
      
    • Methods:
        void change(javax.faces.event.ActionEvent ae) {
          if(currentText == textHi){
            currentText = textBy
          }
          else {
            currentText = textHi
          }
          FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, "Changed text to $currentText", "");
          FacesContext.getCurrentInstance().addMessage(null, message);
        }
      
      The class should now look something like this:
      class DummyBean {
      
      //['view' (jsf2special request scope),'request','session','globalSession' (portlet),'conversation'(swf),'flow'(swf)]
      
        def textHi = "hi"
        def textBy = "bye"
        def currentText = textHi
      
        //def otherBean (autowired bean)
      
        void init() {
          //called when bean starts
        }
      
        void dispose() {
          //called when bean stop
        }
      
        /*String action() {
        }*/
      
        void change(javax.faces.event.ActionEvent ae) {
          if(currentText == textHi){
            currentText = textBy
          }
          else {
            currentText = textHi
          }
          FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, "Changed text to $currentText", "");
          FacesContext.getCurrentInstance().addMessage(null, message);
        }
      }
      


  3. Create a new file
    dummy.xhtml
    in the folder
    grails-app/views/
    and add the following content:

    <html xmlns="http://www.w3.org/1999/xhtml"
          xmlns:h="http://java.sun.com/jsf/html"
          xmlns:p="http://primefaces.prime.com.tr/ui"
          xmlns:f="http://java.sun.com/jsf/core">
    
    <h:head>
    
    </h:head>
    <h:body>
        <f:view contentType="text/html">
            <h:form>
                <p:growl id="messages"/>
                <h:panelGroup id="prop">
                    <p:commandButton value="say #{dummyBean.currentText}" onclick="dlg.show();"/>
                    <p:commandButton value="Change text..." actionListener="#{dummyBean.change}" update="prop,dialogContent,messages"/>
                </h:panelGroup>
            </h:form>
            <p:dialog header="Saying something..." widgetVar="dlg" resizable="false" modal="true">
                <h:panelGroup id="dialogContent">
                <h:outputText value="#{dummyBean.currentText}!"/>
                </h:panelGroup>
            </p:dialog>
        </f:view>
    </h:body>
    </html>
    

  4. Now startup the application by using the command
    grails run-app
    and open the url http://localhost:8080/grails-primefaces/dummy.xhtml in your browser.

Thursday, November 05, 2009

Monitoring von JEE Anwedungen

Wer Details über eine laufende Webanwendung wissen will, sollte sich das Tool JavaMelody genauer ansehen.
Es ist extrem einfach zu installieren:
  • 2 Jar Dateien in den Classpath legen oder per Maven eine neue Dependency konfigurieren
  • 1 Filter und einen neuen Listener in die web.xml eintragen
Wenn man dann seine Webanwendung neu startet, bekommt man unter dem Pfad /monitoring genaue Auswertungen über z.B.Memoryverbrauch
  • Requestzeiten
  • Memoryverbrauch
  • Zustand der Threads
  • Aufgetretene HTTP Errorcodes
  • Warn / Error Einträge in Log4J Dateien
  • Zustand des Secondlevelcaches (wenn EHCache verwendet wird)
  • Wenn konfiguriert: Details über die JDBC Verbindung wie z.B. Anzahl der JDBC Statements, SlowQueryLogs etc.
Da das System mit JRobin arbeitet, werden auch historische Messdaten vorgehalten und graphisch dargestellt (Screenshots).


Als "Schmankerl" kann man sich die Informationen auch in regelmäßigen Abständen als PDF Report zumailen lassen.

Leider funktioniert JavaMelody zur Zeit noch nicht mit Grailsprojekten (Siehe
hier), auch die JDBC Auswertung per JNDI Lookup funktioniert noch nicht einwandfrei, aber alle anderen Features helfen einem immens, den Zustand einer laufenden JEE Applikation besser im Blick zu behalten

UPDATE: Mit Version 1.9.0 funktioniert JavaMelody nun einwandfrei in Grails, auch das JDBC Monitoring per JNDI funktioniert wie gewünscht. Für Grails wird inzwischen auch ein eigenes Plugin entwickelt


JavaMelody wurde per Plugin bereits in den Hudson CI Server integriert

Thursday, November 02, 2006

GenericRCP 0.3.0 veröffentlicht

Seit kurzem haben wir die neueste Version des GenericRCPs veröffentlicht.

Mit der neuen Version können nun auch Hibernate JPA annotierte Klassen gelesen werden. Des weiteren haben wir die Möglichkeit der grafischen Anpassungen weiter ausgebaut.

Mehr dazu auf der offiziellen GenericRCP Homepage.

An alle AppFuser: Auch Matt Raible hat über unser Tool einen kleinen Blogbeitrag geschrieben.

XDoclet und das Äquivalent in JPA

Da nun mit Hibernate Annotations eine lauffähige Implementierung des JPA Standards verfügbar ist, wird es nun langsam Zeit, von den alten XDoclet Tags abschied zu nehmen.

 

Um den Umstieg zu erleichtern, versuchen wir hier eine Liste anzulegen, welche Annotations für welche XDoclet Tags zu verwenden sind.

@hibernate.class -> @Entity

Bsp:

@hibernate.class table="testtabelle"

wird zu

@Entity(name="testtabelle")

Dokumentation

@hibernate.property -> <Gibt es so nicht mehr>

JPA mapped automatisch alle Attribute einer Klasse, die nicht transient sind. Allerdings kann man wie immer einem Attribut noch genauere Angaben über Länge, Typ etc. mitgeben.

Bsp:

@hibernate.property column="spaltenname" length="100" not-null="true"

wird zu

@Column(name="spaltenname", nullable=false, length=100)

Domumentation

@hibernate.many-to-one -> @ManyToOne

Bsp:

@hibernate.many-to-one name="library" column="libraryId" class="org.bambo.library.model.facility.Library" not-null="true"

wird zu

@ManyToOne(optional=false)

Will man den genauen Namen der Spalte angeben, so muss man noch eine zusätzliche Annotation angeben:  @JoinColumn(name="libraryid")

Dokumentation

@hibernate.collection-one-to-many -> @OneToMany

Im Gegensatz zu XDoclet muss man bei den Annotations fast keine zusätzlichen angaben mehr machen. Wichtig is nur, dass zusätzlich zu der Annotation noch angegeben wird, welches Attribut in der Klasse der anderen Seite der Assiozation diese Collection repräsentiert. Dies geschieht durch das Annotationattribut mappedBy(<Attributname>).

Bsp:

 @hibernate.set name="shelfs" lazy="true" inverse="true"
 @hibernate.collection-key column="libraryId"
 @hibernate.collection-one-to-many class="org.bambo.library.model.facility.Shelf"

wird zu

@OneToMany(mappedBy="library")

("library", da das Attribut in der Klasse Shelf, welches mit dieser Collection korrespondiert, "library" heißt).

Dokumentation

@hibernate.collection-many-to-many -> @ManyToMany

Bsp:

 

@hibernate.set name="authors" table="book_author" lazy="true"
@hibernate.collection-key column="bookId"
@hibernate.collection-many-to-many class="org.bambo.library.model.user.Author" column="authorId"

wird zu

@ManyToMany

Verwendet man ungetypte Collections, so muss die Annotation noch um das Attribut (targetEntity=org.bambo.library.model.user.Author.class) erweitert werden.

Will man noch den genauen namen der JoinTabelle angeben, so muss man die zusätliche Annotation @JoinTable(name="authors") angeben.

Die Markierung inverse gibt es in JPA nicht mehr. Statt dessen gibt man der Annotation das Attribut (mappedBy="<Attributname der collection in der anderen Klasse>") an

Dokumentation

 

Weitere Informationen über JPA Annotations findet man auf dieser Oracle Seite und natürlich auf der

J2EE Referenz Seite

Tuesday, October 17, 2006

Abhängigkeiten verwalten ohne Maven

Wer schon einmal mit Maven gearbeitet hat, wird feststellen, dass in manchen Fällen Abhängigkeiten viel Ärger machen können. Zur Zeit wird z.B. AppFuse auf maven umgestellt, was dazu geführt hat, dass Matt 28(!) Issues in Fremdprojekten eröffnen musste, die sich nur auf fehlerhafte pom's und deren Abhängigkeiten bezogen.

Wer also weiterhin ANT (http://ant.apache.org/) nutzen will, aber trotzdem die Vorzüge eines zentralen Library Repositories nutzen will, sollte einen Blick auf Ivy (http://www.jayasoft.org/ivy) werfen.

Ivy nutzt unter anderem die Maven Repositories, um benötigte Libs zu laden und lässt sich natlos in Ant integrieren.