Einfach die folgenden drei Linux Befehle in die Konsole kopieren, Firefox und Thunderbird neustarten, fertig.

sudo apt-add-repository ppa:ubuntu-mozilla-security/ppa
sudo apt-get update
sudo apt-get dist-upgrade

Update: Das Hinzufügen des Repositories aktualisiert Firefox und Thunderbird stets auf die aktuellsten Versionen (Aktuell: Firefox 10, Thunderbird 10). Durch den Updatechannel werden stets die neusten Versionen über die Aktualisierungsverwaltung zeitnah nach der Veröffentlichung durch Mozilla aktualisiert.

Zunächst einmal habe ich mir ein eigenen Ordner für die personalisierten Starter in meinem Home Verzeichnis angelegt.

/home/simon/starter

Anschließend wird die Firefox Desktop Konfigurationsdatei (dies klappt natürlich auch mit jeder anderen Desktop Konfigurationsdatei) aus dem Applications Ordner in meinen “starter” Ordner kopiert.

/usr/share/applications

Einmal in den Terminal gewechselt werden neue Rechte vergeben und der Eigentümer gewechselt:

sudo chown simon:simon firefox.desktop

sudo chmod 744 firefox.desktop

Zum Schluss noch die Starterkonfiguration mit einem Link zu der Anwendung füllen, einen neuen Namen und eine Beschreibung geben, fertig.
Der folgende Screenshot zeigt beispielsweise mein Starter zu der Eclipse IDE.

Eine Kopie dieses Starters kann nun beliebig auf den Desktop oder aber auch in das Startmenü gezogen werden.

Hierzu ein konkretes Beispiel:
In diesem einfachen Beispiel wird ein Calendar Objekt mit dem Datum in genau sieben Tagen erstellt (calendar.add(..)). In der ersten Darstellung ist nicht ansatzweise zu erahnen, was genau in der add Methode passiert. Hier wäre das mindeste wohl gewesen, wenn der Entwickler einen aussagekräftigen Kommentar hinterlegt hätte. Bad Smell!

Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.add(6, 7);

Schlimmer noch wäre es, wenn der Zahlenwert 7 zu einem späteren Zeitpunkt im Code nochmals verwendet wird und diese beiden Werte abhängig voneinander sind. In diesem Fall müssten sogar beide Werte nachträglich gepflegt werden, wenn plötzlich das Datum statt in 7, in 14 Tagen erstellt werden soll. Schaut man sich den Code Monate oder gar Jahre später erst wieder an, fällt dieser Zusammenhang höchstwahrscheinlich gar nicht erst auf und es kommt bei einer Veränderung zu unerwünschten Nebeneffekten der Anwendung. Das unnötige Verstreichen einiger Zeit durch debuggen ist hier vorprogrammiert.

Betrachten wir uns die nachfolgende Umsetzung. In diesem Beispiel fällt direkt auf, welcher tiefere Sinn hinter der add Methode steckt. Verdeutlicht wird dies über zwei Konstanten. Die selbst angelegte DAYS_IN_FUTURE sowie die in der Calendar Klasse befindliche Calendar.DAY_OF_YEAR Konstante.

final int DAYS_IN_FUTURE = 7;
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
calendar.add(Calendar.DAY_OF_YEAR, DAYS_IN_FUTURE);

Durch die Verwendung der Konstante wird der Lesefluss prompt erleichtert. Ohne den Code zu analysieren wird direkt klar, was an dieser Stelle passiert.

Ein Blick hinter die Kulissen: In der Konstante DAY_OF_YEAR steckt der nicht veränderbare Wert 6. Im Ergebnis werden demnach die selben Werte wie in dem ersten Beispiel gesetzt, bloß in Konstanten gekapselt.

public final static int DAY_OF_YEAR = 6;

An diesem recht einfachen Beispiel ist bereits zu erkennen, wie wichtig die Vermeidung von Magic Numbers innerhalb der Softwareentwicklung ist.

