Mrknowledge
Mrknowledge

HDFS CRUD 操作

1 查找

列出某个目录下的文件名称，hdfs命令如下所示：

hdfs dfs –ls/usr/app

java代码片段：

[plain] view plain copy print ?
  1. public void list(String srcPath) {  
  2.            Configuration conf = new Configuration();  
  3.            LOG.info("[Defaultfs] :" +conf.get("fs.default.name"));  
  4.          conf.set("hadoop.job.ugi","app,app");   //It is not necessary for the default user.  
  5.            FileSystem fs;  
  6.           try {  
  7.                    fs= FileSystem.get(conf);  
  8.                    RemoteIterator<LocatedFileStatus>rmIterator = fs.listLocatedStatus(new Path(srcPath));  
  9.                    while (rmIterator.hasNext()) {  
  10.                              Path path = rmIterator.next().getPath();  
  11.                              if(fs.isDirectory(path)){  
  12.                                        LOG.info("-----------DirectoryName: "+path.getName());  
  13.                              }  
  14.                              else if(fs.isFile(path)){  
  15.                                        LOG.info("-----------FileName: "+path.getName());  
  16.                              }  
  17.                    }  
  18.           }catch (IOException e) {  
  19.                    LOG.error("list fileSysetm object stream.:" , e);  
  20.                    new RuntimeException(e);  
  21.           }  
  22. }  


输出结果：

2014-03-11 22:38:15,329 INFO  (com.hdfs.client.SyncDFS:48) ------------File Name: README.txt

2014-03-11 22:38:15,331 INFO  (com.hdfs.client.SyncDFS:45) ------------Directory Name: blog_blogpost

2014-03-11 22:38:15,333 INFO  (com.hdfs.client.SyncDFS:45) ------------Directory Name: test

读取文件中的内容，hdfs命令如下：

hdfs dfs –cat /input

java 代码：

[plain] view plain copy print ?
  1. public void readFile(String file){  
  2.            Configurationconf = new Configuration();  
  3.            FileSystemfs;  
  4.            try {  
  5.                     fs= FileSystem.get(conf);  
  6.                     Pathpath = new Path(file);  
  7.                     if(!fs.exists(path)){  
  8.                              LOG.warn("file'"+ file+"' doesn't exist!");  
  9.                              return ;  
  10.                     }  
  11.                     FSDataInputStreamin = fs.open(path);  
  12.                     Stringfilename = file.substring(file.lastIndexOf('/') + 1, file.length());  
  13.                     OutputStreamout = new BufferedOutputStream(new FileOutputStream(  
  14.                                                                    new File(filename)));  
  15.   
  16.                     byte[] b = new byte[1024];  
  17.                     int numBytes = 0;  
  18.                     while ((numBytes = in.read(b)) > 0) {  
  19.                              out.write(b,0, numBytes);  
  20.                     }  
  21.                     in.close();  
  22.                     out.close();  
  23.                     fs.close();  
  24.            }catch (IOException e) {  
  25.                     LOG.error("ifExists fs Exception caught! :" , e);  
  26.                     new RuntimeException(e);  
  27.            }  
  28.  }  


获取文件的修改时间，java代码：

[plain] view plain copy print ?
  1. /**  
  2.         * Gets the information about the file modifiedtime.  
  3.         * @param source  
  4.         * @throws IOException  
  5.         */  
  6.        public void getModificationTime(String source) throws IOException{  
  7.                     
  8.                  Configurationconf = new Configuration();  
  9.                     
  10.                  FileSystemfs = FileSystem.get(conf);  
  11.                  PathsrcPath = new Path(source);  
  12.                     
  13.                  // Check if the file alreadyexists  
  14.                  if (!(fs.exists(srcPath))) {  
  15.                  System.out.println("No such destination " + srcPath);  
  16.                  return;  
  17.                  }  
  18.                  // Get the filename out of thefile path  
  19.                  Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  20.                     
  21.                  FileStatusfileStatus = fs.getFileStatus(srcPath);  
  22.                  long modificationTime =fileStatus.getModificationTime();  
  23.                     
  24.                  LOG.info("modified datetime: " + System.out.format("File %s; Modification time : %0.2f%n",filename,modificationTime));  
  25.                     
  26.        }  


获取文件块定位信息，java代码：

[plain] view plain copy print ?
  1. /**  
  2.           * Gets the file block location info  
  3.           * @param source  
  4.           * @throws IOException  
  5.           */  
  6.          public void getBlockLocations(String source) throws IOException{  
  7.                    Configurationconf = new Configuration();  
  8.                    FileSystemfs = FileSystem.get(conf);  
  9.                    PathsrcPath = new Path(source);  
  10.                       
  11.                    // Check if the file alreadyexists  
  12.                    if (!(ifExists(source))) {  
  13.                             System.out.println("No such destination " + srcPath);  
  14.                             return;  
  15.                    }  
  16.                    // Get the filename out of thefile path  
  17.                    Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  18.                       
  19.                    FileStatusfileStatus = fs.getFileStatus(srcPath);  
  20.                       
  21.                    BlockLocation[]blkLocations = fs.getFileBlockLocations(fileStatus, 0, fileStatus.getLen());  
  22.                    int blkCount = blkLocations.length;  
  23.                       
  24.                    System.out.println("File :" + filename + "stored at:");  
  25.                    for (int i=0; i < blkCount; i++) {  
  26.                             String[]hosts = blkLocations[i].getHosts();  
  27.                             LOG.info("host ip:" +System.out.format("Host %d: %s %n", i, hosts));  
  28.                    }  
  29.          }  


