Spring MVC + Redis 使用Maven

最新推荐文章于 2025-06-02 15:47:25 发布
原创 最新推荐文章于 2025-06-02 15:47:25 发布 · 1.8k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Spring MVC #Redis #Maven

按照我的思路去配，已跑通！！！
 
import java.io.Serializable;
 
public abstract class BaseModel implements Serializable{
 
}

　　

1
 
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;
    }
}

 

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

 

1
 
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);
    }
 
}

　　

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

　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
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; 
  } 
 
}

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

 

 
 
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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

1
2
3
4
5
6
7
8
9
10
11
# 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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?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>

SpringMVC使用Redis
数据产品小lee
09-30 9246
前置： 1.下载Redis，启动Redis 2.使用idea内置Maven工具构建SpringMVC项目 参考链接：idea创建SpringMVC项目 本次目标：将对象序列化到Redis中，从Redis中取出。 先单元测试测试Service层，再启动应用测试Controller层。 idea创建maven项目。pom文件如下: &lt;?xml version="1.0" encoding="...
使用maven简单搭建Spring mvc + redis缓存
05-31
使用maven简单搭建Spring mvc + redis缓存 个人实验成功
springmvc集成redis的Demo基于maven（内有redis）
05-12
该项目使用spring4.2和redis集成的一个小demo，其中包含32位和64位的redis客户端和服务器端，项目导入即可运行（需要maven环境）
springmvc整合redis架构搭建实例
weixin_39403708的博客
08-26 228
1 原文 http://www.cnblogs.com/dennisit/p/3614521.html 2 3 新换环境,又有新东西可以学习了,哈皮! 抽空学习之余看了一下redis,个人对Springmvc的爱是忠贞不渝,所以整理了一下Springmvc整合redis的环境搭建.分享学习. 4 5 第一步 :...
Maven, SpringMVC, Redis, MyBatis集成框架实现
最新发布
weixin_32099703的博客
06-02 938
在Web应用中，异常处理是一个不可忽视的部分。Spring MVC提供了灵活的方式来统一处理异常。通过使用注解可以创建一个全局的异常处理器，再结合注解可以为特定异常定义处理方法。return mv;// 其他特定异常处理方法...在上面的代码中，标识了这个类作为一个全局异常处理类，而注解表明方法用于处理所有继承自Exception的异常。当异常发生时，Spring MVC会调用此方法，返回一个指定的视图（在这个例子中是名为error的视图）。
SpringMVC中使用Redis
程序员小挽的博客
10-28 2067
SpringMVC中使用Redis。
销售系统项目，spring+spring mvc+mybatis+dubbo+kafka+redis+maven.zip
08-20
【标题】"销售系统项目，spring+spring mvc+mybatis+dubbo+kafka+redis+maven.zip" 提供了一个综合的IT解决方案，涉及到的技术栈主要包括Spring、Spring MVC、MyBatis、Dubbo、Kafka、Redis以及Maven。这个项目采用...
spring+springMVC+Mybatis+MYSQL+Redis+Maven项目整合源码
01-06
该项目是一个基于Spring、SpringMVC、Mybatis、MySQL、Redis和Maven的综合应用实例，旨在为初学者提供一个清晰易懂的学习平台。下面将详细解释这些技术组件及其在项目中的作用。 **Spring框架**： Spring是Java企业...
一个基于SSMM（SpringMVC+ Spring + Mybatis + Redis + Maven）的练手Demo.zip
06-07
本项目是一个基于 Spring MVC + Spring + Mybatis + Redis + Maven 的入门级(拥有完整的登录/注册逻辑)Demo，是在SSM-Demo项目的基础上修改、调整而来，主要涉及以下几项技术及知识点： 使用SpringMVC作MVC控制器；...
基于Springboot+Mybatis+ SpringMvc+springsecrity+Redis完整网站后台管理系统
10-31
项目描述 说明： spring security 全注解式的权限管理 动态配置权限，角色和资源，权限控制到...Springboot+Mybatis+ SpringMvc+springsecrity+Redis+bootstrap+jquery 数据库文件 压缩包内 jar包文件 maven搭建
Java中使用redis所需要的pom依赖
热门推荐
qq_41774226的博客
04-26 3万+
&lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artifactId&gt;jedis&lt;/artifactId&gt; &lt;version&gt;2.1.0&lt;/version&gt; &lt;/dependency&gt; &lt;depende
Spring mvc整合redis实例（测试通过）
09-07
一款封装比较全的 sping 整合 redis实例。 不是Spring-date-redis的，是另一种集成方式，从网上整理的代码，测试已跑通。
SpringMVC+redis集成demo，超简单使用案例
04-19
SpringMVC+redis 简单案例，实现了简单的redis存取功能，以及springmvc的实例化功能，SpringMVC+redis 简单案例，实现了简单的redis存取功能，以及springmvc的实例化功能，SpringMVC+redis 简单案例，实现了简单的redis存取功能，以及springmvc的实例化功能
SpringMVC+maven+redis集成示例
04-05
SpringMVC+maven+redis集成教程 http://blog.youkuaiyun.com/u012775558/article/details/68937298
maven+spring4+springmvc+redis实现分页
08-08
只要你的redis已经准备好即可。该项目需要maven依赖，请自行安装maven。然后把redis的链接地址改一下，用tomcat发布项目之后，进入项目:浏览器地址栏输入http://localhost:8080/ProjectRedis/mvc/news/query?current=1即可进入项目后面的current代表了分页【开始进入时没有数据，在首页进行添加即可】
Redis的maven依赖
weixin_48766614的博客
06-19 6885
Redis的maven依赖 <dependencies> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.7.1</version><!--版本号--> </depe
Redis搭建：Maven+Spring+SpringMVC+Redis
qq_25635139的博客
01-23 410
下载之后直接解压得到以下目录结构 点击redis-server.exe即可启动Redis数据库 输出信息：启动成功、端口号、pid 即启动成功。   二、搭建开发环境 1&gt;搭建springmvc支持 &lt;!-- 搭建springmvc --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework&...
SpringMVC使用 redis 实现缓存
少年闰土
02-28 716
SpringMVC 中也可以将缓存标签和 redis 结合起来使用，其实此时缓存没有起作用，只是通过缓存的那几个注解来操作 redis 而已；SpringMVC 中整合 redis 比较麻烦的是注意版本冲突的问题，如下是官网有关于版本的要求。
SpringMvc 集成Redis
qq_37537164的博客
04-12 1358
spring mvc 集成 redis
Spring MVC+Redis缓存快速搭建教程
在标题“使用maven简单搭建Spring mvc + redis缓存”中提到的任务是将这三个组件整合起来，构建一个简单的Spring MVC应用，同时利用Redis来实现数据的缓存。在描述“使用maven简单搭建Spring mvc + redis缓存 个人...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值