Luventas Web Design Blog

Informationen aus mehreren Reihen trotz “GROUP BY”

luventas — Mon, 07 Nov 2011 21:40:13 +0000

Folgendes Szenario:

Ich habe eine Datenbanktabelle, in der zu einem Benutzer in mehreren Reihen eine Information steht.

user_id, date, information_about_user_on_date
1, 2011-11-01, information_1
1, 2011-11-02, information_2
1, 2011-11-03, information_3

Diese Informationen möchte ich in einer Reihe anzeigen, ohne mir alle Zeilen einzeln holen zu müssen. In SQL gibt es zwar die schöne Funktion “GROUP BY”, hier würde ich aber nur noch eine der Informationen erhalten.

Source code

SELECT * FROM user_information GROUP BY user_id;

Source code

Ergebnis: 1, 2011-11-01, information_1

Hier würde ich also 3 Informationen verlieren. Aber MySQL hat die sehr nützliche Funktion “GROUP_CONCAT” erschaffen, die hier Abhilfe schaffen kann.

Source code

SELECT
  user_id,
  date,
  GROUP_CONCAT(information_about_user_on_date SEPARATOR '|') AS info
FROM user_information;

Das Ergebnis dieser Abfrage sieht nun wie folgt aus:

Source code

user_id, date, info
1, 2011-11-01, information_1|information_2|information_3

Nun habe ich alle Informationen, welche ich haben wollte in einer Zeile. Möchte ich zusätzlich alle Datumsangaben haben, kann ich hier genauso verfahren.

Information from several rows in spite of “GROUP BY”

luventas — Mon, 07 Nov 2011 21:40:00 +0000

Following scenario:

I have a database table, where information about an user is stored in several rows.

Source code

user_id, date, information_about_user_on_date
1, 2011-11-01, information_1
1, 2011-11-02, information_2
1, 2011-11-03, information_3

This information I want to show in one single line without getting this information row by row. SQL has the nice functionality “GROUP BY” but by using this normally I’m only getting one information.

Source code

SELECT * FROM user_information GROUP BY user_id;

Source code

Ergebnis: 1, 2011-11-01, information_1

This means, I will loose 2 information. But now MySQL has the useful fonction “GROUP_CONCAT” created, which can really help in this case.

Source code

SELECT
  user_id,
  date,
  GROUP_CONCAT(information_about_user_on_date SEPARATOR '|') AS info
FROM user_information;

The result of this query looks like the following example:

Source code

user_id, date, info
1, 2011-11-01, information_1|information_2|information_3

Now I have all needed information in one single line. If I also want to have all dates from that example, I can do the same for that column.

Wie mache ich meine Webseiten schöner?

luventas — Fri, 28 Oct 2011 07:27:54 +0000

Jeder, der schon einemal eine Webseite erstellt hat, kennt folgendes Problem:

Du entwickelts dein Webprojekt lokal auf deiner Maschine. Alles sieht gut aus, genau, wie du es dir vorgestellt hast. Dann lädst du diese Seite auf den Webserver und testest, ob es immer noch so aussieht, wie es soll. Ja, alles ist wunderbar!

Dann ruft dich ein Freund an und fragt: Was hast du denn da gemacht? Sieht ja furchtbar aus! Die Texte sehen ganz furchtbar aus und die Abschnitte sprengen dein Seitendesign!

Wie kann das Sein?! Der Grund ist, dass auf deinem System die Schiftarten, die du verwendet hast, existieren uns somit von Browser geladen werden können. Auf anderen Systemen existieren diese vielleicht nicht. Nur Verdana, Arial und eine handvoll anderer Schriftarten sind Standard auf jedem System und somit verfügbar. Du möchtest aber spezielle Schiftarten verwenden, die besser in dein entwickeltes Design passen.

In der Vergangenheit hat man sich damit ausgeholfen, dass man bestimmte Zeilen, die auf jeden Fall in diesem Text angezeigt werden sollten, dann als Bild eingefügt hat. Dies ist aber ein Supergau für die Suchmaschinenoptimierung.

