亚洲理论电影在线观看,亚洲一区二区久久,亚洲精彩视频在线观看

paulwong — Wed, 25 Feb 2015 08:34:00 GMT

ConcurrentMapCacheManager可以作�ؓ一�U�缓存方案，但不能设�|�过期，最大缓存条目等�Q�需�q�行攚w��?br />

pom.xml中加入依赖包

  <dependency>
            <groupId>com.google.guavagroupId>
            <artifactId>guavaartifactId>
            <version>18.0version>
        dependency>
攚w��CacheManager�Q�MyConcurrentMapCacheManager

package com.paul.common.cache;
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;

import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCache;

import com.google.common.cache.CacheBuilder;

/**
* {@link CacheManager} implementation that lazily builds {@link ConcurrentMapCache}
* instances for each {@link #getCache} request. Also supports a 'static' mode where
* the set of cache names is pre-defined through {@link #setCacheNames}, with no
* dynamic creation of further cache regions at runtime.
*
*
Note: This is by no means a sophisticated CacheManager; it comes with no
* cache configuration options. However, it may be useful for testing or simple
* caching scenarios. For advanced local caching needs, consider
* {@link org.springframework.cache.guava.GuavaCacheManager} or
* {@link org.springframework.cache.ehcache.EhCacheCacheManager}.
*
* @author Juergen Hoeller
* @since 3.1
* @see ConcurrentMapCache
*/
public class MyConcurrentMapCacheManager implements CacheManager {

    private final ConcurrentMap cacheMap = new ConcurrentHashMap(16);

    private boolean dynamic = true;

    private boolean allowNullValues = true;

    private long expireTime = 30;

    private long maximumSize = 100;

    /**
     * Construct a dynamic ConcurrentMapCacheManager,
     * lazily creating cache instances as they are being requested.
     */
    public MyConcurrentMapCacheManager() {
    }

    /**
     * Construct a static ConcurrentMapCacheManager,
     * managing caches for the specified cache names only.
     */
    public MyConcurrentMapCacheManager(long expireTime, long maximumSize) {
        if(expireTime > 0)
            this.expireTime = expireTime;
        if(maximumSize > 0)
            this.maximumSize = maximumSize;
    }

    /**
     * Specify the set of cache names for this CacheManager's 'static' mode.
     *
The number of caches and their names will be fixed after a call to this method,
     * with no creation of further cache regions at runtime.
     *
Calling this with a {@code null} collection argument resets the
     * mode to 'dynamic', allowing for further creation of caches again.
     */
    public void setCacheNames(Collection cacheNames) {
        if (cacheNames != null) {
            for (String name : cacheNames) {
                this.cacheMap.put(name, createConcurrentMapCache(name));
            }
            this.dynamic = false;
        }
        else {
            this.dynamic = true;
        }
    }

    /**
     * Specify whether to accept and convert {@code null} values for all caches
     * in this cache manager.
     *
Default is "true", despite ConcurrentHashMap itself not supporting {@code null}
     * values. An internal holder object will be used to store user-level {@code null}s.
     *
Note: A change of the null-value setting will reset all existing caches,
     * if any, to reconfigure them with the new null-value requirement.
     */
    public void setAllowNullValues(boolean allowNullValues) {
        if (allowNullValues != this.allowNullValues) {
            this.allowNullValues = allowNullValues;
            // Need to recreate all Cache instances with the new null-value configuration
            for (Map.Entry entry : this.cacheMap.entrySet()) {
                entry.setValue(createConcurrentMapCache(entry.getKey()));
            }
        }
    }

    /**
     * Return whether this cache manager accepts and converts {@code null} values
     * for all of its caches.
     */
    public boolean isAllowNullValues() {
        return this.allowNullValues;
    }

    @Override
    public Collection getCacheNames() {
        return Collections.unmodifiableSet(this.cacheMap.keySet());
    }

    @Override
    public Cache getCache(String name) {
        Cache cache = this.cacheMap.get(name);
        if (cache == null && this.dynamic) {
            synchronized (this.cacheMap) {
                cache = this.cacheMap.get(name);
                if (cache == null) {
                    cache = createConcurrentMapCache(name);
                    this.cacheMap.put(name, cache);
                }
            }
        }
        return cache;
    }

    /**
     * Create a new ConcurrentMapCache instance for the specified cache name.
     * @param name the name of the cache
     * @return the ConcurrentMapCache (or a decorator thereof)
     */
    protected Cache createConcurrentMapCache(String name) {
//return new ConcurrentMapCache(name, isAllowNullValues());
//此处改用GOOGLE GUAVA的构造MANAGER方式
        return new ConcurrentMapCache(name,
                                        CacheBuilder.newBuilder()
                                                    .expireAfterWrite(this.expireTime, TimeUnit.MINUTES)
                                                    .maximumSize(this.maximumSize)
                                                    .build()
                                                    .asMap(),
                                        isAllowNullValues());
    }

}
配置想着bean, cache-concurrentmap-applicationcontext.xml
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:context="http://www.springframework.org/schema/context"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:c="http://www.springframework.org/schema/c"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/cache
          http://www.springframework.org/schema/cache/spring-cache.xsd
          http://www.springframework.org/schema/jee
          http://www.springframework.org/schema/jee/spring-jee.xsd
          http://www.springframework.org/schema/util
          http://www.springframework.org/schema/util/spring-util.xsd">

    <cache:annotation-driven />



    <bean id="cacheManager"
        class="com.paul.common.cache.MyConcurrentMapCacheManager">
        <constructor-arg index="0" value="1" />
        <constructor-arg index="1" value="5000" />
    bean>

