[원본 출처] http://cxf.apache.org/docs/how-do-i-develop-a-client.html


CXF provides you with many options to build clients for your services. This guide is meant to give you a quick overview of those options and help you orient yourself quickly with CXF.
CXF는 당신의 서비스를 위한 클라이언트를 빌드하기 위한 많은 옵션을 제공한다. 이 가이드는 당신에게 그 옵션들에 대한 빠른 개요와 CXF로 빠르게 규명짓는 것을 돕는 것을  의미한다.

Building Clients (클라이언트 빌드하기)

WSDL2Java generated Client (WSDA2Java 생성된 클라이언트)

One of the most common scenarios is that where you have a service which you may or not manage and this service has a WSDL. In this case you'll often want to generate a client from the WSDL. This provides you with a strongly typed interface by which to interact with the service. Once you've generated a client, typical usage of it will look like so:
가장 일반적인 시나리오중 하나는 어디에 당신이 관리하거나 또는 아닌 서비스를 가지고 있고 그 서비스는 WSDL을 가지고 있다. 이 경우에 당신은 종종 WSDL을 통해서 클라이언트를 생성하는 것을 원하게 될 것이다. 이는 당신이 서비스와 상호작용하는 것에 의해 강한 형식의 인터페이스를 제공한다. 한번 당신은 클라이언트를 생성한 후에 전형적인 그것의 사용예는 다음처럼 보이게 될 것이다. 

HelloService service = new HelloService();
Hello client = service.getHelloHttpPort();
 
String result = client.sayHi("Joe");

The WSDL2Java tool will generate JAX-WS clients from your WSDL. You can run WSDL2java one of three ways:
WSDL2Java 툴은 WSDL로 부터 JAX-WS 클라이언트를 생성하게 될 것이다. 당신은 3가지 방법 중에 하나로 WSDL2java 실행 할 수 있다.

For more in depth information read Developing a JAX-WS consumer or see the Hello World demos inside the distribution. 더 자세한 정보는  Developing a JAX-WS consumer 또는 배포판 안쪽에 Hello World 데모를 보라.

JAX-WS Proxy JAX-WS 프록시

Instead of using a wsdl2java-generated stub client directly, you can use Service.create to create Service instances, the following code illustrates this process:
직접 wsdl2java로 생성된 stub 클라이언트를 사용하는 것 대신에 당신은 Service.create를 Service instances를 생성하기 위해 사용할 수 있다. 

import java.net.URL;
import javax.xml.ws.Service;
...
 
URL wsdlURL = new URL("http://localhost/hello?wsdl");
QName SERVICE_NAME = new QName("http://apache.org/hello_world_soap_http", "SOAPService");
Service service = Service.create(wsdlURL, SERVICE_NAME);
Greeter client = service.getPort(Greeter.class);
String result = client.greetMe("test");

JAX-WS Dispatch APIs (JAX-WS Dispatch API들)

JAX-WS provides the "dispatch" mechanism which makes it easy to dynamically invoke services which you have not generated a client for. Using the Dispatch mechanism you can create messages (which can be JAXB objects, Source objects, or a SAAJMessage) and dispatch them to the server. A simple example might look like this:
JAX-WS 는 클라이언트를 생성하지 않고 동적으로 서비스를 호출 하는 것을 쉽게 만들기 위해 "dispatch" 매카니즘을 제공한다. Dispatch 매카니즘을 사용하여 당신은 메지를 생성할 수 있다 (JAXB 오프젝트, Source 오브젝트, 또는 SAAJMessage를 사용할 수 있고 ) 그리고 서비스에 그것들을 빨리 내보낼수 있다. 단순 에지는 이것처럼 보일지 모른다.

import java.net.URL;
import javax.xml.transform.Source;
import javax.xml.ws.Dispatch;
import javax.xml.ws.Service;
...
 
URL wsdlURL = new URL("http://localhost/hello?wsdl");
Service service = Service.create(wsdlURL, new QName("HelloService"));
Dispatch<Source> disp = service.createDispatch(new QName("HelloPort"), Source.class, Service.Mode.PAYLOAD);
 
