Programmable Web
http://www.programmableweb.com/

各種Webサービスを検索するサービスです。「Music」や「DVD」といったキーワードで検索すると、それに関連するWebサービスを表示してくれます。また、Webサービスを使ったマッシュアップやコードを検索することも出来ます。

マッシュアップのブームは去ってしまった感がありますが、独自アプリのデータソースとしては便利に使えると思います。

I’ve got an account at Google Wave, add me if you wan’t to: mattias.wirf@googlewave.com

Ini contoh sederhana bagaimana menggunakan fitur webservice pada JavaFX. Dalam hal ini memanggil services webMethods yang biasa digunakan di perusahaan skala Enterprise. Komunikasi yang dilakukan menggunakan protokol SOAP-RPC, dan pada ada contoh dibawah ini hanya merubah karakter (case) dari inputan lowercase menjadi uppercase.

Mengenai SOAP-RPC jika ada yang belum jelas silahkan baca di wiki. Kalo tentang webMethods silahkan di gugling saja atau silahkan baca di dokumntasinya, khususnya mengenai SOAP. Tapi dalam kasus ini tidak perlu tahu banyak tentang webmethods, karena prinsipnya sama dengan webservices. Jika tidak menggunakan webMethods silahkan bisa menggunakan Axis atau server webbservices lainya, tinggal disesuiakan format envelopenya.

Pada kasus ini saya menggunakan webMethods sebagai server webservices nya. Dibawah ini adalah format envelope nya yang nanti akan dikirim ke engine SOAP-RPC yang ada di webMethods.

‘<?xml version=”1.0″ encoding=”UTF-8″?>’
‘<SOAP-ENV:Envelope’
‘ xmlns:SOAP-ENV=”http://schemas.xmlsoap.org/soap/envelope/”‘
‘ xmlns:SOAP-ENC=”http://schemas.xmlsoap.org/soap/encoding/”‘
‘ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”‘
‘ xmlns:xsd=”http://www.w3.org/2001/XMLSchema”>’
‘<SOAP-ENV:Body>’
‘<riset:getUp xmlns:riset=”http://www.webmethods.com/riset”>’
‘<input>{masukan}</input>’
‘</riset:getUp>’
‘</SOAP-ENV:Body>’
‘</SOAP-ENV:Envelope>’;

Dan dibawah ini adalah kode JavaFX lengkapnya, silahkan di coba.

/*
* Main.fx
*
* Created on Nov 3, 2009, 4:38:15 PM
*/

package invokewm;

import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.scene.text.Text;
import javafx.scene.text.Font;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.Exception;
import javafx.io.http.HttpHeader;
import javafx.io.http.HttpRequest;
import invokewm.parser.RSSPullParser;
import javafx.data.pull.Event;
import javafx.data.pull.PullParser;
import javafx.scene.control.ProgressBar;
import javafx.ext.swing.SwingTextField;
import javafx.scene.control.Button;
import javafx.scene.layout.VBox;
import javafx.scene.layout.HBox;

/**
* @author bhangun
*/

//– login akses ke webmethods
var httpHeader = HttpHeader.basicAuth(“username”, “password”);

var par:RSSPullParser;
var isi:String;
var progress:Integer;
var masukan:String;

//– hardcode format amplop yg akan dikirim ke webmethods
var amplop: String=bind ‘<?xml version=”1.0″ encoding=”UTF-8″?>’
‘<SOAP-ENV:Envelope’
‘ xmlns:SOAP-ENV=”http://schemas.xmlsoap.org/soap/envelope/”‘
‘ xmlns:SOAP-ENC=”http://schemas.xmlsoap.org/soap/encoding/”‘
‘ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”‘
‘ xmlns:xsd=”http://www.w3.org/2001/XMLSchema”>’
‘<SOAP-ENV:Body>’
‘<riset:getUp xmlns:riset=”http://www.webmethods.com/riset”>’
‘<input>{masukan}</input>’
‘</riset:getUp>’
‘</SOAP-ENV:Body>’
‘</SOAP-ENV:Envelope>’;

//– ukuran amplop yang akan dikirim
def testContentSize: Integer = amplop.getBytes().length;