beans>
通过注释�q�行使用

/*
* JBoss, Home of Professional Open Source
* Copyright 2014, Red Hat, Inc. and/or its affiliates, and individual
* contributors by the @authors tag. See the copyright.txt in the
* distribution for a full listing of individual contributors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.paul.springmvc.data;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.paul.springmvc.model.Member;

@Repository
@Transactional
public class MemberDaoImpl implements MemberDao {
    @Autowired
    private EntityManager em;

    @Cacheable(value = "my-local-cache", key = "#id")
    public Member findById(Long id) {
        System.out.println("MemberDaoImpl NO CACHE");
        return em.find(Member.class, id);
    }

    public Member findByEmail(String email) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery criteria = cb.createQuery(Member.class);
        Root member = criteria.from(Member.class);

        /*
         * Swap criteria statements if you would like to try out type-safe criteria queries, a new
         * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
         */

        criteria.select(member).where(cb.equal(member.get("email"), email));
        return em.createQuery(criteria).getSingleResult();
    }

    public List findAllOrderedByName() {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery criteria = cb.createQuery(Member.class);
        Root member = criteria.from(Member.class);

        /*
         * Swap criteria statements if you would like to try out type-safe criteria queries, a new
         * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
         */

        criteria.select(member).orderBy(cb.asc(member.get("name")));
        return em.createQuery(criteria).getResultList();
    }

    @CacheEvict(value="my-local-cache",allEntries=true,beforeInvocation=true)//清空所有缓�?/span>
    public void register(Member member) {
        em.persist(member);
        return;
    }
}

paulwong 2015-02-25 16:34 发表评论

SPRING CACHE资源

paulwong — Wed, 25 Feb 2015 08:04:00 GMT

SPRING手册
http://docs.spring.io/spring/docs/3.2.x/spring-framework-reference/htmlsingle/#cache

SPRING CONCURRENTMAP MANAGER加过期策�?br />http://stackoverflow.com/questions/8181768/can-i-set-a-ttl-for-cacheable

�l�合KEY
http://stackoverflow.com/questions/14072380/cacheable-key-on-multiple-method-arguments

Spring Cache抽象详解
http://www.open-open.com/lib/view/open1389575623336.html

注释驱动�?Spring cache �~�存介绍
https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/

Spring Cache抽象详解

paulwong 2015-02-25 16:04 发表评论

使用WILDFLY中的分布式缓存INFISHPAN

paulwong — Mon, 23 Feb 2015 05:40:00 GMT

��目部��v的应用服务器�Q�WILDFLY

通过http://127.0.0.1:9991/console/App.html#infinispan��d��CACHE

<cache-container name="tickets" default-cache="default" jndi-name="java:jboss/infinispan/tickets">
       <local-cache name="default" batching="true">
              <locking isolation="REPEATABLE_READ"/>
       local-cache>
cache-container>
pom.xml��d��依赖�?br />
  <dependency>
            <groupId>org.infinispangroupId>
            <artifactId>infinispan-coreartifactId>
            <scope>providedscope>
        dependency>

        <dependency>
            <groupId>org.infinispangroupId>
            <artifactId>infinispan-client-hotrodartifactId>
            <scope>providedscope>
        dependency>

    <dependency>
        <groupId>org.jgroupsgroupId>
        <artifactId>jgroupsartifactId>
        <scope>providedscope>
    dependency>

        <dependency>
            <groupId>org.infinispangroupId>
            <artifactId>infinispan-springartifactId>
            <version>6.0.2.Finalversion>
        dependency>

        <dependency>
            <groupId>org.infinispangroupId>
            <artifactId>infinispan-jcacheartifactId>
            <version>6.0.2.Finalversion>
        dependency>
��d��拦截器，WEB-INF/beans.xml

xml version="1.0"?>
<beans xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://jboss.org/schema/cdi/beans_1_0.xsd">
    <interceptors>
        <class>org.infinispan.jcache.annotation.CacheResultInterceptorclass>
        <class>org.infinispan.jcache.annotation.CachePutInterceptorclass>
        <class>org.infinispan.jcache.annotation.CacheRemoveEntryInterceptorclass>
        <class>org.infinispan.jcache.annotation.CacheRemoveAllInterceptorclass>
    interceptors>
beans>
��d��目的全局依赖�Q�WEB-INF/jboss-deployment-structure.xml

xml version="1.0" encoding="UTF-8"?>
<jboss-deployment-structure>
    <deployment>
        <dependencies>
            <module name="org.jboss.xnio" />
            <module name="org.infinispan" export="true"/>
            <module name="org.infinispan.commons" export="true"/>
            <module name="org.infinispan.client.hotrod" export="true"/>
        dependencies>
    deployment>
jboss-deployment-structure>
在CDI BEAN中��用CACHE

package com.paul.myejb;

import javax.annotation.Resource;
import javax.cache.annotation.CacheResult;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

import org.infinispan.Cache;
import org.infinispan.manager.EmbeddedCacheManager;
//import org.springframework.cache.annotation.Cacheable;
import org.springframework.ejb.interceptor.SpringBeanAutowiringInterceptor;

/**
* Session Bean implementation class HelloWorldBean
*/
@Stateless
//@Local(HelloWorld.class)
@Remote(HelloWorld.class)
@Interceptors(SpringBeanAutowiringInterceptor.class)
//@RolesAllowed({Roles.ADMIN})
public class HelloWorldBean implements HelloWorld {

    @Resource(lookup = "java:jboss/infinispan/tickets")
    private EmbeddedCacheManager container;


