CODING

STUDY

LINKING

SOURCE

TOOLS

LINUX

WEB&H5

BLOGS

说明

后续会不断更新好的学习网站。

前言

Eclipse默认的html,js,jsp的编辑器的颜色很不舒适,而且在编写代码的过程中提示也不是很智能和友好,下面是一个很强大的插件HtmlEditor的安装介绍。

下载文件

• GEF依赖包
• HTMLEditor

安装过程

GEF依赖包解压,有两个文件夹：features和plugins ,分别打开它们拷贝里面所有的,分别放到你所安装的eclipse下的 features和plugins 下面.
HTMLEditor的jar包, 直接复制到eclipse\plugins里面.

验证是否成功

重启eclipse，然后Window — preferences — Amateras(如果有这个项出现表示安装成功).
然后设置jsp文件的编辑器为HtmlEditor,Window — preferences — General — Editors — File Assosiations,选中JSP，然后在下方选中HtmlEditor，设置为Default即可。

参考文档

• EclipseHTMLEditor
• 安装eclipse中html/jsp/xml editor插件

前言

iBATIS一词来源于”internet”和”abatis”的组合，是一个由Clinton Begin在2002年发起的开放源代码项目。于2010年6月16号被谷歌托管，改名为MyBatis。是一个基于SQL映射支持Java和·NET的持久层框架。

iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO），同时还提供一个利用这个框架开发的JPetStore实例。
相对Hibernate和ApacheOJB等”一站式”ORM解决方案而言，ibatis 是一种”半自动化”的ORM实现。
iBATIS 目前提供了三种语言实现的版本，包括：Java、.NET以及Ruby。

主流ORM方案

目前主流的 ORM(对象关系映射)，无论 Hibernate还是Apache OJB，都对数据库结构提供了较为完整的封装，提供了从POJO到数据库表的全套映射机制。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过 Hibernate或者OJB 提供的方法完成持久层操作。程序员甚至不需要对 SQL 的熟练掌握，Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的 SQL 并调用 JDBC 接口加以执行。
大多数情况下（特别是对新项目，新系统的开发而言），这样的机制无往不利，大有一统天下的势头。但是，在一些特定的环境下，这种一站式的解决方案却未必灵光。

半自动化

以下的开发使用场景：
1．系统的部分或全部数据来自现有数据库，出于安全考虑，只对开发团队提供几条Select SQL（或存储过程）以获取所需数据，具体的表结构不予公开。
2．开发规范中要求，所有牵涉到业务逻辑部分的数据库操作，必须在数据库层由存储过程实现（金融行业：工商银行、中国银行、交通银行，都在开发规范中严格指定）
3．系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。

面对这样的需求，再次举起 Hibernate 大刀，却发现刀锋不再锐利，甚至无法使用，奈何？恍惚之际，只好再摸出JDBC 准备拼死一搏……，说得未免有些凄凉，直接使用 JDBC进行数据库操作实际上也是不错的选择，只是拖沓的数据库访问代码，乏味的字段读取操作令人厌烦。

“半自动化”的ibatis，却刚好解决了这个问题。这里的”半自动化”，是相对Hibernate等提供了全面的数据库封装机制的”全自动化”ORM 实现而言，”全自动”ORM 实现了 POJO 和数据库表之间的映射，以及 SQL 的自动生成和执行。而ibatis 的着力点，则在于POJO 与 SQL之间的映射关系。也就是说，ibatis并不会为程序员在运行期自动生成 SQL 执行。具体的 SQL 需要程序员编写，然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定 POJO。
通常在如下场景和条件下，选择ibatis, 将更有助于发挥ibatis在持久层的优越性：

• 1.知道怎样操作10种以上的数据库
• 2.可配置的caching(包括从属)
• 3.支持DataSource、local transaction management和global transaction
• 4.简单的XML配置文档
• 5.支持Map, Collection, List和简单类型包装(如Integer, String)
• 6.支持JavaBeans类(get/set 方法)
• 7.支持复杂的对象映射(如populating lists, complex object models)
• 8.对象模型从不完美(不需要修改)
• 9.数据模型从不完美(不需要修改)
• 10.你已经知道SQL，为什么还要学习其他东西

比较

使用ibatis 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的 Java对象，
这一层与通过 Hibernate 实现 ORM 而言基本一致，而对于具体的数据操作，Hibernate
会自动生成SQL 语句，而ibatis 则要求开发者编写具体的 SQL 语句。相对Hibernate等
“全自动”ORM机制而言，ibatis 以 SQL开发的工作量大和数据库移植性上差为代价，为系统
设计提供了更大的自由空间。作为”全自动”ORM实现的一种有益补充，ibatis 的出现显
得别具意义。

ibatis本是apache的一个开源项目，2010年这个项目由apache software foundation 迁移到了google code，并且改名为mybatis。

搭建iBatis环境

• 1.导入相关的jar 包，ibatis-2.3.0.677.jar 、mysql-connector-java-5.1.6-bin.jar
• 2.编写配置文件：
  • Jdbc 连接的属性文件
  • 总配置文件， SqlMapConfig.xml
  • 关于每个实体的映射文件（Map 文件）

代码示例

student.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package com.iflytek.entity;
import java.sql.Date;
public class Student {
// 注意这里需要保证有一个无参构造方法，因为包括Hibernate在内的映射都是使用反射的，如果没有无参构造可能会出现问题
privateint id;
private String name;
private Date birth;
private float score;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
@Override
public String toString() {
return"id=" + id + "\tname=" + name + "\tmajor=" + birth + "\tscore="
+ score + "\n";
}
}

SqlMap.properties ：

1
2
3
4

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/ibatis
username=root
password=123