Source request = new StreamSource("<hello/>")
Source response = disp.invoke(request);

NOTE: you can also use dispatches without a WSDL.
참조 : 당신은 WSDL 없이 디스패치를 사용할 수 있다.

For more in depth information see the Hello World demos inside the distribution.
더 자세한 깊은 정보는 배포판 안쪽에 Hello World 를 보라.

Simple Frontend Client Proxy (단순 프론트엔드 클라이언트 프록시)

If you've developed a service using the simple frontend, you can use the ClientProxyFactoryBean API to create a Java proxy client for your service. This way you can use the service interface to talk to your service. For more information see the Simple Frontend documentation.
만약 당신이 단순 프론트엔드를 사용하여 서비스를 개발 했다면, 당신은 서비스에 Java 프록시 클라이언트를 생성하기 위해 ClientProxyFactoryBean API를 사용할 수 있다. 이 방법은 당신이 서비스와 대화하기 위해 서비스 인터페이스를 사용한다. 더 많은 정보는 Simple Frontend 문서를 보라.

Dynamic Client (동적 클라이언트)

CXF includes a Client interface which allows you to invoke operations and pass parameters for those operations. For instance:
CXF는 당신이 동작을 호출하고 그 동작의 파라미터를 전달하는 것을 허용하는 클라이언트 인터페이스를 포함한다. 예를들면 

Client client = ....;
Object[] result = client.invoke("sayHi", "Dan");

There are two ways to create Clients at runtime. The first choice is to use the ClientFactoryBean or JaxWsClientFactoryBean classes. These will create proxy objects for the SEI for the service. These proxies cannot handle complex objects.
실시간으로 클라이언트를 생성하는 두가지 방법이 있다. 첫번째 선책은 ClientFactoryBean 이나 JaxWsClientFactoryBean 클래스를 사용 하는 것이다. 그들은 서비스의 SEI를 위한 프록시 오브젝트를 생성한다. 그 프록시들은 복잡한 오프젝트들을 핸들링 할 수 없다.

The second to use the DynamicClientFactory or one of its subclasses. The DynamicClientFactory goes the additional step of generating and compiling JAXB POJOs for complex objects described in the WSDL, for use at runtime via reflection.
두번째로 DynamicClientFactory 나 그것의 서브클래스 중에하나를 사용하는 것이다. DynamicClientFactory 는 reflection을 통해 실시간으로 사용하기 위해 WSDL로 기술된 복잡한 오브젝트 생성되고 컴파일링된 JAXB POJO들에 추가적 단계를 진행한다.

This is most useful when you're using a dynamic language such as Groovy with CXF, but it is possible to use reflection directly from Java.
이는 당신이 CXF에 동적인 언어 즉 Groovy 같은 언어를 사용할때  가장 유용하다. 그러나 그것은 Java로 부터 직접 reflection을 사용하는 것이 가능하다.

More Information: Dynamic Clients


[원본 출처] http://cxf.apache.org/docs/how-do-i-develop-a-service.html


CXF provides you with many options to build services. This guide is meant to give you a quick overview of those options and help you orient yourself quickly with CXF.
CXF 는 서비스를 빌드 하기 위해 많은 옵션을 제공한다. 이 가이드는 그런 옵선의 빠른 개요와 CXF로 빠르게 규명짓는 것을 돕는 것을 의미한다. 

Different Types Of Services
서비스의 다른 유형들

CXF support three major types of services:
CXF 서비스의 3가지 주요 유형을 지원한다.

  • SOAP - this page summarizes the options for creating SOAP services.
    SOAP - 이 페이지는 SOAP 서비스를 생성하기 위해 옵션을 요약한다.
  • REST-ful - REST support is described here.
    REST-ful - REST 지원은 여기 기술되어 있다.
  • CORBA

JAX-WS Annotated Services from Java
Java 에서 JAX-WS 어노테이션 된 서비스들

