You are viewing a plain text version of this content. The canonical link for it is here.
Posted to users@cxf.apache.org by Diana ALLAM <al...@gmail.com> on 2011/11/29 16:33:42 UTC
RESTful implementations by using cxf
Hello,
After using the restful examples in the "samples" directory of cxf distribution, I distinguished
two types of restful request for "put/post" CRUD methods.
1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
// Sent HTTP PUT request to update customer info
System.out.println("\n");
System.out.println("Sent HTTP PUT request to update customer info");
Client client = new Client();
String inputFile = client.getClass().getResource("update_customer.xml").getFile();
URIResolver resolver = new URIResolver(inputFile);
File input = new File(resolver.getURI());
PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
put.setRequestEntity(entity);
HttpClient httpclient = new HttpClient();
try {
int result = httpclient.executeMethod(put);
System.out.println("Response status code: " + result);
System.out.println("Response body: ");
System.out.println(put.getResponseBodyAsString());
System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
} finally {
// Release current connection to the connection pool once you are
// done
put.releaseConnection();
}
2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
Customer customer = new Customer();
customer.setId(123);
customer.setName("Mary");
Response resp = wc.put(customer);
I prefer to use the second method because in the first method,
a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
method allows to avoid such errors as there is a customer object conform to a specified class Customer.
I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
are generated (like the Customer class in my previous example).
But my question is, when and why a developer need to use the first method?
And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
because I suppose that if he had a wadl then he must use the second method.
Thank you in advance.
Regards,
Diana
Re: RESTful implementations by using cxf
Posted by Diana ALLAM <al...@gmail.com>.
Thanks a lot for your help, your answers clarified many things for me
Best Regards,
Diana.
On 30 nov. 2011, at 15:26, Sergey Beryozkin wrote:
> On 30/11/11 14:05, Diana ALLAM wrote:
>> Hi,
>>
>> On 30 nov. 2011, at 11:59, Sergey Beryozkin wrote:
>>
>>> Hi
>>> On 30/11/11 09:29, Diana ALLAM wrote:
>>>> Hello,
>>>> thank you for your reply.
>>>>
>>>> Currently, I am doing a study about well dynamic typing of web service and I choose cxf
>>>> to run some examples.
>>>> In fact, for SOAP/WS* services, there is a standard used , wsdl files, which are generated by a web service.
>>>> A client can use this wsdl to generate an appropriated interface in java to build an appropriated request to
>>>> the designed web service. Thus, I can say, following this way, there must not be any typing errors.
>>>> But for Restful services, the situation differs a bit. There is a WADL files to describe the web services like the
>>>> WSDL files in SOAP/WS*, but WADL still not a standard.
>>>
>>> it's a W3C submission and it appears users who work with RESTful services and happen to see the benefit of providing the documents such as WADL just use WADL;
>>
>> Yes, but I mean that WADL is not yet used by all Restful services like the WSDL for WS*
>>>
>>>> My question is, if a restful web service doesn't define a WADL, thus the client can't generate in java the appropriated
>>>> classes (like using wadltojava), then how he can know the type of messages?
>>>> I suppose that in the absence of a WADL for a web service, there is a text description file describing all methods and
>>>> there messages types. Thus, the client has to read this document to know how to build his messages.
>>>> Here, he can make mistakes by sending to a restful resource an inappropriate data.
>>>>
>>>> Is my reasoning correct about that?
>>> That may not be that big an issue actually - unless we are talking about the completely generic clients, but indeed, with the fluent HTTP-centric API one just needs to apply a bit more care to making sure the correct messages are sent and such - but as I said if the code
>>> were not corect it work it would fail at the first try, then the user would go and check the SLA or whatever and update the code.
>>> In CXF we support both styles:
>>> http://cxf.apache.org/docs/jax-rs-client-api.html
>>> so choose the option you like or experiment with both ones
>>>
>>> Proxies can also be generated from the existing WADLs:
>>> http://cxf.apache.org/docs/jaxrs-services-description.html
>>>
>>> even WSDLs can be used as the input (this option is a bit more involved)
>>
>> Thank you a lot for these informations.
>> I can deduce that from the client developer side, calling a WS* web service is more standardized than a restful one,
>> because the user can get a WSDL and creates properly a proxy, while for Rest it will not be the case if
>> no Wadl is provided.
>>
>> In your opinion, isn't it an advantage for WS*? Doesn't it an annoying checking problem for restful's clients?
>
> What we do in CXF is we keep our heads down and make sure people can write WS-* and RESTful services the way they need to, that is our philosophy, because in production the issues like styles may not necessarily take a precedence, there are many different factors which can tilt a decision into going with SOAP only, REST only, SOAP & REST; you will see me answering SOAP questions if I happen to remember something :-). I'd suggest to take this particular discussion offline if you don't mind.
>
>> Will WADL be defined for all Restful services in the coming days, such as WSDL for WS* services today?
>>
>
> Clearly, it's very important for many users that something like WADL has a final standard tag, I'm not sure right now if it will make it into a final spec but even if it will some users would still prefer a fluent HTTP-centric API and won't rely on WADL at all
>
> Cheers, Sergey
>
>> Regards,
>>
>> Diana
>>
>>
>>> Sergey
>>>>
>>>>
>>>> Regards,
>>>>
>>>> Diana
>>>>
>>>> On 29 nov. 2011, at 18:01, Sergey Beryozkin wrote:
>>>>
>>>>> Hi
>>>>>
>>>>> On 29/11/11 15:33, Diana ALLAM wrote:
>>>>>> Hello,
>>>>>>
>>>>>> After using the restful examples in the "samples" directory of cxf distribution, I distinguished
>>>>>> two types of restful request for "put/post" CRUD methods.
>>>>>> 1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
>>>>>> Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
>>>>>> // Sent HTTP PUT request to update customer info
>>>>>> System.out.println("\n");
>>>>>> System.out.println("Sent HTTP PUT request to update customer info");
>>>>>> Client client = new Client();
>>>>>> String inputFile = client.getClass().getResource("update_customer.xml").getFile();
>>>>>> URIResolver resolver = new URIResolver(inputFile);
>>>>>> File input = new File(resolver.getURI());
>>>>>> PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
>>>>>> RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
>>>>>> put.setRequestEntity(entity);
>>>>>> HttpClient httpclient = new HttpClient();
>>>>>>
>>>>>> try {
>>>>>> int result = httpclient.executeMethod(put);
>>>>>> System.out.println("Response status code: " + result);
>>>>>> System.out.println("Response body: ");
>>>>>> System.out.println(put.getResponseBodyAsString());
>>>>>> System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
>>>>>> } finally {
>>>>>> // Release current connection to the connection pool once you are
>>>>>> // done
>>>>>> put.releaseConnection();
>>>>>> }
>>>>>>
>>>>>
>>>>> This is a very old code that will be replaced
>>>>>
>>>>>> 2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
>>>>>>
>>>>>> WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
>>>>>> Customer customer = new Customer();
>>>>>> customer.setId(123);
>>>>>> customer.setName("Mary");
>>>>>> Response resp = wc.put(customer);
>>>>>>
>>>>>>
>>>>>> I prefer to use the second method because in the first method,
>>>>>> a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
>>>>>> method allows to avoid such errors as there is a customer object conform to a specified class Customer.
>>>>>>
>>>>>> I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
>>>>>> are generated (like the Customer class in my previous example).
>>>>> Agreed
>>>>>> But my question is, when and why a developer need to use the first method?
>>>>>
>>>>> If developers do prefer using Apache HttpClient for whatever reasons then they may want to use that API
>>>>>
>>>>> Cheers, Sergey
>>>>>
>>>>>> And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
>>>>>> and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
>>>>>> because I suppose that if he had a wadl then he must use the second method.
>>>>>>
>>>>>> Thank you in advance.
>>>>>>
>>>>>> Regards,
>>>>>>
>>>>>> Diana
>>>>>>
>>>>>>
>>>>>
>
>
> --
> Sergey Beryozkin
>
> Talend Community Coders
> http://coders.talend.com/
>
> Blog: http://sberyozkin.blogspot.com
Re: RESTful implementations by using cxf
Posted by Sergey Beryozkin <sb...@gmail.com>.
On 30/11/11 14:05, Diana ALLAM wrote:
> Hi,
>
> On 30 nov. 2011, at 11:59, Sergey Beryozkin wrote:
>
>> Hi
>> On 30/11/11 09:29, Diana ALLAM wrote:
>>> Hello,
>>> thank you for your reply.
>>>
>>> Currently, I am doing a study about well dynamic typing of web service and I choose cxf
>>> to run some examples.
>>> In fact, for SOAP/WS* services, there is a standard used , wsdl files, which are generated by a web service.
>>> A client can use this wsdl to generate an appropriated interface in java to build an appropriated request to
>>> the designed web service. Thus, I can say, following this way, there must not be any typing errors.
>>> But for Restful services, the situation differs a bit. There is a WADL files to describe the web services like the
>>> WSDL files in SOAP/WS*, but WADL still not a standard.
>>
>> it's a W3C submission and it appears users who work with RESTful services and happen to see the benefit of providing the documents such as WADL just use WADL;
>
> Yes, but I mean that WADL is not yet used by all Restful services like the WSDL for WS*
>>
>>> My question is, if a restful web service doesn't define a WADL, thus the client can't generate in java the appropriated
>>> classes (like using wadltojava), then how he can know the type of messages?
>>> I suppose that in the absence of a WADL for a web service, there is a text description file describing all methods and
>>> there messages types. Thus, the client has to read this document to know how to build his messages.
>>> Here, he can make mistakes by sending to a restful resource an inappropriate data.
>>>
>>> Is my reasoning correct about that?
>> That may not be that big an issue actually - unless we are talking about the completely generic clients, but indeed, with the fluent HTTP-centric API one just needs to apply a bit more care to making sure the correct messages are sent and such - but as I said if the code
>> were not corect it work it would fail at the first try, then the user would go and check the SLA or whatever and update the code.
>> In CXF we support both styles:
>> http://cxf.apache.org/docs/jax-rs-client-api.html
>> so choose the option you like or experiment with both ones
>>
>> Proxies can also be generated from the existing WADLs:
>> http://cxf.apache.org/docs/jaxrs-services-description.html
>>
>> even WSDLs can be used as the input (this option is a bit more involved)
>
> Thank you a lot for these informations.
> I can deduce that from the client developer side, calling a WS* web service is more standardized than a restful one,
> because the user can get a WSDL and creates properly a proxy, while for Rest it will not be the case if
> no Wadl is provided.
>
> In your opinion, isn't it an advantage for WS*? Doesn't it an annoying checking problem for restful's clients?
What we do in CXF is we keep our heads down and make sure people can
write WS-* and RESTful services the way they need to, that is our
philosophy, because in production the issues like styles may not
necessarily take a precedence, there are many different factors which
can tilt a decision into going with SOAP only, REST only, SOAP & REST;
you will see me answering SOAP questions if I happen to remember
something :-). I'd suggest to take this particular discussion offline if
you don't mind.
> Will WADL be defined for all Restful services in the coming days, such as WSDL for WS* services today?
>
Clearly, it's very important for many users that something like WADL has
a final standard tag, I'm not sure right now if it will make it into a
final spec but even if it will some users would still prefer a fluent
HTTP-centric API and won't rely on WADL at all
Cheers, Sergey
> Regards,
>
> Diana
>
>
>> Sergey
>>>
>>>
>>> Regards,
>>>
>>> Diana
>>>
>>> On 29 nov. 2011, at 18:01, Sergey Beryozkin wrote:
>>>
>>>> Hi
>>>>
>>>> On 29/11/11 15:33, Diana ALLAM wrote:
>>>>> Hello,
>>>>>
>>>>> After using the restful examples in the "samples" directory of cxf distribution, I distinguished
>>>>> two types of restful request for "put/post" CRUD methods.
>>>>> 1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
>>>>> Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
>>>>> // Sent HTTP PUT request to update customer info
>>>>> System.out.println("\n");
>>>>> System.out.println("Sent HTTP PUT request to update customer info");
>>>>> Client client = new Client();
>>>>> String inputFile = client.getClass().getResource("update_customer.xml").getFile();
>>>>> URIResolver resolver = new URIResolver(inputFile);
>>>>> File input = new File(resolver.getURI());
>>>>> PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
>>>>> RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
>>>>> put.setRequestEntity(entity);
>>>>> HttpClient httpclient = new HttpClient();
>>>>>
>>>>> try {
>>>>> int result = httpclient.executeMethod(put);
>>>>> System.out.println("Response status code: " + result);
>>>>> System.out.println("Response body: ");
>>>>> System.out.println(put.getResponseBodyAsString());
>>>>> System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
>>>>> } finally {
>>>>> // Release current connection to the connection pool once you are
>>>>> // done
>>>>> put.releaseConnection();
>>>>> }
>>>>>
>>>>
>>>> This is a very old code that will be replaced
>>>>
>>>>> 2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
>>>>>
>>>>> WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
>>>>> Customer customer = new Customer();
>>>>> customer.setId(123);
>>>>> customer.setName("Mary");
>>>>> Response resp = wc.put(customer);
>>>>>
>>>>>
>>>>> I prefer to use the second method because in the first method,
>>>>> a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
>>>>> method allows to avoid such errors as there is a customer object conform to a specified class Customer.
>>>>>
>>>>> I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
>>>>> are generated (like the Customer class in my previous example).
>>>> Agreed
>>>>> But my question is, when and why a developer need to use the first method?
>>>>
>>>> If developers do prefer using Apache HttpClient for whatever reasons then they may want to use that API
>>>>
>>>> Cheers, Sergey
>>>>
>>>>> And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
>>>>> and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
>>>>> because I suppose that if he had a wadl then he must use the second method.
>>>>>
>>>>> Thank you in advance.
>>>>>
>>>>> Regards,
>>>>>
>>>>> Diana
>>>>>
>>>>>
>>>>
--
Sergey Beryozkin
Talend Community Coders
http://coders.talend.com/
Blog: http://sberyozkin.blogspot.com
Re: RESTful implementations by using cxf
Posted by Diana ALLAM <al...@gmail.com>.
Hi,
On 30 nov. 2011, at 11:59, Sergey Beryozkin wrote:
> Hi
> On 30/11/11 09:29, Diana ALLAM wrote:
>> Hello,
>> thank you for your reply.
>>
>> Currently, I am doing a study about well dynamic typing of web service and I choose cxf
>> to run some examples.
>> In fact, for SOAP/WS* services, there is a standard used , wsdl files, which are generated by a web service.
>> A client can use this wsdl to generate an appropriated interface in java to build an appropriated request to
>> the designed web service. Thus, I can say, following this way, there must not be any typing errors.
>> But for Restful services, the situation differs a bit. There is a WADL files to describe the web services like the
>> WSDL files in SOAP/WS*, but WADL still not a standard.
>
> it's a W3C submission and it appears users who work with RESTful services and happen to see the benefit of providing the documents such as WADL just use WADL;
Yes, but I mean that WADL is not yet used by all Restful services like the WSDL for WS*
>
>> My question is, if a restful web service doesn't define a WADL, thus the client can't generate in java the appropriated
>> classes (like using wadltojava), then how he can know the type of messages?
>> I suppose that in the absence of a WADL for a web service, there is a text description file describing all methods and
>> there messages types. Thus, the client has to read this document to know how to build his messages.
>> Here, he can make mistakes by sending to a restful resource an inappropriate data.
>>
>> Is my reasoning correct about that?
> That may not be that big an issue actually - unless we are talking about the completely generic clients, but indeed, with the fluent HTTP-centric API one just needs to apply a bit more care to making sure the correct messages are sent and such - but as I said if the code
> were not corect it work it would fail at the first try, then the user would go and check the SLA or whatever and update the code.
> In CXF we support both styles:
> http://cxf.apache.org/docs/jax-rs-client-api.html
> so choose the option you like or experiment with both ones
>
> Proxies can also be generated from the existing WADLs:
> http://cxf.apache.org/docs/jaxrs-services-description.html
>
> even WSDLs can be used as the input (this option is a bit more involved)
Thank you a lot for these informations.
I can deduce that from the client developer side, calling a WS* web service is more standardized than a restful one,
because the user can get a WSDL and creates properly a proxy, while for Rest it will not be the case if
no Wadl is provided.
In your opinion, isn't it an advantage for WS*? Doesn't it an annoying checking problem for restful's clients?
Will WADL be defined for all Restful services in the coming days, such as WSDL for WS* services today?
Regards,
Diana
> Sergey
>>
>>
>> Regards,
>>
>> Diana
>>
>> On 29 nov. 2011, at 18:01, Sergey Beryozkin wrote:
>>
>>> Hi
>>>
>>> On 29/11/11 15:33, Diana ALLAM wrote:
>>>> Hello,
>>>>
>>>> After using the restful examples in the "samples" directory of cxf distribution, I distinguished
>>>> two types of restful request for "put/post" CRUD methods.
>>>> 1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
>>>> Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
>>>> // Sent HTTP PUT request to update customer info
>>>> System.out.println("\n");
>>>> System.out.println("Sent HTTP PUT request to update customer info");
>>>> Client client = new Client();
>>>> String inputFile = client.getClass().getResource("update_customer.xml").getFile();
>>>> URIResolver resolver = new URIResolver(inputFile);
>>>> File input = new File(resolver.getURI());
>>>> PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
>>>> RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
>>>> put.setRequestEntity(entity);
>>>> HttpClient httpclient = new HttpClient();
>>>>
>>>> try {
>>>> int result = httpclient.executeMethod(put);
>>>> System.out.println("Response status code: " + result);
>>>> System.out.println("Response body: ");
>>>> System.out.println(put.getResponseBodyAsString());
>>>> System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
>>>> } finally {
>>>> // Release current connection to the connection pool once you are
>>>> // done
>>>> put.releaseConnection();
>>>> }
>>>>
>>>
>>> This is a very old code that will be replaced
>>>
>>>> 2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
>>>>
>>>> WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
>>>> Customer customer = new Customer();
>>>> customer.setId(123);
>>>> customer.setName("Mary");
>>>> Response resp = wc.put(customer);
>>>>
>>>>
>>>> I prefer to use the second method because in the first method,
>>>> a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
>>>> method allows to avoid such errors as there is a customer object conform to a specified class Customer.
>>>>
>>>> I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
>>>> are generated (like the Customer class in my previous example).
>>> Agreed
>>>> But my question is, when and why a developer need to use the first method?
>>>
>>> If developers do prefer using Apache HttpClient for whatever reasons then they may want to use that API
>>>
>>> Cheers, Sergey
>>>
>>>> And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
>>>> and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
>>>> because I suppose that if he had a wadl then he must use the second method.
>>>>
>>>> Thank you in advance.
>>>>
>>>> Regards,
>>>>
>>>> Diana
>>>>
>>>>
>>>
>>>
>>> --
>>> Sergey Beryozkin
>>>
>>> Talend Community Coders
>>> http://coders.talend.com/
>>>
>>> Blog: http://sberyozkin.blogspot.com
>>
>
>
> --
> Sergey Beryozkin
>
> Talend Community Coders
> http://coders.talend.com/
>
> Blog: http://sberyozkin.blogspot.com
Re: RESTful implementations by using cxf
Posted by Sergey Beryozkin <sb...@gmail.com>.
Hi
On 30/11/11 09:29, Diana ALLAM wrote:
> Hello,
> thank you for your reply.
>
> Currently, I am doing a study about well dynamic typing of web service and I choose cxf
> to run some examples.
> In fact, for SOAP/WS* services, there is a standard used , wsdl files, which are generated by a web service.
> A client can use this wsdl to generate an appropriated interface in java to build an appropriated request to
> the designed web service. Thus, I can say, following this way, there must not be any typing errors.
> But for Restful services, the situation differs a bit. There is a WADL files to describe the web services like the
> WSDL files in SOAP/WS*, but WADL still not a standard.
it's a W3C submission and it appears users who work with RESTful
services and happen to see the benefit of providing the documents such
as WADL just use WADL;
> My question is, if a restful web service doesn't define a WADL, thus the client can't generate in java the appropriated
> classes (like using wadltojava), then how he can know the type of messages?
> I suppose that in the absence of a WADL for a web service, there is a text description file describing all methods and
> there messages types. Thus, the client has to read this document to know how to build his messages.
> Here, he can make mistakes by sending to a restful resource an inappropriate data.
>
> Is my reasoning correct about that?
That may not be that big an issue actually - unless we are talking about
the completely generic clients, but indeed, with the fluent HTTP-centric
API one just needs to apply a bit more care to making sure the correct
messages are sent and such - but as I said if the code
were not corect it work it would fail at the first try, then the user
would go and check the SLA or whatever and update the code.
In CXF we support both styles:
http://cxf.apache.org/docs/jax-rs-client-api.html
so choose the option you like or experiment with both ones
Proxies can also be generated from the existing WADLs:
http://cxf.apache.org/docs/jaxrs-services-description.html
even WSDLs can be used as the input (this option is a bit more involved)
Sergey
>
>
> Regards,
>
> Diana
>
> On 29 nov. 2011, at 18:01, Sergey Beryozkin wrote:
>
>> Hi
>>
>> On 29/11/11 15:33, Diana ALLAM wrote:
>>> Hello,
>>>
>>> After using the restful examples in the "samples" directory of cxf distribution, I distinguished
>>> two types of restful request for "put/post" CRUD methods.
>>> 1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
>>> Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
>>> // Sent HTTP PUT request to update customer info
>>> System.out.println("\n");
>>> System.out.println("Sent HTTP PUT request to update customer info");
>>> Client client = new Client();
>>> String inputFile = client.getClass().getResource("update_customer.xml").getFile();
>>> URIResolver resolver = new URIResolver(inputFile);
>>> File input = new File(resolver.getURI());
>>> PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
>>> RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
>>> put.setRequestEntity(entity);
>>> HttpClient httpclient = new HttpClient();
>>>
>>> try {
>>> int result = httpclient.executeMethod(put);
>>> System.out.println("Response status code: " + result);
>>> System.out.println("Response body: ");
>>> System.out.println(put.getResponseBodyAsString());
>>> System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
>>> } finally {
>>> // Release current connection to the connection pool once you are
>>> // done
>>> put.releaseConnection();
>>> }
>>>
>>
>> This is a very old code that will be replaced
>>
>>> 2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
>>>
>>> WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
>>> Customer customer = new Customer();
>>> customer.setId(123);
>>> customer.setName("Mary");
>>> Response resp = wc.put(customer);
>>>
>>>
>>> I prefer to use the second method because in the first method,
>>> a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
>>> method allows to avoid such errors as there is a customer object conform to a specified class Customer.
>>>
>>> I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
>>> are generated (like the Customer class in my previous example).
>> Agreed
>>> But my question is, when and why a developer need to use the first method?
>>
>> If developers do prefer using Apache HttpClient for whatever reasons then they may want to use that API
>>
>> Cheers, Sergey
>>
>>> And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
>>> and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
>>> because I suppose that if he had a wadl then he must use the second method.
>>>
>>> Thank you in advance.
>>>
>>> Regards,
>>>
>>> Diana
>>>
>>>
>>
>>
>> --
>> Sergey Beryozkin
>>
>> Talend Community Coders
>> http://coders.talend.com/
>>
>> Blog: http://sberyozkin.blogspot.com
>
--
Sergey Beryozkin
Talend Community Coders
http://coders.talend.com/
Blog: http://sberyozkin.blogspot.com
Re: RESTful implementations by using cxf
Posted by Diana ALLAM <al...@gmail.com>.
Hello,
thank you for your reply.
Currently, I am doing a study about well dynamic typing of web service and I choose cxf
to run some examples.
In fact, for SOAP/WS* services, there is a standard used , wsdl files, which are generated by a web service.
A client can use this wsdl to generate an appropriated interface in java to build an appropriated request to
the designed web service. Thus, I can say, following this way, there must not be any typing errors.
But for Restful services, the situation differs a bit. There is a WADL files to describe the web services like the
WSDL files in SOAP/WS*, but WADL still not a standard.
My question is, if a restful web service doesn't define a WADL, thus the client can't generate in java the appropriated
classes (like using wadltojava), then how he can know the type of messages?
I suppose that in the absence of a WADL for a web service, there is a text description file describing all methods and
there messages types. Thus, the client has to read this document to know how to build his messages.
Here, he can make mistakes by sending to a restful resource an inappropriate data.
Is my reasoning correct about that?
Regards,
Diana
On 29 nov. 2011, at 18:01, Sergey Beryozkin wrote:
> Hi
>
> On 29/11/11 15:33, Diana ALLAM wrote:
>> Hello,
>>
>> After using the restful examples in the "samples" directory of cxf distribution, I distinguished
>> two types of restful request for "put/post" CRUD methods.
>> 1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
>> Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
>> // Sent HTTP PUT request to update customer info
>> System.out.println("\n");
>> System.out.println("Sent HTTP PUT request to update customer info");
>> Client client = new Client();
>> String inputFile = client.getClass().getResource("update_customer.xml").getFile();
>> URIResolver resolver = new URIResolver(inputFile);
>> File input = new File(resolver.getURI());
>> PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
>> RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
>> put.setRequestEntity(entity);
>> HttpClient httpclient = new HttpClient();
>>
>> try {
>> int result = httpclient.executeMethod(put);
>> System.out.println("Response status code: " + result);
>> System.out.println("Response body: ");
>> System.out.println(put.getResponseBodyAsString());
>> System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
>> } finally {
>> // Release current connection to the connection pool once you are
>> // done
>> put.releaseConnection();
>> }
>>
>
> This is a very old code that will be replaced
>
>> 2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
>>
>> WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
>> Customer customer = new Customer();
>> customer.setId(123);
>> customer.setName("Mary");
>> Response resp = wc.put(customer);
>>
>>
>> I prefer to use the second method because in the first method,
>> a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
>> method allows to avoid such errors as there is a customer object conform to a specified class Customer.
>>
>> I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
>> are generated (like the Customer class in my previous example).
> Agreed
>> But my question is, when and why a developer need to use the first method?
>
> If developers do prefer using Apache HttpClient for whatever reasons then they may want to use that API
>
> Cheers, Sergey
>
>> And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
>> and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
>> because I suppose that if he had a wadl then he must use the second method.
>>
>> Thank you in advance.
>>
>> Regards,
>>
>> Diana
>>
>>
>
>
> --
> Sergey Beryozkin
>
> Talend Community Coders
> http://coders.talend.com/
>
> Blog: http://sberyozkin.blogspot.com
Re: RESTful implementations by using cxf
Posted by Sergey Beryozkin <sb...@gmail.com>.
Hi
On 29/11/11 15:33, Diana ALLAM wrote:
> Hello,
>
> After using the restful examples in the "samples" directory of cxf distribution, I distinguished
> two types of restful request for "put/post" CRUD methods.
> 1) the first one is by sending a request with an xml object description (samples -> jax_rs -> basic)
> Follows, there is a part of the code example for calling the put method by using an input file containing the "customer" xml code:
> // Sent HTTP PUT request to update customer info
> System.out.println("\n");
> System.out.println("Sent HTTP PUT request to update customer info");
> Client client = new Client();
> String inputFile = client.getClass().getResource("update_customer.xml").getFile();
> URIResolver resolver = new URIResolver(inputFile);
> File input = new File(resolver.getURI());
> PutMethod put = new PutMethod("http://localhost:8080/CustomerRestfullTest/jaxrs/customerservice/customers");
> RequestEntity entity = new FileRequestEntity(input, "text/xml; charset=ISO-8859-1");
> put.setRequestEntity(entity);
> HttpClient httpclient = new HttpClient();
>
> try {
> int result = httpclient.executeMethod(put);
> System.out.println("Response status code: " + result);
> System.out.println("Response body: ");
> System.out.println(put.getResponseBodyAsString());
> System.out.println(put.getResponseHeader(Message.ENDPOINT_ADDRESS));
> } finally {
> // Release current connection to the connection pool once you are
> // done
> put.releaseConnection();
> }
>
This is a very old code that will be replaced
> 2) the second one is by using an instance of a Java class, here is Customer, instead of getting data from an input file (samples -> jax_rs -> basic_https)
>
> WebClient wc = WebClient.create(BASE_SERVICE_URL, CLIENT_CONFIG_FILE);
> Customer customer = new Customer();
> customer.setId(123);
> customer.setName("Mary");
> Response resp = wc.put(customer);
>
>
> I prefer to use the second method because in the first method,
> a developer could make mistakes in his input file, then the server will reply by a fault message, while the second
> method allows to avoid such errors as there is a customer object conform to a specified class Customer.
>
> I think also the second method is more adapted if the client wishes using a wadl file, then by using wadltojava, all the appropriated classes
> are generated (like the Customer class in my previous example).
Agreed
> But my question is, when and why a developer need to use the first method?
If developers do prefer using Apache HttpClient for whatever reasons
then they may want to use that API
Cheers, Sergey
> And by such a use, the developer doesn't take the risk of sending inadapted data to the server?
> and how the developer knows which data description form (for the customer example, it is an xsd) he must use in this case, if he doesn't have a wadl?
> because I suppose that if he had a wadl then he must use the second method.
>
> Thank you in advance.
>
> Regards,
>
> Diana
>
>
--
Sergey Beryozkin
Talend Community Coders
http://coders.talend.com/
Blog: http://sberyozkin.blogspot.com