Jetzt hat Google eine neue API entwickelt. Die Benutzung dieser API ist kostenlos: fonts.googleapis.com. Mit dieser API ist es richtig einfach, so ziemlich jede Schriftart, die man sehen möchte, auch auf einer Webseite zu verwenden. Einzige Vorbedingung ist, dass Google diese Schriftart auch gespeichert hat. Man ist aber auch in der Lage, eigene Schriftarten in das Googlesystem hochzuladen und diese dann zu verwenden.

Zum Benutzen eie Schriftart in deiner Webseite benötigst du nur eine einzige Zeile die gleich dem Einfügen deiner Stylesheet-Datei ist:

Source code

<link href='http://fonts.googleapis.com/css?family=Lobster'
    rel='stylesheet' type='text/css' />

Nun kannst du diese Schriftart benutzen. In meinem Beispiel habe ich die Schriftart “Lobster” verwendet. Wie jede Schriftart, kannst du sie in deinen Style-Angaben als “font-family” verwenden.

Source code

<p style="font-family: Lobster; font-size: 24px;">
  Dies ist ein Text for die Google Font 'Lobster'
</p>

Wenn du das getan hast, kann der Text auf deiner Seite so aussehen:

Meiner Meinung nach ist diese API ein echter Zugewinn für Webentwickler und ich will diese API in der Zukunft zu oft wie möglich bei der Entwicklung von Webanwendungen und/oder Webseiten verwenden.

How to make your Website texts nicer

luventas — Fri, 28 Oct 2011 07:27:24 +0000

Everybody knows that problem:

You develop your Website on your local system. Everything looks nice and good. Then you upload your code on your Webserver, test, if everything looks like it should and you are happy.

Then a friend calls you and you got to here: What have you done? It looks horrible! The Texts are looking bad and the Paragraphs are breaking the page design!

How can that be? The Reason is, that on your System the Fonts, you are using are existing and can be loaded by the browser. On other Systems maybe that fonts are not existing. Only Arial and Verdana and a hend full of other fonts are installed on every system. But you want to use special fonts for your website that are fitting better in your design.

In the past sometimes you have to help yourself to insert this lines of Text as picture, but this was bad for SEO (Search engine optimization).

Now Google has developed a good API and its use is for free: fonts.googleapis.com. With this API it it easy to use nearly every font you want to have. Precondition is only, that google has stored the needed font, but it is also possible to upload your own fonts.

For inserting one Font in your Website you need only one single line like the insert of your stylesheet file:

Source code

<link href='http://fonts.googleapis.com/css?family=Lobster'
    rel='stylesheet' type='text/css' />

Now you are able to use this font, in my example it is the font named “Lobster”, in your stylesheets as font-family.

Source code

<p style="font-family: Lobster; font-size: 24px;">
  Dies ist ein Text for die Google Font 'Lobster'
</p>

And if you use it on your page, it can look like this:

In my opinion, this API is a really good gain for website developers and I will use it as much as often in future, when I’m developing Webapplications and/or websites.

Textdateien mit Spring Batch erzeugen

luventas — Tue, 06 Sep 2011 19:04:23 +0000

Wir wollen eine Datei über Spring batch erzeugen. Hierfür benötigen wir einen Marshaller mir “Reader” und “Writer”.

Der Reader:

Source code

 id="fileReader">
   name="dataSource" ref="dataSource" />
   name="sql" value="SELECT * FROM table" />
   name="rowMapper">
     class="de.package.rowmapper.FileRowMapper" />
  >
>

Der RowMapper, welcher vom Reader verwendet wird:

Source code

package de.package.rowmapper;
 
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jdbc.core.RowMapper;
import de.package.domainObjects.SftpFileObject;
 
public class FileRowMapper implements RowMapper {
 
  public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
    FileLineObject fileLine = new FileLineObject();
    try {
      fileLine.setDbField1(rs.getString("dbField1"));
      fileLine.setDbField2(rs.getString("dbField2"));
      fileLine.setDbField3(rs.getString("dbField3"));
      fileLine.setDbField4(rs.getString("dbField4"));
      fileLine.setDbField5(rs.getString("dbField5"));
    } catch (SQLException e) {
      System.out.println("Can't create data row for export File.");
    }
    return fileLine;
  }
}

Das DomainObject, welches über den RowMapper vom Reader befüllt wird:

Source code

package de.package.domainObjects;
 
public class FileLineObject implements java.io.Serializable {
 
  private static final long serialVersionUID = 1L;
 
