• 当我们需要读取一个文件并将其转换为字符串时，可以使用 InputStreamReader 将字节输入流转换为字符输入流，然后使用 BufferedReader 的 readLine() 方法读取文件中的每一行，最后使用 StringBuilder 将读取到的每一行拼接起来。
• 同样的，当我们需要将字符串写入文件时，可以使用 OutputStreamWriter 将字符输出流转换为字节输出流，然后使用 OutputStreamWriter 的 write() 方法将字符串写入文件。

附二：Spring 中的适配器模式

1，Spring AOP 的适配器模式

public interface AdvisorAdapter {
  boolean supportsAdvice(Advice var1);

  MethodInterceptor getInterceptor(Advisor var1);
}

（2）AdvisorAdapter 有三个具体实现类：MethodBeforeAdviceAdapter、AfterReturningAdviceAdapter 和 ThrowsAdviceAdapter。比如 MethodBeforeAdviceAdapter 代码如下：

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
  MethodBeforeAdviceAdapter() {
  }

  public boolean supportsAdvice(Advice advice) {
    return advice instanceof MethodBeforeAdvice;
  }

  public MethodInterceptor getInterceptor(Advisor advisor) {
    MethodBeforeAdvice advice = (MethodBeforeAdvice)advisor.getAdvice();
    return new MethodBeforeAdviceInterceptor(advice);
  }
}

（3）Advice 常用的类型有：BeforeAdvice（目标方法调用前,前置通知）、AfterAdvice（目标方法调用后,后置通知）、AfterReturningAdvice（目标方法执行结束后，return 之前）等等。每个类型 Advice（通知）都有对应的拦器：MethodBeforeAdviceInterceptor、AfterReturningAdviceAdapter、AfterReturningAdviceInterceptor。比如 MethodBeforeAdviceInterceptor 代码如下：

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
  private final MethodBeforeAdvice advice;

  public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
    Assert.notNull(advice, "Advice must not be null");
    this.advice = advice;
  }

  public Object invoke(MethodInvocation mi) throws Throwable {
    this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
    return mi.proceed();
  }
}

（4）Spring 预定义的通知要通过对应的适配器，适配成 MethodInterceptor 接口（方法拦截器）类型的对象，才能被添加到代理链中，从而实现对目标方法的增强。

2，Spring MVC 中使用的适配器模式

if(mappedHandler.getHandler() instanceof AbstractUrlViewController){  
   ((AbstractUrlViewController)mappedHandler.getHandler()).xxx  
}else if(mappedHandler.getHandler() instanceof XXX){  
    ...  
}else if(...){  
   ...  

（5）SringMVC 的做法是，首先定义一个处理器适配器接口 HandlerAdapter：

public interface HandlerAdapter {
  boolean supports(Object var1);

  @Nullable
  ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;

  long getLastModified(HttpServletRequest var1, Object var2);
}

（6）然后具体的处理器适配器会根据不同的需求来实现 HandlerAdapter 接口，并在处理请求时调用对应的处理器进行处理。比如 SimpleControllerHandlerAdapter 这个适配器代码如下：

public class SimpleControllerHandlerAdapter implements HandlerAdapter {
  public SimpleControllerHandlerAdapter() {
  }

  public boolean supports(Object handler) {
    return handler instanceof Controller;
  }

  @Nullable
  public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    return ((Controller)handler).handleRequest(request, response);
  }

  public long getLastModified(HttpServletRequest request, Object handler) {
    return handler instanceof LastModified ? ((LastModified)handler).getLastModified(request) : -1L;
  }
}

（7）当 Spring 容器启动后，会将所有定义好的适配器对象存放在一个 List 集合中，当一个请求来临时，DispatcherServlet 会通过 handler 的类型找到对应适配器，然后就可以统一通过适配器的 handle() 方法来调用处理器中的用于处理请求的方法。

public class DispatcherServlet extends FrameworkServlet {
    private List<HandlerAdapter> handlerAdapters;
    
    //初始化handlerAdapters
    private void initHandlerAdapters(ApplicationContext context) {
        //..省略...
    }
    
    // 遍历所有的 HandlerAdapters，通过 supports 判断找到匹配的适配器
    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		for (HandlerAdapter ha : this.handlerAdapters) {
			if (logger.isTraceEnabled()) {
				logger.trace("Testing handler adapter [" + ha + "]");
			}
			if (ha.supports(handler)) {
				return ha;
			}
		}
	}
	
	// 分发请求，请求需要找到匹配的适配器来处理
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
 
		// Determine handler for the current request.
		mappedHandler = getHandler(processedRequest);
			
		// 确定当前请求的匹配的适配器.
		HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 
		ha.getLastModified(request, mappedHandler.getHandler());
					
		mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    }
	// ...省略...
}	

（8）通过使用适配器模式，可以提高 Spring MVC 的灵活性和可扩展性，使开发人员能够轻松地添加新的处理器和请求，并且能够让多种不同的处理器在 Spring MVC 中进行协作工作。