Optimum polynomial

题意：

最优多项式

如果我们知道了一个数列的前k项，我们仍无法确定地给出下一项的值，因为有无穷个多项式生成函数都有可能是这个数列的模型。

例如，让我们考虑立方数的序列，它可以用如下函数生成，
un = n3: 1, 8, 27, 64, 125, 216, …

如果我们只知道数列的前两项，秉承“简单至上”的原则，我们应当假定这个数列遵循线性关系，并且预测下一项为15（公差为7）。即使我们知道了数列的前三项，根据同样的原则，我们也应当首先假定数列遵循二次函数关系。

给定数列的前k项，定义OP(k, n)是由最优多项式生成函数给出的第n项的值。显然OP(k, n)可以精确地给出n ≤ k的那些项，而可能的第一个不正确项（First Incorrect Term，简记为FIT）将会是OP(k, k+1)；如果事实的确如此，我们称这个多项式为坏最优多项式（Bad OP，简记为BOP）。

在最基本的情况下，如果我们只得到了数列的第一项，我们应当假定数列为常数，也就是说，对于n ≥ 2，OP(1, n) = u1。

由此，我们得到了立方数列的最优多项式如下：

显然，当k ≥ 4时不存在坏最优多项式。

所有坏最优多项式的第一个不正确项（用红色标示的数）之和为1 + 15 + 58 = 74。

考虑下面这个十阶多项式生成函数：

求其所有坏最优多项式的第一个不正确项之和。

题解：

因为我们知道了一个数列的前k项，但我们仍无法确定地给出下一项的值，因为有无穷个多项式生成函数都有可能是这个数列的模型。从这里，我们可以想到拉格朗日插值。什么是拉格朗日插值？我简单得解释一下。

我们都做过数学的规律题，就是给你一个数列，然后让你猜下一个数是什么。这题也是这样。

先写一下拉格朗日插值的定义：

对某个多项式函数，已知有给定的k + 1个取值点：

其中对应着自变量的位置，而对应着函数在这个位置的取值。

假设任意两个不同的x_j都互不相同，那么应用拉格朗日插值公式所得到的拉格朗日插值多项式为：

其中每个为拉格朗日基本多项式（或称插值基函数），其表达式为：

拉格朗日基本多项式的特点是在上取值为1，在其它的点上取值为0。

所谓的插值，就是“插”“值”，就是指找出一个通过给出离散数据点的函数。例如，数列中给出数据可以表示为在坐标系上的点，x坐标就是第几项，y坐标就是该项的值。然后画个图，找出这些数在哪个函数数，求出这个函数，这样就可以求出下一项了。先试一个简单的数列：1、8、27…那下一个是什么呢？

我们知道:

,  

 , 

 , 

那么：

那么下一项就是将x=4代入上面的二元一次方程，就是58啦。

如果你发现这个答案其实是错的！正确的是y=x^3? 其实答案是64。那就是拉格朗日插值是错的咯？

再仔细看一下坑爹的高数课本，才发现原来是我们一直搞错了。如果我们给的是n个点，那么拉格朗日给出的函数将会是(n-1)次的。

也就是拉格朗日插值:n次多项式可以用n+1个点唯一确定.

这不坑爹吗…用公式之前还得想清楚这个函数是几次的，而且如果是更高次数的还没办法加上点去求。

这就意味着，就算是1、2、3、4、5、6…这样的数列，拉格朗日插值法在耗尽你大量的考试时间去求出通项公式以后，还会给出一个超级坑爹的答案！

那么这个方法还有什么用！
别急，前面的计算都是为后面做铺垫的。现在才是重点。

无论是分布得多么奇怪的点，拉格朗日插值法总能给出一条经过这些点的函数图象。也就是说，就算是1、2、3、4、5、6、1568这样明显不靠谱的答案也是“有规律的”。因为你总可以设一个六次多项式，找出这个数列的通项公式。
所以说：
1、3、5、7、9、1598，是对的
3、1、4、1、5、9、2、999，是对的
1，1，2，3，5，7，8989，是对的
2，4，6，8，5，是对的

你想怎么写都是对的，即使看起来不靠谱，但其仍然存在内在关系与规律。

解释完啦！

插值公式是:

拉格朗日插值法可以帮助我们解决以下的问题：
例如：已知x取值0，1，-1，2时， f{x}取值2，2，0，6 。
求x=3时f{x}的值。

#include<cstdio>
#include<iostream>
using namespace std;
int xs[4]={0,1,-1,2};
int ys[4]={2,2,0,6};
//f(3)?
      
int lagrange_Polynomial(int x, int xs[],int ys[]) 
{
    int c1,c2; 
    int n=4;
    c1=0; 
    for(int i=0;i<n;i++)
	{ 
        c2=ys[i]; 
        for(int j=0;j<n;j++)
        {
            if(j!=i) c2=c2*((x-xs[j])*1.0)/((xs[i]-xs[j])*1.0); 
        }
    	c1+=c2; 
    } 
    return c1;
}
int main()
{
	int val=lagrange_Polynomial(3,xs,ys);
	cout<<val<<endl; //输出 ：20 
	return 0;
}

同理，PE101这题就可以按相同的方法解出来啦。

如果你做出了PE101，你可以做另外一题：Codeforces 622F

    ScaleDrawable对应于xml文件中的<scale>标签，可以根据自己的level将指定的drawable缩放到一定比例。基本语法如下：

<?xml version="1.0" encoding="utf-8"?>
<scale xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@color/blue"
    android:level="1"
    android:scaleGravity="center"
    android:scaleHeight="20%"
    android:scaleWidth="20%" />

@Override
    public void draw(Canvas canvas) {
        final Drawable d = getDrawable();
        if (d != null && d.getLevel() != 0) {
            d.draw(canvas);
        }
    }

@Override
    protected void onBoundsChange(Rect bounds) {
        final Drawable d = getDrawable();
        final Rect r = mTmpRect;
        final boolean min = mState.mUseIntrinsicSizeAsMin;
        final int level = getLevel();
        int w = bounds.width();
        if (mState.mScaleWidth > 0) {
            final int iw = min ? d.getIntrinsicWidth() : 0;
            //这里的iw一般都为0 ，可以得到：ScaleDrawable级别最大值10000，level越高，看起来越大，定义的缩放比例越大，看起来越小。
            w -= (int) ((w - iw) * (10000 - level) * mState.mScaleWidth / 10000);//iw一般都为0
        }
        int h = bounds.height();
        if (mState.mScaleHeight > 0) {
            final int ih = min ? d.getIntrinsicHeight() : 0;
            h -= (int) ((h - ih) * (10000 - level) * mState.mScaleHeight / 10000);
        }
        final int layoutDirection = getLayoutDirection();
        Gravity.apply(mState.mGravity, w, h, bounds, r, layoutDirection);
        if (w > 0 && h > 0) {
            d.setBounds(r.left, r.top, r.right, r.bottom);
        }
    }

<?xml version="1.0" encoding="utf-8"?>
<scale xmlns:android="http://schemas.android.com/apk/res/android"
    android:drawable="@mipmap/ic_launcher"
    android:scaleGravity="center"
    android:scaleHeight="70%"
    android:scaleWidth="70%" />

View scale = findViewById(R.id.scaleDrawable);
        ScaleDrawable scaleDrawable = (ScaleDrawable) scale.getBackground();
        scaleDrawable.setLevel(1);

简介说明

使用Spring MVC的Annotation验证可以直接对view model的简单数据验证，比如格式、长度等，如果model的数据验证需要有一些比较复杂的业务逻辑性在里头。

以下是使用Spring MVC自带的annotation验证，加上自定义的一个@Tel的annotation验证例子，此例子具有：

1、支持多语言（国际化）
2、对默认数据先进行转化，比如int、date类型如果传入空值时，会抛异常，默认给定值

案例代码

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <display-name>Test Spring MVC - 1</display-name>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

spring.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:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-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/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <!--注解说明 -->
    <context:annotation-config />

    <!-- 默认的注解映射的支持 -->
    <mvc:annotation-driven validator="validator" conversion-service="conversionService" />

    <!-- 把标记了@Controller注解的类转换为bean -->
    <context:component-scan base-package="com.my" />

    <!-- 视图解释类 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/><!--可为空,方便实现自已的依据扩展名来选择视图解释类的逻辑  -->
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
    </bean>

    <!-- 资源文件：messages.properties -->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basenames">
            <list>
                <value>messages</value>
            </list>
        </property>
    </bean>
    <!-- 验证器 -->
    <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
        <property name="validationMessageSource" ref="messageSource"/>
    </bean>

    <!-- 自定义数据类型转换器 -->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <list>
                <bean class="com.my.controller.converter.IntConverter" />
                <bean class="com.my.controller.converter.DateConverter" />
            </list>
        </property>
    </bean>

</beans>

1）在<mvc:annotation-driven/>中加入conversionService
2） 在conversionService中加入转换器，如上有IntConverter和DateConverter，可以是自定义/系统的类型，这是全局的。
3）在validator验证器中加入了支持多语言的properties – 支持国际化

Controller

package com.my.controller;

import java.util.List;

import javax.validation.Valid;

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.my.controller.bean.User4;

@Controller
@RequestMapping(value="av")
public class TestAnnotationValidController {

    @RequestMapping
    public ModelAndView index() {
        ModelAndView view = new ModelAndView("/TestAnnotationValid/index", "user4", new User4());
        return view;
    }

    @RequestMapping(value="/add", method=RequestMethod.POST)
    public ModelAndView add(@ModelAttribute @Valid User4 user, BindingResult result) {
        ModelAndView view = new ModelAndView("/TestAnnotationValid/index");
        view.addObject("user4", user);

        if(result.hasErrors()) {
            List<FieldError> errors = result.getFieldErrors();
            for(FieldError err : errors) {
                System.out.println("ObjectName:" + err.getObjectName() + "\tFieldName:" + err.getField()
                        + "\tFieldValue:" + err.getRejectedValue() + "\tMessage:" + err.getDefaultMessage() + "\tCode:");
            }
        }

        return view;
    }

}

在add中，有一个@Valid的annotation，这是必需的，不加这个，annotation验证将不起作用

User4.java model实体类

package com.my.controller.bean;

import java.util.Date;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Past;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotBlank;

public class User4 {

    private long id;

    @NotBlank(message="{valid.name}")
    private String name;

    @Length(min=4, max=20, message="{valid.password}")
    private String password;

    @NotBlank(message="{valid.required}")
    @Email(message="{valid.email}")
    private String email;

    @NotNull(message="{valid.required}")
    private boolean married;

    @Min(value=18, message="{valid.ageMin}")
    @Max(value=100, message="{valid.ageMax}")
    private int age;

    @NotNull(message="{valid.required}")
    @Past(message="{valid.birthday}")
    private Date birthday;

    @Pattern(regexp="^[a-zA-Z]{2,}$", message="{valid.address}")
    private String address;

    @Size(min=1, message="{valid.likesMin}")
    private String[] likes;

    @com.my.controller.validator.Tel(message="{valid.tel}", min=3)
    private String tel;

    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public boolean isMarried() {
        return married;
    }
    public void setMarried(boolean married) {
        this.married = married;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String[] getLikes() {
        return likes;
    }
    public void setLikes(String[] likes) {
        this.likes = likes;
    }
    public String getTel() {
        return tel;
    }
    public void setTel(String tel) {
        this.tel = tel;
    }

}

除了@Tel之外，其它都是spring自带的annotation，这些注解中包含规则以及验证失败的返回信息。

message.properties

valid.required=字段值不能为空
valid.name=用户名不能为空
valid.password=密码最小4位
valid.ageMin=年龄不能小于{1}岁
valid.ageMax=年龄不能大于{1}岁
valid.email=邮箱格式不正确
valid.address=联系地址不正确
valid.birthday=生日不能大于今天
valid.likesMin=喜好最小不能小于1个
valid.tel=手机号码不能小于{min}位

对应的是User4 model的annotation的message值。如果需要国际化的多语言，只需要加入多一个messages_en_US.properties这样名字的文件即可。

自定义注解@Tel

package com.my.controller.validator;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy=TelValidator.class)
public @interface Tel {

    int min() default 0;

    String message();

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

验证器TelValidator

package com.my.controller.validator;

import javax.annotation.Resource;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

import org.springframework.context.support.ResourceBundleMessageSource;

public class TelValidator implements ConstraintValidator<Tel, String> {

    @Resource
    private ResourceBundleMessageSource messageSource;

    private Tel tel;

    @Override
    public void initialize(Tel tel) {
        this.tel = tel;
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext constraintContext) {
        boolean isValid;

        if(value != null && value.length() >= tel.min()) {
            isValid = true;
        }
        else {
            isValid = false;
        }

        if(!isValid) {
            constraintContext.disableDefaultConstraintViolation();
            constraintContext.buildConstraintViolationWithTemplate(tel.message()).addConstraintViolation();
        }
        return isValid;
    }

}

转换器Converter

package com.my.controller.converter;

import org.springframework.core.convert.converter.Converter;

public class IntConverter implements Converter<String, Integer> {

    @Override
    public Integer convert(String text) {
        if (text == null || "".equals(text)) {
            return 0;
        } else {
            try {
                Integer value = Integer.parseInt(text);
                return value;
            } catch (Exception e) {
                return 0;
            }
        }
    }

}

package com.my.controller.converter;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.core.convert.converter.Converter;

public class DateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String text) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        dateFormat.setLenient(false);
        try {
            return dateFormat.parse(text);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

}

