Blog - Hannes Pries - Webdeveloper Blog - Entwicklung mit Shopware, PHP, HTML5 und JavaScript

Oracle und Java EE

Wie man überall lesen kann will Oracle nun auch JEE gerne abgeben. Aber sie sichern zu weiterhin an Java festzuhalten.

In den meistens News klingt es so als wäre das ein Widerspruch in sich. Ich kann Oracle aber vollkommen verstehen. Der Java-Core ist so oder so OpenSource und JEE ist optional und kann durch andere Lösungen wie Spring ersetzt werden. Wie Standards wie JMS, EJB3 und so sind wirklich toll und funktionieren super. Sie werden auch viel genutzt, also kann man die auch nicht wirklich sterben lassen, gerade wenn man selbst damit viele Anwendungen gebaut hat.
Oracle auch wirklich viel mit Java gemacht und auch sehr gute Anwendungen damit entwickelt. Nur warum sollte man dafür im Besitz eine Standards sein? Als das alles noch bei Sun lag lief auch alles super und (jetzt folgt der wichtige Punkt) man musste sich nicht mit dem ganzen Drumherum rumärgern.
Als PHP Entwickler hat man ja auch nicht gleich Lust sich den PHP-Standard noch mit auf zu halsen.

Bei der Eclipse Foundation wäre JEE gut aufgehoben und Oracle kann weiterhin mit Java entwickeln und sich sogar einbringen ohne gleich für alles verantwortlich gemacht zu werden.

Ich bin jeden Fall gespannt wie es weiter geht und sehe da mehr Zuspruch in die Zukunft Javas von Oracles Seite als mögliches Abwenden von JEE oder gar Java an sich.

PS: Ich sehe es ähnlich wie dieser Artikel auf Heise-Developer

Shopware Plugins mit Eclipse PDT entwickeln

Momentan steht bei mir an ein Plugin für Shopware zu entwickeln.

Das erste Problem dabei ist nicht mal, wie das funktioniert, weil das ist im Internet mehrfach gut erklärt, sondern wie man seine Entwicklungsumgebung aufsetzt.
Shopware ist schnell installiert. Aber man will für ein Plugin ja nicht immer das gesamte Shopware mit im Projekt haben. Also wird nur das Verzeichnis aus custom/plugins/ als Projekt-Verzeichnis gewählt.
Bei Eclipse kann man Projektverzeichnisse außerhalb des Workspaces anlegen.

Nun hat man das Problem, dass einem die ganzen Klassen von Shopware fehlen und man so viele Warnings und keine Autovervollständigung hätte.

Über Properties > PHP > Source Paths > Build Path kann man externe Source-Verzeichnisse verlinken.

ich habe das engine-Verzeichnis von Shopware gewählt und noch zusätzlich dessen vendor-Verzeichnis.

Die PHPUnit Tests werfen dann zwar noch Fehler. Aber die Plugin-Klasse von Shopware wird schon einmal gefunden und damit ist der erste Schritt schon getan.

Damit kann meine Arbeit an meinem ersten Shopware-Plugin jetzt anfangen.

RXTXComm in Eclipse

Um RXTXComm für Java in Eclipse verwenden zu können muss man auch die DLLs Eclipse bekannt machen.
Im Buildpath muss man die JAR finden und dann ausklappen. Bei der Native Library Location muss man Edit wählen.

Ich hatte die DLLs einfach mit im lib-Folder abgelegt.

Danach lief auch die Suche von SMSlib.

Leider funktioniert mein alter Huawei E1750 unter Windows 10 wohl nicht mehr so einfach. Ich habe mir mal den 4G Systems XS Stick P10 bestellt und hoffe, dass dieser gleich und ohne Probleme funktioniert.

Und dann mal die Beispiele zum SMS-Empfang von SMSlib testen.

Eclipse PDT Extensions

Mit den PDT Extensions kann man auch in Eclipse mit PHP ganz normal Getter und Setter erzeugen.

IDE Einrichten für Einsteiger - Teil 3 - eine Datenbank hinzufügen

