亚洲一区二区三区精品视频,国产偷国产偷亚洲清高APP,亚洲成人动漫在线观看

Wed, 18 Apr 2012 03:35:00 GMT

1.linux安装字体
以微软雅黑�ؓ例，扑ֈ�msyh.ttf ,copy至下面的文�g�?br />

usr/share/fonts/msyh

执行命��o�Q�fc-cache -fv

重启jvm卛_��
2.drawString 部分代码

private static BufferedImage drawString(int type, boolean isWhite,
           int width, int height, String price, Font font_money, Font font,
           Graphics2D g2d, Rectangle2D bounds, Rectangle2D bounds_money) {
       BufferedImage image;
       //透明背景
        image = g2d.getDeviceConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);
       g2d.dispose();
       g2d = image.createGraphics();
       //反锯齿字�?br />       g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
       if(!isWhite){
           //非白�?br />           g2d.setColor(new Color(236,0,137));
       }else{
             //白字
             g2d.setColor(new Color(255,255,255));
       }
       //字体居中
       double y = (height - bounds.getHeight()) / 2;
         double ascent = -bounds.getY();
         double baseY = y + ascent;

       g2d.setStroke(new BasicStroke(1));
       g2d.setFont(font_money);
       g2d.drawString(FONT_RMB_CHAR, -2, (int)baseY);
       g2d.setFont(font);
       g2d.drawString(price, (int)bounds_money.getWidth()-4, (int)baseY);
         g2d.dispose();
       return image;
   }

3.如果需要根据字�W�串的长度生成图片的宽度�Q�可以��用如下方�?/div>

Rectangle2D bounds = font.getStringBounds(price, context);
width = (int)(bounds.getWidth();

4.扚w��生成,使用java自带的线�E�池�Q��ƈ使用CompletionService�Q�目的是在线�E�处理结束后得到生成成功的ProductId

      public boolean generateImagesBatch(){
          boolean flag=true;
          ExecutorService exec = Executors.newFixedThreadPool(8);
           CompletionService completionService=
                    new ExecutorCompletionService(exec);
          long startTime=System.currentTimeMillis();
           String sql="select productId,price from prod";
           List skuList = this.cmsJdbcTemplate.queryForList(sql);
           for(Map map:skuList){
               String prodId=((BigDecimal)map.get("productId")).toString();
               double price=((BigDecimal)map.get("price")).doubleValue();
               completionService.submit(new CreateImageConcurrent(prodId,price,FontEnum.ONE,false));
                completionService.submit(new CreateImageConcurrent(prodId,price,FontEnum.TWO,false));            }
           long endTime=System.currentTimeMillis()-startTime;
           log.info("query db time>>>>>>>>>>>>>>"+endTime/1000);

           Future future;
           int count=skuList.size()*6;
           log.info("generateImagesBatch count:"+count);
           try {
               while(count>0){
                    future = completionService.take();
                   CallBack callBack = future.get();
                   if(null!=callBack){
                       count--; log.info("generateImagesBatch prod id:"+callBack.getSuccesMessage());                    }
                }
           endTime=System.currentTimeMillis()-startTime;
           log.info("create images time>>>>>>>>>>>>>>"+endTime/1000);
           log.info("generateImagesBatch success!");
           flag=true;
           } catch (ExecutionException e) {
               flag=false;
               log.error("generateImagesBatch fail::ExecutionException::"+e.getMessage());
           } catch (InterruptedException e) {
               flag=false;
               log.error("generateImagesBatch fail::InterruptedException::"+e.getMessage());
           }finally{
               exec.shutdown();
           }
           return flag;
      }

阮步�?/a> 2012-04-18 11:35 发表评论

Java多线�E�笔�?4)

Wed, 15 Dec 2010 10:18:00 GMT

以下只是一些概�?br />

1.Semaphore�?a name="N100B4">CountDownLatch
Semaphore 可用于控�?/span>特定资源��h��Q�线�E?操作�Q�数�?br /> CountDownLatch 在功能上�c�M��?/span>Semaphore。区别是�Q?/span>Semaphore允许一�ơ一个线�E�的话，CountDownLatch可以允许多个�U�程在特定的旉��一��h��行�?br />
2.CAS操作
�Ҏ��英文直译其实可以理解其含义，compare and set.

