yuhaibo736

有时候在客户端使用svg画图，而在服务器端需要同样的图片，在服务器端重新画一遍是非常费事的。这时候我们就可以利用已有的svg直接通过下面的类转换成png格式。

使用这个方法需要引用batic相关的包，maven pom文件如下：

方法1: 设定环境变量
set NLS_SORT=SCHINESE_RADICAL_M ;export NLS_SORT （sh）
or setenv NLS_SORT SCHINESE_RADICAL_M (csh)
or regedit 
HKLC/SOFTWARE/ORACLE/home0/NLS_SORT        (win)

方法2: 在session中修改
alter session set NLS_SORT='SCHINESE_RADICAL_M'

方法3: 直接使用NLSSORT函数 (推荐)
select name,id from t
order by NLSSORT(name,'NLS_SORT = SCHINESE_STROKE_M')

设置NLS_SORT值:

SCHINESE_RADICAL_M 按照部首（第一顺序）、笔划（第二顺序）排序 

SCHINESE_STROKE_M 按照笔划（第一顺序）、部首（第二顺序）排序 

SCHINESE_PINYIN_M 按照拼音排序

    在mybatis中，开发组织只提供了一些默认的二级缓存实现的机制，并没有直接内置的支持OSCache和EHCache等二级缓存机制，而是作为一个集成jar包来提供二级缓存的实现，在官方网站上我们可以找到mybatis-ehcache-1.0.1-bundle.zip，mybatis-oscache-1.0.1-bundle.zip等ehcache和oscache提供二级缓存的独立工具包. 这里我就拿oscache在mybatis中的使用来举例说明：

       1.   将mybatis-oscache-1.0.1-bundle.zip中涉及到的jar包放入到classpath路径下 
             maven下可以这样配置
               <dependencies>  
                    ... 

                    <dependency> 

                        <groupId>org.mybatis.caches</groupId> 

                        <artifactId>mybatis-oscache</artifactId>      
                         <version>1.0.2-SNAPSHOT</version> 

                    </dependency>             

                    <dependency>
                        <groupId>javax.jms</groupId>
                        <artifactId>jms</artifactId>
                        <version>1.1</version>
                    </dependency>

                    <dependency>
                         <groupId>opensymphony</groupId>
                         <artifactId>oscache</artifactId>
                         <version>2.4</version>
                         <exclusions>       
                               <exclusion>
                                   <groupId>com.sun.jdmk</groupId>
                                   <artifactId>jmxtools</artifactId>
                               </exclusion>
                           <exclusion>
                           <groupId>com.sun.jmx</groupId>
                           <artifactId>jmxri</artifactId>
                       </exclusion>
                     </exclusions>
                </dependency>

                    ... 

                </dependencies>

       2.   在mapper文件中的配置如下：

             <mapper namespace="org.test.AuthMapper" >         

                 <cache  type="org.mybatis.caches.oscache.OSCache"/>

             </mapper>
            注意下面两点
             (a)在<select id="getAuth" parameterType="Map" resultType="Auth"  useCache="false">中使用useCache="false"或useCache="true"来决定是否使用二级缓存。    
             (b)在增删改中<insert id="insertAuth" parameterType="Auth"  flushCache="true">使用flushCache="true"或flushCache="flase"来决定对这些进行操作后清空该xml文件中所有查询语句的二级缓存。 

       3.  在src目录下创建一个oscache.properties的属性文件，在里面指定缓存的各种属性的设置：
             cache.memory=true             
             cache.path=c:\\myapp\\cache
             cache.persistence.class=com.opensymphony.oscache.plugins.diskpersistence.DiskPersistenceListener
             cache.persistence.overflow.only=true
             cache.capacity=100000

            

import java.awt.Color;
import java.io.FileOutputStream;

import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Document;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.pdf.BaseFont;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfWriter;

public class CellEvents {

 /**
  * @param args
  */
 public static void main(String[] args) {
  Object[] objArr = new Object[]{100,20,300};
  
  Document document = new Document(PageSize.A4.rotate(),50,50,50,50);
  try{
   //bfSongti = BaseFont.createFont("/simsun.ttc,1", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
   Font songtiSFivefont = new Font(BaseFont.createFont("/simsun.ttc,1", BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED), 9f);//宋体小五号字
         //设置存放位置
         PdfWriter.getInstance(document, new FileOutputStream("D:/test.pdf"));
         document.open();
 
         PdfPTable table = new PdfPTable(5);
   table.setSpacingBefore(10f);
   table.getDefaultCell().setPadding(5);
   //HowbuyBorderPdfPTableEvent event = new HowbuyBorderPdfPTableEvent();
   //table.setTableEvent(event);
   //table.getDefaultCell().setBorder(Rectangle.NO_BORDER);
   table.getDefaultCell().setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.getDefaultCell().setHorizontalAlignment(Element.ALIGN_CENTER);
   PdfPCell cellTitle = new PdfPCell(new Phrase("总资产\n（万元）",songtiSFivefont));
   cellTitle.setBorderWidth(2f);
   cellTitle.setBackgroundColor(new BaseColor(new Color(153, 51, 0)));
   cellTitle.setBorderColor(new BaseColor(new Color(153, 51, 0)));
   cellTitle.setHorizontalAlignment(Element.ALIGN_CENTER);
   cellTitle.setVerticalAlignment(Element.ALIGN_MIDDLE);
   cellTitle.setMinimumHeight(25);
   table.addCell(cellTitle);
 
   cellTitle = new PdfPCell(new Phrase(""));
   cellTitle.setBorder(Rectangle.NO_BORDER);
   cellTitle.setHorizontalAlignment(Element.ALIGN_CENTER);
   cellTitle.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cellTitle);
   
   cellTitle = new PdfPCell(new Phrase("当前收益\n（万元）",songtiSFivefont));
   cellTitle.setBorderWidth(2f);
   cellTitle.setBackgroundColor(new BaseColor(new Color(153, 51, 0)));
   cellTitle.setBorderColor(new BaseColor(new Color(153, 51, 0)));
   cellTitle.setHorizontalAlignment(Element.ALIGN_CENTER);
   cellTitle.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cellTitle);
 
   cellTitle = new PdfPCell(new Phrase("",songtiSFivefont));
   cellTitle.setBorder(Rectangle.NO_BORDER);
   cellTitle.setHorizontalAlignment(Element.ALIGN_CENTER);
   cellTitle.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cellTitle);
   
   
   cellTitle = new PdfPCell(new Phrase("累计收益\n（万元）",songtiSFivefont));
   cellTitle.setBorderWidth(2f);
   cellTitle.setBackgroundColor(new BaseColor(new Color(153, 51, 0)));
   cellTitle.setBorderColor(new BaseColor(new Color(153, 51, 0)));
   cellTitle.setHorizontalAlignment(Element.ALIGN_CENTER);
   cellTitle.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cellTitle);
   
   float[] widths2 = { 24.5f, 12.25f,24.5f,12.25f,24.5f};

   table.setWidths(widths2);
   
   table.setHorizontalAlignment(Element.ALIGN_LEFT);//
   table.setWidthPercentage(70);
   double zzc = objArr[0]==null ? 0:Double.parseDouble(objArr[0].toString());
   double dqsy = objArr[1]==null ? 0:Double.parseDouble(objArr[1].toString());
   double ljsy = objArr[2]==null ? 0:Double.parseDouble(objArr[2].toString());
   PdfPCell cell1 = new PdfPCell(new Phrase(String.valueOf(zzc),songtiSFivefont));
   cell1.setBorderWidth(2f);
   cell1.setBorderColor(new BaseColor(new Color(153, 51, 0)));
   cell1.setHorizontalAlignment(Element.ALIGN_CENTER);
   cell1.setVerticalAlignment(Element.ALIGN_MIDDLE);
   cell1.setMinimumHeight(20);
   table.addCell(cell1);
   
   cell1 = new PdfPCell(new Phrase("",songtiSFivefont));
   cell1.setBorder(Rectangle.NO_BORDER);
   cell1.setHorizontalAlignment(Element.ALIGN_CENTER);
   cell1.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cell1);
   
   cell1 = new PdfPCell(new Phrase(String.valueOf(dqsy),songtiSFivefont));
   cell1.setBorderWidth(2f);
   cell1.setBorderColor(new BaseColor(new Color(153, 51, 0)));
   cell1.setHorizontalAlignment(Element.ALIGN_CENTER);
   cell1.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cell1);
   
   cell1 = new PdfPCell(new Phrase("",songtiSFivefont));
   cell1.setBorder(Rectangle.NO_BORDER);
   cell1.setHorizontalAlignment(Element.ALIGN_CENTER);
   cell1.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cell1);
   
   cell1 = new PdfPCell(new Phrase(String.valueOf(ljsy),songtiSFivefont));
   cell1.setBorderWidth(2f);
   cell1.setBorderColor(new BaseColor(new Color(153, 51, 0)));
   cell1.setHorizontalAlignment(Element.ALIGN_CENTER);
   cell1.setVerticalAlignment(Element.ALIGN_MIDDLE);
   table.addCell(cell1);
   document.add(table);
  }catch(Exception ex){
   ex.printStackTrace();
  }
        document.close();

 }

}

说到反向代理，可能很多人都听说，但具体什么是反向代理，很多人估计就不清楚了。摘一段百度百科上的描述：

Html代码

1. 反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。 

反向代理（Reverse Proxy）方式是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。

这里讲得很直白。反向代理方式实际上就是一台负责转发的代理服务器，貌似充当了真正服务器的功能，但实际上并不是，代理服务器只是充当了转发的作用，并且从真正的服务器那里取得返回的数据。这样说，其实nginx完成的就是这样的工作。我们让nginx监听一个端口，譬如80端口，但实际上我们转发给在8080端口的tomcat，由它来处理真正的请求，当请求完成后，tomcat返回，但数据此时没直接返回，而是直接给nginx，由nginx进行返回，这里，我们会以为是nginx进行了处理，但实际上进行处理的是tomcat。

说到上面的方式，也许很多人又会想起来，这样可以把静态文件交由nginx来进行处理。对，很多用到nginx的地方都是作为静态伺服器，这样可以方便缓存那些静态文件，比如CSS，JS，html，htm等文件。

闲话就不多说了，我们直接来看看nginx怎么使用。

1）要用到的软件当然要下载啦。到nginx官网下一个。http://nginx.org/en/download.html可以到这里去下。我现在用的版本是1.1.7，但基本上以后的版本都兼容，而且我们用到的并不涉及到太底层的，应该不会有什么变化。

这里，由于我的是windows，当然下windows版啦。下完后首先要启动吧。进入到nginx文件夹，直接start nginx就OK了。

比如我下载后放在D:\software\developerTools\server\nginx-1.1.7，直接cmd后cd D:\software\developerTools\server\nginx-1.1.7，有些不习惯命令行的可能会奇怪，它没有进行到那个文件夹。windows并不会在分区间跳转，除非你自己指定了。所以我们要直接d:如下：

然后，我们直接start nginx，这里也许你会看到一个窗口一闪而过，根据我们使用tomcat的经验，如果一闪而过，证明有错误了，是吧？但实际上不是。

此时我们打开任务管理器，可以看到两个nginx.exe在那里好好的。这说明我们已经启动了，至于为什么两个，我们这里不深究。