Bevor es dann wirklich mal um die Installation von PDT in Eclipse geht, wollen wir uns erst einmal eine MySQL Datenbank einrichten, damit wir auch richtige kleine Anwendungen schreiben können und nur ganz selten kommt man da ohne Datenbank aus. Auch wenn NoSQL Datenbanken wie Neo4J wirklich toll und momentan sehr in sind, bleiben wir bei einem klassischen RDBMS. Weil MySQL gerade im Web sehr verbreitet ist und sich einfach lokal einrichten lässt, bleiben wir auch bei MySQL.

Wer ein Linux benutzt, kann MySQL immer ganz einfach über den Paket-Mananger installieren. Für Windows kann man schnell zu XAMPP greifen. XAMPP enthält alles vom Apache, PHP7 und MySQL bzw MariaDB.

XAMPP funktioniert am Besten wenn man es direkt unter C:\ installiert.

Zum Verwalten der Server-Anwendungen von XAMPP gibt es das XAMPP Control Panel. Hier müssen nur der Apache und der MySQL Server gestartet
werden.

Damit auf die Datenbank zugegriffen werden kann bringt XAMPP phpMyAdmin mit. phpMyAdmin ist eine Datenbankverwaltung die in PHP geschrieben ist und auch von den meisten Hostern angeboten wird.. wenn nicht sogar von allen. Man kann direkt über die URL http://localhost/phpmyadmin darauf zugreifen.

Zuerst erstellen wir eine Datenbank mit dem Namen blog_test.

Damit wir ein paar Daten haben, legen wir uns eine Tabelle mit ein paar wenigen Daten an. Hier ist das SQL-Script dafür:

CREATE TABLE TEST_ITEMS(
ITEM_ID INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
ITEM_VALUE VARCHAR(255) NOT NULL,
PRIMARY KEY(ITEM_ID)
);

INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_01');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_02');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_03');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_04');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_05');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_06');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_07');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_08');
INSERT INTO TEST_ITEMS (ITEM_VALUE) VALUES('TEST_09');

Die IDs werden automatisch hochgezählt und müssen deswegen nicht extra angegeben werden.

Nun gehen wir wieder in Eclipse zurück und erstellen uns eine kleine JSP mit einer Datenbankabfrage. Und hier wird es etwas komplizierter mit den verschiedenen ClassLoader des Tomcats und den verschiedenen Config-Dateien. Ich hab die einfachste aber nicht beste Variante gewählt. Die JAR-Datei mit dem JDBC-Treiber kommt direkt in das lib-Verzeichnis des Tomcat und wir passen die zentrale context.xml Datei, die uns von Eclipse zur Verfügung gestellt wird.

Die aktuelle JAR mit dem MySQL-Treiber findet man auf dev.mysql.com.

In die Context-Datei definierten wir die DataSource als Resource.

Und in der web.xml die im WEB-INF Verzeichnis des Content-Bereich des Projekts liegt, referenzieren wir diese Resource.

<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/TestDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>

Nun können wir über JNDI uns diese DataSource in eine JSP holen. Wir erstellen eine ganz einfach Abfrage. Das Ergebnis liefert uns ein Statement in Form eines ResultSets. Ich benutzt hier die Methode über den Index die Ergebnisse zu bekommen, z.B. getString(1) wobei aber auch getString("ITEM_ID") funktioniert und für den zielgerichteten Einsatz sehr viel besser ist, weil man so das SQL-Statement ändern kann und auch die Reihenfolge der Columns ändern, ohne dabei auf den Java-Code achten zu müssen. Hier wird aber nicht zielgerichtet ein Wert ausgelesen und z.B. in ein anderes Object geschrieben sondern einfach alles ausgegeben. Deswegen auch nur getString() und keine anderen Methoden, die einen passenden Datentyp zurück liefern und ein eigenes Casten der Werte unnötig machen.

<%@page import="java.sql.ResultSetMetaData"%>
<%@page import="java.sql.ResultSet"%>
<%@page import="java.sql.Statement"%>
<%@page import="java.sql.Connection"%>
<%@page import="javax.sql.DataSource"%>
<%@page import="javax.naming.InitialContext"%>
<%@page import="javax.naming.Context"%>
<html>
<head>
<title>Blog Test DB</title>
<style type="text/css">
table{
border-collapse:collapse;
}

td, th{
border:1px solid #000000;
padding:4px;
}

