Java Streams类代码示例

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 _set_cache_item(final ZCache<ZDocTmplObj> zc, String fname) {
    if (!Strings.isBlank(fname)) {
        topIgnores.add(fname);
        final ZDir d = src.getDir(fname);
        if (null != d) {
            d.walk(true, new ZFWalker() {
                public boolean invoke(int i, ZFile f) {
                    if (f.isDir())
                        return true;
                    if (f.isHidden())
                        return false;
                    ZDocTmplObj ci = new ZDocTmplObj();
                    ci.file(f).raw(Streams.readAndClose(io.readString(f)));
                    String rph = d.relative(f);
                    String key = ZD.rph2key(rph);
                    zc.set(key, ci);
                    return true;
                }
            });
        }
    }
}
 

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包/类
public byte[] getBytes(long pos, int length) throws SQLException {
    if (pos == 1 && length == length())
        try {
            return Streams.readBytes(getBinaryStream());
        } catch (IOException e) {
        }
    throw Lang.noImplement();
}
 

import org.nutz.lang.Streams; //导入依赖的package包/类
public void saveAs(File f) throws IOException {
    Writer w = Streams.fileOutw(f);
    for (String key : keylist()) {
        w.append("/*").append(Strings.dup('-', 60)).append("*/\n");
        String sql = map().get(key);
        w.append(format("/*%s*/\n", key));
        w.append(sql).append('\n');
    }
    w.flush();
    w.close();
}
 

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包/类
public Object get(ResultSet rs, String colName) throws SQLException {
    File f = this.createTempFile();
    Clob clob = rs.getClob(colName);
    if (clob == null)
        return null;
    Streams.writeAndClose(Streams.fileOutw(f), clob.getCharacterStream());
    return new SimpleClob(f);
}
 

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包/类
protected static SnakerEngine buildSnaker(DataSource ds, Object...paths) throws IOException {
 	// 首先,我们构建一个snaker的上下文
 	SimpleContext ctx = new SimpleContext();
 	// 将集成nutz所必须的两个类,关联之. 这样使用者仅需要声明本IocLoader即可完成全部配置
 	ctx.put(NutzAccess.class.getName(), NutzAccess.class);
 	ctx.put(NutzTransactionInterceptor.class.getName(), NutzTransactionInterceptor.class);
 	// 开始构建sanker的配置对象
 	Configuration cnf = new Configuration(ctx);
     cnf.initAccessDBObject(ds);
     SnakerEngine engine = cnf.buildSnakerEngine();
     // 如果用户声明了流程描述文件的路径,加载之
     if (paths != null) {
     	for (Object path : paths) {
	for(NutResource re : Scans.me().scan(String.valueOf(path))) {
		if (log.isDebugEnabled())
			log.debug("Found snakerflow xml > " + re.getName());
		//*********************************************************
		// 这部分属于hack的部分, 因为snaker并不识别相同的流程配置,而是简单地作为新流程
		// 所以,需要自行查询一下是不是数据相同,不一样的时候才deploy
		byte[] data = Streams.readBytesAndClose(re.getInputStream());
		ProcessModel model = ModelParser.parse(data);
		List<Process> list = ctx.find(DBAccess.class).queryList(Process.class, querySql, model.getName());
		if (!list.isEmpty()) {
			Process p = list.get(0);
			byte[] cnt = p.getDBContent();
			if (cnt != null && Arrays.equals(cnt, data)) {
				log.debug("Same  snakerflow xml > " + re.getName() + " skiped");
				continue;
			}
		}
		//*********************************************************
		// 同名的流程数据有更新或这是全新的流程,部署之
		engine.process().deploy(new ByteArrayInputStream(data));
	}
}
     }
     // 工厂方法完成, snaker引擎已经准备好了,可以返回了
     return engine;
 }