Get a JPEG File as an Array of Bytes

In this section, you add a pair of private methods to the FlowerService class body. These methods take the name of a flower, create a path to the flower's JPEG file, and return a binary representation of the JPEG file (an array of bytes). In later sections you add code to the public web service operations so the operations call these private methods.

1. Open the Source view of the project. You need to add code that takes the name of an image, creates a path to the image based on that name, and retrieves the image as an array of bytes. Type or paste the following code into the FlowerService class body:

   private byte[] getFlowerBytes(String name) throws IOException {
       URL resource = this.getClass().getResource("/org/flower/resources/"+name+".jpg");
       return getBytes(resource);
   }

2. A warning appears that the IDE cannot find the class URL. Add an import statement for java.net.URL, either manually or by pressing Ctrl-Shift-I (⌘-Shift-I on Mac).
3. A new warning appears. The warning states that the IDE cannot find the getBytes method. Left-click the warning icon and click the tip to create the getBytes method.
   
4. The editor focuses on the getBytes method you just created. Add the following code to the method. This code opens a connection to the URL you passed from the getFlowerBytes method and returns an InputStream. The code then reads the input stream 1024 bytes at a time, stores the bytes in a byte array buffer, and writes from the buffer to a ByteArrayOutputStream.

   private byte[] getBytes(URL resource) throws IOException {
       InputStream in = resource.openStream();
       ByteArrayOutputStream bos = new ByteArrayOutputStream();
       byte[] buf = new byte[1024];
       for(int read; (read = in.read(buf)) != -1;) {
           bos.write(buf, 0, read);
       }
       return bos.toByteArray();
   }

5. Add import statements for java.io.InputStream and java.io.ByteArrayOutputStream.

Read an Array of Bytes as an Image

In this section, you add a private method to the FlowerService class body. This method takes an array of bytes that represent a JPEG file and returns a java.awt.Image object. Note that the array of bytes is created by the getBytes(URL) method that you created in the section Get a JPEG File as an Array of Bytes.

1. In the FlowerService class body, add the following private method, called getImage. The getImage method's return type is Image. The method takes two parameters. The first parameter is a byte array that is created by the getBytes method. The second parameter is a boolean that indicates whether the image is a thumbnail. The getImage method throws an IOException.

   private Image getImage(byte[] bytes, boolean isThumbnail) throws IOException {
       }

2. In the getImage method body, add a line that creates a ByteArrayInputStream from the byte array that the method takes as a parameter.

   ByteArrayInputStream bis = new ByteArrayInputStream(bytes);

3. Add a line that creates an Object from the ByteArrayInputStream.

   Object source = bis;

4. Add a line that creates an ImageInputStream from the generic Object.

   ImageInputStream iis = ImageIO.createImageInputStream(source);

5. Add a line that creates an Iterator of all currently registered ImageReaders that can decode JPEG files.

   Iterator readers = ImageIO.getImageReadersByFormatName("jpeg");

6. Add a line that creates an ImageReader from the next element in the Iterator.

   ImageReader reader = (ImageReader) readers.next();

7. Add lines that create default image read parameters but add 1-in-4 subsampling to the image read parameters if the Image represents a thumbnail.

   ImageReadParam param = reader.getDefaultReadParam();
   if (isThumbnail) {
       param.setSourceSubsampling(4, 4, 0, 0);
   }

8. Lastly, add code that uses the ImageReader object to read the ImageInputStream object and to return an Image based on that object and the image read parameters.

   reader.setInput(iis, true);
   return reader.read(0, param);

9. Press Ctrl-Shift-I (⌘-Shift-I on MacOS). The Fix All Imports dialog opens. Accept the default suggestions of the Fix All Imports dialog and click OK.
   

The getImage method is now complete.

private Image getImage(byte[] bytes, boolean isThumbnail) throws IOException {
    ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
    Object source = bis; // File or InputStream
    ImageInputStream iis = ImageIO.createImageInputStream(source);
    Iterator readers = ImageIO.getImageReadersByFormatName("jpeg");
    ImageReader reader = (ImageReader) readers.next();
    ImageReadParam param = reader.getDefaultReadParam();
    if (isThumbnail) {
        param.setSourceSubsampling(4, 4, 0, 0);
    }
    reader.setInput(iis, true);
    return reader.read(0, param);
}

Implement getFlower

Add the following implementation code to the getFlower() method to get a flower by its name and return the image of that flower, as follows. Note that this code calls the private getFlowerBytes(name) method to get the JPEG file as an array of bytes. The code then calls the private getImage method to return the array of bytes as an Image object.

@WebMethod(operationName = "getFlower")
public Image getFlower(@WebParam(name = "name") String name) throws IOException {
    byte[] bytes = getFlowerBytes(name);
    return getImage(bytes, false);
}

Create a List of Byte Arrays for All JPEG Files

1. At the top of the class body of FlowerService, create an array of Strings of the names of every flower.

   private static final String[] FLOWERS = {"aster", "honeysuckle", "rose", "sunflower"};

2. Add a method that creates an ArrayList and adds a byte array for every flower to the List.

   private List allFlowers() throws IOException {
       List flowers = new ArrayList();
       for (String flower:FLOWERS) {
           URL resource = this.getClass().getResource("/org/flower/resources/"+flower+".jpg");
           flowers.add(getBytes(resource));
       }
       return flowers;
   }

3. Add import statements for java.util.ArrayList and java.util.List.

Implement getThumbnails

Change the getThumbnails() method as follows. Note that you add the implementation code and change the return type from List to List<Image>. Also note that you pass the boolean isThumbnail value of true to the getImage method. The getThumbnails implementation code calls the allFlowers method to create a list of byte arrays for all the JPEG files. The getThumbnails method then creates a List of Images and calls the getImage method for each flower, to return the array of bytes for that flower as an Image object and add that Image to the List.

@WebMethod(operationName = "getThumbnails")
public List<Image> getThumbnails() throws IOException {
    List<byte[]> flowers = allFlowers();
    List<Image> flowerList = new ArrayList<Image>(flowers.size());
    for (byte[] flower : flowers) {
        flowerList.add(getImage(flower, true));
    }
    return flowerList;
}