今日完成：

             1）badboy与Jmeter结合使用

                          什么是badboy？

                                 一个脚本录制工具，可以将对于网页的执行的过程记录下来，然后导出成Jemter，通过Jmeter进行压力测试。

             2）Memcached的学习

                         |-什么是Memcached？

                                 分布式的内存对象缓存系统，因为分布式，所以必须通过网络进行传输。因为通过内存存储数据，所以减少了像数据库那样需要从硬盘上读取数据的操作，所以速度更快，但随之而来的是不能作为持久化存储工具，因为它把数据放在内存中，如果服务器关掉或者memcached关闭的话，都不能用了。

                        |-安装memcached

                               我 在Win下安装，具体教程百度上一大把。

                        |-java客户端的方式连接Memcached

                                        现在流行的Memcached客户端有四种吧。

                                        我使用的是danga.MemCached，这种出现最早也是使用最广泛的。

                             具体操作：

   传统代码方式：

@Test
public  void show(){
    MemCachedClient client=new MemCachedClient();
    //使用的服务器，由于是在本地测试，只有一个服务器地址。默认端口是11211
    //格式为 服务器IP:端口号
    String [] addr={"127.0.0.1:11211"};
    /**
     * 设置权重，与设定的服务器一一对应
     */
    Integer[] weight={3};

    //建立通信的连接池
    SockIOPool pool=SockIOPool.getInstance("luck");
    //设置连接池可用cache服务器列表，服务器构成形式：ip地址+端口号
    pool.setServers(addr);
    //设置连接池可用cache服务器的权重，和server数组的位置一一对应
    pool.setWeights(weight);


    //设置初始连接数
    pool.setInitConn(5);
    //设置最小连接数
    pool.setMinConn(5);
    //设置最大连接数
    pool.setMaxConn(200);
    //设置可用连接的最长等待时间
    pool.setMaxIdle(1000*30*30);
    //设置连接池维护线程的睡眠时间，设置为0，维护线程不启动
    pool.setMaintSleep(30);
    //设置Nagle算法，设置为false，因为通讯数据量比较大要求相应及时
    pool.setNagle(false);
    //设置socket读取等待超时时间
    pool.setSocketTO(30);
    //设置连接等待超时值
    pool.setSocketConnectTO(0);
    //设置完参数后，启动pool
    pool.initialize();

    client.set("value","Ok");
    String value= (String) client.get("value");

     //设置定时时间2s后消失
    client.set("value1","OK2",new Date(2000));
    String value2= (String) client.get("value1");
    System.out.println(value);
    System.out.println(value2);
}

spring管理方式：

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath:property/memcached.properties</value>
        </list>
    </property>
</bean>
<!--spring整合memched-->
<bean id="memcachedPool" class="com.danga.MemCached.SockIOPool" factory-method="getInstance"
      init-method="initialize"   destroy-method="shutDown">
    <property name="servers">
        <list>
            <value>${memcached.server}</value>
        </list>
    </property>

    <property name="maxConn" value="${memcached.maxConn}"></property>
    <property name="maintSleep" value="${memcached.maniSleep}"></property>
    <property name="nagle" value="${memcached.nagle}"></property>
    <property name="socketTO" value="${memcached.socketTO}"></property>
</bean>

     properties文件

#服务器地址
memcached.server=127.0.0.1:11211
#初始连接数目
memcached.initConn=20
#每个服务器建立最大连接数
memcached.maxConn=50
#自查线程周期工作，其每次休眠时间
memcached.maniSleep=3000
#是否使用nagle算法（Socket参数，如果是true，写数据不缓冲，直接发送）
memcached.nagle=false
#Socket阻塞读取数据的超时时间
memcached.socketTO=3000

          测试：

@RunWith(SpringJUnit4ClassRunner.class)//表示整合JUnit进行测试
@ContextConfiguration(locations ={"classpath:applicationContext.xml"})
public class SpringTest {
    @Test
    public void test1(){
        MemCachedClient memCachedClient=new MemCachedClient();
        memCachedClient.set("username","luck");
        String value= (String) memCachedClient.get("username");
        System.out.println(value);
    }
}

                3）测试了一下在添加缓存与不添加缓存的情况下jsp页面的承压情况，，，真的很明显。

@Component
public class UserMemcached {
    @Autowired
    private UserMapper userMapper;

    public  void add(User user){
        try {
            userMapper.add(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public User findByUsername(String username){
        User user= (User) MemcachedUtils.getValue(username);
        if (user==null){
            User user1=userMapper.findByUsername(username);
            MemcachedUtils.setValue(username,user1);
        }
        return  user;
    }

    public  User findById(Integer id){
        User user= (User) MemcachedUtils.getValue(id.toString());
        if (user==null){
            User user1=userMapper.findById(id);
            MemcachedUtils.setValue(id.toString(),user1);
        }
        return  user;
    }

    public List<User> findAll(){
        List<User>list= (List<User>) MemcachedUtils.getValue("all");
        if (list==null){
            List<User> list1=userMapper.findAll();
            MemcachedUtils.setValue("all",list1);
        }
        return  list;
    }
}

                  通过添加缓存，让service先访问缓存，如果缓存中没有再查询数据库。

                  两者测试都是进行30000次访问。    

-----------这是没有添加缓存的情况

-------------这是添加缓存的情况 

               从图片可以看出，添加缓存之后，访问的错误率以及平均访问时间都有了很大的提高。

                 ps:更多关于Memcached的内容。。。。访问我的博客http://blog.csdn.net/zq17865815296/article/details/78544049

                     要是有啥不对请指出~~~~

今日疑问：

                      无

明日任务：

                 巩固一下redis（之前学过，，，自己搭的小博客里面也用到了redis），学习slf4j log4j打日志。尽快提交这个任务~~~