Inzwischen kann ich behaupten, das ich bereits einige Codezeilen in meinem Leben gesehen habe. Viele waren schön anzusehen, einige aber auch nicht. Leider sind auch heute immer wieder Codezeilen aufzufinden, die weniger schön umgesetzt sind. Codezeilen, die oft mit minimalen Aufwand zu einer besseren Übersicht sowie verständlicherem Code führen könnten. Nicht selten werden auch durch das Refactoring der Bad Smells Fehler eingegrenzt oder gar ausgemerzt. Da es sich hierbei um immer wiederkehrende und auch oft die selben Zeilen handelt, möchte ich auf itblogging.de eine Zusammenfassung der in dem Buch Refactoring beschriebenen sowie weiteren bekannten Bad Smells anhand einiger Beispiele veröffentlichen.
Die nachfolgende Liste werde ich sukzessive erweitern, sollte ich neue Bad Smells in diesem Blog veröffentlichen. Fragen, Anregungen oder Kritik sind natürlich ausdrücklich erwünscht und idealerweise in dem jeweiligen Artikel zu hinterlassen.

• Duplizierter Code
• Magic Numbers

In dem Tutorial Java MySQL (JDBC) Tutorial wurde bereits gezeigt, wie eine Datenbankverbindung zu einem MySQL Server über den “normalen” Weg hergestellt werden kann. In diesem Tutorial wird ebenfalls eine Datenbankverbindung zu einem MySQL Server hergestellt und mit der selben Ausgabe wie in dem zuvor genannten Tutorial ausgegeben, um den Aufwand der Verwendung des Spring JDBC-API einschätzen und gegenüber stellen zu können.

Vorweg möchte ich auf die in der Spring Dokumentation enthaltene who does what? Tabelle hinweisen, die einen guten Einblick über die Zuständigkeiten der JDBC-API des Spring Frameworks zeigt.

Spring JDBC-API – was benötigt wird

Um mit der JDBC-API arbeiten zu können, müssen folgende JAR Dateien dem Classpath hinzugefügt werden.

• org.springframework.beans-3.1.0.M2.jar
• org.springframework.core-3.1.0.M2.jar
• org.springframework.jdbc-3.1.0.M2.jar
• org.springframework.jdbc-sources-3.1.0.M2.jar
• org.springframework.transaction-3.1.0.M2.jar
• mysql-connector-java-5.1.14/mysql-connector-java-5.1.14-bin.jar
• commons-dbcp-1.4/commons-dbcp-1.4.jar
• org.springframework.context.support-3.1.0.M2.jar
• org.springframework.context-3.1.0.M2.jar
• commons-logging-1.1.1.jar
• org.springframework.asm-3.1.0.M2.jar
• org.springframework.expression-3.1.0.M2.jar
• commons-pool-1.5.6.jar

Neues Java Projekt erstellen

Ein neues Java Projekt wird unter folgendem Namen angelegt:

• SpringMySql

Packages hinzufügen

Folgende Packages müssen erstellt werden:

• de.itblogging.spring.mysql
• de.itblogging.spring.config

config Datei anlegen

Folgende Datei wird in dem Package de.itblogging.spring.config angelegt:

• config.xml

Ein neues Bean mit der ID mysqlDataSource wird in dieser Konfigurationsdatei registriert. Die Treiberklasse, die URL des MySQL Servers sowie die Benutzerdaten werden gepflegt.
Hinweis: Die hier in dem Bean hardcodierten Werte können natürlich auch in einer Properties Datei ausgelagert werden. Eine weitere Option wäre die Erstellung der DataSource direkt im JavaCode. Ein Beispiel ist in der JdbcTest.java Klasse auskommentiert wiederzufinden.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="mysqlDataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://192.168.0.110:3306/sakila" />
		<property name="username" value="simon" />
		<property name="password" value="toor" />
	</bean>

</beans>

Java Datei anlegen

In dem Package de.itblogging.spring.mysql wird eine Testklasse angelegt:

• JdbcTest.java

Die Klasse setzt über das JdbcTemplate ein SQL ab und schreibt das Ergebnis in die Konsole.

package de.itblogging.spring.mysql;