//– fungsi untuk memanggil service webmethods
def panggil: HttpRequest = HttpRequest {
location: “http://localhost:5555/soap/rpc”;

method: HttpRequest.POST;

headers: [
HttpHeader {
name: HttpHeader.CONTENT_TYPE;
value: "text/xml";
},
HttpHeader {
name: HttpHeader.CONTENT_LENGTH;
value: "{testContentSize}";
},
HttpHeader {
name: HttpHeader.AUTHORIZATION;
value: "Basic";
},
HttpHeader {
name: HttpHeader.USER_AGENT;
value: "Mozilla/4.0";
},
httpHeader
];

onStarted: function() {
println(“onStarted – started performing method: {panggil.method} on location: {panggil.location}”);
}

onConnecting: function() { println(“onConnecting”) }
onDoneConnect: function() { println(“onDoneConnect”) }
onWriting: function() { println(“onWriting”) }

onOutput: function(os: java.io.OutputStream) {
try {
println(“onOutput – about to write {testContentSize} bytes to output stream”);
os.write(amplop.getBytes());
} finally {
println(“onOutput – about to close output stream.”);
os.close();
}
}

onToWrite: function(bytes: Long) { println(“onToWrite – entire content to be written: {bytes} bytes”) }
onWritten: function(bytes: Long) {

println(“onWritten – {bytes} bytes has now been written”)
}
onDoneWrite: function() { println(“doneWrite”) }
onReadingHeaders: function() { println(“onReadingHeaders”) }
onResponseCode: function(code:Integer) { println(“onResponseCode – responseCode: {code}”) }
onResponseMessage: function(msg:String) { println(“onResponseMessage – responseMessage: {msg}”) }

onResponseHeaders: function(headerNames: String[]) {
println(“onResponseHeaders – there are {headerNames.size()} response headers:”);
for (name in headerNames) {
println(“    {name}: {panggil.getResponseHeaderValue(name)}”);
}
}

onReading: function() { println(“onReading”) }

onToRead: function(bytes: Long) {
if (bytes < 0) {
println(“onToRead – Content length not specified by server; bytes: {bytes}”);
} else {
println(“onToRead – total number of content bytes to read: {bytes}”);
}
}

onRead: function(bytes: Long) {

progress =panggil.toread;

}

onInput: function(is: java.io.InputStream) {
try {
println(“onInput – bytes of content available: {is.available()}”);
def parser = PullParser {

input: is

onEvent: function(event: Event) {

//println(event.toString());
if (event.type == PullParser.START_ELEMENT) {
if(event.qname.name == “hasil” and event.level == 3) {

println(event.name);
}
}

if(event.type == PullParser.TEXT){
if(event.qname.name == “hasil” and event.level == 3) {
isi = event.text;
println(event.text);
}
}

}
}
parser.parse();
} finally {
is.close();
}
}

onException: function(ex: java.lang.Exception) {
println(“onException – exception: {ex.getClass()} {ex.getMessage()}”);
}

onDoneRead: function() { println(“onDoneRead”) }
onDone: function() { println(“onDone”) }
};

var field:SwingTextField = SwingTextField {
columns: 10
editable: true
}

//——————- GUI
Stage {
title: “Uppercase Menggunakan Service webMethods”
width: 380
height: 150
scene: Scene {
content: [
VBox {
content: [
HBox {
content: [
field,
Button {
text: "Kirim"
action: function() {
masukan=field.text;
panggil.start()
}
}

]},
VBox {
content: [ProgressBar {
progress: bind ProgressBar.computeProgress( 100, progress )
},
Text {
font : Font {
size : 20
}
x: 10
y: 50
content: bind isi;
}
]
}
]}
]
}
}

Jika berhasil di jalankan akan muncul seperti dibawah ini:

Untuk mencoba silahkan masukan kata-kata dalam huruf kecil (lowercase), karena nanti hasilnya dalam huruf besar (uppercase).

source dapat di download disini;

<a href=”http://api.ning.com/files/Lqh-Mcf*Rx7JV7mnbsQrxd8Cmazt4ldez1y5LX24xkBIZEQUAD1tCadjVfCAFmltS2e7VDRg1QgIQPNy4*XtkYYfLr3eDwZp/InvokeWM.zip”>InvokeWM.zip</a>

Muitos se deparam com um problema ao tentar executar o servidor de aplicações JBoss nas versões 4.2.x com a versão da JDK1.6.x, onde é lançado algumas exceções. Isso ocorre devido a incompatibilidade com das bibliotecas de webservices.
Para corrigir esse problema é necessário seguir os seguintes passos:

1) Copie as seguintes bibliotecas da pasta %JBOSS_HOME%\client

1. jaxb-api.jar
2. jboss-jaxrpc.jar
3. jboss-jaxws.jar
4. jboss-jaxws-ext.jar
5. jboss-saaj.jar

2) Cole as bibliotecas copiadas na pasta %JBOSS_HOME%\lib\endorsed

E pronto agora é só dar um restart no server que já estará funcionado.

Na versão do JBoss 5 as bibliotecas que deverão ser alteradas são as seguintes, segundo a edição 69 da revista Java Magazine:

1. jbossws-native-jaxrpc.jar
2. jbossws-native-jaxws.jar
3. jbossws-native-jaxws-ext.jar
4. jbossws-native-saaj.jar

* Isso é válido para as versões do JBoss compilados com JDK 1.5 que são executados utilizando JDK 1.6

Atte,
Wilson Bissi

Introduction

In the last post I had a short description on webservice security. In this post, we build a secure webservice and create a client to access it. For doing so, the same environment as in the Simple Webservice example is used. We will use Metro’s WSIT features to enable secrity for our webservice.

Creating the webservice

The steps for creating and deploying an unsecured webservice are described in this post. Follow these steps till Step 6 (we do not deploy the webservice yet). Now we need to make the webservice secure.

Generate Key Pair

In order to perform encryption and signature, the webservice and the client need a public-private key pair. The public key is wrapped inside a X509 certificate. In this example we do not use mutual certificates. The private key (or identity key) is with the webservice only. The public key (X509 certificate) is distributed to clients. What is encrypted using the public certificate, can only be decrypted using the private key and vice-versa. In this example, the private key is part of a KeyStore configured on the webservice, and the public certificate is part of a TrustStore configured on the client side.

