Elfelejtett MySQL root jelszó megváltoztatása

Ha elfelejtenéd a mysql szervered root jelszavát, így változtathatod meg. A művelethez rendszergazdai jogosultság kell (parancsok sudo-val)

1. Keresd meg a mysql process-t (PID):
   ps -ef  | mysql
2. Lődd ki a folyamatot (nálam a PID 8629 volt):
   kill -9 8629
3. Indítsd a mysql-t biztonsági módban, jogok nélkül:
   mysqld_safe -skip-grant-tables & 
4. Jelentkezz be a mysql konzolba jelszó nélkül:
   mysql -u root mysql
5. Frissítsd a jelszót user táblában:
   UPDATE user SET password=PASSWORD("newpassword") WHERE user="root";
   FLUSH PRIVILEGES;
6. Lépj ki a mysql konzolból:
   exit
7. Az 1. és 2. pontokban leírtak alapján lődd ki a a mysqld_safe processt
8. Ha futna a mysqld process is azt is lődd ki.
9. Indítsd a mysqld-t a rendszerednek megfelelő paranccsal:
   /etc/rc.d/rc.mysql start
   /etc/init.d/mysql start (nálam ez kellett UBUNTU 15.04 alatt)
   /etc/rc.5/mysql start
10. A jelszó megváltoztatva. Próbáld ki, most kérni fogja a jelszót:
    mysql -u root mysql 

Forrás: http://blog.dotkam.com/2007/04/10/mysql-reset-lost-root-password/

Fényképek átméretezése Linux alatt (convert)

képek tömeges átméretezésére a következő parancsot használhatjuk Linux parancssorban.

for file in *.jpg; do convert $file -resize 1024 -quality 90 resized-$file; done

A convert parancsot az imagemagick csomag tartalmazza.

részletek, leírás az átalakításról:

http://www.howtogeek.com/109369/how-to-quickly-resize-convert-modify-images-from-the-linux-terminal/

Hogyan tegyünk utólag időbélyeget a fényképeinkre

Nemrégiben szükségem volt arra, hogy meglévő fotókra utólag rákerüljün a készítés időpontja. A legtöbb digitális kamera képes arra, hogy az exponáláskor a képere ráteszi a készítés dátumát. Azonban ha így készülnek a fényképeink, akkor ezt utólag eltüntetni már nem lehet. Ekkor jöhet jól a következő módszer.

Biztosan léteznek rá különféle programok, szerkesztők, amikkel ez manuálisan vagy akár automatikusan is megoldható. Nekem sokkal jobban tetszik az a módszer amikor parancssorban egy szkriptet ráengedek egy könyvtárra és megoldja a feladatot. Nem kell pepecselni, elkészül és kész.

Ami szükséges hozzá az az ImageMagick nevű programcsomag. Ez a csomag létezik Windows, Linux és MacOS verziókban. Én Linuxot használok, így a Linuxos telepítést és szkriptet fogom itt közzétenni.

1. Telepítsük az ImageMagick csomagot:
   sudo apt-get install imagemagick