测试JSP

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<%@ taglib prefix="st" uri="http://www.springframework.org/tags" %>
<%@ taglib prefix="sf" uri="http://www.springframework.org/tags/form"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Index</title>
</head>
<body>
    <sf:form action="${pageContext.request.contextPath}/av/add" method="post" modelAttribute="user4">
        User name:<sf:input path="name"/><sf:errors path="name" /><br/>
        Password:<sf:input path="password"/><sf:errors path="password" /><br/>
        E-mail:<sf:input path="email"/><sf:errors path="email" /><br/>
        Age:<sf:input path="age"/><sf:errors path="age" /><br/>
        Birthday:<sf:input path="birthday"/><sf:errors path="birthday" /><br/>
        Address:<sf:input path="address"/><sf:errors path="address" /><br/>
        Married:
            <sf:radiobutton path="married" label="Yes" value="true"/>
            <sf:radiobutton path="married" label="No" value="false"/>
            <sf:errors path="married" /><br/>
        Likes:
            <sf:checkbox path="likes" label="Football" value="Football"/>
            <sf:checkbox path="likes" label="Badminton" value="Badminton"/>
            <sf:checkbox path="likes" label="Pingpong" value="Pingpong"/>
            <sf:errors path="likes" /><br/>
        Tel:<sf:input path="tel"/><sf:errors path="tel" /><br/>
        <input type="submit" value="Add" />
        <hr/>
        Errors:<br/><sf:errors path="*"></sf:errors>
        <hr/>
        Likes:<c:forEach items="${user4.likes}" var="item">${item},</c:forEach>
    </sf:form>
</body>
</html>

That’s All！测试跑一跑~

  前段时从图书馆借了《必然》（《The inevitable》），这是凯文凯利（KK）三部曲之一（其它两部是《失控》和科技想要什么），其中主要内容是对未来的展望。对未来描述的书很多，前段时间读的《奇点临近》也算是一本。但是这两者区别很大，《必然》主要是从现在预言在未来10~30年内人类生活会有什么样的变化，科技如何融入在我们生活之中，而且KK的风格感觉很像碎碎念。《奇点临近》是纵观进化历史的发展，总结历史发展规律，进而描述未来的状态。其跨越的时间段相对较长，作者满篇旁征博引，参考文献的厚度在书中占了大概20%，让人读来感觉言之凿凿。两本书无法评判孰优孰劣，都有很大的闪光点，都有不同的观点和见解。我觉得能学到不同的观点，了解不同的想法，这才是非常重要的。这本书给我的一个强烈的感觉是它把目前出现的一些新的事物进行了总结，并在合理的基础上进行扩展和发散，描绘出未来20~30年的景象。读这一类书，都感觉是在看一个全新的世界，充满了好奇和期待。

  《必然》全书共十二章，包括形成（Becoming）、知化（Cognifying）、流动（Flowing）、屏读（Screening）、使用（Accessing）、共享（Sharing）、过滤（Filtering）、重混（Remixing）、互动（Interacting）、追踪（Tracking）、提问（Questioning），以及开始（Beginning）。每一章都有新的内容，但每一章的内容并不独立，相同的观点融会贯通。比如第三章流动，之所以目前很多东西能流动，能更广泛的传播，因为当前的数字化技术，让很多东西能够轻易的被复制和传播，比如音乐，电影等等。免费复制又恰恰像催化剂一样，让流动更加剧烈。然而，我觉得流动，也正是后面很多章节的基础，比如第4章屏读，第6章共享等。这两个都离不开“流动”这个前提。但是这两章又不仅仅是“流动”一个特例，它们又包含了很多新的内容和新的体验。

• 第一章 形成(Becoming)。这一章中，作者提出我们现在处于“进托邦”，也就是说现在每天都是比昨天好的，都比昨天有进步。作者举了互联网的发展历程作为一个例子。在这个例子中，让我印象最深的是关于人们对互联网认识的一个转变。最开始，互联网诞生的时候，很少人看好它，特别是当时的媒体，没有想过通过互联网来扩大信息受众，加强自己。因为，他们觉得观众始终是观众，是信息的接收者。而自己才是信息的产生和传播者。如果要生成更加大量的信息，必然要投入很多。然而，在今天，媒体公司并不再是信息的产生着，他们不再创造和生产信息，他们仅仅是提供一个平台，让每一个用户参与其中。此时，用户不仅仅是信息的受众，同样也是信息的生产者。在互联网刚出来的时候，那些媒体公司难以想象这种运作模式。作者在这里提出，类比于互联网的产生到现在，如果我们能站在未来看今天，可能很多新的东西我们还能够做，还能够成为第一人。但是处在今天的我们，估计眼光还会受限吧。但是到达未来是从今天开始，从现在开始，因此作者认为目前仍然是绝无仅有最佳开始时机。
  

• 知化(Cognifying)。这一章中作者介绍了以后无处不在的智能，身边的东西似乎都将变得有了“灵性”，能给我们提供更强大更好的服务。然而它们的智能和我们的人类的智能却不一样，我们可能会难以理解这种“异类智能”。但是在作者说的人类和机器人的工作关系的四大类中，或许只有我们不断创造新的工作（只有人类能干的工作），才能不被机器人征服。然后这些新的工作又给机器人来做，我们再创造新的工作，如此循环，也许这是人类和机器人长久的相处之道。

• 第三章 流动(Flowing)。在现在的科技社会中，数字化给我们带了很大的好处，其中一项就是我们能够轻易的复制被数字化的东西。比如音乐，电影，小说等等。因为能够方便的复制这些东西，这就加速了这些东西的流动，让更多人能够接触和获取，信息的传播更加快速而广泛。再进一步，免费，让我们更加自由的去复制，去传播，去获取，它犹如催化剂一般，让流动更加汹涌澎湃。在免费这个趋势中，无法复制的东西才真正更有价值，比如说人与人之间的信任。作者列举了8中性质（1即时性；2个性化；3解释性；4可靠性；5获取权；6实体化；7可赞助；8可寻性），这些原生性为免费商品增加了价值，从而变成了可出售的商品。作者还指出，流动让我们能改变曾经只能是固定的东西，从而以更低的成本创造出更大的价值。流动让我们在获得产品的过程中能够参与的更多，获得更加个性化的服务。我觉得这些便是在免费使用中获得价值的来源。

• 第四章 屏读(Screening)。这个对于我们现在的人来说应该不陌生了，通过显示屏获取信息已经成为我们生活的日常部分。从语言口口相传， 到文字在纸上的印刷，再到屏幕上五颜六色，变换各异地显示。虽然纸质的书让我们觉得很靠谱，但是采用屏幕显示文字，已经是个趋势。然而，纸质版的书仍然有存在的必要，因为它被印刷出来后确定了，很难像电子书那么容易改变，除非我们重新印刷。除此以外，电子书有更强大的笔记，我们能在不懂的地方注释，还能加入超链接。这让书本不在独立，而是形成一个网络。我们能够通过超链接，从这本书跳转到其他地方。而且我们以后的屏幕更加先进，更加小巧，随意折叠让其能够更加自由的阅读和携带。作者又幻想了一下，在屏读普遍的时候，他的生活是如何的。

• 第五章 使用(Accessing)。未来的30年里，减物质化、去中心化、即时性、平台协同和云端将持续发展。我们使用东西并不需要拥有，我们相当于有一个虚拟橱柜，或者处在魔法租赁店，需要使用什么都能轻易获取。比如Uber，我们不需要拥有车，也不需要在街上拦车，我们只需要打开APP就能让车到身边来，从而使用。作为服务的使用者，我们以后需要的只是订阅，并不是拥有，便能获得更新更全的服务。现在已经进入到这一块儿的，就是软件行业，我们并不需要不断的去购买最新的软件使用权，而是逐年订阅，获得不断的更新。
  

• 第六章 共享(Sharing)。linux，维基百科等便是共享的例子。虽然有人认为，比如比尔盖茨，这是共产主义的形式，对于身处于资本主义世界的他们，或许觉得这些便是值得嘲笑的。然而共产主义之火可以燎原，人们都希望能够免费获取使用，而且能够参与其中，贡献一份力量，从而促进了共享信息的更新和壮大。
  

• 第七章 过滤(Filtering)。我们现在处在信息的洪流之中，如何在其中获取我们想要的信息呢？过滤必不可少。搜索引擎便是一个很好的例子，我们通过输入关键字获取我们想要的信息，过滤掉无关信息。而且搜索引擎现在越来越智能化，能给我们每个人提供个性化的搜索结果。KK说，进行更多的过滤是必然的，因为我们不停地制造新东西。而在我们将要制造的新东西中，首要一点就是创造新的方式来过滤信息和个性化定制，以突显我们的差异。
  

• 第八章 重混(Remixing)。经济学家Brain Arthur认为所有的新技术都源自已有技术的组合。现在，数字技术让我们能够容易的拆分获得原有的元素，然后组合，创造出新的元素。 进而，文化作品是出现重混最多的地方。我们能够轻易的获取别人图片中的一部分，我们能够把影片的中片段提取出来，这便是原有的元素。我们在进一步的组合，融入我们自己的想法，变出现了新的东西。这也是对已有的实物重新排列再应用。作者举例最多的便是现在的电影和小短片之间的关系。作者认为，如果好莱坞是金字塔的定点，那么底层才是滋生各种行动的地方，是开启动态影像未来的地方
  

• 第九章 互动(Interacting)。这一章中作者举的例子，便是目前很火的VR技术。这种方式让使用者感觉身临其境，还能有除了视觉以外的其他感觉。这个技术不仅仅可以用在游戏之中，当然用在游戏中能大大提高游戏的可玩性，还可以用在生活的各个方面。我们能够虚拟地试穿衣服，能够举行更加现实的远程会议等等。当然这仅仅是互动的一种方式，我们还能够使用语音控制设备，设备能观察我们眼球的运动并作出反应，还能够识别我们的表情。这些新的互动方式是更加深层次，更加便利的。我觉得如果能通过新的互动方式，得到对方（同样是人）的感觉和想法，这或许能打破目前人与人之间的交往方式。
  

• 第十章 追踪(Tracking)。作者认为我们能够获取我们身体上各种数据指标，从而实时监测身体状况，这好像是传感器网络的一种应用。通过部署传感器，我们能够实时获取数据，并且进行监测和分析，及时发现问题并进行响应和处理。当然，这里就不得不提一下物联网了，把身边的事物都能接入互联网中，这必然会产生数据的井喷，因此我们需要在云端通过合理的算法进行追踪和处理数据。

• 第十一章 提问(Questioning)。作者以维基百科为例阐述了这个问题。在为维基百科添加词条，丰富内容的人群中，不再有特别的身份限制，我们每个人都能贡献出自己的知识，不断丰富维基百科的内容。这使得维基百科越来越专业，越来越受信任。虽然作者开始认为维基百科不可能成功，然而这不可能成为了可能。

• 第十二章 开始(Beginning)。这一章，作者把全球级别的层级叫做holos，它包括了所有人的集体心智、所有机器的集体行为、自然界的智能相结合形成的整体，以及出现在这个整体中的任何行为。感觉我们目前的就生活在holos这个“智慧之物”下面，我们每一次的行为都在丰富着holos，推动holos的进步和发展。作者在这块儿提到了奇点的概念，他不认为人工智能是“我们最后的发明”，相反，我们创造出的东西让自己成为更好的人。这便是开始。

原文：UICollectionView Tutorial: Getting Started
作者：Bradley Johnson
译者：kmyhy

注：本文由 Bardley Johnson 升级至 Swift 和 iOS 9，原文作者是 Brandon Trebitowski。

iOS 的照片程序采用时髦的多布局方式显示照片。你可以用网格方式浏览照片：

还可以通过“相册”的方式浏览照片：

你还可以通过捏合手势来切换两种布局。你可能会想：“我也想在我的 App 中使用这个！”

通过 UICollectionView 你可以很容易实现自定义布局和布局转换动画（就如照片程序一样)。

不仅仅是网格布局或栈式布局，因为 Collection View 是非常可定制化的。你可以用它们实现环形布局，封面流布局，Pulse news style 布局——只要你能想到的都能做到。

幸好，只要你对 UITableView 不陌生，那么 Collection View 对你来说都不会成为问题——它们的用法和 Table View 的数据源/委托模式差不多。

在本文，你会通过创建自己的网格式照片浏览 App 来学习 UICollectionView。当你学完本教程，你会学会如何使用基本的 Collection View，并可以在自己的 App 中使用这些神奇的技术！

剖析 UICollectionView

我们来看一下最终完成的项目。UICollectionView 有几个构建组件，如下所示：

它们分别是：

1、UICollectionView – 用于显示主要内容的 UIView。和 UITableView 一样，Collection View 也是 UIScrollView 子类。
2、UICollectionViewCell – 和 TableView 中的 UITableViewCell 一样。这些 cell 构成了视图的内容，并以 Collection View 的 subview 形式存在。cell 可以编码创建，也可以用 IB 创建。
3、Supplementary Views – 如果你需要显示一些不能在 cell 中展示、但仍然需要放在 Collection View 中显示的额外信息，你可以使用 Supplementary View。比如 header 或 footer。

注：Collection View 也可以有 Decoration View —— 如果你想通过一些特殊的 view 增强 Collection View 的外观（通常不会放真正有用的数据），你可以使用 Decoration View。比如背景图片或者其他可视化的装饰性组件。在本文中你不会用到 Decoration View，因为它需要我们编写自定义的布局类。

除此之外，Collection View 还有一个 layout 对象用于管理内容的大小、位置或其它属性。Layout 对象是一个 UICollectionViewLayout 子类。Layout 对象可以在运行时改变，Collection View 甚至为 Layout 之间的切换提供内置的动画。

