2005年12月14日

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest) request;

        int length = req.getContentLength();
        if (length > 0) {
            BufferedRequestWrapper bufferedRequest = new BufferedRequestWrapper(req,length);

            InputStream is = bufferedRequest.getInputStream();
            byte[] content = new byte[length];
           
            int pad = 0;
            while(pad < length){
                pad += is.read(content, pad, length);
            }

            request = bufferedRequest;
        }
        chain.doFilter(request, response);      
    }


BufferedRequestWrapper .java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

public class BufferedRequestWrapper extends HttpServletRequestWrapper {

    ByteArrayInputStream bais;

    BufferedServletInputStream bsis;

    byte[] buffer;

    public BufferedRequestWrapper(HttpServletRequest req,int length) throws IOException {
        super(req);
        // Read InputStream and store its content in a buffer.
        InputStream is = req.getInputStream();
        buffer = new byte[length];

        int pad = 0;
        while(pad < length){
            pad += is.read(buffer, pad, length);
        }
    }

    public ServletInputStream getInputStream() {
        try {
            // Generate a new InputStream by stored buffer
            bais = new ByteArrayInputStream(buffer);
            // Istantiate a subclass of ServletInputStream
            // (Only ServletInputStream or subclasses of it are accepted by the
            // servlet engine!)
            bsis = new BufferedServletInputStream(bais);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
        }
        return bsis;
    }

}




BufferedServletInputStream .java

import java.io.*;
import javax.servlet.ServletInputStream;

/*
 Subclass of ServletInputStream needed by the servlet engine.
 All inputStream methods are wrapped and are delegated to
 the ByteArrayInputStream (obtained as constructor parameter)!
 */
public class BufferedServletInputStream extends ServletInputStream {

    ByteArrayInputStream bais;

    public BufferedServletInputStream(ByteArrayInputStream bais) {
        this.bais = bais;
    }

    public int available() {
        return bais.available();
    }

    public int read() {
        return bais.read();
    }

    public int read(byte[] buf, int off, int len) {
        return bais.read(buf, off, len);
    }

}

有发送人名称中文支持，支持bytes格式附件，附件中文支持

  public static boolean send(String fromName, String fromAddr, String to, String subject, String
                             body, String fileName, byte[] file) throws
      Exception {
        //发送人名称，用base64编码，再加上特殊标志
        fromName = "=?GB2312?B?" + new String(base64.encode((fromName).getBytes()))  + "?=";
    Properties props = new Properties();
    Session session = Session.getInstance(props, null);
    props.put("mail.smtp.host", Constants.mailhost);
    props.put("mail.smtp.auth", "false"); 
    Message msg = new MimeMessage(session);
      msg.setFrom(new InternetAddress(fromAddr,fromName));
//后面的BodyPart将加入到此处创建的Multipart中
    Multipart mp = new MimeMultipart();
// Create the message part
    BodyPart messageBodyPart = new MimeBodyPart();

    // Fill the message
    messageBodyPart.setText(body);

    mp.addBodyPart(messageBodyPart);

      /*发送附件*/
     if (file != null && file.length > 0) {
       //利用枚举器方便的遍历集合
         MimeBodyPart mbp = new MimeBodyPart(); 
//         File fileTmp = null;
         //得到数据源
//         FileDataSource fds = new FileDataSource(fileTmp);
         //得到附件本身并至入BodyPart
         mbp.setDataHandler(new DataHandler(new ByteArrayDataSource(file,"application/octet-stream")));
         //得到文件名同样至入BodyPart
         mbp.setFileName(MimeUtility.encodeWord(fileName,"GB2312",null));
         mp.addBodyPart(mbp);
     }
   
    //Multipart加入到信件
    msg.setContent(mp);

    msg.setRecipient(Message.RecipientType.TO, new InternetAddress(to));
    msg.setSubject(subject);

    msg.setHeader("X-Mailer", "personal Email Sender");
    msg.setSentDate(new Date());

    Transport transport = session.getTransport("smtp");

    //添加认证信息
    transport.connect(Constants.mailhost, Constants.user, Constants.pwd);
    transport.sendMessage(msg, msg.getRecipients(Message.RecipientType.TO));
    transport.close();
    return true;
  }

import java.io.*;
import javax.activation.*;

public class ByteArrayDataSource implements DataSource {
    /** * Data to write. */
    private byte[] _data;

    /** * Content-Type. */
    private String _type;

    /* Create a datasource from an input stream */
    public ByteArrayDataSource(InputStream is, String type) {
        _type = type;
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            int ch;

            // XXX : must be made more efficient by
            // doing buffered reads, rather than one byte reads
            while ((ch = is.read()) != -1)
                os.write(ch);
            _data = os.toByteArray();
        } catch (IOException ioe) {
        }
    }

    /* Create a datasource from a byte array */
    public ByteArrayDataSource(byte[] data, String type) {
        _data = data;
        _type = type;
    }

    /* Create a datasource from a String */
    public ByteArrayDataSource(String data, String type) {
        try {
            // Assumption that the string contains only ascii
            // characters ! Else just pass in a charset into this
            // constructor and use it in getBytes()
            _data = data.getBytes("iso-8859-1");
        } catch (UnsupportedEncodingException uee) {
        }
        _type = type;
    }

    public InputStream getInputStream() throws IOException {
        if (_data == null)
            throw new IOException("no data");
        return new ByteArrayInputStream(_data);
    }

    public OutputStream getOutputStream() throws IOException {
        throw new IOException("cannot do this");
    }

    public String getContentType() {
        return _type;
    }

    public String getName() {
        return "dummy";
    }
}

