Eclipse - brak fontów dla plików .jsp

Gdy ściągnąłem nowego Eclipse miałem problem z brakiem fontów dla plików .jsp.
Rozwiązanie:
Ściągamy plugin ze strony: http://amateras.sourceforge.jp/cgi-bin/fswiki_en/wiki.cgi?page=EclipseHTMLEditor
a dokładniej z:
sourceforge.jp/frs/redir.php?m=jaist&f=%2Famateras%2F51002%2Ftk.eclipse.plugin.htmleditor_2.1.0.jar

Rozpakowujemy plik i wklejamy do folderu eclipse/plugin

Programowanie aspektowe - AspectJ

Paradygmat programowania, który wspomaga separację programu na części jak najbardziej ze sobą niezwiązane. Pozwala zredukować ilość pisanego kodu, jednocześnie dzieląc program na logiczne moduły. Zmienia układ modułów widoczny dla programisty, po skompilowaniu do bytecodu jest całkowicie normalnym programem.

Styl programowania aspektowego stosowany jest do np. wydzielenia z kodu programu metod logowania. Zamiast w każdej klasie, czy metodzie pisać linijkę kodu zawierającą zapis do dziennika (log), można to wydzielić do aspektu, czyli innej klasy, która będzie wyszukiwała odpowiednią metodę i sama doda tą linijkę.

Główne zastosowania:

• Zarządzanie transakcjami
• Kontrola dostępu
• Zarządzanie współbieżnym wykonaniem
• Audyt/Monitorowanie
• Wstrzykiwanie zależności
• Uproszczenie wzorców projektowych
• Narzędzia do generowania kodu infrastruktury

Instalacja:

W Eclipsie -> Help -> Install New Software… -> wpisujemy strone: http://download.eclipse.org/tools/ajdt/37/update -> wybieramy AspectJ Development Tools -> instalujemy

HelloWorld:

Aby utworzyć nowy projekt w AspectJ wybieramy:

File -> New -> Other… ->AspectJ -> Aspect Project

Możemy tworzyć zwykłe projekty Javy, do tego mogąc dodać aspekt.

public class Main {

    public static void main(String[] args) {
 HelloWorld.say("wiadomosc");
 HelloWorld.sayToPerson("wiad", "name");
    }
}

public class HelloWorld {
    public static void say(String message) {
 System.out.println(message);
    }

    public static void sayToPerson(String message, String name) {
 System.out.println(name + "," + message);
    }
}

Klasa AspectJ: PPM na projekcie -> New -> Other… -> AspectJ -> Aspect

public aspect MannersAspect {
    pointcut callSayMessage() : call( public static void HelloWorld.say*( . . ) ) ;

    before() : callSayMessage ( ) {
 System.out.println("Good day ! ");
    }

    after() : callSayMessage() {
 System.out.println("Thank you ! ");
    }
}

Uruchomienie: PPM na klasę Main -> Run as -> AspectJ/Java Application

Otrzymany wynik:

Good day !

wiadomosc

Thank you !

Good day !

name,wiad

Thank you !

Powyższy przykład pokazuje jak bez ingerencji w metody można dodać przed ich wykonaniem i po ich zakończeniu komunikat.

Teraz dodam kolejny aspekt obliczający czas wykonania wszystkich metod publicznych:

public aspect TimeAspect {
    pointcut publicTime() : execution(public * *.*(..)) && !execution(* Main.*(..));

    Object around() : publicTime() {
 long time = System.nanoTime();
 Object ret = proceed();
 System.out.println(System.nanoTime() - time);
 return ret;
    }
}

Wynik programu:

Good day !

wiadomosc

65698

Thank you !

Good day !

name,wiad

98034

Thank you !

Jak wygląda aspekt?

Aspekt jest traktowany jak zwykła klasa, zamiast class użyty jest aspect.

Ciało aspektu składa się z:

• pointcut,
• advice,

pointcut (definicja przecięcia)

