国产高清久久,中文成人激情娱乐网,国产在线观看一区二区三区

关于Java String的intern and ==的笔试题�Q�没有全�{�对

凭栏观�v — Mon, 17 Mar 2008 07:43:00 GMT

package testPackage;

class Test {

public static void main(String[] args) {

String hello = "Hello", lo = "lo";

System.out.print((hello == "Hello") + " ");

System.out.print((Other.hello == hello) + " ");

System.out.print((other.Other.hello == hello) + " ");

System.out.print((hello == ("Hel"+"lo")) + " ");

System.out.print((hello == ("Hel"+lo)) + " ");

System.out.println(hello == ("Hel"+lo).intern());

}

}

class Other { static String hello = "Hello"; }

and the compilation unit:

package other;

public class Other { static String hello = "Hello"; }

 正确�{�案�Q�true true true true false true

This example illustrates six points:

Literal strings within the same class (§8) in the same package (§7) represent references to the same String object (§4.3.1).
Literal strings within different classes in the same package represent references to the same String object.
Literal strings within different classes in different packages likewise represent references to the same String object.
Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.
Strings computed at run time are newly created and therefore distinct.
The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.

呵呵�Q�我是没有能够全部答�?/p>

另外一��关于String intern的文章：

http://laiseeme.javaeye.com/blog/102442

凭栏观�v 2008-03-17 15:43 发表评论

设计及设计模式：关于Java权限控制��法(转）

凭栏观�v — Mon, 25 Feb 2008 01:20:00 GMT

http://publish.itpub.net/j/2008-01-24/200801240919412.shtml

作者：来自ITPUB论坛 2008-01-24

向大家介�l�一�U�很不错�Q�也是Linux中的权限��理��法�?

　　定义a^b为：a的b�ơ方

　　假如�Q�我们�ؓ每一个操作设定一个唯一的整数��|��比如�Q?/p>

　　删除A---0

　　修改A---1

　　��d��A---2

　　删除B---3

　　修改B---4

　　��d��B---5

　　。。�?/p>

　　理论上可以有N个操作，�q�取决于你用于储存用��h��限值的数据�c�d��了�?/p>

　　�q�样�Q�如果用��h��权限�Q�添加A---2;删除B---3;修改B---4

　　那用��L��权限�?purview =2^2+2^3+2^4=28�Q�也��是2的权的和�?/p>

　　化成二进制可以表�C�Zؓ11100

　　如果要验证用��h��否有删除B的权限，��可以通过位与�q�算来实现�?/p>

　　在Java里，位与�q�算�q�算�W�号�?amp;

　　��x��Q�int value = purview &((int)Math.pow(2,3));

　　你会发现�Q�当用户有操作权限时�Q�运��出来的�l�果都会�{�于�q�个操作需要的权限�?

　　原理�Q?/p>

　　位与�q�算�Q�顾名思义��是对位�q�行与运��：

　　以上面的式子��Z��Q�purview & 2^3 也就是　28&8

　　��它们化成二�q�制�?/p>

　　11100

　　& 01000

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

　　01000 == 8(十进�?　==　2^3

　　同理�Q�如果要验证是否有删除A---0的权�?/p>

　　可以用：purview &((int)Math.pow(2,0));

　　卻I��

　　11100

　　& 00001

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

　　00000 == 0(十进�?　　!=　2^0

　　�q�种��法的一个优�Ҏ��速度快。可以同时处理N个权限，讄��N�U�角�?

　　如果想验证是否同时有删除A---0和删除B---3的权�?/p>

　　可以用purview&(2^0+2^3)==(2^0+2^3)?true:false;

　　讄��多角色用戗��根据权限值判断用��L��角色。。�?/p>

　　下面提供一个java的单操作权限判断的代码：

　　//userPurview是用户具有的��L���?br />
//optPurview是一个操作要求的权限��Z��个整�?没有�l�过权的!)



public static boolean checkPower(int userPurview, int optPurview){

int purviewValue = (int)Math.pow(2, optPurview);

return (userPurview & purviewValue) == purviewValue;

}

　　当然�Q�多权限的验证只要扩展一下就可以了�?/p>

　　几点注意事项�Q�首先，一个系�l�可能有很多的操作，因此�Q�请建立数据字典�Q�以便查阅，修改时��用。其�ơ，如果用数据库储存用户权限�Q�请注意数值的有效范围。操作权限��D��用唯一的整�?Java的int�c�d��最多可以储�?1个权限和.如果��过�Q�可以选择其它数据�c�d��Q�而且��不同模块�Q��用多个权�? 变量.

凭栏观�v 2008-02-25 09:20 发表评论

java基础�Q�byte与int

凭栏观�v — Tue, 31 Jul 2007 07:54:00 GMT

byte与int的区别：

byte uses 1 byte while int uses 4 bytes.
integer literals like "45" are of int not byte.If you want a literal to be a byte, you have to cast it: "(byte)45".
When values are promoted as part of an expression or as parameters to a method call, they may be promoted to int, but never to byte.
Many parts of the Java language used int, but none of them use byte. For example, the length of an array is an int.

byte�c�d��的��用场合：

�׃��不同的机器对�?strong>多字节数�?int ��是采用4个byte保存数据�Q?/strong>的存储方式不�?可能�?低字节向高字节存�?也可能是从高字节向低字节存储,�q�样,�?分析�|�络协议或文件格�?/strong>,��Z��解决不同机器上的字节存储��序问题,用byte�c�d��来表�C�数据是合适的�?strong>而通常情况�?�׃��其表�C�的数据范围很小,�Ҏ��造成溢出,应避免��用�?/strong>

/**
     * Convert an int to a byte array
     *
     * @param value int
     * @return byte[]
     */
public static byte[] intToByteArray(int value) {
        byte[] b = new byte[4];

     // 使用4个byte表示int
        for (int i = 0; i < 4; i++) {
            int offset = (b.length - 1 - i) * 8; // 偏移�?br>            b[i] = (byte) ((value >> offset) & 0xFF); //每次�?bit
        }
        return b;
    }

    /**
     * Convert the byte array to an int starting from the given offset.
     *
     * @param b The byte array
     * @param offset The array offset,如果byte数组长度��是4�Q�则该��gؓ0
     * @return The integer
     */

public static int byteArrayToInt(byte[] b, int offset) {
        int value = 0;
        for (int i = 0; i < b.length; i++) {
            int shift = (b.length - 1 - i) * 8;
            value += (b[i + offset] & 0xFF) << shift;
        }
        return value;
    }

public static void main(String[] args) {
        byte[] bb=intToByteArray(255);
        for(int i=0;i            System.out.println(bb[i]);
        }
    }
输出�l�果�Q?/p>
0
0
0
-1
�q�是补码的�Ş式（10000001�Q�，取反�?可以得到源码�Q?1111111�Q?

凭栏观�v 2007-07-31 15:54 发表评论

判断resultset是否含有记录

凭栏观�v — Mon, 30 Jul 2007 08:42:00 GMT

boolean hasRows = false;
while (rs.next()){
hasRows = true;
//Do your stuff
}
if (!hasRows ){
//Empty result set
}
//You dont have to test for null result set

凭栏观�v 2007-07-30 16:42 发表评论

凭栏观�v — Fri, 27 Jul 2007 03:11:00 GMT
�l�合了前�D�|��间看unicode的知识补补基��

byte: The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters. They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.

short: The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters.

int: The int data type is a 32-bit signed two's complement integer. It has a minimum value of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive). For integral values, this data type is generally the default choice unless there is a reason (like the above) to choose something else. This data type will most likely be large enough for the numbers your program will use, but if you need a wider range of values, use long instead.

long: The long data type is a 64-bit signed two's complement integer. It has a minimum value of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807 (inclusive). Use this data type when you need a range of values wider than those provided by int.

float: The float data type is a single-precision 32-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in section 4.2.3 of the Java Language Specification. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead. Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.

double: The double data type is a double-precision 64-bit IEEE 754 floating point. Its range of values is beyond the scope of this discussion, but is specified in section 4.2.3 of the Java Language Specification. For decimal values, this data type is generally the default choice. As mentioned above, this data type should never be used for precise values, such as currency.

boolean: The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.

char: The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

�c�d��名称
�c�d��定义 �c�d��取�?/strong>

boolean 布尔�?/td> true, false

byte 8�?strong>有符��h��?/strong> 最��?128�Q�最大�?27

short 16�?strong>有符��h��?/strong>
最��?32768�Q?2¹⁵�Q�，最大�?2767�Q?¹⁵-1�Q?/p>

int 32�?strong>有符��h��?/strong> 最��?2147483648�Q?2³¹�Q�，最大�?147483647�Q?³¹-1�Q?/td>

long 64�?strong>有符��h��?/strong>
-2⁶³~(2⁶³-1)

float 32位��Q�Ҏ��
1.4E-45~3.4028235E38

double 64位��Q�Ҏ�� 4.9E-324~1.7976931348623157E308

char 16位Unicode字符

凭栏观�v 2007-07-27 11:11 发表评论

java语言中的bit �U�M��操作

凭栏观�v — Fri, 27 Jul 2007 03:08:00 GMT

java 位操作符�Q?/strong>

取反�Q?/strong>~x
- flips each bit to the opposite value.
与操作：AND
x & y
- AND operation between the corresponding bits in x and y.
或操作：OR
x | y
- OR operation between the corresponding bits in x and y.
异或操作�Q�XOR
x ^ y
- XOR operation between the corresponding bits in x and y.
左移操作�Q�Shift left
x << y
- shifts x to the left by y bits. The high order bits are lost while zeros fill the right bits.
��x左移y位，�U�d��q�程中，高位会丢�?
有符��h��右移操作�Q�Shift Right - Signed
x >> y
- shifts x to the right by y bits. The low order bits are lost while the sign bit value (0 for positive numbers, 1 for negative) fills in the left bits.
无符��h��右移�Q�Shift Right - Unsigned
x >>> y
- shifts x to the right by y bits. The low order bits are lost while zeros fill in the left bits regardless of the sign.
例子�Q?/strong>

下面的例子显�C�如何将一个int数组通过�U�M��操作压羃��C��个int内保存，其原理是在java语言中，int�c�d��使用4 bytes来保存，因此对于需要压�~�的int数组�Q�其中的每一个int值的大小不能��过255�Q?�?�ơ方-1�Q�，因此�q�只是一个实例：

  int [] aRGB = {0x56, 0x78, 0x9A, 0xBC};   // 是用16�q�制保存�?�U�颜色�?br>  int color_val = aRGB[3];
  color_val = color_val | (aRGB[2] << 8); // ��Z��压羃�Q�需要放�|�到color_val值的�W�二个字节位�|�上�Q�将aRGB[2] 左移到第二个byte�Q�同时与color_val�q�行或操作，下面同理
  color_val = color_val | (aRGB[1] << 16);
  color_val = color_val | (aRBG[0] << 24);
操作完的�l�果�?6 78 9A BC
如果要从colorVal �q�原为int数组�Q�或者得到数�l�中的某个��|��只需要对colorVal �q�行相应的右�U�L��作即可：
  int alpha_val = (colorVal >>> 24) & 0xFF;
  int red_val   = (colorVal >>> 16) & 0xFF;
  int green_val = (colorVal >>> 8) & 0xFF;
  int blue_val = colorVal & 0xFF;
参考资料：
Bits in Java

凭栏观�v 2007-07-27 11:08 发表评论

凭栏观�v — Sat, 21 Jul 2007 12:50:00 GMT

作�? 它山出处:IT168

http://tech.it168.com/j/n/2007-03-05/200703051354348.shtml

PA作�ؓ一��对象持久化的标准，不但可以获得Java EE应用服务器的支持�Q�还可以直接在Java SE中��用�?/p>
介绍得很清楚的文�?/p>

JPA概述
JPA(Java Persistence API)作�ؓJava EE 5.0�q�_��标准的ORM规范�Q�将得到所有Java EE服务器的支持。Sun�q�次吸取了之前EJB规范惨痛��p�|的经历，在充分吸收现有ORM框架的基��上，得到了一个易于��用、�׾~�性强的ORM规范。从目前的开发社区的反应上看�Q�JPA受到了极大的支持和赞扬，JPA作�ؓORM领域标准化整合者的目标应该不难实现�?nbsp;
JPA通过JDK 5.0注解或XML描述对象�Q�关�p�表的映��关�p�，�q�将�q�行期的实体对象持久化到数据库中�Q�图 1很好地描�q�C��JPA的结构：

Sun引入新的JPA ORM规范��Z��两个原因�Q�其一�Q�简化现有Java EE和Java SE应用的对象持久化的开发工作；其二�Q�Sun希望整合对ORM技术，实现天下归一�?nbsp;
JPA由EJB 3.0软�g专家�l�开发，作�ؓJSR-220实现的一部分。但它不囿于EJB 3.0�Q�你可以在Web应用、甚��x��面应用中使用。JPA的宗旨是为POJO提供持久化标准规范，由此可见�Q�经�q�这几年的实跉|��索，能够��q��容器独立�q�行�Q�方便开发和��试的理念已�l�深入�h心了。目前Hibernate 3.2、TopLink 10.1.3以及OpenJpa都提供了JPA的实现�?
JPA的��M��思想和现有Hibernate、TopLink�Q�JDO�{�ORM框架大体一致。�ȝ��来说�Q�JPA包括以下3斚w��的技术：

ORM映射元数据，JPA支持XML和JDK 5.0注解两种元数据的形式�Q�元数据描述对象和表之间的映��关�p�，框架据此��实体对象持久化到数据库表中�Q?nbsp;
JPA 的API�Q�用来操作实体对象，执行CRUD操作�Q�框架在后台替我们完成所有的事情�Q�开发者从�J�琐的JDBC和SQL代码中解脱出来�?nbsp;
查询语言�Q�这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据�Q�避免程序的SQL语句紧密耦合�?nbsp;

凭栏观�v 2007-07-21 20:50 发表评论

凭栏观�v — Mon, 16 Jul 2007 03:22:00 GMT

��Z��备䆾blog�Q�简单写了一个适用于blogjava�{�metaWeblog的blog备䆾工具�Q�功能：

�Q?�Q�备份post的正文到本地

�Q?�Q�备份正文中的图片、css文�g到本�?/p>
�Q?�Q�基于以上两的步骤，修改相关的链接，实现本地脱机��览

惛_��了但是未实现的功能：

�Q?�Q�评论无法保�?/p>
�Q?�Q�合适的话可以考虑以Eclipes RCP形式包装

一、实现原�?/h2>
�Q?�Q�获取post的方法：使用MetaWeblog提供的API接口

metaWeblog.getRecentPosts (blogid, username, password, numberOfPosts) returns array of structs,

Each struct represents a recent weblog post, containing the same information that a call to metaWeblog.getPost would return.

If numberOfPosts is 1, you get the most recent post. If it's 2 you also get the second most recent post, as the second array element. If numberOfPosts is greater than the number of posts in the weblog you get all the posts in the weblog.

(2) 使用正则表达式分析获取下来的post�Q�解析出post中包含的css和图片文件的地址�Q�执行两步操�?/p>

�Ҏ��地址�Q�抓取图片保存到本地
修改post中的地址为本��C��存地址

(3) 使用xml-rpc来简化远�E�调用过�E�的�~�程

二、主要的代码

public ArrayList<SimplePost> getAllPosts(String blogID, String name,String password, int num) throws XmlRpcException {
        ArrayList<SimplePost> posts = new ArrayList<SimplePost>();
        Object[] params = new Object[] { blogID, name, password,new Integer(num) };
        Object[] result = (Object[]) client.execute("metaWeblog.getRecentPosts", params);

        for (int i = 0; i < result.length; i++) {
            Map map = (Map) result[i];
            String postUrl = (String) map.get("link");
            String title = (String) map.get("title");
            String postId = (String) map.get("postid");

                        // post的内�?/span>
            String description = (String) map.get("description");

            Map<String, String> images = new HashMap<String, String>();
            images = getImagesURL(description);

            String newDes = handleImagesURL(description,postId);
            String descriptioFileName = savePostContent(savePath, title,postId, newDes, css);

            SimplePost post = new SimplePost(postUrl, title, postId,descriptioFileName);
            //从postContent获取囑փ�的地址和名�U�ͼ�以便获取囄��q�保�?/span>
            post.setImages(images);
            posts.add(post);
            log.debug("postID: " + postId + "postTitle :" + title);
        }
        return posts;
    }

public static Map<String, String> getImagesURL(String description) {

       Map<String, String> map = new HashMap<String, String>();
        // img 的正则表辑ּ�
      String imgPattern = "<\\s*img\\s+([^>]+)\\s*>";
        Pattern p = Pattern.compile(imgPattern, Pattern.CASE_INSENSITIVE);
        Matcher matcher = p.matcher(description);

        // img src元素的正则表辑ּ�
        String srcPattern = "\\s*src\\s*=\\s*\"([^\"]+)\\s*\"";
       Pattern p2 = Pattern.compile(srcPattern, Pattern.CASE_INSENSITIVE);

        while (matcher.find()) {
            Matcher matcher2 = p2.matcher(matcher.group());
            // 一定要find(),�q�是实际的匹配动�?/span>
            if (matcher2.find()) {
                String src = matcher2.group();
                log.info(src);
                int i2 = src.lastIndexOf('/');
                int i1 = src.indexOf("http");
                if (i1 != -1) {
                    map.put(src.substring(i2 + 1, src.length() - 1), src
                            .substring(i1, src.length() - 1));
                }
            }
        }
        log.debug("囄��Q?/span>" + map);
        return map;
    }

/**
     * 替换description的图片链接�ؓ本地的相寚w��接，�l�构为blogFiles/images/postid/
     *
     * @param description
     * @param userName
     * @param postId
     * @return
     */
    public static String handleImagesURL(String description, String postId) {
        String tmp = description;
        String address="images/" + postId + "/";

        String imgPattern = "<\\s*img\\s+([^>]+)\\s*>";
        Pattern p = Pattern.compile(imgPattern, Pattern.CASE_INSENSITIVE);
        Matcher matcher = p.matcher(tmp);

        // img src元素的正则表辑ּ�
        String srcPattern = "\\s*src\\s*=\\s*\"([^\"]+)\\s*\"";
        // String srcPattern = "\\s*src\\s*=\\s*\'([^\']+)\\s*\'";
        Pattern p2 = Pattern.compile(srcPattern, Pattern.CASE_INSENSITIVE);
        while (matcher.find()) {
            Matcher matcher2 = p2.matcher(matcher.group());
            // 一定要find(),�q�是实际的匹配动�?/span>
            if (matcher2.find()) {
                String src = matcher2.group();
                log.info(src);
                int l2=src.lastIndexOf('/')+1;
                log.info(src.substring(l2,src.length()-1));
                tmp=tmp.replace(src,"  src=\""+address+src.substring(l2,src.length()-1)+"\"");
            }
        }
        return tmp;
    }

凭栏观�v 2007-07-16 11:22 发表评论

正则表达式的�ȝ��

凭栏观�v — Thu, 12 Jul 2007 01:44:00 GMT

一、JDK提供的正则表辑ּ�

Java's java.util.regex 包包括：Pattern�c�R��Matcher�c�R��MatchResult接口和PatternSyntaxException异常�Q?/p>

Pattern 对象代表了编译了的正则表辑ּ��Q�A compiled representation of a regular expression.�Q��?

Matcher �Q�An engine that performs match operations on a character sequence by interpreting a Pattern.

MatchResult接口�Q�The result of a match operation.

PatternSyntaxException对象�Q�描�q�非法的regex patterns�Q�Unchecked exception thrown to indicate a syntax error in a regular-expression pattern.

同时�q�需要了解是CharSequence�Q�JDK 1.4定义的新的接口，它提供了String和StringBuffer�q�两个类的字�W�序列的抽象

interface CharSequence {

charAt(int i);

length();

subSequence(int start, int end);

toString();

}

��Z��实现�q�个新的CharSequence接口�Q�String�Q�StringBuffer以及CharBuffer都作了修改，很多的正则表辑ּ�的操作都要拿CharSequence作参数�?

Matcher�cȝ��几个重要的方法：

boolean matches()�Q�Pattern匚w��整个字符�?

boolean lookingAt()�Q�Pattern匚w��字符串的开�?

boolean find()�Q�发现CharSequence里的�Q�与pattern相匹配的多个字符序列
boolean find(int start)�Q�告诉方法从参数start位置开始查�?/li>

group的概�?/h2>
Group是指里用括号括�v来的�Q�能被后面的表达式调用的正则表达式�?/p>
Group 0 表示整个表达式，group 1表示�W�一个被括�v来的group�Q�以此类推。所以；

A(B(C))D

里面有三个group�Q�group 0是ABCD�Q?group 1是BC�Q�group 2是C�?

你可以用下述Matcher�Ҏ��来��用group�Q?

public int groupCount( )�q�回matcher对象中的group的数目。不包括group0�?

public String group( ) �q�回上次匚w��操作(比方说find( ))的group 0(整个匚w��)

public String group(int i)�q�回上次匚w��操作的某个group。如果匹配成功，但是没能扑ֈ�group�Q�则�q�回null�?

public int start(int group)�q�回上次匚w��所扑ֈ�的group的开始位�|��?

public int end(int group)�q�回上次匚w��所扑ֈ�的group的结束位�|�，最后一个字�W�的下标加一�?

split( ) 是指��以正则表达式�ؓ界，��字�W�串分割成String数组,如果带有limit参数�Q�split( )会限定分割的�ơ数�?

replaceFirst(String replacement)��字�W�串里，�W�一个与模式相匹配的子串替换成replacement�?

replaceAll(String replacement)�Q�将输入字符串里所有与模式相匹配的子串全部替换成replacement�?

appendReplacement(StringBuffer sbuf, String replacement)对sbuf�q�行逐次替换�Q�而不是像replaceFirst( )或replaceAll( )那样�Q�只替换�W�一个或全部子串。这是个非常重要的方法，因�ؓreplacement(replaceFirst( )和replaceAll( )只允许用固定的字�W�串来充当replacement)。有了这个方法，你就可以�~�程区分group�Q�从而实现更强大的替换功能�?

调用完appendReplacement( )之后�Q��ؓ了把剩余的字�W�串拯��回去�Q�必��调用appendTail(StringBuffer sbuf, String replacement)�?

使用group可以做到逐步�~�小匚w��的范��_��直至�_��匚w��的目的�?

start( )和end( )�Q�如果匹配成功，start( )会返回此�ơ匹配的开始位�|�，end( )会返回此�ơ匹配的�l�束位置�Q�即最后一个字�W�的下标加一。如果之前的匚w��不成�?或者没匚w��)�Q�那么无论是调用start( )�q�是end( )�Q�都会引发一个IllegalStateException�?/p>

二�?大��用方法：

查询

String str="abc efg ABC";

String regEx="a|f"; //表示a或f

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher(str);

boolean rs=m.find();

如果str中有regEx�Q�那么rs为true�Q�否则�ؓflase。如果想在查找时忽略大小写，则可以写成Pattern p=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);

提取

String regEx=".+\\\\(.+)$";

String str="c:\\dir1\\dir2\\name.txt";

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher(str);

boolean rs=m.find();

for(int i=1;i<=m.groupCount();i++){

System.out.println(m.group(i));

}

以上的执行结果�ؓname.txt�Q�提取的字符串储存在m.group(i)中，其中i最大��gؓm.groupCount();

分割

String regEx="::";

Pattern p=Pattern.compile(regEx);

String[] r=p.split("xd::abc::cde");

执行后，r��是{"xd","abc","cde"}�Q�其实分割时�q�有跟简单的�Ҏ��Q?

String str="xd::abc::cde";

String[] r=str.split("::");

替换或者删�?/strong>

String regEx="a+"; //表示一个或多个a

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher("aaabbced a ccdeaa");

String s=m.replaceAll("A");

�l�果�?Abbced A ccdeA"

如果写成�I�Z��Q�既可达到删除的功能�Q�比如：

String s=m.replaceAll("");

�l�果�?bbced ccde"

三、一个实际的例子

下面的函数是一个实际应用的例子�Q�需求是需要将抓取的网��中�?lt;img src=''http://aa.bb.cc.com/images/**.jpg"> 中的地址�Q�保存到一个地址列表中（以供抓取囄��使用�Q�，�q�将�l�对地址替换成本地的相对地址�Q�即�?/p>
public static Map getImagesURL(String description) {

      Map map = new HashMap();
        // img 的正则表辑ּ�:匚w��标签
        String imgPattern = "<\\s*img\\s+([^>]+)\\s*>";
        Pattern pattern1 = Pattern.compile(imgPattern, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern1.matcher(description);

        // img src元素的正则表辑ּ��Q�匹配img标签内的src属�?br />         String srcPattern = "\\s*src\\s*=\\s*\"([^\"]+)\\s*\"";
        Pattern pattern2 = Pattern.compile(srcPattern, Pattern.CASE_INSENSITIVE);

        while (matcher.find()) {

           //group()�q�回�W�合表达式的内容
            Matcher matcher2 = pattern2 .matcher(matcher.group());
            // 一定要find(),�q�是实际的匹配动�?br />             if (matcher2.find()) {
                String src = matcher2.group();
                log.info(src);
                int i2 = src.lastIndexOf('/');
                int i1 = src.indexOf("http");
                if (i1 != -1) {
                    map.put(src.substring(i2 + 1, src.length() - 1), src
                            .substring(i1, src.length() - 1));
                }
            }
        }
        log.debug("囄��Q? + map);
        return map;
    }

整体思�\是先匚w��到img标签�Q�然后匹配src属性，�q�修改src的属�?/p>
"<\\s*img\\s+([^>]+)\\s*>" 的解释：

\\s* :0 或多个空�?nbsp; \\s+: 臛_��一个空�?/p>
([^>]+)�Q�指的是�?gt;的所有的字符�Q�至��一�?/p>

常用的正则表辑ּ��Q�参考jdk的regex文档�Q?/h1>

字符集类

.                            表示��L��一个字�W?

[abc]                     表示字符a�Q�b�Q�c中的��L��一�?与a|b|c相同)

[^abc]                   除a�Q�b�Q�c之外的�Q意一个字�W?否定)

[a-zA-Z]                从a到z或A到Z当中的�Q意一个字�W?范围)

[abc[hij]]              a,b,c,h,i,j中的��L��一个字�W?与a|b|c|h|i|j相同)(�q��)

[a-z&&[hij]]          h,i,j中的一�?交集)

\s                          �I�格字符(�I�格�? tab, 换行, 换页, 回�R)

\S                         非空格字�W?[^\s])

\d                         一个数字，也就是[0-9]

\D                         一个非数字的字�W�，也就是[^0-9]

\w                        一个单词字�W?word character)�Q�即[a-zA-Z_0-9]