import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public class JdbcTest
{

	/**
	 * Liefert die in der config.xml Konfigurierte DataSource
	 *
	 * @return MySQL DataSource
	 */
	private DataSource getDataSource()
	{
		// Pfad zu der Konfigurationsdate
		final String CONFIGPATH = "/de/itblogging/spring/config/config.xml";
		ApplicationContext ac = new ClassPathXmlApplicationContext(CONFIGPATH);
		// Bean mit der ID 'mysqlDataSource' (MySQL Konfiguration) laden
		DataSource dataSource = (DataSource) ac.getBean("mysqlDataSource");

		// Beispiel einer hardcodierten DataSource
//		DriverManagerDataSource dataSource2 = new DriverManagerDataSource();
//		dataSource2.setDriverClassName("com.mysql.jdbc.Driver");
//		dataSource2.setUrl("jdbc:mysql://192.168.0.110:3306/sakila");
//		dataSource2.setUsername("simon");
//		dataSource2.setPassword("toor");

		return dataSource;
	}

	/**
	 * Liefert ein mit der vorkonfigurierten DataSource gefülltes JdbcTemplate
	 *
	 * @return JdbcTemplate inkl. DataSource
	 */
	private JdbcTemplate getJdbcTemplate()
	{
		DataSource dataSource = getDataSource();
		return new JdbcTemplate(dataSource);
	}

	/**
	 * Setzt eine normale SQL Query ab und schreibt das Ergebnis in die Konsole
	 */
	private void simpleSqlQuery()
	{
		JdbcTemplate jdbcTemplate = getJdbcTemplate();

		String sql = "SELECT first_name, last_name from actor ORDER BY last_name";
		jdbcTemplate.query(sql,
				new RowMapper<String>()
				{
					@Override
					public String mapRow(final ResultSet result, final int arg1)
							throws SQLException
					{
						String first_name = result.getString("first_name");
						String last_name = result.getString(2);
						String name = last_name + ", " + first_name;

						// Der Name wird in die Konsole geschrieben
						System.out.println(name);

						return null;
					}
				});
	}

	public static void main(String[] args)
	{
		new JdbcTest().simpleSqlQuery();
	}

}

JdbcTest.java ausführen

Das Ergebnis wird wie erwartet in der Konsole ausgegeben.

GUINESS, PENELOPE
WAHLBERG, NICK
CHASE, ED
DAVIS, JENNIFER
LOLLOBRIGIDA, JOHNNY
NICHOLSON, BETTE
...

JDBC Helferklassen

Ist einmal mit Hilfe der DataSource eine JDBC Helferklasse (in diesem Fall JDBCTemplate) erstellt worden, können SQL Befehle über diese Objekt abgesetzt werden. Neben dem JDBCTemplate gibt es viele weitere Helferklassen wie z.B.

• NamedParameterJdbcTemplate
• SimpleJdbcTemplate
• SimpleJdbcInsert
• SimpleJdbcCall

Einige Anwendungsbeispiele mit Hilfe dieser Helferklassen werde ich in den nächsten Artikeln aufzeigen.

Spring Vorbereitungen

Für die Umsetzung des Hello World Tutorials wird zunächst eine Entwicklungsumgebung benötigt. Wer bereits einige Artikel auf itblogging.de gelesen hat, weiß, das ich die Eclipse Umgebung bevorzuge. Für die Softwareentwicklung mit Spring bietet SpringSource sogar eine angepasste Spring IDE, die SpringSource Tool Suite (Spring STS). Die Spring STS basiert auf Eclipse, beinhaltet jedoch einige spezielle Anpassungen für die Entwicklung mit Spring die die Entwicklung erleichtern. Die Spring STS wird jedoch nicht zwingend für das Arbeiten mit Spring benötigt. Optional kann auch die Eclipse IDE ohne weiteres mit den im Eclipse Marketplace befindlichen Tools / Bibliotheken erweitert werden.

Download SpringSource Tool Suite

Wer sich die SpringSource Tool Suite mal anschauen möchte, für den steht auf SpringSource stets die aktuellste Version bereit.
Download SpringSource Tool Suite

Download SpringSource Tool Suite über Eclipse Marketplace

Wie zuvor bereits kurz angesprochen, ist der Download der SpringSource Tool Suite und die damit verbundene Integration in die Eclipse IDE eine weitere Möglichkeit mit den Spring Tools zu arbeiten. Die Suche im Eclipse Marketplace nach “spring” listet die Möglichkeiten der Installation auf. Für Eclipse 3.7 muss entsprechend SpringSource Tool Suite for Eclipse Indigo (3.7) heruntergeladen und installiert werden.

Bedingt der langen Downloadzeit über den Eclipse Marketplace würde ich den Download der SpringSource Tool Suite über die direkte SpringSource Website bevorzugen.

