I believe that many of U thinking it’s a joke. Don’t U? If yes. I agree with ur own opinion because nothing free in the business because it’s related to cost. But maybe we have a different perception only about that. And the real answer is Yes, We promoting your business for free to global world. Click this link to read more about We Promote Your Business to Global World for Free!

Windows Communication Foundation (WCF) is the latest service execution environment from Microsoft that enables you to seamlessly expose CLR types as services and consume services as CLR types. WCF is a unified programming model that combines the best of breed features from XML Web Services, .NET Remoting, MSMQ, and COM+ into an integrated platform that is completely based on a set of open industry standards. Because of that, WCF provides interoperability between services, and it promotes productivity, including the essential off-the-shelf plumbing required by almost any application. This article series will discuss the essential building blocks of WCF describing the concepts and architecture of WCF. The first installment focuses on the basics of WCF by introducing you to the WCF through simple examples and discussion. The future installments will go into more specific features of WCF such as transactions, security, instance management techniques and so on.

Prerequisites

• Visual Studio 2005 Professional Edition
• Microsoft Pre-Release Software Microsoft .NET Framework 3.0 – Release Candidate
• Microsoft Visual Studio Code Name “Orcas” Community Technology Preview – Development Tools for .NET Framework 3.0
• Microsoft® Windows® Software Development Kit for RC 1

Introduction to WCF

WCF is a set of .NET Framework-based technologies for building and running services. WCF is the next step in the evolutionary path that started with COM, COM+, and MSMQ, and continues through .NET Remoting, ASMX, System.Messaging, and .NET Enterprise Services. WCF combines these technologies and offers a unified programming model for developing services using any CLR-compliant language. The below screenshot provides a conceptual representation of the different components that make up the WCF architecture.

As you can see from the above, the major subsystems of WCF are the Service model, the connector framework, hosting environments, and system and messaging services. The WCF service model makes service-oriented development explicit and simple from any CLR-targeted language. You use declarative attributes to mark up which aspects of their type should form the external contract of a service. The service model supports different types of contracts including service contracts, operation contracts and so on, which will be discussed later in this article. The service model also provides instance and context management for a service. WCF routes incoming messages to instances of user-defined service types. As a developer, you can leverage the declarative attributes to control how instances are associated with incoming messages as well as how the session management features of Indigo routes multiple messages to a common session object. Finally, the service model provides declarative behaviors that automate security and reliability. All of the above functionalities of service model are contained in the System.ServiceModel namespace.

Key Components of a WCF Service

A WCF service program contains four elements:

• Contract definitions – A service must have at least one service contract, and it might contain multiple service contracts, data contracts, or message contracts
• Endpoint definitions – One or more address-binding-contract endpoints must be declared
• Hosting code – Some code is needed to create and start the service
• Implementation code – The service contracts in a service need code to implement their service operations

Let us look at each of these components in detail.

Understanding Contracts

Contracts are one of the fundamental concepts in WCF. They allow clients and services to have a common understanding of available operations, data structures, and message structures while remaining loosely coupled and platform independent. WCF includes four kinds of contracts:

• Service contract – Describes the operations a service can perform. A service contract is defined with the [ServiceContract] and [OperationContract] attributes. Binding requirements can be specified for the contract with a [BindingRequirements] attribute.
• Data contract – Describes a data structure. A data contract is defined primarily with the [DataContract] and [DataMember] attributes.
• Message contract – Defines what goes where in a message. A message contract is defined primarily with the [MessageContract], [MessageBodyMember], and [MessageHeader] attributes.
• Fault contract – Allows you to document the errors that WCF code is likely to produce. A fault contract is specified along with the operation contract at the time of declaring the method. A fault contract is defined using the [FaultContract] attribute.

All four types of contracts translate between Microsoft .NET types used internally and the XML representations shared externally:

• A service contract converts between the CLR and Web Services Description Language (WSDL)
• A data contract converts between the CLR and XML Schema Definition (XSD)
• A message contract converts between the CLR and Simple Object Access Protocol (SOAP)
• A fault contract converts the CLR exceptions and to SOAP faults

You define contracts by using familiar object-oriented constructs: interfaces and classes. By decorating interfaces and classes with attributes, you create contracts.

Understanding Service Contracts

A service contract describes the operations a service can perform. A service must have at least one service contract, and it can have more than one. You can think of a service contract as follows:

• It describes the client-callable operations (functions) exposed by the service
• It maps the interface and methods of your service to a platform-independent description
• It describes message exchange patterns that the service can have with another party. Some service operations might be one-way; others might require a request-reply pattern
• It is analogous to the <portType> element in WSDL

You define a service contract by annotating an interface (or class) with the [ServiceContract] attribute. You identify service operations by placing [OperationContract] attributes on the methods of the interface. The following service contract defines only one service operation.

[ServiceContract]
public interface IHelloWorldService
{
[OperationContract]
string HelloWorld (string input);
}

Once you define a service contract using an interface, you can write a class to implement the interface. For example:

public class HelloWorldService : IHelloWorldService
{
public string HelloWorld(string input)
{
return "Hello " + input;
}
}

It is also possible for you to define the service contract directly against the implementation class and skip the interface altogether. The following class both defines and implements a service contract.

[ServiceContract]
public class HelloWorldService
{
[OperationContract]
public string HelloWorld(string input)
{
return "Hello " + input;
}
}

Although this approach works, it is not a recommended way to create services as interfaces allow you to separate the implementation from the definition of a service.

Understanding Endpoints

Services expose one or more endpoints where messages can be sent. Each endpoint consists of an address, a binding, and a contract. The address specifies where to send messages. The binding describes how to send messages. And the contract describes what the messages contain. Clients need to know this information before they can access a service. The below picture demonstrates how the components of end point play a key role in communication between a client and a service.

Services can package up endpoint descriptions to share with clients, typically by using Web Services Description Language (WSDL). Then clients can use the provided service description to generate code within their environment capable of sending and receiving the proper messages .

One of the key components of an end point is bindings, which will be the topic of focus in the next section.

Understanding Bindings

The bindings of a WCF service define how an endpoint will communicate with an external client. A binding has several characteristics, including the following:

• Transport protocols – Some of the choices include HTTP, Named Pipes, TCP, and MSMQ.
• Encoding – Three types of encoding are available-Text, Binary, or Message Transmission Optimization Mechanism (MTOM). MTOM is an interoperable message format that allows the effective transmission of attachments or large messages (greater than 64K).
• Security – Includes wire security (SSL) or schema-defined security (WS-Security).

Bindings can also determine if you are using sessions or a transacted communications channel. You have the choice of creating custom channels or using prebuilt bindings. WCF comes shipped with nine built-in bindings. The following table lists the WCF build-in bindings and their associated features.

You can choose the right binding to use by mapping the features they support to your requirements.

Hosting WCF Services

As for where to put your code and what it compiles to, you have some choices. You can host your service in Internet Information Services (IIS), or you can write a small amount of extra code to host a service yourself. You can self-host a service from just about any environment that supports managed code, including a WinForms application, console application, library assembly (DLL), or Windows Service controlled through SCM (Service Control Manager). The following lists show the common hosting mechanisms for WCF services.

• IIS (Internet Information Services) – IIS provides a number of advantages if the service uses HTTP as its transport. The nice thing about using IIS is that you don’t have to write any hosting code as part of the application since IIS automatically activates service code as required. Services also benefit from IIS features such as process lifetime management and automatic restart after configuration changes. To run services using IIS, you create the service code along with its configuration file and simply save them in an IIS virtual directory.
• WAS (Windows Activation Service) – (WAS) is the new process activation mechanism that ships with IIS 7.0. WAS builds on the existing IIS 6.0 process and hosting models, but is no longer dependent on HTTP. In addition to HTTP based communication, WCF can also use WAS to provide message-based activation over other protocols, such as TCP and named pipes. This helps WCF applications to take advantage of WAS features, such as process recycling, rapid fail protection, and the common configuration system, which were previously available only to HTTP-based applications.
• Self-hosting – WCF services can be hosted inside any managed application, such as console applications and Windows Forms or Windows Presentation Foundation (WPF) graphical applications. To accomplish this, you need to create a class that implements a WCF service contract interface, and specify binding information in the application configuration file. The application code can then use an instance of System.ServiceModel.ServiceHost to make the service available at a particular location. To start the service, you call the ServiceHost.Open() method.
• Managed Windows Service – A WCF service can be registered as a Windows Service, so that it is under control of the Service Control Manager (SCM). This is suitable for long-running WCF services that are hosted outside of IIS in a secure environment and are not message-activated. By hosting a WCF service with Windows Services, you take advantage of Windows service features such as automatic start at start time and control by the SCM. To host a WCF service in this way, the application must be written as a Managed Windows Service by inheriting from System.ServiceProcess.ServiceBase. It must also implement a WCF service contract interface and then create and open a ServiceHost to manage the WCF service.