你可以继承 UICollectionViewLayout 来创建自己的布局，苹果为开发者提供了一个基本的“流式”布局即 UICollectionViewFlowLayout。它将 cell 根据它们的大小一个接一个地排列，就像一个网格。你可以用这个现成的布局，或者对它进行扩展（子类化）实现自己的行为和可视化效果。

在本文和下一篇教程中，你讲深入学习这些元素。现在，请从一个实际项目开始！

FlickrSearch 简介

本文接下来的内容，将创建一个很酷的照片浏览程序，叫做 FlickrSearch。它允许你从著名的照片分享网站 Flickr 上按关键词搜索照片，并将搜索到的照片下载和显示到一个网格视图中，正如早先的截图中所示。

准备好了吗？打开 Xcode ，点开 File\New\Project… 菜单，选择 iOS\Application\Single View Application 模板。

这个模板会提供一个简单的 UIViewController 和 storyboard 故事板文件。这是一个很好的开头。

点击 Next 填写 App 信息。将 Product Name 设为 FlickrSearch, 设备类型选择 iPad ，语言设为 Swift。点击 Next 选择一个文件路径，然后点 Create。

View Controller 和故事板文件对你来说没有用处——我们要使用的是 UICollectionViewController。它和 UITableViewController一样，是一个特殊的 view controller 子类，拥有一个 collection view。将ViewController.swift 删除，然后将 Main.storyboard 中的 View controller 也删除。现在你的故事板是空的了。

打开 AppDelegate.swift，加一个常量用于存放一个阴影色，叫做 Wenderlich Green。在 import 语句下加入：

let themeColor = UIColor(red: 0.01, green: 0.41, blue: 0.22, alpha: 1.0)

Wenderlich Green 作为整个 App 的主题色。然后修改 application(_:didFinishLaunchingWithOptions:) 方法：

func application(application: UIApplication!, didFinishLaunchingWithOptions
  launchOptions: [NSObject: AnyObject]?) -> Bool {

  window?.tintColor = themeColor
  return true
}

开始

打开 Main.storyboard ，拖一个 Collection View Controller。点击 Editor\Embed in\Navigation Controller 菜单，这将创建一个 navigation controller 并将 collection view controller 设置为 root View controller。

现在故事板应该是这个样子：

然后，选择 Navigation Controller ，将它设为 initial view controller:

接着，回到 collection view controller,选中 UICollectionView 背景色修改为白色：

注：知道 Scroll Direction 属性是干什么的吗？这个属性是 UICollectionViewFlowLayout 专有的，默认值是 Vertical。一个垂直的流式布局表示将 cell 按照从左到右排列如果排到最右边，则移到下一行。如果 cell 太多，用户可以通过垂直滚动来查看。
于此对应，水平流式布局将 cell 按照从上到下排列，直到排到最底部。用户可以用水平滚动的方式浏览。本文中使用垂直布局。

选择 collection view 中的 cell,将 Reuse Identifier 设为 FlickrCell。这和 Table View 中是类似的——就像数据源方法会用这个 ID 来重用或创建新的 cell。

拖一个 text field 到 collection view 上方的导航栏中心。这会用于给用户输入搜索关键字。将 Placeholder Text 设置为 Search ，Return Key 设为 Search:

然后，右键从 text field 拖一条线到 collection view controller 并选择 delegate outlet:

!{}(https://koenig-media.raywenderlich.com/uploads/2016/06/rw-cv7.png)

UICollectionViewController 是不错，但通常我们应该创建它的一个子类。点击 File\New\File…, 选择 iOS\Source\Cocoa Touch Class 并点 Next。类名命名为 FlickrPhotosViewController, 继承 UICollectionViewController。模板生成的文件中有许多模板代码，但理解这个类的最好方法还是从空白开始。打开 FlickrPhotosViewController.swift 修改内容为：

import UIKit

final class FlickrPhotosViewController: UICollectionViewController {

  // MARK: - Properties
  private let reuseIdentifier = "FlickrCell"
}

接着，定义一个常量用于 section 的 insets（后面我们会用到）：

private let sectionInsets = UIEdgeInsets(top: 50.0, left: 20.0, bottom: 50.0, right: 20.0)

在本文接下来的内容中，你将填充剩余的代码。

回到 Main.storyboard, 选中 collection view controller ，在 Identity 面板中，将 Class 设置为 FlickrPhotosViewController：

从 Flickr 抓取照片

在这一节，你的第一个任务是快速念出本节标题十次。哈哈，开个玩笑。

Flickr 是一个非常好的图片分享网站，向开发者提供公开的、极其简单的 API。通过这个 API 你可以搜索照片，为照片发表评论，等等。

要使用 Flickr API，你需要一个 API key。在真实的项目中，我建议你从这里注册一个：http://www.flickr.com/services/api/keys/apply/。

但是，如果是用于测试，Flickr 提供一个示例 key，你可以不用注册就能使用。你可以在这里找到： http://www.flickr.com/services/api/explore/?method=flickr.photos.search 一个并拷贝底部的 Url —— 将 “&api_key=” 和后面的 “&” 之间的内容拷贝到文本编辑器中待用。

例如，如果 URL 是：
http://api.flickr.com/services/rest/?method=flickr.photos.search&api_key=6593783 efea8e7f6dfc6b70bc03d2afb&format=rest&api_sig=f24f4e98063a9b8ecc8b522b238 d5e2f

则 API key 就是 6593783efea8e7f6dfc6b70bc03d2afb。

注：如果你使用了示例 API key,注意它每隔几天就会改变一次。因此如果你过几天来做这个例子，你会发现必须更新 API key。因此，如果你完成本文的例子需要几天时间的话，注册自己的 API key 会更轻松一点。

本文的目的是介绍 UICollectionView and 而非 Flickr API，所以有一些关于 Flickr 类已经为你创建好了，这样能减少你搜索 Flickr 时的代码。你可以从这里下载。

将 zip 文件解压缩并将解压缩后的文件拖到你的项目中，确保已勾选 Copy items into destination group’s folder(if needed),然后点击 Finish。

这些文件包含两个类和一个结构：

• FlickrSearchResults: 一个用于封装关键字和搜索结果的结构。
• FlickrPhoto: 用于保存从 Flickr 返回的照片数据——它的缩略图、完整图以及一些元数据比如 ID。还有一些方法，比如用于创建 Flick URL 和关于尺寸大小计算的方法。FlickrSearchResults 存储了一个包含这些对象的数组。
• Flickr: 一个简单的闭包式的 API，用于执行搜索并返回一个 FlickrSearchResult 对象。

你可以看看它们的代码——代码都很简单，但可能会引起你在自己的 App 中使用 Flickr 的兴趣。

在你能够搜索 Flickr 之前，你需要一个 API key。打开 Flickr.swift ，将 apiKey 修改为你获取到的 API key。可能会是这样的：

let apiKey = "hh7ef5ce0a54b6f5b8fbc36865eb5b32"

接下来，进入下一节——在使用 Flickr 之前需要做一点小小准备。

准备数据结构

App 要实现这个效果，每次搜索完之后，都会将搜索结果显示在一个新的 section 里（而不是直接替换掉原来的 section)。也就是说，如果你先搜索了“忍者”，有搜索了“海盗”，则 Collection View 中会同时显示一个“忍者”的 section 和一个“海盗”的 section。来一个灾难的列表怎么样？

要实现这个效果，你需要用一个数据结构将每个 section 所需的数据单独存储。这个可以用一个 FlickrSearchResults 数组来代替。

打开 FlickrPhotosViewController.swift 在 sectonInsets 常量声明下加入：

private var searches = [FlickrSearchResults]()
private let flickr = Flickr()

searches 数组用于保存所有的搜索结果，flickr 用于引用我们要用来进行搜索的对象。然后在文件最后增加一个私有扩展：

// MARK: - Private
private extension FlickrPhotosViewController {
  func photoForIndexPath(indexPath: NSIndexPath) -> FlickrPhoto {
    return searches[indexPath.section].searchResults[indexPath.row]
  }
}

photoForIndexPath 是一个实用方法，根据 Collection View 中的某个的 Index Path 返回对应的 FlickrPhoto 对象。你用 Index Path 来访问照片的地方非常多，这样你就不用重复写同样的代码了。

获取结果

现在开始搜索 Flickr！当用户输入后点击 Search，我们就开始搜索。在 Collectoin View Controller 中，我们已经将 TextField 的 delegate 设置为 self，我们可以利用它来做些事情了。

打开 FlickrPhotosViewController.swift ，添加一个 text field delegate 的扩展:

extension FlickrPhotosViewController : UITextFieldDelegate {
  func textFieldShouldReturn(textField: UITextField) -> Bool {
    // 1
    let activityIndicator = UIActivityIndicatorView(activityIndicatorStyle: .Gray)
    textField.addSubview(activityIndicator)
    activityIndicator.frame = textField.bounds
    activityIndicator.startAnimating()

    flickr.searchFlickrForTerm(textField.text!) {
      results, error in


      activityIndicator.removeFromSuperview()


      if let error = error {
        // 2
        print("Error searching : \(error)")
        return
      }

      if let results = results {
        // 3
        print("Found \(results.searchResults.count) matching \(results.searchTerm)")
        self.searches.insert(results, atIndex: 0)

        // 4
        self.collectionView?.reloadData()
      }
    }

    textField.text = nil
    textField.resignFirstResponder()
    return true
  }
}

代码解释如下：

1. 创建 Activity View ，然后调用 Flickr 类（我提供的用于搜索 Flickr 上的照片）异步搜索给定的关键字。当搜索完成，完成块被调用，并传入一个由 FlickrPhoto 对象构成的结果集，以及一个 NSError 对象（如果有的话）。
2. 将错误打印到控制台。当然，在真正的 App 中你应当将错误显示给用户。
3. 打印结果集并将其插入到 searches 数组的前列。
4. 到这里，你收到新数据，需要刷新 UI。你可以调用 reloadData() 方法，这个方法的作用就如同 TableView 的同名方法。

运行 App。在文本框中进行一个搜索，你会在控制台看到输出的日志，描述结果集的行数：

Found 20 matching bananas

注意 Flickr 类将结果集限制在 20 条数据，以保证加载时间不会太长。

不幸的是，你在 Collectoin View 中看不到图片！正如 TableView，Collection View 需要你实现一系列数据源方法和委托方法。

填充 UICollectionView

你可能想到了，在使用 Table View 时必须设置它的 dataSource 和 delegate 才能为它提供显示数据和处理事件（选中行事件）。

类似地，在使用 Collection View 时也必须设置它的数据源和委托属性。它们的职责分别是：

• 数据源（UICollectionViewDataSource）负责提供要显示的 item 的个数和视图。
• 委托（UICollectionViewDelegate）负责处理事件，比如 cell 被选择、加亮或删除等。

UICollectionViewFlowLayout 也有一个委托协议—— UICollectionViewDelegateFlowLayout。它允许你对布局行为进行调整，对某些对象进行配置，比如 cell 间距、滚动方向等等。

在本文，你会实现必要的 UICollectionViewDataSource 和 UICollectionViewDelegateFlowLayout 方法，以使你的 Collection View 能够正常运行。UICollectionViewDelegate 方法在这里不需要，你将在下一教程中使用它。

UICollectionViewDataSource

打开 FlickrPhotosViewController.swift, 添加一个针对 UICollectionViewDataSource 协议的扩展:

// MARK: - UICollectionViewDataSource
extension FlickrPhotosViewController {
  //1
  override func numberOfSectionsInCollectionView(collectionView: UICollectionView) -> Int {
    return searches.count
  }

  //2
  override func collectionView(collectionView: UICollectionView,
                               numberOfItemsInSection section: Int) -> Int {
    return searches[section].searchResults.count
  }

  //3
  override func collectionView(collectionView: UICollectionView,
                               cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
    let cell = collectionView.dequeueReusableCellWithReuseIdentifier(reuseIdentifier, forIndexPath: indexPath)
    cell.backgroundColor = .blackColor()
    // Configure the cell
    return cell
  }
}

这是较为简单的几个方法：

1. 一个 section 代表一个搜索，因此 section 的数目就是 searches 数组中的元素个数。
2. 每个 section 中的 item 个数，等于对应 FlickrSearch 对象中 searchResults 数组的元素个数。
3. 一个暂时的实现，仅仅返回空白的 cell——后面我们会用数据填充 cell。注意 Collectoin View 需要你为 cell 注册一个重用 ID，否则运行时会出现错误。

运行 app，执行搜索。你会看到多出 20 个 cell，可能看起来会有点奇怪：

UICollectionViewFlowLayoutDelegate

前面说过，每个 Collection View 都有一个与之关联的 layout。你现在用在项目中的 layout 就是系统内置的流式布局，这种布局简单、易用，提供了一个网格式的布局。

回到 FlickrPhotosViewController.swift, 在 flickr 常量下面声明：

private let itemsPerRow: CGFloat = 3

然后，增加一个对 UICollectionViewDelegateFlowLayout 的扩展，以使你的 view controller 采用这个流式布局委托协议：

extension FlickrPhotosViewController : UICollectionViewDelegateFlowLayout {
  //1
  func collectionView(collectionView: UICollectionView,
                      layout collectionViewLayout: UICollectionViewLayout,
                             sizeForItemAtIndexPath indexPath: NSIndexPath) -> CGSize {
    //2
    let paddingSpace = sectionInsets.left * (itemsPerRow + 1)
    let availableWidth = view.frame.width - paddingSpace
    let widthPerItem = availableWidth / itemsPerRow

    return CGSize(width: widthPerItem, height: widthPerItem)
  }

  //3
  func collectionView(collectionView: UICollectionView,
                      layout collectionViewLayout: UICollectionViewLayout,
                             insetForSectionAtIndex section: Int) -> UIEdgeInsets {
    return sectionInsets
  }

