澳门新浦京娱乐场网站-www.146.net-新浦京娱乐场官网
做最好的网站

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

  

花色中需求使用一些查询,数据的改换相当少但查询度异常的大。有的时候依然按频率查询的。

 

图片 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)? 
• 选择什么样办法张开复制?同步还是异步格局?

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 – 监听器监听的端口。 
socket提姆eoutMillis (可选) – 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:内部存款和储蓄器数量最大时是还是不是清除。 
缓存子成分: 
  cacheEventListenerFactory:注册相应的的缓存监听类,用于拍卖缓存事件,如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代码: 
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驱动,选择驱动连接数据库;
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);⑤数组插入或删除成分的岁月复杂度O(n),链表的小时复杂度O(1)。
​  数组:
​ 优点:使用方便 ,查询作用比链表高,内部存款和储蓄器为一老是的区域 。 劣点:大小固定,不切合动态积存,不便利动态增进。
 链表:
​ 优点:可动态拉长删减,大小可变。 缺点:只好通过每种指针访谈,查询功能低。

后言
 有怎么着狼狈的地方还望多多支持,也应接大家关心自小编(简书/GitHub)
多谢观望此文!

世家掌握,举个例子有的散点图,那种类型的表格数量不少,为了加速,笔者急需缓存二种多少:

村办以为业务层本身主宰会比较好。

Ehcache的类档案的次序模型主要为三层,最上层的是CacheManager,那是操作Ehcache的输入。
能够通过CacheManager.getInstance()获得贰个单子的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配置

 

拉下来一测验,卧槽,就的多个CUENCORED操作,连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).diskStore: 为缓存路线,ehcache分为内部存款和储蓄器和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:    
             user.home – 顾客主目录
             user.dir  – 顾客当前工作目录
             java.io.tmpdir – 暗许有的时候文件路线

动用CacheManager 制造并管理Cache 
1).创建CacheManager有4种方式: 

和Java之间的竞相媒介就足以了。(thrift的有血有肉行使格局,差没多少能够倾心一篇)如下图:

  (2).defaultCache:私下认可缓存计谋,当ehcache找不到定义的缓存时,则运用那么些缓存计策。只可以定义二个。

继续吐槽在net下没有合适的Disk,缓存集群。A:使用暗中同意配置文件创制 
CacheManager manager = CacheManager.create();  

图片 5 

       (3).cache:自定缓存计谋,为自定义的缓存计谋。参数解释如下:

B:使用指虞升卿插文件创设 
CacheManager manager = CacheManager.create("src/config/ehcache.xml");  //这一个门路的写法是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,插入一千次,看看功用怎么着,代码如下:

diskSpoolBufferSizeMB:磁盘缓存区大小,默感到30MB。每一个Cache都应当有友好的多个缓存区。

继续吐槽在net下没有合适的Disk,缓存集群。安装二个名称为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()方法。

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,则意味对象足以无有效期地处于空闲状态

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.146.net,转载请注明出处:继续吐槽在net下没有合适的Disk,缓存集群