th{
font-weight:bold;
}
</style>
</head>
<body>
<table>
<%
try{
//get DataSource
Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup("java:/comp/env/jdbc/TestDB");

//prepare SQL
String sql="SELECT * FROM TEST_ITEMS";

//Query database
Connection conn=ds.getConnection();
Statement stmt=conn.createStatement();
ResultSet rset=stmt.executeQuery(sql);
ResultSetMetaData rsetM=rset.getMetaData();

//output
%>
<tr>
<%
for(int i=1; i<=rsetM.getColumnCount();i++){
%>
<th><%=rsetM.getColumnName(i) %></th>
<%
}
%>
</tr>
<%
while(rset.next()){
%>
<tr>
<%
for(int i=1; i<=rsetM.getColumnCount();i++){
%>
<td><%=rset.getString(i) %></td>
<%
}
%>
</tr>
<%
}

//close all resources
rset.close();
stmt.close();
conn.close();
}
catch(Exception e){
e.printStackTrace();
}
%>
</table>
</body>
</html>

Der Vorteil die Connection über eine DataSource zu bekommen und nicht jedes mal selbst zu initiieren ist, dass die DataSource ein Pooling der Connections vornimmt und Datenbankverbindungen zur Wiederverwendung offen hält, um den Overhead für Verbindungsaufbauten zu verringern.

SQL-Abfragen direkt in einer JSP-Seite zu ist aber eine schlechte und man sollte so etwas in DAO-Klassen auslagern und in der JSP nur die Ansicht mit schon fertigen Objekten erstellen, die dann vom DAO geliefert werden.
Außerdem werden immer mehr JPA verwendet, wo die SQL-Statements automatisch erzeugt werden. Handgeschriebenes SQL ist in komplexen Fällen meistens schneller und besser, aber ORM-Frameworks erleichtern einen die Arbeit schon sehr und man sollte sich JPA auf jeden Fall einmal
ansehen, bevor man noch direkt mit JDBC und SQL arbeitet.

Im nächsten Teil geht es dann wirklich mit PHP weiter.

IDE Einrichten Teil 3.. dauert noch etwas

Da ich momentan viel an Projekten und Job zu tun habe, wird es mit dem 3ten Teil über Eclipse und PHP noch etwas dauern.. vorher steht auch noch ein Post über Neo4j und Datenimports auf dem Plan.

Aber hier schon mal ein kleines Video wie man PHP CLI-Anwendungen mit Eclispe + PDT startet.

IDE einrichten für Einsteiger - Teil 2 - Tomcat

Java + Tomcat (Teil 2)

Nachdem wir uns im letzte Teil schon eine Entwicklungsumgebung für Java eingerichtet haben, können wir Desktop Anwendungen schreiben. Aber für Serveranwendungen benötigen wir einen Servlet Container oder einen Application Server. Für Microservices gibt es auch andere Frameworks, aber wir beschränken uns hier erstmal auf eine einfache JSP-Seite.
Ein kleines Servlet kommt auch noch hinzu. Man könnte auch direkt mit JSF anfangen, aber um sich mit dem Thema Webdevelopment in Java vertraut zu machen fangen wir ganz einfach an. Mit JSP und Servlet kann man auch alles bauen. Von einfachen Webanwendungen mit einzelnen Pages, über MVC-Frameworks bis hin zu REST-APIs. Für das meiste gibt natürlich fertige Frameworks, aber es in einem kleinen Beispiel mal selbst zu versuchen, bringt einen oft einen besseren Einblick in diese Bereiche und man versteht, die vorhandenen Frameworks besser und auch warum sie so funktionieren wie sie funktionieren.

Zuerst downloaden wir uns einen aktuellen Tomcat 8. Den Tomcat Servlet-Container gibt es schon seit vielen Jahren.. eigentlich seit Anfang an und entsprang dem Jarkata-Projekt von Apache. Ich bin 2004/2005 mit dem Tomcat 4 angefangenm wo noch alles unter Apache Jarkata tomcat lief und erst später dann mit der 5er Version zum Apache Tomcat wurde. Man wird aber den Begriff Jarkata noch oft genug bei den Libs und Klassen des Tomcat finden.

Download Apache Tomcat 8.0.x

