@Requestparam 绑定单个请求的值

url：/requestparam1?username=zhang
@RequestMapping("/requestparam1")
public String requestparam2(@RequestParam("username") String username)

@PathVariable 绑定URI模板变量值

@RequestMapping(value="/users/{userId}/topics/{topicId}")
public String test(
@PathVariable(value="userId") int userId,
@PathVariable(value="topicId") int topicId)

@SessionAttributes 绑定命令对象到session

//1、在控制器类头上添加@SessionAttributes注解
@SessionAttributes(value = {"user"})
public class SessionAttributeController

//2、@ModelAttribute注解的方法进行表单引用对象的创建
@ModelAttribute("user")
public UserModel initUser()

//3、@RequestMapping注解方法的@ModelAttribute注解的参数进行命令对象的绑定
@RequestMapping("/session1")
public String session1(@ModelAttribute("user") UserModel user)

//4、通过SessionStatus的setComplete()方法清除@SessionAttributes指定的会话数据
@RequestMapping("/session2")
public String session(@ModelAttribute("user") UserModel user, SessionStatus status) {
if(true) { //④
status.setComplete();
}
return "success";
}

@Value 绑定从配置文件取值

Mybatis概览

习惯使用hibernate，mybatis互联网常使用，也掌握一次。
Mybatis的spring支持
Mybatis的DAO只写接口，没有实现类。实现类是mapper.xml自动生成的。配置如下：

**

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" >
    <property name="basePackage" value="com.tcl.mie.credit.persistence.dao" />
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
</bean>**  

Mybatis的Dao个人理解已经不是纯粹的ORM关系了，在DAO里面配置了与业务相关的多表查询结果对象，这样其查询的过程就不是纯的对一个表的操作，常常有多表操作，返回贴近业务的对象结合。

** ... ...

<resultMap id="cmsModelMap" type="com.tcl.mie.credit.common.module.CreditGainTaskModel">
    <id column="id" property="id" jdbcType="INTEGER" />
    <result column="item_code" property="taskId" jdbcType="VARCHAR" />
     ...
    <result column="type" property="type" jdbcType="INTEGER" />
</resultMap>

<resultMap id="cmsVoTempMap" type="com.tcl.mie.credit.common.vo.CreditGainTaskVoTemp">
    <id column="id" property="id" jdbcType="INTEGER" />
    <result column="item_code" property="taskId" jdbcType="VARCHAR" />
    ...
    <result column="description" property="description" jdbcType="VARCHAR" />
</resultMap>

**

 像这样，后两个查询对象已经不是单纯的对单表查询了。因此总结myBatis的粒度是字段，而不是表。hibernate的粒度是表，后者对表进行操作，表被映射为对象。才是真正的ORM。  

通过数据库生成mybatis文件

1、使用mysql batch 设计数据库，设计完成后，到处sql脚本。
2、sql脚本导入到mysql中，生成表。
3、通过maven的mybatis-generator-maven-plugin插件，可以反向生成模型相关代码。
4、编写generatorConfig.xml文件，设置表和model映射关系。可以自动生成modle、DAO（interface）、mapper。

**<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config10.dtd" > <!-- -->

<context id="context" targetRuntime="MyBatis3">
    <commentGenerator>
        <property name="suppressAllComments" value="true" /><!-- 是否取消注释 -->
        <property name="suppressDate" value="true" /> <!-- 是否生成注释代时间戳-->
    </commentGenerator>


    <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://172.26.32.9:3308/databee?useUnicode=true&amp;characterEncoding=UTF-8&amp;autoReconnect=true"
        userId="develop" password="Aa123456" />


    <javaTypeResolver>
        <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator
         targetPackage="com.tcl.databee.persistence.model" 
         targetProject="src/main/java" 
     />

    <sqlMapGenerator 
        targetPackage="mappers" 
        targetProject="src/main/resources" 
    />

    <javaClientGenerator 
        targetPackage="com.tcl.databee.persistence.dao" 
        targetProject="src/main/java"
        type="XMLMAPPER"
     />
  <!-- 数据库与与对象映射 -->
  <table tableName="app" domainObjectName="App" enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false"  />
  <table tableName="app_device" domainObjectName="AppDevice" enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false"  />
  <table tableName="merchant" domainObjectName="Merchant" enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false"  />
  <table tableName="refer" domainObjectName="Refer" enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false"  />
  <table tableName="source" domainObjectName="Source" enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false"  />
  <table tableName="refer_statistics_day" domainObjectName="ReferStatistics" enableCountByExample="false" enableDeleteByExample="false" enableSelectByExample="false" enableUpdateByExample="false"  />