To create a key-pair for use with this example, create a directory to keep the KeyStore and TrustStore in (call it <KEY_DIR>). Browse to this dir on command prompt and run
keytool -genkey -alias serviceKey -keypass mykeypass -keystore wsKeyStore.jks -storepass changeit -keyalg RSA -dname "CN=Tech Tips, OU=Blog, O=The Tech tips, L=DFW, ST=TX, C=US"

This creates the keystore with the private key in it. Now export the public certificate:
keytool -export -alias serviceKey -keypass mykeypass -keystore wsKeyStore.jks -storepass changeit -file publicCert.cer

and import the public certificate into a truststore:
keytool -import -alias publicCert -keystore wsTrustStore.jks -storepass changeit -file publicCert.cer

Specify Security Requirements

In order to convey their security constraints to clients, webservices can include their security specifications as part of the WSDL. This is done by making use of WS-Security Policy (WSSP) assertions. The clients who have access to the WSDL therefore know the security contract for accessing the webservice.

Instead of creating a custom way of specifying security requirements when creating a webservice, WSIT (part of metro stack) makes use of the already developed way (using WSSP assertions). In order to enable security for our webservice, all we need is a static WSDL-like definitions file which contains the desire WSSP assertions assigned to our endpoint. This file needs to have a special name ‘wsit-<fully qualified implementation class name>.xml‘.

In MetroWebserviceSample eclipse project’s WEB-INF directory, create a file named ‘wsit-test.metro.sample.TestService.xml‘. The contents of this file should be as follows:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.2-hudson-182-RC1. -->
<definitions targetNamespace="http://sample.metro.test/"
 xmlns:tns="http://sample.metro.test/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns="http://schemas.xmlsoap.org/wsdl/"
 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
 xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
 xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy"
 xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy">
 
   <wsp:Policy wsu:Id="TestService_Security_Policy">
  <wsp:ExactlyOne>
   <wsp:All>   
    <sp:SymmetricBinding >
     <wsp:Policy>
      <sp:ProtectionToken>
       <wsp:Policy>
        <sp:X509Token sp:IncludeToken="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy/IncludeToken/Never">
         <wsp:Policy>
          <sp:WssX509V3Token10/>
          <sp:RequireDerivedKeys/>
          <sp:RequireIssuerSerialReference/>
         </wsp:Policy>
        </sp:X509Token>
       </wsp:Policy>
      </sp:ProtectionToken>
      
      <sp:AlgorithmSuite>      
       <wsp:Policy>
        <sp:Basic128/>
       </wsp:Policy>       
      </sp:AlgorithmSuite>
      
      <sp:Layout>      
       <wsp:Policy>
        <sp:Strict/>
       </wsp:Policy>       
      </sp:Layout> 
      <sp:IncludeTimestamp/>  
      <sp:EncryptBeforeSigning/>   
     </wsp:Policy>
    </sp:SymmetricBinding>
    <sp:Wss11>
            <wsp:Policy>
              <sp:MustSupportRefIssuerSerial/>
            </wsp:Policy>
          </sp:Wss11>
             <sc:KeyStore wspp:visibility="private"
              xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy"
              xmlns:sc="http://schemas.sun.com/2006/03/wss/server"
              location="<KEY_DIR>\wsKeyStore.jks"
              type="JKS" keypass="mykeypass"
              alias="serviceKey"
              storepass="changeit">
             </sc:KeyStore>
   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>
 
 <wsp:Policy wsu:Id="TestService_Encryption_policy">
  <wsp:ExactlyOne>
   <wsp:All>    
    <sp:EncryptedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
     <sp:Body />
    </sp:EncryptedParts>      
   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>
 <wsp:Policy wsu:Id="TestService_Signature_policy">
  <wsp:ExactlyOne>
   <wsp:All>
    <sp:SignedParts xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy">
     <sp:Body />
    </sp:SignedParts>
   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>
 
 
<portType name="TestService">
  </portType>
 
  <binding name="TestServicePortBinding" type="tns:TestService">
   <wsp:PolicyReference URI="#TestService_Security_Policy"></wsp:PolicyReference>
   <wsp:PolicyReference URI="#TestService_Encryption_policy"></wsp:PolicyReference>
   <wsp:PolicyReference URI="#TestService_Signature_policy"></wsp:PolicyReference>
  </binding>
 
  <service name="TestServiceService">
     <!-- Uncomment this section if above configured security is to be enabled -->
     <!-- -->
  
<port name="TestServicePort" binding="tns:TestServicePortBinding">
   </port>
  </service>
</definitions>

The above file has the minimum content required for this configuration (in other situations we can have the complete WSDL, plus the policy declarations and references). It enforces encryption of the SOAP body element followed by signing the encrypted body (EncryptBeforeSigning) for all messages (requests and responses). For the purpose of encryption and signing derived keys based on an X509 token are used. The location of the token is specified using Metro specific element.

Deploy the Webservice

Note that the element describing the location of X509 token (keystore etc) is not visible in the online WSDL.

Create the Client

In order to create a POJO client which does not run inside a container, the Metro libraries will be needed. As indicated in this post, download Metro and put the expand the contents (call this directory <METRO_HOME>).  For convinience the directory <METRO_HOME>/bin can be added to the environment variable Path, so that the tools wsgen and wsimport can be used without qualified location. For JDK 6 onwards, these tools are part of the jdk.