Download Spring Framework

Im nächsten Schritt muss das Spring Framework noch über die SpringSource Website heruntergeladen werden. In dem heruntergeladenen ZIP File befinden sich alle notwendigen JAR Dateien für die Entwicklung mit Spring. Die darin enthaltenen Libraries müssen anschließend dem Build Path hinzugefügt werden müssen.
http://www.springsource.org/download

Hello World – Spring MVC

Noch ein kleiner Hinweis: Für die Spring Entwicklung aber der Version 3.0 wird mindestens Java in der Version 1.5 benötigt. Die aktuellste Version ist sowohl unter Linux als auch in der Windows Kommandozeile

java -version

abzurufen.
Die aktuellste Java Version gibt es auf der Oracle Java Downloadseite.

Download Tomcat

In diesem Beispiel wird die Umsetzung des Spring MVC mit dem Apache Tomcat 7 durchgeführt.

Servlets und Java Server Pages

Wie ein Tomcat Server eingerichtet wird und grundsätzliche eine Webanwendung mit Servlets und JSP’s aufgebaut ist, erfahrt ihr in dem Tutorial Servlets und Java Server Pages.

Der Vollständigkeitshalber möchte ich beide Varianten zur Erstellung des Spring MVC Einstiegs veranschaulichen. Über die normale Eclipse Umgebung (ohne Spring Plugin) sowie die vereinfachte Variante mit Hilfe eines Spring Template Projects mit Spring STS.

Spring MVC über Eclipse EE

Im ersten Schritt wird ein Dynamic Web Project angelegt. Wie dies im einzelnen geschieht, zeigt das Servlets und Java Server Pages Tutorial. Das Projekt trägt den Namen HelloWorldSpring.
Angelegt, sollte in Eclipse das Web Projekt nun wie folgt aussehen (Navigator View):

Notwendige Bibliotheken

Im nächsten Schritt müssen folgende JAR Dateien in das lib Verzeichnis (WebContent => WEB-INF => lib) kopiert werden.

All diese Dateien habe ich zu einer ZIP Datei zusammengefasst und stelle sie hier zum Download bereit.

web.xml

Falls noch nicht vorhanden, muss die web.xml in dem Ordner WebContent => WEB-INF erstellt und wie folgt angepasst werden. Bitte die Hinweise den Kommentaren entnehmen.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	id="WebApp_ID" version="3.0">

	<display-name>HelloWorldSpring</display-name>
	<welcome-file-list>
		<!-- Die Willkommensseite (muss direkt in dem Ordner 'WebContent' liegen) -->
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>

	<servlet>
		<!-- Registrierung des Spring DispatcherServlet -->
		<servlet-name>helloworld</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- Die Registrierung bereits während des Startvorgangs laden -->
		<load-on-startup>1</load-on-startup>
	</servlet>

	<servlet-mapping>
		<servlet-name>helloworld</servlet-name>
		<!-- Alle Anfragen ( / ) über das helloworld Servlet bearbeiten -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

</web-app>

helloworld-servlet.xml

In der web.xml haben wir dem Servlet den Namen “helloworld” gegeben. Das DispatcherServlet sucht in dem WEB-INF Ordner -falls der Pfad nicht extra angegeben wird- immer nach einer Datei mit dem Namen [servletname]-servlet.xml. In dieser Datei werden weitere Einstellungen für Spring vorgenommen. Zunächst muss also die Datei helloworld-servlet.xml in dem WEB-INF Ordner angelegt und mit folgendem Code gefüllt werden.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

	<!-- Spring sucht in dem angegebenen Package nach Controllern -->
	<context:component-scan base-package="de.itblogging.spring.helloworld" />

	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="viewClass"
			value="org.springframework.web.servlet.view.JstlView" />
		<!-- Die Views müssen alle in dem 'views' Ordner liegen ... -->
		<property name="prefix" value="/WEB-INF/views/" />
		<!-- ... und mit .jsp enden -->
		<property name="suffix" value=".jsp" />
	</bean>

</beans>

HelloWorldController.java

In dem component-scan tag in der helloworld-servlet.xml Datei wurde ein Pfad angegeben. Dies ist der Pfad, an dem Spring automatisch nach Controller Klassen sucht, in diesem Fall de.itblogging.spring.helloworld.