C++字符串完全指南 - Win32字符编码（一）

前言

字符串的表现形式各异，象TCHAR，std::string，BSTR等等，有时还会见到怪怪的用_tcs起头的宏。这个指南的目的就是说明各种字符串类型及其用途，并说明如何在必要时进行类型的相互转换。

在指南的第一部分，介绍三种字符编码格式。理解编码的工作原理是致为重要的。即使你已经知道字符串是一个字符的数组这样的概念，也请阅读本文，它会让你明白各种字符串类之间的关系。

指南的第二部分，将阐述各个字符串类，什么时候使用哪种字符串类，及其相互转换。

字符串基础 - ASCII, DBCS, Unicode

所有的字符串类都起源于C语言的字符串，而C语言字符串则是字符的数组。首先了解一下字符类型。有三种编码方式和三种字符类型。

第一种编码方式是单字节字符集，称之为SBCS，它的所有字符都只有一个字节的长度。ASCII码就是SBCS。SBCS字符串由一个零字节结尾。

第二种编码方式是多字节字符集，称之为MBCS，它包含的字符中有单字节长的字符，也有多字节长的字符。Windows用到的MBCS只有二种字符类型，单字节字符和双字节字符。因此Windows中用得最多的字符是双字节字符集，即DBCS，通常用它来代替MBCS。

在DBCS编码中，用一些保留值来指明该字符属于双字节字符。例如，Shift-JIS(通用日语)编码中，值0x81-0x9F 和 0xE0-0xFC 的意思是：“这是一个双字节字符，下一个字节是这个字符的一部分”。这样的值通常称为前导字节(lead byte)，总是大于0x7F。前导字节后面是跟随字节(trail byte)。DBCS的跟随字节可以是任何非零值。与SBCS一样，DBCS字符串也由一个零字节结尾。

第三种编码方式是Unicode。Unicode编码标准中的所有字符都是双字节长。有时也将Unicode称为宽字符集(wide characters)，因为它的字符比单字节字符更宽(使用更多内存)。注意，Unicode不是MBCS - 区别在于MBCS编码中的字符长度是不同的。Unicode字符串用二个零字节字符结尾(一个宽字符的零值编码)。

单字节字符集是拉丁字母，重音文字，用ASCII标准定义，用于DOS操作系统。双字节字符集用于东亚和中东语言。Unicode用于COM和Windows NT内部。

读者都很熟悉单字节字符集，它的数据类型是char。双字节字符集也使用char数据类型(双字节字符集中的许多古怪处之一)。Unicode字符集用wchar_t数据类型。Unicode字符串用L前缀起头，如：

  wchar_t  wch = L'1';      // 2 个字节, 0x0031

  wchar_t* wsz = L"Hello";  // 12 个字节, 6 个宽字符

字符串的存储

单字节字符串顺序存放各个字符，并用零字节表示字符串结尾。例如，字符串"Bob"的存储格式为：

Unicode编码中，L"Bob"的存储格式为：

用0x0000 (Unicode的零编码)结束字符串。

DBCS 看上去有点象SBCS。以后我们会看到在串处理和指针使用上是有微妙差别的。字符串"日本语" (nihongo) 的存储格式如下(用LB和TB分别表示前导字节和跟随字节)：

注意，"ni"的值不是WORD值0xFA93。值93和FA顺序组合编码为字符"ni"。(在高位优先CPU中，存放顺序正如上所述)。

字符串处理函数

C语言字符串处理函数，如strcpy(), sprintf(), atol()等只能用于单字节字符串。在标准库中有只用于Unicode字符串的函数，如wcscpy(), swprintf(), _wtol()。

微软在C运行库(CRT)中加入了对DBCS字符串的支持。对应于strxxx()函数，DBCS使用_mbsxxx()函数。在处理DBCS字符串(如日语，中文，或其它DBCS)时，就要用_mbsxxx()函数。这些函数也能用于处理SBCS字符串(因为DBCS字符串可能就只含有单字节字符)。

现在用一个示例来说明字符串处理函数的不同。如有Unicode字符串L"Bob"：

x86 CPU的排列顺序是低位优先(little-endian)的，值0x0042的存储顺序为42 00。这时如用strlen()函数求字符串的长度就发生问题。函数找到第一个字节42，然后是00，意味着字符串结尾，于是返回1。反之，用wcslen()函数求"Bob"的长度更糟糕。wcslen()首先找到0x6F42，然后是0x0062，以后就在内存缓冲内不断地寻找00 00直至发生一般性保护错(GPF)。

strxxx()及其对应的_mbsxxx()究竟是如何运作的？二者之间的不同是非常重要的，直接影响到正确遍历DBCS字符串的方法。下面先介绍字符串遍历，然后再回来讨论strxxx()和 _mbsxxx()。

字符串遍历