2. Igazán hatásos az LCD Font nevű ingyenes fontkészlet, melyet töltsünk le és csomagoljuk ki valahová. Nem kell telepíteni, a szkriptben kell megadni a könyvtárat ahol a font található. Ha ezt a lépést kihagyjuk akkor egy alapértelmezett betűtípussal fog dolgozni a szkript. 
3. Íme a szkipt. Ezt másoljuk ki és mentsük el pl. dtmstamp.sh (bármi más név is jó lesz), majd írjuk át a 3. sorban az elérési utat a letöltött fontkészlet helyére.
   

   #!/bin/sh
   # Change the font variable to point to your font location
   font="/Users/max/Library/Fonts/digital-7 (mono).ttf"
   
   if [ $# -eq 0 ]
      then
         cat << _EOF_
   
   USAGE: $0 file1 file2 ..., or
          $0 *.jpg, or
          $0 dir/*.jpg
          ...
   
   _EOF_
         exit
   fi
   
   while [ "$1" != "" ]; do
           # Skip directories
           if [ -d "$1" ]; then
                   shift
                   continue
           fi
           # Skip already converted files (may get overwritten)
           if [[ $1 == *_DT* ]]
           then
                   echo "------  Skipping: $1"
                   shift
                   continue
           fi
   
           # Work out a new file name by adding "_DT" before file extension
           file=$1
           echo "######  Working on file: $file"
           filename=${file%.*}
           extension=${file##*.}
           output=${filename}_DT.${extension}
   
           # Get the file dimension
           dim=$(identify -format "%w %h" "$file")
           width=${dim%% *}
           height=${dim#* }
   
           # Decide the font size automatically
           if [ $width -ge $height ]
           then
                   pointsize=$(($width/30))
           else
                   pointsize=$(($height/30))
           fi
   
           echo "        Width: $width, Height: $height. Using pointsize: $pointsize"
   
           # The real deal here
           convert "$file" -gravity SouthEast -font "$font" -pointsize $pointsize -fill white -annotate +$pointsize+$pointsize "%[exif:DateTimeOriginal]" "$output"
   
           shift
   done
   
   exit 0

4. Mentsük a szkritpet és tegyük futtathatóvá:
   chmod +x dtmstamp.sh
5. Futtassuk a szkriptet a következők szerint:
   ./dtmstamp.sh eleresi_ut/*.jpg
6. A megadott elérési úton az összes jpg fájlról készül egy másolat. A fájl "_DT" végződéssel lesz átnevezve.  Rákerül a kép készítésének időpontja, mégpedig az ami az EXIF adatokban szerepel. Az EXIF adatok minden fényképre rákerülnek a kép készítésekor, letiltani sem lehet. Természetesen szükséges a fényképezőgépen a dátum pontos beállítása. 

FIGYELEM!!! Ha a kép már szerkesztve lett, akkor előfordulhat (nagy valószínűséggel így lesz) hogy a képszerkesztő program átírja, vagy törli az EXIF adatokat. Célszerű tehát az eredeti vágatlan, módosítatlan nyers képet dátumozni.



A leírás a következő cikk alapján készült: http://dptnt.com/2009/08/add-date-time-stamp-to-jpeg-photos-using-free-software-mac-linux-nix-edition/

Web alkalmazás Hibernate + Vaadin segítségével

Diplomamunkám témája a Jáva objektumok perzisztens kezelése volt, mely kapcsán a Hibernate keretrendszert tanulmányoztam és alkalmaztam.
Röviden a perzisztenciáról annyit mondanék, hogy egy Java program futása közben létrejövő objektumokat a perzisztencia kezelő keretrendszer segítségével nagyon egyszerűen tárolhatók, kezelhetők adatbázisokban. Ezzel gyakorlatilag leveszi a programozó válláról azt a terhet hogy az adatbáziskezelés aprólékos feladatával foglalkozzon. Így sokkal inkább a probléma megoldásra koncentrálhatunk. XML fájlok segítségével vagy @nnotációk használatával konfigurálható hogy az objektumok adatmezői melyik adatbázis, melyik táblájában tárolódjanak.
Több keretrendszer létezik erre a feladatra, melyeket objektum-relációs leképező (Object Relation Mapping, ORM) rendszereknek nevezünk. Az egyik ilyen rendszer a Hibernate, melyet széles körben használnak.
Magáról a Hibernate-ről most részletesen nem szándékoztam írni, talán majd egy későbbi alkalommal indítok egy ilyen cikksorozatot.

A jelen jegyzet oka csupán annyi hogy hogyan hoztam létre az első Vaadin - Hibernate háromrétegű alkalmazást.

Természetesen a Hibernate is JAR fájlok formájában érhető el. Ezeket a JAR-okat kell a projektünkhöz kapcsolni és már használhatjuk is a rendszert. Ezt a WAR fájlok definíciója szerinti helyre kell tenni. Ha EE projektben dolgozunk akkor a WEB-INF/Lib alá kell importálni a Hibernate JAR-okat, hogy az alkalmazásszerver (AS, mint pl a Tomcat) használni tudja.
Ezt két módon tehetjük meg. Az első módszer szerint a projekt WEB-INF/Lib mappájába importáljuk a fájlrendszerből a szükséges JAR fájlokat. Ez a Hibernate lib könyvtárában lévő JAR-ok és a használt adatbáziskezelő JDBC elérését biztosító JAR.

A másik módszer szerint a projekt Properties-t indítva a Deployment Assembly opción belül az Add.. gombbal tudjuk a megfelelő helyről betölteni.

Én a példámban létrehoztam egy Vaadin projektet, majd a kis demó programot átírtam úgy hogy a gomb kattintásra generál egy egyedi azonosítót (osztályváltozóba), majd egy üzleti logikának felfogható másik osztályból példányosít egy objektumot ami felépíti a Hibernate kapcsolatot, illetve ennek az addNewRecord nevű metódusa letárolja a generált azonosítóval az objektumot.

Vaadin framework és Apache Tomcat 8 telepítése Eclipse Luna alá

Az utóbbi kommentekben a Java EE futtató és fejlesztői környezet kialakításával foglalkoztam. Gyakorlatilag van egy működő Apache Tomcat kiszolgáló ami alá már lehet telepíteni Java EE alkalmazásokat. Ez mellett van egy Eclipse IDE for Java EE developers fejlesztői környezet telepítve, amivel professzionális keretek között lehet Java programokat készíteni.

Az IDE azonban még nincs teljesen felkészítve. Ahhoz hogy igazán hatékonyan tudjunk dolgozni, szerencsés ha magában az IDE-ben is van egy működő webkonténer (pl. Apache Tomcat). Most ugyanis tesztelni úgy tudunk, ha a projektünket kiexportáljuk WAR fájlba, majd a telepített Tomcat adminisztrációs felületén deployoljuk (telepítjük) a projektünket. Ez így döcögős módszer lenne.
Ezért most első lépésben telepítjük a Tomcat-et az Eclipse alá.
(Eclipse Luna és Apache Tomcat 8.0.9 verziókkal, Ubuntu 14.04 Desktop rendszeren dolgozom)

1. Töltsük le és csomagoljuk ki valahová a Tomcat-et.
2. Indítsuk el az Eclipse-t.
3. Telepítsük a Luna update site-ról (http://download.eclipse.org/releases/luna) a JST Server Adapters és JST Server Adapters Extensions modulokat
   Nyissuk meg a Help/Install new softwares... menüt.
   A megjelenő ablakban válasszuk ki az alábbi képen látható módon a telepítendő modulokat
   
   

   

   JST Server Adapter telepítése

   Next, Next, Finish után települnek a modulok.
   
4. Ez után a Help/Preferences menüre kattintva az alábbi képek alapján rendeljük hozzá az Eclipse-hez az első pontban kicsomagolt Apache Tomcat-et.
   
   

   

   Server/Runtime Environment kiválasztása, majd Add... gomb

   
   

   

   Apache Tomcat v8.0 kiválasztása, majd Next

   
   

   

   A Browse... gombbal válasszuk ki azt a könyvtárat
   ahová a Tomcat-et kitömörítettük, majd Finish

Ezzel készen van az Eclipse a Server használatára úgy hogy az IDE-n belül tudjuk tesztelni, indítani az EE alkalmazásainkat.

Természetesen a Servers fülön még létre kell hozni egy példányt hogy hivatkozni lehessen rá.

A Servers munkaterületen jobb egérgomb, majd New/Server

Válaszuk ki a Tomcat 8.0 Server-t, majd Finish

Most már tényleg kész a szerverpéldány a futtatásra. El is indíthatjuk a servers fülön ha kijelöljük és megnyomjuk a zöld háromszög (Start server) ikont.

Az igazán hatékony EE fejlesztéshez valamilyen framework használata ajánlott. A neten olvasgattam ezekről és nekem a Vaadin framework tetszett meg a leginkább. Segítségével gyorsan lehet AJAX komponenseket felhasználva tetszetős felhazsnálói felületeket létrehozni. Sok leírás, könyv, tutorial lehető fel az interneten, így könnyen tanulható. A profik azt mondják hogy nem igazán szerencsés, mert gyakorlatilag egy olyan bonyolult oldalakat generál, amit nehéz módosítgatni. Na én most nem szeretném módosítgatni és első frameworknek szerintem nagyon jó. 

Szóval most a Vaadin telepítése következik.

Ez sem túl bonyolult, csupán a már ismert Help/Install new software... menüt választva a Vaadin update site-ot beállítjuk (http://vaadin.com/eclipse) és ott kijelöljük a Vaadin plugin-t. Ezután a végtelenségig bonyolult Next, Next, Finish nyomogatás következik és települ a plugin. A végén az  Eclipse kéri hogy had induljon újra. Hagyjuk jóvá.

Ezek után a File/New/Project.../Vaadin csoportból ki tudjuk választani a nekünk tetsző verziót, ezzel elindítva a egy új Vaadin projektet.

Ha egy üres projektet hozunk létre, akkor Run/Run as.../Run on Server menüvel a létrehozott Tomcat kiszolgálón tudjuk futtatni.

Most már komplett környezetünk van. Semmi nem akadályoz meg bennünket hogy komoly vállalati Java EE alkalmazásokat készítsünk!

Apache Tomcat 8 telepítése Ubuntu 14.04 alá lépésről-lépésre

Az előzőekben általánosságban írtam a Tomcat telepítéséről. Most a pontos rendszer struktúrába illeszkedő telepítést írom le, a teljes szolgáltatás indítással, és leállítással együtt.

Jelenleg a legfrissebb Tomcat verzió a 8.0.9. Ezzel fogom bemutatni a telepítést.
Természetesen rendelkeznünk kell működő Java-val. Nálam az Oracle Java 8 van telepítve.
(java -version parancs kiadásával ellenőrizhető)

1. Terminálban dolgozunk, indítsuk el.
2. Töltsük le a Tomcat-et a /tmp könyvtárba, majd csomagoljuk ki
   sudo cd /tmp
   sudo wget http://archive.apache.org/dist/tomcat/tomcat-8/v8.0.9/bin/apache-tomcat-8.0.9.tar.gzsudo tar -xvf apache-tomcat-8.0.9.tar.gz
3. Mozgassuk a teljes kicsomagolt könyvtárstruktúrát a /usr/local/ könyvtárba
   sudo mv apache-tomcat-8.0.9 /usr/local
4. Állítsuk be a Tomcat adminisztrátor felhasználót. Ezt a /usr/local/apache-tomcat-8.0.9/conf/tomcat-user.xml fájlban tehetjük meg. Adjuk hozzá a következő sorokat a fájlhoz, valahol a ... blokkon belül. Az itt megadott felhasználónév/jelszó párossal tudunk majd belépni a webes konfiguráló felületre.
   
   
   
5. Hozzuk létre a /usr/local/apache-tomcat-8.0.9/bin/setenv.sh parancsfájl. Ebben tudjuk beállítani a szükséges környezeti változókat. A JRE_HOME szükséges és a Java könyvtárára kell hogy mutasson. A CATALINA_PID és a CATALINA_OPTS ahhoz kell hogy távoli debugolást tudjunk végezni a szerver által futtatott komponenseken. Az alábbi legyen a fájl tartalma:
   #!/bin/bash
   JRE_HOME=/usr/lib/jvm/java-8-oracle
   CATALINA_PID="$CATALINA_BASE/tomcat.pid"
   CATALINA_OPTS="-agentlib:jdwp=transport=dt_socket,address=8081,server=y,suspend=n"
6. Állítsuk be a script attributumait
   sudo chmod 755 /usr/local/apache-tomcat-8.0.9/bin/setenv.sh
7. Hozzuk létre az indító/leállító/újraindító scriptet. Ehhez a /etc/init.d/tomcat809 fájlt hozzuk létre és a tartalma legyen az alábbi:
   
   #!/bin/bash
   
   export CATALINA_HOME=/usr/local/apache-tomcat-8.0.9
   PATH=/sbin:/bin:/usr/sbin:/usr/bin
   
   start() {
       sh $CATALINA_HOME/bin/startup.sh
   }
   
   stop() {
       sh $CATALINA_HOME/bin/shutdown.sh
   }
   
   case $1 in
       start|stop) $1;;
       restart) stop; start;;
       *) echo "Run as $0 "; exit 1;;
   esac
8. Fájl attributumokat állítsuk be 
   sudo chmod 755 /etc/init.d/tomcat809
9. Ezek után már indíthatjuk/leállíthatjuk/újraindíthatjuk a tomcat-et, a start, stop, restart paraméterekkel meghívva az indító scriptet. Most indítsuk el 
   sudo /etc/init.d/tomcat809 start
10. Ha azt szeretnénk hogy rendszerindításkor automatikusan induljon akkor frissítsük az rc.d-tsudo update-rc.d tomcat809 defaults
11. Ezek után a localhost:8080 URL-el bejön a gépünkön futó Tomcat induló oldala. A menedzselő gombok megnyomásakor a tomcat-users.xml-ben megadott felhasználónév/jelszó adatokkal tudunk belépni.

Java EE fejlesztői környezet kialakítása

A Java Enterprise Edition (EE) nem más mint a komoly nagyvállalati szoftverek készítésére szánt fejlesztői környezet.
Mivel a nagyvállalati szoftverek jellemzően valamilyen kliens-szerver architektúrát valósítanak meg, ezért szükségesek olyan komponensek a fejlesztői környezethez, amivel a nagyvállalati architektúrára készített alkalmazásokat futtatni lehet.
A JAVA desktop alkalmazásokhoz nem kell más, mint egy JRE (Java Runtime Environment) ami végülis maga a Java virtuális gép (Java Virtual Machine, JVM). Ez mindenképp szükséges ahhoz hogy a helyi gépen java programok futtassunk.

Példaként említhető talán a mindenki által ismert adóbevallás készítéséhez használt AbevJava nyomtatványkitöltő alkalmazás. Ha ezt futtatni akarjuk ahhoz szükséges a Java telepítése.

Az operációs rendszerünkhöz illeszkedő JRE telepítőt a Java oldaláról tudjuk letölteni, majd telepíteni.
Miután telepítettük a futtatási környezetet akkor rendszerünkben a java -version parancs kiadásával ellenőrizhetjük hogy működőképes-e a rendszerünk, tudunk-e Java programokat futtatni. A parancs kiírja az elérhető Java futtatási környezet verzióját. Amennyiben nincs elérhető java környezet, akkor értelmetlen parancsnak tekinti a rendszer az utasítást.

java -version parancs hatására megtudhatjuk hogy milyen verziójú futtatókörnyezet érhető el a számítógépen

Mint látható az én gépemen a Java SE 1.8 van telepítve. Ez azt jelenti hogy a számítógépemen tudok futtatni java programokat (pl remekül tudok adóbevallást készíteni az AbevJavával :) )

Az első lépés megvan. Igen ám, de mi nemcsak futtatni szeretnénk Java programokat, hanem készíteni is. Általánosságban elmondható hogy, ahhoz hogy egy adott nyelven megírt programot a számítógép számára futtathatóvá tegyünk, szükséges egy úgynevezett fordítóprogram (compiler), amivel a forráskódot át tudjuk alakítani olyan gépi kódú utasításokká, hogy azt a célszámítógép képes legyen végrehajtani.
Esetünkben szükséges egy Java fordító, ami a Java forráskódú programunkat átalakítja olyan kódsorozattá amit a célszámítógép, azaz a Java virtuális gép (JVM, ami a futtatási környezet része) végre tud hajtani. Ez a javac nevű program, ami a Java Development Kit (JDK, Java fejlesztői készlet) része. A JDK-t le lehet tölteni a Java honlapjáról, szintén az operációs rendszerünknek megfelelőt válasszuk.

Miután telepítettük a javac parancs kiadásával ellenőrizhetjük.

javac - version parancs kiadásával a java fordító verziószámát ellenőrizhetjük

Ezek után már tudunk java programot írni, azt le tudjuk fordítani és tudjuk futtatni is.
Próbáljuk is ki ezt a méltán híres "Hello world!" példaprogrammal.
A kedvenc szövegszerkesztőnkkel (ne a Word-el!!!) hozzuk létre a java forrásprogramot.

Én az alábbi példában a példa rövidsége miatt közvetlenül parancssorból fogom begépelni a kódot egy Linux terminálból. Windows alatt az első cat >HelloWorld.java parancs helyett a copy con HelloWorld.java parancsot kell kiadni. Nyilván nagy projekteknél nem ezt a módszert kell alkalmazni.

A híres Hello, Wolrd! program megírása, fordítása és futtatása

A programkészítés menetét is szépen bemutatja a fenti képernyőrészlet:

• Szerkesztés (edit): először a program forráskódját készítjük el. Ekkor standard ASCII szövegfájlt kell készítenünk, tehát erre a célra nem a Microsoft Word a legjobb megoldás. A példában egy egyszerű terminálparanccsal billentyűzetről közvetlenül a fájlba küldtük a begépelt karaktereket, majd a kód beírása után a CTRL-Z billentyűkombinációval tudjuk a fájl vége karaktert beírni és a szerkesztést befejezni. Ekkor előáll a forráskód, amit a fordítóval lehet tovább kezelni.
• Fordítás (compile): a fordítási művelet a forráskódot átalakítja a célgép számára értelmezhető utasítássorozattá. Java esetében az úgynevezett bájtkódot kell előállítani, amit a Java virtuális gép (ez a célgép) végre tud hajtani. A fordítást az előzőekben a JDK telepítése után a rendszerünkben elérhetővé vált javac paranccsal tudjuk végrehajtani. Paraméterül a HelloWorld.java fájlt adjuk meg természetesen. A kiadandó parancs: javac HelloWorld.java
  A fordítás eredményeként létrejön a HelloWolrd.class fájl, amit már a JVM végre tud hajtani.
• Futtatás (run): a fordító által létrehozott programot már tudjuk futtatni mégpedig a JRE telepítése kapcsán rendszerünkben elérhetővé vált java parancs segítségével. Paraméterül kiterjesztés nélkül kell megadni a .class fájlt. Esetünkben a parancs: java HelloWorld
  Eredményül a program kiírja a Hello, World! szöveget, majd kilép.

A cikk címe szerint Enterprise fejlesztői környezet kialakításáról kellene szólni és eddig csak egy desktop parancssori alkalmazást készítettünk. Valójában már most kész a rendszerünk és tudunk Java EE programot készíteni, hiszen a Java futtató és fejlesztői környezet képes erre. Azonban a szerver oldalon picit másképp történik a java szerver oldali programok futtatása. Valójában nem közvetlenül a JVM vezérli a program végrehajtását, hanem egy úgynevezett alkalmazás szerver (AS, Application Server). Ez egy olyan konténer, melyben a szerver oldali java alkalmazások betölthetők, majd a hálózaton keresztül érkező kérésekre reagál. Jellemzően HTTP kérések érkeznek a kliensek felől, amit az AS fogad, majd átad az általunk megírt szerver oldali komponensnek. Ez a komponens elvégzi a kért műveletet, majd egy HTTP üzenetként visszaküldi a kliensnek az eredményt. A kliens fogad és a kliens oldali komponens megjeleníti az eredményt.

Nagyjából ezek a lépések. Ahhoz hogy mindezt fejlesztőként meg tudjuk csinálni szükségünk van egy alkalmazás szerverre (AS) is. Csinálhatnánk úgy is hogy a szerver oldali részt lefordítjuk, majd feltöltjük egy távoli AS-re és a kliensünkkel rácsatlakozunk. Ennél sokkal jobb megoldás, hogy a saját gépre telepítünk egy AS-t és azon futtatjuk a komponensünket. Na ez az ami hiányzik a valódi Java EE fejlesztői környezethez.

Többféle AS létezik ami ki tud szolgálni Java komponenseket. Kettőt említek meg és abból egyet fogunk bekonfigurálni. Az egyik a GlassFish nevű, valóban nagy teljesítményű és professzionális alkalmazás szerver. Az Oracle fejleszti és ez a Java referencia szerver. 

Ennél egyszerűbb, de továbbra is nagy teljesítményű eszköz az Apache webszerver fejlesztőitől az Apache Tomcat nevű alkalmazásszerver. Konfigurálása, futtatása egyszerű, ezt fogom bemutatni a következőkben.

A Tomcat telepítése nagyon egyszerű. Le kell tölteni a szükséges verziót az Apache honlapról és ki kell csomagolni.

Ezután a Tomcat könyvtár alatt lévő bin könyvtárba létre kell hozni egy setenv.sh (windows alatt setenv.bat) parancsfájlt, amibe csupán ki kell adni néhány környezeti változó beállítására szolgáló parancsot. Linux esetében ezt tartalmazza a fájl:

#!/bin/sh

CATALINA_HOME=/tomcat-elérési-utja/bin

JRE_HOME=/var/lib/jre/java-8-oracle

Ezek után a tomcat könyvtárán belül a bin könyvtárban ki kell adni a ./startup.sh parancsot. Ez elindítja a Tomcat-et:

Apache Tomcat indítása

Ezek után a Tomcat figyeli a 8080-as porton érkező HTTP kéréseket. Ezt ellenőrizhetjük ha a böngészőnkbe behozzuk a http://localhost:8080 URL-t.

Fut a Tomcat és válaszol a 8080-as porton

Amennyiben ezt elértük, akkor készen vagyunk az Enterprise alkalmazások futtatására. Nyilván ha adatbázissal dolgozunk akkor kell valamilyen SQL szerver (MySQL, Postgress) is, de az már alkalmazás specifikus dolog.

Ami még a professzionális fejlesztéshez kell, az egy professzionális integrált fejlesztői környezet (IDE). Erre a célra az Eclipse-t javaslom.
Ennek telepítése sem bonyolult. Le kell tölteni az Eclipse honlapjáról a Java EE developer IDE-t és ki kell csomagolni. Ennyi.

A végén meg kell említenem a http://appdev.bedok.hu/cikk/ECLIPSE_JAVA cikket, ahol rengeteg jó ötletet és gondolatot találtam az EE fejlesztéssel kapcsolatban. Egy részét az ott leírtaknak felhasználtam a cikkben.