Are You Recruiter/Hiring Manager?
Cloud-based Candidate Screening | Online Tests
PMP 1600 Questions
PMP 1600 Questions
1600 PMP mock questions 1400 CAPM mock questions 800 SCJP 6 mock questions 600 OCAJP 7 mock questions 590 OCPJP 7 mock questions 556 SCWCD 5 mock questions 500 OCEJWCD 6 mock questions pdfDownload (java,struts, hibernet etc)

Tutorial Home


  • Advantage of Hibernate over JDBC
  • Hibernate Setup with an web Application
  • First Hibernate Application
  • Hibernate mapping with Database TABLE
  • Hibernate Data Type-Java Data Type - SQL Data Type mapping
  • One to Many Relation in Hibernate
  • One to Many Relation in Hibernate bi-directional
  • Many to Many Relation in Hibernate
  • HQL: The Hibernate Query Language
  • Criteria Queries
  • Criteria Queries : Equal (eq), Not Equal(ne), Less than (le), greater than (gt),greater than or equal(ge) and Ordering the results
  • Criteria Queries: And OR conditions
  • Hibernate generator to generate id (primary key)
  • prevent concurrent update in Hibernate,slate object updatation in Hibernate,version checking in Hibernate


  • Model View Controller (MVC)
  • Model View Controller (MVC)
  • Struts Flow-How Struts Works?
  • Struts Tutorial - Struts Setup- First Struts Action class setup
  • Message Resources
  • Validation Framework
  • Validation Framework-client side
  • ForwardAction
  • IncludeAction
  • DispatchAction
  • LookupDispatchAction
  • DynaActionForm
  • DynaActionForm
  • Struts Tutorial - Mutli-click prevention using struts tokens-Prevent Duplicate Submission
  • Logic Iterate Map and List


  • JSP Tutorial
  • Introduction to JSP
  • JSP Comments
  • JSP Syntax
  • JSP Scripting Elements :Scriptlet, expression, declaration
  • JSP Directives
  • implicit objects in JSP
  • JSP Actions
  • Introduction to JSP
  • jsp:useBean
  • The jsp:setProperty Action
  • The jsp:getProperty Action
  • Introduction to JSP


  • Spring Tutorial
  • Introduction to Spring
  • Benefits of Using Spring Framework
  • Inversion of Control in Spring
  • Introduction to BeanFactory
  • Dependency Injection in Spring
  • Collections Setter Injection
  • Bean Scopes in Spring
  • Spring IOC Setup Step by Step
  • Bean Lifecycle in Spring
  • ApplicationContext
  • MessageSources in Spring
  • Web Spring MVC framework
  • Developing Your First Spring Web Application
  • Developing Your Second Spring Web Application with Spring Form
  • Developing Your First Spring Web Application with Spring Validation Framework with Code Example
  • Spring integration with Hibernate
  • Create a SOAP message that contains an attachment.

    The SOAP with Attachments API for Java (SAAJ) provides a standard way to send XML documents over the Internet from the Java platform. It is based on the SOAP 1.1 and SOAP with Attachments specifications, which define a basic framework for exchanging XML messages.

    The process of creation and sending SOAP message includes following steps:

    • Creating a SOAP connection

    • Creating a SOAP message

    • Populating the message

    • Sending the message

    • Retrieving the reply

    A SAAJ client is a standalone client. That is, it sends point-to-point messages directly to a Web service that is implemented for request-response messaging. Request-response messaging is synchronous, meaning that a request is sent and its response is received in the same operation. A request-response message is sent over a SOAPConnection object via the method, which sends the message and blocks until it receives a response. A standalone client can operate only in a client role, that is, it can only send requests and receive their responses.

    A SOAPMessage object represents an XML document that is a SOAP message. A SOAPMessage object always has a required SOAP part, and it may also have one or more attachment parts. The SOAP part must always have a SOAPEnvelope object, which must in turn always contain a SOAPBody object. The SOAPEnvelope object may also contain a SOAPHeader object, to which one or more headers can be added.

    A SOAPMessage object represents an XML document that is a SOAP message. A SOAPMessage object always has a required SOAP part, and it may also have one or more attachment parts. The SOAP part must always have a SOAPEnvelope object, which must in turn always contain a SOAPBody object. The SOAPEnvelope object may also contain a SOAPHeader object, to which one or more headers can be added.

    The SOAPBody object can hold XML fragments as the content of the message being sent. If you want to send content that is not in XML format or that is an entire XML document, your message will need to contain an attachment part in addition to the SOAP part. There is no limitation on the content in the attachment part, so it can include images or any other kind of content, including XML fragments and documents. Common types of attachment include sound, picture, and movie data: .mp3, .jpg, and .mpg files.

    The first thing a SAAJ client needs to do is get a connection in the form of a SOAPConnection object. A SOAPConnection object is a point-to-point connection that goes directly from the sender to the recipient. The connection is created by a SOAPConnectionFactory object. A client obtains the default implementation for SOAPConnectionFactory by calling the following line of code:

    SOAPConnectionFactory factory = SOAPConnectionFactory.newInstance(); 
    The client can use factory to create a SOAPConnection object.
    SOAPConnection connection = factory.createConnection();

    Messages, like connections, are created by a factory. To obtain a MessageFactory object, you get an instance of the default implementation for the MessageFactory class. This instance can then be used to create a SOAPMessage object:

    MessageFactory messageFactory = MessageFactory.newInstance();
    SOAPMessage message = messageFactory.createMessage();
    All of the SOAPMessage objects that messageFactory creates, including message in the previous line of code, will be SOAP messages. This means that they will have no pre-defined headers. The new SOAPMessage object message automatically contains the required elements SOAPPart, SOAPEnvelope, and SOAPBody, plus the optional element SOAPHeader (which is included for convenience). The SOAPHeader and SOAPBody objects are initially empty, and the following sections will illustrate some of the typical ways to add content. Content can be added to the SOAPPart object, to one or more AttachmentPart objects, or to both parts of a message.

    package javax.xml.soap;
    public abstract class SOAPPart implements org.w3c.dom.Document {
        public abstract SOAPEnvelope getEnvelope() throws SOAPException;				

    As stated earlier, all messages have a SOAPPart object, which has a SOAPEnvelope object containing a SOAPHeader object and a SOAPBody object.

    package javax.xml.soap;
    public interface SOAPEnvelope extends SOAPElement {
        public abstract Name createName(String localName, String prefix, String uri)
            throws SOAPException;
        public abstract Name createName(String localName) throws SOAPException;
        public abstract SOAPHeader getHeader() throws SOAPException;
        public abstract SOAPHeader addHeader() throws SOAPException;
        public abstract SOAPBody getBody() throws SOAPException;
        public abstract SOAPBody addBody() throws SOAPException;

    One way to add content to the SOAP part of a message is to create a SOAPHeaderElement object or a SOAPBodyElement object and add an XML fragment that you build with the method SOAPElement.addTextNode. The first three lines of the following code fragment access the SOAPBody object body, which is used to create a new SOAPBodyElement object and add it to body. The argument passed to the createName method is a Name object identifying the SOAPBodyElement being added. The last line adds the XML string passed to the method addTextNode:

    SOAPPart soapPart = message.getSOAPPart();
    SOAPEnvelope envelope = soapPart.getEnvelope();
    SOAPBody body = envelope.getBody();
    SOAPBodyElement bodyElement = body.addBodyElement(
        envelope.createName("text", "hotitems", 

    Another way is to add content to the SOAPPart object by passing it a javax.xml.transform.Source object, which may be a SAXSource, DOMSource, or StreamSource object. The Source object contains content for the SOAP part of the message and also the information needed for it to act as source input. A StreamSource object will contain the content as an XML document; the SAXSource or DOMSource object will contain content and instructions for transforming it into an XML document.

    The following code fragments illustrates adding content as a DOMSource object. The first step is to get the SOAPPart object from the SOAPMessage object. Next the code uses methods from the JAXP API to build the XML document to be added. It uses a DocumentBuilderFactory object to get a DocumentBuilder object. Then it parses the given file to produce the document that will be used to initialize a new DOMSource object. Finally, the code passes the DOMSource object domSource to the method SOAPPart.setContent:

    SOAPPart soapPart = message.getSOAPPart();
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = dbFactory.newDocumentBuilder();
    Document document = builder.parse("file:///");
    DOMSource domSource = new DOMSource(document);
    This code would work equally well with a SAXSource or a StreamSource object.

    You use the setContent method when you want to send an existing SOAP message. If you have an XML document that you want to send as the content of a SOAP message, you use the addDocument method on the body of the message:

    SOAPBodyElement docElement = body.addDocument(document); 
    This allows you to keep your application data in a document that is separate from the SOAP envelope unless and until it is time to send that data as a message.

    A SOAPMessage object may have no attachment parts, but if it is to contain anything that is not in XML format, that content must be contained in an attachment part. There may be any number of attachment parts, and they may contain anything from plain text to image files. In the following code fragment, the content is an image in a JPEG file, whose URL is used to initialize the javax.activation.DataHandler object handler. The Message object message creates the AttachmentPart object attachPart, which is initialized with the data handler containing the URL for the image. Finally, the message adds attachPart to itself:

    URL url = new URL("");
    DataHandler handler = new DataHandler(url);
    AttachmentPart attachPart = message.createAttachmentPart(handler);

    A SOAPMessage object can also give content to an AttachmentPart object by passing an Object and its content type to the method createAttachmentPart:

    AttachmentPart attachPart = message.createAttachmentPart(
        "content-string", "text/plain");

    Once you have populated a SOAPMessage object, you are ready to send it. A client uses the SOAPConnection method call to send a message. This method sends the message and then blocks until it gets back a response. The arguments to the method call are the message being sent and a URL object that contains the URL specifying the endpoint of the receiver.

    SOAPMessage response =, endpoint);

    The following example shows a SOAP 1.1 message with an attached facsimile image of the signed claim form (claim.tiff), also it illustrates the use of the cid reference in the body of the SOAP 1.1 message:

    MIME-Version: 1.0
    Content-Type: Multipart/Related; boundary=MIME_boundary; type=text/xml;
    Content-Description: This is the optional message description.
    Content-Type: text/xml; charset=UTF-8
    Content-Transfer-Encoding: 8bit
    Content-ID: <>
    <?xml version='1.0' ?>
    <SOAP-ENV:Envelope xmlns:SOAP-ENV="">
        <theSignedForm href=""/>
    Content-Type: image/tiff
    Content-Transfer-Encoding: binary
    Content-ID: <>
    NOTE: In this example the "Content-Type" header line has been continued across two lines so the example prints easily. SOAP message senders should send headers on a single long line.

    NOTE: Associate the attachment to theSignedForm element by adding an href attribute. The attachment is referred to through a cid (Content-ID) URL:

    <myElement href="cid:xxxx" />
    Content-Type: image/tiff
    Content-Transfer-Encoding: binary
    Content-ID: <xxxx>
    NOTE: Unlike SOAP 1.1 XML references, do not use '#' (pound sign) in href attribute value when you refer to attachment, also when you refer to attachment you must prepend unique identifier with prefix 'cid:'.

    The following listing illustrates the creation of the SOAP request. The request asks a server to resize an image. The procedure is as follows:

    1. Create SOAP connection and SOAP message objects through factories.

    2. Retrieve the message body from the message object (intermediary steps: retrieve the SOAP part and envelope).

    3. Create a new XML element to represent the request.

    4. Create the attachment and initialize it with a DataHandler object.

    5. Create more elements to represent the two parameters (source and percent).

    6. Associate the attachment to the first parameter by adding an href attribute. The attachment is referred to through a cid (Content-ID) URI.

    7. Set the value of the second parameter directly as text and call the service.

    The service replies with the resized image, again as an attachment. To retrieve it, you can test for a SOAP fault (which indicates an error). If there are no faults, retrieve the attachment as a file and process it. Using SAAJ API:

    // Using SAAJ
    public File resize(String endPoint,File file) {
       SOAPConnection connection = SOAPConnectionFactory.newInstance().createConnection();
       SOAPMessage message = MessageFactory.newInstance().createMessage();
       SOAPPart part = message.getSOAPPart();
       SOAPEnvelope envelope = part.getEnvelope();
       SOAPBody body = envelope.getBody();
       SOAPBodyElement operation = body.addBodyElement(
           envelope.createName("resize", "ps", ""));
       DataHandler dh = new DataHandler(new FileDataSource(file));
       AttachmentPart attachment = message.createAttachmentPart(dh);
       SOAPElement source  = operation.addChildElement("source",""),
       SOAPElement percent = operation.addChildElement("percent","");
       source.addAttribute(envelope.createName("href"), "cid:" + attachment.getContentId());
       SOAPMessage result =,endPoint);
       part = result.getSOAPPart();
       envelope = part.getEnvelope();
       body = envelope.getBody();
       if(!body.hasFault())  {
          Iterator iterator = result.getAttachments();
          if(iterator.hasNext()) {
             dh = ((AttachmentPart);
             String fname = dh.getName();
             if (null != fname) return new File(fname);
       return null;

    The code above will produce following SOAP 1.1 message with attachment:

    POST /ws/resize HTTP/1.0
    Content-Type: multipart/related; type="text/xml"; 
    Accept: application/soap+xml, multipart/related, text/*
    SOAPAction: ""
    Content-Length: 1506005
    Content-Type: text/xml; charset=UTF-8
    Content-Transfer-Encoding: binary
    Content-Id: <EB6FC7EDE9EF4E510F641C481A9FF1F3>
    <?xml version="1.0" encoding="UTF-8"?>
    <soapenv:Envelope xmlns:soapenv="" 
        <ps:resize  xmlns:ps="">
          <source href="cid:E1A97E9D40359F85CA19D1B8A7C52AA3"/>
    Content-Type: image/jpeg
    Content-Transfer-Encoding: binary
    Content-Id: <E1A97E9D40359F85CA19D1B8A7C52AA3>

    The information you are posting should be related to java and ORACLE technology. Not political.