现在，我们已经启动了nginx，这时就可以启动tomcat，想着直接访问http://localhost就可以直接访问tomcat了。

先不急，我们来看看启动后的nginx是怎样的。直接访问http://localhost可以看到：

    我们可以看到nginx启动成功，现在访问是直接进到nginx的目录里面了。

那么这些实际上是在哪里配置的。这就涉及到nginx的一个重要配置文件nginx.conf了。

2）我们可以看到nginx文件夹内有一个conf文件夹，其中有好几个文件，其他先不管，我们打开nginx.conf，可以看到一段：

这段代码在server里面，相当于一个代理服务器，当然可以配置多个。

下面我们仔细来分析一下：

listen：表示当前的代理服务器监听的端口，默认的是监听80端口。注意，如果我们配置了多个server，这个listen要配置不一样，不然就不能确定转到哪里去了。

server_name：表示监听到之后需要转到哪里去，这时我们直接转到本地，这时是直接到nginx文件夹内。

location：表示匹配的路径，这时配置了/表示所有请求都被匹配到这里

root：里面配置了root这时表示当匹配这个请求的路径时，将会在这个文件夹内寻找相应的文件，这里对我们之后的静态文件伺服很有用。

index：当没有指定主页时，默认会选择这个指定的文件，它可以有多个，并按顺序来加载，如果第一个不存在，则找第二个，依此类推。

下面的error_page是代表错误的页面，这里我们暂时不用，先不管它。

那我们知道了具体的配置了，怎么让它访问localhost时转到tomcat时。实际上就修改两个地方：

Java代码

1. server_name localhost:8080; 
2.  
3. location / { 
4.     proxy_pass http://localhost:8080 
5. } 

server_name localhost:8080;

location / {
    proxy_pass http://localhost:8080
}

我们就修改了上面两个地方，我的tomcat在8080端口，可以根据自己的需要修改。这里有一个新元素proxy_pass，它表示代理路径，相当于转发，而不像之前说的root必须指定一个文件夹。

此时我们修改了文件，是不是就意思着必须先关了nginx再重新启动了，其实不必，nginx可以重新加载文件的。

我们直接运行：

Html代码

1. nginx -s reload 

nginx -s reload

高兴得太早了，我们发现有一个错误：

什么来的，45行发现错误，不希望在那一行找到}，于是我们仔细找，发现我们加入的proxy_pass很奇怪，没有;号结尾，这就是问题了，直接修改，然后再运行一下，发现没错误，OK了。

如果不想直接加载，而只是想看看自己的配置文件有没有问题，可以直接输入:

Xml代码

1. nginx -t 

nginx -t

这可以检查配置文件中是否有错。 下面我们所有的修改都假设我们修改完成后运行了nginx -s reload进行重新加载配置文件，请注意。

一切没问题了，然后我们再重新打开http://localhost，我们看到下面的页面：

这时，我们发现它并不是刚才的welcome页面了，而是tomcat的管理页面了，不管我们点击什么链接都是没问题的，相当于直接访问http://localhost:8080一样。

3）上面我们直接试了一个小例子，让nginx进行转发，即所谓的反向代理。但实际上我们的需求不会是这样的，我们需要分文件类型来进行过滤，比如jsp直接给tomcat处理，因为nginx并不是servlet容器，没办法处理JSP，而html,js,css这些不需要处理的，直接给nginx进行缓存。

下面我们来进行一下配置，让JSP页面直接给tomcat，而html,png等一些图片和JS等直接给nginx进行缓存。

这时最主要用的还是location这个元素，并且涉及到一部分正则，但不难：

Xml代码

1. location ~ \.jsp$ { 
2.         proxy_pass http://localhost:8080; 
3. } 
4.          
5. location ~ \.(html|js|css|png|gif)$ { 
6.     root D:/software/developerTools/server/apache-tomcat-7.0.8/webapps/ROOT; 
7. } 

location ~ \.jsp$ {
        proxy_pass http://localhost:8080;
}
		
location ~ \.(html|js|css|png|gif)$ {
	root D:/software/developerTools/server/apache-tomcat-7.0.8/webapps/ROOT;
}

我们先要去掉之前配的location /，避免全部请求被拦截了。

然后我们再来看看http://localhost

当我们不指定jsp页面的时候，它会出现找不到，因为，此时并没有相应的location匹配，所以就会有404错误，这时就跳到了nginx自定义的error页面去了。

而当我们用http://localhost/index.jsp去访问时，我们看到了熟悉的页面：

而且图片那些都显示正常，因为图片是png的，所以直接在tomcat/webapps/ROOT目录下直接查找，当然，如果我们点击Manager Application HOW-TO这个链接，我们发现：

它还是找不到，为什么呢？因为这是个html页面，但它并不在ROOT目录下，而是在docs目录下，但当我们匹配html时，我们却到ROOT目录下去找，所以还是找不到这个页面。

一般情况下，如果我们需要用nginx来进行静态文件伺服，一般都会把所有静态文件，html,htm,js,css等都放在同一个文件夹下，这样就不会有tomcat这样的情况了，因为tomcat下的是属于不同的项目，这个我们就没办法了。

3）有些人会说，这些都只会找一台服务器，但如果我们想在一台服务器挂了的时候，自动去找另外一台，这怎么办？这实际上nginx都考虑到了。

这时，我们之前用的proxy_pass就有大用途了。

我们把之前的第一个例子，即全部都代理的修改一下：

最后修改如下：

Xml代码

1. upstream local_tomcat { 
2.     server localhost:8080; 
3. } 
4.  
5. server{ 
6.         location / { 
7.            proxy_pass http://local_tomcat; 
8.         } 
9.         #......其他省略 
10. } 

upstream local_tomcat {
	server localhost:8080;
}

server{
        location / {
           proxy_pass http://local_tomcat;
        }
        #......其他省略
}

我们在server外添加了一个upstream，而直接在proxy_pass里面直接用http://+upstream的名称来使用。

我们还是直接来http://localhost，还是和第一个一样的效果，所有链接都没问题，说明我们配置正确。

upstream中的server元素必须要注意，不能加http://，但proxy_pass中必须加。

我们刚才说可以在一个服务器挂了的情况下连到另外一个，那怎么弄呢？

其实很简单，在upstream中的local_tomcat中配置多一个server。比如我现在弄多一个jetty，端口在9999，所以我们配置如下：

Xml代码

1. upstream local_tomcat { 
2.     server localhost:8080; 
3.     server localhost:9999; 
4. } 

upstream local_tomcat {
	server localhost:8080;
	server localhost:9999;
}

此时，我们关闭tomcat，而只开jetty。我们来运行http://localhost看看效果：

我们看到它请求到了jetty的页面，但由于jetty的机制，这时没有显示jetty主页，这个我们先不管。但我们的在一个服务器挂的情况下自动使用另外一个的功能实现了。

但有时我们就不想它挂的时候访问另外一个，而只是希望一个服务器访问的机会比另外一个大，这个可以在server最后加上一个weight=数字来指定，数字越大，表明请求到的机会越大。

Xml代码

1. upstream local_tomcat { 
2.     server localhost:8080 weight=1; 
3.     server localhost:9999 weight=5; 
4. } 

upstream local_tomcat {
	server localhost:8080 weight=1;
	server localhost:9999 weight=5;
}

这时我们给了jetty一个更高的权值，让它更有机会访问到，实际上当我们刷新http://localhost访问的时候发现jetty访问机率大很多，tomcat几乎没机会访问，一般情况下，如果我们必须这样用，不要相关太大，以免一个服务器负载太大。

当然,server还有一些其他的元素，比如down表示暂时不用到该服务器等等。这些可以参考nginx的wiki。也许写了一大堆，有人会有问题，那nginx怎么关闭呢？这倒是个问题，其实直接运行nginx -s stop就可以关闭了。

基本上nginx的用法是这样，深入的以后我们如果用到再学习。

第一步：

   1）下载jad.exe文件：http://www.varaneckas.com/jad

   2）下载jadeclipse插件：http://sourceforge.net/projects/jadclipse/files/

第二步：
    1）解压缩jad158g.win.zip成jad.exe，把它copy至jre的bin目录下，比如我的jre安装到了c盘下，copy的路径即为c:\Program Files\Java\jre6\bin（下一步配置等待net.sf.jadclipse_3.3.0.jar配置完成之后再说）
    2）找到myeclipse的安装目录，我的myeclipse安装在c盘下，路径如下：c:\ Program Files\yEclipse10。该目录下有dropins文件，我们需要在该文件夹下，新建jad文件夹，jad文件夹下新建 features 和 plugins 两个文件夹，把net.sf.jadclipse_3.3.0.jar 复制到两个文件夹下，然后重启myeclipse。

第三步：
    1）在eclipse窗口下，点击Window > Preferences > Java > JadClipse > Path to Decompiler。（设置jad的绝对路径，如 c:\Program Files\Java\jre6\bin\jad.exe  )。Use Eclipse code formatter(overrides Jad formatting instructions)选项打勾，与格式化出来的代码样式一致。

    2）在eclipse窗口下，点击Window > Preferences > Java > JadClipse > Misc，将Convert Unicode strings into ANSI strings选项打勾，避免反编译后可能出现的中文乱码。
第四步：
    安装完成后，myeclipse没有自动将JadClipse Class File Viewer设置成class文件的缺省打开方式，设置方法如

一、vi的基本概念

基本上vi可分为三种操作状态，分别是命令模式（Command mode）、插入模式（Insert mode）和底线命令模式（Last line mode），

各模式的功能区分如下：

1． Comand mode：控制屏幕光标的移动，字符或光标的删除，移动复制某区段及进入Insert mode下，或者到Last line mode。

2． Insert mode：唯有在Insert mode下，才可做文字数据输入，按Esc等可回到Comand mode。

3． Last line mode：将储存文件或离开编辑器，也可设置编辑环境，如寻找字符串、列出行号等。

不过可以把vi简化成两个模式，即是将Last line mode也算入Command mode,把vi分成Command
和Insert mode。

二、vi的基本操作

1．进入vi

在系统提示符号输入vi及文件名称后，即可进入vi全屏幕编辑画面：

$
vi testfile

注意：进入vi之后是处于“Command mode”下，要切换到Insert mode才能输入文字。

初次用vi的用户都会想先用上下左右键移动光标，结果电脑一直叫，把自己气个半死，所以进入vi后，先不要乱动，转换入Insert后再说。

（1）切换至Insert mode编辑文件在Command mode下按‘i’、‘a’或‘o’三键就可进入Insert mode。这时候就可以开始输入文字了。

i: 插入，从目前光标所在之处插入所输入的文字。

a: 增加，目前光标所在的下一个字开始输入文字。

o: 插入新的一行，从行首开始输入文字。

（2）Insert的切换→Command
mode，按Esc键

您目前处于Insert mode，您就只能一直打字。假如您发现打错字了，想用光标键往回移动，将该字删除，就要按ESC键转换回Command mode，再删除文字。

（3）离开vi及存文件

在Command mode下，可按冒号“：”键入入Last line mode，例如：

:w
filename (输入“w filename”，将文章存入指定的文件名filename)