Throughout this article series, I will demonstrate each of these hosting mechanisms as we explore the different features of WCF.

Advantages

Windows Communication Foundation has some important enhancements in comparison with preceding technologies.

· It merges all older separate technologies in one place and allows you to do things easier.

· It has rich communication capabilities.

· It comes with many powerful and ready to use enterprise features.

· It can be integrated with other technologies and has great interoperability.

Implementation of a Simple WCF Service

In this section, you will see the steps involved in creating a simple WCF service. Since the focus of this section is to get you familiar with the service development steps, I will keep the service implementation simple. The service is a simple MathService that implements a service contract named IMathService. This exercise has six development steps:

1. Create the service
2. Choose the service hosting mechanism
3. Create the service configuration file
4. Create the client
5. Create the proxy and configuration file for the client
6. Implement and run the client

1.  Create the Service

To start with, create a new project named WCFBasics using Visual Studio 2005 as shown in the below screenshot.

Once the project is created, add a new WCF Service using the Website->Add New Item menu option and name the service MathService as shown below:

After the service is created, you should see a MathService.svc file in your project with the below line of code.

<%@ ServiceHost Language="C#" Debug="true" Service="MathService" CodeBehind="~/App_Code/MathService.cs" %>

Note that the MathService.svc has a code-behind file (named MathService.cs) that is placed in the App_Code directory. Open up the MathService.cs and modify its code to look as follows:

using System;
using System.ServiceModel;

public int Divide(int x, int y)
{
return x / y;
}
}

2.  Choose the Service Hosting Mechanism

As mentioned before, WCF is flexible because its services can be hosted in different types of applications. For the purposes of this installment, let us use IIS for hosting the WCF services because of its simplified configuration.

3.  Create the Service Configuration File

Configuration-based development permits part of an application’s behavior to be specified in configuration files. You can make such things as addresses, bindings, security details, service behavior, and tracing changeable without having to modify and recompile the program code. By specifying addresses, bindings, and behaviors in a configuration file, you can make deploy-time decisions about services that don’t require any modification to the service programs themselves.

As mentioned before, by using IIS you can take advantage of IIS features such as service activation, process recycling and so on. To host the MathService in IIS, modify the Web.config in the Web service project to look as follows:

<?xml version="1.0"?>
<configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">
<system.serviceModel>
<services>
<service name="MathService"
behaviorConfiguration="MathServiceBehavior">
<endpoint address="" contract="IMathService"
binding="wsHttpBinding"/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="MathServiceBehavior">
<serviceMetadata httpGetEnabled="True"/>
<serviceDebug includeExceptionDetailInFaults="true" />
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>

Through its attributes, the <service> element under <system.ServiceModel>\<services> specifies the name of the service as well as the name of the behavior configuration that will be used to control the behavior of the service. The <service> element also contains another child element named <endpoint> that enables you to specify the address, contract, and binding for the service. In this case, since IIS is the hosting mechanism, the address attribute is set to “”. For an IIS-hosted application, the endpoint address should be defined by the physical *.svc file and the name of its hosting virtual directory and should have an empty value unless you would like to give it an extension and assign a different set of bindings to it. For example, in this case if the endpoint address=”", then the actual communication endpoint is http://localhost/MyProjects/15Seconds/WCFBasics/MathService.svc. Note that the contract attribute is set to the name of the interface, which is IMathService in this case. To expose the service through HTTP, the binding attribute is set to “wsHttpBinding”.

4.  Create the Client

To test the service, let us create an ASP.NET Web site named WCFBasicsServiceClient with Visual C# as the language of choice. Once the Web site is created, you now need to create a proxy for the WCF service that was created earlier. In addition, you also need to create a configuration file that contains the configuration settings required to connect to the service. You can accomplish both of these through a new utility called svcutil.exe. You will see this tool in action in the next section.

5.  Create the Proxy and Configuration file for the Client

The Service Model Metadata Utility (svcutil.exe) builds the proxy and the corresponding configuration file based on the published service’s metadata (WSDL + Schema + Policy). Once the service is up, running and listening, you can run svcutil.exe against the service endpoint address. For example, if it were an IIS-hosted service, it would be something like the following:

svcutil.exe http://localhost/MyProjects/15Seconds/WCFBasics/MathService.svc?WSDL

To use the svcutil utility, open up the command prompt through Start->Programs->Microsoft Visual Studio 2005->Visual Studio Tools->Visual Studio 2005 Command Prompt.

As you can see from the above screenshot, the output has two files.

1. A generated typed WCF proxy in a preferred language that translates method calls to dispatched message. By default, the proxy is generated in C#.
2. An output.config file for the client implementation that corresponds with the technical deployment details of the configuration file of the service side.

6.  Implement the Client

Now that you have created the proxy and the configuration file, you are ready to work with them from the client application. Before that, create a new ASP.NET Web site named WCFBasicsServiceClient using Visual C# as the programming language. Once the Web site is created, add the proxy file MathService.cs to the App_Code folder. Also rename the output.config file created through the svcutil to Web.config and add that to the root of the Web site. If you open up the output.config file, you will notice it contains a number of configuration entries for controlling the invocation behavior of the client. However it is also possible for you to manually generate the Web.config file using the below lines of code:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
<system.serviceModel>
<client>
<endpoint
address="http://localhost/MyProjects/15Seconds/WCFBasics/MathService.svc"
binding="wsHttpBinding" contract="IMathService">
</endpoint>
</client>
</system.serviceModel>
</configuration>

Note the use of <system.ServiceModel> as the root of the service client configuration section. Inside that you have an element named <client> that specifies that you are dealing with client configuration sections here. Underneath the <client> element, you have an element named <endpoint> that captures the address, binding, and the contract information about the service.

At this point, you are ready to consume the service by writing code against the proxy. To this end, add a new ASP.NET Web page named MathServiceClient.aspx and modify its code to look as follows:

<%@ Page Language="C#" %>
<script runat="server">
void Page_Load(object sender, EventArgs e)
{
MathServiceClient obj = new MathServiceClient();
int result = obj.Add(1, 5);
lblResult.Text = "Add (1, 5) =" + result.ToString();
result = obj.Subtract(5,1);
lblResult.Text += "Subtract(5,1)=" + result.ToString();
result = obj.Divide(10,2);
lblResult.Text += "Divide(10,2)=" + result.ToString();
obj.Close();
}
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Invoking the Math Service</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Label ID="lblResult" runat="Server"
Font-Bold="true" Height="128px" Width="405px" />
</div>
</form>
</body>
</html>

The above implementation is very simple. It invokes the various methods of the MathService using the proxy class (generated through the svcutil utility) from the previous section and displays the results of the invocation through a label control. If you navigate to the page using the browser, you should see an output that is somewhat similar to the following:

So far, you have seen a simple WCF service that only dealt with simple types. With that foundation, let us switch gears and discuss a service implementation that works with complex types. As mentioned before, you need to create data contracts to be able to work with complex types, which is the topic of focus in the next section.

Understanding Data Contracts

Data contracts can be explicit or implicit. Simple types such as int, string have an implicit data contract. For example, you can use an int or a string in a service operation without having to define a data contract. If you are passing more than simple types to or from a service operation, you must define an explicit service contract by using the [DataContract] and [DataMember] attributes. A data contract can be defined as follows:

• It describes the external format of data passed to and from service operations
• It defines the structure and types of data exchanged in service messages
• It maps a CLR type to an XML Schema
• It defines how data types are serialized and deserialized. Through serialization, you convert an object into a sequence of bytes that can be transmitted over a network. Through deserialization, you reassemble an object from a sequence of bytes that you receive from a calling application.
• It is a versioning system that allows you to manage changes to structured data

You define a data contract by decorating a class, structure, or enumeration with the [DataContract] attribute. You identify members of a data contract by placing [DataMember] attributes on the fields or properties of the class. The following code defines a data contract for a Category class.

using System;
using System.ServiceModel;
using System.Runtime.Serialization;

[DataMember]
public DateTime ModifiedDate;
}

In a data contract, you must explicitly identify each member of the contract by using a [DataMember] attribute. This requirement ensures that developers make a conscious choice to expose data externally. The DataMember attribute is the sole determinant of whether data is shared externally; access modifiers such as public and private do not play a role.

Implementing the CategoryService that uses the DataContract

Once a data contract is defined, you can use the defined type in service operations. The following code shows the CategoryService that exposes a method named GetCategory that returns the details of the Category object based on the supplied category id.

First, add a new service named CategoryService.svc to the WCFBasics project, which will create a CategoryService.svc with the following lines of code.

<%@ ServiceHost Language="C#" Debug="true" Service="CategoryService" CodeBehind="~/App_Code/CategoryService.cs" %>

Modify the code-behind for the CategoryService to look as follows:

using System;
using System.ServiceModel;
using System.Data;
using System.Data.SqlClient;