Student.xml ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd">
<sqlMap>
<!-- 通过typeAlias使得我们在下面使用Student实体类的时候不需要写包名 -->
<typeAliasalias="Student"type="com.iflytek.entity.Student"/>
<!-- 这样以后改了sql，就不需要去改java代码了 -->
<!-- id表示select里的sql语句，resultClass表示返回结果的类型 -->
<selectid="selectAllStudent"resultClass="Student">
select * from
tbl_student
</select>
<!-- parameterClass表示参数的内容 -->
<!-- #表示这是一个外部调用的需要传进的参数，可以理解为占位符 -->
<selectid="selectStudentById"parameterClass="int"resultClass="Student">
select * from tbl_student where id=#id#
</select>
<!-- 注意这里的resultClass类型，使用Student类型取决于queryForList还是queryForObject -->
<selectid="selectStudentByName"parameterClass="String"
resultClass="Student">
select name,birth,score from tbl_student where name like
'%$name$%'
</select>
<insertid="addStudent"parameterClass="Student">
insert into
tbl_student(name,birth,score) values
(#name#,#birth#,#score#)
<selectKeyresultClass="int"keyProperty="id">
select @@identity as inserted
<!-- 这里需要说明一下不同的数据库主键的生成，对各自的数据库有不同的方式： -->
<!-- mysql:SELECT LAST_INSERT_ID() AS VALUE -->
<!-- mssql:select @@IDENTITY as value -->
<!-- oracle:SELECT STOCKIDSEQUENCE.NEXTVAL AS VALUE FROM DUAL -->
<!-- 还有一点需要注意的是不同的数据库生产商生成主键的方式不一样，有些是预先生成 (pre-generate)主键的，如Oracle和PostgreSQL。
有些是事后生成(post-generate)主键的，如MySQL和SQL Server 所以如果是Oracle数据库，则需要将selectKey写在insert之前 -->
</selectKey>
</insert>
<deleteid="deleteStudentById"parameterClass="int">
<!-- #id#里的id可以随意取，但是上面的insert则会有影响，因为上面的name会从Student里的属性里去查找 -->
<!-- 我们也可以这样理解，如果有#占位符，则ibatis会调用parameterClass里的属性去赋值 -->
delete from tbl_student where id=#id#
</delete>
<updateid="updateStudent"parameterClass="Student">
update tbl_student set
name=#name#,birth=#birth#,score=#score# where id=#id#
</update>
</sqlMap>

说明：

如果xml 中没有ibatis 的提示，则window –> Preference–> XML–>XML Catalog—> 点击add
选择uri URI: 请选择本地文件系统上
iBatisDemo1/WebContent/WEB-INF/lib/sql-map-config-2.dtd 文件；
Key Type: 选择Schema Location；
Key: 需要联网的，不建议使用；

SqlMapConfig.xml ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<!-- 引用JDBC属性的配置文件 -->
<propertiesresource="com/iflytek/entity/SqlMap.properties"/>
<!-- 使用JDBC的事务管理 -->
<transactionManagertype="JDBC">
<!-- 数据源 -->
<dataSourcetype="SIMPLE">
<propertyname="JDBC.Driver"value="${driver}"/>
<propertyname="JDBC.ConnectionURL"value="${url}"/>
<propertyname="JDBC.Username"value="${username}"/>
<propertyname="JDBC.Password"value="${password}"/>
</dataSource>
</transactionManager>
<!-- 这里可以写多个实体的映射文件 -->
<sqlMapresource="com/iflytek/entity/Student.xml"/>
</sqlMapConfig>

StudentDao ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package com.iflytek.dao;
import java.util.List;
import com.iflytek.entity.Student;
/**
* @author xudongwang 2011-12-31
*
* Email:xdwangiflytek@gmail.com
*
*/
publicinterface StudentDao {
/**
* 添加学生信息
*
* @param student
* 学生实体
* @return 返回是否添加成功
*/
publicboolean addStudent(Student student);
/**
* 根据学生id删除学生信息
*
* @param id
* 学生id
* @return 删除是否成功
*/
publicboolean deleteStudentById(int id);
/**
* 更新学生信息
*
* @param student
* 学生实体
* @return 更新是否成功
*/
publicboolean updateStudent(Student student);
/**
* 查询全部学生信息
*
* @return 返回学生列表
*/
public List<Student> selectAllStudent();
/**
* 根据学生姓名模糊查询学生信息
*
* @param name
* 学生姓名
* @return 学生信息列表
*/
public List<Student> selectStudentByName(String name);
/**
* 根据学生id查询学生信息
*
* @param id
* 学生id
* @return 学生对象
*/
public Student selectStudentById(int id);
}

StudentDaoImpl ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

package com.iflytek.daoimpl;
import java.io.IOException;
import java.io.Reader;
import java.sql.SQLException;
import java.util.List;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.iflytek.dao.StudentDao;
import com.iflytek.entity.Student;
/**
* @author xudongwang 2011-12-31
*
* Email:xdwangiflytek@gmail.com
*
*/
publicclass StudentDaoImpl implements StudentDao {
privatestatic SqlMapClient sqlMapClient = null;
// 读取配置文件
static {
try {
Reader reader = Resources
.getResourceAsReader("com/iflytek/entity/SqlMapConfig.xml");
sqlMapClient = SqlMapClientBuilder.buildSqlMapClient(reader);
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
publicboolean addStudent(Student student) {
Object object = null;
boolean flag = false;
try {
object = sqlMapClient.insert("addStudent", student);
System.out.println("添加学生信息的返回值：" + object);
} catch (SQLException e) {
e.printStackTrace();
}
if (object != null) {
flag = true;
}
return flag;
}
publicboolean deleteStudentById(int id) {
boolean flag = false;
Object object = null;
try {
object = sqlMapClient.delete("deleteStudentById", id);
System.out.println("删除学生信息的返回值：" + object + "，这里返回的是影响的行数");
} catch (SQLException e) {
e.printStackTrace();
}
if (object != null) {
flag = true;
}
return flag;
}
publicboolean updateStudent(Student student) {
boolean flag = false;
Object object = false;
try {
object = sqlMapClient.update("updateStudent", student);
System.out.println("更新学生信息的返回值：" + object + "，返回影响的行数");
} catch (SQLException e) {
e.printStackTrace();
}
if (object != null) {
flag = true;
}
return flag;
}
public List<Student> selectAllStudent() {
List<Student> students = null;
try {
students = sqlMapClient.queryForList("selectAllStudent");
} catch (SQLException e) {
e.printStackTrace();
}
return students;
}
public List<Student> selectStudentByName(String name) {
List<Student> students = null;
try {
students = sqlMapClient.queryForList("selectStudentByName",name);
} catch (SQLException e) {
e.printStackTrace();
}
return students;
}
public Student selectStudentById(int id) {
Student student = null;
try {
student = (Student) sqlMapClient.queryForObject(
"selectStudentById", id);
} catch (SQLException e) {
e.printStackTrace();
}
return student;
}
}

TestIbatis.java ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package com.iflytek.test;
import java.sql.Date;
import java.util.List;
import com.iflytek.daoimpl.StudentDaoImpl;
import com.iflytek.entity.Student;
/**
* @author xudongwang 2011-12-31
*
* Email:xdwangiflytek@gmail.com
*
*/
publicclass TestIbatis {
publicstaticvoid main(String[] args) {
StudentDaoImpl studentDaoImpl = new StudentDaoImpl();
System.out.println("测试插入");
Student addStudent = new Student();
addStudent.setName("李四");
addStudent.setBirth(Date.valueOf("2011-09-02"));
addStudent.setScore(88);
System.out.println(studentDaoImpl.addStudent(addStudent));
System.out.println("测试根据id查询");
System.out.println(studentDaoImpl.selectStudentById(1));
System.out.println("测试模糊查询");
List<Student> mohuLists = studentDaoImpl.selectStudentByName("李");
for (Student student : mohuLists) {
System.out.println(student);
}
System.out.println("测试查询所有");
List<Student> students = studentDaoImpl.selectAllStudent();
for (Student student : students) {
System.out.println(student);
}
System.out.println("根据id删除学生信息");
System.out.println(studentDaoImpl.deleteStudentById(1));
System.out.println("测试更新学生信息");
Student updateStudent = new Student();
updateStudent.setId(1);
updateStudent.setName("李四1");
updateStudent.setBirth(Date.valueOf("2011-08-07"));
updateStudent.setScore(21);
System.out.println(studentDaoImpl.updateStudent(updateStudent));
}
}

参考文档

• MyBatis官网
• 维基百科
• 百度百科
• iBatis简单入门教程

ECLIPSE配置Maven

下面是在Eclipse中配置Maven插件，同时安装maven应用，配置Maven环境变量，建立Maven管理的工程的基本步骤。
1.首先到Eclipse Marketplace中下载Maven Integration for Eclipse WTP。
2.然后查看是否成功下载，Window -> ShowView -> Maven，有显示Maven Repositories表示安装成功。
3.下载安装maven环境并配置环境变量。
maven官方下载地址
环境变量配置完成后再cmd中输入mvn -v有输出版本号表面安装配置成功。
4.重新定位eclipse中的maven：Window -> Preference -> Maven -> Installation -> Add，然后输入maven在本地硬盘的路径。
5.然后就可以新建maven工程或者导入已有的maven工程。

说明：通过pom.xml的配置， 会自动管理包的导入。
打开pom.xml 试着添加MySQL的JDBC驱动，添加如下配置：

1
2
3
4
5

<dependency>  
    <groupId>mysql</groupId>  
    <artifactId>mysql-connector-java</artifactId>  
    <version>5.1.10</version>  
</dependency>

保存之后，在repository的子目录中 出现了mysql文件夹.
用Maven导入Gson的包,右击项目， Maven -> add dependency.出现窗口,敲入gson,于是会自动搜索,出现符合的列表,双击com.google.code.gson.
在pom.xml 中就自动加入了Gson的导入依赖,同时， 在repository中导入了Gson的包.

TOMCAT连接MYSQL

1.首先，要安装JDK,Tomcat,mysql等,此处略过.
2.eclipse下布署运行Tomcat的，在eclipse的window–>preference—>Server里，右面的里面添加tomcat的路径，指定jdk,然后在下面的servers选项卡里新建一个服务器，这时候就会在eclipse的project explore中生成一个Servers项目.
3.在context.xml的<context></context>之间添加连接池

1
2
3
4
5
6
7
8
9
10
11
12

<Resource name="jdbc/mysql"
    auth="Container" 
    type="javax.sql.DataSource" 
    maxActive="50"
    maxIdle="10"
    maxWait="5000" 
    username="***"
    password="****" 
    driverClassName="com.mysql.jdbc.Driver"
    url="jdbc:mysql://localhost/mysql?useUnicode=true&amp;
    characterEncoding=UTF-8&amp;zeroDateTimeBehavior=convertToNull"/>
    <!-- XML里 & 要用&amp;替代,不然会被过滤掉 -->

配置文件中Resource标签中各属性的含义：

• driverClassName - JDBC 所用到的数据库驱动的类全名.
• maxActive - 连接池在同一时刻内所提供的最大活动连接数。
• maxIdle - 连接池在空闲时刻保持的最大连接数.
• maxWait - 当发生异常时数据库等待的最大毫秒数 (当没有可用的连接时).
• password - 连接数据库的密码.
• url - 连接至驱动的URL. (为了向后兼容, DRIVERNAME也被允许.)
• username - 数据库用户名

4.将mysql 的jdbc驱动复制到配置tomcat下的lib目录和工程的lib目录下。
mysql-connector-java驱动下载地址

5.配置项目工程WEB-INF下面的web.xml文件

1
2
3
4
5
6

<resource-ref> 
   <description>DB Connection</description> 
   <res-ref-name>jdbc/balloon</res-ref-name> 
   <res-type>javax.sql.DataSource</res-type> 
   <res-auth>Container</res-auth> 
</resource-ref>

注意：context.xml文件中的name="jdbc/mysql"要和web.xml中的<res-ref-name>jdbc/mysql</res-ref-name>要一致.

6.测试连接是否成功,新建测试的JSP文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<%@ page language="java" pageEncoding="UTF-8"%>
<%@ page import="java.sql.*"%> 
<%@ page import="javax.sql.*"%> 
<%@ page import="javax.naming.*"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
   <head>
        <title>mysql连接池测试</title>
        <meta http-equiv="pragma" content="no-cache">
        <meta http-equiv="cache-control" content="no-cache">
        <meta http-equiv="expires" content="0"> 
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
        <meta http-equiv="description" content="This is my page">
   </head>
  
   <body> 
        <%  
        out.print("测试开始<br>"); 
        DataSource ds = null; 
        Connection conn=null;
               try{ 
        InitialContext ctx=new InitialContext(); 
        ds=(DataSource)ctx.lookup("java:comp/env/jdbc/balloon"); 
        conn = ds.getConnection();  
        
            }catch(Exception ex){
             ex.printStackTrace();
            } 
        %>  
        <%   
            if(conn!=null){ 
        %> 
             <%= conn %>;  
        <% 
            } 
        %> 
   </body>
</html>

运行项目在tomcat上，输入jsp所在路径，显示jdbc相关的信息表示连接成功。

参考文档

• Tomcat+mysql连接池配置
• eclipse Maven配置

一、前言

Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。

另外还有一种基于组件的、事件驱动的Web框架在此就不介绍了，如Tapestry、JSF等。

Spring Web MVC也是服务到工作者模式的实现，但进行可优化。

• 前端控制器是DispatcherServlet；
• 应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；
• 页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest(request, response) 方法）的实现（也可以是任何的POJO类）；
  支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

二、Spring Web MVC特性

• 让我们能非常简单的设计出干净的Web层和薄薄的Web层；
• 进行更简洁的Web层的开发；
• 天生与Spring框架集成（如IoC容器、AOP等）；
• 提供强大的约定大于配置的契约式编程支持；
• 能简单的进行Web层的单元测试；
• 支持灵活的URL到页面控制器的映射；
• 非常容易与其他视图技术集成，如Velocity、FreeMarker等等，因为模型数据不放在特定的API里，而是放在一个Model里（Map数据结构实现，因此很容易被其他框架使用）；
• 非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API；
• 提供一套强大的JSP标签库，简化JSP开发；
• 支持灵活的本地化、主题等解析；
• 更加简单的异常处理；
• 对静态资源的支持；
• 支持Restful风格。

三、Spring Web MVC架构

Spring Web MVC框架也是一个基于请求驱动的Web框架，并且也使用了前端控制器模式来进行设计，再根据请求映射规则分发给相应的页面控制器（动作/处理器）进行处理。首先让我们整体看一下Spring Web MVC处理请求的流程：
Spring Web MVC处理请求的流程

具体执行步骤如下：

1、首先用户发送请求————>前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；图2-1中的1、2步骤；

2、页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，这个对象在Spring Web MVC中叫命令对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；图中的3、4、5步骤；

3、前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；图中的步骤6、7；

4、前端控制器再次收回控制权，将响应返回给用户，图中的步骤8；至此整个结束。

问题：

1、请求如何给前端控制器？

2、前端控制器如何根据请求信息选择页面控制器进行功能处理？

3、如何支持多种页面控制器呢？

4、如何页面控制器如何使用业务对象？

5、页面控制器如何返回模型数据？

6、前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？

7、不同的视图技术如何使用相应的模型数据？

首先我们知道有如上问题，那这些问题如何解决呢？请让我们先继续，在后边依次回答。

Spring Web MVC架构

1、Spring Web MVC核心架构图，如图

架构图对应的DispatcherServlet核心代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//前端控制器分派方法  
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
        HttpServletRequest processedRequest = request;  
        HandlerExecutionChain mappedHandler = null;  
        int interceptorIndex = -1;  
  
        try {  
            ModelAndView mv;  
            boolean errorView = false;  
  
            try {  
                   //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析  
                processedRequest = checkMultipart(request);  
                   //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射  
                mappedHandler = getHandler(processedRequest, false);  
                if (mappedHandler == null || mappedHandler.getHandler() == null) {  
                    noHandlerFound(processedRequest, response);  
                    return;  
                }  
                   //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）  
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
  
                  // 304 Not Modified缓存支持  
                //此处省略具体代码  
  
                // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）  
                //此处省略具体代码  
  
                // 步骤4、由适配器执行处理器（调用处理器相应功能处理方法）  
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  
                // Do we need view name translation?  
                if (mv != null && !mv.hasView()) {  
                    mv.setViewName(getDefaultViewName(request));  
                }  
  
                // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）  
                //此处省略具体代码  
            }  
            catch (ModelAndViewDefiningException ex) {  
                logger.debug("ModelAndViewDefiningException encountered", ex);  
                mv = ex.getModelAndView();  
            }  
            catch (Exception ex) {  
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
                mv = processHandlerException(processedRequest, response, handler, ex);  
                errorView = (mv != null);  
            }  
  
            //步骤5 步骤6、解析视图并进行视图的渲染  
            //步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）  
            //步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）  
            if (mv != null && !mv.wasCleared()) {  
                render(mv, processedRequest, response);  
                if (errorView) {  
                    WebUtils.clearErrorRequestAttributes(request);  
                }  
            }  
            else {  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +  
                            "': assuming HandlerAdapter completed request handling");  
                }  
            }  
  
            // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）  
            //此处省略具体代码  
  
  
        catch (Exception ex) {  
            // Trigger after-completion for thrown exception.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
            throw ex;  
        }  
        catch (Error err) {  
            ServletException ex = new NestedServletException("Handler processing failed", err);  
            // Trigger after-completion for thrown exception.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
            throw ex;  
        }  
  
        finally {  
            // Clean up any resources used by a multipart request.  
            if (processedRequest != request) {  
                cleanupMultipart(processedRequest);  
            }  
        }  
    }

核心架构的具体流程步骤如下：

1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

2、DispatcherServlet——>HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；

3、DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；

5、ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；

6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；

7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

此处我们只是讲了核心流程，没有考虑拦截器、本地解析、文件上传解析等，后边再细述。

到此，再来看我们前边提出的问题：

1、请求如何给前端控制器？这个应该在web.xml中进行部署描述，在HelloWorld中详细讲解。

2、前端控制器如何根据请求信息选择页面控制器进行功能处理？ 我们需要配置HandlerMapping进行映射

3、如何支持多种页面控制器呢？配置HandlerAdapter从而支持多种类型的页面控制器

4、如何页面控制器如何使用业务对象？可以预料到，肯定利用Spring IoC容器的依赖注入功能

5、页面控制器如何返回模型数据？使用ModelAndView返回

6、前端控制器如何根据页面控制器返回的逻辑视图名选择具体的视图进行渲染？ 使用ViewResolver进行解析

7、不同的视图技术如何使用相应的模型数据？ 因为Model是一个Map数据结构，很容易支持其他视图技术

在此我们可以看出具体的核心开发步骤：

• DispatcherServlet在web.xml中的部署描述，从而拦截请求到Spring Web MVC
• HandlerMapping的配置，从而将请求映射到处理器
• HandlerAdapter的配置，从而支持多种类型的处理器
• ViewResolver的配置，从而将逻辑视图名解析为具体视图技术
• 处理器（页面控制器）的配置，从而进行功能处理

上边的开发步骤我们会在Hello World中详细验证。

四、Spring Web MVC优势

1、清晰的角色划分：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。

2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要；

3、由于命令对象就是一个POJO，无需继承框架特定API，可以使用命令对象直接作为业务对象；

4、和Spring 其他框架无缝集成，是其它Web框架所不具备的；

5、可适配，通过HandlerAdapter可以支持任意的类作为处理器；

6、可定制性，HandlerMapping、ViewResolver等能够非常简单的定制；

7、功能强大的数据验证、格式化、绑定机制；

8、利用Spring提供的Mock对象能够非常简单的进行Web层单元测试；

9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。

10、强大的JSP标签库，使JSP编写更容易。

还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配置支持等等。

到此我们已经简单的了解了Spring Web MVC，接下来让我们来个实例来具体使用下这个框架。

五、Hello World入门

准备开发环境和运行环境

• 开发工具：eclipse
• 运行环境：tomcat6.0.20
• 工程：动态web工程（springmvc-chapter2）
• spring框架下载：spring-framework-3.1.1.RELEASE-with-docs.zip
• 依赖jar包：

1、Spring框架jar包：
为了简单，将spring-framework-3.1.1.RELEASE-with-docs.zip/dist/下的所有jar包拷贝到项目的WEB-INF/lib目录下；

2、Spring框架依赖的jar包：
需要添加Apache commons logging日志，此处使用的是commons.logging-1.1.1.jar；
需要添加jstl标签库支持，此处使用的是jstl-1.1.2.jar和standard-1.1.2.jar；

前端控制器的配置
在我们的web.xml中添加如下配置：

1
2
3
4
5
6
7
8
9

<servlet>  
    <servlet-name>chapter2</servlet-name>  
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
    <load-on-startup>1</load-on-startup>  
</servlet>  
<servlet-mapping>  
    <servlet-name>chapter2</servlet-name>  
    <url-pattern>/</url-pattern>  
</servlet-mapping>

• load-on-startup：表示启动容器时初始化该Servlet；
• url-pattern：表示哪些请求交给Spring Web MVC处理， “/” 是用来定义默认servlet映射的。也可以如“*.html”表示拦截所有以html为扩展名的请求。

自此请求已交给Spring Web MVC框架处理，因此我们需要配置Spring的配置文件，默认DispatcherServlet会加载WEB-INF/[DispatcherServlet的Servlet名字]-servlet.xml配置文件。本示例为WEB-INF/ chapter2-servlet.xml。

在Spring配置文件中配置HandlerMapping、HandlerAdapter

具体配置在WEB-INF/ chapter2-servlet.xml文件中：

1
2
3
4
5

<!-- HandlerMapping -->  
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>  
   
<!-- HandlerAdapter -->  
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

• BeanNameUrlHandlerMapping：表示将请求的URL和Bean名字映射，如URL为 “上下文/hello”，则Spring配置文件必须有一个名字为“/hello”的Bean，上下文默认忽略。
• SimpleControllerHandlerAdapter：表示所有实现了org.springframework.web.servlet.mvc.Controller接口的Bean可以作为Spring Web MVC中的处理器。如果需要其他类型的处理器可以通过实现HadlerAdapter来解决。

在Spring配置文件中配置ViewResolver

具体配置在WEB-INF/ chapter2-servlet.xml文件中：

1
2
3
4
5
6

<!-- ViewResolver -->  
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>  
    <property name="prefix" value="/WEB-INF/jsp/"/>  
    <property name="suffix" value=".jsp"/>  
</bean>

• InternalResourceViewResolver：用于支持Servlet、JSP视图解析；
• viewClass：JstlView表示JSP模板页面需要使用JSTL标签库，classpath中必须包含jstl的相关jar包；
• prefix和suffix：查找视图页面的前缀和后缀（前缀[逻辑视图名]后缀），比如传进来的逻辑视图名为hello，则该该jsp视图页面应该存放在“WEB-INF/jsp/hello.jsp”；

开发处理器/页面控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package cn.javass.chapter2.web.controller;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import org.springframework.web.servlet.ModelAndView;  
import org.springframework.web.servlet.mvc.Controller;  
public class HelloWorldController implements Controller {  
    @Override  
    public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) throws Exception {  
       //1、收集参数、验证参数  
       //2、绑定参数到命令对象  
       //3、将命令对象传入业务对象进行业务处理  
       //4、选择下一个页面  
       ModelAndView mv = new ModelAndView();  
       //添加模型数据 可以是任意的POJO对象  
       mv.addObject("message", "Hello World!");  
       //设置逻辑视图名，视图解析器会根据该名字解析到具体的视图页面  
       mv.setViewName("hello");  
       return mv;  
    }  
}