Einfach die passende ZIP-Datei downloaden und an einen beliebigen Ort entpacken. Da wir alles über Eclipse steuern, müssen wir erst einmal da nichts weiter machen. Wer den Tomcat auch mal so ausprobieren möchte muss JAVA_HOME bei den Umgebungsvariablen von Windows setzen und auch den Pfad zum JRE (zum Bin-Verzeichnis) im Path von Windows hinterlegen. Dann kann man im Tomcat-Verzeichnis mit bin/startup.bat den Tomcat starten. Die einfache Startseite sollte dann unter http://localhost:8080/ aufrufen.

Aber jetzt zurück zu Eclipse. Wir laden unseren Workspace aus dem letzten Teil oder einen anderen den wir benutzen möchten. Wir öffnen Window -- Preferences -- Server - Runtime Environments.
Dort clicken wir auf Add..., um den Tomcat hinzu zufügen.

Wir wählen den Tomcat 8 aus und clicken auf Next. Dann wählen wir unser Tomcat Verzeichnis aus.

Wenn noch keine Server-View angezeigt wird, müssen wir uns diese nochmal hinzufügen.

Dort clicken wir auf den Link, um einen neuen Server hinzu zufügen. Da wir nur eine Runtime haben, wird uns diese auch direkt vorgeschlagen. Wir übernehmen alle Vorgaben und wählen Finish.

Damit haben wir unseren Server fertig eingerichtet und können nun zu unserem kleinen Beispiel-Projekt übergehen. Wir fangen ganz einfach mit einer JSP-Seite an, bei der wir ein Input-Feld für einen Namen haben, der dann an die Seite übergeben wird und diesen mit Hallo {name}! wieder ausgibt. Klassisch, einfach und die wichtigsten Dinge wie Forms, Request und Ausgabe sind dabei.

Wir brauchen ein Dynamic Web Project:

Das Projekt fügen wir auch gleich zu den Projekten hinzu die automatisch bei Änderungen neu auf dem Tomcat deployed (wichtiges Wort in der Java-Welt!) werden. Wenn also etwas geändert wird, wird Projekt einmal auf dem Tomcat entfernt und neu hinzugefügt, so dass die Änderungen über einen Webbrwoser betrachtet werden können. So etwas kann bei größeren Projekten paar Sekunden dauern.. aber zum Glück muss nur bei Java-Dateien neu deployed werden. HTML, CSS oder JavaScript Dateien erfordern kein erneutes Deployment und Änderungen sind einfach so verfügbar, weil direkt auf die Dateien zu gegriffen wird und nichts kompiliert werden muss.

Nun fügen wir uns eine index.jsp hinzu. JSP-Seiten werden im WebContent angelegt, um gefunden zu werden. Die index.jsp ist wie eine index.html und wird beim Aufruf verwendet, wenn keine andere Seite angegeben wurde. Das Verhalten kann man über eine web.xml definieren. Dort kann man auch Servlet-Mappings und Resources definieren. Aber so eine brauchen wir erst einmal nicht.

Auf die Seite kommt eine einfache Form und die Ausgabe des Namen, wenn im Request ein Name gefunden wird. Wir übergeben einfach mal den Namen per GET damit man sehen kann, wie der Parameter über die URL übergeben wird. Normal sollte man Form-Eingaben über POST übergeben. Aber die Änderung ist ja im Form-Tag schnell gemacht.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Blog-Beispiel</title>
</head>
<body>
<%
if(request.getParameter("name")!=null && request.getParameter("name").length()>0){
%>
Hallo <strong><%=request.getParameter("name") %></strong>! <a href="index.jsp">reset</a>
<%
}
else{
%>
<form method="get">
<input type="text" name="name" /><br/>
<input type="submit" value="ok"/>
</form>
<%
}
%>
</body>
</html>

Aufrufen können wir diese Seite mit der URL nach dem Schema http://localhost:8080/{projectname}/ bei meinem Beispiel als http://localhost:8080/BlogTomcat/.

Eine JSP-Seite ist ja nur die Ausgangsdatei und diese wird in ein Servlet kompiliert. Servlets sind gerade für Dinge noch sehr gut, wenn man keine große Ausgaben hat, z.B. für Uploads, Downloads (mit vorherigen Benutzercheck) oder REST-APIs, die einfach immer ein Object in JSON umwandeln. Um schon mal ein Servlet gesehen zu haben erstellen wir unser Beispiel noch mal direkt als Servlet.

package de.hannespries.blog.ides.tomcat;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name="nameservlet",urlPatterns={"/name"})
public class NameServlet extends HttpServlet{
private static final long serialVersionUID = 609957577169396811L;

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String out="<html><head><title>Blog-Beispiel</title></head><body>";
if(req.getParameter("name")!=null && req.getParameter("name").length()>0){
out+="Hallo <strong>"+req.getParameter("name")+"</strong>! <a href="/name">reset</a>";
}
else{
out+="<form method="get"><input type="text" name="name" /><br/><input type="submit" value="ok"/></form>";
}
out+="</body></html>";
resp.getWriter().println(out);
}

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
}
}

Das URL-Pattern ist hier sehr einfach gehalten. Man kann auch Wildcards und ähnliches setzen, was sehr praktisch ist, wenn man Werte in URLs einbauen möchte, was sehr gut für SEO ist. Beipsiel /service/item/2/ wobei 2 die Id des Item in der Datenbank ist und darüber geladen werden kann.

Wobei wir zum Thema Datenbanken im nächsten Teil kommen, wo wir uns eine Entwicklungsumgebung für PHP einrichten. Da auch dort Eclipse zum Einsatz kommt, sollte man auch wenn man sich nur für Java interessiert den Teil doch mal durchlesen und gerade der Bereich mit der Einrichtung einer MySQL-Datenbank ist interessant, wenn man eine Webanwendung im Tomcat entwickelt. Das Anlegen einer Datasource in der Config des Tomcats werde ich dort auch nochmal kurz erläutern.

IDE einrichten für Einsteiger - Teil 1 - Java

Bald ist wieder die Zeit der Bewerbungstest und -gespräche für Fachinformatiker AE(=Anwendungsentwicklung) Ausbildungsstellen oder man ist noch in der Schule und überlegt sich, ob man sich den Abi-Stress wirklich antun soll. In beiden Fällen hat man sich wohl schon einige Gedanken gemacht und wollte sich schon mal ein Bild davon machen wie Programmieren in de, Beruf aussieht. Privat zu entwickeln ist doch immer etwas anderes als anderes.

In den meisten Fällen wird man sich seinen Ausbildungsplatz nicht danach aussuchen, welche Programmiersprachen in der jeweiligen Firma verwendet werden. Man wird nehmen was man bekommt. Wenn man sich aber mal grob auf ein Gespräch vorbereiten will und man in eine neue Sprache hinein schnuppern möchte, muss man sich erst einmal eine Umgebung einrichten. Es gibt genug Tutorials dazu.. deswegen möchte ich in nichts nachstehen.

Ich musste damals mir auf die Schnelle alles einrichten um ein C-Programm unter Linux zu schreiben und zu compilieren. Mit Hilfe des Internets ging es auch ganz gut. Aber für C bringt Linux auch alles.

Ich zeige hier aber einfach mal, was man alles braucht, um mit Java, PHP und JavaScript ein kleines "Hello World" Programm zu schreiben. Wobei die Einrichtung der Umgebung im Vordergrund steht und nicht das kleine Programm.

Java (Teil 1)
Java Umgebungen sind nicht immer das einfachste. Wenn man eine Webanwendung schreiben möchte, hat man schon relativ viel zu konfigurieren. Deswegen erst einmal ein kleine und einfache Anwendung.
Als erstes brauchen wir Java. Für die Entwicklung mit Java benutzt man am Besten das JDK (Java SE Development Kit). Es enthält zusätzliche Werkzeuge und den Source-Code zu den Java-Klassen. Außerdem wird keine komische Ask-Toolbar mit installiert. Das JRE ist mit dabei, so dass man mit dem JDK allein auskommt.

Die aktuelle Version der 8er Reihe findet man hier: Oracle Java 8 JDK

Man könnte jetzt theoretisch schon mit einem Text-Editor sein erstes Java-Programm schreiben und mit dem Java-Compiler compilieren. In einem Text-Editor zu schreiben ist aber alles andere als angenehm und man hat keine Syntax-Highlighting, Code-Vervollständigung oder automatische Anzeige von Fehlern. So eine Integrierte Entwicklungsumgebung (IDE) erleichtert einen schon sehr viel.

Die IDE meiner Wahl ist Eclipse. Man kann aber auch NetBeans oder IntelliJ verwenden. Das Grundprinzip ist bei allen gleich. Aber hier nehmen wir Eclipse.

Hier findet man den Download von Eclpise J2EE. Die J2EE-Version, weil da alles mit dabei ist, was man so braucht. Auch alles was man braucht, um ein einfaches Web-Project mit einem Tomcat zu realisieren.

Bei Eclipse einfach die Zip-Datei downloaden und entpacken. Beim ersten Start wird ein Workspace angelegt. Der Workspace ist ein Verzeichnis in dem die Projekte abgelegt werden.
Man kann beliebig viele Workspaces haben und auch mehrere Eclipse Instanzen mit verschiedenen Workspaces gleichzeitig geöffnet haben.

Sollte man schonvorher eine Java-Version installtiert gehabt haben, sollte man nun das neu installierte JDK auswählen. Dazu geht man im Menu in den Menüpunkt.

Window -- Preferences -- Java -- Installed JREs

Dort mit Hilfe der Search... Funktion nach dem neuen JDK suchen lassen. Wenn es gefunden wurde dieses mit dem Hacken vorne als default JRE definieren. Dann wird es automatisch für jedes Projekt verwendet, dass keine eigenen Einstellungen für JRE-Libs hat. Aber das ist jetzt erst einmal nicht so wichtig. Für uns ist nur wichtig, dass unser neues Project das JDK verwendet.

Wenn wir unser JDK eingebunden haben können wir nun unser Project erstellen.

Wir geben dem Project einen Namen. Hier kann man auch gleich sehen, ob unser JDK die default JRE ist. Hier könnten wir auch ein abweichendes JRE auswählen.

Weitere Einstellungen nehmen wir nicht vor und klicken einfach auf finish.

Das Project wird angelegt und wir legen uns unsere Klasse an, die unser Haupt-Programm enthalten wird. Die Klasse ist Main und wird im Package de.hannespries.blog.ides liegen. Packages sind so etwas wie Verzeichnisse, um die Klassen zu strukturieren, aber auch nur ähnlich, weil ein Package über mehrere JAR-Dateien verteilt sein können.

In die Main Methode kommt unser Code. Da wir schreibfaul sind und jetzt eine tolle IDE haben geben wir nur syso ein

jetzt drücken wir Strg+Space und nutzen unser syso zu einem System.out.println() zumachen. Das geht so sehr viel schneller als wenn man alles per Hand schreiben würde, wie man es in einem Text-Editor machen müsste.

package de.hannespries.blog.ides;

public class Main {

public Main() {
// TODO Auto-generated constructor stub
}

public static void main(String[] args) {
//unser Code:
System.out.println("Hello World!");
//
}
}

Nun wollen wir den Code einmal testen. Erst einmal Speichern. Dann öffnen wir mit einem Rechtsclick das Context-Menü, wählen Run as und dann Java-Application.

Damit wir immer die Console direkt anzeigt bekommen, wenn eine Ausgabe kommt, selbst, wenn wir einen anderen Tab gerade offenen hatten, nehmen wir noch folgende Einstellung vor.

Wenn man das Programm dann mal mit anderen Teilen möchten, kann man über die Export-Funktion eine JAR-Datei erstellen. Wichtig dabei ist, dass man die main-Methode der entsprechenden Klasse auswählt, damit das Programm direkt gestartet werden kann. Die Manifest-Datei ist aber sehr komplex und ist an sich einen eigenen Artikel wert.

Damit haben wir Java und Eclipse installiert. Der Test lief auch. Im nächsten Teil werden wir dieser Installation einen Tomcat hinzufügen und unsere erste kleine JSP-Seite erstellen und im Browser anzeigen lassen.

Spontaner Weihnachts- Nikolausgeschenk-Tipp: SSD

Ist leider nur ein Tagesangebot bei Amazon. 25.11.2015

Aber auch ein gutes Weihnachts- oder Nikolausgeschenk. Es sollte auch gut in einen Schuh passen.. bei 3,5 Zoll Laufwerken kann es ja schon schwieriger werden.

Es ist ein ideales Geschenk für ITler mit älteren Notebooks oder PCs, Fallout 4 Spielern, die sich über die hohen Ladezeiten aufregen (ich hab es gesehen, wärend meine Frau es spielte.. die Ladezeiten sind shcon wirklich alles andere als optimiert).
Eclipse sollte beim Bauen des Workspaces auch sehr davon profitieren können.