  public String dbField1;
  public String dbField2;
  public String dbField3;
  public String dbField4;
  public String dbField5;
 
  public String getDbField1() {
    return dbField1;
  }
 
  public void setDbField1(String dbField1) {
    this.dbField1= dbField1;
  }
 
  public String getDbField2() {
    return dbField2;
  }
 
  public void setDbField2(String dbField2) {
    this.dbField2= dbField2;
  }
 
  public String getDbField3() {
    return dbField3;
  }
 
  public void setDbField3(String dbField3) {
    this.dbField3= dbField3;
  }
 
  public String getDbField4() {
    return dbField4;
  }
 
  public void setDbField4(String dbField4) {
    this.dbField4= dbField4;
  }
 
  public String getDbField5() {
    return dbField5;
  }
 
  public void setDbField5(String dbField5) {
    this.dbField5= dbField5;
  }
}

Der Writer:

Source code

 id="fileWriter" scope="step">
   name="resource" value="file:path/to/file/filename.csv" />
   name="encoding" value="ISO-8859-1" />
   name="headerCallback">
     class="de.package.helper.HeaderCallback" />
  >
   name="lineAggregator">
     class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
       name="delimiter" value=";" />
       name="fieldExtractor">
         class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
           name="names" value="dbField1, dbField2, dbField3, dbField4, dbField5" />
        >
      >
    >
  >
>

Den HeaderCallback benötigen wir nur, wenn wir in der Datei eine Kopfzeile verwenden wollen, welche nicht vom Reader geliefert wird. Wenn wir diese Zeile haben wollen, müssen wir folgende kleine JavaKlasse verwenden, welche die Zeile in die Datei einfügt.
Es gibt außerdem noch die Möglichkeit, einen FooterCallback zu verwenden, um Zeilen an das ende der Datei anzuhängen, wenn der RowMapper seine Arbeit getan hat. Im meinem Beispiel gehe ich aber nicht weiter darauf ein.

Source code

package de.package.helper;
 
import java.io.IOException;
import java.io.Writer;
import org.springframework.batch.item.file.FlatFileHeaderCallback;
 
public class HeaderCallback implements FlatFileHeaderCallback {
 
  @Override
  public void writeHeader(Writer writer) throws IOException {
    writer.write("FieldHeadline1;FieldHeadline2;FieldHeadline3;FieldHeadline4;FieldHeadline5");
  }
}

Diese Beans zusammen können nun über einen BatchJob aufgerufen werden.

Source code

Create text files with spring batch

luventas — Tue, 06 Sep 2011 19:03:46 +0000

To create a file over spring batch, first you need a marshaller with a Reader and a Writer.

The Reader:

Source code

 id="fileReader">
   name="dataSource" ref="dataSource" />
   name="sql" value="SELECT * FROM table" />
   name="rowMapper">
     class="de.package.rowmapper.FileRowMapper" />
  >
>

The RowMapper which is used by the Reader:

Source code

package de.package.rowmapper;
 
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jdbc.core.RowMapper;
import de.package.domainObjects.SftpFileObject;
 
public class FileRowMapper implements RowMapper {
 
  public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
    FileLineObject fileLine = new FileLineObject();
    try {
      fileLine.setDbField1(rs.getString("dbField1"));
      fileLine.setDbField2(rs.getString("dbField2"));
      fileLine.setDbField3(rs.getString("dbField3"));
      fileLine.setDbField4(rs.getString("dbField4"));
      fileLine.setDbField5(rs.getString("dbField5"));
    } catch (SQLException e) {
      System.out.println("Can't create data row for export File.");
    }
    return fileLine;
  }
}

The Domain Object which is used by the Reader:

Source code

package de.package.domainObjects;
 
public class fileLineObject implements java.io.Serializable {
 
  private static final long serialVersionUID = 1L;
 
  public String dbField1;
  public String dbField2;
  public String dbField3;
  public String dbField4;
  public String dbField5;
 
  public String getDbField1() {
    return dbField1;
  }
 
  public void setDbField1(String dbField1) {
    this.dbField1= dbField1;
  }
 
  public String getDbField2() {
    return dbField2;
  }
 
  public void setDbField2(String dbField2) {
    this.dbField2= dbField2;
  }
 
  public String getDbField3() {
    return dbField3;
  }
 
