`
liufei.fir
  • 浏览: 685061 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论
阅读更多
什么是BOM

BOM(byte-order mark),即字节顺序标记,它是插入到以UTF-8、UTF16或UTF-32编码Unicode文件开头的特殊标记,用来识别Unicode文件的编码类型。对于UTF-8来说,BOM并不是必须的,因为BOM用来标记多字节编码文件的编码类型和字节顺序(big-endian或little- endian)。

BOMs 文件头:
   00 00 FE FF    = UTF-32, big-endian
   FF FE 00 00    = UTF-32, little-endian
   EF BB BF       = UTF-8,
   FE FF          = UTF-16, big-endian
   FF FE          = UTF-16, little-endian



下面举个例子,针对UTF-8的文件BOM做个处理:

String xmla = StringFileToolkit.file2String(new File(“D:\\projects\\mailpost\\src\\a.xml”),“UTF-8”);

byte[] b = xmla.getBytes(“UTF-8”);

String xml = new String(b,3,b.length-3,“UTF-8”);

..............

思路是:先按照UTF-8编码读取文件后,跳过前三个字符,重新构建一个新的字符串,然后用Dom4j解析处理,这样就不会报错了。

其他编码的方式处理思路类似,其实可以写一个通用的自动识别的BOM的工具,去掉BOM信息,返回字符串。

不过这个处理过程已经有牛人解决过了:http://koti.mbnet.fi/akini/java/unicodereader/

‍Example code using UnicodeReader class
Here is an example method to read text file. It will recognize bom marker and skip it while reading. 

//import ‍http://koti.mbnet.fi/akini/java/unicodereader/UnicodeReader.java.txt
   public static char[] loadFile(String file) throws IOException {
      // read text file, auto recognize bom marker or use 
      // system default if markers not found.
      BufferedReader reader = null;
      CharArrayWriter writer = null;
      UnicodeReader r = new UnicodeReader(new FileInputStream(file), null);
  
      char[] buffer = new char[16 * 1024];   // 16k buffer
      int read;
      try {
         reader = new BufferedReader(r);
         writer = new CharArrayWriter();
         while( (read = reader.read(buffer)) != -1) {
            writer.write(buffer, 0, read);
         }
         writer.flush();
         return writer.toCharArray();
      } catch (IOException ex) {
         throw ex;
      } finally {
         try {
            writer.close(); reader.close(); r.close();
         } catch (Exception ex) { }
      }
   }


Example code to write UTF-8 with bom marker
Write bom marker bytes to start of empty file and all proper text editors have no problems using a correct charset while reading files. Java's OutputStreamWriter does not write utf8 bom marker bytes. 


   public static void saveFile(String file, String data, boolean append) throws IOException {
      BufferedWriter bw = null;
      OutputStreamWriter osw = null;
  
      File f = new File(file);
      FileOutputStream fos = new FileOutputStream(f, append);
      try {
         // write UTF8 BOM mark if file is empty
         if (f.length() < 1) {
           final byte[] bom = new byte[] { (byte)0xEF, (byte)0xBB, (byte)0xBF };
            fos.write(bom);
         }

         osw = new OutputStreamWriter(fos, "UTF-8");
         bw = new BufferedWriter(osw);
         if (data != null) bw.write(data);
      } catch (IOException ex) {
         throw ex;
      } finally {
         try { bw.close(); fos.close(); } catch (Exception ex) { }
      }
   }
 



实际应用:
package com.dayo.gerber;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.util.Properties;

/**
 * 
 * @author 刘飞(liufei)
 * 
 */
public class Generate4YYQTPScript {

	private static final String ENCODING = "UTF-8";
	private static final String GERBER_CONFIG = "config/gerber4yy.properties";

	private static Properties GERBER_CONFIG_PROPS = null;
	private static final String GERBER_FORMAT_DIALOG_TITLE_SCRIPT = "{#GERBER_FORMAT_DIALOG_TITLE}";
	private static String GERBER_FORMAT_DIALOG_TITLE = "";

	/* gerber properties parmters keys config */
	private static final String QTP_SCRIPT_IN = "script.in";

	private static final String QTP_SCRIPT_OUT = "script.out";

	private static final String QTP_SYSTEM_PATH = "QTP.system.path";
	private static final String QTP_SYSTEM_PATH_SCRIPT = "{#QTPSYSTEMPATH}";

	private static final String GERBER_FILE_DRIVER_PATH = "gerber.file.driver.path";
	private static final String GERBER_FILE_DRIVER_PATH_SCRIPT = "{#driver}";

	private static final String GERBER_FILE_DRIVER = "gerber.file.driver";
	private static final String GERBER_FILE_DRIVER_SCRIPT = "{#dr}";

	private static final String GERBER_FILE_DIR = "gerber.file.dir";
	private static final String GERBER_FILE_DIR_SCRIPT = "{#dirName}";

	private static final String GERBER_FILE = "gerber.file";
	private static final String GERBER_FILE_SCRIPT = "{#fileName}";

	private static final String GERBER_OUT = "gerber.out";
	private static final String GERBER_OUT_SCRIPT = "{#gerberout}";

	private static final String VB_EXE_PATH = "vb.exe.path";

	/* bigBoard props */
	private static final String LEAGUE_BOARD_NUM_SCRIPT = "{#LEAGUE_BOARD_NUM}";
	private static final String WIDTH_SCRIPT = "{#WIDTH}";
	private static final String P_SCRIPT = "{#P}" ;
	private static final String DY_SCRIPT = "{#DY}";

	private Properties BIGBOARD_PROPS = null;

	public Generate4YYQTPScript(Properties bigboard_props) {
		super();
		BIGBOARD_PROPS = bigboard_props;

		try {
			GERBER_CONFIG_PROPS = ConfigHelper
					.getConfigProperties(GERBER_CONFIG);
			GERBER_FORMAT_DIALOG_TITLE = GERBER_CONFIG_PROPS.getProperty(
					GERBER_FILE_DRIVER).trim().toUpperCase()
					+ "\\"
					+ GERBER_CONFIG_PROPS.getProperty(GERBER_FILE_DIR).trim()
							.toUpperCase()
					+ "\\"
					+ GERBER_CONFIG_PROPS.getProperty(GERBER_FILE).trim()
							.toUpperCase();
			GERBER_FORMAT_DIALOG_TITLE = GERBER_FORMAT_DIALOG_TITLE.substring(0, 17) ;
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) throws IOException {
		Properties bigboard_props = new Properties() ;
		bigboard_props.setProperty("{#LEAGUE_BOARD_NUM}", String.valueOf(4)) ;
		bigboard_props.setProperty("{#WIDTH}", String.valueOf(new Double("54"))) ;
		bigboard_props.setProperty("{#P}", String.valueOf(new Double("2"))) ;
		bigboard_props.setProperty("{#DY}", String.valueOf(new Double("0.00"))) ;
		
		Generate4YYQTPScript generateQTPScript = new Generate4YYQTPScript(bigboard_props);
		generateQTPScript.generateQTPScript();
//		RuntimeUtil.getInstance().run(generateQTPScript.getVBEXE(), 1, 50000);
	}

	public String getCheckOutFilePath() {
		return GERBER_CONFIG_PROPS.getProperty(GERBER_FILE_DRIVER).trim() + "/"
				+ GERBER_CONFIG_PROPS.getProperty(GERBER_FILE_DIR).trim();
	}

	public String getSavePath() {
		return GERBER_CONFIG_PROPS.getProperty(GERBER_OUT);
	}

	public String getVBEXE() {
		return GERBER_CONFIG_PROPS.getProperty(VB_EXE_PATH);
	}

	/**
	 * Generate QTP Script
	 * 
	 * @return
	 * @throws IOException
	 */
	public File generateQTPScript() throws IOException {
		return generateQTPScript(GERBER_CONFIG_PROPS
				.getProperty(QTP_SCRIPT_OUT), GERBER_CONFIG_PROPS
				.getProperty(QTP_SCRIPT_IN));
	}

	/**
	 * set value to script
	 * 
	 * @param source
	 * @return
	 * @throws IOException
	 */
	private String scriptConvey(String source) throws IOException {
		String _source = source;
		_source = this.replace(this.replace(this.replace(
				this.replace(this.replace(this.replace(this.replace(
						
						_source
						,
						GERBER_FORMAT_DIALOG_TITLE_SCRIPT,
						GERBER_FORMAT_DIALOG_TITLE), GERBER_FILE_SCRIPT,
						GERBER_CONFIG_PROPS.getProperty(GERBER_FILE)),
						GERBER_FILE_DRIVER_SCRIPT, GERBER_CONFIG_PROPS
								.getProperty(GERBER_FILE_DRIVER)),
						GERBER_OUT_SCRIPT, GERBER_CONFIG_PROPS
								.getProperty(GERBER_OUT)),
				GERBER_FILE_DIR_SCRIPT, GERBER_CONFIG_PROPS
						.getProperty(GERBER_FILE_DIR)),
				GERBER_FILE_DRIVER_PATH_SCRIPT, GERBER_CONFIG_PROPS
						.getProperty(GERBER_FILE_DRIVER_PATH)),
				QTP_SYSTEM_PATH_SCRIPT, GERBER_CONFIG_PROPS
						.getProperty(QTP_SYSTEM_PATH));

		if (this.BIGBOARD_PROPS != null) {
			_source = this.replace(this.replace(this.replace(
					
					_source
					
					,
					DY_SCRIPT, this.BIGBOARD_PROPS.getProperty(DY_SCRIPT)),
					WIDTH_SCRIPT, this.BIGBOARD_PROPS
							.getProperty(WIDTH_SCRIPT)),
					LEAGUE_BOARD_NUM_SCRIPT, this.BIGBOARD_PROPS
							.getProperty(LEAGUE_BOARD_NUM_SCRIPT));
			
			_source = this.replace(_source, P_SCRIPT, this.BIGBOARD_PROPS.getProperty(P_SCRIPT)) ;
		}

		return _source;
	}

	/**
	 * Generate QTP Script
	 * 
	 * @param target
	 *            target file
	 * @param source
	 *            source file
	 * @throws IOException
	 */
	public File generateQTPScript(File target, File source) throws IOException {
		return generateQTPScript(target.getAbsolutePath(), source
				.getAbsolutePath());
	}

	/**
	 * Generate QTP Script
	 * 
	 * @param target
	 *            target file path
	 * @param source
	 *            source file path
	 * @return
	 * @throws IOException
	 */
	public File generateQTPScript(String target, String source)
			throws IOException {
		File f = new File(target);
		if (!f.exists()) {
			f.getParentFile().mkdirs();
			try {
				f.createNewFile();
			} catch (Exception e) {
			}
		}
		FileOutputStream fos = null;
		OutputStreamWriter osw = null;
		BufferedWriter bw = null;
		try {
			final byte[] bom = new byte[] { (byte)0xEF, (byte)0xBB, (byte)0xBF };
			fos = new FileOutputStream(f);
			osw = new OutputStreamWriter(fos, ENCODING);
			bw = new BufferedWriter(osw);
			fos.write(bom);
			bw.write(scriptConvey(getSourceFileContentReader(source)));

			bw.flush();
			bw.close();
			return f;
		} catch (IOException e) {
			throw e;
		}
	}

	/**
	 * Reader convey to string
	 * 
	 * @param source
	 * @return
	 * @throws IOException
	 */
	private String reader2String(Reader source) throws IOException {
		BufferedReader bufferedReader = new BufferedReader(source);
		StringBuffer result = new StringBuffer();
		String buffer = null;
		while ((buffer = bufferedReader.readLine()) != null) {
			result.append(buffer + "\n");
		}
		return result.toString();
	}

	/**
	 * 
	 * @param source
	 *            file path
	 * @return
	 * @throws IOException
	 */
	private Reader getReader(String source) throws IOException {
		return source == "" ? null : new BufferedReader(new InputStreamReader(
				getInputStream(source)));
	}

	/**
	 * get script file content string
	 * 
	 * @param source
	 * @return
	 * @throws IOException
	 */
	private String getSourceFileContentReader(String source) throws IOException {
		return source == "" ? "" : reader2String(getReader(source));
	}

	/**
	 * get inputstream
	 * 
	 * @param source
	 *            file path
	 * @return
	 * @throws IOException
	 */
	private InputStream getInputStream(String source) throws IOException {
		return source == "" ? null : new FileInputStream(new File(source));
	}

	/**
	 * Replace all occurences of a substring within a string with another
	 * string.
	 * 
	 * @param inString
	 *            String to examine
	 * @param oldPattern
	 *            String to replace
	 * @param newPattern
	 *            String to insert
	 * @return a String with the replacements
	 */
	private String replace(String inString, String oldPattern, String newPattern) {
		if (!hasLength(inString) || !hasLength(oldPattern)
				|| newPattern == null) {
			return inString;
		}
		StringBuilder sb = new StringBuilder();
		int pos = 0;
		int index = inString.indexOf(oldPattern);
		int patLen = oldPattern.length();
		while (index >= 0) {
			sb.append(inString.substring(pos, index));
			sb.append(newPattern);
			pos = index + patLen;
			index = inString.indexOf(oldPattern, pos);
		}
		sb.append(inString.substring(pos));
		return sb.toString();
	}

	private boolean hasLength(String str) {
		return hasLength((CharSequence) str);
	}

	private boolean hasLength(CharSequence str) {
		return (str != null && str.length() > 0);
	}
}
分享到:
评论

相关推荐

    java去掉txt文本的bom头信息

    以下是一个简单的示例,展示了如何读取带有BOM头的UTF-8文件,并将其写入一个新的不带BOM头的文件: ```java import java.io.*; import java.nio.charset.Charset; import java.nio.charset.StandardCharsets; ...

    Python-convert2utf将目录下的全部源文件转成UTF8编码

    同时,`utf-8-sig`编码器会处理可能存在的BOM,确保写入的文件不含BOM。 标签"Python开发-其它杂项"表明这个话题属于Python开发的范畴,但并不属于特定的库或框架,而是日常开发中可能会遇到的通用问题。这类问题的...

    深入UTF8字符编码

    - BOM(Byte Order Mark):UTF-8编码的文件可以带有一个可选的BOM标记,用于指示数据流的字节顺序,但某些工具或程序可能不支持带BOM的UTF-8。 - 乱码问题:检查文件读取和写入时的编码设置,确保一致。 - 汉字全角...

    批量移除文件的BOM格式

    在编程世界里,BOM(Byte Order Mark)是一种特殊的Unicode字符,用于标识文件的编码方式。在UTF-8编码中,BOM是...同时,这也提醒我们在编写或处理文本文件时,应尽可能遵循无BOM的UTF-8编码标准,以避免兼容性问题。

    JAVA_字符编码

    处理字符编码时,Java提供了`InputStreamReader`和`OutputStreamWriter`类来读写带有特定字符编码的数据。这两个类分别用于将字节流转换为字符流和反之。例如,如果你需要从一个使用UTF-8编码的文件读取数据,你可以...

    Ini for Java

    ps:INI文件一般是Windows平台在使用,而Windows系统中的“记事本”程序比较坑:如果文本文件是UTF-8编码,在用记事本打开并保存后,会变成“UTF-8 Bom”格式。而 Windows中读写INI的相关API又不支持“UTF-8 Bom”...

    poi3.7支持中文编码

    在Java中,使用InputStreamReader和OutputStreamWriter与特定的字符编码(如"UTF-8")结合,可以确保数据读写时的正确编码。例如,当打开一个Excel文件时,可以设置适当的字符集来避免乱码: ```java InputStream ...

    java中的编码知识

    字符编码是用来表示文本中字符的数字系统,如ASCII、ISO-8859-1和Unicode(包括其子集UTF-8、UTF-16等)。在Java中,默认的字符编码是UTF-8,这是因为它能够支持多种语言的字符,包括中文。然而,在处理不同来源的...

    mysql+jsp+SSH网站开发中文乱码解决方案

    开发工具如Eclipse、IntelliJ IDEA等,以及用于编辑文本文件的工具,如Notepad++,都需要设置为UTF-8无BOM格式,以避免源代码中的中文字符在编译或运行时出现乱码。 9. **数据库连接池配置**: 如果使用了连接池...

    java识别文件编码格式

    例如,UTF-8的BOM是EF BB BF,UTF-16LE的BOM是FF FE,UTF-16BE的BOM是FE FF。 5. **CharsetDetector**:虽然Java标准库中没有提供直接的文件编码检测工具,但我们可以自定义实现。一种常见的方法是逐行读取文件,...

    文件编码检测

    6. **最佳实践**:为了避免编码问题,推荐在保存文件时统一使用UTF-8无BOM格式,因为它广泛支持且兼容性好。同时,处理外部文件时,先尝试检测编码,然后再进行读写操作。 压缩包中的文件名称“A Different Top ...

    kindeditor乱码解决版

    1. **检查并统一编码**:确保你的项目从头到尾都是UTF-8无BOM格式。 2. **修改服务器配置**:根据服务器类型,调整响应头的编码设置。 3. **调整数据库设置**:检查数据库的编码设置,确保与前端一致。 4. **更新...

    Unicode转换

    Unicode转换涉及到将文本数据从一种编码格式转换为Unicode编码,常见的Unicode编码有UTF-8、UTF-16和UTF-32等。这些编码方式的主要区别在于如何用二进制表示每个字符。 1. **UTF-8**: UTF-8是最广泛使用的Unicode...

    commons-io-2.6-src.zip

    8. **ByteOrderMark**: 用于识别和处理字节顺序标记(BOM),常在处理UTF-8或UTF-16编码的文件时用到。 与"commons-fileupload.jar"配合使用时,Apache Commons IO 可以帮助处理文件上传过程中的临时文件操作、流的...

    commons-io-2.8.0.rar

    10. **ByteOrderMark**: 用于识别和处理文件或流中的字节顺序标记(BOM),常在处理UTF-8、UTF-16等编码的文本文件时用到。 Commons IO库通过提供这些便利的工具类,简化了Java开发中的IO操作,使开发者能够更专注...

    commons-io-2.8.0-bin.zip

    8. **ByteOrderMark**: 处理字节顺序标记(BOM),在处理UTF-8、UTF-16等编码的文件时,能够识别并处理BOM。 9. **TeeOutputStream**: 实现了输出流的分支,使得数据可以同时写入多个目的地,这在需要记录日志或...

    解决Properties写中文乱码

    在保存Properties文件时,选择UTF-8编码并确保包含BOM(Byte Order Mark),这样Java才能识别出正确的编码。 4. **配置IDE的编码设置**:如果你使用的是集成开发环境(IDE),可以在项目或全局设置中指定源代码和...

    新编码转换大全模块+应用例程.rar

    - **BOM(Byte Order Mark)**:UTF-8编码的文件可能会带有BOM,某些程序可能会因此出现问题。 - **处理策略**:确保文件编码信息的准确传递,或使用能自动识别编码的工具。 5. **应用例程**: 提供的应用例程...

    有错的.vimrc配置文件

    - `setfileencodings=ucs-bom,utf-8,chinese`:设定当打开文件时Vim将按此顺序检测文件的编码。 - `setfileencoding=utf-8`:指定默认保存文件时所使用的编码格式。 - `settermencoding=utf-8`:确保在终端环境下Vim...

    commons-io-2.4

    7. **ByteOrderMark**: 用于检测和处理字节顺序标记(BOM),在处理UTF-8、UTF-16等编码的文件时很有帮助。 8. **DirectoryWalker**: 实现了递归遍历目录的功能,可以根据需要过滤和处理文件。 9. **StreamUtils**...

Global site tag (gtag.js) - Google Analytics