public class CategoryService : ICategoryService
{
public Category GetCategory(int categoryID)
{
string connectionString = System.Web.Configuration.
WebConfigurationManager.ConnectionStrings["AdventureWorks"].
ConnectionString;
Category categoryObj = new Category();
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
string sql = "Select ProductCategoryID, Name, rowguid, " +
" ModifiedDate from Production.ProductCategory " +
" Where ProductCategoryID = " + categoryID.ToString();
SqlCommand command = new SqlCommand(sql, connection);
SqlDataReader reader =
command.ExecuteReader(CommandBehavior.CloseConnection);
while(reader.Read())
{
categoryObj.CategoryID = (int)reader["ProductCategoryID"];
categoryObj.Name = (string)reader["Name"];
categoryObj.Rowguid = (System.Guid)reader["rowguid"];
categoryObj.ModifiedDate = (DateTime)reader["ModifiedDate"];
}
}
return categoryObj;
}
}

Let us examine the GetCategory() method implementation. You start by retrieving the connection string from the Web.config file that is defined as follows:

<connectionStrings>
<add name="AdventureWorks" connectionString="server=localhost;Initial
Catalog=AdventureWorks;uid=sa;pwd=thiru;"
providerName="System.Data.SqlClient" />
</connectionStrings>

After that, you open the connection to the database through a SqlConnection object, create a SqlCommand object with the appropriate sql to be executed. Then you execute the query against the database using the SqlCommand.ExecuteReader() method.

SqlDataReader reader =
command.ExecuteReader(CommandBehavior.CloseConnection);

Now you loop through the resultant SqlDataReader object and set the Category object with the values retrieved from the SqlDataReader object.

while(reader.Read())
{
categoryObj.CategoryID = (int)reader["ProductCategoryID"];
categoryObj.Name = (string)reader["Name"];
categoryObj.Rowguid = (System.Guid)reader["rowguid"];
categoryObj.ModifiedDate = (DateTime)reader["ModifiedDate"];
}
}


Finally you return the Category object back to the client. Now that you have created the service, you can now consume the service from a client application.

Creating the Client Application for the CategoryService

Prior to creating an ASP.NET page that consumes the service, you need to first create the proxy file using the same steps outlined in the previous example. Once you have the CategoryService proxy class created, add that to the App_Code folder of the WCFBasicsServiceClient project. After that, add a new ASP.NET page named CategoryServiceClient and add the following lines of code to it.

<%@ Page Language="C#" %>
<script runat="server">

protected void btnGetCategory_Click(object sender, EventArgs e)
{
CategoryServiceClient obj = new CategoryServiceClient();
int categoryID = Convert.ToInt32(txtCategoryID.Text);
Category cate = obj.GetCategory(categoryID);
lblResult.Text = "Category ID=" + cate.CategoryID.ToString() + "<br>";
lblResult.Text += "Name=" + cate.Name + "<br>";
lblResult.Text += "RowGuid=" + cate.Rowguid + "<br>";
lblResult.Text += "Modified Date=" + cate.ModifiedDate;
obj.Close();
}
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
<title>Invoking the Category Service</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Label ID="lblCategoryID" runat="server" Height="20px"
Text="Category ID:" Width="135px"></asp:Label>
<asp:TextBox ID="txtCategoryID" runat="server"></asp:TextBox>
<asp:Button ID="btnGetCategory" runat="server"
OnClick="btnGetCategory_Click" Text="Get Category"/>
<br/><br/>
</div>
<asp:Label ID="lblResult" Font-Bold="true" runat="Server" Height="128px"
Width="405px"/>
</form>
</body>
</html>

Before navigating to the page, add the following section to the Web.config file directly under the <system.serviceModel>/<client> section.

<endpoint address="http://localhost/MyProjects/15Seconds/WCFBasics/CategoryService.svc" binding="wsHttpBinding" contract="ICategoryService">
</endpoint>

Open up the browser and navigate to the CategoryServiceClient.aspx page. In the Category ID textbox, enter a valid category id and hit the “Get Category” button and you should see an output like the below one.

Conclusion

In this article, you have understood the WCF’s architecture and its key design characteristics. You have also seen the different types of contracts including ServiceContract, OperationContract, DataContract, and MessageContract. In addition, you have also seen the end points and the different components that make up an end point such as address, binding, and contract. After a thorough discussion of these concepts, you have also seen examples demonstrating the steps involved in creating and consuming a WCF service. Specifically,

• How to create a simple WCF service and host it in IIS
• How to create client proxy and configuration files using the Service Model Metadata Utility (svcutil.exe)
• How to consume the WCF service from a client application
• How to leverage the DataContract to return complex types from a WCF service

For more Details :

http://www.15seconds.com/Issue/061130.htm

http://aspalliance.com/1103_introduction_to_windows_communication_foundation

http://msdn.microsoft.com/en-us/library/ms731082.aspx

Web Service Addressing is the standard method used in Oracle BPEL processes to support asynchronous two-way routing between processes. This is done by injecting routing data into the message SOAP headers so that the process being called has sufficient context to call back to the invoking service (and where necessary the correct instance of the invoking service) on completion.

In some circumstances it may be desirable to redirect the callback from and an asynchronous call to a completely different process or some other compliant service (such as an EJB or ESB). This can be achieved by directly manipulating the WS-Adressing information in the SOAP header of message invoking the asynchronous call:

1. Create an instance of the WS-Addressing Header

If your service is sing WS-Addressing for callback, it will have imported the associated schema, which will allow you to create a variable of the type WSAReplyToHeader, ie.

<variable name="wsaReplyToHeader" messageType="ns7:WSAReplyToHeader"/>

2. Set ReplyTo

Change the reply to so that the URL points to the endpoint of the desired recipient, ie.

<assign name="ChangeReplyURL">
  <copy>
    <from expression="http://some.other/webservice/endpoint/"/>
    <to variable="wsaReplyToHeader" part="ReplyTo"         query="/ns25:ReplyTo/ns25:Address"/>
  </copy>
</assign>

3. Include the Custom Header In The Message

To get the header we’ve created into the SOAP message edit the relevant invoke to include thebpelx:inputHeaderVariable element, and list the custom header by name, ie

<invoke name="ClearUsageTransaction"
        partnerLink="Foo"
        portType="Foo_pt"
        operation="doFoo"
        inputVariable="Foo_doFoo_InputVariable"
        bpelx:inputHeaderVariable="wsaReplyToHeader"/>

4. Trick For New Players – Update the Associated Partnerlink To Force SOAP

When sending messages within a single container, the BPEL engine will usually optimize away the SOAP call for performance, which has the undesirable side effect of ignoring the header changes. To avoid this and force use of SOAP in this particular call edit he process bpel.xml file and add the optSoapShortcut property to the invoking partnerlink, set to false, ie.

<?xml version = '1.0' encoding = 'UTF-8'?>
<BPELSuitcase>
  <BPELProcess id="FooBarProcess" src="FooBarProcess.bpel">
    <partnerLinkBindings>
      <partnerLinkBinding name="client">
        <property name="wsdlLocation">FooBarProcess.wsdl</property>
      lt;/partnerLinkBinding>
      <partnerLinkBinding name="Foo">
        <property name="wsdlLocation">Foo.wsdl</property>
        <property name="optSoapShortcut">false</property>
      </partnerLinkBinding>
    </partnerLinkBindings>
  </BPELProcess>
</BPELSuitcase>

5. Build and Deploy

And that’s it – your callback should now redirect to the custom endpoint. I say should, because redirecting in this way can be fiddly, and as the Oracle BPEL Process Manager does not support viewing of the full SOAP headers in it’s process flow views it can be fiendishly difficult to debug. In such cases third party TCP monitoring tool such as tcpmon (there is usually a version bundled somewhere in the SOA suite install) or Wireshark can be used to view the raw SOAP.

After playing with Web services for so many years this was a tricky error which kept me thinking for few minutes.
Today when i tried to add WCF reference to my application it gave the following error,
Error

—————————
Microsoft Visual Studio
—————————
Failed to update Service Reference ‘XXXBusiness.Reference’.
Error:The components required to enumerate Web references are not installed on this computer. Please re-install Visual Studio.(0×80004002)

http://thetechjungle.blogspot.com/2009/11/add-web-service-reference-components.html

In the previous article we reviewed the process for publishing a matlab application as a web service

http://iomes.wordpress.com/2009/11/09/publishing-a-matlab-application-as-a-web-service-the-caiman-php-service/

In this article we describe the configuration and start up of the service which will accept client requests for running matlab tasks.

In this case the example service for the CAIMAN project is considered. For the CAIMAN project results are emailed to the user but the web client it self may request results files from the job server, this aspect is considered in another example.

Files for setting up the IOME job service for the CAIMAN matlab service are contained in the folder src/examples/matlab/caiman-ws. The folder caimanDir contains the main function files used by the matlab routines. Once the caiman-ws folder has been copied into a suitable working area, the CAIMAN job service can be started almost immediately with relatively minor modification. We describe some of the required modifications here. The main files for enabling the CAIMAN service are as follows

