Wymagania środowiska JBuilder 5 Enterprise

Promoter: prof. W. Khadzhynov
Autor: Maksymiuk Mateusz, gr. I.3
Przykład realizacji aplikacji bazodanowej w środowisku JBuilder
Zadanie ............................................................................................................................................. 1
Realizacja zadania w środowisku JBuilder 5 Enterprise. ................................................................. 1
Stworzenie modułu danych. ............................................................................................................. 1
Przykład utworzenia formularza w projekcie Wypożyczalni samochodów. ................................. 18
Stworzenie formularza do wyświetlania rapotrów ......................................................................... 24
Stworzenie pliku uruchomieniowego *.jar ..................................................................................... 28
Uruchomienie programu ................................................................................................................ 31
Wymagania środowiska JBuilder 5 Enterprise .............................................................................. 31
Wymagania do uruchomienia przykładowej aplikacji ................................................................... 31
Zadanie
Stworzyć aplikację w języku Java, obsługującą bazę danych wypożyczalni samochodów w
platformie SYBASE. Aplikacja ma umożliwiać dodawanie, usuwanie oraz edycję rekordów.
Ponadto program należy wyposażyć w opcje generowania raportów na podstawie tabel baz
danych.
Realizacja zadania w środowisku JBuilder 5 Enterprise.
Stworzenie modułu danych.
Moduł danych jest specyficznym kontenerem, mającym na celu przechowywanie wszystkich
komponentów związanych z obsługą bazy danych. Zazwyczaj zawiera on komponent Database
(połączenie z bazą danych), komponenty queryDataSet (obsługa zapytań) czy komponenty
tableDataSet. Wszystkie te komponenty są komponentami niewizualnymi. Aby utworzyć pusty
moduł danych należy wybrać polecenie menu File|New, po czym pokaże się okno dialogowe :
Wybieramy obiekt DataModule i wciskamy przycisk OK. W następnym oknie podajemy nazwę
pakietu oraz nazwę klasy (np. DM1) :
Zaznaczenie pola „Invoke Data Modeler” powoduje ukazanie się pomocniczego formularza
służącego do wizualnego tworzenia obiektów do obsługi danych (np. zapytań), a ponieważ nasz
moduł danych nie będzie zbyt skomplikowany (np. nie zawiera zapytań połączonych relacjami
master/detail) to nie zaznaczamy tego pola. Drugie pole decyduje o generacji komentarzy. Po
wciśnięciu przycisku Ok pojawi się pusty kod źródłowy modułu danych umieszczony na palecie
„Source”. Klikamy na paletę „Design” (dolna część ekranu) :
Przechodzimy teraz na kartę „DataExpress” w palecie komponentów :
Karta ta zawiera komponenty służące do budowy modułu danych – obsługującego bazę danych.
Pierwszym komponentem, który umieścimy na formularzu będzie komponent „Database”. Służy
on do uzyskania połączenia z bazą danych. Klikamy na komponent „Database”:
i umieszczamy go na formularzu poprzez pojedyncze kliknięcie :
Ponieważ wszystkie komponenty do obsługi baz danych są niewizualne toteż nie widać ich na
formularzu, lecz zamiast tego pojawiają się w drzewku w lewym dolnym rogu ekranu. W tymże
drzewku możemy wybrać żądany komponent a następnie zmienić jego właściwości w tabelce po
prawej strony ekranu. Aby utrzorzyć połączenie z bazą danych „SYBASE – SQL Anywhere”
musimy najpierw stworzyć źródło danych (alias) ODBC. Otwieramy Panel Sterowania systemu
Windows i klikamy podwójnie na ikonę „Źródła danych ODBC”:
Pojawia się następujący formularz, w którym naciskamy przycisk dodaj :
Ukazuje się okno z listą sterowników baz danych dostępnych w systemie. Wybieramy „Sybase
SQL Anywhere 5.0” i wciskamy przycisk zakończ:
Należy teraz podać parametry bazy danych (nazwa i opis aliasu, użytkownik, haslo – „sql”, plik
bazy danych itp.):
Wszystko akceptujemy przyciskiem Ok. Wracamy z powrotem do JBuilder’a. Wybieramy
komponent Database pojedynczym kliknięciem i ustawiamy jego właściwość „Connection” –
klikając na mały przycisk z 3 kropkami :
Po czym ukazuje się następujące okno dialogowe :
Jako driver wybieramy sterownik JDBC do obsługi ODBC, a wartość URL ustawiamy (za
pomocą przycisku z 3 kropkami) na uprzednio utworzony alias ODBC – „Sybase –
Wypozyczalnia”. Podajemy także standardową nazwę użytkownika i hasło. Przyciskiem „Test
Connection” testujemy połączenie – powinna się wyświetlić etykieta z napisem „Success”.
Zamykamy okno przyciskiem Ok. Teraz do modułu danych musimy dodać zapytania. Zapytanie
SQL jest obsługiwane poprzez komponent „queryDataSet” z palety „DataExpress” – wybieramy
go:
i klikamy na moduł danych :
Komponent pokazuje się w drzewku w lewym dolnym rogu ekranu pod nazwą queryDataSet1:
Zmieniamy jego następujące właściwości :
- właściwość „name” na wartość „Klienci” (zapytanie to będzie obsługiwać tabelę klienci).
Klikamy teraz na właściwość „query” – z prawej strony pola edycji pojawi się mały przycisk
służący do wyboru zapytania, na który klikamy:
Ukazuje się następujący formularz :
W polu „Database” wybieramy uprzednio utworzony komponent „Database1” – za pomocą tego
komponentu uzyskamy połączenie z bazą danych. Poniżej wpisujemy proste zapytanie
wybierające wszystkie kolumny z tabeli Klienci. Pole „Execute query immediately...” decyduje
czy zapytanie ma zostać otwarte od razu po wciśnięciu przycisku OK. Pole „Place SQL text in
resource...” informuje kompilator czy treść zapytania ma być przechowywana w pliku z
zasobami. Pole wyboru „Load options” decyduje o sposobie ładowania wierszy zapytania. Pole
to ma szczególne znaczenie w przypadku dużych tabel. My wybieramy opcję „Load all rows” –
oznacza to, że zapytanie od razu ładuje wszystkie wiersze. Teraz sprawdzamy działanie zapytania
wciskając przycisk „Test Query” – powinien się pojawić napis „Success”. Zamykamy okno
przyciskiem Ok.
Teraz w drzewku z komponentami – nasze zapytanie możemy rozwinąć – wtedy ukaże się lista
pól :
Dokładniejszy opis pól (wraz z mżliwością ich edycji) uzyskamy gdy dwukrotnie klikniemy na
nazwę zapytania Klienci, znajdującą się w drzewku. Jednak przedtem należy zapisać moduł
danych (File|Save DM1.java) oraz skompilować projekt (Project|Make Praoject...). Wtedy
wszysktie kolumny pokażą się na formularzu modułu danych :
Tym samym nasze zapytanie jest już dostępne dla innych formularzy. Ponieważ program będzie
obsługiwać bazę danych wypożyczalni, która zawiera pięć tabel (Klienci, Miejsca, Pracownicy,
Samochody, Wypożyczenia) należy jeszcze utworzyć pozostałe cztery zapytania. Proces ten
będzie przebiegał tak samo jak w przypadku zapytania „Klienci” – różnice będą polegać na
kodzie SQL dla poszczególnych zapytań:
- Miejsca : „select * from miejsca”,
- Pracownicy : „select * from pracownicy”,
- Samochody : „select * from samochody”,
- Wypożyczenia : „select * from wypozyczenia”,
Oprócz tego wygodnie jest zmienić właściwość „name” każdego komponentu queryDataSet na
nazwę obsługiwanej tabeli (analogicznie jak w poprzednio utworzonym zapytaniu Klienci).
Ponieważ nasz program będzie generował cztery rodzaje raportów, należy jeszcze dodać cztery
dodatkowe zapytania. Każde z nich będzie użyte go generowania poszczególnego raportu. Raport
jest zestawieniem informacji dla użytkownika na podstawie danych z kilku tabel (złączenie). Oto
treści zapytań SQL poszczególnych komponentów queryDataSet :
Raport1 :
select
k.imie,
k.nazwisko,
k.ulica,
k.miasto,
k.nr_telefonu,
sum( w.cena_jedn*(w.data_odd - w.data_wyp) ) "Kwota łączna",
count(w.nr_klienta) "Ilosc wyp."
from
wypozyczenia w,
klienci k
where
(w.nr_klienta=k.nr_klienta)
group by k.imie, k.nazwisko, k.ulica, k.miasto, k.nr_telefonu
order by 6 desc
Raport2 :
select
p.imie,
p.nazwisko,
m.miasto,
m.ulica,
sum( w.cena_jedn*(w.data_odd - w.data_wyp) ) "Kwota łączna",
count(w.nr_pracow_wyp) "Ilosc wyp."
from
wypozyczenia w,
pracownicy p,
miejsca m
where
(w.nr_pracow_wyp=p.nr_pracownika)and
(p.nr_miejsca=m.nr_miejsca)
group by p.imie, p.nazwisko, m.miasto, m.ulica
order by 5 desc
Raport3 :
select
m.miasto,
m.ulica,
sum( w.cena_jedn*(w.data_odd - w.data_wyp) ) "Kwota łączna",
count(w.nr_pracow_wyp) "Ilosc wyp.",
count(p.nr_pracownika) "Liczba pracow.",
sum(p.pensja)/count(p.nr_pracownika) "Średnia pensja"
from
wypozyczenia w,
pracownicy p,
miejsca m
where
(w.nr_pracow_wyp=p.nr_pracownika)and
(p.nr_miejsca=m.nr_miejsca)
group by p.imie, p.nazwisko, m.miasto, m.ulica
order by 3 desc
Raport4 :
select
s.marka,
s.typ,
s.poj_silnika,
s.przebieg,
sum( w.cena_jedn*(w.data_odd - w.data_wyp) ) "Kwota łączna",
count(w.nr_samochodu) "Liczba wypożycz."
from
wypozyczenia w,
samochody s
where
(w.nr_samochodu=s.nr_samochodu)
group by s.marka, s.typ, s.poj_silnika, s.przebieg
order by 5 desc
Raport1 generuje zestawienie klientów, wraz z kwotami, za które łącznie wypożyczyli
samochody i ilością wypożyczeń przypadającą na każdego klienta. Raport2 przedstawia podobne
zestawienie, z tym, że odnosi się ono do pracowników, wraz z miejscami ich pracy. Raport3
wyświetla zestawienie danych na temat poszczególnych oddziałów (łączna kwota wypożyczeń,
ilość wypożyczeń, liczba pracowników i średnia pensja). Raport4 pokazuje informacje na temat
samochodów – markę, typ, pojemność, przebieg, łączną kwotę wypożyczeń oraz ich liczbę.
Teraz powinniśmy otrzymać taki widok :
Jako, że nasza baza danych jest znormalizowaną, relacyjną bazą danych – nie występuje w niej
nadmiarowość danych. To znaczy, że np. w tabeli Wypożyczenia nie występują wszystkie dane
wypożyczanego samochodu, a jedynie jego numer indentyfikacyjny (klucz obcy), za pomocą
którego można się odwołać do konkretnego rekordu w tabeli samochodów. Wygodnie byłoby
przeglądając dane w tabeli Wypożyczenia, widzieć markę samochodu czy nazwisko pracownika
zamiast ich numeru. Aby to zrealizować należy utworzyć pola odnośników dla poszczególnych
zapytań. Pola te, nie są fizycznymi polami w bazie danych, lecz polami obliczanymi podczas
pracy programu na podstawie danych z innych tabel. Najpierw przed utworzeniem pól
odnośników utworzymy pola obliczane, które będą scalać kilka kolumn w jedną, np. „Imie” i
„Nazwisko” pracownika w jedno pole „Nazwa”. Aby utworzyć pole obliczane dla zapytania
Klienci należy wybrać odpowiednie zapytanie (dwukrotne kliknięcie) oraz dodać nowe pole za
pomocą przycisku „+”:
Wciskając ten przycisk, zostanie utworzone pole o domyślnej nazwie „column...”, możemy
zmienić jego właściwość ColumnName na wartość „Nazwa” oraz właściwość „Name” na
wartość „nazwa_klienta”:
Zmieniamy także właściwość dataType na wartość „STRING” oraz właściwość calcType na
wartość „calculated” – informuje ona program, że jest to pole obliczane. Teraz jeszcze musimy
zdefiniować procedurę obsługi zdarzenia odpowiedzialną za obliczanie wartości pola. W tym
celu wybieramy zapytanie Klienci, przechodzimy na kartę Events w tabelce z właściwościami:
Klikamy dwukrotnie na polu „calcFields”:
Po czym zostaje dodana do kodu źródłowego pusta procedura obsługi zdarzenia – wypełniamy ją
następującym kodem :
Ta linijka kodu jest odpowiedzialna, za nadanie polu obliczanemu wartości będącej złączeniem
łańcuchów nazwiska i imienia.
Pozostały jeszcze do utworzenia dwa pola obliczane dla tabel : Miejsca i Pracownicy. Proces ich
tworzenia przebiega analogicznie jak w przypadku tabeli Klienci, z tą różnicą, że poszczególne
pola nie tworzymy dla tabeli Klienci, a Miejsca i Pracownicy. Właściwość „columnName”
wszystkich pól obliczanych ustawiamy na wartość „nazwa”. Kod procedur obsługi zdarzenia
calcFields :
Teraz należy utworzyć pola odnośników – będą one występować w zapytaniach : Pracownicy
(odnośnik do tabeli Miejsca) oraz Wypożyczenia (odnośniki do tabel Klienci, Miejsca,
Pracownicy, Samochody).
Aby utworzyć pole odnośnika dla zapytania Pracownicy - wybieramy zapytanie Pracownicy
(dwukrotne kliknięcie) i dodajemy nowe pole za pomocą przycisku „+” :
Ustawiamy właściwość „name” dodanego pola na wartość „miejsce” oraz właściwość
„columnName” na wartość „miejsce”. Właściwość „dataType” ma wartość „STRING” (jest to
pole tekstowe), a właściwość „calcType” zmieniamy na wartość „lookup”. Teraz klikamy na
właściwość „pickList” pola i wciskamy mały przycisk, który pokazuje okno dialogowe służące
do konfiguracji odnośnika :
Pierwsze pole wyboru o nazwie „PickList/Lookup DataSet” oznacza źródło danych (zapytanie
lub tabelę), z którego nasze pole będzie czerpać informacje. Ponieważ nasze pole będzie
wyświetlać infomacje o miejscu pracy pracownika, więc będzie to zapytanie „Miejsca”. Poniżej
ukaże się nam lista pól wybranego zapytania. Opcja „Show in picklist” decyduje czy dane pole
będzie widoczne w liście rozwijalnej (podobnie jak ComboBox’ie), w której będziemy wybierać
miejsce pracy pracownika. Zaznaczamy pole „nazwa” – podczas wyboru miejsca pracy
pracownika – będziemy widzieć adres miejsca oraz miasto (pole obliczane nazwa w tabeli
miejsca jest połączeniem adresu i miasta). W kolumnie „Pracownicy” określamy pola wzajemnie
odpowiadające polom z tabeli „Miejsca” – pole „Nr_miejsca” w tabeli pracownicy odwołuje się
do pola „nr_miejca” w tabeli „Miejsca”.
Opcja „Lookup column to display” – określa które z pól ma być wyświetlane w naszym polu o
nazwie „miejsce” w zapytaniu „Pracownicy”. Właściwość „pickList” można też ustawić poprzez
napiasnie odpowiedniego kodu :
miejsce.setPickList(new com.borland.dx.dataset.PickListDescriptor(Miejsca, new
String[] {"NR_MIEJSCA"}, new String[] {"NAZWA"}, new String[] {"NR_MIEJSCA"},
"NAZWA", false));
Pozostało jeszcze utworzyć pola odnośników w zapytaniu Wypożyczenia. Będzie ich aż 6 :
- „klient” :
-
„samochód” :
-
„prac_wyp” :
-
„prac_odd” :
-
„miej_wyp” :
-
„miej_odd” :
Należy teraz zapisać moduł danych poleceniem menu File|Save DM1.java, a następnie
skompilować projekt poleceniem Project|Make Project.
Przykład utworzenia formularza w projekcie Wypożyczalni
samochodów.
Tworzony przez nas formularz będzie formularzem bazowym do obsługi pojedynczego
zapytania. Za pomocą tego formularza można dodawać, usuwać i zmieniać rekordy w bazie
danych. Nasz formularz jest formularzem bazowym dla formularzy obsługujących tabele Klienci,
Pracownicy, Samochody, Miejsca oraz Wypożyczenia. Jak można łatwo zauważyć wszystkie te
formularze są prawie identyczne, dlatego też korzystając z dziedziczenia zaoszczędzimy sporo
czasu – wykonując całą pracę tylko jeden raz.
W celu utworzenia formularza wybieramy polecenie menu File|New Class (to samo można też
zrobić szybciej wybierając polecenie File|New i zaznaczając obiekt Frame) :
W oknie dialogowym podajemy nazwę pakietu, w skład którego będzie wchodził formularz,
nazwę kalsy formularza, klasę bazową (tą z której będzie dziedziczył), oraz kilka innych opcji
określających dodanie pewnych części kodu do pliku źródłowego (m.in. funkcja main,
komentarze, konstruktor domyślny oraz określenie czy klasa ma być publiczna):
Można także utworzyć nowy formularz poprzez uruchomienie opcji File|New i wybranie obiektu
Frame. Po utworzeniu nowej klasy (formularza – dziedziczy on od klasy JFrame) przechodzimy
na kartę „Design”, na której kształtujemy graficzny interfejs użytkownika:
Mamy teraz widok pustego formularza :
Najpierw dodajemy do niego pasek narzędzi, czyli komponent JToolBar z palety „Swing
Containers”. Po umieszczeniu go na formularzu domyślnie znajdzie się on w górnej części
(rozmieszczenie „North”).
Do paska narzędzi trzeba dodać przyciski do obsługi poleceń użytkownika. Dodajemy do niego
cztery przyciski JButton z palety Swing :
Aby zmienić etykietę wyświetlaną na przycisku, należy wybrać przycisk, a następnie zmienić
właściwość Text w tabelce z właściwościami (prawa, środkowa część ekranu).
Następnie dodamy komponent, który będzie wyświetlać rekordy tabeli lub zapytania. Aby to
umożliwić musimy dodać dwa komponenty. Pierwszy z nich to tableScrollPane z palety
„dbSwing”:
Następnie do komponentu tableScrollPane należy dodać komponent jdbTable z palety
„dbSwing”:
Aby rekordy były wyświetlane w tabeli trzeba ustawić prawidłowo właściwość DataSet
komponentu jdbTable. Ponieważ nasz formularz jest formularzem bazowym dla innych
formularzy, to nie będziemy w nim ustawiać tej właściwości (każdy formularz dziedziczący od
formularza bazowego będzie się odwoływać do innej tabeli, więc dopiero w formularzach
pochodnych ustawnimy właściwość DataSet komponentu jdbTable). Teraz należy zdefiniować
kod obsługi zdarzeń dla przycisków paska narzędzi. Aby dodać procedurę obsługi zdarzenia do
przycisku należy na niego dwukrotnie kliknąć – pojawi się wtedy automatycznie wybrana karta
„Source” zawierająca kod źródłowy :
Wypełniamy procedury obsługi zdarzeń poszczególnych przycisków następująco :
void jButton1_actionPerformed(ActionEvent e) {
Dodaj();
}
void jButton2_actionPerformed(ActionEvent e) {
Usun();
}
void jButton3_actionPerformed(ActionEvent e) {
Edytuj();
}
void jButton4_actionPerformed(ActionEvent e) {
dispose();
}
Teraz musimy jeszcze zdefiniować procedury : Dodaj, Usun i Edytuj :
protected void Pokaz() {};
pochodnym
// procedura ta będzie przedefiniowana w formularzu
protected boolean Pusta() { //sprawdza czy tabela jest pusta
return jdbTable1.getDataSet().isEmpty();
}
protected void Dodaj() {
jdbTable1.getDataSet().insertRow(false); //dodaje rekord do tabeli/zapytania
Pokaz(); // pokazuje formularz do edycji rekordu
}
protected void Usun() {
try {
if (!Pusta()) { // czy tabela nie jest pusta
jdbTable1.getDataSet().deleteRow(); // usuń rekord
jdbTable1.getDataSet().saveChanges(); // zapisz zmiany do bazy danych
}
}
catch (Exception e) {
e.printStackTrace(); // w razie bledu wypis jego komunikat
}
}
protected void Edytuj() {
if (!Pusta()) { // czy tabela nie jest pusta
jdbTable1.getDataSet().editRow(); // edytuje rekord
Pokaz(); // pokazuje formularz do edycji rekordu
}
}
Ponieważ na poziomie tego formularza nie wiemy z jakim zapytaniem będzie on połączony więc
nie możemy się odwoływać bezpośrednio do zapytania – robimy to poprzez metodę getDataSet()
komponentu jdbTable. Procedura saveChanges() komponentu DataSet służy do zapisania zmian
dokonanych w zapytaniu do bazy danych (inaczej mówiąc utrwala ona zmiany na stałe).
Ponadto nasz formularz ma nieznacznie zmodyfikowany konstruktor – chodzi o to aby okno
pojawiło się na środku formularza głównego (domyślnie pokazuje się w lewym górnym rogu
ekranu):
public TabelaF(Frame parent) {
super();
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
if (parent!=null) {
Dimension dlgSize = getPreferredSize();
Dimension frmSize = parent.getSize();
Point loc = parent.getLocation();
setLocation((frmSize.width - dlgSize.width) / 2 + loc.x, (frmSize.height dlgSize.height) / 2 + loc.y);
}
}
catch(Exception e) {
e.printStackTrace();
}
}
Aby zapisać naszą pracę wybieramy polecenie menu File|Save „TabelaF.java”.
Stworzenie formularza do wyświetlania rapotrów
Raporty służą do przedstawienia informacji z bazy danych dla użytkownika. Najczęściej
informacje te są wynikiem odpowiednich zapytań SQL, będących złączeniami kilku tabel.
Formularze raportów są dość proste w budowie – w naszym przypadku będą się składać z
jednego przycisku oraz siatki do wyświetlania rekordów zapytania. Ponieważ wszystkie raporty
jakie zawiera nasz program mają identyczną budowę, więc w celu zminimalizowania pracy
stworzymy tylko jeden formularz wspólny dla wszystkich raportów. Najpierw tworzymy pustą
ramkę JFrame poleceniem menu File|New:
Wybieramy obiekt „Frame” i wciskamy przycisk OK. Następnie wypełniamy już nam znane pola
okna dialogowego :
Do pustego formularza wstawiamy komponent JToolBar z palety „Swing containers”:
Najlepiej jest umieścić go od razu w górnej części formularza – wtedy przyjmie on
rozmieszczenie górne (North) lub można tą właściwość zmienić w tabelce z właściwościami.
W komponenci JToolBar umieszczamy przycisk Jbutton z palety „Swing”:
Ustawiamy właściwość Text przycisku na wartość „Koniec”:
Teraz umieszczamy na formularzu komponent TableScrollPane z palety „dbSwing”:
Ustawiamy jego rozmieszczenie (właściwość Constrainst) na wartość „Center” – rozmieszczenie
centralne.
Do komponentu TableScrollPane należy dodać komponent jdbTable, także z palety „dbSwing” :
Ponieważ jest to formularz wspólny, nie ustawiamy właściwości DataSet komponentu jdbTable
(ponieważ każdy raport będzie połączony z innym zapytaniem), natomiast zrobimy to podczas
działania programu na kiedy użytkownik wybierze konkretny raport (kod obsługujący
wyświetlanie raportu znajduje się w formularzu głównym) :
Teraz musimy jeszcze dodać procedurę obsługi akcji kliknięcia na przycisk. W tym celu
dwukrotnie klikamy na przycisk „Koniec” i uzupełniamy procedurę następującym kodem :
Formularz ten ma zmieniony konstruktor – jednym z jego parametrów jest zmienna typu DataSet
– przekazująca zapytanie, które raport ma wyświetlać. Dzięki temu jeden formularz obsługuje
kilka raportów:
public RaportF(Frame parent, DataSet dataset) {
super();
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
jdbTable1.setDataSet(dataset); // ustawia zapytanie raportu
pack();
if (parent!=null) {
Dimension dlgSize = getPreferredSize();
Dimension frmSize = parent.getSize();
Point loc = parent.getLocation();
setLocation((frmSize.width - dlgSize.width) / 2 + loc.x, (frmSize.height dlgSize.height) / 2 + loc.y);
}
}
catch(Exception e) {
e.printStackTrace();
}
}
Zapisujemy formularz poleceniem File|Save... .
Stworzenie pliku uruchomieniowego *.jar
W celu utworzenia pliku uruchomieniowego wybieramy polecenie menu Wizards|Archive
Builder... . Pokazuje się następujące okno dialogowe :
W polu „Archive type” wybieramy pozycję „Application” i wciskamy przycisk Next. Pojawia się
kolejna karta :
W polu „name” wpisujemy nazwę aplikacji, pole „File” służy do podania pliku jaki ma być
utworzony. Zaznaczenie „Compress the contents of the archive” oznacza kompresję zawartości
pliku *.jar, dzięki czemu będzie on zajmował mniej miejsca. Ostatnia opcja decyduje o tym, czy
plik *.jar ma być tworzony na nowo przy każdym budowaniu projektu. Wciskamy przycisk Next:
W polu wyboru zaznaczamy trzecią opcję – oznacza ona, że do pliku *.jar zawsze będą
dodawane wszystkie klasy i zasoby projektu. Ponadto możemy dodawać klasy z poza projektu.
My zostawiamy wybór domyślny – tak jak na obrazku. Klikamy przycisk Next:
Na tej karcie wybieramy, które biblioteki załączyć do pliku *.jar. Najbezpieczniej jest zaznaczyć
wszystkie i wybrać opcję „Always include all classes and resources”. Oczywiście wtedy plik
uruchomieniowy będzie mieć większą objętość. W naszym przypadku można by odznaczyć
Ostatnią pozycję „JdataStore Server” – ponieważ zamiast niego korzystamy z serwera SYBASE.
Dwie pierwsze pozycje są niezbędne w naszej aplikacji. Wybieramy przycisk Next:
W większości przypadków nie będziemy zmieniać żadnych ustawień na tej karcie. W naszym
projekcie także zostawiamy ją domyślną – klikamy Next:
Na ostatniej karcie możemy ustawić główną klasę. My wybieramy opcję „Use the main class
specified in the default runtime” – która determinuje użycie jako klasy głównej klasy głównej
projektu. Kończymy dialog przyciskiem Finish.
Teraz należy zbudować projekt – polecenie Project|Rebuild Project. Zostanie wygenerowany plik
*.jar w katalogu, który wcześniej podaliśmy.
Uruchomienie programu
Program można uruchomić na dwa sposoby. Pierwszy to otworzenie projektu w środowisku
JBuilder 5 i uruchomienie poleceniem menu Run|Run. Drugi sposób to uruchomienie pliku *.jar.
Na komputerze musi być zainstalowane środowisko JRE (Java Runtime Enviroment). W obu
przypadkach przed uruchomieniem projektu należy utworzyć alias ODBC. Opis utworzenia alisu
ODBC – został opisany w rozdziale „Stworzenie modułu danych”.
Wymagania środowiska JBuilder 5 Enterprise
-
System operacyjny Windows 98, 2000 lub NT 4.0 (Service Pack 3.0 lub wyższy),
Procesor Pentium II 233Mhz,
128 MB pamięci RAM (zalecane 256 MB),
115-250 MB wolnego miejsca na dysku (zależnie od rodzaju instalacji).
Wymagania do uruchomienia przykładowej aplikacji
-
spełnione wymagania środowiska JBuilder 5,
zainstalowany pakiet SYBASE SQL Anywhere .