ehcache完毕赶快查询,继续戏弄在net下并未有适当的Disk

By admin in 4858.com on 2019年5月7日

  

项目中需求运用一些查询,数据的修改很少但查询度极大。有时依然按频率查询的。

 

4858.com 1

         谈到缓存,我们恐怕口如悬河,各体系型的缓存都能挨个分析,但在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完毕赶快查询,继续戏弄在net下并未有适当的Disk。 

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平台下与服务器数据库通讯的方法首要有:
一、直接连接:在Android工程中引进jdbc驱动,选用驱动连接数据库;
二、直接连接:在服务器上用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);  

接口回调

调用本身服务器接口再次来到的数据,须要提供服务器地址,然后通过网络通讯本领分析服务器重临的数量。

一:背景

翻开二级缓的老毛病:壹)唯有在二个namespace操作单表时接纳,比如:user,和user_role两张表,如果user_role修改了,利用user的namespace去查询的结果正是脏数据。

ehcache 是线程安全的吧?
假诺二个反复修改的表,会涉嫌到多线程,适合放入ehcache吗?(近日便是因为数据库IO压力过大,才想放入缓存)

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

聊起图片管理,大家得重点学习一下五个类:Bitmap、BitmapFactory。
Bitmap
 Bitmap是Android系统中的图像管理的最要害类之1。用它能够博得图像文件新闻,进行图像剪切、旋转、缩放等操作,并能够钦赐格式保存图像文件。

第2函数

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那一个类是Android三.壹本子中提供的,假设您是在更早的Android版本中付出,则要求导入android-support-v四的jar包。
2、磁盘层:(SD卡)
 相比较内部存款和储蓄器缓存来讲速度要来得慢好多,但体量非常的大,这里的落到实处笔者利用了DiskLruCache类。
DiskLruCache是非谷歌官方编写,但收获官方认证的硬盘缓存类,该类未有限制在Android内,所以理论上java应用也得以应用DiskLreCache来缓存。
 那是DiskLruCache类的下载地址:http://pan.baidu.com/s/1o6tPjz8
三、网络层:(移动网络,有线互联网)
 那些就没怎么解释的了,正是大家上网用的流量。网络访问实现能够用开源框架Volley。
 开源框架Volley是20一三年谷歌I/O大会公布的,Volley是Android平台上的互联网通讯库,能使网络通讯更快,更轻便,更健康。它的宏图目标就是万分适合去开始展览数据量非常小,但通讯频仍的互联网操作,而对于大数据量的互联网操作,比如说下载文件等,Volley的展现就能够那多少个倒霉。
 那是Volley的下载地址:http://pan.baidu.com/s/1kThedX9

  事情是这么的,近期的一个品种中,须要在web端绘制一些表格,因为表格的功底数据源都以全内部存款和储蓄器式的,所以内部存储器相对大家的话是比较缺乏的,大家莫不

         2)在更新当中一条的时候,整个namespace都会被刷新。大家实际通晓纵然刷新一条就好。

ehcache查找时key:ID,那么1旦本人不是以ID为查询条件的话,是还是不是就不曾选拔到缓存,
比方说:笔者用电话号码来询问用户,开采缓存就像并未有选取,怎么着本事化解此主题素材?

-数组和链表的分别

数组结构在通过索引进行询问数据时成效相比高,而对此数组插入和删除操作,则成效会相当的低,在第2个地点打开插队数据,别的数据就供给各样向后运动,而首先个数据开始展览删减,则要求有所数据总体迈入移。

链表:为了保险数据插入和删除,不会影响其余数据的移动,保障线性开支,就引出了指针链接,链表是由一名目好多节点组成的,每种节点都会有二个链点,next链,next链会推行下1个node的引用,所以大家在插入也许去除的时候,须求链表next链的针对地址就能够,各类节点无需内存举行接二连三存款和储蓄,那样会减小删除和插入的线性开支。链表结构重要分为三种链表,单向链表和双向链表
,即单向链表唯有三个next链,而双向链表会有next链和pre链。
 轻易的区别如下:
一数组静态分配内部存款和储蓄器,链表动态分配内部存款和储蓄器;2数组在内部存款和储蓄器中总是,链表不总是;叁数组成分在栈区,链表成分在堆区;四数组选取下标定位,时间复杂度为O(一),链表定位成分时间复杂度O(n);伍数组插入或删除成分的时刻复杂度O(n),链表的时日复杂度O(一)。
​  数组:
​ 优点:使用方便 ,查询功效比链表高,内存为一总是的区域 。
缺点:大小固定,不吻合动态积攒,不方便人民群众动态拉长。
 链表:
​ 优点:可动态增加删减,大小可变。
缺点:只好通过各样指针访问,查询成效低。

后言
 有哪些窘迫的地点还望多多指教,也接待我们关怀笔者(简书/GitHub)
多谢观察此文!

大家知道,比方部分散点图,这体系型的表格数量十分的多,为了加紧,作者急需缓存二种多少:

民用以为业务层本身调控会相比较好。

Ehcache的类档次模型首要为三层,最上层的是CacheManager,那是操作Ehcache的输入。
能够因而CacheManager.getInstance()获得三个床单的CacheManger,只怕通过CacheManger的构造函数创造多个新的CacheManger。
每一个CacheManager都管理着多少个Cache。
种种Cache都是1种类Hash的不贰诀要,关联着多个Element。而Element则是大家用来存放要缓存内容的地点。
在配置EhCache前须求引进七个开荒包:ehcache-一.三.0.jar和commons-logging-1.0四.jar

 

自个儿日前项目中蒙受贰种意况,

Cache的配备很利索,官方提供的Cache配置方式有少数种。你能够通过注解配置、在xml中配置、在先后里布署也许调用构造方法时传出不一致的参数。
你能够将Cache的陈设从代码中退出出去,也得以在选取运营时布置,所谓的运行时安插无非也便是在代码中布局。以下是运作时布署的功利:
在同二个地点安插全体的Cache,这样很轻松管理Cache的内部存款和储蓄器和磁盘消耗。
宣布时可改换Cache配置。
可再设置阶段就反省出布局错误消息,而幸免了运营时不当。

一.
基于基础数据源总计出中间结果,为了下二遍加速,缓存个几十秒钟,那么些数据量相对来讲相当的大。

1)业务只询问目前半钟头的多寡,数据日常更新,不断会有数量插入。正是部分一时半刻的本性数据。

CacheManager配置
DmulticastGroupPort=44四6,那样能够布署监听端口。

2.
将劳动的Response进行三十八分钟缓存,那一个数据量也针锋绝对非常大,大约十-50M的标准。

方案:给个ehcache,保存目前半时辰的多少,设置定期任务,把前边的多寡批量入库。查询优先在缓存中张开。

DiskStore配置
假使您选取的DiskStore(磁盘缓存),你必供给布置DiskStore配置项。假设不配备,Ehcache将会使用java.io.tmpdir。
diskStroe的“path”属性是用来布局磁盘缓存使用的情理路线的,Ehcache磁盘缓存使用的文本后缀名是.data和.index。
<disStore path=”java.io.tmpdir”/>

 

贰)数据库的数据是配置型的,比方用户的个人音讯,然后五个位置须求用到。并且使用的频率都不小。

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,属性的含义基本上能够从名字上赢得,详细的认证能够参见下边包车型地铁链接。

  

4858.com ,maven构建。

之所以选用EHCache大约的步子为: 
第一步:生成CacheManager对象 
第二步:生成Cache对象 
其三步:向Cache对象里增加由key,value组成的键值对的Element成分 
演示程序:
例子:

         
 平衡点找到了,貌似在.net领域中很少听他们讲有磁盘缓存那种概念,既然据书上说的少,那就在nuget中浪一浪,然后就找到了贰个top一的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>        

