Create Struts 2 Application in Eclipse : HTTP Status 500

HTTP Status 500 

java.lang.NullPointerException 	
org.apache.struts2.impl.StrutsActionProxy.getErrorMessage(StrutsActionProxy.java:69) 	
com.opensymphony.xwork2.DefaultActionProxy.prepare(DefaultActionProxy.java:185) 

posted @ 2012-04-21 02:41 九宝 阅读(393) | 评论 (0) | 编辑 收藏

How to check file properties through WMI command line (fw)

How to check file properties through WMI command line

With the lack of Graphical Interface on Windows 2008 Core server there comes a need of performing a lot of task through command line. One of which is checking file properties like file version, path, product verision etc. Luckily we have a command that makes this task simple. On a side note, We can also run the same command on other operating systems like Windows Xp, 2003, vista.

Here is the command:
wmic datafile where name='c:\\windows\\system32\\notepad.exe'

Click here to view the enlarged screenshot

Notice that we have used two backslashes \\ in the file path. Also, notice that the path is enclosed in the single quotes.
The output will be confusing to read in command prompt window. To read and understand it better, we can take the output in text format and read it in notepad.

While doing so, please do NOT wrap the text.
wmic datafile where name='c:\\windows\\system32\\notepad.exe' > out.txt

Click here to view the enlarged screenshot

The output will reveal the file properties like Hidden, Path, Drive, Version Caption, Access rights etc.

To get one particular property of a file we need to modify the command a little bit. We need to use the GET Alias injunction to the command mentioned above. Let's say we want to check the version for the file notepad.exe. The command that is used for this is:
wmic datafile where name='c:\\windows\\system32\\notepad.exe' get version

Similarily, there is a list of properties that can be fetched through this command line. They are:

Access Rights
Caption
Class Name
Compressed
Compression Method
Computer System Class Name
Computer System Name
Creation Date
Current File Open Count
Description
Drive
Eight Dot Three File Name
Encrypted
Encryption Method
File Extension
File Name
File System Class Name
File System Name
File Type
Hidden
Install Date
Last Accessed
Last Modified
Manufacturer
Name
Path
Readable
Should Be Archived
Size
Status
System File
Version
Writeable

posted @ 2011-12-07 22:29 九宝 阅读(349) | 评论 (0) | 编辑 收藏

Windows Authentication

<windowsAuthentication enabled="false" />

<windowsAuthentication enabled="false">
   <providers>
      <add value="Negotiate" />
      <add value="NTLM" />
   </providers>
</windowsAuthentication>

<location path="Contoso">
   <system.webServer>
      <security>
         <authentication>
            <anonymousAuthentication enabled="false" />
            <windowsAuthentication enabled="true" />
         </authentication>
      </security>
   </system.webServer>
</location>

appcmd.exe set config "Contoso" -section:system.webServer/security/authentication/anonymousAuthentication /enabled:"False" /commit:apphost

appcmd.exe set config "Contoso" -section:system.webServer/security/authentication/windowsAuthentication /enabled:"True" /commit:apphost

using System;
using System.Text;
using Microsoft.Web.Administration;

internal static class Sample {

   private static void Main() {

      using(ServerManager serverManager = new ServerManager()) { 
         Configuration config = serverManager.GetApplicationHostConfiguration();

         ConfigurationSection anonymousAuthenticationSection = config.GetSection("system.webServer/security/authentication/anonymousAuthentication", "Contoso");
         anonymousAuthenticationSection["enabled"] = false;

         ConfigurationSection windowsAuthenticationSection = config.GetSection("system.webServer/security/authentication/windowsAuthentication", "Contoso");
         windowsAuthenticationSection["enabled"] = true;

         serverManager.CommitChanges();
      }
   }
}

Imports System
Imports System.Text
Imports Microsoft.Web.Administration

Module Sample
   Sub Main()
      Dim serverManager As ServerManager = New ServerManager
      Dim config As Configuration = serverManager.GetApplicationHostConfiguration

      Dim anonymousAuthenticationSection As ConfigurationSection = config.GetSection("system.webServer/security/authentication/anonymousAuthentication", "Contoso")
      anonymousAuthenticationSection("enabled") = False

      Dim windowsAuthenticationSection As ConfigurationSection = config.GetSection("system.webServer/security/authentication/windowsAuthentication", "Contoso")
      windowsAuthenticationSection("enabled") = True

      serverManager.CommitChanges()
   End Sub
End Module

var adminManager = new ActiveXObject('Microsoft.ApplicationHost.WritableAdminManager');
adminManager.CommitPath = "MACHINE/WEBROOT/APPHOST";

var anonymousAuthenticationSection = adminManager.GetAdminSection("system.webServer/security/authentication/anonymousAuthentication", "MACHINE/WEBROOT/APPHOST/Contoso");
anonymousAuthenticationSection.Properties.Item("enabled").Value = false;

var windowsAuthenticationSection = adminManager.GetAdminSection("system.webServer/security/authentication/windowsAuthentication", "MACHINE/WEBROOT/APPHOST/Contoso");
windowsAuthenticationSection.Properties.Item("enabled").Value = true;

adminManager.CommitChanges();

Set adminManager = CreateObject("Microsoft.ApplicationHost.WritableAdminManager")
adminManager.CommitPath = "MACHINE/WEBROOT/APPHOST"

Set anonymousAuthenticationSection = adminManager.GetAdminSection("system.webServer/security/authentication/anonymousAuthentication", "MACHINE/WEBROOT/APPHOST/Contoso")
anonymousAuthenticationSection.Properties.Item("enabled").Value = False

Set windowsAuthenticationSection = adminManager.GetAdminSection("system.webServer/security/authentication/windowsAuthentication", "MACHINE/WEBROOT/APPHOST/Contoso")
windowsAuthenticationSection.Properties.Item("enabled").Value = True

adminManager.CommitChanges()

posted @ 2011-09-16 21:46 九宝 阅读(640) | 评论 (0) | 编辑 收藏

How To Determine if Your Computer Is 32-Bit or 64-Bit(forward)

1. Open the System Information

   Open the Start menu, and click on Programs -> Accessories -> System Tools -> System Information

    

2. Look in the System Summary

   The System Information tool will display detailed information about your Windows operating system. Once opened it will show the "System Summary" – it’s an overview of your computer and operating system.

3. Look for the System Type Item

   On the right hand side of the window you will see a list of items. Look for the item called "System Type".

   The value of this item will tell you whether your computer is 32-bit or 64-bit:

   • x86-based PC: It’s a 32-bit computer.
   • x64-based PC: It’s a 64-bit computer.

    

posted @ 2011-09-16 03:34 九宝 阅读(249) | 评论 (0) | 编辑 收藏

ContentProvider分析

posted @ 2011-02-18 14:51 九宝 阅读(1856) | 评论 (0) | 编辑 收藏

GestureDetector手势识别类 (转)

View是在onTouchEvent(MotionEvent event)里对用户的动作做了一定的分析，从而通知我们是发生了点击还是长按等事件。

我们需要创建一个GestureDetector的对象，传入listener对象，view接收到的onTouchEvent中将event传给GestureDetector进行分析，listener会回调给我们相应的动作。其中GestureDetector.SimpleOnGestureListener（Framework帮我们简化了）是实现了上面提到的OnGestureListener和OnDoubleTapListener两个接口的类，我们只需要继承它并重写其中我们关心的回调即可。

posted @ 2011-02-16 15:03 九宝 阅读(533) | 评论 (0) | 编辑 收藏

onNewIntent 什么时候调用

posted @ 2011-02-14 11:18 九宝 阅读(6200) | 评论 (1) | 编辑 收藏

Observer模式在J2EE中的实现 [http://35java.com/zhibo/forum.php?mod=viewthread&tid=108&extra=page%3D3]

• 表示层(presentation)－窗口、报表-
• 业务逻辑层(business logic)－管理业务过程的任务和规则。它又可以细分为领域对象层（代表领域概念）和服务层（提供数据库交互、安全性、打印报表）。
• 存储层(storage)－持久化存储机制。如数据库服务器等。
  

• 支持聚合度更高的模型定义，使模型的定义可以集中在领域过程的定义，而不是图形界面上。
• 允许将模型和用户界面并行开发。
• 使用户界面的需求变化对领域层所造成的影响最小化。
• 允许建立与一个现有的领域层对象相连接的新视图，同时不影响领域层。
• 允许一个模型同时有多个视图，例如使用SVG和表格。
• 允许模型层独立于用户界面层执行。
  

posted @ 2011-02-13 19:24 九宝 阅读(413) | 评论 (0) | 编辑 收藏

RMI的定义(转)http://blog.csdn.net/ocean181/archive/2010/09/02/5857273.aspx

RMI的定义

Java RMI （Remote Method Invocation 远程方法调用）是用Java在JDK1.1中实现的，它大大增强了Java开发分布式应用的能力。Java作为一种风靡一时的网络开发语言，其巨大的威力就体现在它强大的开发分布式网络应用的能力上，而RMI就是开发百分之百纯Java的网络分布式应用系统的核心解决方案之一。其实它可以被看作是RPC的Java版本。但是传统RPC并不能很好地应用于分布式对象系统。而Java RMI 则支持存储于不同地址空间的程序级对象之间彼此进行通信，实现远程对象之间的无缝远程调用。

RMI目前使用Java远程消息交换协议JRMP（Java Remote Messaging Protocol）进行通信。JRMP是专为Java的远程对象制定的协议。因此，Java RMI具有Java的“Write Once,Run Anywhere”的优点，是分布式应用系统的百分之百纯Java解决方案。用Java RMI开发的应用系统可以部署在任何支持JRE（Java Run Environment Java，运行环境）的平台上。但由于JRMP是专为Java对象制定的，因此，RMI对于用非Java语言开发的应用系统的支持不足。不能与用非Java语言书写的对象进行通信。

RMI与CORBA的关系

RMI 和CORBA常被视为相互竞争的技术，因为两者都提供对远程分布式对象的透明访问。但这两种技术实际上是相互补充的，一者的长处正好可以弥补另一者的短处。RMI 和 CORBA 的结合产生了 RMI-IIOP，RMI-IIOP 是企业服务器端 Java 开发的基础

1997 年，IBM 和 Sun Microsystems启动了一项旨在促进 Java 作为企业开发技术的发展的合作计划。两家公司特别着力于如何将 Java 用作服务器端语言，生成可以结合进现有体系结构的企业级代码。所需要的就是一种远程传输技术，它兼有 Java 的 RMI（Remote Method Invocation，远程方法调用）较少的资源占用量和更成熟的 CORBA（Common Object Request Broker Architecture，公共对象请求代理体系结构）技术的健壮性。出于这一需要，RMI-IIOP问世了，它帮助将 Java 语言推向了目前服务器端企业开发的主流语言的领先地位。

RMI的组成

一个正常工作的RMI系统由下面几个部分组成：

1、远程服务的接口定义

2、远程服务接口的具体实现

3、桩（Stub）和框架（Skeleton）文件

4、一个运行远程服务的服务器

5、一个RMI命名服务，它允许客户端去发现这个远程服务

6、类文件的提供者（一个HTTP或者FTP服务器）

7、一个需要这个远程服务的客户端程序

RMI的实现

下面我们一步一步建立一个简单的RMI系统。首先在你的机器里建立一个新的文件夹，以便放置我们创建的文件，为了简单起见，我们只使用一个文件夹存放客户端和服务端代码，并且在同一个目录下运行服务端和客户端。

如果所有的RMI文件都已经设计好了，那么你需要下面的几个步骤去生成你的系统：

1、   编写并且编译接口的Java代码
2、   编写并且编译接口实现的Java代码
3、   从接口实现类中生成 Stub 和 Skeleton 类文件
4、   编写远程服务的主运行程序
5、   编写RMI的客户端程序
6、   安装并且运行RMI系统

1、接口

第一步就是建立和编译服务接口的Java代码。这个接口定义了所有的提供远程服务的功能，下面是源程序：

   1. //Calculator.java
   2. //define the interface
   3. import java.rmi.Remote;
   4.
   5. public interface Calculator extends Remote
   6. {
   7.     public long add(long a, long b)
   8.         throws java.rmi.RemoteException;
   9.
  10.     public long sub(long a, long b)
  11.         throws java.rmi.RemoteException;
  12.
  13.     public long mul(long a, long b)
  14.         throws java.rmi.RemoteException;
  15.
  16.     public long div(long a, long b)
  17.         throws java.rmi.RemoteException;
  18. }


注意，这个接口继承自Remote，每一个定义的方法都必须抛出一个RemoteException异常对象。

建立这个文件，把它存放在刚才的目录下，并且编译。

>javac Calculator.java

2、接口的具体实现

下一步，我们就要写远程服务的具体实现，这是一个CalculatorImpl类文件：

   1. //CalculatorImpl.java
   2. //Implementation
   3. import java.rmi.server.UnicastRemoteObject;
   4.
   5. public class CalculatorImpl extends UnicastRemoteObject implements Calculator
   6. {
   7.
   8.     // 这个实现必须有一个显式的构造函数，并且要抛出一个RemoteException异常
   9.     public CalculatorImpl()
  10.         throws java.rmi.RemoteException {
  11.         super();
  12.      }
  13.
  14.     public long add(long a, long b)
  15.         throws java.rmi.RemoteException {
  16.         return a + b;
  17.      }
  18.
  19.     public long sub(long a, long b)
  20.         throws java.rmi.RemoteException {
  21.         return a - b;
  22.      }
  23.
  24.     public long mul(long a, long b)
  25.         throws java.rmi.RemoteException {
  26.         return a * b;
  27.      }
  28.
  29.     public long div(long a, long b)
  30.         throws java.rmi.RemoteException {
  31.         return a / b;
  32.      }
  33. }


同样的，把这个文件保存在你的目录里然后编译他。

这个实现类使用了UnicastRemoteObject去联接RMI系统。在我们的例子中，我们是直接的从UnicastRemoteObject 这个类上继承的，事实上并不一定要这样做，如果一个类不是从UnicastRmeoteObject上继承，那必须使用它的exportObject() 方法去联接到RMI。

如果一个类继承自UnicastRemoteObject，那么它必须提供一个构造函数并且声明抛出一个RemoteException对象。当这个构造函数调用了super()，它久激活UnicastRemoteObject中的代码完成RMI的连接和远程对象的初始化。

3、Stubs 和Skeletons

下一步就是要使用RMI编译器rmic来生成桩和框架文件，这个编译运行在远程服务实现类文件上。

>rmic CalculatorImpl

在你的目录下运行上面的命令，成功执行完上面的命令你可以发现一个Calculator_stub.class文件，如果你是使用的Java2SDK，那么你还可以发现Calculator_Skel.class文件。

4、主机服务器

远程RMI服务必须是在一个服务器中运行的。CalculatorServer类是一个非常简单的服务器。

   1. //CalculatorServer.java
   2. import java.rmi.Naming;
   3.
   4. public class CalculatorServer {
   5.
   6.    public CalculatorServer() {
   7.      try {
   8.         Calculator c = new CalculatorImpl();
   9.        Naming.rebind("rmi://localhost:1099/CalculatorService", c);
  10.       } catch (Exception e) {
  11.        System.out.println("Trouble: " + e);
  12.       }
  13.     }
  14.
  15.    public static void main(String args[]) {
  16.      new CalculatorServer();
  17.     }
  18. }


建立这个服务器程序，然后保存到你的目录下，并且编译它。

5、客户端

客户端源代码如下：

   //CalculatorClient.java
   
    import java.rmi.Naming;
    import java.rmi.RemoteException;
    import java.net.MalformedURLException;
   import java.rmi.NotBoundException;
   
   public class CalculatorClient {
   
       public static void main(String[] args) {
         try {
             Calculator c = (Calculator)
                              Naming.lookup(
                    "rmi://localhost
                            /CalculatorService");
               System.out.println( c.sub(4, 3) );
            System.out.println( c.add(4, 5) );
               System.out.println( c.mul(3, 6) );
              System.out.println( c.div(9, 3) );
            }
           catch (MalformedURLException murle) {
               System.out.println();
              System.out.println(
                 "MalformedURLException");
               System.out.println(murle);
            }
           catch (RemoteException re) {
              System.out.println();
               System.out.println(
                          "RemoteException");
               System.out.println(re);
           }
          catch (NotBoundException nbe) {
              System.out.println();
               System.out.println(
                          "NotBoundException");
               System.out.println(nbe);
            }
           catch (
               java.lang.ArithmeticException
                                         ae) {
              System.out.println();
              System.out.println(
               "java.lang.ArithmeticException");
             System.out.println(ae);
            }
       }
   }

保存这个客户端程序到你的目录下（注意这个目录是一开始建立那个，所有的我们的文件都在那个目录下），并且编译他。

6、运行RMI系统

现在我们建立了所有运行这个简单RMI系统所需的文件，现在我们终于可以运行这个RMI系统啦！来享受吧。

我们是在命令控制台下运行这个系统的，你必须开启三个控制台窗口，一个运行服务器，一个运行客户端，还有一个运行RMIRegistry。

首先运行注册程序RMIRegistry，你必须在包含你刚写的类的那么目录下运行这个注册程序。

>rmiregistry

好，这个命令成功的话，注册程序已经开始运行了，不要管他，现在切换到另外一个控制台，在第二个控制台里，我们运行服务器CalculatorService，因为RMI的安全机制将在服务端发生作用,所以你必须增加一条安全策略。以下是对应安全策略的例子
grant {
permission java.security.AllPermission "", "";
};

注意:这是一条最简单的安全策略,它允许任何人做任何事,对于你的更加关键性的应用,你必须指定更加详细安全策略。

现在为了运行服务端，你需要除客户类(CalculatorClient.class)之外的所有的类文件。确认安全策略在policy.txt文件之后,使用如下命令来运行服务器。

> java -Djava.security.policy=policy.txt CalculatorServer

这个服务器就开始工作了，把接口的实现加载到内存等待客户端的联接。好现在切换到第三个控制台，启动我们的客户端。

为了在其他的机器运行客户端程序你需要一个远程接口(Calculator.class) 和一个stub(CalculatorImpl_Stub.class)。 使用如下命令运行客户端

> java -Djava.security.policy=policy.txt CalculatorClient

如果所有的这些都成功运行，你应该看到下面的输出：
1
9
18
3

如果你看到了上面的输出，恭喜你，你成功了，你已经成功的创建了一个RMI系统，并且使他正确工作了。即使你运行在同一个计算机上，RMI还是使用了你的网络堆栈和TCP/IP去进行通讯，并且是运行在三个不同的Java虚拟机上。这已经是一个完整的RMI系统。

posted @ 2011-02-13 18:46 九宝 阅读(252) | 评论 (0) | 编辑 收藏

JavaBean PropertyChange 之设计模式Observer(转)

posted @ 2011-02-13 18:26 九宝 阅读(932) | 评论 (0) | 编辑 收藏

(转)UML中类图实例

posted @ 2011-02-12 13:02 九宝 阅读(350) | 评论 (0) | 编辑 收藏

android register mimetype

在manifest文件里->activity 添加

<intent-filter>

     <action android:name="android.intent.action.VIEW" />

     <category android:name="android.intent.category.DEFAULT" />

     <data android:mimeType="*/*">

</intent-filter>

这样就把当前程序注册为 可以打开/查看所有类型的文件. 或者要查看jpeg, mimeType要改为: image/jpeg

当在文件管理器里点击任何文件, 系统都会试图去执行你的程序.

posted @ 2011-02-11 14:49 九宝 阅读(626) | 评论 (0) | 编辑 收藏

Android Log Analysis

posted @ 2011-01-17 11:41 九宝 阅读(797) | 评论 (0) | 编辑 收藏

如何使Android应用程序获取系统权限【转】

posted @ 2010-12-20 16:06 九宝 阅读(346) | 评论 (0) | 编辑 收藏

Android Looper(转)

posted @ 2010-12-20 15:13 九宝 阅读(391) | 评论 (0) | 编辑 收藏

android : px dip（转）

px (pixels) 像素
dip (device independent pixels) 设备独立像素
sp (scaled pixels - best for text size ) 放大像素，对文本大小最好
pt (points) 点
in (inches) 英寸
mm (millimeters) 毫米

很多网友可能发现在Android的layout文件中layout_width或layout_height有时候可能会指定具体的单位，比如有时候为px、dip或者sp等等。下面android123把常见的单位做下简单的介绍，比如说

px (pixels)像素 -- 一般我们HVGA代表320x480像素，这个用的比较多。

dip或dp (device independent pixels)设备独立像素 -- 这个和设备硬件有关，一般我们为了支持WVGA、HVGA和QVGA cwj推荐使用这个，不依赖像素。

sp (scaled pixels — best for text size)放大像素-- 主要处理字体的大小。

 下面的几个是不常用的，大家也知道这里android123就不再过多的赘述。

in (inches)英寸

mm (millimeters)毫米  

pt (points)点

px像素如何转为dip设备独立像素

最近有网友问如何将px像素转为dip独立设备像素，由于Android的设备分辨率众多，目前主流的为wvga，而很多老的设备为hvga甚至低 端的qvga，对于兼容性来说使用dip无非是比较方便的，由于他和分辨率无关和屏幕的密度大小有关，所以推荐使用，不过这里android123提示大 家，ophone os的手机对于dip的支持糟糕透了，显示的结果会放大很多，同时黑色的主题会导致常规的黑色文字让用户无法分辨。

  px= (int) (dip*density+0.5f) //这里android开发网提示大家很多网友获取density的方法存在问题，从资源中获取的是静态定义的，一般为1.0对于HVGA是正好的，而对于wvga这样的应该从WindowsManager中获取，WVGA为1.5

QVGA HVGA WVGA区别

文章分类:移动开发

QVGA即"Quarter VGA"。顾名思义即VGA的四分之一尺寸，亦即在液晶屏幕（LCD）上输出的分辨率是240×320像素。QVGA支持屏幕旋转，可以开发出相应的程序，以显示旋转90°、180°、270°屏幕位置。由HandEra公司发布。多用于手持/移动设备。 　　需要说明的是有些媒体把QVGA屏幕当成与TFT和TFD等LCD材质相同的东西是错误的，QVGA屏幕的说法多见与日本的一些手机中，目前采用微软Pocket PC操作系统的智能手机屏幕也大多是320×240像素的QVGA屏幕。 　　所谓QVGA液晶技术，就是在液晶屏幕上输出的分辨率是240×320的液晶输出方式。这个分辨率其实和屏幕本身的大小并没有关系。比如说，如果2.1英寸液晶显示屏幕可以显示240×320分辨率的图像，就叫做“QVGA 2.1英寸液晶显示屏”；如果3.8英寸液晶显示屏幕可以显示240×320的图像，就叫做“QVGA 3.8英寸液晶显示屏”，以上两种情况虽然具有相同的分辨率，但是由于尺寸的不同实际的视觉效果也不同，一般 HVGA 即VGA(640*480)的一半,分辨率为(480*320),(3:2宽高比) 　　它是用于各种各样的PDA设备，首先是2002年的索尼Clie PEG - NR70， 来说屏幕小的一个画面自然也会细腻一些。 WVGA 数码产品屏幕材质的一种，VGA的另一种形式，比VGA分辨率高，别名 ： Wide VGA, ，其分辩率为800×480象素。是扩大了VGA（640×480)的分辨率。应用于PDA和手机等，因为很多网页的宽度都是800，所以WVGA的屏幕会更加适和于浏览网页，可以说是未来手持设备的分辨率的大趋势

posted @ 2010-12-16 16:35 九宝 阅读(1160) | 评论 (0) | 编辑 收藏

drawable各个目录

posted @ 2010-12-09 16:24 九宝 阅读(286) | 评论 (0) | 编辑 收藏

andorid padding margin

posted @ 2010-12-08 15:38 九宝 阅读(399) | 评论 (0) | 编辑 收藏

(转) Android核心分析（22）-----Android应用框架之Activit

Android核心分析（22）-----Android应用框架之Activity 收藏

posted @ 2010-09-25 15:39 九宝 阅读(332) | 评论 (0) | 编辑 收藏

（转）Android核心分析（21）----Android应用框架之AndroidApplication

From  http://blog.csdn.net/maxleng/archive/2010/05/24/5621345.aspx

Android Application

    Android提供给开发程序员的概念空间中Application只是一个松散的表征概念，没有多少实质上的表征。在Android实际空间中看不到实际意义上的应用程序的概念,即使有一个叫Application的类，这个也就是个应用程序上下文状态，是一个极度弱化的概念。Application只是一个空间范畴的概念，Application就是Activity，Service之类的组件上下文描述。Application并不是Android的核心概念，而Activity才是Android的核心概念。

    从Android的SDK文档中，我们知道一般情况Android应用程序是由以下四种组件构造而成的：Activity，Broadcast Intent Receiver，服务（Service），内容提供器（Content Provider）。我们可以使用下面的图来表示一下Android的概念空间。这些组件依附于应用程序中，应用程序并不会一开始就建立起来，而是在这些组件建立起来后，需要运行时，才开始建立应用程序对象。

2.1应用进程名称

    为什么要从应用进程名称开始？作为内核研究，我们还是回到问题的最本质处：不管Activity，Service等组件如何设计和运行，它要提供服务，就必须要依附在Linux的进程上，建立消息循环，组件才能够真正的运作。Activity实例是如何Hosting在Linux进程上的？这个是我们首先想要弄明白的。

我们在的项目中看到android:process="string"这个定义。

allowClearUserData=["true" | "false"] 
android:allowTaskReparenting=["true" | "false"] 
android:backupAgent="string" 
…

android:label="string resource" 
android:manageSpaceActivity="string" 
android:name="string" 
android:permission="string" 
android:persistent=["true" | "false"] 
android:process="string" 
android:restoreAnyVersion=["true" | "false"] 
android:taskAffinity="string" 
android:theme="resource or theme" > 
    . . . 

在SDK用已经描述的很清楚到了。

android:process

The name of a process where all components of the application should run. Each component can override this default by setting its own process attribute.

By default, Android creates a process for an application when the first of its components needs to run. All components then run in that process. The name of the default process matches the package name set by the element.

By setting this attribute to a process name that's shared with another application, you can arrange for components of both applications to run in the same process — but only if the two applications also share a user ID and be signed with the same certificate.

为什么要提出这么一个定义？android:process名称。

    默认状态下，Activity Manager Service在应用程序的第一个组件需要运行时将会为应用程序建立一个进程，而这个进程的名字就是android:process=”string”所指定，缺省的是应用程序包的名字。该进程一旦建立，后面的该应用的组件都将运行在该进程中，他们绑定的根据就是这个Android：Process指定的名称，因为在他们都在同一个应用程序包里，也就具有了同样的进程名字，于是他们都托管在了同一进程中。组件将通过ClassLoader从Package中获取到应用程序的信息。

    在建立Actvitiy时，如果在应用进程端没有应用对象，系统在该过程中利用makeApplication建立一个Application对象，实例化"android.app.Application"，建立一个应用程序上下文完成例如资源，package等信息管理。

2.2  ActivityThread运行框架

    在分析中，我们可以看到真正对应应用进程的不是Application而是ActivityThread。我们从实际的应用堆栈可以看到：

NaiveStart.main()

        ZygoteInit.main

           ZygoteInit$MethodAndArgsCall.run

              Method.Invoke

                                       method.invokeNative

                     ActivityThread.main()

                         Looper.loop()

                                                                 ....

    每个应用程序都以ActivityThread.main()为入口进入到消息循环处理。对于一个进程来讲，我们需要这个闭合的处理框架。

    ActivitiyThread是应用程序概念空间的重要概念，他建立了应用进程运行的框架，并提供了一个IActivityThread接口作为与Activity Manager Service的通讯接口.通过该接口AMS可以将Activity的状态变化传递到客户端的Activity对象。

2．3 ActivitiyThread的建立

为了叙述的方便我将Actvitiy Manager Service简写成AMS。

    在AMS中关于应用程序的概念是ProcessRecord，请求都是从Activity，Service…等开始的，在Activity需要Resume时，此时如果与Activity相关的应用进程没有起来，AM则启动应用进程。

AMS与应用进程的绑定分为两个部分，第一部分就是AM建立应用进程，第二部分就是应用进程Attach到AM，与AM建立通讯通道。

1）创建建立进程：startProcessLocked(processName,Appinfo.uid)。该函数在StartSecificActivityLocked等调用。

（1）建立ProcessRecord对象app,并将该对象添加到mProcessNames中。应用对象在mProcessNames中使用应用名字和uid来标识自己。如果在同一个Package中的Activity,如果都使用默认设置，那么这些Activity都会托管在同一个进程中，这是因为他们在带的ApplicationInfo中的ProcessName都是一样的。

mPidsSelfLocked数组记录了PID，这个将会在应用进程跑起来后，将自己Attach到AM时，根据pid找到自己的前世：ProcessRecord.

2）android.app.ActivityThread进程启动

     Android.app.ActivityThread进程建立后，将跳入到ActivityThread的main函数开始运行，进入消息循环。

    应用进程使用thread.attach()发起AMS的AttachApplicationLocked调用，并传递 ActvitiyThread对象和CallingPid。AttachApplicationLocked将根据CallingPid在mPidsSelfLocked找到对应的ProcessRecord实例app,将ActvitiyThread放置app.thread中。这样应用进程和AMS建立起来双向连接。AM可以使用AIDL接口，通过app.thread可以访问应用进程的对象。

    应用程序通过ActivityThread提供的框架，建立消息循环Looper和Handler。从前面的相关章节我们知道有Looper和Handler,整个系统就可以运作了。

为了更为系统的了解应用程序的建立时序及其涉及到数据操作，我给出了应用进程的建立过程示意图：

posted @ 2010-09-25 15:38 九宝 阅读(743) | 评论 (0) | 编辑 收藏

Activitie之间传对象,通过Parcelable(转)

posted @ 2010-09-10 16:00 九宝 阅读(2132) | 评论 (0) | 编辑 收藏

DU和DF(转)

posted @ 2010-08-26 16:27 九宝 阅读(149) | 评论 (0) | 编辑 收藏

How does Python manage memory?(http://docs.python.org/3.1/faq/design.html)

The details of Python memory management depend on the implementation. The standard C implementation of Python uses reference counting to detect inaccessible objects, and another mechanism to collect reference cycles, periodically executing a cycle detection algorithm which looks for inaccessible cycles and deletes the objects involved. The gc module provides functions to perform a garbage collection, obtain debugging statistics, and tune the collector’s parameters.

Jython relies on the Java runtime so the JVM’s garbage collector is used. This difference can cause some subtle porting problems if your Python code depends on the behavior of the reference counting implementation.

Sometimes objects get stuck in tracebacks temporarily and hence are not deallocated when you might expect. Clear the tracebacks with:

import sys
sys.exc_clear()
sys.exc_traceback = sys.last_traceback = None

Tracebacks are used for reporting errors, implementing debuggers and related things. They contain a portion of the program state extracted during the handling of an exception (usually the most recent exception).

In the absence of circularities and tracebacks, Python programs need not explicitly manage memory.

Why doesn’t Python use a more traditional garbage collection scheme? For one thing, this is not a C standard feature and hence it’s not portable. (Yes, we know about the Boehm GC library. It has bits of assembler code for most common platforms, not for all of them, and although it is mostly transparent, it isn’t completely transparent; patches are required to get Python to work with it.)

Traditional GC also becomes a problem when Python is embedded into other applications. While in a standalone Python it’s fine to replace the standard malloc() and free() with versions provided by the GC library, an application embedding Python may want to have its own substitute for malloc() and free(), and may not want Python’s. Right now, Python works with anything that implements malloc() and free() properly.

In Jython, the following code (which is fine in CPython) will probably run out of file descriptors long before it runs out of memory:

for file in <very long list of files>:
f = open(file)
c = f.read(1)

Using the current reference counting and destructor scheme, each new assignment to f closes the previous file. Using GC, this is not guaranteed. If you want to write code that will work with any Python implementation, you should explicitly close the file; this will work regardless of GC:

for file in <very long list of files>:
f = open(file)
c = f.read(1)
f.close()

posted @ 2009-11-30 11:01 九宝 阅读(282) | 评论 (0) | 编辑 收藏

Python 循环引用导致内存泄漏的内存管理TEST ref from：http://meizhini.javaeye.com/blog/249716

posted @ 2009-11-30 10:47 九宝 阅读(1322) | 评论 (0) | 编辑 收藏

Come from : Python源码剖析——Python的内存管理机制

posted @ 2009-11-30 10:35 九宝 阅读(472) | 评论 (0) | 编辑 收藏

Python 小块空间内存管理TEST ref from： http://www.javaeye.com/topic/309753

def test():
   for i in range ( 1000000 * 10 ):
        del i

if ( __name__ == "__main__" ):
    test()
    while ( True ):
        time.sleep( 1 )
观察mem:内存维持不变! 

从这点可以猜测:python不是立即释放资源的.

个人测试代码:
-----------------------------------------------test0.py-------------------------------------

import time

def test():
    for i in range ( 1000000 * 10 ):
        del i

def test_2():
    #i = range ( 1000000 * 10 )
    #del i
    pass

def test_3():
    #i = "*" * ( 1000000 * 10 )
    #del i
    pass

if ( __name__ == "__main__" ):
    for i in range( 10 ):
        test()
        test_2()
        test_3()
        time.sleep( 1 )
    while ( True ):
        time.sleep( 1 )
-----------------------------------------------------test0.py-------------------------------------- 

运行 python test0.py

"while ( True ):
        time.sleep( 1 )
 "
保证python不退出.

发现python的内存占用率为60%.

如何解决这个问题呢?看下面的:

-----------------------------------------------test1.py-------------------------------------

#coding=utf-8
import time

max_number = 1000000 * 10
def test_0():
    for i in range ( max_number ):
        del i

def test_1():
    for i in range( 1000 ):
        for i in range ( max_number / 1000 ):
            del i

if ( __name__ == "__main__" ):
    #test_0()#内存使用率占40%
    test_1()#内存使用率占0.2%
 
    print "---------------------"
    while ( True ):
        time.sleep( 1 )

-----------------------------------------------test1.py-------------------------------------

 我想问题:问题也许解决了.

这就要看你的实际需求是什么了.

例如:

我做过一个爬虫程序,如果不断往这个线程里面传递url,那么这个线程不到一会就挂了.我的改进方法:就是控制这线程能够接受的url队列长度.以及其他的优化.
 其实这个不是循环导致的内存被python持有,而是range( n )让python分配了很多的内存.退出test(),python回收内存,但是python并不释放了,而是让pool持有内存空间.

posted @ 2009-11-27 16:54 九宝 阅读(460) | 评论 (1) | 编辑 收藏

void select_font_face (const std::string &family, FontSlant slant, FontWeight weight)

also:
cr.select_font_face("Droid Sans Bold")  works! Strange!

posted @ 2009-08-12 16:47 九宝 阅读(132) | 评论 (0) | 编辑 收藏

配置SWT开发环境 -Djava.library.path=.\exe

本文假定读者使用Windows操作系统+JDK 1.4，其他平台和JDK版本应该也是八九不离十。

为了编译和运行SWT程序，我们有两种选择：1- 使用Eclipse SDK；2- 下载单独的SWT二进制文件和源文件。

随Eclipse SDK，我们可以在它的plugins目录下找到SWT的二进制文件，通常的目录名称是：org.eclipse.swt.win32_xxxx，后缀是版本号，在这个目录下有os和ws两个子目录，内容分别是SWT的JNI库和swt.jar。

如果不是使用Eclipse来开发，或者需要SWT的源文件，那么需要下载单独的SWT二进制和源文件包，在下面的地址可以找到：

http://mirror.pacific.net.au/eclipse/eclipse/downloads/drops/R-3.0.1-200409161125/swt-3.0.1-win32.zip

这个zip文件解包以后包含JNI库（一些DLL）和swt.jar，以及swtsrc.zip，这个swtsrc就是我们SWT的源文件了，包括C和Java的源代码。

为了运行SWT程序，我们需要首先编译我们SWT的代码，这个时候需要告诉编译器swt.jar的位置；编译成功以后，我们除了指明classpath包含swt.jar之外，需要在命令行告诉java.exe另一个参数，那就是java.library.path，看上去大概是这个样子：

java -cp %SWT_HOME%\swt.jar SimplestSWT -Djava.library.path=%SWT_HOME%

如果你使用的是Eclipse SDK 3.1M5a或者更新的版本，你可以直接右键.java文件选择Run As -> SWT Application，则不用在命令行写那么长的参数了。

比较有意思的是，我们可以在eclipse.org的SWT下载页面看到目前SWT支持的平台：

       Windows 98/ME/2000/XP
       Windows CE (ARM PocketPC)
       Windows CE (ARM PocketPC, J2ME profile)
       Linux (x86/Motif)
       Linux (x86/GTK 2)
       Linux (AMD 64/GTK 2)
       Solaris 8 (SPARC/Motif)
       QNX (x86/Photon)
       AIX (PPC/Motif)
       HP-UX (HP9000/Motif)      
       Mac OSX (Mac/Carbon)
呵呵，支持的平台虽然有限，不过还是蛮多了。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/tiney/archive/2008/09/12/2916785.aspx

posted @ 2009-07-22 16:22 九宝 阅读(957) | 评论 (0) | 编辑 收藏

java中的sizeof（转）

posted @ 2009-06-24 17:02 九宝 阅读(403) | 评论 (0) | 编辑 收藏

批处理-如何对作参数的文件名进行操作

ECHO %~[<format>]<n>

<format>的取值如下：

              以上参数可以组合，其格式是：

%~[{f|d|a|z|s|n|x|t|p}][$<var>:]<n>

posted @ 2009-06-01 16:01 九宝 阅读(699) | 评论 (0) | 编辑 收藏

(转) 经典的DOS批处理入门教程(2)（建议耐心看完，必有收获）

posted @ 2009-06-01 15:52 九宝 阅读(308) | 评论 (0) | 编辑 收藏

(转) 经典的DOS批处理入门教程(1)（建议耐心看完，必有收获）

posted @ 2009-06-01 15:50 九宝 阅读(1299) | 评论 (0) | 编辑 收藏

制作数字签名(转)

一、服务器端：  
          1．将程序需要用到的各种包文件全部解压，然后使用JDK的打包命令将编译好的监控程序.class和刚才解压的包一起打包到一个包中。都是dos状态下的命令，具体命令见jdk1.4的bin目录下，（这里的文件包括JDBC驱动的三个文件）  
    命令如下：  
  jar   cvf     monitor.jar   *.class  
  此命令生成一个名为monitor.jar的包  
  2．为刚才创建的包文件（monitor.jar）创建keystore和keys。其中  
  keystore将用来存放密匙(private   keys)和公共钥匙的认证，alias别名这儿取为monitor。  
  命令如下：  
  keytool   -genkey   -keystore   monitor.keystore   –alias   monitor   -validity   4000  
      此命令生成了一个名为monitor.keystore的keystore文件，  
  接着这条命令，系统会问你好多问题，比如你的公司名称，你  
  的地址，你要设定的密码等等，都由自己的随便写。            
  3．使用刚才生成的钥匙来对jar文件进行签名  
  命令如下：  
      jarsigner     -keystore     monitor.keystore     monitor.jar   monitor  
            这个命令将对monitor.jar文件进行签名，不会生成新文件。                    
  4．将公共钥匙导入到一个cer文件中，这个cer文件就是要拷贝到客户端的唯一文件   。  
  命令如下：  
  keytool     -export     -keystore     monitor.keystore   -alias   monitor     -file     monitor.cer  
                  此条命令将生成monitor.cer认证文件，当然这几步都有可能问你刚  
  才设置的密码。  
  这样就完成了服务器端的设置。这时你就可以将jar文件和keystore文件以及cer文件(我这儿是monitor.jar,monitor.keystore,monitor.cer)拷贝到服务器的目录下了，我用的是Tomcat，所以就拷贝到C:\JBuilder8\thirdparty\jakarta-tomcat-4.1.12-LE-jdk14\webapps\ROOT下的自己建的一个目录下了。    
       
  二、客户端：  
  1．         首先应该安装2re-1_4_1_03-windows-i586-i，然后将服务器端生成的monitor.cer  
  文件拷贝到jre的特定目录下，我这儿是：  
  C:\Program   Files\Java\j2re1.4.1_03\lib\security目录下。  
  2．         将公共钥匙倒入到jre的cacerts（这是jre的默认keystore）  
  命令如下：  
      keytool     -import     -alias   monitor   -file     monitor.cer      
  -keystore     cacerts  
        注意这儿要你输入的是cacerts的密码，应该是changeit，而不  
  是你自己设定的keystore的密码。  
  3．         修改policy策略文件，在dos状态下使用命令     policytool  
  系统会自动弹出一个policytool的对话框，如图4所示，在这里面首先选择file菜单的open项，  
  打开C:\Program   Files\Java\j2re1.4.1_03\lib\security目录下的java.poliy文件，然后在edit菜单中选择Change   keystore   ，在对话框中new   keystore   url:中输入  
  file:/   C:/Program   Files/Java/j2re1.4.1_03/lib/security/cacerts,  
  这儿要注意反斜杠，在new   keystore   type   中输入JKS，这是cacerts的固定格式，然后单击Add   Policy   Entry，在出现的对话框中CodeBase中输入：  
            http://168.168.1.202：8080/*  
  其中的168.168.1.202是我服务器的IP地址，8080是我的Tomcat的端口，如果你是在别的应用服务器上比如说是apache，那端口号就可以省略掉。  
  在SignedBy中输入(别名alias):这儿是Monitor  
  然后单击add   peimission按钮，在出现的对话框中permission中选择你想给这个applet的权限，这儿具体有许多权限，读者可以自己找资料看看。我这儿就选用allpeimission，右边的signedBy中输入别名：monitor  
  最后保存，在file菜单的save项。  
    当然你可以看见我已经对多个包实现了签名认证。  
   
   
  看需要可以选择设不设置客户端.

posted @ 2009-05-19 16:40 九宝 阅读(222) | 评论 (0) | 编辑 收藏

java数字签名（签名生成，用证书验证签名） (转)

证书在公钥加密应用中的作用是保证公钥在某些可信的机构发布，其在协议SSL、电子交易协议SET等方面有重要的应用。图1显示了一个最简单的证书应用方法：

证书的应用步骤是：

（1） A把自己的公钥PKA送到CA(Certificate Authority)；

（2） CA用自己的私钥和A的公钥生成A的证书，证书内包括CA的数字签名。签名对象包括需要在证书中说明的内容，比如A的公钥、时间戳、序列号等，为了简化这里不妨假设证书中只有三项内容：A的公钥PKA、时间戳TIME1、序列号IDA。那么CA发送给A的简单证书凭证可表达为：CertA=Eca[TIME1,IDA,PKA]；

（3） B同样把自己的公钥PKB送到CA；

（4） B得到CA发布的证书CertB;

（5） A告知B证书CertA；

（6） B告知A证书CertB。

A、B各自得到对方证书后，利用从CA得到的公钥(在CA的自签证书中)验证彼此对方的证书是否有效，如果有效，那么就得到了彼此的公钥。利用对方的公钥，可以加密数据，也可以用来验证对方的数字签名。

本文为了方便说明，并没有使用从CA获得的证书，而是通信双方各自产生自签证书，也就是说图1的A和B并没有经过CA，不过前提是A和B之间是互相拥有对方的证书。

证书的内容和意义如表1所示（这里以通用X .509证书格式为例）。

对证书的详细定义及其应用相关的各种协议，这里不加详细说明，详细细节请查看RFC2450、RFC2510、RFC2511、RFC2527、RFC2528、RFC2559、RFC2560、RFC2585、RFC2587等文档。

个人或机构可以从信任的证书分发机构申请得到证书，比如说，可以从http://ca.pku.edu.cn 得到一个属于个人的证书。这里可以利用J2SDK的安全工具keytool手工产生自签证书，所谓自签证书是指证书中的“Subject Name”和“Issuer Name”相同的证书。

下面产生一个自签证书。安装完J2SDK（这里用的是J2SDK1.4）后，在J2SDK安装目录的bin目录下，有一个keytool的可执行程序。利用keytool产生自签证书的步骤如下：

第一步，用-genkey命令选项，产生公私密钥对。在控制台界面输入：keytool -genkey -alias testkeypair -keyalg RSA -keysize 1024 -sigalg MD5withRSA。这里的-alias表示使用这对公私密钥产生新的keystore入口的别名(keystore是用来存放管理密钥对和证书链的，缺省位置是在使用者主目录下，以.keystore为名的隐藏文件，当然也可指定某个路径存放.keystore文件)；-keyalg是产生公私钥对所用的算法，这里是RSA；-keysize定义密钥的长度；-sigalg是签名算法，选择MD5withRSA，即用RSA签名，然后用MD5哈希算法摘要。接下来，系统会提示进行一些输入：

输入keystore密码： abc123 您的名字与姓氏是什么？ [Unknown]： Li 您的组织单位名称是什么？ [Unknown]： InfosecLab 您的组织名称是什么？ [Unknown]： InfosecLab Group 您所在的城市或区域名称是什么？ [Unknown]： Beijing 您所在的州或省份名称是什么？ [Unknown]： Beijing 该单位的两字母国家代码是什么 [Unknown]： CN CN=Li, OU=InfosecLab, O=InfosecLab Group, L=Beijing, ST=Beijing, C=CN 正确吗？ [否]： y 输入<testkeypair>的主密码 (如果和 keystore 密码相同，按回车）：

第二步，产生自签证书，输入以下命令：

keytool -selfcert -alias testkeypair -dname "CN=Li, OU=InfosecLab, O=InfosecLab Group, L=Beijing, ST=Beijing, C=CN" 输入keystore密码： abc123

第三步，导出自签证书，由上面两步产生的证书，已经存放在以“testkeypair”为别名的keystore入口了，如果使用其文件，必须导出证书。输入:

keytool -export -rfc -alias testkeypair -file mycert.crt 输入keystore密码： abc123 保存在文件中的认证 <mycert.crt>

这样，就得到了一个自签的证书mycert.crt。注意，选项rfc是把证书输出为RFC1421定义的、用Base64最终编码的格式。

Java为安全应用提供了丰富的API，J2SDK1.4 的JSSE (JavaTM Secure Socket Extension) 包括javax.security.certificate包，并且提供对证书的操作方法。而对证书的读操作，只用java.security.cert. CertificateFactory和java.security.cert.X509Certificate就可以了。下面是读取证书内容的部分代码：

import javax.swing.*; import java.awt.*; import java.awt.event.*; import javax.swing.table.*; import java.security.cert.CertificateFactory; import java.security.cert.X509Certificate; import java.io.*; public class CARead extends JPanel { private String CA_Name; private String CA_ItemData[][] = new String[9][2]; private String[] columnNames = {"证书字段标记","内容" }; public CARead(String CertName) { CA_Name=CertName; /* 三个Panel用来显示证书内容*/ JTabbedPane tabbedPane = new JTabbedPane(); JPanel panelNormal = new JPanel(); tabbedPane.addTab("普通信息", panelNormal); JPanel panelAll=new JPanel(); panelAll.setLayout(new BorderLayout()); tabbedPane.addTab("所有信息",panelAll); JPanel panelBase64=new JPanel(); panelBase64.setLayout(new BorderLayout()); tabbedPane.addTab("Base64编码信息",panelBase64); /* 读取证书常规信息 */ Read_Normal(panelNormal); /* 读取证书文件字符串表示内容 */ Read_Bin(panelAll); /* 读取证原始Base64编码形式的证书文件 */ Read_Raw(panelBase64); tabbedPane.setSelectedIndex(0); setLayout(new GridLayout(1, 1)); add(tabbedPane); } /*以下是定义的Read_Normal()，Read_Bin(),Read_Raw()以及main() 这里省略... */ }

定义证书信息的读取函数如下：

private int Read_Normal(JPanel panel){ String Field; try{ CertificateFactory certificate_factory=CertificateFactory.getInstance("X.509"); FileInputStream file_inputstream=new FileInputStream(CA_Name); X509Certificate x509certificate=(X509Certificate)certificate_factory.generateCertificate (file_inputstream); Field=x509certificate.getType(); CA_ItemData[0][0]="类型"; CA_ItemData[0][1]=Field; Field=Integer.toString(x509certificate.getVersion()); CA_ItemData[1][0]="版本"; CA_ItemData[1][1]=Field; Field=x509certificate.getSubjectDN().getName(); CA_ItemData[2][0]="标题"; CA_ItemData[2][1]=Field; /* 以下类似，这里省略 Field=x509certificate.getNotBefore().toString();得到开始有效日期 Field=x509certificate. getNotAfter().toString();得到截止日期 Field=x509certificate.getSerialNumber().toString(16);得到序列号 Field=x509certificate.getIssuerDN().getName();得到发行者名 Field=x509certificate.getSigAlgName();得到签名算法 Field=x509certificate.getPublicKey().getAlgorithm();得到公钥算法 */ file_inputstream.close(); final JTable table = new JTable(CA_ItemData, columnNames); TableColumn tc=null; tc = table.getColumnModel().getColumn(1); tc.setPreferredWidth(600); panel.add(table); }catch(Exception exception){ exception.printStackTrace(); return -1; } return 0; }

如果以字符串形式读取证书，加入下面Read_Bin这个函数。其中CertificateFactory.generateCertificate() 这个函数可以从证书标准编码(RFC1421定义)中解出可读信息。Read_Bin函数代码如下：

private int Read_Bin(JPanel panel){ try{ FileInputStream file_inputstream=new FileInputStream(CA_Name); DataInputStream data_inputstream=new DataInputStream(file_inputstream); CertificateFactory certificatefactory=CertificateFactory.getInstance("X.509"); byte[] bytes=new byte[data_inputstream.available()]; data_inputstream.readFully(bytes); ByteArrayInputStream bais=new ByteArrayInputStream(bytes); JEditorPane Cert_EditorPane; Cert_EditorPane=new JEditorPane(); while(bais.available()>0){ X509Certificate Cert=(X509Certificate)certificatefactory.generateCertificate(bais); Cert_EditorPane.setText(Cert_EditorPane.getText()+Cert.toString()); } Cert_EditorPane.disable(); JScrollPane edit_scroll=new JScrollPane(Cert_EditorPane); panel.add(edit_scroll); file_inputstream.close(); data_inputstream.close(); }catch( Exception exception){ exception.printStackTrace(); return -1; } return 0; }

如果要得到原始证书编码后的信息，则可用如下代码：

private int Read_Raw(JPanel panel){ try{ JEditorPane Cert_EditorPane=new JEditorPane(); String CertText=null; File inputFile = new File(CA_Name); FileReader in = new FileReader(inputFile); char[] buf=new char[2000]; int len=in.read(buf,0,2000); for(int i=1;i<len;i++) { CertText=CertText+buf[i]; } in.close(); Cert_EditorPane.setText(CertText); Cert_EditorPane.disable(); JScrollPane edit_scroll=new JScrollPane(Cert_EditorPane); panel.add(edit_scroll); }catch( Exception exception){ exception.printStackTrace(); return -1; } return 0; }

最后用这个小程序看一看刚才生成的证书mycert.crt内容，把文件名写入main()中：

public static void main(String[] args) { JFrame frame = new JFrame("证书阅读器"); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0);} }); frame.getContentPane().add(new CARead("mycert.crt"),BorderLayout.CENTER); frame.setSize(700, 425); frame.setVisible(true); }

证书mycert.crt的内容显示如图2所示，所有信息和Base64的显示内容，这里不再列举。

现在已经读取了证书的一些内容，那么怎样使用证书呢？我们可以假设A和B要共享一个绝密的文件F，B信任并拥有A的证书，也就是说B拥有A的公钥。那么A通过A和B共知的加密算法(对称密钥算法，比如DES算法)先加密文件F，然后对加密后的F进行签名和散列摘要(比如MD5算法，目的是保证文件的完整性)，然后把F发送到B。B收到文件后，先用A的证书中的公钥验证签名，然后再用通过共知的加密算法解密，就可以得到原文件了。这里使用的数字签名，可以保证B得到的文件，就是A的，A不能否认其不拥有文件F，因为只有A拥有可以让A的公钥验证其签名的私钥，同时这里使用DES算法加密，使得文件有保密性。

使用DES算法的加密解密函数类似，这里不对加密算法做进一步讨论，详细请看J2SDK的JSE部分内容，加密签名、解密验证文件结构见图3。



图3 加密签名、解密验证文件结构图

加密函数中的desKeyData存放DES加密密钥，如果要在程序中指定，可以设置为：

static byte[] desKeyData = { (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x08 };

加密函数写成：

public static void crypt(byte[] cipherText,String outFileName){ try{ DESKeySpec desKeySpec = new DESKeySpec(desKeyData); SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); SecretKey secretKey = keyFactory.generateSecret(desKeySpec); Cipher cdes = Cipher.getInstance("DES"); cdes.init(Cipher.ENCRYPT_MODE, secretKey); byte[] ct = cdes.doFinal(cipherText); try{ FileOutputStream out=new FileOutputStream(outFileName); out.write(ct); out.close(); }catch(IOException e){ e.printStackTrace(); } }catch (Exception e){ e.printStackTrace(); } }

其中ct就是加密后的内容,outFileName保存加密后文件的文件名。把cdes.init(Cipher.ENCRYPT_MODE, secretKey)换成cdes.init(Cipher.DECRYPT_MODE, secretKey)就是解密文件了。

文件加密后就要对文件签名，保证A发送到B的文件不可伪造。下面是用存放在.keystore中的私钥进行签名的函数，签名使用的摘要算法是MD5。其中sigText是被签名内容的输入数组，outFileName是保存签名后输出文件的名称，KeyPassword是读取Keystore使用的密码，KeyStorePath是存放.keystore文件的路径，函数代码如下：

public static void sig(byte[] sigText, String outFileName,String KeyPassword,String KeyStorePath){ char[] kpass; int i; try{ KeyStore ks = KeyStore.getInstance("JKS"); FileInputStream ksfis = new FileInputStream(KeyStorePath); BufferedInputStream ksbufin = new BufferedInputStream(ksfis); kpass=new char[KeyPassword.length()]; for(i=0;i<KeyPassword.length();i++) kpass[i]=KeyPassword.charAt(i); ks.load(ksbufin, kpass); PrivateKey priv = (PrivateKey) ks.getKey(KeystoreAlias,kpass ); Signature rsa=Signature.getInstance("MD5withRSA"); rsa.initSign(priv); rsa.update(sigText); byte[] sig=rsa.sign(); System.out.println("sig is done"); try{ FileOutputStream out=new FileOutputStream(outFileName); out.write(sig); out.close(); }catch(IOException e){ e.printStackTrace(); } }catch(Exception e){ e.printStackTrace(); } }

验证签名需要存放签名文件和被签名的文件以及证书，其中，updateData存放被签名文件的内容，sigedText存放得到的签名内容，CertName是证书名。验证签名代码如下：

public static void veriSig(byte[] updateData, byte[] sigedText){ try{ CertificateFactory certificatefactory=CertificateFactory.getInstance("X.509"); FileInputStream fin=new FileInputStream(CertName); X509Certificate certificate=(X509Certificate)certificatefactory.generateCertificate(fin); PublicKey pub = certificate.getPublicKey(); Signature rsa=Signature.getInstance("MD5withRSA"); rsa.initVerify(pub); rsa.update(updateData); boolean verifies=rsa.verify(sigedText); System.out.println("verified "+verifies); if(verifies){ System.out.println("Verify is done!"); }else{ System.out.println("verify is not successful"); } }catch(Exception e){ e.printStackTrace(); } }

可以用keytool产生两个自签的签名证书，或者到某个CA去申请两个证书。用Java编写加密和验证程序，上述例子只是一个非常简单的证书应用，实际协议对证书的使用(比如SSL)要比这个复杂多了。

posted @ 2009-05-19 16:30 九宝 阅读(478) | 评论 (0) | 编辑 收藏

Java加密和数字签名编程快速入门（转）

Java加密和数字签名编程快速入门