  // 4
  func collectionView(collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumLineSpacingForSectionAtIndex section: Int) -> CGFloat {
    return sectionInsets.left
  }
}

1. collectionView(_:layout:sizeForItemAtIndexPath:) 方法负责告诉布局引擎每个 cell 应该是多大尺寸。
2. 计算所有 padding 加起来有多少。即 n+1 乘以每个 cell 所留下的 padding，其中 n 为每行的 cell 个数。cell 间距采用 section inset 的左边边距。将视图的宽减去所有 padding 后再除以每行 cell 数即得到每个 cell 或 item 的宽。然后以这个宽和相等的高作为 item 的 size 返回（也就是一个正方形）。
3. collectionView(_:layout:insetForSectionAtIndex:) 方法负责返回 cell 之间的间距，cell 和 header/footer 之间的间距。这个值保存在一个常量中。
4. 这个方法布局中每行之间的间距，我们设为和左右 Padding 相同。

运行程序，进行一次搜索。看！比原来更大的黑色方块！

一切就绪，现在让我们来显示照片吧！

创建自定义 UICollectionViewCells

UICollectionView 中最精彩的一点就是，它和 Table View 一样，通过故事板能够用可视化的方式很方便地配置 CollectionView。你可以拖一个 UICollctionView 到你的 View Controller 中，在故事板编辑器中设计你的 cell。让我们来看看怎么做。

打开 Main.storyboard 选择 collection view。在 Size 面板中将 cell 大小修改为 200x200，让它的空间更大一点。

注：修改 cell 的 size 并不会影响 App 中实际 cell 的大小，因为我们会通过委托方法来配置 cell 的大小，它会覆盖你在故事板中的设置。

拖一个 Image View 到 cell，拖拉其大小占据整个 cell。在保持 Image View 被选中的状态下，打开 Pin 菜单，清除 Constrain to margins 选项，将 4 个方向的间距设置为 0：

选中状态下，将 Image View 的 Mode 设置为 Aspect Fit，这样图片无论哪个方向都不会被剪切和拉伸：

UICollectionViewCell 不允许进行任何定制，除了改变它的背景色外。你只能通过子类化进行定制，并方便地访问所有添加在上面的 subview。

打开 File\New\File… 菜单，选择 iOS\Source\Cocoa Touch Class 模板，点击 Next，类名命名为 FlickrPhotoCell, 并继承 UICollectionViewCell。

打开 Main.storyboard 选择 cell。在 Identity 面板，将 cell 的 Class 设为 FlickrPhotoCell:

打开助手编辑器，源代码窗口切换到 FlickrPhotoCell.swift ，右键从 Image View 拖一条线到源文件，创建一个 IBOutlet，命名为 imageView:

现在你创建了一个带有一个 ImageView 的自定义 cell。让我们来将照片显示在上面！打开 FlickrPhotosViewController.swift 将 collectionView(_:cellForItemAtIndexPath:) 方法替换为：

override func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
  //1
  let cell = collectionView.dequeueReusableCellWithReuseIdentifier(reuseIdentifier,
               forIndexPath: indexPath) as! FlickrPhotoCell
  //2
  let flickrPhoto = photoForIndexPath(indexPath)
  //3
  cell.imageView.image = flickrPhoto.thumbnail

  return cell
}

这个方法和之前的占位方法有点不同了。

1. cell 现在变成了一个 FlickrPhotoCell 对象。
2. 你需要获得存储有要显示的照片的 FlickrPhoto 对象，你可以调用先前定义的实用方法来获得。
3. 将缩略图传给 Image View。

运行程序，进行一次搜索，你可以看到你所找到的图片了！

耶！我们成功了！

注：如果你看到的结果与此不同，或者图片看起来有点奇怪，很可能是你的自动布局配置不正确。如果遇到坎，你可以对项目中的设置进行比较。

到此，你的所有工作就完成了（非常酷）—— 给自己一个表扬吧！这是最终完成的项目。

结尾

但还不够！继续阅读第二部分的教程，你会学习到：

• 如何添加自定义的 section header
• 如何通过拖放来移动 cell
• 如何在选中一个 cell 时打开详情页
• 如何选择多个 cell

同时，如果在学习中有任何问题或建议，请留言！

1：Modbus协议简介

            

2：FreeMODBUS移植

3：PLC modbus 地址

4：相关资料及工具

原文：UICollectionView Tutorial: Reusable Views, Selection, and Reordering
作者：Bradley Johnson
译者：kmyhy

注：本文由 Bardley Johnson 升级至 Swift 和 iOS 9，原文作者是 Brandon Trebitowski。

在第一部分教程中，你学习了如何用 UICollectionView 以网格的形式显示图片。
在第二部分，你将继续学习如何与 UICollectionView 交互以及定制它的 header。我们将继续利用第一部分教程中的项目。打开你的项目或者上节课中的 FlickrSearch 然后开始。 你还是需要使用上节课中用到新的 API key。如果你学习上节课的时候已经隔了一段时间了，那么你还需要重新获得一个 API key。

添加 header

这个 app 每搜索一次就添加一个 section。最好将每个搜索的结果集放在单独的 section 里展示。让用户更加清楚这些照片都是关于什么的。

我们将使用 UICollectionReusableView 来创建 header。这个类就像 Collection View Cell（事实上，cell 也继承了这个类），但它是用来表示别的东西比如 header 或 footer。