org.springframework.web.servlet.mvc.Controller：页面控制器/处理器必须实现Controller接口，注意别选错了；后边我们会学习其他的处理器实现方式；

public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp) ：功能处理方法，实现相应的功能处理，比如收集参数、验证参数、绑定参数到命令对象、将命令对象传入业务对象进行业务处理、最后返回ModelAndView对象；

ModelAndView：包含了视图要实现的模型数据和逻辑视图名；“mv.addObject(“message”, “Hello World!”);

”表示添加模型数据，此处可以是任意POJO对象；“mv.setViewName(“hello”);”表示设置逻辑视图名为“hello”，视图解析器会将其解析为具体的视图，如前边的视图解析器InternalResourceVi。wResolver会将其解析为“WEB-INF/jsp/hello.jsp”。

我们需要将其添加到Spring配置文件(WEB-INF/chapter2-servlet.xml)，让其接受Spring IoC容器管理:

1
2

<!-- 处理器 -->  
<bean name="/hello" class="cn.javass.chapter2.web.controller.HelloWorldController"/>

name=”/hello”：前边配置的BeanNameUrlHandlerMapping，表示如过请求的URL为 “上下文/hello”，则将会交给该Bean进行处理。
2.5.6、开发视图页面

创建 /WEB-INF/jsp/hello.jsp视图页面：

1
2
3
4
5
6
7
8
9
10
11

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>  
<!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>Hello World</title>  
</head>  
<body>  
${message}  
</body>  
</html>

${message}：表示显示由HelloWorldController处理器传过来的模型数据。

启动服务器运行测试

通过请求：http://localhost:9080/springmvc-chapter2/hello，如果页面输出“Hello World! ”就表明我们成功了！

运行流程分析

运行步骤：

1、首先用户发送请求http://localhost:9080/springmvc-chapter2/hello——>web容器，web容器根据“/hello”路径映射到DispatcherServlet（url-pattern为/）进行处理；

2、DispatcherServlet——>BeanNameUrlHandlerMapping进行请求到处理的映射，BeanNameUrlHandlerMapping将“/hello”路径直接映射到名字为“/hello”的Bean进行处理，即HelloWorldController，BeanNameUrlHandlerMapping将其包装为HandlerExecutionChain（只包括HelloWorldController处理器，没有拦截器）；

3、DispatcherServlet——> SimpleControllerHandlerAdapter，SimpleControllerHandlerAdapter将HandlerExecutionChain中的处理器（HelloWorldController）适配为SimpleControllerHandlerAdapter；

4、SimpleControllerHandlerAdapter——> HelloWorldController处理器功能处理方法的调用，SimpleControllerHandlerAdapter将会调用处理器的handleRequest方法进行功能处理，该处理方法返回一个ModelAndView给DispatcherServlet；

5、hello（ModelAndView的逻辑视图名）——>InternalResourceViewResolver， InternalResourceViewResolver使用JstlView，具体视图页面在/WEB-INF/jsp/hello.jsp；

6、JstlView（/WEB-INF/jsp/hello.jsp）——>渲染，将在处理器传入的模型数据(message=HelloWorld！)在视图中展示出来；

7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

到此HelloWorld就完成了，步骤是不是有点多？而且回忆下我们主要进行了如下配置：

1、前端控制器DispatcherServlet；

2、HandlerMapping

3、HandlerAdapter

4、ViewResolver

5、处理器/页面控制器

6、视图

因此，接下来几章让我们详细看看这些配置，先从DispatcherServlet开始吧。

六、POST中文乱码解决方案

spring Web MVC框架提供了org.springframework.web.filter.CharacterEncodingFilter用于解决POST方式造成的中文乱码问题，具体配置如下：

1
2
3
4
5
6
7
8
9
10
11
12

<filter>  
    <filter-name>CharacterEncodingFilter</filter-name>  
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
    <init-param>  
        <param-name>encoding</param-name>  
        <param-value>utf-8</param-value>  
    </init-param>  
</filter>  
<filter-mapping>  
    <filter-name>CharacterEncodingFilter</filter-name>  
    <url-pattern>/*</url-pattern>  
</filter-mapping>

以后我们项目及所有页面的编码均为UTF-8。

七、Spring3.1新特性

1.Spring2.5之前，我们都是通过实现Controller接口或其实现来定义我们的处理器类。

2.Spring2.5引入注解式处理器支持，通过@Controller 和 @RequestMapping注解定义我们的处理器类。并且提供了一组强大的注解：

需要通过处理器映射DefaultAnnotationHandlerMapping和处理器适配器AnnotationMethodHandlerAdapter来开启支持@Controller 和 @RequestMapping注解的处理器。

• @Controller：用于标识是处理器类；
• @RequestMapping：请求到处理器功能方法的映射规则；
• @RequestParam：请求参数到处理器功能处理方法的方法参数上的绑定；
• @ModelAttribute：请求参数到命令对象的绑定；
• @SessionAttributes：用于声明session级别存储的属性，放置在处理器类上，通常列出模型属性（如@ModelAttribute）对应的名称，则这些属性会透明的保存到session中；
• @InitBinder：自定义数据绑定注册支持，用于将请求参数转换到命令对象属性的对应类型；

3.Spring3.0引入RESTful架构风格支持(通过@PathVariable注解和一些其他特性支持),且又引入了更多的注解支持：

• @CookieValue：cookie数据到处理器功能处理方法的方法参数上的绑定；
• @RequestHeader：请求头（header）数据到处理器功能处理方法的方法参数上的绑定；
• @RequestBody：请求的body体的绑定（通过HttpMessageConverter进行类型转换）；
• @ResponseBody：处理器功能处理方法的返回值作为响应体（通过HttpMessageConverter进行类型转换）；
• @ResponseStatus：定义处理器功能处理方法/异常处理器返回的状态码和原因；
• @ExceptionHandler：注解式声明异常处理器；
• @PathVariable：请求URI中的模板变量部分到处理器功能处理方法的方法参数上的绑定，从而支持RESTful架构风格的URI；

4.还有比如：

JSR-303验证框架的无缝支持（通过@Valid注解定义验证元数据）；

使用Spring 3开始的ConversionService进行类型转换（PropertyEditor依然有效），支持使用@NumberFormat 和 @DateTimeFormat来进行数字和日期的格式化；

HttpMessageConverter（Http输入/输出转换器，比如JSON、XML等的数据输出转换器）；

ContentNegotiatingViewResolver，内容协商视图解析器，它还是视图解析器，只是它支持根据请求信息将同一模型数据以不同的视图方式展示（如json、xml、html等），RESTful架构风格中很重要的概念（同一资源，多种表现形式）；

Spring 3 引入 一个 mvc XML的命名空间用于支持mvc配置，包括如：

• <mvc:annotation-driven>：
  自动注册基于注解风格的处理器需要的DefaultAnnotationHandlerMapping、AnnotationMethodHandlerAdapter
  支持Spring3的ConversionService自动注册
  支持JSR-303验证框架的自动探测并注册（只需把JSR-303实现放置到classpath）
  自动注册相应的HttpMessageConverter（用于支持@RequestBody 和 @ResponseBody）（如XML输入输出转换器（只需将JAXP实现放置到classpath）、JSON输入输出转换器（只需将Jackson实现放置到classpath））等。
• <mvc:interceptors>：注册自定义的处理器拦截器；
• <mvc:view-controller>：和ParameterizableViewController类似，收到相应请求后直接选择相应的视图；
• <mvc:resources>：逻辑静态资源路径到物理静态资源路径的支持；
• <mvc:default-servlet-handler>：当在web.xml 中DispatcherServlet使用/ 映射时，能映射静态资源（当Spring Web MVC框架没有处理请求对应的控制器时（如一些静态资源），转交给默认的Servlet来响应静态文件，否则报404找不到资源错误，）。

5.Spring3.1新特性：

对Servlet 3.0的全面支持。

@EnableWebMvc：用于在基于Java类定义Bean配置中开启MVC支持，和XML中的<mvc:annotation-driven>功能一样；

新的@Contoller和@RequestMapping注解支持类：处理器映射RequestMappingHandlerMapping 和 处理器适配器RequestMappingHandlerAdapter组合来代替Spring2.5开始的处理器映射DefaultAnnotationHandlerMapping和处理器适配器AnnotationMethodHandlerAdapter，提供更多的扩展点，它们之间的区别我们在处理器映射一章介绍。

新的@ExceptionHandler 注解支持类：ExceptionHandlerExceptionResolver来代替Spring3.0的AnnotationMethodHandlerExceptionResolver，在异常处理器一章我们再详细讲解它们的区别。

@RequestMapping的”consumes” 和 “produces” 条件支持：用于支持@RequestBody 和 @ResponseBody，
1.consumes指定请求的内容是什么类型的内容，即本处理方法消费什么类型的数据，如consumes=”application/json”表示JSON类型的内容，Spring会根据相应的HttpMessageConverter进行请求内容区数据到@RequestBody注解的命令对象的转换；

2.produces指定生产什么类型的内容，如produces=”application/json”表示JSON类型的内容，Spring的根据相应的HttpMessageConverter进行请求内容区数据到@RequestBody注解的命令对象的转换，Spring会根据相应的HttpMessageConverter进行模型数据（返回值）到JSON响应内容的转换

URI模板变量增强：URI模板变量可以直接绑定到@ModelAttribute指定的命令对象、@PathVariable方法参数在视图渲染之前被合并到模型数据中（除JSON序列化、XML混搭场景下）。

@Validated：JSR-303的javax.validation.Valid一种变体（非JSR-303规范定义的，而是Spring自定义的），用于提供对Spring的验证器（org.springframework.validation.Validator）支持，需要Hibernate Validator 4.2及更高版本支持；

@RequestPart：提供对“multipart/form-data”请求的全面支持，支持Servlet 3.0文件上传（javax.servlet.http.Part）、支持内容的HttpMessageConverter（即根据请求头的Content-Type，来判断内容区数据是什么类型，如JSON、XML，能自动转换为命令对象），比@RequestParam更强大（只能对请求参数数据绑定，key-alue格式），而@RequestPart支持如JSON、XML内容区数据的绑定；详见本章的第×××节；

Flash 属性 和 RedirectAttribute：通过FlashMap存储一个请求的输出，当进入另一个请求时作为该请求的输入，典型场景如重定向（POST-REDIRECT-GET模式，1、POST时将下一次需要的数据放在FlashMap；2、重定向；3、通过GET访问重定向的地址，此时FlashMap会把1放到FlashMap的数据取出放到请求中，并从FlashMap中删除；从而支持在两次请求之间保存数据并防止了重复表单提交）。

Spring Web MVC提供FlashMapManager用于管理FlashMap，默认使用SessionFlashMapManager，即数据默认存储在session中。

转载自Spring MVC入门

参考文档

• Spring MVC入门

介绍

网络安全已成为大家最关心的问题. 如果你利用服务器存储客户资料, 那你应该考虑使用 SSL 加密客户跟服务器之间的通讯. 随着这几年手机应用迅速崛起. 黑客也开始向手机应用转移, 原因有下列3点:

• 手机系统各式各样, 缺乏统一的标准.
• 许多程序员缺乏手机应用开发经验.
• 更严重的是, 通过手机应用, 黑客可以得到手机用户的隐私数据, 如:日程安排, 联系人信息, 网页浏览历史记录, 个人资料, 社交数据, 短信或者手机用户所在的地理位置.

最为一个网络安全爱好者的我, 最近花了几个月的时间对50到60个安卓应用进行安全分析, 结果发现这些应用存在许多安全漏洞.

下面我主要讲一讲, 怎样才能写出比较安全的安卓代码.

背景

从最基本的开始讲.阅读本文前, 最好先看下 Ranjan.D article 写的一篇跟安卓连接有关的文章Android Connectivity.

下列代码用来打开一个 http 连接.

1
2

URL urlConnection = new URL("http://www.codeproject.com/");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

不要在 http连接中打开:登陆页面, 或是传递用户名, 密码, 银行卡之类的重要个人资料. 这些重要个人数据应该通过 HTTPS 传输. (具体参看HTTPS).

HTTPS是什么

HTTPS 其实就是个安全版的 http. HTTPS 能保证电子商务的交易安全. 如:网上银行.
像 IE 或者火狐浏览器, 如果出现下面的挂锁图标.

同时, 在浏览器的地址栏中以 https:// 开头, 这表示, 你的浏览器跟这个网站的数据往来都是安全的.

https 跟 http 的最大区别在于 https 多加了一个保障通讯安全的层.

像下列代码这样打开一个 https 连接, 可以保障这个连接的数据通讯安全.

1
2
3

URL urlConnection = new URL("https://www.codeproject.com/");
HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
InputStream in = new BufferedInputStream(urlConnection.getInputStream());

HTTPS 通过 SSL/TLS 传递数据.

SSL/TLS

SSL (Secure Sockets Layer) 是一种在客户端跟服务器端建立一个加密连接的安全标准. 一般用来加密网络服务器跟浏览器, 或者是邮件服务器跟邮件客户端(如: Outlook)之间传输的数据.

SSL 能保障敏感信息(如:银行卡号, 社保卡号, 登陆凭证等)的传输安全. 一般情况下, 数据在浏览器跟服务器之间的传输使用的是明文格式, 这种方式存在资料被窃取的风险. 如果黑客能拦截浏览器跟服务器之间的通讯数据, 就能看到通讯的内容.

SSL/HTTPS and X.509 证书概述

你要是对 SSL 或 X.509 证书一无所知, 那我大概解释下. 对于那些打算用自签名证书(self-signed certificate)的人来说, 需要了解自签名证书跟花钱购买机构颁发的证书有什么区别.

首先我们需要了解下 SSL 证书究竟是个什么东东? 其实它就包含俩部分:
1) 一个身份标识, 一个用来识别身份的东西, 有点类似警察叔叔通过护照或驾照查你的身份;
2) 一个公共密钥, 这个用来给数据加密, 而且只有证书的持有者才能解密.
简而言之, SSL 证书就俩个功能, 身份验证跟保障通讯过程中的数据安全.

另外还有一点很重要. 那就是一个证书可以给另外一个证书“签字”. 用 layman 的话说就是 Bob 用他自己的证书在别的证书上盖上 “同意” 两个红红的大字. 如果你信任 Bob (当然还有他的证书), 那么你也可以信任由他签发的证书. 在这个例子中, Bob 摇身一变, 成了证书颁发机构(Certificate Authority). 现在主流的浏览器都自带一大堆受信任证书颁发机构(trusted Certificate Authorities)(比如:Thawte, Verisign等).

最后我们讲一讲浏览器是怎么使用证书的. 笼统的讲, 当你打开下列连接的时候 “https://www.yoursite.com” :

• 服务器会给浏览器发一个证书.
• 浏览器会对比证书中的“common name”(有时也叫 “subject”) 跟服务器的域名是否一样. 例如, 一个从“www.yoursite.com” 网站发过来的证书就应该有一个内容是 “www.yoursite.com” 的 common name, 否则浏览器就会提示该证书有问题.
• 浏览器验证证书真伪, 有点像门卫通过证件上的全息图辨别你的证件是不是真的. 既然在现实生活中有人伪造别人的身份. 那么在网络世界也就有人造假, 比如用你的域名“www.yoursite.com” 来伪造一个安全证书. 浏览器在验证的时候, 会检查这个证书是否是它信任机构颁发的, 如果不是, 那么浏览器就会提示这个证书可能有问题. 当然, 用户可以选择无视警告, 继续使用.

一旦证书通过验证 (或是用户无视警告, 继续使用有问题的证书), 浏览器就开始利用证书中的公开密钥加密数据并传给服务器.

TLS (SSL)中的加密

一旦服务器发过来的证书通过验证, 浏览器就会利用证书中包含的公共密钥加密某个指定的共享密钥, 然后发给服务器. 这个加密过的共享密钥只能用服务器的私有密钥才能解密(非对称加密), 别人无法解密出其中的内容. 服务器把解密出来的共享密钥保存起来, 供本次连接会话专用. 从现在开始, 服务器跟浏览器之间的所有通讯信息都用这个共享密钥加密解密(对称加密).

理论部分就这么多, 下面我们来看几个例子.

在浏览器中打开网站 mail.live.com , 地址栏中会出现一个绿色图标, http 也会变成 https.

单击这个绿色图标, 然后点证书信息连接, 就能看到下列内容.

这是个 SSL 证书, 该证书是 Verisign 给 mail.live.cm 颁发的.

Verisign 是一个证书颁发机构, 它提示你的浏览器正在连接的网站是: mail.live.com, 需要跟这个网站的服务器建立一条安全连接进行通讯, 避免他人拦截或篡改浏览器跟服务器之间传递的数据.

MITM攻击(中间人攻击)

MITM 攻击(MITMA)是指: 黑客拦截篡改网络中的通讯数据

被动 MITMA 是指黑客只能窃取通讯数据, 而在主动 MITMA 中, 黑客除了窃取数据, 还能篡改通讯数据. 黑客利用 MITMA 方式攻击手机要比攻击台式电脑容易的多. 这主要是因为使用手机的环境在不固定, 有些地方用手机连接上网并不安全, 尤其是那些对公众免费开放的无线网络热点.

证书颁发机构（CA）

• Symantec (which bought VeriSign’s SSL interests and owns Thawte and Geotrust) 38.1% 市场份额
• Comodo SSL 29.1%
• Go Daddy 13.4%
• GlobalSign 10%

Jelly bean 版本的安卓系统中, 你可以在下列路径中找到证书颁发机构:
设置 -> 安全 -> 受信任的凭证.

Https 连接

1
2
3

URL url = new URL("https://www.example.com/");   
HttpsURLConnection urlConnection = (HttpsURLConnection)url.openConnection();   
InputStream in = urlConnection.getInputStream();

如果你连接的服务器(www.example.com)传过来的证书是由机构颁发的, 这段代码就能正常运行.

但是如果你连的服务器用的是自己颁发的证书(self-singed certificate), 那就会出现错误.

自签名证书( self-signed certicates)

自签名证书就是没有通过受信任的证书颁发机构, 自己给自己颁发的证书.

SSL 证书大致分三类:

• 由安卓认可的证书颁发机构(如: VeriSign), 或这些机构的下属机构颁发的证书.
• 没有得到安卓认可的证书颁发机构颁发的证书.
• 自己颁发的证书, 分临时性的(在开发阶段使用)或在发布的产品中永久性使用的两种.

只有第一种, 也就是那些被安卓系统认可的机构颁发的证书, 在使用过程中不会出现安全提示.
为什么有人喜欢用自签名证书

• 免费. 购买受信任机构颁发的证书每年要交 100 到 500 美元不等的费用. 自签名证书不花一分钱.
• 自签名证书在手机应用中的普及率较高 (跟用电脑浏览网页不同, 手机的应用一般就固定连一台服务器.).
• 在开发阶段写的代码, 测试跟发布的时候也可以用.

最近一项调查表明, 810万个证书中, 只有 320万个是由受信任机构颁发的. 剩余490万证书中, 自签名的占48%, 未知机构颁发的占33%, 而不被信任的机构颁发的证书占19%.

无独有偶, 我的分析结果也表明, 起码有 60% 安卓应用使用自签证书.

个人以为, 在手机应用中使用自签名证书没什么不好, 既不需要花钱, 也不需要修改代码.(注:如果你用的是机构颁发的证书, 在产品发布阶段, 需要修改代码).

但是下面的戏法的一般性的https代码

1
2
3

URL url = new URL("https://www.example.com/");   
HttpsURLConnection urlConnection = (HttpsURLConnection)url.openConnection();   
InputStream in = urlConnection.getInputStream();

如果你使用上述的代码去验证你的自己签署的证书，由于在android操作系统中自己签署的不能通过验证的，所以安卓应用软件将会抛出错误。因此你需要书写你自己的代码来检查你的自己签署的证书。

但是在这个领域中，安卓开发者犯了一个很大的错误，自己签署的证书在web开发中不是常见的，同时大多数安卓开发者来自于web开发者，所以开发者缺失在密码学的概念的知识。

在我分析中，我发现开发者仅仅是简单的复制、粘贴Stack Overflow和其他博客中允许你的应用默认信任所以证书的答案。即使大多说的答案表述仅仅在测试模式下可以使用，但是开发者简单地复制代码，将会导致应用软件在遭到中间件攻击和session黑客攻击时，表现的非常的脆弱！

例子：

• How to ignore SSL certificate errors in Apache HttpClient 4.0
• Accepting a certificate for HTTPs on Android
• Using self signed certificates with Android
• Trusting all certificates using HttpClient over HTTPS

在使用自己签署的证书时一般性的错误

信任所有的证书

TrustManager的主要责任是去决定提出的认证证书应该是可信任的。如果证书是不可信任的，那么连接将会被终止。去认证远程的安全套接字识别，你需要用一个或者多个TrustManager（s）初始化SSLContext对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import org.apache.http.conn.ssl.SSLSocketFactory;
public class MySSLSocketFactory extends SSLSocketFactory {
    SSLContext sslContext = SSLContext.getInstance("TLS");
    public MySSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
        super(truststore);
        TrustManager tm = new X509TrustManager() {
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };
        sslContext.init(null, new TrustManager[] { tm }, null);
   }
    @Override
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
        return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
    }
    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }
}

我发现，80到100个应用软件中，在20到25个应用中实现了上述的代码。

在上述的TrustManager接口中，可以实现信任所有的证书，不论是谁签署的或者即使他们发布的任何主题。这个接口将会允许接受ANY证书。接受任何的证书将会危害数据的完整性、安全性等等。

在上述的例子中，检查客户端可信任性，获得接受事件，检查服务器端可信任性是三点重要的功能。每一位开发者都应该留意这三点功能的实现上。但是却很少有开发者从不同的网站中搜索、负责上述的功能。

允许所有的主机名

忘记检查证书是否在这个地址发布是有可能的。当证书接受了example.com的服务器，那么另外的一个域名也将被接受。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

HostnameVerifier hostnameVerifier = org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
DefaultHttpClient client = new DefaultHttpClient();
SchemeRegistry registry = new SchemeRegistry();
SSLSocketFactory socketFactory = SSLSocketFactory.getSocketFactory();
socketFactory.setHostnameVerifier((X509HostnameVerifier) hostnameVerifier);
registry.register(new Scheme("https", socketFactory, 443));
SingleClientConnManager mgr = new SingleClientConnManager(client.getParams(), registry);
DefaultHttpClient httpClient = new DefaultHttpClient(mgr, client.getParams());
// Set verifier     
HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
// Example send http request
final String url = "https://www.paypal.com";
HttpPost httpPost = new HttpPost(url);
HttpResponse response = httpClient.execute(httpPost);
HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
HostnameVerifier hostnameVerifier = org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;

上述的代码中，即使是错误的实现，也将会接受对任何域名的任何CA证书声明。

Mixed-Mode/No SSL

应用软件开发者在相同的应用中使用最大安全、不安全的连接，或者不使用SSL将是免费的。这不是直接的SSL声明，但是和提到的没有向外的签署个有关，同时对于一般软件的使用者，检查是否使用一个安全的连接是不可能的。这将会为例如SSL剥离，或者像FireSheep这样的攻击开后门。

SSL剥离是另外的一种可以使MITMA登陆并抵制SSL连接方式。利用使用最大HTTP和HTTPS应用。SSL剥离依赖大量建立在点击链接、或者来自于没有SSL重定向保护的网站SSL连接。在SSL剥离中，Mallory用HTTPS://取代了没有保护的网站中http:// 链接中。因此，除非使用者注意到了链接被篡改了，Mallory可以完全地规避SSL保护。这样的攻击主要与浏览器应用、或者原生使用安卓WebView应用有关。

更多关于SSL剥离的信息：
http://security.stackexchange.com/questions/41988/how-does-sslstrip-work
http://www.thoughtcrime.org/software/sslstrip/

证书锁定

直接在代码中固定写死使用某个服务器的证书. 然后在应用中使用自己定义的信任存储(trust store)代替手机系统自带的那个, 去连接指定的服务器.

这样做的好处是, 我们既能使用自签名证书, 又不需要额外安装其他证书.
优势

• 安全性提升 - 采用这种方式, 应用不再依赖系统自带的信任存储(trust store). 使得破解这种应用变得复杂: 首先你要反编译, 修改完后, 还要重新编译. 关键是你不可能使用应用作者原先用的那个 keystore 文件重新颁发证书.
• 成本降低 - 证书锁定方式让我们可以在自己的服务器上使用免费的自签名证书, 调用自己写的 API. 虽说复杂了点, 可是像这种既不花钱, 还能提高应用安全的好事上哪找去?

缺点

• 适应性较差 - 一旦 SSL 证书出现变动, 应用也要跟着升级. 再发布到 Google Play. 然后祈祷用户能都升级到最新版本.

安卓的 SSLContext 自带的 TrustManager 无法让本文示例中提到的自签名证书通过验证. 解决的办法是自己定义一个 TrustManager 类. 然后用这个类去验证自签名证书.

先把证书加载到 KeyStore, 然后用 KeyStore 生成一个 TrustManager 数组, 最后再用这个 TrustManager 数组创建 SSLContext.

本文的应用把服务器的证书直接存进应用的资源.(毕竟这个文件是所有用户都共用的, 而且也不会经常改动), 当然你可以把它存到别的地方.

实现的步骤

第1步: 创建自签名证书和.bks 文件

1) 创建 BKS 或者 keystore, 需要用到下面这个文件,bcprov-jdk15on-146.jar.下载后, 把文件存到 C:\codeproject.

然后用 Keytool 生成 keystore 文件.(keytool 是 Java SDK 自带的文件, 跟javac 放在同一个目录下)在命令提示符窗口中输入 keytool 就能看到这个工具的各种选项说明. 或者输入下列路径运行.

“C:\Program Files (x86)\Java\jre7\bin>keytool”.

2)下面是用 keytool 生成 keysotre 文件的命令. 要是这个文件已经存在, 这一步可以忽略.

1

keytool -genkey -alias codeproject -keystore C:\codeproject\codeprojectssl.keystore -validity 365

这行命令创建一个别名为 code project 的密钥(key), 生成的文件名是 codeprojectssl.keystore. 执行文件生成过程中会要求输入密钥(key)跟keystore的密码诸如此类的东东. 这里需要注意下, 当要求你录入 Common name 的时候, 要填你的主机名. 本文例子用的是: codeproject.com

3)将密钥(key)从 .keystore 文件导入 .cer 文件.

1

keytool -export -alias codeproject -keystore C:\codeproject\codeprojectssl.keystore -file C:\codeproject\codeprojectsslcert.cer

4) 生成 bks 文件

1

keytool -import -alias codeproject -file C:\codeproject\codeprojectsslcert.cer -keystore C:\codeproject\codeprojectssl.bks -storetype BKS -providerClass org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath C:\codeproject\bcprov-jdk15on-146.jar

搞定! 现在, 全部 .bks 文件都生成了. 稍后将这些文件复制到安卓应用中. 连接那些使用自签名证书的服务器的时候会用到.

第2步 把 .keystore 文件复制到 /androidappdir/res/raw/

第3步 创建一个新类: MyHttpClient, 继承 DefaultHttpClient 类.

这个新类在验证SSL 证书的时候, 会自动加载我们自己创建的 keystore 文件, 而不是安卓自带的那个. 只要证书跟服务器匹配上了就没问题. 代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import java.io.InputStream;
import java.security.KeyStore;
import android.content.Context;
public class MyHttpClient extends DefaultHttpClient {
  
 private static Context context;
 
 public static void setContext(Context context) {
  MyHttpClient.context = context;
 }
 public MyHttpClient(HttpParams params) {
  super(params);
 }
 public MyHttpClient(ClientConnectionManager httpConnectionManager, HttpParams params) {
  super(httpConnectionManager, params);
 }
 @Override
    protected ClientConnectionManager createClientConnectionManager() {
        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
        
        // 用我们自己定义的 SSLSocketFactory 在 ConnectionManager 中注册一个 443 端口  
        registry.register(new Scheme("https", newSslSocketFactory(), 443));
        return new SingleClientConnManager(getParams(), registry);
    }
 
    private SSLSocketFactory newSslSocketFactory() {
        try {
            // Get an instance of the Bouncy Castle KeyStore format
            KeyStore trusted = KeyStore.getInstance("BKS");
            // 从资源文件中读取你自己创建的那个包含证书的 keystore 文件
            
            InputStream in = MyHttpClient.context.getResources().openRawResource(R.raw.codeprojectssl); //这个参数改成你的 keystore 文件名
            try {
                // 用 keystore 的密码跟证书初始化 trusted                            
                trusted.load(in, "这里是你的 keystore 密码".toCharArray());
            } finally {
                in.close();
            }
            // Pass the keystore to the SSLSocketFactory. The factory is responsible
            // for the verification of the server certificate.
            SSLSocketFactory sf = new SSLSocketFactory(trusted);
            // Hostname verification from certificate
            // http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html#d4e506
            sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER); // 这个参数可以根据需要调整, 如果对主机名的验证不需要那么严谨, 可以将这个严谨程度调低些.
            return sf;
        } catch (Exception e) {
            throw new AssertionError(e);
        }
    }
}

MyHttpClient 类的调用代码如下:

1
2
3
4
5
6

// Instantiate the custom HttpClient
DefaultHttpClient client = new MyHttpClient(getApplicationContext());
HttpGet get = new HttpGet("https://www.google.com");
// 以 GET 方式读取服务器返回的数据
HttpResponse getResponse = client.execute(get);
HttpEntity responseEntity = getResponse.getEntity();

这是我在 CodeProject 上的发布的处女作.

祝大家开心编程, 安全第一.为你的Android App实现自签名的 SSL 证书 .

本文地址
原文地址

参考文档

• PKI常见证书格式和转换
• 为你的Android App实现自签名的 SSL 证书
• Your app shouldn’t suffer SSL’s problems
• What is certificate pinning
• How does SSLstrip work
• Certificate and Public Key Pinning
• Public Key Pinning Extension for HTTP draft-ietf-websec-key-pinning-20
• How SSL Works
• p12 file’s certificates to x509
• Security with HTTPS and SSL
• TESTTOOL-google/nogotofail
• OpenSSL

前言

本文介绍在Android中实现推送方式的基础知识及相关解决方案。推送功能在手机开发中应用的场景是越来起来了，不说别的，就我们手机上的新闻客户端就时不时的推送过来新的消息，很方便的阅读最新的新闻信息。这种推送功能是好的一面，但是也会经常看到很多推送过来的垃圾信息，这就让我们感到厌烦了，关于这个我们就不能多说什么了，毕竟很多商家要做广告。本文就是来探讨下Android中实现推送功能的一些解决方案，也希望能够起到抛砖引玉的作用。

推送方式基础知识

在移动互联网时代以前的手机，如果有事情发生需要通知用户，则会有一个窗口弹出，将告诉用户正在发生什么事情。可能是未接电话的提示，日历的提醒，或是一封新的彩信。推送功能最早是被用于Email中，用来提示我们新的信息。由于时代的发展和移动互联网的热潮，推送功能更加地普及，已经不再仅仅用在推送邮件了，更多地用在我们的APP中了。

当我们开发需要和服务器交互的应用程序时，基本上都需要获取服务器端的数据，比如《地震应急通》就需要及时获取服务器上最新的地震信息。要获取服务器上不定时更新的信息，一般来说有两种方法：

• 第一种是客户端使用Pull（拉）的方式，就是隔一段时间就去服务器上获取一下信息，看是否有更新的信息出现。
• 第二种就是服务器使用Push（推送）的方式，当服务器端有新信息了，则把最新的信息Push到客户端上。这样，客户端就能自动的接收到消息。 

虽然Pull和Push两种方式都能实现获取服务器端更新信息的功能，但是明显来说Push方式比Pull方式更优越。因为Pull方式更费客户端的网络流量，更主要的是费电量，还需要我们的程序不停地去监测服务端的变化。  

在开发Android和iPhone应用程序时，我们往往需要从服务器不定的向手机客户端即时推送各种通知消息。我们只需要在Android或IPhone的通知栏处向下一拉，就展开了Notification Panel，可以集中一览各种各样通知消息。目前IOS平台上已经有了比较简单的和完美的推送通知解决方案，可是Android平台上实现起来却相对比较麻烦。

最近利用几天的时间对Android的推送通知服务进行初步的研究，也希望能和大家共同探讨一下。

几种常见的解决方案实现原理

轮询(Pull)方式
应用程序应当阶段性的与服务器进行连接并查询是否有新的消息到达，你必须自己实现与服务器之间的通信，例如消息排队等。而且你还要考虑轮询的频率，如果太慢可能导致某些消息的延迟，如果太快，则会大量消耗网络带宽和电池。

SMS(Push)方式
在Android平台上，你可以通过拦截SMS消息并且解析消息内容来了解服务器的意图，并获取其显示内容进行处理。这是一个不错的想法，我就见过采用这个方案的应用程序。这个方案的好处是，可以实现完全的实时操作。但是问题是这个方案的成本相对比较高，我们需要向移动公司缴纳相应的费用。我们目前很难找到免费的短消息发送网关来实现这种方案。

持久连接(Push)方式
这个方案可以解决由轮询带来的性能问题，但是还是会消耗手机的电池。IOS平台的推送服务之所以工作的很好，是因为每一台手机仅仅保持一个与服务器之间的连接，事实上C2DM也是这么工作的。不过刚才也讲了，这个方案存在着很多的不足之处，就是我们很难在手机上实现一个可靠的服务，目前也无法与IOS平台的推送功能相比。

Android操作系统允许在低内存情况下杀死系统服务，所以我们的推送通知服务很有可能就被操作系统Kill掉了。 轮询(Pull)方式和SMS(Push)方式这两个方案也存在明显的不足。至于持久连接(Push)方案也有不足，不过我们可以通过良好的设计来弥补，以便于让该方案可以有效的工作。毕竟，我们要知道GMail，GTalk以及GoogleVoice都可以实现实时更新的。

第一种解决方案：C2DM云端推送 [不推荐]

在Android手机平台上，Google提供了C2DM（Cloud to Device Messaging）服务，起初我就是准备采用这个服务来实现自己手机上的推送功能，并将其带入自己的项目中。 

Android Cloud to Device Messaging (C2DM)是一个用来帮助开发者从服务器向Android应用程序发送数据的服务。该服务提供了一个简单的、轻量级的机制，允许服务器可以通知移动应用程序直接与服务器进行通信，以便于从服务器获取应用程序更新和用户数据。C2DM服务负责处理诸如消息排队等事务并向运行于目标设备上的应用程序分发这些消息。关于C2DM具体使用过程，大家可以去查阅相关的资料，在这里先让我们了解下大致方案情况。

下面是C2DM操作过程示例图:

但是经过一番研究发现，这个服务存在很大的问题：
1）C2DM内置于Android的2.2系统上，无法兼容老的1.6到2.1系统;

2）C2DM需要依赖于Google官方提供的C2DM服务器，由于国内的网络环境，这个服务经常不可用，如果想要很好的使用，我们的App Server必须也在国外，这个恐怕不是每个开发者都能够实现的。

3) 不像在iPhone中，他们把硬件系统集成在一块了。所以对于我们开发者来说，如果要在我们的应用程序中使用C2DM的推送功能，因为对于不同的这种硬件厂商平台，比如摩托罗拉、华为、中兴做一个手机，他们可能会把Google的这种服务去掉，尤其像在国内就很多这种，把Google这种原生的服务去掉。买了一些像什么山寨机或者是华为这种国产机，可能Google的服务就没有了。而像在国外出的那些可能会内置。

有了上述几个方面的制约，导致我最终放弃了这个方案，不过可以了解一下C2DM的框架以及客户端和App Server的相应设置方法，可以作为学习作为参考的资料。 即然C2DM无法满足我们的要求，那么我们就需要自己来实现Android手机客户端与App Server之间的通信协议，保证在App Server想向指定的Android设备发送消息时，Android设备能够及时的收到。

第二种解决方案：MQTT协议实现Android推送

采用MQTT协议实现Android推送功能也是一种解决方案。MQTT是一个轻量级的消息发布/订阅协议，它是实现基于手机客户端的消息推送服务器的理想解决方案。

wmqtt.jar 是IBM提供的MQTT协议的实现。我们可以从这里下载该项目的实例代码，并且可以找到一个采用PHP书写的服务器端实现（https://github.com/tokudu/PhpMQTTClient）。

架构如下图所示：

　　
wmqtt.jar 是IBM提供的MQTT协议的实现。我们可以从如下站点下载它。我们可以将该jar包加入自己的Android应用程序中。

说明: MQTT（Message Queuing Telemetry Transport，消息队列遥测传输）是IBM开发的一个即时通讯协议，有可能成为物联网的重要组成部分。该协议支持所有平台，几乎可以把所有联网物品和外部连接起来，被用来当做传感器和致动器（比如通过Twitter让房屋联网）的通信协议。

第三种解决方案：RSMB实现推送

Really Small Message Broker (RSMB) ，他是一个简单的MQTT代理，同样由IBM提供，其查看地址是：RSMB。缺省打开1883端口，应用程序当中，它负责接收来自服务器的消息并将其转发给指定的移动设备。

SAM是一个针对MQTT写的PHP库。我们可以从这里下载。
send_mqtt.php是一个通过POST接收消息并且通过SAM将消息发送给RSMB的PHP脚本。

第四种解决方案：XMPP协议实现推送

这是我希望在项目中采用的方案，因为目前它是开源的，对于其简单的推送功能它还是能够实现的。我们可以修改其源代码来适应我们的应用程序。

事实上Google官方的C2DM服务器底层也是采用XMPP协议进行的封装。XMPP(可扩展通讯和表示协议)是基于可扩展标记语言（XML）的协议，它用于即时消息（IM）以及在线探测。这个协议可能最终允许因特网用户向因特网上的其他任何人发送即时消息。关于XMPP协议可以参考博文XMPP协议实现原理介绍。

androidpn是一个基于XMPP协议的java开源Android push notification实现。它包含了完整的客户端和服务器端。经过源代码研究我发现，该服务器端基本是在另外一个开源工程openfire基础上修改实现的，不过比较郁闷的是androidpn的文档是由韩语写的，所以整个研究过程基本都是读源码。

这是androidpn的项目主页

androidpn实现意图如下图所示：

　　
androidpn 客户端需要用到一个基于java的开源XMPP协议包asmack，这个包同样也是基于openfire下的另外一个开源项目smack，不过我们不需要自己编译，可以直接把androidpn客户端里面的asmack.jar拿来使用。客户端利用asmack中提供的XMPPConnection类与服务器建立持久连接，并通过该连接进行用户注册和登录认证，同样也是通过这条连接，接收服务器发送的通知。

androidpn服务器端也是java语言实现的，基于openfire开源工程，不过它的Web部分采用的是spring框架，这一点与openfire是不同的。Androidpn服务器包含两个部分，一个是侦听在5222端口上的XMPP服务，负责与客户端的 XMPPConnection类进行通信，作用是用户注册和身份认证，并发送推送通知消息。另外一部分是Web服务器，采用一个轻量级的HTTP服务器， 负责接收用户的Web请求。服务器架构如下：

最上层包含四个组成部分，分别是SessionManager，Auth Manager，PresenceManager以及Notification Manager。SessionManager负责管理客户端与服务器之间的会话，Auth Manager负责客户端用户认证管理，Presence Manager负责管理客户端用户的登录状态，NotificationManager负责实现服务器向客户端推送消息功能。

这个解决方案的最大优势就是简单，我们不需要象C2DM那样依赖操作系统版本，也不会担心某一天Google服务器不可用。利用XMPP协议我们还可以进一步的对协议进行扩展，实现更为完善的功能。 采用这个方案，我们目前只能发送文字消息，不过对于推送来说一般足够了，因为我们不能指望通过推送得到所有的数据，一般情况下，利用推送只是告诉手机端服务器发生了某些改变，当客户端收到通知以后，应该主动到服务器获取最新的数据，这样才是推送服务的完整实现。 XMPP协议书相对来说还是比较简单的，值得我们进一步研究。

但是在经过一段时间的测试，我发现关于androidpn也存在一些不足之处：

• 时间过长时，就再也收不到推送的信息了。
• 性能上也不够稳定。
• 如果将消息从服务器上推送出去，就不再管理了，不管消息是否成功到达客户端手机上。

等等，总之，androidpn也有很多的缺点。如果我们要使用androidpn，则还需要做大量的工作。

说明: XMPP（Extensible Messageing and Presence Protocol：可扩展消息与表现协议）是目前主流的四种IM（IM：instant messaging,即时消息）协议之一，其他三种分别为：即时信息和空间协议(IMPP)、空间和即时信息协议(PRIM)、针对即时通讯和空间平衡扩充的进程开始协议SIP(SIMPLE)。

第五种解决方案：使用第三方平台

第三方平台有商用的也有免费的，我们可以根据实现情况使用。关于国内的第三方平台，我感觉目前比较不错的就是极光推送。关于极光推送目前是免费的，我们可以直接使用。关于详细情况，大家可以查看它的主页：Jpush。

关于MQTT的方案，国内最近出现基于 mqtt 的第三方解决方案 云巴，据了解是原极光推送 CTO 创办的，有兴趣的朋友可以研究下。

关于国外的第三方平台我也见过几个：push-notification。有兴趣的朋友可以查阅相关信息。使用第三方平台就需要使用别人的服务器，关于这点，你懂的。

第六种解决方案：自己搭建推送平台

这不是一件轻松的工作，当然可以根据各自的需要采取合适的方案。

好了，以上是关于在Android中实现推送方式的基础知识及相关解决方案。

原文地址

相关参考

• RSMB
• androidnp
• 极光推送
• 云巴官网
• XMPP协议实现原理介绍

前言

开门见山，本篇博客讲解一下如何在Android平台下播放一个逐帧动画。逐帧动画在Android下可以通过代码和XML文件两种方式定义，本篇博客都将讲到，最后将以一个简单的Demo来演示两种方式定义的逐帧动画的播放。

Android中的逐帧动画

先来说说什么是逐帧动画，逐帧动画是一种常见的动画形式（Frame By Frame），其原理是在“连续的关键帧”中分解动画动作，也就是在时间轴的每帧上逐帧绘制不同的内容，使其连续播放而成动画。 因为逐帧动画的帧序列内容不一样，不但给制作增加了负担而且最终输出的文件量也很大，但它的优势也很明显：逐帧动画具有非常大的灵活性，几乎可以表现任何想表现的内容，而它类似与电影的播放模式，很适合于表演细腻的动画。

在Android中逐帧动画需要得到AnimationDrawable类的支持，它位于”android.graphics.drawable.AnimationDrawable”包下，是Drawable的间接子类。它主要用来创建一个逐帧动画，并且可以对帧进行拉伸，把它设置为View的背景即可使用AnimationDrawable.start()方法播放。既然逐帧动画是需要播放一帧一帧的图像，所以需要为其添加帧。在Android中提供了两种方式为AnimationDrawable添加帧：XML定义的资源文件和Java代码创建，后面再详细讲讲这两种添加帧的方式。

光为AnimationDrawable设置帧还不能完成播放动画的功能，还需要AnimationDrawable定义好的其他的一些方法来操作逐帧动画，下面简单介绍一下AnimationDrawable的常用方法：

• void start()：开始播放逐帧动画。
• void stop()：停止播放逐帧动画。
• void addFrame(Drawable frame,int duration)：为AnimationDrawable添加一帧，并设置持续时间。
• int getDuration(int i)：得到指定index的帧的持续时间。
• Drawable getFrame(int index)：得到指定index的帧Drawable。
• int getNumberOfFrames()：得到当前AnimationDrawable的所有帧数量。
• boolean isOneShot()：当前AnimationDrawable是否执行一次，返回true执行一次，false循环播放。
• boolean isRunning()：当前AnimationDrawable是否正在播放。
• void setOneShot(boolean oneShot)：设置AnimationDrawable是否执行一次，true执行一次，false循环播放

使用XML定义的资源文件设置动画帧

Android下所有的资源文件均要放在/res目录下，对于动画帧的资源需要当成一个Drawable，所以需要把它放在/res/Drawable目录下。而定义逐帧动画非常简单，只要在元素中使用子元素定义动画的全部帧，并制定各帧的持续时间即可。还可以在元素中添加属性，来设定逐帧动画的属性。
例如：

1
2
3
4
5

<?xml version="1.0" encoding="utf-8"?>
 <animation-list xmlns:android="http://schemas.android.com/apk/res/android" android:oneshot="false"  >
     <!-- 定义一个动画帧，Drawable为img0，持续时间50毫秒 -->
     <item android:drawable="@drawable/img0" android:duration="50" />
</animation-list>

定义好逐帧动画的资源文件之后，只需要使用getResources().getDrawable(int)方法获取AnimationDrawable示例，然后把它设置为某个View的背景即可。
下面通过一个简单的Demo，来演示如何播放一个XML定义的逐帧动画，布局很简单，一个ImageView来承载逐帧动画，两个Button控制播放与停止：

XML帧动画的资源文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<?xml version="1.0" encoding="utf-8"?>
<animation-list xmlns:android="http://schemas.android.com/apk/res/android" android:oneshot="false"  >
    <!-- 定义一个动画帧，Drawable为img0，持续时间50毫秒 -->
    <item android:drawable="@drawable/img0" android:duration="50" />
    <item android:drawable="@drawable/img1" android:duration="50" />
    <item android:drawable="@drawable/img2" android:duration="50" />
    <item android:drawable="@drawable/img3" android:duration="50" />
    <item android:drawable="@drawable/img4" android:duration="50" />
    <item android:drawable="@drawable/img5" android:duration="50" />
    <item android:drawable="@drawable/img6" android:duration="50" />
    <item android:drawable="@drawable/img7" android:duration="50" />
    <item android:drawable="@drawable/img8" android:duration="50" />
    <item android:drawable="@drawable/img9" android:duration="50" />
    <item android:drawable="@drawable/img10" android:duration="50" />
    <item android:drawable="@drawable/img11" android:duration="50" />
    <item android:drawable="@drawable/img12" android:duration="50" />
    <item android:drawable="@drawable/img13" android:duration="50" />
    <item android:drawable="@drawable/img14" android:duration="50" />
    <item android:drawable="@drawable/img15" android:duration="50" />
    <item android:drawable="@drawable/img16" android:duration="50" />
    <item android:drawable="@drawable/img17" android:duration="50" />
    <item android:drawable="@drawable/img18" android:duration="50" />
    <item android:drawable="@drawable/img19" android:duration="50" />
    <item android:drawable="@drawable/img20" android:duration="50" />
    <item android:drawable="@drawable/img21" android:duration="50" />
    <item android:drawable="@drawable/img22" android:duration="50" />
    <item android:drawable="@drawable/img23" android:duration="50" />
    <item android:drawable="@drawable/img24" android:duration="50" />
</animation-list>

实现代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

package cn.bgxt.frameanimationdemo;
import android.app.Activity;
import android.graphics.drawable.AnimationDrawable;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;
public class ToXMLActivity extends Activity {
    private Button btn_start, btn_stop;
    private ImageView iv_frame;
    private AnimationDrawable frameAnim;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_frameanim);
        btn_start = (Button) findViewById(R.id.btn_start);
        btn_stop = (Button) findViewById(R.id.btn_stop);
        btn_start.setOnClickListener(click);
        btn_stop.setOnClickListener(click);
        iv_frame = (ImageView) findViewById(R.id.iv_frame);
        
        // 通过逐帧动画的资源文件获得AnimationDrawable示例
        frameAnim=(AnimationDrawable) getResources().getDrawable(R.drawable.bullet_anim);
        // 把AnimationDrawable设置为ImageView的背景
        iv_frame.setBackgroundDrawable(frameAnim);
    }
    private View.OnClickListener click = new OnClickListener() {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
            case R.id.btn_start:
                start();
                break;
            case R.id.btn_stop:
                stop();
                break;
            default:
                break;
            }
        }
    };
    /**
     * 开始播放
     */
    protected void start() {
        if (frameAnim != null && !frameAnim.isRunning()) {
            frameAnim.start();
            Toast.makeText(ToXMLActivity.this, "开始播放", 0).show();
            Log.i("main", "index 为5的帧持续时间为："+frameAnim.getDuration(5)+"毫秒");
            Log.i("main", "当前AnimationDrawable一共有"+frameAnim.getNumberOfFrames()+"帧");
        }
    }
    /**
     * 停止播放
     */
    protected void stop() {
        if (frameAnim != null && frameAnim.isRunning()) {
            frameAnim.stop();
            Toast.makeText(ToXMLActivity.this, "停止播放", 0).show();
        }
    }
}