获取Hadoop集群中data node的DNS主机名，java代码：

[plain] view plain copy print ?
  1. public void getHostnames () throwsIOException{  
  2.                    Configurationconfig = new Configuration();  
  3.                     
  4.                    FileSystemfs = FileSystem.get(config);  
  5.                    DistributedFileSystemhdfs = (DistributedFileSystem) fs;  
  6.                    DatanodeInfo[]dataNodeStats = hdfs.getDataNodeStats();  
  7.                       
  8.                    String[]names = new String[dataNodeStats.length];  
  9.                    for (int i = 0; i < dataNodeStats.length; i++) {  
  10.                             names[i]= dataNodeStats[i].getHostName();  
  11.                             LOG.info("datenode hostname:"+(dataNodeStats[i].getHostName()));  
  12.                    }  
  13.          }  


 

2 创建

创建一个目录，指定具体的文件路径。hdfs命令如下：

[plain] view plain copy print ?
  1. hdfs dfs –mkdir/usr/app/tmp  


java代码：

       

[java] view plain copy print ?
  1. public void mkdir(String dir){  
  2.                  Configurationconf = new Configuration();  
  3.                  FileSystemfs = null;  
  4.                  try {  
  5.                           fs= FileSystem.get(conf);  
  6.                           Pathpath = new Path(dir);  
  7.                           if(!fs.exists(path)){  
  8.                                    fs.mkdirs(path);  
  9.                                    LOG.debug("create directory '"+dir+"' successfully!");  
  10.                           }else{  
  11.                                    LOG.debug("directory '"+dir+"' exits!");  
  12.                           }  
  13.                  }catch (IOException e) {  
  14.                           LOG.error("FileSystem get configuration with anerror");  
  15.                           e.printStackTrace();  
  16.                  }finally{  
  17.                           if(fs!= null){  
  18.                                    try {  
  19.                                              fs.close();  
  20.                                    }catch (IOException e) {  
  21.                                              LOG.error("close fs object stream. :" , e);  
  22.                                              new RuntimeException(e);  
  23.                                    }  
  24.                           }  
  25.                  }  
  26.        }  

将本地文件上传到hdfs上去，java代码如下：

[plain] view plain copy print ?
  1. public void copyFromLocal (String source, String dest) {  
  2.                       
  3.                    Configurationconf = new Configuration();  
  4.                    FileSystemfs;  
  5.                    try {  
  6.                             fs= FileSystem.get(conf);  
  7.                             PathsrcPath = new Path(source);  
  8.                                
  9.                             PathdstPath = new Path(dest);  
  10.                             // Check if the file alreadyexists  
  11.                             if (!(fs.exists(dstPath))) {  
  12.                                      LOG.warn("dstPathpath doesn't exist" );  
  13.                                      LOG.error("No such destination " + dstPath);  
  14.                                      return;  
  15.                             }  
  16.                                
  17.                             // Get the filename out of thefile path  
  18.                             Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  19.                                
  20.                             try{  
  21.                                      //if the file exists in thedestination path, it will throw exception.  
  22. //                                   fs.copyFromLocalFile(srcPath,dstPath);  
  23.                                      //remove and overwrite files withthe method  
  24.                                      //copyFromLocalFile(booleandelSrc, boolean overwrite, Path src, Path dst)  
  25.                                      fs.copyFromLocalFile(false, true, srcPath, dstPath);  
  26.                                      LOG.info("File " + filename + "copied to " + dest);  
  27.                             }catch(Exception e){  
  28.                                      LOG.error("copyFromLocalFile exception caught!:" , e);  
  29.                                      new RuntimeException(e);  
  30.                             }finally{  
  31.                                      fs.close();  
  32.                             }  
  33.                    }catch (IOException e1) {  
  34.                             LOG.error("copyFromLocal IOException objectstream. :" ,e1);  
  35.                             new RuntimeException(e1);  
  36.                    }  
  37.          }  


        

添加一个文件到指定的目录下，java代码如下：

      

[java] view plain copy print ?
  1. public void addFile(String source, String dest)  {  
  2.                          // Conf object will readthe HDFS configuration parameters  
  3.                          Configurationconf = new Configuration();  
  4.                          FileSystemfs;  
  5.                          try {  
  6.                                   fs= FileSystem.get(conf);  
  7.                                   // Get the filename out of thefile path  
  8.                                   Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  9.                                    
  10.                                   // Create the destination pathincluding the filename.  
  11.                                   if (dest.charAt(dest.length() - 1) != '/') {  
  12.                                             dest= dest + "/" + filename;  
  13.                                   }else {  
  14.                                             dest= dest + filename;  
  15.                                   }  
  16.                                    
  17.                                   // Check if the file alreadyexists  
  18.                                   Pathpath = new Path(dest);  
  19.                                   if (fs.exists(path)) {  
  20.                                             LOG.error("File " + dest + " already exists");  
  21.                                             return;  
  22.                                   }  
  23.                                    
  24.                                   // Create a new file and writedata to it.  
  25.                                   FSDataOutputStreamout = fs.create(path);  
  26.                                   InputStreamin = new BufferedInputStream(new FileInputStream(  
  27.                                                                                                                                                   new File(source)));  
  28.                                    
  29.                                   byte[] b = new byte[1024];  
  30.                                   int numBytes = 0;  
  31.                                   //In this way read and write datato destination file.  
  32.                                   while ((numBytes = in.read(b)) > 0) {  
  33.                                             out.write(b,0, numBytes);  
  34.                                   }  
  35.                                   in.close();  
  36.                                   out.close();  
  37.                                   fs.close();  
  38.                          }catch (IOException e) {  
  39.                                   LOG.error("addFile Exception caught! :" , e);  
  40.                                   new RuntimeException(e);  
  41.                          }  
  42.       }  