CAS 操作包含三个操作�?—�? 内存位置�Q�V�Q�、预期原��|��A�Q�和新�?B)。如果内存位�|�的��g��预期原值相匚w��Q�那么处理器会自动将该位�|�值更��Cؓ新倹{��否则，处理器不做�Q何操作。CAS 认�ؓ位置 V 应该包含�?A�Q�如果包含该��|��则将 B 攑ֈ��q�个位置�Q�否则，不要更改该位�|�，只告诉我�q�个位置现在的值即可通常��?CAS 用于同步的方式是从地址 V ��d��?A�Q�执行多步计��来获得新�?B�Q�然后��?CAS ��?V 的��g�� A 改�ؓ B。如�?V 处的值尚未同时更改，�?CAS 操作成功�?

3.ABA问题

因�ؓ在更�?V 之前�Q�CAS 主要询问“V 的值是否仍�?A”�Q�所以在�W�一�ơ读�?V 以及�?V 执行 CAS 操作之前�Q�如果将��g�� A 改�ؓ B�Q�然后再改回 A�Q�会使基�?CAS 的算法�؜乱。在�q�种情况下，CAS 操作会成功，但是在一些情况下�Q�结果可能不是您所预期的。这�c�问题称�? ABA 问题�?code>

4.原子操作

A与B两个操作。从执行A的线�E�看�Q�当其他�U�程执行B�Ӟ��要么B全部执行完成�Q�要么一炚w��不执行。这样A与B互�ؓ原子操作。要保证数据状态的一致性，要在单一的原子操作中更新所有相兌��的状态�?/p> 5.可见�?br />
在单�U�程环境下，��d��操作都在一个线�E�内完成�Q�不存在可见性问题。但是，当读与写操作不在同一个线�E�内�Ӟ��需要有可见性的要求——即可变的共享变量对所有线�E�都是可见的�?br />

6.重排�?/p>

JVM实现中，�U�程内部�l�持��序化语义。如果程序的最�l�结果等同于它在严格的顺序化环境下的�l�果�Q�那么指令的执行��序��可能与代码的顺序不一致。这个过�E�通过叫做指��o的重排序。比如Java存储模型允许�~�译器重排序操作指��o�Q�在寄存器中�~�存数��|��q�允许CPU重排序，�q�在处理器的�~�存中缓存数倹{�?br />

当然�Q�在没有同步的多�U�程情况下，�~�译器，处理器，�q�行时安排操作的执行��序可能完全��Z�h意料�?/p>

7.内部�?/p>

每个Java对象都可以隐士的扮演一个用于同步的锁的角色。比如synchronized(object){},执行�U�程�q�入synchronized�? 之前自动获得锁。无论是正确执行或是抛出异常�Q�最�l�都会释放该锁。内部锁是一�U�互斥锁(mutex)——至多只有一个线�E�可以拥有锁。JDK中有该锁的实现�?/p>

8.锁与内存

锁不仅仅是关于同步与互斥�Q�也是关于内存可见性的。�ؓ了保证所有线�E�都能访问共享变量的最新��|��d��写的�U�程必须使用公用的锁�q�行同步�?/p>

9.锁与volatile

加锁可以保证可见性与原子性，volatile只能保证可见性�?/p>

10.happen-before法则

Java存储模型有一个happens-before原则�Q�就是如果动作B要看到动作A的执行结果（无论A/B是否在同一个线�E�里面执行）�Q�那么A/B��需要满��happens-before关系。比如一个对象构造函数的�l�束happens-before与该对象的finalizer的开�?/p>

参�?https://www.ibm.com/developerworks/cn/java/j-jtp11234/

http://www.ibm.com/developerworks/cn/java/j-5things5.html

http://www.tkk7.com/xylz/archive/2010/07/03/325168.html

《Java �q�发�~�程实践�?br />

阮步�?/a> 2010-12-15 18:18 发表评论

BTrace 工具使用(1)

Fri, 10 Dec 2010 10:30:00 GMT

BTrace是一个实时监控工��P��使用�?/span>java agent �?/span>jvm attach技术，可以在product的情况下实时监控�U�上�E�序的运行情�?/span>。另�Q�有插�g可与visualVM一起��用�?br /> 不多说了�Q�具体的可见:http://kenai.com/projects/btrace

下面介绍几个Helloworld�C�Z��:
主要使用了btrace命��o:btrace [pid] class

pid可由jps命��o快速查�?br />
1.监控�Ҏ��输入参数:
@OnMethod(
                clazz="com.btrace.Person",
                method="/set.*/"
            )
            public static void anyRead(@ProbeClassName String pcn, @ProbeMethodName String pmn, AnyType[] args) {
                println(pcn);
                println(pmn);
                printArray(args);
            }

执行btract命��o
后台输出:
com.btrace.Person
setId
[1, ]……

2.监控�Ҏ��q�回�?br /> @OnMethod(
                 clazz="com.btrace.Person",
                 method="/get.*/",
                 location=@Location(Kind.RETURN)
               )
    public static void defineclass(@Return String cl) {
           println(Strings.strcat("getValue ", cl));
           Threads.jstack();
       }
执行btract命��o
后台输出:
getValue gum
com.btrace.TestThread.main(TestThread.java:23)

3.监控jvm内存使用情况
@OnTimer(4000)
    public static void printMem() {
        println("Heap:");
        println(heapUsage());
        println("Non-Heap:");
        println(nonHeapUsage());
    }
执行btract命��o
后台输出:
Heap:
init = 268435456(262144K) used = 26175176(25561K) committed = 251658240(245760K)
max = 492175360(480640K)
Non-Heap:
init = 12746752(12448K) used = 5892104(5754K) committed = 13598720(13280K) max =
100663296(98304K)
4.监控�Ҏ��执行旉��
   @TLS private static long startTime;

    @OnMethod(clazz="com.btrace.Person",method="setId")
    public static void onCall(){
        println("enter this method");
        startTime=timeMillis();
    }

    @OnMethod(clazz="com.btrace.Person",method="setId",location=@Location(Kind.RETURN))
    public static void onReturn(){
        println("method end!");
        println(strcat("Time taken ms",str(timeMillis()-startTime)));
    }
后台输出:
   enter this method
   method end!
   Time taken ms0
5.监控Thread start
@OnMethod(
        clazz="java.lang.Thread",
        method="start"
    )
    public static void func() {
        println("about to start a thread!");
    }
后台输出�Q�about to start a thread!

阮步�?/a> 2010-12-10 18:30 发表评论

Java多线�E�笔�?3)

Thu, 11 Nov 2010 09:47:00 GMT

一.限制设计——从�l�构上说�Q�是利用��装技术，保证某一时刻只有一个活动访问某个对象�?/p>

方式主要三类�Q�方法限制、线�E�限制和对象内限�?/p>

�Ҏ��限制:

1.�Ҏ��内部限制:采用局部变量方�?/p>

2.�Ҏ��间传递限�Ӟ��

a.调用者copy�Q�比如print(p) 可以改�ؓprint(new Point(p));

b.接收者copy�Q�Point p=new Point(p.x,p.y);

c.标量参数�Q�print(int x,int y);d.print(p.x,p.y);

�U�程限制�Q?/strong>

   1.最��单的�Ҏ��是将所有可变对象都攑֜�一个线�E�内执行

               public display(){

                         new Thread(){

                                  public void run(){//do something here}

                      }.start()

                }

      2.�U�程�U�有成员变量

         最直接的办法是利用现有�c?ThreadLocal.

        当然你可以利用Thread.currentThread()自己实现一个类似功能的�c?但Thread.currentThread有限�Ӟ��是对特定线�E�的一�c�R�?/p>
        而ThreadLocal则摆�׃��q�样的限制。而且在线�E�内对ThreadLocal�U�有变量的读写不需要同步�?/p>
对象限制�Q?/p>
       在前面两�U�方法都不能做到对对象的限制讉K��Ӟ��你就不得不��用锁。但同时�Q�也可以对对象内部及不同部分的访问进行结构上的限制�?/p>
     1.适配器模�?/p>
      比如 class Point{

                 public double x;

                 public double y;

                 public synchronized double getX(){};

                //……

      }

    采用对象限制的设计方式，会将synchronized 锁移除到一个其他对象里�Q�这样就解脱了Point.

     like this

           class SychPoint {

                 private final Point point=new Point();

                public synchronized double getX(){point.x}

         }

    class Point{

                 public double x;

                 public double y;

                 public double getX(){};

      }

    说白了就是采用适配器模式，改变了一下原来类的结构。java.util.Collection framework 里面��是使用�q�种�{�略�l�织起集合类的同步�?/p>
   2.子类�?/p>
       ��锁延迟到子�c�d��玎ͼ��q�里��不再罗嗦�?/p>
�?同步设计

     使用锁的注意事项

       1.有些入口锁在只有��数�U�程讉K��的情况下�Q�可以很好的工作�Q�开销�q�不大。但是当�q�发量变大，竞争加剧�Q�开销也变大，�pȝ��的性能会随之下降。大多数�U�程会把大部分时间浪费在�{�待上。系�l�出��C��延迟�Q�限制了�q�发�pȝ��的优��性�?/p>
       2.使用太多的锁�Q�会增加�pȝ��负担�Q�以及不可料的情况发生，比如死锁�?/p>
       3.只用一把锁来保护一个功能的多个斚w��会导致资源竞争�?/p>
       4.长时间持有锁�Q�会带来性能问题和异常处理的复杂�?/p>
       5.有时候加锁�ƈ不一定能保证得到我们惌��的结果�?/p>
    对付以上�q�些问题�Q�没有什么最佳策略，大都需要去权衡各个斚w��的利弊来�q�行设计。写多线�E�的�E�序�Q�前期的设计比后期维护更为重要�?/p>
    初期的设计原则，

        1.减少同步

             a.用户可以接受陈旧数据�Q�可以拿掉同步，使用volatile

             b.用户在得到非法数据时�Q�只要能得到提示��够了，可以使用double-check�Ҏ��?/p>
                在不同步时check一�ơ，再在同步状态在check一�ơ。这么做的意义在于羃��锁使用范围�Q�在�W�一�ơcheck不满��的情况�Q�蟩出方法，那么锁也��q��不到了�?/p>
             c.只对�l�护状态部分加锁：当对象的某个同步�Ҏ��是比较耗时的操作，那么锁持有的旉��p��长，而仅仅是��Z��保持一个状态是�Q�可以采用openCall的方式，减少持有锁时间�?/p>
                              public sychronized void updateState(){}

                              public void readFile(){

                                      updateState();//持有�?/p>
                                    file.read();

                               }

               如上�Q�这�U�方式的前提是程序不需要同步一个方法中无状态的部分。如果整个方法都需要锁�Q�那�q�种方式��׃��适用�?

            D.能��用同步块�Q�就不需同步整个�Ҏ��?/p>
     2.分解同步�Q?/p>
        分解�c?/p>
            ��锁拆分到辅助类�?/p>
        分解�?/p>
           如果不愿分解�c�，可以设计分解�?/p>
                    private static Object lock1 = new Object();

                   private static Object lock2 = new Object();

                  synchronize(lock1){}

                  synchronized(lock2){}

              在jdk 5.0之后的�ƈ发包里，已有可重入锁供��用�?/p>
          隔离成员变量

              Person的age,income�{�属性都需要同步处理，以保证�ƈ发修�Ҏ��Q�可以设计一些同步的int,Double�{�类型（util.concurrent已提供类似的�c�）�Q�将锁交�l�辅助类��d��理。�v到隔��M��?

阮步�?/a> 2010-11-11 17:47 发表评论

Java多线�E�笔�?2)

Wed, 03 Nov 2010 09:56:00 GMT

Java 内存模型

JVM�pȝ��中存在一个主内存(Main Memory)�Q�Java中所有变量都储存在主存中�Q�对于所有线�E�都是共享的�?/span>每条�U�程都有自己的工作内�?Working Memory)�Q�工作内存中保存的是��d��中某些变量的拯��Q�线�E�对所有变量的操作都是在工作内存中�q�行�Q�线�E�之间无法相互直接访问，变量传递均需要通过��d��完成�?/span>

模型的规则：

1.原子性：保证�E�序得到成员变量�Q�非局部变量）的值或者是初始��|��又或者是某线�E�修改后的，�l�对不是多个�U�程混�ؕ修改后的�?/p>
2.可见�?�׃�n内存的数�?�Q�什么情况下�Q�写入成员变量的值对��d��该变量的值是可见的？

     A.写操作释放了同步锁，��L��作获得了同步�?/p>
           原理�Q�释��N��的时候强制线�E�把所使用的工作内存中的值刷新到��d��Q�获得锁的时候从��d��重新装蝲倹{�?/p>
           p.s.锁只被同步块和方法中的操作占有，但却控制了执行该操作的线�E�的所有成员变量�?/p>
     B.如果一个成员变量�ؓvolatile,那么在写�U�程做存储操作前�Q�写入这个成员变量的数据会在��d��中刷斎ͼ��q�对其他�U�程可见。读�U�程每次使用�q�个成员变量前都要重��C��d��L��据�?/p>
     C.如果一个线�E�访问一个对象的成员变量�Q�读到的��gؓ初始值或者另一个线�E�修改后的倹{�?/p>
        p.s. 不要对引用未完全创徏好的对象�?/p>
       如果一个类可以被子�c�d��Q�那么在构造函数里启动一个线�E�是非常危险�?/p>
     D.当一个线�E�结束后�Q�所有的写入数据都会被刷新到��d��?/p>
          p.s.同一个线�E�的不同�Ҏ��之间传递对象的引用�Q�永�q�不会有可见性问�?/p>
   存储模型保证�Q�如果上面的操作都会发生�Q�那么一个线�E�对一个成员变量的更新最�l�对另一个线�E�是可见的�?/p>
3.��序�?内存操作的顺�?�Q�什么情况下�Q�一个线�E�的操作可以是无序的�Q�顺序化的问题主要围�l�和��d��有关的赋��D��句的执行��序�?/p>
   如果采用同步机制�Q�那不用多说�Q�顺序化可以保证�?/p>
   当没有同步机制时�Q�存储模型所做的保证是难以相信的。在多线�E�环境下�Q�存储模型是难以保证一定正��的�?/p>
只有当满��下面的三个原则�Q�顺序化才得以保证�?/p>
   A.从线�E�执行方法的角度看，如果指��o都是串行执行的，那么��序可以保证

   B.保证同步�Ҏ��或块的顺序执�?/p>
   C.使用volatile定义成员变量

�U�程执行�q�程中，存储模型与锁的关�p?

(1) 获取对象的锁

(2) 清空工作内存数据, 从主存复制变量到当前工作内存, 卛_��步数�?

(3) 执行代码�Q�改变共享变量�?/span>

(4) ��工作内存数据刷回主�?/span>

(5) 释放对象的锁

最后介�l�一下volatile关键�?/p>
     volatile定义的成员变量可以保证可见性和��序化，但不保证原子性。比如count++�?br />      *比如把一个变量声明�ؓvolatile�Q��ƈ不能保证�q�个变量引用的非volatile数据的可见性。比如volatile string[10]�Q�数�l�）

   正确使用volatile的前提条�?/p>
   a.对变量的写操作不依赖于当前�?/p>
     b.不要和其他成员变量遵守不变约束。见*处的解释

    volatile的应�?/p>
     a.状态标�?/p>
        volatile boolean shutdownFlag;

       public void shutdown() { shutdownFlag= true; }
       public void doWork() {
   while (!shutdownFlag) {
        // do something
   }

     b.假设一个后台线�E�可能会每隔几秒��d��一�ơ数据库里的合同金额�Q��ƈ更新�?volatile 变量。然后，其他�U�程可以��d��q�个变量�Q�从而随时能够看到最新的金额�?比较�q�泛应用在统计类的系�l�中�?/p>
参考文�?

http://www.cs.umd.edu/~pugh/java/memoryModel/

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

《Java�q�发�~�程�Q�设计原则与模式�?/p>

阮步�?/a> 2010-11-03 17:56 发表评论

Java多线�E�笔�?1)

Thu, 28 Oct 2010 03:45:00 GMT

1.�q�代问题

多线�E�环境下�Q��P代容易引起问题，�?/p>
for(int i=0;i
解决办法之一�Q?/p>
     客户端加�?/p>
     for(int i=0;true;i++){

                   Sychronzied(v){

                            if(i
                                 System.out.println(v.get(i)

                             }

               }

}�Q�当然这�U�也有问题，一旦程序可以重新设�|�元素位�|�，也会出错�?/p>
�q�好有一�U�比较安全的办法�Q?copy遍历对象

   Sychronzied(v){

                        Object v_clone= copy(v);

               }

     iterateV(v_clone);

2.Singleton

   单例习惯的方式，采用延时初始化，

   public static A getInstance(){

                   if(null==instance){

                     instance=new A();

                }

             return instance

   }

在多�U�程模式下，需要加锁，来保证同步Sychronized(object){}�?/p>
如果初始化对象�ƈ不占用太多资源，其实没有必要加锁�Q�毕竟同步也是很耗资源的。取消�g时初始化�Q�priavte static final instance=new A();

3.��序化资�?/p>
   ��序化资源是避免死锁的简单的方式�?/p>
   死锁:T1旉��Q�线�E�A 拥有objA的锁�Q�请求objB的锁。线�E�B拥有objB的锁�Q�请求objA的锁�?/p>
如： System.identityHashCode(objA)
或者：public sychronized add(A a){sychronized(a){//do something}}

4.wait and notify

��Z��防止�{�待-通知机制出现race condition,需要加sychronized
race condition�Q�objA在被wait之前已经被另一�U�程objB �l�notify �? 之后的wait 会永久停�?�q�导致deadlock(死锁)�Q�当�Ӟ��如果你确认可以控制wait-notify很好,��׃��需要加�?/p>

阮步�?/a> 2010-10-28 11:45 发表评论

J2EE应用安全性�ȝ��

Mon, 27 Sep 2010 03:52:00 GMT
1.J2EE安全性介�l?br />

说明性的安全性：通过安全�l�构描述的方式来代表应用�E�序的安全需求，安全�l�构一般包括安全角�Ԍ��讉K��控制和验证要求等。在j2ee�q�_��中部�|�描�q�符�? 当了说明的安全性的主要工具。部�|�描�q�符是组件开发者和应用�E�序部��v者或应用�E�序�l�装者之间的交流工具。应用程序的开发者用它来表示应用中的安全需求，应用�E�序部��v者或应用�E�序�l�装者将安全角色与部�|�环境中的用户和�l�映��v来�?/p>
在程序运行时容器从部�|�描�q�符中提取出相应的安全策略，然后容器�Ҏ��安全�{�略执行安全验证。说明的安全性不需要开发�h员编写�Q何安全相关的代码�Q�一切都是通过配置部��v描述�W�来完成的�?/p>
可编�E�的安全�? 可编�E�的安全性在说明性的安全性的基础上，使安全敏感的应用可以通过调用被容器提供的API来对安全作出��x��。这在说明性的安全性不��以满��企业的安全模型的情况是非常有用的。比如J2ee在servlet HttpServletRequest interface中各提供两个�Ҏ��Q?br /> isUserInRole (HttpServletRequest)——判断用戯��?br /> getUserPrincipal (HttpServletRequest) ——获得用戯��证信息principal
另外�Q�就是用戯��定义��d��认证�Q�而不是��用J2EE的部�|�描�q�符里面的定�?三种��d��认证�c�d��)�?br />
2.��Z��J2EE�?/font>认证与授�?/strong>

提到安全性，��׃��能不说到两个概念�Q�认证与授权�?/span>

认证是用��h��计算讑֤�用来验证�w�䆾的过�E�。授权是�Ҏ��h��用户的��n份允许访问和操作一�D�|��感��Y件的�q�程�? �q�两个概念密不可分。没有授权， ��无需知道用户的��n份。没能认证，��׃��可能区分可信和不可信用户�Q? 更不可能安全地授权访问许多系�l�部分�?/font>

因�ؓ之前的项�?00% web方式�Q�所以本文只讨论web应用的认证和授权�?/span>

A.认证方式�Q?/strong>
Web客户端通常通过http协议来请求web服务器端的资源，�q�些web资源通常包括html�|�页、jsp�Q�java server page�Q�文件、java servlet和其他一些二�q�制或多媒体文�g。在企业环境中，企业的某些资源往往要求只允许某些�h讉K��Q�有些资源甚��x��机密的或安全敏感的。因此对企业�? 各种web资源�q�行讉K��控制是十分必要的。�ؓ了满��企业中的不同安全��别和客户化的需求，J2EE提供了三�U�基于web客户端的认证方式�Q?br />

HTTP基本�?/strong>证（HTTP Basic Authentication�Q?/strong>
HTTP基本验证是HTTP协议所支持的验证机制。这�U�验证机制��用用��L��用户名和密码作�ؓ验证信息。Web客户端从用户获取用户名和密码�Q�然后传递他们给web服务器，web服务器在指定的区域（realm�Q�中验证用户。但需要注意的是，�q�种验证�Ҏ��是不够安全的。因��U�验证方法�ƈ不对用户密码�q�行加密�Q�而只是对密码�q�行基本的base64的编码。而且目标web服务器对用户来说也是非验证过的。不能保证用戯��问到的web服务器就是用户希望访问的�?/p>
��Z��表单�?/strong>�?/strong>证（Form-Based Authentication�Q?/strong>
��Z��表单的验�? 使系�l�开发者可以自定义用户的登陆页面和报错��面。这�U�验证方法与基本HTTP的验证方法的唯一区别��在于它可以�Ҏ��用户的要求制定登陆和出错��面。基�? 表单的验证方法同样具有与基本HTTP验证�c�M��的不安全的弱炏V��用户在表单中填写用户名和密码，而后密码以明文�Ş式在�|��\中传递，如果在网路的某一节点��? 此验证请求截��P��在经�q�反�~�码很容易就可以获取用户的密码。因此在使用基本HTTP的验证方式和��Z��表单的验证方法时�Q�一定确定这两种方式的弱点对你的�? 用是可接受的�?

��Z��客户端证书的�?/strong>证（Client-Certificate Authentication�Q?/strong>
��Z��客户端证书的验证方式要比上面两种方式更安全。它通过HTTPS�Q�HTTP over SSL�Q�来保证验证的安全性。安全套接层�Q�Secure Sockets Layer�Q��ؓ验证�q�程提供了数据加密，服务器端认证�Q�信息真实性等斚w��的安全保证。在此验证方式中�Q�客��L��必须提供一个公钥证书，你可以把�q�个公钥证书看作是你的数字护照。公钥证书也�U�数字证书，它是被称作证书授权机构（CA�Q�－一个被信�Q的组�l�颁发的。这个数字证书必��ȝ��合X509公钥体系�l�构 �Q�PKI�Q�的标准。如果你指定了这�U�验证方式，Web服务器将使用客户端提供的数字证书来验证用��L��w�䆾�?nbsp;

B.授权模型�Q?/strong>

代码授权�Q�Code Authorization�Q?/strong>
j2ee产品通过java 2 安全模型来限制特定J2SE的类和方法的执行�Q�以保护和确保操作系�l�的安全�?/p>
调用者授权（Caller Authorization�Q?/strong> ——这个是我们常用的方�?br /> 安全角色�Q�安全角色是��h��相同安全属性的逻辑�l�。比如是admin,Supervisor�{��?/p>
用户和组�Q�用户和�l�是在实际系�l�环境下的用户和用户的集合。它们对应者现实当中的人和��体�?

讉K��控制�Q�访问控制可以确保安全角色只能访问已授予它安全权限的授权对象。授权对象包括EJB的远�E�方法、web资源�Q�html�|�页�Q�jsp/servlet和多媒体或二�q�制文�g�Q�等。在j2ee中访问控制在应用�E�序描述文�g中与安全角色兌��h��?

映射�Q�通过映射应用�E�序的系�l�管理员��实际系�l�环境中的用户与安全角色联系��h��Q�从而是实际的用��h��有对企业资源讉K��的适当授权�?nbsp;

C.部��v描述�W�安全性相关介�l�：

安全�U�束——定义那些资源是受约束访问的�Q�以及认证通过后的授权范围

//安全�U�束部分 //受约束的web资源�? WRCollection //资源集名 /webtest.jsp //资源的url表达�? GET //受约束的资源操作�Ҏ�� POST //对安全角色授�? user //安全角色�? NONE
定义安全角色 this is a user user
基本的HTTP认证方式——��用不�?br /> //验证方式讄�� BASIC //使用基本的HTTP验证方式
��Z��表单的认证方式——��用较�?br /> FORM //使用��Z��表单的验证方�? Default //使用�~�省的安全域 /login.html //定义登陆��面 /error.html //定义出错��面
��Z��证书的认证方式——与CA用户数据中心一起��?br /> CLIENT-CERT

注：后两�U�均在项目中应用�q��?br /> 以上三种认证方式都属于配�|�式��d��认证�?br /> �q�有一�U�是�E�序�?�~�程�?的登录认证，即通过web application自��n�q�行验证�Q�比较典型的是利用过滤器代理操作�?br /> 比如开源的acegi�Q��用它你将无需再web.xml里配�|�如此多的东�?当然�Q�也多了许多acegi的配�|?�?br />

参�?http://www.ibm.com/developerworks/cn/java/l-j2eeSecurity/
     企业�U�Java安全性——构建安全的J2EE应用

阮步�?/a> 2010-09-27 11:52 发表评论

Java之ThreadPool应用

Tue, 31 Aug 2010 13:37:00 GMT

1.�c�M��l�：
Executor接口提供一�U�将��d��提交与每个�Q务将如何�q�行的机�Ӟ��包括�U�程使用的细节、调度等�Q�分��d��来的�Ҏ��?br /> 它只有一个方法excute(Runnable command),你可以复写此�Ҏ��Q�让Runnable同步或异步执�?br /> ExecutorService�?strong>Executor的一个子接口�Q�提供了��理�U�程的方法，可�ؓ跟踪一个或多个异步��d��执行状况而生�?Future 的方法�?br /> ThreadPoolExecutor是ExecutorService的一个实现类�Q�它通常与Executors工厂一起��用�?br /> 下面的方法取自Executors�c?br /> public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
�q�里面��用ThreadPoolExecutor创徏一个线�E�数为nThreads的线�E�池�?br /> �c�M��的工厂方法还有很多，可以查看JDK
ExecutorService的常用方法：
invokeAll 执行所有�Q�?全部执行完毕后返回每个�Q务的�l�果(FutureList),包括每个��d��的状�?br /> invokeAny 与上面方法的区别是，只返回一个�Q务成功执行结果Future
submit 提交一个Task��L��行，�q�返回执行结�?br /> awaitTermination 当执行线�E�中断、超�Ӟ��或调用了shutdown�Ҏ��后，��d��直到所有的Task都执行结束�?br /> shutdown 关闭所有执行过的Task,�q�不再接收新�U�程
isTerminated 如果所有Task都关闭则�q�回True,前提是调用过shutdown或shutdownNow
2.使用�C�Z��Q?/strong>
a.首先定义一个辅助类SystemConstant�Q�大致方法如下：
//初始化一个线�E�池
public static ExecutorService getExecutor() {
if(PROCESS_EXECUTOR == null || PROCESS_EXECUTOR.isTerminated()) {
PROCESS_EXECUTOR = Executors.newFixedThreadPool(EXECUTOR_SIZE);
}
return PV_PROCESS_EXECUTOR;
}
//定义关闭�Ҏ��
public static void awaitTerminationExecutor(long timeout, TimeUnit unit) {
getExecutor().shutdown();
try {
getExecutor().awaitTermination(timeout, unit);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
b.接下来是调用�Q?br /> try {
SystemConstant.getExecutor().invokeAll(SystemUtils.toCallable(
new SystemUtils.CallableHandle() {

public void handle(Process process) throws Exception {
process.processLogs(logs, statDate);
}

}, prepareProcesses), perOutOfTime, TimeUnit.HOURS);
} catch (Exception e) {
logger.error(e);
}
SystemConstant.awaitTerminationProgramExecutor(allOutOfTime, TimeUnit.HOURS);

3. �cȝ��构图

java.util.concurrent
Class ThreadPoolExecutor

java.lang.Object
java.util.concurrent.AbstractExecutorService
java.util.concurrent.ThreadPoolExecutor

All Implemented Interfaces:
Executor, ExecutorService

Direct Known Subclasses:
ScheduledThreadPoolExecutor

阮步�?/a> 2010-08-31 21:37 发表评论

Mon, 30 Aug 2010 14:29:00 GMT

如果用过python�Q�就知道它有了command line 工具�Q�比如你输入 print 'a' ,该工兯��?a�Q�好处是便于快速学习python 语法�?/p>
其实java也可以做到�?/p>
下面是一个java 脚本解释器的helloword版本,思�\如下�Q?/p>
1动态创��Z��个Temp.java�c�L��Ӟ��里面只有一个excute�Ҏ��Q�把从控制台输入的字�W�串加入到类�Ҏ��中，比如for(int i=0;i<10;i++){System.out.println(i);}�?/p>
2再利用com.sun.tools.javac.Main.compile 动态编译Temp.java 生成class

3��Temp.class载入到jvm

4生成object实例�Q�利用反��执行excute�Ҏ��

说明�Q�这只是个test版本�?/p>
public class Test {
   public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, SecurityException, InvocationTargetException, NoSuchMethodException{


        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        while(true){
            String js=reader.readLine();
           OutputStream os = new FileOutputStream("Temp.java");
            String tempJava="public class Temp"+
               " {   "+
                " public void excute() "+
                " { "+
                 js+
                " } "+
               " } ";
            os.write(tempJava.getBytes());
            os.close();
            String[] compileArgs = new String[] {"Temp.java"};
            com.sun.tools.javac.Main.compile(compileArgs);
            URLClassLoader loader =
               new URLClassLoader(new URL[]{new File(".").toURI().toURL()});
            Class scriptClass = loader.loadClass("Temp");
            Object obj = scriptClass.newInstance();
            obj.getClass().getDeclaredMethod("excute").invoke(obj);
            obj=null;
        }
   }
}

阮步�?/a> 2010-08-30 22:29 发表评论

[导入]Effective Java�ȝ��

Sat, 27 Feb 2010 07:38:00 GMT
1.使用静态工厂方法构造对�?br /> 2.Boolean.valueOf() ��x��1的实玎ͼ��c�M��的还有collection集合的实例化�Q�所有的集合实现�c�都是通过collection的静态工厂方法构造的�?br /> 3.静态工�? �Ҏ��比构造函数的好处�Q�可以构建原�c�d��的子�c?不一定每�ơ都创徏新的对象。缺点：静�?如果工厂�Ҏ��不是公有则不能被子类�l�承
4.注意销毁过期的对象.array=null
5.对于函数里需要构建复杂的对象旉��要注意，是否可以攑ֈ��cȝ��成员变量�Q�这样就不必每次调用该函数都创徏新的复杂�? �?br /> 6.避免创徏重复的对象strng a=new String("a"); ---> String a="a";
7.当你改写 equals�Ӟ��L��要改写hashcode�Ҏ��:相等的对象必��d��有相同的散列码，�q�样在此对象与map合用的时候才不会出错
8.复写 equals原则�Q�自反性，对称性，传递性，一致�?br /> 9.equals�Ҏ��的参��C��定要说object�Q�方法内不要依赖不可靠资�?br /> 10. 提供对象的toString�Ҏ��
11.实现Cloneable接口提供克隆机制�Q�深层克�?br /> 12.接口优于抽象�c?br /> 13.�l�合优于�l? �?br /> 14.compareTo,Comparable接口比较
15.注意�Ҏ��的参数检�?

阮步�?/a> 2010-02-27 15:38 发表评论