这个 View 可以通过故事板创建，然后连接到某个自定义类上。打开 File\New\File… 菜单，选择 iOS\Source\Cocoa Touch Class 模板，然后点 Next，类名命名为 FlickrPhotoHeaderView ，继承自 UICollectionReusableView。点击 Next、Create ，保存文件。
打开 MainStoryboard.storyboard ，从左边的 Scene 面板中点击 collection view ( 可能需要从根视图往下展开若干层级）。打开属性面板，勾选 Accessories 下面的 Section Header:

查看左边 Scene 面板，你会发现在 Collection View 下方增加了一个 “Collection Reusable View” 。点击这个 Collection Reusable View ，你就可以在里面添加 subview 了。

现在扩大一下它的空间，点击底部的白色拉柄向下拉，让它有 90 像素高。（或者在 Size 面板中修改大小）。

拖一个 Label 到 header上，将它居中对齐到导线。字体修改为 System 32.0，然后使用 Alignment 菜单，将它和 container view 水平和垂直对齐并 update frame:

选中 header，打开 Identity 面板，将 Class 设为 FlickrPhotoHeaderView。

打开属性面板，背景色设为 Group Table View Background Color，将 Identifier 设为 FlickrPhotoHeaderView。这个Identity 将在重用 Header View 时用到。

打开助手编辑器，源代码窗口中打开 FlickrPhotoHeaderView.swift ，右键从 label 拖一条线到源文件中，创建一个 IBOutlet，命名为 label:

class FlickrPhotoHeaderView: UICollectionReusableView {
  @IBOutlet weak var label: UILabel!
}

如果你这时运行程序，你还看不见 header(它仅仅是空白的一条，上面写着“Label”）。你还需要实现另外一个数据源方法。打开 FlickrPhotosViewController.swift 在 UICollectionViewDataSource 扩展的collectionView(_:numberOfItemsInSection:) 方法下加入这个方法：

override func collectionView(collectionView: UICollectionView,
                             viewForSupplementaryElementOfKind kind: String,
                             atIndexPath indexPath: NSIndexPath) -> UICollectionReusableView {
  //1
  switch kind {
  //2
  case UICollectionElementKindSectionHeader:
    //3
    let headerView = collectionView.dequeueReusableSupplementaryViewOfKind(kind,
                       withReuseIdentifier: "FlickrPhotoHeaderView",
                       forIndexPath: indexPath) as! FlickrPhotoHeaderView
    headerView.label.text = searches[indexPath.section].searchTerm
    return headerView
  default:
    //4
    assert(false, "Unexpected element kind")
  }
}

这个方法和 cellForItemAtIndexPath 方法相似，只不过是用在补充视图上。代码解释如下：

• layout 对象 kind 参数表明这个方法是针对哪一种类型的补充视图。
• UICollectionElementKindSectionHeader 是属于流式布局的一种补充视图。通过勾选故事版编辑器中的选项，我们增加了这种类型的补充视图——section header，同时流式布局就知道需要去请求哪一种类型的视图。还有一种补充视图是 UICollectionElementKindSectionFooter, 但是我们现在没有用到。如果你采用的不是流式布局，那你可以不用 header 和 footer。
• header 视图通过在故事板中指定的 identifier 进行重用。这种机制类似于 cell。标签上的文本会被搜索关键字替代。
• 用一个断言告诉其它开发者（包括以后的你）除了 header view 之外，你不会提供别的视图了。

运行程序。你会看到你的 UI 接近完成了。如果你进行多次搜索，你会发现每个结果集都有一个漂亮的 section header。另外当你旋转屏幕——注意看布局，包括 header，都会自适应，不需要进行额外的工作。

和 cell 进行交互

在本课的最后一部分，你将学习与 cell 的交互。有 3 种不同的方式。第一种是显示一个大图。第二种是通过多选进行分享。第三种是允许用户通过拖动重排图片。

单选

Collection View 可以动态修改它们的布局。你的第一个任务是当 item 被点击时显示大图。

首先，要加一个属性，保存当前被点击的 cell。打开 FlickrPhotosViewController.swift ，在 itemPerRow 之下添加属性：

//1
var largePhotoIndexPath: NSIndexPath? {
  didSet {
    //2
    var indexPaths = [NSIndexPath]()
    if let largePhotoIndexPath = largePhotoIndexPath {
      indexPaths.append(largePhotoIndexPath)
    }
    if let oldValue = oldValue {
      indexPaths.append(oldValue)
    }
    //3
    collectionView?.performBatchUpdates({
      self.collectionView?.reloadItemsAtIndexPaths(indexPaths)
    }) { completed in
      //4
      if let largePhotoIndexPath = self.largePhotoIndexPath {
        self.collectionView?.scrollToItemAtIndexPath(
          largePhotoIndexPath,
          atScrollPosition: .CenteredVertically,
          animated: true)
      }
    }
  }
}

代码解释如下：

1. largePhotoIndexPath 是一个可空变量，保存了当前点击到的图片的 Index Path，如果它存在的话。
2. 当这个属性改变，Collection View 需要刷新。利用 didSet 属性观察器能被很方便地做到这一点。这里有两个 cell 需要改变，用户当前点击的 cell 和之前点击过另一个 cell，或者用户是再次点击第一次点击的 cell，这些 cell 的大小需要改变。
3. performBatchUpdates 能够以动画块的方式改变 Collection View。 在动画块中，你刷新受影响的 cell。
4. 当动画结束，将变大的 cell 滚动到屏幕中央。

你也许会问，怎样让 cell 变大？请稍等一分钟！

点击 cell 时会让 Cellection View 去调用 cell 选中方法。你想知道是哪个 cell 被点击，可以修改 largeIndexPath 属性，当然你并不想真的选择这个 cell，因为之后我们要做多选，那会让我们混淆。UICollectionViewDelegate 为你想到了这一点。Collection View 会询问 delegate 某个 cell 是否能够被选中。打开 FlickrPhotosViewController.swift, 在 UICollectionViewDataSource 扩展中新增方法:

// MARK: - UICollectionViewDelegate
extension FlickrPhotosViewController {

  override func collectionView(collectionView: UICollectionView,
                               shouldSelectItemAtIndexPath indexPath: NSIndexPath) -> Bool {

    largePhotoIndexPath = largePhotoIndexPath == indexPath ? nil : indexPath  
    return false
  }
}

这个方法非常简单。如果点击的 cell 已经是一个大图，设置 largePhotoIndexPath 属性为 nil，否则设置为所点的 cell 的 IndexPath。这将调用这个属性的属性观察器，在这个方法中刷新受影响的 cell。

要让点击的 cell 变大，你需要修改 sizeForItemAtIndexPath 委托方法。在这个方法中使用如下代码：

// 新增代码
if indexPath == largePhotoIndexPath {
  let flickrPhoto = photoForIndexPath(indexPath)
  var size = collectionView.bounds.size
  size.height -= topLayoutGuide.length
  size.height -= (sectionInsets.top + sectionInsets.right)
  size.width -= (sectionInsets.left + sectionInsets.right)
  return flickrPhoto.sizeToFillWidthOfSize(size)
}

这里将 cell 的大小设置为尽可能占据整个 Collection View 大小，同时保持它的宽高比。除非你要显示更大的图片，否则没必要将 cell 弄得很大。

打开 Main.storyboard，拖入一个 Activity Indicator 到 cell 的 Image View 上。在属性面板中，将 Style 设置为 Large White 并勾选 Hides When Stopped 。将 Indicator 拖在 cell 的中央（这时导线出现），然后使用 Alignment 菜单，选择水平和垂直居中于 Container。

打开助手编辑器，右键，从 Activity Indicator 拖一条线到 FlickrPhotoCell.swift，创建一个 Outlet，命名为 activitIndicator:

@IBOutlet weak var activityIndicator: UIActivityIndicatorView!

同样在 FlickrPhotoCell.swift 中，添加下一个属性观察器，指定 cell 的背景色，然后调用属性观察器：

// MARK: - Properties
override var selected: Bool {
  didSet {
    imageView.layer.borderWidth = selected ? 10 : 0
  }
}

// MARK: - View Life Cycle
override func awakeFromNib() {
  super.awakeFromNib()
  imageView.layer.borderColor = themeColor.CGColor
  selected = false
}

然后，打开 FlickrPhotosViewController.swift 修改 collectionView(_:cellForItemAtIndexPath:) 方法为：

override func collectionView(collectionView: UICollectionView,
                             cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {

  let cell = collectionView.dequeueReusableCellWithReuseIdentifier(
               reuseIdentifier, forIndexPath: indexPath) as! FlickrPhotoCell
  var flickrPhoto = photoForIndexPath(indexPath)

  //1
  cell.activityIndicator.stopAnimating()

  //2
  guard indexPath == largePhotoIndexPath else {
    cell.imageView.image = flickrPhoto.thumbnail
    return cell
  }

  //3
  guard flickrPhoto.largeImage == nil else {
    cell.imageView.image = flickrPhoto.largeImage
    return cell
  }

  //4
  cell.imageView.image = flickrPhoto.thumbnail
  cell.activityIndicator.startAnimating()

  //5
  flickrPhoto.loadLargeImage { loadedFlickrPhoto, error in

    //6
    cell.activityIndicator.stopAnimating()

    //7
    guard loadedFlickrPhoto.largeImage != nil && error == nil else {
      return
    }

    //8
    if let cell = collectionView.cellForItemAtIndexPath(indexPath) as? FlickrPhotoCell
                  where indexPath == self.largePhotoIndexPath  {
      cell.imageView.image = loadedFlickrPhoto.largeImage
    }
  }

  return cell
}

代码有点长，我们分别解释如下：

1. 停止 Activity 的旋转——以便重用先前正在加载图片的 cell。
2. 这部分和之前的一样。如果没有找到当前 cell 的大图，那么将它设置为缩略图并返回。
3. 如果已经加载到大图，设置它为大图并返回。
4. 如果执行到这一步，说明你想要查看大图，但它还没下载。先使用缩略图，然后让 Activity 开始旋转。缩略图会被拉大显示，直到大图下载完成后。
5. 从 Flickr 请求大图。通过异步方式加载大图，并提供一个完成块。
6. 当下载完成，让小菊花停止旋转。
7. 如果发生错误或者图片未能下载，什么也不做。
8. 当下载完成时，根据 Index Path 来判断用户是否选择了另一个的 cell（如果视图发生过滚动，则很可能这个 cell 已经不是原来的 cell 了），如果还是原来那个 cell，设置它的 image 为下载到的大图。

运行程序，进行一次搜索，然后选一张图片——它会被拉伸到整个屏幕，其他 cell 会自动移开以挪出足够的空间。

再次点击 cell，或者开始滚动或点击其它 cell。你不需要写任何一句移动或让这些 cell 移动的代码，Collection View 和它的 layout 对象为你完成剩下的所有事情。

多选

你接下来的任务是允许用户选择多张图片，并和朋友分享。在 Collection View 中进行多选非常类似于 Table View。唯一的一点是告诉 Collection View 启用多选。

这个过程分为几个步骤进行：

1. 用户点击 Share 按钮告诉 UICollectionView 开启多选模式——并将 sharing 属性标记为 YES。
2. 用户选择多张图片，将它们添加到一个数组中。
3. 用户再次点击分享按钮，打开分享界面。
4. 用户或者完成分享，或者点击取消，选中的图片和 Collection View 又恢复单选模式。

首先打开 FlickrPhotosViewController.swift 在 itemsPerRow 属性下添加:

private var selectedPhotos = [FlickrPhoto]()
private let shareTextLabel = UILabel()

然后，在私有扩展的 photoForIndexPath(_:) 方法下添加方法:

func updateSharedPhotoCount() {
  shareTextLabel.textColor = themeColor
  shareTextLabel.text = "\(selectedPhotos.count) photos selected"
  shareTextLabel.sizeToFit()
}

selectedPhotos 数组会保存住用户所选的图片，shareTextLabel 则用于显示用户选择了几张图片。你会调用 updateSharedPhotoCount 来更新 shareTextLabel 的显示。

然后在 largePhotoIndexPath 属性下添加下列属性:

var sharing: Bool = false {
  didSet {
    collectionView?.allowsMultipleSelection = sharing
    collectionView?.selectItemAtIndexPath(nil, animated: true, scrollPosition: .None)
    selectedPhotos.removeAll(keepCapacity: false)

    guard let shareButton = self.navigationItem.rightBarButtonItems?.first else {
      return
    }

    guard sharing else {
      navigationItem.setRightBarButtonItems([shareButton], animated: true)
      return
    }

    if let _ = largePhotoIndexPath  {
      largePhotoIndexPath = nil
    }

    updateSharedPhotoCount()
    let sharingDetailItem = UIBarButtonItem(customView: shareTextLabel)
    navigationItem.setRightBarButtonItems([shareButton,sharingDetailItem], animated: true)
  }
}

sharing 是一个 Bool 属性，我们为它定义了另一个属性观察器，和前面的 largePhotoIndexPath 类似。在这个属性观察器中，你会切换 Collection View 的多选状态，清空所选的 cell 和照片数组。同时，你还要在导航栏中加入和刷新 shareTextLabel 和 UIBarButtonItem。

打开 Main.storyboard ，拖一个 UIBarButtonItem 到 Collectoin View 上面的导航栏的右边。 在属性面板中，将 System Item 设置为 Action，并选择一个常见的分享图标。打开助手编辑器，确认源代码窗口中打开的是 FlickrPhotosViewController.swift ，然后用右键从 bar button 拖一条线到源代码中，创建一个 IBAction 叫做 share:，sender 类型设置为 UIBarButtonItem。
实现这个 IBAction 方法：

@IBAction func share(sender: UIBarButtonItem) {
  guard !searches.isEmpty else {
    return
  }

  guard !selectedPhotos.isEmpty else {
    sharing = !sharing
    return
  }

  guard sharing else  {
    return
  }
  //TODO actually share photos!
}

这个方法仅仅判断用户是否搜索结果是否为空，如果不为空，分享所选照片。

现在开始允许用户选择 cell。在 collectionView(_:shouldSelectItemAtIndexPath:) method: 顶部加入：

guard !sharing else {
  return true
}

这段代码只允许用户在分享模式下选择 cell.

然后，在 UICollectionViewDelegate 扩展的 collectionView(_:shouldSelectItemAtIndexPath:) 方法后面加入:

override func collectionView(collectionView: UICollectionView,
                             didSelectItemAtIndexPath indexPath: NSIndexPath) {
  guard sharing else {
    return
  }

  let photo = photoForIndexPath(indexPath)
  selectedPhotos.append(photo)
  updateSharedPhotoCount()
}

这个方法将选中的图片添加到要分享的照片数组中，然后刷新 shareTextLabel 标签。

最后，在 collectionView(_:didSelectItemAtIndexPath:) 方法下面添加:

override func collectionView(collectionView: UICollectionView,
                             didDeselectItemAtIndexPath indexPath: NSIndexPath) {

  guard sharing else {
    return
  }

  let photo = photoForIndexPath(indexPath)

  if let index = selectedPhotos.indexOf(photo) {
    selectedPhotos.removeAtIndex(index)
    updateSharedPhotoCount()
  }
}

这个方法将照片从要分享的照片数组中删除，并刷新 shareTextLabel 标签。

允许程序，进行一个搜索。点击分享按钮，切换到分享模式，选择几张图片。标签会实时发生变化，选到的照片会有一个 Wenderlich 绿的加亮边框。

再次点击 Share 按钮，所有 cell 恢复未选中状态，你又会回到非分享模式，这时你点击 cell 会显示大图。

当然，现在分享按钮还没有任何意义，因为我们还没有真正做到图片的分享！
在 share(_:) 方法中，将 TODO 注释替换为如下代码：

var imageArray = [UIImage]()
for selectedPhoto in selectedPhotos {
  if let thumbnail = selectedPhoto.thumbnail {
    imageArray.append(thumbnail)
  }
}

if !imageArray.isEmpty {
  let shareScreen = UIActivityViewController(activityItems: imageArray, applicationActivities: nil)
  shareScreen.completionWithItemsHandler = { _ in
    self.sharing = false
  }
  let popoverPresentationController = shareScreen.popoverPresentationController
  popoverPresentationController?.barButtonItem = sender
  popoverPresentationController?.permittedArrowDirections = .Any
  presentViewController(shareScreen, animated: true, completion: nil)
}

首先，创建了一个 UIImage 数组，将缩略图放入。这个 UIImage 数组可以很方便地传给 UIActivityViewController。而 UIActivityViewController 会显示要手机上所有存在的分享程序或动作：iMessage、Mail、打印机扥等。你只需将 UIActivity以 Popover 方式呈现（因为这是一个 iPad App），剩下的就是用户的事情了。

运行程序，进入分享模式，选择几张图片，再次点击分享按钮。分享对话框会出现！

注：如果你用模拟器进行测试，你会发现模拟器中的分享选项要比设备中更少。如果你不能确定分享界面能否正常分享照片，请使用保存图片选项。无论设备还是模拟器，这都会将照片保存进照片程序，你可以通过这种方式确认分享功能是正常的。

渲染 cell

在 iOS 9 之前，Collection View 和它的近亲 Table View 相比缺少一个重要的功能：即很容易对 cell 进行重排。幸运的是，这种情况得到改变，在这个项目中你能够很容易地实现它，因为你使用的是 Collection View Controller。

现在， Collection View Controller 有一个 installsStandardGestureForInteractiveMovement 属性，它默认是 true。这个属性决定是否可以在 Collection View 上通过一个手势来重排 cell。你唯一需要做的事情就是重写 UICollectionViewDataSource 协议中的某个方法。打开 FlickrPhotosViewController.swift, 在 UICollectionViewDataSource 扩展的 collectionView(_:cellForItemAtIndexPath:) 方法后加入这个方法 :

override func collectionView(collectionView: UICollectionView,
                             moveItemAtIndexPath sourceIndexPath: NSIndexPath,
                             toIndexPath destinationIndexPath: NSIndexPath) {

  var sourceResults = searches[sourceIndexPath.section].searchResults
  let flickrPhoto = sourceResults.removeAtIndex(sourceIndexPath.row)

  var destinationResults = searches[destinationIndexPath.section].searchResults
  destinationResults.insert(flickrPhoto, atIndex: destinationIndexPath.row)  
}

实现这个方法很简单。你只需要将要移动的 cell 从结果集数组中删除，然后重新放到数组的新位置即可。

运行程序，选择一张照片，移动到另外一个位置：

太好了，只需要短短 4 行代码！

结束

完整项目在这里下载。

恭喜你，你创建了一个非常定制化的 Flickr 照片浏览程序，使用了一个非常酷网格式的 UICollectionView。

在本教程中，你学习了如何定制 UICollectionView，通过 UICollectionReusableView 创建 header，监听 cell 的点击，支持多选等等。

如果你有问题或建议，请留言。

ClipDrawabe对应于标签，他可以根据自己当前的等级(level)来裁剪一个Drawable，裁剪方向可以通过android:clipOrientation和android:gravity两个属性共同控制。语法如下：

<?xml version="1.0" encoding="utf-8"?> 
<clip xmlns:android="http://schemas.android.com/apk/res/android" 
android:clipOrientation="vertical\horizontal" 
android:drawable="@drawable/bitmapdrawable" 
android:gravity="bottom|top|left|right|center|fill|center_vertical|center_horizontal|fill_vertical|fill_horizontal|clip_vertical|clip_horizontal" />

ClipDrawable的gravity属性

选项 含义

• top 将内部的Drawable放在容器的顶部，不改变大小，如果为竖直裁剪，就从底部开始裁剪

• bottom 将内部的Drawable放在容器的底部，不改变大小，如果为竖直裁剪，就从顶部开始裁剪

• left 默认值。内部Drawable放在容器左边，不改变大小，如果为水平裁剪，就从右边开始裁剪。

• right 内部Drawable放在容器右边，不改变大小，如果为水平裁剪，就从左边开始裁剪

• center_vertical Drawable在容器中竖直居中，不改变大小，竖直裁剪的时候上下同时开始裁剪

• fill_vertical Drawable在竖直方向填充容器，如果为竖直裁剪，仅当ClipDrawable的等级为0（level=0，完全不可见）时，才会有裁剪行为

• center_horizontal Drawable水平居中，不改变大小，水平裁剪的时候从左右两边开始裁剪

• fill_horizontal Drawable在水平方向填充，如果为水平裁剪，仅当ClipDrawable等级=0的时候，才能有裁剪行为。

• center Drawable在水平和竖直方向居中，不改变大小，水平裁剪的时候从左右开始裁剪，竖直裁剪的时候从上下开始裁剪。

• fill Drawable在竖直和水平方向填充容器，仅当level=0的时候才有裁剪行为

• clip_vertical 附加选项，竖直方向的裁剪，少使用

• clip_horizontal 附加选项，水平方向的裁剪，少使用

使用示例

1.定义ClipDrawable

<?xml version="1.0" encoding="utf-8"?> 
<clip xmlns:android="http://schemas.android.com/apk/res/android" 
android:clipOrientation="vertical" 
android:drawable="@drawable/bitmapdrawable" 
android:gravity="fill_vertical" /> 

2.布局文件引用

<ImageView 
android:id="@+id/image_clip" 
android:layout_width="100dp" 
android:layout_height="100dp" 
android:src="@drawable/clipdrawable" /> 

3.代码控制level

ImageView imageClip = (ImageView) findViewById(R.id.image_clip); 
ClipDrawable drawable = (ClipDrawable) imageClip.getDrawable(); 
drawable.setLevel(5000);

最后补充

对于ClipDrawable来说，level=0的时候，表示完全裁剪，level=10000的时候表示完全不裁剪，level=5000的时候表示裁剪了一半。即等级越大，裁剪的区域越小。

在实际的业务中我们会遇见生产者产生的消息，不立即消费，而是延时一段时间在消费。RabbitMQ本身没有直接支持延迟队列功能，但是我们可以根据其特性Per-Queue Message TTL和 Dead Letter Exchanges实现延时队列。也可以通过改特性设置消息的优先级。

1.Per-Queue Message TTL
RabbitMQ可以针对消息和队列设置TTL（过期时间）。队列中的消息过期时间(Time To Live, TTL)有两种方法可以设置。第一种方法是通过队列属性设置，队列中所有消息都有相同的过期时间。第二种方法是对消息进行单独设置，每条消息TTL可以不同。如果上述两种方法同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的TTL值，就成为dead message,消费者将无法再收到该消息。
2.Dead Letter Exchanges
当消息在一个队列中变成死信后，它能被重新publish到另一个Exchange。消息变成Dead Letter一向有以下几种情况：
消息被拒绝（basic.reject or basic.nack）并且requeue=false
消息TTL过期
队列达到最大长度
实际上就是设置某个队列的属性，当这个队列中有Dead Letter时，RabbitMQ就会自动的将这个消息重新发布到设置的Exchange中去，进而被路由到另一个队列，publish可以监听这个队列中消息做相应的处理，这个特性可以弥补RabbitMQ 3.0.0以前支持的immediate参数中的向publish确认的功能。

一、在队列上设置TTL

1.建立delay.exchange

这里Internal设置为NO，否则将无法接受dead letter，YES表示这个exchange不可以被client用来推送消息，仅用来进行exchange和exchange之间的绑定。

2.建立延时队列(delay queue)

如上配置延时5min队列(x-message-ttl=300000)

x-max-length:最大积压的消息个数，可以根据自己的实际情况设置，超过限制消息不会丢失，会立即转向delay.exchange进行投递

x-dead-letter-exchange:设置为刚刚配置好的delay.exchange,消息过期后会通过delay.exchange进行投递

这里不需要配置"dead letter routing key"否则会覆盖掉消息发送时携带的routingkey，导致后面无法路由为刚才配置的delay.exchange

3.配置延时路由规则

需要延时的消息到exchange后先路由到指定的延时队列

1）创建delaysync.exchange通过Routing key将消息路由到延时队列

2.配置delay.exchange 将消息投递到正常的消费队列

配置完成。

下面使用代码测试一下：

生产者：

package cn.slimsmart.study.rabbitmq.delayqueue.queue;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {

	private static String queue_name = "test.queue";

	public static void main(String[] args) throws IOException {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("10.1.199.169");
		factory.setUsername("admin");
		factory.setPassword("123456");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		// 声明队列
		channel.queueDeclare(queue_name, true, false, false, null);
		String message = "hello world!" + System.currentTimeMillis();
		channel.basicPublish("delaysync.exchange", "deal.message", null, message.getBytes());
		System.out.println("sent message: " + message + ",date:" + System.currentTimeMillis());
		// 关闭频道和连接
		channel.close();
		connection.close();
	}
}

package cn.slimsmart.study.rabbitmq.delayqueue.queue;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

public class Consumer {

	private static String queue_name = "test.queue";

	public static void main(String[] args) throws Exception {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("10.1.199.169");
		factory.setUsername("admin");
		factory.setPassword("123456");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		// 声明队列
		channel.queueDeclare(queue_name, true, false, false, null);
		QueueingConsumer consumer = new QueueingConsumer(channel);
		// 指定消费队列
		channel.basicConsume(queue_name, true, consumer);
		while (true) {
			// nextDelivery是一个阻塞方法（内部实现其实是阻塞队列的take方法）
			QueueingConsumer.Delivery delivery = consumer.nextDelivery();
			String message = new String(delivery.getBody());
			System.out.println("received message:" + message + ",date:" + System.currentTimeMillis());
		}
	}

}

实现代码：

生产者：

package cn.slimsmart.study.rabbitmq.delayqueue.message;

import java.io.IOException;
import java.util.HashMap;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {

	private static String queue_name = "message_ttl_queue";

	public static void main(String[] args) throws IOException {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("10.1.199.169");
		factory.setUsername("admin");
		factory.setPassword("123456");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		HashMap<String, Object> arguments = new HashMap<String, Object>();
		arguments.put("x-dead-letter-exchange", "amq.direct");
		arguments.put("x-dead-letter-routing-key", "message_ttl_routingKey");
		channel.queueDeclare("delay_queue", true, false, false, arguments);

		// 声明队列
		channel.queueDeclare(queue_name, true, false, false, null);
		// 绑定路由
		channel.queueBind(queue_name, "amq.direct", "message_ttl_routingKey");

		String message = "hello world!" + System.currentTimeMillis();
		// 设置延时属性
		AMQP.BasicProperties.Builder builder = new AMQP.BasicProperties.Builder();
		// 持久性 non-persistent (1) or persistent (2)
		AMQP.BasicProperties properties = builder.expiration("300000").deliveryMode(2).build();
		// routingKey =delay_queue 进行转发
		channel.basicPublish("", "delay_queue", properties, message.getBytes());
		System.out.println("sent message: " + message + ",date:" + System.currentTimeMillis());
		// 关闭频道和连接
		channel.close();
		connection.close();
	}
}

package cn.slimsmart.study.rabbitmq.delayqueue.message;

import java.util.HashMap;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;

public class Consumer {

	private static String queue_name = "message_ttl_queue";

	public static void main(String[] args) throws Exception {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("10.1.199.169");
		factory.setUsername("admin");
		factory.setPassword("123456");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		HashMap<String, Object> arguments = new HashMap<String, Object>();
		arguments.put("x-dead-letter-exchange", "amq.direct");
		arguments.put("x-dead-letter-routing-key", "message_ttl_routingKey");
		channel.queueDeclare("delay_queue", true, false, false, arguments);

		// 声明队列
		channel.queueDeclare(queue_name, true, false, false, null);
		// 绑定路由
		channel.queueBind(queue_name, "amq.direct", "message_ttl_routingKey");

		QueueingConsumer consumer = new QueueingConsumer(channel);
		// 指定消费队列
		channel.basicConsume(queue_name, true, consumer);
		while (true) {
			// nextDelivery是一个阻塞方法（内部实现其实是阻塞队列的take方法）
			QueueingConsumer.Delivery delivery = consumer.nextDelivery();
			String message = new String(delivery.getBody());
			System.out.println("received message:" + message + ",date:" + System.currentTimeMillis());
		}
	}

}

查看资料：

http://www.rabbitmq.com/ttl.html 
http://www.rabbitmq.com/dlx.html 
http://www.rabbitmq.com/maxlength.html
https://www.cloudamqp.com/docs/delayed-messages.html 

      对于template 的支持，最困难的就是template function的instatiation【具现】。截至此书问世，大家的编译器提供了两种策略：一个是编译时期策略——模板程序代码必须在program text file【程序文本文件】中备好可用；另一个是编译时起策略，有一些meta-compilation【元编译】工具可以导引编译器的具现行为。

      对于编译器的设计者们，必须要能回答出下面三个问题：

1）：编译器如何找出函数的定义？

      答案之一是包含template program text file【模板程序文本文件】，就好像它是个头文件一样，borland编译器就是遵循的这种策略。还有一个方法是要求一种文件命名规则，例如，我们可以规定：在Point.h中发现的函数声明，其相应的template program text file一定要放在文件Point.C或Point.cpp中，以此类推，cfront就是遵循的这种策略。edison design group编译器对这两种策略都支持。

2）：编译器如何能够只具现出程序需要用到的函数？

      嗯，这个难度系数很高，所以目前的很多编译器是根本忽略这个问题：把一个已经具现出来的template class的所有member function都具现出来。borland就是这么做的——虽然它也提供#pragmas让用户可以压制一些特定的实体。但还有一种方法——仿真链接操作，检测看一下哪个member function是程序运行时真正需要的，然后只为它或它们产生实体，cfront就是这么做的。edison design group对这两种方法都支持。

3）：编译器如何阻止member definitions在多个.o文件中都被具现出来呢？

      有一个办法是产生多个实体，然后从连接器中提供支持，只留下其中一个实体，其余的都忽略。另一个办法是由用户自己来导引“仿真链接阶段”的具现策略，决定哪些instances【实体】才是我们所需求的。

      但不管是编译时期还是链接时期的instantiation【具现】策略，都有一个共同的弱点：当template实体被产生出来时，有时候会大量增加程序的编译时间。显然，这是模板函数第一次具现时的必要条件。然而当这些模板函数被非必要的再次具现，或者当“决定那些模板函数是否需要被再次具现”所花费的代价太大时，编译器的表现令人失望！

      c++支持模板的原始意图是一个由用户导引的use-directed automatic instantiation mechanism【自动具现机制】：既不需要用户的介入，也不需要相同文件有多次的具现行为。但这已经被证明是一个很难的任务，随着cfront3.0版所附加的原始具现工具，提供了一个由用户执行的use-driven automatic instantiation mechanism【自动具现机制】，但它实在太复杂了，即使是一个久经世故的人也没法一下子了解。

      Edison Design Group开发出的一套第二代directed-instantiation【直接具现】机制，非常接近于template facility【模板工具】的原始含义。它的主要过程如下：

1）：一个程序的代码被编译时，最初并不会产生任何模板具现体，相关信息被产生于object files之中。

2）：当object files被链接到一块时，会有一个prelinker程序被执行，该程序会检查object files，寻找模板实体的相互参考以及对应的定义。

3）：对于每一个参考到的模板实体而该实体却没有定义的情况，prelinker会将该文件看作于另一个文件【在这个文件中，实体已经定义】的同类。用这种方法，就可以把必要的程序具现操作指定给特定的文件。这些都会注册在prelinker所产生的.ii文件【放在磁盘目录ii_file】中。

4）：prelinker重新执行编译器，重新编译每一个“.ii文件曾被改变过”的文件。这个过程不断重复，直到所有必要的具现操作都已经被完成。

5）：所有的object files都被链接成一个可执行问价。

      上面这个directed-instantiation【直接具现】机制的主要成本在于，程序被第一次编译时的.ii文件设定时间；次要成本则是必须针对每一个compile afterwords【后续编译】执行prelinker，以确保所有被参考到的模板们都存在定义。在最初的设定以及成功的第一次链接后，重新编译操作包含以下程序：

1）：对于每一个将被重新编译的program text file，编译器会检查其对应的.ii文件。

2）：如果这些对应的.ii文件能列出一组要被具现的模板们，那么这些模板将在此次编译时被具现。

3）：prelinker必须执行起来，确保所有参考到的模板们都已经被定义好。

      不幸的是，所有的机制都存在一定bugs。Edison Design Group的编译器使用了一个由cfront2.0引入的算法，在大部分情况下，针对程序的每一个class自动产生虚函数表的单一实体，例如下面的class声明：

class PrimitiveObject:public Geometry
{
public:
  virtual ~PrimitiveObject();
  virtual draw();
   ...
}

      Andy Koenig【应该是一个c++编译器设计值】用下面的方法解决上面的问题：每一个虚函数的地址都被放置在active classes的虚函数表中，如果取得了函数地址，则意味着虚函数的定义肯定出现在程序的某个地点，否则程序就无法链接成功。此外，该函数只能有一个实体，否则也是链接不成功。那么，就把虚函数表放在定义了该class的第一个non-inline、nonpure virtual function的文件中吧。以我们上面的例子而言，编译器会把虚函数表放在存储着虚析构器的文件之中。

      然而在template之中，这种单一定义并不一定为真，在template所支持的将模块中的每一样东西都编译的模型下，不只是多个定义可能被产生，而且链接器也放任让多个定义同时出现，它只要选择其中一个忽略掉其它的就可以了。

      Edison Design Group机制会做什么事呢？考虑下面这个library函数：

void foo(const Point<float>* ptr)
{
  ptr->virtual_func();
}

//c++伪码
//ptr->virtual_func();的转换后形式
(*ptr->_vtbl_Point<float>[2])(ptr);

      然而，如果编译器遵循cfront的虚函数表实现机制，那么在“Point的float实体有一个virtual destructor定义被具现出来”之前，这个虚函数表不会被产生，除非在这一点上，并没有明确使用virtual destructor以担保其具现行为。

      Edison Design Group的automatic template【自动模板】机制并不明确它自己的编译器对于一个non-inline、nonpure virtual function的隐晦使用，所以并没有把它标示于.ii文件中，所以，链接器反而回头抱怨下面这个符号并没有出现：

_vtbl_Point<float>

template class Point3d<float>;

template class Point3d<float>::X() const;

template class Point3d<float> operator+(const Point3d<float>&, const Point3d<float>&);

转载来源http://www.cnblogs.com/qianxudetianxia/p/4948499.html

android{
    defaultConfig{
        manifestPlaceholders = [app_label:"@string/app_name"]
    }
}

android{
    buildTypes {
        debug {
              manifestPlaceholders = [app_label:"@string/app_name_debug"]
        }
        release {
        }
    }
}

android{
    productFlavors {
        // 把dev产品型号的apk的AndroidManifest中的channel替换dev
        "dev"{
            manifestPlaceholders = [channel:"dev"]
        }
    }
}

RELEASE_KEY_PASSWORD=xxxx
RELEASE_KEY_ALIAS=xxx
RELEASE_STORE_PASSWORD=xxx
RELEASE_STORE_FILE=../.keystore/xxx.jks

android {
    signingConfigs {
        release {
            storeFile file(RELEASE_STORE_FILE)
            storePassword RELEASE_STORE_PASSWORD
            keyAlias RELEASE_KEY_ALIAS
            keyPassword RELEASE_KEY_PASSWORD
        }
    }
}

android {
    productFlavors {
        dev{
            manifestPlaceholders = [channel:"dev"]
        }
        official{
            manifestPlaceholders = [channel:"official"]
        }
        // ... ...
        wandoujia{
            manifestPlaceholders = [channel:"wandoujia"]
        }
        xiaomi{
            manifestPlaceholders = [channel:"xiaomi"]
        }
        "360"{
            manifestPlaceholders = [channel:"360"]
        }
}

devDebug
devRelease
officialDebug
officialRelease
wandoujiaDebug
wandoujiaRelease
xiaomiDebug
xiaomiRelease
360Debug
360Release

// release版本生成的BuildConfig特性信息
public final class BuildConfig {
  public static final boolean DEBUG = false;
  public static final String BUILD_TYPE = "release";
}
// debug版本生成的BuildConfig特性信息
public final class BuildConfig {
  public static final boolean DEBUG = true;
  public static final String BUILD_TYPE = "debug";
}

android {
    signingConfigs {
        debug {
            storeFile file(RELEASE_STORE_FILE)
            storePassword RELEASE_STORE_PASSWORD
            keyAlias RELEASE_KEY_ALIAS
            keyPassword RELEASE_KEY_PASSWORD
        }
        preview {
            storeFile file(RELEASE_STORE_FILE)
            storePassword RELEASE_STORE_PASSWORD
            keyAlias RELEASE_KEY_ALIAS
            keyPassword RELEASE_KEY_PASSWORD
        }
        release {
            storeFile file(RELEASE_STORE_FILE)
            storePassword RELEASE_STORE_PASSWORD
            keyAlias RELEASE_KEY_ALIAS
            keyPassword RELEASE_KEY_PASSWORD
        }
    }

    buildTypes {
        debug {
            manifestPlaceholders = [app_label:"@string/app_name_debug"]
        }
        release {
            manifestPlaceholders = [app_label:"@string/app_name"]
        }
        preview{
            manifestPlaceholders = [app_label:"@string/app_name_preview"]
        }
    }
}

android {
        debug {
            manifestPlaceholders = [app_label:"@string/app_name_debug"]
            applicationIdSuffix ".debug"
            minifyEnabled false
            signingConfig signingConfigs.debug
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        release {
            manifestPlaceholders = [app_label:"@string/app_name"]
            minifyEnabled true
            shrinkResources true
            signingConfig signingConfigs.release
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        preview{
            manifestPlaceholders = [app_label:"@string/app_name_preview"]
            applicationIdSuffix ".preview"
            debuggable true // 保留debug信息
            minifyEnabled true
            shrinkResources true
            signingConfig signingConfigs.preview
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

// minifyEnabled 混淆处理
// shrinkResources 去除无用资源
// signingConfig 签名
// proguardFiles 混淆配置
// applicationIdSuffix 增加APP ID的后缀
// debuggable 是否保留调试信息
// ... ...

android {
    compileSdkVersion 22
    buildToolsVersion "23.0.1"

    defaultConfig {
        minSdkVersion 10
        targetSdkVersion 22
        versionCode 34
        versionName "v2.6.1"
    }
}

ext {
    compileSdkVersion = 22
    buildToolsVersion = "23.0.1"
    minSdkVersion = 10
    targetSdkVersion = 22
    versionCode = 34
    versionName = "v2.6.1"
}

android {
    compileSdkVersion rootProject.ext.compileSdkVersion
    buildToolsVersion rootProject.ext.buildToolsVersion

    defaultConfig {
        applicationId "com.xxx.xxx"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
        versionCode rootProject.ext.versionCode
        versionName rootProject.ext.versionName
    }
}

android {
    // rename the apk with the version name
    applicationVariants.all { variant ->
        variant.outputs.each { output ->
            output.outputFile = new File(
                    output.outputFile.parent,
                    "ganchai-${variant.buildType.name}-${variant.versionName}-${variant.productFlavors[0].name}.apk".toLowerCase())
        }
    }
}

android {
    // rename the apk with the version name
    // add output file sub folder by build type
    applicationVariants.all { variant ->
        variant.outputs.each { output ->
            output.outputFile = new File(
                    output.outputFile.parent + "/${variant.buildType.name}",
                    "ganchai-${variant.buildType.name}-${variant.versionName}-${variant.productFlavors[0].name}.apk".toLowerCase())
        }
    }
}

## 位于module下的proguard-rules.pro
#####################################
######### 主程序不能混淆的代码 #########
#####################################

-dontwarn xxx.model.**
-keep class xxx.model.** { *; }

## 等等，自己的代码自己清楚

#####################################
########### 不优化泛型和反射 ##########
#####################################

-keepattributes Signature

-dontwarn cn.jpush.**
-keep class cn.jpush.** { *; }

#####################################
######### 第三方库或者jar包 ###########
#####################################

-dontwarn cn.jpush.**
-keep class cn.jpush.** { *; }

-dontwarn com.squareup.**
-keep class com.squareup.** { *; }

-dontwarn com.octo.**
-keep class com.octo.** { *; }

-dontwarn de.**
-keep class de.** { *; }

-dontwarn javax.**
-keep class javax.** { *; }

-dontwarn org.**
-keep class org.** { *; }

-dontwarn u.aly.**
-keep class u.aly.** { *; }

-dontwarn uk.**
-keep class uk.** { *; }

-dontwarn com.baidu.**
-keep class com.baidu.** { *; }

-dontwarn com.facebook.**
-keep class com.facebook.** { *; }

-dontwarn com.google.**
-keep class com.google.** { *; }

## ... ...

java.lang.NullPointerException: java.lang.NullPointerException
    at com.xxx.TabMessageFragment$7.run(Unknown Source)

project > module
        > build > outputs > {flavor name} > {build type} > mapping.txt

-keepattributes SourceFile,LineNumberTable

android {
    defaultConfig {
        resValue "string", "build_time", buildTime()
        resValue "string", "build_host", hostName()
        resValue "string", "build_revision", revision()
    }
}

def buildTime() {
    return new Date().format("yyyy-MM-dd HH:mm:ss")
}
def hostName() {
    return System.getProperty("user.name") + "@" + InetAddress.localHost.hostName
}
def revision() {
    def code = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'rev-parse', '--short', 'HEAD'
        standardOutput = code
    }
    return code.toString()
}

// 在Activity里调用
getString(R.string.build_time)  // 输出2015-11-07 17:01
getString(R.string.build_host)  // 输出jay@deepin，这是我的电脑的用户名和PC名
getString(R.string.build_revision) // 输出3dd5823, 这是最后一次commit的sha值

private int clickCount = 0;
private long clickTime = 0;

sevenClickView.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {

        if (clickTime == 0) {
            clickTime = System.currentTimeMillis();
        }
        if (System.currentTimeMillis() - clickTime > 500) {
            clickCount = 0;
        } else {
            clickCount++;
        }
        clickTime = System.currentTimeMillis();

        if (clickCount > 6) {
            // 点七下条件达到，跳到debug界面
        }
    }
});

好文要顶 关注我 收藏该文  

websocket连接时，如果长时间没有进行数据的通讯就会自动断开连接。为了不让其断开就在要断开的时候自动发送数据进行通讯，就产生了心跳连接的效果。

具体的操作就是在客户端建立连接的时候开启发送心跳信息的线程，之后再每次收到信息之后就线程重启。服务端在处理数据的时候多处理一下心跳信息，将其发给连接的用户，从而实现心跳通讯。

服务端代码

@ServerEndpoint("/video")
public class AcgistVideo {
    //连接超时
    public static final long MAX_TIME_OUT = 2 * 60 * 1000;
    //房间和房间对应的用户列表
    public static Map<String, ArrayList<String>> room_user = Collections.synchronizedMap(new HashMap<String, ArrayList<String>>());
    //用户的sid和用户的session一一对应
    public static Map<String, Session> user_session = Collections.synchronizedMap(new HashMap<String, Session>());
    //用户的sid和房间一一对应
    public static Map<String, String> userInRoom = Collections.synchronizedMap(new HashMap<String, String>());
    public static Logger log = LoggerFactory.getLogger(AcgistVideo.class);

    /**
     * 打开websocket
     *
     * @param session websocket的session
     * @param uid     打开用户的UID
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("uid") String uid) throws IOException {
        log.info("--------------------onOpen--------------------");
        session.setMaxIdleTimeout(MAX_TIME_OUT);
    }
    /**
     * 收到消息
     *
     * @param message 消息内容
     * @param session 发送消息的session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("接收到来自客户端--" + session.getId() + "--的信息：" + message);
        JSONObject json = JSONObject.fromObject(message);

        if (json.get("type").equals("create")) {
            ArrayList arrayList = new ArrayList();
            arrayList.add(session.getId());

            String roomId = createRoom();
            room_user.put(roomId, arrayList);
            userInRoom.put(session.getId(), roomId);
            user_session.put(session.getId(), session);

            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "create");
            jsonstr.put("room", roomId);
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(roomId));
            sendMessage(jsonstr.toString(), session);

        } else if (json.get("type").equals("apply")) {
            String roomId = "";
            if (json.has("room")) {
                roomId = json.getString("room");
            }

            if (!("".equals(roomId)) && null != room_user.get(roomId)) {
                ArrayList<String> arrayList = room_user.get(roomId);
                arrayList.add(session.getId());
                room_user.put(roomId, arrayList);
                userInRoom.put(session.getId(), roomId);
                user_session.put(session.getId(), session);

                JSONObject jsonstr = new JSONObject();
                jsonstr.put("type", "apply");
                jsonstr.put("room", roomId);
                jsonstr.put("sid", session.getId());
                jsonstr.put("count", getUserNumberByRoom(roomId));

                sendMessageToUserInSameRoom(session.getId(), jsonstr, false);
            } else {
                ArrayList arrayList = new ArrayList();
                arrayList.add(session.getId());

                roomId = createRoom();
                room_user.put(roomId, arrayList);
                userInRoom.put(session.getId(), roomId);
                user_session.put(session.getId(), session);

                JSONObject jsonstr = new JSONObject();
                jsonstr.put("type", "create");
                jsonstr.put("room", roomId);
                jsonstr.put("sid", session.getId());
                jsonstr.put("count", getUserNumberByRoom(roomId));
                sendMessage(jsonstr.toString(), session);
            }
        } else if (json.get("type").equals("receipt")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "receipt");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("link")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "link");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("offer")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "offer");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            jsonstr.put("offer", json.get("offer"));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("answer")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "answer");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            jsonstr.put("answer", json.get("answer"));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("candidate")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "candidate");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            jsonstr.put("candidate", json.get("candidate"));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("bye")) {
            remove(session);
        } else if (json.get("type").equals("beat")) {
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "beat");
            jsonstr.put("msg", json.get("msg"));
            jsonstr.put("sid", session.getId());
            sendMessageToUserInSameRoom(session.getId(), jsonstr, false);
        }
    }
    /**
     * websocket错误
     *
     * @param e
     * @param session
     */
    @OnError
    public void onError(Throwable e, Session session) {
        log.info("--------------------onError--------------------");
        log.info("session ID: --" + session.getId() + " --离开了");
        log.error("--", e);
        log.info("----------------------------------------");
    }
    /**
     * websocket关闭
     *
     * @param session 关闭的session
     */
    @OnClose
    public void onClose(Session session) {
        log.info("--------------------onClose--------------------");
        remove(session);
    }
    /**
     *    * 随机生成UUID
     *    * @return
     *    
     */
    public static synchronized String getUUID() {
        log.info("--------------------getUUID--------------------");
        UUID uuid = UUID.randomUUID();
        String str = uuid.toString();
        String uuidStr = str.replace("-", "");
        return uuidStr;
    }
    /**
     * 通过房间号获取房间中的用户数量
     *
     * @param roomId 房间号
     * @return 房间中的用户数量 如果只为-1则房间不存在
     */
    public int getUserNumberByRoom(String roomId) {
        log.info("--------------------getUserNumberByRoom--------------------");
        if (room_user.containsKey("roomId")) {
            ArrayList<String> userList = room_user.get(roomId);
            return userList.size();
        } else {
            return -1;
        }
    }
    /**
     * 发送信息
     *
     * @param message 发送内容
     * @param session 用户session
     */
    public void sendMessage(String message, Session session) {
        log.info("--------------------sendMessage--------------------");
        try {
            log.info("发送消息到客户端--" + session.getId() + "--信息为：" + message);
            synchronized (session) {
                if (session.isOpen()) {
                    session.getBasicRemote().sendText(message);
                }
            }
        } catch (Exception e) {
            log.error("send message exception", e);
        }
    }
    /**
     * 创建房间
     *
     * @return 房间ID
     */
    public String createRoom() {
        log.info("--------------------createRoom--------------------");
        String roomId = getUUID();
        return roomId;
    }
    /**
     * 移除聊天用户
     *
     * @param session 移除的session
     */
    private void remove(Session session) {
        log.info("--------------------remove--------------------");

        String roomId = userInRoom.get(session.getId());
        ArrayList<String> arrayList = room_user.get(roomId);

        if (arrayList.contains(session.getId())) {
            log.info("移除SID：" + session.getId());
            arrayList.remove(session.getId());
            if (arrayList.size() < 1) {
                log.info("移除房间：" + roomId);
                room_user.remove(roomId);
            } else {
                room_user.put(roomId, arrayList);

                //用户退出的时候给房间中的每一位用户发一条信息
                JSONObject jsonstr = new JSONObject();
                jsonstr.put("type", "bye");
                jsonstr.put("sid", session.getId());
                sendMessageToUserInSameRoom(session.getId(), jsonstr, false);
            }
            userInRoom.remove(session.getId());
            user_session.remove(session.getId());
        }
    }
    /**
     * 给用户所在房间中的每一位用户发一条信息
     *
     * @param selfId     用户Id
     * @param jsonstr    需要发的信息
     * @param isSendSelf 是否发给自己
     */
    private void sendMessageToUserInSameRoom(String selfId, JSONObject jsonstr, boolean isSendSelf) {
        String roomId = userInRoom.get(selfId);
        ArrayList<String> arrayList = room_user.get(roomId);

        for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i).equals(selfId)) {
                if (isSendSelf) {
                    sendMessage(jsonstr.toString(), user_session.get(arrayList.get(i)));
                }
            } else {
                sendMessage(jsonstr.toString(), user_session.get(arrayList.get(i)));
            }
        }
    }
}

var MyWebSocket = function (obj) {
    var _this = this;
    this.timeout = 30 * 1000;
    this.timeoutObj = null;
    this.socket = null;
    this.initSocket = function () {
        this.socket = new WebSocket(GLOBAL.getConstant("WEB_SOCKET_URL"));

        this.socket.onopen = function () {
            console.log("websocket-----> Opened");
            _this.start();
        };

        this.socket.onmessage = this.socketMessage;

        this.socket.onclose = function () {
            console.log("websocket-----> Closed");
            obj.closeWebSocket();
        };

        this.socket.onerror = function () {
            console.log("websocket-----> Error:" + JSON.stringify(event));
        };

        console.log("-------websocket初始化完成执行回调函数-------");
        obj.initWebRtc(obj.entitys);
    }
    //接收到服务器的回复
    this.socketMessage = function (message) {
        console.log("websocket-----> Message:" + message.data);
        _this.reset();
        obj.SocketCallBack(message.data);
    }
    //向服务器发送信息
    this.sendMessage = function (message, callback) {
        this.waitForConnection(function () {
            var msgJson = JSON.stringify(message);
            this.socket.send(msgJson);
            console.log("websocket-----> SendMessage:" + msgJson);
            if (typeof callback !== 'undefined') {
                callback();
            }
        }, 1000);
    };
    this.waitForConnection = function (callback, interval) {
        if (this.socket.readyState === 1) {
            callback();
        } else {
            var that = this;
            setTimeout(function () {
                that.waitForConnection(callback, interval);
            }, interval);
        }
    };
    this.onClose = function () {
        this.socket.close();
    }
    this.start = function () {
        _this.timeoutObj = setTimeout(function () {
            var heartbeat = {
                type: "beat",
                msg: "HeartBeat"
            };
            _this.socket.send(JSON.stringify(heartbeat));
        }, _this.timeout)
    };
    this.reset = function () {
        clearTimeout(this.timeoutObj);
        _this.start();
    };

    this.initSocket();

    return this;
}

本文主要讲解Spring的基本知识以及基本的配置步骤。

环境：

Eclipse neon

Tomcat7.0

jdk7

Spring3.2

相关源码下载：点击下载

SpringMVC架构

SpringMVC主要流程以及步骤如下所示：

1、  用户发起request请求至控制器(Controller)

控制接收用户请求的数据，委托给模型进行处理

2、  控制器通过模型(Model)处理数据并得到处理结果

模型通常是指业务逻辑

3、  模型处理结果返回给控制器

4、  控制器将模型数据在视图(View)中展示

web中模型无法将数据直接在视图上显示，需要通过控制器完成。如果在C/S应用中模型是可以将数据在视图中展示的。

5、  控制器将视图response响应给用户

通过视图展示给用户要的数据或处理结果。

架构图

流程

根据上图，分析执行流程如下：

1、  用户发送请求至前端控制器DispatcherServlet

2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、  处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、  DispatcherServlet通过HandlerAdapter处理器适配器调用处理器

5、  执行处理器(Controller，也叫后端控制器)。

6、  Controller执行完成返回ModelAndView

7、  HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

8、  DispatcherServlet将ModelAndView传给ViewReslover视图解析器

9、  ViewReslover解析后返回具体View

10、DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。

11、DispatcherServlet响应用户

非注解方式配置

通过上面的分析，接下来我们通过实例进行配置说明。

需求：在Jsp页面显示数据（通过List装载传送到页面进行显示）

1、新建工程

新建web工程，并且导入相应jar包（具体见源码包lib目录下）

2、配置前端控制器

在web.xml中做相应配置，如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>SpringMVC-1</display-name>
 
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
    <!-- 指定springmvc配置的加载位置，如果不指定则默认加
		载WEB-INF/[DispatcherServlet 的Servlet 名字]-servlet.xml
     -->
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!-- tomcat随服务启动 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  
  <!-- <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/classes/spring/applicationContext-*.xml</param-value>
  </context-param>
  
  <listener>
  	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>	
  </listener> -->
  
  
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.action</url-pattern>
  </servlet-mapping>
  
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

load-on-startup：表示servlet随服务启动；

url-pattern：*.action的请交给DispatcherServlet处理。

contextConfigLocation：指定springmvc配置的加载位置，如果不指定则默认加

载WEB-INF/[DispatcherServlet的Servlet 名字]-servlet.xml。

Servlet拦截方式

（1）拦截固定后缀的url，比如设置为 *.do、*.action， 例如：/user/add.action

此方法最简单，不会导致静态资源（jpg,js,css）被拦截。

（2）拦截所有，设置为/，例如：/user/add  /user/add.action

此方法可以实现REST风格的url，很多互联网类型的应用使用这种方式。

但是此方法会导致静态文件（jpg,js,css）被拦截后不能正常显示。需要特殊处理。

（3）拦截所有，设置为/*，此设置方法错误，因为请求到Action，当action转到jsp时再次被拦截，提示不能根据jsp路径mapping成功。

3、加载SpringMVC配置文件

<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>

4、配置处理器适配器

在Springmvc.xml文件下做出如下配置：

<bean		class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/> 

SimpleControllerHandlerAdapter：即简单控制器处理适配器，所有实现了org.springframework.web.servlet.mvc.Controller 接口的Bean作为

5、开发处理器

创建java文件，实现controller接口如下：

package com.sw.ssm.controller;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import com.sw.ssm.po.Items;

/*
 *@Author swxctx
 *@time 2016年12月9日
 *@Explain:实现controller接口的处理器
 */
public class ItemsController1 implements Controller{

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		// TODO Auto-generated method stub
		//调用servlce查找数据库，查询商品列表
		List<Items> list = new ArrayList<Items>();
		//填充订单数据
		Items items_1 = new Items();
		items_1.setName("Lenovo");
		items_1.setPrice(6000f);
		items_1.setDetail("ThinkPad T430");
		
		Items items_2 = new Items();
		items_2.setName("iphone");
		items_2.setPrice(5000f);
		items_2.setDetail("iphone6");
		
		list.add(items_1);
		list.add(items_2);
		
		//返回ModelAndView
		ModelAndView modelAndView = new ModelAndView();
		//作用类似于request的setAttribute(在jsp页面中通过itemsList取出相关数据)
		modelAndView.addObject("itemsList", list);
		
		//指定视图
		modelAndView.setViewName("/items/itemsList");
		return modelAndView;
	}

}

org.springframework.web.servlet.mvc.Controller：处理器必须实现Controller 接口。

ModelAndView：包含了模型数据及逻辑视图名

6、配置处理器映射器

<!-- 处理器映射器 -->
	<!-- 根据bean的name进行查找Handler 将action的url配置在bean的name中 -->
	<bean
		class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

BeanNameUrlHandlerMapping：表示将定义的Bean名字作为请求的url，需要将编写的controller在spring容器中进行配置，且指定bean的name为请求的url，且必须以.action结尾。

7、处理器配置

<!-- 2 配置加载Handler（实现controller接口） -->
	<bean id="itemsController1" name="/queryItems_text.action" class="com.sw.ssm.controller.ItemsController1"/>

8、配置视图解析器

<!-- 4 视图解析器 -->
	<!-- 解析jsp视图，默认使用jstl -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置jsp路径的前缀 -->
		<property name="prefix" value="/WEB-INF/jsp/"/>
		<!-- 配置jsp路径的后缀 -->
		<property name="suffix" value=".jsp"/>
	</bean>

InternalResourceViewResolver：支持JSP视图解析

viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，所以classpath中必须包含jstl的相关jar 包；

prefix 和suffix：查找视图页面的前缀和后缀，最终视图的址为：

前缀+逻辑视图名+后缀，逻辑视图名需要在controller中返回ModelAndView指定，比如逻辑视图名为swxctx，则最终返回的jsp视图地址 “WEB-INF/jsp/swxctx.jsp”

9、视图开发(Jsp、Html)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>查询商品列表</title>
</head>
<body> 
<form action="${pageContext.request.contextPath }/item/queryItem.action" method="post">
查询条件：
<table width="100%" border=1>
<tr>
<td><input type="submit" value="查询"/></td>
</tr>
</table>
商品列表：
<table width="100%" border=1>
<tr>
	<td>商品名称</td>
	<td>商品价格</td>
	<td>生产日期</td>
	<td>商品描述</td>
	<td>操作</td>
</tr>
<c:forEach items="${itemsList }" var="item">
<tr>
	<td>${item.name }</td>
	<td>${item.price }</td>
	<td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
	<td>${item.detail }</td>
	
	<td><a href="${pageContext.request.contextPath }/item/editItem.action?id=${item.id}">修改</a></td>

</tr>
</c:forEach>

</table>
</form>
</body>

</html>

但是在开发中，我们还可能会使用其他适配器。例如HttpRequestHandler，接下来，我们使用HttpRequestHandler适配器进行配置。

1、配置适配器

<!-- http请求处理器适配器，实现HttpRequestHandler接口 -->
	<bean
		 class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>

package com.sw.ssm.controller;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.HttpRequestHandler;

import com.sw.ssm.po.Items;

/*
 *@Author swxctx
 *@time 2016年12月9日
 *@Explain:实现HttpRequestHandler接口的处理器
 */
public class ItemsController2 implements HttpRequestHandler{

	@Override
	public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		//调用servlce查找数据库，查询商品列表
		List<Items> list = new ArrayList<Items>();
		//填充订单数据
		Items items_1 = new Items();
		items_1.setName("Lenovo");
		items_1.setPrice(6000f);
		items_1.setDetail("ThinkPad T430 ");
		
		Items items_2 = new Items();
		items_2.setName("iphone");
		items_2.setPrice(5000f);
		items_2.setDetail("iphone6");
		
		list.add(items_1);
		list.add(items_2);
		
		//填充数据
		//设置模型数据
		request.setAttribute("itemsList", list);
		//设置转发的视图
		request.getRequestDispatcher("/WEB-INF/jsp/items/itemsList.jsp").forward(request, response);
	}

}

