solr入门之pinyin4j的源码改写初尝试

目标:

pinyin4j中收录了很多的词,但是也有一些词语是未被收录的,目前想做到的效果是

能将为收录的词语收录进去,而且还不需要重新启动服务

===================================================

源码观看

//测试用调用的方法
String[] strs = PinyinHelper.toHanyuPinyinStringArray(c, format);

  static public String[] toHanyuPinyinStringArray(char ch, HanyuPinyinOutputFormat outputFormat)
      throws BadHanyuPinyinOutputFormatCombination {
    return getFormattedHanyuPinyinStringArray(ch, outputFormat);
  }


  static private String[] getFormattedHanyuPinyinStringArray(char ch,
      HanyuPinyinOutputFormat outputFormat) throws BadHanyuPinyinOutputFormatCombination {
    String[] pinyinStrArray = getUnformattedHanyuPinyinStringArray(ch);

    if (null != pinyinStrArray) {

      for (int i = 0; i < pinyinStrArray.length; i++) {
        pinyinStrArray[i] = PinyinFormatter.formatHanyuPinyin(pinyinStrArray[i], outputFormat);
      }

      return pinyinStrArray;

    } else
      return ARR_EMPTY;
  }


//这里初始化是很重要的一步
  private static String[] getUnformattedHanyuPinyinStringArray(char ch) {
    return ChineseToPinyinResource.getInstance().getHanyuPinyinStringArray(ch);
  }


//单例类
  static ChineseToPinyinResource getInstance() {
    return ChineseToPinyinResourceHolder.theInstance;
  }

  /**
   * Singleton implementation helper.
   */
  private static class ChineseToPinyinResourceHolder {
    static final ChineseToPinyinResource theInstance = new ChineseToPinyinResource();
  }