package de.itblogging.spring.helloworld;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class HelloWorldController
{

	@RequestMapping("/helloWorld")
	public ModelAndView helloWorld()
	{
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.setViewName("helloWorld");
		String message = "Geschafft! Ich bin dein erstes Spring MVC Erfolgserlebnis! : - ) ";
		modelAndView.addObject("message", message);
		return modelAndView;
	}

}

index.jsp

Ebenfalls wird in der web.xml als Startseite auf eine index.jsp verwiesen. Diese muss in dem Ordner WebContent liegen. Die index.jsp könnte wie folgt aussehen:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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=UTF-8">
<title>itblogging.de - Spring Tutorial</title>
</head>
<body>
<h2>Spring MVC - Hello World Tutorial</h2>
Jetzt geht es los. Wir rufen den <a href="helloWorld">HelloWorldController</a> auf.
</body>
</html>

helloWorld.jsp

Zu guter Letzt wird noch die View benötigt, die die Mitteilung des Spring Controllers ausgibt. Hierzu wird eine Datei helloWorld.jsp in dem Ordner WEB-INF => views angelegt.

Mit ${message} wird der zuvor in das Model geschriebene Parameter ausgelesen und in der View eingesetzt.

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!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=UTF-8">
<title>itblogging.de - Spring Tutorial</title>
</head>
<body>

<h2>Ich wurde von einem Controller aufgerufen</h2>

Der Controller hat mir folgende Nachricht mitgeteilt:
${message}

</body>
</html>

Tomcat starten

Zu guter Letzt muss lediglich der Tomcat Server gestartet werden.

Ist der Tomcat Server einmal gestartet, kann unter http://localhost:8080/HelloWorldSpring/ die Webanwendung aufgerufen werden. Der Inhalt der index.jsp begrüßt uns und das Tutorial ist somit erfolgreich abgeschlossen worden.

Spring MVC über Spring STS

Nachdem die Spring MVC Einführung in der Eclipse IDE (dies würde so natürlich auch in der Spring STS klappen) durchgeführt wurde, möchte ich an dieser Stelle noch den einfachen schnellen Weg über die Spring STS vorstellen.
Die Spring STS liefert für den schnellen Einstieg in das Spring Framework einige Template Projekte mit. So auch für Spring MVC.

Spring Template Project anlegen

In dem Spring STS Menü wird unter New => Other => SpringSource Tool Suite => Spring Template Project ein neues Template Projekt angelegt.

Anschließend muss das Spring MVC Project ausgewählt werden.

Bei der ersten Verwendung des Spring MVC Projects fragt die Spring STS, ob sie die notwendigen Dateien herunterladen darf. Um fortzufahren, muss dies mit YES bestätigt werden.
Im nächsten Schritt wird der Name sowie die Projekthierarchie angegeben. Die Namensgebung wird analog zu der ersten Variante des Spring MVC vergeben.

Mit Finish wird von der Spring STS ein neues Projekt angelegt. Das Hinzufügen von JAR Dateien oder das Anlegen des Controllers, der Views oder die Servlet Einstellungen wurde bereits von der Spring STS übernommen.

Tomcat starten

Nachdem die Anwendung über den Tomcat Server gestartet wurde, kann ebenfalls unter http://localhost:8080/HelloWorldSpring/ die Webanwendung abgerufen werden. Ein kleiner Text mit der aktuellen Uhrzeit wird ausgegeben.

Weitere Informationen

Da Spring MVC weitaus komplizierter werden kann als es in diesem Hello World Tutorial gezeigt wurde, möchte ich für viele weitere Informationen die offizielle Spring Dokumentation empfehlen:
Web MVC framework

Aufbau der Crontab Tabelle

Die Crontab Tabelle besteht insgesamt aus sechs Spalten, wobei die ersten fünf Spaltenangaben zur zeitlichen Ausführung des in der sechsten Spalte enthaltenen Befehls verantwortlich sind. Jede Spalte wird durch ein Leerzeichen oder ein Tab getrennt.

*   *   *   *   *  auszuführender Befehl
|   |   |   |   |
|   |   |   |   |
|   |   |   |    ----- Wochentag (0 - 7)
|   |   |   |     (0 und 7 ist der Sonntag)
|   |   |    ------- Monat (1 - 12)
|   |    --------- Tag (1 - 31)
|    ----------- Stunde (0 - 23)
 ------------- Minute (0 - 59)