The JAX-WS APIs include a set of annotations which allow you to build services using annotated classes. These services are based on a single class which contains a set of operations.
JAX-WS API들은 어노테이션된 클래스를 사용하여 서비스를 빌드하는 것을 허용하는 annotations 의 집합을 포함한다. 그 서비스들은 동작들의 집합을 포함하는 단일 클래스에 기반한다.

Here's a simple example:
여기 단순한 예가 있다.

@WebService
public class Hello {
  public String sayHi(String name) {
    return "Hello " + name;
  }
}

JAX-WS includes many more annotations as well such as:
JAX-WS 다음 과 같은 더 많은 어노테이션들을 포함한다.

  • @WebMethod - allows you to customize the operation name, exclude the operation from inclusion in the service, etc
    @WebMethod - 서비스 등에서 포함에서 동작을 제외 하는 동작 명을 사용자 정의 하는 것을 허용한다.
  • @WebParam - allows you to customize a parameter's name, namespace, direction (IN or OUT), etc
    @WebParam - 파라미터의 이름과 네임스페이스, 방향 (IN or OUT) 등을 사용자 정의 하는 것을 허용한다.
  • @WebResult - allows you to customize the return value of the web service call
    @WebResult - 리턴 값을 사용자 정의 하는 것을 허용한다. 

Data is marshalled from XML to Java and vice versa via the JAXB data-binding.
Data는 XML에서 Java로 반대의 경우도 마찬가지로 JAXB data-binding을 통해 정렬된다. 

Services are publish via one of two means:
서비스들은 두 방법중 하나를 통해 발행된다.

  • The JAX-WS standard Endpoint APIs
    JAX-WS 표준 Endpoints API들
  • CXF's XML configuration format - i.e. <jaxws:endpoint ... />
    CXF의 XML 환경 구성 규격 - 즉 <jaxws:endpoint ... />

More Information: A simple JAX-WS serviceDeveloping a JAX-WS Service (goes into much more depth), Writing a service with Spring
더 많은 정보 :  A simple JAX-WS serviceDeveloping a JAX-WS Service(좀 더 많이 깊이 있는 ), Writing a service with Spring

JAX-WS Annotated Services from WSDL
WSDL로 부터 JAX-WS 어노테이션 된 서비스들

If you have existing WSDLs for your service or wish to write your WSDL first and then generate classes, CXF has many tools to help you do this.
만약 당신이 서비스를 위해 존재하는 WSDL들을 가지고 있으면 또는 당신이 먼저 WSDL을 작성하기를 원하면 class들을 생성하기를 원하면 CXF 는 그것을 하기는 것을 돕기 위한 많은 툴을 가지고 있다.

The WSDL2Java tool will generate a JAX-WS annotated service and server stub from your WSDL. You can run it one of three ways:
WSDL2Java 툴이 WSDL로 부터  JAX-WS 어노테이션 된 서비스와 서버 스텁을 생성하게 될 것이다. 

Note that CXF generally restricts WSDL support to WSI-BP, not the full WSDL 1.1 specification.

CXF는 일반적으로 WSI-BP를 지원하는 WSDL을 제한하고 WSDL 1.1 스팩 전체를 지원 하는 것은 아니다는 것을 참조하라.

There is also a Simple Frontend that allows you to create services without usage of Java annotations, using XML configuration files instead.
XML 환경 구성파일을 대신 사용하여 Java 어노테이션을 사용없이 서비스를 생성하는 것을 허용하는 단순 프론트엔드이다 

JAX-WS Providers

JAX-WS Providers allow you to create services which work at the message level - as opposed to the operation level as with annotated classes. The have a single operation "invoke" which receives either the message payload (i.e. the SOAP Body) or the whole message itself (i.e. the SOAP Envelope).

JAX-WS Provider는 어노테이션된 클래스로서 동작 레벨에 반대하여 메시지 레벨에 작업하는 서비스를 생성하는 것을 허용한다. SOAP Body와 같이 미리 지불된 메시지 이거나 SOAP Envelope 같은 전체 메시지를 수신 받는 단일 동작 "invoke" 를 가진다.