:wq
(输入“wq”，因为进入之时已经指定文件名testfile，所以会写入testfile并离开vi)

:q!
(输入“q!”，强制离开并放弃编辑的文件)

2.Command
mode功能键列表

在介绍command mode指令的时后，指令后面加上“常用”字眼的功能键，表示比较常用的vi指令，

请读者您一定要学会、记住。

（1）I、a、o切换进入Insert mode。[超级常用]

（2）移动光标

vi可以直接用键盘上的光标键来上下左右移动，但正规的vi是用小写英文字母

h、j、k、l，分别控制光标左、下、上、右移一格。

按Ctrl+B：屏幕往后移动一页。[常用]

按Ctrl+F：屏幕往前移动一页。[常用]

按Ctrl+U：屏幕往后移动半页。

按Ctrl+D：屏幕往前移动半页。

按 0 （数字零）：移动文章的开头。[常用]

按 G：移动到文章的最后。[常用]

按 w：光标跳到下个word的开头。[常用]

按 e：光标跳到下个word的字尾。

按 b：光标回到上个word的开头。

按 $：移到光标所在行的行尾。[常用]

按 ^：移到该行第一个非空白的字符。

按 0：移到该行的开头位置。[常用]

按 #：移到该行的第#个位置，例：51、121。[常用]

（3）删除文字

x：每按一次删除光标所在位置的后面一个字符。[超常用]

#x：例如，6x 表删除光标所在位置的后面6个字符。[常用]

X：大字的X，每按一次删除光标所在位置的前面一个字符。

#X：例如，20X 表删除光标所在位置的前面20个字符。

dd：删除光标所在行。[超常用]

#dd：例如，6dd表删除从光标所在的该行往下数6行之文字。[常用]

（4）复制

yw：将光标所在处到字尾的字符复制到缓冲区中。

（想在和#x、#X的功能相反）

p：将缓冲区内的字符粘贴到光标所在位置（指令‘yw’与‘p必须搭配使用）。

yy：复制光标所在行。[超常用]

p：复制单行到您想粘贴之处。（指令‘yy’与‘p’必须搭配使用）

#yy：如：6yy表示拷贝从光标所在的该行往下数6行之文字。[常用]

p:复制多行到您想粘贴之处。（指令‘#yy’与‘p’必须搭配使用）

“ayy：将复制行放入buffer a, vi提供buffer功能，可将常用的数据存在buffer

“ap：将放在buffer a的数据粘贴。

“b3yy：将三行数据存入buffer b。

“b3p：将存在buffer b的资料粘贴

（5）取代

r: 取代光标所在处的字符：[常用]

R：取代字符直到按Esc为止。

（6）复原（undo）上一个指令

u：假如您误操作一个指令，可以马上按u，回复到上一个操作。[超常用]

.:
.可以重复执行上一次的指令。

（7）更改

cw：更改光标所在处的字到字尾$处。

c#w：例如，c3w代表更改3个字。

（8）跳至指定行

Ctrl+G：列出光标所在行的行号。

#G：例如，15G，表示移动光标至文章的第15行行首。[常用]

3.Last
line mode下指令简介

读者您要使用Last line mode之前，请记得先按Esc键确定您已经处于Command mode下后，再按冒号“：”或“/”或“？”

三键的其中一键进入Last line mode。

(1)．列出行号

set
nu: 输入“set
nu或者set number”后，会在文章的每一行前面列出行号。

set
nonu：输入“set
nonu或者set nonumber”，取消行号

(2)．跳到文章的某一行

#：井号代表一个数字，在Last line
mode提示符号“：”前输入数字，再按Enter就会跳到该行了，

如：15[Enter]就会跳到文章的第15行。[常用]

(3)．寻找字符串

/关键字：先按/，再输入您想寻找的字，如果第一次找的关键字不是您相尽可能的，可以一直按n会往下寻找到您要的关键字为止。自上而下进行搜索！

？关键字：先按？，再输入您想寻找的字，如果第一次找的关键字不是您想要的，可以按n会往前寻找到您要的关键字为止。自下而上搜索！

如：3/x 表示查找当前点第三次出现 x 的地方，就像是 /x 后跟 2n。类似地，2/^e 将从当前位置开始的第二行查找以 e 开始的内容。

注意，到达文件底部之后，搜索将回到顶部。

(4)．取代字符串

1，$s/string/replae/g：在last line mode输入“1，$s/string/replace/g”会将全文的string字符串取代为replace字符串，

其中1,$s就是指搜寻区间为文章从头至尾的意思，g则是表示全部取代不必确认。

%s/string/replace/c：同样会将全文的string字符串取代为replace字符串，和上面指令不同的地方是，%s和1,$s是相同的功能，

c则是表示要替代之前必须再次确认是否取代。

1,20s/string/replace/g：将1至20行间的string替代为relpace字符串。

(5)．存文件

w：在last line mode提示符号“：”前按w即可将文件存起来。[超常用]

#，# w filename：如果您想摘取文章的某一段，存成另一个文件，可用这个指令#代表行号，例如30,50 w nice，

将您正在编辑文章的第30~50行存成nice这个文件。

或者是30,50 w >> nice ,表示把内容附加到nice文件，不覆盖

(6)．离开

q：按q就离开，有时如果无法离开vi，可搭配“！：强置离开vi，如“q！”

qw：一般建议离开时，搭配w一起使用，如此离开时还可存文件。[常用]

系统信息
arch 显示机器的处理器架构(1)
uname -m 显示机器的处理器架构(2)
uname -r 显示正在使用的内核版本
dmidecode -q 显示硬件系统部件 - (SMBIOS / DMI)
hdparm -i /dev/hda 罗列一个磁盘的架构特性
hdparm -tT /dev/sda 在磁盘上执行测试性读取操作
cat /proc/cpuinfo 显示CPU info的信息
cat /proc/interrupts 显示中断
cat /proc/meminfo 校验内存使用
cat /proc/swaps 显示哪些swap被使用
cat /proc/version 显示内核的版本
cat /proc/net/dev 显示网络适配器及统计
cat /proc/mounts 显示已加载的文件系统
lspci -tv 罗列 PCI 设备
lsusb -tv 显示 USB 设备
date 显示系统日期
cal 2007 显示2007年的日历表
date 041217002007.00 设置日期和时间 - 月日时分年.秒
clock -w 将时间修改保存到 BIOS

关机 (系统的关机、重启以及登出 )
shutdown -h now 关闭系统(1)
init 0 关闭系统(2)
telinit 0 关闭系统(3)
shutdown -h hours:minutes & 按预定时间关闭系统
shutdown -c 取消按预定时间关闭系统
shutdown -r now 重启(1)
reboot 重启(2)
logout 注销

