springmvc整合redis架构搭建实例

新换环境，又有新东西可以学习了，哈皮！ 抽空学习之余看了一下redis,个人对Springmvc的爱是忠贞不渝，所以整理了一下Springmvc整合redis的环境搭建。分享学习。

　　第一步： 创建maven项目：

　　实例pom.xml内容如下

　　<?xml version="1.0" encoding="UTF-8"?>

　　<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="w3.org/2001/XMLSchema-instance"

　　xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

　　<modelVersion>4.0.0</modelVersion>

　　<packaging>war</packaging>

　　<name>orm-bae</name>

　　<groupId>com.orm</groupId>

　　<artifactId>orm-bae</artifactId>

　　<version>0.0.1-SNAPSHOT</version>

　　<properties>

　　<org.springframework.version>3.0.5.RELEASE</org.springframework.version>

　　<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

　　</properties>

　　<dependencies>

　　<!-- config junit jar -->

　　<dependency>

　　<groupId>junit</groupId>

　　<artifactId>junit</artifactId>

　　<version>4.8.2</version>

　　<scope>test</scope>

　　</dependency>

　　<!-- config redis data and client jar-->

　　<dependency>

　　<groupId>org.springframework.data</groupId>

　　<artifactId>spring-data-redis</artifactId>

　　<version>1.0.2.RELEASE</version>

　　</dependency>

　　<dependency>

　　<groupId>redis.clients</groupId>

　　<artifactId>jedis</artifactId>

　　<version>2.1.0</version>

　　</dependency>

　　<!-- config need jar -->

　　<dependency>

　　<groupId>commons-lang</groupId>

　　<artifactId>commons-lang</artifactId>

　　<version>2.6</version>

　　</dependency>

　　<dependency>

　　<groupId>org.apache.geronimo.specs</groupId>

　　<artifactId>geronimo-servlet_3.0_spec</artifactId>

　　<version>1.0</version>

　　</dependency>

　　<!-- cofig spring jar -->

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-core</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-expression</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-beans</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-aop</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-context</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-context-support</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-tx</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-jdbc</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-orm</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-oxm</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-web</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-webmvc</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-webmvc-portlet</artifactId>

　　<version>${org.springframework.version}</version>

　　</dependency>

　　<dependency>

　　<groupId>org.springframework</groupId>

　　<artifactId>spring-test</artifactId>

　　<version>${org.springframework.version}</version>

　　<scope>test</scope>

　　</dependency>

　　</dependencies>

　　<build>

　　<resources>

　　<resource>

　　<directory>/src/main/resources</directory>

　　<filtering>true</filtering>

　　</resource>

　　</resources>

　　</build>

　　</project>

　　第二步：配置文件整合

　　Web.xml文件配置

　　<?xml version="1.0" encoding="UTF-8"?>

　　<web-app version="2.4"

　　xmlns="http://java.sun.com/xml/ns/j2ee"

　　xmlns:xsi="w3.org/2001/XMLSchema-instance"

　　xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

　　<listener>

　　<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

　　</listener>

　　<context-param>

　　<param-name>contextConfigLocation</param-name>

　　<param-value>/WEB-INF/context/spring-context.xml</param-value>

　　</context-param>

　　<!-- Spring字符集过滤器 -->

　　<filter>

　　<filter-name>SpringEncodingFilter</filter-name>

　　<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

　　<init-param>

　　<param-name>encoding</param-name>

　　<param-value>UTF-8</param-value>

　　</init-param>

　　<init-param>

　　<param-name>forceEncoding</param-name>

　　<param-value>true</param-value>

　　</init-param>

　　</filter>

　　<filter-mapping>

　　<filter-name>SpringEncodingFilter</filter-name>

　　<url-pattern>/*</url-pattern>

　　</filter-mapping>

　　<servlet>

　　<servlet-name>mvc</servlet-name>

　　<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

　　<init-param>

　　<param-name>contextConfigLocation</param-name>

　　<param-value>/WEB-INF/context/spring-mvc.xml</param-value>

　　</init-param>

　　<load-on-startup>2</load-on-startup>

　　</servlet>

　　<servlet-mapping>

　　<servlet-name>mvc</servlet-name>

　　<url-pattern>/</url-pattern>

　　</servlet-mapping>

　　<welcome-file-list>

　　<welcome-file>index.jsp</welcome-file>

　　</welcome-file-list>

　　</web-app>

　　spring-context.xml内容

　　<?xml version="1.0" encoding="UTF-8"?>

　　<beans xmlns="springframework.org/schema/beans"

　　xmlns:xsi="w3.org/2001/XMLSchema-instance" xmlns:p="springframework.org/schema/p"

　　xmlns:mvc="springframework.org/schema/mvc" xmlns:context="springframework.org/schema/context"

　　xmlns:util="springframework.org/schema/util"

　　xsi:schemaLocation="springframework.org/schema/beans springframework.org/schema/beans/spring-beans-3.0.xsd

　　springframework.org/schema/context springframework.org/schema/context/spring-context-3.0.xsd

　　springframework.org/schema/mvc springframework.org/schema/mvc/spring-mvc-3.0.xsd

　　springframework.org/schema/util springframework.org/schema/util/spring-util-3.0.xsd">

　　<!-- 激活@Controller模式 -->

　　<mvc:annotation-driven />

　　<!-- 对包中的所有类进行扫描，以完成Bean创建和自动依赖注入的功能 需要更改 -->

　　<context:component-scan base-package="com.pudp.bae.*" />

　　<!-- 引入同文件夹下的redis属性配置文件 -->

　　<import resource="redis-context.xml"/>

　　</beans>

　　redis-context.xml内容

　　<beans     xmlns="springframework.org/schema/beans"

　　xmlns:xsi="w3.org/2001/XMLSchema-instance"

　　xmlns:p="springframework.org/schema/p"

　　xmlns:tx="springframework.org/schema/tx"

　　xmlns:context="springframework.org/schema/context"

　　xsi:schemaLocation="

　　springframework.org/schema/beans

　　springframework.org/schema/beans/spring-beans-3.0.xsd

　　springframework.org/schema/tx

　　springframework.org/schema/tx/spring-tx-3.0.xsd

　　springframework.org/schema/context

　　springframework.org/schema/context/spring-context-3.0.xsd

　　">

　　<!-- scanner redis properties  -->

　　<context:property-placeholder location="/WEB-INF/property/redis.properties" />

　　<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">

　　<property name="maxIdle" value="${redis.maxIdle}" />

　　<property name="maxActive" value="${redis.maxActive}" />

　　<property name="maxWait" value="${redis.maxWait}" />

　　<property name="testOnBorrow" value="${redis.testOnBorrow}" />

　　</bean>

<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"

　　p:host-name="${redis.host}"

　　p:port="${redis.port}"

　　p:password="${redis.pass}"

　　p:pool-config-ref="poolConfig"/>

　　<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">

　　<property name="connectionFactory"   ref="connectionFactory" />

　　</bean>

　　</beans>

　　Redis.properties文件内容

　　# Redis settings

　　#redis.host=192.168.20.101

　　#redis.port=6380

　　#redis.pass=foobared

　　redis.host=127.0.0.1

　　redis.port=6379

　　redis.pass=

　　redis.maxIdle=300

　　redis.maxActive=600

　　redis.maxWait=1000

　　redis.testOnBorrow=true

　　第三步：Springmvc对Redis的支持与实例应用。

　　实例对象

　　package com.pudp.bae.model;

　　import com.pudp.bae.base.BaseModel;

　　public class Member extends BaseModel{

　　/**

　　*

　　*/

　　private static final long serialVersionUID = -1959528436584592183L;

　　private String id;

　　private String nickname;

　　public Member（）{}

　　public Member（String id, String nickname）{

　　this.setId（id）；

　　this.setNickname（nickname）；

　　}

　　public String getId（） {

　　return id;

　　}

　　public void setId（String id） {

　　this.id = id;

　　}

　　public String getNickname（） {

　　return nickname;

　　}

　　public void setNickname（String nickname） {

　　this.nickname = nickname;

　　}

　　}

　　View Code

　　Redis对象持久化操作

　　package com.pudp.bae.base;

　　import java.io.Serializable;

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

　　import org.springframework.data.redis.core.RedisTemplate;

　　import org.springframework.data.redis.serializer.RedisSerializer;

　　public abstract class RedisGeneratorDao<K extends Serializable, V extends Serializable>  {

　　@Autowired

　　protected RedisTemplate<K,V> redisTemplate ;

　　/**

　　* 设置redisTemplate

　　* @param redisTemplate the redisTemplate to set

　　*/

　　public void setRedisTemplate（RedisTemplate<K, V> redisTemplate） {

　　this.redisTemplate = redisTemplate;

　　}

　　/**

　　* 获取 RedisSerializer

　　* <br>------------------------------<br>

　　*/

　　protected RedisSerializer<String> getRedisSerializer（） {

　　return redisTemplate.getStringSerializer（）；

　　}

　　}

　　package com.pudp.bae.base;

　　import java.io.Serializable;

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

　　import org.springframework.data.redis.core.RedisTemplate;

　　import org.springframework.data.redis.serializer.RedisSerializer;

　　public abstract class RedisGeneratorDao<K extends Serializable, V extends Serializable>  {

　　@Autowired

　　protected RedisTemplate<K,V> redisTemplate ;

　　/**

　　* 设置redisTemplate

　　* @param redisTemplate the redisTemplate to set

　　*/

　　public void setRedisTemplate（RedisTemplate<K, V> redisTemplate） {

　　this.redisTemplate = redisTemplate;

　　}

　　/**

　　* 获取 RedisSerializer

　　* <br>------------------------------<br>

　　*/

　　protected RedisSerializer<String> getRedisSerializer（） {

　　return redisTemplate.getStringSerializer（）；

　　}

　　}

　　redis对象操作

　　package com.pudp.bae.dao.redis;

　　import java.util.ArrayList;

　　import java.util.List;

　　import org.springframework.dao.DataAccessException;

　　import org.springframework.data.redis.connection.RedisConnection;

　　import org.springframework.data.redis.core.RedisCallback;

　　import org.springframework.data.redis.serializer.RedisSerializer;

　　import org.springframework.stereotype.Repository;

　　import org.springframework.util.Assert;

　　import com.pudp.bae.base.RedisGeneratorDao;

　　import com.pudp.bae.model.Member;

　　/**

　　* 参看博客 <br>

　　* -------------------------------------------------------------------------------

　　*  http://blog.csdn.net/java2000_wl/article/details/8543203

　　* -------------------------------------------------------------------------------

　　*/

　　@Repository（value="memberDao"）

　　public class MemberDaoImpl extends RedisGeneratorDao<String,Member> implements MemberDao{

　　/**

　　* 添加对象

　　*/

　　@Override

　　public boolean add（final Member member） {

　　boolean result = redisTemplate.execute（new RedisCallback<Boolean>（） {

　　public Boolean doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　byte[] key  = serializer.serialize（member.getId（））；

　　byte[] name = serializer.serialize（member.getNickname（））；

　　return connection.setNX（key, name）；

　　}

　　}）；

　　return result;

　　}

　　/**

　　* 添加集合

　　*/

　　@Override

　　public boolean add（final List<Member> list） {

　　Assert.notEmpty（list）；

　　boolean result = redisTemplate.execute（new RedisCallback<Boolean>（） {

　　public Boolean doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　for （Member member : list） {

　　byte[] key  = serializer.serialize（member.getId（））；

　　byte[] name = serializer.serialize（member.getNickname（））；

　　connection.setNX（key, name）；

　　}

　　return true;

　　}

　　}, false, true）；

　　return result;

　　}

　　/**

　　* 删除对象 ,依赖key

　　*/

　　public void delete（String key） {

　　List<String> list = new ArrayList<String>（）；

　　list.add（key）；

　　delete（list）；

　　}

　　/**

　　* 删除集合 ,依赖key集合

　　*/

　　public void delete（List<String> keys） {

　　redisTemplate.delete（keys）；

　　}

　　/**

　　* 修改对象

　　*/

　　public boolean update（final Member member） {

　　String key = member.getId（）；

　　if （get（key） == null） {

　　throw new NullPointerException（"数据行不存在， key = " + key）；

　　}

　　boolean result = redisTemplate.execute（new RedisCallback<Boolean>（） {

　　public Boolean doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　byte[] key  = serializer.serialize（member.getId（））；

　　byte[] name = serializer.serialize（member.getNickname（））；

　　connection.set（key, name）；

　　return true;

　　}

　　}）；

　　return result;

　　}

　　/**

　　* 根据key获取对象

　　*/

　　public Member get（final String keyId） {

　　Member result = redisTemplate.execute（new RedisCallback<Member>（） {

　　public Member doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　byte[] key = serializer.serialize（keyId）；

　　byte[] value = connection.get（key）；

　　if （value == null） {

　　return null;

　　}

　　String nickname = serializer.deserialize（value）；

　　return new Member（keyId, nickname）；

　　}

　　}）；

　　return result;

　　}

　　}

　　package com.pudp.bae.dao.redis;

　　import java.util.ArrayList;

　　import java.util.List;

　　import org.springframework.dao.DataAccessException;

　　import org.springframework.data.redis.connection.RedisConnection;

　　import org.springframework.data.redis.core.RedisCallback;

　　import org.springframework.data.redis.serializer.RedisSerializer;

　　import org.springframework.stereotype.Repository;

　　import org.springframework.util.Assert;

　　import com.pudp.bae.base.RedisGeneratorDao;

　　import com.pudp.bae.model.Member;

　　/**

　　* 参看博客 <br>

　　* -------------------------------------------------------------------------------

　　*  http://blog.csdn.net/java2000_wl/article/details/8543203

　　* -------------------------------------------------------------------------------

　　*/

　　@Repository（value="memberDao"）

　　public class MemberDaoImpl extends RedisGeneratorDao<String,Member> implements MemberDao{

　　/**

　　* 添加对象

　　*/

　　@Override

　　public boolean add（final Member member） {

　　boolean result = redisTemplate.execute（new RedisCallback<Boolean>（） {

　　public Boolean doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　byte[] key  = serializer.serialize（member.getId（））；

　　byte[] name = serializer.serialize（member.getNickname（））；

　　return connection.setNX（key, name）；

　　}

　　}）；

　　return result;

　　}

　　/**

　　* 添加集合

　　*/

　　@Override

　　public boolean add（final List<Member> list） {

　　Assert.notEmpty（list）；

　　boolean result = redisTemplate.execute（new RedisCallback<Boolean>（） {

　　public Boolean doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　for （Member member : list） {

　　byte[] key  = serializer.serialize（member.getId（））；

　　byte[] name = serializer.serialize（member.getNickname（））；

　　connection.setNX（key, name）；

　　}

　　return true;

　　}

}, false, true）；

　　return result;

　　}

　　/**

　　* 删除对象 ,依赖key

　　*/

　　public void delete（String key） {

　　List<String> list = new ArrayList<String>（）；

　　list.add（key）；

　　delete（list）；

　　}

　　/**

　　* 删除集合 ,依赖key集合

　　*/

　　public void delete（List<String> keys） {

　　redisTemplate.delete（keys）；

　　}

　　/**

　　* 修改对象

　　*/

　　public boolean update（final Member member） {

　　String key = member.getId（）；

　　if （get（key） == null） {

　　throw new NullPointerException（"数据行不存在， key = " + key）；

　　}

　　boolean result = redisTemplate.execute（new RedisCallback<Boolean>（） {

　　public Boolean doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　byte[] key  = serializer.serialize（member.getId（））；

　　byte[] name = serializer.serialize（member.getNickname（））；

　　connection.set（key, name）；

　　return true;

　　}

　　}）；