posted @ 2009-05-19 16:21 九宝 阅读(218) | 评论 (0) | 编辑 收藏

Python- 映射 list

posted @ 2009-05-14 11:57 九宝 阅读(253) | 评论 (0) | 编辑 收藏

Python study -格式化字符串

posted @ 2009-05-14 11:50 九宝 阅读(249) | 评论 (0) | 编辑 收藏

Python study- List extend() and append()

>>> li = ['a', 'b']

>>> li = li + ['example', 'new'] 

>>> li

['a', 'b', 'example', 'new']

>>> li += ['two']              

>>> li

['a', 'b', 'example', 'new', 'two']

>>> li = [1, 2] * 3      

>>> li

[1, 2, 1, 2, 1, 2]

posted @ 2009-05-14 11:15 九宝 阅读(745) | 评论 (0) | 编辑 收藏

Creating a JAR File(转)

 Creating a JAR File

The basic format of the command for creating a JAR file is:

jar cf jar-file input-file(s)

Let's look at the options and arguments used in this command:

• The c option indicates that you want to create a JAR file.
• The f option indicates that you want the output to go to a file rather than to stdout.
• jar-file is the name that you want the resulting JAR file to have. You can use any filename for a JAR file. By convention, JAR filenames are given a .jar extension, though this is not required.
• The input-file(s) argument is a space-delimited list of one or more files that you want to be placed in your JAR file. The input-file(s) argument can contain the wildcard * symbol. If any of the "input-files" are directories, the contents of those directories are added to the JAR archive recursively.