Create a directory for the client code <CLIENT_HOME>. This can as well be an eclipse Java project. However, the instructions here are for running the client without using eclipse.

While the webservice is running on Tomcat, on the command prompt run:
wsimport -d <CLIENT_HOME> -s <CLIENT_HOME> -p test.metro.sample.client http://localhost:8080/MetroWebserviceSample/test?wsdl
This will create the classes needed by the client, under the package structure test.metro.sample.client. Note that the classes are already compiled, so we will not recompile them.

In the directory <CLIENT_HOME>/test/metro, create a directory named client. Create a file TestServiceClient.java in this directory (so the package for this class is test.metro.client). The contents of TestServiceClient.java should be:

package test.metro.client;

import test.metro.sample.client.TestService;
import test.metro.sample.client.TestServiceService;

public class TestServiceClient {

 private String defaultGreeter = "TheTechTips";
 /**
  * @param args
  */
 public static void main(String[] args) {
  
  TestServiceClient client = new TestServiceClient();
  TestService service = new TestServiceService().getPort(TestService.class);
  System.out.println("Greeatings are...");
  if (args.length == 0) {
   System.out.println(service.greet(client.defaultGreeter));
  } else {
   for (String greeter : args) {
    System.out.println(service.greet(greeter));
   }
  }
 }

}

To compile the above class, browse to <CLIENT_HOME> directory on command prompt (for convinience) and run:
javac -cp %CLASSPATH%;.;<METRO_HOME>/lib/webservices-api.jar test/metro/client/TestServiceClient.java

Client Security Configuration

Similar to the wsdl-like file we created for securing the webservice, we need to specify where the client can find the security certificate to send proper requests to the service. The client config file should be named <service>Service.xml and placed in the META-INF directory. In addition, another xml file called wsit-client.xml is to be pesent in META-INF. The latter file imports the former.

Create a META-INF directory under <CLIENT_HOME>. Put files TestServiceService.xml and wsit-client.xml in the META-INF directory with following contents.

TestServiceService.xml

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- Generated by JAX-WS RI at http://jax-ws.dev.java.net. RI's version is JAX-WS RI 2.1.2-hudson-182-RC1. -->
<definitions targetNamespace="http://sample.metro.test/"
 xmlns:tns="http://sample.metro.test/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns="http://schemas.xmlsoap.org/wsdl/"
 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
 xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
 xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy"
 xmlns:sp="http://schemas.xmlsoap.org/ws/2005/07/securitypolicy"
 xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy">
 
 <wsp:Policy xmlns:sc="http://schemas.sun.com/2006/03/wss/client"
  xmlns:wspp="http://java.sun.com/xml/ns/wsit/policy"
  wsu:Id="TestService_Security_Client_Policy">
  <wsp:ExactlyOne>
   <wsp:All>
      <sc:TrustStore wspp:visibility="private" location=
        "<KEY_DIR>\wsTrustStore.jks"
        storepass="changeit"
        peeralias="publicCert"/>

   </wsp:All>
  </wsp:ExactlyOne>
 </wsp:Policy>

 
<portType name="TestService">
  </portType>
 
  <binding name="TestServicePortBinding" type="tns:TestService">
   <wsp:PolicyReference URI="#TestService_Security_Client_Policy"></wsp:PolicyReference>
  </binding>
 
  <service name="TestServiceService">
     <!-- Uncomment this section if above configured security is to be enabled -->
     <!-- -->
  
<port name="TestServicePort" binding="tns:TestServicePortBinding">
   </port>
  </service>
</definitions>

wsit-client.xml

<?xml version="1.0" encoding="UTF-8"?>
 <definitions
 xmlns="http://schemas.xmlsoap.org/wsdl/"
 xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
 xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
name="mainclientconfig">
    <import location="TestServiceService.xml" namespace="http://sample.metro.test/"/>
</definitions>

Run client

To run the client, execute (while command prompt is in <CLIENT_HOME> directory)
java -cp %CLASSPATH%;.;<METRO_HOME>/lib/webservices-api.jar;<METRO_HOME>/lib/webservices-rt.jar test.metro.client.TestServiceClient

The output will be something like
Oct 2, 2009 11:14:43 AM [com.sun.xml.ws.policy.jaxws.PolicyConfigParser] parseModel
INFO: WSP1049: Loaded WSIT configuration from file: file:<CLIENT_HOME>/META-INF/wsit-client.xml
Greeatings are...
Hello TheTechTips!

I always liked the concept behind WebServices. Having a single place to store a bunch of complex but commonly used functions is a great way to decrease complexity of other programs that all sit on the same network. If you’re like me and tend to do a lot of intranet applications, a web service can prevent a lot of duplicate code.

My only real problem with WebServices was having to use SOAP. Adding a Web Reference to a project wasn’t that big of a deal but if you ever wanted to just call a function real quick, say from a script file (yes, I do VBScript occasionally… ick) then it isn’t quite as I’d prefer. You end up spending more time making sure your XML is well formed and less time on the logic inside your quick script.

MVC helps get around that problem by allowing you to perform normal HTTP calls and plug all your arguments into the query string or the body of the request – something much easier to do. The problem, however, is that you end up losing the convenience of using a WebService with other applications.

A Simple Solution