3 修改

重新命名hdfs中的文件名称，java代码如下：

    

[java] view plain copy print ?
  1. public void renameFile (String fromthis, String tothis){  
  2.               Configurationconf = new Configuration();  
  3.                  
  4.               FileSystemfs;  
  5.               try {  
  6.                        fs= FileSystem.get(conf);  
  7.                        PathfromPath = new Path(fromthis);  
  8.                        PathtoPath = new Path(tothis);  
  9.                           
  10.                        if (!(fs.exists(fromPath))) {  
  11.                                 LOG.info("No such destination " + fromPath);  
  12.                            return;  
  13.                        }  
  14.                           
  15.                        if (fs.exists(toPath)) {  
  16.                                 LOG.info("Already exists! " + toPath);  
  17.                            return;  
  18.                        }  
  19.                           
  20.                        try{  
  21.                                 boolean isRenamed = fs.rename(fromPath,toPath);     //renames file name indeed.  
  22.                                 if(isRenamed){  
  23.                                           LOG.info("Renamed from " + fromthis + " to " + tothis);  
  24.                                 }  
  25.                        }catch(Exception e){  
  26.                                 LOG.error("renameFile Exception caught! :" , e);  
  27.                                 new RuntimeException(e);  
  28.                        }finally{  
  29.                                 fs.close();  
  30.                        }  
  31.               }catch (IOException e1) {  
  32.                        LOG.error("fs Exception caught! :" , e1);  
  33.                        new RuntimeException(e1);  
  34.               }  
  35.     }  

 

4 删除

在hdfs上，删除指定的一个文件。Java代码：

[java] view plain copy print ?
  1. public void deleteFile(String file)  {  
  2.                             Configurationconf = new Configuration();  
  3.                             FileSystemfs;  
  4.                             try {  
  5.                                      fs= FileSystem.get(conf);  
  6.           
  7.                                      Pathpath = new Path(file);  
  8.                                      if (!fs.exists(path)) {  
  9.                                                LOG.info("File " + file + " does not exists");  
  10.                                                return;  
  11.                                      }  
  12.                                      /* 
  13.                                       * recursively delete the file(s) if it is adirectory. 
  14.                                       * If you want to mark the path that will bedeleted as 
  15.                                       * a result of closing the FileSystem. 
  16.                                       *  deleteOnExit(Path f) 
  17.                                       */  
  18.                                      fs.delete(new Path(file), true);  
  19.                                      fs.close();  
  20.                             }catch (IOException e) {  
  21.                                      LOG.error("deleteFile Exception caught! :" , e);  
  22.                                      new RuntimeException(e);  
  23.                             }  
  24.    
  25.                    }  


 

Appendix 完整代码

 

