SpringMVC+redis整合

最新推荐文章于 2024-07-25 13:50:57 发布

天枫丶

最新推荐文章于 2024-07-25 13:50:57 发布

阅读量841

点赞数

文章标签： redis spring mvc

在网络上有一个很多人转载的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>

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

原文地址：点击查看原文

天枫丶

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
SpringMVC+redis整合

在网络上有一个很多人转载的springmvc+redis整合的案例，不过一直不完整，也是被各种人装来转去，现在基本将该框架搭建起来。package com.pudp.bae.base; import java.io.Serializable; public abstract class BaseModel implements Serializable{ }pa
复制链接

扫一扫