env.java

java xml开发指南（初学者推荐）Java Xml 编程指南书籍源码

package MyNa.utils;

import java.util.Hashtable;
import java.util.Stack;
import java.util.Enumeration;
import java.io.Serializable;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.FileReader;
import javax.servlet.http.HttpServletRequest; 

public class Env extends Hashtable {
Logger lg;
  // we specifically expect keys to be strings,
  // values to be strings or string-arrays;
  // more types may be added later. We expect
  // to use serializability; more important, we
  // expect to add read and write to editable text-files

public Env(Hashtable H){
  lg=new Logger();
  addHashtable(H);
}
public void addHashtable(Hashtable H){
  Enumeration k=H.keys();
  while(k.hasMoreElements()){
    Object S=k.nextElement();
    this.put(S,H.get(S));
    }
  addEnvironmentFile();
}

public String toString(){
  StringBuffer sB=new StringBuffer();
  Enumeration k=keys();
  while(k.hasMoreElements()){
    String S=(String)k.nextElement();
    sB.append(S);
    sB.append("=");
    sB.append(getStr(S));
    sB.append(", \t");
    }
  return sB.toString();
}

public String toStringRec(){
  // use if subEnvs might be cyclic
  StringBuffer sB=new StringBuffer();
  tSS(this,new Stack(),sB);
  return sB.toString();
}

public void tSS(Env E,Stack eS,StringBuffer sB){
  // tostring subfunction for safe recursive Envs
  if(0<=eS.search(E)){
    sB.append("***CYCLIC ENV***\n");
    return;
    }
  eS.push(E);
  Enumeration k=E.keys();
  while(k.hasMoreElements()){
    String key=(String)k.nextElement();
    for(int i=0;i<eS.size();i++)sB.append("  ");
    sB.append(key); sB.append("=");
    Object ob=E.get(key);
    if(null==ob)sB.append("null;\n");
    else if(ob instanceof String){
       sB.append((String)ob);
       sB.append(";\n");
       }
    else if(ob instanceof String[]){
      sB.append(Misc.stringArrayJoin((String[])ob,", "));
      sB.append(";\n");
      }
    else if(ob instanceof Env){
      sB.append("[\n");
      tSS((Env)ob,eS,sB);
      for(int i=0;i<=eS.size();i++)sB.append("  ");
      sB.append("]\n");
      }
    else sB.append("??\n");
  }
  eS.pop();
}


public Env(){ lg=new Logger(); 
}

public Env(BufferedReader brin){
  lg=new Logger();
  try{
  addBufferedReader(brin);
  }catch(Exception ex){lg.logIt("env br fail: "+ex);}
}

public String getLine(BufferedReader brin){
  try{
    String theLine=brin.readLine(); 
    if(theLine==null)return null;
    else return theLine;
  }catch(Exception ex){return null;}
}

public void addBufferedReader (BufferedReader brin)throws ParseSubstException {
  if(brin==null){
     lg.logIt("addBufferedReader failure: null reader");
     return;
     }
  String key; String line;  StringBuffer value=new StringBuffer();
  try{
  while((key=brin.readLine())!=null){
    if((line=brin.readLine())!=null){
      value.setLength(0);
      while(line!=null && line.endsWith("\\") && !line.endsWith("\\\\")){
        value.append(line); 
        value.setCharAt(value.length()-1,'\n');
        line=brin.readLine();
        }
      if(line!=null)value.append(line);
//       lg.logIt("Env.addBufferedReader key="+key+", value="+value);
      putQuotedVal(key,Misc.substLineByTags(value.toString(),this));
      } 
    }
  brin.close();
  addEnvironmentFile();
  }
  catch(IOException ex)
     {lg.logIt("addBufferedReader: ",ex);}
}

public void addEnvironmentFile(){
  String envFile=getStr("includeEnvironmentFile");
  if(envFile==null)return;
  lg.logIt("including env file "+envFile);
try{
  remove("includeEnvironmentFile");
  put("includedEnvironmentFile",envFile);
  BufferedReader br=getBufferedReader(envFile);
  if(br==null){lg.logIt("null envFile br"); return;}
  addBufferedReader(br);
  lg.logIt("included env file "+envFile);
}catch(Exception ex){lg.logIt("addEnvF:"+ex);}
}

public void putQuotedVal(String key,String val){
  val=Misc.evalQuotedChars(val);
  if(!key.startsWith("[]"))put(key,val);
  else put(key.substring(2,key.length()),
           Misc.stringSplit(val) );
}

public Env(String fName){
  this(getBufferedReader(fName));
}
public static BufferedReader getBufferedReader(String fName){
 try{
   FileReader fR=new FileReader(fName);
   if(fR==null)return null;
   return new BufferedReader(fR);
 }catch(Exception ex)
    {ex.printStackTrace(); 
     return null;}
}

public Env(HttpServletRequest req){
  lg=new Logger(); lg.logIt("reading an httpservletrequest");
  Enumeration E=req.getParameterNames();
  while(E.hasMoreElements()){
    String name=(String)E.nextElement();
    String[]vals=req.getParameterValues(name);
    if(vals.length!=1)this.put(name,vals);
    else this.put(name,vals[0]);
    }
  lg.logIt("got through initial env");
  addEnvironmentFile();
}

public String getStr(String key){
  Object ob=this.get(key);
  if(ob==null)lg.logIt("null getStr for ["+key+"]");
  if(ob instanceof String)
    return (String)ob;
  else if(ob instanceof String[])
    return Misc.stringArrayJoin((String[])ob,", ");
  else if(ob instanceof Env)
    return "["+((Env)ob).toString()+"]";
  else return null;
}
public String getStr(String key,String dflt){
  Object ob=this.get(key);
  if(ob==null)return dflt;
  if(ob instanceof String) return (String)ob;
  else if(ob instanceof String[])
    return Misc.stringArrayJoin((String[])ob,", ");
  else return dflt;
}

public String[] getStrSeq(String key){
  Object ob=this.get(key);
  if(ob==null)lg.logIt("null getStrSeq for ["+key+"]");
  if(ob instanceof String[]) return (String[])ob;
  else if(ob instanceof String) return new String[]{(String)ob};
  else return null;
}
public int getInt(String key,int dfault){
  Object ob=this.get(key);
  if(ob==null)return dfault;
  if(ob instanceof String) return Integer.parseInt((String)ob);
  return ((Integer)ob).intValue();
}
public void append2StrSeq(String key,String val){
  Object ob=get(key);
  if(null==ob)return;
  String[]A;
  if(ob instanceof String[])A=(String[])ob;
  else if(ob instanceof String)A=new String[]{(String)ob};
  else return;
  String[]B=new String[A.length+1];
  for(int i=0;i<A.length;i++)B[i]=A[i];
  B[A.length]=val;
  put(key,B);
}
public void takeStrSeq(String key,int numToTake){
  Object ob=get(key);
  if(null==ob)return;
  String[]A;
  if(ob instanceof String[])A=(String[])ob;
  else if(ob instanceof String)A=new String[]{(String)ob};
  else return;
  if(numToTake>=A.length)return;
  String[]B=new String[numToTake];
  for(int i=0;i<numToTake;i++)B[i]=A[i];
  put(key,B);
}
public Env getEnv(String key){
  Object ob=get(key); 
  if(ob==null || !(ob instanceof Env))return null;
  return (Env)ob;
}
public void put(String[]keys,Object val){
   // put(["subEnv","subsubEnv","subSubSubEnv","key"],"val")
   // makes sure that 
   // this.getEnv("subEnv").getEnv("subsubEnv").get("key")=="val"
  if(null==keys||0==keys.length)return;
  Env E=this; int lastIndex=keys.length-1;
  for(int i=0;i<lastIndex;i++){
    Object ob=E.get(keys[i]);
    if(null==ob || !(ob instanceof Env))
      {ob=new Env(); E.put(keys[i],ob);}
    E=(Env)ob;
    }
  E.put(keys[lastIndex],val);
}
public Object get(String[]keys){
  if(null==keys||0==keys.length)return null;
  Env E=this; int lastIndex=keys.length-1;
  for(int i=0;i<lastIndex;i++){
    Object ob=E.get(keys[i]);
    if(null==ob || !(ob instanceof Env)) return null;
    E=(Env)ob;
    }
  return E.get(keys[lastIndex]);
}

public void putSplit(String key, Object val){
  if(null==key)return;
  if(key.indexOf('_')<0)put(key,val);
  else put(Misc.stringSplit(key,'_'),val);
}

public Object getSplit(String key){
  if(null==key)return null;
  if(key.indexOf('_')<0)return get(key);
  return get(Misc.stringSplit(key,'_'));   
}

   
}