\W                       一个非单词的字�W�，[^\w]

字符�c�：

B                         字符B

\xhh                    16�q�制�?xhh所表示的字�W?

\uhhhh                16�q�制�?xhhhh所表示的Unicode字符

\t                         Tab

\n                        换行�W?

\r                         回�R�W?

\f                        换页�W?

\e                       Escape

逻辑�q�算�W?/strong>

XY                      X 后面跟着 Y

X|Y                    X或Y

(X)                     一�?要匹配的�l?capturing group)". 以后可以用\i来表�C�第i个被匚w��的组�?

边界匚w��W?/strong>

^                      一行的开�?

$                      一行的�l�尾

\b                    一个单词的边界

\B                    一个非单词的边�?

\G                   前一个匹配的�l�束

数量表示�W?/strong>

"数量表示�W?quantifier)"的作用是定义模式应该匚w��多少个字�W��?

Greedy(贪婪�?�Q?除非另有表示�Q�否则数量表�C�符都是greedy的。Greedy的表辑ּ�会一直匹配下去，直到匚w��不下��Mؓ止�?u>(如果你发现表辑ּ�匚w��的结果与预期的不�W?�Q�很有可能是因�ؓ�Q�你以�ؓ表达式会只匹配前面几个字�W�，而实际上它是greedy的，因此会一直匹配下厅R�?

Reluctant(勉强�?�Q?用问可��C�，它会匚w��最��的字符。也�U�Cؓlazy, minimal matching, non-greedy, 或ungreedy�?

Possessive(占有�?�Q?目前只有Java支持(其它语言都不支持)。它更加先进�Q�所以你可能�q�不太会用。用正则表达式匹配字�W�串的时候会产生很多中间状态，(一般的匚w��引擎会保存这�U�中间状态，)�q�样匚w��p�|的时候就能原路返回了。占有型的表辑ּ�不保存这�U�中间状态，因此也就不会回头重来了。它能防止正则表辑ּ�的失控，同时也能提高�q�行的效率�?

Greedy                    Reluctant                           Possessive                      匚w��

X?                            X??                                      X?+                                  匚w��一个或零个X

X*                            X*?                                      X*+                                  匚w��零或多个X

X+                           X+?                                      X++                                 匚w��一个或多个X

X{n}                        X{n}?                                   X{n}+                               匚w��正好n个X

X{n,}                       X{n,}?                                 X{n,}+                              匚w��臛_��n个X

X{n,m}                   X{n,m}?                                X{n,m}+                           匚w��臛_��n个，臛_��m个X

参考资�?/h2>
要想�q�一步学习正则表辑ּ��Q�徏议看Mastering Regular Expression, 2nd Edition�Q�作者Jeffrey E. F. Friedl (O’Reilly, 2002)�?

"Regular Expressions and the Java Programming Language," Dana Nourie and Mike McCloskey (Sun Microsystems, August 2002) presents a brief overview of java.util.regex, including five illustrative regex-based applications:
http://developer.java.sun.com/developer/technicalArticles/releases/1.4regex/

http://www.aygfsteel.com/beike/archive/2006/04/28/43832.html

http://wcjok.bokee.com/4293762.html

凭栏观�v 2007-07-12 09:44 发表评论

用HttpClient来模拟浏览器GET POST(收藏)

凭栏观�v — Tue, 10 Jul 2007 08:05:00 GMT

用HttpClient来模拟浏览器GET POST

http://www.xd-tech.com.cn/blog/article.asp?id=34

作�?jaddy0302 日期:2006-12-21

      一般的情况下我们都是��用IE或者Navigator��览器来讉K��一个WEB服务器，用来��览��面查看信息或者提交一些数据等�{�。所讉K��的这些页面有的仅仅是一些普通的��面�Q�有的需要用��L��录后方可使用�Q�或者需要认证以及是一些通过加密方式传输�Q�例如HTTPS。目前我们��用的��览器处理这些情况都不会构成问题。不�q�你可能在某些时候需要通过�E�序来访问这��L��一些页面，比如从别人的�|�页中“偷”一些数据；利用某些站点提供的页面来完成某种功能�Q�例如说我们想知道某个手机号码的归属地而我们自己又没有�q�样的数据，因此只好借助其他公司已有的网站来完成�q�个功能�Q�这个时候我们需要向�|�页提交手机��L��q�从�q�回的页面中解析出我们想要的数据来。如果对方仅仅是一个很��单的��面�Q�那我们的程序会很简单，本文也就没有必要大张旗鼓的在�q�里��费口舌。但是考虑��C��些服务授权的问题�Q�很多公司提供的��面往往�q�不是可以通过一个简单的URL��可以访问的�Q�而必��ȝ��q�注册然后登录后方可使用提供服务的页面，�q�个时候就涉及�?COOKIE问题的处理。我们知道目前流行的***��|��术例如ASP、JSP无不是通过COOKIE来处理会话信息的。�ؓ了��我们的程序能使用别�h所提供的服务页面，��p��求程序首先登录后再访问服务页面，�q�过�E�就需要自行处理cookie�Q�想惛_��你用java.net.HttpURLConnection 来完成这些功能时是多么恐怖的事情啊！况且�q�仅仅是我们所说的��固的WEB服务器中的一个很常见的“顽固”！再有如通过HTTP来上传文件呢�Q�不需要头��|��q�些问题有了“它”就很容易解决了�Q?
我们不可能列举所有可能的��固�Q�我们会针对几种最常见的问题进行处理。当然了�Q�正如前面说到的�Q�如果我们自�׃��?java.net.HttpURLConnection来搞定这些问题是很恐怖的事情�Q�因此在开始之前我们先要介�l�一下一个开放源码的��目�Q�这个项目就�?Apache开源组�l�中的httpclient�Q�它隶属于Jakarta的commons��目�Q�目前的版本�?.0RC2。commons下本来已�l�有一个net的子��目�Q�但是又把httpclient单独提出来，可见http服务器的讉K��l�非易事�?
Commons-httpclient��目��是专门设计来简化HTTP客户端与服务器进行各�U�通讯�~�程。通过它可以让原来很头疼的事情现在��L��的解冻I��例如你不再管是HTTP或者HTTPS的通讯方式�Q�告诉它你想使用HTTPS方式�Q�剩下的事情交给 httpclient替你完成。本文会针对我们在编写HTTP客户端程序时�l�常��到的几个问题进行分别介�l�如何��用httpclient来解军_��们，��Z��让读者更快的熟悉�q�个��目我们最开始先�l�出一个简单的例子来读取一个网��늚�内容�Q�然后��@序渐�q�解��x��前进中的所形侍�?/font>
1�Q?��d��|�页(HTTP/HTTPS)内容
下面是我们给出的一个简单的例子用来讉K��某个��面
/*
* Created on 2003-12-14 by Liudong
*/
package http.demo;
import java.io.IOException;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.*;
/**
* 最��单的HTTP客户�?用来演示通过GET或者POST方式讉K��某个��面
* @author Liudong
*/
public class SimpleClient {
    public static void main(String[] args) throws IOException
    {
        HttpClient client = new HttpClient();
        //讄��代理服务器地址和端�?nbsp;
        //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);
        //使用GET�Ҏ��Q�如果服务器需要通过HTTPS�q�接�Q�那只需要将下面URL中的http换成https
        HttpMethod method = new GetMethod("        //使用POST�Ҏ��
        //HttpMethod method = new PostMethod("        client.executeMethod(method);
        //打印服务器返回的状�?
        System.out.println(method.getStatusLine());
        //打印�q�回的信�?
        System.out.println(method.getResponseBodyAsString());
        //释放�q�接
        method.releaseConnection();
    }
}
在这个例子中首先创徏一个HTTP客户�?HttpClient)的实例，然后选择提交的方法是GET或�?POST�Q�最后在HttpClient实例上执行提交的�Ҏ��Q�最后从所选择的提交方法中��d��服务器反馈回来的�l�果。这��是使用HttpClient的基本流�E�。其实用一行代码也��可以搞定整个请求的�q�程�Q�非常的��单！
2�Q?以GET或者POST方式向网��|��交参�?
其实前面一个最��单的�C�Z��中我们已�l�介�l�了如何使用GET或者POST方式来请求一个页面，本小节与之不同的是多了提交时讑֮��面所需的参敎ͼ�我们知道如果是GET的请求方式，那么所有参数都直接攑ֈ��面的URL后面用问号与��面地址隔开�Q�每个参数用&隔开�Q�例如：http://java.sun.com?name=liudong&mobile=123456�Q�但是当使用POST�Ҏ��时就会稍微有一点点�ȝ��。本��节的例子演�C�向如何查询手机��L��所在的城市�Q�代码如下：
/*
* Created on 2003-12-7 by Liudong
*/
package http.demo;
import java.io.IOException;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.methods.*;
/**
* 提交参数演示
* 该程序连接到一个用于查询手机号码所属地的页�?
* 以便查询��L��D?330227所在的省䆾以及城市
* @author Liudong
*/
public class SimpleHttpClient {
    public static void main(String[] args) throws IOException
    {
        HttpClient client = new HttpClient();
        client.getHostConfiguration().setHost("        HttpMethod method = getPostMethod();//使用POST方式提交数据
        client.executeMethod(method);
       //打印服务器返回的状�?
        System.out.println(method.getStatusLine());
        //打印�l�果��面
        String response = new String(method.getResponseBodyAsString().getBytes("8859_1"));
       //打印�q�回的信�?
        System.out.println(response);
        method.releaseConnection();
    }
    /**
     * 使用GET方式提交数据
     * @return
     */
    private static HttpMethod getGetMethod(){
        return new GetMethod("/simcard.php?simcard=1330227");
    }
    /**
     * 使用POST方式提交数据
     * @return
     */
    private static HttpMethod getPostMethod(){
        PostMethod post = new PostMethod("/simcard.php");
        NameValuePair simcard = new NameValuePair("simcard","1330227");
        post.setRequestBody(new NameValuePair[] { simcard});
        return post;
    }
}
在上面的例子中页�?a >http://www.imobile.com.cn/simcard.php需要一个参数是simcard�Q�这个参数��gؓ手机��L��D�，��x��机号码的前七位，服务器会�q�回提交的手机号码对应的省䆾、城市以及其他详�l�信息。GET的提交方法只需要在URL后加入参��C��息，而POST则需要通过NameValuePair�c�L��讄��参数名称和它所对应的�?
3�Q?处理��面重定�?
在JSP/Servlet�~�程中response.sendRedirect�Ҏ��是使用HTTP协议中的重定向机制。它与JSP中的状态码
对应HttpServletResponse的常�?br> 详细描述
301　 SC_MOVED_PERMANENTLY
��面已经�怹��U�d��另外一个新地址
302　 SC_MOVED_TEMPORARILY
��面暂时�U�d��到另外一个新的地址
303　 SC_SEE_OTHER
客户端请求的地址必须通过另外的URL来访�?br>307　 SC_TEMPORARY_REDIRECT　同SC_MOVED_TEMPORARILY
下面的代码片�D�|��C�如何处理页面的重定�?
client.executeMethod(post);
        System.out.println(post.getStatusLine().toString());
        post.releaseConnection();
        //��查是否重定向
        int statuscode = post.getStatusCode();
        if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||
            (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
            (statuscode == HttpStatus.SC_SEE_OTHER) ||
(statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
//��d��新的URL地址
            Header header = post.getResponseHeader("location");
            if (header != null) {
                String newuri = header.getValue();
                if ((newuri == null) || (newuri.equals("")))
                    newuri = "/";
                GetMethod redirect = new GetMethod(newuri);
                client.executeMethod(redirect);
                System.out.println("Redirect:"+ redirect.getStatusLine().toString());
                redirect.releaseConnection();
            } else
                System.out.println("Invalid redirect");
        }
我们可以自行�~�写两个JSP��面�Q�其中一个页面用response.sendRedirect�Ҏ��重定向到另外一个页面用来测试上面的例子�?
4�Q?模拟输入用户名和口��o�q�行��d��
本小节应该说是HTTP客户端编�E�中最常碰见的问题�Q�很多网站的内容都只是对注册用户可见的，�q�种情况下就必须要求使用正确的用户名和口令登录成功后�Q�方可浏览到惌��的页面。因为HTTP协议是无状态的�Q�也��是�q�接的有效期只限于当前请求，��h��内容�l�束后连接就关闭了。在�q�种情况下�ؓ了保存用��L��d��信息必须使用到Cookie机制。以JSP/Servlet��Z��Q�当��览器请求一个JSP或者是Servlet的页面时�Q�应用服务器会返回一个参敎ͼ�名�ؓjsessionid�Q�因不同应用服务器而异�Q�，值是一个较长的唯一字符串的Cookie�Q�这个字�W�串��g��是当前讉K��该站点的会话标识。浏览器在每讉K��该站点的其他��面时候都要带上jsessionid�q�样的Cookie信息�Q�应用服务器�Ҏ��d��q�个会话标识来获取对应的会话信息�?
对于需要用��L��录的�|�站�Q�一般在用户��d��成功后会��用戯��料保存在服务器的会话中，�q�样当访问到其他的页面时候，应用服务器根据浏览器送上的Cookie中读取当前请求对应的会话标识以获得对应的会话信息�Q�然后就可以判断用户资料是否存在于会话信息中�Q�如果存在则允许讉K��面�Q�否则蟩转到��d��面中要求用戯��入帐号和口��o�q�行��d��。这��是一般��用JSP开发网站在处理用户��d��的比较通用的方法�?
�q�样一来，对于HTTP的客��L��来讲�Q�如果要讉K��一个受保护的页面时��必��L��拟浏览器所做的工作�Q�首先就是请求登录页面，然后��d��Cookie��|��再次��h��d��面�q�加入登录页所需的每个参敎ͼ�最后就是请求最�l�所需的页面。当然在除第一�ơ请求外其他的请求都需要附带上 Cookie信息以便服务器能判断当前��h��是否已经通过验证。说了这么多�Q�可是如果你使用httpclient的话�Q�你甚至�q�一行代码都无需增加�Q�你只需要先传递登录信息执行登录过�E�，然后直接讉K��惌��的页面，跟访问一个普通的��面没有��M��区别�Q�因为类HttpClient已经帮你做了所有该做的事情了，太棒了！下面的例子实��C��q�样一个访问的�q�程�?
/*
* Created on 2003-12-7 by Liudong
*/
package http.demo;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.cookie.*;
import org.apache.commons.httpclient.methods.*;
/**
* 用来演示��d��表单的示�?
* @author Liudong
*/
public class FormLoginDemo {
    static final String LOGON_SITE = "localhost";
    static final int    LOGON_PORT = 8080;
    public static void main(String[] args) throws Exception{
        HttpClient client = new HttpClient();
        client.getHostConfiguration().setHost(LOGON_SITE, LOGON_PORT);
       //模拟��d��面login.jsp->main.jsp
        PostMethod post = new PostMethod("/main.jsp");
        NameValuePair name = new NameValuePair("name", "ld");
        NameValuePair pass = new NameValuePair("password", "ld");
        post.setRequestBody(new NameValuePair[]{name,pass});
       int status = client.executeMethod(post);
        System.out.println(post.getResponseBodyAsString());
        post.releaseConnection();
       //查看cookie信息
        CookieSpec cookiespec = CookiePolicy.getDefaultSpec();
        Cookie[] cookies = cookiespec.match(LOGON_SITE, LOGON_PORT, "/", false, client.getState().getCookies());
       if (cookies.length == 0) {
           System.out.println("None");
       } else {
           for (int i = 0; i < cookies.length; i++) {
               System.out.println(cookies[i].toString());
           }
       }
       //讉K��所需的页面main2.jsp
        GetMethod get = new GetMethod("/main2.jsp");
        client.executeMethod(get);
        System.out.println(get.getResponseBodyAsString());
        get.releaseConnection();
    }
}
5�Q?提交XML格式参数
提交XML格式的参数很��单，仅仅是一个提交时候的ContentType问题�Q�下面的例子演示从文件文件中��d��XML信息�q�提交给服务器的�q�程�Q�该�q�程可以用来��试Web服务�?
import java.io.File;
import java.io.FileInputStream;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.EntityEnclosingMethod;
import org.apache.commons.httpclient.methods.PostMethod;
/**
* 用来演示提交XML格式数据的例�?
*/
public class PostXMLClient {
    public static void main(String[] args) throws Exception {
        File input = new File(“test.xml�?;
        PostMethod post = new PostMethod(“http://localhost:8080/httpclient/xml.jsp�?;
        // 讄��h��的内容直接从文�g中读�?
        post.setRequestBody(new FileInputStream(input));
        if (input.length() < Integer.MAX_VALUE)
            post.setRequestContentLength(input.length());
        else

post.setRequestContentLength(EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);

        // 指定��h��内容的类�?
        post.setRequestHeader("Content-type", "text/xml; charset=GBK");
        HttpClient httpclient = new HttpClient();
        int result = httpclient.executeMethod(post);
        System.out.println("Response status code: " + result);
        System.out.println("Response body: ");
        System.out.println(post.getResponseBodyAsString());
        post.releaseConnection();
    }
}
6�Q?通过HTTP上传文�g
httpclient使用了单独的一个HttpMethod子类来处理文件的上传�Q�这个类��是MultipartPostMethod�Q�该�c�d��l�封装了文�g上传的细节，我们要做的仅仅是告诉它我们要上传文�g的全路径卛_��Q�下面的代码片段演示如何使用�q�个�c�R�?
MultipartPostMethod filePost = new MultipartPostMethod(targetURL);
filePost.addParameter("fileName", targetFilePath);
HttpClient client = new HttpClient();
//�׃��要上传的文�g可能比较�?因此在此讄��最大的�q�接��时旉��
client.getHttpConnectionManager().getParams().setConnectionTimeout(5000);
int status = client.executeMethod(filePost);
上面代码中，targetFilePath即�ؓ要上传的文�g所在的路径�?
7�Q?讉K��启用认证的页�?
我们�l�常会碰到这��L��面�Q�当讉K��它的时候会弹出一个浏览器的对话框要求输入用户名和密码后方可，�q�种用户认证的方式不同于我们在前面介�l�的��Z��表单的用戯��n份验证。这是HTTP的认证策略，httpclient支持三种认证方式包括�Q�基本、摘要以及NTLM认证。其中基本认证最��单、通用但也最不安全；摘要认证是在HTTP 1.1中加入的认证方式�Q�而NTLM则是微��Y公司定义的而不是通用的规范，最新版本的NTLM是比摘要认证�q�要安全的一�U�方式�?
下面例子是从httpclient的CVS服务器中下蝲的，它简单演�C�如何访问一个认证保护的��面�Q?
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.methods.GetMethod;
public class BasicAuthenticationExample {
    public BasicAuthenticationExample() {
    }
    public static void main(String[] args) throws Exception {
        HttpClient client = new HttpClient();
        client.getState().setCredentials(
            "            "realm",
            new UsernamePasswordCredentials("username", "password")
        );
        GetMethod get = new GetMethod("        get.setDoAuthentication( true );
        int status = client.executeMethod( get );
        System.out.println(status+""+ get.getResponseBodyAsString());
        get.releaseConnection();
    }
}
8�Q?多线�E�模式下使用httpclient
多线�E�同时访问httpclient�Q�例如同时从一个站点上下蝲多个文�g。对于同一个HttpConnection 同一个时间只能有一个线�E�访问，��Z��保证多线�E�工作环境下不��生冲�H�，httpclient使用了一个多�U�程�q�接��理器的�c�： MultiThreadedHttpConnectionManager�Q�要使用�q�个�c�d��单，只需要在构造HttpClient实例的时候传入即可，代码如下�Q?pre>MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager(); HttpClient client = new HttpClient(connectionManager);

以后��管讉K��client实例卛_��?
参考资料：
httpclient首页�Q?nbsp;   http://jakarta.apache.org/commons/httpclient/
关于NTLM是如何工作： http://davenport.sourceforge.net/ntlm.html

凭栏观�v 2007-07-10 16:05 发表评论

java IO�?学习记录

凭栏观�v — Tue, 10 Jul 2007 04:30:00 GMT

所有类的根接口�Q�InputStream/OutputStream
一、底层的�q�是装饰�?/b>

1、底层的直接与文件系�l�或者硬件打交道的类(充当数据源的�c?�Q?
包括InputStream和OutPutStream两大�c�，分别用于输入和输出，数据源可以是bytes array�Q�String对象�Q�file文�g�Q�stream序列�{�：

FileInputStream/FileOutputStream
ByteArrayInputStream/ByteArrayOutputStream
StringBufferInputStream/StringBufferOutputStream

�{�，具体参看下面的java io�c�d��
2、充当装饰功能的io�c?通过装饰底层的类来实现更高��的功能，�l�承自FilterOutputStream/FilterOutputStream�Q�包括：

BufferedOutputStream/BufferedInputStream
Datainputstream/Dataoutputstream

�{�，具体参看下面的java io�c�d��
使用FilterOutputStream/FilterOutputStream�Ӟ��首先创徏一个数据源IO�Q�然后根据需要的功能创徏装饰�c�io�Q�其构造函数的参数为已创徏的数据源io�?

二、面向字�W�还是面向字�?/b>

同时�Q�java的IO体系又可以分成：inputStream/outputStream和reader/writer两类�Q?
�Q?�Q?Reader/Writer是面向Unicode字符的（Characters�Q?
�Q?�Q?InputStream/OutputStream是直接面向字节的�Q�bytes�Q��?
Reader/Writer�l�承体系之所以存在，最重要的原因是��Z��国际化，旧式I/O stream 的��承体�p�M��仅支�?-bit byte stream�Q�而且无法处理16-bit unicode 字符。由于unicode被用于字�W�国际化�Q�所以加入Reader/Writer以便在所有的io动作上提供对unicode的支持�?
几乎所有的java io stream classes都有相应的Reader和Writer来提供对unicode的支持，但是在某些场合，使用byte-oriented InputStream和OutPutStream才是正取的方法，最合理的方式是��可能先��试使用Read和Writer�Q�其�ơ才使用byte-oriented库�?
三、从InputStream/OutPutStream到Reader/Writer的�{�?/b>

InputStreamReader和OutputStreamWriter�Q�可以把一个以字节为导向的stream转换成一个以字符为导向的stream�?
Java 1.0 class�Q�byte oriented�Q?nbsp;     Java 1.1 class(unicode character oriented)
装饰前的行�ؓ
InputStream                                                       Reader 转换器：InputStreamReader
OutputStreamReader                                          Writer 转换器：OutputStreamWriter
FileInputSream                                                   FileOutputStream
FileReader                                                          FileWriter
StringBufferInputStream                                    StringReader/StringWriter
ByteArrayInputStream                                        ByteArrayOutputStream
CharArrayReader                                                CharArrayWriter
装饰后的行�ؓ
BufferedInputStream                                          BufferedOutputStream
BufferedReader                                                  BufferedWriter
PrintStream                                                        PrintWriter

四、示�?/b>

DataInputStream和DataOutputStream
Java中除了二�q�制文�g和��用文本文件外�q�有��Z��Data的数据操作，�q�里的Data指的是Java的基本数据类型和String。基本数据类型包括byte、int、char、long、float、double、boolean和short�?/b>

例子�Q?/b>
protected void connect (Socket socket)
throws IOException, SocketException
{
this.socket = socket;
applyTimeout();
serverIn = new DataInputStream (
new BufferedInputStream (socket.getInputStream ())
);
serverOut = new DataOutputStream(
new BufferedOutputStream(socket.getOutputStream(), 2048)
);
usable = true;
cnt[CONNECT]++;
setChanged();
notifyObservers();
}
在DataInputStream和DataOutputStream两个�c�M��的方法都很简单，基本�l�构为readXXXX()和writeXXXX()其中XXXX代表基本数据�c�d��或者String�?/p>

凭栏观�v 2007-07-10 12:30 发表评论

牛刀��试-用jdom来解析ant的build文�g

凭栏观�v — Thu, 05 Jul 2007 01:11:00 GMT

/**
* 学习jdom操作xml的习作：解析ant的build文�g�Q�目的是得到target的执行顺�?br>*
*/
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class AntFileParser {
    private static Map<String, Element> targetMap;

    /**
     * @param args
     */
    public static void main(String[] args) {
        String xmlfile = "xmlfile/aaa.xml";
        Document doc;
        String finalTarget = "run";
        try {
            doc = build(xmlfile);
        } catch (JDOMException e) {
            throw new RuntimeException("parse error" + e, e);
        } catch (IOException e) {
            throw new RuntimeException("parse error" + e, e);
        }

        generateTargetNameMap(doc);
        // 首先��最�l��Q务入�?/span>
        Stack<String> stack = new Stack<String>();
        stack.push(finalTarget);
        // 计算其他��d��的执行顺�?/span>
        getExecuteOrder(findElementByAttributeName(finalTarget), stack);
        System.out.print("执行��序�Q?nbsp; ");
        while (!stack.isEmpty()) {
            System.out.print(stack.pop() + " ");
        }

    }

    public static Document build(String file) throws JDOMException, IOException {
        SAXBuilder b = new SAXBuilder();
        Document doc = b.build(new File(file));
        return doc;
    }

    /**
     * 获取所有target元素
     *
     * @param doc
     * @return
     */
    public static List getTarget(Document doc) {
        return doc.getRootElement().getChildren("target");
    }

    /**
     * 获取指定元素的所有依�?br>     *
     * @param element
     * @return
     */
    public static String[] getDepents(Element element) {
        String depends = element.getAttribute("depends").getValue();
        return depends.split(",");
    }

    /**
     * 使用递归的方法查找执行顺�?br>     *
     * @param element
     * @param stack
     */
    public static void getExecuteOrder(Element element, Stack<String> stack) {
        String cur;
        if (element.getAttribute("depends") == null) {
            // 已经扑ֈ�了第一个�Q务，退�?/span>
            return;
        } else {
            String[] depends = getDepents(element);
            cur = depends[0];
            if (depends.length != 1) {
                // 存在多个依赖��d��Q�可能有两种情况�Q?br>                // �Q?�Q�多个�Q务之间有依赖关系�Q�则�q�回依赖最大的��d��Q?br>                // �Q?�Q�多个�Q务之间没有依赖关�p�，则返回全部依赖，用逗号分隔
                cur = getmaxDependence(depends);
            }
            String[] curs = cur.split(",");
            // 如果存在�q�行��d��且�ƈ行�Q务之间没有互�怾�赖，则一�q�放入堆栈，无所谓顺�?/span>
            for (String string : curs) {
                element = findElementByAttributeName(string);
                // ��查是否已�l�入�?/span>
                if (!stack.contains(element.getAttributeValue("name")))
                    stack.push(element.getAttributeValue("name"));
            }
            // 递归
            getExecuteOrder(element, stack);
        }

    }

    /**
     * 从缓存的Map中，依据target元素的name属性查找target元素
     *
     * @param name
     * @return
     */
    public static Element findElementByAttributeName(String name) {
        return targetMap.get(name);
    }

    /**
     * ��target元素和其name属性缓存到map�?br>     *
     * @param doc
     */
    public static void generateTargetNameMap(Document doc) {
        List targetList = getTarget(doc);
        targetMap = new HashMap<String, Element>();
        for (Object object : targetList) {
            Element ele = (Element) object;
            String name = ele.getAttributeValue("name");
            targetMap.put(name, ele);
        }
    }

    public static String getmaxDependence(String[] depends) {
        int size = depends.length;
        String target = "";
        // 保存每一个�Q务对其他��d��的存在依赖关�pȝ��ơ数
        int[] counts = new int[size];
        //
        for (int i = 0; i < size; i++) {
            Element cur = findElementByAttributeName(depends[i]);
            // ��数�l��{换成ArrayList
            List list = arrayToList(getDepents(cur));
            for (int j = i + 1; j < size; j++) {
                // ��查当前�Q务对depends数组中的其他��d��是否存在依赖
                if (list.contains(depends[j])) {
                    counts[i]++;
                }
            }
        }
        // 获取最大依�?/span>
        int max = 0;
        for (int a : counts) {
            if (max < a)
                max = a;
        }
        // 如果最大依赖�ؓ0�Q�则说明depends中的��d��之间没有互相依赖�Q��ؓ�q�行��d��Q��{换逗号分隔�q�回
        if (max == 0) {
            for (int i = 0; i < size; i++) {
                target = target + depends[i] + ",";
            }
            // 除去最后一个逗号
            target = target.substring(0, target.length() - 1);
            return target;
        }
        // 否则�Q��Q务之间存在依赖，取最大依�?/span>
        for (int i = 0; i < size; i++) {
            if (counts[i] == max)
                target = depends[i];
        }
        return target;
    }

    public static List<String> arrayToList(String[] array) {
        ArrayList<String> list = new ArrayList<String>();
        for (String string : array) {
            list.add(string);
        }
        return list;
    }

}

用到的xml文�g

xml version="1.0" encoding="UTF-8"?>
<project name="srping_study" default="run">

    <property name="src" value="src" />
    <property name="bin" value="bin" />
    <property name="test" value="test" />
    <property name="run.classpath" value="bin" />
    <property name="lib" value="lib" />
    <property name="xmlfile" value="xmlfile" />

    <path id="spring.lib">
        <pathelement path="${lib}" />
        <fileset dir="${lib}" includes="*.jar" />
    path>

    <target name="clear">
        <delete dir="${bin}" quiet="true" />
    target>

    <target name="compile" depends="clear">
        <mkdir dir="bin" />
        <javac destdir="${run.classpath}" srcdir="${src}" classpathref="spring.lib">
        javac>
        <copy todir="${run.classpath}">
            <fileset dir="${xmlfile}">
                <include name="*.xml" />
                <include name="*.properties" />
            fileset>
        copy>
    target>

    <target name="deploy" depends="compile">
        <java classname="org.chen.spring_study.HibernateUtil" classpathref="spring.lib">
            <classpath path="${run.classpath}" />
        java>
    target>

    <target name="deploy1" depends="deploy">
            <java classname="org.chen.spring_study.HibernateUtil" classpathref="spring.lib">
                <classpath path="${run.classpath}" />
            java>
        target>

    <target name="test" depends="compile">
        <java classname="org.chen.spring_study.transaction.programmic.ProgramicCodingTrans" classpathref="spring.lib">
            <classpath path="${run.classpath}" />
        java>
    target>


    <target name="run" depends="test,deploy,deploy1">
        <java classname="org.chen.spring_study.transaction.declaretrans.DeclareClient" classpathref="spring.lib">
            <classpath path="${run.classpath}" />
        java>
    target>
project>

凭栏观�v 2007-07-05 09:11 发表评论

Jdom 常用API

凭栏观�v — Wed, 04 Jul 2007 08:35:00 GMT

使用Jdom�Q�操作xml从此变得方便�Q�^_^

一、创建XML文�g

Document doc = new Document(new Element("rootElement"))

或�?

Document doc = new Document();
// 根元�?/p>
Element root = new Element("persons");
doc.addContent(root);

// add person
Element person = new Element("person").setText("test1");
root.addContent(person);

//add person 2
person = new Element("person").setText("test2");
root.addContent(person);

另外一�U�方式：

Document doc = new Document(new Element("family")
.addContent(new Element("mom"))
.addContent(new Element("dad").addContent("kidOfDad")));

二、解析XML文�g

   一般而言�Q��用org.jdom.input.SAXBuilder更快�Q�推荐��用，而org.jdom.input.DOMBuilder适用于已�l�存在DOM对象的场合�?

SAXBuilder b = new SAXBuilder();
            // Create the document
Document doc = b.build(new File(xmlfilename));

获取根元素：Element webapp = doc.getRootElement();

获取子节点（支持namespace�Q�：

// Get a List of direct children as Elements
List allChildren = element.getChildren();

// Get all direct children with a given name
List namedChildren = element.getChildren("name");

// Get the first kid with a given name
Element kid = element.getChild("name");

增加/删除子节点，可以像操作List对象一��h��作子节点集合�Q�当然也可以以传�l�的方式来操�?/li>

List allChildren = element.getChildren();
// Remove the fourth child
allChildren.remove(3);
// Remove all children named "jack"
allChildren.removeAll(element.getChildren("jack"));

或�?br /> element.removeChildren("jack");
// Add a new child
allChildren.add(new Element("jane"));

或�?br /> element.addContent(new Element("jane"));
// Add a new child in the second position
allChildren.add(1, new Element("second"));

��d��/讄��属�?/li>

// ��d��属性：

String value =table.getAttributeValue("width");// table 是element
// 也可以在��d��属性的同时�q�行�c�d��转换
try {
value =table.getAttribute("border").getIntValue();
}
catch (DataConversionException e) { }

// 讄��属�?

// Add an attribute
table.addAttribute("vspace", "0");
// Add an attribute more formally 比较正式的写�?br /> table.addAttribute(new Attribute("name", "value"))
// Remove an attribute
table.removeAttribute("border");
// Remove all attributes �U�除所有属�?br /> table.getAttributes().clear();

获取元素的内�?/li>

比如A cool demo�Q�则可以直接获取内容

String content = element.getText();

// �U�除多余的空白，字符串前后的�I�白�Q�不会移除字�W�串内部的空�?

element.getTextNormalize();

讄��元素的内�?/li>

// This blows away all current content
element.setText("A new description");

//Special characters are interpreted correctly: �Ҏ��字符可以被正��地转义

element.setText(" content");

// 创徏cdata元素

element.addContent(new CDATA(" content"));

三、输出XML

XMLOutputter �cȝ��来实现XML文�g的输出，在创建的时候需要一个Format对象来格式化XML文�g�Q�Format对象是一个工厂类�Q�提供几个静态的工厂�Ҏ��来提供一些常规的XML格式�Q�比如getPrettyFormat()�Q?

XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
        try {
            outputter.output(doc, new FileOutputStream(new File("xmlfile/persons.xml")));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

四、xml Namespace的支�?/h2>

获取名空�?/li>

Namespace xhtml = Namespace.getNamespace("xhtml", “http://www.w3.org/1999/xhtml”);

Namespace 对象可以作�ؓElement 和Attribute的大多数�Ҏ��的可选参敎ͼ�

List kids = element.getChildren("p", xhtml);
Element kid = element.getChild("title", xhtml);
Attribute height = element.getAttribute("height", xhtml);

附录�Q�Java下XML�~�程接口比较�Q�DOM SAX JDOM JAXP�Q�网�l�装载）

一、DOM �Q�文档对象模型）
�?XML 文档的已解析版本定义了一�l�接口。解析器��d��整个文档�Q�然后构��Z��个驻留内存的树结构，然后代码��可以��?DOM 接口来操作这个树�l�构�?br /> 优点�Q�整个文档树在内存中�Q�便于操作；支持删除、修攏V��重新排列等多种功能�Q?br /> �~�点�Q�将整个文档调入内存�Q�包括无用的节点�Q�，��费旉��和空��_��
使用场合�Q�一旦解析了文档�q�需多次讉K��q�些数据�Q?br /> ��g资源充��Q�内存、CPU�Q?br /> 二、SAX
��决DOM的问题，出现了SAX�?br /> SAX �Q�事仉��动。当解析器发现元素开始、元素结束、文本、文档的开始或�l�束�{�时�Q�发送事�Ӟ��E�序员编写响应这些事件的代码�Q�保存数据�?br /> 优点�Q�不用事先调入整个文档，占用资源��；
SAX解析器代码比DOM解析器代码小�Q�适于Applet�Q�下�?br /> �~�点�Q�不是持久的�Q�事件过后，若没保存数据�Q�那么数据就丢了�Q?br /> 无状态性；从事件中只能得到文本�Q�但不知该文本属于哪个元素；
使用场合�Q�Applet;
只需XML文档的少量内容，很少回头讉K��Q?br /> 机器内存��；
三、JDOM
为减��DOM、SAX的编码量�Q�出��C��JDOM�Q?br /> 优点�Q?0-80原则�Q�极大减��了代码�?br /> 使用场合�Q�要实现的功能简单，如解析、创建等�Q�但在底层，JDOM�q�是使用SAX�Q�最常用�Q�、DOM、Xanan
四、JAXP
为多个XML解析器提供了�l�一�~�程接口
更换解析器，不用更改代码
使用场合�Q�若不用Jdom�Q�一般徏议��用JAPX�Q�将代码与各�U�解析器的实现细节隔��R�?/p>

凭栏观�v 2007-07-04 16:35 发表评论

The JDOM Philosophy

凭栏观�v — Wed, 04 Jul 2007 03:19:00 GMT

The JDOM Philosophy

• JDOM should be straightforward for Java programmers
– Use the power of the language (Java 2)
– Take advantage of method overloading, the Collections APIs, reflection, weak references
– Provide conveniences like type conversions

• JDOM should hide the complexities of XML wherever possible
– An Element has content, not a child Text node with content
– Exceptions should contain useful error messages
– Give line numbers and specifics, use no SAX or DOM specifics

• JDOM should integrate with DOM and SAX
– Support reading and writing DOM documents and SAX events
– Support runtime plug-in of any DOM or SAX parser
– Easy conversion from DOM/SAX to JDOM
– Easy conversion from JDOM to DOM/SAX

• JDOM should stay current with the latest XML standards
– DOM Level 2, SAX 2.0, XML Schema

• JDOM does not need to solve every problem
– It should solve 80% of the problems with 20% of the effort
– We think we got the ratios to 90% / 10%

JDOM consists of five packages

The org.jdom.input Package

• Classes for reading XML from existing sources:
– DOMBuilder
– SAXBuilder
• Also, outside contributions in jdom-contrib:
– ResultSetBuilder
– SpitfireBuilder
• New support for JAXP-based input
– Allows consistency across applications
– Builders pick up JAXP information and user automatically
– Sets stage for JAXP version.next

The org.jdom.output Package

Classes for writing XML to various forms of output:
– DOMOutputter
– SAXOutputter
– XMLOutputter
Also, outside contributions in jdom-contrib:
– JTreeOutputter

org.jdom.transform

• TRaX is now supported in org.jdom.transform
– Supports XSLT transformations
– Defines Source and Result interfaces
– JDOMSource
– JDOMResult

General Program Flow

• Normally XML Document -> SAXBuilder ->XMLOutputter

完整的pdf下蝲地址�Q?span style="font-weight: bold;">JDOM: How It Works,and How It Opened the Java Processby Jason Hunter

http://www.aygfsteel.com/Files/cherishchen/JDOM%20How%20It%20Works.zip

凭栏观�v 2007-07-04 11:19 发表评论

一家之�a�--Java异常处理

凭栏观�v — Wed, 04 Jul 2007 01:18:00 GMT
   Java异常为我们提供了一致的识别和处理程序错误的机制�Q�有效的异常处理能增强程序的健壮性和易于调试性�?/span>
首先�q�是重温�?/span>java的异�怽��pȝ��构，如图所�C�，所有异常的�Ҏ��Throwable�Q�异常又分�ؓchecked exception�?/span>unchecked exception�Q?/span>RuntimeException��是属于unchecked exception�Q?/span>JVM 一旦捕捉到unchecked exception ��׃��l�止当前�q�行的程序，�q�在console中打出错误信息�?/span>

ption hierarchy

一�?/span>Unchecked exceptions VS Checked exceptions

下表列出使用两种异常的场合：

Client's reaction when exception happens

Exception type

Client code cannot do anything

Make it an unchecked exception

Client code will take some useful recovery action based on information in exception

Make it a checked exception

�q�个斚w��的例�?/span>hibernate��是一个，�?/span>hibernate2中，HibernateException�q�是checked exceptions�Q�但是到�?/span>hibernate3中就成了unchecked exceptions�Q�因为对于数据库操作来说�Q�一旦出现异常，��是比较严重的错误，而且�?/span>client端基本上是无能�ؓ力的�Q��?/span>unchecked exceptions更加合适�?/span>

另外�Q?/span>unchecked exceptions的优点在于不��客户端代码显式地处理他们�Q�异常可以一直往上传递（除非需要�{化异常，否则异常不需要在中间被捕捉，节省了很多的try{}catch()�Q�代码更加简�z�）�Q�直��C��x��捉处理他们，�Q�有��Z��问，如何不强制客��L��处理他们�Q�比如像checked exceptions�q�样�Q�不处理��是语法错误�Q�如何保证异常能够得到处理呢�Q�在�q�点上，java提供的完善的文档机制�Q�通过API客户端程序员可以很方便地知道他调用的�Ҏ��可能会抛��Z��么异常，一个负责�h的程序员��应该对其进�?/span>catch和处理）�Q?/span>Java API提供了很多的unchecked exceptions�Q�比�?/span>NullPointerException, IllegalArgumentException, and IllegalStateException�Q��?span lang="EN-US">java提供的标准的unchecked exceptions是值得推荐的，�q�样的好处在于��代码更加��z��ƈ可以减少代码对内存的占用�?/span>

二�?/span>Java异常的推�q�处�?/span>

Java异常应该��可能地推迟处理�Q�除非要转化异常�Q�重新抛出，否则最好不要处理，而是留给最后能够处理异常的地方�?/span>

通过为方法添�?/span>throws声明�Q�可以将处理异常的责��M��递到更高的层�ơ。在声明哪些需要抛出的时候，应该��可能地详细。这样做的目的是可以�?/span>API中详�l�地表述��Ҏ��可能会出现的异常�Q�从而让调用该方法的clinet�E�序员做好处理异常的准备�Q�比如对于代码通过throws语句详细地声明了可能会抛出的异常�Q�这栯��用该�Ҏ��的程序员��׃��知道��会有什么样的异�怼�发生�?/span>

public void readPreferences(String filename)

    throws IllegalArgumentException,

          FileNotFoundException, IOException
{

    if (filename == null)
    {

        throw new IllegalArgumentException

                        ("filename is null");

    }  //if
    //
    InputStream in = new FileInputStream(filename);

    //
}

从语法上�Ԍ��IllegalArgumentException�?/span>unckecked exception 是不需要声明的�Q�但是�ؓ了从文档的角度考虑�Q�最好还是加上，�q�样可以让调用这个方法的�E�序员知道，�q�个�Ҏ��会可能抛��异常�Q�需要加以捕捉和处理�?/span>

三、异常的处理

不管如何�Q�最�l�程序肯定是要对异常�q�行处理的，否则会导致不��定情况的发生，但是选择异常处理的位�|�却是有技巧的�Q�通常要么是程序在�q�些地方从异�怸�恢复、��l�执行且不会��D��q�一步异常的发生�Q�要么是在这些地方能为用户反馈特定的信息�Q�比如，如何避免异常的发生或者如何从异常中恢复。因此，对于有用��L��面层的程序，��异常的捕捉和处理推�q�到UI层是有好处的�Q�在UI层可以��用对话框或者其他方式提�C�用户出现异常�?/span>

参考文�?/span>

Best Practices for Exception Handling by Gunjan Doshi

Three Rules for Effective Exception Handling by Jim Cushing

凭栏观�v 2007-07-04 09:18 发表评论

凭栏观�v — Tue, 03 Jul 2007 08:28:00 GMT

Dijkstra��法是由荷兰计算机科学家艑օ��?#183;�q�科斯彻发现的。算法解决的是有向图中最短�\径问题�?/p>
举例来说�Q�如果图中的��点表示城市�Q�而边上的权重表示著城市间开车行�l�的距离�?Dijkstra��法可以用来扑ֈ�两个城市之间的最短�\径�?/p>
Dijkstra��法的输入包含了一个有权重的有向图G�Q�以及G中的一个来源顶�?em>S�?我们�?em>V表示G中所有顶点的集合。图中的每一个边�Q�都是两个顶�Ҏ��形成的有序元素对�?u,v)表示从顶�?em>u�?em>v有�\径相�q��?假设E�?/em>所有边的集合，而边的权重则由权重函�?em>w: E → [0, ∞]定义�?因此�Q?em>w(u,v)��是从顶�?em>u到顶�?em>v的非负花费�?cost)�?边的��p��可以惛_��成两个顶点之间的距离。�Q两点间�\径的��p��|��是该�\径上所有边的花费值��d��?已知�?em>V中有��点s�?em>t�Q�Dijkstra��法可以扑ֈ�s�?em>t的最低花费�\�?i.e. 最短�\�?�?�q�个��法也可以在一个图中，扑ֈ�从一个顶�?em>s��C�Q何其他顶点的最短�\径�?/p>

��法描述

�q�个��法是通过为每个顶�?em>v保留目前为止所扑ֈ�的从s到v的最短�\径来工作的。初始时�Q�源点s的�\径长度��D��赋�ؓ0�Q?em>d[s]=0�Q�，同时把所有其他顶点的路径长度设�ؓ无穷大，卌��C�我们不知道��M��通向�q�些��点的�\径（对于V中所有顶�?em>v�?em>s�?em>d[v]= ∞�Q�。当��法�l�束�Ӟ��d[v]中储存的便是�?em>s�?em>v的最短�\径，或者是无穷大（如果路径不存在的话）�?

   Dijstra��法的基��操作是边的拓展：如果存在一条从u�?em>v的边�Q�那么从s到v的最短�\径可以通过��边(u,v)��d��到s到u的尾部来拓展。这条�\径的长度是d[u]+w(u,v)。如果这个值比目前已知�?em>d[v]的��D��，我们可以用新值来替代当前d[v]中的倹{��拓展边的操作一直执行到所有的d[v]都代表从s到v最短�\径的��p��。这个算法经�q�适当的组�l�因而当d[u]辑ֈ�它最�l�的值的时候，每条�?u,v)都只被拓展一�ơ�?/p>
��法�l�护两个��点集S和Q。集合S保留了我们已知的所有d[v]的值已�l�是最短�\径的值顶点，而集合Q则保留其他所有顶炏V��集合S初始状态�ؓ�I�，�? 后每一步都有一个顶点从Q�U�d��到S。这个被选择的顶�Ҏ��Q中拥有最��的d[u]值的��点。当一个顶点u从Q中�{�U�d��了S中，��法�Ҏ��条外接边(u,v)�q? 行拓展�?/p>

��法思想
设S为最短距��d��定的顶炚w��Q�看作红炚w��Q�，V-S是最短距��d��未确定的��点集（看作蓝点集）�?br> ①初始化
    　初始化时�Q�只有源点s的最短距��L��已知�?SD(s)=0)�Q�故�U�点集S={s}�Q�蓝炚w��为空�?br> ②重复以下工作，按�\径长度递增�ơ序产生各顶�Ҏ��短�\�?/strong>
    　在当前蓝炚w��中选择一个最短距��L��的蓝点来扩充红炚w��Q�以保证按�\径权重递增的次序来产生各顶点的最短�\径�?br>     　当蓝炚w��中仅剩下最短距��Mؓ∞的蓝点，或者所有蓝点已扩充到红炚w��Ӟ��s到所有顶点的最短�\径就求出来了�?br> 注意�Q?/font>
    　①若从源点到蓝点的�\径不存在�Q�则可假设该蓝点的最短�\径是一条长度�ؓ无穷大的虚拟路径�?br>     　②从源点s到终点v的最短�\径简�U�Cؓv的最短�\径；s到v的最短�\径长度简�U�Cؓv的最短距��，�q�记为SD(v)�?br> �Q?�Q�在蓝点集中选择一个最短距��L��的蓝点k来扩充红炚w��
    　�Ҏ��按长度递增序��生最短�\径的思想�Q�当前最短距��L��的蓝点k的最短�\径是�Q?br>     　源点�Q�红�?�Q�红�?�Q?#8230;�Q�红点n�Q�蓝点k
距离为：源点到红点n最短距��?<�U�点n,蓝点k>辚w��
    　为求解方便，讄��一个向量D[0�Q�．n-1]�Q�对于每个蓝点v∈ V-S�Q�用D[v]记录从源点s到达v且除v外中间不�l�过��M��蓝点(若有中间点，则必为红�?�?最�?路径长度�Q�简�U�C��计距��）�?br>     　若k是蓝炚w��中估计距��L��的��点�Q�则k的估计距��d��是最短距��，卌��D[k]=min{D[i] i∈V-S}�Q�则D[k]=SD(k)�?br>     　初始�Ӟ��每个蓝点v的D[c]值应为权w�Q�且从s到v的�\径上没有中间点，因�ؓ该�\径仅含一条边�?br> 注意�Q?/font>
    　在蓝炚w��中选择一个最短距��L��的蓝点k来扩充红炚w��是Dijkstra��法的关�?

�Q?�Q�k扩充�U�点集s后，蓝点集估计距��ȝ��修改
    　��k扩充到红点后�Q�剩余蓝炚w��的估计距��d��能由于增加了新红点k而减��，此时必须调整相应蓝点的估计距��R�?br>     对于��L��的蓝点j�Q�若k��p��变红后��D[j]变小�Q�则必定是由于存在一条从s到j且包含新�U�点k的更短�\径：P=。且D [j]减小的新路径P只可能是�׃��路径和边�l�成�?br>     　所以，当length(P)=D[k]+w��于D[j]�Ӟ��应该用P的长度来修改D[j]的倹{�?br>
�Q?�Q�Dijkstra��法

Dijkstra(G�Q�D�Q�s){
    //用Dijkstra��法求有向网G的源点s到各��点的最短�\径长�?br>     //以下是初始化操作
      S={s}�Q�D[s]=0�Q?//讄��初始的红炚w��及最短距��?br>     for( all i∈ V-S )do //对蓝炚w��中每个顶点i
          D[i]=G[s][i]�Q?//讄��i初始的估计距��Mؓw
       //以下是扩充红炚w��
      for(i=0;i            D[k]=min{D[i]�Q�all i V-S}�Q?//在当前蓝炚w��中选估计距��L��的��点k
           if(D[k]�{�于∞)
                return�Q?//蓝点集中所有蓝点的估计距离均�ؓ∞�Ӟ��
                     //表示�q�些��点的最短�\径不存在�?br>            S=S∪{k}�Q?//��蓝点k涂红后扩充到�U�点�?br>            for( all j∈V-S )do //调整剩余蓝点的估计距��?br>                if(D[j]>D[k]+G[k][j])
                //新红点k使原D[j]值变��时�Q�用新�\径的长度修改D[j]�Q?br>               //使j��s更近�?br>                    D[j]=D[k]+G[k][j]�Q?br>           }
   }

凭栏观�v 2007-07-03 16:28 发表评论

spring学习日志-事务��理

凭栏观�v — Tue, 03 Jul 2007 07:26:00 GMT

在service层控制事�?br>

Spring推荐事务的控制在service层实玎ͼ�而不是像单独使用hibernate那样�Q�在dao层实玎ͼ��q�样的好处在于更好地支持declear方式的事务（service层通常提供接口�Q�这样可以针�Ҏ��口来定义事务�{�略�Q�而不是针对具体的service实现�Q�因此可以很方便地替换service的实玎ͼ�而不需要修改事务的配置�Q�，更加灉|��。同�Ӟ��可以更加斚w��自然地实现全局事务的控制�?/span>

举例如下�Q?/p> service接口

package x.y.service;
public interface FooService {

    Foo getFoo(String fooName);

    Foo getFoo(String fooName, String barName);

    void insertFoo(Foo foo);

    void updateFoo(Foo foo);
}

一个service实现

package x.y.service;
public class DefaultFooService implements FooService {
    public Foo getFoo(String fooName) {
        throw new UnsupportedOperationException();
    }

    public Foo getFoo(String fooName, String barName) {
        throw new UnsupportedOperationException();
    }

    public void insertFoo(Foo foo) {
        throw new UnsupportedOperationException();
    }

    public void updateFoo(Foo foo) {
        throw new UnsupportedOperationException();
    }
}

spring.xml�Q�注意在声明事务的时候，是针对service接口的，而不是针对service实现�?br>

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">


    <bean id="fooService" class="x.y.service.DefaultFooService" />


    <tx:advice id="txAdvice" transaction-manager="txManager">

        <tx:attributes>

            <tx:method name="get*" read-only="true" />


            <tx:method name="*" />
        tx:attributes>
    tx:advice>


    <aop:config>
        <aop:pointcut id="fooServiceOperation"
            expression="execution(* x.y.service.FooService.*(..))" />
        <aop:advisor advice-ref="txAdvice"
            pointcut-ref="fooServiceOperation" />
    aop:config>


    <bean id="dataSource"
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="org.h2.Driver" />
        <property name="url"
            value="jdbc:h2:tcp://localhost/D:/try/data/sample;IFEXISTS=TRUE" />
        <property name="username" value="sa" />
        <property name="password" value="123456" />
    bean>


    <bean id="txManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    bean>

beans>

使用service层方便了使用全局事务

对于横跨多个Hibernate SessionFacotry的分布式事务�Q�只需��单地��?/span> JtaTransactionManager 同多�?/span> LocalSessionFactoryBean 的定义结合�v来作��Z��务策略。你的每一�?/span>DAO通过bean属性得到各自的 SessionFactory 引用。在需要进行跨多个数据库的事务操作�Ӟ��只需要定义一�?/span>service层，使用 JtaTransactionManager 作�ؓ事务�{�略�Q�横跨多�?/span>DAO和多�?/span>session factories来划分事务，而不需要特�D�的处理�?/span>
�C�Z��的配�|�文件如下：

<beans>
  <bean id="mySessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="myDataSource1"/>
   ..
  bean>
  <bean id="mySessionFactory2" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="myDataSource2"/>
…
  bean>
  <bean id="myTxManager" class="org.springframework.transaction.jta.JtaTransactionManager"/>
  <bean id="myProductDao" class="product.ProductDaoImpl">
    <property name="sessionFactory" ref="mySessionFactory1"/>
  bean>
  <bean id="myInventoryDao" class="product.InventoryDaoImpl">
    <property name="sessionFactory" ref="mySessionFactory2"/>
  bean>

<aop:config>
    <aop:pointcut id="productServiceMethods" expression="execution(* product.ProductService.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods"/>
aop:config>

  <tx:advice id="txAdvice" transaction-manager="myTxManager">
    <tx:attributes>
      <tx:method name="increasePrice*" propagation="REQUIRED"/>
      <tx:method name="someOtherBusinessMethod" propagation="REQUIRES_NEW"/>
      <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
    tx:attributes>
  tx:advice>

    <bean class="product.ProductServiceImpl">
       <property name="productDao" ref="myProductDao"/>
       <property name="inventoryDao" ref="myInventoryDao"/>
    bean>
    beans>

凭栏观�v 2007-07-03 15:26 发表评论

Jbpm学习log

凭栏观�v — Mon, 02 Jul 2007 03:43:00 GMT

Introduction

    jPDL是一�U�直观的��程语言�Q�用以展现商业逻辑的处理过�E�。jPDL包含的概忉|��及�Q务、异步通讯状态、定时器、自动执行的动作�{�，为此�Q��ؓ了整合上�q�行为，jPDL提供了强大、可扩展的控制流机制�?/p>
graph based execution languages

implementation technique for graph based execution languages�Q?/p>

based on runtime interpretation of a graph.

based on message queues

code generation.

The strategy on how graph execution can be implemented on top of an OO programming language. For those who are familiar with design patterns, it's a combination of the command pattern and the chain of responsibility pattern.

1、Transitions 可以理解��入和��d��节点的箭��_��应该存在多个Transitions �q�入一个节点和一个节�Ҏ��多个��d��?strong>Transitions 的情�?/p>
the structure of the graph is represented with the classes Node and Transition�Q��?tt>Transition是具有方向性的

transitions are able to pass the execution from a source node to a destination node with the method take.

2、execution �Q�类似petri中的标记�Q�是变迁��q�A的前�?/strong>

An execution (also known as a token) is represented with a class called Execution. An execution has a reference to the current node.

3、Node

A node is a command and has an execute method. Subclasses of Node are supposed to override the execute method to implement some specific behaviour for that node type.

When an execution arrives in a node, that node is executed. The Node's execute method is also responsible for propagating the execution. Propagating the execution means that a node can pass the execution that arrived in the node over one of its leaving transitions to the next node.

When a node's execute method does not propagate the execution, it behaves as a wait state.

Also when a new execution is created, it is initialized in some start node and then waits for an event.

An event is given to an execution and it can trigger the execution to start moving. If the event given to an execution relates to a leaving transition of the current node, the execution takes that transition. The execution then will continue to propagate until it enters another node that behaves as a wait state.

So now we can already see that the two main features are supported : wait states and a graphical representation. During wait states, an Execution just points to a node in the graph

4、Actions

An Action is a command with an execute method. Actions can be associated with events.

Synchronous execution

The default propagation of execution is synchronous.

凭栏观�v 2007-07-02 11:43 发表评论

JGAP - Genetic Algorithms and Genetic Programming

凭栏观�v — Wed, 27 Jun 2007 05:34:00 GMT

http://jgap.sourceforge.net/

WHAT IS JGAP?

JGAP (pronounced "jay-gap") is a Genetic Algorithms and Genetic Programming component provided as a Java framework. It provides basic genetic mechanisms that can be easily used to apply evolutionary principles to problem solutions. See the examples for a demonstration or watch out the graphical tree that can be created with JGAP for found solutions of genetically evolved programs.
JGAP was designed to be very easy to use "out of the box", while also designed to be highly modular so that more adventurous users can easily plug-in custom genetic operators and other sub-components.

Documentation, quality and stability of code are the top concerns when developing JGAP. You find really many unit tests packaged with JGAP, extensive Javadocs, and quite a lot of examples. Compare JGAP with other projects! Feedback is always welcome.

凭栏观�v 2007-06-27 13:34 发表评论

凭栏观�v — Wed, 27 Jun 2007 03:20:00 GMT

http://www.h2database.com/html/frame.html

最�q�一个桌面的�E�序需要��用嵌入式数据库，选择了很多不同的嵌入式数�?最�l�选择了H2�Q�性能是一个很重要的原因，下图是h2提供的Performance的比较图

http://www.h2database.com/html/images/performance.png

h2是Thomas Mueller提供的一个开源的、纯java实现的关�p�L��据库�Q�在google上面有讨论组h2-database@googlegroups.com�Q�Thomas Mueller也非常热情，回答问题非常及时�?/p>

下面说下我最�l�选择h2的原因：

�Q?�Q�性能、小�?/p>
�Q?�Q�同时支持网�l�版和嵌入式版本�Q�另外还提供了内存版

�Q?�Q�有比较好的兼容性，支持相当标准的sql标准�Q�实际上也不存在一个数据库能够100%�W�合标准�Q?/p>
�Q?�Q�提供了非常友好的基于web的数据库��理界面

�Q?�Q�支持hibernate

补充�Q?br>支持的事务隔��ȝ�别：

Transaction Isolation

This database supports the following transaction isolation levels:

Serializable
This is the default level.
To enable, execute the SQL statement 'SET LOCK_MODE 0'
or append ;LOCK_MODE=1 to the database URL: jdbc:h2:~/test;LOCK_MODE=1

Read Committed
Read locks are released immediately. Higher concurrency is possible when using this level.
This is the isolation level used for many database systems.
To enable, execute the SQL statement 'SET LOCK_MODE 0'
or append ;LOCK_MODE=3 to the database URL: jdbc:h2:~/test;LOCK_MODE=3

Read Uncommitted
This level means that transaction isolation is disabled.
To enable, execute the SQL statement 'SET LOCK_MODE 0'
or append ;LOCK_MODE=0 to the database URL: jdbc:h2:~/test;LOCK_MODE=0

When using the isolation level 'serializable', dirty reads, non-repeatable reads, and phantom reads are prohibited.

Dirty Reads
Means a connection can read uncommitted changes made by another connection.
Possible with: read uncommitted

Non-Repeatable Reads
A connection reads a row, another connection changes a row and commits, and the first connection re-reads the same row and gets the new result.
Possible with: read uncommitted, read committed

Phantom Reads
A connection reads a set of rows using a condition, another connection inserts a row that falls in this condition and commits, then the first connection re-reads using the same condition and gets the new row.
Possible with: read uncommitted, read committed

Table Level Locking
The database allows multiple concurrent connections to the same database. To make sure all connections only see consistent data, table level locking is used. This mechanism does not allow high concurrency, but is very fast. Shared locks and exclusive locks are supported. Before reading from a table, the database tries to add a shared lock to the table (this is only possible if there is no exclusive lock on the object by another connection). If the shared lock is added successfully, the table can be read. It is allowed that other connections also have a shared lock on the same object. If a connection wants to write to a table (update or delete a row), an exclusive lock is required. To get the exclusive lock, other connection must not have any locks on the object. After the connection commits, all locks are released. This database keeps all locks in memory.

凭栏观�v 2007-06-27 11:20 发表评论

java异常处理的一�Ҏ�ȝ��Q�原创）

凭栏观�v — Mon, 25 Jun 2007 08:11:00 GMT

java提供了很好的异常处理机制�Q�但是如何用好异常�ƈ不容易，需要根据开发对象的不同采用的异常机�Ӟ��本文主要在eclipse rcp开发的时候�ȝ��的一个异常的处理机制�Q�个��为适合于图形界面开发，�ȝ��h��Q�归�U�_��下：

�Q?�Q�合理��用checked exception和unchecked exception�Q�说明��用这两种异常的原则的文章很多�Q�不多罗嗦了

�Q?�Q�异常的转换�Q�如果需要，可以��底层的异常包装为包含更多含义的自定义异帔R��新抛出（包括checked�?/span>unchecked的自定义异常体系�Q�，自定义异�怸�仅仅需要包含原始的异常信息�Q�还要包含一些特定的含义和处理方法；

(3) 异常的抛出，��量不要在中间层处理异常�Q�要么在异常发生的地方处理，要么抛出�Q�推�q�到由最�l�调用层来处理，比如�?span style="font-size: 10pt;">与用��L��接打交道�?span lang="EN-US">UI�?/span>�Q�捕捉异常，�q�以错误信息框、对话框�{�信息蝲体反馈良好的信息�l�用�?/span>

�q�也只是我个人的一些观点，希望大家能给出更好的方式

范例�Q?span lang="EN-US">

�Q?span lang="EN-US">1�Q�定义自定义的异常：包括了两个构造函敎ͼ�一个用于提供默认的异常信息�Q�一个供�E�序员添加更加详�l�的异常信息�Q�这个异常，可以用来��装所有的底层异常�Q�但是一般在逻辑上更加清楚，可以增加不同的自定义异常�Q�比如数据库处理异常、文件处理异常、网�l�处理异常等

public class DataException extends RuntimeException {

    public DataException(String str, Throwable cause) {

       super(str, cause);

    }

    public DataException(Throwable e) {

       super("数据操作出错错误", e);

    }

}

�Q?/span>2�Q��用自定义的异常封装底层异常：

public static boolean exportToExcel(String desLocation,String templateName, List list, String beanName) hrows DataException {

boolean ok = false;

Map beans = new HashMap();

beans.put(beanName, list);

XLSTransformer transformer = new XLSTransformer();

try {

      transformer.transformXLS(templateName, beans, desLocation);

      ok = true;

     } catch (ParsePropertyException e) {

       throw new DataException("导出excel出错�Q�解析excel文�g出错",e);

     } catch (IOException e) {

       throw new DataException("导出excel出错�Q�文件操作出�?/span>",e);

    }

return ok;

}

�Q?span lang="EN-US">3�Q�在用户界面部分的处理，通过MessageDialog反馈�l�用��h��的信息�Q?/span>

try {

String templateName = BundlePathUtil.getRealPath(Activator.PLUGIN_ID, "excelTplts\\");

    templateName = templateName + "aaa.xls";

    // 从tableviewer中获取数�?/span>

    List list = (List) personTableViewer.getInput();

    ExcelUtil.exportToExcel(desLocation, templateName, list,"aaa");

} catch (DataException e) {

// �q�里我用了e.getMessage(),但是再更实际的环境中�Q�应该给最�l�用��L��到的是一个友好的、高层的出错信息�Q�详�l�的出错信息// 应该在日志文件中体现

      MessageDialog.openError(window.getShell(), "导出��p�|", "��p�|原因�Q?/span>"+ e.getMessage());

    // 退�?/span>

return;

    }

    // 增加导出完成的提�C�，比如信息�?/span>

MessageDialog.openInformation(window.getShell(), "导出成功", "查询�l�果已导入到"+ desLocation);

�ȝ��
�Ҏ��java异常使用最佛_��践，使用unchecked exception的效率最高，��管unchecked exception不会��用户捕捉和处理异常，调用层的�E�序员也可以凭着个�h责�Q心来�q�行异常的捕获和处理�Q�但是如果你不捕捉处理异常，随之而来的是�E�序的健壮性就得不��C��证�?/span>

参考资�?br>Best Practices for Exception Handling
http://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html

凭栏观�v 2007-06-25 16:11 发表评论

凭栏观�v — Mon, 25 Jun 2007 07:52:00 GMT
数据�?span style="font-size: 10pt; font-family: 宋体;" lang="EN-US">t的ddl�Q?br>create table t(class char(1),callcount int,calldate date)

sql语句:
select calldate,

sum(case class when '1' then callcount else 0 end) as A�c?span lang="EN-US">,

sum(case class when '2' then callcount else 0 end) as B�c?span lang="EN-US">,

sum(case class when '3' then callcount else 0 end) as C�c?
from t group by calldate

最后结果：

凭栏观�v 2007-06-25 15:52 发表评论

凭栏观�v — Mon, 25 Jun 2007 07:18:00 GMT
     摘要: Jpos体系�l�构一�?nbsp; ISOComponet �q�里ISOField和ISOBitMap都是实现了ISOComponent的叶子节点，ISOMsg则是包含了ISOField的Composite �Q�组合类�Q�：ISOMsg�cȝ��护了Hashtable fields�Q�维护了该报文的所有的位元�? 参考：composite模式 ...  阅读全文

凭栏观�v 2007-06-25 15:18 发表评论

�c�d��名称	�c�d��定义	�c�d��取�?/strong>
boolean	布尔�?/td>	true, false
byte	8�?strong>有符��h��?/strong>	最��?128�Q�最大�?27
short	16�?strong>有符��h��?/strong>	最��?32768�Q?2¹⁵�Q�，最大�?2767�Q?¹⁵-1�Q?/p>
int	32�?strong>有符��h��?/strong>	最��?2147483648�Q?2³¹�Q�，最大�?147483647�Q?³¹-1�Q?/td>
long	64�?strong>有符��h��?/strong>	-2⁶³~(2⁶³-1)
float	32位��Q�Ҏ��	1.4E-45~3.4028235E38
double	64位��Q�Ҏ��	4.9E-324~1.7976931348623157E308
char	16位Unicode字符

Client's reaction when exception happens	Exception type
Client code cannot do anything	Make it an unchecked exception
Client code will take some useful recovery action based on information in exception	Make it a checked exception

国产高清久久,中文成人激情娱乐网,国产在线观看一区二区三区

关于Java String的intern and ==的笔试题�Q�没有全�{�对

设计及设计模式：关于Java权限控制���法(转）

java基础�Q�byte与int

byte�c�d��的��用场合：

判断resultset是否含有记录

java语言中的bit �U�M��操作

java 位操作符�Q?/strong>

例子�Q?/strong>

二、主要的代码

正则表达式的�ȝ��

一、JDK提供的正则表辑ּ�

Matcher�cȝ��几个重要的方法：

二�?大��用方法：

查询

提取

分割

替换或者删�?/strong>

三、一个实际的例子

用HttpClient来模拟浏览器GET POST(收藏)

用HttpClient来模拟浏览器GET POST

作�?jaddy0302 日期:2006-12-21

java IO�?学习记录

一、底层的�q�是装饰�?/b>

二、面向字�W�还是面向字�?/b>

三、从InputStream/OutPutStream到Reader/Writer的�{�?/b>

四、示�?/b>

牛刀���试-用jdom来解析ant的build文�g

Jdom 常用API

一、创建XML文�g

二、解析XML文�g

三、输出XML

The JDOM Philosophy

The JDOM Philosophy

JDOM consists of five packages

The org.jdom.input Package

The org.jdom.output Package

org.jdom.transform

General Program Flow

一家之�a�--Java异常处理

一�?/span>Unchecked exceptions VS Checked exceptions

二�?/span>Java异常的推�q�处�?/span>

三、异常的处理

参考文�?/span>

���法描述

���法思想

spring学习日志-事务���理

在service层控制事�?br>

使用service层方便了使用全局事务

Jbpm学习log

Introduction

graph based execution languages

Synchronous execution

JGAP - Genetic Algorithms and Genetic Programming

WHAT IS JGAP?

Transaction Isolation

Table Level Locking

java异常处理的一�Ҏ�ȝ���Q�原创）

设计及设计模式：关于Java权限控制��法(转）

牛刀��试-用jdom来解析ant的build文�g

��法描述

��法思想

spring学习日志-事务��理

java异常处理的一�Ҏ�ȝ��Q�原创）