**

一、Maven项目资源文件创建

Maven项目常分开发环境、测试环境、生产环境，会出各种包，为了避免配置文件的反复修改，因此在打maven包时候，进行资源文件修改。 配置如下： ### 1、Pom配置 <!-- maven build 使用filter资源文件，进行替换 --> llp-boss src/main/resources true .properties logback.xml src/main/resources false .properties logback.xml

<!-- 获取filter -->
<filters>
  <filter>${resource.filter}</filter>
</filters>

<plugins>
  <plugin>
    <groupId>org.apache.tomcat.maven</groupId>
    <artifactId>tomcat7-maven-plugin</artifactId>
    <configuration>
      <charset>UTF-8</charset>
      <port>8080</port>
      <path>/boss</path>
      <uriEncoding>UTF-8</uriEncoding>
      <systemProperties>
        <druid.log.stmt.executableSql>true</druid.log.stmt.executableSql>
      </systemProperties>
    </configuration>
  </plugin>
</plugins>

<!-- 定义profiles --> dev true filters/dev.properties test filters/test.properties production filters/production.properties

2、src/main/resources 要替换的资源文件

src/main/resources/conf/db.properties ======db.properties jdbc.datasource=com.mchange.v2.c3p0.ComboPooledDataSource jdbc.driverClass=com.mysql.jdbc.Driver jdbc.url=${jdbc.url} jdbc.username=${jdbc.username} jdbc.password=${jdbc.password}

jdbc.minPoolSize=10 jdbc.maxPoolSize=50 jdbc.autoCommit=false

Paxos 算法理解

背景

Paxos 发音是[皮克索斯或帕克索斯]
是由莱斯利·兰伯特（Leslie Lamport)，1990年提出的一种基于消息传递的一致性算法。
Leslie Lamport，1941年生，新晋图灵奖得主，一个在计算机领域拥有辉煌成就的大师，他关于时间时钟、面包店算法、拜占庭将军等问题的思考令人乍舌。亲近他的人还会告诉你，他是个年愈古稀仍爱穿旱冰鞋上下班的幽默老头。全球无数人受益于他的成就，却很少听说他的名字。

1）概要

分布式系统中的节点通信存在两种模型：共享内存（Shared memory）和消息传递（Messages passing）。 基于消息传递通信模型的分布式系统，不可避免的会发生以下错误：进程可能会慢、重启，消息可能会延迟、丢失、重复，在基础Paxos场景中，先不考虑可能出现消息篡改即拜占庭将军问题。
Paxos算法解决的问题是在一个可能发生上述异常的分布式系统中，如何就某个值达成一致，保证不论发生以上任何异常，都不会破坏决议的一致性。
一个典型的场景是，在一个分布式数据库系统中，如果各节点的初始状态一致，每个节点都执行相同的操作序列，那么他们最后能得到一个一致的状态。另一个场景是集群中选举Leader。

角色：
Proposer ：提议者
Acceptor：决策者
Client：产生议题者
Learner：最终决策学习者
上面4种角色中，提议者和决策者是很重要的，其他的2个角色在整个算法中应该算做打酱油的，Proposer就像Client的使者，由Proposer使者拿着Client的议题去向Acceptor提议，让Acceptor来决策。这里上面出现了个新名词：最终决策

动作：
promise：Acceptor对proposer承诺，如果没有更大编号的proposal会accept它提交的proposal
accept：Acceptor没有发现有比之前的proposal更大编号的proposal，就批准了该proposal
chosen：当Acceptor的多数派都accept一个proposal时，该proposal就被最终选择，也称为决议

论文结构：
先提出P1的基本需求
对整个结果提出要求（P2）
对Acceptor提出要求（P2a）
对Proposer提出要求（P2b）
对Acceptor与Proposer同时提出要求（P2c）

2）问题描述