文件和目录
cd /home 进入 '/ home' 目录'
cd .. 返回上一级目录
cd ../.. 返回上两级目录
cd 进入个人的主目录
cd ~user1 进入个人的主目录
cd - 返回上次所在的目录
pwd 显示工作路径
ls 查看目录中的文件
ls -F 查看目录中的文件
ls -l 显示文件和目录的详细资料
ls -a 显示隐藏文件
ls *[0-9]* 显示包含数字的文件名和目录名
tree 显示文件和目录由根目录开始的树形结构(1)
lstree 显示文件和目录由根目录开始的树形结构(2)
mkdir dir1 创建一个叫做 'dir1' 的目录'
mkdir dir1 dir2 同时创建两个目录
mkdir -p /tmp/dir1/dir2 创建一个目录树
rm -f file1 删除一个叫做 'file1' 的文件'
rmdir dir1 删除一个叫做 'dir1' 的目录'
rm -rf dir1 删除一个叫做 'dir1' 的目录并同时删除其内容
rm -rf dir1 dir2 同时删除两个目录及它们的内容
mv dir1 new_dir 重命名/移动 一个目录
cp file1 file2 复制一个文件
cp dir/* . 复制一个目录下的所有文件到当前工作目录
cp -a /tmp/dir1 . 复制一个目录到当前工作目录
cp -a dir1 dir2 复制一个目录
ln -s file1 lnk1 创建一个指向文件或目录的软链接
ln file1 lnk1 创建一个指向文件或目录的物理链接
touch -t 0712250000 file1 修改一个文件或目录的时间戳 - (YYMMDDhhmm)
file file1 outputs the mime type of the file as text
iconv -l 列出已知的编码
iconv -f fromEncoding -t toEncoding inputFile > outputFile creates a new from the given input file by assuming it is encoded in fromEncoding and converting it to toEncoding.
find . -maxdepth 1 -name *.jpg -print -exec convert "{}" -resize 80x60 "thumbs/{}" \; batch resize files in the current directory and send them to a thumbnails directory (requires convert from Imagemagick)

文件搜索
find / -name file1 从 '/' 开始进入根文件系统搜索文件和目录
find / -user user1 搜索属于用户 'user1' 的文件和目录
find /home/user1 -name \*.bin 在目录 '/ home/user1' 中搜索带有'.bin' 结尾的文件
find /usr/bin -type f -atime +100 搜索在过去100天内未被使用过的执行文件
find /usr/bin -type f -mtime -10 搜索在10天内被创建或者修改过的文件
find / -name \*.rpm -exec chmod 755 '{}' \; 搜索以 '.rpm' 结尾的文件并定义其权限
find / -xdev -name \*.rpm 搜索以 '.rpm' 结尾的文件，忽略光驱、捷盘等可移动设备
locate \*.ps 寻找以 '.ps' 结尾的文件 - 先运行 'updatedb' 命令
whereis halt 显示一个二进制文件、源码或man的位置
which halt 显示一个二进制文件或可执行文件的完整路径

挂载一个文件系统
mount /dev/hda2 /mnt/hda2 挂载一个叫做hda2的盘 - 确定目录 '/ mnt/hda2' 已经存在
umount /dev/hda2 卸载一个叫做hda2的盘 - 先从挂载点 '/ mnt/hda2' 退出
fuser -km /mnt/hda2 当设备繁忙时强制卸载
umount -n /mnt/hda2 运行卸载操作而不写入 /etc/mtab 文件- 当文件为只读或当磁盘写满时非常有用
mount /dev/fd0 /mnt/floppy 挂载一个软盘
mount /dev/cdrom /mnt/cdrom 挂载一个cdrom或dvdrom
mount /dev/hdc /mnt/cdrecorder 挂载一个cdrw或dvdrom
mount /dev/hdb /mnt/cdrecorder 挂载一个cdrw或dvdrom
mount -o loop file.iso /mnt/cdrom 挂载一个文件或ISO镜像文件
mount -t vfat /dev/hda5 /mnt/hda5 挂载一个Windows FAT32文件系统
mount /dev/sda1 /mnt/usbdisk 挂载一个usb 捷盘或闪存设备
mount -t smbfs -o username=user,password=pass //WinClient/share /mnt/share 挂载一个windows网络共享

磁盘空间
df -h 显示已经挂载的分区列表
ls -lSr |more 以尺寸大小排列文件和目录
du -sh dir1 估算目录 'dir1' 已经使用的磁盘空间'
du -sk * | sort -rn 以容量大小为依据依次显示文件和目录的大小
rpm -q -a --qf '%10{SIZE}t%{NAME}n' | sort -k1,1n 以大小为依据依次显示已安装的rpm包所使用的空间 (fedora, redhat类系统)
dpkg-query -W -f='${Installed-Size;10}t${Package}n' | sort -k1,1n 以大小为依据显示已安装的deb包所使用的空间 (ubuntu, debian类系统)

返回顶部索引 ^

用户和群组
groupadd group_name 创建一个新用户组
groupdel group_name 删除一个用户组
groupmod -n new_group_name old_group_name 重命名一个用户组
useradd -c "Name Surname " -g admin -d /home/user1 -s /bin/bash user1 创建一个属于 "admin" 用户组的用户
useradd user1 创建一个新用户
userdel -r user1 删除一个用户 ( '-r' 排除主目录)
usermod -c "User FTP" -g system -d /ftp/user1 -s /bin/nologin user1 修改用户属性
passwd 修改口令
passwd user1 修改一个用户的口令 (只允许root执行)
chage -E 2005-12-31 user1 设置用户口令的失效期限
pwck 检查 '/etc/passwd' 的文件格式和语法修正以及存在的用户
grpck 检查 '/etc/passwd' 的文件格式和语法修正以及存在的群组
newgrp group_name 登陆进一个新的群组以改变新创建文件的预设群组

返回顶部索引 ^

文件的权限 - 使用 "+" 设置权限，使用 "-" 用于取消
ls -lh 显示权限
ls /tmp | pr -T5 -W$COLUMNS 将终端划分成5栏显示
chmod ugo+rwx directory1 设置目录的所有人(u)、群组(g)以及其他人(o)以读（r ）、写(w)和执行(x)的权限
chmod go-rwx directory1 删除群组(g)与其他人(o)对目录的读写执行权限
chown user1 file1 改变一个文件的所有人属性
chown -R user1 directory1 改变一个目录的所有人属性并同时改变改目录下所有文件的属性
chgrp group1 file1 改变文件的群组
chown user1:group1 file1 改变一个文件的所有人和群组属性
find / -perm -u+s 罗列一个系统中所有使用了SUID控制的文件
chmod u+s /bin/file1 设置一个二进制文件的 SUID 位 - 运行该文件的用户也被赋予和所有者同样的权限
chmod u-s /bin/file1 禁用一个二进制文件的 SUID位
chmod g+s /home/public 设置一个目录的SGID 位 - 类似SUID ，不过这是针对目录的
chmod g-s /home/public 禁用一个目录的 SGID 位
chmod o+t /home/public 设置一个文件的 STIKY 位 - 只允许合法所有人删除文件
chmod o-t /home/public 禁用一个目录的 STIKY 位

返回顶部索引 ^

文件的特殊属性 - 使用 "+" 设置权限，使用 "-" 用于取消
chattr +a file1 只允许以追加方式读写文件
chattr +c file1 允许这个文件能被内核自动压缩/解压
chattr +d file1 在进行文件系统备份时，dump程序将忽略这个文件
chattr +i file1 设置成不可变的文件，不能被删除、修改、重命名或者链接
chattr +s file1 允许一个文件被安全地删除
chattr +S file1 一旦应用程序对这个文件执行了写操作，使系统立刻把修改的结果写到磁盘
chattr +u file1 若文件被删除，系统会允许你在以后恢复这个被删除的文件
lsattr 显示特殊的属性

返回顶部索引 ^

打包和压缩文件
bunzip2 file1.bz2 解压一个叫做 'file1.bz2'的文件
bzip2 file1 压缩一个叫做 'file1' 的文件
gunzip file1.gz 解压一个叫做 'file1.gz'的文件
gzip file1 压缩一个叫做 'file1'的文件
gzip -9 file1 最大程度压缩
rar a file1.rar test_file 创建一个叫做 'file1.rar' 的包
rar a file1.rar file1 file2 dir1 同时压缩 'file1', 'file2' 以及目录 'dir1'
rar x file1.rar 解压rar包
unrar x file1.rar 解压rar包
tar -cvf archive.tar file1 创建一个非压缩的 tarball
tar -cvf archive.tar file1 file2 dir1 创建一个包含了 'file1', 'file2' 以及 'dir1'的档案文件
tar -tf archive.tar 显示一个包中的内容
tar -xvf archive.tar 释放一个包
tar -xvf archive.tar -C /tmp 将压缩包释放到 /tmp目录下
tar -cvfj archive.tar.bz2 dir1 创建一个bzip2格式的压缩包
tar -xvfj archive.tar.bz2 解压一个bzip2格式的压缩包
tar -cvfz archive.tar.gz dir1 创建一个gzip格式的压缩包
tar -xvfz archive.tar.gz 解压一个gzip格式的压缩包
zip file1.zip file1 创建一个zip格式的压缩包
zip -r file1.zip file1 file2 dir1 将几个文件和目录同时压缩成一个zip格式的压缩包
unzip file1.zip 解压一个zip格式压缩包

返回顶部索引 ^

RPM 包 - （Fedora, Redhat及类似系统）
rpm -ivh package.rpm 安装一个rpm包
rpm -ivh --nodeeps package.rpm 安装一个rpm包而忽略依赖关系警告
rpm -U package.rpm 更新一个rpm包但不改变其配置文件
rpm -F package.rpm 更新一个确定已经安装的rpm包
rpm -e package_name.rpm 删除一个rpm包
rpm -qa 显示系统中所有已经安装的rpm包
rpm -qa | grep httpd 显示所有名称中包含 "httpd" 字样的rpm包
rpm -qi package_name 获取一个已安装包的特殊信息
rpm -qg "System Environment/Daemons" 显示一个组件的rpm包
rpm -ql package_name 显示一个已经安装的rpm包提供的文件列表
rpm -qc package_name 显示一个已经安装的rpm包提供的配置文件列表
rpm -q package_name --whatrequires 显示与一个rpm包存在依赖关系的列表
rpm -q package_name --whatprovides 显示一个rpm包所占的体积
rpm -q package_name --scripts 显示在安装/删除期间所执行的脚本l
rpm -q package_name --changelog 显示一个rpm包的修改历史
rpm -qf /etc/httpd/conf/httpd.conf 确认所给的文件由哪个rpm包所提供
rpm -qp package.rpm -l 显示由一个尚未安装的rpm包提供的文件列表
rpm --import /media/cdrom/RPM-GPG-KEY 导入公钥数字证书
rpm --checksig package.rpm 确认一个rpm包的完整性
rpm -qa gpg-pubkey 确认已安装的所有rpm包的完整性
rpm -V package_name 检查文件尺寸、 许可、类型、所有者、群组、MD5检查以及最后修改时间
rpm -Va 检查系统中所有已安装的rpm包- 小心使用
rpm -Vp package.rpm 确认一个rpm包还未安装
rpm2cpio package.rpm | cpio --extract --make-directories *bin* 从一个rpm包运行可执行文件
rpm -ivh /usr/src/redhat/RPMS/`arch`/package.rpm 从一个rpm源码安装一个构建好的包
rpmbuild --rebuild package_name.src.rpm 从一个rpm源码构建一个 rpm 包

返回顶部索引 ^

YUM 软件包升级器 - （Fedora, RedHat及类似系统）
yum install package_name 下载并安装一个rpm包
yum localinstall package_name.rpm 将安装一个rpm包，使用你自己的软件仓库为你解决所有依赖关系
yum update package_name.rpm 更新当前系统中所有安装的rpm包
yum update package_name 更新一个rpm包
yum remove package_name 删除一个rpm包
yum list 列出当前系统中安装的所有包
yum search package_name 在rpm仓库中搜寻软件包
yum clean packages 清理rpm缓存删除下载的包
yum clean headers 删除所有头文件
yum clean all 删除所有缓存的包和头文件

返回顶部索引 ^

DEB 包 (Debian, Ubuntu 以及类似系统)
dpkg -i package.deb 安装/更新一个 deb 包
dpkg -r package_name 从系统删除一个 deb 包
dpkg -l 显示系统中所有已经安装的 deb 包
dpkg -l | grep httpd 显示所有名称中包含 "httpd" 字样的deb包
dpkg -s package_name 获得已经安装在系统中一个特殊包的信息
dpkg -L package_name 显示系统中已经安装的一个deb包所提供的文件列表
dpkg --contents package.deb 显示尚未安装的一个包所提供的文件列表
dpkg -S /bin/ping 确认所给的文件由哪个deb包提供

返回顶部索引 ^

APT 软件工具 (Debian, Ubuntu 以及类似系统)
apt-get install package_name 安装/更新一个 deb 包
apt-cdrom install package_name 从光盘安装/更新一个 deb 包
apt-get update 升级列表中的软件包
apt-get upgrade 升级所有已安装的软件
apt-get remove package_name 从系统删除一个deb包
apt-get check 确认依赖的软件仓库正确
apt-get clean 从下载的软件包中清理缓存
apt-cache search searched-package 返回包含所要搜索字符串的软件包名称

返回顶部索引 ^

查看文件内容
cat file1 从第一个字节开始正向查看文件的内容
tac file1 从最后一行开始反向查看一个文件的内容
more file1 查看一个长文件的内容
less file1 类似于 'more' 命令，但是它允许在文件中和正向操作一样的反向操作
head -2 file1 查看一个文件的前两行
tail -2 file1 查看一个文件的最后两行
tail -f /var/log/messages 实时查看被添加到一个文件中的内容

返回顶部索引 ^

文本处理
cat file1 file2 ... | command <> file1_in.txt_or_file1_out.txt general syntax for text manipulation using PIPE, STDIN and STDOUT
cat file1 | command( sed, grep, awk, grep, etc...) > result.txt 合并一个文件的详细说明文本，并将简介写入一个新文件中
cat file1 | command( sed, grep, awk, grep, etc...) >> result.txt 合并一个文件的详细说明文本，并将简介写入一个已有的文件中
grep Aug /var/log/messages 在文件 '/var/log/messages'中查找关键词"Aug"
grep ^Aug /var/log/messages 在文件 '/var/log/messages'中查找以"Aug"开始的词汇
grep [0-9] /var/log/messages 选择 '/var/log/messages' 文件中所有包含数字的行
grep Aug -R /var/log/* 在目录 '/var/log' 及随后的目录中搜索字符串"Aug"
sed 's/stringa1/stringa2/g' example.txt 将example.txt文件中的 "string1" 替换成 "string2"
sed '/^$/d' example.txt 从example.txt文件中删除所有空白行
sed '/ *#/d; /^$/d' example.txt 从example.txt文件中删除所有注释和空白行
echo 'esempio' | tr '[:lower:]' '[:upper:]' 合并上下单元格内容
sed -e '1d' result.txt 从文件example.txt 中排除第一行
sed -n '/stringa1/p' 查看只包含词汇 "string1"的行
sed -e 's/ *$//' example.txt 删除每一行最后的空白字符
sed -e 's/stringa1//g' example.txt 从文档中只删除词汇 "string1" 并保留剩余全部
sed -n '1,5p;5q' example.txt 查看从第一行到第5行内容
sed -n '5p;5q' example.txt 查看第5行
sed -e 's/00*/0/g' example.txt 用单个零替换多个零
cat -n file1 标示文件的行数
cat example.txt | awk 'NR%2==1' 删除example.txt文件中的所有偶数行
echo a b c | awk '{print $1}' 查看一行第一栏
echo a b c | awk '{print $1,$3}' 查看一行的第一和第三栏
paste file1 file2 合并两个文件或两栏的内容
paste -d '+' file1 file2 合并两个文件或两栏的内容，中间用"+"区分
sort file1 file2 排序两个文件的内容
sort file1 file2 | uniq 取出两个文件的并集(重复的行只保留一份)
sort file1 file2 | uniq -u 删除交集，留下其他的行
sort file1 file2 | uniq -d 取出两个文件的交集(只留下同时存在于两个文件中的文件)
comm -1 file1 file2 比较两个文件的内容只删除 'file1' 所包含的内容
comm -2 file1 file2 比较两个文件的内容只删除 'file2' 所包含的内容
comm -3 file1 file2 比较两个文件的内容只删除两个文件共有的部分

