第一：两者之间的介绍

Redis：属于独立的运行程序，需要单独安装后，使用Java中的 Jedis 来操纵。因为它是独立，所以如果你写个单元测试程序，放一些数据在 Redis 中，然后又写一个程序去拿数据，那么是可以拿到这个数据的。，

ehcache：与 Redis 明显不同，它与 java 程序是绑在一起的，java 程序活着，它就活着。譬如，写一个独立程序放数据，再写一个独立程序拿数据，那么是拿不到数据的。只能在独立程序中才能拿到数据。

第二：使用及各种配置：

两者都可以集群：

1.Redis 可以做主从来集群，例如，在 A 电脑上装个 Redis，作为主库；在其他电脑上装 Redis，作为从库；这样主库拥有读和写的功能，而从库只拥有读的功能。每次主库的数据都会同步到从库中。

1. 默认方式启动

[html] view plain copy

1. Linux 下使用 Redis  
2. 安装：从官网上下载 tar.gz 格式的包，然后使用 tar zxvf redis-2.8.24.tar.gz 命令解压，然后进入 Redis 文件夹目录下的 src 目录，使用 make 编译一下  
3.   
4. 1. 开启：进入 /usr/local/redis-3.2.1/src  
5. 然后./redis-server  

2. 如果我们想修改端口，设置密码：那么得修改配置文件的 redis.conf

port 6379                                         // 端口修改

requirepass redis123                  // 设置密码  redis123 为密码

配置主从：主库的配置文件不用修改，从库的配置文件需要修改，因为从库需要绑定主库，以便可以获取主库的数据

slaveof 192.168.1.100 6379                              // 主库的 IP 地址和端口号
masterauth redis123                                      // 主库设定的密码

3. 要让配置文件的属性生效，那么启动的 redis 的时候，要将配置文件加上去

进入 /usr/local/redis-3.2.1/src

然后 ./redis-server  redis.conf

那么将成功的启动 redis，如果没有加入配置的话，按照普通方式启动的话，端口仍然还是 6379.

4.客户端连接远程的 Redis
第一步：在远程端处设置密码：config set requirepass 123       //123 为密码
第二步：可以在客户端登录  redis-cli.exe -h 114.215.125.42 -p 6379 
第三步：认证：auth 123                                       //123 为密码
本地端设置密码后，要使用密码登录；如果 Redis 重启的话，密码需要重新设置

5. 主从配置后，为保证主库写的能力，一般不在主库做持久化，而是在从库做持久化：

主库配置：

将 save 注释，不使用 rdb

# save 900 1
# save 300 10
# save 60 10000

appendonly no        不使用 aof

从库配置：

save 900 1
save 300 10
save 60 10000

appendonly yes

这样做的优缺点：

优点：保证了主库写的能力。

缺点：主库挂掉后，重启主库，然后进行第一次写的动作后，主库会先生成 rdb 文件，然后传输给从库，从而覆盖掉从库原先的 rdb 文件，造成数据丢失。但是第二次写的时候，主库会以快照方式直接传数据给从库，不会重新生成 rdb 文件。

解决方案：先复制从库中的数据到主库后，再启动主库。

使用：

引入 jedis 包

[html] view plain copy

1. <dependency>  
2.     <groupId>redis.clients</groupId>  
3.     <artifactId>jedis</artifactId>  
4.     <version>2.7.3</version>  
5. </dependency>  

简单的写个类玩玩吧

[html] view plain copy

1. public class RedisMain {  
2.       
3.       
4.     public static void main(String [] str)  
5.     {  
6.           
7.          Jedis jedis = new Jedis("114.215.125.42",6379);  
8.          jedis.auth("123");     // 密码认证  
9.           System.out.println("Connection to server sucessfully");  
10.           // 查看服务是否运行  
11.           jedis.set("user","namess");  
12.          // System.out.println("Server is running: "+jedis.ping());  
13.           System.out.println(jedis.get("user").toString());  
14.           jedis.set("user","name");  
15.           System.out.println(jedis.get("user"));  
16.             
17.   
18.     }  
19.   
20. }  