假设有一组可以提出提案的进程集合。一个一致性算法需要保证：在这些被提出的提案中，只有一个会被选定；如果，没有提案被提出，那么就不会有被选定的提案；当一个提案被选定后，进程应该可以获取被选定的提案信息。
对于一致性来说，安全性(safety)需求就是这样的：
a.只有被提出的提案才能被选定。
b.只能有一个值被选定(chosen)，同时
c.如果某个进程认为某个提案被选定了，那么这个提案必须是真的被选定的那个。
• Only a value that has been proposed may be chosen,
• Only a single value is chosen, and
• A process never learns that a value has been chosen unless it actually has been.
整体上来说，目标就是要保证最终有一个提案会被选定，当提案被选定后，进程最终也能获取到被选定的提案。
{!一个分布式算法，有两个最重要的属性：safety 和livness，简单来说safety就是指那些需要保证永远都不会发生的事情，livness是指那些最终一定会发生的事情}。有三种参与角色，我们用Proposers，Acceptors和Learners来表示。在具体的实现中，一个进程可能充当不止一种角色。每个参与者以任意的速度执行，可能会出错而停止，也可能会重启。当一个提案被选定后，所有的参与者都有可能失败或重启，因此除非那些失败或重启的参与者可以记录某些信息，否则是不可能存在一个解的。}
消息在传输中可能花费任意的时间，可能会重复，丢失，但是不会被损坏{!即其内容不会被篡改}。

3）提案选定

选定提案的最简单方式就是只允许一个Accpetor存在，Proposer发送提案给Accpetor，Acceptor会选择它接收到的第一个提案作为被选定的提案。但是显而易见存在单点问题。
用多个Accpetor来避免一个Accpetor时的单点问题。现在，Proposer向一个Acceptor集合发送提案，某个Acceptor可能会通过(Accept)这个提案。当有足够多的Acceptor通过(accept)它的时候，我们就可以认为这个提案被选定了。什么是足够多呢？为了确保只有一个提案被选定，我们可以让这个集合包含Acceptor集合中的多数成员。因为任何两个多数集至少有一个公共成员，如果我们再规定一个Acceptor最多只能通过一个提案，那么就能保证只有一个提案被选定。
---至此，就确定了要用多数派来决定提案选定

在没有失败和消息丢失的情况下，如果我们希望即使在只有一个提案被提出的情况下，仍然可以选出一个提案来，这就暗示了如下这个需求：
P1.一个Acceptor必须通过第一个他收到的提案。
这个需求产生的问题是：不能选定一个提案。 因为不能形成多数派。比如奇数个接收者中，某个接收者n挂了，导致两个提案的接收者数量相同。或者奇数个通过者都同时收到了提案者的提议。

P1 and the requirement that a value is chosen only when it is accepted by a majority of acceptors imply that an acceptor must be allowed to accept more than one proposal.
【P1再加上一个提案被选定需要由半数以上的Acceptor通过】的需求，暗示着一个Acceptor必须能够通过(accept)不止一个提案。为每个提案设定一个编号来记录一个Acceptor通过的那些提案。为了避免混淆，需要保证不同的提案具有不同的编号。如何实现这种保证取决于实现，假设已经提供了这种保证。当一个具有某value值的提案被半数以上的Acceptor通过后，我们就认为该value被选定了。即认为该提案被选定了。
{!此时的提案已经跟value变成了不同的东西，提案是由编号+value组成的}
We can allow multiple proposals to be chosen, but we must guarantee that all chosen proposals have the same value.By induction on the proposal number, it suffices to guarantee:
P2. If a proposal with value v is chosen, then every higher-numbered proposalthat is chosen has value v.
P2.如果具有value值v的提案被选定(chosen)了，那么所有比它编号更高的被选定的提案的value值也必须是v。
因为编号是全序的，条件P2就保证了只有一个value值被选定的这一关键安全性属性。
被选定的提案，首先必须被至少一个acceptor通过，因此我们可以通过满足如下条件来满足P2：
P2a.If a proposal with value v is chosen, then every higher-numbered proposal accepted by any acceptor has value v.
P2a.如果具有value值v的提案被选定(chosen)了，那么所有比它编号更高的被acceptor通过的提案的value值也必须是v。
我们仍然需要P1来保证提案会被选定。但是因为通信是异步的，一个提案可能会在某个Acceptor c还未收到任何提案时就被选定了。假设一个新的proposer苏醒了，然后产生了一个具有另一个value值的更高编号的提案，根据P1，就需要c通过这个提案，但是这与P2a矛盾。