返回顶部索引 ^

字符设置和文件格式转换
dos2unix filedos.txt fileunix.txt 将一个文本文件的格式从MSDOS转换成UNIX
unix2dos fileunix.txt filedos.txt 将一个文本文件的格式从UNIX转换成MSDOS
recode ..HTML < page.txt > page.html 将一个文本文件转换成html
recode -l | more 显示所有允许的转换格式

返回顶部索引 ^

文件系统分析
badblocks -v /dev/hda1 检查磁盘hda1上的坏磁块
fsck /dev/hda1 修复/检查hda1磁盘上linux文件系统的完整性
fsck.ext2 /dev/hda1 修复/检查hda1磁盘上ext2文件系统的完整性
e2fsck /dev/hda1 修复/检查hda1磁盘上ext2文件系统的完整性
e2fsck -j /dev/hda1 修复/检查hda1磁盘上ext3文件系统的完整性
fsck.ext3 /dev/hda1 修复/检查hda1磁盘上ext3文件系统的完整性
fsck.vfat /dev/hda1 修复/检查hda1磁盘上fat文件系统的完整性
fsck.msdos /dev/hda1 修复/检查hda1磁盘上dos文件系统的完整性
dosfsck /dev/hda1 修复/检查hda1磁盘上dos文件系统的完整性

返回顶部索引 ^

初始化一个文件系统
mkfs /dev/hda1 在hda1分区创建一个文件系统
mke2fs /dev/hda1 在hda1分区创建一个linux ext2的文件系统
mke2fs -j /dev/hda1 在hda1分区创建一个linux ext3(日志型)的文件系统
mkfs -t vfat 32 -F /dev/hda1 创建一个 FAT32 文件系统
fdformat -n /dev/fd0 格式化一个软盘
mkswap /dev/hda3 创建一个swap文件系统

返回顶部索引 ^

SWAP文件系统
mkswap /dev/hda3 创建一个swap文件系统
swapon /dev/hda3 启用一个新的swap文件系统
swapon /dev/hda2 /dev/hdb3 启用两个swap分区

返回顶部索引 ^

备份
dump -0aj -f /tmp/home0.bak /home 制作一个 '/home' 目录的完整备份
dump -1aj -f /tmp/home0.bak /home 制作一个 '/home' 目录的交互式备份
restore -if /tmp/home0.bak 还原一个交互式备份
rsync -rogpav --delete /home /tmp 同步两边的目录
rsync -rogpav -e ssh --delete /home ip_address:/tmp 通过SSH通道rsync
rsync -az -e ssh --delete ip_addr:/home/public /home/local 通过ssh和压缩将一个远程目录同步到本地目录
rsync -az -e ssh --delete /home/local ip_addr:/home/public 通过ssh和压缩将本地目录同步到远程目录
dd bs=1M if=/dev/hda | gzip | ssh user@ip_addr 'dd of=hda.gz' 通过ssh在远程主机上执行一次备份本地磁盘的操作
dd if=/dev/sda of=/tmp/file1 备份磁盘内容到一个文件
tar -Puf backup.tar /home/user 执行一次对 '/home/user' 目录的交互式备份操作
( cd /tmp/local/ && tar c . ) | ssh -C user@ip_addr 'cd /home/share/ && tar x -p' 通过ssh在远程目录中复制一个目录内容
( tar c /home ) | ssh -C user@ip_addr 'cd /home/backup-home && tar x -p' 通过ssh在远程目录中复制一个本地目录
tar cf - . | (cd /tmp/backup ; tar xf - ) 本地将一个目录复制到另一个地方，保留原有权限及链接
find /home/user1 -name '*.txt' | xargs cp -av --target-directory=/home/backup/ --parents 从一个目录查找并复制所有以 '.txt' 结尾的文件到另一个目录
find /var/log -name '*.log' | tar cv --files-from=- | bzip2 > log.tar.bz2 查找所有以 '.log' 结尾的文件并做成一个bzip包
dd if=/dev/hda of=/dev/fd0 bs=512 count=1 做一个将 MBR (Master Boot Record)内容复制到软盘的动作
dd if=/dev/fd0 of=/dev/hda bs=512 count=1 从已经保存到软盘的备份中恢复MBR内容

返回顶部索引 ^

光盘
cdrecord -v gracetime=2 dev=/dev/cdrom -eject blank=fast -force 清空一个可复写的光盘内容
mkisofs /dev/cdrom > cd.iso 在磁盘上创建一个光盘的iso镜像文件
mkisofs /dev/cdrom | gzip > cd_iso.gz 在磁盘上创建一个压缩了的光盘iso镜像文件
mkisofs -J -allow-leading-dots -R -V "Label CD" -iso-level 4 -o ./cd.iso data_cd 创建一个目录的iso镜像文件
cdrecord -v dev=/dev/cdrom cd.iso 刻录一个ISO镜像文件
gzip -dc cd_iso.gz | cdrecord dev=/dev/cdrom - 刻录一个压缩了的ISO镜像文件
mount -o loop cd.iso /mnt/iso 挂载一个ISO镜像文件
cd-paranoia -B 从一个CD光盘转录音轨到 wav 文件中
cd-paranoia -- "-3" 从一个CD光盘转录音轨到 wav 文件中（参数-3）
cdrecord --scanbus 扫描总线以识别scsi通道
dd if=/dev/hdc | md5sum 校验一个设备的md5sum编码，例如一张 CD

返回顶部索引 ^

网络 - （以太网和WIFI无线）
ifconfig eth0 显示一个以太网卡的配置
ifup eth0 启用一个 'eth0' 网络设备
ifdown eth0 禁用一个 'eth0' 网络设备
ifconfig eth0 192.168.1.1 netmask 255.255.255.0 控制IP地址
ifconfig eth0 promisc 设置 'eth0' 成混杂模式以嗅探数据包 (sniffing)
dhclient eth0 以dhcp模式启用 'eth0'
route -n show routing table
route add -net 0/0 gw IP_Gateway configura default gateway
route add -net 192.168.0.0 netmask 255.255.0.0 gw 192.168.1.1 configure static route to reach network '192.168.0.0/16'
route del 0/0 gw IP_gateway remove static route
echo "1" > /proc/sys/net/ipv4/ip_forward activate ip routing
hostname show hostname of system
host www.example.com lookup hostname to resolve name to ip address and viceversa(1)
nslookup www.example.com lookup hostname to resolve name to ip address and viceversa(2)
ip link show show link status of all interfaces
mii-tool eth0 show link status of 'eth0'
ethtool eth0 show statistics of network card 'eth0'
netstat -tup show all active network connections and their PID
netstat -tupl show all network services listening on the system and their PID
tcpdump tcp port 80 show all HTTP traffic
iwlist scan show wireless networks
iwconfig eth1 show configuration of a wireless network card
hostname show hostname
host www.example.com lookup hostname to resolve name to ip address and viceversa
nslookup www.example.com lookup hostname to resolve name to ip address and viceversa
whois www.example.com lookup on Whois database

GO TOP INDEX ^
Microsoft Windows networks (SAMBA)
nbtscan ip_addr netbios name resolution
nmblookup -A ip_addr netbios name resolution
smbclient -L ip_addr/hostname show remote shares of a windows host
smbget -Rr smb://ip_addr/share like wget can download files from a host windows via smb
mount -t smbfs -o username=user,password=pass //WinClient/share /mnt/share mount a windows network share

手工建库后出现ORA-06553：PLS-213：Standard包不可访问 问题，在网上查下了资料解决了！

webservice的原理及概念

1 webservice

所谓webservice就是定义了一套标准的调用过程:

a 服务器首先用一套标准的方法向外界描述它所提供的服务的内容，就属于WSDL

b 客户端需要以一种标准的协议来调用此服务，这属于SOAP.

c 服务提供者将服务内容放在一个公共的网址让大家查询，就属于UDDI.

2 命名空间

命名空间其主要目的通过加一个命名属性，使名称保持唯一性。WSDL有大量的使用命名空间的地方。本质上WSDL是一个XML文件，作为一个XML文件，为了区别同名的元素，就需要采用命名空间的概念。

3 WSDL的本质:服务内容的标准化描述

WSDL的全称是web service Description Language,是一种基于XML格式的关于web服务的描述语言。其主要目的在于web service的提供者将自己的web服务的所有相关内容,如所提供的服务的传输方式，服务方法接口，接口参数，服务路径等，生成相应的完全文档，发布给使用者。使用者可以通过这个WSDL文档，创建相应的SOAP请求消息，通过HTTP传递给webservice提供者；web服务在完成服务请求后，将SOAP返回消息传回请求者，服务请求者再根据WSDL文档将SOAP返回消息解析成自己能够理解的内容。

4 SOAP的本质：标准的传输协议

SOAP是web service的标准通信协议，SOAP为simple object access protocoll的缩写，简单对象访问协议. 它是一种标准化的传输消息的XML消息格式。

5 UDDI的本质:服务的公共网址

将web service进行UDDI注册发布,UDDI是一种创建注册表服务的规范,以便大家将自己的web service进行注册发布供使用者查找.然而当服务提供者想将自己的web service向全世界公布，以便外部找到其服务时，那么服务提供者可以将自己的web service注册到相应的UDDI商用注册网站，目前全球有IBM等4家UDDI商用注册网站。因为WSDL文件中已经给定了web service的地址URI，外部可以直接通过WSDL提供的URI进行相应的web service调用。所以UDDI并不是一个必需的web service组件，服务方完全可以不进行UDDI的注册。

java处理word已经存在很多种方法了，但是用起来都不是那么方便，而且不太灵活，而使用xml的方法可以做到非常灵活，你可以先建好模板，然后往里面填数，模板怎么建，填出来的效果就是怎么样的。首先说说word和xml的关系，每个word它都对应着一个xml文件，也就是说你修改了xml，对应的word文件也就跟着修改了。通过word的保存功能可以将一个word文件保存为xml文件，该文件虽然是.xml格式的，但是直接双击打开的话还是使用word打开，所以你只能用txt将它打开，用txt打开之后将里面的一句话：<?mso-application progid="Word.Document"?>去掉，然后保存，接着就可以双击直接打开了，这样使用的就是IE打开的，你这样就可以查看里面的节点具体的构造。

