UriMatcher类的学习
UriMatcher类
在ContentProvider中，该类主要用来帮助匹配相对应的URI。
1. 构造函数：创建URI树的根节点
a) Public UriMatcher()：默认根节点编码为-1；
b) Public UriMatcher(int code):code参数表示指定根节点的编码。
2. 方法
a) Public void addURI(String authority, String path, int code)
添加一个用于匹配的URI，当匹配成功时则code。URI可以是精确的字符串，uri中带有*表示可匹配任意text，#表示只能匹配数字。
Authority：用于匹配的域名；
Path：匹配路径，*表示text的占位符，#表示使用数字的占位符；
Code：当使用匹配成功后返回code，值需要大于0，否则抛出IllegalArgument异常。
此方法将authority按照”/”进行拆分，然后将拆分后的每一部分保存到UriMatcher类型的ArrayList中；在添加的时候会判断当前authority是否已经添加过，若已加则break；若未添加过，则判断是否含有”#”则将其标识成1代表域名后面跟随的是数字;”*”标识成2,代表域名后面跟随的是文本；0代表后面没有跟随数据；最后创建一个新的UriMatcher对象添加到集合中。
b) Public int match(Uri uri)
尝试在url中匹配相对应的路径
Uri：指定需要匹配的url；
返回值：在使用addURI时产生的code，若没有匹配则返回-1。
使用uri. getPathSegments()获取uri中各段存入list中，若list size为0或uri的Authority为null则返回默认值（此默认值在new时指定，若为指定则为-1）；
然后遍历ArrayLis<UriMatcher>进行匹配uri。
参考源码：
/* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import android.net.Uri;
public class UriMatcher
{
public static final int NO_MATCH = -1;
/***
*
* Creates the root node of the URI tree.
*
*
*
* @param code
* the code to match for the root URI
*/
public UriMatcher(int code){
mCode = code;
mWhich = -1;
mChildren = new ArrayList<UriMatcher>();
mText = null;
}
private UriMatcher(){
mCode = NO_MATCH;
mWhich = -1;
mChildren = new ArrayList<UriMatcher>();
mText = null;
}
/***
*
* Add a URI to match, and the code to return when this URI is
*
* matched. URI nodes may be exact match string, the token "*"
*
* that matches any text, or the token "#" that matches only
*
* numbers.
*
*
*
* @param authority
* the authority to match
*
* @param path
* the path to match. * may be used as a wild card for
*
* any text, and # may be used as a wild card for numbers.
*
* @param code
* the code that is returned when a URI is matched
*
* against the given components. Must be positive.
*/
public void addURI(String authority, String path, int code){
if (code < 0) {
throw new IllegalArgumentException("code " + code
+ " is invalid: it must be positive");
}
String[] tokens = path != null ? PATH_SPLIT_PATTERN.split(path) : null;
int numTokens = tokens != null ? tokens.length : 0;
UriMatcher node = this;
for (int i = -1; i < numTokens; i++) {
String token = i < 0 ? authority : tokens[i];
ArrayList<UriMatcher> children = node.mChildren;
int numChildren = children.size();
UriMatcher child;
int j;
for (j = 0; j < numChildren; j++) {
child = children.get(j);
if (token.equals(child.mText)) {
node = child;
break;
}
}
if (j == numChildren) {
// Child not found, create it
child = new UriMatcher();
if (token.equals("#")) {
//mWhich=1
child.mWhich = NUMBER;
} else if (token.equals("*")) {
//mWhich=2
child.mWhich = TEXT;
} else {
//mWhich=0
child.mWhich = EXACT;
}
child.mText = token;
node.mChildren.add(child);
//node = child;
node = child;
}
}
//node.mCode = code;
node.mCode = code;
}
static final Pattern PATH_SPLIT_PATTERN = Pattern.compile("/");
/***
*
* Try to match against the path in a url.
*
*
*
* @param uri
* The url whose path we will match against.
*
*
*
* @return The code for the matched node (added using addURI),
*
* or -1 if there is no matched node.
*/
public int match(Uri uri){
final List<String> pathSegments = uri.getPathSegments();
final int li = pathSegments.size();
UriMatcher node = this;
if (li == 0 && uri.getAuthority() == null) {
return this.mCode;
}
for (int i = -1; i < li; i++) {
String u = i < 0 ? uri.getAuthority() : pathSegments.get(i);
ArrayList<UriMatcher> list = node.mChildren;
if (list == null) {
break;
}
node = null;
int lj = list.size();
for (int j = 0; j < lj; j++) {
UriMatcher n = list.get(j);
which_switch:
switch (n.mWhich) {
case EXACT:
if (n.mText.equals(u)) {
node = n;
}
break;
case NUMBER:
int lk = u.length();
for (int k = 0; k < lk; k++) {
char c = u.charAt(k);
if (c < '0' || c > '9') {
break which_switch;
}
}
node = n;
break;
case TEXT:
node = n;
break;
}
if (node != null) {
break;
}
}
if (node == null) {
return NO_MATCH;
}
}
return node.mCode;
}
private static final int EXACT = 0;
private static final int NUMBER = 1;
private static final int TEXT = 2;
private int mCode;
private int mWhich;
private String mText;
private final ArrayList<UriMatcher> mChildren;
}