如何在Java中利用IOC控制反转

这篇文章给大家介绍如何在Java中利用IOC控制反转，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

张家港网站制作公司哪家好，找创新互联公司！从网页设计、网站建设、微信开发、APP开发、响应式网站建设等网站项目制作，到程序开发，运营维护。创新互联公司从2013年成立到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联公司。

Java的特点有哪些

Java的特点有哪些 1.Java语言作为静态面向对象编程语言的代表，实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。 3.使用Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

IOC范式揭秘

控制反转是一种带有某些特征的模式。下面，给出了由Martin Fowler给出的一个IOC经典范例，该范例实现的功能是从控制台中收集用户数据。

public static void main(String[] args) {
  while (true) {
    BufferedReader userInputReader = new BufferedReader(
        new InputStreamReader(System.in));
    System.out.println("Please enter some text: ");
    try {
      System.out.println(userInputReader.readLine());
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

这个用例中，在main方法中进行流程控制：在无限循环调用中，读取用户输入，并将读取的内容输出到控制台上。完全又main方法控制何时去读取用户输入，何时去输出。

考虑下，上述程序的一个新版本，该版本中需要通过图形界面中的文本框来收件用户输入，另外还有个按钮，该按钮上绑定有一个action监听器。这样的话，用户每次点击按钮，输入的文本由监听器收集并打印到面板。

在这个版本的程序中，它实际上是由事件监听器模型（在这种情况下，这是框架）的控制下，调用开发者编写的用于读取和打印用户输入的代码。简单地说，框架将调用开发人员的代码，而不是其他方式。该框架实际上是一个可扩展的结构，它为开发人员提供了一组注入自定义代码段的切入点。

这种情况下，控制已经被有效的反转了。

从更通用的角度来看，由框架定义的每个可调用扩展点（以接口实现，实现继承（也称为子类）的形式）是IoC的一种明确定义的形式。

看下，下述这个简单的Servlet例子：

public class MyServlet extends HttpServlet {
 
  protected void doPost(
      HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // developer implementation here
  }
 
  protected void doGet(
      HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // developer implementation here
  }
 
}

此处，HttpServlet类（属于框架）是完全控制程序的元素，而不是MyServlet这个子类。在由servlet容器创建之后，当收到servlet的GET和POST的HTTP请求，doGet（）和doPost（）方法中的代码会分别自动调用。

与典型的继承方式相比，即子类是控制的元素，而不是基类，该例中，控件已经被反转了。

事实上，servlet的方法是模板方法模式的实现，稍后我们再深入讨论。

使用那些通过提供可扩展API，秉承开闭原则的框架时，使用框架的开发人员的角色，最终被归结为定义自己的一组自定义类，即开发人员要么通过实现框架提供的一个或多个接口方式，要么通过继承现有基类的方式。反过来，类的实例却是直接框架进行实例化，并且这些事例是被框架调用的。

此处引用Fowler的话：该框架调用开发人员，而不是开发人员调用该框架。因此，IoC通常被称为好莱坞原则：不要打电话给我们，我们会打电话给你。

IOC的实现方式

该问题上，显而易见的是，实现控制反转是有几种不同方法的。我们不妨来总结一下，那些常见的实现方式。

注入依赖实现IOC
如前所述，注入依赖是IOC的一种实现方式，而且是最常见的一种面向对象设计方式。但是，思考一下：注入依赖究竟是如何达到控制反转效果的呢？

为了回答这个问题，我们给出如下一个原始的例子：

public interface UserQueue { 
  void add(User user); 
  void remove(User user);
  User get();
 
}
 
public abstract class AbstractUserQueue implements UserQueue {
  protected LinkedList queue = new LinkedList<>();
 
  @Override
  public void add(User user) {
    queue.addFirst(user);
  }
 
  @Override
  public void remove(User user) {
    queue.remove(user);
  }
 
  @Override
  public abstract User get();
 
}
 
public class UserFifoQueue extends AbstractUserQueue { 
  public User get() {
    return queue.getLast();
  }
 
}
 
public class UserLifoQueue extends AbstractUserQueue {
  public User get() {
    return queue.getFirst();
  }
 
}

UserQueue 接口定义了公共的API，用于在一个队列中去存放User对象（为了简单明了，此处忽略User的具体实现）。AbstractUserQueue则是为后续的继承类，提供了一些公用的方法实现。最后的UserFifoQueue 和 UserLifoQueue，则是分别实现了FIFO 和 LIFO 队列。

这是，实现子类多态性的一种有效方式。但是这具体用什么来买我们好处呢？实际上，好处还是蛮多的。

通过创建一个依赖于UserQueue抽象类型（也称为DI术语中的服务）的客户端类，可以在运行时注入不同的实现，无需会重构使用客户端类的代码：

public class UserProcessor { 
  private UserQueue userQueue;
 
  public UserProcessor(UserQueue userQueue) {
    this.userQueue = userQueue;
  }
 
  public void process() {
    // process queued users here
  }
 
}

UserProcessor展示了，注入依赖确实是IOC的一种方式。

我们可以通过一些硬编码方式如 new 操作，直接在构造函数中实例化在UserProcessor中获取对队列的依赖关系。但是，这是典型的代码硬编程，它引入了客户端类与其依赖关系之间的强耦合，并大大降低了可测性。耳边警钟声声想起啦！不是吗？是的，这样设计真的很挫。

该类在构造函数中声明对抽象类 UserQueue 的依赖。也就是说，依赖关系不再通过在构造函数中使用 new 操作，相反，通过外部注入的方式，要么使用依赖注入框架（如CDI和谷歌的Guice），要么使用factory或builders模式。

简而言之，使用DI，客户端类的依赖关系的控制，不再位于这些类中；而是在注入器中进行：

public static void main(String[] args) {
   UserFifoQueue fifoQueue = new UserFifoQueue();
   fifoQueue.add(new User("user1"));
   fifoQueue.add(new User("user2"));
   fifoQueue.add(new User("user3"));
   UserProcessor userProcessor = new UserProcessor(fifoQueue);
   userProcessor.process();
}

上述方式达到了预期效果，而且对UserLifoQueue的注入也简单明了。显而易见，DI确实是实现IOC的一种方式（该例中，DI是实现IOC的一个中间层）。

观察者模式实现IOC

直接通过观察者模式实现IOC，也是一种常见的直观方式。广义上讲，通过观察者实现IOC，与前文提到的通过GUI界面中的action监听器方式类似。但是在使用action监听器情况下，只有在特定的用户事件发生时（点击鼠标，键盘或窗口事件等），才会发生调用。观察者模式通常用于在模型视图的上下文中，跟踪模型对象的状态的变迁。

在一个典型的实现中，一到多个观察者绑定到可观察对象（也称为模式术语中的主题），例如通过调用addObserver方法进行绑定。一旦定义了被观察者和观察者之间的绑定，则被观察者状态的变迁都会触发调用观察者的操作。

为了深入了解这个概念，给出如下例子：

@FunctionalInterface
public interface SubjectObserver {
 
  void update();
 
}

值发生改变时，会触发调用上述这个很简单的观察者。真实情况下，通常会提供功能更丰富的API，如需要保存变化的实例，或者新旧值，但是这些都不需要观察action（行为）模式，所以这里举例尽量简单。

下面，给出一个被观察者类:

public class User {
 
  private String name;
  private List observers = new ArrayList<>();
 
  public User(String name) {
    this.name = name;
  }
 
  public void setName(String name) {
    this.name = name;
    notifyObservers();
  }
 
  public String getName() {
    return name;
  }
 
  public void addObserver(SubjectObserver observer) {
    observers.add(observer);
  }
 
  public void deleteObserver(SubjectObserver observer) {
    observers.remove(observer);
  }
 
  private void notifyObservers(){
    observers.stream().forEach(observer -> observer.update());
  }
}

User类中，当通过setter方法变更其状态事，都会触发调用绑定到它的观察者。

使用主题观察者和主题，以下是实例给出了观察方式：

public static void main(String[] args) {
  User user = new User("John");
  user.addObserver(() -> System.out.println(
      "Observable subject " + user + " has changed its state."));
  user.setName("Jack");
}

每当User对象的状态通过setter方法进行修改时，观察者将被通知并向控制台打印出一条消息。到目前为止，给出了观察者模式的一个简单用例。不过，通过这个看似简单的用例，我们了解到在这种情况下控制是如何实现反转的。

观察者模式下，主题就是起到”框架层“的作用，它完全主导何时何地去触发谁的调用。观察者的主动权被外放，因为观察者无法主导自己何时被调用（只要它们已经被注册到某个主题中的话）。这意味着，实际上我们可以发现控制被反转的”事发地“ – - – 当观察者绑定到主题时：

user.addObserver(() -> System.out.println(
      "Observable subject " + user + " has changed its state."));

上述用例，简要说明了为什么，观察者模式（或GUI驱动环境中的action监听器）是实现IoC的一种非常简单的方式。正是以这种分散式设计软件组件的形式，使得控制得以发生反转。

通过模板方法模式实现IoC

模板方法模式实现的思想是在一个基类中通过几个抽象方法（也称算法步骤）来定义一个通用的算法，然后让子类提供具体的实现，这样保证算法结构不变。

我们可以应用这个思想，定义一个通用的算法来处理领域实体：

public abstract class EntityProcessor {
 
  public final void processEntity() {
    getEntityData();
    createEntity();
    validateEntity();
    persistEntity();
  }
 
  protected abstract void getEntityData();
  protected abstract void createEntity();
  protected abstract void validateEntity();
  protected abstract void persistEntity();
 
}

processEntity() 方法是个模板方法，它定义了处理实体的算法，而抽象方法代表了算法的步骤，它们必须在子类中实现。通过多次继承 EntityProcessor 并实现不同的抽象方法，可以实现若干算法版本。

虽然这说清楚了模板方法模式背后的动机，但人们可能想知道为什么这是 IoC 的模式。

典型的继承中，子类调用基类中定义的方法。而这种模式下，相对真实的情况是：子类实现的方法(算法步骤)被基类的模板方法调用。因此，控制实际是在基类中进行的，而不是在子类中。
这也是 IoC 的典型例子，通过分层结构实现。这种情况下，模板方法只是可调的扩展点的一个漂亮的名字，被开发者用来管理自己的一系列实现。

关于如何在Java中利用IOC控制反转就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。

新闻名称：如何在Java中利用IOC控制反转
转载来源：http://scyanting.com/article/jodsji.html

如何在Java中利用IOC控制反转

Java的特点有哪些

其他资讯