使用Java代码创建逐帧动画

在Android中，除了可以通过XML文件定义一个逐帧动画之外，还可以通过AnimationDrawable.addFrame()方法为AnimationDrawable添加动画帧，上面已经提供了addFrame()的方法签名，它可以设置添加动画帧的Drawable和持续时间。其实没什么技术含量，下面通过一个简单的Demo演示一下。

实现代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

package cn.bgxt.frameanimationdemo;
import android.app.Activity;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.drawable.AnimationDrawable;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;
public class ToCodeActivity extends Activity {
    private Button btn_start, btn_stop;
    private ImageView iv_frame;
    private AnimationDrawable frameAnim;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_frameanim);
        btn_start = (Button) findViewById(R.id.btn_start);
        btn_stop = (Button) findViewById(R.id.btn_stop);
        btn_start.setOnClickListener(click);
        btn_stop.setOnClickListener(click);
        iv_frame = (ImageView) findViewById(R.id.iv_frame);
        frameAnim =new AnimationDrawable();
        // 为AnimationDrawable添加动画帧
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img0), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img1), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img2), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img3), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img4), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img5), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img6), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img7), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img8), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img9), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img10), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img11), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img12), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img13), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img14), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img15), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img16), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img17), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img18), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img19), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img20), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img21), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img22), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img23), 50);
        frameAnim.addFrame(getResources().getDrawable(R.drawable.img24), 50);
        frameAnim.setOneShot(false);
        
        // 设置ImageView的背景为AnimationDrawable
        iv_frame.setBackgroundDrawable(frameAnim);
    }
    private View.OnClickListener click = new OnClickListener() {
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
            case R.id.btn_start:
                start();
                break;
            case R.id.btn_stop:
                stop();
                break;
            default:
                break;
            }
        }
    };
    /**
     * 开始播放
     */
    protected void start() {
        if (frameAnim != null && !frameAnim.isRunning()) {
            frameAnim.start();
            Toast.makeText(ToCodeActivity.this, "开始播放", 0).show();
        }
    }
    /**
     * 停止播放
     */
    protected void stop() {
        if (frameAnim != null && frameAnim.isRunning()) {
            frameAnim.stop();
            Toast.makeText(ToCodeActivity.this, "停止播放", 0).show();
        }
    }
}