• iogenericsim.sh  , this routine is called when a submit (or request ) simulation is received from a client a unique job working directory is created an this script is copied into that directory. The example provided here submits a further script to a job scheduler (sun grid engine). It could easily be modified to submit to a generic process scheduler available on windows/linx (this line has been commented out.
• iogenericsim_sge.sh the actual script that runs invokes the matlab application will be described below
• simfile.xml an example of the simulation input file this is received from web client and is located in the job working directory
• caimansaasexample.m, the matlab script that styarts the actual processing job
• cpanellogin.sh

The main modifications to be made are

• qsub -sync y iogenericsim_sge.shFor the file iogenericsim.sh, If you are using sungrid engine or PBS as a batch scheduler then remove the comment from the line reading #    ’qsub -sync y iogenericsim_sge.sh . Place a comment at the start of the  line   ../iogenericsim_sge.shFor iogenericsim_sge.sh, check and modify (if necessary) the line    ftp -i staff.shef.ac.uk < cpanellogin.sh , this should refer to the corrrect ftp serverThe cpanellogin.sh file should be modified at the first line as follows, cd public_html/iometest/uploads, the directory should refer to the uploads directry for the IOME client
• Using batchmode to access the ftp server store ftp server information in a file in $HOME called .netrc the .netrc filehas the following line (or lines) “machine iomewebclient.organisation.ac.uk login username passwd thepassword”. It is important to set the permissions for .netrc to  600(rw—-). Further details may be obtained at ( http://rcsg-gsir.imsb-dsgi.nrc-cnrc.gc.ca/documents/internet/node52.html )

The IOME service is then started with the following invocation

iogs initiome null caiman null 60000 >& iogs.log

Putting this command in script file e.g. called startserver.sh

#!/bin/bash

iogs initiome null caiman null 60000 >& iogs.log

The server is started using the command

./startserver.sh &

At this point the IOME example CAIMAN service will be operational. We now provide some additional comments enabling the developer to undesrstand how to deploy their application as a web service.

The IOME web service works in the following way.

• Receives a submitsimulation request and creates a working area
• Receives a copy of the simfile.xml that contains the job description
• Executes the iogenericsim.sh script

The iogenericsim.sh script is provided by the author of the service and this will invoke the following.

• Starts a local server
• Reads the simfile.xml into the local server
• Starts the actual job on the server the actual job will then read any data from the server (alternatively we could use string replacements to edit an input file. There is a large number of possibilities here. It is also possible to parse the simfile.xml file directly with out invoking a local IOME server

Reviewing the iogenericsim_sge.sh script it should be noted that the actual job starts its own IOME server which runs as a localhost server and is invoked using the command “iogs initiome null $IOME_SIMNAME null  &”.  Data is loaded onto the server using the command “iogs readsimulation simfile.xml 0 $IOME_WSPORT localhost”. We then obtain the name of the imagefile to be processed using command ” IMFILE=`iogs getparam string imagefile 0 $IOME_WSPORT localhost` “, this is used in the stream editor command for editing the ftp input file. The final line of iogenericsim_sge.sh invokes the matlab job.

The main features of the matlab driver script are as follows

• Reads the port for the local IOME server
• Sets up contact details for the local IOME server ( e.g. “elist=iome(‘localhost’,res{1},0);”  )
• Requests the parameters for the job from the local IOME server e.g. “userEmail=getparamstring(‘useremail’,elist);”, “ imageFile=getparamstring(‘imagefile’,elist);” and “jobtype=getparamstring(‘jobtype’,elist);”
• At the end of the routine terminate the local IOME server using “exitiome(elist);”

An earlier entry on generating web service applications

http://iomes.wordpress.com/2009/09/25/publishing-an-application-as-an-iome-web-service/

In a CMS website, the content can be managed easily by an individual without involving any IT professional. It gives ample scope to the user operating the website and its content single handedly.

Basically CMS stands for Content Management System. CMS website designing is done by the professionals of IT.

At Hans we have professionals of Content management system website.

Hello friends,
In this session we are going to take a look how do we connect a silver light application with database.
So here I would like to say that there are basically 4 options by which you can handle database in silver light application.
1) WCF for Silver light
2) Ado.net Data Services
3) Web services
4) RIA Services (need to explore more)

Here I will explain how to connect your WPF Silver light application with database using well know Web service.
It’s easy and I think we all already work on some part of Web services.

So let’s start with it.
We have added a silver light navigation project. In navigation silver light project part we have added 2 new pages employee, register page.
Employee page is for show employee list,And register page is for register employee.

Just see project structure as below.

And In web part we have added a new web service with name my services.
Whose functionality to save, updates, Delete, and read all employee record.
As shown in below fig.

Now our next step is how to integrate this web service with silver light.
For this we add a services reference in our navigation project with the help of Add services reference menu as shown below.

Now you can rename name space according to your choice.

If you do not get any error in referencing then till now you are ok with your work.
Now our next step is calling web method in our pages.
Here I am taking first page which is employee list
We are calling web method which returns all employee lists so here we go.

Private Sub EmployeePage_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
Try
Dim myBinding As New ServiceModel.BasicHttpBinding()
Dim myEndPoint As New ServiceModel.EndpointAddress(New Uri(“http://localhost/MyTest/MyWebService.asmx”, UriKind.Absolute))
Dim proxy As New MyWebServiceSoapClient(myBinding, myEndPoint)
proxy.pub_ReadAllDataAsync()
AddHandler proxy.pub_ReadAllDataCompleted, AddressOf proxy_ReadAllEmployeeCompleted

Catch ex As Exception

End Try
End Sub

Private Sub proxy_ReadAllEmployeeCompleted(ByVal sender As Object, ByVal e As myService.pub_ReadAllDataCompletedEventArgs)
Try
Me.myGrid.ItemsSource = e.Result
Catch ex As Exception
Me.HeaderText.Text = ex.InnerException.Message.ToString
End Try
End Sub

Now things to remember here
1) Dim myBinding As New ServiceModel.BasicHttpBinding()
Its shows the binding is http binding
2) Dim myEndPoint As New ServiceModel.EndpointAddress(New Uri(“http://localhost/MyTest/MyWebService.asmx”, UriKind.Absolute))
Here the path can be absolute or relative.

3) Next you have to call web method like we have call here proxy.pub_ReadAllDataAsync()
4) once we have call the method asyncronously then we have to make a event handler like we have create here

AddHandler proxy.pub_ReadAllDataCompleted, AddressOf proxy_ReadAllEmployeeCompleted

5) when the asyncronous method is complete we have to take result complete argument and covert according to our requirement.
I have just bind the result to datagrid and get below screen.
Just see below.

So friends in this way we can call web service in a Silverlight application.

Still we can use DataServices, RIA services, and WCF services for data manipulation application.

Hope in next few chapter we will take this example and work on it.

That’s all friends, thanks for reading the article.

Happy programming!

Thanks
Rajat

–> Web Services rely on the ability of remote components to communicate with each other, irrespective of how they are implemented or what systems they are running on.

That is why XML is the cornerstone of web services, as it is a neutral data description language that makes data portable across difference systems.

Java is compatible with XML since it allows us to create applications that can be used on any operating system.

–> Java has dedicated APIs for creating, validating and processing XML and for implementing XML based communications.

Mature enterprise platform, J2EE has many capabilities to web services.  Inbuilt support for multiple transactions, data connection pooling, security and enterprise messaging.

Existing J2EE components such as Servlets, JSPs and EJBs can also be exposed as web services, allowing you to add web service functionality to existing systems.

The Java WSDP also comes with a range of tools designed to help create, test, and deploy web services.

NOTE: The Java WSDP can be integrated into the current J2EE 1.3 release by use of a simple script.  Instructions for running this automated script are included in the Java WSDP documentation.

The next release of the J2EE platform is Version 1.4. It will include many of the Java APIs for XML and will come with much greater built-in web service support, including

1. support for exposing J2EE components as web service clients and endpoints.

2.
interoperability with other web services that use SOAP and WSDL.

3.
a dedicated specification – Web Services for J2EE 1.0 – that details how web services should work on the J2EE platform.

This page describes how to generate a client to call a few popular web services that are available on the web.

Requirements:

• Desktop Computer
• Maven 2

We will be generating clients for the following web services