The idea here is to create a controller that acts as a wrapper to a WebService. By doing this we can override a few methods on our Controller that use reflection to invoke the matching method on the WebService. Also, because the Controller is still a unique class, we can still attach any number of Actions to it as we normally would. Below is some code that I wrote the other day. It isn’t battle tested so if you use it be sure to verify it does everything that you need it to do.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using System.Web.Mvc;
using System.Reflection;
using System.Xml.Serialization;
using System.Xml.Linq;
using System.IO;

namespace Interface.Controllers {

    /// <summary>
    /// Abstract wrapper that handles calling WebService methods on behalf of a controller
    /// </summary
    public abstract class WebServiceControllerWrapper<T> : Controller where T : WebService {

        #region Constructors

        /// <summary>
        /// Creates a new Controller Wrapper for a WebService
        /// </summary>
        public WebServiceControllerWrapper() {
            this.Service = Activator.CreateInstance<T>();
        }

        #endregion

        #region Properties

        //The service that is being used for this call
        private T Service { get; set; }

        #endregion

        #region Overriding Methods

        //finds the correct method for the WebService method
        protected override void HandleUnknownAction(string actionName) {

            //find if the method exists
            MethodInfo method = this.Service
                .GetType()
                .GetMethods()
                .Where(found =>
                    found.IsPublic &&
                    found.Name.Equals(actionName, StringComparison.OrdinalIgnoreCase) &&
                    found.GetCustomAttributes(typeof(WebMethodAttribute), true).Count() > 0
                    )
                    .FirstOrDefault();

            //if no method was found, just give up
            if (method == null) { return; }

            //check if all the arguments were found
            List<object> arguments = new List<object>();
            ParameterInfo[] parameters = method.GetParameters();
            foreach (ParameterInfo param in parameters) {

                //check if this argument was found
                object arg = this.ValueProvider[param.Name].ConvertTo(param.ParameterType);
                arguments.Add(arg);
            }

            //with the arguments try and call the result
            object result = method.Invoke(this.Service, arguments.ToArray());

            //if there is a return value, serialize it and write it
            this.Response.ContentType = "text/xml";
            if (method.ReturnType != null) {

                //if this is an XElement of some kind, just use it as is
                if (result is XObject) {

                    //write the string
                    using (StreamWriter writer = new StreamWriter(this.Response.OutputStream)) {
                        writer.Write(result.ToString());
                    }

                }
                else {

                    //try and serialize it
                    XmlSerializer serialize = new XmlSerializer(result.GetType());
                    serialize.Serialize(this.Response.OutputStream, result);
                }

            }

        }

        #endregion

    }

}

The idea here is to inherit this class instead of the standard Controller class and provide the name of the WebService we want to wrap around as our Generic argument. For example…

//that's about it - actions are mapped automatically to the correct method on the webservice
public class AccountController : WebServiceControllerWrapper<AccountWebService> { }

By doing this, when our controller receives an Action, is checks the WebService instance for the same method and then tries to call the method with the arguments it finds as part of the request!

And that’s it! A quick and simple way to map incoming actions to a matching method on a Web Service!

The Return Type

I’m not sure the best way to handle the return type at this time. It seems to me that the XmlSerializer should be sufficient for object with the exception of Xml which should probably just be written out as a string. If you have a suggestion on a better way to respond to incoming requests, please let me know.

Remember: This is just some quick and dirty code – This needs some more polish and exception handling before I’d use it in a real project, but at least it might help you get going in the right direction.

Steps to add a Web service 2.0 in SharePoint 2007

Setting up a Website, a Blog and some accounts on different Webservices (which I just did) is really not that much fun. Once you thought of a good name, you can almost be sure that it is already taken on at least one of the services that you wanted to use. So I just spend a lot of time switching from site to site (Thanks for tabbed browsing – oh mighty Webrowser Developer) and checking available usernames. But for now I’m done and I will try to recuperate.

Note: This is for SharePoint environment not configured for anonymous users, usually intranet environment.

Scenario: I have had few request coming where users ask for an Anonymous feature for discussion board or custom list. Few solutions I came across were all around custom Input form and restrictive access to users and hidden views. All of the above seems doable, but I doubt all scenarios are covered for instance RSS Feeds and Web service calls.
OOB SharePoint has a functionality for Survey list which "Show user names in survey results?  " which basically in OM is SPlist.ShowUser = boolean value which is available for all SharePoint list but does it function as expected, Answer is yes.

I decided update my previous Client Tool, Show-Hide fields, which uses web services to Hide List Fields on different Form Pages, it made sense to add additional functionality of Masking User names as well.

It works exactly the same but has an additional Check box for Masking User Information thus.  On how to use the tool check the link here http://spyralout.com/releasestoolscode/moss-showhide-fields-using-web-services/

Below are screenshots for Masking User Info

List

Tool :

Click Update and Result

Download Link :

http://spiralout.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=22305

Hi,

Here the placement for J2ee developer

• Our client are looking for a J2ee developer with 4-7 years experience

JOB DESCRIPTION :

• Knowledge of JSP/Servlets a must.
• Experience with Webservices, XML, AJAX highly desirable.
• Knowledge of MVC frameworks a must – STRUTS, SPRING(highly desired).
• Strong OO concepts, Large project experience preferred.
• Good communication skills required.
• Good schooling preferably city bred person.

Would you be interested ?

Please send us your latest updated profile with contact nos.current & expected salary details and joining time required to radha@kbsconsultants.com

