Once the Memcached server has been installed you may start it by typing memcached at the command line. When you execute memcached without any command-line options, the Memcached server will start up on port 11211 with 64 MB of memory by default. You can achieve greater control over how to start Memcached such as changing the port or running as a daemon. Use the help option to view all the available command line options: 

memcached –help

Testing the installation.

For debugging purposes, it is useful to use telnet to fire commands against Memcached. Start telnet on your localhost connecting to port 11211 as fallows:

To start memcached on localhost and on port 1121 with maximum 32 MB of main memory as the root user:

memcached -u root -m 32 127.0.0.1 -p 1121
telnet 127.0.0.1 11211
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
set my_key 0 60 1 
1
STORED
get my_key
VALUE my_key 0 1
1
END

If at any time you wish to terminate the Telnet session, simply type “quit” and hit return:

quit
Connection closed by foreign host.

For more commands follow below links  click here

To access the cache from a Java application, first we need to open a connection to a memcached process:

try {
   client = new MemcachedClient(new InetSocketAddress(hostname, port));
} catch (IOException e) {
   e.printStackTrace();
   System.err.println("connection problem");
}

After creating a MemcachedClient, we can now perform operations on the items in the cache. Each item in the cache is associated with a key and an expiration time value. Setting an item in the cache is straightforward, all we need to specify is a key,the corresponding value and an expiration time after which the item will be evicted from the cache. The set operation is asynchronous in the memcached library:

client.set(key, expiration, val);

To get an item, we specify its key. It is possible to perform both synchronous and asynchronous gets with the memcached library. For example

try {
   retrieved = f.get(GET_TIMEOUT, TimeUnit.SECONDS);
  // async get,  timeout after  GET_TIMEOUT  seconds
  // throws InterruptedException, ExecutionException or TimeoutException
} catch (Exception e) {
   // process timeout
   f.cancel(true);// cancel the task
}

Sample Java code to test memcached

import java.io.IOException;
import java.net.InetSocketAddress;
import net.spy.memcached.MemcachedClient;

public class MemcachedTestClient {

 public static void main(String[] args) {
 //initialize Memcached Server Connection
 InetSocketAddress address=new InetSocketAddress("localhost", 11211);

 try {
 MemcachedClient mcc = new MemcachedClient(address);
 mcc.add("someKey", 3600, "Radhey");
 // Retrieve a value (synchronously).
 System.out.println(mcc.get("someKey"));
 //To change value
 mcc.set("someKey", 3600, "Shyam"); 
 System.out.println(mcc.get("someKey"));

 //To delete
 mcc.delete("someKey"); 
 System.out.println(mcc.get("someKey"));

 } catch (IOException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 } 
 }
}

Add memcached-2.6.jar file in lib folder if you are getting error. Download

Using memcache with Spring and maven

Follow the below steps

Step 1 : Create a maven java project and put the project name what ever you want. In my case i am using MemcacheExample.

Step 2: In The pom.xml file add the below dependency

<dependencies>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring</artifactId>
 <version>2.5.6.SEC03</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-asm</artifactId>
 <version>3.1.4.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-beans</artifactId>
 <version>3.2.3.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>3.2.3.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>3.2.3.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
 <version>3.2.3.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-expression</artifactId>
 <version>3.2.3.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>com.danga</groupId>
 <artifactId>memcached</artifactId>
 <version>2.0.1</version>
 </dependency>
 <dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-log4j12</artifactId>
 <version>1.5.6</version>
 <type>jar</type>
 <scope>compile</scope>
 </dependency>
 </dependencies>

Step 3: Create a resource folder and named it config

Step 4: Create a memcache.properties file in config folder and paste below contents into the file.

memcache.poolname=POOL
memcache.server.ip=localhost
memcache.server.port=11211
memcache.initConn=5
memcache.minConn=5
memcache.maxConn=250
memcache.maxIdle=21600000
memcache.socketTO=3000
memcache.socketConnectTO=0
memcache.nagle=false
memcache.maintSleep=30

Step 5: Create xml file having name of memcacheConfig.xml for spring and memcache configuration. And paste below contents into  this.