  public void setDbField3(String dbField3) {
    this.dbField3= dbField3;
  }
 
  public String getDbField4() {
    return dbField4;
  }
 
  public void setDbField4(String dbField4) {
    this.dbField4= dbField4;
  }
 
  public String getDbField5() {
    return dbField5;
  }
 
  public void setDbField5(String dbField5) {
    this.dbField5= dbField5;
  }
}

The Writer:

Source code

 id="fileWriter" scope="step">
   name="resource" value="file:path/to/file/filename.csv" />
   name="encoding" value="ISO-8859-1" />
   name="headerCallback">
     class="de.package.helper.HeaderCallback" />
  >
   name="lineAggregator">
     class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
       name="delimiter" value=";" />
       name="fieldExtractor">
         class="org.springframework.batch.item.file.transform.DelimitedLineAggregator">
           name="names" value="dbField1, dbField2, dbField3, dbField4, dbField5" />
        >
      >
    >
  >
>

The HeaderCallback we only need, if we want to create a headline in the file, which is not coming from the reader. If we want to use the headline, we have to use the following small java class, which fills the line and write it to the file.
There is also the possibility to use a FooterCallback to write line(s) at the end of the file after the RowMapper has done his work, but in my example I do not used it.

Source code

package de.package.helper;
 
import java.io.IOException;
import java.io.Writer;
import org.springframework.batch.item.file.FlatFileHeaderCallback;
 
public class HeaderCallback implements FlatFileHeaderCallback {
 
  @Override
  public void writeHeader(Writer writer) throws IOException {
    writer.write("FieldHeadline1;FieldHeadline2;FieldHeadline3;FieldHeadline4;FieldHeadline5");
  }
}

These beans together can be now called by a BatchJob.

Source code

Daten sicher versenden mit SFTP und Spring Batch

luventas — Mon, 05 Sep 2011 20:17:53 +0000

Datenversand mit spring batch in auf viele Weisen möglich. Der bekannteste Weg ist der Versand von XML-Dateien aber das Springframework bietet auch eine Menge anderer Möglichkeiten an. Einer Dieser Wege ist der sichere Datenversand über SFTP. Für diesen Fall müssen wir das Spring integration Framework verwenden.

Als erstes benötigen wir eine SftpSessionFactory für den Versand der Dateien an den SFTP-Server. Diese Factory beinhaltet die Zugangsdaten zum Server.

Source code

 id="sftpSessionFactory" class="org.springframework.integration.sftp.session.DefaultSftpSessionFactory">
   name="host" value="host.of.receiver"/>
   name="user" value="username"/>
   name="password" value="secureSftpPassword"/>
   name="port" value="22"/>
>

Dann brauchen wir einen Channel, über den die Daten gesendet werden können.

Source code

 id="outputChannel" />

Als nächstes müssen wir den Channel mit der SftpSessionFactory verlinken. Hierfür verwenden wir einen sogenannten outbound-channel-adapter, welcher den Channel und die SftpSessionFactory beinhaltet und dem Framework mitteilt, mit welchem Namen die Datei auf dem zielserver gespeichert werden soll (remote-filename-generator).

Source code

 id="sftpOutboundAdapter"
  session-factory="sftpSessionFactory"
  channel="outputChannel"
  charset="UTF-8"
  remote-directory="/target"
  remote-filename-generator="fileNameGenerator" />

Um es uns einfach zu machen, sagen wir einfach einmal, die Datei soll unter dem selben Namen wie auf dem sendenden Server gespeichert werden, denn dann können wir den DefaultFileNameGenerator vom Spring integration Framework verwenden.

Source code

 id="fileNameGenerator" class="org.springframework.integration.file.DefaultFileNameGenerator" />

Jetzt möchten wir die Datei aber wirklich senden. Hierfür benötigen wir ein Tasklet für die Bussiness Logik und zu guter Letzt einen BatchJob.
Für das Tasklet verwenden wir folgende Java Klasse und Bean, der wir den Dateinamen als Parameter mitgeben:

The Tasklet:

Source code

 id="sftpJobTasklet" class="de.package.tasklets.SftpTasklet">
   name="fileName" value=" path/to/file/filename.csv" />
   name="sftpChannel" ref="outputChannel" />
>