    /**
     * Default constructor.
     */
    public HelloWorldBean() {
    }

//    @Transactional
//    @Cacheable(value = "books", key = "#name")
    @CacheResult
    public String sayHello(String name) {
        System.out.println("NO CACHE");
        String result = "Hello " + name + ", I am HelloWorldBean.";
        Cache cache = this.container.getCache();
        cache.put(name, result);
        return result;
    }

}
修改modules/system/layers/base/org/infinispan/client/hotrod/main/modules.xml

xml version="1.0" encoding="UTF-8"?>

<module xmlns="urn:jboss:module:1.3" name="org.infinispan.client.hotrod">
    <properties>
        <property name="jboss.api" value="private"/>
    properties>

    <resources>
        <resource-root path="infinispan-client-hotrod-6.0.2.Final.jar"/>
    resources>

    <dependencies>
        <module name="javax.api"/>


        <module name="org.apache.commons.pool"/>
        <module name="org.infinispan.commons"/>
        <module name="org.infinispan.query.dsl"/>
        <module name="org.jboss.logging"/>
    dependencies>
module>

以下是SPRING版本

��d��依赖的SPRING BEAN
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:context="http://www.springframework.org/schema/context"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/cache
          http://www.springframework.org/schema/cache/spring-cache.xsd
          http://www.springframework.org/schema/jee
          http://www.springframework.org/schema/jee/spring-jee.xsd">

    <cache:annotation-driven />

    <bean id="cacheManager"
          class="org.infinispan.spring.provider.ContainerCacheManagerFactoryBean">
          <constructor-arg ref="cacheContainer"  />
    bean>

    <jee:jndi-lookup id="cacheContainer" jndi-name="java:jboss/infinispan/tickets" >
    jee:jndi-lookup>



beans>
使用CACHE
package com.paul.myejb.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class MySpringBean {

    @Autowired
    private CacheManager cacheManager;

    @Cacheable(value = "my-local-cache", key = "#name")
    public String sayHello(String name)
    {
        System.out.println("MySpringBean NO CACHE");
        String result = "Hi " + name + ", I am Spring!";
        org.springframework.cache.Cache springCache = this.cacheManager.getCache("my-local-cache");
        System.out.println(springCache.get(name) == null ? "null" : springCache.get(name).get());
        springCache.put(name, result);
        return result;
    }

}

paulwong 2015-02-23 13:40 发表评论

Infinispan资源

paulwong — Sun, 22 Feb 2015 06:03:00 GMT

Infinispan是一个分布式的缓存，由JBOSS开发。支持JSR-107标准�?br /> 使用时最好与SPRING�l�合�Q�用在DAO层�?br /> 以某�Ҏ��参数作�ؓKEY�Q�返回的对象作�ؓVALUE保存到缓存中�?br /> ADD/EDIT/REMOVE�Ҏ��被执行时则清除所有的�~�存�?br />
Infinispan的运行模式有两种�Q?br /> 1、嵌入式
先启动一个进�E�，再在此进�E�中启动Infinispan的CACHE MANAGER�?br /> 2、CLIENT/SERVER
直接�q�行startserver.sh来启动�?br />
两者区�?br /> 嵌入式：
1、Infinispan和启动进�E�是在同一个进�E�里�Q�如JBOSS中的Infinispan
2、要使用Infinispan的CACHE�Q�必��d��应用部��v到此�q�程中，如将WAR应用部��v到JBOSS�?br /> 3、如有多台机以此模式�q�行�Q�则互相可以通讯