• IP2Geo (http://ws.cdyne.com/ip2geo/ip2geo.asmx?wsdl)
• Currency Converter (http://webservice.webserviceshare.com/currencyconverter/rates.asmx?WSDL)
• Bible Web Service (http://www.webservicex.net/BibleWebservice.asmx?wsdl)

Before we can start to use any of the above web services we need to create a new Java project in Eclipse. Name the project

Go ahead and create a new java project in eclipse and save the following pom.xml file to the main folder.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.vermatech</groupId>
	<artifactId>TestApacheCXFClient</artifactId>
	<packaging>war</packaging>
	<version>1.0.1-SNAPSHOT</version>
	<name>TestApacheCXFClient</name>
	<url>http://maven.apache.org</url>

	<build>
		<sourceDirectory>src</sourceDirectory>
<resources><resource><directory>src</directory></resource></resources>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.0.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<dependency>
		  <groupId>log4j</groupId>
		  <artifactId>log4j</artifactId>
		  <version>1.2.15</version>
			<exclusions>
				<exclusion>
					<groupId>javax.mail</groupId>
					<artifactId>mail</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.jms</groupId>
					<artifactId>jms</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jdmk</groupId>
					<artifactId>jmxtools</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jmx</groupId>
					<artifactId>jmxri</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.activation</groupId>
					<artifactId>activation</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf</artifactId>
			<version>2.1</version>
			<type>pom</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>2.2.4</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http-jetty</artifactId>
			<version>2.2.4</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>

	</dependencies>
</project>

regenerate the project by dropping to the command line and typing:

mvn eclipse:clean eclipse:eclipse

IP2Geo

This web service accepts an ip address and returns some information about it.

We start by getting the wsdl and saving it to our project as

document.wsdl

We insert the following into the pom.xml file in the plugins section.

<plugin>
	<groupId>org.apache.cxf</groupId>
	<artifactId>cxf-codegen-plugin</artifactId>
	<version>2.2.4</version>
	<executions>
		<execution>
			<id>generate-sources</id>
			<phase>generate-sources</phase>
			<configuration>
				<sourceRoot>generated/cxf</sourceRoot>
				<wsdlOptions>
					<wsdlOption>
						<wsdl>document.wsdl</wsdl>
					</wsdlOption>
				</wsdlOptions>
			</configuration>
			<goals>
				<goal>wsdl2java</goal>
			</goals>
		</execution>
	</executions>
</plugin>

To generate the code type the following at the command prompt inside your eclipse project:

mvn generate-sources

• Return to eclipse and refresh the project.
• You will see additional files added to the /generated/cxf folder within the project.
• Copy these files to the folder where your javasource files are located.

Create a simple client that calls these web services.

SimpleClientApp.java

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cdyne.ws.IP2GeoSoap;
import com.cdyne.ws.IPInformation;

public class HelloWorldClientApp {
public static void main(String args[]) throws Exception {
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"app-context.xml"});

IP2GeoSoap ip2Geo = (IP2GeoSoap) context.getBean("ip2Geo");
IPInformation ipInformation = ip2Geo.resolveIP("12.12.12.12", "0");

System.out.println("City: " + ipInformation.getCity());
System.out.println("State: " + ipInformation.getStateProvince());
System.out.println("Country: " + ipInformation.getCountry());
}
}

The above program initialized the spring application context and gets a bean that represents the web service. It invokes a method called “resolveIp()” to get a ipInformation object. Next it simply displays the values on the console.

One thing to note here is that the client code does not need all the files the wsdl2java has generated for us. We can trim down the generated code by deleting some classes we dont need.

We first start with the ObjectFactory. At this point it does not look like the object factory provides any benefit.

Delete the following

• ObjectFactory.java
• IP2GeoHttpGet.java
• IP2GeoHttpPost.java

Modify

• IP2GeoSoap.java and comment out the following line…
• @XmlSeeAlso({ObjectFactory.class})
• Delete the IP2GeoHttpGet.java and IP2GeoHttpPost.java as these methods will not be used to access the service
• Delete the IP2Geo.java class because we will use spring to generate the proxy that will access the service.
• Delete the ObjectFactory.java, ResolveIP.java, and ResolveIPResponse.java files as well
• Fix any compile issues that may arise from doing the deletes

You should only be left with 3 class files in your package

• IP2GeoSoap.jvaa
• IPInformation.java
• package-info.java

Next you need to make your app-context.xml should look like this… this file is located at the top package.

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

    <jaxws:client id="ip2Geo"
                  serviceClass="com.cdyne.ws.IP2GeoSoap"
                  address="http://ws.cdyne.com/ip2geo/ip2geo.asmx" />
</beans>

Testing the program

Create a class in the test package.
HelloWorldClientApp.java

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cdyne.ws.IP2GeoSoap;
import com.cdyne.ws.IPInformation;

public class HelloWorldClientApp {
	public static void main(String args[]) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"app-context.xml"});

		IP2GeoSoap ip2Geo = (IP2GeoSoap) context.getBean("ip2Geo");
		IPInformation ipInformation = ip2Geo.resolveIP("12.12.12.12", "0");

		System.out.println("City: " + ipInformation.getCity());
		System.out.println("State: " + ipInformation.getStateProvince());
		System.out.println("Country: " + ipInformation.getCountry());
	}
}

Run the program

you should get output similar to the following

log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
Nov 6, 2009 6:07:51 PM org.apache.cxf.bus.spring.BusApplicationContext getConfigResources
INFO: No cxf.xml configuration file detected, relying on defaults.
Nov 6, 2009 6:07:52 PM org.apache.cxf.service.factory.ReflectionServiceFactoryBean buildServiceFromClass
INFO: Creating Service {http://ws.cdyne.com/}IP2GeoSoapService from class com.cdyne.ws.IP2GeoSoap
City: Anchorage
State: AK
Country: United States

Currency Converter

We will now investigate how to convert over the currency conversion web service that can be accessed using the following wsdl.

http://webservice.webserviceshare.com/currencyconverter/rates.asmx?WSDL

We start by saving the file to
document.wsdl

To generate the code type the following:

Open a command prompt and cd to the project’s folder

mvn generate-sources

you should see the following output

[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building TestApacheCXFClient
[INFO]    task-segment: [generate-sources]
[INFO] ------------------------------------------------------------------------
[INFO] [cxf-codegen:wsdl2java {execution: generate-sources}]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: Fri Nov 06 18:23:44 EST 2009
[INFO] Final Memory: 25M/534M
[INFO] ------------------------------------------------------------------------

Return to the eclipse project and click refresh.
At this point you should see new files under the project /generated/cxf/com/websevriceshare folder.

We quickly identify that CurrencyConverterSoap.java is the main interface class for the web service. This class has the following methods

• getRates
• getSupportedCurrencies
• getRatesInAllCurrencies
• getConvertedAmount
• getConvertedAmountInAllCurrencies

Create a package com.websvriceshare (spelled incorrectly I know but do it anyway) and paste in all the generated code. We will run the project as-is.

We test he web service by defining the following in your spring configuration file…

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

    <jaxws:client id="currencyConverter"
                  serviceClass="com.websevriceshare.CurrencyConverterSoap"
                  address="http://webservice.webserviceshare.com/currencyconverter/rates.asmx" />

</beans>

Define the following test code

HelloWorldClientApp.java

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.websevriceshare.CurrencyConverterSoap;
import com.websevriceshare.CurrencyListRow;

public class HelloWorldClientApp {
	public static void main(String args[]) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"app-context.xml"});

		CurrencyConverterSoap currencyConverter = (CurrencyConverterSoap) context
				.getBean("currencyConverter");

		System.out.println("These currencies are supported: ");
		for (CurrencyListRow row : currencyConverter.getSupportedCurrencies().getCurrencyListRow()) {
			System.out.println(row.getCurrencyName());
		}

	}
}

Run the class and you should get output to the console that looks like this…

log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
Nov 6, 2009 6:44:04 PM org.apache.cxf.bus.spring.BusApplicationContext getConfigResources
INFO: No cxf.xml configuration file detected, relying on defaults.
Nov 6, 2009 6:44:04 PM org.apache.cxf.service.factory.ReflectionServiceFactoryBean buildServiceFromClass
INFO: Creating Service {http://websevriceshare.com/}CurrencyConverterSoapService from class com.websevriceshare.CurrencyConverterSoap
These currencies are supported:
Albanian Lek
Algerian Dinar
Argentine Peso
Aruba Florin
Australian Dollar
Bahamian Dollar
...
Yemen Riyal
Zambian Kwacha
Zimbabwe Dollar
Croatian Kuna
Russian Rouble

Once we are comfortable that its running we will start deleting un-necessary code that was generated.

Bible Web Service

This web service list all versus by Book Title ,Chapter and Verse from the Kings James version Bible

Download the source of the wsdl and again put it into document.wsdl

re-run the command to generate the sources and copy the generated sources to its package under the src folder. This time the source code got generated into the net.webservicex package. We create a similar package in our src folder within our project.

We quickly look at the generated classes once they have been moved over to our source folder and find out that BibleWebserviceSoap.java is the main web service class. It contains the following methods. All of them return a String. This is unfortunate since whomever is implementing the web service will need to parse the xml. It would have been better for the web service author to create a complex Type object and save the client programmers some time.

• getBibleWordsbyKeyWord
• getBookTitles
• getBibleWordsByChapterAndVerse
• getBibleWordsByBookTitleAndChapter

Modify the spring configuration file to generate the proxy for this service.

    <jaxws:client id="bibleWebService"
                  serviceClass="net.webservicex.BibleWebserviceSoap"
                  address="http://www.webservicex.net/BibleWebservice.asmx" />

Create a client program to test the service

package test;

import net.webservicex.BibleWebserviceSoap;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorldClientApp {
	public static void main(String args[]) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"app-context.xml"});

		BibleWebserviceSoap bibleWebService = (BibleWebserviceSoap) context
				.getBean("bibleWebService");

		System.out.println(bibleWebService.getBookTitles());
	}
}