The Javacode:

Source code

package de.package.tasklets;
 
import java.io.File;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.integration.Message;
import org.springframework.integration.MessageChannel;
import org.springframework.integration.support.MessageBuilder;
 
public class SftpTasklet implements Tasklet {
 
  private String fileName;
  private MessageChannel sftpChannel;
 
  @Override
  public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
 
    File file = new File(fileName);
    if (file.exists()) {
      Message message = MessageBuilder.withPayload(file).build();
      try {
        sftpChannel.send(message);
      } catch (Exception e) {
        System.out.println("Could not send file per SFTP: " + e);
      }
    } else {
      System.out.println("File does not exist.");
    }
    return RepeatStatus.FINISHED;
  }
 
  public String getFileName() {
    return fileName;
  }
 
  public void setFileName(String fileName) {
    this.fileName = fileName;
  }
 
  public MessageChannel getSftpChannel() {
    return this.sftpChannel;
  }
 
  public void setSftpChannel(MessageChannel sftpChannel) {
    this.sftpChannel = sftpChannel;
  }
}

Und nun, zu guter Letzt, der XML-Code für den BatchJob:

Source code

 id="sftpJob" restartable="false">
   id="sftpFileGenerateStep" next="sftpFileSendStep">
    >
       reader="sftpFileCreator" writer="sftpFileWriter" commit-interval="100" />
      >
         ref="fileNameListener" />
      >
    >
  >
   id="sftpFileSendStep">
     ref="sftpJobTasklet" />
  >
>

dieser BatchJob kann nun durch einen CronJob auf dem Server gestartet werden.

Zum Abschluß noch der Header der XML-Datei (applicationContext.xml), welche die beschriebenen Beans beinhaltet:

Source code

 version="1.0" encoding="UTF-8"?>
   xmlns="http://www.springframework.org/schema/beans"
  xmlns:batch="http://www.springframework.org/schema/batch"
  xmlns:int="http://www.springframework.org/schema/integration"
  xmlns:int-file="http://www.springframework.org/schema/integration/file"
  xmlns:int-sftp="http://www.springframework.org/schema/integration/sftp"
  xmlns:int-stream="http://www.springframework.org/schema/integration/stream"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch-2.1.xsd
  http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
  http://www.springframework.org/schema/integration/file http://www.springframework.org/schema/integration/file/spring-integration-file-2.0.xsd
  http://www.springframework.org/schema/integration/sftp http://www.springframework.org/schema/integration/sftp/spring-integration-sftp-2.0.xsd
  http://www.springframework.org/schema/integration/stream http://www.springframework.org/schema/integration/stream/spring-integration-stream-2.0.xsd">

Secure data sending with sftp and spring batch

luventas — Mon, 05 Sep 2011 20:17:41 +0000

It is possible to send data with spring batch in several ways. The most used case is sending XML files, but the spring framework offers you a lot of other ways too. One of these ways is to send your data files secure by using SFTP. For this use case you can use the spring integration framework.

Firstly we need a SftpSesstionFactory for sending the files to a sftp server. This factory includes the properties for access to the server.

Source code

 id="sftpSessionFactory" class="org.springframework.integration.sftp.session.DefaultSftpSessionFactory">
   name="host" value="host.of.receiver"/>
   name="user" value="username"/>
   name="password" value="secureSftpPassword"/>
   name="port" value="22"/>
>

Afterwards we need a channel. This channel is used to send the data.

Source code

 id="outputChannel" />

Now we have to link the channel to the SftpSessionFactory. For this we use an outbound-channel-adapter, which includes the channel, the sessionFactory and tells the framework how the file should be named on the target server (remote-filename-generator).

Source code

 id="sftpOutboundAdapter"
  session-factory="sftpSessionFactory"
  channel="outputChannel"
  charset="UTF-8"
  remote-directory="/target"
  remote-filename-generator="fileNameGenerator" />

To make it easy for us, the target server should store the file with the same name like the sending file was named. For this we can use the DefaultFileNameGenerator of spring integration.

Source code

 id="fileNameGenerator" class="org.springframework.integration.file.DefaultFileNameGenerator" />

Now we really want to send the file. For this we need a tasklet with the bussiness logic and at least the batch job.
For the tasklet we need a small java class with the filename as parameter.

