Marcin Słowik - wszystko i nic: Eclipse

W tym artykule chciałbym podzielić się swoim doświadczeniem w ramach konfiguracji projektu typu Web wykorzystującego Spring, SmartGWT, Hiberante. Całość konfiguracji w zamierzeniu ma być budowana przez Maven-a. Zakładam, że do developmentu używane będzie środowisko Eclipse Helios SR 2. Dlatego zacznijmy od konfiguracji środowiska projektowego.

Zaczynamy od ściągnięcia Eclipsa ze strony Eclipse Helios SR2 Packages (v 3.6.2). Teraz, żeby nam się dobrze pracowało instalujemy następujące pluginy:
- Maven Integration for Eclipse Update Site
- Google Update Site for Eclipse 3.6
- GWT Designer Update Site
- SpringSource Update Site for Eclipse 3.6
- SpringSource Update Site for Eclipse 3.6 (Dependencies)
- JBoss Tools Development Milestone Update Site
Po instalacji Eclipse oraz wymienionych pluginów jesteśmy przygotowani do pracy, więc możemy zacząć. Moja propozycja podziału na moduły aplikacji typu Web jest następująca:
- moduł dziedzinowy: zawierający zarówno model dziedzinowy jak i operacje związane z modelem, czyli inaczej mówiąc model JPA oraz związane z nimi DAO (Data Access Objects)
- moduł usług: zawierający bean-y Springowe udostępniające usługi biznesowe w oparciu o model dziedzinowy
- moduł warstwy web: moduł zawierający całość logiki klienckiej, udostępniający warstwę UI dla użytkownika końcowego.

Moduł warstwy web komunikuje się z modułem serwisów w celu wykonywania akcji po stronie serwera. Nie ma on dostępu do modułu domenowego, gdyż moduł serwisów izoluje dostęp do warstwy domenowej.

Zajmijmy się teraz konfiguracją modułów. W tym celu utworzyć należy strukturę plików tak jak zostało to przedstawione na rysunku obok.

Najważniejsze w tym momencie są pliki pom.xml, czyli pliki konfiguracyjne Mavena. Teraz zajmę się ustawieniami w tych plikach. Dobrze, główny plik konfiguracyjny (root) znajdujący się na poziomie katalogów m2-domain, m2-service, m2-web wygląda następująco:

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  4.0.0
  pl.masl.m2
  m2-root
  1.0.0-SNAPSHOT
  pom
  M-2 :: ${project.artifactId}

  
    UTF-8
    1.6
    1.6
    4.8.2
    3.0.5.RELEASE
    3.0.5.RELEASE
    3.5.6-Final
    1.0.0.Final
    2.0.8
    5.1.10
  

  
    m2-domain
    m2-service
    m2-web
  

  
    
      junit
      junit
      ${junit.verion}
      test
    
    
      org.slf4j
      jcl-over-slf4j
      1.5.8
    
    
      org.slf4j
      slf4j-log4j12
      1.5.8
    
  
 
  
    
      maven-annotation-plugin
      
        http://maven-annotation-plugin.googlecode.com/svn/trunk/mavenrepo
     
    
  

  
    
      Central Repo
      http://repo1.maven.org/maven2
    
    
      com.springsource.repository.maven.release
      http://maven.springframework.org/release/
      
        false
      
    
    
      com.springsource.repository.maven.snapshot
      http://maven.springframework.org/snapshot/
      
        true
      
    
    
      com.springsource.repository.maven.milestone
      http://maven.springframework.org/milestone/
      
        false
      
    
    
      SmartGWT Repo
      http://www.smartclient.com/maven2/
    
    
      JavaNet
      http://download.java.net/maven/2

Co widać w tym pliku to ustawienia dotyczące wersji bibliotek używanych w ramach aplikacji, definicję modułów z których składa się aplikacja oraz definicja repozytoriów dla bibliotek.

Następnie konfigurujemy plik pom.xml dla modułu domenowego:

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.0.0

  
    m2-root
    pl.masl.m2
    1.0.0-SNAPSHOT
  

  pl.masl.m2
  m2-domain
  1.0.0-SNAPSHOT
  M-2 :: ${project.artifactId}

  
    
      org.hibernate
      hibernate-jpamodelgen
      ${hibernate-jpa.version}
    
    
      org.hibernate
      hibernate-entitymanager
      ${hibernate.version}
    
    
      org.hibernate
      hibernate-c3p0
      ${hibernate.version}
    
    
      org.hibernate
      hibernate-ehcache
      ${hibernate.version}
    
    
      org.springframework
      spring-test
      ${spring.version}
    
    
      org.springframework.data
      spring-data-jpa
      1.0.0.M2
    
    
      org.springframework
      spring-orm
      ${spring.version}
    
    
      mysql
      mysql-connector-java
      ${mysql.connector.version}
    
  

  
    
      
        org.apache.maven.plugins
        maven-compiler-plugin
        2.0.2
        
          ${maven.compiler.source}
          ${maven.compiler.target}
          ${project.build.sourceEncoding}
          -proc:none
        
      

      
        org.bsc.maven
        maven-processor-plugin
        1.3.1
        
          
            process
            
              process
            
            generate-sources
            
              target/metamodel
              
                
                  org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor
              
              
            
          
        
      

      
        org.codehaus.mojo
        build-helper-maven-plugin
        1.3
        
          
            add-source
            generate-sources
            
              add-source
            
            
              
                target/metamodel

Co mamy w tym pliku to zależności od hibernate-a i Springa, definicja pluginu do kompilacji, definicja pluginów do generacji modelu JPA 2.0.

