Service implementation

Create a "locator_service" project first, following the steps as above.

Create a GreeterImpl.java which implements the Greeter interface defined above.

The content of GreeterImpl.java is:

import javax.jws.WebService;

import demo.common.Greeter;
@WebService(targetNamespace = "http://talend.org/esb/examples/", 
        serviceName = "GreeterService")
public class GreeterImpl implements Greeter {

    public String greetMe(String me) {
        System.out.println("Executing operation greetMe");
        System.out.println("Message received: " + me + "\n");
        return "Hello " + me;
    }
}

For each input, a statement "'Hello '+input" will be returned.

This is where the Service Locator becomes useful, because as mentioned at the beginning of this section, the Service Locator is a mechanism to discover service endpoints at runtime.

In order to make the Implementation discoverable, you need to register it first.

There are two ways to register a service: by Spring configuration or by code directly.

For Spring configuration:

The Locator feature is enabled by declaring instances of its classes in the Spring configuration file: <import resource="classpath:META-INF/tesb/locator/beans.xml" />.
```
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:jaxws="http://cxf.apache.org/jaxws"
    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">
    <import resource="classpath:META-INF/cxf/cxf.xml" />
    <import resource="classpath:META-INF/tesb/locator/beans.xml" />

    <jaxws:endpoint xmlns:tns="http://talend.org/esb/examples/"
        id="greeter" implementor="demo.service.GreeterImpl" 
        serviceName="tns:GreeterService"
        address="/GreeterService">
        <jaxws:features>
            <ref bean="locatorFeature"/>
        </jaxws:features>
    </jaxws:endpoint>
</beans>
```
In the Spring file example above, the OSGi import line (classpath:META-INF/tesb/locator/beans.xml) is the only difference from a standard Spring configuration file.

And to add the Locator feature to a CXF service provider, use the <jaxws:features> including the org.talend.esb.servicelocator.cxf.LocatorFeature.

Then load it by using "ClassPathXmlApplicationContext". It is important to include the configuration file in exported bundle and also add the necessary dependencies for Spring configuration.

The alternative code version is:

LocatorFeature locatorFeature = new LocatorFeatureImpl();
Greeter greeterService = new GreeterImpl();
svrFactory = new JaxWsServerFactoryBean();
// WSDL operations that service will implement
svrFactory.setServiceClass(Greeter.class); 
// endpoint service will listen on
svrFactory.setAddress("http://localhost:8082/services/Greeter"); 
// implementation of WSDL operations
svrFactory.setServiceBean(greeterService); 
// attach LocatorFeature to web service provider
svrFactory.getFeatures().add(locatorFeature); 
svrFactory.create();

Similar to , export "locator_service" as a bundle, so the BundleActivator is the best place to register or remove this service:

import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.talend.esb.servicelocator.cxf.LocatorFeature;
import org.talend.esb.servicelocator.cxf.internal.LocatorFeatureImpl;

import demo.common.Greeter;

public class Activator implements BundleActivator {

    private JaxWsServerFactoryBean svrFactory;

    public void start(BundleContext context) throws Exception {
        LocatorFeature locatorFeature = new LocatorFeatureImpl();
        Greeter greeterService = new GreeterImpl();
        svrFactory = new JaxWsServerFactoryBean();
        svrFactory.setServiceClass(Greeter.class);
        svrFactory.setAddress("http://localhost:8082/services/Greeter");
        svrFactory.setServiceBean(greeterService);
        svrFactory.getFeatures().add(locatorFeature);
        svrFactory.create();
    }

    public void stop(BundleContext context) throws Exception {
        svrFactory.destroy();
    }
}

There is all the code you need to provide.

Configure the pom.xml, add the necessary dependencies, and configure the exported bundle information.

Finally, the content of pom.xml is:

<groupId>com.talend.liugang.cxf</groupId>
<artifactId>locator_service</artifactId>
<version>1.0.0</version>
<packaging>bundle</packaging>

<name>locator_service</name>
<url>http://maven.apache.org</url>
<properties>
    <cxf.version>3.3.1</cxf.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-core</artifactId>
        <version>${cxf.version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-rt-frontend-jaxws</artifactId>
        <version>${cxf.version}</version>
        <scope>compile</scope>
    </dependency>
    
    <dependency>
        <groupId>org.apache.cxf</groupId>
        <artifactId>cxf-rt-transports-http-jetty</artifactId>
        <version>${cxf.version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.talend.esb</groupId>
        <artifactId>locator</artifactId>
        <version></version>
    </dependency>
    
    <dependency>
        <groupId>${project.groupId}</groupId>
        <artifactId>locator_common</artifactId>
        <version>${project.version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.felix</groupId>
        <artifactId>org.osgi.core</artifactId>
        <version>1.4.0</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.felix</groupId>
            <artifactId>maven-bundle-plugin</artifactId>
            <extensions>true</extensions>
            <version>2.3.7</version>
            <configuration>
                <instructions>
                    <Bundle-SymbolicName>
                        ${project.artifactId}
                    </Bundle-SymbolicName>
                    <Import-Package>demo.common,javax.jws,
                        org.apache.cxf.endpoint,org.apache.cxf.jaxws,
                        org.osgi.framework,org.talend.esb.locator
                    </Import-Package>
                    <Bundle-Activator>demo.service.Activator</Bundle-Activator>
                    <Require-Bundle>
                        org.apache.cxf.bundle;version=""
                    </Require-Bundle>
                </instructions>
            </configuration>
        </plugin>
    </plugins>
</build>

Install it into Maven by running Maven Install.

Now the Service interface is defined, and implemented. It is time to write a client which will consume the service.

Did this page help you?