SpringMVC+redis整合

时间：2023-12-15 19:58:08

SpringMVC+redis整合

SpringMVC+redis整合

在网络上有一个很多人转载的springmvc+redis整合的案例，不过一直不完整，也是被各种人装来转去，现在基本将该框架搭建起来。

package com.pudp.bae.base;

import java.io.Serializable;

public abstract class BaseModel implements Serializable{

}

　　

package com.pudp.bae.base;

import java.util.Map;

import org.springframework.web.servlet.ModelAndView;

public class BaseMultiController {

	protected ModelAndView toView(final String url,final Map<String,Object> map)

	{

		ModelAndView  view = new ModelAndView(url);

		return view;

	}

}

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.controller;

import java.util.HashMap;

import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

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

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 {

	@Autowired

	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>();

		Member member = new Member();

		member.setId("1");

		member.setNickname("guoxiaoming");

		this.memberService.add(member);

		return toView("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("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("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("message", map);

	}

}

　　

package com.pudp.bae.dao.redis;

import java.util.List;

import com.pudp.bae.model.Member;

public interface MemberDao {

	boolean add(Member member);

	abstract boolean add(List<Member> list);

	void delete(String key);

	Member get(String keyId);

}

　

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;

@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

   */

  @Override

  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获取对象

   */

  @Override

  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.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;

  }

}

package com.pudp.bae.service;

import javax.annotation.Resource;

import com.pudp.bae.dao.redis.MemberDao;

import com.pudp.bae.model.Member;

public class MemberService {

	 @Resource(name="memberDao")

	 private MemberDao memberDao;

	 public void setMemberDao(MemberDao memberDao)

	 {

	    this.memberDao = memberDao;

	 }

     public void add(Member member){

    	 memberDao.add(member);

     }

     public void delete(String id){

    	 memberDao.delete(id);

     }

     public Member get(String id)

     {

    	 return memberDao.get(id);

     }

}

redis-context.xml

<beans	 xmlns="http://www.springframework.org/schema/beans"

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

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

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

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

       xsi:schemaLocation="

      http://www.springframework.org/schema/beans

      http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

      http://www.springframework.org/schema/tx

      http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

      http://www.springframework.org/schema/context

      http://www.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>

spring-context.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:p="http://www.springframework.org/schema/p"

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

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

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

      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd

      http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd

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

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

    <mvc:annotation-driven />

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

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

    <bean id="memberService" class="com.pudp.bae.service.MemberService"/>

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

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

</beans>

spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"

     xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.0.xsd

         http://www.springframework.org/schema/mvc

         http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<!-- 配置视图解析器，把控制器的逻辑视频映射为真正的视图 -->

<!-- /WEB-INF/jsp/start.jsp -->

<bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">

	<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>

	<property name="prefix" value="/WEB-INF/jsp/" />

	<property name="suffix" value=".jsp" />

</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=xx

redis.maxIdle=300

redis.maxActive=600

redis.maxWait=1000

redis.testOnBorrow=true

web.xml

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

<web-app version="2.4" aaxmlns="http://java.sun.com/xml/ns/j2ee"

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

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

	<display-name>SpringMVCRedis</display-name>

	<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>

	<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>

2018年5月16号更

时过境迁，没想到两年多前的一个笔记还有那么多人关注，在此补上当时源码包(幸好找到了)

https://download.csdn.net/download/wuxinliulei/10417976

附上csdn的下载路径

相关文章