其实上面两个Demo实现的都是一种效果，是一个子弹击中墙体的逐帧动画效果，下面展示一下Demo的运行效果：

原文出自

• 承香墨影

前言

Volley 是 Google 推出的 Android 异步网络请求框架和图片加载框架。在 Google I/O 2013 大会上发布。特别适合数据量小，通信频繁的网络操作。（个人认为 Android 应用中绝大多数的网络操作都属于这种类型）。

Volley 的主要特点

• 扩展性强。Volley 中大多是基于接口的设计，可配置性强。
• 一定程度符合 Http 规范，包括返回 ResponseCode(2xx、3xx、4xx、5xx）的处理，请求头的处理，缓存机制的支持等。并支持重试及优先级定义。
• 默认 Android2.3 及以上基于 HttpURLConnection，2.3 以下基于 HttpClient 实现。
• 提供简便的图片加载工具。

总体设计

1.总体设计图

上面是 Volley 的总体设计图，主要是通过两种Dispatch Thread不断从RequestQueue中取出请求，根据是否已缓存调用Cache或Network这两类数据获取接口之一，从内存缓存或是服务器取得请求的数据，然后交由ResponseDelivery去做结果分发及回调处理。

2.Volley 中的概念
Volley 的调用比较简单，通过 newRequestQueue(…) 函数新建并启动一个请求队列RequestQueue后，只需要往这个RequestQueue不断 add Request 即可。

• Volley：Volley 对外暴露的 API，通过 newRequestQueue(…) 函数新建并启动一个请求队列RequestQueue。
• Request：表示一个请求的抽象类。StringRequest、JsonRequest、ImageRequest 都是它的子类，表示某种类型的请求。
• RequestQueue：表示请求队列，里面包含一个CacheDispatcher(用于处理走缓存请求的调度线程)、NetworkDispatcher数组(用于处理走网络请求的调度线程)，一个ResponseDelivery(返回结果分发接口)，通过 start() 函数启动时会启动CacheDispatcher和NetworkDispatchers。
• CacheDispatcher：一个线程，用于调度处理走缓存的请求。启动后会不断从缓存请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给ResponseDelivery去执行后续处理。当结果未缓存过、缓存失效或缓存需要刷新的情况下，该请求都需要重新进入NetworkDispatcher去调度处理。
• NetworkDispatcher：一个线程，用于调度处理走网络的请求。启动后会不断从网络请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给ResponseDelivery去执行后续处理，并判断结果是否要进行缓存。
• ResponseDelivery：返回结果分发接口，目前只有基于ExecutorDelivery的在入参 handler 对应线程内进行分发。
• HttpStack：处理 Http 请求，返回请求结果。目前 Volley 中有基于 HttpURLConnection 的HurlStack和 基于 Apache HttpClient 的HttpClientStack。
• Network：调用HttpStack处理请求，并将结果转换为可被ResponseDelivery处理的NetworkResponse。
• Cache：缓存请求结果，Volley 默认使用的是基于 sdcard 的DiskBasedCache。NetworkDispatcher得到请求结果后判断是否需要存储在 Cache，CacheDispatcher会从 Cache 中取缓存结果。

3.Volley 请求流程图

详细设计

1.类关系图

这是 Volley 框架的主要类关系图
图中红色圈内的部分，组成了 Volley 框架的核心，围绕 RequestQueue 类，将各个功能点以组合的方式结合在了一起。各个功能点也都是以接口或者抽象类的形式提供。
红色圈外面的部分，在 Volley 源码中放在了 toolbox 包中，作为 Volley 为各个功能点提供的默认的具体实现。
通过类图我们看出， Volley 有着非常好的拓展性。通过各个功能点的接口，我们可以给出自定义的，更符合我们需求的具体实现。

多用组合，少用继承；针对接口编程，不针对具体实现编程。
优秀框架的设计，令人叫绝，受益良多。

2.核心类功能介绍
Volley.java

这个和 Volley 框架同名的类，其实是个工具类，作用是构建一个可用于添加网络请求的RequestQueue对象。
(1). 主要函数
Volley.java 有两个重载的静态方法。

1
2

public static RequestQueue newRequestQueue(Context context)
public static RequestQueue newRequestQueue(Context context, HttpStack stack)

第一个方法的实现调用了第二个方法，传 HttpStack 参数为 null。
第二个方法中，如果 HttpStatck 参数为 null，则如果系统在 Gingerbread 及之后(即 API Level >= 9)，采用基于 HttpURLConnection 的 HurlStack，如果小于 9，采用基于 HttpClient 的 HttpClientStack。

1
2
3
4
5
6
7

if (stack == null) {
    if (Build.VERSION.SDK_INT >= 9) {
        stack = new HurlStack();
    } else {
        stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
    }
}

得到了 HttpStack,然后通过它构造一个代表网络（Network）的具体实现BasicNetwork。
接着构造一个代表缓存（Cache）的基于 Disk 的具体实现DiskBasedCache。
最后将网络（Network）对象和缓存（Cache）对象传入构建一个 RequestQueue，启动这个 RequestQueue，并返回。

1
2
3
4

Network network = new BasicNetwork(stack);
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
return queue;

我们平时大多采用Volly.newRequestQueue(context)的默认实现，构建 RequestQueue。
通过源码可以看出，我们可以抛开 Volley 工具类构建自定义的 RequestQueue，采用自定义的HttpStatck，采用自定义的Network实现，采用自定义的 Cache 实现等来构建RequestQueue。
优秀框架的高可拓展性的魅力来源于此。

HttpURLConnection 和 AndroidHttpClient(HttpClient 的封装)如何选择及原因：
在 Froyo(2.2) 之前，HttpURLConnection 有个重大 Bug，调用 close() 函数会影响连接池，导致连接复用失效，所以在 Froyo 之前使用 HttpURLConnection 需要关闭 keepAlive。
另外在 Gingerbread(2.3) HttpURLConnection 默认开启了 gzip 压缩，提高了 HTTPS 的性能，Ice Cream Sandwich(4.0) HttpURLConnection 支持了请求结果缓存。
再加上 HttpURLConnection 本身 API 相对简单，所以对 Android 来说，在 2.3 之后建议使用 HttpURLConnection，之前建议使用 AndroidHttpClient。

User Agent
通过代码我们发现如果是使用 AndroidHttpClient，Volley 还会将请求头中的 User-Agent 字段设置为 App 的${packageName}/${versionCode}，如果异常则使用 “volley/0”，不过这个获取 User-Agent 的操作应该放到 if else 内部更合适。而对于 HttpURLConnection 却没有任何操作，为什么呢？
如果用 Fiddler 或 Charles 对数据抓包我们会发现，我们会发现 HttpURLConnection 默认是有 User-Agent 的，类似：

1

Dalvik/1.6.0 (Linux; U; Android 4.1.1; Google Nexus 4 - 4.1.1 - API 16 - 768x1280_1 Build/JRO03S)

经常用 WebView 的同学会也许会发现似曾相识，是的，WebView 默认的 User-Agent 也是这个。实际在请求发出之前，会检测 User-Agent 是否为空，如果不为空，则加上系统默认 User-Agent。在 Android 2.1 之后，我们可以通过

1

String userAgent = System.getProperty("http.agent");

得到系统默认的 User-Agent，Volley 如果希望自定义 User-Agent，可在自定义 Request 中重写 getHeaders() 函数

1
2
3
4
5
6
7

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
    // self-defined user agent
    Map<String, String> headerMap = new HashMap<String, String>();
    headerMap.put("User-Agent", "android-open-project-analysis/1.0");
    return headerMap;
}