<?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:p="http://www.springframework.org/schema/p"
 xmlns:context="http://www.springframework.org/schema/context"
 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"> 
 <context:property-placeholder location="classpath:memcache.properties"/>
 <bean id="memcachedSockIOPool" class="com.danga.MemCached.SockIOPool" init-method="initialize" factory-method="getInstance" autowire-candidate="true">
 <constructor-arg type="java.lang.String" value="${memcache.poolname}"/>
 <property name="servers">
 <list>
 <value type="java.lang.String">${memcache.server.ip}:${memcache.server.port}</value>
 </list>
 </property>
 <property name="initConn" value="${memcache.initConn}"/>
 <property name="minConn" value="${memcache.minConn}"/>
 <property name="maxConn" value="${memcache.maxConn}"/>
 <property name="maxIdle" value="${memcache.maxIdle}"/>
 <property name="socketTO" value="${memcache.socketTO}"/>
 <property name="socketConnectTO" value="${memcache.socketConnectTO}"/>
 <property name="nagle" value="${memcache.nagle}"/>
 <property name="maintSleep" value="${memcache.maintSleep}"/>
 </bean> 
 <bean id="memcache-initialize" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
 <property name="targetObject"><ref local="memcachedSockIOPool"/></property>
 <property name="targetMethod"><value>initialize</value></property>
 </bean>
 <context:annotation-config />
</beans>

Step 6: Create a package com.radhey.memcache.manager for creating class for memcache manager.

Step 7: create a class MemcachedManager.java for handing memcache service

package com.radhey.memcache.manager;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import com.danga.MemCached.MemCachedClient;
@Component
@Scope("prototype")
public class MemcachedManager {
 private MemCachedClient memCachedClient;

 public MemCachedClient getMemCachedClient() {
 return memCachedClient;
 }

 public void setMemCachedClient(MemCachedClient memCachedClient) {
 this.memCachedClient = memCachedClient;
 }

 protected Object get(String key){
 if ((key == null) || (key.trim().equals(""))){
 System.out.println("Get attempt against null or empty key.Returning null value.");
 return null;
 }
 System.out.println("Memcache key = " + key);
 return memCachedClient.get(key);
 }

 protected boolean add(String key, Object value){
 boolean status = false;
 if ((key == null) || (key.trim().equals(""))){
 System.out.println("Add attempt against null or empty key.");
 return status;
 }

 if (value == null){
 System.out.println("Add attempt of null value against key = " + key);
 return status;
 }

 System.out.println("Memcache key = " + key);

 if (get(key) != null){
 System.out.println("Add attempt of value which is already present in memcache against key = " + key);
 status = replace(key, value);
 return status;
 }else 
 status = memCachedClient.add(key, value);

 if (status){
 System.out.println("Successfully added value against key = " + key);
 //addMemcacheKeyToMaster(key);
 }else {
 System.out.println("Failed to add value against key = " + key);
 }
 return status;
 }

 protected boolean add(String key, Object value, Date date){
 boolean status = false;
 if ((key == null) || (key.trim().equals(""))){
 System.out.println("Add attempt against null or empty key.");
 return status;
 }

 if (value == null){
 System.out.println("Add attempt of null value against key = " + key);
 return status;
 }

 System.out.println("Memcache key = " + key);

 if (get(key) != null){
 System.out.println("Add attempt of value which is already present in memcache against key = " + key);
 System.out.println("Call delete or replace");
 return status;
 }

 status = memCachedClient.add(key, value, date);

 if (status){
 System.out.println("Successfully added value against key = " + key);
 //addMemcacheKeyToMaster(key);
 }else {
 System.out.println("Failed to add value against key = " + key);
 }
 return status;
 }

 protected boolean delete(String key){
 boolean status = false;
 if ((key == null) || (key.trim().equals(""))){
 System.out.println("Delete attempt against null or empty key.");
 return status;
 }

 if (get(key) == null){
 System.out.println("Delete attempt of value which is not present in memcache against key = " + key);
 return status;
 }

 System.out.println("Memcache key = " + key);

 status = memCachedClient.delete(key);
 if (status){
 System.out.println("Successfully deleted value against key = " + key);
 //deleteMemcacheKeyFromMaster(key);
 }else {
 System.out.println("Failed to delete value against key = " + key);
 }
 return status;
 }

 protected boolean replace(String key, Object value){
 boolean status = false;
 if ((key == null) || (key.trim().equals(""))){
 System.out.println("Replace attempt against null or empty key.");
 return status;
 }

 System.out.println("Memcache key = " + key);

 status = memCachedClient.replace(key, value);
 if (status){
 System.out.println("Successfully replaced value against key = " + key);
 }else {
 System.out.println("Failed to replace value against key = " + key);
 }
 return status;
 }

