亚洲美女视频免费,亚洲精品无码久久,亚洲精品国产综合久久一线

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 发表评论

mysql学习�W�记(2)

Thu, 09 Dec 2010 04:56:00 GMT

摘要: 1.注意auto_increment mysql5.0在高�q�发�?每天�q?�?插入单表数据出现了死�?偶现)�Q�查了下相关文档�Q�发现是因�ؓ采用了auto-increment的主键带来的问题�Q�造成Table�U�的死锁�?原因�Q�对于auto_increment字段�Q�innodb会在内存里保存一个计数器用来记录auto_increment的��|��当插入一个新行数据时�Q�就会用一个表锁来锁住�q�个计数器，所以会... 阅读全文

阮步�?/a> 2010-12-09 12:56 发表评论

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 发表评论

Hibernate Annotation �W�记

Tue, 12 Oct 2010 08:52:00 GMT

1.@Entity 标识实体
2.@Table (name = "tableName") //指定物理�?br />
@Table(name="tbl_sky",
    uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})}//唯一性约�?br /> )

3.@Embeddable 被声明的�c�d��以嵌入其他实体中
public class Address {
   private String street1;//persistent
   public String getStreet1() { return street1; }
   public void setStreet1() { this.street1 = street1; }
   private hashCode; //not persistent
}
@Embedded 在实体中嵌入一个类型：常用的像名字�Q�地址之类�?br /> 另，使用@AttributeOverrides标识覆盖原类中的属性取��|��因�ؓ原实体可能引用的是其他字�D�c�?br /> @Embedded
    @AttributeOverrides( {
            @AttributeOverride(name="iso2", column = @Column(name="bornIso2") ),
            @AttributeOverride(name="name", column = @Column(name="bornCountryName") )
    } )
Country bornIn;

例子�Q?br /> @Entity

class User {
@EmbeddedId
@AttributeOverride(name="firstName", column=@Column(name="fld_firstname")
UserId id;
Integer age;
}
@Embeddable
class UserId implements Serializable {//此处Serializable是必��ȝ��
String firstName;
String lastName;
}

4.@Access(AcessType.PROPERTY)
必须定义getter/setter�Ҏ��才能实现持久�?br /> �q�有另一�U�取��|��AcessType.FILED,可以不定义getter/setter�Ҏ��Q�也能实现持久化
此annotation也可以定义字�D�c�?br />
5.主键�Q?br />    A.单键
    @Id
    @GeneratedValue (generator = "identity")
    @GenericGenerator (name = "identity", strategy = "identity")
    或�?br />     @javax.persistence.SequenceGenerator(
    name="SEQ_STORE",
    sequenceName="my_sequence")
    @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
    其中�Q?br />      strategy取��gؓ:
     AUTO - either identity column, sequence or table depending on the underlying DB
     TABLE - table holding the id
     IDENTITY - identity column
     SEQUENCE - sequence
   B.复合�l�键
    @Entity
class Customer {
@EmbeddedId CustomerId id;
boolean preferredCustomer;
@MapsId("userId")//user.id与customerId.userId 使用相同的�?br /> @JoinColumns({
    @JoinColumn(name="userfirstname_fk", referencedColumnName="firstName"),
    @JoinColumn(name="userlastname_fk", referencedColumnName="lastName")
})
@OneToOne User user;
}

@Embeddable
class CustomerId implements Serializable {
UserId userId;
String customerNumber;
}

@Entity
class User {
@EmbeddedId UserId id;
Integer age;
}

@Embeddable
class UserId implements Serializable {
String firstName;
String lastName;
}


6.字段讄��Q?br /> @Column(
    name="columnName";
    boolean un(2)ique() default false;
    boolean nu(3)llable() default true;
    boolean in(4)sertable() default true;
    boolean up(5)datable() default true;
    String col(6)umnDefinition() default "";
    String tab(7)le() default "";
    int length(8)() default 255;
    int precis(9)ion() default 0; // decimal precision
    int scale((10)) default 0; // decimal scale
@Transient 非持久化字段
@Basic 持久化字�D?br /> @Basic(fetch = FetchType.LAZY) basic 用于定义property的fetch属�?br /> @Enumerated(EnumType.STRING) 标识enum persisted as String in database
@Lob blob clob字段
@Formula("obj_length * obj_height * obj_width")//自定义输�?br /> public long getObjectVolume()

7.Mapping关系
A.一对多或者一对一�Q?br /> @OneToOne(cascade = CascadeType.ALL) 一对一关系�Q��联关�p�Mؓall
@PrimaryKeyJoinColumn或�?br /> 指定兌��外键
@JoinColumn(name="passport_fk")
Passport passport�Q?br /> 一对一的另一端只需@OneToOne(mappedBy = "passport")�Q�passport为前一个实体声明的名字

@OneToMany(fetch = FetchType.LAZY , mappedBy = "adProduct")
@Cascade(value = {CascadeType.ALL,CascadeType.DELETE_ORPHAN})

@OrderBy(value = "id") //排序
B.多对一�Q?br />     @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="adPosition_id",nullable=false)


