/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.baomidou.mybatisplus.toolkit; import java.io.Closeable; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.Reader; import java.io.Writer; import java.net.HttpURLConnection; import java.net.ServerSocket; import java.net.Socket; import java.net.URLConnection; import java.nio.channels.Selector; import java.sql.Connection; /** *

* IOUtils Copy org.apache.commons.io.IOUtils *

* * @author Caratacus * @Date 2016-11-23 */ public class IOUtils { /** * Closes a URLConnection. * * @param conn * the connection to close. * @since 2.4 */ public static void close(final URLConnection conn) { if (conn instanceof HttpURLConnection) { ((HttpURLConnection) conn).disconnect(); } } /** * Closes an Reader unconditionally. *

* Equivalent to {@link Reader#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * char[] data = new char[1024];
	 * Reader in = null;
	 * try {
	 * 	in = new FileReader("foo.txt");
	 * 	in.read(data);
	 * 	in.close(); // close errors are handled
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(in);
	 * }
	 *
* * @param input * the Reader to close, may be null or already closed */ public static void closeQuietly(final Reader input) { closeQuietly((Closeable) input); } /** * Closes an Writer unconditionally. *

* Equivalent to {@link Writer#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * Writer out = null;
	 * try {
	 * 	out = new StringWriter();
	 * 	out.write("Hello World");
	 * 	out.close(); // close errors are handled
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(out);
	 * }
	 *
* * @param output * the Writer to close, may be null or already closed */ public static void closeQuietly(final Writer output) { closeQuietly((Closeable) output); } /** * Closes an InputStream unconditionally. *

* Equivalent to {@link InputStream#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * byte[] data = new byte[1024];
	 * InputStream in = null;
	 * try {
	 * 	in = new FileInputStream("foo.txt");
	 * 	in.read(data);
	 * 	in.close(); // close errors are handled
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(in);
	 * }
	 *
* * @param input * the InputStream to close, may be null or already closed */ public static void closeQuietly(final InputStream input) { closeQuietly((Closeable) input); } /** * Closes an OutputStream unconditionally. *

* Equivalent to {@link OutputStream#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * byte[] data = "Hello, World".getBytes();
	 * 
	 * OutputStream out = null;
	 * try {
	 * 	out = new FileOutputStream("foo.txt");
	 * 	out.write(data);
	 * 	out.close(); // close errors are handled
	 * } catch (IOException e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(out);
	 * }
	 *
* * @param output * the OutputStream to close, may be null or already closed */ public static void closeQuietly(final OutputStream output) { closeQuietly((Closeable) output); } /** * Closes a Closeable unconditionally. *

* Equivalent to {@link Closeable#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: *

* * 
	 * Closeable closeable = null;
	 * try {
	 * 	closeable = new FileReader("foo.txt");
	 * 	// process closeable
	 * 	closeable.close();
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(closeable);
	 * }
	 *
*

* Closing all streams: *

* * 
	 * try {
	 * 	return IOUtils.copy(inputStream, outputStream);
	 * } finally {
	 * 	IOUtils.closeQuietly(inputStream);
	 * 	IOUtils.closeQuietly(outputStream);
	 * }
	 *
* * @param closeable * the objects to close, may be null or already closed * @since 2.0 */ public static void closeQuietly(final Closeable closeable) { try { if (closeable != null) { closeable.close(); } } catch (final IOException ioe) { // ignore } } /** * Closes a Closeable unconditionally. *

* Equivalent to {@link Closeable#close()}, except any exceptions will be * ignored. *

* This is typically used in finally blocks to ensure that the closeable is * closed even if an Exception was thrown before the normal close statement * was reached.
* It should not be used to replace the close statement(s) which should * be present for the non-exceptional case.
* It is only intended to simplify tidying up where normal processing has * already failed and reporting close failure as well is not necessary or * useful. *

* Example code: *

* * 
	 * Closeable closeable = null;
	 * try {
	 *     closeable = new FileReader("foo.txt");
	 *     // processing using the closeable; may throw an Exception
	 *     closeable.close(); // Normal close - exceptions not ignored
	 * } catch (Exception e) {
	 *     // error handling
	 * } finally {
	 *     IOUtils.closeQuietly(closeable); // In case normal close was skipped due to Exception
	 * }
	 *
*

* Closing all streams:
* * 

	 * try {
	 * 	return IOUtils.copy(inputStream, outputStream);
	 * } finally {
	 * 	IOUtils.closeQuietly(inputStream, outputStream);
	 * }
	 *
* * @param closeables * the objects to close, may be null or already closed * @see #closeQuietly(Closeable) * @since 2.5 */ public static void closeQuietly(final Closeable... closeables) { if (closeables == null) { return; } for (final Closeable closeable : closeables) { closeQuietly(closeable); } } /** * Closes a Socket unconditionally. *

* Equivalent to {@link Socket#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * Socket socket = null;
	 * try {
	 * 	socket = new Socket("http://www.foo.com/", 80);
	 * 	// process socket
	 * 	socket.close();
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(socket);
	 * }
	 *
* * @param sock * the Socket to close, may be null or already closed * @since 2.0 */ public static void closeQuietly(final Socket sock) { if (sock != null) { try { sock.close(); } catch (final IOException ioe) { // ignored } } } /** * Closes a Selector unconditionally. *

* Equivalent to {@link Selector#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * Selector selector = null;
	 * try {
	 * 	selector = Selector.open();
	 * 	// process socket
	 * 
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(selector);
	 * }
	 *
* * @param selector * the Selector to close, may be null or already closed * @since 2.2 */ public static void closeQuietly(final Selector selector) { if (selector != null) { try { selector.close(); } catch (final IOException ioe) { // ignored } } } /** * Closes a ServerSocket unconditionally. *

* Equivalent to {@link ServerSocket#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * ServerSocket socket = null;
	 * try {
	 * 	socket = new ServerSocket();
	 * 	// process socket
	 * 	socket.close();
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(socket);
	 * }
	 *
* * @param sock * the ServerSocket to close, may be null or already closed * @since 2.2 */ public static void closeQuietly(final ServerSocket sock) { if (sock != null) { try { sock.close(); } catch (final IOException ioe) { // ignored } } } /** * Closes a Connection unconditionally. *

* Equivalent to {@link Connection#close()}, except any exceptions will be * ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * Connection conn = null;
	 * try {
	 * 	conn = new Connection();
	 * 	// process close
	 * 	conn.close();
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(conn);
	 * }
	 *
* * @param conn * the Connection to close, may be null or already closed * @since 2.2 */ public static void closeQuietly(final Connection conn) { if (conn != null) { try { conn.close(); } catch (Exception e) { // ignored } } } /** * Closes a AutoCloseable unconditionally. *

* Equivalent to {@link AutoCloseable#close()}, except any exceptions will * be ignored. This is typically used in finally blocks. *

* Example code: * * 

	 * AutoCloseable closeable = null;
	 * try {
	 * 	closeable = new Connection();
	 * 	// process close
	 * 	closeable.close();
	 * } catch (Exception e) {
	 * 	// error handling
	 * } finally {
	 * 	IOUtils.closeQuietly(conn);
	 * }
	 *
* * @param closeable * the Connection to close, may be null or already closed * @since 2.2 */ public static void closeQuietly(final AutoCloseable closeable) { if (closeable != null) { try { closeable.close(); } catch (Exception e) { // ignored } } } /** * Closes a AutoCloseable unconditionally. *

* Equivalent to {@link AutoCloseable#close()}, except any exceptions will * be ignored. *

* This is typically used in finally blocks to ensure that the closeable is * closed even if an Exception was thrown before the normal close statement * was reached.
* It should not be used to replace the close statement(s) which should * be present for the non-exceptional case.
* It is only intended to simplify tidying up where normal processing has * already failed and reporting close failure as well is not necessary or * useful. *

* Example code: *

* * 
	 * AutoCloseable closeable = null;
	 * try {
	 *     closeable = new AutoCloseable();
	 *     // processing using the closeable; may throw an Exception
	 *     closeable.close(); // Normal close - exceptions not ignored
	 * } catch (Exception e) {
	 *     // error handling
	 * } finally {
	 *     IOUtils.closeQuietly(closeable); // In case normal close was skipped due to Exception
	 * }
	 *
*

* Closing all streams:
* * @param closeables * the objects to close, may be null or already closed * @see #closeQuietly(AutoCloseable) * @since 2.5 */ public static void closeQuietly(final AutoCloseable... closeables) { if (closeables == null) { return; } for (final AutoCloseable closeable : closeables) { closeQuietly(closeable); } } }