不使用spring的例子

上一节完成了新建examples模块后，我们将新建一个练习模块来开发不使用spring的示例应用，来感受下没有spring的世界，生活会有多么糟糕吧。

示例应用

ReadingApp

一个最简单的儿童读书应用程序。定义POJO类如下：

Book.java

package com.xiaoma.spring.example.reading;

import ...

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
	private String name;
	private String type;
}

Child.java

package com.xiaoma.spring.example.reading;

import ...

@Data
@NoArgsConstructor
@AllArgsConstructor
@Slf4j
public class Child {

   private String name;
   private Book book;

   public void read() {
      log.info("{}在读{}类的{}", name, book.getType(), book.getName());
   }
}

儿童类中有一个对图书类的引用成员变量，代表一个小孩持有的书，read()方法通过日志输出小孩读书的描述信息。接下来是一个简单的应用程序类：

ReadingApp.java

package com.xiaoma.spring.example.reading;

import ...

@Slf4j
public class ReadingApp {

   public void run() {
      // 手动构造和组装实例
      Book book1 = new Book("金瓶梅", "文学");
      Book book2 = new Book("Spring入门", "IT");
      Child dabao = new Child("大宝", book1);
      Child erbao = new Child("二宝", book2);
      dabao.read();
      erbao.read();
   }
}

在程序运行前的编译阶段，由开发人员手动实例化对象并完成依赖的组装，然后再调用Child实例的read()方法。运行单元测试：

package com.xiaoma.spring.example.reading;

import ...

class ReadingAppTest {
	@Test
	void run() {
		new ReadingApp().run();
	}
}

输出：

12:22:26.902 [Test worker] INFO  c.x.s.e.r.Child - 大宝在读文学类的金瓶梅
12:22:26.907 [Test worker] INFO  c.x.s.e.r.Child - 二宝在读IT类的Spring入门

BookStoreApp

这里模拟了一个最简单得书店管理系统图书入库的应用场景实现。

BookDto.java

package com.xiaoma.spring.example.bookstore.dto;

import ...

@Data
@NoArgsConstructor
@AllArgsConstructor
public class BookDto {
    private String name;
    private String type;
}

Book.java

package com.xiaoma.spring.example.bookstore.model;

import ...

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private String name;
    private String type;
}

BookDao.java

package com.xiaoma.spring.example.bookstore.dao;

import ...

public interface BookDao {
    void insert(Book book);
}

提供了BookDao接口的简易实现：

BookDaoImpl.java

package com.xiaoma.spring.example.bookstore.dao.impl;

import ...

@Slf4j
public class BookDaoImpl implements BookDao {
    @Override
    public void insert(Book book) {
		log.info("插入book对象：{}", book);
    }
}

BookDaoMockImpl.java

package com.xiaoma.spring.example.bookstore.dao.impl;

import ...

@Slf4j
public class BookDaoMockImpl implements BookDao {
    @Override
    public void insert(Book book) {
      log.info("模拟插入book对象：{}", book);
    }
}

接下来是Service接口，定义了一个保存图书的方法定义。

BookService.java

package com.xiaoma.spring.example.bookstore.service;

import ...

public interface BookService {
    void saveBook(BookDto bookDto);
}

BookService的具体实现如下：

BookServiceImpl.java

package com.xiaoma.spring.example.bookstore.service.impl;

import ...

public class BookServiceImpl implements BookService {

   private BookDao bookDao;

   @Override
   public void saveBook(BookDto bookDto) {
      Book book = new Book();
      BeanUtils.copyProperties(bookDto, book);
      bookDao.insert(book);
   }

   public void setBookDao(BookDao bookDao) {
      this.bookDao = bookDao;
   }
}

最后是调用Service组件的应用类：

BookStoreApp.java

package com.xiaoma.spring.example.bookstore;

import ...

public class BookStoreApp {

   private BookService bookService;

   public void saveBook(String name, String type) {
      this.bookService.saveBook(new BookDto(name, type));
   }

   public void setBookService(BookService bookService) {
      this.bookService = bookService;
   }
}

看下整体的类层次结构：

我们编写了一个单元测试来测试该应用程序，会发现同样需要在编译阶段来完成各种人工的对象初始化和依赖组装操作，及其繁琐：

package com.xiaoma.spring.example.bookstore;

import ...

import static org.junit.jupiter.api.Assertions.*;

class BookStoreAppTest {

   @Test
   void saveBook() {
      BookStoreApp bookStoreApp = new BookStoreApp();
      BookServiceImpl bookServiceImpl = new BookServiceImpl();
      BookDao bookDao = new BookDaoImpl();
      bookServiceImpl.setBookDao(bookDao);
      bookStoreApp.setBookService(bookServiceImpl);
      bookStoreApp.saveBook("金瓶梅", "文学");
   }
}

执行结果：

08:00:17.626 [Test worker] INFO  c.x.s.e.b.d.i.BookDaoImpl - 插入book对象：Book(name=金瓶梅, type=文学)

引入Bean容器的必要性

从这两个例子我们发现，应用中需要的各种对象（bean），需要我们在程序的执行入口自己完成各种对象的创建以及组装。因为对象有依赖时，我们采用面向接口编程，实际传入什么实现类只有在程序运行的时候才能确定，做到类型与具体实现的解耦。就像我们想拥有一台按照自己的需求打造的台式机，我们会先考虑主板，在此基础上再去找匹配接口要求的其他部件。

如果我们自己组装，需要确定好各种部件的规格参数以及相互之间的依赖，并且需要在实际动手组装前需要把这些零部件都搞到手，然后再参照预先的设计图一步步组装。这种人为的构造需要的类型以及拼图式的组装关系很容易出错，我们不应该借助编译阶段来绑定对象的依赖，程序在运行期它更清楚自己需要依赖什么类型的对象。因此，组装个人台式机这种需求可以交给专业的店铺帮我们完成。而我们要做的只是列出各个部件的参数和希望的搭配。回到应用程序上来，我们希望有一个bean工厂能按照开发人员对bean声明（构造器、属性包括依赖定义），在程序启动后，能帮我们在构造这些实例的同时注入需要的依赖。这就是spring IoC容器能为我们做到的，原先是开发人员控制对象的设置，现在反转了，交给容器来做，因此叫控制反转容器。容器实现了创建和管理bean的生命周期，当然最重要的是它实现了依赖注入（DI）的功能。

我们先不引伸出IoC容器以及依赖注入相关的话题，下一节我们将用Spring来改造这两个示例应用，先来体验下spring提供的这些特性是如何大大的减轻我们的开发压力、实现关注点分离的。