BlogJava-闲人野居-随笔分类-jdk相关

用泛型时遇到的尴尬问题

布衣郎 — Tue, 17 Apr 2007 00:22:00 GMT

几天前遇到这么一个问题，让我郁闷了半天。当初为了方便定义了以下的一个接口：

public interface IBusinessObject<PK extends Serializable> extends Serializable {
PK getPrimaryKey();
void setPrimaryKey(PK id);
}

在我的子类中是这么实现的

public class Code implements IBusinessObject<Long>{
private Long primaryKey;
public void setPrimaryKey(Long id){
this.primaryKey=id;
}
public Long getPrimaryKey(){
return primaryKey
}
}

在通常的实例化过程中，是不会存在问题的。当时的问题是，我定义了另外一个类，用于引用Code

public class TestBean {
    private Code code;
    public void setCode(){}
    public Code getCode(){}
}

当在spring环境中时，使用spring的bind类处理的时候，发现，我的code.primaryKey的类型居然为Serializable,而不是我想要的Long
当时以为其他地方搞错了，写了个简单的测试代码

TestBean b=new TextBean();
BeanWrapperImpl wrapper=new BeanWrapperImpl(b);
b.setPropertyValue("code.primaryKey","1");
assertTrue(b.getCode().getPrimaryKey() instanceof Long);

居然是失败的。
只有在

b.setPropertyValue("code.primaryKey",new Long(1));
assertTrue(b.getCode().getPrimaryKey() instanceof Long);

才成功。
仔细跟踪，发现原来，泛型的时候，产生的编译类中，有两个同名的方法

public void setPrimaryKey(Long id){
    this.primaryKey=id;
}
public Long getPrimaryKey(){
    return primaryKey
}
和
public void setPrimaryKey(Serializable id){
    this.primaryKey=id;
}
public Serializable getPrimaryKey(){
    return primaryKey
}

而java.beans规范对于这种情况是没有办法分清楚，所以也就导致了结果和预期的不同。
如果是在程序中，这点算不了问题。可是我需要在web的页面上进行值的绑定，而输入的东西，只能为字符串。所以不可能出来Long类型。
目前，采用了一种比较傻的办法，在TestBean中增加了一个临时变量x，通过x向code传值
如下：

public void setWsCode(String wsCode) {
        this.wsCode = wsCode;
        if (StringUtils.isNumeric(wsCode))
            this.code.setPrimaryKey(NumberUtils.toLong(wsCode));
}

不知道还有没有其他好的解决方案。

布衣郎 2007-04-17 08:22 发表评论

关于ehcache 配置

布衣郎 — Thu, 05 Apr 2007 10:42:00 GMT

欠了很久的文章，本来都不想发了，可还是发吧

ehcache的默认配置文件名为ehcache.xml，也可以自己指定。配置文件比较的简单，基本上也就是常用的几个元素。

配置元素说明：

diskStore：配置DiskStore，当需要使用磁盘保存的时候，需要对象实现序列化接口

    属性：path 配置文件存储位置，如user.home，user.dir，java.io.tmpdir

cacheManagerEventListenerFactory ：指定CacheManagerEventListenerFactory，用于创建CacheManagerPeerProvider

用于提醒当CacheManager中的缓存增加或者删除时。

    属性:class:完整的工厂类名称
         properties:逗号分割的属性

事件包括增加cache和删除cache

cacheManagerPeerProviderFactory:指定CacheManagerPeerProviderFactory，用于创建CacheManagerPeerProvider，用于在cluster中查找CacheManagers，主要用于机群环境

    属性：
        class:完整的工厂类名称
        properties:逗号分割的属性

默认的配置：

                                class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
                                properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1,
                                    multicastGroupPort=4446, timeToLive=32"/>

                          "net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
                          properties="peerDiscovery=manual,
                          rmiUrls=//server1:40000/sampleCache1|//server2:40000/sampleCache1
                          | //server1:40000/sampleCache2|//server2:40000/sampleCache2"/>