CLIENT/SERVER�Q?br /> 1、Infinispan单独一个进�E?br /> 2、通过SDK�Q�以MEMCHAED�Q�RHQ�{�协议访问CACHE
3、如有多台机以此模式�q�行�Q�互�怸�可以通讯

JBOSS中的INFINISPAN肯定是嵌入式�Q�要讉K��INFINISPAN的CACHE必须部��v到JBOSS才能讉K��Q�没有远�E�模式�?/span>

Infinispan中的CACHE有两�U�模式：本地�~�存和集��缓存�?br />
本地�~�存是单机版�?br /> 集群�~�存是多机网�l�版�Q�又分�ؓ三种�Q?br /> 1、分布式�Q�网�l�中的每个节点只保存部䆾�~�存条目�Q�所有的节点合�v来保存全部缓存条�?br /> 当本机无此条目时�Q�要通过�|�络��d��别的机器上取
2、复制式�Q�网�l�中的每个节炚w��保存全部�~�存条目�Q�但�~�存条目有更新时�Q�所有节点一�q�更�?br /> 当本机无此条目时�Q�不用到别的节点取，但缓存条目有更新�Ӟ��所有节炚w��会执行更新本地缓存操�?br /> 3、无效式�Q�网�l�中的每个节点互不通讯�Q�但�~�存条目有更新时�Q�节�Ҏ��到失效通知�Q�各自处理本机的�~�存条目

�~�程使用�Ҏ��
1、通过�E�序使用�Q�即在代码中写cache的存取�?br /> 2、通过注释使用�Q�这各注释是通过截面拦截�Ҏ��方式实现�Q�即如果在缓存中有此�~�存条目�Q�则�Ҏ��不会被执行，直接�q�回�l�果�?br /> 又细分两�U�：
通过SPRING实现�Q�通过JAVA EE的CDI实现�?br />
JBoss �p�d��三十一�Q�JBoss Data Grid�Q�Infinispan�Q�缓存模�?/a>

JBoss �p�d��三十二：JBoss Data Grid�Q�Infinispan�Q�缓存模式示�?/a>

infinispan-quickstart

https://docs.jboss.org/infinispan/5.0/apidocs/org/infinispan/spring/provider/package-summary.html

Infinispan integrate with spring based application
http://timtang.me/blog/2012/11/04/infinispan-spring-based-application-integration/

Java�~�存新标准（javax.cache�Q?br /> http://www.importnew.com/11723.html

https://developer.jboss.org/en/infinispan/cn/content?filterID=contentstatus[published]~objecttype~objecttype[document]

paulwong 2015-02-22 14:03 发表评论

几大NOSQL数据库性能比较

paulwong — Thu, 29 Jan 2015 16:16:00 GMT

Apache Cassandra NoSQL Performance Benchmarks
http://planetcassandra.org/nosql-performance-benchmarks

NoSQL Benchmarking
http://www.cubrid.org/blog/dev-platform/nosql-benchmarking/

http://www.badrit.com/blog/2013/11/18/redis-vs-mongodb-performance#.VMpfW2SUfsg

How many requests per second can I get out of Redis?
http://skipperkongen.dk/2013/08/27/how-many-requests-per-second-can-i-get-out-of-redis/

redis性能��试�Q�测试�ƈ发性能
http://my.oschina.net/pblack/blog/102394

paulwong 2015-01-30 00:16 发表评论

paulwong — Tue, 15 Jul 2014 23:58:00 GMT

paulwong 2014-07-16 07:58 发表评论

一些数据切分、缓存、rpc框架、nosql�Ҏ��资料

paulwong — Mon, 14 Oct 2013 02:14:00 GMT

1、数据切�?/span>

1.1�?a style="color: #108ac6;" target="_blank">mysql中间件研�IӞ��Atlas�Q�cobar�Q�TDDL�Q?/a>

1.2�?a style="color: #108ac6;" target="_blank">利用 MySQL Proxy 实现数据切分及整�?nbsp;

1.3�?a style="color: #108ac6;" target="_blank">��Z��MySQL分库分表�Ҏ��?nbsp;

1.4�?a style="color: #108ac6;" target="_blank">tddl和diamond

2、缓�?/p>

2.1�?a style="color: #108ac6;" target="_blank">java客户端三�U�方式操�?nbsp;

2.2�?a style="color: #108ac6;" target="_blank">myibatis配置memcached评测

2.3�?a style="color: #108ac6;" target="_blank">Memcached + Spring Caching

2.4�?a style="color: #108ac6;" target="_blank">memcachedb-持久化存储的�~�存�pȝ��

2.5�?a style="color: #108ac6;" target="_blank">memcachedb让memcache的数据持久化

2.6�?a style="color: #108ac6;" target="_blank">淘宝kv�~�存框架tair

2.7�?a style="color: #108ac6;" target="_blank">ibatis之扩展缓存ibatis-tair-cache

3、rpc框架

3.1�?a style="color: #108ac6;">dubbo

3.2、hsf 未开�?/p>

3.3�?a style="color: #108ac6;" target="_blank">服务框架HSF分析之一容器启动

4、noSql

4.1�?a style="color: #108ac6;" target="_blank">学习NoSQL数据库的必读资料

paulwong 2013-10-14 10:14 发表评论

paulwong — Wed, 02 May 2012 02:24:00 GMT

http://code.google.com/p/xcache-j/

paulwong 2012-05-02 10:24 发表评论

实战Memcached�~�存�pȝ��

paulwong — Sun, 29 Apr 2012 13:42:00 GMT

实战Memcached�~�存�pȝ��Q?�Q�Memcached基础及示例程�?/font>
实战Memcached�~�存�pȝ��Q?�Q�Memcached Java API基础之MemcachedClient
内容�Q�以Memcached的Java Spy API��Z��Q�讲�q�基本的客户端��用�?
实战Memcached�~�存�pȝ��Q?�Q�Memcached配置参数初解
内容�Q�提供Memcached配置的初步解诅R�?
实战Memcached�~�存�pȝ��Q?�Q�Memcached的CAS协议
内容�Q�Memcached的CAS协议�?
实战Memcached�~�存�pȝ��Q?�Q�Memcached的CAS�E�序实例
内容�Q�Memcached Client使用CAS协议的实例�?
实战Memcached�~�存�pȝ��Q?�Q�Memcached CAS的多�U�程�E�序实例
内容�Q�Memcached Client使用CAS协议的多�U�程实例�?
实战Memcached�~�存�pȝ��Q?�Q�Memcached的一些基��FAQ
内容�Q�一些关于Memcached的常见问题和基础知识汇总，不断更新中�?
实战Memcached�~�存�pȝ��Q?�Q�Memcached异步实时��d��问题的解��x��案SAC

paulwong 2012-04-29 21:42 发表评论

Spring��Z��注解的缓存配�|?-web应用实例

paulwong — Thu, 16 Feb 2012 09:04:00 GMT

��Z��Ҏ��U�别的缓存：通常如果一个带有参数的�Ҏ��执行后会�q�回一个Object�Q�那可以认�ؓ如果参数相同�Q�则�q�回的结果一��P��q�样��可以�ؓ�q�个�Ҏ��建立一个缓存Map�Q�参数就是KEY�Q�返回的�l�果��是VALUE�Q�调用此�Ҏ��前可以先判断参数是否和之前的一��P��如果是则从Map中取出结果返回调用者，而无需再进入此�Ҏ��内执行得刎ͼ�从而节省了此方法执行时的时间�?br />
http://hanqunfeng.iteye.com/blog/605123

�l�验证，如果要支持分布式的缓存，用spring-modules-cache不好使，必须转用com.googlecode.ehcache-spring-annotations�?br />
全套MAVEN的POM:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <groupId>EhCache-Cluster-TestergroupId>
    <artifactId>EhCache-Cluster-TesterartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <packaging>warpackaging>
    <dependencies>
        <dependency>
            <groupId>net.sf.ehcachegroupId>
            <artifactId>ehcache-jgroupsreplicationartifactId>
            <version>1.4version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>springartifactId>
            <version>${spring.version}version>
        dependency>


        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>${spring.version}version>
        dependency>
        <dependency>
            <groupId>javax.servletgroupId>
            <artifactId>servlet-apiartifactId>
            <version>2.4version>
            <scope>providedscope>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-jdk14artifactId>
            <version>1.5.6version>
            <type>jartype>
            <scope>compilescope>
        dependency>
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.13version>
            <type>jartype>
            <scope>compilescope>
        dependency>
        <dependency>
            <groupId>cglibgroupId>
            <artifactId>cglib-nodepartifactId>
            <version>2.2.2version>
            <type>jartype>
            <scope>compilescope>
        dependency>

        <dependency>
            <groupId>com.googlecode.ehcache-spring-annotationsgroupId>
            <artifactId>ehcache-spring-annotationsartifactId>
            <version>1.2.0version>
            <type>jartype>
            <scope>compilescope>
            <exclusions>
                <exclusion>
                    <artifactId>spring-aopartifactId>
                    <groupId>org.springframeworkgroupId>
                exclusion>
                <exclusion>
                    <artifactId>spring-expressionartifactId>
                    <groupId>org.springframeworkgroupId>
                exclusion>
            exclusions>
        dependency>
    dependencies>
    <build>
        <finalName>cluster-testfinalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-compiler-pluginartifactId>
                <configuration>
                    <source>1.6source>
                    <target>1.6target>
                    <encoding>UTF-8encoding>
                configuration>
            plugin>
            <plugin>
                <groupId>org.mortbay.jettygroupId>
                <artifactId>jetty-maven-pluginartifactId>
                <version>8.0.4.v20111024version>

                <configuration>
                    <contextPath>/cluster-testcontextPath>
                    <scanIntervalSeconds>3scanIntervalSeconds>
                    <scanTargetPatterns>
                        <scanTargetPattern>
                            <directory>src/main/webapp/WEB-INFdirectory>
                            <excludes>
                                <exclude>**/*.jspexclude>
                            excludes>
                            <includes>
                                <include>**/*.propertiesinclude>
                                <include>**/*.xmlinclude>
                            includes>
                        scanTargetPattern>
                    scanTargetPatterns>
                configuration>
            plugin>
        plugins>
    build>
    <properties>
        <spring.version>2.5.2spring.version>
    properties>
project>

paulwong 2012-02-16 17:04 发表评论

paulwong — Tue, 14 Feb 2012 07:46:00 GMT

�?.2版本开始，Ehcache可以使用分布式的�~�存了�?br />
分布式这个特性是以plugin的方式实现的。Ehcache自带了一些默认的分布式缓存插件实玎ͼ��q�些插�g可以满��大部分应用的需要。如果需要��用其他的插�g那就需要自己开发了�Q�开发者可以通过查看distribution包里的源代码及JavaDoc来实现它�?br />
��管不是必须的，在��用分布式�~�存时理解一些ehcahce的设计思想也是有帮助的。这可以参看分布式缓存设计的��面�?br /> 以下的部分将展示如何让分布式插�g同ehcache一起工作�?br />
下面列出的是一些分布式�~�存中比较重要的斚w��Q?br />
你如何知道集��环境中的其他缓存？分布式传送的消息是什么�Ş式？什么情况需要进行复�Ӟ��增加�Q�Puts�Q�，更新�Q�Updates�Q�或是失效（Expiries�Q�？采用什么方式进行复�Ӟ��同步�q�是异步方式�Q?br />
��Z��安装分布式缓存，你需要配�|�一个PeerProvider、一个CacheManagerPeerListener�Q�它们对于一个CacheManager来说是全局的。每个进行分布式操作的cache都要��d��一个cacheEventListener来传送消息�?br />
正确的元素类�?/strong>

只有可序列化的元素可以进行复制�?br />
一些操作，比如�U�除�Q�只需要元素的键��D��不用整个元素；在这��L��操作中即使元素不是可序列化的但键值是可序列化的也可以被复�Ӟ��

成员发现�Q�Peer Discovery�Q?/strong>

Ehcache�q�行集群的时候有一个cache�l�的概念。每个cache都是其他cache的一个peer�Q�没有主cache的存在。刚才我们问了一个问题：你如何知道集��环境中的其他缓存？�q�个问题可以命名为成员发玎ͼ�Peer Discovery�Q��?br />
Ehcache提供了两�U�机制用来进行成员发玎ͼ��像一辆汽车：手动档和自动档�?br />
要��用一个内�|�的成员发现机制要在ehcache的配�|�文件中指定cacheManagerPeerProviderFactory元素的class属性�ؓnet.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory�?br />
自动的成员发�?/strong>

自动的发现方式用TCP�q�播机制来确定和�l�持一个广播组。它只需要一个简单的配置可以自动的在�l�中��d��和移除成员。在集群中也不需要什么优化服务器的知识，�q�是默认推荐的�?br />
成员每秒向群�l�发送一�?#8220;心蟩”。如果一个成�?5�U�种都没有发��Z��号它��被��组�U�除。如果一个新的成员发送了一�?#8220;心蟩”它将被添加进��组�?br />
��M��一个用�q�个配置安装了复制功能的cache都将被其他的成员发现�q�标识�ؓ可用状态�?br />
要设�|�自动的成员发现�Q�需要指定ehcache配置文�g中cacheManagerPeerProviderFactory元素的properties属性，��像下面�q�样�Q?br />

peerDiscovery=automatic multicastGroupAddress=multicast address | multicast host name multicastGroupPort=port
# (timeToLive属性详见常见问题部分的描述)
timeToLive=0-255

�C�Z��

假设你在集群中有两台服务器。你希望同步sampleCache1和sampleCache2。每台独立的服务器都要有�q�样的配�|�：
配置server1和server2

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

手动�q�行成员发现

�q�行手动成员配置要知道每个监听器的IP地址和端口。成员不能在�q�行时动态地��d��和移除。在技术上很难使用�q�播的情况下��可以手动成员发玎ͼ�例如在集��的服务器之间有一个不能传送广播报文的路由器。你也可以用手动成员发现�q�行单向的数据复�Ӟ��只让server2知道server1而server1不知道server2�?br />
配置手动成员发现�Q�需要指定ehcache配置文�g中cacheManagerPeerProviderFactory的properties属性，像下面这��P��

peerDiscovery=manual rmiUrls=//server:port/cacheName,
rmiUrls配置的是服务器cache peers的列表。注意不要重复配�|��?/span>

�C�Z��

假设你在集群中有两台服务器。你要同步sampleCache1和sampleCache2。下面是每个服务器需要的配置�Q?br /> 配置server1

<cacheManagerPeerProviderFactory
class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
properties="peerDiscovery=manual,
rmiUrls=//server2:40001/sampleCache11|//server2:40001/sampleCache12"/>

配置server2

<cacheManagerPeerProviderFactory
class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
properties="peerDiscovery=manual,
rmiUrls=//server1:40001/sampleCache11|//server1:40001/sampleCache12"/>

配置CacheManagerPeerListener

每个CacheManagerPeerListener监听成员们发向当前CacheManager的消息�?br /> 配置CacheManagerPeerListener需要指定一个CacheManagerPeerListenerFactory�Q�它以插件的机制实现�Q�用来创建CacheManagerPeerListener�?br />
cacheManagerPeerListenerFactory的属性有�Q?br /> class – 一个完整的工厂�c�d��?br /> properties – 只对�q�个工厂有意义的属性，使用逗吃分隔�?br />
Ehcache有一个内�|�的��Z��RMI的分布系�l�。它的监听器是RMICacheManagerPeerListener�Q�这个监听器可以用RMICacheManagerPeerListenerFactory来配�|��?br />

<cacheManagerPeerListenerFactory
class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
properties="hostName=localhost, port=40001,
socketTimeoutMillis=2000"/>

有效的属性是�Q?br /> hostname (可�? – �q�行监听器的服务器名�U�。标明了做�ؓ集群��组的成员的地址�Q�同时也是你惌��控制的从集群中接收消息的接口�?br />
在CacheManager初始化的时候会��查hostname是否可用�?br />
如果hostName不可用，CacheManager��拒�l�启动�ƈ抛出一个连接被拒绝的异常�?br />
如果指定�Q�hostname��用InetAddress.getLocalHost().getHostAddress()来得到�?br />
警告�Q�不要将localhost配置为本地地址127.0.0.1�Q�因为它在网�l�中不可见将会导致不能从�q�程服务器接收信息从而不能复制。在同一台机器上有多个CacheManager的时候，你应该只用localhost来配�|��?br />
port – 监听器监听的端口�?br /> socketTimeoutMillis (可�? – Socket��时的时间。默认是2000ms�?br />
配置CacheReplicators

每个要进行同步的cache都需要设�|�一个用来向CacheManagerr的成员复制消息的�~�存事�g监听器。这个工作要通过为每个cache的配�|�增加一个cacheEventListenerFactory元素来完成�?br />

<cache name="sampleCache2"
maxElementsInMemory="10"
eternal="false"
timeToIdleSeconds="100"
timeToLiveSeconds="100"
overflowToDisk="false">
<cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"
properties="replicateAsynchronously=true,
replicatePuts=true, replicateUpdates=true, replicateUpdatesViaCopy=false, replicateRemovals=true "/>
cache>

name�Q�缓存名�U�。通常为缓存对象的�c�d��Q�非严格标准�Q��?br />
maxElementsInMemory�Q�设�|�基于内存的�~�存可存攑֯�象的最大数目�?br />
maxElementsOnDisk�Q�设�|�基于硬盘的�~�存可存攑֯�象的最大数目�?br />
eternal�Q�如果�ؓtrue�Q�表�C�对象永�q�不会过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false;

timeToIdleSeconds�Q?讑֮�允许对象处于�I�闲状态的最长时��_��以秒为单位。当对象自从最�q�一�ơ被讉K��后，如果处于�I�闲状态的旉��过了timeToIdleSeconds属性��|��q�个对象��׃��q�期。当对象�q�期�Q�EHCache��把它从�~�存中清�I�。只有当eternal属性�ؓfalse�Q�该属性才有效。如果该属性��gؓ0�Q�则表示对象可以无限期地处于�I�闲状态�?br />
timeToLiveSeconds�Q�设定对象允许存在于�~�存中的最长时��_��以秒为单位。当对象自从被存攑ֈ��~�存中后�Q�如果处于缓存中的时间超�q�了 timeToLiveSeconds属性��|��q�个对象��׃��q�期。当对象�q�期�Q�EHCache��把它从�~�存中清除。只有当eternal属性�ؓfalse�Q�该属性才有效。如果该属性��gؓ0�Q�则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义�?br />
overflowToDisk�Q�如果�ؓtrue,表示当基于内存的�~�存中的对象数目辑ֈ�了maxElementsInMemory界限后，会把益出的对象写到基于硬盘的�~�存中�?br />
class – 使用net.sf.ehcache.distribution.RMICacheReplicatorFactory

�q�个工厂支持以下属性：
replicatePuts=true | false – 当一个新元素增加到缓存中的时候是否要复制到其他的peers. 默认是true�?br /> replicateUpdates=true | false – 当一个已�l�在�~�存中存在的元素被覆盖时是否要进行复制。默认是true�?br /> replicateRemovals= true | false – 当元素移除的时候是否进行复制。默认是true�?br /> replicateAsynchronously=true | false – 复制方式是异步的�Q�指定�ؓtrue�Ӟ��q�是同步的（指定为false�Ӟ��。默认是true�?br /> replicateUpdatesViaCopy=true | false – 当一个元素被拯��到其他的cache中时是否�q�行复制�Q�指定�ؓtrue时�ؓ复制�Q�，默认是true�?br />
你可以��用ehcache的默认行��Z��而减��配�|�的工作量，默认的行为是以异步的方式复制每�g事；你可以像下面的例子一样减��RMICacheReplicatorFactory的属性配�|�：

<cache name="sampleCache4"
maxElementsInMemory="10"
eternal="true"
overflowToDisk="false"
memoryStoreEvictionPolicy="LFU">
<cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>
cache>

常见的问题Windows上的Tomcat

有一个Tomcat或者是JDK的bug�Q�在tomcat启动时如果tomcat的安装�\径中有空格的话，在启动时RMI监听器会��p�|。参见http://archives.java.sun.com/cgi-bin/wa?A2=ind0205&L=rmi-users&P=797和http://www.ontotext.com/kim/doc/sys-doc/faq-howto-bugs/known-bugs.html�?br />
�׃��在Windows上安装Tomcat默认是装�?#8220;Program Files”文�g多w��的，所以这个问题经常发生�?br />
�q�播��L��

自动的peer discovery与广播息息相兟뀂广播可能被路由��L��Q�像Xen和VMWare�q�种虚拟化的技术也可以��L��q�播。如果这些都打开了，你可能还在要��你的网卡的相关配置打开�?br />
一个简单的办法可以告诉�q�播是否有效�Q�那��是使用ehcache remote debugger来看“心蟩”是否可用�?br />
�q�播传播的不够远或是传得太远

你可以通过讄��badly misnamed time to live来控制广播传播的距离。用�q�播IP协议�Ӟ��timeToLive的值指的是数据包可以传递的域或是范围。约定如下：

0是限制在同一个服务器
1是限制在同一个子�|?br />32是限制在同一个网�?br />64是限制在同一个region
128是限制在同一个大�z?br />255是不限制

译者按�Q�上面这些资料翻译的不够准确�Q�请读者自行寻扑֎�文理解吧�?br />
在Java实现中默认值是1�Q�也��是在同一个子�|�中传播。改变timeToLive属性可以限制或是扩展传播的范围�?br />
原文地址�?http://ehcache.sourceforge.net/documentation/distributed_caching.html

paulwong 2012-02-14 15:46 发表评论

优化�E�序之前�Q�可用Jamon来监��你的Spring应用

paulwong — Wed, 25 Jan 2012 08:32:00 GMT
/**
*作者：张荣�?ahuaxuan)
*2007-8-15
*转蝲��h��明出处及作�?
*/

前两天在看Spring内置的拦截器的时候，发现了一个之前没有注意的�c�：org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor�Q�好奇心促��我上�|�查了一下这个jamon。大概看了一下之后发现这个玩意还真挺好用的而且挺重要的�Q�而且现在国内对它的介�l�也很少�Q�所以写了一��文章和大家分��n�?

一�Q�Jamon��介：
Jamon的全名是�Q�Java Application Monitor。它是一个小巧的�Q�免费的�Q�高性能的，�U�程安全的性能监测工具。它可以用来��定�pȝ��的性能瓉��Q�也可以用来监视用户和应用程序之间的交互情况�?Jamon主要是用来检��jee的应用程序。它最新的版本�?.1�Q�可以用�?.4以上的jdk上�?

二，��jamon导入��C��的应用程序中�?
首先下蝲jamon的开发包�Q�见我的附�g�Q�同时你也可以去Sourceforge上自�׃��载。Sourceforge的下载地址为http://jamonapi.sourceforge.net。解压之后可以得��C��个jar包和一个war包。jar包是自己会用到的�Q�而war包是一个例子（不要��看�q�个例子�Q�待会也要把它导入到��目中）。把war包之间丢到服务器上，讉K��Q�localhost:8080/jamon��可以看到这个例子了�Q�这个例子是一个简单的性能监控�pȝ��?

接着把例子中的所有的包都导入到项目中�Q��ƈ把war包中的jsp和images�q�有css都考到��目中，比如新徏一个目录叫monitor�Q�它和WEB-INF是同�U�目录）�?

三，正确配置自己的应�?
我们在性能监测的时候最监测的就是页面的讉K��率和�c�M��Ҏ��的访问率。所以在�q�一部分主要讲解一下如何监��自��q��面和类中方法的讉K��?

1�Q?��自��q��面讉K��?
首先我们需要在web.xml中添加一个filter�Q�这个filter��是用来判断哪些��面需要被监视的，如下所�C�：
<filter>
        <filter-name>JAMonFilterfilter-name>
        <filter-class>com.easywebwork.filter.EasyPageMonFilterfilter-class>
    filter>
    <filter-mapping>
        <filter-name>JAMonFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

接下来我们看看这个filter的写法：

/** *//**
* @author 张荣华（ahuaxuan�Q?br /> *
* @since 2007-8-13
*/
public class PageMonFilter extends JAMonFilter{

private static final long serialVersionUID = 5746197114960908454L;

public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
Monitor allPages = MonitorFactory.start(new MonKeyImp("org.easywebwork.allPages",getURI(request),"ms."));
//�q�里��是我们要监视的所有的��面的配�|?/span>
Monitor monitor = MonitorFactory.start(getURI(request));
//�q�里��是我们要监视的某个��面的配�|?/span>
try {
filterChain.doFilter(request, response);
} finally {
monitor.stop();
allPages.stop();
}
}

protected String getURI(ServletRequest request) {
if (request instanceof HttpServletRequest) {
return ((HttpServletRequest) request).getRequestURI();
} else {
return "Not an HttpServletRequest";
}
}

private FilterConfig filterConfig = null;

}}

