springmvc-spring-mybatis-redis实现简单的CRUD

最新推荐文章于 2023-03-09 14:41:57 发布

天体_

最新推荐文章于 2023-03-09 14:41:57 发布

阅读量139

点赞数

分类专栏： spring mybatis总结 redis 文章标签： java

本文链接：https://blog.csdn.net/qq_41740369/article/details/112231834

版权

spring 同时被 3 个专栏收录

3 篇文章 0 订阅

订阅专栏

mybatis总结

2 篇文章 0 订阅

订阅专栏

redis

2 篇文章 0 订阅

订阅专栏

本文介绍了如何使用Spring MVC、Spring MyBatis和Redis实现简单的CRUD操作。涉及内容包括controller、mapper接口及XML配置、pojo实体类、redis缓存处理、service接口及实现类，以及相关的配置文件如log4j.properties、spring-mvc.xml和spring-mybatis.xml。作者自认对Redis理解尚浅，欢迎读者交流指正。

摘要由CSDN通过智能技术生成

controller类

package com.zking.controller；
import com.zking.mapper.IusersMapper;
import com.zking.pojo.User;
import com.zking.redis.RedisCacha;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Controller
@RequestMapping("UsersController")
public class UsersController {
//创建全局变量 Key
    private final String key = "com.zking.service.impl.UsersServiceImpl";
//得到iusersMapper接口实现类
    @Autowired
    public IusersMapper iusersMapper;
    //得到redisCacha接口实现类
    @Autowired
    public RedisCacha redisCacha;


   //判断是否要读取缓存信息
//        //如果没缓存信息那么就先加载到缓存中 然后根据当前数据库返回的信息返回来进行数据的返回
//        //如果有缓存那么直接读取缓存中的信息
//
//        String outStr = redisCache.getRedisString(key);
//        System.out.println(outStr);
//        if (outStr == null) {
//            redisCache.setRedisString(key,smbms_roleimpl.Smbms_roleFindAll());
//            //没有缓存 加入缓存
//            ObjectMapper objectMapper=new ObjectMapper();
//            //将数据转换成json格式
//            outStr= objectMapper.writeValueAsString(smbms_roleimpl.Smbms_roleFindAll());
//          //将数据加入到redis中
//            redisCache.setRedisString(key,outStr);
//        }
//        return outStr;
//    }
//先删除缓存     然后add edit 数据库数据 查询数据

//add edit 成功更新数据  读取redis缓存 并将缓存转换为list集合 然后重新写入到redis中
//key值不改变的情况下 value会覆盖








    //判断是否要读取缓存信息
    //如果没缓存信息那么就先加载到缓存中 然后根据当前数据库返回的信息返回来进行数据的返回
    //如果有缓存那么直接读取缓存中的信息
    @ResponseBody
    @RequestMapping(value = "FindAll")
    public String FindAll() throws Exception {
        String outStr = redisCacha.getRedisDate(key);
        if (outStr == null) {
            redisCacha.setRedisDate(key, iusersMapper.FindAll());
        }
        return outStr;
}


//增加缓存
    @ResponseBody
    @RequestMapping("Add")
    public Map Add(User user) throws Exception {
        Map<String, String> map = new HashMap<>();
        if (iusersMapper.Add(user) > 0) {
            //首先获取缓存中的集合
            //将当前对象加入到集合中
            //将集合重新写入缓存中
            List<User> lu = redisCacha.getRedisDateList(key, User.class);
            lu.add(user);
            redisCacha.setRedisDate(key, lu);
            map.put("masage", "y");
        } else {
            map.put("masage", "n");
        }
        return map;
    }


 //更新数据，读取redis的缓存，并将缓存转换为list的集合，然后重新写入到redis中，
    //key值不改变的情况下，value会覆盖。
    @ResponseBody
    @RequestMapping("Edit")
    public Map Edit(User user) throws Exception {
        Map<String, String> map = new HashMap<>();
        if (iusersMapper.Edit(user) > 0) {
            //首先获取缓存中的集合
            //将当前对象加入到集合中
            //将集合重新写入缓存中
            List<User> lu = redisCacha.getRedisDateList(key, User.class);
            for (User u : lu) {
                if (u.getId().equals(user.getId())) {
                    u.setUname(user.getUname());
                    u.setUpwd(user.getUpwd());
                }
            }
            redisCacha.setRedisDate(key, lu);
            map.put("masage", "y");
        } else {
            map.put("masage", "n");
        }
        return map;
    }

    //删除
    @RequestMapping("Delete")
    public Map Delete(User user) throws Exception {
        Map<String, String> map = new HashMap<>();
        if (iusersMapper.Delete(user) > 0) {
            //首先获取缓存中的集合
            //将当前对象加入到集合中
            //将集合重新写入缓存中
            List<User> lu = redisCacha.getRedisDateList(key, User.class);
            for (User u : lu) {
                if (user.getId().equals(u.getId())) {
                    lu.remove(user);
                    redisCacha.setRedisDate(key, lu);
                    map.put("masage", "y");
                    break;
                }
            }
        } else {
            map.put("masage", "n");
        }
        return map;
    }

mapper包

IusersMapper接口

    public List<User> FindAll();
    public int Add(User user);
    public int Edit(User user);
    public int Delete(User user);

UsersMapper.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zking.mapper.IusersMapper">
    <select id="FindAll" resultType="User">

        select * FROM  user

    </select>

    <insert id="Add" parameterType="User">
        <selectKey keyProperty="id" resultType="java.lang.Integer" order="BEFORE">
            SELECT uuid();
        </selectKey>
        INSERT  INTO  USER VALUES (#{id},#{uname},#{upwd});
    </insert>


    <update id="Edit" parameterType="User">
        UPDATE USER  <set>
        <if test="uname!=null">
          AND  uname=#{uname}
        </if>
        <if test="upwd!=null">
          and  upwd=#{upwd}
        </if>
    </set>
        where id=#{id}
    </update>

    <delete id="Delete" parameterType="User">
        delete from user where id=#{id}
    </delete>



    <select id="findlogin" resultType="java.lang.String" parameterType="java.lang.String">
        select upwd from user where uname=#{uname}
    </select>
</mapper>

pojo包

User类

package com.zking.pojo;

public class User {
//id
    private String id;
//用户名
    private String uname;
//密码
    private String upwd;

//无参方法
    public User() {
    }

    //有参方法  
    public User(String id, String uname, String upwd) {
        this.id = id;
        this.uname = uname;
        this.upwd = upwd;
    }

    //get set 方法
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getUpwd() {
        return upwd;
    }

    public void setUpwd(String upwd) {
        this.upwd = upwd;
    }

    //toString输出
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", uname='" + uname + '\'' +
                ", upwd='" + upwd + '\'' +
                '}';
    }
}

redis包

RedisCacha

package com.zking.redis;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.org.apache.bcel.internal.generic.RETURN;
import redis.clients.jedis.JedisPool;

import java.util.ArrayList;
import java.util.List;

public class RedisCacha {
    //redis的缓冲池
    private JedisPool jedisPool;

    public JedisPool getJedisPool() {
        return jedisPool;
    }

    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

//查询是否有缓存 没有就 设置redis缓存
    public <T> void setRedisDate(String key, T value) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String outStr = objectMapper.writeValueAsString(value);
        if (outStr != null) {
            jedisPool.getResource().set(key, outStr);
        }
    }
//获取redis缓存方法
    public String getRedisDate(String key) {
        return jedisPool.getResource().get(key);
    }
//返回一个获取redis缓存信息（list）
    public <T> List<T> getRedisDateList(String key,Class<T> values) throws  Exception {
        String readStr = jedisPool.getResource().get(key);
        ObjectMapper objectMapper = new ObjectMapper();
        JavaType javaType = objectMapper.getTypeFactory().constructParametricType(ArrayList.class, values);
        return objectMapper.readValue(readStr, javaType);
    }
//返回一个获取的redis缓存信息
    public  <T> T getRedisDateobject(String key,Class<T> values)throws  Exception{
        String readStr = jedisPool.getResource().get(key);
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.readValue(readStr,values);
    }

}

service包impl类

IusersService接口


    public List<User> FindAll();
    public int Add(User user);
    public int Edit(User user);
    public int Delete(User user);

UsersServiceImpl类

@Service
public class UsersServiceImpl implements IusersService {
    @Autowired
    public IusersMapper IusersMapper;
查询
    @Override
    public List<User> FindAll() {
        return IusersMapper.FindAll();
    }
//增加
    @Override
    public int Add(User user) {
        return IusersMapper.Add(user);
    }
//修改
    @Override
    public int Edit(User user) {
        return IusersMapper.Edit(user);
    }
//删除
    @Override
    public int Delete(User user) {
        return IusersMapper.Delete(user);
    }

resources

log4j.properties

log4j.rootLogger=INFO,Console,File  
#定义日志输出目的地为控制台  
log4j.appender.Console=org.apache.log4j.ConsoleAppender  
log4j.appender.Console.Target=System.out  
#可以灵活地指定日志输出格式，下面一行是指定具体的格式  
log4j.appender.Console.layout = org.apache.log4j.PatternLayout  
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n  

#文件大小到达指定尺寸的时候产生一个新的文件  
log4j.appender.File = org.apache.log4j.RollingFileAppender  
#指定输出目录  
log4j.appender.File.File = logs/ssm.log  
#定义文件最大大小  
log4j.appender.File.MaxFileSize = 10MB  
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志  
log4j.appender.File.Threshold = ALL  
log4j.appender.File.layout = org.apache.log4j.PatternLayout  
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

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

    <!--1) 排除扫描@Component、@Repository、@Service 注解-->
    <context:component-scan base-package="com.zking.controller"></context:component-scan>
    <!--2) 此标签默认注册DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
    <!--两个bean，这两个bean是spring MVC为@Controllers分发请求所必须的。并提供了数据绑定支持，-->
    <!--@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）-->
    <mvc:annotation-driven>
        <!--解决ResponseBody中文乱码问题-->
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes" value="text/http;charset=UTF-8"></property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--但是，从spring3.1开始DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter的使用已经过时-->
    <!--spring3.1开始我们应该用RequestMappingHandlerMapping 来替换DefaultAnnotationHandlerMapping，-->
    <!--spring3.1开始我们应该用用RequestMappingHandlerAdapter 来替换AnnotationMethodHandlerAdapter-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>
    <bean id="mappingJackson2HttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <!--处理中文乱码以及避免IE执行AJAX时，返回JSON出现下载文件-->
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
                <value>text/json;charset=UTF-8</value>
                <value>application/json;charset=UTF-8</value>
            </list>
        </property>
    </bean>


    <!--3) ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--4) 单独处理图片、样式、js等资源 -->
    <!--<mvc:resources location="/css/" mapping="/css/**"/>-->
    <!--<mvc:resources location="/images/" mapping="/images/**"/>-->
    <!--<mvc:resources location="/js/" mapping="/js/**"/>-->
    <!--<mvc:resources location="/jsp/" mapping="/jsp/**"/>-->
    <!--<mvc:resources location="/jquery-easyui/" mapping="/jquery-easyui/**"/>-->


    <!-- ********************* 国际化配置开始***************** -->
    <!--修改springmvc-servlet.xml-->
    <!--1) 配置国际化资源文件 -->
    <!--<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">-->
    <!--<property name="basenames">-->
    <!--<list>-->
    <!--<value>i18n</value>-->
    <!--</list>-->
    <!--</property>-->
    <!--</bean>-->
    <!--&lt;!&ndash;2) 指定语言区域解析器，由它来确定使用哪个语言 &ndash;&gt;-->
    <!--<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">-->
    <!--</bean>-->
    <!--&lt;!&ndash;3) 配置国际化操作拦截器&ndash;&gt;-->
    <!--<mvc:interceptors>-->
    <!--<bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"/>-->
    <!--</mvc:interceptors>-->


    <!-- ********************* 文件上传配置开始***************** -->
    <!--<bean id="multipartResolver"-->
          <!--class="org.springframework.web.multipart.commons.CommonsMultipartResolver">-->
        <!--&lt;!&ndash; 必须和用户JSP 的pageEncoding属性一致，以便正确解析表单的内容 &ndash;&gt;-->
        <!--<property name="defaultEncoding" value="UTF-8"></property>-->
        <!--&lt;!&ndash; 文件最大大小(字节) 1024*1024*100=50M&ndash;&gt;-->
        <!--<property name="maxUploadSize" value="52428800"></property>-->
        <!--&lt;!&ndash;resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常&ndash;&gt;-->
        <!--<property name="resolveLazily" value="true"/>-->
    <!--</bean>-->