Eine 120GB SSD. Kein Highend und nicht so viel Speicher (4-5 Spiele oder das Betriebssystem sollten aber ohne Probleme passen).. aber sehr günstig.

bbcode-image

SanDisk SSD PLUS 120GB Sata III

520MB/s beim Lesen ist schon eine brauchbare Leistung, wir sind ja auch mit Festplatten ausgewachsen die 20MB groß waren. Man kann sich ja mal ausrechnen wie viele dieser Festplatten da pro Sekunde ausgelesen werden würden.

Hannes installiert sich seine Entwickler-Werkzeuge:

Gehen wir mal davon aus, ich hätte doch mal das Geld für einen neuen PC und würde alles neu installieren müssen.
Was wäre das alles? Bei vielen Programmen nehme ich die portable-Version wenn vorhanden, weil man dann einfach das
Programm inkl. alle Einstellungen und Daten kopieren kann und sich nicht über die Migration der Daten Gedanken machen braucht.

* Notepad++ (Portable): Seit man einfach den Editor schließen kann und er speichert auch nicht gespeicherte Texte automatisch mit, ist er ideal für Notizen, kleine Text und schnelle Bearbeitungen einzelner Dateien. EmEditor kann es nicht, dafür paar andere tolle Dinge, wie Zeilen mit Such-Treffen in ein neues Dokument extrahieren, aber gerade dass ich EmEditor nicht einfach schließen kann ohne zu speichern, empfinde ich als großen Nachteil.

* WinSCP (Portable): Der eingebaute Editor ist kein Highlight, aber besser als wenn per Default immer der von Windows verwendet werden würde. Das Programm läuft auch stabil und hat mich bis jetzt nie im Stich gelassen. Bitvise finde ist als SFTP oder SSH Client irgendwie schlechter zu bedienen und es ist eben nicht Opensource.

* Eclipse + PDT: Bei Eclipse reicht es auch die ZIP-Datei zu entpacken. Über das Software-Menü dann einfach PDT nach installieren und vielleicht nochmal die Zuordnung der *.php-Dateien zum entsprechenden Editor bearbeiten.Wie man Unterstützung für Getter und
Setter installiert findet man hier: PDT-Extensions. PHPStorm kann auch einiges. Ich finde es aber auch unübersichtlich. RemoteHost-View.. ist unter Deployment zu finden. An sich ja nicht verkehrt, wenn man das weiß. Bei Eclipse einfach bei den Views gucken. Da kann man auch suchen und findet alles innerhalb von Sekunden. Vielleicht liegt es auch daran dass ich Jahre mit Eclipse verbracht habe und es lieben und auch oft
genug hassen gelernt habe, aber bei PHP ist es mein Favorit und es ist eben Opensource.

* Oracle SQLDeveloper: Wenn man mal mit Oracle zu tun hat oder keine Lust auf phpMyAdmin hat, ist es immer noch meine Lieblingssoftware für Datenbank-Entwicklung. phpMyAdmin ist eben sehr träge (für eine Webanwendung aber noch wirklich schnell.. nur im Vergleich). HeidiSQL ist einfach nicht so professionell. Man merkt dass Oracle sich mit Datenbanken auskennt.

* Source Tree für GIT-Repositories. Die GIT-Integration in Eclipse war jedenfalls nie wirklich toll, wie ich fand. Der Konsolen-Client funktionierte,war aber für Nicht-Programmierer wirklich zu umständlich. Tortoise.. ja.. hat bei mir noch aus Delphi+SVN Zeiten einen schlechten Nachgeschmack hinterlassen. Auch wenn deren SVN Client manchmal durch mergen zerstörte Projekte wieder retten musste zusammen mit Notepad++.

* XAMPP oder Bitnami... Benutze ich beides und am Ende mag ich XAMPP minimal lieber. Deren Kontroll-GUI ist etwas aufgeräumter und ich kann auch hier einfaches von einem PC auf den anderen kopieren. Aber funktionieren tun beide gut.