This is the output we get.

<NewDataSet>
  <Table>
    <Book>1</Book>
    <BookTitle>Genesis</BookTitle>
  </Table>
  <Table>
    <Book>2</Book>
    <BookTitle>Exodus</BookTitle>
  </Table>
  <Table>
    <Book>3</Book>
    <BookTitle>Leviticus</BookTitle>
  </Table>
  <Table>
    <Book>4</Book>
    <BookTitle>Numbers</BookTitle>
  </Table>

Once we are comfortable with this we delete any un-necessary code.

We have successfully generated code that calls 3 web services using the Apache CXF framework.

Thats All for now!!!

I have speak with most of the person and they always saying they would not be able to understand the basic terms which is used in WCF. I am trying to give here terms with meaningfull description:

1. Address

Specifies the location where messages are received. It is specified as a Uniform Resource Identifier (URI). The URI schema part names the transport mechanism to use to reach the address, such as HTTP and TCP.

2. Application endpoint

An endpoint exposed by the application and that corresponds to a service contract implemented by the application.

3. Behavior

A behavior is a component that controls various run-time aspects of a service, an endpoint, a particular operation, or a client. Behaviors are grouped according to scope: common behaviors affect all endpoints globally, service behaviors affect only service-related aspects, endpoint behaviors affect only endpoint-related properties, and operation-level behaviors affect particular operations.

4. Binding

Defines which communication protocols are used to communicate with WCF services.

5. Binding element

A binding element represents a particular piece of the binding, such as a transport, an encoding, an implementation of an infrastructure-level protocol (such as WS-ReliableMessaging), or any other component of the communication stack.

6. Channel

A concrete implementation of a binding element. The binding represents the configuration, and the channel is the implementation associated with that configuration. Therefore, there is a channel associated with each binding element. Channels stack on top of each other to create the concrete implementation of the binding: the channel stack.

7. Client application

A client application is a program that exchanges messages with one or more endpoints.

8. Contract

A contract is a specification of support for the particular type of contract that it is. A service contract, for example, is a specification for a group of operations. In WCF, contracts have a hierarchy that is mirrored in the description objects located in the System.ServiceModel.Description namespace. A service contract is the largest contract scope in WCF. Each service operation in a service contract has an operation contract, which specifies the messages — including fault messages — the operation can exchange, and in which direction. Each message in an operation has a message contract, a specification for the structure of the SOAP message envelope, and each message contract has a data contract, which specifies the data structures contained in the messages.

9. Data contract

The data types a service uses must be described in metadata to enable others to interoperate with the service. The descriptions of the data types are known as the data contract, and the types can be used in any part of a message, for example, as parameters or return types. If the service is using only simple types, there is no need to explicitly use data contracts.

10. Endpoint

Consists of an address, a binding, and a contract used for communicating with a WCF service.

11. Fault contract

A fault contract can be associated with a service operation to denote errors that can be returned to the caller. An operation can have zero or more faults associated with it. These errors are SOAP faults that are modeled as exceptions in the programming model. The exception is converted into a SOAP fault that can then be sent to the client.

12. Hosting

A service must be hosted in some process. A host is an application that controls the lifetime of the service. Services can be self-hosted or managed by an existing hosting process.

13. Hosting process

A hosting process is an application that is designed to host services. These include Internet Information Services (IIS), Windows Activation Services (WAS), and Windows Services. In these hosted scenarios, the host controls the lifetime of the service. For example, using IIS you can set up a virtual directory that contains the service assembly and configuration file. When a message is received, IIS starts the service and controls its lifetime.

14. Message

A message is a self-contained unit of data that may consist of several parts, including a body and headers.

15. Message contract

A message contact describes the format of a message. For example, it declares whether message elements should go in headers versus the body, what level of security should be applied to what elements of the message, and so on.

16. Message security mode

Message security mode specifies that security is provided by implementing one or more of the security specifications. Each message contains the necessary mechanisms to provide security during its transit, and to enable the receivers to detect tampering and to decrypt the messages. In this sense, the security is encapsulated within every message, providing end-to-end security across multiple hops. Because security information becomes part of the message, it is also possible to include multiple kinds of credentials with the message (these are referred to as claims). This approach also has the advantage of enabling the message to travel securely over any transport, including multiple transports between its origin and destination. The disadvantage of this approach is the complexity of the cryptographic mechanisms employed, resulting in performance implications.

17. Metadata

The metadata of a service describes the characteristics of the service that an external entity needs to understand to communicate with the service. Metadata can be consumed by the ServiceModel Metadata Utility Tool (Svcutil.exe) to generate a WCF client and accompanying configuration that a client application can use to interact with the service. The metadata exposed by the service includes XML schema documents, which define the data contract of the service, and WSDL documents, which describe the methods of the service. When enabled, metadata for the service is automatically generated by WCF by inspecting the service and its endpoints. To publish metadata from a service, you must explicitly enable the metadata behavior.

18. Operation contract

An operation contract defines the parameters and return type of an operation. When creating an interface that defines the service contract, you signify an operation contract by applying the T:System.ServiceModel.OperationContractAttribute attribute to each method definition that is part of the contract. The operations can be modeled as taking a single message and returning a single message, or as taking a set of types and returning a type. In the latter case, the system determines the format for the messages that are exchanged for that operation.

19. Self-hosted service

A self-hosted service is one that runs within a process application that the developer created. The developer controls its lifetime, sets the properties of the service, opens the service (which sets it into a listening mode), and closes the service.

20. Service

A program or process that exposes one or more endpoints, with each endpoint exposing one or more operations.

21. Service contract

The service contract ties together multiple related operations into a single functional unit. The contract can define service-level settings, such as the namespace of the service, a corresponding callback contract, and other such settings. In most cases, the contract is defined by creating an interface in the programming language of your choice and applying the T:System.ServiceModel.ServiceContractAttribute attribute to the interface. The actual service code results by implementing the interface.

22. Service operation

A service operation is a procedure defined in a service’s code that implements the functionality for an operation. This operation is exposed to clients as methods on a WCF client. The method may return a value, and may take an optional number of arguments, or take no arguments, and return no response. For example, an operation that functions as a &quot;Hello&quot; can be used as a notification of a client’s presence and to begin a series of operations.

23. System-provided bindings

WCF includes a number of system-provided bindings. These are collections of binding elements that are optimized for specific scenarios. For example, the T:System.ServiceModel.WSHttpBinding is designed for interoperability with services that implement various WS-* specifications. These bindings save time by presenting only those options that can be correctly applied to the specific scenario. If one of these bindings does not meet your requirements, you can create your own custom binding.

24. Transport security mode

Security can be provided by one of three modes: transport mode, message security mode, and transport with message credential mode. The transport security mode specifies that confidentiality, integrity, and authentication are provided by the transport layer mechanisms (such as HTTPS). When using a transport like HTTPS, this mode has the advantage of being efficient in its performance, and well understood because of its prevalence on the Internet. The disadvantage is that this kind of security is applied separately on each hop in the communication path, making the communication susceptible to a &quot;man in the middle&quot; attack.

25. Transport with message credential security mode

This mode uses the transport layer to provide confidentiality, authentication, and integrity of the messages, while each of the messages can contain multiple credentials (claims) required by the receivers of the message.

26. WCF client