[java] view plain copy print ?
  1. import java.io.BufferedInputStream;  
  2. import java.io.BufferedOutputStream;  
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.InputStream;  
  8. import java.io.OutputStream;  
  9.    
  10. import org.apache.commons.logging.Log;  
  11. import org.apache.commons.logging.LogFactory;  
  12. import org.apache.hadoop.conf.Configuration;  
  13. import org.apache.hadoop.fs.BlockLocation;  
  14. import org.apache.hadoop.fs.FSDataInputStream;  
  15. import org.apache.hadoop.fs.FSDataOutputStream;  
  16. import org.apache.hadoop.fs.FileStatus;  
  17. import org.apache.hadoop.fs.FileSystem;  
  18. import org.apache.hadoop.fs.LocatedFileStatus;  
  19. import org.apache.hadoop.fs.Path;  
  20. import org.apache.hadoop.fs.RemoteIterator;  
  21. importorg.apache.hadoop.hdfs.DistributedFileSystem;  
  22. import org.apache.hadoop.hdfs.protocol.DatanodeInfo;  
  23.    
  24. public class SyncDFS {  
  25.           
  26.          private static final Log LOG = LogFactory.getLog(SyncDFS.class);  
  27.           
  28.          /** 
  29.           * Reads the directory name(s) and file name(s)from the specified parameter "srcPath" 
  30.           * @param srcPath 
  31.           */  
  32.          public void list(String srcPath) {  
  33.                     Configuration conf = new Configuration();  
  34.                     LOG.info("[Defaultfs] :" +conf.get("fs.default.name"));  
  35. //                conf.set("hadoop.job.ugi","app,app");   //It is not necessary for the default user.  
  36.                     FileSystem fs;  
  37.                    try {  
  38.                             fs= FileSystem.get(conf);  
  39.                             RemoteIterator<LocatedFileStatus>rmIterator = fs.listLocatedStatus(new Path(srcPath));  
  40.                             while (rmIterator.hasNext()) {  
  41.                                       Path path = rmIterator.next().getPath();  
  42.                                       if(fs.isDirectory(path)){  
  43.                                                 LOG.info("-----------DirectoryName: "+path.getName());  
  44.                                       }  
  45.                                       else if(fs.isFile(path)){  
  46.                                                 LOG.info("-----------FileName: "+path.getName());  
  47.                                       }  
  48.                             }  
  49.                    }catch (IOException e) {  
  50.                             LOG.error("list fileSysetm object stream.:" , e);  
  51.                             new RuntimeException(e);  
  52.                    }  
  53.          }  
  54.    
  55.          /** 
  56.           * Makes the specified directory if it doesn'texist. 
  57.           * @param dir 
  58.           */  
  59.          public void mkdir(String dir){  
  60.                    Configurationconf = new Configuration();  
  61.                    FileSystemfs = null;  
  62.                    try {  
  63.                             fs= FileSystem.get(conf);  
  64.                             Pathpath = new Path(dir);  
  65.                             if(!fs.exists(path)){  
  66.                                      fs.mkdirs(path);  
  67.                                      LOG.debug("create directory '"+dir+"' successfully!");  
  68.                             }else{  
  69.                                      LOG.debug("directory '"+dir+"' exits!");  
  70.                             }  
  71.                    }catch (IOException e) {  
  72.                             LOG.error("FileSystem get configuration with anerror");  
  73.                             e.printStackTrace();  
  74.                    }finally{  
  75.                             if(fs!= null){  
  76.                                      try {  
  77.                                                fs.close();  
  78.                                      }catch (IOException e) {  
  79.                                                LOG.error("close fs object stream. :" , e);  
  80.                                                new RuntimeException(e);  
  81.                                      }  
  82.                             }  
  83.                    }  
  84.          }  
  85.           
  86.          /** 
  87.           * Reads the file content in console. 
  88.           * @param file 
  89.           */  
  90.          public void readFile(String file){  
  91.                    Configurationconf = new Configuration();  
  92.                    FileSystemfs;  
  93.                    try {  
  94.                             fs= FileSystem.get(conf);  
  95.                             Pathpath = new Path(file);  
  96.                             if(!fs.exists(path)){  
  97.                                      LOG.warn("file'"+ file+"' doesn't exist!");  
  98.                                      return ;  
  99.                             }  
  100.                             FSDataInputStreamin = fs.open(path);  
  101.                             Stringfilename = file.substring(file.lastIndexOf('/') + 1, file.length());  
  102.                             OutputStreamout = new BufferedOutputStream(new FileOutputStream(  
  103.                                                                             new File(filename)));  
  104.    
  105.                             byte[] b = new byte[1024];  
  106.                             int numBytes = 0;  
  107.                             while ((numBytes = in.read(b)) > 0) {  
  108.                                      out.write(b,0, numBytes);  
  109.                             }  
  110.                             in.close();  
  111.                             out.close();  
  112.                             fs.close();  
  113.                    }catch (IOException e) {  
  114.                             LOG.error("ifExists fs Exception caught! :" , e);  
  115.                             new RuntimeException(e);  
  116.                    }  
  117.          }  
  118.           
  119.          public boolean ifExists(String source){  
  120.                    if(source == null || source.length() ==0){  
  121.                             return false;  
  122.                    }  
  123.                    Configurationconf = new Configuration();  
  124.                    FileSystemfs = null;  
  125.                    try {  
  126.                             fs= FileSystem.get(conf);  
  127.                             LOG.debug("judge file '"+source +  "'");  
  128.                             return fs.exists(new Path(source));  
  129.                    }catch (IOException e) {  
  130.                             LOG.error("ifExists fs Exception caught! :" , e);  
  131.                             new RuntimeException(e);  
  132.                             return false;  
  133.                    }finally{  
  134.                             if(fs != null){  
  135.                                      try {  
  136.                                                fs.close();  
  137.                                      }catch (IOException e) {  
  138.                                                LOG.error("fs.close Exception caught! :" , e);  
  139.                                                new RuntimeException(e);  
  140.                                      }  
  141.                             }  
  142.                              
  143.                    }  
  144.                     
  145.          }  
  146.           
  147.          /** 
  148.           * Recursively copies the source pathdirectories or files to the destination path of DFS. 
  149.           * It is the same functionality as thefollowing comand: 
  150.           *      hadoopfs -copyFromLocal <local fs><hadoop fs> 
  151.           * @param source 
  152.           * @param dest 
  153.           */  
  154.          public void copyFromLocal (String source, String dest) {  
  155.                       
  156.                    Configurationconf = new Configuration();  
  157.                    FileSystemfs;  
  158.                    try {  
  159.                             fs= FileSystem.get(conf);  
  160.                             PathsrcPath = new Path(source);  
  161.                                
  162.                             PathdstPath = new Path(dest);  
  163.                             // Check if the file alreadyexists  
  164.                             if (!(fs.exists(dstPath))) {  
  165.                                      LOG.warn("dstPathpath doesn't exist" );  
  166.                                      LOG.error("No such destination " + dstPath);  
  167.                                      return;  
  168.                             }  
  169.                                
  170.                             // Get the filename out of thefile path  
  171.                             Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  172.                                
  173.                             try{  
  174.                                      //if the file exists in thedestination path, it will throw exception.  
  175. //                                   fs.copyFromLocalFile(srcPath,dstPath);  
  176.                                      //remove and overwrite files withthe method  
  177.                                      //copyFromLocalFile(booleandelSrc, boolean overwrite, Path src, Path dst)  
  178.                                      fs.copyFromLocalFile(false, true, srcPath, dstPath);  
  179.                                      LOG.info("File " + filename + "copied to " + dest);  
  180.                             }catch(Exception e){  
  181.                                      LOG.error("copyFromLocalFile exception caught!:" , e);  
  182.                                      new RuntimeException(e);  
  183.                             }finally{  
  184.                                      fs.close();  
  185.                             }  
  186.                    }catch (IOException e1) {  
  187.                             LOG.error("copyFromLocal IOException objectstream. :" ,e1);  
  188.                             new RuntimeException(e1);  
  189.                    }  
  190.                    }  
  191.           
  192.           
  193.          public void renameFile (String fromthis, String tothis){  
  194.                    Configurationconf = new Configuration();  
  195.                       
  196.                    FileSystemfs;  
  197.                    try {  
  198.                             fs= FileSystem.get(conf);  
  199.                             PathfromPath = new Path(fromthis);  
  200.                             PathtoPath = new Path(tothis);  
  201.                                
  202.                             if (!(fs.exists(fromPath))) {  
  203.                                      LOG.info("No such destination " + fromPath);  
  204.                                 return;  
  205.                             }  
  206.                                
  207.                             if (fs.exists(toPath)) {  
  208.                                      LOG.info("Already exists! " + toPath);  
  209.                                 return;  
  210.                             }  
  211.                                
  212.                             try{  
  213.                                      boolean isRenamed = fs.rename(fromPath,toPath);     //renames file name indeed.  
  214.                                      if(isRenamed){  
  215.                                                LOG.info("Renamed from " + fromthis + " to " + tothis);  
  216.                                      }  
  217.                             }catch(Exception e){  
  218.                                      LOG.error("renameFile Exception caught! :" , e);  
  219.                                      new RuntimeException(e);  
  220.                             }finally{  
  221.                                      fs.close();  
  222.                             }  
  223.                    }catch (IOException e1) {  
  224.                             LOG.error("fs Exception caught! :" , e1);  
  225.                             new RuntimeException(e1);  
  226.                    }  
  227.          }  
  228.           
  229.          /** 
  230.           * Uploads or adds a file to HDFS 
  231.           * @param source 
  232.           * @param dest 
  233.           */  
  234.          public void addFile(String source, String dest)  {  
  235.                             // Conf object will readthe HDFS configuration parameters  
  236.                             Configurationconf = new Configuration();  
  237.                             FileSystemfs;  
  238.                             try {  
  239.                                      fs= FileSystem.get(conf);  
  240.                                      // Get the filename out of thefile path  
  241.                                      Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  242.                                       
  243.                                      // Create the destination pathincluding the filename.  
  244.                                      if (dest.charAt(dest.length() - 1) != '/') {  
  245.                                                dest= dest + "/" + filename;  
  246.                                      }else {  
  247.                                                dest= dest + filename;  
  248.                                      }  
  249.                                       
  250.                                      // Check if the file alreadyexists  
  251.                                      Pathpath = new Path(dest);  
  252.                                      if (fs.exists(path)) {  
  253.                                                LOG.error("File " + dest + " already exists");  
  254.                                                return;  
  255.                                      }  
  256.                                       
  257.                                      // Create a new file and writedata to it.  
  258.                                      FSDataOutputStreamout = fs.create(path);  
  259.                                      InputStreamin = new BufferedInputStream(new FileInputStream(  
  260.                                                                                                                                                      new File(source)));  
  261.                                       
  262.                                      byte[] b = new byte[1024];  
  263.                                      int numBytes = 0;  
  264.                                      //In this way read and write datato destination file.  
  265.                                      while ((numBytes = in.read(b)) > 0) {  
  266.                                                out.write(b,0, numBytes);  
  267.                                      }  
  268.                                      in.close();  
  269.                                      out.close();  
  270.                                      fs.close();  
  271.                             }catch (IOException e) {  
  272.                                      LOG.error("addFile Exception caught! :" , e);  
  273.                                      new RuntimeException(e);  
  274.                             }  
  275.          }  
  276.           
  277.          /** 
  278.           *Deletes the files if it is a directory. 
  279.           * @param file 
  280.           */  
  281.          public void deleteFile(String file)  {  
  282.                             Configurationconf = new Configuration();  
  283.                             FileSystemfs;  
  284.                             try {  
  285.                                      fs= FileSystem.get(conf);  
  286.           
  287.                                      Pathpath = new Path(file);  
  288.                                      if (!fs.exists(path)) {  
  289.                                                LOG.info("File " + file + " does not exists");  
  290.                                                return;  
  291.                                      }  
  292.                                      /* 
  293.                                       * recursively delete the file(s) if it is adirectory. 
  294.                                       * If you want to mark the path that will bedeleted as 
  295.                                       * a result of closing the FileSystem. 
  296.                                       *  deleteOnExit(Path f) 
  297.                                       */  
  298.                                      fs.delete(new Path(file), true);  
  299.                                      fs.close();  
  300.                             }catch (IOException e) {  
  301.                                      LOG.error("deleteFile Exception caught! :" , e);  
  302.                                      new RuntimeException(e);  
  303.                             }  
  304.    
  305.                    }  
  306.          /** 
  307.           * Gets the information about the file modifiedtime. 
  308.           * @param source 
  309.           * @throws IOException 
  310.           */  
  311.          public void getModificationTime(String source) throws IOException{  
  312.                       
  313.                    Configurationconf = new Configuration();  
  314.                       
  315.                    FileSystemfs = FileSystem.get(conf);  
  316.                    PathsrcPath = new Path(source);  
  317.                       
  318.                    // Check if the file alreadyexists  
  319.                    if (!(fs.exists(srcPath))) {  
  320.                    System.out.println("No such destination " + srcPath);  
  321.                    return;  
  322.                    }  
  323.                    // Get the filename out of thefile path  
  324.                    Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  325.                       
  326.                    FileStatusfileStatus = fs.getFileStatus(srcPath);  
  327.                    long modificationTime =fileStatus.getModificationTime();  
  328.                       
  329.                    LOG.info("modified datetime: " + System.out.format("File %s; Modification time : %0.2f%n",filename,modificationTime));  
  330.                       
  331.          }  
  332.           
  333.          /** 
  334.           * Gets the file block location info 
  335.           * @param source 
  336.           * @throws IOException 
  337.           */  
  338.          public void getBlockLocations(String source) throws IOException{  
  339.                    Configurationconf = new Configuration();  
  340.                    FileSystemfs = FileSystem.get(conf);  
  341.                    PathsrcPath = new Path(source);  
  342.                       
  343.                    // Check if the file alreadyexists  
  344.                    if (!(ifExists(source))) {  
  345.                             System.out.println("No such destination " + srcPath);  
  346.                             return;  
  347.                    }  
  348.                    // Get the filename out of thefile path  
  349.                    Stringfilename = source.substring(source.lastIndexOf('/') + 1, source.length());  
  350.                       
  351.                    FileStatusfileStatus = fs.getFileStatus(srcPath);  
  352.                       
  353.                    BlockLocation[]blkLocations = fs.getFileBlockLocations(fileStatus, 0, fileStatus.getLen());  
  354.                    int blkCount = blkLocations.length;  
  355.                       
  356.                    System.out.println("File :" + filename + "stored at:");  
  357.                    for (int i=0; i < blkCount; i++) {  
  358.                             String[]hosts = blkLocations[i].getHosts();  
  359.                             LOG.info("host ip:" +System.out.format("Host %d: %s %n", i, hosts));  
  360.                    }  
  361.          }  
  362.           
  363.          public void getHostnames () throws IOException{  
  364.                    Configurationconfig = new Configuration();  
  365.                     
  366.                    FileSystemfs = FileSystem.get(config);  
  367.                    DistributedFileSystemhdfs = (DistributedFileSystem) fs;  
  368.                    DatanodeInfo[]dataNodeStats = hdfs.getDataNodeStats();  
  369.                       
  370.                    String[]names = new String[dataNodeStats.length];  
  371.                    for (int i = 0; i < dataNodeStats.length; i++) {  
  372.                             names[i]= dataNodeStats[i].getHostName();  
  373.                             LOG.info("datenode hostname:"+(dataNodeStats[i].getHostName()));  
  374.                    }  
  375.          }  
  376.          /** 
  377.           * @param args 
  378.           */  
  379.          public static void main(String[] args) {  
  380.                    SyncDFSdfs = new SyncDFS();  
  381.                    dfs.list("/user/app");  
  382.                     
  383.                    dfs.mkdir("/user/app");  
  384.                     
  385. //                dfs.readFile("/user/app/README.txt");  
  386.                    LOG.info("--------------" +  
  387.                              dfs.ifExists("/user/warehouse/hbase.db/u_data/u.data")); //false  
  388.                    LOG.info("--------------" + dfs.ifExists("/user/app/README.txt")); //true  
  389.                     
  390.                    //copied the local file(s) to thedfs.  
  391. //                dfs.copyFromLocal("/opt/test","/user/app");  
  392.                     
  393.                    //delete the file(s) from the dfs  
  394. //                dfs.deleteFile("/user/app/test");  
  395.                    //rename diretory in dfs  
  396. //                dfs.renameFile("/user/app/test","/user/app/log");  
  397.                    //rename file in dfs  
  398. //                dfs.renameFile("/user/app/log/derby.log","/user/app/log/derby_info.log");  
  399.                     
  400.          }  
  401.    
  402.           
  403. } 