You may also suggest this opening to your friends who may be interested.

Further Information:

KBS Consultants

Flat H,Kulothungan Apts,

No, 5 Natesan Road

Ashoknagar,

Chennai 600 083.India

Phone: +91-44 2489 5341 / 2371 9622

Visit Our Sites:

International jobs: http://www.jobsearchworld.com/
SAP ERP Jobs : http://www.jobsvista.com/
Core Engineering Jobs : http://www.gotachance.com/
Technology Jobs : http://www.kbsconsultants.com/
India Jobs : http://www.kbsconsultants.net.in/
http://www.kbsconsultants.org.in/

When considering securing web-service invocations, there are many levels of security that cane be applied. The outermost levels can be viwed as

1. Protocol level security: The security mechanisms used for regular request/response for the particular protocol. For example, Basic Authentication and SSL certificates for HTTP. These mechanisms only ensure that the messages are secured till they reach the protocol (say HTTP) destination. After that, when the actual SOAP message is un secured till it reaches the actual Web service endpoint.
2. SOAP message security: In this case the messages are to be secured all the way to the endpoint beyond the protocol level. This is specified by the WS-Security specifications.

WS-Security Specification

The WS-Security specification 1.0 was released in 2002. The next version 1.1 was released in 2006. It specifies how to enhance SOAP messages to secure the information exchange.