A WCF client is a client-application construct that exposes the service operations as methods (in the .NET Framework programming language of your choice, such as Visual Basic or Visual C#). Any application can host a WCF client, including an application that hosts a service. Therefore, it is possible to create a service that includes WCF clients of other services. A WCF client can be automatically generated by using the ServiceModel Metadata Utility Tool (Svcutil.exe) and pointing it at a running service that publishes metadata.

27. WS-*

Shorthand for the growing set of Web Service (WS) specifications, such as WS-Security, WS-ReliableMessaging, and so on, that are implemented in WCF.

Thanks,

Parwej Ahamad

e-ahamad.parwej@gmail.com

One of the hardest things about developing a wave robot is coming up with an original idea. My smiley bot [smiley_wave@appspot.com] was just for me to play with wave & get used to uploading apps to App Engine / get back into java coding and using eclipse. Now that that’s done, it’s time to think of something useful; an application that people will actually want to use. The point of this post is partly a brainstorming session for myself, and partly to put these ideas out there to anyone stuck for ideas, who think they can code one of these, and finally, to encourage others to submit ideas.

Webby – The Web Service Robot
A robot which when added, detects any URLs pointing to web services, generates a form based on the parameters, then submits this data via SOAP, and puts the return value into a new blip.

Squely – A Database Query Bot
A robot which can run SQL statements against given connection strings. At present, this will only be possible if the database is publicly accessible, or if you have a wave server installed on the same network as your database.

QIFry – Interesting
This robot would monitor waves for key words, then on detection, pop in an interesting fact about that word (e.g. if it spots the word Banana, it says “did you know that bananas are herbs, and these shrubs can walk?”). It also monitors for boring words, and replaces them with more eloquent ones.

Pretty – Pretty Print
Detects common languages / markup & changes the layout to make it more readable.

Recipe
Finds recipes based on ingredients or dish names in the wave.

FindMe
Uses the GEO features of HTML 5 to locate where each wave user is and lets wavers know where their nearest wavers are. This could also take info about their interests to help match people up to folks whose hobbies they share.

It’s been well over a week since I wrote about battling the SAS BI Web Services for .Net beast and a lot has changed. A week or so ago I was pretty sure that I had gotten it installed and was dealing with problems created by configuration issues. I have since found out that I did not have it installed correctly and through the course of the last 10 days SAS sent me 3 additional plan files, the last of which still didn’t work correctly.

I’ll recap what I’m doing. I’m trying to get SAS BI Web Services for .Net installed and working so that I can work on the bigger picture of my project which is to document how to call these web services from a .Net web application. Installing SAS is like building the bay bridge from a bucket (a really big one) of nuts and bolts and cables and other stuff. The full installation for all of the SAS components encompasses dozens and dozens of CDs. So you install SAS in almost any permutation of components but the specific permutation which I need is the one which enables me to use SAS BI Web Services for .Net. The ‘plan’ file which I spoke of above is basically the blueprint to the bridge. It is an XML file which is fed into the SAS installer to tell it which components to install in what order and how to configure them.

Dissecting a SAS installation plan file

I’m still trying to get a working plan file from SAS. I have a ticket open with them to get a plan file with which I can install SAS BI Web Services for .Net plus all the other needed components. But to date, I haven’t received a working plan file. I am now in receipt of the 5^th plan file but it doesn’t work and so I’m currently awaiting the 6^th one. SAS does not support user modifications of a plan file, they only support plan files from SAS Support or a dedicated account rep. Well, I don’t have a dedicated account rep and I’m still waiting on a good plan file from SAS so last week I set about creating my own. And I succeeded. But I’m not telling SAS because with all of the complexity of SAS, I may have missed something so I’m going to wait on a blessed and ordained plan file from SAS rather than my own creation.

I took a look at the XML plan file to see what it looked like and I found that the plan file’s contents really don’t look that complicated; there are 3 basic types of information in it:

1. Component section. These are sections which identify a component (e.g. SAS Web Infrastructure Client) and give it a unique ID within the plan file.
2. The properties section of a component section. Properties are sequentially numbered within the whole plan file so if a new component section is inserted; all properties in the entire file need to be renumbered. These properties for the most part have identical names and values between sections. There are a couple of components which have different props but overall, they’re the same for each component section.
3. References to other components. This seems to be the way dependencies between components are defined. Here is an example of the first 3 types of information:
   1. 
4. Some components are hierarchically children of other components. I *think* that is because the parent component is dependent on the child but then again, number 3 above seemed to indicate.  Here is an example:
   1. 

I now have a working installation of SAS BI Web Services for .Net but, like I said, I’m keeping my ticket open with SAS until I get an official one from SAS because I probably missed something.

This page describes the steps necessary to generate and run a standalone java application that calls a web service. This application will be generated from an existing WSDL using the Apache CXF, Maven and The Spring Framework.

Please note that this page describes the generation of the client side application only. If you want to generate the server side please click on the following link.

After you return from reading the above link we will need to add a few more lines of code to the web service…

At this time open up the HelloWorldImpl.java and add the following few lines of code to that class.

	@Override
	public Employee getEmployee(Integer id) {
		Employee employee = new Employee();
		employee.setFirstName("John");
		employee.setLastName("Doe");
		employee.setHireDate(new Date());

		return employee;
	}

Now add the following class to the demo.spring package
Employee.java

package demo.spring;

import java.util.Date;

public class Employee {
	private String firstName;
	private String lastName;
	private Date hireDate;

	public String getFirstName() {
		return firstName;
	}
	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public Date getHireDate() {
		return hireDate;
	}
	public void setHireDate(Date hireDate) {
		this.hireDate = hireDate;
	}

}

Add the following line to the HelloWorld.java Interface

    public Employee getEmployee(Integer id);

Return to the web service URL and you should see another web service method appear.

Please verify that it is appearing before proceeding further on this page.

We start with a new simple Java project.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.vermatech</groupId>
	<artifactId>TestApacheCXFClient</artifactId>
	<packaging>war</packaging>
	<version>1.0.1-SNAPSHOT</version>
	<name>TestApacheCXFClient</name>
	<url>http://maven.apache.org</url>

	<build>
		<sourceDirectory>src</sourceDirectory>
<resources><resource><directory>src</directory></resource></resources>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.0.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<dependency>
		  <groupId>log4j</groupId>
		  <artifactId>log4j</artifactId>
		  <version>1.2.15</version>
			<exclusions>
				<exclusion>
					<groupId>javax.mail</groupId>
					<artifactId>mail</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.jms</groupId>
					<artifactId>jms</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jdmk</groupId>
					<artifactId>jmxtools</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jmx</groupId>
					<artifactId>jmxri</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.activation</groupId>
					<artifactId>activation</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf</artifactId>
			<version>2.1</version>
			<type>pom</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-frontend-jaxws</artifactId>
			<version>2.2.4</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.cxf</groupId>
			<artifactId>cxf-rt-transports-http-jetty</artifactId>
			<version>2.2.4</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>

	</dependencies>
</project>

regenerate the eclipse project by typing: mvn eclipse:clean eclipse:eclipse

WSDL

We will call a web service described by the following WSDL.

save this wsdl to the eclipse project’s top level folder.

myService.wsdl

<?xml version='1.0' encoding='UTF-8'?><wsdl:definitions name="HelloWorldImplService" targetNamespace="http://spring.demo/" xmlns:ns1="http://cxf.apache.org/bindings/xformat" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://spring.demo/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <wsdl:types>
<xs:schema elementFormDefault="unqualified" targetNamespace="http://spring.demo/" version="1.0" xmlns:tns="http://spring.demo/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="getEmployee" type="tns:getEmployee" />
<xs:element name="getEmployeeResponse" type="tns:getEmployeeResponse" />
<xs:element name="sayHi" type="tns:sayHi" />
<xs:element name="sayHiResponse" type="tns:sayHiResponse" />
<xs:complexType name="sayHi">
<xs:sequence>
<xs:element minOccurs="0" name="arg0" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="sayHiResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="xs:string" />
</xs:sequence>

</xs:complexType>
<xs:complexType name="getEmployee">
<xs:sequence>
<xs:element minOccurs="0" name="arg0" type="xs:int" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="getEmployeeResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="tns:employee" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="employee">
<xs:sequence>
<xs:element minOccurs="0" name="firstName" type="xs:string" />
<xs:element minOccurs="0" name="hireDate" type="xs:dateTime" />
<xs:element minOccurs="0" name="lastName" type="xs:string" />
</xs:sequence>

</xs:complexType>
</xs:schema>
  </wsdl:types>
  <wsdl:message name="getEmployeeResponse">
    <wsdl:part element="tns:getEmployeeResponse" name="parameters">
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="sayHiResponse">
    <wsdl:part element="tns:sayHiResponse" name="parameters">
    </wsdl:part>

  </wsdl:message>
  <wsdl:message name="getEmployee">
    <wsdl:part element="tns:getEmployee" name="parameters">
    </wsdl:part>
  </wsdl:message>
  <wsdl:message name="sayHi">
    <wsdl:part element="tns:sayHi" name="parameters">
    </wsdl:part>
  </wsdl:message>

  <wsdl:portType name="HelloWorld">
    <wsdl:operation name="sayHi">
      <wsdl:input message="tns:sayHi" name="sayHi">
    </wsdl:input>
      <wsdl:output message="tns:sayHiResponse" name="sayHiResponse">
    </wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="getEmployee">
      <wsdl:input message="tns:getEmployee" name="getEmployee">

    </wsdl:input>
      <wsdl:output message="tns:getEmployeeResponse" name="getEmployeeResponse">
    </wsdl:output>
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="HelloWorldImplServiceSoapBinding" type="tns:HelloWorld">
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http" />
    <wsdl:operation name="sayHi">
      <soap:operation soapAction="" style="document" />

      <wsdl:input name="sayHi">
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output name="sayHiResponse">
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
    <wsdl:operation name="getEmployee">
      <soap:operation soapAction="" style="document" />

      <wsdl:input name="getEmployee">
        <soap:body use="literal" />
      </wsdl:input>
      <wsdl:output name="getEmployeeResponse">
        <soap:body use="literal" />
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="HelloWorldImplService">

    <wsdl:port binding="tns:HelloWorldImplServiceSoapBinding" name="HelloWorldImplPort">
      <soap:address location="http://localhost:8080/TestApacheCXF/HelloWorld" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

Generate The Source

Next we generate the Java Source from the WSDL using Maven. The source is generated by the section of code seen in the pom.xml file. It is shown here for clarity.

<plugin>
	<groupId>org.apache.cxf</groupId>
	<artifactId>cxf-codegen-plugin</artifactId>
	<version>2.2.4</version>
	<executions>
		<execution>
			<id>generate-sources</id>
			<phase>generate-sources</phase>
			<configuration>
				<sourceRoot>generated/cxf</sourceRoot>
				<wsdlOptions>
					<wsdlOption>
						<wsdl>myService.wsdl</wsdl>
					</wsdlOption>
				</wsdlOptions>
			</configuration>
			<goals>
				<goal>wsdl2java</goal>
			</goals>
		</execution>
	</executions>
</plugin>

To generate the code type the following at the command prompt inside your eclipse project:

mvn generate-sources

Navigate to the /generated/cxf folder inside the eclipse project. Grab the HelloWorld.java interface and the Employee Bean. Move them to the src folder’s test package. As you can see the 2 files are heavily annotated. There are many other classes that are generated that are not absolutely necessary for the web service to operate. At this point you only need the main interface class that represents the web service and any POJO beans that are used to pass information into or get information out of the web service. In our case this is the Employee and HelloWorld class and interface.

Make sure to get rid of all the compile issues. We can place the generated files in any package of our choosing. It does not need to be in the package that was indicated by the wsdl.

Next we will modify the spring configuration and add the following bean.

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

    <jaxws:client id="helloClient"
                  serviceClass="test.HelloWorld"
                  address="http://localhost:8080/TestApacheCXF/HelloWorld2" />
</beans>

Finally we will write the following to run the actual code to call the service.

HelloWorldClientApp.java

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorldClientApp {
	public static void main(String args[]) throws Exception {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"app-context.xml"});

		HelloWorld helloWorld = (HelloWorld) context.getBean("helloClient");
		// with spring 3.0 cast will no longer be needed  

		System.out.println(helloWorld.sayHi("World"));

		Employee emp = helloWorld.getEmployee(1);
		System.out.println(emp.getFirstName());

	}
}