你可能感兴趣的:(HDFS CRUD 操作)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • 将cmd中命令输出保存为txt文本文件 落难Coder Windowscmdwindow
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • 【PG】常见数据库、表属性设置 江无羡 数据库
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • EIO国际确定性的交易（3/10）资管 ， 资金委托安全吗？ 古城鹏哥
    大家可能都知道资金托管，账户是自己开，钱在自己的账户上，密码是由自己掌控，别人提不走你账户的资金，每天可以看下到自己的账户，也可以看到交易流水。现金只能提到自己的银行卡中。账户由技术人员或操作人员，或者是机构团队帮你操作账户，产生盈利和收入，以获得的利润来分配盈利，技术强硬和做的时间久了过硬技术团队，会保证你的资金本金，不会让你的本金亏损的按照一定比例分配收入。所以在这个过程当中一定要看清楚技术的
  • Shell、Bash、Zsh这都是啥啊 小白码上飞 bashlinux开发语言
    Zsh和Bash都是我们常用的Shell，那先搞明白啥是shell吧。Shell作为一个单词，他是“壳”的意思，蛋壳坚果壳。之所以叫壳，是为了和计算机的“核”来区分，用它表示“为使用者提供的操作界面”。所以这个命名其实很形象，翻译成中文，直译过来叫“壳层”。个人认为这个叫法很奇怪，意译貌似也没有什么好的词汇来匹配。就还是叫shell吧。维基百科给的定义是：Incomputing,ashellisa
  • ios GCD _Waiting_
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • 【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linuxlinux运维服务器
    归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
  • linux 发展史 种树的猴子 内核java操作系统linux大数据
    linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
  • 2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python华为leetcode算法力扣广度优先无向图
    1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
  • 2024.9.14 Python，差分法解决区间加法，消除游戏，压缩字符串 RaidenQ python游戏开发语言算法力扣
    1.区间加法假设你有一个长度为n的数组，初始情况下所有的数字均为0，你将会被给出k个更新的操作。其中，每个操作会被表示为一个三元组：[startIndex,endIndex,inc]，你需要将子数组A[startIndex…endIndex]（包括startIndex和endIndex）增加inc。请你返回k次操作后的数组。示例:输入:length=5,updates=[[1,3,2],[2,4,
  • 4.C_数据结构_队列 荣世蓥 数据结构数据结构
    概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
  • MongoDB知识概括 GeorgeLin98 持久层mongodb
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
  • 异常的核心类Throwable 无量 java源码异常处理exception
    java异常的核心是Throwable，其他的如Error和Exception都是继承的这个类 里面有个核心参数是detailMessage，记录异常信息，getMessage核心方法，获取这个参数的值，我们可以自己定义自己的异常类，去继承这个Exception就可以了，方法基本上，用父类的构造方法就OK，所以这么看异常是不是很easy package com.natsu;
  • mongoDB 游标（cursor） 实现分页 迭代 开窍的石头 mongodb
    上篇中我们讲了mongoDB 中的查询函数，现在我们讲mongo中如何做分页查询      如何声明一个游标        var mycursor = db.user.find({_id:{$lte:5}});       迭代显示游标数
  • MySQL数据库INNODB 表损坏修复处理过程 0624chenhong tomcatmysql
    最近mysql数据库经常死掉，用命令net stop mysql命令也无法停掉，关闭Tomcat的时候，出现Waiting for N instance(s) to be deallocated 信息。查了下，大概就是程序没有对数据库连接释放，导致Connection泄露了。因为用的是开元集成的平台，内部程序也不可能一下子给改掉的，就验证一下咯。启动Tomcat,用户登录系统，用netstat -
  • 剖析如何与设计人员沟通 不懂事的小屁孩 工作
    最近做图烦死了，不停的改图，改图……。烦，倒不是因为改，而是反反复复的改，人都会死。很多需求人员不知该如何与设计人员沟通，不明白如何使设计人员知道他所要的效果，结果只能是沟通变成了扯淡，改图变成了应付。 那应该如何与设计人员沟通呢？ 我认为设计人员与需求人员先天就存在语言障碍。对一个合格的设计人员来说，整天玩的都是点、线、面、配色，哪种构图看起来协调；哪种配色看起来合理心里跟明镜似的，
  • qq空间刷评论工具 换个号韩国红果果 JavaScript
    var a=document.getElementsByClassName('textinput'); var b=[]; for(var m=0;m<a.length;m++){ if(a[m].getAttribute('placeholder')!=null) b.push(a[m]) } var l
  • S2SH整合之session 灵静志远 springAOPstrutssession
    错误信息： Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'cartService': Scope 'session' is not active for the current thread; consider defining a scoped
  • xmp标签 a-john 标签
    今天在处理数据的显示上遇到一个问题： var html = '<li><div class="pl-nr"><span class="user-name">' + user + '</span>' + text + '</div></li>'; ulComme
  • Ajax的常用技巧（2）---实现Web页面中的级联菜单 aijuans Ajax
    在网络上显示数据，往往只显示数据中的一部分信息，如文章标题，产品名称等。如果浏览器要查看所有信息，只需点击相关链接即可。在web技术中，可以采用级联菜单完成上述操作。根据用户的选择，动态展开，并显示出对应选项子菜单的内容。 在传统的web实现方式中，一般是在页面初始化时动态获取到服务端数据库中对应的所有子菜单中的信息，放置到页面中对应的位置，然后再结合CSS层叠样式表动态控制对应子菜单的显示或者隐
  • 天-安-门，好高 atongyeye 情感
        我是85后，北漂一族，之前房租1100，因为租房合同到期，再续，房租就要涨150。最近网上新闻，地铁也要涨价。算了一下，涨价之后，每次坐地铁由原来2块变成6块。仅坐地铁费用，一个月就要涨200。内心苦痛。     晚上躺在床上一个人想了很久，很久。        我生在农
  • android 动画 百合不是茶 android透明度平移缩放旋转
    android的动画有两种  tween动画和Frame动画   tween动画;,透明度,缩放,旋转,平移效果   Animation   动画 AlphaAnimation 渐变透明度 RotateAnimation 画面旋转 ScaleAnimation 渐变尺寸缩放 TranslateAnimation 位置移动 Animation
  • 查看本机网络信息的cmd脚本 bijian1013 cmd
    @echo 您的用户名是：%USERDOMAIN%\%username%>"%userprofile%\网络参数.txt" @echo 您的机器名是：%COMPUTERNAME%>>"%userprofile%\网络参数.txt" @echo ___________________>>"%userprofile%\
  • plsql 清除登录过的用户 征客丶 plsql
    tools---preferences----logon history---history  把你想要删除的删除 -------------------------------------------------------------------- 若有其他凝问或文中有错误，请及时向我指出， 我好及时改正，同时也让我们一起进步。 email ： binary_spac
  • 【Pig一】Pig入门 bit1129 pig
    Pig安装 1.下载pig   wget http://mirror.bit.edu.cn/apache/pig/pig-0.14.0/pig-0.14.0.tar.gz   2. 解压配置环境变量      如果Pig使用Map/Reduce模式，那么需要在环境变量中，配置HADOOP_HOME环境变量   expor
  • Java 线程同步几种方式 BlueSkator volatilesynchronizedThredLocalReenTranLockConcurrent
    为何要使用同步？      java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），      将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，      从而保证了该变量的唯一性和准确性。 1.同步方法&
  • StringUtils判断字符串是否为空的方法（转帖） BreakingBad nullStringUtils“”
    转帖地址：http://www.cnblogs.com/shangxiaofei/p/4313111.html   public static boolean isEmpty(String str)   　　判断某字符串是否为空，为空的标准是 str== null  或 str.length()== 0  
  • 编程之美-分层遍历二叉树 bylijinnan java数据结构算法编程之美
    import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class LevelTraverseBinaryTree { /** * 编程之美 分层遍历二叉树 * 之前已经用队列实现过二叉树的层次遍历，但这次要求输出换行，因此要
  • jquery取值和ajax提交复习记录 chengxuyuancsdn jquery取值ajax提交
    // 取值 // alert($("input[name='username']").val()); // alert($("input[name='password']").val()); // alert($("input[name='sex']:checked").val()); // alert($("
  • 推荐国产工作流引擎嵌入式公式语法解析器-IK Expression comsci java应用服务器工作Excel嵌入式
    这个开源软件包是国内的一位高手自行研制开发的，正如他所说的一样，我觉得它可以使一个工作流引擎上一个台阶。。。。。。欢迎大家使用，并提出意见和建议。。。 ----------转帖--------------------------------------------------- IK Expression是一个开源的（OpenSource），可扩展的（Extensible），基于java语言
  • 关于系统中使用多个PropertyPlaceholderConfigurer的配置及PropertyOverrideConfigurer daizj spring
    1、PropertyPlaceholderConfigurer Spring中PropertyPlaceholderConfigurer这个类，它是用来解析Java Properties属性文件值，并提供在spring配置期间替换使用属性值。接下来让我们逐渐的深入其配置。 基本的使用方法是：(1) <bean id="propertyConfigurerForWZ&q
  • 二叉树:二叉搜索树 dieslrae 二叉树
        所谓二叉树,就是一个节点最多只能有两个子节点,而二叉搜索树就是一个经典并简单的二叉树.规则是一个节点的左子节点一定比自己小,右子节点一定大于等于自己(当然也可以反过来).在树基本平衡的时候插入,搜索和删除速度都很快,时间复杂度为O(logN).但是,如果插入的是有序的数据,那效率就会变成O(N),在这个时候,树其实变成了一个链表. tree代码:
  • C语言字符串函数大全 dcj3sjt126com cfunction
    C语言字符串函数大全     函数名: stpcpy 功 能: 拷贝一个字符串到另一个 用 法: char *stpcpy(char *destin, char *source); 程序例:   #include <stdio.h> #include <string.h>   int main
  • 友盟统计页面技巧 dcj3sjt126com 技巧
    在基类调用就可以了, 基类ViewController示例代码 -(void)viewWillAppear:(BOOL)animated { [super viewWillAppear:animated]; [MobClick beginLogPageView:[NSString stringWithFormat:@"%@",self.class]];
  • window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 flyvszhb javajdk
    window下在同一台机器上安装多个版本jdk，修改环境变量不生效问题处理办法 本机已经安装了jdk1.7，而比较早期的项目需要依赖jdk1.6，于是同时在本机安装了jdk1.6和jdk1.7. 安装jdk1.6前，执行java -version得到 C:\Users\liuxiang2>java -version java version "1.7.0_21&quo
  • Java在创建子类对象的同时会不会创建父类对象 happyqing java创建子类对象父类对象
      1.在thingking in java 的第四版第六章中明确的说了，子类对象中封装了父类对象，   2."When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the sam
  • 跟我学spring3 目录贴及电子书下载 jinnianshilongnian spring
        一、《跟我学spring3》电子书下载地址： 《跟我学spring3》  （1-7 和 8-13） http://jinnianshilongnian.iteye.com/blog/pdf     跟我学spring3系列 word原版 下载     二、 源代码下载 最新依
  • 第12章 Ajax（上） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • BI and EIM 4.0 at a glance blueoxygen BO
    http://www.sap.com/corporate-en/press.epx?PressID=14787   有机会研究下EIM家族的两个新产品~~~~   New features of the 4.0 releases of BI and EIM solutions include: Real-time in-memory computing –
  • Java线程中yield与join方法的区别 tomcat_oracle java
    长期以来，多线程问题颇为受到面试官的青睐。虽然我个人认为我们当中很少有人能真正获得机会开发复杂的多线程应用(在过去的七年中，我得到了一个机会)，但是理解多线程对增加你的信心很有用。之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 &nb
  • android Manifest.xml选项 阿尔萨斯 Manifest
    结构 继承关系 public final class Manifest extends Objectjava.lang.Objectandroid.Manifest 内部类 class Manifest.permission权限 class Manifest.permission_group权限组 构造函数 public Manifest () 详细 androi
  • Oracle实现类split函数的方 zhaoshijie oracle
    关键字：Oracle实现类split函数的方 项目里需要保存结构数据，批量传到后他进行保存，为了减小数据量，子集拼装的格式，使用存储过程进行保存。保存的过程中需要对数据解析。但是oracle没有Java中split类似的函数。从网上找了一个，也补全了一下。 CREATE OR REPLACE TYPE t_split_100 IS TABLE OF VARCHAR2(100); cr
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他