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

Ubuntu - problem z Alt

Ubuntu 12 - problem z klawiszem Alt.
Po podłączeniu nowej klawiatury klawisz "alt" wywołuje jakieś menu. Takie zachowanie mocno denerwuje przy próbie pisania tekstu z polskimi znakami.
Rozwiązanie:
Ustawienia -> Osobiste -> Układ klawiatury -> Opcje -> Zachowania klawiszy Alt/Win -> Alt pod prawym Win, Super pod Menu.

Spring - pierwszy projekt

Spring
Spring składa się z pliku XML i Beanów.
Bean:
Jest to klasa zgodna ze specyfikacją JavaBeans.
Przykładowy program na bazie Springa.

HelloWorld.java

package hello;

public class HelloWorld {
    public void hello() {
 System.out.println("Hello World!!!");
    }
}

Plik XML:
Plik w którym zapisane są zależności między obiektami.

helloworld.xml

< beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
              
 <  bean id="helloworld" class="hello.HelloWorld" />

Uruchomienie:
Aby uruchomić przykład musimy podać ścieżkę do pliku XML, z którego będziemy korzystali:
Main.java

package hello;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
 public static void main(String[] args) {
  ApplicationContext context = new ClassPathXmlApplicationContext("helloBeans.xml");
  BeanFactory factory = context;
  HelloWorld bean = (HelloWorld) factory.getBean("helloworld");
  bean.hello();
  
 }
}

Cechy Springa:
Odwrócenie sterowania – kontener IoC (Inversion of Control) – technika, która pozwala przekazać na zewnątrz tworzenie i zarządzanie zależnościami obiektów. Opis zależności między klasami jest przeniesiony do oddzielnego pliku xml.

Zależności między Beanami:
Zależności między konkretnymi Beanami określa się w pliku XML. Są dwa sposoby ich określenia:
Za pomocą konstruktora:

 < bean id="PrimeServiceBean" class="kkk.PrimeService" />
 < bean id="ApplicationBean" class="kkk.Application">
  < constructor−arg>< ref bean=”PrimeServiceBean” />

Za pomocą setterów:

 < bean id="PrimeServiceBean" class="kkk.PrimeService" />
 < bean id="ApplicationBean" class="kkk.Application" >
  < property name="primeService" ref="PrimeServiceBean" />
 

Wykorzystanie zależności zapisanych w beanie. Program sprawdza czy podana liczba jest liczbą pierwszą.


Main.java

package kkk;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
 public static void main(String[] args) {
  ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
  BeanFactory factory = context;
  Application test = (Application) factory.getBean("ApplicationBean");
  test.run();
  
 }
}

PrimeService.java

package kkk;

// odpowiedzialna za sprawdzenie czy dana liczba jest liczbą pierwszą
// powinny zostać wstrzyknięte do instancji Application z użyciem kontenera Spring 

public class PrimeService {
    public boolean sprawdzCzyPierwsza(int liczba) {
 double r = Math.sqrt(liczba);
 int i = 2;
 while (i <= r) {
     if ((liczba % i) == 0)
  return false;
     i++;
 }
 return true;
    }

}

Application.java

package kkk;

import java.util.Scanner;


// odpowiedzialna za wczytywanie wejścia i wypisywanie odpowiedzi

public class Application {
    private PrimeService primeService;

    public void setPrimeService(PrimeService primeService) {
 this.primeService = primeService;
    }

    public void run() {
 int liczba = wczytajDane();
 boolean czyPierwsza = primeService.sprawdzCzyPierwsza(liczba);
 wypiszWynik(czyPierwsza);
    }

    public static int wczytajDane() {
 Scanner s = new Scanner(System.in);
 System.out.print("Podaj liczbe: ");
 int w = s.nextInt();
 return w;
    }

    public static void wypiszWynik(boolean czyPierwsza) {
 if (czyPierwsza) {
     System.out.println("Wpisałeś liczbę pierwszą");
 } else {
     System.out.println("To nie jest liczba pierwsza");
 }
    }

}

bean.xml

< beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:aop="http://www.springframework.org/schema/aop"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">

 < bean id="PrimeServiceBean" class="kkk.PrimeService" />
 < bean id="ApplicationBean" class="kkk.Application">
  
 

CRUD – podstawowe operacje na bazach danych

CRUD.java

package kkk;

public interface CRUD {
 public void create(Osoba osoba);
 public Osoba read(int id);
 public void update(Osoba osoba);
 public void delete(int id);
}

Manager.java