�q�个�cȝ��上去很简单，其实也挺��单的�Q�就是得到uri�Q�然后把它注册到MonitorFactory�c�M��。这样只要我们去讉K��刚才创徏的monitor目录下的jsp��可以看到性能监测��面了�?

2�Q?接下来我们看看在使用spring的情况下如何监测一个bean的方法调用�?br />Spring也提供了对Jamon的支�?spring支持的东西还真多�?�Q�也��是文章开头提出的那个拦截器，��Z��l�我们的bean加上拦截器，我们在spring的applicationcontext配置文�g中加入如下语句：

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>userServicevalue>
list>
property>
<property name="interceptorNames">
<list>
<value>jamonInterceptorvalue>
list>
property>
bean>

<bean id="jamonInterceptor" class="org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor">
bean>

上面�q�个是典型的spring的aop的配�|�，如果对spring的aop配置不了解的可以�ȝ��一下spring中文文档�Q�当然如果不想了解的话即使直接把�q�段配置拷到自己的项目中也是可以直接使用的�?

�q�有一个步骤就是在你的log4j.properties中加入这句代码：

log4j.logger.org.springframework.aop.interceptor.JamonPerformanceMonitorInterceptor = TRACE

如果没有�q�一行，那么�q�个拦截器是不会把方法调用的信息向MonitorFactory注册的�?