The Tasklet:

Source code

 id="sftpJobTasklet" class="de.package.tasklets.SftpTasklet">
   name="fileName" value=" path/to/file/filename.csv" />
   name="sftpChannel" ref="outputChannel" />
>

The Javacode:

Source code

package de.package.tasklets;
 
import java.io.File;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.integration.Message;
import org.springframework.integration.MessageChannel;
import org.springframework.integration.support.MessageBuilder;
 
public class SftpTasklet implements Tasklet {
 
  private String fileName;
  private MessageChannel sftpChannel;
 
  @Override
  public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
 
    File file = new File(fileName);
    if (file.exists()) {
      Message message = MessageBuilder.withPayload(file).build();
      try {
        sftpChannel.send(message);
      } catch (Exception e) {
        System.out.println("Could not send file per SFTP: " + e);
      }
    } else {
      System.out.println("File does not exist.");
    }
    return RepeatStatus.FINISHED;
  }
 
  public String getFileName() {
    return fileName;
  }
 
  public void setFileName(String fileName) {
    this.fileName = fileName;
  }
 
  public MessageChannel getSftpChannel() {
    return this.sftpChannel;
  }
 
  public void setSftpChannel(MessageChannel sftpChannel) {
    this.sftpChannel = sftpChannel;
  }
}

And now, at least, the xml code for the batch job:

Source code

 id="sftpJob" restartable="false">
   id="sftpFileSendStep">
     ref="sftpJobTasklet" />
  >
>

This batch job can be started by a cron job on the server.

At last part I will shortly post the header of the xml file called applicationContext.xml, which includes all the described beans:

Source code

 version="1.0" encoding="UTF-8"?>
   xmlns="http://www.springframework.org/schema/beans"
  xmlns:batch="http://www.springframework.org/schema/batch"
  xmlns:int="http://www.springframework.org/schema/integration"
  xmlns:int-file="http://www.springframework.org/schema/integration/file"
  xmlns:int-sftp="http://www.springframework.org/schema/integration/sftp"
  xmlns:int-stream="http://www.springframework.org/schema/integration/stream"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch-2.1.xsd
  http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
  http://www.springframework.org/schema/integration/file http://www.springframework.org/schema/integration/file/spring-integration-file-2.0.xsd
  http://www.springframework.org/schema/integration/sftp http://www.springframework.org/schema/integration/sftp/spring-integration-sftp-2.0.xsd
  http://www.springframework.org/schema/integration/stream http://www.springframework.org/schema/integration/stream/spring-integration-stream-2.0.xsd">

Why is my WordPress blog so slow?

luventas — Sun, 07 Aug 2011 21:58:30 +0000

Since my last update of my WordPress blog it was horrible slow. My mobile phone was not able to load the blog anymore, my computer needs something arround one or one and a half minutes to load the next page, on the blog and in the admin dashboard too. I asked myself why.

I googled a lot to solve this problem. Nowere I found a tip that helps. So I took the logfile of myserver and tried to find the problem there. But there was no error shown in logfile. The only hint I got from this logfile was the solution. There were a lot of entries, that my blog loads the WordPress Hit Counter. So I deactivated this plugin and, suprise suprise, my blog was as fast as before again.

Maybe It is also a solution for you, if you do not know, why your blog is so slow?

Send Email by Spring batch with variable attachments

luventas — Sun, 07 Aug 2011 20:11:15 +0000

It is very simple to send an Email with attachments by Spring batch framework.

Firstly you need 3 beans for handling the email:
- The first bean initializes JavaMail and sets all needed properties

Source code

 id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">

     name="host" value="smtp.yourEmailDomain.de"/>

     name="port" value="25"/>

     name="username" value="yourUserName"/>

     name="password" value="yourPassword"/>

     name="javaMailProperties">

        >

             key="mail.smtp.auth">true>

        >

    >

>

- The second bean initializes the Tasklet, which calls the Service for sending the mail. It creates the references to the both other beans.

Source code

 id="sendMailManager">

     name="mailSender" ref="mailSender"/>

     name="sendMailService" ref="sendMailService"/>

     name="senderAddress" value="sender@emailaddress.de"/>

     name="recipient" value="recipient@emailaddress.de"/>

     name="attachmentFilePath" value="/path/to/attachment/file/"/>

