Completed Functionality and CXF analogues

For more details on how to migrate:

• Are you using the ObjectServiceFactory, AnnotationServiceFactory, or JAXWSServiceFactory? Go->
• Are you using the Spring ServiceBean? Go->
• Are you using the Spring XFireExporter? Go->
• Are you using the XFireServlet? Go->

Should I Migrate Yet?

XFire users should consider migrating to CXF. Anyone looking to start a new web services project should seriously consider CXF. The main barrier is liable to be documentation at this moment. We will be adding LOTS more documentation though over the next couple weeks as we move toward the 2.0 final release.

CXF includes many new features for XFire users:

• Improved WSDL support
• Improved JAX-WS support
• Improved JMS transport
• Maven plugins
• Spring 2.0 syntax support
• Improved WS-* support
• Cleaned up APIs for building services
• Easier to use extension points
• RESTful services support
• Support for a "bare" XML binding, which doesn't include a SOAP envelope

Who should not migrate

There a couple small areas where we haven't replicated all of the XFire functionality yet. Namely the JiBX and XMLBeans databindings. These will be ported for CXF 2.1. The only other reason not to migrate to CXF that we see is a requirement for Java 1.4. Although, we would encourage users to take a look at using CXF on Java 1.4 via Retrotranslator.

Service Factories

XFire included serveral service factories for building services. CXF also includes service factories, but the concept has been improved somewhat to make them easier to use. CXF now includes the concept of ServerFactoryBeans which produce Servers, ClientFactoryBeans which produce Clients, and ClientProxyFactoryBeans which produce Client proxies.

CXF now includes the following classes:

• ServerFactoryBean - This creates a server endpoint from a class
• ClientProxyFactoryBean - this creates a client proxy from a class
• JaxWsServerFactoryBean - This creates a JAX-WS server endpoint from a class or WSDL
• JaxWsProxyFactoryBean - this creates a JAX-WS client proxy from a class

Its important to keep in mind a few differences in how CXF works compared to XFire:

• CXF uses a bean factory approach. This means that there is one (Server/ClientProxy)FactoryBean per endpoint. In XFire these beans could be reused.
• CXF requires that you specify the endpoint address, unless it finds it in your WSDL. If you're using HTTP this has some nice benefits.
  • If you haven't set up the Servlet transport, it will automatically start an embedded Jetty instance for you. In XFire this required you to use the XFireHttpServer class, resulting in additional work.
  • This allows you to map services to different URLs easier. In XFire the way URLs were mapped to Services was much more static.
• When you specify an endpoint address for your service, it's important to remember that when you're using the sServlet you don't need to specify the host name. Lets say you set up the CXFServlet to listen on "http://localhost/services". If you specify your endpoint address as "/myservice" then all requests that come to "http://localhost/services/myservice" will go to your service.
• JAXB is now the default databinding. Any time you want to use Aegis, you must explicitly say so.

Example ObjectServiceFactory Migration

Here is an example of using the ObjectServiceFactory in XFire:

ObjectServiceFactory osf = new ObjectServiceFactory();
Service service = osf.create(MyServiceInterface.class);
service.setInvoker(new BeanInvoker(new MyServiceImpl());

This would be the CXF equivalent:

ServerFactoryBean sf new ServerFactoryBean();
sf.getServiceFactory().setDataBinding(new AegisDatabinding();
sf.setServiceBean(new MyServiceImpl());
sf.setServiceClass(MyServiceInterface.class);
sf.setAddress("http://localhost:8080/myservice");
sf.create();

Example AnnotationServiceFactory Migration

Here is an example of using the AnnotationServiceFactory in XFire:

AnnotationServiceFactory osf = new AnnotationServiceFactory();
Service service = osf.create(MyServiceInterface.class);
service.setInvoker(new BeanInvoker(new MyServiceImpl());

This would be the CXF equivalent:

JaxWsServerFactoryBean sf = new JaxWsServerFactoryBean ();
sf.getServiceFactory().setDataBinding(new AegisDatabinding();
sf.setServiceClass(MyServiceImpl.class);
sf.setAddress("http://localhost:8080/myservice");
sf.create();

Example JAXWSServiceFactory Migration

Here is an example of using the JAXWSServiceFactory in XFire:

JAXWSServiceFactory sf = new JAXWSServiceFactory();
Service service = sf.create(MyServiceImpl.class);
service.setInvoker(new BeanInvoker(new MyServiceImpl());

This would be the CXF equivalent:

JaxWsServerFactoryBean sf = new JaxWsServerFactoryBean();
sf.setServiceClass(MyServiceImpl.class);
sf.setAddress("http://localhost:8080/myservice");
sf.create();

HTTP and Servlet Setup