8.Fetch and Lazy

Annotations Lazy Fetch

@[One|Many]ToOne](fetch=FetchType.LAZY) @LazyToOne(PROXY) @Fetch(SELECT)

@[One|Many]ToOne](fetch=FetchType.EAGER) @LazyToOne(FALSE) @Fetch(JOIN)

@ManyTo[One|Many](fetch=FetchType.LAZY) @LazyCollection(TRUE) @Fetch(SELECT)

@ManyTo[One|Many](fetch=FetchType.EAGER) @LazyCollection(FALSE) @Fetch(JOIN)

9.Cascade

PERSIST

MERGE

REMOVE

REFRESH

DELETE

SAVE_UPDATE

10.�~�存

�~�存的注释写法如下，加在Entity的java�c�M��Q?br />

@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

�~�存的方式有四种�Q�分别�ؓ�Q?/p>

CacheConcurrencyStrategy.NONE

CacheConcurrencyStrategy.READ_ONLY�Q�只��L��式，在此模式下，如果�Ҏ��据进行更新操作，会有异常�Q?

CacheConcurrencyStrategy.READ_WRITE�Q�读写模式在更新�~�存的时候会把缓存里面的数据换成一个锁�Q�其它事务如果去取相应的�~�存数据�Q�发现被锁了直接��去数据库查询；

CacheConcurrencyStrategy.NONSTRICT_READ_WRITE�Q�不严格的读写模式则不会对缓存数据加锁；

CacheConcurrencyStrategy.TRANSACTIONAL�Q�事务模式指�~�存支持事务�Q�当事务回滚�Ӟ��~�存也能回滚�Q�只支持JTA环境�?

11.No-Annotation 字段�Q?br />
      If the property is of a single type, it is mapped as @Basic

      Otherwise, if the type of the property is annotated as @Embeddable, it is mapped as @Embedded

      Otherwise, if the type of the property is Serializable, it is mapped as @Basic in a column holding the object in its serialized version

      Otherwise, if the type of the property is java.sql.Clob or java.sql.Blob, it is mapped as @Lob with the appropriate LobType

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

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 发表评论

Rule Engine之Drools

Sat, 25 Sep 2010 09:48:00 GMT
对于做��Y件的人来��_��唯一不变的就是变化。此��业真理。而对于复杂业务系�l�的逻辑�l��g的定义不得不多考虑一下业务的可扩展性，来应对客��L��变化。选择Rule Engine是一个不错的�Ҏ��?br />
Drools 是用 Java 语言�~�写的开放源码规则引擎。Drools 允许使用声明方式表达业务逻辑。可以��用非 XML 的本地语�a��~�写规则�Q�这点很重要�Q�本��Z��前曾用过自己公司的一套业务规则组�Ӟ��无论是编写还是调试都很麻烦）�Q�从而便于学习和理解。�ƈ且，�q�可以将 Java 代码直接嵌入到规则文件中�Q��Drools 更加吸引人。简单的概括�Q�就是简单��用，易于理解。而且它是免费的�?br />
1.rule文�g�Q?/strong>
rule "rule name"
    no-loop
    when
      customer : Customer( state == CustomerState.UNCENSORED )
    then
        customer.setState(CustomerState.AUDITING);
        CustomerTask task=new CustomerTask();
        Post law=userService.getPostByPostCode(Constants.PostCode.ROOT_LAW);
        task.setAuditorPost(law);
        task.setEntityState(CustomerState.AUDITING);
        task.setEntityId(customer.getId());
        task.setEntityCode(String.valueOf(customer.getId()));
        task.setEntityType(Customer.class.getSimpleName());
        task.setTitle(customer.getName()+" test");
        taskService.assignmentTask(task);
        logger.info("CustomerTask Submit auditorTitle:" + task.getAuditorTitle());
end

�q�里面有个状态的条�g判断state == CustomerState.UNCENSORED �Q�then 关键字后面的便是�W�合条�g的处理逻辑�Q�只要是java�E�度都可以看懂，比xml�cȝ��rule文�g好懂了许多�?br />
接下�?br /> 语法说明�Q?/strong>

