澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

缓存集群,继续吐槽在net下没有合适的Disk

2019-12-12 作者:www.8455.com   |   浏览(140)

  

品种中须求动用一些查询,数据的更改超级少但查询度相当的大。一时照旧按频率查询的。

 

澳门新萄京官方网站 1

EhCache 系统简单介绍

EhCache 是三个纯 Java 的经过内缓存框架,具备便捷、精干等特色。 
EhCache 的主要特色有:

  1. 快速、精干
  2. 简单;
  3. 二种缓存计谋;
  4. 缓存数占领两级:内部存储器和磁盘,由此不须求担心容积难题;
  5. 缓存数据会在设想机重启的长河中写入磁盘;
  6. 能够通过 RMI、可插入 API 等措施展开布满式缓存;
  7. 具有缓存和缓存微电脑的侦听接口;
  8. 援救多缓存微电脑实例,以致二个实例的八个缓存区域;
  9. 提供 Hibernate 的缓存达成;

EhCache集群化解的主题材料: 
  由 于 EhCache 是进程中的缓存系统,生龙活虎旦将动用陈设在集群景况中,每两个节点维护各自的缓存数据,当某个节点对缓存数据举行翻新,这么些改过的数量不可能在任何节点中分享, 那不独有会减低节点运转的功用,何况会形成数据不一同的动静发生。举例有个别网址接受A、B 多少个节点作为集群铺排,当 A 节点的缓存更新后,而 B 节点缓存还未有更新就可能现身顾客在浏览页面包车型大巴时候,一会是翻新后的数量,一会是未曾更新的数目。 
  所以就须要用到 EhCache 的集群应用方案。 
   
EhCache集群方案:

• Terracotta 
• RMI 
• JMS : 依赖 ehcache-jmsreplication.jar 
• JGroups : 依赖ehcache-jgroupsreplication.jar 
• EhCache Server

  个中的三种最为常用集群格局,分别是 RMI、JGroups 以致 EhCache Server 。

EhCache集群众的狐疑问

• 你什么知道集群意况中的其余缓存? 
• 布满式传送的音讯是怎么格局? 
• 什么状态要求打开复制?扩充(Puts),更新(Updates)或是失效(Expiries)? 
• 采Nash么样方法进行复制?同步依旧异步方式?

EhCache集群基本概念

1、正确的因素类型:独有可系列化的要素得以扩充复制。一些操作,举例移除,只必要成分的键值而不用风度翩翩体因素;在这里样的操作中就算成分不是可系列化的但键值是可种类化的也足以被复制。 
2、成员开掘(Peer Discovery):Ehcache实行集群的时候有叁个cache组的概念。各样cache都以其余cache的一个peer,未有主cache的留存。成员发掘(Peer Discovery)就是用来消除 “你怎么领悟集群情况中的其余缓存?” 这几个难题的。Ehcache提供了三种体制用来开展成员发掘,即:自动成员开掘和手动成员发掘。要利用二个放松权利的积极分子开采体制要在ehcache的配置文件中钦命cacheManagerPeerProviderFactory成分的class属性为 
net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory。

  自动的开掘方法用TCP广播机制来明确和保全多个广播组。它只需求四个简便的铺排能够自动的在组中增进和移除成员。在集群中也无需如何优化服务器的学识,那是私下认可推荐的。ehcache.xml配置示范代码如下:

<cacheManagerPeerProviderFactory
class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1,
multicastGroupPort=4446, timeToLive=32"/>
<!-- timeToLive
    0是限制在同一个服务器
    1是限制在同一个子网
    32是限制在同一个网站
    64是限制在同一个region
    128是限制在同一个大洲
    255是不限制-->

 手动的开掘方法亟待了然种种监听器的IP地址和端口。集群成员(也正是服务器)不能在运行时动态地加上和移除。ehcache.xml配置示范代码如下:

<!-- 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的音讯。配置 CacheManagerPeerListener需求内定二个CacheManagerPeerListenerFactory,它以插件的体制贯彻, 用来创设CacheManagerPeerListener。 
  Ehcache有二个内置的依据RMI的布满系统。它的监听器是RMICacheManagerPeerListener,那个监听器可以用RMICacheManagerPeerListenerFactory来安插。 
  示例代码:

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

  属性表达:

