import eu.fusepool.p3.transformer.commons.util.WritingEntity; //导入依赖的package包/类
@Override
public Entity transform(HttpRequestEntity entity) throws IOException {
    final MimeType mimeType = entity.getType();
    final InputStream in = entity.getData();
    final Entity output = new WritingEntity() {
        @Override
        public MimeType getType() {
            return mimeType;
        }

        @Override
        public void writeData(OutputStream out) throws IOException {
            IOUtils.copy(in, out);
        }
    };

    return output;
}
 

import eu.fusepool.p3.transformer.commons.util.WritingEntity; //导入依赖的package包/类
@Test
public void testXML() throws Exception {
	Transformer t = new TransformerClientImpl(setUpDataServer());
	// the transformer fetches the xml data from the data server, geocode the address 
	// and sends the RDF result to the client
       {
           Entity response = t.transform(new WritingEntity() {

               @Override
               public MimeType getType() {
                   return inputDataMimeType;
               }

               @Override
               public void writeData(OutputStream out) throws IOException {
                   out.write(inputData);
               }
               
           }, transformerMimeType );

           // the client receives the response from the transformer
           Assert.assertEquals("Wrong media Type of response", TRANSFORMER_MIME_TYPE, response.getType().toString());  
           // Parse the RDF data returned by the transformer after the geocoding 
           final Graph responseGraph = Parser.getInstance().parse(response.getData(), "text/turtle");
           //checks for the presence of a specific property added by the transformer to the input data
           final Iterator<Triple> propertyIter = responseGraph.filter(null, geo_lat, null);
           Assert.assertTrue("No specific property found in response", propertyIter.hasNext());
           //verify that the xml has been loaded from the data server (one call)
           //verify(1,getRequestedFor(urlEqualTo("/xml/" + XML_DATA)));
           
       }
}
 

import eu.fusepool.p3.transformer.commons.util.WritingEntity; //导入依赖的package包/类
@Override
public Entity transform(HttpRequestEntity entity) throws IOException {
    logMessage(entity.getRequest());

    final HttpRequestEntity request = cast(entity);

    final ImmutablePair<MimeType, Properties> options = exporterOptions(request);
    options.right.putAll(transformerConfig);
    final File input = downloadInput(entity);
    final File output = File.createTempFile("reply", "tmp");

    final ITransformEngine engine = getEngine();

    return new WritingEntity() {
        @Override
        public void writeData(OutputStream out) throws IOException {
            try {
                // Can't allow more than one transform at a time as OpenRefine is not
                // designed for that.
                synchronized (SynchronousTransformer.this) {
                    engine.transform(input.toURI(), fetchTransform(request), output.toURI(),
                            options.right);
                }

                try (FileInputStream stream = new FileInputStream(output)) {
                    IOUtils.copy(stream, out);
                }
            } finally {
                input.delete();
                output.delete();
            }
        }

        @Override
        public MimeType getType() {
            return options.left;
        }
    };
}
 

import eu.fusepool.p3.transformer.commons.util.WritingEntity; //导入依赖的package包/类
/**
    * The transformer receives RDF data and a url from the client, fetches the SILK config file from the url, applies the linkage rules
    * and then check if the transformation is compatible with the expected result.
    * @throws Exception
    */
@Test
   public void testTransformation() throws Exception {
	
       Transformer t = new TransformerClientImpl(setUpMockServer());
       // the transformer fetches the SILK config file from the mock server, applies its rules and sends the RDF result to the client
       {
           Entity response = t.transform(new WritingEntity() {

               @Override
               public MimeType getType() {
                   return clientDataMimeType;
               }

               @Override
               public void writeData(OutputStream out) throws IOException {
                   out.write(ttlData);
               }
           }, transformerMimeType);

           // the client receives the response from the transformer
           Assert.assertEquals("Wrong media Type of response", transformerMimeType.toString(), response.getType().toString());  
           // Parse the RDF data returned by the transformer after the xslt transformation has been applied to the xml data
           final Graph responseGraph = Parser.getInstance().parse(response.getData(), "text/turtle");
           //checks for the presence of a specific property added by the transformer
           final Iterator<Triple> propertyIter = responseGraph.filter(null, OWL.sameAs, null);
           Assert.assertTrue("No specific property found in response", propertyIter.hasNext());
           
       }
               
    
}
 

import eu.fusepool.p3.transformer.commons.util.WritingEntity; //导入依赖的package包/类
private WritingEntity wrapInEntity(final String transformed) {
    return new WritingEntity() {
        @Override
        public MimeType getType() {
            return MIME_TEXT_PLAIN;
        }

        @Override
        public void writeData(OutputStream out) throws IOException {
            out.write(transformed.getBytes());
        }
    };
}