`
lshh83
  • 浏览: 162487 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

redis+spring例子

 
阅读更多

一、Redis了解

1.1、Redis介绍:

redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。在此基础上,redis支持各种不同方式的排序。与memcached一样,为了保证效率,数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了master-slave(主从)同步。

Redis数据库完全在内存中,使用磁盘仅用于持久性。相比许多键值数据存储,Redis拥有一套较为丰富的数据类型。Redis可以将数据复制到任意数量的从服务器。

1.2、Redis优点:

(1)异常快速:Redis的速度非常快,每秒能执行约11万集合,每秒约81000+条记录。

(2)支持丰富的数据类型:Redis支持最大多数开发人员已经知道像列表,集合,有序集合,散列数据类型。这使得它非常容易解决各种各样的问题,因为我们知道哪些问题是可以处理通过它的数据类型更好。

(3)操作都是原子性:所有Redis操作是原子的,这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。

(4)多功能实用工具:Redis是一个多实用的工具,可以在多个用例如缓存,消息,队列使用(Redis原生支持发布/订阅),任何短暂的数据,应用程序,如Web应用程序会话,网页命中计数等。

1.3、Redis缺点:

(1)单线程

(2)耗内存

二、64位windows下Redis安装

Redis官方是不支持windows的,但是Microsoft Open Tech group 在 GitHub上开发了一个Win64的版本,下载地址:https://github.com/MSOpenTech/redis/releases注意只支持64位哈

小宝鸽是下载了Redis-x64-3.0.500.msi进行安装。安装过程中全部采取默认即可。

安装完成之后可能已经帮你开启了Redis对应的服务,博主的就是如此。查看资源管理如下,说明已经开启:

已经开启了对应服务的,我们让它保持,下面例子需要用到。如果没有开启的,我们命令开启,进入Redis的安装目录(博主的是C:\Program Files\Redis),然后如下命令开启:

redis-server redis.windows.conf

OK,下面我们进行实例。

三、详细实例

本工程采用的环境:eclipse + maven + spring + junit

3.1、添加相关依赖(spring+junit+redis依赖),pom.xml:

 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.luo</groupId>
  <artifactId>redis_project</artifactId>
  <version>0.0.1-SNAPSHOT</version>

  <properties>
        <!-- spring版本号 -->
        <spring.version>3.2.8.RELEASE</spring.version>
        <!-- junit版本号 -->
        <junit.version>4.10</junit.version>
  </properties>

  <dependencies>
        <!-- 添加Spring依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--单元测试依赖 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!--spring单元测试依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- Redis 相关依赖  -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>

    </dependencies>
</project>

 3.2、spring配置文件application.xml:

 

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="  
           http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
           http://www.springframework.org/schema/aop  
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 自动扫描注解的bean -->
    <context:component-scan base-package="com.luo.service" />

    <!-- 引入properties配置文件 -->  
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
               <value>classpath:properties/*.properties</value>
                <!--要是有多个配置文件,只需在这里继续添加即可 -->
            </list>
        </property>
    </bean>

    <!-- jedis 配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
          <property name="maxIdle" value="${redis.maxIdle}" />
          <property name="maxWaitMillis" value="${redis.maxWait}" />
          <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean >

    <!-- redis服务器中心 -->
    <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
          <property name="poolConfig" ref="poolConfig" />
          <property name="port" value="${redis.port}" />
          <property name="hostName" value="${redis.host}" />
          <!-- <property name="password" value="${redis.password}" /> -->
          <property name="timeout" value="${redis.timeout}" ></property>
    </bean >
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
          <property name="connectionFactory" ref="connectionFactory" />
          <property name="keySerializer" >
              <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
          </property>
          <property name="valueSerializer" >
              <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
          </property>
    </bean >

    <!-- cache配置 -->
    <bean id="methodCacheInterceptor" class="com.luo.redis.cache.MethodCacheInterceptor" >
          <property name="redisTemplate" ref="redisTemplate" />
    </bean >

    <!-- aop配置切点跟通知 -->
    <bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="methodCacheInterceptor"/>
        <property name="pattern" value=".*ServiceImpl.*getTimestamp"/>
    </bean>
    <bean id="redisTestService" class="com.luo.service.impl.RedisTestServiceImpl">
    </bean>
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

</beans>

 3.3、Redis配置参数,redis.properties:

 

 

#redis中心
#绑定的主机地址
redis.host=127.0.0.1 
#指定Redis监听端口,默认端口为6379
redis.port=6379 
#授权密码(本例子没有使用)
redis.password=123456  
#最大空闲数:空闲链接数大于maxIdle时,将进行回收
redis.maxIdle=100  
#最大连接数:能够同时建立的“最大链接个数”
redis.maxActive=300  
#最大等待时间:单位ms
redis.maxWait=1000   
#使用连接时,检测连接是否成功 
redis.testOnBorrow=true 
#当客户端闲置多长时间后关闭连接,如果指定为0,表示关闭该功能
redis.timeout=10000 

 3.4、添加接口及对应实现RedisTestService.Java和RedisTestServiceImpl.java:

 

 

package com.luo.service;

public interface RedisTestService {
    public String getTimestamp(String param);
}
package com.luo.service.impl;

import org.springframework.stereotype.Service;
import com.luo.service.RedisTestService;

@Service
public class RedisTestServiceImpl implements RedisTestService {

    public String getTimestamp(String param) {
        Long timestamp = System.currentTimeMillis();
        return timestamp.toString();
    }

}

 3.5、本例采用spring aop切面方式进行缓存,配置已在上面spring配置文件中,对应实现为MethodCacheInterceptor.java:

package com.luo.redis.cache;

import java.io.Serializable;
import java.util.concurrent.TimeUnit;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

public class MethodCacheInterceptor implements MethodInterceptor {

    private RedisTemplate<Serializable, Object> redisTemplate;
    private Long defaultCacheExpireTime = 10l; // 缓存默认的过期时间,这里设置了10秒

    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object value = null;

        String targetName = invocation.getThis().getClass().getName();
        String methodName = invocation.getMethod().getName();

        Object[] arguments = invocation.getArguments();
        String key = getCacheKey(targetName, methodName, arguments);

        try {
            // 判断是否有缓存
            if (exists(key)) {
                return getCache(key);
            }
            // 写入缓存
            value = invocation.proceed();
            if (value != null) {
                final String tkey = key;
                final Object tvalue = value;
                new Thread(new Runnable() {
                    public void run() {
                        setCache(tkey, tvalue, defaultCacheExpireTime);
                    }
                }).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (value == null) {
                return invocation.proceed();
            }
        }
        return value;
    }

    /**
     * 创建缓存key
     *
     * @param targetName
     * @param methodName
     * @param arguments
     */
    private String getCacheKey(String targetName, String methodName,
            Object[] arguments) {
        StringBuffer sbu = new StringBuffer();
        sbu.append(targetName).append("_").append(methodName);
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
                sbu.append("_").append(arguments[i]);
            }
        }
        return sbu.toString();
    }



    /**
     * 判断缓存中是否有对应的value
     * 
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     * 
     * @param key
     * @return
     */
    public Object getCache(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate
                .opsForValue();
        result = operations.get(key);
        return result;
    }



    /**
     * 写入缓存
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean setCache(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public void setRedisTemplate(
            RedisTemplate<Serializable, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
}

 3.6、单元测试相关类:

package com.luo.baseTest;

import org.junit.runner.RunWith;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  

//指定bean注入的配置文件  
@ContextConfiguration(locations = { "classpath:application.xml" })  
//使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner  
@RunWith(SpringJUnit4ClassRunner.class)  
public class SpringTestCase extends AbstractJUnit4SpringContextTests {

}

 

package com.luo.service;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import com.luo.baseTest.SpringTestCase;

public class RedisTestServiceTest extends SpringTestCase {

    @Autowired  
    private RedisTestService redisTestService;

    @Test  
    public void getTimestampTest() throws InterruptedException{  
        System.out.println("第一次调用:" + redisTestService.getTimestamp("param"));
        Thread.sleep(2000);
        System.out.println("2秒之后调用:" + redisTestService.getTimestamp("param"));
        Thread.sleep(11000);
        System.out.println("再过11秒之后调用:" + redisTestService.getTimestamp("param"));
    } 
}

 3.7、运行结果:

分享到:
评论

相关推荐

    maven 创建 spring + springmvc + mybatis + redis + mysql 学生查询例子

    在IT行业中,构建高效、可扩展的Web应用是至关重要的。本示例提供了一个使用Maven集成Spring、SpringMVC...通过深入学习和调整这个例子,你可以进一步提升在Spring、SpringMVC、MyBatis、Redis和MySQL集成方面的技能。

    Java生态研究(Spring Boot + Redis + Dubbo + RocketMQ)

    本项目可能包含了使用Jedis或Lettuce客户端操作Redis的例子,例如设置和获取键值、订阅发布消息等。 **Dubbo** Dubbo是阿里巴巴开源的一款高性能、轻量级的Java服务治理框架,主要用于实现服务间的远程调用。它提供...

    Spring-Data-Redis2.0+Spring5

    Spring-Data-Redis2.0整合Spring5的cachemanage例子,JDK要1.8,maven3.5吧。文档地址:http://blog.csdn.net/u011189939/article/details/78621724

    《深入理解Spring Cloud与微服务构建》学习笔记(六)-整合redis实践

    在本篇《深入理解Spring Cloud与微服务构建》的学习笔记中,我们将重点探讨如何将Redis这一流行的内存数据存储系统整合到Spring Cloud微服务架构中。Redis不仅被广泛用于缓存,还支持多种数据结构,如字符串、哈希、...

    springBoot集成redis

    首先,为了在Spring Boot项目中引入Redis,我们需要在`pom.xml`文件中添加Spring Data Redis依赖: ```xml &lt;groupId&gt;org.springframework.boot &lt;artifactId&gt;spring-boot-starter-data-redis ``` 接下来,配置...

    采用最新版本SpringBoot2+MyBatis+Mysql+Apollo+Redis+Rabbitmq集成例子

    在本集成例子中,我们探讨的是一个基于最新版本SpringBoot2、MyBatis、Mysql、Apollo、Redis和Rabbitmq构建的现代化Web应用程序。这个项目旨在展示如何将这些技术有效地整合在一起,以实现高效、可扩展且具有弹性的...

    Spring+Redis整合例子

    Spring Data Redis是Spring框架的一个模块,旨在简化Redis操作。它提供了RedisTemplate和StringRedisTemplate两个核心模板类,用于执行Redis命令。这两个模板类提供了丰富的API,使得开发者能够方便地进行键值操作...

    学废SpringBoot+Redis+Lua=王炸(值得珍藏)

    【Spring Boot + Redis + Lua 知识点详解】 1. Spring Boot Spring Boot是Spring框架的一个子项目,旨在简化Spring应用的初始搭建以及开发过程。它预设了许多默认配置,使得开发者可以快速启动和运行应用程序,而...

    springboot+redis+slf4j的demo

    这个Demo是初学者了解和学习Spring Boot与Redis整合的一个良好起点,同时也为开发者提供了一个实践日志记录策略的例子。 首先,Spring Boot是一个由Pivotal团队提供的开源框架,它简化了创建独立的、生产级别的基于...

    spring集成redis,spring mvc实现session共享以及redis排行榜.zip

    spring集成redis,spring mvc实现session共享以及redis排行榜春季会议Redis这一系列项目,将会有多个spring相关的简单的例子,包括session-with-redis、spring整合redis等1、在springmvc项目session存储到redis中...

    spring data redis 小例子

    在本文中,我们将深入探讨Spring Data Redis的基本概念、功能和如何通过一个小例子来实现其应用。 首先,Spring Data Redis是Spring Data项目的一部分,该项目致力于简化各种数据存储的访问,包括关系型数据库、...

    nginx+tomcat+redis完成session共享

    你可以使用第三方库如`spring-session-data-redis`来简化这个过程。 3. **配置Nginx**:在Nginx配置文件中,设置负载均衡策略,例如轮询、最少连接数或根据session ID进行粘滞会话。使用`proxy_pass`指令将请求转发...

    ssm+redis的小例子

    SSM(Spring、SpringMVC、MyBatis)是一个经典的Java web开发框架组合,而Redis则是一种高性能的键值数据库,常被用作缓存来提高应用性能。在这个"ssm+redis的小例子"中,我们将探讨如何将这三者进行有效整合,以及...

    MyBatis+SpringBoot+Redis

    "MyBatis+SpringBoot+Redis"的组合就是一个典型的例子,它结合了MyBatis的灵活SQL映射、SpringBoot的快速开发能力和Redis的高性能数据缓存功能。下面我们将详细探讨这三个组件及其相互间的整合。 首先,MyBatis是一...

    spring+websocket+hibernate小例子

    在本项目"spring+websocket+hibernate小例子"中,开发者通过集成Spring框架、WebSocket技术和Hibernate ORM,创建了一个小型的交互式应用。这个应用能够实现实时通信,并且能够与数据库进行数据交互,展示了现代Web...

    Redis整合SpringCache实例

    **Redis整合SpringCache实例** 在现代的Web应用中,数据缓存是提高系统性能的关键技术之一。本示例主要探讨如何将开源的内存数据结构存储系统Redis与Spring Cache框架结合,实现高效的分布式缓存解决方案。Redis以...

    redis分布式缓存例子

    redis分布式缓存+spring整合及 集群、分片等配置使用例子

    spring 结合 Redis 例子,简单入门例子

    spring 结合 Redis 例子,简单入门例子http://blog.csdn.net/sunny243788557/article/details/34431357

    redis与springcache集成

    在这个例子中,当`findById`方法被调用时,Spring Cache会检查是否存在对应的缓存。如果存在,就直接返回;否则,执行方法,将结果存入缓存,并返回结果。 此外,我们还可以使用`@CacheEvict`注解来清除特定缓存,`...

Global site tag (gtag.js) - Google Analytics