Here's a simple example:
간단한 예제가 있다.

@WebServiceProvider
public class HelloProvider {
  public Source invoke(Source request) {
    return ....;
  }
}

Services are publish via one of two means:
서비스는 두가지 방법 중 하나로 발행된다.

  • The JAX-WS standard Endpoint APIs
  • CXF's XML configuration format - i.e. <jaxws:endpoint ... />

More Information: Developing a JAX-WS Service

Javascript

CXF provides a Javascript module which allows you to build services in Javascript with the Java Rhino library. One advantage of this is that you can use E4X to interact more easily with the XML. For more information see the JavaScript page.
CXF 는 Java Rhino library로 Javascript에서 서비스를 빌드 하는 것을 허용하는 Javascript module 을 제공한다. 이 잇점 중에 하나로 당신은 XML로 쉽게 상호작용하기 위해서 E4X를 사용할 수 있다. 더 많은 정보는  JavaScript page를 보라


[원본 출처] http://cxf.apache.org/docs/how-do-i-integrate-my-application-with-cxf.html


CXF provides a broad variety of touch points which your application can take advantage of. This guide should give you an overview of some of the features and options at your disposal.
CXF 는 어플리케이션이 활용할수 있는 넓은 터치 포인트의 다양성을 제공한다. 이 가이드는 당신에게 기능의 몇몇 개요와 처리 옵션을 줄 것이다.

Transports 

CXF works with many different transports. Currently CXF includes support for HTTPJMS, and Local (that is, "in-JVM") transports. The local transport is unique in that it will not work across machines, but simply sends messages in memory. You can also configure the local transport to avoid serialization by using the Object binding or the colocation feature if desired. You can also write your own transport.
CXF 는 많은 transports로 동작한다. 현재 CXF는 HTTPJMS, 과 Local (that is, "in-JVM") transports를 지원 하는 것을 포함한다. local transport는 머신간에 동작하지 않지만 단순히 메모리에 메시지를 보내는 것이 유일하다.  당신은 또한 Object 바인딩과 당신이 희망하는 colocation 기능을 사용하게 됨으로써 직렬화를 피하기 위해 local transport를 환경 구성할 수 있다. 당신은 또한 자체의 transport으로 쓸 수 있다.

Bindings (바인딩)

Bindings map a particular service's messages to a particular protocol. CXF includes support for several different bindings. The SOAP binding, which is the default, maps messages to SOAP and can be used with the various WS-* modules inside CXF. The Pure XML binding avoids serialization of a SOAP envelope and just sends a raw XML message. There is also an HTTP binding which maps a service to HTTP using RESTful semantics.
바인딩은 특별한 프로토콜에 틀별한 서비스의 메시지를 맵핑한다. CXF는 몇몇 다른 바인딩을 지원하는 것을 포함한다. 기본적인 SOAP 바인딩은 SOAP에 메시지를 매핑하고 CXF 내에서 다양한 WS-* 모듈이 사용 될 수 있다. 순수  XML 바인딩은 SOAP envelop의 직렬화를 피하고 단지 원시 XML 메시지를 보낸다. 또한 RESTful 문법(의미론)을 사용하여 HTTP에 서비스를 맵핑하는 HTTP binding 이 있다.

Message Interception and Modification
(메시지 통합과 수정)

Many times you may want to provide functionality for your application that works at a low level with XML messages. This commonly occurs through functionality referred to as Handlers or Interceptors. Handlers/Interceptors are useful for:
많은 시간 당신은  XML 메시지로 로우레벨에서 동작하는 어플리케이션을 위해 기능들을 제공하는 것을 원한다. 이것은 일반적으로  Handlers 나 Interceptors에 참조된  기능을 통해서 발생한다. 

  • Performing authentication based on Headers
    헤더에 기반한 인증을 수행하기
  • Processing custom headers
    사용자정의 헤더 처리하기
  • Transforming a message (i.e. via XSLT or GZip)
    메시지 변환하기(즉 XSLT 또는 GZip을 통해)
  • Redirecting a message
    메시지 리다이렉션하기
  • Getting access to the raw I/O or XML stream
    원시 I/O 또는 XML stream에 접근하기