我们中的大多数人都是从SBCS成长过来的，都习惯于用指针的 ++ 和 -- 操作符来遍历字符串，有时也使用数组来处理字符串中的字符。这二种方法对于SBCS 和 Unicode 字符串的操作都是正确无误的，因为二者的字符都是等长的，编译器能够的正确返回我们寻求的字符位置。

但对于DBCS字符串就不能这样了。用指针访问DBCS字符串有二个原则，打破这二个原则就会造成错误。

1. 不可使用 ++ 算子，除非每次都检查是否为前导字节。

2. 绝不可使用 -- 算子来向后遍历。

先说明原则2，因为很容易找到一个非人为的示例。假设，有一个配制文件，程序启动时要从安装路径读取该文件，如：C:\Program Files\MyCoolApp\config.bin。文件本身是正常的。

假设用以下代码来配制文件名：

bool GetConfigFileName ( char* pszName, size_t nBuffSize )

{

char szConfigFilename[MAX_PATH];

    // 这里从注册表读取文件的安装路径，假设一切正常。

    // 如果路径末尾没有反斜线，就加上反斜线。

    // 首先，用指针指向结尾零：

char* pLastChar = strchr ( szConfigFilename, '\0' );

    // 然后向后退一个字符：

    pLastChar--;  

    if ( *pLastChar != '\\' )

        strcat ( szConfigFilename, "\\" );

    // 加上文件名：

    strcat ( szConfigFilename, "config.bin" );

    // 如果字符串长度足够，返回文件名：

    if ( strlen ( szConfigFilename ) >= nBuffSize )

        return false;

    else

        {

        strcpy ( pszName, szConfigFilename );

        return true;

        }

}

这段代码的保护性是很强的，但用到DBCS字符串还是会出错。假如文件的安装路径用日语表达：C:\ヨウユソ，该字符串的内存表达为：

这时用上面的GetConfigFileName()函数来检查文件路径末尾是否含有反斜线就会出错，得到错误的文件名。

错在哪里？注意上面的二个十六进制值0x5C(蓝色)。前面的0x5C是字符"\"，后面则是字符值83 5C，代表字符"ソ"。可是函数把它误认为反斜线了。

正确的方法是用DBCS函数将指针指向恰当的字符位置，如下所示：

bool FixedGetConfigFileName ( char* pszName, size_t nBuffSize )

{

char szConfigFilename[MAX_PATH];

    // 这里从注册表读取文件的安装路径，假设一切正常。

    // 如果路径末尾没有反斜线，就加上反斜线。

    // 首先，用指针指向结尾零：

char* pLastChar = _mbschr ( szConfigFilename, '\0' );

    // 然后向后退一个双字节字符：

    pLastChar = CharPrev ( szConfigFilename, pLastChar );

    if ( *pLastChar != '\\' )

        _mbscat ( szConfigFilename, "\\" );

    // 加上文件名：

    _mbscat ( szConfigFilename, "config.bin" );

    // 如果字符串长度足够，返回文件名：

    if ( _mbslen ( szInstallDir ) >= nBuffSize )

        return false;

    else

        {

        _mbscpy ( pszName, szConfigFilename );

        return true;

        }

} 

这个改进的函数用CharPrev() API 函数将指针pLastChar向后移动一个字符。如果字符串末尾的字符是双字节字符，就向后移动2个字节。这时返回的结果是正确的，因为不会将字符误判为反斜线。

现在可以想像到第一原则了。例如，要遍历字符串寻找字符":"，如果不使用CharNext()函数而使用++算子，当跟随字节值恰好也是":"时就会出错。

与原则2相关的是数组下标的使用：

　2a. 绝不可在字符串数组中使用递减下标。

出错原因与原则2相同。例如，设置指针pLastChar为：

char* pLastChar = &szConfigFilename [strlen(szConfigFilename) - 1];

结果与原则2的出错一样。下标减1就是指针向后移动一个字节，不符原则2。

再谈strxxx() 与_mbsxxx()

现在可以清楚为什么要用 _mbsxxx() 函数了。strxxx() 函数不认识DBCS字符而 _mbsxxx()认识。如果调用strrchr("C:\\", '\\')函数可能会出错，但 _mbsrchr()认识双字节字符，所以能返回指向最后出现反斜线字符的指针位置。

最后提一下strxxx() 和 _mbsxxx() 函数族中的字符串长度测量函数，它们都返回字符串的字节数。如果字符串含有3个双字节字符，_mbslen()将返回6。而Unicode的函数返回的是wchar_ts的数量，如wcslen(L"Bob") 返回3

C++字符串完全指南 - Win32字符编码（二）
翻译：连波
15/11/2002
URL: http://www.zdnet.com.cn/developer/tech/story/0,2000081602,39098306,00.htm

BOOL WINAPI SetWindowTextA ( HWND hWnd, LPCSTR lpString );

BOOL WINAPI SetWindowTextW ( HWND hWnd, LPCWSTR lpString );

#ifdef UNICODE

　#define SetWindowText  SetWindowTextW

#else

　#define SetWindowText  SetWindowTextA

#endif

#define SetWindowText  SetWindowTextA

HWND hwnd = GetSomeWindowHandle();

char szNewText[] = "we love Bob!";