hostname (可选卡塔尔国 – 运转监听器的服务器名称。评释了做为集群群组的积极分子的地点,同期也是您想要调节的从集群中抽出音信的接口。 
   在CacheManager开首化的时候会检查hostname是或不是可用。 
   假设hostName不可用,CacheManager将谢绝运行并抛出三个三回九转被反驳回绝的丰盛。 
  即使钦定,hostname将用InetAddress.getLocalHost(卡塔尔(قطر‎.getHostAddress(卡塔尔国来获取。 
port – 监听器监听的端口。 
socketTimeoutMillis (可选卡塔尔(قطر‎ – Socket超时的命宫。私下认可是贰零零壹ms。当您socket同步缓存恳求地址超远,不是地点局域网。你大概要求把这一个小时安插大些,不然很恐怕延时诱致同步缓存失利。

CacheReplicators 
  各类要开展合作的cache都亟需设置一个用来向CacheManager的积极分子复制新闻的缓存事件监听器。这些工作要由此为每种cache的配备增添一个cacheEventListenerFactory成分来成功。 
  代码:

<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>

  cache伊芙ntListenerFactory 扶持以下属性

replicatePuts=true | false – 当多个新因素增到缓存中的时候是不是要复制到其余的peers. 暗中同意是true。 
replicateUpdates=true | false – 当贰个早已在缓存中存在的因素被隐瞒时是或不是要开展复制。暗中同意是true。 
replicateRemovals= true | false – 当成分移除的时候是或不是举办复制。暗中认可是true。 
replicateAsynchronously=true | false – 复制方式是异步的(钦赐为true时)还是意气风发道的(内定为false时)。私下认可是true。 
replicatePutsViaCopy=true | false – 当多少个骤增成分被拷贝到别的的cache中时是还是不是开展复制钦定为true时为复制,暗许是true。

Cache属性表明:

<cache 
        name="userCache" 
        maxElementsInMemory="10000" 
        eternal="true" 
        overflowToDisk="true" 
        timeToIdleSeconds="0" 
        timeToLiveSeconds="0"
        diskPersistent="false" 
        diskExpiryThreadIntervalSeconds="120">
        <cacheEventListenerFactory 
           class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" 
          properties="replicateAsynchronously=true,replicatePuts=true,replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true">  
        </cacheEventListenerFactory>
        <bootstrapCacheLoaderFactory
          class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"
               properties="bootstrapAsynchronously=true"> 
        </bootstrapCacheLoaderFactory>
    </cache>

 

总得属性: 
  name:缓存名称。 
  maxElementsInMemory:缓存最大个数。 
  eternal:对象是或不是永恒有效,大器晚成但设置了,timeout将不起成效。 
  overflowToDisk:当内部存款和储蓄器中对象数量达 
  maxElementsInMemory时,Ehcache将会对象写到磁盘中。 
   diskSpoolBufferSizeMB:这一个参数设置DiskStore(磁盘缓存)的缓存区大小。暗中同意是30MB。每种Cache都应有有投机的叁个缓冲区。 
  maxElementsOnDisk:硬盘最大缓存个数。 
可选的属性: 
  timeToIdleSeconds:设置对象在失效前的同意闲置时间(单位:秒)。仅当eternal=false对象不是长久有效时行使,可选属性,暗许值是0,相当于可闲置时间无穷大。 
  timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大日子介于创制时间和失效时间里面。仅当eternal=false对象不是恒久有效时接受,默许是0.,也正是目的共处时间无穷大。 
  diskPersistent:是不是disk store在设想机运维时持久化. The default value is false. 
  memoryStoreEvictionPolicy:当达到maxElementsInMemory节制时,Ehcache将会基于钦点的政策去清理内部存款和储蓄器。私下认可攻略是LRU(这两天起码使用)。你能够设置为FIFO(先进先出)或是LFU(超级少使用)。 
  diskExpiryThreadIntervalSeconds:磁盘失效线程运营时刻间距,私下认可是120秒。 
  clearOnFlush:内部存储器数量最大时是还是不是扫除。 
缓存子成分: 
  cache伊夫ntListenerFactory:注册相应的的缓存监听类,用于拍卖缓存事件,如put,remove,update,和expire 
  bootstrapCacheLoaderFactory:钦定相应的BootstrapCacheLoader,用于在开头化缓存,以至机关安装。

         聊到缓存,大家也许口齿伶俐,各种类型的缓存都能挨个分析,但在net下找到后生可畏款合适的Disk Cache貌似依旧有几许难度的。

 无论如何缓存都以针对性查询远远不仅更新和插入的情况

ehcache FAQ中提到
Remember that a value in a cache element is globally accessible from multiple threads. It is inherently not thread safe to modify the value . It is safer to retrieve a value, delete the cache element and then reinsert the value.

Android interview

EhCache RMI 手动情势铺排缓存

Tomcat1: 127.0.0.1:8080, Cache Server1: 127.0.0.1:40001 
Tomcat2: 127.0.0.1:8088, Cache Server2: 127.0.0.1:40002

用到的架包: 
ehcache-core-2.6.8.jar 
log4j-1.2.17.jar 
servlet-api.jar (示例中动用了@WebServlet,请保管servler-api的架包版本大于3.0卡塔尔(قطر‎ 
slf4j-api-1.6.1.jar 
slf4j-log4j12-1.6.1.jar

成立Web工程TestEhcache, 工程目录如下: 
澳门新萄京官方网站 2

CacheManagerFactory.java

private CacheManager manager;
    private static CacheManagerFactory factory = new CacheManagerFactory();
    private final static String EHCACHEFILE = "/ehcache.xml";

    private CacheManagerFactory() {
    }

    public static CacheManagerFactory getInstance() {
        return factory;
    }

    public CacheManager getCacheManager() {
        if (manager == null) {
            InputStream is = this.getClass().getResourceAsStream(EHCACHEFILE);
            manager = CacheManager.create(is);
        }
        return manager;
    }

    public Cache getCache(String cache) {
        return getCacheManager().getCache(cache);
    }

    public void setCache(Cache cache) {
        getCacheManager().addCache(cache);
    }

    public void setCache(String cache) {
        getCacheManager().addCache(cache);
    }

    public Element getElement(String cacheName, String key) {
        if (getCache(cacheName) == null)
            setCache(cacheName);
        return getCache(cacheName).get(key);
    }

    public void setElement(String cache, Element element) {
        if (getCache(cache) == null)
            setCache(cache);
        getCache(cache).put(element);
    }

    public Boolean continaElementKey(String cacheName, String key) {
        if (getCache(cacheName) == null)
            setCache(cacheName);
        return getCache(cacheName).isKeyInCache(key);
    }

 

TesAction.java

@WebServlet("/test")
public class TesAction extends HttpServlet {

    private static final long serialVersionUID = 1L;

    CacheManagerFactory cmf = CacheManagerFactory.getInstance();

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        doPost(request,response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String res = "";
        String key = request.getParameter("key");

        Element element = cmf.getElement("userCache", "map");
        if(element == null){
            Map<String, String> map = new HashMap<String, String>();
            map.put(key, key);
            cmf.setElement("userCache", new Element("map", map));
        }else{
            Map<String, String> map = (Map<String, String>) element.getValue();
            res = map.get(key);
            if(res == null){
                map.put(key, key);
                // 多次测试发现,存在同名Element是,重复put的是无法复制的,因此当遇到两个节点同步不上的时候,先remove后put。 
                cmf.getCache("userCache").remove("map");
                cmf.setElement("userCache", new Element("map", map));
                res = "0;null";
            }
        }

        response.setContentType("text/html;charset=UTF-8");
        response.setCharacterEncoding("UTF-8");
        PrintWriter out = response.getWriter();
        out.write(res);
        out.close();
    }

    @Override
    public void init() throws ServletException {
        super.init();
    }

}

 

ehcache.xml:

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">

    <diskStore path="java.io.tmpdir" />

    <cacheManagerPeerProviderFactory 
        class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
        properties="peerDiscovery=manual,rmiUrls=//127.0.0.1:40002/userCache|//127.0.0.1:40002/resourceCache">
    </cacheManagerPeerProviderFactory>

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

    <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="30" timeToLiveSeconds="30" overflowToDisk="false"/>

    <cache 
        name="userCache" 
        maxElementsInMemory="10000" 
        eternal="true" 
        overflowToDisk="true" 
        timeToIdleSeconds="0" 
        timeToLiveSeconds="0"
        diskPersistent="false" 
        diskExpiryThreadIntervalSeconds="120">
        <cacheEventListenerFactory 
            class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" 
            properties="replicateAsynchronously=true,replicatePuts=true,replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true">    
        </cacheEventListenerFactory>
        <bootstrapCacheLoaderFactory
            class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"
            properties="bootstrapAsynchronously=true"> 
        </bootstrapCacheLoaderFactory>
    </cache>

    <cache 
        name="resourceCache" 
        maxElementsInMemory="10000" 
        eternal="true" 
        overflowToDisk="true" 
        timeToIdleSeconds="0" 
        timeToLiveSeconds="0"
        diskPersistent="false" 
        diskExpiryThreadIntervalSeconds="120">
        <cacheEventListenerFactory 
            class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" 
            properties="replicateAsynchronously=true,replicatePuts=true,replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true">    
        </cacheEventListenerFactory>
        <bootstrapCacheLoaderFactory
            class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"
            properties="bootstrapAsynchronously=true"> 
        </bootstrapCacheLoaderFactory>
    </cache>

</ehcache>

 

复制TestEhcache到 TestEhcache1, 改过TestEhcache1下的ehcache.xml ,只需求纠正cacheManagerPeerProviderFactory和cacheManagerPeerListenerFactory纠正为如下代码,别的不改变

<cacheManagerPeerProviderFactory 
        class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
        properties="peerDiscovery=manual,rmiUrls=//127.0.0.1:40001/userCache|//127.0.0.1:40001/resourceCache">
    </cacheManagerPeerProviderFactory>

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

为了不一样,将TestEhcache1的TesAction.doPost(卡塔尔国方法改过为如下代码,只get的缓存不put缓存,用于观望TestEhcache1是或不是能同步TestEhcache的数码:

String res = "0;null";
        Element element = cmf.getElement("userCache", "map");
        if(element != null){
            Map<String, String> map = (Map<String, String>) element.getValue();
            res = map.get(request.getParameter("key"));
            if(res == null){
                res = "0;null";
            }
        }
        response.setContentType("text/html;charset=UTF-8");
        response.setCharacterEncoding("UTF-8");
        PrintWriter out = response.getWriter();
        out.write(res);
        out.close();

将TestEhcache布署到tomcat1, TestEhcache1陈设到汤姆cat2。依次施行如下代码: 
localhost:8080/TestEhcache/test?key=125 
localhost:8080/TestEhcache/test?key=125 
localhost:8088/TestEhcache1/test?key=125 
如若出口内容分别如下,表达集群ok, 两节点数据同步没问题, 否者请留意检查陈设文件和TestAction代码: 
缓存集群,继续吐槽在net下没有合适的Disk。0;null 
125 
125

EhCache RMI 自动情势布署缓存 
将ehcache.xml的cacheManagerPeerProviderFactory代码改为:

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

 

mybatis 有自带的缓存,顶级缓存是session品级,二级缓存是namespace 。

The UpdatingCacheEntryFactory does work by modifying the contents of values in place in the cache. This is outside of the core of ehcache and is targeted at high performance CacheEntryFactories for SelfPopulatingCaches.

-Android连接数据库

Android平台下与服务器数据库通讯的不二法门首要有:
1、直接连接:在Android工程中引进jdbc驱动,接收驱动连接数据库;
缓存集群,继续吐槽在net下没有合适的Disk。2、直接连接:在服务器上用PHP DBMS做劳动器端,PHP将DBMS中的数据用JSON或然XML实行打包,然后将数据封装成接口,给Android平台回调。
 注意:接纳jdbc方法首要难题是安全性不高,何况只要须求拜望的数据过多,轻便出难点。其余,Android本身有对JSON恐怕XML数据直接深入解析的API,所以直接连接的措施更是可靠。

JDBC连接

JDBC是JavaData Base Connectivity的缩写,意思为“Java数据库连接”,由大器晚成组用Java语言编写的类和接口组成,为java层直接操作关系型数据库提供了标准的API。原理很简短,首假设先服务器DBMS发送SQL(布局化查询语言)指令。达成各个数据库的操作。
 在Android工程应用JDBC连接数据库的首要步骤:加载JDBC驱动程序------->创立连接--------->发送SQL语句。
 在项目中程导弹入jdbc驱动,然后在代码开头出import jdbc的包。
  创建链接:每一种DBMS的JDBC驱动是不相像的,同二个DBMS也是有三种JDBC驱动,如Microsoft SQL Server的JDBC驱动首要有三种,Microsoft 官方提供的JDBC驱动和民间开源的JDBC驱动(JTDS),推荐JTDS,bug少,况且是全然开放源代码的。前段时间JTDS只可以支持Microsoft SQL Server和Sybase。
 由于DBMS与JDBC驱动的例外,所以每一个JDBC连接数据库的字符串书写方式也是不等同的。 上边给出二种常见的JDBC与DBMS创设连接的字符串书写格式:

//1. MySQL(http://www.mysql.com)mm.mysql-2.0.2-bin.jar  
Connection con = null;  
Class.forName( "org.gjt.mm.mysql.Driver" );// 加载驱动程序  
con = DriverManager.getConnection( "jdbc:mysql://DbComputerNameOrIPAddr:3306/DatabaseName", UserName, Password );  
//2. PostgreSQL(http://www.de.postgresql.org)pgjdbc2.jar  
Connection con = null;  
Class.forName( "org.postgresql.Driver" );// 加载驱动程序  
con = DriverManager.getConnection( "jdbc:postgresql://DbComputerNameOrIPAddr/DatabaseName", UserName, Password );  
//3. Oracle(http://www.oracle.com/ip/deploy/database/oracle9i/)classes12.zip  
Connection con = null;  
Class.forName( "oracle.jdbc.driver.OracleDriver" );// 加载驱动程序  
con = DriverManager.getConnection( "jdbc:oracle:thin:@DbComputerNameOrIPAddr:1521:DatabaseName", UserName, Password );  
//4. Sybase(http://jtds.sourceforge.net)jconn2.jar  
Connection con = null;  
Class.forName( "com.sybase.jdbc2.jdbc.SybDriver" );// 加载驱动程序  
con = DriverManager.getConnection( "jdbc:sybase:Tds:DbComputerNameOrIPAddr:2638/DatabaseName", UserName, Password );  
//(Default-Username/Password: "dba"/"sql")  
//5. Microsoft SQLServer(http://jtds.sourceforge.net)  
Connection con = null;  
Class.forName( "net.sourceforge.jtds.jdbc.Driver" );// 加载驱动程序  
con = DriverManager.getConnection( "jdbc:jtds:sqlserver://DbComputerNameOrIPAddr:1433/DatabaseName", UserName, Password );   
//6. Microsoft SQLServer(http://www.microsoft.com)  
Connection con = null;  
Class.forName( "com.microsoft.jdbc.sqlserver.SQLServerDriver" );// 加载驱动程序  
con = DriverManager.getConnection( "jdbc:microsoft:sqlserver://DbComputerNameOrIPAddr:1433;databaseName=master", UserName, Password );

出殡SQL语句(以SQL server为例卡塔尔(قطر‎,当成功连接数据库之后,就可以发送操作数据的言辞并管理结果了。在发送SQL语句以前,首先要开创叁个statement对象,statement对象首要办事是把SQL语句发送到DBMS。然后发送SQL语句。对于SELECT操作,使用的是Statement对象的executeQuery(sql 卡塔尔(قطر‎方法,对于部分创制table和修正table的操作,使用的是Statement对象的executeUpdate(sql )方法。

//查询表名为“table_test”的所有内容  
String sql = "SELECT * FROM table_test";
//创建Statement 
Statement stmt = con.createStatement(); 
ResultSet rs = stmt.executeQuery(sql);  

接口回调

调用自个儿服务器接口重返的数量,供给提供服务器地址,然后经过网络通讯本领剖判服务器再次回到的数目。

EhCache Jgroups 格局配置缓存

在TestEhcache和TestEhcache1工程中增多ehcache-jgroupsreplication-1.7.jar和jgroups-3.6.9.Final.jar。 使用该方法比RMI方式布置轻松。

TestEhcache 的 ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.sf.net/ehcache.xsd">

    <diskStore path="java.io.tmpdir" />

    <cacheManagerPeerProviderFactory 
        class="net.sf.ehcache.distribution.jgroups.JGroupsCacheManagerPeerProviderFactory"
        properties="connect=TCP(bind_port=4001):
            TCPPING(initial_hosts=192.168.8.150[4001],192.168.8.150[4002];port_range=10;timeout=3000;num_initial_members=3):
            MERGE2(min_interval=3000;max_interval=5000):  
            FD_ALL(interval=5000;timeout=20000):  
            FD(timeout=5000;max_tries=48;):  
            VERIFY_SUSPECT(timeout=1500):  
            pbcast.NAKACK(retransmit_timeout=100,200,300,600,1200,2400,4800;discard_delivered_msgs=true):  
            pbcast.STABLE(stability_delay=1000;desired_avg_gossip=20000;max_bytes=0):  
            pbcast.GMS(print_local_addr=true;join_timeout=5000)"
        propertySeparator="::">
    </cacheManagerPeerProviderFactory>

    <defaultCache 
        maxElementsInMemory="10000" 
        eternal="true" 
        overflowToDisk="true" 
        timeToIdleSeconds="0" 
        timeToLiveSeconds="0"
        diskPersistent="false" 
        diskExpiryThreadIntervalSeconds="120">
        <cacheEventListenerFactory 
            class="net.sf.ehcache.distribution.jgroups.JGroupsCacheReplicatorFactory"
            properties="replicateAsynchronously=true,replicatePuts=true,replicateUpdates=true,replicateUpdatesViaCopy=false,replicateRemovals=true"/>
        <bootstrapCacheLoaderFactory
            class="net.sf.ehcache.distribution.jgroups.JGroupsBootstrapCacheLoaderFactory"
            properties="bootstrapAsynchronously=true"> 
        </bootstrapCacheLoaderFactory>
    </defaultCache>
</ehcache>

复制TestEhcache的ehcache.xml到TestEhcache1,并且改革下列代码:

connect=TCP(bind_port=4002)

推荐介绍随笔: 

 

来源:

一:背景

打开二级缓的瑕玷:1)唯有在多个namespace操作单表时利用,比方:user,和user_role两张表,如果user_role校正了,利用user的namespace去询问的结果就是脏数据。

ehcache 是线程安全的吗?
澳门新萄京官方网站,若是叁个频繁改良的表,会涉及到三十多线程,切合归入ehcache吗?(近来就是因为数据库IO压力过大,才想归入缓存卡塔尔(قطر‎

-Android图片管理、图片缓存机制

谈到图片管理,大家得注重学习一下多少个类:Bitmap、BitmapFactory。
Bitmap
 Bitmap是Android系统中的图像管理的最关键类之生龙活虎。用它能够收获图像文件消息,进行图像剪切、旋转、缩放等操作,并能够钦定格式保存图像文件。

重大函数

public void recycle() // 回收位图占用的内存空间,把位图标记为Dead
public final boolean isRecycled() //判断位图内存是否已释放  
public final int getWidth()//获取位图的宽度 
public final int getHeight()//获取位图的高度
public final boolean isMutable()//图片是否可修改 
public int getScaledWidth(Canvas canvas)//获取指定密度转换后的图像的宽度 
public int getScaledHeight(Canvas canvas)//获取指定密度转换后的图像的高度 
public boolean compress(CompressFormat format, int quality, OutputStream stream)//按指定的图片格式以及画质,将图片转换为输出流。 
format:Bitmap.CompressFormat.PNG或Bitmap.CompressFormat.JPEG 
quality:画质,0-100.0表示最低画质压缩,100以最高画质压缩。对于PNG等无损格式的图片,会忽略此项设置。
public static Bitmap createBitmap(Bitmap src) //以src为原图生成不可变得新图像 
public static Bitmap createScaledBitmap(Bitmap src, int dstWidth, int dstHeight, boolean filter)//以src为原图,创建新的图像,指定新图像的高宽以及是否可变。 
public static Bitmap createBitmap(int width, int height, Config config)——创建指定格式、大小的位图 
public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height)以source为原图,创建新的图片,指定起始坐标以及新图像的高宽。

BitmapFactory

 Option 参数类:
public boolean inJustDecodeBounds//如果设置为true,不获取图片,不分配内存,但会返回图片的高度宽度信息。
public int inSampleSize//图片缩放的倍数
public int outWidth//获取图片的宽度值
public int outHeight//获取图片的高度值 
public int inDensity//用于位图的像素压缩比 
public int inTargetDensity//用于目标位图的像素压缩比(要生成的位图) 
public byte[] inTempStorage //创建临时文件,将图片存储
public boolean inScaled//设置为true时进行图片压缩,从inDensity到inTargetDensity
public boolean inDither //如果为true,解码器尝试抖动解码
public Bitmap.Config inPreferredConfig //设置解码器
public String outMimeType //设置解码图像
public boolean inPurgeable//当存储Pixel的内存空间在系统内存不足时是否可以被回收
public boolean inInputShareable //inPurgeable为true情况下才生效,是否可以共享一个InputStream
public boolean inPreferQualityOverSpeed  //为true则优先保证Bitmap质量其次是解码速度
public boolean inMutable //配置Bitmap是否可以更改,比如:在Bitmap上隔几个像素加一条线段
public int inScreenDensity //当前屏幕的像素密度

工厂方法:
public static Bitmap decodeFile(String pathName, Options opts) //从文件读取图片 
public static Bitmap decodeFile(String pathName)
public static Bitmap decodeStream(InputStream is) //从输入流读取图片
public static Bitmap decodeStream(InputStream is, Rect outPadding, Options opts)
public static Bitmap decodeResource(Resources res, int id) //从资源文件读取图片
public static Bitmap decodeResource(Resources res, int id, Options opts) 
public static Bitmap decodeByteArray(byte[] data, int offset, int length) //从数组读取图片
public static Bitmap decodeByteArray(byte[] data, int offset, int length, Options opts)
public static Bitmap decodeFileDescriptor(FileDescriptor fd)//从文件读取文件 与decodeFile不同的是这个直接调用JNI函数进行读取 效率比较高

枚举变量 (位图位数越高代表其可以存储的颜色信息越多,图像越逼真,占用内存越大)
public static final Bitmap.Config ALPHA_8 //代表8位Alpha位图        每个像素占用1byte内存
public static final Bitmap.Config ARGB_4444 //代表16位ARGB位图  每个像素占用2byte内存
public static final Bitmap.Config ARGB_8888 //代表32位ARGB位图  每个像素占用4byte内存
public static final Bitmap.Config RGB_565 //代表8位RGB位图          每个像素占用2byte内存

​ Android中一张图纸(BitMap)占用的内部存款和储蓄器主要和以下多少个因数有关:图片长度,图片宽度,单位像素占用的字节数。一张图纸(BitMap)占用的内部存款和储蓄器= 图片长度 ** 图片宽度 * * 单位像素占用的字节数。

上面罗列多少个常用艺术的详实介绍:

/**
     * 获取缩放后的本地图片
     *
     * @param filePath 文件路径
     * @param width    宽
     * @param height   高
     * @return
     */
    public static Bitmap readBitmapFromFileDescriptor(String filePath, int width, int height) {
        try {
            FileInputStream fis = new FileInputStream(filePath);
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFileDescriptor(fis.getFD(), null, options);
            float srcWidth = options.outWidth;
            float srcHeight = options.outHeight;
            int inSampleSize = 1;

            if (srcHeight > height || srcWidth > width) {
                if (srcWidth > srcHeight) {
                    inSampleSize = Math.round(srcHeight / height);
                } else {
                    inSampleSize = Math.round(srcWidth / width);
                }
            }

            options.inJustDecodeBounds = false;
            options.inSampleSize = inSampleSize;

            return BitmapFactory.decodeFileDescriptor(fis.getFD(), null, options);
        } catch (Exception ex) {
        }
        return null;
    }

/**
     * 将图片保存至文件
     *
     * @param filePath 文件路径
     * @param b    bitmap图片对象
     * @param quality   图片画质
     */
     public static void writeBitmapToFile(String filePath, Bitmap b, int quality) {
        try {
            File desFile = new File(filePath);
            FileOutputStream fos = new FileOutputStream(desFile);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            b.compress(Bitmap.CompressFormat.JPEG, quality, bos);
            bos.flush();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

/**
     * 图片压缩
     *
     * @param image 压缩的图片对象
     * @return 返回bitmap对象
     */
private static Bitmap compressImage(Bitmap image) {
        if (image == null) {
            return null;
        }
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
            byte[] bytes = baos.toByteArray();
            ByteArrayInputStream isBm = new ByteArrayInputStream(bytes);
            Bitmap bitmap = BitmapFactory.decodeStream(isBm);
            return bitmap;
        } catch (OutOfMemoryError e) {
        } finally {
            try {
                if (baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
            }
        }
        return null;
    }

/**
     * 图片旋转角度
     *
     * @param b 旋转的图片对象
     * @param rotateDegree 旋转角度
     * @return 返回bitmap对象
     */
private static Bitmap rotateBitmap(Bitmap b, float rotateDegree) {
        if (b == null) {
            return null;
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(rotateDegree);
        Bitmap rotaBitmap = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), matrix, true);
        return rotaBitmap;
    }

三级图片缓存机制
  在开采安卓应用中防止不了要使用到互联网图片,获取网络图片很简短,可是急需交给一定的代价—流量。对于个其他图片来说难点一点都不大,但万一手提式有线电话机使用中饱含大量的图形,那势必会耗成本户的必然流量,借使大家不加以管理,每一次张开应用都去互联网获得图片,客商可就不乐意了,所以大家得用三级缓存战略(缓存层分为三层:内部存款和储蓄器层,磁盘层,网络层),纵然内部存款和储蓄器依旧本地球磁性盘中已持有需图片,就不用通过互联网层获取图片,收缩流量的消耗。
 关于缓存层的办事,当大家第贰回张开应用获取图片时,先到网络去下载图片,然后挨家挨户存入内部存款和储蓄器缓存,磁盘缓存,当大家再叁次索要使用刚才下载的那张图纸时,就不需求再另行的到网络上去下载,直接能够从内部存款和储蓄器缓存和磁盘缓存中找,由于内部存款和储蓄器缓存速度非常的慢,我们先行到内部存款和储蓄器缓存中搜索该图片,假诺找到则选择,若无找到(内部存款和储蓄器缓存大小有限),那么大家再到磁盘缓存中去找。只要大家创建的去和煦那三层缓存运用,便能够进级利用品质和客户体验。
1、内部存款和储蓄器层:(手提式有线电话机内部存款和储蓄器)
 内部存款和储蓄器缓存相对于磁盘缓存来讲,速度要来的快非常多,但短处容积十分的小且会被系统回笼,这里的兑现本身使用了LruCache。
LruCache那么些类是Android3.1本子中提供的,倘令你是在更早的Android版本中支出,则供给导入android-support-v4的jar包。
2、磁盘层:(SD卡)
 相比较内部存储器缓存来讲速度要来得慢比较多,但容积很大,这里的达成自个儿动用了DiskLruCache类。
DiskLruCache是非谷歌(Google卡塔尔国官方编写,但拿到合法证实的硬盘缓存类,该类未有节制在Android内,所以理论上java应用也足以选拔DiskLreCache来缓存。
 那是DiskLruCache类的下载地址:http://pan.baidu.com/s/1o6tPjz8
3、互联网层:(移动网络,有线网络)
 那个就没怎么解释的了,就是大家上网用的流量。网络访谈完毕能够用开源框架Volley。
 开源框架Volley是二零一三年GoogleI/O大会发表的,Volley是Android平台上的网络通讯库,能使互联网通讯更加快,更简便,越来越壮。它的安排指标正是非常相符去举行数据量相当的小,但通讯频仍的互连网操作,而对此大数据量的网络操作,举例说下载文件等,Volley的显现就能非凡倒霉。
 那是Volley的下载地址:http://pan.baidu.com/s/1kThedX9

  事情是这么的,近些日子的叁个种类中,必要在web端绘制一些表格,因为表格的底子数据源都以全内部存款和储蓄器式的,所以内部存款和储蓄器相对大家的话是相比恐慌的,大家兴许

         2)在创新个中一条的时候,整个namespace都会被刷新。大家实际领悟如若刷新一条就好。

ehcache查找时key:ID,那么只要我不是以ID为查询条件的话,是或不是就没有使用到缓存,
诸如:作者用电话号码来查询顾客,开掘缓存就好像并未行使,怎么着才干一蹴而就此难点?

-数组和链表的区分

数组布局在通过索引进行查询数据实效用比较高,而对此数组插入和删除操作,则效用会好低,在第叁个职分张开插队数据,其他数据就须要各个向后运动,而首先个数据开展删减,则需求有所数据总体迈入移。
  链表:为了保证数据插入和删除,不会影响此外数据的运动,有限扶持线性费用,就引出了指针链接,链表是由一花样繁多节点组成的,每种节点都会有叁个链点,next链,next链会施行下一个node的援引,所以大家在插入可能去除的时候,供给链表next链的指向地址就可以,种种节点不须要内部存款和储蓄器实行连接存款和储蓄,那样会减小删除和插入的线性开销。链表构造首要分为三种链表,单向链表和双向链表 ,即单向链表唯有二个next链,而双向链表会有next链和pre链。
 简单的差别如下:
①数组静态分配内存,链表动态分配内部存款和储蓄器;②数组在内部存款和储蓄器中连连,链表不总是;③数组成分在栈区,链表成分在堆区;④数组利用下标定位,时间复杂度为O(1卡塔尔,链表定位成分时间复杂度O(n卡塔尔(英语:State of Qatar);⑤数组插入或删除成分的时刻复杂度O(n卡塔尔(英语:State of Qatar),链表的时日复杂度O(1卡塔尔。
​  数组:
​ 优点:使用方便 ,查询成效比链表高,内部存款和储蓄器为意气风发老是的区域 。 劣势:大小固定,不相符动态积攒,不方便人民群众动态增加。
 链表:
​ 优点:可动态增进删减,大小可变。 劣点:只可以通过逐个指针访谈,查询功能低。

后言
 有怎样狼狈的地点还望多多帮助,也接待大家关心自个儿(简书/GitHub)
多谢观望此文!

我们精晓,举例有的散点图,那种类型的表格数量丰盛的多,为了加速,笔者索要缓存三种多少:

民用感觉业务层自个儿调节会相比好。

Ehcache的类等级次序模型首要为三层,最上层的是CacheManager,那是操作Ehcache的入口。
能够由此CacheManager.getInstance(卡塔尔(英语:State of Qatar)得到贰个单子的CacheManger,大概通过CacheManger的布局函数创造二个新的CacheManger。
各类CacheManager都管理着多少个Cache。
各种Cache都以生机勃勃种类Hash的办法,关联着多少个Element。而Element则是大家用来寄存要缓存内容的地点。
在配置EhCache前要求引进多少个开垦包:ehcache-1.3.0.jar和commons-logging-1.04.jar

 

本人当下项目中碰着2种情状,

Cache的安插很利索,官方提供的Cache配置方式有好三种。你能够经过注解配置、在xml中配备、在程序里布署大概调用布局方法时传出差异的参数。
您能够将Cache的布局从代码中分离出来,也足以在行使运维时计划,所谓的运转时布置无非也正是在代码中配置。以下是运作时安插的实惠:
在同贰个地方安插全部的Cache,那样十分轻松管理Cache的内部存款和储蓄器和磁盘消耗。
公布时可改正Cache配置。
可再设置阶段就反省出布局错误消息,而防止了运维时不当。

1. 基于功底数据源总结出中间结果,为了下一次加速,缓存个几十分钟,那些数据量相对来讲一点都十分大。

1)业务只询问这段日子半个小时的多寡,数据平常更新,不断会有数量插入。就是局地不时的习性数据。

CacheManager配置
DmulticastGroupPort=4446,那样能够安插监听端口。

2. 将劳动的Response进行30分钟缓存,这些数据量也针锋相投超大,大致10-50M的标准。

方案:给个ehcache,保存如今半小时的多寡,设置依期职务,把前边的数据批量入库。查询优先在缓存中进行。

DiskStore配置
只要您使用的DiskStore(磁盘缓存),你必供给安顿DiskStore配置项。如若不安顿,Ehcache将会利用java.io.tmpdir。
diskStroe的“path”属性是用来结构磁盘缓存使用的物理路线的,Ehcache磁盘缓存使用的公文后缀名是.data和.index。
<disStore path=”java.io.tmpdir”/>

 

2)数据库的数目是配置型的,比如客商的个人消息,然后多少个地点需求用到。况兼动用的频率都非常的大。

name:Cache的独步一时标记
maxElementsInMemory:内部存款和储蓄器中最大缓存对象数。
maxElementsOnDisk:磁盘中最大缓存对象数,倘使0代表无穷大。
eternal:Element是或不是永远有效,风华正茂但设置了,timeout将不起作用。
overflowToDisk:配置此属性,当内部存款和储蓄器中Element数量抵达maxElementsInMemory时,Ehcache将会Element写到磁盘中。
timeToIdleSeconds:设置Element在失效前的同意闲置时间。仅当element不是长久有效时使用,可选属性,暗中认可值是0,也正是可闲置时间无穷大。 timeToLiveSeconds:设置Element在失效前允许存活时间。最大时间介于创立时间和失灵时间里面。仅当element不是世代有效时选用,暗中同意是0.,也正是element存活时间无穷大。
diskPersistent:是或不是缓存设想机重启期数据。(这一个设想机是指什么虚拟机向来没看驾驭是何等,有哲人还期望能辅导生机勃勃二)。
diskExpiryThreadIntervalSeconds:磁盘失效线程运营时刻间隔,暗中认可是120秒。
diskSpoolBufferSizeMB:那些参数设置DiskStore(磁盘缓存)的缓存区大小。暗中同意是30MB。每种Cache都应当有温馨的叁个缓冲区。
memoryStoreEvictionPolicy:当达到maxElementsInMemory约束时,Ehcache将会依据钦赐的国策去清理内部存款和储蓄器。暗中认可计策是LRU(前段时间起码使用)。
你能够安装为FIFO(先进先出)或是LFU(少之甚少使用)。这里相比较可惜,Ehcache并从未提供叁个客商定制攻略的接口,仅仅补助三种钦命计策,以为做的相当不够美丽。

      刚才也说了,内部存款和储蓄器相比较吃紧,假诺把这几个数量再停放内部存款和储蓄器里面就相比较难堪,也是事情分裂意的,假若把如此大的数据块放在遍及式缓存中,流量起来现在带

方案:业务层使用ehcache和mybatis 缓存。当然,你也能够独自写八个ehcache缓存类来操作这些缓存。然后趁着业务的叠合,感觉好多表的数目都必要那类缓存的时候,你就开头思索人生了。

宽也是叁个标题,会更加多的直面超时的风险,所以最棒的艺术就是应用本机磁盘缓存,那样就足以在性质和内部存款和储蓄器中取二个平衡点~~~

 

安插文件
例子:ehcache.xml

 

独自写ehcache类,保存数据。

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <defaultCache maxElementsInMemory="2" eternal="false"
                  timeToIdleSeconds="1" timeToLiveSeconds="1" overflowToDisk="false"
                  memoryStoreEvictionPolicy="LRU"/>
    <cache name="sampleCache1" maxElementsInMemory="5" eternal="false"
           overflowToDisk="false" timeToIdleSeconds="1" timeToLiveSeconds="1"
           memoryStoreEvictionPolicy="LRU">
    </cache>
</ehcache>

二:寻觅解决方案

spring-boot mybaits ehcache (缓存申明,你想放哪儿就哪个地方。假若考虑参预直接退换数据库,写个后门,直接刷新缓存,注意安全!)

注:
在ehcache的布局文件之中必得配备defaultCache。
种种<cache>标签定义贰个新的cache,属性的意义基本上能够从名字上获得,详细的辨证能够参照上边的链接。

  

maven构建。

所以使用EHCache大致的步骤为: 
第一步:生成CacheManager对象 
第二步:生成Cache对象 
其三步:向Cache对象里增加由key,value组成的键值对的Element成分 
事必躬亲程序:
例子:

           平衡点找到了,貌似在.net领域中非常少据他们说有磁盘缓存这种概念,既然据他们说的少,那就在nuget中浪风流倜傥浪,然后就找到了叁个top1的diskcache,如下图:

首要正视的包(具体版本按最新的来)

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import java.util.List;

/**
 * Created by MyWorld on 2016/1/20.
 */
public class EHCacheDemo {
    public static void main(String[] args) {
        CacheManager manager = new CacheManager("ehcache.xml");
        Cache cache = manager.getCache("sampleCache1");
        for (int i = 0; i < 6; i  ) {
            Element e = new Element("key"   i, "value"   i);
            cache.put(e);
        }

        List keys = cache.getKeys();
        for (Object key : keys) {
            System.out.println(key   ","   cache.get(key));
        }
    }
}

 

    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
      <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
    </dependency>        

注:程序的流程也是比较清楚的,首先是得到一个CacheManager,那是使用Ehcache的输入,然后经过名字获取有个别Cache,然后就可以对Cache存取Element。Cache使用类Hash的点子来管理Element。
事件管理
证实:可以为CacheManager加多风波监听,当对CacheManager增加和删除Cache时,事件微型机将会拿到布告。要布局事件管理,须要经过ehcache的布局文件来成功。
配备文件:ehcache.xml

澳门新萄京官方网站 3

 

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <defaultCache maxElementsInMemory="2" eternal="false"
                  timeToIdleSeconds="1" timeToLiveSeconds="1" overflowToDisk="false"
                  memoryStoreEvictionPolicy="LRU"/>
    <cache name="sampleCache1" maxElementsInMemory="5" eternal="false"
           overflowToDisk="false" timeToIdleSeconds="1" timeToLiveSeconds="1"
           memoryStoreEvictionPolicy="LRU">
        <cacheEventListenerFactory class="ehcache.test.CELF"/>
    </cache>
</ehcache>

 

ehcache.xml配置

 

拉下来生机勃勃测量试验,卧槽,就的一个CUGL450D操作,连TTL和TTI的效劳都未有,还要捐啥比特币,O(∩_∩)O

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
    updateCheck="false">
    <diskStore path="user.dir/sqlEhCache" />

    <defaultCache eternal="false" maxElementsInMemory="1000"
        overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"
        timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU" />

    <cache name="baseCache" eternal="true" maxElementsInMemory="1000" maxElementsOnDisk="10000"
        overflowToDisk="true" diskPersistent="false" timeToIdleSeconds="0"
        timeToLiveSeconds="300" memoryStoreEvictionPolicy="LRU" />

</ehcache>

注:通过<cacheManagerEventListenerFactory>来注册事件微型机的厂子类。
代码:
package ehcache.test;
import java.util.Properties;
import net.sf.ehcache.CacheException;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;
import net.sf.ehcache.event.CacheEventListener;
import net.sf.ehcache.event.CacheEventListenerFactory;
public class CELF extends CacheEventListenerFactory {
@Override
public CacheEventListener createCacheEventListener(Properties properties) {
return new CEL();
}
}
class CEL implements CacheEventListener {
public void dispose() {}
public void notifyElementEvicted(Ehcache cache, Element element) {}
public void notifyElementExpired(Ehcache cache, Element element) {}
public void notifyElementPut(Ehcache cache, Element element)
throws CacheException {
System.out.println(element.getKey() " was added.");
}
public void notifyElementRemoved(Ehcache cache, Element element)
throws CacheException {
System.out.println(element.getKey() " was removed.");
}
public void notifyElementUpdated(Ehcache cache, Element element)
throws CacheException {}
public void notifyRemoveAll(Ehcache cache) {}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
注:这里的代码与从前的相通,一言以蔽之Ehcache的事件管理采纳的是后生可畏体系plugin方式,约等于说,事件管理的丰富是以不改进源代码为前提的。

澳门新萄京官方网站 4

 

 

 

  1. EHCache 的风味,是二个纯Java ,进度中(也能够领悟成插入式)缓存完结,单独安装Ehcache ,需把ehcache-X.X.jar 和有关类库方到classpath中。
    如项目已设置了Hibernate ,则不须要做哪些。。直接可以采纳Ehcache 
    Cache 存款和储蓄格局 :内存或磁盘 

  2. 单身选拔 EHCache 

既然net下并未什么好的化解方案,目光只可以投到java下边看看,非常快就找到了ehCache,看下官方证实挺牛叉的,到场方式依旧和上意气风发篇同样,使用thrift做C#

(1卡塔尔(英语:State of Qatar).diskStore: 为缓存路线,ehcache分为内部存款和储蓄器和磁盘两级,此属性定义磁盘的缓存地点。参数解释如下:    
             user.home – 客户主目录
             user.dir  – 顾客当前工作目录
             java.io.tmpdir – 私下认可有时文件路线

接收CacheManager 成立并拘系Cache 
1).创建CacheManager有4种方式: 

和Java之间的人机联作媒介就足以了。(thrift的实际使用办法,大致能够倾心意气风发篇)如下图:

  (2卡塔尔(英语:State of Qatar).defaultCache:暗许缓存战术,当ehcache找不到定义的缓存时,则利用那个缓存计策。只好定义三个。

A:使用暗许配置文件创立 
CacheManager manager = CacheManager.create();  

澳门新萄京官方网站 5 

       (3卡塔尔(قطر‎.cache:自定缓存战术,为自定义的缓存计策。参数解释如下:

B:使用内定布置文件创立 
CacheManager manager = CacheManager.create("src/config/ehcache.xml"卡塔尔(英语:State of Qatar);  //那么些门路的写法是eclipse中的格式。源码是通过new File的措施来开始化配置文件

三:Ehcache的配置

cache成分解释:

C:从classpath中搜索配置文件并创办 

  1. maven的ehcache地址

          <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
          <dependency>
              <groupId>org.ehcache</groupId>
              <artifactId>ehcache</artifactId>
              <version>3.5.2</version>
         </dependency>
    

cache成分的属性:

URL url = getClass().getResource("/anothername.xml");
CacheManager manager = CacheManager.create(url);

 

name:缓存名称

D:通过输入流创制

ehcache的官方网址:http://www.ehcache.org/ ,大家能够回顾领悟下,具体采纳官方都多少samples,在DBEngines上的排名也仍旧十分不易的。

maxElementsInMemory:内部存款和储蓄器中最大缓存对象数

InputStream fis = new FileInputStream(new File("src/config/ehcache.xml").getAbsolutePath());
try {
manager = CacheManager.create(fis);
} finally {
fis.close();
}

澳门新萄京官方网站 6

maxElementsOnDisk:硬盘中最大缓存对象数,若是0代表无穷大

卸载CacheManager ,关闭Cache 
manager.shutdown();    

 

eternal:true表示对象无须过期,那时候会忽视timeToIdleSeconds和timeToLiveSeconds属性,暗中认可为false

2)使用Caches

  1. 运用全代码模式的安顿

overflowToDisk:true表示当内部存款和储蓄器缓存的靶子数目到达了

拿到配置文件中优先 定义的sampleCache1设置,通过CacheManager生成三个Cache
Cache cache = manager.getCache("sampleCache1");  
设置三个名叫test 的新cache,test属性为暗许 

 

maxElementsInMemory界限后,会把溢出的指标写到硬盘缓存中。注意:假使缓存的靶子要写入到硬盘中的话,则该指标必需完结了Serializable接口才行。

CacheManager manager = CacheManager.create();
manager.addCache("test");

         接下来就可以写风流洒脱段代码测验一下,向diskcache中插入10000个字符大小的cache,插入1000次,看看功效怎么着,代码如下:

diskSpoolBufferSizeMB:磁盘缓存区大小,默以为30MB。种种Cache都应有有温馨的一个缓存区。

安装多少个名叫test 的新cache,并定义其属性 

public class App {
    public static void main(String[] args) throws CachePersistenceException {

        LocalPersistenceService persistenceService = new DefaultLocalPersistenceService(
                new DefaultPersistenceConfiguration(new File("C:\1\cache")));

        PersistentUserManagedCache<String, String> cache = UserManagedCacheBuilder
                .newUserManagedCacheBuilder(String.class, String.class)
                .with(new UserManagedPersistenceContext<String, String>("persistentCache", persistenceService))
                .withResourcePools(ResourcePoolsBuilder.newResourcePoolsBuilder().disk(10L, MemoryUnit.GB, true))
                .withExpiry(Expirations.timeToLiveExpiration(Duration.of(30, TimeUnit.MINUTES))).build(true);

        StringBuilder sBuilder = new StringBuilder();
        for (int i = 1; i < 10000; i  ) {
            sBuilder.append(i);
        }

        long startTime = System.currentTimeMillis(); // 获取开始时间

        for (int i = 1; i < 1000; i  ) {
            String key = "username"   i;
            String value = sBuilder.toString();
            cache.put(key, value);
            System.out.println(String.format("%s:当前key=%s插入到缓存中", i, key));
        }

        long endTime = System.currentTimeMillis(); // 获取结束时间

        System.out.println("程序运行时间: "   (endTime - startTime)   "ms");
    }
}

diskPersistent:是不是缓存虚构机重启期数据,是或不是持久化磁盘缓存,当以此性情的值为true时,系统在初步化时会在磁盘中查找文件名字为cache名称,后缀名叫index的公文,那几个文件中寄放了意气风发度长久化在磁盘中的cache的index,找到后会把cache加载到内部存款和储蓄器,要想把 cache真正长久化到磁盘,写程序时只顾推行net.sf.ehcache.Cache.put(Element element卡塔尔国后要调用flush(卡塔尔(英语:State of Qatar)方法。

CacheManager manager = CacheManager.create();
Cache cache = new Cache("test", 1, true, false, 5, 2);
manager.addCache(cache);

 

diskExpiryThreadIntervalSeconds:磁盘失效线程运维时刻间距,默以为120秒

往cache中踏向元素 

澳门新萄京官方网站 7

timeToIdleSeconds: 设定允许对象处于空闲状态的最长日子,以秒为单位。当对象自从近日一遍被访谈后,要是处在空闲状态的年月当先了timeToIdleSeconds属性 值,那几个目的就可以晚点,EHCache将把它从缓存中清空。独有当eternal属性为false,该属性才使得。要是该属性值为0,则代表对象足以Infiniti制期限地处于空闲状态

Element element = new Element("key1", "value1");
cache.put(new Element(element);

澳门新萄京官方网站 8

timeToLiveSeconds:设定目的允许存在于缓存中的最长日子,以秒为单位。当目的自从被寄放到缓存中后,假若处在缓存中的时间超过了 timeToLiveSeconds属性值,这一个指标就能够晚点,EHCache将把它从缓存中革除。唯有当eternal属性为false,该属性才有 效。若是该属性值为0,则象征对象足以Infiniti制时间地存在于缓存中。timeToLiveSeconds必须当先timeToIdleSeconds属性,才有 意义

从cache中赢得元素
Element element = cache.get("key1");  
 

 

memoryStoreEvictionPolicy:当达到maxElementsInMemory约束时,Ehcache将会依照钦定的国策去清理内部存款和储蓄器。可选战术有:LRU(最近起码使用,默许战术)、FIFO(先进先出)、LFU(起码访谈次数)。

采纳Cache实例来支配缓存了,首要的不二秘诀是:
Cache.get(Object key),
Cache.put(new Element(Object key, Object value)),
Cache.remove(Object key)。  

进度大概是600多皮秒,时间也许能够选择的,在自己的品种中也是比较相符的。

spring-boot注入,该java代码主假如依附配置生成cache

 

   

package com.configure;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
//标注启动了缓存
@EnableCaching
public class CacheConfiguration {

 /*
  * ehcache 主要的管理器
  */
 @Bean(name = "appEhCacheCacheManager")
 public EhCacheCacheManager ehCacheCacheManager(EhCacheManagerFactoryBean bean){
     return new EhCacheCacheManager (bean.getObject ());
 }

 /*
  * 据shared与否的设置,Spring分别通过CacheManager.create()或new CacheManager()方式来创建一个ehcache基地.
  */
 @Bean
 public EhCacheManagerFactoryBean ehCacheManagerFactoryBean(){
     EhCacheManagerFactoryBean cacheManagerFactoryBean = new EhCacheManagerFactoryBean ();
     cacheManagerFactoryBean.setConfigLocation (new ClassPathResource ("ehcache.xml"));
     cacheManagerFactoryBean.setShared (true);
     return cacheManagerFactoryBean;
 }
}

         当然也足以行使xml的方法动态配置ehcache,可能采取spring data来集成那个ehcache都以能够的,因为根本用java来打补助,就不现实浓重介绍了,

 

好了,本篇就说这么多吗,希望对你有救助。

然后选拔申明,能够在你想要的地点使用缓存,注意就算有缓存了,就不会走原本的法子。

 

public interface TransformerDao {
   /**
     *删除该value下的所有缓存,整个都刷新
     * @param stationOid
     * @return
     */
    @Caching(evict={@CacheEvict(value="baseCache",allEntries=true)})
    public int deleteByStationOid(@Param("stationOid") String stationOid);
  /**
     * 查询该充电桩所属变压群(器)信息
     * 
     * @param pileOid
     * @return
     */
    @Cacheable(value="baseCache", key = "#p0")
    public Transformer queryTransformerByPileOid(
            @Param("pileOid") String pileOid);

}

关于@Cacheable、@CachePut和@CacheEvict介绍,参考:

有八个坑,正是不可能平昔运用 参数名作为key

只得使用  #p 这种方式

切切实实原因参照他事他说加以考察:

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:缓存集群,继续吐槽在net下没有合适的Disk

关键词: