public class FUDHandlerClass extends AbstractHandlingManagerImpl{

    @Override
    public FUDFile doDownload(String reference) {
	     //write the download logic here     
    }
    
    @Override
    public FUDImageFile doDownloadForImage(String reference) {
      //write the download logic here     
    }
    
    @Override
    public String doUpload(FUDFile file) {
     //write the upload logic here   
    }
    @Override
    public String doUpload(FUDImageFile file) {
     //write the upload logic here   
    }
}

public class FUDService extends AbstractFUDServiceImpl<FUDHandlerClass>
        implements FUDFileHandler {
        
    private class HandlingConnector extends FUDHandler<FUDHandlerClass> {  }
    
    public FUDService() {
        this.handler = new HandlingConnector();
    }
    
}

public class FUDService extends AbstractFUDServiceHandlerImpl{
	  
      @Override	  
      public String uploadImage(FUDImageFile file){
	     //the logic here
      }
      
    @Override
    public String uploadFile(FUDFile file) {
	    //the logic here
    }
    
    @Override
    public FUDImageFile downloadImage(String ref) {
	     //the logic here
    }
    @Override
    public FUDFile downloadFile(String ref) {
	   //the logic here
    }
}

@WebService(endpointInterface = "kaolin.mtom.fud.handling.FUDFileHandler")

        byte[] data = ...
        FUDFile toUpload = new FUDFile();
        ByteArrayDataSource bads = new ByteArrayDataSource(data, "image/*");
        toUpload.setFileHandler(new DataHandler(bads));
        toUpload.setReference(ref);
        toUpload.setFileLength(data.length);

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.util.Calendar;
import javax.activation.DataHandler;
import javax.imageio.ImageIO;
import kaloin.mtom.client.ds.ByteArrayDataSource;
import kaolin.mtom.fud.FUDFile;
import kaolin.mtom.fud.FUDImageFile;
import kaolin.mtom.fud.service.AbstractFUDServiceHandlerImpl;
import org.apache.cxf.helpers.IOUtils;

/**
 *
 * @author Desbocages
 */
public class FUDService extends AbstractFUDServiceHandlerImpl{

    @Override
    public String uploadImage(FUDImageFile file) {
        try {
            InputStream in = file.getFileHandler().getInputStream();
            String id = file.getReference();
            byte[] data = IOUtils.readBytesFromStream(in);
            saveByteArrayAsJPEGFile(data, id + Calendar.getInstance().getTimeInMillis());
            return "OK";
        } catch (IOException | RuntimeException e) {
            return "KO - " + e.getMessage();
        }
    }

    @Override
    public String uploadFile(FUDFile file) {
         try {
            InputStream in = file.getFileHandler().getInputStream();
            String id = file.getReference();
            byte[] data = IOUtils.readBytesFromStream(in);
            saveByteArrayAsFile(data, id + Calendar.getInstance().getTimeInMillis());
            return "OK";
        } catch (IOException | RuntimeException e) {
            return "KO - " + e.getMessage();
        }
    }

    @Override
    public FUDImageFile downloadImage(String ref1) {
        String ref = ref1;
        FUDImageFile toReturn;
        ByteArrayDataSource bads;
        toReturn = new FUDImageFile();
        try {
            bads = new ByteArrayDataSource(
	               getByteArrayFromJPEGImageFile(new File(ref)), "image/jpeg");
        } catch (IOException ex) {
            return null;
        }
        toReturn.setFileHandler(new DataHandler(bads));
        toReturn.setReference(ref);
        return toReturn;
    }

    @Override
    public FUDFile downloadFile(String ref1) {
        String ref = ref1;
        FUDFile toReturn;
        ByteArrayDataSource bads;
        toReturn = new FUDFile();
        try {
            //make sure the file exists (this is just an example)
            bads = new ByteArrayDataSource(
	                     Files.readAllBytes(
			            new File(ref).toPath()), "application/octet-stream");
        } catch (IOException ex) {
            return null;
        }
        toReturn.setFileHandler(new DataHandler(bads));
        toReturn.setReference(ref);
        return toReturn;
    }
    
    private void saveByteArrayAsFile(byte[] tb, String absoluteOutputFilePath) 
                                               throws FileNotFoundException, IOException {
        FileOutputStream fos;
        fos = new FileOutputStream(absoluteOutputFilePath);
        fos.write(tb);
        fos.flush();
        fos.close();
    }

    private byte[] getByteArrayFromJPEGImageFile(File f) throws IOException {
        byte[] toReturn;
        BufferedImage bimg = ImageIO.read(f);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(bimg, "jpg", baos);
        baos.flush();
        toReturn = baos.toByteArray();
        baos.close();
        return toReturn;
    }

    private void saveByteArrayAsJPEGFile(byte[] tb, String absoluteOutputFilePath)
    throws IOException {
        InputStream in = new ByteArrayInputStream(tb);
        BufferedImage bImageFromConvert = ImageIO.read(in);
        ImageIO.write(bImageFromConvert, "jpg", new File(
                absoluteOutputFilePath));
    }
    
}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.activation.DataHandler;
import kaloin.mtom.client.ds.ByteArrayDataSource;
import kaolin.mtom.fud.FUDFile;
import kaolin.mtom.fud.FUDImageFile;
import kaolin.mtom.fud.handling.FUDFileHandler;
import org.apache.commons.io.IOUtils;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

/**
 *
 * @author Desbocages
 */
public class MainClass {

    private static void saveByteArrayAsFile(byte[] tb,
            String absoluteOutputFilePath)
            throws FileNotFoundException, IOException {
        FileOutputStream fos;
        fos = new FileOutputStream(absoluteOutputFilePath);
        fos.write(tb);
        fos.flush();
        fos.close();
    }

    public static <T> T get(String factoryBeanName,
            Class interfaceClass) {
        JaxWsProxyFactoryBean proxyFactory;
        proxyFactory = (JaxWsProxyFactoryBean) (new XmlBeanFactory(
                new ClassPathResource(
                        "other/package/name/cxf-client.xml")))
                .getBean(factoryBeanName);
        T proxy = null;
        proxy = (T) proxyFactory.create(interfaceClass);
        return proxy;
    }

    public static void main(String[] args) throws IOException {
    
        // getting the proxy to access the remote server
        FUDFileHandler server = get("fudServiceFactory", FUDFileHandler.class);
	
	//downloading a file from the server knowing its path
        FUDFile file = server.downloadImage("F:\\img_prototype_6.jpg");
	
	//saving the gotten data on the local disk.
        saveByteArrayAsFile(
                IOUtils.toByteArray(file.getFileHandler().getInputStream()),
                "G:/jpg-dl-FUD.jpg");
		
	//collecting an image on the local disk
        String ref = "F:\\img_prototype_6.jpg";
        FUDImageFile toReturn;
        ByteArrayDataSource bads;
        toReturn = new FUDImageFile();
        InputStream inStream;
        inStream = new FileInputStream(new File(ref));
        bads = new ByteArrayDataSource(
                IOUtils.toByteArray(inStream), "images/*");
        toReturn.setFileHandler(new DataHandler(bads));
        toReturn.setReference(ref);
	
	//sending the collected file to the server
        server.uploadImage(toReturn);
    }
}