SetWindowText ( hwnd, szNewText );

HWND hwnd = GetSomeWindowHandle();

char szNewText[] = "we love Bob!";

SetWindowTextW ( hwnd, szNewText );

HWND hwnd = GetSomeWindowHandle();

#ifdef UNICODE

　wchar_t szNewText[] = L"we love Bob!";

#else

　char szNewText[] = "we love Bob!";

#endif

SetWindowText ( hwnd, szNewText );

#ifdef UNICODE

　typedef wchar_t TCHAR;

#else

　typedef char TCHAR;

#endif

#ifdef UNICODE

　#define _T(x) L##x

#else

　#define _T(x) x

#endif

TCHAR szNewText[] = _T("we love Bob!");

1. 程序只运行于Windows NT。
2. 处理的字符串长于MAX_PATH定义的字符数。
3. 程序用于Windows XP中的新接口，那里没有A/W版本之分。

void SomeFunc ( LPCWSTR widestr );
main()
{
  SomeFunc ( (LPCWSTR) "C:\\foo.txt" );  // 错！
}

typedef OLECHAR* BSTR;

BSTR bstr = NULL;
bstr = SysAllocString ( L"Hi Bob!" );
if ( NULL == bstr )
    // 内存溢出
   // 这里使用bstr
SysFreeString ( bstr );

 // 构造
_bstr_t bs1 = "char string";        // 从LPCSTR构造 
_bstr_t bs2 = L"wide char string"; // 从LPCWSTR构造
_bstr_t bs3 = bs1;              // 拷贝另一个 _bstr_t
_variant_t v = "Bob";
_bstr_t bs4 = v;              // 从一个含有字符串的 _variant_t 构造
// 数据萃取
LPCSTR psz1 = bs1;              // 自动转换到MBCS字符串
LPCSTR psz2 = (LPCSTR) bs1;     // cast OK, 同上
LPCWSTR pwsz1 = bs1;            // 返回内部的Unicode字符串
LPCWSTR pwsz2 = (LPCWSTR) bs1;  // cast OK, 同上
BSTR    bstr = bs1.copy();      // 拷贝bs1, 返回BSTR
// ...
  SysFreeString ( bstr );

// 构造
_variant_t v1 = "char string"; // 从LPCSTR 构造
_variant_t v2 = L"wide char string"; // 从LPCWSTR 构造
_bstr_t bs1 = "Bob";
_variant_t v3 = bs1; // 拷贝一个 _bstr_t 对象
// 数据萃取
_bstr_t bs2 = v1; // 从VARIANT中提取BSTR
_bstr_t bs3 = (_bstr_t) v1; // cast OK, 同上

// 特例化
typedef basic_string tstring; // TCHAR字符串
// 构造
string str = "char string"; // 从LPCSTR构造
wstring wstr = L"wide char string"; // 从LPCWSTR构造
tstring tstr = _T("TCHAR string"); // 从LPCTSTR构造
// 数据萃取
LPCSTR psz = str.c_str(); // 指向str缓冲区的只读指针
LPCWSTR pwsz = wstr.c_str(); // 指向wstr缓冲区的只读指针
LPCTSTR ptsz = tstr.c_str(); // 指向tstr缓冲区的只读指针

// 从basic_string构造_bstr_t 
_bstr_t bs1 = str.c_str();  // 从LPCSTR构造 _bstr_t
_bstr_t bs2 = wstr.c_str(); // 从LPCWSTR构造 _bstr_t

// 简单接口
struct IStuff : public IUnknown
{
  // 略去COM程序...
  STDMETHOD(SetText)(BSTR bsText);
  STDMETHOD(GetText)(BSTR* pbsText);
};

CComBSTR bs1;
CComBSTR bs2 = "new text";
pStuff->GetText ( &bs1 );       // ok, 取得内部BSTR地址
  pStuff->SetText ( bs2 );        // ok, 调用BSTR转换
  pStuff->SetText ( (BSTR) bs2 ); // cast ok, 同上

// 构造
CComBSTR bs1 = "char string"; // 从LPCSTR构造
CComBSTR bs2 = L"wide char string"; // 从LPCWSTR构造
CComBSTR bs3 = bs1; // 拷贝CComBSTR
CComBSTR bs4;
bs4.LoadString ( IDS_SOME_STR ); // 从字符串表加载
// 数据萃取
BSTR bstr1 = bs1; // 返回内部BSTR，但不可修改！
BSTR bstr2 = (BSTR) bs1; // cast ok, 同上
BSTR bstr3 = bs1.Copy(); // 拷贝bs1, 返回BSTR
BSTR bstr4;
bstr4 = bs1.Detach(); // bs1不再管理它的BSTR
// ...
SysFreeString ( bstr3 );
SysFreeString ( bstr4 );

  std::list< CAdapt> bstr_list;

// 构造
CComVariant v1 = "char string";       // 从LPCSTR构造
CComVariant v2 = L"wide char string"; // 从LPCWSTR构造
CComBSTR bs1 = "BSTR bob";
CComVariant v3 = (BSTR) bs1;          // 从BSTR拷贝
// 数据萃取
CComBSTR bs2 = v1.bstrVal;            // 从VARIANT提取BSTR

CComVariant v4 = ... // 从某种类型初始化 v4
CComBSTR bs3;
if ( SUCCEEDED( v4.ChangeType ( VT_BSTR ) ))
    bs3 = v4.bstrVal;

// 带有字符串的函数：
void Foo ( LPCWSTR wstr );
void Bar ( BSTR bstr );
// 返回字符串的函数：
void Baz ( BSTR* pbstr );
#include 
main()
{
using std::string;
USES_CONVERSION;    // 声明局部变量由宏控制使用
// 示例1：送一个MBCS字符串到Foo()
LPCSTR psz1 = "Bob";
string str1 = "Bob";
Foo ( A2CW(psz1) );
  Foo ( A2CW(str1.c_str()) );
// 示例2：将MBCS字符串和Unicode字符串送到Bar()
LPCSTR psz2 = "Bob";
LPCWSTR wsz = L"Bob";
BSTR bs1;
CComBSTR bs2;
bs1 = A2BSTR(psz2);         // 创建 BSTR
  bs2.Attach ( W2BSTR(wsz) ); // 同上，分配到CComBSTR
Bar ( bs1 );
  Bar ( bs2 );
SysFreeString ( bs1 );      // 释放bs1
  // 不必释放bs2，由CComBSTR释放。
// 示例3：转换由Baz()返回的BSTR
BSTR bs3 = NULL;
string str2;
Baz ( &bs3 );          // Baz() 填充bs3内容
str2 = W2CA(bs3);      // 转换为MBCS字符串
  SysFreeString ( bs3 ); // 释放bs3
}

// 构造
CString s1 = "char string"; // 从LPCSTR构造
CString s2 = L"wide char string"; // 从LPCWSTR构造
CString s3 ( ' ', 100 ); // 预分配100字节，填充空格
CString s4 = "New window text";
// 可以在LPCTSTR处使用CString：
SetWindowText ( hwndSomeWindow, s4 );
// 或者，显式地做强制类型转换：
SetWindowText ( hwndSomeWindow, (LPCTSTR) s4 );

// 从字符串表构造/加载
CString s5 ( (LPCTSTR) IDS_SOME_STR );  // 从字符串表加载
CString s6, s7;
// 从字符串表加载
  s6.LoadString ( IDS_SOME_STR );
// 从字符串表加载打印格式的字符串
  s7.Format ( IDS_SOME_FORMAT, "bob", nSomeStuff, ... );

CString str = _T("new text");
LVITEM item = {0};
item.mask = LVIF_TEXT;
  item.iItem = 1;
  item.pszText = (LPTSTR)(LPCTSTR) str; // 错！
  item.pszText = str.GetBuffer(0);      // 正确
ListView_SetItem ( &item );
  str.ReleaseBuffer();  // 将队列返回给str

// 转换成BSTR
CString s5 = "Bob!";
BSTR bs1 = NULL, bs2 = NULL;
bs1 = s5.AllocSysString();
  s5.SetSysString ( &bs2 );
// ...
  SysFreeString ( bs1 );
  SysFreeString ( bs2 );

// 构造
CString s1 = _T("tchar string");
COleVariant v1 = _T("Bob"); // 从LPCTSTR构造
COleVariant v2 = s1; // 从CString拷贝

// 数据萃取
COleVariant v3 = ...; // 从某种类型构造v3
BSTR bs = NULL;
try
    {
    v3.ChangeType ( VT_BSTR );
    bs = v3.bstrVal;
    }
  catch ( COleException* e )
    {
    // 出错，无法转换
    }
SysFreeString ( bs );

// 构造
String* ms = S"This is a nice managed string";

String* ms1 = S"this is nice";
String* ms2 = S"this is nice";
String* ms3 = L"this is nice";
Console::WriteLine ( ms1 == ms2 ); // 输出true
Console::WriteLine ( ms1 == ms3);  // 输出false

  Console::WriteLine ( ms1->CompareTo(ms2) );
  Console::WriteLine ( ms1->CompareTo(ms3) );

  CString s1 ( "hello world" );
  String* s2 ( s1 );  // 从CString拷贝

  String* s1 = S"Three cats";
  CString s2 ( s1 );

  CStringT ( System::String* pString );

String* s1 = S"Three cats";
Console::WriteLine ( s1 );
const __wchar_t __pin* pstr = PtrToStringChars(s1);
for ( int i = 0; i < wcslen(pstr); i++ )
    (*const_cast<__wchar_t*>(pstr+i))++;
Console::WriteLine ( s1 );

  _bstr_t bs = L"Bob!";
  ATLTRACE("The string is: %s in line %d\n", (LPCSTR) bs, nLine);

启动server时如果遇到找不到stub问题，原因是rmiregistry找不到stub，而不是java com.Server找不到stub，解决方法，在stub的类同一个目录下启动rmiregistry

keytool -genkey -dname "CN=demo, OU=softDept, O=company, L=puddong,S=shanghai, C=cn" -alias demo -keyalg RSA -keysize 1024 -keystore demoKeystore -validity 3650 -storepass storePwd -keypass demoPwd
生成保存公钥和私钥的密钥仓库，保存在demoKeystore文件中。这里storepass 和 keypass 不要有java 正则表达式中的特殊字符，否则程序里要转义麻烦。

keytool -export -alias demo -keystore demoKeystore -rfc -file demo.cer //从密钥仓库中导出保存公钥的证书
输入keypass 即demoPwd 


  try{     
   //密钥仓库
   KeyStore ks = KeyStore.getInstance("JKS");
//读取密钥仓库
   FileInputStream ksfis = new FileInputStream("demoKeystore");
   BufferedInputStream ksbufin = new BufferedInputStream(ksfis);
   char[] storePwd = "storePwd".toCharArray();
   ks.load(ksbufin, storePwd);
   ksbufin.close();
   char[] keyPwd = "demoPwd".toCharArray();
//从密钥仓库得到私钥
   PrivateKey priK = (PrivateKey) ks.getKey("demo", keyPwd);  
//生成cipher
   Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding",new org.bouncycastle.jce.provider.BouncyCastleProvider());
//用私钥初始化cipher
   cipher.init(Cipher.ENCRYPT_MODE, priK);
   byte[] plain = "This is plain text".getBytes("UTF-8");
   
   //因为用的1024位rsa算法，一次只能加密1024/8-11字节数据，分开加密
   byte[] code = new byte[(((plain.length-1)/117+1))*128];  
            int ixplain = 0;
            int ixcode = 0;
            while((plain.length - ixplain) > 117) {//每117字节做一次加密
                ixcode += cipher.doFinal(plain, ixplain, 117, code, ixcode);
                ixplain += 117;
            }
            cipher.doFinal(plain, ixplain, plain.length - ixplain, code, ixcode);
            //加密后的code
            System.out.println(Arrays.toString(code));
            //通常会用base64编码
           String base64 = encoder.encode(code);

   CertificateFactory certificatefactory = CertificateFactory
     .getInstance("X.509");
   //读取证书
   FileInputStream fin = new FileInputStream("demo.cer");
   X509Certificate certificate = (X509Certificate) certificatefactory
     .generateCertificate(fin);
   fin.close();
   //得到公钥
   PublicKey pubK = certificate.getPublicKey();
         //初始化cipher
            cipher.init(Cipher.DECRYPT_MODE, pubK);
      //base64解码
            code = decoder.decodeBuffer(base64);
            System.out.println(Arrays.toString(code));
            byte[] plain2 = new byte[code.length];
            int ixplain2 = 0;
            int ixcode2 = 0;
            while((code.length - ixcode2) > 128) {//每128字节做一次解密
                ixplain2 += cipher.doFinal(code, ixcode2, 128, plain2, ixplain2);
                ixcode2 += 128;
            }
            ixplain2 += cipher.doFinal(code, ixcode2, code.length - ixcode2, plain2, ixplain2);
            String s2 = new String(plain2, 0, ixplain2, "UTF-8");
            System.out.println(s2);
   
  }catch(Exception ex){
   ex.printStackTrace();
  }

keytool使用方法可以参考jdk文档
Java keytool工具的作用及使用方法

找出内存泄漏另一方法

程序有内存泄漏的第一个迹象通常是它抛出一个 OutOfMemoryError，或者因为频繁的垃圾收集而表现出糟糕的性能。幸运的是，垃圾收集可以提供能够用来诊断内存泄漏的大量信息。如果以 -verbose:gc 或者 -Xloggc 选项调用 JVM，那么每次 GC 运行时在控制台上或者日志文件中会打印出一个诊断信息，包括它所花费的时间、当前堆使用情况以及恢复了多少内存。记录 GC 使用情况并不具有干扰性，因此如果需要分析内存问题或者调优垃圾收集器，在生产环境中默认启用 GC 日志是值得的。

有工具可以利用 GC 日志输出并以图形方式将它显示出来，JTune 就是这样的一种工具（请参阅 参考资料）。观察 GC 之后堆大小的图，可以看到程序内存使用的趋势。对于大多数程序来说，可以将内存使用分为两部分：baseline 使用和 current load 使用。对于服务器应用程序，baseline 使用就是应用程序在没有任何负荷、但是已经准备好接受请求时的内存使用，current load 使用是在处理请求过程中使用的、但是在请求处理完成后会释放的内存。只要负荷大体上是恒定的，应用程序通常会很快达到一个稳定的内存使用水平。如果在应用程序已经完成了其初始化并且负荷没有增加的情况下，内存使用持续增加，那么程序就可能在处理前面的请求时保留了生成的对象。

图 1 显示  GC 之后应用程序堆大小随着时间的变化图。上升趋势是存在内存泄漏的警示信号。（在真实的应用程序中，坡度不会这么大，但是在收集了足够长时间的 GC 数据后，上升趋势通常会表现得很明显。）

确信有了内存泄漏后，下一步就是找出哪种对象造成了这个问题。所有内存分析器都可以生成按照对象类进行分解的堆快照。有一些很好的商业堆分析工具，但是找出内存泄漏不一定要花钱买这些工具 —— 内置的 hprof 工具也可完成这项工作。要使用 hprof 并让它跟踪内存使用，需要以 -Xrunhprof:heap=sites 选项调用 JVM。

清单 3 显示分解了应用程序内存使用的 hprof 输出的相关部分。（hprof 工具在应用程序退出时，或者用 kill -3 或在 Windows 中按 Ctrl+Break 时生成使用分解。）注意两次快照相比，Map.Entry、Task 和 int[] 对象有了显著增加。

请参阅 清单 3。

清单 4 展示了 hprof 输出的另一部分，给出了 Map.Entry 对象的分配点的调用堆栈信息。这个输出告诉我们哪些调用链生成了 Map.Entry 对象，并带有一些程序分析，找出内存泄漏来源一般来说是相当容易的。

TRACE 300446:
	java.util.HashMap$Entry.<init>(<Unknown Source>:Unknown line)
	java.util.HashMap.addEntry(<Unknown Source>:Unknown line)
	java.util.HashMap.put(<Unknown Source>:Unknown line)
	java.util.Collections$SynchronizedMap.put(<Unknown Source>:Unknown line)
	com.quiotix.dummy.MapLeaker.newTask(MapLeaker.java:48)
	com.quiotix.dummy.MapLeaker.main(MapLeaker.java:64)

HP-UX下使用JNI访问标准C++程序

问题的关键在于用aCC编译时的参数.  根据HP网站上的两篇文章可以很容易的使用JNI访问传统C++(Classical C++)程序:  http://www.hp.com/products1/unix/java/infolibrary/prog_guide/JNI_java2.html  http://forums1.itrc.hp.com/service/forums/questionanswer.do?admit=716493758+1092296929165+28353475&threadId=245738  但是,如果代码中使用到了标准C++,也就是用到了STL,就会出现莫名其妙的JVM crash. 而且一般的现象是使用string的时候出错.  最后发现是JVM的多线程机制和aCC编译的缺省的多线程机制不一样.所以编译时需要加参数指定.  总的说来,编译参数为:  OPTS=-AA +z +u4 -D_RWSTD_MULTI_THREAD -D_REENTRANT -D_HPUX -D_HPUX_SOURCE -D_POSIX_C_SOURCE=199506L -D_XOPEN_SOURCE_EXTENDED  其中,-D_RWSTD_MULTI_THREAD -D_REENTRANT 是指定多线程机制;同时必须添加-D_HPUX_SOURCE 参数,否则,编译时会出现奇怪的错误.  连接参数为:  -AA -b -lCsup_v2 -lstd_v2  值得注意的是根据上面所说的第二篇文章可知使用-AA编译连接时,要连的库是libCsup_v2.sl和libstd_v2.sl(这两个库是支持标准C++的库),而不是第一篇文章中提到的libCsup.sl和libstd.sl(这两个库是支持传统C++的库).  另外,有几个碰到的问题:  1. 如果编译参数没有指定多线程机制,禁用JIT(启动JVM加参数:-Djava.compiler=none -Xint )可以使简单的例子通过,但是有些情况下还是会出错.  2. 当null作为String传入JNI native接口代码中是,使用env->GetStringUTFChars(jstring)会出现如下错误导致虚拟机崩溃:  Function=verify_instance_jfieldID__18jfieldIDWorkaroundSFP12klassOopDescP9_jfieldID  3. 在使用String作为JNI的传入传出参数,使用GetStringUTFChars解决不了中文问题,还是会有乱码. 正确的解决方法是使用以下两个函数:  void JNU_ThrowByName(JNIEnv *env, const char *name, const char *msg)  {      jclass cls = env->FindClass(name);      /* if cls is NULL, an exception has already been thrown */      if (cls != NULL) {          env->ThrowNew(cls, msg);      }      /* free the local ref */      env->DeleteLocalRef(cls);  }  jstring JNU_NewStringNative(JNIEnv *env, const char *str)  {    if (str==NULL)    {     return NULL;    }    jclass jcls_str = env->FindClass("java/lang/String");    jmethodID jmethod_str = env->GetMethodID(jcls_str, "", "([B)V");    jstring result;    jbyteArray bytes = 0;    int len;    if (env->EnsureLocalCapacity(2) < 0) {      return NULL; /* out of memory error */    }    len = strlen(str);    bytes = env->NewByteArray(len);    if (bytes != NULL) {      env->SetByteArrayRegion(bytes, 0, len,(jbyte *)str);      result = (jstring)env->NewObject(jcls_str, jmethod_str, bytes);      env->DeleteLocalRef(bytes);      return result;    } /* else fall through */    return NULL;  ]  char *JNU_GetStringNativeChars(JNIEnv *env, jstring jstr)  {      jbyteArray bytes = 0;      jthrowable exc;      char *result = 0;      if (env->EnsureLocalCapacity(2) < 0) {          return 0; /* out of memory error */      }  jclass jcls_str = env->FindClass("java/lang/String");  jmethodID MID_String_getBytes = env->GetMethodID(jcls_str, "getBytes", "()[B"];      bytes = (jbyteArray)env->CallObjectMethod(jstr, MID_String_getBytes);      exc = env->ExceptionOccurred();      if (!exc) {          jint len = env->GetArrayLength( bytes);          result = (char *)malloc(len + 1);          if (result == 0) {              JNU_ThrowByName(env, "java/lang/OutOfMemoryError",                              0);              env->DeleteLocalRef(bytes);              return 0;          }          env->GetByteArrayRegion(bytes, 0, len, (jbyte *)result);          result[len] = 0; /* NULL-terminate */      } else {          env->DeleteLocalRef(exc);      }      env->DeleteLocalRef(bytes);      return (char*)result;  )  ★注意：使用char *JNU_GetStringNativeChars()获得的指针用完后要显式的free().

使用Axis传送附件有两种方式：

1. 将你要传送的文件封装在DataHandler中，然后将DataHandler对象或DataHandler数组（多个文件传送的时候）作为客户端调用函数的参数（从客户端上传文件到服务器）Axis服务的返回类型（从服务器端下载文件到客户端）进行传输。

2. 还有一种方式是直接修改soap信封的内容，将附件信息加到soap信封中发送。

这里我们只讨论第一种方法，因为它实现起来非常简单。关于第二种方法在Axis包的webapps/attachments/TestRf.java中有详细的原码可以参考。

下面的例子是把文件从服务器端下载到客户端：

1.服务端程序：

假设传输多个文件：在服务器端将文件取出来，并将文件封装在DataHandler数组中。
代码如下：

 DataHandler[] ret = new DataHandler[totalFileNum];
 ... ...
 java.io.File myFile = new java.io.File(filePath);
 if(myFile.isFile() && myFile.canRead())
 {
  String fname = myFile.getAbsoluteFile().getCanonicalPath();
  DataHandler[0] = new DataHandler(new FileDataSource(fname));
 }
 ... ...

 return ret;

上面的代码将所有的文件封装在了DataHandler数组中，并返回。

2. 客户端的访问：

代码如下：
 Service service = new Service();
 Call call = (Call) service.createCall();

 URL myURL = new URL("http://192.168.0.26:8080/axis/servlet/AxisServlet");
 call.setTargetEndpointAddress(myURL); //设定服务的主机和位置
 call.setOperationName(new QName("urn:MyAttachServer","echoDir")); //设置要调用的服务的方法
 QName qnameAttachment = new QName("urn:MyAttachServer","DataHandler");

 call.registerTypeMapping(DataHandler.class, qnameAttachment, JAFDataHandlerSerializerFactory.class,JAFDataHandlerDeserializerFactory.class); //为附件（即DataHandler类）创建序列化生成器

 call.addParameter("source", XMLType.XSD_STRING ,ParameterMode.IN); //设置服务调用方法的传入参数类型
 call.setReturnType(XMLType.SOAP_ARRAY); //设置调用服务方法的返回类型，由于返回的是DataHandler数组，所以设置为SOAP_ARRAY类型
 javax.activation.DataHandler[] ret = (javax.activation.DataHandler[])call.invoke(new Object[]{null}); //调用方法

 for (i = 0; i < ret.length; ++i)
        {
            DataHandler recDH = ret[i];
            java.io.File receivedFile = new java.io.File(recDH.getName()); //文件生成
        }

3. 服务的部署：

注意：你要在部署的时候，定义DataHandler的序列化生成器。

  编写deploy.wsdd文件：

 <deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java" xmlns:ns1="urn:att_STC_Server" >
  <service name="urn:att_STC_Server" provider="java:RPC" >
    <parameter name="className" value="samples.att_STC.att_STC_Server"/>
    <parameter name="allowedMethods" value="echoDir"/>

 <typeMapping deserializer="org.apache.axis.encoding.ser.JAFDataHandlerDeserializerFactory"
   languageSpecificType="java:javax.activation.DataHandler" qname="ns1:DataHandler"
    serializer="org.apache.axis.encoding.ser.JAFDataHandlerSerializerFactory"
    encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/>
  </service>

</deployment>

运行java org.apache.axis.client.AdminClient %* deploy.wsdd，部署服务。

2004-05-29 17:39:53

主题: 使用Java实现CA(四)

    前面几篇文章已经把如何用Java实现一个CA基本上讲完了.但是他们都有一个特点,就是用户的信息都是在现场获取的,不能做申请和签发相分离.今天我们要讲述的是PKCS#10证书请求文件.它的作用就是可以使申请和签发相分离.

[返回顶部]

2004-05-28 16:46:12

主题: 使用Java实现CA(三)

    前几次我已经基本上把如何做CA所需要的基础知识讲得差不多了,今天直接讲如何用Java程序来实现一个CA应该就不是什么太困难的事情了.

2004-05-27 15:34:59

主题: 使用Java实现CA(二)

    昨天本来快写完了,结果不小心按了"tab"键,然后向按退格键,结果退到前一个页面了,然后全部都白写了,不爽.只好今天重新写了.

2004-05-25 21:23:52

主题: 使用Java实现CA(一)

    通过我昨天的文章大家应该已经清楚了,用Java写信息安全方面的程序需要做的准备工作.好了,现在假设你已经是一个对Java语言本身比较熟悉,能够用Java写一些程序的人,并且这些该下载的jar包已经下载好了,可以正式开工了.

2004-05-24 17:23:06

主题: 使用Java开发和信息安全相关的程序

    这里说的信息安全是相对于系统安全而言的,它更侧重于加密,解密,数字签名,验证,证书等等.而系统安全主要侧重于系统本身是否有安全漏洞,如常见的由于软件设计的不完善而导致的满天飞的缓冲区溢出等等.