package kkk;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class Manager implements CRUD {

 @Override
 public void create(Osoba c) {
  String query = "INSERT INTO OSOBA VALUES(" 
+ c.getId() + ", '" + c.getImie() + "','" + c.getNazwisko() + "');";
  try {
   polaczenieUpdate(query);
  } catch (Exception e) {
   e.printStackTrace();
  }

 }

 @Override
 public Osoba read(int id) {
  Osoba osoba = new Osoba();
  Statement statement;
  ResultSet rs;
  try {
   Class.forName("org.h2.Driver");
   Connection conn = DriverManager.getConnection("jdbc:h2:~/baza_ksiazki",
 "sa", "");
   statement = conn.createStatement();
   String query = "SELECT * FROM OSOBA where id = " + id;
   rs = statement.executeQuery(query);
   while (rs.next()) {
    osoba = new Osoba(rs.getInt("id"), 
rs.getString("IMIE"), rs.getString("nazwisko"));
   }
   conn.close();
   System.out.println(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return osoba;
 }

 @Override
 public void update(Osoba c) {
  String query = "UPDATE Osoba SET imie='" 
+ c.getImie() + "',nazwisko='" + c.getNazwisko() + "' WHERE ID=" + c.getId()
    + ";";
  try {
   polaczenieUpdate(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 @Override
 public void delete(int id) {
  String query = "DELETE from Osoba  WHERE ID=" + id + ";";
  try {
   polaczenieUpdate(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public void polaczenieUpdate(String query) {
  Statement statement;
  try {
   Class.forName("org.h2.Driver");
   Connection conn = DriverManager.getConnection("jdbc:h2:~/baza_ksiazki",
 "sa", "");
   statement = conn.createStatement();
   statement.executeUpdate(query);
   conn.close();
   System.out.println(query);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 public void tworzenieBazy() {
  String konstruktorTabeliOsoba = "DROP TABLE IF EXISTS OSOBA; CREATE 
TABLE OSOBA(ID INT PRIMARY KEY, IMIE VARCHAR(255), NAZWISKO VARCHAR(255));";
  try {
   polaczenieUpdate(konstruktorTabeliOsoba);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

}

Main.java

package kkk;

public class Main {

 public static void main(String[] args) {
  Manager manager = new Manager();
  manager.tworzenieBazy();

  Osoba os1 = new Osoba(1, "adam", "piep");
  Osoba os2 = new Osoba(2, "tom", "kiep");

  manager.create(os1);
  manager.create(os2);

  Osoba wczytanaOsoba = manager.read(2);
  System.out.println("--- " + wczytanaOsoba.getImie() + " " 
+ wczytanaOsoba.getNazwisko() + " ---");

  Osoba os3 = new Osoba(2, "kamil", "rosol");
  manager.update(os3);

  wczytanaOsoba = manager.read(2);
  System.out.println("--- " + wczytanaOsoba.getImie() + " " 
+ wczytanaOsoba.getNazwisko() + " ---");

  manager.delete(2);
  wczytanaOsoba = manager.read(2);
  System.out.println("--- " + wczytanaOsoba.getImie() + " " 
+ wczytanaOsoba.getNazwisko() + " ---");
 }

}

Osoba.java

package kkk;

public class Osoba {
 private int  id;
 private String imie;
 private String nazwisko;

 public Osoba() {
 };

 public Osoba(int id, String imie, String nazwisko) {
  this.id = id;
  this.imie = imie;
  this.nazwisko = nazwisko;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getImie() {
  return imie;
 }

 public void setImie(String imie) {
  this.imie = imie;
 }

 public String getNazwisko() {
  return nazwisko;
 }

 public void setNazwisko(String nazwisko) {
  this.nazwisko = nazwisko;
 }

}

Programowanie aspektowe – aspekty statyczne

W części pierwszej opisane zostały aspekty dynamiczne, czyli dodatki do istniejących klas i metod. Tym razem opiszę aspekty statyczne. Aspekty te pozwalają dodać nowe metody i pola do istniejących klas.

Aaa:

package kkk;

public class Aaa {

    public static void main(String[] args) {

 Obiekt samochodzik = new Obiekt((float) 99.99);
 System.out.println("cena - " + samochodzik.getCena());

 System.out.println("po podatku - " + samochodzik.dodajPodatek(99));
 System.out.println("po uldze - " + dodajUlge(99));

    }

    public static float dodajUlge(float cena) {
 return cena - cena * ulga / 100;
    }
}

AddMethod:

package kkk;

public aspect AddMethod {
    public static float podatek = 23;
    public static int Aaa.ulga = 15;

    public float Obiekt.dodajPodatek(float cena) {
 return cena + cena * podatek / 100;
    }
}

Obiekt:

package kkk;

public class Obiekt {
    private float cena;

    public Obiekt(float cena) {
 this.setCena(cena);
    }

    public float getCena() {
 return cena;
    }

    public void setCena(float cena) {
 this.cena = cena;
    }
}

Wynik:

cena - 99.99

po podatku - 121.770004

po uldze - 84.15

Jak widać w przykładzie aspekt dodaje jedną metodę do klasy Obiekt i jedno pole do klasy Aaa.

Na tych metodach i polach można operować tak samo jak na tych napisanych wprost.

Czytywanie z i zapis do pliku

Dwie podstawowe operacje wykorzystywane przy pracy z plikami tekstowymi.

Wczytywanie pojedynczej linii z pliku:

public static void odczyt() {
 Scanner odczyt = null;
 try {
     odczyt = new Scanner(new File("C:/pliktekstowy.txt"));
 } catch (FileNotFoundException e) {
     e.printStackTrace();
 }
 String zdanie = odczyt.nextLine();
 System.out.println(zdanie);
    }

Zapis do pliku:

public static void zapis() {
 PrintWriter zapis = null;
 try {
     zapis = new PrintWriter("C:/pliktekstowy2.txt");
 } catch (FileNotFoundException e) {
     e.printStackTrace();
 }
 zapis.println("Hello World");
 zapis.close();
    }

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.