>

- The last bean is the Service for sending the email.

Source code

 id="sendMailService" class="de.batch.mail.SendMailService" />

Now these beans can be called by a batchJob.

Source code

 id="sendEmailJob" restartable="false" job-repository="jobRepository">

     id="sendEMail">

         ref="sendMailManager" />

    >

>

This is all you need on the XML side in the applicationContext.xml.

Now you have to create the needed Java class files wich are cleed by the beans in XML.

The Bean “sendMailService” is a reference to the de.batch.mail.SendMailService class. In the batch job it is called by the Tasklet named “sendMailManager”.

Source code

package de.batch.mail;

import java.io.File;

import javax.ejb.Stateless;

import javax.mail.Message;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.jboss.seam.annotations.Name;

import org.springframework.core.io.FileSystemResource;

import org.springframework.mail.MailException;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.mail.javamail.MimeMessageHelper;

import org.springframework.mail.javamail.MimeMessagePreparator;

/**

* @author carsten.froehlich

*/

@Stateless

@Name("SendMail")

public class SendMailService {

    private static final Log log = LogFactory.getLog(SendMailService.class);

    private JavaMailSender mailSender;

    private String senderAddress;

    private String recipient;

    private String attachmentFilePath;

    // set the fields

    public void setFields(JavaMailSender mailSender, String senderAddress, String recipient, String attachmentFilePath) {

        this.mailSender = mailSender;

        this.senderAddress = senderAddress;

        this.recipient = recipient;

        this.attachmentFilePath = attachmentFilePath;

    }

    public void sendMail() {

        log.debug("send Email started");

        // read directory

        File directory = new File(attachmentFilePath);

        // get file from directory

        final File file = directory.listFiles(FILE_FILTER)[0];

        MimeMessagePreparator preparator = new MimeMessagePreparator() {

            public void prepare(MimeMessage mimeMessage) throws Exception {

                mimeMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(recipient));

                mimeMessage.setFrom(new InternetAddress(senderAddress));

                mimeMessage.setSubject("Neuer Report");

                // MimeMessagesHelper is needed for the attachment. The Boolean value in

                // constructor is for multipart/data = true

                MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);

                helper.addAttachment(file.getName(), new FileSystemResource(file));

                helper.setText("Text in Email Body");

            }

        };

        try {

            this.mailSender.send(preparator);

            log.debug("send Email completed");

        } catch (MailException ex) {

            log.debug("send Email failed", ex);

        }

    }

    public static FileFilter FILE_FILTER = new FileFilter() {

        public boolean accept(File file) {

            return !file.isDirectory();

        }

    };

 }

This is the tasklet, which calls the Service:

Source code

package de.batch.tasklets;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.batch.core.StepContribution;

import org.springframework.batch.core.scope.context.ChunkContext;

import org.springframework.batch.core.step.tasklet.Tasklet;

import org.springframework.batch.repeat.RepeatStatus;

import org.springframework.mail.javamail.JavaMailSender;

import de.mail.SendMailService;

/**

* @author carsten.froehlich

*/

public class SendMailTasklet implements Tasklet {

    private static final Log log = LogFactory.getLog(SendMailTasklet.class);

    private SendMailService sendMailService;

    private JavaMailSender mailSender;

    private String senderAddress;

    private String recipient;

    private String attachmentFilePath;

    public void setMailSender(JavaMailSender mailSender) {

       this.mailSender = mailSender;

    }

    public void setSenderAddress(String senderAddress) {

        this.senderAddress = senderAddress;

    }

    public void setRecipient(String recipient) {

        this.recipient = recipient;

    }

    public void setAttachmentFilePath(String attachmentFilePath) {

        this.attachmentFilePath = attachmentFilePath;

    }

    public void setSendMailService(SendMailService sendMailService) {

        this.sendMailService = sendMailService;

    }

    @Override

    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {

        log.debug("execute(StepContribution contribution, ChunkContext chunkContext) begin");

        sendMailService.setFields(mailSender, senderAddress, recipient, attachmentFilePath);

        sendMailService.sendMail();

        log.debug("execute(StepContribution contribution, ChunkContext chunkContext) end");

        return RepeatStatus.FINISHED;

    }

}

This is somehow all you need for sending emails by spring batch with attachment.