注:程序的流水生产线也是相比清楚的,首先是取得2个CacheManager,那是应用Ehcache的进口,然后经过名字获取某些Cache,然后就足以对Cache存取Element。Cache使用类Hash的点子来管理Element。
事件管理
证实:可以为CacheManager增加风云监听,当对CacheManager增加和删除Cache时,事件管理器将会获得通告。要配备事件管理,须求经过ehcache的布署文件来达成。
配备文件:ehcache.xml

4858.com 2

 

<?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配置

 

拉下来壹测试,卧槽,就的多个CU猎豹CS陆D操作,连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>

注:通过<cacheManager伊夫ntListenerFactory>来注册事件管理器的工厂类。
代码:
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情势,也正是说,事件管理的丰富是以不修改源代码为前提的。

4858.com 3

 

 

 

  1. EHCache 的风味,是1个纯Java
    ,进程中(也得以精晓成插入式)缓存落成,单独安装Ehcache
    ,需把ehcache-X.X.jar 和有关类库方到classpath中。
    如项目已设置了Hibernate ,则无需做什么。。直接能够动用Ehcache 
    Cache 存款和储蓄形式 :内部存款和储蓄器或磁盘 

  2. 独立接纳 EHCache 

既然如此net下未有何好的解决方案,目光只可以投到java上面看看,非常快就找到了ehCache,看下官方认证挺牛叉的,插足方式或许和上壹篇同样,使用thrift做C#

(一).diskStore: 为缓存路径,ehcache分为内部存款和储蓄器和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:    
             user.home –
用户主目录
             user.dir  –
用户当前专门的职业目录
             java.io.tmpdir –
暗中认可临时文件路线

采用CacheManager 创制并保管Cache 
1).创建CacheManager有4种方式: 

和Java之间的竞相媒介就足以了。(thrift的切切实进行使办法,大致能够倾心一篇)如下图:

  (2).defaultCache:默许缓存计谋,当ehcache找不到定义的缓存时,则运用那几个缓存战略。只好定义二个。

A:使用暗中认可配置文件成立 
CacheManager manager = CacheManager.create();  

4858.com 4 

      
(三).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();
}

4858.com 5

maxElementsOnDisk:硬盘中最大缓存对象数,借使0表示无穷大

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

 

eternal:true表示对象并非过期,此时会忽视timeToIdleSeconds和timeToLiveSeconds属性,默以为false

2)使用Caches

  1. 运用全代码形式的布置

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

赢得配置文件中先行
定义的sampleCache一设置,通过CacheManager生成二个Cache
Cache cache = manager.getCache(“sampleCache1”);  
设置一个名称叫test 的新cache,test属性为默许 

 

maxElementsInMemory界限后,会把溢出的靶子写到硬盘缓存中。注意:要是缓存的对象要写入到硬盘中的话,则该目的必须兑现了Serializable接口才行。

CacheManager manager = CacheManager.create();
manager.addCache(“test”);

       
 接下来就能够写壹段代码测试一下,向diskcache中插入一千0个字符大小的cache,插入1000次,看看功用怎么着,代码如下:

diskSpoolBufferSizeMB:磁盘缓存区大小,默以为30MB。每种Cache都应该有和好的2个缓存区。

设置3个名称叫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中参美金素 

4858.com 6

timeToIdleSeconds:
设定允许对象处于空闲状态的最长日子,以秒为单位。当目标自从近年来三遍被访问后,借使处在空闲状态的岁月超越了timeToIdleSeconds属性
值,那一个目的就能晚点,EHCache将把它从缓存中清空。唯有当eternal属性为false,该属性才使得。如若该属性值为0,则表示对象足以Infiniti制时间地处于空闲状态

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

4858.com 7

timeToLiveSeconds:设定目标允许存在于缓存中的最长日子,以秒为单位。当对象自从被寄存到缓存中后,如果处在缓存中的时间抢先了
timeToLiveSeconds属性值,那几个目的就能够晚点,EHCache将把它从缓存中排除。唯有当eternal属性为false,该属性才有
效。假若该属性值为0,则意味对象足以无有效期地存在于缓存中。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 那种格局

具体原因参考:

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有