<!-- 配置handler（实现HttpRequestHandler接口） -->
	<bean id="itemsController2" class="com.sw.ssm.controller.ItemsController2"/>

<!-- 2 配置加载Handler（实现controller接口） -->
	<bean id="itemsController1" name="/queryItems_text.action" class="com.sw.ssm.controller.ItemsController1"/>
	<!-- 配置handler（实现HttpRequestHandler接口） -->
	<bean id="itemsController2" class="com.sw.ssm.controller.ItemsController2"/>
	
	<!-- 简单url映射 -->
	<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<property name="mappings">
			<props>
				<!-- 对itemsController1进行url映射，url为：/queryItems1.action -->
				<prop key="/queryItems1.action">itemsController1</prop>
				<prop key="/queryItems2.action">itemsController1</prop>
				<!-- 实现HttpRequestHandler的url映射 -->
				<prop key="/queryItems3.action">itemsController2</prop>
			</props>
		</property>
	</bean>

至此，非注解的开发方式已经完成，接下来我们进行注解的开发讲解。

注解方式的配置

使用注解的方式进行配置，其他地方均与上面相同，我们只需要更改处理器映射器与适配器以及更改处理器的开发。

1、处理器适配器

<!--注解适配器 -->
	<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

2、注解映射器

<!--注解映射器（与非注解可并存） -->
	<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

