使用Memcached、Spring AOP构建数据库前端缓存框架

数据库访问可能是很多网站的瓶颈。动不动就连接池耗尽、内存溢出等。前面已经讲到如果我们的网站是一个分布式的大型站点，那么使用 memcached实现数据库的前端缓存是个很不错的选择；但如果网站本身足够小只有一个服务器，甚至是vps的那种，不推荐使用memcached，使 用Hibernate或者Mybatis框架自带的缓存系统就行了。

一、开启memcached服务器端服务

如果已经安装了memcached服务器端程序，请确认服务器端服务已开启。

二、引入jar

1.  alisoft-xplatform-asf-cache-2.5.1.jar

2.  commons-logging-1.0.4.jar

3.  hessian-3.0.1.jar

4.  log4j-1.2.9.jar

5.  stax-api-1.0.1.jar

6.  wstx-asl-2.0.2.jar

三、创建memcached客户端配置文件

[java] view plaincopy

  1. <memcached>
  2. <!-- name 属性是程序中使用Cache的唯一标识;socketpool 属性将会关联到后面的socketpool配置; -->
  3. <client name="mclient_0" compressEnable="true" defaultEncoding="UTF-8"
  4. socketpool="pool_0">
  5. <!-- 可选，用来处理出错情况 -->
  6. <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler
  7. </errorHandler>
  8. </client>
  9. <!--
  10. name 属性和client 配置中的socketpool 属性相关联。
  11. maintSleep属性是后台线程管理SocketIO池的检查间隔时间，如果设置为0，则表明不需要后台线程维护SocketIO线程池，默认需要管理。
  12. socketTO 属性是Socket操作超时配置，单位ms。 aliveCheck
  13. 属性表示在使用Socket以前是否先检查Socket状态。
  14. -->
  15. <socketpool name="pool_0" maintSleep="5000" socketTO="3000"
  16. failover="true" aliveCheck="true" initConn="5" minConn="5" maxConn="250"
  17. nagle="false">
  18. <!-- 设置memcache服务端实例地址.多个地址用","隔开 -->
  19. <servers>127.0.0.1:11211</servers>
  20. <!--
  21. 可选配置。表明了上面设置的服务器实例的Load权重. 例如 <weights>3,7</weights> 表示30% load 在
  22. 10.2.224.36:33001, 70% load 在 10.2.224.46:33001
  23. <weights>3,7</weights>
  24. -->
  25. </socketpool>
  26. </memcached>

四、创建memcached客户端程序

客户端工具类：

[java] view plaincopy

  1. package com.hl.usersmanager.memcached.client;
  2. import com.alisoft.xplatform.asf.cache.ICacheManager;
  3. import com.alisoft.xplatform.asf.cache.IMemcachedCache;
  4. import com.alisoft.xplatform.asf.cache.memcached.CacheUtil;
  5. import com.alisoft.xplatform.asf.cache.memcached.MemcachedCacheManager;
  6. public class MemcachedCache {
  7. private ICacheManager<IMemcachedCache> manager;
  8. private IMemcachedCache cache;
  9. public MemcachedCache(){
  10. manager = CacheUtil.getCacheManager(IMemcachedCache.class,
  11. MemcachedCacheManager.class.getName());
  12. manager.setConfigFile("memcached.xml");
  13. manager.setResponseStatInterval(5*1000);
  14. manager.start();
  15. cache = manager.getCache("mclient_0");
  16. }
  17. /**
  18. * 获取缓存接口
  19. * @return
  20. */
  21. public IMemcachedCache getCache(){
  22. return cache;
  23. }
  24. /**
  25. * 数据放入缓存
  26. * @param key
  27. * @param object
  28. */
  29. public void put(String key,Object object){
  30. cache.put(key, object);
  31. }
  32. /**
  33. * 从缓存中读取数据
  34. * @param key
  35. * @return
  36. */
  37. public Object get(String key){
  38. return cache.get(key);
  39. }
  40. }

五、使用Spring AOP在数据查询的Service层实现数据缓存及读取

实现数据缓存的过程很简单，就是在Service层查询数据库操作前判断要查询的数据在缓存中是否存在，如果不存在就到数据库中查询，查询完成后将数据放入缓存系统；如果要查询的数据在缓存中已经存在，则直接从缓存中读取，不需要操作数据库。这就大大降低了数据库的连接次数。原理就是这么简单。

但是，如果直接对Service层代码进行修改，就违背了“开放-封闭”原则，也会导致缓存系统的操作代码散落到Service层的各处，不方便代码的管理和维护。所以，Spring
AOP华丽登场了。它使用非入侵式的来创建、管理这些缓存操作代码。

关于Spring AOP本身的一些知识，我们这里不做讲述。参考资料：

由于首先要判断查询数据是否存在于缓存系统，如果存在直接从缓存中读取，也就是说Service层的查询代码根本不会执行；另一方面，如果数据在缓存系统中不存在，从数据库查询出的结果，我们需要将其放入缓存系统中。

我们来看Spring AOP的几个装备中哪个适用呢？那就是最强大的环绕通知装备@Around！

下面以UserService为例，其源代码如下：

[java] view plaincopy

  1. package com.hl.usersmanager.service.impl;
  2. import java.util.List;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Service;
  5. import org.springframework.transaction.annotation.Transactional;
  6. import com.hl.usersmanager.dao.IUserMapper;
  7. import com.hl.usersmanager.model.Users;
  8. import com.hl.usersmanager.service.IUserService;
  9. //使用Service注解 不需要再在配置文件中配置bean
  10. @Service
  11. public class UserServiceImpl implements IUserService{
  12. @Autowired
  13. private IUserMapper userMapper;
  14. @Override
  15. @Transactional
  16. public Users findUserByName(String name) {
  17. return userMapper.findUserByName(name);
  18. }
  19. ……
  20. }

findUserByName主要实现按照用户名查询用户的功能，现在我们使用Spring AOP来实现缓存：

[java] view plaincopy

  1. package com.hl.usersmanager.aop.service;
  2. import org.apache.log4j.Logger;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import com.hl.usersmanager.memcached.client.MemcachedCache;
  9. import com.hl.usersmanager.model.Users;
  10. @Aspect
  11. public class UserServiceInterceptor {
  12. public static final Logger log = Logger
  13. .getLogger(UserServiceInterceptor.class);
  14. //将缓存客户端工具类 MemcachedCache 织入进来
  15. @Autowired
  16. private MemcachedCache memcachedCache;
  17. /*
  18. * 定义pointcunt
  19. */
  20. @Pointcut("execution(* com.hl.usersmanager.service.impl.UserServiceImpl.*(..))")
  21. public void aPointcut() {
  22. }
  23. /**
  24. * 环绕装备 用于拦截查询 如果缓存中有数据，直接从缓存中读取；否则从数据库读取并将结果放入缓存
  25. *
  26. * @param call
  27. * @param name
  28. * @return
  29. */
  30. @Around("aPointcut()&&args(name)")
  31. public Users doFindUserByNameAround(ProceedingJoinPoint call, String name) {
  32. Users users = null;
  33. if (memcachedCache.getCache().containsKey("findUserByName_" + name)) {
  34. users = (Users) memcachedCache.get("findUserByName_" + name);
  35. log.debug("从缓存中读取！findUserByName_" + name);
  36. } else {
  37. try {
  38. users = (Users) call.proceed();
  39. if (users != null) {
  40. memcachedCache.put("findUserByName_" + name, users);
  41. log.debug("缓存装备被执行：findUserByName_" + name);
  42. }
  43. } catch (Throwable e) {
  44. e.printStackTrace();
  45. }
  46. }
  47. return users;
  48. }
  49. }

环绕通知装备需要一个ProceedingJoinPoint 类型的参数，它的强大之处在于可以代理一个我们的切入点，指定切入点方法是否执行，或者获取执行后的返回结果！！

memcachedCache.getCache().containsKey("findUserByName_" + name)

可以判断缓存中是否有指定的数据。如果有则直接从缓存中读取：

users = (Users) memcachedCache.get("findUserByName_" + name);

否则调用切入点UserServiceImpl的findUserByName方法：

users = (Users) call.proceed();

call.proceed()表示执行切入点的方法。

使用Spring AOP以后，整个缓存系统代码看起来 就是这么优雅！UserServiceImpl根本不知道外界发了什么，更不知道外界调用它的findUserByName的时候已经被拦截了！

那天不用缓存系统，只需要将Aop这块的代码去掉即可。

当然，我们还需要在Spring配置文件中注册一个memcached客户端工具类的bean：

[java] view plaincopy

    1. <!-- MemcachedCache缓存 -->
    2. <bean id="MemcachedCache" class="com.hl.usersmanager.memcached.client.MemcachedCache"></bean>
时间： 2024-08-11 09:40:02

使用Memcached、Spring AOP构建数据库前端缓存框架的相关文章

Memcached与Spring AOP构建数分布式据库前端缓存框架

由于上一篇有介绍了Memcached缓存,并集群部署,这边我们就不介绍,我们直接介绍Memcached与Spring AOP构建分布式数据库前端缓存框架 一.Java 实现Memcached客户端,实现分布式 (1)需要的jar 1)commons-pool-1.5.6.jar 2)java_memcached-release_2.6.3.jar 3)slf4j-api-1.6.1.jar 4)slf4j-simple-1.6.1.jar (2)Java 实现Memcached客户端代码如下:

Spring AOP+自定义注解实现缓存

Spring AOP配置: <aop:config> <aop:aspect ref="cacheAdvice"> <aop:pointcut id="cachePointcut" expression="execution(* cn.vobile.service..*.*(..)) and @annotation(cacheable)"/> <aop:around method="cacheD

Spring AOP整合redis 实现缓存统一管理

项目使用redis作为缓存数据,但面临着问题,比如,项目A,项目B都用到redis,而且用的redis都是一套集群,这样会带来一些问题.问题:比如项目A的开发人员,要缓存一些热门数据,想到了redis,于是乎把数据放入到了redis,自定义一个缓存key:hot_data_key,数据格式是项目A自己的数据格式,项目B也遇到了同样的问题,也要缓存热门数据,也是hot_data_key,数据格式是项目B是自己的数据格式,由于用的都是同一套redis集群,这样key就是同一个key,有的数据格式适合

Spring实战（九）AOP概念以及Spring AOP

1.横切关注点(cross-cutting concern) 软件开发中,散布于应用中多处的功能被称为横切关注点,如事务.日志.安全. 横切关注点从概念上是与应用的业务逻辑相分离的(但是往往会直接嵌入到应用的业务逻辑中),而把横切关注点和业务逻辑分离正是AOP要解决的问题. DI用于应用对象之间的解耦,AOP实现横切关注点与他们所影响的对象之间的解耦. 2.重用通用功能,最常见的技术是继承和委托 继承会导致脆弱的对象体系:委托可能需要对委托对象进行复杂的调用. 所以用切面取而代之. 3.AOP术

spring Aop概念

面向切面编程(AOP)通过提供另外一种思考程序结构的途经来弥补面向对象编程(OOP)的不足.在OOP中模块化的关键单元是类(classes),而在AOP中模块化的单元则是切面.切面能对关注点进行模块化,例如横切多个类型和对象的事务管理.(在AOP术语中通常称作横切(crosscutting)关注点.) AOP框架是Spring的一个重要组成部分.但是Spring IoC容器并不依赖于AOP,这意味着你有权利选择是否使用AOP,AOP做为Spring IoC容器的一个补充,使它成为一个强大的中间件

Spring AOP初步总结(一)

学习AOP有段时间了,一直没空总结一下,导致有些知识点都遗忘了,之后会把以前学过的Spring核心相关的知识点总结一轮... 先大体介绍下Spring AOP的特点(均摘自"Spring in action第四版"): Spring支持了AOP,另外还有很多实现了AOP的技术,例如AspectJ,它补充了Spring AOP框架的功能,他们之间有着大量的协作,而且Spring AOP中大量借鉴了AspectJ项目,Spring AOP相对粗粒度,而AspectJ提供更强大更细粒度的控制

Spring AOP构成Spring框架的重要基石

Spring AOP是构成Spring框架的重要基石,spring AOP 构建在IOC 之上,和ioc浑然天成,统一于Spring容器之中. AOP有特定的应用场合:适合于具有特定逻辑的应用场合,如性能检测,访问控制,事物管理以及日志记录. AOP(Aspect Oriented Programing)面向切面编程,根据软件重构的思想,如果多个类中出现相同的代码,将这些相同的代码提取到父类中,AOP通过横向抽取机制为这类无法通过纵向继承体系进行抽象的重复性代码提供了解决方按. AOP术语:1,

spring AOP Capability and Goals（面向方面编程功能和目标归纳）

原官方文档链接: https://docs.spring.io/spring/docs/5.1.6.RELEASE/spring-framework-reference/core.html#aop-introduction-spring-defn 个人归纳: Spring AOP Capabillity 是用纯Java实现的,不需要特殊的编译过程. 不需要控制类加载器层次结构,因此适合在servlet容器或应用程序服务器中使用. 目前仅支持方法执行连接点(建议在Spring bean上执行方法)

Spring AOP Capabilities and Goals

Spring AOP目前仅支持方法执行连接点(建议在Spring bean上执行方法).虽然可以在不破坏核心Spring AOP API的情况下添加对字段拦截的支持,但未实现字段拦截.如果您需要建议字段访问和更新连接点,请考虑使用AspectJ等语言. Spring AOP的AOP方法与大多数其他AOP框架的方法不同.目的不是提供最完整的AOP实现(尽管Spring AOP非常强大).相反,目标是在AOP实现和Spring IoC之间提供紧密集成,以帮助解决企业应用程序中的常见问题. 因此,例如