Określa kontekst, dla którego ma działać aspekt, tzn. specyfikuje dla jakich metod (np. publicznych), o jakich nazwach (albo np. początkach nazw (HelloWorld.say*)-gwiazdka oznacza, że może być tu dowolny tekst), czy dla metod z jakimi parametrami aspekt ma być stosowany.

Specyfikator pointcut nazwa() : typ sygnatura

• Specyfikator – tak jak w zwykłych metodach public, private…
• pointcut – słowo kluczowe,
• nazwa() – nazwa naszego przecięcia – może zawierać parametry, które są przekazywane w przechwytywanych metodach,
• typ: call albo execution. Zazwyczaj dają taki sam efekt,

1. call – aspekt wplatany jest w każde miejsce wywołania metody
2. execution – aspekt wplatany jest w ciało przechwyconej metody, bardziej preferowana

• Sygnatura – określa jakie metody aspekt ma przechwytywać, określa kolejno :

1. adnotacje (opcjonalne)
2. modyfikatory (opcjonalne)
3. zwracaną wartość (wymagane)
4. pakiet (opcjonalnie)
5. klasę (wymagane)
6. nazwę metody (wymagane)
7. parametry (wymagane)

Przykład:

Zastosowane wszystkie parametry:

pointcut p1() : execution (@Special public void p2.App.m1(String));

Zastosowane tylko wymagane parametry:

pointcut p1() : execution (void App.m1(String));

Wieloznaczniki:

Zamiast wpisywania wszystkich parametrów można użyć wieloznaczników typu: * .. +

• * oznacza wiele znaków (ale bez kropki),
• .. oznacza wiele znaków (również kropki),
• + rozszerza określenie typu o dowolny podtyp,

execution (void ppp.kkk.*(*)); - wszystkie metody w klasie “kkk” paczki „ppp”

execution (* ppp.*.*()); - wszystkie metody bez parametrów w paczce „ppp”,

execution (* ppp..*.*(..)); - oznacza paczkę „ppp” i wszystkie podrzędne pakiety metoda bez lub z dowolną ilością parametrów,

advice (rada):

miejsce(parametry) : nazwaPointcuta(parametry){

ciało metody

}

miejsce - określa w którym miejscu ma być wykonany kod aspektu:

• before(): rada zostanie wykonana przed przechwyconym punktem złączenia,
• around(): rada zostanie wykonana zamiast punktu złączania, chyba że metoda proceed() nakazuje inaczej,
• after(): rada zostanie wykonana po przechwyconym punkcie złączenia, niezależnie od wyniku wykonania tego punktu;,
• after() returning: rada zostanie wykonana po przechwyconym punkcie złączenia wyłącznie wtedy, gdy punkt ten wykonał się nie zgłaszając wyjątku;,
• after() throwing: rada zostanie wykonana po przechwyconym punkcie złączenia wyłącznie wtedy, gdy punkt ten wykonał się zgłaszając wyjątek,

Przykład aspektu z parametrami:

public aspect ValidAspect {
    pointcut valid(int a) :
 call( public static int HelloWorld.sprawdz(int) ) && args(a) ;

    before(int a) : valid (a) {
 System.out.println("Good day ! " + a);
 if (a == 9) {
     System.out.println("----- znaleziono 9 -----");
 }
    }

    after(int a) : valid(a) {
 System.out.println("Thank you ! ");
    }
}

Część druga - aspekty statyczne.

Maven - Eclipse

Maven jest narzędziem do budowy oprogramowania.
Cechy Mavena:

• standaryzuje rozmieszczenie katalogów w systemie, nazewnictwo bibliotek i archiwów,
• umożliwia podział projektu na moduły, z których każdy ma własną konfigurację,
• wszystkie dane związane z budową aplikacji i  potrzebnymi wtyczkami umieszczone są w pliku konfiguracyjnym POM (Project Object Model).,
• proces budowania oparty jest na wtyczkach,
• istnieje możliwość dziedziczenia i system zależności pozwalający ograniczyć powtarzanie kodu,
• pozwala generować raporty,