最上面的主节点是<w:wordDocument>(如果不是的话，相信你将word文件保存成xml的时候使用的是07word,选择的是：word xml文档(*.xml),你可以选择word 2003 xml文档(*.xml)试试)；该主节点下面有大致8个节点，其中我们要操作的就是<w:body>节点，该节点是word的正文节点，其他的节点没有去研究；<w:body>下面包含的节点可能会有：<w:p>段落节点、<w:tbl>表格节点。

接着要做的就是在java程序中，使用dom来解析编辑xml文件，这里贴出一些代码来供大家参考：

public Document loadXML(String filename){//////////加载xml文件

Document document = null; 

   try{

   DocumentBuilderFactory   factory = DocumentBuilderFactory.newInstance();    

       DocumentBuilder builder=factory.newDocumentBuilder();    

       document=builder.parse(new File(filename));    

       document.normalize(); 

   }catch (Exception ex){

       ex.printStackTrace(); 

   }   

   return document; 

}

public boolean doc2XmlFile(Document document,File targetFile){ ///////回写xml文件

boolean flag = true; 

   try{

   TransformerFactory tFactory = TransformerFactory.newInstance();    

       Transformer transformer = tFactory.newTransformer();  

       DOMSource source = new DOMSource(document);  

       StreamResult result = new StreamResult(targetFile.toURI().getPath());

       transformer.transform(source, result);  

   }catch(Exception ex){ 

       flag = false; 

       ex.printStackTrace(); 

   } 

   return flag;       

}

String void function(){///////////程序入口

String rootPath=ServletActionContext.getServletContext().getRealPath("/excelTemplate")+"\\";

try{

Document document=loadXML(rootPath+"projectModel.xml");

Element root = document.getDocumentElement();

NodeList rootList=root.getChildNodes();

Node bodyNode=null;///////w:body

for(int i=0;i<rootList.getLength();i++){////////找到<w:body>节点

bodyNode=rootList.item(i);

if("w:body".equals(bodyNode.getNodeName())){

break;

}

}

NodeList nodeList=bodyNode.getChildNodes();

for(int i=0;i<nodeList.getLength();i++){

Node node=nodeList.item(i);

if("w:tbl".equals(node.getNodeName())){

dealWithTableNode(document,node);

}else if("w:p".equals(node.getNodeName())){

dealWithWPNode(document,node);

}

}

File destFile = File.createTempFile("project", ".xml");

doc2XmlFile(document,destFile);///////回写

inputStream = new FileInputStream(destFile);/////////生成流，用于下载

fileName=URLEncoder.encode(project.getProjectName(),"utf-8")+".doc";

}catch(Exception e){

e.printStackTrace();

}

}

注意：

1、在解析编辑xml文件的时候一定好看好节点的位置，比如一般的文本内容的话可能是在<w:p>节点下的<w:r>节点下的<w:t>里设置，使用的是getTextContent()方法来获取它的内容，setTextContent()来设置它的参数

2、对于图片如何插入呢？首先最好在模板中插入一张图片，主要用于定下图片的那些格式，然后图片必须用java转成base64的字符串，这里也提供一个方法：

private String toBASE64codeFile(File file){

String codeString="";

try{

FileInputStream fis=new FileInputStream(file);

BASE64Encoder encoder=new BASE64Encoder();

byte[] b=new byte[228];

int count=-1,n=0;

while((count=fis.read(b))!=-1){

codeString+=encoder.encode(b);

}

return codeString;

}catch(Exception e){

e.printStackTrace();

return "";

}

}

然后找到<w:pict>节点：一般如果图片是在table里的话，该节点就是在<w:tbl>-<w:tr>-<w:tc>-<w:p>-<w:r>节点下面，不在table里的话就是：<w:p>-<w:r>，建议仿照用IE打开的xml对照一下。然后将该节点下的<w:binData>的内容置成你所要插入的图片的base64码即可。

将几个word文件合并到一个word文件，需要下载jacob-1.17-M2.zip，将压缩文件内的jacob-1.17-M2-x64.dll放到windows/system32下，将jacob.jar放到项目中
public static void main(String[] args) {
   List list  = new ArrayList();
   String file1= "D:\\file1.doc";
   String file2= "D:\\file2.doc";
   String file3= "D:\\file3.doc";
   list.add(file1);
   list.add(file2);
   list.add(file3);
   uniteDoc(list,"d:\\file.doc");
 }
 public static void uniteDoc(List fileList, String savepaths) {
  if (fileList.size() == 0 || fileList == null) {
   return;
  }
  //打开word
  ActiveXComponent app = new ActiveXComponent("Word.Application");//启动word
  try {
   // 设置word不可见
   app.setProperty("Visible", new Variant(false));
   //获得documents对象
   Object docs = app.getProperty("Documents").toDispatch();
   //打开第一个文件
   Object doc = Dispatch
                .invoke(
                        (Dispatch) docs,
                        "Open",
                        Dispatch.Method,
                        new Object[] { (String) fileList.get(0),
                                new Variant(false), new Variant(true) },
                        new int[3]).toDispatch();
   //追加文件
   for (int i = 1; i < fileList.size(); i++) {
    Dispatch.invoke(app.getProperty("Selection").toDispatch(),
                    "insertFile", Dispatch.Method, new Object[] {
                            (String) fileList.get(i), "",
                            new Variant(false), new Variant(false),
                            new Variant(false) }, new int[3]);
   }
   //保存新的word文件
   Dispatch.invoke((Dispatch) doc, "SaveAs", Dispatch.Method,
                new Object[] { savepaths, new Variant(1) }, new int[3]);
   Variant f = new Variant(false);
   Dispatch.call((Dispatch) doc, "Close", f);
  } catch (Exception e) {
   throw new RuntimeException("合并word文件出错.原因:" + e);
  } finally {
   app.invoke("Quit", new Variant[] {});
  }
 }

package com.cbd.dk.test;

import java.util.ListIterator;
import java.util.Stack;

public class Test {

 private String src;

 public Test(String src) {
  this.src = src;
 }
 public double getResult() {
  String postfix = getPostfix();
  Stack<String> stk = new Stack<String>();
  //System.out.println(postfix);
  String parts[] = postfix.split(" +");
  double result=0;
  for(int i=0; i<parts.length; i++){
   char tmp = parts[i].charAt(0);
   if(!isOperator(tmp)){
    stk.push(parts[i]);
   }else{
    double a = Double.parseDouble(stk.pop());
    double b = Double.parseDouble(stk.pop());
    result = calculate(b,a,tmp);
    stk.push(String.valueOf(result));
   }
  }
  return result;
 }

 /**
  * test if the character is an operator,such +,-,*,/
  * @param op  the character to test
  * @return  true if op is an operator otherwise false
  */
 private boolean isOperator(char op){
  return (op=='+'||op=='-'||op=='*'||op=='/');
 }

 /**
  * calculate an expression such (a op b)
  * @param a  number 1
  * @param b  number 2
  * @param op the operator
  * @return  (double)(a op b)
  */
 public double calculate(double a, double b, char op) {
  switch (op) {
   case '+':
    return a + b;
   case '-':
    return a - b;
   case '*':
    return a * b;
   case '/':
    return a / b;
  }
  return -1;
 }

 /**
  * convert the suffix to postfix
  * @return the postfix as a string
  */
 private String getPostfix() {
  Stack<String> stk = new Stack<String>();
  String postfix = new String();
  char op;
  int i = 0;
  while (i < src.length()) {
   if (Character.isDigit(src.charAt(i))||src.charAt(i)=='.') {
    postfix += " ";
    do {
     postfix += src.charAt(i++);
    } while ((i < src.length()) && (Character.isDigit(src.charAt(i))));
    postfix += " ";
   }else {
    switch (op = src.charAt(i++)) {
     case '(':
      stk.push("(");
      break;
     case ')':
      while (stk.peek() != "(") {
       String tmp = stk.pop();
       postfix += tmp;
       if(tmp.length()==1 && isOperator(tmp.charAt(0)))
        postfix += " ";
      }
      stk.pop();
      postfix += " ";
      break;
     case '+':
     case '-':
      while ((!stk.empty()) && (stk.peek() != "(")) {
       postfix += stk.pop()+" ";
      }
      stk.push(new Character(op).toString());
      break;
     case '*':
     case '/':
      while ((!stk.empty()) && ((stk.peek() == "*") || (stk.peek() == "/"))) {
       postfix += stk.pop()+" ";
      }
      stk.push(new Character(op).toString());
      break;
    }
   }
  }
  ListIterator it = stk.listIterator(stk.size());
  while (it.hasPrevious())
   postfix += it.previous() + " ";
  return postfix.trim().replaceAll(" +\\.",".");
 }

 /**
  * main function
  * @param args
  */
 public static void main(String args[]) {
  //System.out.println(new Test("((1.5+6.000)*9+9.36)*(8-8*8+8*7)").getResult());
  System.out.println(new Test("(2+(3*2)/2)").getResult());
 }
}

package test;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

public class TestStringUtils {
 
 public static void main(String[] args) {
  // 空字符串检查
  String t1_1 = "";
  String t1_2 = "\n\n\t";
  String t1_3 = null;
  String t1_4 = "Test";
  System.out.println("t1_1 blank? " + StringUtils.isBlank(t1_1));
  System.out.println("t1_2 blank? " + StringUtils.isBlank(t1_2));
  System.out.println("t1_3 blank? " + StringUtils.isBlank(t1_3));
  System.out.println("t1_4 blank? " + StringUtils.isBlank(t1_4));
  // 清除空白字符
  String t2_1 = "\t";
  String t2_2 = "  A  Test  ";
  String t2_3 = null;
  System.out.println("t2_1 trimToNull: " + StringUtils.trimToNull(t2_1));
  System.out.println("t2_2 trimToNull: " + StringUtils.trimToNull(t2_2));
  System.out.println("t2_3 trimToNull: " + StringUtils.trimToNull(t2_3));
  System.out.println("t2_1 trim: " + StringUtils.trim(t2_1));
  System.out.println("t2_2 trim: " + StringUtils.trim(t2_2));
  System.out.println("t2_3 trim: " + StringUtils.trim(t2_3));
  // 取得字符串的缩写
  String t3_1 = "This is a test of the abbreviation.";
  String t3_2 = "Test";
  System.out.println(StringUtils.abbreviate(t3_1, 15));
  System.out.println(StringUtils.abbreviate(t3_1, 5, 15));
  System.out.println(StringUtils.abbreviate(t3_2, 10));
  // 劈分字符串
  String t4_1 = "A b,c.d|e";
  String t4_2 = "Pharmacy, basketball funky";
  String[] array1 = StringUtils.split(t4_1, " ,.|");
  String[] array2 = StringUtils.split(t4_2, " ,", 2);
  System.out.println(ArrayUtils.toString(array1));
  System.out.println(ArrayUtils.toString(array2));
  // 查找嵌套字符串
  String t5_1 = "ABC1234ABC4567";
  System.out.println(StringUtils.substringBetween(t5_1, "1234", "4567"));
  System.out.println(StringUtils.substringBetween(t5_1, "12345", "4567"));
  // 去除尾部换行符
  String t6_1 = "Hello\n";
  System.out.println(StringUtils.chomp(t6_1));
  String t6_2 = "Another test\r\n";
  System.out.println(StringUtils.chomp(t6_2));
  // 重复字符串
  System.out.println(StringUtils.repeat("*", 10));
  System.out.println(StringUtils.repeat("China ", 5));
  // 颠倒字符串
  System.out.println(StringUtils.reverse("ABCDE"));
  // 判断字符串内容的类型
  String t7_1 = "Virginia";
  System.out.println("Is state number? " + StringUtils.isNumeric(t7_1));// 全由数字组成
  System.out.println("Is state alpha? " + StringUtils.isAlpha(t7_1));// 全由字母组成
  System.out.println("Is state alphanumeric? " + StringUtils.isAlphanumeric(t7_1));// 全由数字或数字组成
  System.out.println("Is state alphaspace? " + StringUtils.isAlphaSpace(t7_1));// 全由字母或空格组成
  // 取得某字符串在另一字符串中出现的次数
  System.out.println(StringUtils.countMatches("Chinese People", "e"));
  // 部分截取字符串
  String t8_1 = " 25 * (30,40) [50,60] | 30";
  System.out.print("N0: " + StringUtils.substringBeforeLast(t8_1, "*"));
  System.out.print(", N1: " + StringUtils.substringBetween(t8_1, "(", ","));
  System.out.print(", N2: " + StringUtils.substringBetween(t8_1, ",", ")"));
  System.out.print(", N3: " + StringUtils.substringBetween(t8_1, "[", ","));
  System.out.print(", N4: " + StringUtils.substringBetween(t8_1, ",", "]"));
  System.out.print(", N5: " + StringUtils.substringAfterLast(t8_1, "|"));
 }

}