It should print to the screen something like this…

Hello World
John

Thats all for now!

Spotify just announced the launch of a “Resource” section on their official website.

The Resource section contains A LOT of resources in the categories:

• News Sites & Blogs
• Music Finder Sites & Blogs
• Apps and Tools: Remotes
• Apps and Tools: Search Tools
• Apps and Tools: Others
• Developer Resources
• Other Sites
• Personal Playlist Sites
• Automated Playlist Sites

Go check it out, you will definately find a lot of cool links to applications, sites and communities. http://www.spotify.com/en/about/resources/

Döngüsel Bağ (Cyclic Reference) nedir?

Baba-Cocuk iliskisine sahip siniflarda, bir baba sahip oldugu cocuklarina referans tutarken, cocuk da babasina referans tuttugu durumda döngüsel bağ problemi ortaya cikar. Derleyiciler bu durumu anlayip döngüyü bir sekilde kirabilmektedirler. Asil sorun bu iliskideki nesnelerin XML’e bind edilmesi sirasinda ortaya cikabiliyor.  JAXB standardinda bu sorunu ele alma yontemleri bu baglantida gosteriliyor : https://jaxb.dev.java.net/guide/Mapping_cyclic_references_to_XML.html

1.Yontem: @XMLTransient kullanmak:

Bu yontemde, Cocuk sinif icerisindeki baba referansinin yok sayilmasi saglanir. Boylece marshall edilirken Cocuk sinifi icerisinde Baba nesnesi olmaz. Sakincasi istemci Cocuk sinifindan Babasina erisememesi. Örnek olarak:

package data;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;

/**
*
* @author emre
*/
@XmlRootElement
public class Child {

private String name;
private String okulAdi;
private Parent parent;

public Child(){

}

@XmlAttribute
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@XmlAttribute
public String getOkulAdi() {
return okulAdi;
}

public void setOkulAdi(String okulAdi) {
this.okulAdi = okulAdi;
}

@XmlTransient
public Parent getParent() {
return parent;
}

public void setParent(Parent parent) {
this.parent = parent;
}

}

2.Yontem: CycleRecoverable arayuzunu kullanmak

JAXB, cycle reference sorunuyla karsilastiginda, bu arayuzu gerceklestirdigimiz takdirde onCycleDetected metodunda durumu ele almamiza olanak verir. Bu metod bir Object nesnesi doner. Donen nesne, XML’e eklenecek olan nesneyi temsil eder. Burada return null dememiz, Baba icinde cocuk olsun ama cocuk icinde baba olmasin sekline donusur.

package data2;

import com.sun.xml.bind.CycleRecoverable;
import data.Parent;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

/**
*
* @author emre
*/
public class Parent2 implements CycleRecoverable{
private String name;
private String isYeri;
private List<Child2> cocuklar = new ArrayList<Child2>();

public Parent2(){

}

public List<Child2> getCocuklar() {
return cocuklar;
}

public void setCocuklar(List<Child2> cocuklar) {
this.cocuklar = cocuklar;
}

public String getIsYeri() {
return isYeri;
}

public void setIsYeri(String isYeri) {
this.isYeri = isYeri;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Object onCycleDetected(Context arg0) {
Parent2 p = new Parent2();
p.setIsYeri(this.getIsYeri());
p.setName(this.getName());
p.setCocuklar(null);
return p;
//throw new UnsupportedOperationException(“Not supported yet.”);
}
}

A web designing company really does a lot to promote your business in terms of a global approach. Your products or services are very much important to be sold. And it can be done by a web designing company.

Website gives you each and every chance to promote your business at a larger scale. In order to make your website able to globally accessible web designing company with its professionals does its best.

Hans Cyber Technology gives an ample scope of promoting website by its great web designing work.

The bcaching API is intended for use by mobile geocaching apps to retrieve geocache data and have access to a large repository of geocache data without needing to store it all on the device itself. Response data for all requests except for “login” is in the standard GPX format. All query results are restricted to those that are accessible by the authenticated user.

Request format is
http://(www|test).bcaching.com/api/q.ashx?u=<username>&{{REQUEST}}&time=<current-time>&sig=<signature>
where:

• username is a valid bcaching.com username
• current-time is the current mobile device time in “java” milliseconds (i.e. java.util.Date.getTime) or equivalent
• signature is an md5 hash of the querystring plus an md5 hash of the bcaching user’s password.

{{REQUEST}} can be one of the following:

• Verify login only: a=login
  Does nothing more than return success or failure based on the validation of the username password/hashword.

• Find nearest caches (Summary): a=find&lat=<latitude>&lon=<longitude>&find=<find>&maxdistance=<max-distance>&maxcount=<max-count>
  Returns summary-only gpx data — with no short or long descriptions, extra waypoints, logs, etc.

   

  • latitude is the latitude in signed degree decimal form i.e. 40.123456
  • longitude is the longitude in signed degree decimal form i.e. -74.987654
  • find is a URL-encoded string to search for caches by waypoint# (with or without the GC prefix) or partial name match.
  • max-distance is optional and specifies the maximum distance in degrees. Default is 0.3 – about 30 miles
  • max-count is optional and specifies the maximum number of nearest caches to return in the gpx data. Default is 50.

• Get cache detail: a=detail&ids=<cache-id-list>&desc=<description-mode>&wpts=<wpts>&logs=<logs>&tbs=<tbs>
  Returns detailed gpx data for one or more caches

   

  • cache-id-list is a comma-separated list of cache ids (not waypoint numbers). Cache ids are included in the summary gpx request.
  • description-mode indicates what form to send the description and can be one of the following:
    • none: neither short nor long description is included
    • short: short description is included, converted to text if was html
    • long: short and long description are included, converted to text they were html
    • html: full original short and long descriptions are included
  • wpts is a flag indicating whether or not additional waypoints should be included: 0 = no waypoints (default), 1 = include waypoints
  • logs is the maximum number of logs to include: 0 = none (default), 1 or more indicates the maximum number
  • tbs is a flag indicating whether or not cache inventory should be included: 0 = no waypoints (default), 1 = include TBs

• Get nearest caches (Detail): a=nearest&maxcount=<max-count>&desc=<description-mode>&wpts=<wpts>&logs=<logs>&tbs=<tbs>
  • max-count is optional and specifies the maximum number of nearest caches to return in the gpx data. Default is 30.
  • all other parameters (desc, wpts, logs, tbs) are identical to Get cache detail section.