因此如果要同时满足P1和P2a，需要对P2a进行强化：
P2b.If a proposal with value v is chosen, then every higher-numbered proposal issued by any proposer has value v.
P2b.如果具有value值v的提案被选定，那么所有比它编号更高的被proposer提出的提案的value值也必须是v。
一个提案被acceptor通过之前肯定要由某个proposer提出，因此P2b就隐含了P2a，进而隐含了P2为了发现如何保证P2b，我们来看看如何证明它成立。我们假设某个具有编号m和value值v的提案被选定了，需要证明具有编号n(n>m)的提案都具有value值v。我们可以通过对n使用归纳法来简化证明，这样我们就可以在额外的假设下—即编号在m…(n-1)之间的提案具有value值v，来证明编号为n的提案具有value值v。因为编号为m的提案已经被选定了，这意味着肯定存在一个由半数以上的acceptor组成的集合C，C中的每个acceptor都通过了这个提案。再结合归纳假设，m被选定意味着：
C中的每个acceptor都通过了一个编号在m…n-1之间的提案，每个编号在m…n-1之间的被acceptor通过的提案都具有value值v。
因为任何包含半数以上的acceptor的集合S都至少包含C中的一个成员，我们可以通过维护如下不变性就可以保证编号为n的提案具有value v：
P2c. For any v and n, if a proposal with value v and number n is issued, then there is a set S consisting of a majority of acceptors such that either (a) no acceptor in S has accepted any proposal numbered less than n, or (b) v is the value of the highest-numbered proposal among all proposals numbered less than n accepted by the...

Continue Reading...

一致性哈希 ConsistentHash

背景

一致哈希由MIT的Karger及其合作者提出，现在这一思想已经扩展到其它领域。在这篇1997年发表的学术论文中介绍了“一致哈希”如何应用于用户易变的分布式Web服务中。哈希表中的每一个元素代表分布式系统中一个节点，在系统添加或删除节点只需要移动K/n项。

一致哈希也可用于实现健壮缓存来减少大型Web应用中系统部分失效带来的负面影响。 一致哈希的概念还被应用于分布式散列表（DHT）的设计。DHT使用一致哈希来划分分布式系统的节点。所有关键字都可以通过一个连接所有节点的覆盖网络高效地定位到某个节点。

需求

在使用n台缓存服务器时，一种常用的负载均衡方式是，对资源o的请求使用\mbox{hash}(o) = o \mod n来映射到某一台缓存服务器。当增加或减少一台缓存服务器时这种方式可能会改变所有资源对应的hash值，也就是所有的缓存都失效了，这会使得缓存服务器大量集中地向原始内容服务器更新缓存。因些需要一致哈希算法来避免这样的问题。 一致哈希尽可能使同一个资源映射到同一台缓存服务器。这种方式要求增加一台缓存服务器时，新的服务器尽量分担存储其他所有服务器的缓存资源。减少一台缓存服务器时，其他所有服务器也可以尽量分担存储它的缓存资源。 一致哈希算法的主要思想是将每个缓存服务器与一个或多个哈希值域区间关联起来，其中区间边界通过计算缓存服务器对应的哈希值来决定。（定义区间的哈希函数不一定和计算缓存服务器哈希值的函数相同，但是两个函数的返回值的范围需要匹配。）如果一个缓存服务器被移除，则它会从对应的区间会被并入到邻近的区间，其他的缓存服务器不需要任何改变。

实现

一致哈希将每个对象映射到圆环边上的一个点，系统再将可用的节点机器映射到圆环的不同位置。查找某个对象对应的机器时，需要用一致哈希算法计算得到对象对应圆环边上位置，沿着圆环边上查找直到遇到某个节点机器，这台机器即为对象应该保存的位置。 当删除一台节点机器时，这台机器上保存的所有对象都要移动到下一台机器。添加一台机器到圆环边上某个点时，这个点的下一台机器需要将这个节点前对应的对象移动到新机器上。 更改对象在节点机器上的分布可以通过调整节点机器的位置来实现。

特性

冗余少 负载均衡 过渡平滑（单调性）: 当缓冲区大小变化时一致性哈希(Consistent hashing)尽量保护已分配的内容不会被重新映射到新缓冲区（避免无效迁移）。 存储均衡 关键词单调

测试一下代码

public class TraditionalServer {
    public static void main(String args[]) {
        int port = 2000;
        ServerSocket server_socket;
        DataInputStream input;
                       server_socket.getLocalPort());
            // server infinite loop
            while(true) {
            Socket socket = server_socket.accept();
            System.out.println("New connection accepted " +
                       socket.getInetAddress() +
                       ":" + socket.getPort());
            input = new DataInputStream(socket.getInputStream()); 
            // print received data 
            try {
                byte[] byteArray = new byte[4096];
                while(true) {
                    int nread = input.read(byteArray , 0, 4096);
                    if (0==nread) 
                        break;
                }
            }
            catch (IOException e) {
                System.out.println(e);
            }
            // connection closed by client
            try {
                socket.close();
                System.out.println("Connection closed by client");
            }
            catch (IOException e) {
                System.out.println(e);
            }
            System.out.println(e);
        }
    }
}

测试一下图片