3、处理器开发

package com.sw.ssm.controller;

import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import com.sw.ssm.po.Items;

/*
 *@Author swxctx
 *@time 2016年12月9日
 *@Explain:实现注解Handler处理器
 */
//使用注解表示该类为一个控制器
@Controller
public class ItemsController3{
	//商品查询列表
	//实现对queryItems方法进行url映射（一个方法对应一个url）
	@RequestMapping("/queryItems.action")
	public ModelAndView queryItems()throws Exception{
		//调用servlce查找数据库，查询商品列表
		List<Items> list = new ArrayList<Items>();
		//填充订单数据
		Items items_1 = new Items();
		items_1.setName("联想笔记本");
		items_1.setPrice(6000f);
		items_1.setDetail("ThinkPad T430 联想笔记本电脑！");
		
		Items items_2 = new Items();
		items_2.setName("苹果手机");
		items_2.setPrice(5000f);
		items_2.setDetail("iphone6苹果手机！");
		
		list.add(items_1);
		list.add(items_2);
		
		//返回ModelAndView
		ModelAndView modelAndView = new ModelAndView();
		//作用类似于request的setAttribute(在jsp页面中通过itemsList取出相关数据)
		modelAndView.addObject("itemsList", list);
		
		//指定视图
		modelAndView.setViewName("/items/itemsList");
		return modelAndView;
	}
}

4、处理器配置

<!-- 配置加载注解的Handler（url已通过注解的方式配置在url中） -->
	<!-- 单个配置（在实际开发中不常用） -->
	<bean class="com.sw.ssm.controller.ItemsController3"/>
	<!-- 通过组件扫描的方式加载 -->
	<!-- <context:component-scan base-package="com.sw.ssm.controller"></context:component-scan> -->

以上则为注解的配置方式，在实际开发中，较为常用的即为注解方式。