Java 接口联调 xml java调接口的方式

接口（interface）对于面向对象编程来说是一个非常重要的概念。它是一系列方法的声明，却没有具体实现。有些编程语言，比如swift，把接口解释成“协议（protocol）”，我觉得也是非常的恰当的，接口就是对方法制定的一套规范。

总结了以下几点接口的常见用法

1. 作为对类内执行流程的具体描述

这是接口的最根本的作用。有时候类内部流程的某一个环节，并不是由此类自己决定的。类并不知道在这一步时具体会执行什么内容。所以需要在此处设置一枚接口，提供对外界的扩展。

对于这个功能有一个非常好的范例。

一个秒表类：用于测量执行某一段代码执行所需的时间。

初步的代码类似于下面这样：

public class Stopwatch {
  
    private long deltaTime;
 
    public void clear() {
        deltaTime = 0L;
    }
 
    public long getDeltaTime() {
        return deltaTime;
    }
 
    public void start() {
        long startTime = System.currentTimeMillis();
        // do something
        deltaTime = System.currentTimeMillis() - startTime;
    }
}

而使用Stopwatch的代码类似于这样：

public static void main(String[] args) {
  Stopwatch stopwatch = new Stopwatch();
  stopwatch.clear();	//时间清零
  stopwatch.start();	//开始运行
  System.out.printf("time: %dms\n",stopwatch.getDeltaTime());
}

那么我们知道对于秒表这个类本身，它并不能决定自己在do something那个位置将会测量什么内容的代码。

也就是说此处代码将会由Stopwatch的外部决定。所以此处可以商定一个协议，也就是接口。Stopwatch决定自己开放出一个接口叫NeedMonitoringProgram需要监控的程序，其中doProgram()方法就是执行需要被监控的代码。外部在使用Stopwatch时只需要去实现NeedMonitoringProgram接口也就定义好了需要监测的代码。

public interface NeedMonitoringProgram {
  void doProgram();
}

给Stopwatch赋予NeedMonitoringProgram对象

public class Stopwatch {
 
    private long deltaTime;
    private NeedMonitoringProgram program;
 
    public void setProgram(NeedMonitoringProgram program) {
        this.program = program;
    }
 
    public void start() {
        long startTime = System.currentTimeMillis();
        program.doProgram();
        deltaTime = System.currentTimeMillis() - startTime;
    }
 
    public interface NeedMonitoringProgram {
        void doProgram();
    }
  
  //省略clear()和getDeltaTime()方法
}

模拟测量1到1000000叠加求和所需时间

Stopwatch stopwatch = new Stopwatch();
Stopwatch.NeedMonitoringProgram program = new Stopwatch.NeedMonitoringProgram() {
 
  @Override
  public void doProgram() {
    int sum = 0;
    int number = 1_000_000;
    for (int i = 0; i <= number; i++) {
      sum += i;
    }
    System.out.printf("sum: %d\n", sum);
  }
};
stopwatch.setProgram(program);
stopwatch.clear();
stopwatch.start();
System.out.printf("time: %dms\n",stopwatch.getDeltaTime());

假如说待测代码是需要外部参数的，并且也需要返回给外部执行结果的。也可以把接口方法改进一下。

添加一个Param类来存储参数。

private Param params = new Param();
 
public void addParam(String key, Object value) {
  	params.put(key, value);
}
 
public interface NeedMonitoringProgram<RETURN_OBJECT> {
  RETURN_OBJECT doProgram(Param params);
}
 
public class Param extends HashMap<String, Object> {
 
}

start方法也可以直接加入NeedMonitoringProgram对象，减少使用时的步骤。 并且NeedMonitoringProgram类的泛型指定了返回类型。

public <T> T start(NeedMonitoringProgram<T> program) {
  long startTime = System.currentTimeMillis();
  T returnObject = program.doProgram(params);
  deltaTime = System.currentTimeMillis() - startTime;
  return returnObject;
}

在执行start()之前使用addParam()给代码赋值。而start()也会返回代码执行的结果。

Stopwatch stopwatch = new Stopwatch();
stopwatch.clear();
stopwatch.addParam("number", 1_000_000);
int sum = stopwatch.start(new Stopwatch.NeedMonitoringProgram<Integer>() {
 
    @Override
    public Integer doProgram(Stopwatch.Param params) {
      int sum = 0;
      int number = (Integer)params.get("number");
      for (int i = 0; i <= number; i++) {
      	sum += i;
      }
      return sum;
  }
});
System.out.printf("sum: %d\n", sum);
System.out.printf("time: %dms\n",stopwatch.getDeltaTime());

运用JDK8的lambda表达式甚至可以缩写为

int sum = stopwatch.start(params -> {
  int s = 0;
  int number = (Integer)params.get("number");
  for (int i = 0; i <= number; i++) {
    s += i;
  }
  return s;
});

虽然java没有函数对象这一概念，但是使用lambda可以充分表达一种函数式编程的思想，在这里接口即等同于代表了一个函数对象。

以上是接口最最根本的功能，广泛运用在AWT、Swing、Android这类图形化程序中。像XXXListener这些处理控件事件的接口都是运用了此功能。

2. 多态

可以把具体子类对象都当作父类来看，屏蔽不同子类对象之间的差异。

public interface Animal {
    void sayHello();
}

public class Cat implements Animal{
    @Override
    public void sayHello() {
        System.out.println("I'm a cat.");
    }
}

public class Dog implements Animal{
    @Override
    public void sayHello() {
        System.out.println("I'm a dog.");
    }
}

public static void main(String[] args) {
  Animal[] animals = new Animal[]{new Cat(), new Dog()};
  for (Animal animal : animals) {
    animal.sayHello();
  }
}

在这里把Cat和Dog都一视同仁的放入了Animal的数组内，并且批量处理。多态的功能其实和抽象类（abstract class）相同。

3. 用于隐藏方法的具体实现过程

一个简单的Dao

public interface UserDao {
  
  	User findUser(int id);
  
    void addUser(User user);
    
    void updateUser(User user);
    
    void deleteUser(int id);
}

这个DaoFactory工厂类代表某一框架内部生成Dao的逻辑（超简化）

public class DaoFactory {
  
  	public <T> T getDaoInstance(Class<T> clazz) {
     	if(clazz == UserDao.class) {
          	return new UserDaoImpl();
     	} else if(……) {
          
     	}
  	}
}

那么我们在使用该框架时，只需要从DaoFactory中通过Dao的类型获得该Dao的具体实现对象。

我们只关心该Dao接口有哪些我们可以用的方法，而不会去关心这个Dao内部是怎么实现增删改查的。拿着这个Dao对象我们就可以去完成数据库的操作。也就是说接口为我们屏蔽了方法的具体实现，屏蔽了具体的实现类中一些杂乱无章的，对于使用者来说无用的中间方法。

4. 暴露分布式服务

public interface XXXService {
  
}

在大型网站项目中，底层的服务都是基于分布式部署的。比如说Dubbo框架，在分布式项目中，接口和实现是分离于两个子项目中的。分布式的优势在于，通过架设多台服务提供者（provider）维持了服务提供的稳定性。只要不是所有服务提供者挂机，服务消费者（consumer）依然可以得到稳定的服务。对于服务消费者来说它并不关心服务是由谁提供的，只关心有哪些服务可以用，所以接口既屏蔽了方法的具体实现，甚至还可以接来自不同服务提供者的服务。在这里，接口起到了一个协议的作用，消费者需要哪些服务，由接口描述，同时提供者根据接口实现了自己的处理服务逻辑。

5. 赋予类某种能力

我们常常会遇到一些诸如XXXable，以able结尾的类

比如说java.io.Serializable这是赋予了类可序列化的能力

我们自己也可以写给类赋予能力的接口以及实现。

做过微信支付的应该都知道，对接微信支付需要发送包含xml字符串的HTTP请求。

那么就可以对微信支付功能封装一个客户端（Client）

那么大致步骤如下：

public class WechatClient{
 
    /**
     * 统一下单
     */
    public void unifiedOrder() {
        //1. 生成xml
      	//2. 发送HTTP请求
      	//3. 处理请求结果
    }
}

接下来给客户端类赋予可发送HTTP请求的能力，声明一个接口：

public interface HttpSendable {
	//发送GET请求
    HttpResponse getHttps(String url);
	//发送包含raw富文本的POST请求
    HttpResponse postHttps(String url, String raw);
}

HttpSendable顾名思义就是可发送HTTP请求的能力

那么给客户端加上这个能力

public class WechatClient implements HttpSendable

这个能力的实现可以使用抽象父类实现，不会造成次要代码污染主要类的逻辑

public abstract class HttpSender implements HttpSendable{
    @Override
    public HttpResponse getHttps(String url) {
        return null;
    }
 
    @Override
    public HttpResponse postHttps(String url, String raw) {
        return null;
    }
}

HttpSender就是HTTP的发送者，当然它也有发送HTTP的能力HttpSendable然后客户端继承了它

public class WechatClient extends HttpSender implements HttpSendable{
 
    /**
     * 统一下单
     */
    public void unifiedOrder() {
      	//1. 生成xml
      	String xml = "";//代码略
      	//2. 发送HTTP请求
        HttpResponse response = super.postHttps("https://", xml);
      	//3. 处理请求结果
      	//代码略
    }
}

像这样写代码，是不是会增加代码的可理解性了呢？

6. 作为常量接口

一般老java程序员都喜欢这么用，包括JDK内部也有这么用的。把一些常量扔在接口里面。

//申请状态常量
public interface ApplyStatusContants {
  	public static final String STATIC_UNTREATED = "STATIC_UNTREATED";//未处理
  	public static final String STATIC_ACCEPT = "STATIC_ACCEPT"; //通过
  	public static final String STATIC_REJECT = "STATIC_REJECT"; //拒绝
}

不过自从JDK1.5以后新增了enum枚举类型。我们就不需要常量接口了，可以如下方式：

public enum ApplyStatus {
  	UNTREATED, ACCEPT, REJECT
}

简单粗暴。

接口的用法还是特别灵活多变的