zoukankan      html  css  js  c++  java

  • SpringMVC+redis整合

    转载：http://www.cnblogs.com/wuxinliulei/p/5216712.html

            http://www.tuicool.com/articles/7Bni6f

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

    1
    2
    3
    4
    5
    6
    7
    package com.pudp.bae.base;
     
    import java.io.Serializable;
     
    public abstract class BaseModel implements Serializable{
     
    }

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    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;
        }
    }
    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
    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(); 
      }
     
    }
    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
    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);
        }
     
    }

    　　

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    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);
         
    }

    　

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

    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" /> 
    <!--         如果不配置Serializer，那么存储的时候智能使用String，如果用User类型存储，那么会提示错误User can't cast to String！！！
      -->        <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>  
        
    </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>
  • 相关阅读:
    Android开发过程中的坑及解决方法收录（二）
    【转】Android开发之数据库SQL
    Android开发过程中的坑及解决方法收录（一）
    Android开发之基于监听的事件处理
    Android开发——导入github安卓项目源码
    Android开发之常见事件响应方式
    Android studio导入eclipse项目（亲测）
    Android开发——diglog cancel与dismiss方法区别
    Android开发——Toast知识
    android 点击返回键 以及 加载activity 生命周期 记录。。。，一目了然
  • 原文地址：https://www.cnblogs.com/ruiati/p/6378720.html
Copyright © 2011-2022 走看看