要使用Simple-Spring-Memcached首先需要确认使用哪种memcached客户端，在这里将使用XMemcached。第一步，将依赖jar导入项目中，推荐使用maven。具体的依赖可以参照SSM源码的pom.xml配置。具体步骤如下

1、创建一个maven项目，在pom.xml添加上Simple-Spring-Memcached的依赖，还有其它Spring,aop,Xmemcached等如下：

<dependency>
<groupId>com.googlecode.xmemcached</groupId>
<artifactId>xmemcached</artifactId>
<version>1.3.5</version>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>r09</version>
</dependency>
<dependency>
<groupId>com.google.code.simple-spring-memcached</groupId>
<artifactId>simple-spring-memcached</artifactId>
<version>2.0.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.9.3</version>
</dependency>

2、在src/main/resources目录下增加spring的配置文件，其中一个为xmemcached的配置文件，一个为spring主配置文件。如下：

context.xml

<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<import resource="simplesm-context.xml" />

<aop:aspectj-autoproxy />
<context:annotation-config />
<context:component-scan base-package="com.google.code.ssm,org.colorfuldays.ssm" />

<import resource="xmemcached.xml"/>
</beans>

xmemcached.xml:

<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

<aop:aspectj-autoproxy/>

<bean name="defaultMemcachedClient" class="com.google.code.ssm.CacheFactory">
<property name="cacheClientFactory">
<bean class="com.google.code.ssm.providers.xmemcached.MemcacheClientFactoryImpl"/>
</property>
<property name="addressProvider">
<bean class="com.google.code.ssm.config.DefaultAddressProvider">
<property name="address" value="127.0.0.1:11211"/>
</bean>
</property>
<property name="configuration">
<bean class="com.google.code.ssm.providers.CacheConfiguration">
<property name="consistentHashing" value="true"/>
</bean>
</property>
<property name="cacheTranscoders">
<map>
<entry key="org.colorfuldays.ssm.domain.UserDO" value-ref="jsonTranscoder"/>
</map>
</property>
</bean>

<bean name="jsonTranscoder" class="com.google.code.ssm.transcoders.JsonTranscoder">
<constructor-arg index="0" value="org.colorfuldays.ssm.domain.UserDO"/>
<constructor-arg index="1">
<ref bean="JsonObjectMapper"/>
</constructor-arg>
<constructor-arg index="2">
<ref bean="longToStringTranscoder"/>
</constructor-arg>
</bean>

<bean name="longToStringTranscoder" class="com.google.code.ssm.transcoders.LongToStringTranscoder"/>
<bean name="JsonObjectMapper" class="org.codehaus.jackson.map.ObjectMapper"/>
</beans>

这两个配置文件与官方源码中提供的测试例子差别不大，只是多出了Transcoder的配置。在配置TransCoder时，要注意JsonTranscoder只能通过构造函数注入。cacheTranscoders的配置中需要注意其key为Class对象。

完成上述配置后，写个简单的例子测试。测试代码如下：
TestNG测试类

package org.colorfuldays.ssm.dao;

import junit.framework.Assert;
import org.codehaus.jackson.map.ObjectMapper;
import org.colorfuldays.ssm.domain.UserDO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