JAX-WS Handlers (JAX-WS 핸들러)

If you are using the JAX-WS frontend, JAX-WS supports the concept of logical and protocol handlers. Protocol handlers allow you to manipulate the message in its raw, often XML-based, form - i.e. a SAAJ SOAPMessage. Logical handlers allow you to manipulate the message after its already been bound from the protocol to the JAXB object that your service will receive. See this article to learn more about JAX-WS handlers.
만약 당신이 JAX-WS frontend를 사용한다면 JAX-WS는 로컬 또는 프로토콜 핸들러의 개념을 지원한다. 프로코콜 핸들러는 당신이 그것의 가공되지 않는 메시지 종종 XML 기반 form 즉 SAAJ SOAPMessage를 다루는 것을 허용한다. 로컬 핸들러는 당신이 받게 될 서비스의 JAXB 오프젝트에 프로토콜로 부터 이미 바인드된 뒤에 메시지를 다루는 것을 허용한다.

Interceptors (인터셉터)

Interceptors provide access to all the features that CXF has to offer - allowing you to do just about anything, including manipulating the raw bytes or XML of the message.
Interceptors 는 가공되지 않는 Byte 또는 XML 메시지를 다루는 것을 포함하여 단지 무엇을 하는지를 허용하는 CXF가 제공하는 모든 기능에 접근 하는 것을 허용한다. 

Transmitting Binary Data (바이너리 데이타 전송하기)

CXF provides facilities to transmit binary data efficiently via a standard called MTOM. Normally binary data inside an XML message must be Base64 encoded. This results in processing overhead and increases message size by 30%. If you use MTOM, CXF will send/receive MIME messages with the message stored as a MIME attachment, just like email. This results in much more efficient communication and allows you to transmit messages much larger than memory.
CXF 는 MTOM 이라는 표준을 통해서 능률적으로 바이너리 데이타를 전송하기 위한 설비를 제공한다. 보통 XML 메시지 안쪽에 바이너리 데이타는 Base64로 인코딩 되어야 한다. 처리 하는 결과는 과부화되고 30% 메시지 사이즈 증가한다. 만약 당신이 MTOM을 사용하면 CXF는 이메일 처럼 MIME 첨부로써 저장된 메시지로 MIME 메시지를 보내고 받게 될 것이다. 그것은 좀 더 많은 충분한 통신결과이고 메모리보다 더 큰 메시지를 전송하는 것을 허용한다.

WS-*

CXF provides support for a variety of WS-* specifications.
CXF 는 WS-* 명세의 종류를 지원을 제공한다.

Invokers 

Invokers allow you to customize how a particular method or backend service object is executed. This is particularly useful if your underlying service objects are not plain javabeans and instead need to be created or looked up via a custom factory.
Invokers 는 당신이 특별한 메서드 또는 백엔드 서비스 오프젝트를 실행하는  방법을 사용자정의 하는 것을 허용한다. 만약 당신이 제일 밑에 있는 서비스 오프벡트가 순수한 자바 빈즈 그리고 사용자정의 Factory를 통해 생성되거나 찾게 될 필요가 있는 대신으로써 이것은 특별히 유용하다. 



[원본 출처] http://cxf.apache.org/docs/why-cxf.html


With so many options available to developers today in the web services space, one of the questions worth asking is why should I use CXF? In no particular order, here are some of the reasons you might want to use CXF:
웹서비스에서 가능한 많은 옵션을 가진 요즘 개발자들에게 왜 CXF를 사용해야 하는가? 라고 묻는 가치있는 질문 중에 하나는 특별한 순서 없이, 여기 당신이 CXF를 사용하는 것을 원할지 모르는 몇가지 이유가 있다.