只需要这些步骤，userservice中的�Ҏ��在调用的时候就可以被拦截，然后��其注册到MonitorFactory中去了�?

所有的配置完成之后我们来看一下效果吧:
http://www.iteye.com/topics/download/b2bac96e-6c18-4340-b7e0-f84c7bb6adca从这个图上我们可以看刎ͼ�所有页面被讉K��的次敎ͼ�UserService中的getAllUsers被调用的�ơ数�Q�最双��的是讉K��旉��。这只是整个囄��一部分�Q�当然这个页面中也包括每一个页面被讉K��的次数和�W�一�ơ访问的旉��{�等。下载附件运行，��可以看到所有的��面了�?

三，�ȝ��
�Ҏ��以上的步骤，我们��可以监��我们的�E�序了，应用�E�序中哪些页面被讉K��的多�Q�哪些页面被讉K��的少�Q�哪些方法被讉K��的多�Q�哪些方法被讉K��的少�Q�以及访问高峰期集中在什么时间等�{�，有了�q�些参数�Q�我们更可以有针�Ҏ��的对应用程序进行优化了�Q�比如说某个��面讉K��比较频繁�Q�我��可以用ehcache或oscache�l�这个页面做一个缓存。如果某个方法的讉K��比较频繁那就看看�q�个�Ҏ��能否�q�一步优化，是需要异步，�q�是需要缓存，�q�是需要其他等�{�，��M��有了jamon可以�l�我们带来更多的便捷�Q�既可以让我们知道我们的客户的行为，也可以让我们知道我们开发的�E�序�?#8220;能力”�?

其实本文提供的只是对��面和方法调用的监控�Q�但是jamon可以提供更多功能�Q�比如说sql语句的监控等�{�，�q�就需要我们共同去发掘了�?

附�g中包括了一个easywebwork的例子，我把jamon导入到这个例子工�E�中去，大家可以直接下蝲�q�行观看效果。Easywebwork是一个旨在减��webwork2.2.x�p�d��的xml配置文�g的项目�?br />
JamonSample.rar (3.7 MB)
描述: �׃��上传文�g大小有限�Ӟ��所以需要同学们自己��d��一下jar包： spring,common-logging,log4j,common-collections activation, common-lang

lib.rar (3.3 MB)
描述: �W�二�l�包包括 spring,common-logging,log4j,common-collections activation, common-lang

paulwong 2012-01-25 16:32 发表评论

memcache-client-forjava

paulwong — Tue, 24 Jan 2012 12:34:00 GMT
http://code.google.com/p/memcache-client-forjava/
http://marc.iteye.com/blog/28700
http://www.jayxu.com/2010/06/09/2342/
http://www.iteye.com/topic/128458
http://code.google.com/p/xmemcached/wiki/User_Guide_zh

paulwong 2012-01-24 20:34 发表评论

paulwong — Tue, 24 Jan 2012 12:32:00 GMT
     摘要: EhCache 是一个纯Java的进�E�内�~�存框架�Q�具有快速、精�q�等特点�Q�是Hibernate中默认的CacheProvider�? 下图�?EhCache 在应用程序中的位�|�： EhCache 的主要特性有�Q? 1. 快�?2. ��?3. 多种�~�存�{�略4. �~�存数据有两�U�：内存和磁盘，因此无需担心定w��问题5. �~�存数据会在虚拟机重启的�q�程中写入磁�?. 可以通过RMI、可插入API...  阅读全文

paulwong 2012-01-24 20:32 发表评论