 protected boolean replace(String key, Object value, Date date){
 boolean status = false;
 if ((key == null) || (key.trim().equals(""))){
 System.out.println("Replace attempt against null or empty key.");
 return status;
 }

 System.out.println("Memcache key = " + key);

 status = memCachedClient.replace(key, value, date);
 if (status){
 System.out.println("Successfully replaced value against key = " + key);
 }else {
 System.out.println("Failed to replace value against key = " + key);
 }
 return status;
 }

 public boolean flushAll(){
 boolean status = false;
 status = memCachedClient.flushAll();
 if (status){
 System.out.println("Successfully flushed all memcached data");
 }else {
 System.out.println("Failed to flush all memcached data");
 }
 return status;
 }

 /**
 * Returns the running statistics for MemCache.
 * @return Map
 */
 public Map showStats(){
 Map statsMap = memCachedClient.stats();
 Map stats = null;
 if(statsMap != null && statsMap.keySet().size() > 0) {
 Set keys = statsMap.keySet();
 Iterator ite = keys.iterator();
 while(ite.hasNext()){
 String key = (String)ite.next();
 stats = (Map)statsMap.get(key);
 }
 return stats;
 }else
 return null;
 }

 protected Object getMulti(String[] keyList){
 if ((keyList == null) || keyList.length==0){
 System.out.println("Get attempt against null or empty key.Returning null value.");
 return null;
 }
 System.out.println("Memcache key = " + keyList);
 return (Object)memCachedClient.getMulti(keyList);
 }
}

Step 8:  Create an implementation class that instantiate memcache client. TestMemcachedManager.java

package com.radhey.memcache.manager;

import org.springframework.stereotype.Component;
import com.danga.MemCached.MemCachedClient;

@Component
public class TestMemcachedManager extends MemcachedManager {
public TestMemcachedManager(){
super(); 
MemCachedClient memCachedClient = new MemCachedClient("POOL");
super.setMemCachedClient(memCachedClient);
 }
}

Step 9:  Create a package  com.radhey.memcache.service, then create a java file CacheService.java. This class entends TestMemcachedManager

package com.radhey.memcache.service;

import org.springframework.stereotype.Component;
import com.radhey.memcache.manager.TestMemcachedManager;
@Component
public class CacheService extends TestMemcachedManager {

public void loadCache() {
loadDataInCatch();
 fetchValue();
 }

public void loadDataInCatch() {
 boolean isAdded = add("Key1", "radhey");
 if (isAdded)
 System.out.println("Added success fully");
if (!isAdded)
 System.out.println("Error in addition fully");
 }

 public void fetchValue() {
 String value = (String) get("Key1");
 if(value!=null && !value.equalsIgnoreCase(""))
 {
 //value fetch from catched
 System.out.println("catched value:" +value);
 }
 else
 {
 // something wrong with catch. Fetch data from db
 System.out.println("something wrong with catch. Fetch data from db");
 }
}

public void updateCatchValue(String key,String value) 
 {
 boolean isAdded = replace(key, "Shyam");
 if (isAdded)
 System.out.println("replaced success fully");
 if (!isAdded)
 System.out.println("Error in replacing fully");
 }
}

Step 10:  Create a test package com.radhey.test . Then create a MemcacheTest.java class

package com.radhey.test;

import java.util.logging.Logger;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.radhey.memcache.service.CacheService;
public class MemcacheTest {
 static Logger log = Logger.getLogger(MemcacheTest.class.getName());
 public static void main(String[] args) {
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("memcacheConfig.xml");
 CacheService cacheService=new CacheService();
 cacheService.loadCache();
 cacheService.updateCatchValue("Key1", "Shyam");
 cacheService.fetchValue();
 }
}

Step 11 : run the MemcacheTest class if every thing work fine then you will get the below output.

log4j:WARN No appenders could be found for logger (org.springframework.context.support.ClassPathXmlApplicationContext).
log4j:WARN Please initialize the log4j system properly.
Memcache key = Key1
Memcache key = Key1
Add attempt of value which is already present in memcache against key = Key1
Memcache key = Key1
Successfully replaced value against key = Key1
Added success fully
Memcache key = Key1
catched value:radhey
Memcache key = Key1
Successfully replaced value against key = Key1
replaced success fully
Memcache key = Key1
catched value:Shyam

you can checkout above example from github
https://github.com/itthought/noSQL-Test/tree/master/MemcacheExample