依赖包 json-lib-2.2.3-jdk13.jar、dom4j-1.6.1.jar

package com.shine.framework.core.util;
import java.io.ByteArrayOutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import net.sf.json.JSON;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
/**
* common xml conver utility
*
* @author viruscodecn@gmail.com
* @version Framework 2010.10.26
*/
public class XmlConverUtil {
/**
* map to xml xml <node><key label="key1">value1</key><key
* label="key2">value2</key>......</node>
*
* @param map
* @return
*/
public static String maptoXml(Map map) {
Document document = DocumentHelper.createDocument();
Element nodeElement = document.addElement("node");
for (Object obj : map.keySet()) {
Element keyElement = nodeElement.addElement("key");
keyElement.addAttribute("label", String.valueOf(obj));
keyElement.setText(String.valueOf(map.get(obj)));
}
return doc2String(document);
}
/**
* list to xml xml <nodes><node><key label="key1">value1</key><key
* label="key2">value2</key>......</node><node><key
* label="key1">value1</key><key
* label="key2">value2</key>......</node></nodes>
*
* @param list
* @return
*/
public static String listtoXml(List list) {
Document document = DocumentHelper.createDocument();
Element nodesElement = document.addElement("nodes");
for (Object o : list) {
Element nodeElement = nodesElement.addElement("node");
for (Object obj : ((Map) o).keySet()) {
Element keyElement = nodeElement.addElement("key");
keyElement.addAttribute("label", String.valueOf(obj));
keyElement.setText(String.valueOf(((Map) o).get(obj)));
}
}
return doc2String(document);
}
/**
* json to xml {"node":{"key":{"@label":"key1","#text":"value1"}}} conver
* <o><node class="object"><key class="object"
* label="key1">value1</key></node></o>
*
* @param json
* @return
*/
public static String jsontoXml(String json) {
try {
XMLSerializer serializer = new XMLSerializer();
JSON jsonObject = JSONSerializer.toJSON(json);
return serializer.write(jsonObject);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* xml to map xml <node><key label="key1">value1</key><key
* label="key2">value2</key>......</node>
*
* @param xml
* @return
*/
public static Map xmltoMap(String xml) {
try {
Map map = new HashMap();
Document document = DocumentHelper.parseText(xml);
Element nodeElement = document.getRootElement();
List node = nodeElement.elements();
for (Iterator it = node.iterator(); it.hasNext();) {
Element elm = (Element) it.next();
map.put(elm.attributeValue("label"), elm.getText());
elm = null;
}
node = null;
nodeElement = null;
document = null;
return map;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* xml to list xml <nodes><node><key label="key1">value1</key><key
* label="key2">value2</key>......</node><node><key
* label="key1">value1</key><key
* label="key2">value2</key>......</node></nodes>
*
* @param xml
* @return
*/
public static List xmltoList(String xml) {
try {
List<Map> list = new ArrayList<Map>();
Document document = DocumentHelper.parseText(xml);
Element nodesElement = document.getRootElement();
List nodes = nodesElement.elements();
for (Iterator its = nodes.iterator(); its.hasNext();) {
Element nodeElement = (Element) its.next();
Map map = xmltoMap(nodeElement.asXML());
list.add(map);
map = null;
}
nodes = null;
nodesElement = null;
document = null;
return list;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* xml to json <node><key label="key1">value1</key></node> 转化为
* {"key":{"@label":"key1","#text":"value1"}}
*
* @param xml
* @return
*/
public static String xmltoJson(String xml) {
XMLSerializer xmlSerializer = new XMLSerializer();
return xmlSerializer.read(xml).toString();
}
/**
*
* @param document
* @return
*/
public static String doc2String(Document document) {
String s = "";
try {
// 使用输出流来进行转化
ByteArrayOutputStream out = new ByteArrayOutputStream();
// 使用UTF-8编码
OutputFormat format = new OutputFormat(" ", true, "UTF-8");
XMLWriter writer = new XMLWriter(out, format);
writer.write(document);
s = out.toString("UTF-8");
} catch (Exception ex) {
ex.printStackTrace();
}
return s;
}
public static void main(String args[]) {
XmlConverUtil util = new XmlConverUtil();
String xml = "{/"node/":{/"key/":{/"@lable/":/"key1/",/"#text/":/"value1/"}}}";
System.out.println(util.jsontoXml(xml));
}
}

　　1.将Image图像文件存入到数据库中 我们知道数据库里的Image类型的数据是"二进制数据",因此必须将图像文件转换成字节数组才能存入数据库中。

　　//根据文件名(完全路径)

　　public byte[] SetImageToByteArray(string fileName)

　　{ FileStream fs = new FileStream(fileName, FileMode.Open);

　　int streamLength = (int)fs.Length; byte[] image = new byte[streamLength];

　　fs.Read(image, 0, streamLength);

　　fs.Close();

　　return image; }

　　//另外，在ASP.NET中通过FileUpload控件得到的图像文件可以通过以下方法

　　public byte[]

　　SetImageToByteArray(FileUpload FileUpload1)

　　{ Stream stream = FileUpload1.PostedFile.InputStream;

　　byte[] photo = new byte[FileUpload1.PostedFile.ContentLength];

　　stream.Read(photo, 0, FileUpload1.PostedFile.ContentLength);

　　stream.Close();

　　return photo;

　　}

　　2.从SQL Server数据库读取Image类型的数据，并转换成bytes[]或Image图像文件

　　//要使用SqlDataReader要加载using System.Data.SqlClient命名空间

　　//将数据库中的Image类型转换成byte[] public byte[] SetImage(SqlDataReader reader)

　　{ return (byte[])reader["Image"];//Image为数据库中存放Image类型字段 }

　　//将byte[]转换成Image图像类型 //加载以下命名空间using System.Drawing;/using System.IO;

　　using System.Data.SqlClient;*/ public Image SetByteToImage(byte[] mybyte)

　　{ Image image; MemoryStream mymemorystream = new MemoryStream(mybyte,0, mybyte.Length);

　　image = Image.FromStream(mymemorystream);

　　return image;

　　}

当然这点小问题是难不倒我们程序员的，“max+1啊”，有人会说这样的方式。是的，这种方式实现起来也比较简单。当然你也许还会说，最Sql的方式是采用identity列，自增的方式去增加就ok了。但是这样的列如果要实现“YYYYMMDD”+“部门编号（如ZX）”+Sequence值 （例如：20100707ZX000002）的格式就不行了。还是老老实实用存储过程来取得一个Sequence值吧，使用起来也就随心所欲了。

网上常见的一个存储过程为 为当前库所有用到Sequence建一张表，譬如“AllSequence”，内含四个字段【名字，起点值，递增值，当前值】，创建Sequence的时候就创建一条记录，获取Sequence的时候就从对应行的当前值按递增值增加得到。

在并发性请求不那么高的系统里，这种过程是没有问题的。但是并发性请求一旦处于某个量级以后，这个过程常常会遇到问题。

以下为一个改进方法，适合于高吞吐量的访问请求，比如每秒数千次的请求：

-- 假定要给T_0101001创建一个Sequence

-- 创建表SeqT_0101001
create table SeqT_0101001(

      -- ID列为自增列
      SeqID int identity(1,1) primary key,

      -- Sequence值
      SeqVal varchar(1)
)

-- 创建从SeqT_0101001表获取最新Sequence值的存储过程
create procedure P_GetNewSeqVal_SeqT_0101001
as
begin
      -- 声明新Sequence值变量
      declare @NewSeqValue int

      -- 设置插入、删除操作后的条数显示取消
      set NOCOUNT ON

      -- 插入新值到SeqT_0101001表
      insert into SeqT_0101001 (SeqVal) values ('a')   

      -- 设置新Sequence值为插入到SeqT_0101001表的标识列内的最后一个标识值  
      set @NewSeqValue = scope_identity()   

      --如果组合的Sequence值<999999999(大于的话数值会溢出)，如:“YYYY”+5位的Sequence值(201019988)，可以采用下面的方式来实现
      --set @NewSeqValue = Convert(char(4),Getdate(),112) + right('00000'+CAST(scope_identity() AS varchar(5)),5)
      --这样直接Print @NewSeqVal 就可以得到类似“201019988”的Sequence值

      -- 删除SeqT_0101001表(不显示被锁行)
      delete from SeqT_0101001 WITH (READPAST)

-- 返回新Sequence值
return @NewSeqValue

end

--使用Sequence
Declare @NewSeqVal int
Exec @NewSeqVal =  P_GetNewSeqVal_SeqT_0101001
Print @NewSeqVal
Print Convert(char(8),Getdate(),112) +'ZX'+ right('000000'+CAST(@NewSeqVal AS varchar(5)),6)

要获取刚才我们提到的 “20100707ZX000002”这种格式的话，下面这样就可以了
Print Convert(char(8),Getdate(),112) +'ZX'+ right('000000'+CAST(@NewSeqVal AS varchar(5)),6)

缺点：不能直接在非存储过程的select的语句中直接使用。

信息来源：http://www.cnblogs.com/heekui/archive/2008/07/24/1250842.html

Mongo是没有like查询的方式的 
要进行模糊匹配只能借助于正则表达式

Java代码:

     Mongo m=new Mongo();  

      DB db=m.getDB("UserDB");  

      DBCollection collection=db.getCollection("userCollection");  

      BasicDBObject cond=new BasicDBObject();          

      if(province!=""){  

         cond.put("province", province);

      }  

      if(area!=""){  

         cond.put("area", area);  

      }              

      if(keywords!=""){  

          Pattern pattern=Pattern.compile("^.*"+keywords+".*$");            

          cond.put("name", pattern);

      }  

      DBCursor returns=collection.find(cond);  

还有一种是mongoDB 和Spring结合的 Spring-data的模式查询  代码如下 :

       public List<User> findUserTop9(String s) {  

             mongoTemplate.setDatabaseName("UserDB");

             mongoTemplate.setDefaultCollectionName("userColl");  

             List<User> users = mongoTemplate.find(new Query(new Criteria(      "name").regex(".*?"+"张"+".*")).limit(9), User.class);  

             return users;

        }  

public ModelAndView getAssessmentStaffEvaluationHandler(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException, ParseException {

  String userId = Utils.trim(request.getParameter("userId"));
  String startDate = Utils.trim(request.getParameter("startDate"));
  String endDate = Utils.trim(request.getParameter("endDate"));
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  Map param = new HashMap();
  param.put("inputid", userId);
  param.put("beginDate", sdf.parse(startDate));
  param.put("endDate", sdf.parse(endDate));
  Response response1 = customerServiceService.getCustomerServiceCount(param);
  Integer count1 = response1.getReturnInt();

  Calendar c = Calendar.getInstance();
  c.setTime(sdf.parse(endDate));
  c.add(Calendar.DATE, 1);
  Map param1 = new HashMap();
  param1.put("userid", userId);
  param1.put("beginDate", sdf.parse(startDate));
  param1.put("endDate", c.getTime());
  Response response2 = reportReadLogService.getReportReadLogCount(param1);
  Integer count2 = (Integer) response2.getReturnObject();

  Response response3 = htreportService.getHtreportCount(param1);
  Integer count3 = (Integer) response3.getReturnObject();

  Map param2 = new HashMap();
  param2.put("createId", userId);
  param2.put("flag", 1);
  param2.put("startTime", sdf.parse(startDate));
  param2.put("endTime", c.getTime());
  Response response4 = taskService.getTaskCount(param2);
  Integer count4 = (Integer) response4.getReturnObject();

  Map param3 = new HashMap();
  param3.put("createId", userId);
  param3.put("beginDate", sdf.parse(startDate));
  param3.put("endDate", c.getTime());
  Response response5 = applyTaskService.getApplyTaskCount(param3);
  Integer count5 = (Integer) response5.getReturnObject();

  response.setContentType("text/json");
  PrintWriter out = response.getWriter();
  out.println("{\"customerService\":\"" + count1 + "\", \"reportReadLog\":\"" + count2 + "\", \"htreport\":\""
          + count3 + "\", \"task\":\"" + count4 + "\", \"applyTask\":\"" + count5 + "\"}");
  out.flush();
  out.close();

  return null;
 }

最主要的是设置font

柱状图(CategoryPlot):
    CategoryPlot plot=chart.getCategoryPlot();//获取图表区域对象
   CategoryAxis domainAxis=plot.getDomainAxis();
    //水平底部列表
    domainAxis.setLabelFont(new Font("黑体",Font.BOLD,14));
    //水平底部标题
    domainAxis.setTickLabelFont(new Font("宋体",Font.BOLD,12));
    //垂直标题
    ValueAxis rangeAxis=plot.getRangeAxis();//获取柱状
    rangeAxis.setLabelFont(new Font("黑体",Font.BOLD,15));
     chart.getLegend().setItemFont(new Font("黑体", Font.BOLD, 15));
饼图(PiePlot):
     JFreeChart chart = ChartFactory.createPieChart3D("IT行业职业分布图", dataset, true, false, false);
    chart.getTitle().setFont(new Font("黑体",Font.BOLD,20));//设置标题字体
    PiePlot piePlot= (PiePlot) chart.getPlot();//获取图表区域对象
    piePlot.setLabelFont(new Font("黑体",Font.BOLD,10));
    chart.getLegend().setItemFont(new Font("黑体",Font.BOLD,10));
时序图(TimeSeries)  
   XYPlot plot = (XYPlot) chart.getPlot();
    //纵轴字体
    plot.getRangeAxis().setLabelFont(new Font("宋体", Font.BOLD, 15));
    //横轴框里的标题字体
    chart.getLegend().setItemFont(new Font("宋体", Font.ITALIC, 15));
    //横轴列表字体
    plot.getDomainAxis().setTickLabelFont(new Font("新宋体", 1, 15));
    //横轴小标题字体
    plot.getDomainAxis().setLabelFont(new Font("新宋体", 1, 12));
折线图
chart.getTitle().setFont(new Font("宋体", Font.BOLD, 15));
   chart.getLegend().setItemFont(new Font("黑体", Font.BOLD, 15));
   CategoryAxis domainAxis = plot.getDomainAxis();   
   /*------设置X轴坐标上的文字-----------*/ 
   domainAxis.setTickLabelFont(new Font("黑体", Font.PLAIN, 11));   
   /*------设置X轴的标题文字------------*/ 
   domainAxis.setLabelFont(new Font("宋体", Font.PLAIN, 12));   
   NumberAxis numberaxis = (NumberAxis) plot.getRangeAxis();   
   /*------设置Y轴坐标上的文字-----------*/ 
   numberaxis.setTickLabelFont(new Font("黑体", Font.PLAIN, 12));   
    
   /*------设置Y轴的标题文字------------*/ 
   numberaxis.setLabelFont(new Font("黑体", Font.PLAIN, 12)) 

方式一：

四舍五入
double   f   =   111231.5585;
BigDecimal   b   =   new   BigDecimal(f);
double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();
保留两位小数

方式二：

java.text.DecimalFormat   df   =new   java.text.DecimalFormat(”#.00″);
df.format(你要格式化的数字);

例：new java.text.DecimalFormat(”#.00″).format(3.1415926)

#.00 表示两位小数 #.0000四位小数 以此类推…

方式三：

double d = 3.1415926;

String result = String .format(”%.2f”);

%.2f %. 表示 小数点前任意位数   2 表示两位小数 格式后的结果为f 表示浮点型。

方式四：

此外如果使用struts标签做输出的话，有个format属性,设置为format="0.00"就是保留两位小数

例如：<bean:write name="entity" property="dkhAFSumPl"  format="0.00" />

　　import java.text.DateFormat;

　　import java.text.ParsePosition;

　　import java.text.SimpleDateFormat;

　　import java.util.Calendar;

　　import java.util.Date;

　　import java.util.GregorianCalendar;

　　public class TimeTest {

　　//用来全局控制上一周，本周，下一周的周数变化

　　private  int weeks = 0;

　　private int MaxDate;//一月最大天数

　　private int MaxYear;//一年最大天数

　　public static void main(String[] args) {

　　TimeTest tt = new TimeTest();

　　System.out.println("获取当天日期:"+tt.getNowTime("yyyy-MM-dd"));

　　System.out.println("获取本周一日期:"+tt.getMondayOFWeek());

　　System.out.println("获取本周日的日期~:"+tt.getCurrentWeekday());

　　System.out.println("获取上周一日期:"+tt.getPreviousWeekday());

　　System.out.println("获取上周日日期:"+tt.getPreviousWeekSunday());

　　System.out.println("获取下周一日期:"+tt.getNextMonday());

　　System.out.println("获取下周日日期:"+tt.getNextSunday());

　　System.out.println("获得相应周的周六的日期:"+tt.getNowTime("yyyy-MM-dd"));

　　System.out.println("获取本月第一天日期:"+tt.getFirstDayOfMonth());

　　System.out.println("获取本月最后一天日期:"+tt.getDefaultDay());

　　System.out.println("获取上月第一天日期:"+tt.getPreviousMonthFirst());

　　System.out.println("获取上月最后一天的日期:"+tt.getPreviousMonthEnd());

　　System.out.println("获取下月第一天日期:"+tt.getNextMonthFirst());

　　System.out.println("获取下月最后一天日期:"+tt.getNextMonthEnd());

　　System.out.println("获取本年的第一天日期:"+tt.getCurrentYearFirst());

　　System.out.println("获取本年最后一天日期:"+tt.getCurrentYearEnd());

　　System.out.println("获取去年的第一天日期:"+tt.getPreviousYearFirst());

　　System.out.println("获取去年的最后一天日期:"+tt.getPreviousYearEnd());

　　System.out.println("获取明年第一天日期:"+tt.getNextYearFirst());

　　System.out.println("获取明年最后一天日期:"+tt.getNextYearEnd());

　　System.out.println("获取本季度第一天到最后一天:"+tt.getThisSeasonTime(11));

　　System.out.println("获取两个日期之间间隔天数2008-12-1~2008-9.29:"+TimeTest.getTwoDay("2008-12-1","2008-9-29"));

　　}

　　public static String getTwoDay(String sj1, String sj2) {

　　SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");

　　long day = 0;

　　try {

　　java.util.Date date = myFormatter.parse(sj1);

　　java.util.Date mydate = myFormatter.parse(sj2);

　　day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);

　　} catch (Exception e) {

　　return "";

　　}

　　return day + "";

　　}

　　public static String getWeek(String sdate) {

　　// 再转换为时间

　　Date date = TimeTest.strToDate(sdate);

　　Calendar c = Calendar.getInstance();

　　c.setTime(date);

　　// int hour=c.get(Calendar.DAY_OF_WEEK);

　　// hour中存的就是星期几了，其范围 1~7

　　// 1=星期日 7=星期六，其他类推

　　return new SimpleDateFormat("EEEE").format(c.getTime());

　　}

　　public static Date strToDate(String strDate) {

　　SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");

　　ParsePosition pos = new ParsePosition(0);

　　Date strtodate = formatter.parse(strDate, pos);

　　return strtodate;

　　}

　　public static long getDays(String date1, String date2) {

　　if (date1 == null || date1.equals(""))

　　return 0;

　　if (date2 == null || date2.equals(""))

　　return 0;

　　// 转换为标准时间

　　SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");

　　java.util.Date date = null;

　　java.util.Date mydate = null;

　　try {

　　date = myFormatter.parse(date1);

　　mydate = myFormatter.parse(date2);

　　} catch (Exception e) {

　　}

　　long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);

　　return day;

　　}

　　// 计算当月最后一天,返回字符串

　　public String getDefaultDay(){

　　String str = "";

　　SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

　　Calendar lastDate = Calendar.getInstance();

　　lastDate.set(Calendar.DATE,1);//设为当前月的1号

　　lastDate.add(Calendar.MONTH,1);//加一个月，变为下月的1号

　　lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天

　　str=sdf.format(lastDate.getTime());

　　return str;

　　}

　　// 上月第一天

　　public String getPreviousMonthFirst(){

　　String str = "";

　　SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

　　Calendar lastDate = Calendar.getInstance();

　　lastDate.set(Calendar.DATE,1);//设为当前月的1号

　　lastDate.add(Calendar.MONTH,-1);//减一个月，变为下月的1号

　　//lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天

　　str=sdf.format(lastDate.getTime());

　　return str;

　　}

　　//获取当月第一天

　　public String getFirstDayOfMonth(){

　　String str = "";

　　SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

　　Calendar lastDate = Calendar.getInstance();

　　lastDate.set(Calendar.DATE,1);//设为当前月的1号

　　str=sdf.format(lastDate.getTime());

　　return str;

　　}

例如有个users表如下：

id         yhm             xm

1          001             小唐

2          002             小李

3          003             小张

select wm_concat(yhm) 用户名, wm_concat(xm) 姓名  from users

执行结果为：

用户名                 姓名

001,002,003      小唐,小李,小张