The c and f options can appear in either order, but there must not be any space between them.

This command will generate a compressed JAR file and place it in the current directory. The command will also generate a default manifest file for the JAR archive.

You can add any of these additional options to the cf options of the basic command:

jar cmf existing-manifest jar-file input-file(s)
            

In version 1.1, the JAR-file format supports only ASCII filenames. Version 1.2 adds support for UTF8-encoded names.

Let's look at an example. The JDK demos include a simple TicTacToe applet. This demo contains a bytecode class file, audio files, and images all housed in a directory called TicTacToe having this structure:

The audio and images subdirectories contain sound files and GIF images used by the applet.

To package this demo into a single JAR file named TicTacToe.jar, you would run this command from inside the TicTacToe directory:

jar cvf TicTacToe.jar TicTacToe.class audio images

The audio and images arguments represent directories, so the Jar tool will recursively place them and their contents in the JAR file. The generated JAR file TicTacToe.jar will be placed in the current directory. Because the command used the v option for verbose output, you'd see something similar to this output when you run the command:

adding: TicTacToe.class
            (in=3825) (out=2222) (deflated 41%)
            adding: audio/ (in=0) (out=0) (stored 0%)
            adding: audio/beep.au
            (in=4032) (out=3572) (deflated 11%)
            adding: audio/ding.au
            (in=2566) (out=2055) (deflated 19%)
            adding: audio/return.au
            (in=6558) (out=4401) (deflated 32%)
            adding: audio/yahoo1.au
            (in=7834) (out=6985) (deflated 10%)
            adding: audio/yahoo2.au
            (in=7463) (out=4607) (deflated 38%)
            adding: images/ (in=0) (out=0) (stored 0%)
            adding: images/cross.gif
            (in=157) (out=160) (deflated -1%)
            adding: images/not.gif
            (in=158) (out=161) (deflated -1%)
            

You can see from this output that the JAR file TicTacToe.jar is compressed. The Jar tool compresses files by default. You can turn off the compression feature by using the 0 (zero) option, so that the command would look like:

jar cvf0 TicTacToe.jar TicTacToe.class audio images

You might want to avoid compression, for example, to increase the speed with which a JAR file could be loaded by a browser. Uncompressed JAR files can generally be loaded more quickly than compressed files because the need to decompress the files during loading is eliminated. However, there's a tradeoff in that download time over a network may be longer for larger, uncompressed files.

The Jar tool will accept arguments that use the wildcard * symbol. As long as there weren't any unwanted files in the TicTacToe directory, you could have used this alternative command to construct the JAR file:

jar cvf TicTacToe.jar *

Though the verbose output doesn't indicate it, the Jar tool automatically adds a manifest file to the JAR archive with pathname META-INF/MANIFEST.MF. See the Understanding the Manifest section for information about manifest files.

In the above example, the files in the archive retained their relative pathnames and directory structure. The Jar tool in version 1.2 of the Java Development Kit provides the -C option that you can use to create a JAR file in which the relative paths of the archived files are not preserved. It's modeled after GZIP's -C option.

As an example, suppose you wanted put audio files and gif images used by the TicTacToe demo into a JAR file, and that you wanted all the files to be on the top level, with no directory hierarchy. You could accomplish that by issuing this command from the parent directory of the images and audio directories:

jar cf ImageAudio.jar -C images * -C audio *

The -C images part of this command directs the Jar tool to go to the images directory, and the * following -C images directs the Jar tool to archive all the contents of that directory. The -C audio * part of the command then does the same with the audio directory. The resulting JAR file would have this table of contents:

META-INF/MANIFEST.MF
            cross.gif
            not.gif
            beep.au
            ding.au
            return.au
            yahoo1.au
            yahoo2.au
            

By contrast, suppose that you used a command that didn't employ the -C option:

jar cf ImageAudio.jar images audio

The resulting JAR file would have this table of contents:

META-INF/MANIFEST.MF
            images/cross.gif
            images/not.gif
            audio/beep.au
            audio/ding.au
            audio/return.au
            audio/yahoo1.au
            audio/yahoo2.au
            

posted @ 2009-03-30 11:27 九宝 阅读(269) | 评论 (0) | 编辑 收藏

版本与固件刷包知识讲解(转)

版本与固件刷包知识讲解

posted @ 2009-03-20 14:07 九宝 阅读(265) | 评论 (0) | 编辑 收藏

perl print @

posted @ 2009-02-18 15:00 九宝 阅读(336) | 评论 (0) | 编辑 收藏

关于java的JIT知识（转）

什么是JIT？

JIT是just in time,即时编译技术。使用该技术，能够加速java程序的执行速度。下面，就对该技术做个简单的讲解。

首先，我们大家都知道，通常javac将程序源代码编译，转换成java字节码，JVM通过解释字节码将其翻译成对应的机器指令，逐条读入，逐条解释翻译。很显然，经过解释执行，其执行速度必然会比可执行的二进制字节码程序慢。为了提高执行速度，引入了JIT技术。

在运行时JIT会把翻译过的机器码保存起来，已备下次使用，因此从理论上来说，采用该JIT技术可以，可以接近以前纯编译技术。下面我看看，JIT的工作过程。

JIT 编译过程

当JIT编译启用时（默认是启用的），JVM读入.class文件解释后，将其发给JIT编译器。JIT编译器将字节码编译成本机机器代码，下图展示了该过程。

什么是JIT？

JIT是just in time,即时编译技术。使用该技术，能够加速java程序的执行速度。下面，就对该技术做个简单的讲解。

首先，我们大家都知道，通常javac将程序源代码编译，转换成java字节码，JVM通过解释字节码将其翻译成对应的机器指令，逐条读入，逐条解释翻译。很显然，经过解释执行，其执行速度必然会比可执行的二进制字节码程序慢。为了提高执行速度，引入了JIT技术。

在运行时JIT会把翻译过的机器码保存起来，已备下次使用，因此从理论上来说，采用该JIT技术可以，可以接近以前纯编译技术。下面我看看，JIT的工作过程。

JIT 编译过程

当JIT编译启用时（默认是启用的），JVM读入.class文件解释后，将其发给JIT编译器。JIT编译器将字节码编译成本机机器代码，下图展示了该过程。

通过上面的解释，我们了解了JIT的工作原理及过程，同样也发现了个问题，由于JIT对每条字节码都进行编译，造成了编译过程负担过重。为了避免这种情况，当前的JIT只对经常执行的字节码进行编译，如循环等。

需要说明的是，JIT并不总是奏效，不能期望JIT一定能够加速你代码执行的速度，更糟糕的是她有可能降低代码的执行速度。这取决于你的代码结构，当然很多情况下我们还是能够如愿以偿的。

posted @ 2009-01-13 14:18 九宝 阅读(2130) | 评论 (0) | 编辑 收藏

[Embedded]嵌入式 Linux 的根文件系统 - rootfs (转)

* 嵌入式系统中主要的存储介质 Flash 是稀有资源，为数不多的 RAM 也是。在嵌入式
系统开发中，开发人员十分珍惜这两种资源，也想出了许多办法解决资源短缺的问题。
* Linux 中，rootfs 是必不可少的。PC 上主要实现有 ramdisk 和直接挂载 HD（
Harddisk，硬盘） 上的根文件系统；嵌入式中一般不从 HD 启动，而是从 Flash 启
动，最简单的方法是将 rootfs load 到 RAM 的 RAMDisk，稍复杂的就是 直接从
Flash 读取的 Cramfs，更复杂的是在 Flash 上分区，并构建 JFFS2 等文件系统。
* RAMDisk 将制作好的 rootfs 压缩后写入 Flash，启动的时候由 Bootloader load 到
RAM，解压缩，然后挂载到 /。这种方法操作简单，但是在 RAM 中的文件系统不是压
缩的，因此需要占用许多嵌入式系统中稀有资源 RAM。
* initrd 是 RAMDisk 的格式，kernel 2.4 之前都是 image-initrd，Kernel 2.5 引入
了 cpio-initrd，大大简化了 Linux 的启动过程，附合 Linux 的基本哲学：Keep it
simple, stupid(KISS). 不过，cpio-initrd 作为新的格式，还没有经过广泛测试，
嵌入式 Linux 中主要采用的还是 image-initrd。
* Cramfs 是 Linus 写的很简单的文件系统，有很好的压缩绿，也可以直接从 Flash 上
运行，不须 load 到 RAM 中，因此节约了 RAM。但是 Cramfs 是只读的，对于需要运
行时修改的目录（如： /etc, /var, /tmp）多有不便，因此，一般将这些目录做成
ramfs 等可写的 fs。
* SquashFS 是对 Cramfs 的增强。突破了 Cramfs 的一些限制，在 Flash 和 RAM 的使
用量方面也具有优势。不过，据开发者介绍，在性能上可能不如 Cramfs。这也是一种
新方法，在嵌入式系统采用之前，需要经过更多的测试。
* XIP（exece-in-place，就地运行) 是一种不须将应用程序 load 到 RAM 就可以运行
的技术，无疑可以减少 RAM 的使用。不过在嵌入式系统我还没有遇到这种技术的使用

posted @ 2008-12-29 16:58 九宝 阅读(901) | 评论 (0) | 编辑 收藏