public static byte[] toByteArray(InputStream input) throws IOException {
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    byte[] buffer = new byte[4096];
    int n = 0;
    while (-1 != (n = input.read(buffer))) {
        output.write(buffer, 0, n);
    }
    return output.toByteArray();
}

下面是IOUtils中摘录出与toByteArray相关的方法

org.apache.commons.io.IOUtils.toByteArray

方法如下:
public static byte[] toByteArray(InputStream input)
  throws IOException
{
  ByteArrayOutputStream output = new ByteArrayOutputStream();
  copy(input, output);
  return output.toByteArray();
}

public static int copy(InputStream input, OutputStream output)
  throws IOException
{
  long count = copyLarge(input, output);
  if (count > 2147483647L) {
    return -1;
  }
  return (int)count;
}

public static long copyLarge(InputStream input, OutputStream output)
  throws IOException
{
  byte[] buffer = new byte[4096];
  long count = 0L;
  int n = 0;
  while (-1 != (n = input.read(buffer))) {
    output.write(buffer, 0, n);
    count += n;
  }
  return count;
}

文章详细出处：http://blog.csdn.net/zdwzzu2006/article/details/7745827

Tomcat6设置虚拟目录的方法, 不修改server.xml

在tomcat文件夹的conf"catalina"localhost(对于Tomcat6版本及其以上，需要自己创建catalina和localhost这两个文件夹)

增加project .xml文件（该文件名的project要和下面的“path=“/xxx"”的xxx相同）

文件内容:

<Context path="/project" reloadable="true" docBase="E:"javastudio"oob" workDir="E:"javastudio"oob"work" />

docBase是项目文件夹的web-inf文件夹的上一层目录
workDir是指Tomcat解析Jsp转换为Java文件，并编译为class存放的文件夹，设置在项目文件夹里面，可以避免移植到其他地方首次读取jsp文件需要重新解析 。一般格式：项目文件夹"work
reloadable是指可以重新加载，一般设置为true，方便使用，不需要经常重启Tomcat。
 

以后启动Tomcat，在浏览器输入http://localhost:8080/project就能访问
该项目的welcome文件。

转：TomCat 6.0虚拟目录配置！2008年03月09日 星期日 13:51之前在5.0下配置虚拟目录，我一般是采用在conf"server.xml中增加<Context .../>的方法，可是此法在6.0中失效(后经验证有效，可能是之前实验过程中有误)。按照tomcat 6.0启动之后的相关文档的说明http://localhost:8080/docs/config/context.html，尝试了一些方法：

-----------------------------tomcat6.0文档中关于Context的说明-------------------
You may define as many Context elements as you wish. Each such Context MUST have a unique context path. In addition, a Context must be present with a context path equal to a zero-length string. This Context becomes the default web application for this virtual host, and is used to process all requests that do not match any other Context's context path.

For Tomcat 6, unlike Tomcat 4.x, it is NOT recommended to place <Context> elements directly in the server.xml file. This is because it makes modifing the Context configuration more invasive since the main conf/server.xml file cannot be reloaded without restarting Tomcat.

Context elements may be explicitly defined:

in the $CATALINA_HOME/conf/context.xml file: the Context element information will be loaded by all webapps
in the $CATALINA_HOME/conf/[enginename]/[hostname]/context.xml.default file: the Context element information will be loaded by all webapps of that host
in individual files (with a ".xml" extension) in the $CATALINA_HOME/conf/[enginename]/[hostname]/ directory. The name of the file (less the .xml) extension will be used as the context path. Multi-level context paths may be defined using #, e.g. context#path.xml. The default web application may be defined by using a file called ROOT.xml.
if the previous file was not found for this application, in an individual file at /META-INF/context.xml inside the application files
inside a Host element in the main conf/server.xml
-------------------------------------------------------------------------------