Ein Sternchen steht für jede mögliche Variante einer Zeitangabe. Sollte als Beispiel ein Sternchen für die Tageinheit angegeben werden, wird der Befehl an jedem Tag ausgeführt. Analog verhält sich das Sternchen bei den anderen Spalten (jedes Jahr, jeder Monat …).
Für die Monate sowie für die Wochentage können statt der Zahlen, auch die in englisch gebräuchlichen Namen verwendet werden. Hierbei dürfen lediglich die ersten drei Buchstaben des Wortes verwendet werden. So kann beispielsweise anstatt des zweiten Wochentags (Zahl 1) auch mon geschrieben werden (der Wochentag beginnt bei crontab immer Sonntags (0)).
Ebenfalls ist es möglich ausgewählte Wochentage anzugeben. Der Wert 1-5 (wichtig: ohne Leerzeichen) würde bedeuten, das der Befehl von Montag bis Freitag ausgeführt wird, nicht jedoch am Wochenende. Der Wert 1,3,5 (wichtig: ohne Leerzeichen) führt den Befehl am Montag, Mittwoch und Freitag aus. Gleiches gilt natürlich auch für die anderen Werte (Monate, Jahre, ..).
Statt der Zahlen oder aber auch die Verwendung der ersten drei Buchstaben des Wochentages, können für die ersten fünf Felder auch bestimmte Schlüsselwörter angegeben werden.

Weitere Crontab Beispiele

Hier nun ein paar konkrete Beispiele einiger Zeitangaben eines Crontabs.

Wenn Ihr der Meinung seid, das ich wichtige Beispiele vergessen habe, dann bitte ich euch dies in einen Kommentar zu hinterlassen. Ich werde die Tabelle anschließend komplettieren.

Wichtiger Hinweis

Am Ende der Crontab Tabelle muss eine Leerzeile eingefügt werden!

Crontab einrichten

Um einen benutzerdefinierten crontab einzurichten, muss folgender Unix Befehl in einen Terminal eingegeben werden:

crontab -e