* ein aktuelles JDK: Weil viele der oben genannten Programme Java-Programme sind und ich unter Umständen auch mal ein kleines Java-Programm schreiben oder pflegen muss. Eine aktuelle JDK8-Version installieren und die reicht erst einmal lange ohne Updates. Sollte ich nicht doch plötzlich wieder voll auf Java setzen. Dann aber nur mit Tomcat und vielleicht der aktuellsten JSF-Version oder meinen REST-Framework und das Frontend entsteht komplett in AngularJS (habe ich so schon benutzt und funktioniert extrem gut und ist PHP mit dem Application-Scope und echten Singletons teilweise
weit voraus bei der Performance.. mal PHP7 abwarten).

Und dann eben noch der ganze Rest wie Firefox Developer Edition (64-Bit), Thunderbird, Chrome, etc. Was man auch zum Testen und dem Alltag so
braucht.

PHP Projekte bauen mit ANT

Privat arbeite ich ja mit Eclipse und PDT. An sich gefällt mir das auch sehr viel besser als PHPStorm. Genauso wie ich auch immer WinSCP Bitvise vorziehen würde.

Aber zurück zum Thema. Wenn man schon mit einer eigentlich auf Java ausgelegten IDE arbeitet, kommt man beim Build-System als erstes auf Apache ANT. Ich mag ANT und es funktioniert echt super.
Da ich demnächst etwas über Datenbanken, Mapping und Reflections in meinem Blog verfassen will und diesmal auch direkt komplett lauffähigen Code mit liefern möchte, musste ich alles in eine Zip-Datei packen. Per Hand ist es doof, aber mit 6 Zeilen XML kann man mit ANT einfach eine Zip-Datei mit Datum im Dateinamen erstellen.

build.xml

PS: PDBC steht für PHP DataBase Connectivity. Began vor 10 Jahren in der Berufsschule und der Name ist wie man merkt sehr an JDBC angelehnt.

PDT und Getter und Setter

Das was PDT immer fehlte war die Erzeugung von Gettern und Settern. Bei Klassen verbrachte man viel zu viel Zeit damit diese Methoden hinzu zufügen.. es war unglaublich monoton und fehleranfällig. Aber es gibt Rettung!

http://p2-dev.pdt-extensions.org/

Damit funktioniert es mit Gettern und Settern wie im Java-Code.

Eclipse Mars

Morgen kommt ja Eclipse Mars raus. Es soll besonders im JavaScript-Bereich viele Fortschritte gemacht haben. Ich werde es mir auf jeden Fall dann mal ansehen.
Bis jetzt war die Unterstützung bei Eclipse zwar nicht so toll, aber immerhin besser als ein einfacher Text-Editor und hat meistens gereicht. Verbesserungen im PDT-Bereich scheint es so nicht zu gehen.. jedenfalls war untern den ersten 5 Ergebnissen meiner Suche bei Google nicht zu finden :-)

PHP und Annotations

Ich habe lange Zeit mit PHPclipse in einem Eclipse 3.2 mein PHP entwickelt und bin dann mit Eclipse Luna doch irgendwie mal auf die Idee gekommen jetzt PDT verwenden zu können. PHPclipse nutzte eine Code-Vervollständigung, die einfach alle Methoden aller Klassen kannte und dann diese auch präsentierte und man mußte eben darauf achten dass man die Methode der richtigen Klasse hatte.
PDT bekam es nur selten hin einen Methoden anzu bieten. Nun habe ich heraus gefunden, dass PDT auch ganz anders arbeitet und extrem gut mit Annotations zusammenarbeit.
Wenn man mit den Annotations arbeitet ist das Entwickeln an sich genau so gut wie bei Java.

/**
* @param number $index
* @return XWBlogMedia
*/
public function getMedia($index){
return $this->list->get($index);
}

User	annonyme	Date	2016-11-20 20:03
Tags	eclipse, getter, hannes pries, pdt, pdt extensions, php, setter, tipp

User	annonyme	Date	2016-02-08 20:13
Tags	cli, eclipse, hannes pries, ide, pdt, php, video

User	annonyme	Date	2015-11-04 20:49
Tags	ant, apache ant, bauen, build, eclipse, hannes pries, jdbc, pdt, project

User	annonyme	Date	2015-07-07 20:42
Tags	eclipse, hannes pries, pdt, php

Hannes Pries - Web/Shopware/JavaScript-Developer BlogWeil es immer eine simple Lösung gibt!

Hannes Pries - Web/Shopware/JavaScript-Developer Blog
Weil es immer eine simple Lösung gibt!