Request.java

代表一个网络请求的抽象类。我们通过构建一个Request类的非抽象子类(StringRequest、JsonRequest、ImageRequest 或自定义)对象，并将其加入到·RequestQueue·中来完成一次网络请求操作。
Volley 支持 8 种 Http 请求方式 GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE, PATCH
Request 类中包含了请求 url，请求请求方式，请求 Header，请求 Body，请求的优先级等信息。

因为是抽象类，子类必须重写的两个方法。

1

abstract protected Response<T> parseNetworkResponse(NetworkResponse response);

子类重写此方法，将网络返回的原生字节内容，转换成合适的类型。此方法会在工作线程中被调用。

1

abstract protected void deliverResponse(T response);

子类重写此方法，将解析成合适类型的内容传递给它们的监听回调。

以下两个方法也经常会被重写

1

public byte[] getBody()

重写此方法，可以构建用于 POST、PUT、PATCH 请求方式的 Body 内容。

1

protected Map<String, String> getParams()

在上面getBody函数没有被重写情况下，此方法的返回值会被 key、value 分别编码后拼装起来转换为字节码作为 Body 内容。

RequestQueue.java

Volley 框架的核心类，将请求 Request 加入到一个运行的RequestQueue中，来完成请求操作。
(1). 主要成员变量

RequestQueue 中维护了两个基于优先级的 Request 队列，缓存请求队列和网络请求队列。
放在缓存请求队列中的 Request，将通过缓存获取数据；放在网络请求队列中的 Request，将通过网络获取数据。

1
2

private final PriorityBlockingQueue<Request<?>> mCacheQueue = new PriorityBlockingQueue<Request<?>>();
private final PriorityBlockingQueue<Request<?>> mNetworkQueue = new PriorityBlockingQueue<Request<?>>();

维护了一个正在进行中，尚未完成的请求集合。

1

private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();

维护了一个等待请求的集合，如果一个请求正在被处理并且可以被缓存，后续的相同 url 的请求，将进入此等待队列。

1

private final Map<String, Queue<Request<?>>> mWaitingRequests = new HashMap<String, Queue<Request<?>>>();

(2). 启动队列

创建出 RequestQueue 以后，调用 start 方法，启动队列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * Starts the dispatchers in this queue.
 */
public void start() {
    stop();  // Make sure any currently running dispatchers are stopped.
    // Create the cache dispatcher and start it.
    mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
    mCacheDispatcher.start();
    // Create network dispatchers (and corresponding threads) up to the pool size.
    for (int i = 0; i < mDispatchers.length; i++) {
        NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                mCache, mDelivery);
        mDispatchers[i] = networkDispatcher;
        networkDispatcher.start();
    }
}

start 方法中，开启一个缓存调度线程CacheDispatcher和 n 个网络调度线程NetworkDispatcher，这里 n 默认为 4，存在优化的余地，比如可以根据 CPU 核数以及网络类型计算更合适的并发数。
缓存调度线程不断的从缓存请求队列中取出 Request 去处理，网络调度线程不断的从网络请求队列中取出 Request 去处理。
(3). 加入请求

1

public <T> Request<T> add(Request<T> request);

流程图如下：

(4). 请求完成

1

void finish(Request<?> request)

Request 请求结束
A首先从正在进行中请求集合mCurrentRequests中移除该请求。
b然后查找请求等待集合mWaitingRequests中是否存在等待的请求，如果存在，则将等待队列移除，并将等待队列所有的请求添加到缓存请求队列中，让缓存请求处理线程CacheDispatcher自动处理。

(5). 请求取消

1
2

public void cancelAll(RequestFilter filter)
public void cancelAll(final Object tag)

取消当前请求集合中所有符合条件的请求。
filter 参数表示可以按照自定义的过滤器过滤需要取消的请求。
tag 表示按照Request.setTag设置好的 tag 取消请求，比如同属于某个 Activity 的。

CacheDispatcher.java

一个线程，用于调度处理走缓存的请求。启动后会不断从缓存请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给ResponseDelivery 去执行后续处理。当结果未缓存过、缓存失效或缓存需要刷新的情况下，该请求都需要重新进入NetworkDispatcher去调度处理。
(1). 成员变量

1
2
3
4

BlockingQueue<Request<?>> mCacheQueue 缓存请求队列
BlockingQueue<Request<?>> mNetworkQueue 网络请求队列
Cache mCache 缓存类，代表了一个可以获取请求结果，存储请求结果的缓存
ResponseDelivery mDelivery 请求结果传递类

(2). 处理流程图

NetworkDispatcher.java

一个线程，用于调度处理走网络的请求。启动后会不断从网络请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给 ResponseDelivery 去执行后续处理，并判断结果是否要进行缓存。
(1). 成员变量

1
2
3
4

BlockingQueue<Request<?>> mQueue 网络请求队列
Network mNetwork 网络类，代表了一个可以执行请求的网络
Cache mCache 缓存类，代表了一个可以获取请求结果，存储请求结果的缓存
ResponseDelivery mDelivery 请求结果传递类，可以传递请求的结果或者错误到调用者

(2). 处理流程图

Cache.java

缓存接口，代表了一个可以获取请求结果，存储请求结果的缓存。
(1). 主要方法：

public Entry get(String key); 通过 key 获取请求的缓存实体
public void put(String key, Entry entry); 存入一个请求的缓存实体
public void remove(String key); 移除指定的缓存实体
public void clear(); 清空缓存
(2). 代表缓存实体的内部类 Entry

成员变量和方法
byte[] data 请求返回的数据（Body 实体）
String etag Http 响应首部中用于缓存新鲜度验证的 ETag
long serverDate Http 响应首部中的响应产生时间
long ttl 缓存的过期时间
long softTtl 缓存的新鲜时间
Map responseHeaders 响应的 Headers
boolean isExpired() 判断缓存是否过期，过期缓存不能继续使用
boolean refreshNeeded() 判断缓存是否新鲜，不新鲜的缓存需要发到服务端做新鲜度的检测

DiskBasedCache.java

继承 Cache 类，基于 Disk 的缓存实现类。
(1). 主要方法：

1
2
3
4
5
6

public synchronized void initialize() 初始化，扫描缓存目录得到所有缓存数据摘要信息放入内存。
public synchronized Entry get(String key) 从缓存中得到数据。先从摘要信息中得到摘要信息，然后读取缓存数据文件得到内容。
public synchronized void put(String key, Entry entry) 将数据存入缓存内。先检查缓存是否会满，会则先删除缓存中部分数据，然后再新建缓存文件。
private void pruneIfNeeded(int neededSpace) 检查是否能再分配 neededSpace 字节的空间，如果不能则删除缓存中部分数据。
public synchronized void clear() 清空缓存。 
public synchronized void remove(String key) 删除缓存中某个元素。

(2). CacheHeader 类
CacheHeader 是缓存文件摘要信息，存储在缓存文件的头部，与上面的Cache.Entry相似。

NoCache.java
继承 Cache 类，不做任何操作的缓存实现类，可将它作为构建RequestQueue的参数以实现一个不带缓存的请求队列。

Network.java
代表网络的接口，处理网络请求。
唯一的方法，用于执行特定请求。

1

public NetworkResponse performRequest(Request<?> request) throws VolleyError;

NetworkResponse.java