Der Parameter -e veranlasst das Erstellen eines neuen Crontabs. Wird dieser Befehl zum ersten Mal aufgerufen, fragt in der Regel der Terminal nach einen gewünschten Editor. Unter Ubuntu stehen hier ed, nano und vim standardmäßig zur Verfügung.
Anschließend öffnet sich eine Datei, in der nochmals ein paar einführende Worte zu cron verloren werden. Die am Zeilenanfang befindlichen Hashes (#) signalisieren, das es sich bei den jeweiligen Zeilen um Kommentarzeilen handelt. Wer diese Informationen nicht weiter benötigt, kann das Datenblatt selbstverständlich leeren.

Benutzerdefinierter Crontab

Der Besitzer des neu erstellten Crontabs ist immer der eingeloggten User. Möchte man beispielsweise für einen andere User einen Crontab anlegen, geschieht dies über einen zusätzlichen siebten Parameter. Der Username wird in diesem Fall nach der Zeitangabe und vor dem auszuführenden Befehl angegeben (im folgenden mit <username> gekennzeichnet).

* * * * * <username> Befehl

Testdatei anlegen

Zur Demonstration des Crontabs wird eine Datei mit dem Namen time.sh angelegt. Es wird der einzeilige Unix Befehl

date

als Inhalt gespeichert. date gibt das aktuelle Datum inklusive Zeit aus. Diese Datei soll nun minütlich ausgeführt und das Ergebnis in eine Textdatei ergebnis.txt gespeichert werden. Ein neuer Crontab wird wie folgt angelegt:

*/1 * * * * /pfad/zur/time.sh >> pfad/zur/ergebnis.txt

Nach dem Speichern des Crontabs, wird die Zeit in Minutentakt in die Datei ergebnis.txt geschrieben.

Hinweis: Es kann gut möglich sein, dass das Recht der Datei time.sh noch geändert werden muss (chmod 755 time.sh).

Alternativ würde in diesem einfachen Fall auch folgender Befehl für das selbe Resultat sorgen:

*/1 * * * * date >> pfad/zur/ergebnis.txt

Crontab Liste anzeigen

Der Parameter -l listet die Crontabelle mit allen Crontabs auf.

crontab -l

Benutzerdefinierte Crontabs können über den Parameter -u <username> angezeigt werden:

crontab -u <username> -l

E-Mail Benachrichtigung

Als Standard wird die Ausgabe eines Skriptes an die im System lokal hinterlegte E-Mail Adresse gesendet. Wenn dies nicht erwünscht ist, oder aber das Ergebnis an eine andere beliebige Adresse versendet werden soll, gibt es auch hierfür eine passende Lösung.

E-Mail Benachrichtigung deaktivieren

*/1 * * * * pfad/zu/meinem/skript.sh > /dev/null 2> &1

E-Mail Benachrichtigung an eine beliebige Adresse

Über die Angabe MAILTO kann das Ergebnis des Skriptes an eine beliebige Adresse versendet werden.

MAILTO="meine-adresse@anbieter.de
*/1 * * * * pfad/zu/meinem/skript.sh

Crontab löschen

Der -r Paramter löscht alle Crontabs.

crontab -r

Sollen lediglich benutzerspezifische Crontabs gelöscht werden, passiert dies -u <username> mit:

crontab -r -u <username>

Eines Vorweg: Gibt es einen weiteren Benutzer mit root Rechten in dem System, kann mit diesem das vergessene root Passwort mit Hilfe des Unix Befehls passwd root geändert werden.
Für das Zurücksetzen des vergessenen Benutzerpasswortes gibt es verschiedene Ansätze. Zum einen ist es möglich, das Passwort über den Wiederherstellungsmodus zurück zu setzen oder aber auch über den Boot-Loader an entsprechender Stelle zu ändern. Den nun mir gezeigten Lösungsansatz halte ich jedoch für den einfachsten und überschaubarsten.
Ausgangspunkt ist ein ausgeschalteter Computer mit einem Linux Betriebssystem, bei dem logischerweise das Root Passwort vergessen wurde. Ein Nicht-Root Authentifizierter User ist zwar hilfreich um an die meisten Daten auf dem Betriebssystem zu gelangen, jedoch ist es mit solch einem Benutzer nicht möglich das vergessene root Passwort zurückzusetzen, da die Bearbeitung / Manipulation bestimmter Dateien wiederum root Rechte benötigt.

Der einfachste Weg das vergessene root Passwort zurückzusetzen, ist die Verwendung einer Live-CD. Eine Live-CD ist eine CD, mit dessen Hilfe on-the-fly ein beliebiges (in diesem Fall Linux) Betriebssystem gestartet werden kann (Heutzutage sind die meisten Linux Betriebssystem CD’s Live-CD’s). Hierzu ist es lediglich notwendig, dem PC während des Start Vorganges mitzuteilen, das dieser von der eingelegte CD booten soll. Oft ist das Starten von CD als Standard in dem BIOS eingestellt, andernfalls ist eine Anpassung in den jeweiligen Einstellungen notwendig.

Live-CD

Wer beispielsweise bereits eine Ubuntu CD (oder ein anderes Linux Derivat wie z.B. Knoppix, Damn Small Linux, Kubuntu, …) in der Nähe liegen hat, darf gerne auf diese zurückgreifen. Alternativ kann die aktuellste Ubuntu Version auf der offiziellen Ubuntu Homepage heruntergeladen werden.

Download Ubuntu

http://www.ubuntu.com/download/ubuntu/download
Das Image muss lediglich auf ein Rohling gepresst werden um das Betriebssystem anschließend von der CD starten zu können.

Terminal

Nach erfolgreichem booten der Live-CD ist es zunächst einmal notwendig -wenn nicht bereits in einem Terminal gestartet-, einen Terminal zu öffnen. Im nächsten Schritt muss die Partition um die es sich handelt, in das Live-System eingebunden werden. Damit auch die richtige Partition aus der Partitionstabelle ausgelesen und später in das Live-System eingebunden wird, ist es zunächst notwendig mit folgendem Befehl die Partitionstabelle auszulesen.

sudo fdisk -l

Bei der Ausführung von fdisk unbedingt darauf achten, diesen Befehl mit sudo (oder anderen root Rechten) abzusetzen, da sonst eine leere Ergebnismenge zurückgeliefert wird.

Eine mögliche Partitionstabelle könnte wie folgt aussehen:

Platte /dev/sda: 500.1 GByte, 500107862016 Byte
255 Köpfe, 63 Sektoren/Spur, 60801 Zylinder
Einheiten = Zylinder von 16065 × 512 = 8225280 Bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0xfbc39217

   Gerät  boot.     Anfang        Ende     Blöcke   Id  System
/dev/sda1   *           1       13055   104864256    7  HPFS/NTFS
/dev/sda2           13056       19321    50330624   83  Linux
/dev/sda3           19322       19582     2096482+  82  Linux Swap / Solaris
/dev/sda4           19583       60801   331091587    5  Erweiterte
/dev/sda5           19583       45690   209712478+   7  HPFS/NTFS
/dev/sda6           45691       60801   121379076    7  HPFS/NTFS

Partition mounten

Im nächsten Schritt muss die Linux Partition (in diesem Beispiel /dev/sda2) in das Live System eingebunden werden. Dies passiert über den den Unix Befehl mount.
Hinweis: SATA Festplatten werden mit sda gekennzeichnet, IDE Festplatten in der Regel mit hda.

mount /dev/sda2 /mnt/

Das Benutzerbetriebssystem befindet sich nun in der Ordnerhierarchie des Live Systems. Alle unter /dev/mnt/ angesprochenen Ordner betreffen das Betriebssystem, bei welchem das root Passwort abhanden gekommen ist.

Möglichkeit 1: chroot

Mit dem Unix Befehl passwd das vergessene Passwort als neuer root (chroot) neu vergeben:

chroot /mnt
passwd
<Passwort ändern>

Möglichkeit 2: /etc/shadow

Die /etc/shadow Textdatei beinhaltet hoch sensible Daten über die im System registrierten Benutzer, weshalb diese Datei nur mit root Rechten bearbeitet werden kann.
Die /etc/shadow Datei ist eine zeilenweise mit Doppelpunkten getrennte Textdatei, die wie folgt aufgebaut:

Aufbau der /etc/shadow

<login name>:<encrypted password>:<date of last password change>:<minimum password age>:<maximum password age>:<password warning period>:<password inactivity period>:<account expiration date>:<reserved field>

/etc/shadow bearbeiten

Zum bearbeiten der /etc/shadow benutzen wir den Standard Texteditor vi.

sudo vi /etc/shadow

Zum Löschen des root Passworts wird folgende Zeile wie folgt geändert.

Vorher (mit Beispiel Passwort):

root:$6$bHsXq2UD$5ox1BKQ9y/Fa2aVDAMuic2tRiZrNNm2ibg1.m7SQtJ7eJVUhPIkS3T6GET/13yE8M7rO9nsHaFj2lFI5rgA0a0:15197:0:99999:7:::

Nachher:

root::15197:0:99999:7:::

Das Kennwort des root Benutzers wird schlicht und einfach aus der Datei gelöscht.

Reboot

Nachdem die shadow-Datei erfolgreich manipuliert wurde, kann das Betriebssystem nun ganz normal gestartet werden. Der root Benutzer beantwortet zum Anmelden die Passwortabfrage mit einem einfachen Enter (leeres Passwort).

Hinweis: Der root Benutzer muss immer mit einem Passwort abgesichert sein, damit potentiellen Angreifer nicht ohne Weiteres den PC mit root Rechten bedienen können. Daher bitte unmittelbar nach dem Login das Passwort des Root Benutzers ändern. In der Konsole geht dies am einfachsten mit dem Unix Befehl passwd.

Wer also noch nicht bei Google+ angemeldet ist und sich bereits seit längerer Zeit nach einer Anmeldung umschaut, hat nun über folgenden Link die Möglichkeit die lange Warteperiode zu beenden.

https://plus.google.com/_/notifications/ngemlink?path=%2F%3Fgpinv%3DXYN-9i-3WDM%3ARKPER97dHAo

Viel Spaß in der neuen sozialen Welt wünscht,
itblogging.de

Update: In den letzten drei Monaten benötigten User, die dem neuen sozialen Netzwerk Google+ beitreten wollten, eine Einladung. Ab heute öffnet Google die Pforten für jedermann. Eine Einladung ist somit nicht mehr nötig.
Seit dem Start von Google+ sind circa 100 Änderungen vorgenommen worden, ein Ende ist jedoch noch lange nicht in Sicht.