逐一验证，方法1，2均无效，成功的有以下2种：(下文用%tomcat%表示Tomcat6.0的安装目录，希望在浏览器中通过http://localhost:8080/abc/default.jsp 来访问d:"myJsp"default.jsp)

方法一：(文档中说不建议使用)

找到%tomcat%"conf"server.xml，在</Host>之前加入：
<Context docBase="d:"myJsp" path="/abc" />
保存文件之后，重启Tomcat即可。注意：大小写不能错! 斜杆"/"或"""的方向别搞错。

方法二：该方法推荐使用，比较简单。

在%tomcat%"conf"Catalina"locahost(该目录可能需要手工创建)下新建一个文件abc.xml，注意文件名中的abc就表示虚拟目录的名称，所以不可随意命名，该文件的内容为:
<Context docBase="d:"myJsp" />
重启Tomcat即可。

-------------------------------------------------------------------------------------------
其它设置：当url中未明确指定文件名时，是否列出相关目录下所有文件的开关设置：

打开 %tomcat%"conf"web.xml 文件，找到:
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
把false改成true即可。

-------------------------------------------------------------------------------------------
其他人的同类经验：http://fengzhiyu-sh.javaeye.com/blog/153506 经验证无需设置文中的web application下的web.xml文件。

阅读

下载的windows版本是redis-2.0.2，解压到D盘下：

D:\redis-2.0.2

进到该目录下，有下列文件：

　redis-server.exe：服务程序

启动Redis服务（conf文件指定配置文件，若不指定则默认）：

D:\redis-2.0.2>redis-server.exe redis.conf

启动cmd窗口要一直开着，关闭后则Redis服务关闭。

这时服务开启着，另外开一个窗口进行，设置客户端：

D:\redis-2.0.2>redis-cli.exe -h 202.117.16.133 -p 6379

然后可以开始玩了：

--------------------------------------------------------------------------------------------------------------------------------

Redis提供了多种语言的客户端，包括Java，C++，python。

Redis官网上推荐的Java包是Jedis，去下载Jedis，在Java项目中导入Jedis包，开始发现有错误，是因为缺少org.apache.commons这个包，

去网上找此包，下载导入后，Jedis就没有错误了。

可以开始了，用Jedis来操作Redis：

package test;

import redis.clients.jedis.Jedis;

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Jedis jj = new  Jedis("localhost");
        jj.set("key1", "I am value 1");
        String ss = jj.get("key1");
        System.out.println(ss);
    }
    
}

文章详细参考：

StringBuffer url = request.getRequestURL();
String tempContextUrl = url.delete(url.length() - request.getRequestURI().length(), url.length()).append("/").toString();

StringBuffer url = request.getRequestURL();  

String tempContextUrl = url.delete(url.length() - request.getRequestURI().length(), url.length()).append(request.getServletContext().getContextPath()).append("/").toString();  

文章详细参考：http://f0rb.iteye.com/blog/1253746

当数据库连接池中的连接被创建而长时间不使用的情况下，该连接会自动回收并失效，但客户端并不知道，在进行数据库操作时仍然使用的是无效的数据库连接，这样，就导致客户端程序报“ java.sql.SQLException: Io 异常: Connection reset” 或“java.sql.SQLException 关闭的连接”异常。

解决办法：客户端在使用一个无效的连接时会先对该连接进行测试，如果发现该连接已经无效，则重新从连接池获取有效数据库连接来使用。

在tomcat的context.xml里面设置数据源时候可参考：

 <Resource auth="Container"
  driverClassName="oracle.jdbc.OracleDriver"
  type="javax.sql.DataSource"
  url="jdbc:oracle:thin:@11.11.11.45:1521:orcl"
  name="jdbc/login"
  username="login"
  password="login"
  maxActive="15"
  maxIdle="10"
  maxWait="-1"
  minIdle="2"
  removeAbandonedTimeout="5"
  testOnBorrow="true"
  testWhileIdle="true"
  testOnReturn="true"
  removeAbandoned="true"
  logAbandoned="true"
  validationQuery="select 1 from dual"
 /> 
 
 
参考：http://www.cnblogs.com/younes/archive/2012/06/01/2529483.html

DBCP数据库连接失效的解决方法(Io 异常：Connection reset)

参考：http://hi.baidu.com/dobodo/item/7d95e3384d181cc4392ffab5



Tomcat Resource可配置的属性

1) 算法的独立性和可靠性。

2) 实现的独立性和相互作用性。

算法的独立性是通过定义密码服务类来获得。用户只需了解密码算法的概念,而不用去关心如何实现这些概念。实现的独立性和相互作用性通过密码服务提供器来实现。密码服务提供器是实现一个或多个密码服务的一个或多个程序包。软件开发商根据一定接口,将各种算法实现后,打包成一个提供器,用户可以安装不同的提供器。安装和配置提供器,可将包含提供器的ZIP和JAR文件放在CLASSPATH下,再编辑Java安全属性文件来设置定义一个提供器。

DES算法及如何利用DES算法加密和解密类文件的步骤：

DES算法简介
DES（Data Encryption Standard）是发明最早的最广泛使用的分组对称加密算法。DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字节共64位，是DES算法的工作密钥；Data也为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密。

package com.afreon.util;

import java.io.IOException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class DesUtil {

    private final static String DES = "DES";

    public static void main(String[] args) throws Exception {
        String data = "123 456";
        String key = "wang!@#$%";
        System.err.println(encrypt(data, key));
        System.err.println(decrypt(encrypt(data, key), key));

    }
    
    /** *//**
     * Description 根据键值进行加密
     * @param data 
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    public static String encrypt(String data, String key) throws Exception {
        byte[] bt = encrypt(data.getBytes(), key.getBytes());
        String strs = new BASE64Encoder().encode(bt);
        return strs;
    }

    /** *//**
     * Description 根据键值进行解密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws IOException
     * @throws Exception
     */
    public static String decrypt(String data, String key) throws IOException,
            Exception {
        if (data == null)
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        byte[] buf = decoder.decodeBuffer(data);
        byte[] bt = decrypt(buf,key.getBytes());
        return new String(bt);
    }

    /** *//**
     * Description 根据键值进行加密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }
    
    
    /** *//**
     * Description 根据键值进行解密
     * @param data
     * @param key  加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }
}

我使用sun.net.ftp来连接linux的vsftp时，出现如下的异常（在windows下是没有的）

java.io.FileNotFoundException: PORT 192,168,0,80,9,205: 550 Permission denied.

at sun.net.ftp.FtpClient.readReply(FtpClient.java:236)

at sun.net.ftp.FtpClient.issueCommand(FtpClient.java:193)

at sun.net.ftp.FtpClient.openDataConnection(FtpClient.java:434)

at sun.net.ftp.FtpClient.put(FtpClient.java:594)

at org.lab24.util.FtpTool.processfile(FtpTool.java:193)

at org.lab24.util.FtpTool.upload(FtpTool.java:116)

at org.lab24.spider.Spider.run(Spider.java:55)

at EDU.oswego.cs.dl.util.concurrent.PooledExecutor$Worker.run(PooledExecutor.java:743)

at java.lang.Thread.run(Thread.java:619)

exception e in ftp upload(): java.io.FileNotFoundException: PORT 192,168,0,80,9,205: 550 Permission denied.

后来查过网上的解决方案，才知道：

该类默认使用的是Port模式传输数据，但实际上Linux配的是Pasv模式，所以传不过去，修改办法：

ftpclient.sendServer("quote PASV");

精度的问题！用基本类型的double类型进行运算可能会丢失精度。而且特别大的数又没法处理。所以如果用BigDecimal这个类问题就解决了。这个类在java.Math包下。它可以处理任意精度的数据。对于楼主出现的问题，我从新写了段代码，供楼主参考。但是主要是还得查看API！代码如下：

import java.math.*;

public class oopp

{

 public static void main(String[] args)

 {

  String a="1467000000";

  double aa=Double.parseDouble(a);

  BigDecimal beichushu=new BigDecimal(aa);

  BigDecimal chushu=new BigDecimal(100000000);

  BigDecimal result=beichushu.divide(chushu,new MathContext(4));//MathConText(4)表示结果精确4位！

  boolean isTrue=String.valueOf(result).equals("14.67");

  System.out.println("1467000000除以100000000="+result);

  System.out.println(result+"与14.67比较的结果是"+isTrue);

 }

}

有时Tomcat的启动窗口一闪而过，根本就看不出启动过程中发生了什么错误。这中间的原因有好多种，最常见的解决办法就是使用run命令，打开startup.bat文件，找到下面这行：

call "%EXECUTABLE%" start %CMD_LINE_ARGS%

修改为：

call "%EXECUTABLE%" run %CMD_LINE_ARGS%

这样，Tomcat启动时就不会弹出新窗口，就可以从容不迫地观察这的启动错误了。

修改文件后：需要从DOS命令行窗口进入到%TOMCAT_HOME%\bin路径下，然后启动startup.bat文件。

   Calendar calendar=Calendar.getInstance();  
   calendar.setTime(new Date());
   System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//今天的日期
   calendar.set(Calendar.DAY_OF_MONTH,calendar.get(Calendar.DAY_OF_MONTH)+1);//让日期加1  
   System.out.println(calendar.get(Calendar.DATE));//加1之后的日期Top
===============================================================================

2.用java.text.SimpleDateFormat和java.util.Date来实现
          
    Date d=new Date();  
   SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");  
   System.out.println("今天的日期："+df.format(d));  
   System.out.println("两天前的日期：" + df.format(new Date(d.getTime() - 2 * 24 * 60 * 60 * 1000)));  
   System.out.println("三天后的日期：" + df.format(new Date(d.getTime() + 3 * 24 * 60 * 60 * 1000)));

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

GregorianCalendar gc=new GregorianCalendar();
gc.setTime(new Date);
gc.add(field,value);
value为正则往后,为负则往前
field取1加1年,取2加半年,取3加一季度,取4加一周
取5加一天....

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

/*
*java中对日期的加减操作
*gc.add(1,-1)表示年份减一.
*gc.add(2,-1)表示月份减一.
*gc.add(3.-1)表示周减一.
*gc.add(5,-1)表示天减一.
*以此类推应该可以精确的毫秒吧.没有再试.大家可以试试.
*GregorianCalendar类的add(int field,int amount)方法表示年月日加减.
*field参数表示年,月.日等.
*amount参数表示要加减的数量.
*
* UseDate.java 测试如下:
*/
package temp.util;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.text.SimpleDateFormat;
public class UseDate {

Date d=new Date();
GregorianCalendar gc =new GregorianCalendar();
SimpleDateFormat sf  =new SimpleDateFormat("yyyy-MM-dd");

public String getYears()
{
gc.setTime(d);
gc.add(1,+1);
gc.set(gc.get(Calendar.YEAR),gc.get(Calendar.MONTH),gc.get(Calendar.DATE));

return sf.format(gc.getTime());
}

public String getHalfYear()
{
gc.setTime(d);
gc.add(2,+6);
gc.set(gc.get(Calendar.YEAR),gc.get(Calendar.MONTH),gc.get(Calendar.DATE));

return sf.format(gc.getTime());
}
public String getQuarters()
{
gc.setTime(d);
gc.add(2,+3);
gc.set(gc.get(Calendar.YEAR),gc.get(Calendar.MONTH),gc.get(Calendar.DATE));

return sf.format(gc.getTime());
}

public String getLocalDate()
{
return sf.format(d);
}

public static  void  main(String[] args)
{
UseDate ud= new UseDate();
System.out.println(ud.getLocalDate());
System.out.println(ud.getYears());
System.out.println(ud.getHalfYear());
System.out.println(ud.getQuarters());
}

}
    //当月第一天和最后一天

     SimpleDateFormat sf  =new SimpleDateFormat("yyyyMMdd");
     Calendar a=Calendar.getInstance();
     int MaxDate=a.get(Calendar.DATE);
     System.out.println("该月最大天数:"+MaxDate+","+sf.format(a.getTime()));
     a.set(Calendar.DATE, 1);//把日期设置为当月第一天 
     System.out.println("当月第一天:"+sf.format(a.getTime())); 
     a.roll(Calendar.DATE, -1);//日期回滚一天，也就是最后一天

     System.out.println("当月最后一天:"+sf.format(a.getTime())); 

4 ,

GregorianCalendar gc=new GregorianCalendar();
       
        try {
            gc.setTime( new SimpleDateFormat("yyyyMM").parse("200901"));
            gc.add(2, -Integer.parseInt("7"));
        } catch (ParseException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        }
        System.out.println(new SimpleDateFormat("yyyyMM").format(gc.getTime()));

运行结果：200806

  $(function(){
   //alert('${tip}');
   if('${tip}'!=''){
    $('#tip').css('display','inline-block');
   }
  });
 
  var zTreeObj;
  var allSelectedId="";
  var allSelectedName = "";
  var zNodes = ${data};
  var setting = {
   isSimpleData: true,
   treeNodeKey: "id",         //设置节点唯一标识属性名称
   treeNodeParentKey: "pId",  //设置节点的父节点唯一标识属性名称
   nameCol: "name",           //设置 zTree 显示节点名称的属性名称,此处默认为Name
   showLine: true,            //在树型中是否显示线条样式
   
   check: {
    enable: true,
    chkStyle: "<%=type%>",
    chkboxType: <%=chkboxType%>,
    radioType: "all"
   },
   callback: {
    onClick: onClick
   },
   data: {
    simpleData: {
     enable: true
    }
   }
  };
   
  $(function(){
   $("#btnClose").bind("click",doClose);
   $("#btnConfirm").bind("click",doConfirm);
   zTreeObj = $("#tree").zTree(setting,zNodes);
  });
  
  //关闭窗口
  function doClose(){
   window.close();
  }
   
  function doConfirm(){
   var checkedNodes = zTreeObj.getCheckedNodes(true);
   alert(checkedNodes);
   for (i=0;i<checkedNodes.length;i++) {
   
    var treeNode = checkedNodes[i];
    alert(treeNode.id);
     if(!treeNode.open){
      allSelectedId += (allSelectedId == "" ? "" : ",") + treeNode.id;
      allSelectedName += (allSelectedName == "" ? "" : ",") + treeNode.name;      
     }
    }
   $('#hiddenId').val(allSelectedId);
   $('#hiddenName').val(allSelectedName);
  }
  
  function showMenu() {
   var deptname = $("#deptname");
   var offset = deptname.offset();
   $("#menu").width(deptname.width())
   .css({left:offset.left + "px", top:offset.top + deptname.outerHeight() + "px"})
   .slideDown("fast");
  }
  
  function hideMenu() {
   $("#menu").fadeOut("fast");
  }
  
  function onClick(e, treeId, treeNode) {
   alert(treeId);
   if(treeNode.checked){
    hideMenu();
   }else{
    zTreeObj.checkNode(treeNode, true, null, true);
   }
   return false;
  }
  
  function onCheck(e, treeId, treeNode){
   alert(treeNode.id);
   allSelectedId += (allSelectedId == "" ? "" : ",") + treeNode.pId+"|"+treeNode.id+"|"+treeNode.name;
  }
 </script>

java代码：

       
程序员天生都是内聚的高手，违反高内聚的反而是那些有一定水平的程序员，可能是误用了设计模式，可能是考虑问题过分全面，把一个功能单一的类分割成多个类。这里重点说低耦合，耦合就是类之间的互相调用关系，如果耦合很强，互相牵扯调用很多，那么会牵一发而动全身，不利于维护和扩展。什么方法、数据、不加分析地往一个类里整，甚至时一个类的所有数据成员设成public，方便在其它类里直接修改数据。生活中很多“低耦合”的例子，如床与床单，如果是紧耦合的话，换床单时，也要换床。再如桌子与抽屉。

      
图中的上半部分中，把一个软件模块抽象成线条，软件模块互相依赖，这是一种面向过程的开发方式，如果软件是不改变的，那么这种高耦合度的结构也无可厚非，有时象底层软件如操作系统等，一切以执行效率优先，而且需求并不改变频繁的情况下，是适用的。但在实际开发过程中，软件需求的变化是导致这种模式被否定的真正原因。一旦有一个模块改变，那么需要改动到其它好几个模块，而且更要命的时，被影响的模块又会影响其它模块，或者干脆又把影响力传递给当初最先改动的模块。

       
下图中的模块结构通过梳理，使他们依附于一条粗线条，它是主逻辑模块，是相对稳定的高层的、抽象的模块。而其它通过一个小空心圆点（表示接口）与粗线条进行连接的小短线条代表次模块，它被分成两个部分，接口和实现接口的子类对象，它们通过接口与主逻辑模块形成依赖。相对来说，次模块变化较快，而主模块变化较慢。刚才提到的生活例子中，床相对于床单来说是主要的，核心的，成本较高的，它的使用年限是10年，而床单使用年限是2年，就是说床的模块变化速度慢于床单的变化速度，如果床2个月变一次，那么逻辑结构就混乱了。床为床单提供了一个尺寸接口，床单只要符合这个接口，就可以组合使用。那么这个接口就必须是相对稳定的。

      
设计模式做为软件开发过程中一种创造性的总结思维，使软件开发人员，在开发软件产品时，有了更加明确的软件解耦的思路，设计模式来源于生活，却指导于软件。事实上，短期来看，要求低耦合并没有很明显的好处，因为利用设计模式来解决问题是需要软件开发的智力和时间成本的。况且引入了误用设计模式的风险，所以短期内使用设计模式来解耦反而会影响系统的开发进度。低耦合的好处是长期回报的，体现在系统持续发展的过程中，系统具有更好的重用性，维护性，扩展性，持续的支持业务的发展，而不会成为业务发展的障碍。