文�g头部分：
package drools.java.demo;定义包名,�{�同于命名空�?br /> import drools.java.demo.Machine;导入java�c?br /> global java.util.List myGlobalList;此关键字让规则引擎知道，myGlobalList对象应该可以从规则中讉K��.
function:�c�M��于公用方法的抽象�Q�如下定义后�Q�各个同一文�g下的rule都可以��?br /> function void setTestsDueTime(Machine machine, int numberOfDays) {
    setDueTime(machine, Calendar.DATE, numberOfDays);
}

rule�Q�定义了一个规�?br />
rule ""
*
when
*
then
*
end

即rule的名字标�?br />
:

常用的属性：
no-loop �Q�true 条�g�l�果更改后，修改此条件且定义为no-loop:true的规则不会再重新执行�?br />
lock-on-active�Q�true 可以看作是no-loop的加强版�Q�当条�g�l�果更改后，不但修改此条件的规则不会重新执行�Q�文件中的�Q何规则（�?active-lock 属性被设�ؓ true�Q�不会重新执行�?/pre> salience�Q?00 使用它可以让规则执行引擎知道应该启动规则的结果语句的��序。具有最高显著值的规则的结果语句首先执行；��h��W�二高显著值的规则的结果语句第二执行，依此�c�L��。当您需要让规则按预定义��序启动�Ӟ��q�一炚w��帔R��要�?br />
其他属性的解释误��http://downloads.jboss.com/drools/docs/5.1.1.34858.FINAL/drools-expert/html_single/index.html#d0e2607

when:填写条�g的地方，比如�Q?br />
Cheese( type == "stilton", price < 10, age == "mature" )�?br />
Cheese( type == "stilton" && price < 10, age == "mature" )

then:业务规则的地方，略�?br />
2.用法

规则文�g定义好后�Q�就该是怎么使用它了

如上图，file rule定义好后�Q�就该是如何使用它了。最重要的两个类RuleBase和WorkingMemory

下面是一个example:
public class RulesEngine {
    private RuleBase rules;
    private boolean debug = false;
    public RulesEngine(String rulesFile) throws RulesEngineException {
        super();
        try {
            // Read in the rules source file
            Reader source = new InputStreamReader(RulesEngine.class
                    .getResourceAsStream("../../rules/" + rulesFile));

            // Use package builder to build up a rule package
            PackageBuilder builder = new PackageBuilder();

            // This will parse and compile in one step
            builder.addPackageFromDrl(source);

            // Get the compiled package
            Package pkg = builder.getPackage();

            // Add the package to a rulebase (deploy the rule package).
            rules = RuleBaseFactory.newRuleBase();
            rules.addPackage(pkg);

        } catch (Exception e) {
            throw new RulesEngineException(
                    "Could not load/compile rules file: " + rulesFile, e);
        }
    }
    public RulesEngine(String rulesFile, boolean debug)
            throws RulesEngineException {
        this(rulesFile);
        this.debug = debug;
    }
    public void executeRules(WorkingEnvironmentCallback callback) {
        WorkingMemory workingMemory = rules.newStatefulSession();
        if (debug) {
            workingMemory
                    .addEventListener(new DebugWorkingMemoryEventListener());
        }
        callback.initEnvironment(workingMemory);
        workingMemory.fireAllRules();
    }
}
RulesEngine构造方法演�C�Z��如何去读入一个rule文�g,�q�构��Z��一个RuleBase对象(RuleBase 是一个包含了rule文�g的所有规则的集合)
executeRules�Ҏ��定义了如何��用规则文件中定义的那些内容，用RuleBase构徏一个WorkingMemory对象�Q�再执行fireAllRules()�Ҏ��?br /> WorkingMemory 代表了与rulebase链接的session会话�Q�也可以看作是工作内存空间。如果你要向内存中插入一个对象可以调用insert()�Ҏ��,同理�Q�更��C��个对象��用update()�Ҏ��。WorkingMemory�q�有一个setGlobal()�Ҏ��Q�用来设�|�规则内可以引用的对�?相当于规则的全局变量)�?br />
3.��技�?/strong>

可以一�ơ把所有的rule文�g都蝲入内存中存放�Q�这样就不用每次执行都读取文件�?br /> 如果规则文�g被修改，也可以用�q�一个方法来判断是否需要重新蝲入rule文�g
比如�Q�根据文件的最后修�Ҏ��_��与内存中对应对象的时间做比较
public boolean hasChange(List ruleFileList){
        for(RuleFile ruleFile:ruleFileList){
            if(!ruleFile.getLastModifyTime().equals(ruleFileMap.get(ruleFile.getFileName()).getLastModifyTime())){
                return true;
            }
        }
        return false;
    }

注：具体的helloWorld 误��http://www.ibm.com/developerworks/cn/java/j-drools/#listing12�Q�比我说得好多了�?br />

阮步�?/a> 2010-09-25 17:48 发表评论

Annotations	Lazy	Fetch
@[One\|Many]ToOne](fetch=FetchType.LAZY)	@LazyToOne(PROXY)	@Fetch(SELECT)
@[One\|Many]ToOne](fetch=FetchType.EAGER)	@LazyToOne(FALSE)	@Fetch(JOIN)
@ManyTo[One\|Many](fetch=FetchType.LAZY)	@LazyCollection(TRUE)	@Fetch(SELECT)
@ManyTo[One\|Many](fetch=FetchType.EAGER)	@LazyCollection(FALSE)	@Fetch(JOIN)