From the WS-Security specification (http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wss#overview):

“WS-Security describes enhancements to SOAP messaging to provide quality of protection through message integrity, message confidentiality, and single message authentication. These mechanisms can be used to accommodate a wide variety of security models and encryption technologies.”

The WS-Security spec provides SOAP extensions that can be used when building secure web-services. There are three main aspects of security:

1. Message AuthenticationWS-Security provides a way of associating security tokens with SOAP messages. These tokens (like Basic Authentication or SSL certificates for HTTP) can be used to identify the sender of the message. The specification does not require use of any particular token. Two commonly used tokens are Username tokens and X509 tokens. Other tokens like Kerberos tokens can also be used. These tokens can be included directly in the SOAP message header, or an indirect reference to the token can be sent using digital signature or encryption.
2. Message Integrity Message integrity ensures that the message was not tampered with on its way from the sender to the receiver. WS-Security provides a way to include XML digital signatures in the SOAP message header to help verify integrity. Exactly what parts of the message are signed or what digest/algorithms are used is left to be decided by the web-service provider.
3. Message ConfidentialityMessage confidentiality means that on the wire, the message should not be readable. WS-Security specifies how the full message or parts of the message can be encrypted and sent so that they are unreadable to attackers. This will use XML encryption and the encryption related information is exchanged in the SOAP header. Either the whole message can be encrypted (like HTTPS transport encryption), or parts of the message are encrypted. Again, the encryption algorithms to be used, the way of exchanging keys (or tokens) is to be decided by the web-service provider. 

In the next post, I am going to create a secure web services using JAXWS implementation Metro and create client for the service. Explaining the various types of security in more detail.

Las Jornadas Científico-Técnicas en Servicios Web y SOA se han configurado como punto de encuentro nacional de referencia sobre el uso y la adopción de las tecnologías y plataformas que proporcionan los servicios Web y las Arquitecturas Orientadas a Servicios. Las jornadas han conseguido mantener una creciente y equilibrada participación de los profesionales de la Industria, la Administración Pública e investigadores más relevantes del área. La V edición de estas jornadas tendrá lugar en Madrid, entre el 30 de Septiembre y el 1 de Octubre de 2009. (Acceso a la página oficial clickando la imagen)

El otro día, hablando con la contable de la empresa, me comentó la posibilidad de añadir en las aplicaciones la validación de unos “NIF” un poco especiales. Digo un poco especiales porque en principio no se trata de un número de identificación sino más bien es un registro de aquellas empresas “legalizadas” para poder trabajar con IVAs a nivel intracomunitario. Digo legalizada entre comillas puesto que desconozco totalmente si el medio para entrar en esa base de datos se realiza automáticamente al trabajar con empresas intracomunitarias o hace falta algún tipo de registro especial.

Bueno, el caso es que mala validación podemos crear si el origen es una base de datos, así que no me queda más remedio que empezar a buscar y encuentro lo que andaba buscando en lo que creo que es la AEAT Europea: http://ec.europa.eu/taxation_customs/vies/lang.do?fromWhichPage=vieshome&selectedLanguage=ES.

Dentro de los servicios informáticos con los que he trabajado, quizás éste sea uno de los más originales. De hecho, no existe una base de datos centralizada. Se trata de bases de datos con un ámbito del país local que va “replicando” con el resto de países (igual me he pasado al escribir “replicando”). Por otro lado, resulta que no todos los países atienden las 24 horas del día (igual los ordenadores se van a tomar un café): http://ec.europa.eu/taxation_customs/vies/viesspec.do

Al fin y al cabo, somos programadores y nuestros profes siempre nos han enseñado que debemos desglosar un problema gordo en problemas más pequeños para poder afrontarlos con mayor destreza, así que eso voy a hacer en estos momentos. Imagino que al final pasará como ha ocurrido con otra entrada en el blog (Validar NIF, NIE, CIF ), que empezó con una pequeña validación y se ha ido ampliando y mejorando con el tiempo. Así, el objetivo inicial será el de comprobar si el NIF introducido es correcto o no, siempre según el servicio de Fiscalidad y Unión Aduanera.

La primera me la doy en la frente. Resulta que para solicitar la validez de un Número de IVA, necesitamos el código del país y… ¿cómo no?, no encuentro ningún servicio que devuelva los países aceptados, así que hay que hacer una lectura del código HTML de la página para poder tenerlos todos. Para poder trabajar con los países y poder ponerlos como origen de datos de los controles se me ocurre hacer lo más sencillo, una clase List<T>.

Paises

using System;
using System.Collections.Generic;

namespace ValidacionVies
{
    class Pais : IComparable
    {
        public string CodigoPais { get; set; }
        public string NombrePais { get; set; }

        public Pais(string codigoPais, string pais)
        {
            this.CodigoPais = codigoPais;
            this.NombrePais  = pais;
        }

        // Se implementa la interfaz IComparable para poder ordenar por el país 
        public int CompareTo(object obj)
        {
            return this.NombrePais.CompareTo(((Pais)obj).NombrePais);
        }
    }

    class Paises : List<Pais>
    {
        public Paises()
        {
            this.Add(new Pais("AT", "Austria"));
            this.Add(new Pais("BE", "Bélgica"));
            this.Add(new Pais("BG", "Bulgaria"));
            this.Add(new Pais("CY", "Chipre"));
            this.Add(new Pais("CZ", "Chequia"));
            this.Add(new Pais("DE", "Alemania"));
            this.Add(new Pais("DK", "Dinamarca"));
            this.Add(new Pais("EE", "Estonia"));
            this.Add(new Pais("EL", "Grecia"));
            this.Add(new Pais("ES", "España"));
            this.Add(new Pais("FI", "Finlandia"));
            this.Add(new Pais("FR", "Francia"));
            this.Add(new Pais("GB", "Reino Unido"));
            this.Add(new Pais("HU", "Hungría"));
            this.Add(new Pais("IE", "Irlanda"));
            this.Add(new Pais("IT", "Italia"));
            this.Add(new Pais("LT", "Lituania"));
            this.Add(new Pais("LU", "Luxemburgo"));
            this.Add(new Pais("LV", "Letonia"));
            this.Add(new Pais("MT", "Malta"));
            this.Add(new Pais("NL", "Países Bajos"));
            this.Add(new Pais("PL", "Polonia"));
            this.Add(new Pais("PT", "Portugal"));
            this.Add(new Pais("RO", "Rumania"));
            this.Add(new Pais("SE", "Suecia"));
            this.Add(new Pais("SI", "Eslovenia"));
            this.Add(new Pais("SK", "Eslovaquia"));

            this.Sort();
        }
    }

}

El problema lo encontraré el día que haya que hacer alguna modificación, así que tomo nota de la mejora que podría hacerse creando un XML o un simple TXT para poder almacenar los países.

Una vez tenemos los países, conociendo los resultados que nos devuelve el WebService, es cuestión de empezar a preparar un entorno de interacción con el usuario:

- <element name="checkVatResponse">
- <complexType>
- <sequence>
  <element name="countryCode" type="xsd:string" />
  <element name="vatNumber" type="xsd:string" />
  <element name="requestDate" type="xsd:date" />
  <element name="valid" type="xsd:boolean" />
  <element name="name" type="xsd:string" />
  <element name="address" type="xsd:string" />
  </sequence>
  </complexType>
  </element>

Como que me hace gracia jugar un poco con las llamadas asíncronas al Web Service, opto por crear una aplicación WinForms que me permita realizar las primeras pruebas, así, me sale algo así como lo siguiente (ya dice mi jefe que lo mío no es el diseño):

De hecho, en el formulario no hay nada raro, un combo en el que se cargan los países (cboPaises), un textBox en el que deberá teclearse el número a validar (txtVatNumber) y los textBox de resultado (rstXXXX).

Al lío:

Código del formulario

using System;
using System.Windows.Forms;
using ValidacionVies.eu.europa.ec;

namespace ValidacionVies
{
    public partial class Form1 : Form
    {
        checkVatService cvs;

        public Form1()
        {
            InitializeComponent();

            // Asignación de eventos
            this.Load += new EventHandler(Form1_Load);
            this.cmdValida.Click += new EventHandler(cmdValida_Click);
        }

        void Form1_Load(object sender, EventArgs e)
        {
            lblProgreso.Text = string.Empty;

            // Carga de paises y asignación al combo
            Paises paises = new Paises();
            cboPaises.DataSource = paises;
            cboPaises.DisplayMember = "NombrePais";
            cboPaises.ValueMember = "CodigoPais";
            cboPaises.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
            cboPaises.AutoCompleteSource = AutoCompleteSource.ListItems;

            // Asignación del evento IndexChanged para el combo.
            cboPaises.SelectedIndexChanged += new EventHandler(cboPaises_SelectedIndexChanged);
            txtCountryCode.Text = cboPaises.SelectedValue.ToString();
        }

        void cboPaises_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox cbo = (ComboBox)sender;
            txtCountryCode.Text = cbo.SelectedValue.ToString();
        }

        void cmdValida_Click(object sender, EventArgs e)
        {
            lblProgreso.Text = "Consultando";

            // Llamada asíncrona al WebService
            cvs = new checkVatService();
            cvs.checkVatCompleted += new checkVatCompletedEventHandler(cvs_checkVatCompleted);
            cvs.checkVatAsync(txtCountryCode.Text, txtVatNumber.Text);
        }

        void cvs_checkVatCompleted(object sender, checkVatCompletedEventArgs e)
        {
            // Respuesta de la llamada asíncrona al WebService
            try
            {
                if (!e.Cancelled)
                {
                    lblProgreso.Text = string.Empty;
                    rstAddress.Text = e.address;
                    rstCountryCode.Text = e.countryCode;
                    rstName.Text = e.name;
                    rstResult.Text = e.Result.ToShortDateString();
                    rstCorrecto.Text = e.valid ? "Sí" : "No";
                }
                else
                {
                    lblProgreso.Text = string.Empty;
                    rstAddress.Text = string.Empty;
                    rstCountryCode.Text = string.Empty;
                    rstName.Text = string.Empty;
                    rstResult.Text = string.Empty;
                    rstCorrecto.Text = string.Empty;
                }
            }
            catch (System.Reflection.TargetInvocationException ex)
            {
                lblProgreso.Text = ex.Message;
            }
            catch (Exception ex)
            {
                lblProgreso.Text = "Se ha producido un error " + ex.GetType().ToString();

            }
        }
    }
}