JAX-WS Support (JAX-WS 지원)

CXF implements the JAX-WS APIs which make building web services easy. JAX-WS encompasses many different areas:
CXF는 웹서비스를 쉽게 만들기 위해 JAX-WS API를 구현했다. JAX-WS는 많은 다른 영역을 포함한다.

  • Generating WSDL from Java classes and generating Java classes from WSDL
    Java 클래스들로 부터 WSDL 생성하기와 WSDL로 부터 Java 클래스들 생성하기
  • Provider API which allows you to create simple messaging receiving server endpoints
    단순히 메시지를 받는 서버 Endpoints를 허용하는 Provider API 
  • Dispatch API which allows you to send raw XML messages to server endpoints
    원시 XML 메시지를 서버의 Endpoints에 보내는 것을 허용하는 Dispatch API
  • Much more...

Spring Integration (Spring 통합)

Spring is a first class citizen with Apache CXF. CXF supports the Spring 2.0 XML syntax, making it trivial to declare endpoints which are backed by Spring and inject clients into your application.
Spring은 Apache CXF를 사용하는  첫 클래스 주민이다(?) CXF는 당신의 어플리케이션에 Spring과 주입으로 지원을 받은 선언된 Endpoints에 그것을 진부하게 만드는 Spring 2.0 XML 구문을 지원한다.

Aegis Databinding (Aegis 데이타 바인딩)

Aegis Databinding (2.0.x) is our own databinding library that makes development of code-first web services incredibly easy. Unlike JAXB, you don't need annotations at all. It also works correctly with a variety of datatypes such as Lists, Maps, Dates, etc. right out of the box. If you're building a prototype web services that's really invaluable as it means you have to do very little work to get up and running (and one of the primary reasons XFire was started a while back)
Aegis Databinding (2.0.x) 은 믿을수 없이 쉽게 웹서비스의 첫 코드를 개발만드는데 자체의 데이타바인딩 라이블러리이다. JAXB를 좋아 하지 않으면 당신은 모든 어노테이션을 필요로 하지 않는다. 그것은 또한 List나 Maps나 Dates등 같은 다양한데이타 유형을 가지고 정확하게 동작한다.  바로 특출ㅎ게 만약 당신이 웹서비스의 프로토 타입을 만들고 있다면 그것은 웹서비스를 올리고 실행하기 위해 매우 작은 작업으로 해야 한다는 의미로 진짜로 귀중하다. 

RESTful services (RESTful 서비스)

CXF enables the development of RESTful services via annotations using the HTTP Binding. Using URI templates and annotations you can bind a service operation to arbitrary URL/verb combinations. For instance, you can annotate a getCustom method with @Get @HttpResource("/customers/{id}"). CXF will then listen for GET requests on that URL and using the parameter at the {id} location as a parameter to the service.
CXF 는 HTTP Binding 을 사용하는 어노테이션을 통해서 RESTful 서비스들의 개발을 가능하게 한다. URI 템플릿과 어노테이션을 사용여 당신은 서비스 운영을 독자적인 URL/verb 조합으로 바인딩할 수 있다. 예를 들면 당신은 getCustom 메서드에 @Get @HttpResource("/customers/{id}")를 사용하여 어노테이션 할 수 있다. CXF 는 GET URL에 요청과 서비스의 파라터로써 {id} 위치에 파라미터를 사용하여 리스팅하게 될 것이다. 

WS-* Support (WS-* 지원)

CXF supports a variety of web service specifications including WS-Addressing, WS-Policy, WS-ReliableMessaging and WS-Security.
CXF는  WS-Addressing, WS-Policy, WS-ReliableMessaging 와 WS-Security를 가지고 웹서비스 명세의 다양성을 지원한다.

Apache Licensed (아파치 라이선스된)

CXF comes under the liberal Apache license, making CXF great for all types of applications.
CXF 는 applications의 모든 유형을 위한 다수의 CXF를 만드는 것은 자유 Apache license 하에서 나온다. 


+ Recent posts