Teraz konfiguracja pliku pom.xml dla modułu usług:

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.0.0
  
    m2-root
    pl.masl.m2
    1.0.0-SNAPSHOT
  
  pl.masl.m2
  m2-service
  1.0.0-SNAPSHOT
  M-2 :: ${project.artifactId}

  
    
      pl.masl.m2
      m2-domain
      1.0.0-SNAPSHOT
      jar
      compile
    
    
      aspectj
      aspectjrt
      1.5.4
    
    
      aspectj
      aspectjweaver
      1.5.4
    
    
      net.sf.dozer
      dozer
      5.3.2
    
    
      org.springframework
      spring-tx
      ${spring.version}
    
    
      org.springframework.security
      spring-security-config
      ${springframework.security.version}
    
  

  
    
      
        org.apache.maven.plugins
        maven-compiler-plugin
        2.3.2
        
          ${maven.compiler.source}
          ${maven.compiler.target}
          ${project.build.sourceEncoding}
        
      
      
        org.apache.maven.plugins
        maven-source-plugin
        2.1.2
        
          
            attach-sources
            verify
            
              jar-no-fork

W tym pliku widać definicję zależności od modułu domenowego, bibliotek Springa oraz pluginów do kompilacji.

No i na koniec definicja pom.xml-a dla modułu webowego:


  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  
    m2-root
    pl.masl.m2
    1.0.0-SNAPSHOT
  

  4.0.0
  pl.masl.m2
  m2-web
  war
  1.0.0-SNAPSHOT
  M-2 :: ${project.artifactId}

  
    
    2.3.0
    2.4
    ${project.build.directory}/${project.build.finalName}
  

  
    
      pl.masl.m2
      m2-service
      1.0.0-SNAPSHOT
    
    
      com.google.gwt
      gwt-user
      ${gwtVersion}
      provided
    
    
      com.google.gwt
      gwt-servlet
      ${gwtVersion}
      compile
    
    
      javax.validation
      validation-api
      1.0.0.GA
      test
    
    
      javax.validation
      validation-api
      1.0.0.GA
      sources
      test
    
    
      com.smartgwt
      smartgwt
      ${smartgwt.version}
      compile
    
    
      com.smartgwt
      smartgwt-skins
      ${smartgwt.version}
      compile
    
    
      com.google.code
      gwt-log
      3.1.3
    
    
      net.sf.gwt-widget
      gwt-sl
      1.3-RC1
      jar
      compile
      
        
          gwt-servlet
          com.google.gwt
        
        
         cglib-nodep
         cglib
        
      
    
    
      org.springframework
      spring-web
      ${spring.version}
    
    
      org.springframework
      spring-webmvc
      ${spring.version}
    
    
    
      org.springframework.security
      spring-security-config
      ${springframework.security.version}
    
    
      org.springframework.security
      spring-security-web
      ${springframework.security.version}
    
  

  
    ${webappDirectory}/WEB-INF/classes
    m2
    
      
      
        org.codehaus.mojo
        gwt-maven-plugin
        2.3.0-1
        
          
            
              compile
              test
              i18n
              generateAsync
            
          
        
        
          
            pl.masl.m2:m2-service
          
          M2.html
          ${webappDirectory}
                      pl.masl.m2.web.gwt.client.Constants
          
          
            pl.masl.m2.web.gwt.client.Messages
          
        
      
      
        org.apache.maven.plugins
        maven-war-plugin
        2.1.1
        
          
            compile
            
              exploded
            
          
        
        
          ${webappDirectory}
        
      
      
        org.apache.maven.plugins
        maven-compiler-plugin
        2.3.2
        
          ${maven.compiler.source}
          ${maven.compiler.target}
          ${project.build.sourceEncoding}

Tutaj mamy uzależnienie od bibliotek Springa, bibliotek GWT, bibliotek SmartGWT, ustawień dla kompilacji GWT oraz ustawień dla modułu typu WEB.

Teraz zajmiemy się wciągnięciem modułów do Eclipsa.

Nadszedł czas by napisać Webservice JAX-WS przy użyciu środowiska Eclipse Helios, który uruchomiony mógłby zostać na serwerze Tomcat. Poniżej podam przepis, który krok po kroku opisuje w jaki sposób można to wykonać. Więc do roboty.

1. Ściągnij sobie APACHE-CXF
2. Rozpakuj w lokalizacji c:\apache-cxf
3. Podepnij APACHE-CXF do Eclipsa Window -> Preferences

4. Skonfiguruj serwer Tomcat w Eclipsie - patrz poniżej

5. Utwórz nowy projekt File -> New -> Dynamic Web Project

6.Utwórzmy sobie prostą klasę Webservice-u:

package pl.masl;

public class TestWebService {
  public void testMethod(String param) {
    System.out.println("TEST: " + param);
  }
}

7. Kliknij prawym na klasie i utwórz Webservice

8. Jako "Webservice runtime" wybierz "Apache CXF 2.x"

9. Po naciśnięciu Next zaznacz pole wyboru Use a Service Endpoint Interface
10. Wybierz Create an SEI
11. Wpisz w odpowiednie pole nazwę interfejsu pl.masl.ITestWebService oraz zaznacz pole wyboru obok testWebservice()
12. Kliknij Next, a następnie wybierz pola wyboru w kolumnach @WebMethod i @WebParam. Poniżej jest podgląd na generowany kod interfejsu.
13.Kliknij Next i zaznacz wszystkie pola wyboru na następnej planszy oraz zakończ przez Finish

Marcin Słowik - wszystko i nic

Web Project Template, czyli Eclipse + Maven+ Spring + GWT + Hibernate

Linki do stron o SmartGWT

Eclipse + Tomcat + JAX-WS

O mnie

Kategorie

Linki

Lista BLOG-ów

Archiwum

Ostatnie Komentarze

Recent Posts

Ostatnie Komentarze

Recent Posts