Network中方法 performRequest 的返回值，Request的 parseNetworkResponse(…) 方法入参，是 Volley 中用于内部 Response 转换的一级。
封装了网络请求响应的 StatusCode，Headers 和 Body 等。
(1). 成员变量

• int statusCode Http 响应状态码
• byte[] data Body 数据
• Map headers 响应 Headers
• boolean notModified 表示是否为 304 响应
• long networkTimeMs 请求耗时
  (2). Volley 的内部 Response 转换流程图
  
  从上到下表示从得到数据后一步步的处理，箭头旁的注释表示该步处理后的实体类。

BasicNetwork.java

实现 Network，Volley 中默认的网络接口实现类。调用HttpStack处理请求，并将结果转换为可被ResponseDelivery处理的NetworkResponse。
主要实现了以下功能：
(1). 利用 HttpStack 执行网络请求。
(2). 如果 Request 中带有实体信息，如 Etag,Last-Modify 等，则进行缓存新鲜度的验证，并处理 304（Not Modify）响应。
(3). 如果发生超时，认证失败等错误，进行重试操作，直到成功、抛出异常(不满足重试策略等)结束。

HttpStack.java

用于处理 Http 请求，返回请求结果的接口。目前 Volley 中的实现有基于 HttpURLConnection 的 HurlStack 和 基于 Apache HttpClient 的 HttpClientStack。
唯一方法，执行请求

1
2

public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
        throws IOException, AuthFailureError;

执行 Request 代表的请求，第二个参数表示发起请求之前，添加额外的请求 Headers。

HttpClientStack.java
实现 HttpStack 接口，利用 Apache 的 HttpClient 进行各种请求方式的请求。
基本就是 org.apache.http 包下面相关类的常见用法，不做详解，不过与下面 HttpURLConnection 做下对比就能发现 HttpURLConnection 的 API 相对简单的多。

HurlStack.java
实现 HttpStack 接口，利用 Java 的 HttpURLConnection 进行各种请求方式的请求。

Response.java
封装了经过解析后的数据，用于传输。并且有两个内部接口 Listener 和 ErrorListener 分别可表示请求失败和成功后的回调。
Response 的构造函数被私有化，而通过两个函数名更易懂的静态方法构建对象。

ByteArrayPool.java
byte[] 的回收池，用于 byte[] 的回收再利用，减少了内存的分配和回收。 主要通过一个元素长度从小到大排序的ArrayList作为 byte[] 的缓存，另有一个按使用时间先后排序的ArrayList属性用于缓存满时清理元素。

1

public synchronized void returnBuf(byte[] buf)

将用过的 byte[] 回收，根据 byte[] 长度按照从小到大的排序将 byte[] 插入到缓存中合适位置。

1

public synchronized byte[] getBuf(int len)

获取长度不小于 len 的 byte[]，遍历缓存，找出第一个长度大于传入参数len的 byte[]，并返回；如果最终没有合适的 byte[]，new 一个返回。

1

private synchronized void trim()

当缓存的 byte 超过预先设置的大小时，按照先进先出的顺序删除最早的 byte[]。

PoolingByteArrayOutputStream.java
继承 ByteArrayOutputStream，原始 ByteArrayOutputStream 中用于接受写入 bytes 的 buf，每次空间不足时便会 new 更大容量的 byte[]，而 PoolingByteArrayOutputStream 使用了 ByteArrayPool 作为 Byte[] 缓存来减少这种操作，从而提高性能。

HttpHeaderParser.java
Http header 的解析工具类，在 Volley 中主要作用是用于解析 Header 从而判断返回结果是否需要缓存，如果需要返回 Header 中相关信息。
有三个方法

1

public static long parseDateAsEpoch(String dateStr)

解析时间，将 RFC1123 的时间格式，解析成 epoch 时间

1

public static String parseCharset(Map<String, String> headers)

解析编码集，在 Content-Type 首部中获取编码集，如果没有找到，默认返回 ISO-8859-1

1

public static Cache.Entry parseCacheHeaders(NetworkResponse response)

比较重要的方法，通过网络响应中的缓存控制 Header 和 Body 内容，构建缓存实体。如果 Header 的 Cache-Control 字段含有no-cache或no-store表示不缓存，返回 null。

• 根据 Date 首部，获取响应生成时间
• 根据 ETag 首部，获取响应实体标签
• 根据 Cache－Control 和 Expires 首部，计算出缓存的过期时间，和缓存的新鲜度时间

两点需要说明下：
1.没有处理Last-Modify首部，而是处理存储了Date首部，并在后续的新鲜度验证时，使用Date来构建If-Modified-Since。 这与 Http 1.1 的语义有些违背。
2.计算过期时间，Cache－Control 首部优先于 Expires 首部。

RetryPolicy.java
重试策略接口
有三个方法：

1
2
3

public int getCurrentTimeout();//获取当前请求用时（用于 Log）
public int getCurrentRetryCount();//获取已经重试的次数（用于 Log）
public void retry(VolleyError error) throws VolleyError; //确定是否重试，参数为这次异常的具体信息。在请求异常时此接口会被调用，可在此函数实现中抛出传入的异常表示停止重试。

DefaultRetryPolicy.java
实现 RetryPolicy，Volley 默认的重试策略实现类。主要通过在 retry(…) 函数中判断重试次数是否达到上限确定是否继续重试。
其中mCurrentRetryCount变量表示已经重试次数。
mBackoffMultiplier表示每次重试之前的 timeout 该乘以的因子。
mCurrentTimeoutMs变量表示当前重试的 timeout 时间，会以mBackoffMultiplier作为因子累计前几次重试的 timeout。

ResponseDelivery.java
请求结果的传输接口，用于传递请求结果或者请求错误。
有三个方法：

1

public void postResponse(Request<?> request, Response<?> response);

此方法用于传递请求结果，request 和 response 参数分别表示请求信息和返回结果信息。

1

public void postResponse(Request<?> request, Response<?> response, Runnable runnable);

此方法用于传递请求结果，并在完成传递后执行 Runnable。

1

public void postError(Request<?> request, VolleyError error);

此方法用于传输请求错误。

ExecutorDelivery.java
请求结果传输接口具体实现类。
在 Handler 对应线程中传输缓存调度线程或者网络调度线程中产生的请求结果或请求错误，会在请求成功的情况下调用 Request.deliverResponse(…) 函数，失败时调用 Request.deliverError(…) 函数。

StringRequest.java
继承 Request 类,代表了一个返回值为 String 的请求。将网络返回的结果数据解析为 String 类型。通过构造函数的 listener 传参，支持请求成功后的 onResponse(…) 回调。

JsonRequest.java
抽象类，继承自 Request，代表了 body 为 JSON 的请求。提供了构建 JSON 请求参数的方法。

JsonObjectRequest.java
继承自 JsonRequest，将网络返回的结果数据解析为 JSONObject 类型。

sonArrayRequest.java
继承自 JsonRequest，将网络返回的结果数据解析为 JSONArray 类型。

ImageRequest.java
继承 Request 类，代表了一个返回值为 Image 的请求。将网络返回的结果数据解析为 Bitmap 类型。
可以设置图片的最大宽度和最大高度，并计算出合适尺寸返回。每次最多解析一张图片防止 OOM。

ImageLoader.java
封装了 ImageRequst 的方便使用的图片加载工具类。
1.可以设置自定义的ImageCache，可以是内存缓存，也可以是 Disk 缓存，将获取的图片缓存起来，重复利用，减少请求。
2.可以定义图片请求过程中显示的图片和请求失败后显示的图片。
3.相同请求（相同地址，相同大小）只发送一个，可以避免重复请求。

NetworkImageView.java
利用 ImageLoader，可以加载网络图片的 ImageView
有三个公开的方法：

1

public void setDefaultImageResId(int defaultImage)

设置默认图片，加载图片过程中显示。

1

public void setErrorImageResId(int errorImage)

设置错误图片，加载图片失败后显示。

1

public void setImageUrl(String url, ImageLoader imageLoader)

设置网络图片的 Url 和 ImageLoader，将利用这个 ImageLoader 去获取网络图片。
如果有新的图片加载请求，会把这个 ImageView 上旧的加载请求取消。

ClearCacheRequest.java
用于人为清空 Http 缓存的请求。
添加到 RequestQueue 后能很快执行，因为优先级很高，为Priority.IMMEDIATE。并且清空缓存的方法mCache.clear()写在了isCanceled()方法体中，能最早的得到执行。
ClearCacheRequest 的写法不敢苟同，目前看来唯一的好处就是可以将清空缓存操作也当做一个请求。而在isCanceled()中做清空操作本身就造成了歧义，不看源码没人知道在NetworkDispatcher run 方法循环的过程中，isCanceled()这个读操作竟然做了可能造成缓存被清空。只能跟源码的解释一样当做一个 Hack 操作。

Authenticator.java
身份认证接口，用于基本认证或者摘要认证。这个类是 Volley 用于和身份验证打通的接口，比如 OAuth，不过目前的使用不是特别广泛和 Volley 的内部结合也不是特别紧密。

AndroidAuthenticator.java
继承 Authenticator，基于 Android AccountManager 的认证交互实现类。

VolleyLog.java
Volley 的 Log 工具类。

VolleyError.java
Volley 中所有错误异常的父类，继承自 Exception，可通过此类设置和获取 NetworkResponse 或者请求的耗时。

AuthFailureError.java
继承自 VolleyError，代表请求认证失败错误，如 RespondeCode 的 401 和 403。

NetworkError.java
继承自 VolleyError，代表网络错误。

ParseError.java
继承自 VolleyError，代表内容解析错误。

ServerError.java
继承自 VolleyError，代表服务端错误。

TimeoutError.java
继承自 VolleyError，代表请求超时错误。

NoConnectionError.java
继承自 NetworkError，代表无法建立连接错误。

补充说明

1 关于 Http 缓存
Volley 构建了一套相对完整的符合 Http 语义的缓存机制。
优点和特点

• 根据Cache-Control和Expires首部来计算缓存的过期时间。如果两个首部都存在情况下，以Cache-Control为准。
• 利用If-None-Match和If-Modified-Since对过期缓存或者不新鲜缓存，进行请求再验证，并处理 304 响应，更新缓存。
• 默认的缓存实现，将缓存以文件的形式存储在 Disk，程序退出后不会丢失。

不足之处
缓存的再验证方面，在构建If-Modified-Since请求首部时，Volley 使用了服务端响应的Date首部，没有使用Last-Modified首部。整个框架没有使用Last-Modified首部。这与 Http 语义不符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) {
    // If there's no cache entry, we're done.
    if (entry == null) {
        return;
    }
    if (entry.etag != null) {
        headers.put("If-None-Match", entry.etag);
    }
    if (entry.serverDate > 0) {
        Date refTime = new Date(entry.serverDate);
        headers.put("If-Modified-Since", DateUtils.formatDate(refTime));
    }
}

服务端根据请求时通过If-Modified-Since首部传过来的时间，判断资源文件是否在If-Modified-Since时间 以后有改动，如果有改动，返回新的请求结果。如果没有改动，返回 304 not modified。
Last-Modified代表了资源文件的最后修改时间。通常使用这个首部构建If-Modified-Since的时间。
Date代表了响应产生的时间，正常情况下Date时间在Last-Modified时间之后。也就是Date>=Last-Modified。
通过以上原理，既然Date>=Last-Modified。那么我利用Date构建，也是完全正确的。

可能的问题出在服务端的 Http 实现上，如果服务端完全遵守 Http 语义，采用时间比较的方式来验证If-Modified-Since，判断服务器资源文件修改时间是不是在If-Modified-Since之后。那么使用Date完全正确。
可是有的服务端实现不是比较时间，而是直接的判断服务器资源文件修改时间，是否和If-Modified-Since所传时间相等。这样使用Date就不能实现正确的再验证，因为Date的时间总不会和服务器资源文件修改时间相等。

尽管使用Date可能出现的不正确情况，归结于服务端没有正确的实现 Http 语义。
但我还是希望 Volley 也能完全正确的实现 Http 语义，至少同时处理Last-Modified和Date,并且优先使用Last-Modified。

2 Bug
(1). BasicNetwork.performRequest(…)

如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Override
public NetworkResponse performRequest(Request<?> request) throws VolleyError {
    ……
    while (true) {
        ……
        try {
            ……
        } catch (IOException e) {
            int statusCode = 0;
            NetworkResponse networkResponse = null;
            ……
            if (responseContents != null) {
              ……
            } else {
                throw new NetworkError(networkResponse);
            }
        }
    }
}

BasicNetwork.performRequest(…) 最后的throw new NetworkError(networkResponse);应该是throw new NetworkError(e);更合理。

参考文档

• Volley 源码解析
• Volley open source
• Volley Demo

前言

JNI和NDK之前也有接触过，现在工作中有用到这个，所以决定静下心来研究一下，并且整理一下网上的一些资源结合实际的DEMO，写一篇博客。

安装NDK开发环境

这里介绍的是在AS下的安装和使用。Android Studio 1.3 Beta1开始，就支持了NDK。不过使用的是一个全新的实验性的gradle构建工具官方地址。进行配置前请先将Android Studio更新至最新版本，目前最新版本是1.5.1。然后使用Android Studio内置的SDK管理器下载NDK。

打开Project Structure，切到的SDK Location页进行安装:

不知道Project Structure在哪直接search，安装的时候直接点Download，直接下载的安装包就会自动安装并配置。

参考文档

• Android Tools Project Site
• NDK Setup
• Android JNI和NDK学习(01)–搭建NDK开发环境
• Android Studio使用新的Gradle构建工具配置NDK环境
• android jni ndk 开发实践和理论基础