import javax.annotation.Resource;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * Created by IntelliJ IDEA.
 * User: huxing(huxing1985#gmail.com)
 * Date: 12-5-18
 * Time: 下午6:14
 */
@ContextConfiguration(locations = {"classpath:context.xml"})
public class UserDAOTest extends AbstractTestNGSpringContextTests {
    private static final Logger LOG = LoggerFactory.getLogger(UserDAOTest.class);
    @Resource
    UserDAO userDAO;
    UserDO orignUserDO;

    @BeforeTest
    public void before() {
        orignUserDO = new UserDO();
        orignUserDO.setId(1024l);
        orignUserDO.setName("Inzaghi");
        orignUserDO.setPassword("password");
    }

    @Test
    public void testGetUserById() throws Exception {
        UserDO userDO = userDAO.getUserById(1124);
        System.out.println(userDO);
        Assert.assertTrue(orignUserDO.equals(userDO));
    }

    @Test
    public void testUpdateUserDO() throws Exception {

    }
}

DAOImpl类

package org.colorfuldays.ssm.dao.impl;

import com.google.code.ssm.api.InvalidateSingleCache;
import com.google.code.ssm.api.ParameterValueKeyProvider;
import com.google.code.ssm.api.ReadThroughSingleCache;
import com.google.code.ssm.api.format.UseJson;
import org.colorfuldays.ssm.dao.UserDAO;
import org.colorfuldays.ssm.domain.UserDO;
import org.springframework.stereotype.Repository;

/**
 * Created by IntelliJ IDEA.
 * User: huxing(huxing1985#gmail.com)
 * Date: 12-5-18
 * Time: 下午5:50
 */
@Repository("userDAO")
public class UserDAOImpl implements UserDAO {
    @Override
    @UseJson // 以json格式序列化
    @ReadThroughSingleCache(namespace = "star",expiration = 30)
    public UserDO getUserById(@ParameterValueKeyProvider long id) {
        UserDO userDO = new UserDO();
        userDO.setId(1024l);
        userDO.setName("Inzaghi");
        userDO.setPassword("password");
        return userDO;
    }

    @Override
    public int updateUserDO(UserDO userDO) {
        return 0;
    }

    @InvalidateSingleCache(namespace = "star")
    public int deleteUser(@ParameterValueKeyProvider long userId) {
        return 0;
    }

}

package org.colorfuldays.ssm.domain;

import java.io.Serializable;

/**
 * Created by IntelliJ IDEA.
 * User: huxing(xing.hu@360hqb.com)
 * Date: 12-5-18
 * Time: 下午5:44
 */
public class UserDO implements Serializable{

    private static final long serialVersionUID = -9096141633317522945L;

    private String name;
    private Long id;
    private String password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Long getId() {
        return id;
    }

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

    public String getPassword() {
        return password;
    }

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

    @Override
    public String toString() {
        return "UserDO{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof UserDO)) return false;

        UserDO userDO = (UserDO) o;

        if (id != null ? !id.equals(userDO.id) : userDO.id != null) return false;
        if (name != null ? !name.equals(userDO.name) : userDO.name != null) return false;
        if (password != null ? !password.equals(userDO.password) : userDO.password != null) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + (id != null ? id.hashCode() : 0);
        result = 31 * result + (password != null ? password.hashCode() : 0);
        return result;
    }
}

启动memcached后即可运行单元测试了。其中使用了@UseJson的注解指定使用json格式对对象做序列化。通过下面的方式可以看到对象存入memcached后结果如下：

star@star:simple-spring-memcached-read-only$ telnet 127.0.0.1 11211
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
get star:1124
END
get star:1124
VALUE star:1124 8 50
{"name":"Inzaghi","id":1024,"password":"password"}
END

如果不使用@UseJson注解，则存入Memcached的数据则是Java默认序列化的数据。
测试代码在这里：https://github.com/iamxhu/ssm-demo

首先MC 990官方标识支持DDR3 1066mhz的内存，但是在咨询过一位换过内存的朋友时，他告诉我用1333mhz的内存也能用。于是在易讯换了两条金士顿DDR3 1333mhz的内存。

给换Mac换内存另外一个需要准备的工具是螺丝刀，Mac的螺丝钉比较特殊，我的MC990对应的十字螺丝需要用PH00规格的螺丝刀。所幸在家门口的五金店发现有买，而且还有很多其它的螺丝刀，于是花了30块买下一整套螺丝刀。

用螺丝刀将螺丝都取出后，就可以开始换内存了，这些按照苹果官方文档就行（在关于本机/更多信息/内存一档可以看到内存升级的链接）。打开后盖后，发现Mac里面还是挺脏的，特别是风扇那块，于是用一个刷子清理了一下。

换上新内存后，到了关键时刻了，按下电源按钮后，大约等了7，8秒种系统正常点亮，启动，进行系统查看了一下更新后内存信息。发现变成8G了，而且还直接以1333mhz在运行，完全出乎意料。下面是几张换内存时的图。

未拆时的样子

拆后后盖后的样子

装内存区域按照

换上一根新内存

全部换好后的样子

最后看一下系统中显示内存的情况

Eclipse CDT好像可以阅读C++代码，但是作为Intellij IDEA的踏实Fans，对Eclipse实在无爱，于是尝试着在Intellij IDEA的插件库中查找C++相关的插件，非常幸运地发现了一个C/C++插件。装上后，试了一下，开发Java源码时的那些快捷方法都还能用，顿时感到很欣慰。

Intellij IDEA装上C/C++插件后，需要先完成一些基本的全局配置。有如下几项配置

• path to gcc (/usr/bin/gcc)
• path to gdb (/usr/bin/gdb)
• Defines
• Additional include directories  (配置IDEA类似LD_LIBRARY_PATH，在阅读代码时自动分析相关头的依赖，并能点进方法中)

除此之外在每一个项目中，还可以配置项目的include，对于多模块项目来说，这东西太重要。还有一些宏定义等的配置。

在编译cscope-15.7a版本的代码，make这一步时抛出如下错误

In file included from build.c:50:
/usr/include/ncurses.h:539:40: error: macro “cbreak” passed 1 arguments, but takes just 0
/usr/include/ncurses.h:564:44: error: macro “erasechar” passed 1 arguments, but takes just 0
/usr/include/ncurses.h:600:43: error: macro “killchar” passed 1 arguments, but takes just 0
make[2]: *** [build.o] Error 1
make[1]: *** [all-recursive] Error 1
make: *** [all] Error 2

于是grep一下cscope的源码，找到constants.h中含有这几个方法。代码如下:

#if (BSD || V9) && !__NetBSD__ && !__FreeBSD__
# define TERMINFO 0 /* no terminfo curses */
#else
# define TERMINFO 1
#endif

#undef TERMINFO 0
#define TERMINFO 1

#if !TERMINFO
# ifndef KEY_BREAK
# define KEY_BREAK 0400 /* easier to define than to add #if around the use */
# endif
# ifndef KEY_ENTER
# define KEY_ENTER 0401
# endif
# ifndef KEY_BACKSPACE
# define KEY_BACKSPACE 0402
# endif

# if !sun
# define cbreak() crmode() /* name change */
# endif

# if UNIXPC
# define erasechar() (_tty.c_cc[VERASE]) /* equivalent */
# define killchar() (_tty.c_cc[VKILL]) /* equivalent */
# else
# define erasechar() (_tty.sg_erase) /* equivalent */
# define killchar() (_tty.sg_kill) /* equivalent */
# endif /* if UNIXPC */
#endif /* if !TERMINFO */

看这段代码，只要让TERMINFO为1，即可不使用这几个函数。于是加上上面蓝色的两行，即可通过编译。

== gdb ==

* 启动:
gdb ./bin/nginx

* 设置参数
set args -s reload

* 运行程序
r (run)

* 设置断点
** 在代码行上设置断点
b xxx.cpp:117 (break)

** 在代码方法上设置断点
b star::PManager::load
star 表示使用PManager时申明的namespace名称,PManager表示被调用的类，load 指调用的方法, 保证可以找到代码执行唯一的地方
如果某个函数被重载，也可以直接使用上述方法，gdb会自动关联到程序实际执行的那个函数。

* 查看断点信息
info break

* 单条执行
n (next)

* 执行到下一断点
c (continue)

* 打印出程序中变量的值
p (print)

* 自动显示变量
display  field
该功能类似于Intellij IDEA中的watch，每一步执行都会将这个指定变量打出，在debug 观察for循环中的某个值时，非常有用。

* 删除显示的变量
delete display

* 查看函数棧
bt

* 退出函数
finish

* 退出GDB
q

至于Intellij IDEA11.1官方网站是提到的一些更新，在今天的使用过程在体会都不大。而且很多都针对ULTIMATE版，作为买不起正版，只能用社区版的屌丝，表示很伤心。今天体会最深的是 Project 面板中新增了“Scroll to Source” 和“Scroll from Source”的功能选项。在编辑代码时，跳到Project面板时，可以快速定位到文件了。

这次的升级带来的好处，比起JRebel不能用带来的不便，实在是太不值了，升级需谨慎啊！

如下面的示例所示：


abstract class C {
abstract T id(T x);
}
class D extends C {
String id(String x) { return x; }
}

上面这段代码在编译成.class时，在D中会增加一个方法：

Object id(Object x) { return id((String) x); }

这个方法即是所谓的Bridge Method。如果此时直接使用如下调用c.id(new Object())时，则会抛出ClassCastException。

在使用Java反射机制时，需要特别注意BridgeMethod，因为此时拿到的Method对象的参数类型或返回值类型并不是实际调用方法的真实类型。在Simple-Spring-Memcached中就提供了两个注解(BridgeMethodMapping,BridgeMethodMappings)来解决这个问题，标示出范型T代表的真实类型。示例如下：

     public interface Generic {
       void set(K key, V value);
       V get(K key);
       void put(K key, V value, boolean overwrite);
     }

    @BridgeMethodMappings({
        @BridgeMethodMapping(methodName="set",erasedParamTypes={Object.class, Object.class}, targetParamTypes={Number.class, String.class}),
        @BridgeMethodMapping(methodName="get",erasedParamTypes={Object.class}, targetParamTypes={Number.class}),
        @BridgeMethodMapping(methodName="put",erasedParamTypes={Object.class, Object.class, boolean.class}, targetParamTypes={Number.class, String.class, boolean.class})
    })
    public class SubGeneric implements Generic {
     public void set(Number key, String value) {
     .....
     }

     public String get(Number key) {
     ....
     }

     public void put(Number key, String value, boolean overwrite) {
     ....
     }
 }

参考文献: Java Language Specification p490
http://stas-blogspot.blogspot.com/2010/03/java-bridge-methods-explained.html

之前自己写过一个通过注解和AOP来实现缓存的代码，最早的原型来自于在淘宝工作时的一个项目。当时这段代码写得比较差，之后重构时发现之前的功能实现有很大的局限。主要问题在于：

1. key的生成规则
2. update 与 query 的参数不一样，如何让其生成一样的key
3. 列表缓存如何定义key及失效

最近同事推荐了一个开源项目：Simple-Spring-Memcached（简称ssm），它也是一个通过Annatation与AOP来完成缓存数据操作的开源项目。仔细看了一下代码，基本上把我之前碰到的问题都解决了，而且MultiCache这一块的实现超出我的预期。该项目主要优点如下：

1. 与Spring完善集成
2. 支持两种Memcached Java Client (spymemcached,Xmemcached)
3. 基于Annotation方式实现缓存操作，对代码侵入性小
4. annotation丰富，可以满足绝大部分需求

下面介绍一下其中各annotation的使用。ssm项目中的Annotation主要分成以下几类

• SingleCache类 操作单个POJO的Cache数据，由ParameterValueKeyProvider和CacheKeyMethod来标识组装key
• MultiCache类 操作List型的Cache数据，由ParameterValueKeyProvider和CacheKeyMethod来标识组装key
• AssignCache类 指定key操作Cache数据，由annotation中的 assignedKey 指定key

各Annotation的详细说明

• ReadThroughSingleCache
  作用：读取Cache中数据，如果不存在，则将读取的数据存入Cache
  key生成规则：ParameterValueKeyProvider指定的参数，如果该参数对象中包含CacheKeyMethod注解的方法，则调用其方法，否则调用toString方法
  代码示例：

      @ReadThroughSingleCache(namespace = "Alpha", expiration = 30)
      public String getDateString(@ParameterValueKeyProvider final String key) {
          final Date now = new Date();
          try {
              Thread.sleep(1500);
          } catch (InterruptedException ex) {
          }
          return now.toString() + ":" + now.getTime();
      }

• InvalidateSingleCache
  作用：失效Cache中的数据
  key生成规则：
  • 使用 ParameterValueKeyProvider注解时，与ReadThroughSingleCache一致
  • 使用 ReturnValueKeyProvider 注解时，key为返回的对象的CacheKeyMethod或toString方法生成

    @InvalidateSingleCache(namespace = "Charlie")
    public void updateRandomString(@ParameterValueKeyProvider final Long key) {
        // Nothing really to do here.
    }

    @InvalidateSingleCache(namespace = "Charlie")
    @ReturnValueKeyProvider
    public Long updateRandomStringAgain(final Long key) {
        return key;
    }

• UpdateSingleCache
  作用：更新Cache中的数据
  key生成规则：ParameterValueKeyProvider指定
  ParameterDataUpdateContent：方法参数中的数据，作为更新缓存的数据
  ReturnDataUpdateContent：方法调用后生成的数据，作为更新缓存的数据
  注：上述两个注解，必须与Update*系列的注解一起使用

      @UpdateSingleCache(namespace = "Alpha", expiration = 30)
      public void overrideDateString(final int trash, @ParameterValueKeyProvider final String key,
              @ParameterDataUpdateContent final String overrideData) {
      }
  
      @UpdateSingleCache(namespace = "Bravo", expiration = 300)
      @ReturnDataUpdateContent
      public String updateTimestampValue(@ParameterValueKeyProvider final Long key) {
          try {
              Thread.sleep(100);
          } catch (InterruptedException ex) {
          }
          final Long now = new Date().getTime();
          final String result = now.toString() + "-U-" + key.toString();
          return result;
      }

• ReadThroughAssignCache
  作用：读取Cache中数据，如果不存在，则将读取的数据存入Cache
  key生成规则： ReadThroughAssignCache 注解中的 assignedKey 字段指定

      @ReadThroughAssignCache(assignedKey = "SomePhatKey", namespace = "Echo", expiration = 3000)
      public List<String> getAssignStrings() {
          try {
              Thread.sleep(500);
          } catch (InterruptedException ex) {
          }
          final List<String> results = new ArrayList<String>();
          final long extra = System.currentTimeMillis() % 20;
          final String base = System.currentTimeMillis() + "";
          for (int ix = 0; ix < 20 + extra; ix++) {
              results.add(ix + "-" + base);
          }
          return results;
      }

• InvalidateAssignCache
  作用：失效缓存中指定key的数据
  key生成规则：assignedKey 字段指定

      @InvalidateAssignCache(assignedKey = "SomePhatKey", namespace = "Echo")
      public void invalidateAssignStrings() {
      }

• UpdateAssignCache
  作用：更新指定缓存
  key生成规则：assignedKey 字段指定

      @UpdateAssignCache(assignedKey = "SomePhatKey", namespace = "Echo", expiration = 3000)
      public void updateAssignStrings(int bubpkus, @ParameterDataUpdateContent final List<String> newData) {
      }

1、安装Ubuntu支持smbfs的包

sudo apt-get install smbfs

2、创建一个目录，用于挂载Windows共享目录

sudo mkdir /mnt/smb

3、将Windows共享目录mount到/mnt/smb目录

sudo mount -t smbfs -o username=guest //192.168.10.34/tools /mnt/smb
其中username 为windows共享目录的访问用户
4、卸载Windows共享目录

sudo umount /mnt/smb


上面故事中作者自由攀岩用的是R型思维，因为它完全利用直觉，感觉去做事，而回到传统的授课时，这是L型 思维，在教如何攀岩时，会讲到各种情况下如何处理，它包含分析，逻辑判断等等。在这R->L的思维方式转变中，可以看到L型思维和R型思维在解决问题时是相辅相成的。

回到开篇的话题，我的踢球生涯始于高中，开始是一群同学拿个球就开始乱踢一通。完全按照自己的直觉踢，很少思考过具体应该怎么踢，也没有人教过应该怎么踢。在学习踢球这件事情上，我采用的是完全R型方式处理，现在来看，效果并不好，因为我踢得挺臭的。最近踢球时，才开始思考，在球场上，应该如何处理球，而不是跟球着跑。已经有通过L型思维来提高的欲望了，无奈现在没时间去学了。

因为这些，想起了另外一个话题，最近在学习C++，目前在看《Essential C++》一书，边看书时也把书中的一些代码自己写一遍，总体来讲，那些自己输入过的代码的知识点，记得比较深刻。看来《程序员的思维修炼》书中介绍的R型到L型思维方式的不断转换应用，是提高学习效率的重要方法。也无怪乎徐宥总结出自己敲完书中所有代码和章亦春的“眼到，手到，心到的抄书大法”都那么有效。