Instalacja:

w Eclipsie wybieramy Help->Install New Software... Dodajemy stronę: http://m2eclipse.sonatype.org/sites/m2e  -> zaznaczamy wszystko ->instalujemy.

Pierwszy projekt:

File->New->Other...->Maven->Maven Project

Wybieramy archetyp, czyli rodzaj budowanej aplikacji (w tym przypadku do budowy prostego programu wystarczy zaznaczony maven-archetype-quickstart)

Uzupełniamy podstawowe informacje o projekcie:

• GroupID - id organizacji tworzącej projekt np. com.mycompany.app,
• ArtifactId - nazwa projektu,
• modelVersion - wersja modelu POM,
• Package – nazwa automatycznie utworzonej paczki z domyślną klasą,

Te i inne dane wpisane przy tworzeniu można później zmienić w pliku POM.xml.

Po utworzeniu projektu w pliku POM.xml mamy jeszcze pozycje:

• packaging - rodzaj wynikowego archiwum jar,war,...
• url - adres strony projektu
• properties - project.build.sourceEncoding - zastosowane kodowanie

Struktura katalogów:

Dodanie biblioteki:

Aby dodać bibliotekę używaną w projekcie wystarczy dopisać ją do POM, a Maven sam już ją ściągnie i zamontuje. Aby to zrobić należy wpisać w sekcji <dependencies> </dependencies> nową zależność:

Dodanie biblioteki JUnit:

<dependency>
    <groupId>junit</groupId>   <!--nazwa archiwum-->
    <artifactId>junit</artifactId>   <!--nazwa archiwum-->
    <version>3.8.1</version>   <!--wersja archiwum-->
    <scope>test</scope>   <!--zasięg widoczności artefaktu-->
</dependency>

Zakres widoczności <scope> dzielimy na:

• test  - obecna tylko przy uruchomieniu testów, nie włączana do wynikowego archiwum,
• compile - włączana do archiwum,
• provided - udostępniona przez środowisko uruchomieniowe, nie włączana do archiwum,
• system - udostępniania przez system,
• import - dołącza artefakt typu POM,

Moduły:

Dzięki Maven można tworzyć projekty złożone z modułów, czyli innych projektów, projekty podrzędne dziedziczą z nadrzędnego.

POM projektu głównego:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>pl.kodujemy</groupId>
    <artifactId>ProjektGlowny</artifactId>
<packaging>pom</packaging>   <!-- projekt nadrzędny trzeba zmienić na pom-->
    <version>1.0-SNAPSHOT</version>
    <name>kodujemy</name>
    <url>http://maven.apache.org</url>
<modules>  <!-- litsta modułów projektu -->
<module>widok</module>
        <module>model</module>
        <module>kontroler</module>
</modules>
...
</project>

POM podrzędny:

<project>
<parent>   <!-- nazwa rodzica -->
<groupId>pl.kodujemy</groupId>
        <artifactId>ProjektGlowny</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <groupId>pl.kodujemyy</groupId>
    <artifactId>widok</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>widok</name>
    <url>http://maven.apache.org</url>
...
</project>

Aby stworzyć moduł do projektu:

New->Other...->Maven->Maven Module

Wybieramy Parent Project - czyli projekt pod który chcemy się podpiąć, pamiętając, aby wcześniej zmienić wartość jego <packaging> na pom.

Funkcje:

Z poziomu menu kontekstowego PPM->Run As mamy do wyboru kilka funkcji Mavena do wyboru:

• assembly,
• build,
• clean,
• generate sources,
• install – skopiowanie utworzonego artefaktu do lokalnego repozytorium,
• package – utworzenie wynikowego artefaktu, np.: archiwum jar lub war,
• test – wykonanie testów jednostkowych,

Raporty:

Maven umożliwia wygenerowanie raportów np:

• maven-javadoc-plugin – tworzy dokumentacje javadoc,
• maven-checkstyle-plugin – raport stylu kodu: obecność komentarzy, użycie zmiennych, importów...
• maven-pmd-plugin – wykrywa fragmenty pisane metodą „kopiuj/wklej”, pomijane bloki kodu...
• findbugs-maven-plugin – wykrywa typowe błędy statyczne,
• maven-surefire-report-plugin – raport wykonania testów,

Sekcja raportów:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>3.0-beta-2</version>
                <configuration>
                    <reportPlugins>
                        <plugin>
                          <groupId>org.apache.maven.plugins</groupId>
                          <artifactId>maven-javadoc-plugin</artifactId>
                          <version>2.7</version>
                        </plugin>
                        <plugin>
                          <groupId>org.apache.maven.plugins</groupId>
                          <artifactId>maven-jxr-plugin</artifactId>
                          <version>2.1</version>
                          <configuration>
                              <aggregate>true</aggregate>
                          </configuration>
                        </plugin>
                        <plugin>
                          <groupId>org.apache.maven.plugins</groupId>
                          <artifactId>maven-surefire-report-plugin</artifactId>
                          <version>2.6</version>
                        </plugin>
                    </reportPlugins>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Skróty klawiszowe w Eclipse

Skróty klawiszowe zdecydowanie ułatwiają prace przy kodzie. Oto moje propozycje do codziennego stosowania:

Ctrl+Spacja – czyli auto-uzupełnianie tekstu. Chyba najważniejszy skrót w historii :) Bardzo ułatwia pisanie. Nie trzeba martwić się o literówki. Wystarczy wpisać początek interesującej nas formułki i po naciśnięciu tej kombinacji wyświetlona zostanie lista propozycji dokończenia tekstu. Dodatkowo pozwala szybko wpisywać całe często używane komendy np.:

syso + Ctrl+spacja   > System.out.println()

Inne ciekawe skróty:

Ctrl+/ - zakomentowanie zaznaczonych linii za pomocą "//"

Ctrl+Shift+F – formatuje kod według zapisanych wcześniej reguł

Ctrl+D - usunięcie całej linii w której znajduje się kursor (bez konieczności jej zaznaczenia)

Ctrl+Shift+O - porządkowanie importów

Ctrl+F6, Ctrl+E - wyświetla okno dzięki któremu możemy przeskoczyć no innego otwartego edytora. 

Poniżej przedstawiam listę wszystkich skrótów klawiszowych w Eclipse znalezioną na:

http://sureshkrishna.files.wordpress.com/2008/02/eclipse_shortcuts.pdf

Aby zmienić, bądź ustawić własne skróty klawiszowe należy wybrać:

Windows › Preferences › General › Keys, wybrać Command, który chcemy ustawić i w polu Binding wpisać skrót.

Dla przykładu ustawiłem skrót do automatycznego generowania Getterów i Setterów dla istniejących pól jako Alt+Shift+S.

Eclips + Javadoc

Eclipse ułatwia korzystanie z javadoc-u. Aby wygenerować szkielet komentarza, należy:

• Wpisać ciąg znaków: „*/**”,
• Umieścić kursor w linijce z nagłówkiem klasy/ metody/ zmiennej, którą chcemy skomentować. Z menu kontekstowego wybrać Source->Add javadoc comment, lub nacisnąć Shift+Alt+J.

Np. dla metod zostanie wygenerowany komentarz zawierający odpowiednie wpisy:

•  @param,
•  @returns,
•  @throws.

Szkielet komentarzu można modyfikować w preferencjach Eclipse'a: menu Window->Preferences->Java->Code Style->Code Templates.

Aby wygenerować dokumentacje należy wybrać: menu Project -> Generate Javadoc. Można tam określić dla jakich pakietów, czy klas chcemy wygenerować dokumentacje, albo jakie tagi uwzględnić.