Spring4.X + Spring MVC + Mybatis3 零配置应用开发框架搭建详解(5) - Redis缓存配置

最新推荐文章于 2024-04-25 08:00:00 发布
最新推荐文章于 2024-04-25 08:00:00 发布
阅读量8.3k 收藏 9
点赞数 2
分类专栏： Spring Spring4.x零配置集成框架 文章标签： Spring4.x零配置框架搭建 Spring4.x零配置
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chwshuang/article/details/52238728
版权

Spring4.X + Spring MVC + Mybatis3 零配置应用开发框架搭建详解(5) - Redis缓存配置

对于缓存管理，其实就是四个步骤

  • 第一，在【cache】组件中的pom.xml中加入redis的第三方java客户端jedis的jar包
  • 第二，通过编写一个缓存配置类，来管理连接池
  • 第三，编写缓存服务，提供缓存操作接口
  • 第四，在需要使用缓存服务的【back】服务中，加入项目依赖，其他任何服务需要使用缓存服务，都可以配置类似的依赖
  • 第五，在【back】服务启动配置中加入缓存配置类，以保障缓存服务能再服务启动的时候初始化
  • 第六，在需要使用缓存服务的模块中，编写业务代码，完成缓存操作。

1. 加入缓存jar包依赖配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>web</artifactId>
        <groupId>com.aitongyi.web</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cache</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- CacheService缓存服务中需要用到的对象依赖    -->
        <dependency>
            <groupId>com.aitongyi.web</groupId>
            <artifactId>bean</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- Redis依赖    -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.2</version>
        </dependency>
    </dependencies>
</project>


2. 创建配置对象

  

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;


import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = {"com.aitongyi.web.cache"})
public class CacheConfig {
    /** redis缓存服务器地址    */
    @Value("${redis.host}")
    private String host;
    /** redis缓存服务器端口    */
    @Value("${redis.port}")
    private Integer port;
    /** redis缓存服务器连接超时时间    */
    @Value("${redis.timeout}")
    private Integer timeout;

    @Bean(name = "jedisPool")
    public JedisPool jedispool() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxWaitMillis(30000); //  最大等待时间
        config.setMaxTotal(32);         //  最大连接数
        config.setMinIdle(6);           //  允许最小的空闲连接数
        config.setTestOnBorrow(false);  //  申请到连接时是否效验连接是否有效,对性能有影响,建议关闭
        config.setTestOnReturn(false);  //  使用完连接放回连接池时是否效验连接是否有效,对性能有影响,建议关闭
        config.setTestWhileIdle(true);  //  申请到连接时,如果空闲时间大于TimeBetweenEvictionRunsMillis时间,效验连接是否有效,建议开启,对性能有效不大
        config.setTimeBetweenEvictionRunsMillis(30000); //TestWhileIdle的判断依据
        return new JedisPool(config, host, port, timeout);
    }
}


3. 创建缓存服务

/**
 * 缓存服务
 * Created by admin on 16/8/18.
 */
@Component
public class CacheService {
    @Autowired
    private JedisPool jedisPool;

    /**
     * 设置缓存对象
     * @param key
     * @param value
     */
    public void set(String key,String value){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            jedis.set(key, value);
        }finally{
            if(jedis != null){
                jedis.close();
            }
        }
    }

    /**
     * 获取缓存对象
     * @param key
     * @return
     */
    public String get(String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            return jedis.get(key);
        }finally{
            if(jedis != null){
                jedis.close();
            }
        }
    }

    /**
     * 删除缓存对象
     * @param key
     */
    public void del(String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            jedis.del(key);
        }finally{
            if(jedis != null){
                jedis.close();
            }
        }
    }

}

4. 对缓存服务的依赖管理

在【back】服务中的pom.xml中加入【cache】模块的依赖

<dependencies>
        <dependency>
            <groupId>com.aitongyi.web</groupId>
            <artifactId>dao</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>com.aitongyi.web</groupId>
            <artifactId>bean</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>com.aitongyi.web</groupId>
            <artifactId>service</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>com.aitongyi.web</groupId>
            <artifactId>task</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--  缓存模块  -->
        <dependency>
            <groupId>com.aitongyi.web</groupId>
            <artifactId>cache</artifactId>
            <version>${project.version}</version>
        </dependency>

5. 缓存配置加入项目启动配置中

在【back】项目中的com.aitongyi.web.back.conf.WebApplicationInitializer类中加入缓存项目的配置类【CacheConfig.class】

import com.aitongyi.web.cache.conf.CacheConfig;
import com.aitongyi.web.dao.conf.DatabaseConfig;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;

/**
 * 项目启动基类
 * -- 整个项目的入口
 */
public class WebApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
	/**
	 * 获取配置信息
	 * @return
	 */
	@Override
	protected Class<?>[] getRootConfigClasses() {
		return new Class[] { BackConfig.class, DatabaseConfig.class, SecurityConfig.class, CacheConfig.class};
	}
	@Override
	protected Class<?>[] getServletConfigClasses() {
		return new Class[] { MvcConfig.class };
	}

	@Override
	protected String[] getServletMappings() {
		return new String[] { "/" };
	}

	@Override
	protected Filter[] getServletFilters() {
		return null;
	}
}


6. 缓存业务操作代码

在操作业务代码时，需要一些工具类，比如json操作的fastjson，需要在pom.xml中加入依赖，

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.6</version>
        </dependency>

然后在用户控制器中加入处理逻辑

import com.aitongyi.web.bean.User;
import com.aitongyi.web.cache.CacheService;
import com.aitongyi.web.service.UserService;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * 用户请求处理器
 * Created by admin on 16/8/6.
 */
@Controller
public class UserController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    @Autowired
    private CacheService cacheService;

    @RequestMapping(value = "/home", method = RequestMethod.GET)
    @PreAuthorize("isAuthenticated()")// isAuthenticated 如果用户不是匿名用户就返回true
    public String showHomePage() {
        try {
            
            User user = userService.loadUserByUsername("admin");

//            测试缓存服务
//            缓存用户对象到redis,以用户ID区分
            cacheService.set("LOGIN_USER_" + user.getId(), JSON.toJSONString(user));
//            从缓存中取出
            String userStr = cacheService.get("LOGIN_USER_" + user.getId());
//            进行反序列化
            User u = JSON.parseObject(userStr, User.class);
            if(u != null){
                logger.info("user:{}", u);
            }
            logger.info("load user ");
        }catch (Exception e){
            logger.error(e.getLocalizedMessage(), e);
        }

        return "/index/index";
    }
}

当然，直接打印user会出现 @45sd3sdf这样的情况，需要重写User的toString方法 

import java.util.Date;

/**
 * Created by admin on 16/8/8.
 */
public class User {
    private Integer id;
    private String username;
    private String password;
    private boolean enabled;
    private Date createDate;

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    public Integer getId() {
        return id;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("User{");
        sb.append("id=").append(id);
        sb.append(", username='").append(username).append('\'');
        sb.append(", password='").append(password).append('\'');
        sb.append(", enabled=").append(enabled);
        sb.append(", createDate=").append(createDate);
        sb.append('}');
        return sb.toString();
    }
}

7. 加入数据库配置

在【back】项目的back.properties中，增加redis和mysql的连接配置

#redis
redis.host = 127.0.0.1
redis.port = 6380
redis.timeout = 2000

#========= Mysql ============
jdbc.driver = com.mysql.jdbc.Driver
db.url = jdbc:mysql://127.0.0.1/web?useUnicode=true&characterEncoding=UTF-8
db.username = web
db.password = 123456
db.maxtotal = 150
db.minidle = 40
db.maxidle = 60
这两个配置意味着你需要在本机安装一个redis服务器（默认端口6379），端口是6380，本机安装一个mysql，并创建一个名称为web的库，使用utf-8这个字符集，并且创建一个web的用户，密码是123456，另外需要在数据库中创建两张表，一个是【users】表，用来存储用户信息，另外一个是【authorities】表，用来存储权限信息 

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;


# Dump of table authorities
# ------------------------------------------------------------

DROP TABLE IF EXISTS `authorities`;

CREATE TABLE `authorities` (
  `username` varchar(50) NOT NULL,
  `authority` varchar(50) NOT NULL,
  UNIQUE KEY `ix_auth_username` (`username`,`authority`),
  CONSTRAINT `fk_authorities_users` FOREIGN KEY (`username`) REFERENCES `users` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

LOCK TABLES `authorities` WRITE;
/*!40000 ALTER TABLE `authorities` DISABLE KEYS */;

INSERT INTO `authorities` (`username`, `authority`)
VALUES
	('admin','ROLE_ADMIN');

/*!40000 ALTER TABLE `authorities` ENABLE KEYS */;
UNLOCK TABLES;


# Dump of table users
# ------------------------------------------------------------

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  `enabled` tinyint(1) NOT NULL,
  `create_date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ix_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

LOCK TABLES `users` WRITE;
/*!40000 ALTER TABLE `users` DISABLE KEYS */;

INSERT INTO `users` (`id`, `username`, `password`, `enabled`, `create_date`)
VALUES
	(1,'admin','e10adc3949ba59abbe56e057f20f883e',1,'2016-08-18 14:51:06');

/*!40000 ALTER TABLE `users` ENABLE KEYS */;
UNLOCK TABLES;

表创建完成，数据写入完成，启动服务器，运行back这个web项目，就可以看到登录页面，输入用户名admin，密码123456，登录，完成我们的操作。

然后看看日志，就可以看到存储缓存和打印缓存数据的日志了。如果你有兴趣，还可以在代码上打上断点，用debug模式启动，然后一步步的看运行状态！



8. 缓存KEY管理最佳实践

到此，缓存就说完了，这里要提一下这个redis的key，很多时候我们开发，定义redis中的缓存key很随意，也不规范，结果导致最终key管理混乱，代码管理难度加大。通过我们的项目，可以看到，每个功能基本是分模块的，在缓存中，需要定义一个公共的KEY管理类，所有的key都通过这个公共类来声明，如果要看缓存中定义了那些Key，就可以从这个类中一目了然。

下面我们就用【UserController】中的一个缓存KEY来做例子说明一下：

原来的key是这样的：

//            缓存用户对象到redis,以用户ID区分
            cacheService.set("LOGIN_USER_" + user.getId(), JSON.toJSONString(user));
//            从缓存中取出
            String userStr = cacheService.get("LOGIN_USER_" + user.getId());


通过统一管理，我们要再【cache】模块下创建一个CacheKey：

/**
 * 缓存Key统一管理类
 * Created by admin on 16/8/18.
 */
public class CacheKey {

    /**
     * <pre>
     * 登录用户缓存Key
     * 格式 :  str.login.user.{userId}
     * </pre>
     */
    public static final String LOGIN_USER_KEY = "str.login.user.";
}

然后将原来的代码改为： 

//            缓存用户对象到redis,以用户ID区分
            cacheService.set(CacheKey.LOGIN_USER_KEY + user.getId(), JSON.toJSONString(user));
//            从缓存中取出
            String userStr = cacheService.get(CacheKey.LOGIN_USER_KEY + user.getId());

通过这样的管理，所有用户都统一的缓存Key的使用，如果要查看redis中用了那些缓存key，缓存中的key代表什么意思，就一目了然了。


目录

        （一）基本介绍    
        （二）基础框架搭建
        （三）实现最基本的登录处理        
        （四）任务调度管理   
        （五）Redis缓存配置
        （六）安全框架集成

        （七） git版本源代码下载


大大的微笑
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Spring 4.x版本新特性
生活在别处
09-11 515
jdbc:initialize-database 和 jdbc:embedded-database 支持可配置的分离器被应用到每个脚本。整个框架代码都基于Java 8，并且自2016年7月起与Java 9完全兼容。这是基于Java5的第一个版本，旨在充分利用Java5的功能。Spring从1.0开始，至今已经更新到5.x版本。第一个完全支持Java 8的版本。
Spring4 全细节回顾
pshdhx的博客
01-08 481
spring4的全细节回顾。包括IOC，AOP，代理模式和单例模式，事务控制等的配置详解
解读Spring 4.x架构
Samurai77的博客
03-04 376
Spring简介 Spring官方主页（http://spring.io）有两句话： Let’s build a better Enterprise. 　　我们共同来构建更好的企业应用。 　　Spring helps development teams everywhere build simple, portable, fast and flexible JVM-based systems an...
SpringMVC——AbstractAnnotationConfigDispatcherServletInitializer如何基于Java配置的方式来替代传统的web.xml配置文件。
最新发布
程序员阿皓的博客
04-25 433
在这个示例中，MyWebAppInitializer类继承自AbstractAnnotationConfigDispatcherServletInitializer，并实现了三个抽象方法，分别指定了根应用上下文的配置类。是一个抽象类，用于配置Spring应用程序的DispatcherServlet和ContextLoaderListener。应用上下文的配置类ServletConfig，以及DispatcherServlet的映射为"/"。：用于指定DispatcherServlet应用上下文的配置类。
【深入浅出Spring原理及实战】「缓存Cache开发系列」带你深入分析Spring所提供的缓存Cache抽象详解的核心原理探索
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
05-27 925
在Java中，我们通常会对方法调用进行缓存控制，例如对于方法 “getValueByKey(String key)”，我们应该首先从缓存中查找是否有对应的数据，如果没有再调用该方法从数据库中加载用户数据，并将其添加到缓存中。自Spring 3.1起，提供了Cache支持，且提供了Cache抽象，在此之前一般通过AOP实现，使用Spring Cache的好处：提供基本的Cache抽象，方便切换各种底层Cache；缓存的工作机制是先从缓存中读取数据，如果没有再从慢速设备上读取实际数据，并将数据存入缓存中。
Spring4基础知识(一)
我能在河边钓一整天的鱼
03-26 392
IOC Inversion of Control，其思想是反转资源获取的方向，传统的资源查找方式要求组件向容器发起请求查找资源。作为回应，容器适时的返回资源，而应用了IOC之后，则是容器主动地将资源推送给它所管理的组件，组件所要做的仅是选择一种合适的方式来接受资源。这种行为也被称为查找的被动形式 DI Dependency Injection IOC的另一种表...
spring-boot+redis+mybatis.zip
07-30
本项目案例结合了Spring Boot、Redis缓存和MyBatis持久层框架，旨在提供一个高效、可扩展的应用程序开发模板。本文将详细解析这一整合过程中的关键知识点。 首先，Spring Boot是Spring框架的简化版本，它通过自动...
spring、 spring mvc、 mybatis 开发的java客户关系管理系统,前端采用easyui编写.zip
06-18
《基于Spring、Spring MVC、MyBatis的Java客户关系管理系统详解》 在现代企业运营中，客户关系管理（CRM）系统扮演着至关重要的角色，它帮助企业有效地管理与客户的交互，提高销售效率，优化客户服务，从而增强企业...
spring+springmvc+mybatis简单框架搭建
05-31
在本项目中，我们主要探讨的是如何搭建一个基于Spring、SpringMVC和MyBatis的简单Web应用程序框架，也就是SSM框架。这是一个经典的Java后端开发组合，常用于构建高效、可扩展的企业级应用。首先，让我们逐一了解这三...
基于SSM（springmvc+spring+mybatis）+Mysql图书管理系统.zip
12-25
同时，还要熟悉Spring Boot的使用，这是一个集成了大量默认配置的框架，使得开发环境搭建和应用部署变得极其简便。 在实际运行中，用户可以通过前端界面进行图书的添加、删除、修改和查询操作。后台系统会根据请求...
spring4 中文API
10-08
版权归原作者所有
配置Spring4.0注解Cache+Redis缓存的用法
08-30
本篇文章主要介绍了详解配置Spring4.0注解Cache+Redis缓存的用法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring mvc整合redis实例(redis连接池)
09-19
Spring mvc整合redis实例(redis连接池) 将所有jedis 增删改进行事务的封装、查询单独做为有返回参数的封装。简化了很多代码
Spring4 视频教程
05-15
Spring4.0是 Spring 推出的一个重大版本升级，进一步加强了 Spring 作为 Java 领域第一开源平台的地位。Spring4.0 引入了众多 Java 开发者期盼的新特性，如泛型依赖注入、SpEL、校验及格式化框架、Rest风格的 WEB 编程模型等。
Redis之—— Spring4.0 注解Cache+Redis缓存
冰河的专栏
04-26 4099
前言：       目前公司项目在上一个技术架构的处理，已经搭建好了Redis，但redis只用在了做session的管理，然而 后台的对象缓存没有用上  1. redis 和 ehcache的区别        简单了解了下，个人觉得 从部署上而言，redis更适合分布式部署，ehcache是在每台应用服务器上开辟一块内存做缓存，集群时还得考虑缓存的情况， redis就不需要考虑缓存了
Spring4实战（一）-Spring的前世今生
Ricky
12-25 2867
Spring简介Spring 是一个轻量级的控制反转（ IOC，Inversion of Control）/（DI ，Dependency Injection）和 面向切面（AOP，Aspect Oriented Programming） 容器框架，它为简化企业级应用开发而生。使用 Spring 可以使简单的JavaBean 实现以前只有 EJB 才能实现的功能。Spring作为现在最优秀的框架之一
Spring 4.x 总体架构
大龙的博客
12-05 431
一、架构图 spring framework 总共分为三层，底层是核心层，包含 beans、core、context 和 expression（spel），中间层是封装的J2EE服务（企业层），包含aop、aspects、instrument 和 messaging，最上层是应用层，包含两部分，一部分是数据层，包含jdbc、orm、oxm 和 jms，两一部分是web层，包含web、webmvc...
使用Spring4搭建Java web项目(初级入门)
复制乔布斯
07-13 7131
spring框架搭建！
spring boot + spring security + jwt + spring mvc + mybatis + redis商城项目
12-12
Spring Boot 可以用于构建商城项目的后端服务，Spring Security 可以确保用户信息的安全性，JWT 可以用于用户的身份验证，Spring MVC 可以处理前端请求，MyBatis 可以操作数据库，Redis 可以用于缓存用户信息和商品...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值