cacheManagerPeerListenerFactory：指定CacheManagerPeerListenerFactory，用于创建CacheManagerPeerListener，监听cluster中的复制信息
    属性：
        class:完整的工厂类名称
        properties:逗号分割的属性

默认配置

            class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
        properties="hostName=fully_qualified_hostname_or_ip,
                    port=40001,
                    socketTimeoutMillis=120000"/>

defaultCache: 默认缓存配置

    必须属性：
        name:设置缓存的名称，用于标志缓存,惟一
        maxElementsInMemory:在内存中最大的对象数量
        maxElementsOnDisk：在DiskStore中的最大对象数量，如为0，则没有限制
        eternal：设置元素是否永久的，如果为永久，则timeout忽略
        overflowToDisk：是否当memory中的数量达到限制后，保存到Disk

    可选的属性：
        timeToIdleSeconds：设置元素过期前的空闲时间
        timeToLiveSeconds：设置元素过期前的活动时间
        diskPersistent：是否disk store在虚拟机启动时持久化。默认为false
        diskExpiryThreadIntervalSeconds:运行disk终结线程的时间，默认为120秒
        memoryStoreEvictionPolicy：策略关于Eviction

缓存子元素：

    cacheEventListenerFactory：注册相应的的缓存监听类，用于处理缓存事件，如put,remove,update,和expire
    bootstrapCacheLoaderFactory:指定相应的BootstrapCacheLoader，用于在初始化缓存，以及自动设置。
如下的例子：

          properties="replicateAsynchronously=true,
         replicatePuts=true,
         replicateUpdates=true,
         replicateUpdatesViaCopy=true,
         replicateRemovals=true "/>

        class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"
        properties="bootstrapAsynchronously=true, maximumChunkSizeBytes=5000000"/>

             maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
            maxElementsOnDisk="10000000"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU"
            />

cache配置同defaultCache

           maxElementsInMemory="10"
           eternal="false"
           timeToIdleSeconds="100"
           timeToLiveSeconds="100"
           overflowToDisk="false">
                        class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
                        class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"/>


基本上都比较简单，当然也可以直接使用程序实现相应的功能

布衣郎 2007-04-05 18:42 发表评论

使用ehcache

布衣郎 — Wed, 28 Feb 2007 12:14:00 GMT

    一直以来懒得配置缓存，基本的缓存也就是orm层，基本上都交给hibernate去配置了。这段时间，感觉页面速度太慢了，还是需要使用缓存。现在的缓存工具也挺多的，较不错的属ehcache和oscache了。决定分别研究一下。
    先来说说ehcache，目前的版本为1.2,已经支持集群了。对于ehcache的使用，感觉很容易上手，基本上都是配置。以前在hibernate的时候配置过，所以也不是很陌生。API也挺简单，如下的api：
    CacheManager主要的缓存管理类，一般一个应用为一个实例，如下
    CacheManager.create();也可以使用new CacheManager的方式创建
     默认的配置文件为ehcache.xml文件，也可以使用不同的配置：


CacheManager manager = new CacheManager("src/config/other.xml");

缓存的创建，采用自动的方式

CacheManager singletonManager = CacheManager.create();
singletonManager.addCache("testCache");
Cache test = singletonManager.getCache("testCache");

或者直接创建Cache

CacheManager singletonManager = CacheManager.create();
Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);
manager.addCache(memoryOnlyCache);
Cache test = singletonManager.getCache("testCache");

删除cache

CacheManager singletonManager = CacheManager.create();
singletonManager.removeCache("sampleCache1");

在使用ehcache后，需要关闭

CacheManager.getInstance().shutdown()

caches 的使用

Cache cache = manager.getCache("sampleCache1");

执行crud操作

Cache cache = manager.getCache("sampleCache1");
Element element = new Element("key1", "value1");
cache.put(element);

update