　　return result;

　　}

　　/**

　　* 根据key获取对象

　　*/

　　public Member get（final String keyId） {

　　Member result = redisTemplate.execute（new RedisCallback<Member>（） {

　　public Member doInRedis（RedisConnection connection）

　　throws DataAccessException {

　　RedisSerializer<String> serializer = getRedisSerializer（）；

　　byte[] key = serializer.serialize（keyId）；

　　byte[] value = connection.get（key）；

　　if （value == null） {

　　return null;

　　}

　　String nickname = serializer.deserialize（value）；

　　return new Member（keyId, nickname）；

　　}

　　}）；

　　return result;

　　}

　　}

　　Controller实现

　　package com.pudp.bae.controller;

　　import java.util.HashMap;

　　import java.util.Map;

　　import javax.annotation.Resource;

　　import javax.servlet.http.HttpServletRequest;

　　import javax.servlet.http.HttpServletResponse;

　　import org.springframework.stereotype.Controller;

　　import org.springframework.web.bind.annotation.ModelAttribute;

　　import org.springframework.web.bind.annotation.PathVariable;

　　import org.springframework.web.bind.annotation.RequestMapping;

　　import org.springframework.web.bind.annotation.RequestMethod;

　　import org.springframework.web.servlet.ModelAndView;

　　import com.pudp.bae.base.BaseMultiController;

　　import com.pudp.bae.model.Member;

　　import com.pudp.bae.service.MemberService;

　　@Controller

　　@RequestMapping（value="/member"）

　　public class MemberController extends BaseMultiController{

　　@Resource（name="memberService"）

　　private MemberService memberService;

　　public void setMemberService（MemberService memberService） {

　　this.memberService = memberService;

　　}

　　@RequestMapping（value={"/add","/add.html"},method={RequestMethod.GET}）

　　public ModelAndView add（HttpServletRequest request,HttpServletResponse response）{

　　Map<String,Object> map = new HashMap<String, Object>（）；

　　return toView（"member/add", map）；

　　}

　　@RequestMapping（value={"/add","/add.html"},method={RequestMethod.POST}）

　　public ModelAndView addMember（HttpServletRequest request,HttpServletResponse response,

　　@ModelAttribute（"member"）Member member）{

　　Map<String,Object> map = new HashMap<String, Object>（）；

　　System.out.println（member）；

　　map.put（"message", "成功添加数据到库，" + member）；

　　this.memberService.add（member）；

　　return toView（"member/message", map）；

　　}

　　@RequestMapping（value={"/{id:\d+}/query","/{id:\d+}/query.html"},method={RequestMethod.GET,RequestMethod.POST}）

　　public ModelAndView queryMember（HttpServletRequest request,HttpServletResponse response,

　　@PathVariable（"id"）String id）{

　　Map<String,Object> map = new HashMap<String, Object>（）；

　　System.out.println（id）；

　　Member member = this.memberService.get（id）；

　　if（null!=member）{

　　map.put（"message", "查询Id=" + id + "的用户名为：" + member.getNickname（））；

　　}else{

　　map.put（"message", "没有查询到与Id=" + id + "相关的数据"）；

　　}

　　return toView（"member/message", map）；

　　}

　　@RequestMapping（value={"/{id:\d+}/delete","/{id:\d+}/delete.html"},method={RequestMethod.GET,RequestMethod.POST}）

　　public ModelAndView deleteMember（HttpServletRequest request, HttpServletResponse response,

　　@PathVariable（"id"）String id）{

　　Map<String,Object> map = new HashMap<String, Object>（）；

　　try {

　　this.memberService.delete（id）；

　　map.put（"message", "删除Id为" + id +"的用户成功。"）；

　　} catch （Exception e） {

　　e.printStackTrace（）；

　　map.put（"message", "删除Id为" + id +"的用户失败， "+e.getMessage（））；

　　}

　　return toView（"member/message", map）；

　　}

　　}

　　整合完毕。