Coffee makes me wired, to be sure; especially since I don't drink enough of it to build any sort of tolerance. It isn't a real alertness, however. It doesn't feel genuine. It feels like my body is exhausted but lying to me and telling me "oh, sure dude, don't worry about it, we're cool" all while struggling to keep up. My muscles sometimes ache, and often times I'll feel a strange, awake version of grogginess.

I don't usually crash hard like I do wish sugar. Instead the grogginess and general heaviness lingers for most of the day. I get sore easier, usually by sitting for too long, and I'll usually sleep like a catatonic slug the following night.

I can't wait to see how my body reacts to excessive alcohol.

indexOf (o upper case - returns -1 of not found...)

Always send the complete URL to external party instead of alias -

Always check the path of each of pst files and do a regular back up. Do not depend on office laptop.
Recheck pst file for opening before formatting the drive.

Can we use regex for extraction of domain from the url?

.NET

FormsAuthentication.HashPasswordForStoringInConfigFile()

Java

import java.security.MessageDigest; ... public String md5(String s, String s1)     {         String s2 = s + s1;         byte abyte0[] = s2.getBytes();         StringBuffer stringbuffer = new StringBuffer();         String s3 = null;         try         {             MessageDigest messagedigest = MessageDigest.getInstance("MD5");             messagedigest.reset();             messagedigest.update(abyte0);             byte abyte1[] = messagedigest.digest();             for(int i = 0; i < abyte1.length; i++)                 stringbuffer.append(Integer.toHexString(0xff & abyte1[i] | 0x100).substring(1, 3));             s3 = stringbuffer.toString();         }         catch(Exception exception) { }         return s3;     }

VB/ASP

Google.

]]> http://offsignal.wordpress.com/?p=3 Wed, 15 Oct 2008 23:12:24 +0000 offsignal http://offsignal.lt.wordpress.com/2008/10/15/hacking/ 1. Basic Socket Programming: (4 videos - 65 mins)

1.1 Presentation on Socket Programming basics (25 mins)
1.2 "Type with Me" exercise - a simple TCP server (19 mins)
1.3 Coding a TCP Echo server (13 mins)
1.4 Coding a TCP Echo client (9 mins)

http://www.security-freak.net/sockets/socket-programming.html

2. Packet Sniffing using Raw Sockets: (7 videos - 86 mins)

2.1 Presentation on raw socket basics (14 mins)
2.2 Sniffer coding basics (15 mins)
2.3 Sniffer - Ethernet header parsing (10 mins)
2.4 Sniffer - IP header parsing (14 mins)
2.5 Sniffer - TCP header parsing (10 mins)
2.6 Sniffer - Data parsing (9 mins)
2.7 A look at Tcpdump and Ethereal (14 mins)

http://www.security-freak.net/raw-sockets/raw-sockets.html

3. Packet Injection using Raw Sockets: (6 videos - 75 mins)

3.1 Packet injection basics presentation (10 mins)
3.2 Your first packet injection program (9 mins)
3.3 Ethernet header contruction & injection (10 mins)
3.4 IP header construction & injection (14 mins)
3.5 TCP header and data contruction & injection (17 mins)
3.6 ARP Request query injector (15 mins)

http://www.security-freak.net/packet-injection/packet-injection.html

4. Architecture of a Proactive Security Tool: (4 videos - 43 mins)

4.1 The "Sniff - Think - Inject" logic - a presentation (10 mins)
4.2 Programming the Framework (7 mins)
4.3 Communication via the Framework (8 mins)
4.4 ARP DoS tool using the Framework (18 mins)

http://www.security-freak.net/architecture/architecture.html

5. Encryption Basics using RC4: (3 videos - 38 mins)

5.1 RC4 basics presentation (13 mins)
5.2 Understanding RC4 via simulations (13 mins)
5.3 File encryption / decryption using RC4 (12 mins)

http://www.security-freak.net/encryption/encryption-rc4.html

http://www.irongeek.com/i.php?page=security/hackingillustrated

para instalarlo:

#apt-get install openjdk-6-jdk openjdk-6-jre

opcionalmente pueden bajarce las fuentes

#apt-get install openjdk-6-source

Como antes ya tenia instalado el java-6-sun es necesario indicar cual opción utilizar para java, para ello usamos el comando update-alternatives

# update-alternatives --config java