Cache cache = manager.getCache("sampleCache1");
cache.put(new Element("key1", "value1");
//This updates the entry for "key1"
cache.put(new Element("key1", "value2");

get Serializable

Cache cache = manager.getCache("sampleCache1");
Element element = cache.get("key1");
Serializable value = element.getValue();

get non serializable

Cache cache = manager.getCache("sampleCache1");
Element element = cache.get("key1");
Object value = element.getObjectValue();

remove

Cache cache = manager.getCache("sampleCache1");
Element element = new Element("key1", "value1"
cache.remove("key1");

不过缓存还是基本上以配置方式为主，下一篇文章将会说明ehcache如何配置

布衣郎 2007-02-28 20:14 发表评论

使用javassist动态注入代码

布衣郎 — Sat, 10 Feb 2007 13:02:00 GMT

    关于java字节码的处理，目前有很多工具，如bcel，asm。不过这些都需要直接跟虚拟机指令打交道。如果你不想了解虚拟机指令，可以采用javassist。javassist是jboss的一个子项目，其主要的优点，在于简单，而且快速。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。
    下面通过一个简单的例子，通过javassist来实现如何动态注入代码。
    假设，存在类A,如下：
public class A {
    public void method() {
        for (int i = 0; i < 1000000; i++) {
        }
        System.out.println("method1");
    }
}
测试类B如下：
public class B {
    public static void main(String[] args) {
        A a = new A();
        a.method();
    }
}
现在想统计一下method的执行时间，
默认的实现是修改method：
public void method() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
        }
        System.out.println("method1");
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
如果A的方法很多，统计方法的执行时间的代码就会相应的增加。为了减少工作量，通过动态注入代码的形式来实现。
修改B的main方法：
    public static void main(String[] args) throws Exception {
      //用于取得字节码类，必须在当前的classpath中，使用全称
        CtClass ctClass = ClassPool.getDefault().get("org.esoft.A");
         //需要修改的方法名称
        String mname = "method";
        CtMethod mold = ctClass.getDeclaredMethod(mname);
         //修改原有的方法名称
        String nname = mname + "$impl";
        mold.setName(nname);
         //创建新的方法，复制原来的方法
        CtMethod mnew = CtNewMethod.copy(mold, mname, ctClass, null);
         //主要的注入代码
        StringBuffer body = new StringBuffer();
        body.append("{\nlong start = System.currentTimeMillis();\n");
        //调用原有代码，类似于method();($$)表示所有的参数
        body.append(nname + "($$);\n");
        body.append("System.out.println(\"Call to method "
                    + mname
                    + " took \" +\n (System.currentTimeMillis()-start) + "
                    + "\" ms.\");\n");

        body.append("}");
         //替换新方法
        mnew.setBody(body.toString());
         //增加新方法
        ctClass.addMethod(mnew);
        //类已经更改，注意不能使用A a=new A();，因为在同一个classloader中，不允许装载同一个类两次
        A a=(A)ctClass.toClass().newInstance();
        a.method();
    }
这只是简单的一个应用。javassist还提供了很多的功能，用于更改类结构。有兴趣的可以参考相关文档

布衣郎 2007-02-10 21:02 发表评论

基本的类装入异常

布衣郎 — Sun, 04 Feb 2007 12:58:00 GMT

    在java中，类装载异常虽然不是很常见，可如果发生异常，其处理还是比较麻烦的。
    下面的几种异常是比较常见的：
ClassNotFoundException
    ClassNotFoundException 是最常见的类装入异常类型。它发生在装入阶段。Java 规范对 ClassNotFoundException 的描述是这样的：
    当应用程序试图通过类的字符串名称，使用以下三种方法装入类，但却找不到指定名称的类定义时抛出该异常。
    * 类 Class 中的 forName() 方法。
    * 类 ClassLoader 中的 findSystemClass() 方法。
    * 类 ClassLoader 中的 loadClass() 方法。
    所以，如果显式地装入类的尝试失败，那么就抛出 ClassNotFoundException。
    这些异常修复起来通常比较简单。可以用 verbose 选项检查类路径，确保使用的类路径设置正确。如果类路径设置正确，但是仍然看到这个错误，那么就是需要的类在类路径中不存在。要修复这个问题，可以把类移动到类路径中指定的目录或 JAR 文件中，或者把类所在的位置添加到类路径中。

NoClassDefFoundError
    NoClassDefFoundError 是类装入器在装入阶段抛出的另一个常见异常。JVM 规范对 NoClassDefFoundError 的定义如下：
    如果 Java 虚拟机或 ClassLoader 实例试图装入类定义（作为正常的方法调用的一部分，或者作为使用 new 表达式创建新实例的一部分），但却没有找到类定义时抛出该异常。
    当目前执行的类已经编译，但是找不到它的定义时，会存在 searched-for 类定义。
    实际上，这意味着 NoClassDefFoundError 的抛出，是不成功的隐式类装入的结果。
    简单说来，就是引用的类在类路径中没有找到。
ClassCastException
    类装入器能够抛出的另一个异常是 ClassCastException。它是在类型比较中发现不兼容类型的时候抛出的。JVM 规范指定 ClassCastException 是：
    该异常的抛出，表明代码企图把对象的类型转换成一个子类，而该对象并不是这个子类的实例。
UnsatisfiedLinkError
    在把本地方法调用链接到对应的本机定义时，类装入器扮演着重要角色。如果程序试图装入一个不存在或者放错的本机库时，在链接阶段的解析过程会发生 UnsatisfiedLinkError。JVM 规范指定 UnsatisfiedLinkError 是：
    对于声明为 native 的方法，如果 Java 虚拟机找不到和它对应的本机语言定义，就会抛出该异常。
    当调用本机方法时，类装入器会尝试装入定义了该方法的本机库。如果找不到这个库，就会抛出这个错误。
    本机库的装入由调用 System.loadLibrary() 方法的类的类装入器启动，根据使用的类装入器，会搜索不同的位置：
    * 对于由 bootstrap 类装入器装入的类，搜索 sun.boot.library.path。
    * 对于由扩展类装入器装入的类，先搜索 java.ext.dirs，然后是 sun.boot.library.path，然后是 java.library.path。
    * 对于由系统类装入器装入的类，搜索 sun.boot.library.path，然后是 java.library.path。
ClassCircularityError
    JVM 规范指定 ClassCircularityError 的抛出条件是：
    类或接口由于是自己的超类或超接口而不能被装入。
    这个错误是在链接阶段的解析过程中抛出的。这个错误有点奇怪，因为 Java 编译器不允许发生这种循环情况。但是，如果独立地编译类，然后再把它们放在一起，就可能发生这个错误。
ClassFormatError
JVM 规范指出，抛出 ClassFormatError 的条件是：
    负责指定所请求的编译类或接口的二进制数据形式有误。
    这个异常是在类装入的链接阶段的校验过程中抛出。如果字节码发生了更改，例如主版本号或次版本号发生了更改，那么二进制数据的形式就会有误。例如，如果对字节码故意做了更改，或者在通过网络传送类文件时现出了错误，那么就可能发生这个异常。
    修复这个问题的惟一方法就是获得字节码的正确副本，可能需要重新进行编译。
ExceptionInInitializerError
根据 JVM 规范，抛出 ExceptionInInitializer 的情况是：
    * 如果初始化器突然完成，抛出一些异常 E，而且 E 的类不是 Error 或者它的某个子类，那么就会创建 ExceptionInInitializerError 类的一个新实例，并用 E 作为参数，用这个实例代替 E。
    * 如果 Java 虚拟机试图创建类 ExceptionInInitializerError 的新实例，但是因为出现 Out-Of-Memory-Error 而无法创建新实例，那么就抛出 OutOfMemoryError 对象作为代替。

布衣郎 2007-02-04 20:58 发表评论