Java Streams.safeClose方法代码示例

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public JarResourceLocation(String jarPath) throws IOException {
    if (jarPath.startsWith("zip:"))
        jarPath = jarPath.substring(4);
    if (jarPath.startsWith("file:/")) {
        jarPath = jarPath.substring("file:/".length());
        if (!new File(jarPath).exists() && !jarPath.startsWith("/")) {
            jarPath = "/" + jarPath;
        }
    }
    this.jarPath = new File(jarPath).getAbsoluteFile().getCanonicalPath();
    ZipInputStream zis = null;
    try {
        zis = Scans.makeZipInputStream(jarPath);
        ZipEntry ens = null;
        while (null != (ens = zis.getNextEntry())) {
            if (ens.isDirectory())
                continue;
            names.add(ens.getName());
        }
    }
    catch (Throwable e) {
        throw Lang.wrapThrow(e);
    } finally {
        Streams.safeClose(zis);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
/**
  * 执行根据字符流来加载sql内容的操作
  * 
  * @param reader
  * @throws IOException
  */
 protected void loadSQL(Reader reader) throws IOException {
     BufferedReader bufferedReader = null;
     try {
         if(reader instanceof BufferedReader)
             bufferedReader = (BufferedReader)reader;
         else
             bufferedReader = new BufferedReader(reader);
         SqlFileBuilder p = new SqlFileBuilder(bufferedReader);
         _sql_keys = new ArrayList<String>(p.map.size());
         for (Entry<String, String> en : p.entrySet()) {
         	addSql(en.getKey(), Strings.trim(en.getValue()));
}
     }
     finally {
         Streams.safeClose(bufferedReader);
     }

 }
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
/**
 * 将一个 JAVA 对象以 JSON 的形式写到一个文件里，并且可以设定 JSON 字符串的格式化方式
 * 
 * @param f
 *            文本文件
 * @param obj
 *            JAVA 对象
 * @param format
 *            JSON 字符串格式化方式 ，若 format 为 null ，则以 JsonFormat.nice() 格式输出
 */
public static void toJsonFile(File f, Object obj, JsonFormat format) {
    Writer writer = null;
    try {
        Files.createFileIfNoExists(f);
        writer = Streams.fileOutw(f);
        Json.toJson(writer, obj, format);
        writer.append('\n');
    }
    catch (IOException e) {
        throw Lang.wrapThrow(e);
    }
    finally {
        Streams.safeClose(writer);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
/**
 * 向某主机发送一些字节内容，并将返回写入输出流
 * 
 * @param host
 *            主机
 * @param port
 *            端口
 * @param ins
 *            发送的内容
 * @param ops
 *            主机返回的输入流
 */
public static void send(String host, int port, InputStream ins, OutputStream ops, int timeout) {
    Socket socket = null;
    try {
        socket = new Socket();
        socket.connect(InetSocketAddress.createUnresolved(host, port), timeout);
        // 发送关闭命令
        OutputStream sOut = socket.getOutputStream();
        Streams.write(sOut, ins);
        sOut.flush();

        // 接收服务器的反馈
        if (!socket.isClosed()) {
            InputStream sReturn = socket.getInputStream();
            Streams.write(ops, sReturn);
        }
    }
    catch (IOException e) {
        throw Lang.wrapThrow(e);
    }
    finally {
        Streams.safeClose(ins);
        Streams.safeClose(ops);
        safeClose(socket);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
protected void load(String... confFilesPath) {
    if (log.isDebugEnabled()) {
        log.debugf("Loading config files[%s].", confFilesPath);
    }
    InputStream is = null;
    BufferedReader br = null;
    Properties p = new Properties();
    try {
        for (String confFilePath : confFilesPath) {
            is = this.getClass().getResourceAsStream(confFilePath);
            br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            p.load(br);
        }
    }
    catch (Exception e) {
        throw Lang.wrapThrow(e);
    }
    finally {
        Streams.safeClose(is);
        Streams.safeClose(br);
    }
    putAll(p);
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
private void _gen_tag_page(Rendering ing,
                           ZDocTemplate tmpl,
                           NutMap page,
                           ZDocTag tag) {
    page.setv("title", tag.getText());
    ing.context().setv("tag", tag.genItems());

    // 在目标目录创建对应文件
    ZFile destf = dest.createFileIfNoExists(tagPath
                                            + "/"
                                            + tag.getKey()
                                            + ".html");
    // 准备渲染
    Writer wr = Streams.utf8w(ing.io().openOutputStream(destf));
    tmpl.outputTo(wr, ing.context());
    Streams.safeClose(wr);
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
/**
 * 从一个流读取数据库配置
 * @param in 输入流,包含配置信息
 * @throws IOException 读取失败是抛出异常
 */
public void init(InputStream in) throws IOException {
    Properties props = new Properties();
    try {
        props.load(in);
        init(props);
    }
    finally {
        Streams.safeClose(in);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
SqlFileBuilder(BufferedReader reader) throws IOException {
    InnerStack stack = new InnerStack();
    int c;
    stack.eat('\n');
    while (-1 != (c = reader.read())) {
        stack.eat(c);
    }
    if (stack.key != null)
        stack.addOne();
    map = stack.map;
    Streams.safeClose(reader);
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
/**
 * 根据指定的类型，读取指定的 JSON 文件生成 JAVA 对象。 指定的类型可以是任意 JAVA 对象。
 * 
 * @param type
 *            对象类型
 * @param f
 *            文件对象
 * @return 指定类型的 JAVA 对象
 * @throws JsonException
 */
public static <T> T fromJsonFile(Class<T> type, File f) {
    BufferedReader br = null;
    try {
        br = buffr(fileInr(f));
        return Json.fromJson(type, br);
    }
    finally {
        Streams.safeClose(br);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public String toString(String charset) throws IOException {
    index = 0;
    cursor = 0;
    StringBuilder sb = new StringBuilder();
    StringOutputStream sos = new StringOutputStream(sb, charset);
    byte c;
    while ((c = (byte) this.read()) != -1)
        sos.write(c);
    Streams.safeFlush(sos);
    Streams.safeClose(sos);
    return sb.toString();
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public WxAccessToken get() {
    Map<String, String> map;
    Jedis jedis = null;
    try {
        jedis = jedisAgent.getResource();
        map = jedis.hgetAll(tokenKey);
    } finally {
        Streams.safeClose(jedis);
    }
    if (map == null || map.isEmpty())
        return null;
    return Lang.map2Object(map, WxAccessToken.class);
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public void save(String token, int expires, long lastCacheTimeMillis) {
    Map<String, String> map = new HashMap<String, String>();
    map.put("token", token);
    map.put("expires", "" + expires);
    map.put("lastCacheTimeMillis", "" + lastCacheTimeMillis);
    Jedis jedis = null;
    try {
        jedis = jedisAgent.getResource();
        jedis.hmset(tokenKey, map);
    } finally {
        Streams.safeClose(jedis);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public void scan(Parsing ing) {
    try {
        scanWithException(ing);
    }
    catch (Exception e) {
        throw Lang.wrapThrow(e);
    }
    finally {
        Streams.safeClose(ing.reader);
    }
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public void init() throws IOException {
    log.debug("beetl init ....");
    Configuration cfg = Configuration.defaultConfiguration();
    Properties prop = new Properties();
    InputStream ins = Configuration.class.getResourceAsStream("/beetl.properties");
    if (ins != null) {
        log.debug("found beetl.properties, loading ...");
        try {
            prop.load(ins);
        }
        finally {
            Streams.safeClose(ins);
        }
    }
    if (!prop.containsKey(Configuration.RESOURCE_LOADER)) {
        // 默认选用WebAppResourceLoader,除非用户自定义了RESOURCE_LOADER
        log.debug("no custom RESOURCE_LOADER found , select WebAppResourceLoader");
        cfg.setResourceLoader(WebAppResourceLoader.class.getName());
    }
    if (!prop.containsKey(Configuration.DIRECT_BYTE_OUTPUT)) {
        // 默认启用DIRECT_BYTE_OUTPUT,除非用户自定义, 一般不会.
        log.debug("no custom DIRECT_BYTE_OUTPUT found , set to true");
        // 当DIRECT_BYTE_OUTPUT为真时, beetl渲染会通过getOutputStream获取输出流
        // 而BeetlView会使用LazyResponseWrapper代理getOutputStream方法
        // 从而实现在模板输出之前,避免真正调用getOutputStream
        // 这样@Fail视图就能正常工作了
        cfg.setDirectByteOutput(true);
    }
    if (!prop.containsKey(Configuration.ERROR_HANDLER)) {
        // 没有自定义ERROR_HANDLER,用定制的
        cfg.setErrorHandlerClass(LogErrorHandler.class.getName());
    }
    groupTemplate = new GroupTemplate(cfg);
    render = new WebRender(groupTemplate);
    log.debug("beetl init complete");
}
 

import org.nutz.lang.Streams; //导入方法依赖的package包/类
public void add(Reader r) throws IOException {
    try {
        BufferedReader br = null;
        if (r instanceof BufferedReader)
            br = (BufferedReader)r;
        else
            br = new BufferedReader(r);
        StringBuilder key = new StringBuilder();
        StringBuilder sb = new StringBuilder();
        OUT: while (br.ready()) {
            String line = Streams.nextLineTrim(br);
            if (line == null)
                break;
            if (line.startsWith("/*")) {
                if (key.length() > 0 && line.contains("*/") && !line.endsWith("*/")) {
                    sb.append(line);
                    continue;
                }
                if (key.length() > 0 && sb.length() > 0) {
                    addSql(key.toString(), sb.toString());
                }
                key.setLength(0);
                sb.setLength(0);
                
                if (line.endsWith("*/")) {
                    if (line.length() > 4)
                        key.append(line.substring(2, line.length() - 2).trim());
                    continue;
                } else {
                    key.append(line.substring(2).trim());
                    while (br.ready()) {
                        line = Streams.nextLineTrim(br);
                        if (line == null)
                            break OUT;
                        if (line.endsWith("*/")) {
                            if (line.length() > 2)
                                key.append(line.substring(0, line.length() - 2).trim());
                            continue OUT;
                        } else {
                            key.append(line);
                        }
                    }
                }
            }
            if (key.length() == 0) {
                log.infof("skip not key sql line %s", line);
                continue;
            }
            if (sb.length() > 0)
                sb.append("\n");
            sb.append(line);
        }
        
        // 最后一个sql也许是存在的
        if (key.length() > 0 && sb.length() > 0) {
            addSql(key.toString(), sb.toString());
        }
    }
    finally {
        Streams.safeClose(r);
    }
}