Archivos por Etiqueta: inputstream

Java: Speed Limit on InputStream/OutputStream

Si necesitas reducir la velocidad de un InputStream/OutputStream de un modo sencillo, esta es la solución!

public class ThrottleStream {
	protected final int speedLimitBytesSecond;
	protected int currentTransferredBytes = 0;
	protected long lastTimeStampSeconds = 0;

	protected ThrottleStream(final int maxSpeedInKilobytesPerSecond) {
		this.speedLimitBytesSecond = maxSpeedInKilobytesPerSecond * 1024;
	}

	protected void addAndWait(final int transferred) throws IOException {
		long now = System.currentTimeMillis() / 1000;
		if (now != lastTimeStampSeconds) {
			currentTransferredBytes = 0;
			lastTimeStampSeconds = now;
		}
		currentTransferredBytes += transferred;
		if (currentTransferredBytes >= speedLimitBytesSecond) {
			try {
				while (true) {
					Thread.sleep(10);
					now = System.currentTimeMillis() / 1000;
					if (now != lastTimeStampSeconds) {
						currentTransferredBytes = 0;
						lastTimeStampSeconds = now;
						break;
					}
				}
			} catch (InterruptedException e) {
				Thread.currentThread().interrupt();
				throw new IOException(e);
			}
		}
	}

	/**
	 * Speed Limit de un InputStream
	 */
	public static class ThrottleInputStream extends FilterInputStream {
		final ThrottleStream limit;

		public ThrottleInputStream(final InputStream in, 
				final int maxSpeedInKilobytesPerSecond) {
			super(in);
			limit = new ThrottleStream(maxSpeedInKilobytesPerSecond);
		}

		@Override
		public int read() throws IOException {
			final int read = super.read();
			limit.addAndWait(read);
			return read;
		}

		@Override
		public int read(final byte[] b) throws IOException {
			final int read = super.read(b);
			limit.addAndWait(read);
			return read;
		}

		@Override
		public int read(final byte[] b, final int off, final int len) 
				throws IOException {
			final int read = super.read(b, off, len);
			limit.addAndWait(read);
			return read;
		}
	}

	/**
	 * Speed Limit de un OutputStream
	 */
	public static class ThrottleOutputStream extends FilterOutputStream {
		final ThrottleStream limit;

		public ThrottleOutputStream(final OutputStream out, 
				final int maxSpeedInKilobytesPerSecond) {
			super(out);
			limit = new ThrottleStream(maxSpeedInKilobytesPerSecond);
		}

		@Override
		public void write(final int b) throws IOException {
			super.write(b);
			limit.addAndWait(1);
		}

		@Override
		public void write(final byte[] b) throws IOException {
			super.write(b);
			limit.addAndWait(b.length);
		}

		@Override
		public void write(final byte[] b, final int off, final int len) 
				throws IOException {
			super.write(b, off, len);
			limit.addAndWait(len);
		}
	}
}

Source code: ThrottleStream.java

Java: Universal Placeholder for InputStreams

Los ficheros XML tienen una sintaxis muy completa y los ficheros de Properties un formato sencillo de manipular:

# placeholders.properties

user = root
password = secret

Y como queremos ambas cosas, los “placeholders” nos permiten hacer el mix de lo mejor de un lenguaje de marcado como XML con la sencillez de un fichero de propiedades, ejemplo:

# config.xml

<config>
  <init-param>
    <param-name>user</param-name>
    <param-value>${user}</param-value>
  </init-param>
  <init-param>
    <param-name>password</param-name>
    <param-value>${password}</param-value>
  </init-param>
</config>

La idea detras de esto es incluir el valor de “user” y “password” (extraidos del fichero de propiedades) dentro del XML. Y aqui una implementación muy sencilla y generica que permite usar placeholders en cualquier InputStream, independiente del formato:

Leer más de esta entrada

A %d blogueros les gusta esto: