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客户端代码如下：

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class TestCache {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		       String[] servers = { "192.168.74.129:12000,192.168.74.130:13000"};
		       SockIOPool pool = SockIOPool.getInstance();
		       pool.setServers(servers);
		       pool.setFailover(true);
		       pool.setInitConn(10);
		       pool.setMinConn(5);
		       pool.setMaxConn(250);
		       pool.setMaintSleep(30);
		       pool.setNagle(false);
		       pool.setSocketTO(3000);
		       pool.setAliveCheck(true);
		       pool.initialize();
		       MemCachedClient memCachedClient = new MemCachedClient();
		       boolean success = memCachedClient.set("zcy", "dataValue");
		       System.out.println(success);
		       Object obj= memCachedClient.get("zcy");
                System.out.println(obj);
		}
}

二.Memcached与Spring AOP构建数据库前端缓存框架，并用Maven来管理项目

（1）我们先温习一下Spring AOP

AOP（Aspect Orient Programming）面向切面编程,可以运用在事务管理、安全检查、缓存、对象池管理等。面向切面编程中有一个主要的是Advice，这个Advice定义好的切入点处，连接点之前先执行增强中的代码或者连接点执行后，再执行增强中的代码等。

（2）我们用Maven管理SpringMVC的jar和Memcached的jar

我们这里就介绍Memcached的jar,在POM.XML中添加Memcached对应的jar包

 <dependency>
  <groupId>com.danga</groupId>
  <artifactId>java-memcached</artifactId>
  <version>2.6.3</version>
 </dependency>
  <dependency>
        <groupId>commons-pool</groupId>
        <artifactId>commons-pool</artifactId>
        <version>1.5.6</version>
    </dependency>
   <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-simple</artifactId>
        <version>1.6.1</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.6.1</version>
    </dependency>

（3）用Spring来管理Memcached连接信息的配置和实现

1）global.properties 文件

#服务器地址
memcached.server=192.168.74.129:12000
memcached.server2=192.168.74.130:13000
#初始化时对每个服务器建立的连接数目
memcached.initConn=20
#每个服务器建立最小的连接数
memcached.minConn=10
#每个服务器建立最大的连接数
memcached.maxConn=50
#自查线程周期进行工作，其每次休眠时间
memcached.maintSleep=3000
#Socket的参数，如果是true在写数据时不缓冲，立即发送出去
memcached.nagle=false
#Socket阻塞读取数据的超时时间
memcached.socketTO=3000
memcached.aliveCheck=true
memcached.failover=true

2）Spring配置文件（applicationContext-memached.xml）

<!-- 注入属性文件 -->
	<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:global.properties</value>
			</list>
		</property>
	</bean>

   <bean id="memCachedPool" class="com.danga.MemCached.SockIOPool" factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
        <constructor-arg>
           <value>memcachedPool</value>
         </constructor-arg>

         <property name="servers">
             <list>
                <value>${memcached.server}</value>
                 <value>${memcached.server2}</value>
             </list>
         </property>
        <property name="initConn">
            <value>${memcached.initConn}</value>
        </property>

        <property name="minConn">
            <value>${memcached.minConn}</value>
        </property>

        <property name="maxConn">
            <value>${memcached.maxConn}</value>
        </property>

        <property name="maintSleep">
            <value>${memcached.maintSleep}</value>
         </property>

        <property name="nagle">
            <value>${memcached.nagle}</value>
        </property>

        <property name="socketTO">
             <value>${memcached.socketTO}</value>
        </property>
        <property name="aliveCheck">
             <value>${memcached.aliveCheck}</value>
        </property>
        <property name="failover">
             <value>${memcached.failover}</value>
        </property>

    </bean>

<bean id="memCachedClient" class="com.danga.MemCached.MemCachedClient">
         <constructor-arg>
           <span style="color:#ff0000;"><value>memcachedPool</value></span>
         </constructor-arg>
    </bean>

3）junit测试一下这样配置是否正确，代码如下：

  import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.danga.MemCached.MemCachedClient;

public class MemcachedServiceTest
{

	 private MemCachedClient  memCachedClient;
	 @Before
	  public void beforeTest(){
	        ApplicationContext atx = new ClassPathXmlApplicationContext("classpath:applicationContext-memached.xml");
	        memCachedClient = (MemCachedClient)atx.getBean("memCachedClient");
	 }

	@Test
	public void memCached()
	{
		boolean b=memCachedClient.set("hello","dataValue");
		System.out.println(b);
		Object obj=memCachedClient.get("hello");
		System.out.println(obj);

	}

}

能保存并能获取数据说明配置成功

（4）实现MVC业务逻辑

 //Dao层
@Service("dataDao")
public class DataDaoImpl implements DataDao {
	@Override
	public String getData(String name) {
		return name+" get data";
	}
}

//server层
  @Service("dataService")
public class DataServiceImpl implements DataService{
	@Autowired
	private DataDao dataDao;
	public String findDataByParams(String name) {

		return dataDao.getData(name);
	}
}
//Controller层
@Controller
public class IndexController {
	@Autowired
	private DataService dataService;

	@RequestMapping("/index")
	public String index(Model model,@RequestParam(value="name") String name){
	String dataValue=dataService.findDataByParams(name);
	System.out.println(dataValue);
		return "";
	}
}