Ya está. ¡Qué bonitas se ven las cosas cuando están acabadas!

Por cierto, se si alguien tiene interés, puede descargar el proyecto en VisualStudio2008: Descargar

In this tip, we will go over the steps for creating a webservice using the Metro stack that can be deployed into any web container. This example will deploy it to Tomcat.

System Environment

1. JRE 1.5.0_10
2. Tomcat 5.5.28
3. Eclipse 3.2

Introduction

JAXWS stands for Java API for XML Web Services. It is the new web services specification for creating and consuming web services in J2EE. It makes use of annotations for creating web services and their clients.

JAXB stands for Java API for XML Binding. It is the new xml binding specification for Java to XML and XML to Java binding (again makes use of annotations). The bindings can also be specified using xml files.

Metro is Sun’s web services stack also packaged with the Glassfish server. It includes WSIT (Web Service Interoperability Technologies) in addition to JAXWS-RI and JAXB-RI (Sun’s reference implementations of the specs).

Creating the Service

Before starting, download Metro and extract the libs. Lets create a simple servlet endpoint using a POJO now.

1. Create a Dynamic Web Project in Eclipse (lets name it MetroWebserviceSample).
2. Copy the Metro download’s webservices-api.jar, webservices-rt.jar and webservices-extra.jar to WEB-INF/lib.
3. Under the java source directory (the ’src’ directory), create a new package named test.metro.sample.
4. Create a class TestService.java under test.metro.sample package. 

   
   package test.metro.sample;
   
   import javax.jws.WebService;
   
   @WebService
   public class TestService {
    public String greet (String name) {
     if (name != null && name.trim().length() > 0) {
      return "Hello " + name + "!";
     } else {
      return "No one to greet.";
     }
    }
   }
   

5. Configure WSServlet and WSServletContextListener to web.xml. This servlet should be set up to load on start-up

   
   <?xml version="1.0" encoding="UTF-8"?>
   <web-app id="WebApp_ID" version="2.4" xmlns="<a href="http://java.sun.com/xml/ns/j2ee">http://java.sun.com/xml/ns/j2ee</a>" xmlns:xsi="<a href="http://www.w3.org/2001/XMLSchema-instance">http://www.w3.org/2001/XMLSchema-instance</a>" xsi:schemaLocation="<a href="http://java.sun.com/xml/ns/j2ee">http://java.sun.com/xml/ns/j2ee</a> <a href="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd</a>">
    <display-name>MetroWebserviceSample</display-name>
    
   	<listener>
   	<listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-class>
    </listener>
    <servlet>
       <description>JAX-WS + WSIT endpoint - wsit-enabled-fromjava</description>
       <display-name>wsit-enabled-fromjava</display-name>
       <servlet-name>TestWebService</servlet-name>
       <servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
       <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
       <servlet-name>TestWebService</servlet-name>
       <url-pattern>/test</url-pattern>
    </servlet-mapping>
   </web-app>
   

6. The WSServlet looks at a config file sun-jaxws.xml to deploy the webservices specified in this config file. Create the following sun-jaxws.xml and put it in the WEB-INF directory

   
   <?xml version="1.0" encoding="UTF-8"?> 
   
   <endpoints xmlns='http://java.sun.com/xml/ns/jax-ws/ri/runtime' version='2.0'>
       <endpoint name='TestService'
           implementation='test.metro.sample.TestService'
           url-pattern='/test'/>
   </endpoints>
   

7. Right click the eclipse project MetroWebserviceSample and export to a .war  file (MetroWebserviceSample.war).
8. Copy MetroWebserviceSample.war to <TOMCAT_HOME>/webapps and start the Tomcat server.
9. The WSDL can be looked up at http://localhost:8080/MetroWebserviceSample/test?wsdl.

SOAP-UI can be used to quickly test that the webservice is working. Eclipse also has a tool called, ‘Web Services Explorer’ which can be used to quickly test webservices. The steps for creating a Java client will be included later.

T3