</beans>

spring-mybatis.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans      http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
	http://www.springframework.org/schema/context    http://www.springframework.org/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 开启注解-->
    <context:component-scan base-package="com.zking"></context:component-scan>

    <!-- 配置dbcp数据库连接池 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!-- 数据库用户名 -->
        <property name="username" value="root"></property>
        <!-- 数据库密码 -->
        <property name="password" value="sasa"></property>
        <!-- 数据库连接驱动 -->
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <!-- 数据库连接地址 -->
        <property name="url" value="jdbc:mysql://localhost:3306/zx?characterEncoding=UTF-8"></property>
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="20"></property>
        <!-- 连接池最大数量 -->
        <property name="maxActive" value="100"></property>
        <!-- 连接池最大空闲 -->
        <property name="maxIdle" value="20"></property>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="1"></property>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="6000"></property>
    </bean>

    <!--配置sessionFactory工厂类-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="com.zking.pojo"></property>
        <!--这会从类路径下加载所有在 com.zking.mappers 包和它的子包中的 MyBatis 映射器 XML 配置文件-->
        <property name="mapperLocations" value="classpath*:com/zking/mapper/*.xml"></property>

    </bean>
    <!--配置mapperScannerConfigurer自动扫描 将Mapper接口生成代理注入到Spring
Mybatis在与Spring集成的时候可以配置MapperFactoryBean来生成Mapper接口的代理-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zking.mapper"></property>
        <property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
    </bean>

    <!--配置事务-->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--开启事务-->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"></tx:annotation-driven>

    <!--创建jedis的池子-->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="host" value="192.168.203.130"></constructor-arg>
        <constructor-arg name="port" value="6379"></constructor-arg>
    </bean>
    <!--注入对象给redis自定义类使用-->
    <bean id="redisCacha" class="com.zking.redis.RedisCacha">
        <property name="jedisPool" ref="jedisPool"></property>
    </bean>


</beans>

maven依赖

 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <!--spring 版本号-->
    <spring.version>4.3.10.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.4.5</mybatis.version>
    <!-- slf4j日志文件版本 -->
    <slf4j.version>1.7.7</slf4j.version>
    <!-- log4j日志文件版本 -->
    <log4j.version>1.2.17</log4j.version>
    <!--mybatis-sping 版本-->
    <mybatis-spring.version>1.3.1</mybatis-spring.version>
    <!--mysql 版本-->
    <mysql-version>5.1.43</mysql-version>
    <!--jackson 版本-->
    <jackson-version>2.9.2</jackson-version>
    <!--servlet 版本-->
    <servlet-version>4.0.0</servlet-version>
    <!--dbcp 版本-->
    <dbcp-version>1.4</dbcp-version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- spring核心包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- mybatis核心包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!-- mybatis/spring包 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis-spring.version}</version>
    </dependency>
    <!--加入servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet-version}</version>
    </dependency>

    <!-- 导入Mysql数据库链接jar包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-version}</version>
    </dependency>
    <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>${dbcp-version}</version>
    </dependency>


    <!-- 日志文件管理包 -->
    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!-- log end -->

    <!--加入jackson包-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson-version}</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jackson-version}</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${jackson-version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- 引入jedis依赖 -->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
    </dependency>

总结：我对redis只了解皮毛，请各位大佬指点指点我不足之处，继续加油下次出更细的知识；

天体_

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
springmvc-spring-mybatis-redis实现简单的CRUD

controller类package com.zking.controller；import com.zking.mapper.IusersMapper;import com.zking.pojo.User;import com.zking.redis.RedisCacha;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller
复制链接

扫一扫

专栏目录