（5）Spring AOP与Memcached构建数据库前端缓存框架

1）实现AOP的逻辑代码

@Service("dataInterceptor")
public class DataInterceptor  implements MethodInterceptor{
	@Autowired
	private MemCachedClient memCachedClient;
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		 Object[] args = invocation.getArguments();
	     String param=args[0].toString();
	     Object  object = null;
	     if(param!=null&&memCachedClient!=null){
	    	 object=memCachedClient.get(param);
	    	 System.out.println("执行从MemCached获取的值======="+object);
	     }
	     if(object==null){
	    	 object =invocation.proceed();
	    	 System.out.println("执行数据库操作获取的值======="+object);
				if (object != null) {
					boolean b=memCachedClient.set(param,object);
					if(b){
					 System.out.println("=====保存值"+object+"到memCached 成功===========");
					}else{
						 System.out.println("=====保存值"+object+"到memCached 失败===========");
					}
				}
	    	 System.out.println("没有从memCached获取===========");
	     }else{
	    	 System.out.println("从memCached获取======="+object);
	     }
		return object;
	}
}

2）Spring 配置文件配置AOP

  <bean id="dataInterceptorAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
		<property name="mappedName"><value>getData</value></property>
		<property name="advice" ref="dataInterceptor"/>
	</bean>

	<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="beanNames" value="dataDao"/>
		<property name="interceptorNames" value="dataInterceptorAdvisor"/>
	</bean>

配置了对哪个方法进行拦截，这里我们对getData方法进行拦截

（6）测试Spring AOP与Memcached构建数据库前端缓存框架

1)第一次执行我们传参数hello，Memcached里面肯定没有，因为是第一次执行，所示从数据库获取对应的值，并保存到Memcached服务端，如图所示：

2）执行第二次，参数是hello，这次没有去操作数据库，直接从Memcached服务端获取对应的值

3）我们这边对Memcached服务端进行集群部署，所以我们查看一下，数据保存到其中的一台，如图所示：

三．构建Memcached与Spring AOP构建数据库前端缓存框架出现的错误

Error:com.schooner.MemCached.SchoonerSockIOPool - attempting to get SockIO from uninitialized pool!

原因是我们设置MemCachedClient和SockIOPool的ProxName不一样导致，所以两个名称要一样，如图所示：

四.总结

我们在上一篇介绍了，Memcached集群部署，有两台memcached.server=192.168.74.129:12000 和memcached.server2=192.168.74.130:13000，我们通过Memcached客户端实现了分布式缓存的，Memcached服务端之间是不能通讯的，所示我们通过Memcached客户端实现分布式缓存的。

时间： 2024-11-07 13:17:23

Memcached与Spring AOP构建数分布式据库前端缓存框架的相关文章

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

数据库访问可能是很多网站的瓶颈.动不动就连接池耗尽.内存溢出等.前面已经讲到如果我们的网站是一个分布式的大型站点,那么使用 memcached实现数据库的前端缓存是个很不错的选择:但如果网站本身足够小只有一个服务器,甚至是vps的那种,不推荐使用memcached,使 用Hibernate或者Mybatis框架自带的缓存系统就行了. 一.开启memcached服务器端服务 如果已经安装了memcached服务器端程序,请确认服务器端服务已开启. 二.引入jar 1.  alisoft-xplat

Spring AOP +EHcache为Service层方法增加缓存

在铁科院做了一个关于医保报销的项目,在这个个系统中大量使用了下拉列表框,系统主要是给机关单位使用而且都是一些干部退休了啥的,年龄都比较大不愿意自己输入东西,因此界面上的很多值都是下拉列表框从数据字典表里面加载出来. 如此以来字典表的数据量变的越来越大,在一个界面上往往需要频繁的与字典表交互,觉的很影响性能于是我们增加了缓存,即为service层中的指定方法缓存功能,具体实现是利用Spring AOP+EHcache来做. 第一次执行某个方法的时候会去数据库里面查询,当第二次执行该方法时就会去从缓

spring cloud构建b2b2c分布式-搭建eureka服务

1.pom.xml 有spring cloud b2b2c电子商务需求的朋友可以加企鹅求求:三五三六二四七二五九 <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://mave

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

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

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 实现一个简单的memcached小插件

memcached我就不多做介绍了,也就是一个分布式缓存系统!是一个典型的NOSQL. 下面我将用spring aop来实现一个简单的插件,来实现annotation方式,简单方便的取得缓存 一.首先我们得定义一个annotation. <strong>package org.xiezhaodong.spring.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType

Spring Cloud构建微服务架构（四）分布式配置中心

Spring Cloud Config为服务端和客户端提供了分布式系统的外部化配置支持.配置服务器为各应用的所有环境提供了一个中心化的外部配置.它实现了对服务端和客户端对Spring Environment和PropertySource抽象的映射,所以它除了适用于Spring构建的应用程序,也可以在任何其他语言运行的应用程序中使用.作为一个应用可以通过部署管道来进行测试或者投入生产,我们可以分别为这些环境创建配置,并且在需要迁移环境的时候获取对应环境的配置来运行. 配置服务器默认采用git来存储

使用Redisson实现分布式锁，Spring AOP简化之

源码 Redisson概述 Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid).它不仅提供了一系列的分布式的Java常用对象,还提供了许多分布式服务.其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publi