最近公司内项目，需要开发接口给ios,android客户端去调用。因此，做了一些思考，主要是关于如何更好的定义接口以及联调。
RESTFul接口作为一个通行的标准，当然是优先使用的。项目都是基于Spring的，因此采用的是Spring MVC.
作为一个技术人员，写文档是一大令人头疼的事情。况且即使把文档写好了，也可能导致在以后的修修补补中，导致不一致的情况。
因此，考虑采用文档自动生成的方式。最终选用了Swagger
作为技术负责人
Spring MVC本身对Restful支持非常好。它的@RequestMapping、@RequestParam、@PathVariable、@ResponseBody注解很好的支持了REST。18.2 Creating RESTful services
@RequestMappingSpring uses the @RequestMapping method annotation to define the URI Template for the request. 类似于struts的action-mapping。 可以指定POST或者GET。
@PathVariableThe @PathVariable method parameter annotation is used to indicate that a method parameter should be bound to the value of a URI template variable. 用于抽取URL中的信息作为参数。（注意，不包括请求字符串，那是@RequestParam做的事情。）
@RequestMapping("/owners/{ownerId}", method=RequestMethod.GET)
public String findOwner(@PathVariable String ownerId, Model model) {
// ...
}
如果变量名与pathVariable名不一致，那么需要指定：
@RequestMapping("/owners/{ownerId}", method=RequestMethod.GET)
public String findOwner(@PathVariable("ownerId") String theOwner, Model model) {
// implementation omitted
}
Tip
method parameters that are decorated with the @PathVariable annotation can be of any simple type such as int, long, Date… Spring automatically converts to the appropriate type and throws a TypeMismatchException if the type is not correct.
@RequestParam官方文档居然没有对这个注解进行说明，估计是遗漏了（真不应该啊）。这个注解跟@PathVariable功能差不多，只是参数值的来源不一样而已。它的取值来源是请求参数（querystring或者post表单字段）。
对了，因为它的来源可以是POST字段，所以它支持更丰富和复杂的类型信息。比如文件对象:
@RequestMapping("/imageUpload")
public String processImageUpload(@RequestParam("name") String name,
@RequestParam("description") String description,
@RequestParam("image") MultipartFile image) throws IOException {
this.imageDatabase.storeImage(name, image.getInputStream(),
(int) image.getSize(), description);
return "redirect:imageList";
}
还可以设置defaultValue：
@RequestMapping("/imageUpload")
public String processImageUpload(@RequestParam(value="name", defaultValue="arganzheng") String name,
@RequestParam("description") String description,
@RequestParam("image") MultipartFile image) throws IOException {
this.imageDatabase.storeImage(name, image.getInputStream(),
(int) image.getSize(), description);
return "redirect:imageList";
}
@RequestBody和@ResponseBody这两个注解其实用到了Spring的一个非常灵活的设计——HttpMessageConverter 18.3.2 HTTP Message Conversion
与@RequestParam不同，@RequestBody和@ResponseBody是针对整个HTTP请求或者返回消息的。前者只是针对HTTP请求消息中的一个 name=value 键值对(名称很贴切)。
HtppMessageConverter负责将HTTP请求消息(HTTP request message)转化为对象，或者将对象转化为HTTP响应体(HTTP response body)。
public interface HttpMessageConverter<T> {
// Indicate whether the given class is supported by this converter.
boolean supports(Class<? extends T> clazz);
// Return the list of MediaType objects supported by this converter.
List<MediaType> getSupportedMediaTypes();
// Read an object of the given type form the given input message, and returns it.
T read(Class<T> clazz, HttpInputMessage inputMessage) throws IOException,
HttpMessageNotReadableException;
// Write an given object to the given output message.
void write(T t, HttpOutputMessage outputMessage) throws IOException,
HttpMessageNotWritableException;
}
Spring MVC对HttpMessageConverter有多种默认实现，基本上不需要自己再自定义HttpMessageConverter
>
然而对于RESTful应用，用的最多的当然是MappingJacksonHttpMessageConverter。
但是MappingJacksonHttpMessageConverter不是默认的HttpMessageConverter：
public class AnnotationMethodHandlerAdapter extends WebContentGenerator
implements HandlerAdapter, Ordered, BeanFactoryAware {
...
public AnnotationMethodHandlerAdapter() {
// no restriction of HTTP methods by default
super(false);
// See SPR-7316
StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
stringHttpMessageConverter.setWriteAcceptCharset(false);
this.messageConverters = new HttpMessageConverter[]{new ByteArrayHttpMessageConverter(), stringHttpMessageConverter,
new SourceHttpMessageConverter(), new XmlAwareFormHttpMessageConverter()};
}
}
如上：默认的HttpMessageConverter是ByteArrayHttpMessageConverter、stringHttpMessageConverter、SourceHttpMessageConverter和XmlAwareFormHttpMessageConverter转换器。所以需要配置一下：
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>text/plain;charset=GBK</value>
</list>
</property>
</bean>
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
</list>
</property>
</bean>
配置好了之后，就可以享受@Requestbody和@ResponseBody对JONS转换的便利之处了：
@RequestMapping(value = "api", method = RequestMethod.POST)
@ResponseBody
public boolean addApi(@RequestBody
Api api, @RequestParam(value = "afterApiId", required = false)
Integer afterApiId) {
Integer id = apiMetadataService.addApi(api);
return id > 0;
}
@RequestMapping(value = "api/{apiId}", method = RequestMethod.GET)
@ResponseBody
public Api getApi(@PathVariable("apiId")
int apiId) {
return apiMetadataService.getApi(apiId, Version.primary);
}
一般情况下我们是不需要自定义HttpMessageConverter，不过对于Restful应用，有时候我们需要返回jsonp数据：
package me.arganzheng.study.springmvc.util;
import java.io.IOException;
import java.io.PrintStream;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.http.converter.json.MappingJacksonHttpMessageConverter;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
public class MappingJsonpHttpMessageConverter extends MappingJacksonHttpMessageConverter {
public MappingJsonpHttpMessageConverter() {
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setSerializationConfig(objectMapper.getSerializationConfig().withSerializationInclusion(Inclusion.NON_NULL));
setObjectMapper(objectMapper);
}
@Override
protected void writeInternal(Object o, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
String jsonpCallback = null;
RequestAttributes reqAttrs = RequestContextHolder.currentRequestAttributes();
if(reqAttrs instanceof ServletRequestAttributes){
jsonpCallback = ((ServletRequestAttributes)reqAttrs).getRequest().getParameter("jsonpCallback");
}
if(jsonpCallback != null){
new PrintStream(outputMessage.getBody()).print(jsonpCallback + "(");
}
super.writeInternal(o, outputMessage);
if(jsonpCallback != null){
new PrintStream(outputMessage.getBody()).println(");");
}
}
}
如果请求的参数中带有jsonpCallback，那么会返回jsonp格式数据。比如：
http://open.buy.qq.com/meta/api/1.xhtml?jsonpCallback=clientFunction。
会返回clientFunction(…);
@CookieValue@CookieValue用于将请求的Cookie数据映射到功能处理方法的参数上。
public String test(@CookieValue(value="JSESSIONID", defaultValue="") String sessionId){
...
}
如上配置将自动将JSESSIONID值入参到sessionId参数上，defaultValue表示Cookie中没有JSESSIONID时默认为空。
public String test2(@CookieValue(value="JSESSIONID", defaultValue="") Cookie sessionId){
...
}
传入参数类型也可以是javax.servlet.http.Cookie类型。
TIPS 如果是使用cookies值来保持回话状态的话，推荐使用Spring的Bean Scopes机制，具体参见笔者的另一篇文章：Spring的Bean Scopes。非常方便。
@RequestHeader@RequestHeader用于将请求的头信息区数据映射到功能处理方法的参数上。
@RequestMapping(value="/header")
public String test(
@RequestHeader("User-Agent") String userAgent,
@RequestHeader(value="Accept") String[] accepts)
如上配置将自动将请求头“User-Agent”值入参到userAgent参数上，并将“Accept”请求头值入参到accepts参数上。
对于Restful服务，一个资源往往有多种表现形式，比如最常见的就是返回xml和json格式数据，还有就是RSS和ATOM。怎样让客户端告诉Restful服务，我希望得到什么样表现形式的资源呢？
一般来说client可以通过以下三者方式来通知Server它希望拿到的资源格式：
application/pdf则表示期望收到pdf格式资源。这其实就是Spring MVC默认的三个ContentNegotiationStrategy，即所谓的PPA Strategy（path extension, then parameter, then Accept header) ，顺序也是先path extension，然后parameter(默认是format参数)，然后才是accept头。
Spring提供了ContentNegotiatingViewResolver来解决这个问题：
public class ContentNegotiatingViewResolver extends WebApplicationObjectSupport implements ViewResolver, Ordered {
private static final Log logger = LogFactory.getLog(ContentNegotiatingViewResolver.class);
private static final String ACCEPT_HEADER = "Accept";
private static final boolean jafPresent =
ClassUtils.isPresent("javax.activation.FileTypeMap", ContentNegotiatingViewResolver.class.getClassLoader());
private static final UrlPathHelper urlPathHelper = new UrlPathHelper();
private int order = Ordered.HIGHEST_PRECEDENCE;
private boolean favorPathExtension = true;
private boolean favorParameter = false;
private String parameterName = "format";
private boolean useNotAcceptableStatusCode = false;
private boolean ignoreAcceptHeader = false;
private boolean useJaf = true;
private ConcurrentMap<String, MediaType> mediaTypes = new ConcurrentHashMap<String, MediaType>();
private List<View> defaultViews;
private MediaType defaultContentType;
private List<ViewResolver> viewResolvers;
// ignore some setter and getter...
public void setMediaTypes(Map<String, String> mediaTypes) {
Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
for (Map.Entry<String, String> entry : mediaTypes.entrySet()) {
String extension = entry.getKey().toLowerCase(Locale.ENGLISH);
MediaType mediaType = MediaType.parseMediaType(entry.getValue());
this.mediaTypes.put(extension, mediaType);
}
}
public void setDefaultViews(List<View> defaultViews) {
this.defaultViews = defaultViews;
}
public void setDefaultContentType(MediaType defaultContentType) {
this.defaultContentType = defaultContentType;
}
public void setViewResolvers(List<ViewResolver> viewResolvers) {
this.viewResolvers = viewResolvers;
}
@Override
protected void initServletContext(ServletContext servletContext) {
if (this.viewResolvers == null) {
Map<String, ViewResolver> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(getApplicationContext(), ViewResolver.class);
this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.size());
for (ViewResolver viewResolver : matchingBeans.values()) {
if (this != viewResolver) {
this.viewResolvers.add(viewResolver);
}
}
}
if (this.viewResolvers.isEmpty()) {
logger.warn("Did not find any ViewResolvers to delegate to; please configure them using the " +
"'viewResolvers' property on the ContentNegotiatingViewResolver");
}
OrderComparator.sort(this.viewResolvers);
}
public View resolveViewName(String viewName, Locale locale) throws Exception {
RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
Assert.isInstanceOf(ServletRequestAttributes.class, attrs);
List<MediaType> requestedMediaTypes = getMediaTypes(((ServletRequestAttributes) attrs).getRequest());
if (requestedMediaTypes != null) {
List<View> candidateViews = getCandidateViews(viewName, locale, requestedMediaTypes);
View bestView = getBestView(candidateViews, requestedMediaTypes);
if (bestView != null) {
return bestView;
}
}
if (this.useNotAcceptableStatusCode) {
if (logger.isDebugEnabled()) {
logger.debug("No acceptable view found; returning 406 (Not Acceptable) status code");
}
return NOT_ACCEPTABLE_VIEW;
}
else {
logger.debug("No acceptable view found; returning null");
return null;
}
}
protected List<MediaType> getMediaTypes(HttpServletRequest request) {
if (this.favorPathExtension) {
String requestUri = urlPathHelper.getRequestUri(request);
String filename = WebUtils.extractFullFilenameFromUrlPath(requestUri);
MediaType mediaType = getMediaTypeFromFilename(filename);
if (mediaType != null) {
if (logger.isDebugEnabled()) {
logger.debug("Requested media type is '" + mediaType + "' (based on filename '" + filename + "')");
}
return Collections.singletonList(mediaType);
}
}
if (this.favorParameter) {
if (request.getParameter(this.parameterName) != null) {
String parameterValue = request.getParameter(this.parameterName);
MediaType mediaType = getMediaTypeFromParameter(parameterValue);
if (mediaType != null) {
if (logger.isDebugEnabled()) {
logger.debug("Requested media type is '" + mediaType + "' (based on parameter '" +
this.parameterName + "'='" + parameterValue + "')");
}
return Collections.singletonList(mediaType);
}
}
}
if (!this.ignoreAcceptHeader) {
String acceptHeader = request.getHeader(ACCEPT_HEADER);
if (StringUtils.hasText(acceptHeader)) {
try {
List<MediaType> mediaTypes = MediaType.parseMediaTypes(acceptHeader);
MediaType.sortByQualityValue(mediaTypes);
if (logger.isDebugEnabled()) {
logger.debug("Requested media types are " + mediaTypes + " (based on Accept header)");
}
return mediaTypes;
}
catch (IllegalArgumentException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Could not parse accept header [" + acceptHeader + "]: " + ex.getMessage());
}
return null;
}
}
}
if (this.defaultContentType != null) {
if (logger.isDebugEnabled()) {
logger.debug("Requested media types is " + this.defaultContentType +
" (based on defaultContentType property)");
}
return Collections.singletonList(this.defaultContentType);
}
else {
return Collections.emptyList();
}
}
protected MediaType getMediaTypeFromFilename(String filename) {
String extension = StringUtils.getFilenameExtension(filename);
if (!StringUtils.hasText(extension)) {
return null;
}
extension = extension.toLowerCase(Locale.ENGLISH);
MediaType mediaType = this.mediaTypes.get(extension);
if (mediaType == null && this.useJaf && jafPresent) {
mediaType = ActivationMediaTypeFactory.getMediaType(filename);
if (mediaType != null) {
this.mediaTypes.putIfAbsent(extension, mediaType);
}
}
return mediaType;
}
protected MediaType getMediaTypeFromParameter(String parameterValue) {
return this.mediaTypes.get(parameterValue.toLowerCase(Locale.ENGLISH));
}
private List<View> getCandidateViews(String viewName, Locale locale, List<MediaType> requestedMediaTypes)
throws Exception {
List<View> candidateViews = new ArrayList<View>();
for (ViewResolver viewResolver : this.viewResolvers) {
View view = viewResolver.resolveViewName(viewName, locale);
if (view != null) {
candidateViews.add(view);
}
for (MediaType requestedMediaType : requestedMediaTypes) {
List<String> extensions = getExtensionsForMediaType(requestedMediaType);
for (String extension : extensions) {
String viewNameWithExtension = viewName + "." + extension;
view = viewResolver.resolveViewName(viewNameWithExtension, locale);
if (view != null) {
candidateViews.add(view);
}
}
}
}
if (!CollectionUtils.isEmpty(this.defaultViews)) {
candidateViews.addAll(this.defaultViews);
}
return candidateViews;
}
private List<String> getExtensionsForMediaType(MediaType requestedMediaType) {
List<String> result = new ArrayList<String>();
for (Entry<String, MediaType> entry : this.mediaTypes.entrySet()) {
if (requestedMediaType.includes(entry.getValue())) {
result.add(entry.getKey());
}
}
return result;
}
private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes) {
MediaType bestRequestedMediaType = null;
View bestView = null;
for (MediaType requestedMediaType : requestedMediaTypes) {
for (View candidateView : candidateViews) {
if (StringUtils.hasText(candidateView.getContentType())) {
MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
if (requestedMediaType.includes(candidateContentType)) {
bestRequestedMediaType = requestedMediaType;
bestView = candidateView;
break;
}
}
}
if (bestView != null) {
if (logger.isDebugEnabled()) {
logger.debug("Returning [" + bestView + "] based on requested media type '" +
bestRequestedMediaType + "'");
}
break;
}
}
return bestView;
}
...
}
可以看到ContentNegotiationViewResolver有点类似于ComposeCommand（参见Command模式 by GoF），它本身实现了ViewResolver接口，所以它是一个ViewResolver，但是它组合了一堆的ViewResolver，根据一定的规则（前面讨论的content negotiation）将视图请求转发给最match的ViewResolver。
所以关键在两点：
ContentNegotiationStrategy)This view resolver uses the requested media type to select a suitable View for a request. This media type is determined by using the following criteria:
- If the requested path has a file extension and if the setFavorPathExtension(boolean) property is true, the mediaTypes property is inspected for a matching media type.
- If the request contains a parameter defining the extension and if the setFavorParameter(boolean) property is true, the mediaTypes property is inspected for a matching media type. The default name of the parameter is format and it can be configured using the parameterName property.
- If there is no match in the mediaTypes property and if the Java Activation Framework (JAF) is both enabled and present on the classpath, FileTypeMap.getContentType(String) is used instead.
- If the previous steps did not result in a media type, and ignoreAcceptHeader is false, the request Accept header is used.
Once the requested media type has been determined, this resolver queries each delegate view resolver for a View and determines if the requested media type is compatible with the view’s content type). The most compatible view is returned.
这个就是上面提到的Spring MVC默认的三个ContentNegotiationStrategy，即所谓的PPA Strategy（path extension, then parameter, then Accept header) ，顺序也是先path extension，然后parameter(默认是format参数)，然后才是accept头。
关于ContentNegotiationStrategy，可以参考笔者的另一篇文章：content negotiation using spring mvc。有具体的实际案例。
The ContentNegotiatingViewResolver does not resolve views itself, but delegates to other ViewResolvers. By default, these other view resolvers are picked up automatically from the application context, though they can also be set explicitly by using the viewResolvers property. Note that in order for this view resolver to work properly, the order property needs to be set to a higher precedence than the others (the default is Ordered.HIGHEST_PRECEDENCE.)
说明：即
private List<ViewResolver> viewResolvers;属性。需要注意的是Spring会自动加载和注册所有其他的ViewResolver到ContentNegotiationViewResolover的viewResolvers属性。但是你需要告诉Spring MVC，你希望controller返回的view都是由ContentNegotiationViewResolover来解析，而不是其他定义的ViewResolver。这是通过order配置项来决定。你应该给ContentNegotiationViewResolover配置最高的order(其实默认就是最高了)。Additionally, this view resolver exposes the defaultViews property, allowing you to override the views provided by the view resolvers. Note that these default views are offered as candicates, and still need have the content type requested (via file extension, parameter, or Accept header, described above). You can also set the default content type directly, which will be returned when the other mechanisms (Accept header, file extension or parameter) do not result in a match.
说明：即
private List<View> defaultViews;和private MediaType defaultContentType;属性。
关于ContentNegotiatingViewResolver，下面两篇文章都不错，值得一看：
viewResolvers配置。ViewResolvers配置。defaultViews配置。注意：@ResponseBody是为了单个View准备的，即它只能转换成一种格式，对于ContentNegotiatingViewResolver，需要多个SingleViewResolver来接收。
Spring MVC不仅大大的简化了服务端RESTful服务的开发和开放，还提供了一些辅助类来方便客户端调用REST服务。
以前Client如果要调用REST服务，一般是使用HttpClient来发送HTTP请求：
String uri = "http://example.com/hotels/1/bookings";
PostMethod post = new PostMethod(uri);
String request = // create booking request content
post.setRequestEntity(new StringRequestEntity(request));
httpClient.executeMethod(post);
if (HttpStatus.SC_CREATED == post.getStatusCode()) {
Header location = post.getRequestHeader("Location");
if (location != null) {
System.out.println("Created new booking at :" + location.getValue());
}
}
太过底层，而且代码比较冗长，一般都要手动封装一下（即类似于SDK，封装了签名和HTTP发送和接受细节）。我们看一下Spring MVC是怎么解决这个问题的。
RestTemplate是client-site HTTP access的核心类。正如它的名称所示，RestTemplate非常类似于JdbcTemplate, JmsTemplate等XXXTemplate。这意味着RestTemplate是线程安全的并且可以通过callback来定制它的行为。
TIPS Spring提供的Template类非常灵活和好用，种类也很丰富。当你需要做一些事情的时候可以先考虑一下有没有相应的template可以用。
RestTemplate默认使用java.net包下的基础类来创建HTTP请求。你可以实现ClientHttpRequestFactory接口，提供你自己的Http请求工厂类。Spring提供了CommonsClientHttpRequestFactory，这个工厂类使用Jakarta Commons HttpClient来创建HTTP请求。这样就可以使用HttpClient提供的认证和链接池功能了。
HTTP Method RestTemplate Method
- DELETE delete(String url, String… urlVariables)
- GET getForObject(String url, Class
responseType, String… urlVariables) - HEAD headForHeaders(String url, String… urlVariables)
- OPTIONS optionsForAllow(String url, String… urlVariables)
- POST postForLocation(String url, Object request, String… urlVariables)
- PUT put(String url, Object request, String…urlVariables)
- ANY exchange(String, HttpMethod, HttpEntity, Class, Object…)
execute(String, HttpMethod, RequestCallback, ResponseExtractor, Object...)
方法名称很有规律，都是这个pattern——${HTTP Method}${WhatIsReturne}。例如getForObject() will perform a GET, convert the HTTP response into an object type of your choice, and returns that object. postForLocation will do a POST, converting the given object into a HTTP request, and returns the response HTTP Location header where the newly created object can be found. As you can see, these methods try to enforce REST best practices.
其中getForObject()、postForLocation()和put()方法接收或者返回的参数通过HttpMessageConverter来转换为Http Request或者Http Response。这点与前面介绍服务端RESTful的@RequestBody和@ResponseBody是一样的，Spring MVC默认会注册常用的Converter，你也可以自定义。
另外，每个方法的第一个参数都是一个url string，但是这个URI可以带有变量(还记得@PathVariable吗:)哦。参数有两种方式绑定值：
作为字符串变量数组(String variable arguments array)
String result = restTemplate.getForObject("http://example.com/hotels/{hotel}/bookings/{booking}", String.class, "42", "21");
会转换为一个对http://example.com/hotels/42/bookings/21的GET请求。
或者Map对象(Map)
The map variant expands the template based on variable name, and is therefore more useful when using many variables, or when a single variable is used multiple times.
Map<String, String> vars = new HashMap<String, String>();
vars.put("hotel", "42");
vars.put("booking", "21");
String result = restTemplate.getForObject("http://example.com/hotels/{hotel}/bookings/{booking}", String.class, vars);
会转换为一个对`http://example.com/hotels/42/rooms/42`的GET请求。
关于RestTemplate使用的具体例子可以参考这篇文章
REST IN SPRING 3: RESTTEMPLATE。写的非常好，强烈推荐！
在开发功能模块之前，应该先把URL设计好。比查对 消息 这个资源的操作URL可以这么设计：
http://arganzheng.me/messages/show/123456
http://arganzheng.me/messages/preview/123456
http://arganzheng.me/messages/delete/123456
http://arganzheng.me/messages/new
http://arganzheng.me/message/update
说明：可以看到我们的URL中有动作在里面，事实上纯粹的RESTful URL是把动作隐含在HTTP头中：GET、PUT、DELETE、POST。。不过这样对用户编码有要求，这个相对简单点。
要支持这种URL，web.xml需要这么配置：
<!-- REST servlet-mapping -->
<servlet-mapping>
<servlet-name>DispatcherServlet<srvlet-name>
<url-pattern>/</url-pattern>
<srvlet-mapping>
但是这样的话有个问题，就是静态文件也被mapping了，会导致找不到资源。Spring提供了一个resources配置项支持静态文件的处理16.14.5 Configuring Serving of Resources：
<!-- Forwards requests to the "/" resource to the "welcome" view -->
<mvc:view-controller path="/" view-name="index"/>
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources/ directory -->
<mvc:resources mapping="/resources/**" location="/resources/" />
<!-- 注意：配置了mvc:resources就必须配置这个选项，否则handler mapping都失效了
@see http://stackoverflow.com/questions/7910845/the-handler-mapping-from-the-mvcresource-override-other-mappings-which-defined
-->
<mvc:annotation-driven />
这样所有请求：http://arganzheng.me/resources/**会映射到webapp下的resources目录，而不是找我们的controller处理。
但是有个奇怪的问题，就是配置这个之后，原来动态东西就不能访问到了，提示找不到对应的handler，解决方案是增加一个<mvc:annotation-driven />配置。具体参见The handler mapping from the mvc:resource override other mappings which defined with annotation。
另外，静态的html页面一般不放在resources路面下，而是直接在根目录下，比如：http://arganzheng.me/index.html或者http://arganzheng.me/404.html。所以应该在web.xml中在配置一个url-mapping规则：
<!-- 避免被Spring DispatcherServlet接管 -->
<servlet-mapping>
<servlet-name>default<srvlet-name>
<url-pattern>*.html</url-pattern>
<srvlet-mapping>
最近常有数据库和网络设备升级和搬迁等事情，而各个应用都是基于数据库连接池做的，大部分都是基于C3P0，数据库或网络状况的变动都会导致客户端连接池中的connection失效，如何剔除这些blocked connection就和C3P0的各个配置息息相关。
####1）C3P0容错和自动重连与以下配置参数有关：
breakAfterAcquireFailure ：true表示pool向数据库请求连接失败后标记整个pool为block并close，就算后端数据库恢复正常也不进行重连，客户端对pool的请求都拒绝掉。false表示不会标记 pool为block，新的请求都会尝试去数据库请求connection。默认为false。因此，如果想让数据库和网络故障恢复之后，pool能继续请求正常资源必须把此项配置设为false
当使用Solr来构建搜索引擎的时候，你可能经常会遇到这样的场景：你有一个同义词列表，并且你想用户查询也能够命中到同义词。听起来很简单不是吗？为什么搜索“dog”的时候，不能命中包含“hound(猎犬)”或者“pooch(狗)”的文档呢？甚至包含“Rover(流浪者)”和“canis familiaris(犬)”?
叫Rover或者其他名字，可能只是为了让小狗听起来很可爱。
事实证明，Solr的同义词扩展没有你想象的那么简单。但是我们有很多好的方法来搬石头砸自己的脚。
###软件版本
###Sogou语料库处理
下载后的预料库，文档都是GB2312编码的。虽然mahout支持不同的编码方式，但是为了更方便的放到Hadoop里跑，还是建议先转化为标准的UTF-8.
语料库解压后，是sogou目录。我们执行以下代码进行转化，转换后的在utf/sogou目录下：
find sogou -type d -exec mkdir -p utf/{} \;
find sogou -type f -exec iconv -f GB2312 -t UTF-8 {} -o utf/{} \;
###使用mahout生成sequence file
进入utf/sogou目录，执行：
mahout seqdirectory -i sogou -o sogou-seq -c UTF-8 -ow
生成的sequence file存放在sogou-seq目录内。
可以通过seqdumper命令查看：
在工作中，经常会遇到使用操作系统不一样的环境，从而导致在不同环境下的文件编辑的编码是不一样的，Windows默认是GBK编码格式，Linux默认是UTF-8的格式，这样就会出现把GBK编码的文件拷贝到Linux下出现乱码情况，很是让人头疼，下面给大家介绍下GBK->UTF-8文件编码批量转换。
Linux命令-enca 查看文件的编码
Enca语法
Usage: enca [-L LANGUAGE] [OPTION]... [FILE]...
enconv [-L LANGUAGE] [OPTION]... [FILE]...
Detect encoding of text files and convert them if required.
Enca用法
$ enca -L zh_CN file 检查文件的编码
$ enca -L zh_CN -x UTF-8 file 将文件编码转换为"UTF-8"编码
$ enca -L zh_CN -x UTF-8 file1 file2 如果不想覆盖原文件可以这样
除了有检查文件编码的功能以外，”enca”还有一个好处就是如果文件本来就是你要转换的那种编码，它不会报错，还是会print出结果来， 而”iconv”则会报错。这对于脚本编写是比较方便的事情。
###安装需求
确保可以ssh到localhost，并且不需要密码
ssh localhost
如果报错，connect to host localhost port 22:Connection refused。说明ssh-server未安装或者未启动。
运行：
ps -ef | grep sshd
查看sshd进程是否存在，如果不存在，说明没有安装。那么进行安装。
sudo apt-get install openssh-server
然后再执行ssh localhost,如果不能无密码登陆，需要做一下操作：
ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa
cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys
Hadoop软件供应商Cloudera去年收购了一家总部位于伦敦的新兴企业Myrrix——但在此之后无论是买家还是卖家在机器学习技术方面都开始归于沉寂。不过无论如何，Myrrix公司的技术方案加上其创始人Sean Owen可能已经足以值回票价。
Owen目前的正式头衔为数据科学部门主管，目前他正专注投身于名为Oryx的开源机器学习项目当中。(Oryx意思是剑羚、属于非洲羚羊的一类分支，Cloudera在售的产品中则有一款名为Impala——即黑斑羚)。Oryx的开发意图在于帮助Hadoop用户构建机器学习模式并将其加以部署，这样我们就能够以实时方式查询并获取其结果——例如将其作为垃圾邮件过滤器或者推荐引擎的组成部分。在理想状态下，Oryx能够在接纳输入数据流的同时对自身进行更新。
solr 查询参数中有tie这样的一个参数，下面是它的官方解释：
The tie (Tie Breaker) Parameter
The tie parameter specifies a float value (which should be something much less than 1) to use as tiebreaker in DisMax queries.
When a term from the user’s input is tested against multiple fields, more than one field may match. If so, each field will generate a different score based on how common that word is in that field (for each document relative to all other documents). The tie parameter lets you control how much the final score of the query will be influenced by the scores of the lower scoring fields compared to the highest scoring field.
A value of “0.0” makes the query a pure “disjunction max query”: that is, only the maximum scoring subquery contributes to the final score. A value of “1.0” makes the query a pure “disjunction sum query” where it doesn’t matter what the maximum scoring sub query is, because the final score will be the sum of the subquery scores. Typically a low value, such as 0.1, is useful.
读起来比较令人费解。
简单解释就是：
这个tie参数通常是一个小于1的浮点数，用于defType=disMax的solr查询。当查询命中多个field的时候，最终的score获得多少将由这个tie参数来进行调节。比如命中了field1，field2这2个field。
如果field1.score= 10，field2.score=3。那么 score = 10 + tie * 3.
也就是说，如果tie=1的话，最终的score就相当于多个字段得分总和;如果tie=0,那么最终的score就相当于是命中的field的最高分。
通常情况下呢，官方推荐tie=0.1。
##Java7新特性
###Java7语法特性
根据JSR 334，Java7添加了数个语法方面的新特性：
####1. switch可以消化String
比如：
public static void switchString(String s){
switch (s){
case "db": ...
case "wls": ...
case "ibm": ...
case "soa": ...
case "fa": ...
default: ...
}
}