Building a database front-end caching framework using memcached, Spring AOP

Database access can be a bottleneck for many websites. Connection pool exhaustion, memory overflow, and so on. As already mentioned, if our site is a large distributed site, then using memcached to implement a database's front-end caching is a good choice, but if the site itself is small enough to have only one server, or even the kind of VPS, it is not recommended to use memcached, so Use Hibernate or the MyBatis framework to bring your own cache system on the line.

First, open memcached server-side services

If you have already installed the Memcached server-side program, make sure that the server-side service is turned on.

Ii. introduction of 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

Iii. Creating a memcached client configuration file

[Java]View Plaincopy

2. <memcached>
4. <!--The Name property is a unique identifier for using the cache in the program; the Socketpool property will be associated to the Socketpool configuration later; -
6. <client name= "Mclient_0" compressenable= "true" defaultencoding= "UTF-8"
8. Socketpool= "Pool_0" >
10. <!--optional to handle errors--
12. <errorhandler>com.alisoft.xplatform.asf.cache.memcached.memcachederrorhandler
14. </errorHandler>
16. </client>
20. <!--
22. The Name property is associated with the Socketpool property in the client configuration.
24. The Maintsleep property is the check interval for the background thread management Socketio pool, and if set to 0, indicates that no background thread is required to maintain the socketio thread pool, which is managed by default.
26. The Socketto property is the socket operation timeout configuration, in unit Ms. Alivecheck
28. property indicates whether the socket state is checked before using the socket.
30. -
32. <socketpool name= "Pool_0" maintsleep= "socketto=" 3000 "
34. Failover= "true" alivecheck= "true" initconn= "5" minconn= "5" maxconn= "250"
36. Nagle= "false" >
38. <!--set the Memcache server instance address. Multiple addresses with "," separated--
40. <servers>127.0.0.1:11211</servers>
42. <!--
44. Optional configuration. Indicates the load weight of the server instance set above. For example, <weights>3,7</weights> indicates that 30% load is
46. 10.2.224.36:33001, 70% load in 10.2.224.46:33001
50. <weights>3,7</weights>
52. -
54. </socketpool>
56. </memcached>

Iv. Creating a memcached client program

Client Tool Classes:

[Java]View Plaincopy

2. Package com.hl.usersmanager.memcached.client;
6. Import Com.alisoft.xplatform.asf.cache.ICacheManager;
8. Import Com.alisoft.xplatform.asf.cache.IMemcachedCache;
10. Import Com.alisoft.xplatform.asf.cache.memcached.CacheUtil;
12. Import Com.alisoft.xplatform.asf.cache.memcached.MemcachedCacheManager;
16. public class Memcachedcache {
18. Private icachemanager<imemcachedcache> Manager;
20. Private Imemcachedcache Cache;
24. Public Memcachedcache () {
26. Manager = Cacheutil.getcachemanager (Imemcachedcache.class,
28. MemcachedCacheManager.class.getName ());
30. Manager.setconfigfile ("Memcached.xml");
32. Manager.setresponsestatinterval (5*1000);
34. Manager.start ();
36. Cache = Manager.getcache ("Mclient_0");
38. }
42. /**
44. * Get Cache interface
46. * @return
48. */
50. Public Imemcachedcache GetCache () {
52. return cache;
54. }
58. /**
60. * Data into the cache
62. * @param key
64. * @param Object
66. */
68. public void put (String key,object Object) {
70. Cache.put (Key, object);
72. }
76. /**
78. * Read data from the cache
80. * @param key
82. * @return
84. */
86. Public Object get (String key) {
88. return Cache.get (key);
90. }
92. }

V. Using spring AOP to implement data caching and reading at the service layer of the data query

The process of implementing data caching is simple, that is, before the service layer queries the database operation to determine whether the data to be queried exists in the cache, if it does not exist in the database query, the query is completed after the data into the cache system, if the data to be queried in the cache already exists, it is read directly from the cache. You do not need to manipulate the database. This greatly reduces the number of connections to the database. The principle is so simple.

However, if the service layer code is directly modified, it violates the "open-closed" principle, it will also cause the operation code of the cache system scattered throughout the service layer, inconvenient code management and maintenance. So, Spring AOP is a gorgeous debut. It uses non-intrusive to create and manage these cache operation codes.

We don't tell you about the knowledge of spring AOP itself. Resources:

As the first to determine whether the query data exists in the cache system, if there is directly read from the cache, that is, the service layer of the query code is not executed at all, on the other hand, if the data does not exist in the cache system, from the database query results, we need to put it into the cache system.

What do we see in some of the equipment for spring AOP? That's the most powerful surround-notice outfit @Around!

The following is an example of userservice with the following source code:

[Java]View Plaincopy

2. Package Com.hl.usersmanager.service.impl;
6. Import java.util.List;
10. Import org.springframework.beans.factory.annotation.Autowired;
12. Import Org.springframework.stereotype.Service;
14. Import org.springframework.transaction.annotation.Transactional;
18. Import Com.hl.usersmanager.dao.IUserMapper;
20. Import Com.hl.usersmanager.model.Users;
22. Import Com.hl.usersmanager.service.IUserService;
26. Using service annotations does not require the bean to be configured in the configuration file
28. @Service
30. public class Userserviceimpl implements iuserservice{
32. @Autowired
34. Private Iusermapper Usermapper;
38. @Override
40. @Transactional
42. Public Users finduserbyname (String name) {
44. return Usermapper.finduserbyname (name);
46. }
50. ......
52. }

Finduserbyname primarily implements the ability to query users by user name, and now we use Spring AOP to implement caching:

[Java]View Plaincopy

2. Package com.hl.usersmanager.aop.service;
6. Import Org.apache.log4j.Logger;
8. Import Org.aspectj.lang.ProceedingJoinPoint;
10. Import Org.aspectj.lang.annotation.Around;
12. Import Org.aspectj.lang.annotation.Aspect;
14. Import Org.aspectj.lang.annotation.Pointcut;
16. Import org.springframework.beans.factory.annotation.Autowired;
20. Import Com.hl.usersmanager.memcached.client.MemcachedCache;
22. Import Com.hl.usersmanager.model.Users;
26. @Aspect
28. public class Userserviceinterceptor {
30. public static final Logger log = Logger
32. . GetLogger (Userserviceinterceptor.class);
36. To weave the Cache client tool class Memcachedcache in
38. @Autowired
40. Private Memcachedcache Memcachedcache;
44. /*
46. * Define Pointcunt
48. */
50. @Pointcut ("Execution (* com.hl.usersmanager.service.impl.userserviceimpl.* (..))")
52. public void Apointcut () {
56. }
60. /**
62. * Surround equipment to intercept queries if there is data in the cache, read directly from the cache, otherwise read from the database and put the results in the cache
64. *
66. * @param call
68. * @param name
70. * @return
72. */
74. @Around ("Apointcut () &&args (name)")
76. Public Users Dofinduserbynamearound (Proceedingjoinpoint call, String name) {
78. Users users = null;
80. if (Memcachedcache.getcache (). ContainsKey ("finduserbyname_" + name)) {
82. Users = (users) memcachedcache.get ("finduserbyname_" + name);
84. Log.debug ("read from Cache! Finduserbyname_ "+ name);
86. } else {
88. try {
90. Users = (users) call.proceed ();
92. if (users! = null) {
94. Memcachedcache.put ("finduserbyname_" + Name, users);
96. Log.debug ("Cache equipment is executed: finduserbyname_" + name);
98. }
100. } catch (Throwable e) {
102. E.printstacktrace ();
104. }
106. }
108. return users;
110. }
112. }

Surround notification equipment requires a parameter of type Proceedingjoinpoint, its strength is that it can proxy a pointcut, specify whether the Pointcut method executes, or get the result after execution!!

Memcachedcache.getcache (). ContainsKey ("finduserbyname_" + name)

You can determine whether there is a specified data in the cache. If any, read directly from the cache:

Users = (users) memcachedcache.get ("finduserbyname_" + name);

Otherwise, call the Pointcut Userserviceimpl's Finduserbyname method:

Users = (users) call.proceed ();

Call.proceed () represents the method that executes the pointcut.

With spring AOP, the entire cache system code looks so elegant! Userserviceimpl do not know what the outside world, more do not know the outside call its finduserbyname time has been intercepted!

You don't need to cache the system that day, just remove the code from the AOP block.

Of course, we also need to register a bean for the Memcached Client tool class in the Spring configuration file:

[Java]View Plaincopy

1. <!--Memcachedcache Cache--
2. <bean id= "Memcachedcache" class= "Com.hl.usersmanager.memcached.client.MemcachedCache" ></bean>

Building a database front-end caching framework using memcached, Spring AOP