Hay 4 alternativas que proveen `java'.

Selección     Alternativa
-----------------------------------------------
1    /usr/bin/gij-4.3
2    /usr/lib/jvm/java-gcj/jre/bin/java
*    3    /usr/lib/jvm/java-6-sun/jre/bin/java
+   4    /usr/lib/jvm/java-6-openjdk/jre/bin/java

Pulse <Intro> para mantener el valor por omisión [*] o pulse un número de selección:

en mi caso pulso 4 para poner el openjdk por omisión esto quiere decir que por ejemplo cuando utilice el comando java sera el del openjdk.

Una de las sorpresas con que me encontre fue que al momento de abrir netbeans 6 este se configuro para compilar y correr programas con el openjdk  X).

Ahora puedo decir que tengo java totalmente libre :D

]]> http://bodez.wordpress.com/?p=130 Wed, 15 Oct 2008 20:56:50 +0000 gcatanese http://bodez.lt.wordpress.com/2008/10/15/xwiki-user-authentication-with-oracle-sso/ XWiki is a popular Java-based wiki software offering a good variety of features and plugins. It is pretty advanced, therefore ideal for any enterprise requiring a content management tool which is flexible, professional and free :-)

Installation and configuration come in different flavors, starting with the standalone distribution (Jetty container on HSQLDB db), by far the easiest option. Alternatively the XWiki WAR file can be deployed on any servlet container and any database of your choice (Oracle 10.1.2 RDBMS and OC4J 10.1.3 in my case).

Installation on Oracle infrastructure

Create a new XWIKI database schema with all privileges.

Edit the XWiki WAR file (hibernate.cfg.xml) to point the datasource to the newly created schema. Deploy the WAR file itself (or package the WAR in an EAR file).

Restart the OC4J (the database objects will be created/populated when xwiki is first invoked).

Optional: import the default XWiki XAR file to populate the wiki with an initial set of pages

User Authentication

XWiki has its default built-in authentication module, or it can be configured to use an LDAP server.

However if you need to use an existing authentication mechanism (Oracle SSO or any other) you will have to plugin a Custom Authentication handler.

Implement the handler

First of all you need to implement the com.xpn.xwikiuser.api.XWikiAuthService interface. One easy way to accomplish that is to extend the existing XWiki implementation (com.xpn.xwiki.user.impl.xwiki.XWikiAuthServiceImpl) as shown below:

   public class SSOAuthServiceImpl extends XWikiAuthServiceImpl {
    ....

Next step is to override the method which performs the authentication:

    @Override
    public XWikiUser checkAuth(XWikiContext context) throws XWikiException {
    ....

Your implementation of the checkAuth() method must contain the authentication logic and return an instance of the XWikiUser class:

        String user = context.getRequest().getRemoteUser();
        if(user == null) {
           log.error("User cannot be authenticated");
           return super.checkAuth(context);
        } else {
           return new XWikiUser("XWiki." + user);
        }

Create the users

Oracle SSO relies on Oracle Internet Directory (LDAP) to store the user information, however XWiki has its own repository. If you don't want to register manually each user into XWiki then you can create those programatically (maybe during logon):

    context.getWiki().createEmptyUser("beppe", "edit", context);

Source

I have attached my implementation (ssoauthserviceimpl.java) as an example, hope it helps.

This is definitely not desired - in case of specific input that contains repeatable sets of information (like text documents, bitmaps with large areas of the same color), the encrypted chunks might repeat just like original plain-text values do. As a result of that, encrypted data might reveal important details of the original content.

You might want to have a look at a very interesting article about this subject on (ahem) Wikipedia. It clearly describes, how block cipher modes solve the problem and additionaly demonstrates how it manifests itself in case of bitmaps. I wanted to play with various block cipher modes and in order to do so I wrote a simple tool that encrypts a user-provided BMP file while leaving its headers intact. As a result of that we are still able to view the encrypted bitmap file in image browser and observe how particular ciphers, key sizes and block modes influence the output. Below are some examples showing:

1. raw image
2. image encrypted with 56 bit DES using Electronic Codebook (ECB) mode
3. image encrypted with 56 bit DES using Cipher-block Chaining (CBC) mode

In case of the second example I chose a rather high resolution (3923x4656) scan of an old document. What you see here is just a small cropped part of it, which is hopefully more than enough to observe the effect. I guess I could spare us all pictures representing the CBC mode since they are pretty noisy.

We can also look at this subject from slightly different perspective. The chart below shows how byte values are distributed in a file. Horizontal axis represents bytes from 0 to 255 obviously, while vertical axis stands for count of bytes of given value.

You can clearly see that in case of raw data as well as ECB mode some bytes show up more often than others. But if we look at the green line representing CBC mode - the distribution is very even across the whole scale which suggests that the encrypted data would contain less information valuable to a person willing to find out what is behind it.

The code to the BMP encrypter is below.

[sourcecode language="Java"]

import java.io.*;
import java.security.GeneralSecurityException;

import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;

public class BitmapPaddingTest {

    public static void main(String[] args) throws Exception {
        if (args.length < 4) {
            throw new Exception("Parameters: [file] [cipher] [keySize] [useInitVector]");
        }
        new BitmapPaddingTest().encrypt(
                new File(args[0]), args[1], Integer.parseInt(args[2]), Boolean.parseBoolean(args[3]));
    }

    public void encrypt(File file, String cipherName, int keySize, boolean useIv) throws Exception {
        File encryptedFile = buildEncryptedFile(file, cipherName, keySize);
        System.out.print("Encrypting " + file.getName() + " to " + encryptedFile.getName() + "... ");

        OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(encryptedFile));
        InputStream fileStream = new BufferedInputStream(new FileInputStream(file));
        byte[] data = new byte[54]; // first 54 bytes of BMP file contain its header (in most cases)
        fileStream.read(data);
        outputStream.write(data);
        outputStream.flush();       

        CipherOutputStream cipherStream =
            new CipherOutputStream(outputStream, createCipher(cipherName, keySize, useIv));
        data = new byte[1024];
        int size = 0;
        while ((size = fileStream.read(data)) > 0) {
            cipherStream.write(data, 0, size);
        }
        cipherStream.flush();
        cipherStream.close();
        System.out.println("done.");
    }

    private SecretKey createSymmetricKey(String cipherName, int keySize) throws GeneralSecurityException {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(cipherName.substring(0, cipherName.indexOf("/")));
        keyGenerator.init(keySize);
        return keyGenerator.generateKey();
    }

    private Cipher createCipher(String cipherName, int keySize, boolean useIv) throws GeneralSecurityException {
        SecretKey symmetricKey = createSymmetricKey(cipherName, keySize);
        Cipher cipher = Cipher.getInstance(cipherName);
        IvParameterSpec iv = useIv ? new IvParameterSpec(symmetricKey.getEncoded()) : null;
        cipher.init(Cipher.ENCRYPT_MODE, symmetricKey, iv);
        return cipher;
    }

    private File buildEncryptedFile(File file, String cipherName, int keySize) {
        String cipherNameUnderscored = cipherName.replaceAll("/", "_");
        return new File(file.getParentFile(),
                file.getName().replace(".bmp", "_" + cipherNameUnderscored + "_" + keySize + ".bmp"));
    }
}

[/sourcecode]

If run as follows:

java BitmapPaddingTest source.bmp DES/ECB/PKCS5Padding 56 false
java BitmapPaddingTest source.bmp DES/CBC/PKCS5Padding 56 true

will generate two files located in the same directory as the source bitmap.

2. A form added into this app. User inputs a number, app calculates then return:
- Several beans are defined in "springapp-servlet.xml":
      productManager (with product list)
      messageSource (ResourceBundleMessageSource)
      /hello.htm (InventoryController)
      /priceincrease.htm (PriceIncreaseFormController)
- /priceincrease.htm bean is like:
    <bean name="/priceincrease.htm" class="springapp.web.PriceIncreaseFormController">
        <property name="sessionForm" value="true" />
        <property name="commandName" value="priceIncrease" />
        <property name="commandClass" value="springapp.service.PriceIncrease" />
        <property name="validator">
            <bean class="springapp.service.PriceIncreaseValidator" />
        </property>
        <property name="formView" value="priceincrease" />
        <property name="successView" value="hello.htm" />
        <property name="productManager" ref="productManager" />
    </bean>
- And inside InventoryController, a reference to a ProductManager is added,
  so this time when user visits "hello.htm", we could retrieve a list of products to display.
- User uses this link "priceincrease.htm" to the form (form in priceincrease.jsp)
- A Java bean (commandClass) "PriceIncrease.java" is created to hold the increase value.
- A SimpleFormController: PriceIncreaseFormController, do calculations, return ModelAndView.

Eu mesmo, em minha mesa, tenho vários reference cards. Alguns até colados na parede. (parece festa).

Encontrei um site muito bom com ótimos reference cards, espero que aproveite! Ai vai: http://www.digilife.be/quickreferences/quickrefs.htm

Utilizando o MyEclispe para fazer o hot deployment no OC4J. Ele faz o deployment na pasta application-autodeploy. Para funcionar são necessários os seguintes passos:

1) Configurar o server.xml (dentro de j2ee/home/config) para varrer esta pasta. Ele deverá estar da seguinte forma:

<application-server  ..
 check-for-updates="all"
 application-auto-deploy-directory="../application-autodeploy" >
...
</application-server>

2) Faca o deployment de um archive packaged e inicie o oc4j. Isto fara com que ele encontre sua aplicacao e automaticamente registre-a no server.xml e no default-web-site.xml. Se voce souber configurar estes arquivos manualmente, podera pular este passo.

3) Com o OC4J desligado, remova o deployment packaged e faca o deployment exploded. Inicie novamente o OC4J.

Isto devera ser o suficiente para EARs e WARs, mas se você tiver algum módulo EJB, o OC4J 10.1.13 tem um bug. Quando voce faz o deployment exploded, ele diz uma mensagem "EJB module contains no beans" ou em portugues "O módulo EJB não contém beans". Isto é porque a pasta do EJB deve ter o sufixo .jar. Então, a estrutura do seu EAR deverá ser assim:

MinhaAplicacao/
 + MeuModuloEJB.jar/
   + ...
 + MeuModuloWeb/
    + ...

O problema é que se você então decide usar a opção de deployment "Custom Location - Suffixed" do MyEclipse também não deverá funcionar, pois ele adiciona o sufixo em todos os módulos, e o OC4J não encontra os módulos web se estiverem com o sufixo .war!

Odeio fazer gambiarras, mas desta vez nao teve jeito. Nao tenho tempo para fazer um script ant bem legal, tampouco para fazer um plugin do eclipse, entao la vai a marreta: Faco um deployment do oc4j exploded do meu EAR sem o EJB (resolvo as dependencias manualmente), dai depois faco um deployment custom location - suffixed do meu EJB no diretorio onde o EAR foi disponibilizado. E pronto! Funciona...

O pior de tudo é que com a compra da BEA, a Oracle provavelmente deve deixar o antigo OC4J de lado e investir no Oracle WebLogic. Então dificilmente encontraremos uma correção para este bug, apenas fazendo o upgrade. Testei com a versao 10.1.3.3 e 10.1.3.4. Arggg...

Abcs.

LH.

Program singkat berikut memperlihatkan cara pemanfaatan perintah getbyName():

import java.net.*;
import java.util.*;

public class NamekeIP {
public static void main (String[] args) {
try {
InetAddress address = InetAddress.getByName("www.iGoogle.com");
System.out.println("IP Address: " + address.toString());
}
catch (UnknownHostException uhEx) {
System.out.println("Host tidak dapat ditemukan.");
}
}
}

Ada beberapa hal penting yang perlu diperhatikan dalam penggunaan kelas InetAddress:

1. Pastikan penggunaan dasar seperti di atas, selalu gunakan try dan catch...jika tidak maka program tidak dapat berjalan.

2. Jangan lupa mengimport paket java.util.* dan java.net.*.

Sedangkan contoh berikut memungkinkan pengguna untuk memasukkan nama host setiap kali dijalankan, tidak hanya iGoogle.com:

import java.net.*;
import java.util.*;

public class IPFinder {
public static void main (String[] args) {
String host;
Scanner input = new Scanner(System.in);

System.out.print("Masukan nama host: ");
host = input.next();

try {
// mendapatkan IP address berdasarkan nama host
InetAddress address = InetAddress.getByName(host);

// mendapatan namahost dan IP address dari localhost
//InetAddress address = InetAddress.getLocalHost();

System.out.println("IP Address: " + address.toString());
}
catch (UnknownHostException uhEx) {
System.out.println("Tidak dapat menemukan " + host);
}
}
}

OK, begitu saja ya...tidak banyak penjelasan...karena sangat sederhana...namun jika anda pemula...saran saya coba tulis dan jalankan kode program di atas.

The IcedTea6 project provides a harness to build the source code from
OpenJDK6 (http://openjdk.java.net) using Free Software build tools and
provides replacements libraries for the binary plugs with code from the
GNU Classpath project. More information on IcedTea can be found here:
http://icedtea.classpath.org

What's New?
-----------------
- Updated to b12 bundle.
- Fixed to use new sound service, Gervill.
- Many Netx fixes and now built by default.
- LiveConnect support (--enable-liveconnect).
- Implemented JavaScript->Java security.
- PulseAudio integrated (--enable-pulse-java)
- VisualVM tool integrated (--enable-visualvm).
- Added out-of-the-box CACAO support (--with-cacao).
- Added the experimental Shark JIT for Zero.
- Cleaned up crypto support, all algorithms and key sizes are fully
supported now without any (regional) restrictions. No more need for
separate crypto policy jars.
- Integration of Mozilla Rhino javascript support for javax.script.
(See http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=179 when
you want to enable non-system-installed versions of Rhino).
- Add support for Zero builds on alpha, arm, mips, mipsel, m68k, s390.
- Various build fixes.
- Several bug and security fixes: (http://icedtea.classpath.org/bugzilla/ and
https://bugzilla.redhat.com/).

-----------------

The tarball and nosrc RPM can be downloaded here:
- java-1.6.0-openjdk-1.6.0.0-0.23.b12.fc10.nosrc.rpm
- icedtea6-1.3.tar.gz

The following people helped with this release:
Gary Benson, Deepak Bhole, Tom Callaway, Pablo del Campo, Thomas Fitzsimmons, Dennis Gilmore, Andrew Haley, Andrew John Hughes, Ioana Ivan, Matthias Klose, DJ Lucas, Omair Majid, Xerxes Ranby, Marc Schoenefeld, Keith Seitz, Joshua Sumali, Christian Thalinger, Mark Wielaard, Lillian Angel

We would also like to thank the bug reporters and testers!

To get started:
$ hg clone http://icedtea.classpath.org/hg/icedtea6
$ cd icedtea6

Full build requirements and instructions are in INSTALL:
$ ./configure (--enable-liveconnect --enable-visualvm --enable-pulse-java)
$ make

This really is a key observation. If you say static typing is too verbose, anyone who's familiar with OCaml, Haskell or Scala disagrees. But the fact is that our current selection of useful statically typed languages are verbose. C# isn't quite as bad as Java, but Java is terrible.

The question then becomes whether Ruby or Python are less maintainable than Java. In my experience, the answer is 'that really depends on your project'. Maintainability isn't a language feature. No matter what language someone is writing they can create code that is difficult to maintain. The qualities of maintainable code is different in different style languages. A coding style that may be easier to deal with down the line with one language can be more difficult in another language.

In my experience tests are more far important than static type checking when doing refactorings. And personally, I find Java to be worse for reading code than Ruby or Python. People easily become thoughtless code generators when dealing with Java. Just keep hitting ctrl+space until it compiles, right? Meanwhile, languages like Ruby and Python make you focus on what the code actually does when it runs. Neither of these statements are absolutes and they're both limited by my experience, but I have seen both sides of things and my preference is clear.

[Se l'oggetto contenuto s'allarga troppo] il contenitore non riesce più a contenere il suo contenuto!

Per il resto... il livello di fame aumenta a dismisura e ti viene voglia di mordere un collega... :shock:

Ficha de Descarga:

Autor: Horstmann, Gary Cornell

Host: Rapidshare

Tamaño: 9.4 Mb

Comprimido: WinRar

Formato manual: pdf

Idioma: Ingles

Descargar Core Java Volume 1 Fundamentals

Eclipse squashing lines

Originally uploaded by Lenniboy

I used to have terrible problems with Eclipse on my MacBook running OS X. Editor text was bouncing up and down and all my lines were squashing. Have a look at the photo if you think I'm crazy.

Finally I have managed to find out what has caused this behaviour: It is the font size, which was set to 9.5. I'm not sure if the small size or the .5 bit that is to blame but but as soon as I set it to 11pt everything was fine.

I'm happy I found this because I was very short of changing over to XCode.

I guess most people who are using Lucene came to the point where they want to score direct matches higher than wildcard matches. For example if we have the searchphrase "cup" and we have several documents in our index which contain the searchphrase like:

• doc 4711: name: cupholder
• doc 4712: name: cup

In most use-cases people want the direct match, in this case doc 4712 to appear as the first hit. Because cup is contained in both names, you get both documents as matches, but doc 4712 as the first match. So far so good. If you add more complexity to the documents perhaps by giving them a description, you might end up with a messed up scoring. This can have different causes (perhaps "cup" appears in the description of doc 4711 but not in 4712). Check out the Similarity class in Lucene and call searcher.explain() on your document to find out the reason for the score. What you want to do is to boost a direct match. Here is how I did it:

[sourcecode language='java']
//where fieldName is 'name' or 'description'
Query tmpQuery = new TermQuery(new Term(fieldName, searchString));
//boost the direct match
tmpQuery.setBoost(2.0f);
query.add(tmpQuery, BooleanClause.Occur.SHOULD);

//search for other occurences
tmpQuery = new WildcardQuery(new Term(fieldName, "*" + searchString + "*"));
query.add(tmpQuery, BooleanClause.Occur.SHOULD);
[/sourcecode]

I hope that helped somebody on his or her Lucene journey. Have a nice day.

"C:\Program Files\NetBeans 6.1\bin\netbeans.exe" --locale en:US

日文：

"C:\Program Files\NetBeans 6.1\bin\netbeans.exe" --locale ja:JA

NetBeans 6.1 多国语言版本下载地址：

http://download.netbeans.org/netbeans/6.1/final/

Generellt sätt kan man säga att webbtjänster är XML/HTTP (XML över HTTP). Webbtjänster är alltså ofta tjänster som finns tillgängliga över ett nätverk. Eftersom en webbtjänst typiskt är baserad på ett XML-gränssnitt gör detta att webbtjänsten blir oberoende av programmeringsspråk. Exempelvis kan tjänsten implementeras i Java men anropas från en klient skriven i C++.

SOAP är ett standardiserat protokoll för överföring av XML-meddelanden som används för webbtjänster. Detta protokoll är standardiserat av W3C och det finns ett brett stöd för SOAP-baserade webbtjänster via Spring/Java, .NET, C++ och så vidare. Andra standarder för webbtjänster är exempelvis REST som inte kommer att behandlas i detta inlägg.

En SOAP-baserad webbtjänst kan beskrivas med hjälp av WSDL. Det finns inget krav på att WSDL måste användas men en WSDL-definition måste finnas tillgänglig för att en klient på ett automatiserat sätt ska kunna skapa proxy-objekt och liknande för att komma åt en webbtjänst.

Den typ av webbtjänster som kommer att diskuteras i detta inlägg är alltså webbtjänster som definieras via WSDL och använder protokollet SOAP.

Contract First

Om man ska generalisera lite kan man säga att det finns två vedertagna metoder för att utveckla webbtjänster, Contract First och Contract Last. Contract Last innebär helt enkelt att man först skapar ett javagränssnitt och sedan utifrån detta skapar en XML-definition via exempelvis WSDL som beskriver detta gränssnitt. Contract First innebär det motsatta det vill säga att man först skapar XML-kontraktet och sedan utifrån detta kontrakt skapar javagränssnittet.

Spring WS erbjuder endast stöd för det senare det vill säga Contract First och detta motiveras av Spring själva med följande:

• Java/XML inkompatibilitet – Vissa javatyper är svåra att beskriva i XML och det finns inget standardiserat sätt att göra detta på. Detta innebär att beroende på vilket sätt som används för att generera XML kan resultatet se olika ut.
• Stabilitet – Om man genererar XML-kontraktet från ett javagränssnitt så kommer kontraktet att förändras om javagränssnittet förändras. Olika verktyg kan dessutom generera olika XML baserat på hur gränssnittet ser ut.
• Prestanda – Om man genererar XML utifrån ett javagränssnitt kan en komplex objektgraf leda till att en väldigt stor mängd XML genereras. Ett objekt kan ha ett beroende till ett objekt som har ett beroende till ett objekt och så vidare. Om ett kontrakt specificeras så är det tydligt vilken XML som skickas.
• Återanvändbarhet – Genom att deklarera ett schema i en separat XSD (XML Schema Definition) kan denna återanvändas i andra delar av applikationen eller rent av i andra applikationer.
• Version – Om ett XML-schema måste uppdateras kan fortfarande samma javaimplementation användas för att hantera gamla och nya versioner.

Kontraktet

Kontraktet som används för att uttrycka en webbtjänst baseras på en vanlig XSD. I exemplet nedan (som faktiskt är samma exempel som i inlägget tidigare om Distribuerade tjänster via Spring) så används följande XSD:

<xs:schema
      xmlns:xs="http://www.w3.org/2001/XMLSchema"
      xmlns:calc="http://cygni.se/exporters/schemas"
      elementFormDefault="qualified"
      targetNamespace="http://cygni.se/exporters/schemas">

    <xs:element
        name="CalculatorRequest"
        type="calc:CalculatorOperationType" />
    <xs:element
        name="CalculatorResponse"
        type="calc:CalculatorResponseType" />

    <xs:complexType name="CalculatorOperationType">
        <xs:sequence>
            <xs:element name="First" type="xs:integer" />
            <xs:element name="Second" type="xs:integer" />
            <xs:element name="Operation" type="calc:OperationType" />
        </xs:sequence>
    </xs:complexType>

    <xs:complexType name="CalculatorResponseType">
        <xs:all>
            <xs:element name="Answer" type="xs:integer" />
            <xs:element name="Error" type="xs:string" />
        </xs:all>
    </xs:complexType>

    <xs:simpleType name="OperationType">
        <xs:restriction base="xs:string">
            <xs:enumeration value="ADD" />
            <xs:enumeration value="SUBTRACT" />
            <xs:enumeration value="MULTIPLY" />
            <xs:enumeration value="DIVIDE" />
        </xs:restriction>
    </xs:simpleType>
</xs:schema>

Användning av ovanstående schema kan se ut som nedan när operanderna 3 och 2 ska adderas (det vill säga 3 + 2 = 5):

<CalculatorRequest>
    <First>3</First>
    <Second>2</Second>
    <Operation>ADD</Operation>
</CalculatorRequest>

Om allt går bra blir svaret ett CalculatorResponse enligt nedan:

<CalculatorResponse>
    <Answer>5</Answer>
</CalculatorResponse>

Observera att detta endast är "vanlig" XML baserad på en XSD. Inga WSDL-definitioner eller liknande ännu.

Javatjänst

Det förra inlägget i denna serie som handlade om Distribuerade tjänster via Spring beskrev hur man med hjälp av en service exporter kan exponera tjänster via exempelvis RMI, Hessian och så vidare. Springstödet för webbtjänster baseras på samma princip men det krävs lite mer manuellt arbete för att få en webbtjänst att fungera. Vi utgår från samma exempel som i Distribuerade tjänster via Spring det vill säga CalculatorService som passar väl ihop med det webbtjänstkontrakt som vi definierat ovan.

Javagränssnittet för CalculatorService ser ut så här:

package se.cygni.sample.spring.exporters;

public interface CalculatorService {
    int add(int first, int second);
    int subtract(int first, int second);
    int divide(int first, int second);
    int multiply(int first, int second);
}

Tjänsten realiseras med hjälp av en POJO enligt nedan:

package se.cygni.sample.spring.exporters;

public class PojoCalculatorService implements CalculatorService {

    public int add(int first, int second) {
        return first + second;
    }

    public int subtract(int first, int second) {
        return first - second;
    }

    public int divide(int first, int second) {
        return first / second;
    }

    public int multiply(int first, int second) {
        return first * second;
    }
}

Inga konstigheter, nu gäller det bara att koppla ihop XML-kontraktet och javatjänsten via en webbtjänst.

Webbtjänst

Springs webbtjänststöd på serversidan baseras kring en komponent som kallas MessageDispatcher. Denna komponent vidarebefordrar webbtjänstanrop till så kallade Endpoints. En endpoint är alltså en mottagare av ett webbtjänstanrop och är en javaklass som kan hanteras via Spring som vilken annan komponent som helst. Observera att man programmatiskt inte behöver känna till komponenten MessageDispatcher, Spring WS hanterar detta åt dig. Som applikationsutvecklare behöver du endast skapa/konfigurera endpoints.

Eftersom en endpoint är en javaklass och kontraktet är XML måste en mappning mellan XML och Java ske. Detta kallas marshalling/unmarshalling och Spring erbjuder stöd för detta via sin OXM teknologi (OXM – Object/XML Mapping). Spring OXM är alltså ett abstraktionslager för olika typer av tekniker för Object/XML Mapping, för mer information rekommenderas Springs OXM-dukumentation.

De tekniker som följer med Spring för marshalling/unmarshalling är:

• XStream
• JiBX
• JAXB
• Castor
• XMLBeans

Den teknologi som används i detta exempel är baserat på XStream. XStream är ett enkelt ramverk för serialisering av javaobjekt till och från XML. XStream erbjuder bland annat stöd för serialisering via annotationer.

Marshalling och unmarshalling är definierat via två springgränssnitt, Marshaller och Unmarshaller. Gränssnittet för marshalling är enkelt och innehåller metoden marshal som används för att konvertera ett Object till XML. XML:en skrivs till ett javax.xml.transform.Result.

Marshaller:

package org.springframework.oxm;

import java.io.IOException;
import javax.xml.transform.Result;

public interface Marshaller {
    void marshal(Object graph, Result result) throws XmlMappingException, IOException;
    boolean supports(Class clazz);
}

Gränssnittet för unmarshalling innehåller en motsvarande unmarshal-metod som konverterar en javax.xml.transform.Source till ett Object.

package org.springframework.oxm;

import java.io.IOException;
import javax.xml.transform.Source;

public interface Unmarshaller {
    Object unmarshal(Source source) throws XmlMappingException, IOException;
    boolean supports(Class clazz);
}

En endpoint kan skapas på flera sätt men i detta exempel kommer annotationer att användas. Till skillnad från de "automagiska" service exporters vi tidigare träffat på måste vi nu mappa upp XML-requestet till en specifik metod i en javaklass (en endpoint).

package se.cygni.sample.spring.exporters.ws;

import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;

import se.cygni.sample.spring.exporters.CalculatorService;

@Endpoint
public class CalculatorServiceEndpoint {
    private CalculatorService calculatorService;

    public CalculatorServiceEndpoint(CalculatorService calculatorService) {
        this.calculatorService = calculatorService;
    }

    @PayloadRoot(
            localPart = "CalculatorRequest",
            namespace = "http://cygni.se/exporters/schemas")
    public CalculatorResponse executeOperation(CalculatorRequest request) {
        try {
            int result;
            switch (request.getOperation()) {
                case ADD:
                    result = calculatorService.add(
                            request.getFirst(),
                            request.getSecond());
                    break;
                case SUBTRACT:
                    result = calculatorService.subtract(
                            request.getFirst(),
                            request.getSecond());
                    break;
                case DIVIDE:
                    result = calculatorService.divide(
                            request.getFirst(),
                            request.getSecond());
                    break;
                case MULTIPLY:
                    result = calculatorService.multiply(
                            request.getFirst(),
                            request.getSecond());
                    break;
                default:
                    return new CalculatorResponse("No valid operation");
            }
            return new CalculatorResponse(result);
        } catch (Throwable thr) {
            return new CalculatorResponse(thr.getMessage());
        }
    }
}

Exemplet ovan visar implementation av en endpoint som delegerar vidare till en implementation av CalculatorService. Metoden executeOperation mappas via annotationen @PayloadRoot mot XML-taggen CalculatorRequest.

Värt att notera är inargument och returvärde. Inargumentet är av typen CalculatorRequest och returvärdet är av typen CalculatorResponse. Dessa typer mappas alltså mot XML-taggar via unmarshalling/marshalling som diskuterats tidigare. För detta exempel är klasserna CalculatorRequest och CalculatorResponse annoterade med XStream-annotationer (XStreamAlias och en marshaller/unmarshaller för XStream är deklarerad i applikationskontextet. För mer information om XStream och annotationer rekommenderas XStream-dokumentationen.

Requestobjektet:

package se.cygni.sample.spring.exporters.ws;

import com.thoughtworks.xstream.annotations.XStreamAlias;

@XStreamAlias("CalculatorRequest")
public class CalculatorRequest {
    @XStreamAlias("First")
    private int first;

    @XStreamAlias("Second")
    private int second;

    @XStreamAlias("Operation")
    private OperationType operation;

    public CalculatorRequest() {
        // Ingen initiering nödvändig
    }

    public CalculatorRequest(
            int first,
            int second,
            OperationType operation) {

        this.first = first;
        this.second = second;
        this.operation = operation;
    }

    public int getFirst() {
        return first;
    }

    public int getSecond() {
        return second;
    }

    public OperationType getOperation() {
        return operation;
    }
}

Enumeration för vilken typ av operation som ska utföras (add, subtract och så vidare):

package se.cygni.sample.spring.exporters.ws;

public enum OperationType {
    ADD, SUBTRACT, MULTIPLY, DIVIDE;
}

Responseobjektet:

package se.cygni.sample.spring.exporters.ws;

import com.thoughtworks.xstream.annotations.XStreamAlias;

@XStreamAlias("CalculatorResponse")
public class CalculatorResponse {
    @XStreamAlias("Answer")
    private Integer answer;

    @XStreamAlias("Error")
    private String error;

    public CalculatorResponse(Integer answer) {
        this.answer = answer;
    }

    public CalculatorResponse(String error) {
        this.error = error;
    }

    public Integer getAnswer() {
        return answer;
    }

    public String getError() {
        return error;
    }
}

Själva marshaller/unmarshaller-bönan är en del av Spring OXM och deklareras enligt följande:

<bean id="xstreamMarshaller"
      class="org.springframework.oxm.xstream.AnnotationXStreamMarshaller">
    <property
        name="annotatedClasses"
        value="se.cygni.sample.spring.exporters.ws.CalculatorRequest,
               se.cygni.sample.spring.exporters.ws.CalculatorResponse" />
</bean>

Alla de marshallers/unmarshallers som tillhandahålls av Spring implementerar både Marshaller- och Unmarshaller-gränssnitten. XStream-exemplet ovan använder propertyn annotatedClasses för att deklarera vilka klasser som är annoterade med XStream-annotationer.

Eftersom webbtjänster (som namnet antyder) är webbaserade så krävs det att tjänsterna exponeras via HTTP. Det sker enkelt via en deklaration i web.xml enligt nedan.

<servlet>
    <servlet-name>spring-ws</servlet-name>
    <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>spring-ws</servlet-name>
    <url-pattern>/spring-ws/*</url-pattern>
</servlet-mapping>

Klassen MessageDispatcherServlet är en utökning av den vanliga DispatcherServlet från Spring MVC som kommer att diskuteras i ett senare inlägg. MessageDispatcherServlet vidarebefordrar anrop till MessageDispatchern som vidare delegerar till de olika endpoints som finns deklarerade.

Den konvention som används är att applikationskontextet måste heta -servlet.xml, precis som för Spring MVC. Om servletnamnet är spring-ws som i exemplet ovan så måste kontextfilen heta spring-ws-servlet.xml och den måste vara placerad i WEB-INF katalogen. Nedan visas ett exempel på hur spring-ws-servlet.xml kan se ut:

<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-2.5.xsd">

    <bean id="pojoCalculatorService"
          class="se.cygni.sample.spring.exporters.PojoCalculatorService" />

    <bean id="calculatorServiceEndpoint"
          class="se.cygni.sample.spring.exporters.ws.CalculatorServiceEndpoint">

        <constructor-arg ref="pojoCalculatorService" />
    </bean>

    <bean id="endpointAdapter"
          class=
           "org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter">
        <constructor-arg ref="xstreamMarshaller" />
    </bean>

    <bean id="xstreamMarshaller"
          class="org.springframework.oxm.xstream.AnnotationXStreamMarshaller">
        <property name="annotatedClasses"
            value="se.cygni.sample.spring.exporters.ws.CalculatorRequest,
                   se.cygni.sample.spring.exporters.ws.CalculatorResponse" />
    </bean>

    <bean id="annotationMapper"
          class=
      "org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping" />

    <bean id="calculatorWsdl" class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
        <property name="schema" ref="calculatorSchema" />
        <property name="portTypeName" value="Calculator" />
        <property name="locationUri" value="/spring-ws" />
    </bean>

    <bean id="calculatorSchema" class="org.springframework.xml.xsd.SimpleXsdSchema">
        <property name="xsd" value="classpath:schemas/calculator.xsd" />
    </bean>
</beans>

De bönor som deklarerats är:

• pojoCalculatorService – Den faktiska POJO det vill säga den konkreta implementationen av CalculatorService.
• calculatorServiceEndpoint – Endpoint är den klass som tar emot det faktiska webbtjänstanropet. Komponenten MessageDispatcher kommer att vidarebefordra anrop till denna endpoint som sedan typiskt vidarebefordrar till en POJO.
• endpointAdapter – Generell springklass för att hantera marshalling/unmarshalling. Den unmarshaller som används är den konfigurerade xstreamMarshaller.
• xstreamMarshaller – Den unmarshaller/marshaller som används för XStream-hanteringen.
• annotationMapper – Hanterar mappningen mellan XML-taggar och javametoder via @PayloadRoot-annoteringar som visats ovan.
• calculatorWsdl – Komponent som genererar en WSDL-fil baserat på ett vanligt schema.
• calculatorSchema – Komponent som håller en referens till ett XML-schema och kan konfigureras till WSDL-komponenten.

För att exponera en webbtjänst krävs alltså följande:

• Ett XML-schema.
• En endpoint som typiskt delegerar vidare till en POJO (i ovanstående fall delegeras alla anrop till POJO:n för CalculatorService). Endpointen kan skapas genom att använda annoteringarna @Endpoint och @PayloadRoot.
• OXM – Mappning mellan XML och Java via Springs OXM-stöd. Observera att genom att implementera gränssnitten Marshaller/Unmarshaller kan egna mappningsklasser skapas.
• Deklaration i web.xml för MessageDispatcherServlet.
• Applikationskontext för hantering av exempelvis annoteringsmappers, WSDL och liknande.

Anropa webbtjänster

Ett enkelt sätt att anropa eller testa en webbtjänst är att använda gratisprogrammet soapUI. Detta program kan automatiskt utifrån en WSDL-fil skapa olika requests och sedan anropa den exponerade tjänsten. Dessutom kan programmet användas till att bygga upp testfall som liknar enhetstester.

Om man vill anropa en webbtjänst rent programmatiskt erbjuder Spring stöd för detta genom klassen WebServiceTemplate. Denna klass bygger som så många andra klasser i Spring på templatingmönstret som tidigare nämnts i inlägget om Spring JDBC. För att anropa en webbtjänst används typiskt också OXM det vill säga mappning mellan XML och Java. WebServiceTemplate kan konfigureras med Marshaller/Unmarshaller-objekt men erbjuder även stöd att anropa webbtjänster direkt med XML via användning av XML-objekt av typen javax.xml.transform.Source. Några metoder värda att nämna är:

• sendSourceAndReceiveToResult – Metod för att sända ett objekt av typen javax.xml.transform.Source och spara returvärde i ett objekt av typen javax.xml.transform.Result. Detta innebär att du som applikationsutvecklare själv måste producera den XML som ska skickas via Source-objektet.
• marshalSendAndReceive – Metod för att hantera objektserialisering via Marshaller/Unmarshallers. Detta är det sätt som rekommenderas för att XML-hanteringen helt enkelt kan abstraheras bort via Spring OXM.

Springklassen WebServiceGatewaySupport är en stödklass som kan användas som basklass för de klasser som behöver använda webbtjänster. Den innehåller metoder för att konfigurera in en WebServiceTemplate och flera stödmetoder för att sända meddelanden via WebServiceTemplate.

Sammanfattning

Webbtjänster som baseras på SOAP är i grund och botten XML/HTTP. XML är ett relativt "pratigt" format så denna typ webbtjänster kanske inte alltid är det bästa alternativet. Det kanske är smidigare att använda exempelvis Hessian eller liknande som diskuterats tidigare i inlägget om Distribuerade tjänster via Spring.

För att exportera en tjänst som en webbtjänst via Spring krävs en rad åtgärder. Först och främst måste ett XML-schema tas fram eftersom Spring endast stöder metoden Contract First. Sedan måste en så kallad endpoint skapas och konfigureras med hjälp av de mekanismer som Spring WS erbjuder. XML-innehållet måste konverteras till javaobjekt via så kallad unmarshalling och stöd för detta finns via Spring OXM.

För att anropa en tjänst krävs det betydligt färre handgrepp. Klassen WebServiceTemplate erbjuder så kallade templatingmetoder för att på olika sätt anropa webbtjänster. Det finns framför allt två sätt att använda denna template, genom att använda Source/Result från paketet javax.xml.transform eller genom att konfigurera Marshaller/Unmarshaller från Spring OXM.