//初始化过程
  private ChineseToPinyinResource() {
    initializeResource();
  }

  /**
   * Initialize a hash-table contains <Unicode, HanyuPinyin> pairs
   */
  private void initializeResource() {
    try {
      final String resourceName = "/pinyindb/unicode_to_hanyu_pinyin.txt";
      final String resourceMultiName = "/pinyindb/multi_pinyin.txt";

      setUnicodeToHanyuPinyinTable(new Trie());
      getUnicodeToHanyuPinyinTable().load(ResourceHelper.getResourceInputStream(resourceName));//加载单个词语--我做的就是再加载一次自定义的文件

      getUnicodeToHanyuPinyinTable().loadMultiPinyin(
          ResourceHelper.getResourceInputStream(resourceMultiName));//加载联想词

      getUnicodeToHanyuPinyinTable().loadMultiPinyinExtend();//加载用户扩展多音词

    } catch (FileNotFoundException ex) {
      ex.printStackTrace();
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }



/**
*主要内容都在这个类中
 */
public class Trie {

  private Hashtable<String, Trie> values = new Hashtable<String, Trie>();//本节点包含的值

  private String pinyin;//本节点的拼音

  private Trie nextTire;//下一个节点,也就是匹配下一个字符

  public String getPinyin() {
    return pinyin;
  }

  public void setPinyin(String pinyin) {
    this.pinyin = pinyin;
  }

  public Trie getNextTire() {
    return nextTire;
  }

  public void setNextTire(Trie nextTire) {
    this.nextTire = nextTire;
  }

  /**
   * 加载拼音
   *
   * @param inStream 拼音文件输入流
   * @throws IOException
   */
  public synchronized void load(InputStream inStream) throws IOException {
    BufferedReader bufferedReader = null;
    InputStreamReader inputStreamReader = null;
    try {
      inputStreamReader = new InputStreamReader(inStream);
      bufferedReader = new BufferedReader(inputStreamReader);
      String s;
      while ((s = bufferedReader.readLine()) != null) {
        String[] keyAndValue = s.split(" ");
        if (keyAndValue.length != 2) continue;
        Trie trie = new Trie();
        trie.pinyin = keyAndValue[1];
        put(keyAndValue[0], trie);
      }
    } finally {
      if (inputStreamReader != null) inputStreamReader.close();
      if (bufferedReader != null) bufferedReader.close();
    }
  }

  /**
   * 加载多音字拼音词典
   *
   * @param inStream 拼音文件输入流
   */
  public synchronized void loadMultiPinyin(InputStream inStream) throws IOException {
    BufferedReader bufferedReader = null;
    InputStreamReader inputStreamReader = null;
    try {
      inputStreamReader = new InputStreamReader(inStream);
      bufferedReader = new BufferedReader(inputStreamReader);
      String s;
      while ((s = bufferedReader.readLine()) != null) {
        String[] keyAndValue = s.split(" ");
        if (keyAndValue.length != 2) continue;

        String key = keyAndValue[0];//多于一个字的字符串
        String value = keyAndValue[1];//字符串的拼音
        char[] keys = key.toCharArray();

        Trie currentTrie = this;
        for (int i = 0; i < keys.length; i++) {
          String hexString = Integer.toHexString(keys[i]).toUpperCase();

          Trie trieParent = currentTrie.get(hexString);
          if (trieParent == null) {//如果没有此值,直接put进去一个空对象
            currentTrie.put(hexString, new Trie());
            trieParent = currentTrie.get(hexString);
          }
          Trie trie = trieParent.getNextTire();//获取此对象的下一个

          if (keys.length - 1 == i) {//最后一个字了,需要把拼音写进去
            trieParent.pinyin = value;
            break;//此行其实并没有意义
          }

          if (trie == null) {
            if (keys.length - 1 != i) {
              //不是最后一个字,写入这个字的nextTrie,并匹配下一个
              Trie subTrie = new Trie();
              trieParent.setNextTire(subTrie);
              subTrie.put(Integer.toHexString(keys[i + 1]).toUpperCase(), new Trie());
              currentTrie = subTrie;
            }
          } else {
            currentTrie = trie;
          }

        }
      }
    } finally {
      if (inputStreamReader != null) inputStreamReader.close();
      if (bufferedReader != null) bufferedReader.close();
    }
  }

  /**
   * 加载用户自定义的扩展词库
   */
  public void loadMultiPinyinExtend() throws IOException {
    String path = MultiPinyinConfig.multiPinyinPath;
    if (path != null) {
      File userMultiPinyinFile = new File(path);
      if (userMultiPinyinFile.exists()) {
        loadMultiPinyin(new FileInputStream(userMultiPinyinFile));
      }
    }
  }

  public Trie get(String hexString) {
    return values.get(hexString);
  }

  public void put(String s, Trie trie) {
    values.put(s, trie);
  }
}

准备工作--测试文件的读写方式--加载的

package com.git.pinyin;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;

/**
 * 读取配置文件中信息到map中并且能够写入信息到文件中和map中
 * @author songqinghu
 * 可以软加载的方法  定时去加载 一次配置文件 
 */
public class ReadAndWriteTest {

    private final static Map<String,String> dict = new HashMap<String,String>();
    
    public static void main(String[] args) throws IOException {
        String path  = "/pinyindb/gome_hanyu_pinyin_ext.txt";
       // readText(path);
       // HashMap<String, String> map = new HashMap<String,String>();
       // map.put("我是好人", "wo");
       // map.put("我", "wo");
       // map.put("是", "shi");
        //map.put("好", "hao,ren");
        //writeText(map);
        unicodeTohanzi("3007");  // 龦 9FA6 cháng //这个词典里没有 一会用她测试
    }
    private static void unicodeTohanzi(String unicode){
        
        int code = Integer.parseInt(unicode, 16);
        System.out.println((char)code);
        
    }
    /**
     * 
     * @描述：将汉字和拼音写入文件中  汉字  拼音集合 xxx,xxx,xxx
     * @param content
     * @return void
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     * @throws IOException 
     */
    public static void writeText(Map<String,String> content) throws IOException{
        String path = ReadAndWriteTest.class.getResource("/pinyindb/gome_hanyu_pinyin_ext.txt").getPath();
        System.out.println(path);
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(path, true)));
        Set<Entry<String, String>> entrySet = content.entrySet();
        String line = null;
        //writer.newLine();
        for (Entry<String, String> entry : entrySet) {
            String key = entry.getKey();
            char[] charArray = key.toCharArray();
            for (int i = 0; i < charArray.length; i++) {
                if(i!=0){
                    break;
                }
                key = Integer.toHexString(charArray[i]);
            }
            line = key +" (" +entry.getValue()+")";
            writer.write(line);
            writer.newLine();
        }
        writer.flush();
        writer.close();
        System.out.println("====");
    }
    
    
    
    /**
     * 
     * @描述：读取文件中信息到map中
     * @param path  文件路径  格式 "/pinyindb/gome_hanyu_pinyin_ext.txt"
     * @return void
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     * @throws IOException 
     */
    private static synchronized void readText(String path){
        if(StringUtils.isNotBlank(path)){
            BufferedReader reader = new BufferedReader(new InputStreamReader(ReadAndWriteTest.class.getResourceAsStream(path)));
            if(reader != null){
                String line=null;
                try {
                    while((line = reader.readLine())!=null){//读取一行到String中
                        String[] values = line.split(" ");
                        if(values.length != 2){
                            continue;
                        }
                        String unicode = values[0];
                        int code = Integer.parseInt(unicode, 16);
                        char ch = (char) code;
                        String pinyin  = values[1];
                        System.out.println("编码后的字符: " + unicode + "  对应的拼音:"+ pinyin);
                        System.out.println(ch);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }finally {
                    if(reader !=null){
                        try {
                            reader.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        
    }
    
}

3.简单的向源码中添加类

从git上下载后,改写的源码地址

链接：http://pan.baidu.com/s/1i5zvYfz 密码：zodu

package com.gome.mx.plus.pinyin.ext;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

/**
 * 输入汉字获取对应拼音的工具类
 * @author songqinghu
 *
 */
public class PYReadUtils {

    /**
     * 
     * @描述：输入汉字获取对应的全拼  可能是多音字  返回为数组类型 ---如果该汉字查不到则返回null
     * @param words
     * @return
     * @return String[]
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     * @throws BadHanyuPinyinOutputFormatCombination 
     */
    public static String[] getFullPY(String words) throws BadHanyuPinyinOutputFormatCombination{
        
        StringBuffer buffer = new StringBuffer();
        
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        
        char[] chars = words.toCharArray();
        
        for (char c : chars) {
            if(c>128){//汉字
               String[] results  = PinyinHelper.toHanyuPinyinStringArray(c, defaultFormat);
                   
               for (int i = 0; i < results.length; i++) {
                buffer.append(results[i]);
                if(results.length - 1 != i){
                    buffer.append(",");
                 }
               }
               buffer.append(" ");
           }//不是汉字 --不处理 直接过滤掉
        }
        //所有汉字都变成了拼音  转换组合一下  将拼音拼凑起来
        return combination(buffer.toString());
    }
    //拼音封装去重复
    private static String[] combination(String all){
        ArrayList<Map<String, Integer>> list = new ArrayList<Map<String,Integer>>();
        
        String[] words = all.split(" ");//切为每个词
        for (String word : words) {
            String[] pys = word.split(",");//切出来每个词的每个拼音
            HashMap<String, Integer> map = new HashMap<String,Integer>();
            for (String py : pys) {//
                if(map.containsKey(py)){//去除重复拼音
                    Integer count = map.get(py);
                    map.put(py, count+1);
                }else{
                    map.put(py,1);
                }
            }
            list.add(map);//拼音顺序保持正确
        }
        //所有拼音处理完毕---进行拼凑
        return midMakeUp(list);
    }
    //组合拼音
    private static String[] midMakeUp(ArrayList<Map<String, Integer>> list){
        
        HashMap<String, Integer> firsts = null;
        
        for (Map<String, Integer> map : list) {
            
            HashMap<String, Integer> temp = new HashMap<String,Integer>();
            
            if(firsts !=null){//如果不是第一次--考虑组合问题
                for (String str : firsts.keySet()) {
                    for (String st : map.keySet()) {
                        temp.put(str + st, 1);//组合
                    }
                }
                
                if(temp != null && temp.size()>0){//清理容器  做容器转换
                    firsts.clear();
                }
                
            }else{//如果是第一次
                for (String str : map.keySet()) {
                    temp.put(str, 1);
                }
            }
            if(temp !=null && temp.size()>0){
                firsts = temp;
            }
        }
        //组合结束---调用方法转为string[] 
        
        return toStringArr(firsts);
    }
    
    private static String[] toStringArr(Map<String,Integer> map){
        if(map !=null && map.size()>0){
            String[] strs = new String[map.size()];
            Set<String> keySet = map.keySet();
            int i = 0;
            for (String key : keySet) {
                strs[i] = key;
                i++;
            }
            return strs;
        }
        return null;
    }
    
    
}

package com.gome.mx.plus.pinyin.ext;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import net.sourceforge.pinyin4j.ChineseToPinyinResource;
import net.sourceforge.pinyin4j.multipinyin.Trie;
/**
 * 将汉语和拼音写入指定的文件中--文件位置可以指定
 * 并且能够动态的加载  不需要重启服务
 * 还能指定是否重新写 还是追加的方式
 * 还能够将原来已经存在的拼音合并过来--可以指定
 * @author songqinghu
 *
 */
public class PYWriterUtils {

    private static String path  = "/pinyindb/gome_hanyu_pinyin_ext.txt";
    
    /**
     * @描述：获取配置文件的位置
     * @return void
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     */
    public static void setPath(String path){
        PYWriterUtils.path = path;
    }
    
    /**
     * 
     * @描述：默认写入的方式  设置为追加模式  合并已经存在的拼音为一个
     * @param word  汉字
     * @param pinyin 拼音
     * @param voice  声调
     * @return
     * @return boolean  是否成功
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     * @throws Exception 
     */
    public static boolean dufaultWriter(String word,String pinyin,Integer voice) throws Exception{
        return writerControler(word, pinyin, voice, true, true);
    }
    /**
     * 
     * @描述：可以设置的写入方式  --这里还要增加一个批量写入的功能  本方法只是处理一个汉字
     * @param word  汉字
     * @param pinyin 拼音
     * @param voice  声调
     * @param additional 是否追加到文件后
     * @param merge 是否合并已经出现的拼音到文件中
     * @return
     * @return boolean
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     * @throws Exception 
     * 龦
     */
    public static boolean writerControler(String word,String pinyin,Integer voice,
            boolean additional ,boolean merge) throws Exception{
        //添加音调
        pinyin = pinyin + voice;
        //配置文件地址
        String filePath = PYWriterUtils.class.getResource(path).getPath();
        //获取
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filePath, additional)));
        //写入--16进制  查询 --
        if(word !=null && word.length()>0){
            char c = word.toCharArray()[0];
            if(c>128){//是汉字
                String unicode = Integer.toHexString(c).toUpperCase();//编码
                if(merge){//如果要合并
                    Trie trie = ChineseToPinyinResource.getInstance().getUnicodeToHanyuPinyinTable();
                    String before = trie.get(unicode).getPinyin();
                    before = before.trim().substring(1, before.trim().length()-1);//去除()
                    pinyin = before +Field.COMMA+ pinyin;
                }
                pinyin = addSymbol(pinyin);
                writer.write(unicode+Field.SPACE+pinyin);
                writer.newLine();
                System.out.println(unicode+Field.SPACE+pinyin);
            }
        }
        writer.flush();
        writer.close();
        
        return true;
    }
    /**
     * 
     * @描述：当自定义文件需要更新时,调用方法 重新加载自己的配置文件
     * @return
     * @return boolean
     * @exception
     * @createTime：2016年4月6日
     * @author: songqinghu
     * @throws IOException 
     */
    public static boolean reloadText() throws IOException{
        
        InputStream is = PYWriterUtils.class.getResourceAsStream(path);
        
        ChineseToPinyinResource.getInstance().getUnicodeToHanyuPinyinTable().load(is);
        
        return true;
    }
    
    
    
    /**
     * 添加操作符号
     */
    private static String addSymbol(String pinyin){
        return Field.LEFT_BRACKET+pinyin+Field.RIGHT_BRACKET;
    }
    
    class Field {
        static final String LEFT_BRACKET = "(";

        static final String RIGHT_BRACKET = ")";

        static final String COMMA = ",";
        
        static final String SPACE = " ";
    }
}

package com.gome.mx.plus.pinyin.ext;

public enum Voice {

    One(1),Two(2),Three(3),Four(4);
    
    private  final Integer value;
    
    Voice(Integer value){
        this.value = value;
    }
    
    public Integer getValue(){
        return value;
    }
}

测试的类--第一次写入 但是不加载进map中 读取不到  加载后能读取到了

说明:默认自定义的文件地址为:path  = "/pinyindb/gome_hanyu_pinyin_ext.txt"  即和pinyin4j的字典在相同的目录下

package com.gome.mx.plus.pinyin.ext;

import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

public class MyTest {

    
    public static void main(String[] args) throws BadHanyuPinyinOutputFormatCombination {
//        String[] fullPY = PYReadUtils.getFullPY("龦");
//        for (String string : fullPY) {
//            System.out.println(string);
//        }
        try {
            //写入全新的字符到文件中
            PYWriterUtils.writerControler("骉", "test", Voice.Two.getValue(),true, true);
            String[] fullPY = PYReadUtils.getFullPY("骉");
            if(fullPY == null){
                System.out.println("没有查到");
            }else{
                System.out.println("查到");
                for (String string : fullPY) {
                    System.out.println(string);
                }
            }
            PYWriterUtils.reloadText();
            String[] full = PYReadUtils.getFullPY("骉");
            if(full == null){
                System.out.println("没有查到");
            }else{
                System.out.println("查到");
                for (String string : full) {
                    System.out.println(string);
                }
            }
            
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}