Redis 完毕

下面说说 Ehcache:

Ehcache 的使用：

1. 首先引入包

[html] view plain copy

1. <dependency>  
2.            <groupId>net.sf.ehcache</groupId>  
3.            <artifactId>ehcache-core</artifactId>  
4.            <version>2.6.6</version>  
5.        </dependency>  
6.    
7.        <dependency>  
8.            <groupId>org.slf4j</groupId>  
9.            <artifactId>slf4j-log4j12</artifactId>  
10.            <version>1.6.6</version>  
11.        </dependency>  

2. 创建一个 ehcache.xml 文件，里面配置 cache 的信息，这个配置是包含了集群的配置：与 192.168.93.129：40001 的机器集群了：Ip 为 192.168.93.129 机子的配置要将 rmiUrls 对应的数据改为这个配置文件的机子的 IP 地址，和对应的缓存名字

[html] view plain copy

1. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
2.    xsi:noNamespaceSchemaLocation="ehcache.xsd">  
3.     <cacheManagerPeerProviderFactory   
4.    class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"  
5. properties="peerDiscovery=manual,rmiUrls=//192.168.93.129:40001/demoCache"/>           <!-- 另一台机子的 ip 缓存信息 -->  
6. <cacheManagerPeerListenerFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"  
7. properties="hostName=localhost,port=40001,socketTimeoutMillis=2000" />                  <!--hostName 代表本机子的 ip-->     
8.   <diskStore path="java.io.tmpdir"/>  
9.   <defaultCache  
10.     maxElementsInMemory="10000"  
11.     maxElementsOnDisk="0"  
12.     eternal="true"  
13.     overflowToDisk="true"  
14.     diskPersistent="false"  
15.     timeToIdleSeconds="0"  
16.     timeToLiveSeconds="0"  
17.     diskSpoolBufferSizeMB="50"  
18.     diskExpiryThreadIntervalSeconds="120"  
19.     memoryStoreEvictionPolicy="LFU"  
20.     >  
21.      <cacheEventListenerFactory    
22.                 class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>                
23.     </defaultCache>  
24.   <cache name="demoCache"  
25.     maxElementsInMemory="100"  
26.     maxElementsOnDisk="0"  
27.     eternal="false"  
28.     overflowToDisk="false"  
29.     diskPersistent="false"  
30.     timeToIdleSeconds="119"  
31.     timeToLiveSeconds="119"  
32.     diskSpoolBufferSizeMB="50"  
33.     diskExpiryThreadIntervalSeconds="120"  
34.     memoryStoreEvictionPolicy="FIFO"  
35.     >  
36.     <cacheEventListenerFactory class="net.sf.ehcache.distribution.RMICacheReplicatorFactory"/>          <!-- 监听这个 cache-->  
37.     </cache>  
38. </ehcache>  

配置完后写代码：

放数据：

[html] view plain copy

1. @RequestMapping("/testehcache.do")  
2.     public void testehcache(HttpServletResponse response) throws IOException  
3.     {  
4.         URL url = getClass().getResource("ehcache.xml");   
5.          CacheManager singletonmanager = CacheManager.create(url);  
6.         Cache cache = singletonmanager.getCache("demoCache");  
7.         // 使用缓存  
8.         Element element = new Element("key1", "value1");  
9.         cache.put(element);  
10.         cache.put(new Element("key2", "value2"));  
11.          
12.         response.getWriter().println("我存放了数据");  
13.     }  

拿数据：

1. @RequestMapping("/getcache.do")  
2.     public void getcache(HttpServletResponse response) throws IOException  
3.     {  
4.         CacheManager singletonmanager = CacheManager.create();   
5.         Cache cache = singletonmanager.getCache("demoCache");  
6.         String one=cache.get("key1").getObjectValue().toString();  
7.         String two=cache.get("key2").getObjectValue().toString();  
8.         response.getWriter().println(one+two);  
9.     }  

配置集群后，A 机器放数据，在 B 机器上能拿到数据，B 机器放数据，A 机器也可以拿到数据

本文结束！！！！！

源码来源: minglisoft.cn/technology