Flowable(三)：Java知识学习

Flowable(三)：Java知识学习

选文资料来自于：csdn、pdai，更多的精彩博客，尽在码农修炼笔记！

一、CDI扩展机制（Contextual Dependency Injection，上下文依赖注入）

要想知道什么是CDI，首先需要知道什么是容器。

容器：一个组件管理器，我们可以向容器注册组件，或者向容器申请一个特定状态的组件。 常见的容器：Tomcat、Weld、spring等。

我们了解Spring的话，就知道Spring的IOC是离不开DI依赖注入的，DI就是实现IOC的一种比较直观的方式。

Contextual ，也就是上下文的，作为一个形容词他修饰后面的短语DI（Dependency Injection）代表的是依赖注入的形式，是以上下文的形式进行的。

总结一下就是：

CDI中，DI以类型安全的方式注入一个组件到应用中去，包括指定特定实现注入，可以与组件绑定生命周期，可以与有状态的组件交互。

关于CDI的常见配置：

CDI必须有beans.xml，文件可以为空，但必须有。

1. 对一个web应用，这个文件必须在WEB-INF中。
2. 对EJB模块或JAR文件，必须在META-INF下。

CDI特性：

（1）CDI定义了一套强大的配套服务，帮助提高应用程序的代码结构。

（2）良好组织的组件生命周期管理：方便性。

（3）类型安全的依赖注入：高可靠性基于事件通知机制的组件通讯：充分解耦。

（4）优雅的组件拦截器（Interceptor/Decorator）：业务逻辑处理。

（5）扩展容器功能的 SPI：可扩展性。

二、JavaDelegate-Java的委托机制

委派模式，并不属于23种经典的设计模式。但是在Spring框架源码中，它有多次体现。

委派模式是Java中的一种行为模式，将任务的分配与实现分开。

举例来说，一个公司使用委派模式前，Boss直接管理Employee；使用委派模式后，Boss通过将任务分发给Leader，Leader再让Employee实现。

​ 使用委派模式有什么好处呢，如果一个公司内部委派恰到好处，就能够把一个大型的任务细化，不同的工作交给擅长该工作的人做，提高办公效率；

但委派模式也有缺点，如果采用过多委派，容易造成多重委派：A委托B，B委托C，让公司陷入责任混乱。

Java中是怎么实现委派模式的呢？

下面以一个简单的公司内部任务分配作为案例：

// 首先，Boss向Leader发放任务：

public class Boss {

    public void command(String command, Leader leader) {
        leader.doing(command);
    }
    
}
1
2
3
4
5
6
7
8
9

//Leader有着所有员工的信息，当他接到任务后，寻找对应的Employee完成工作：

public class Leader {

    private final Map<String, Employee> register = new HashMap<>();
    
    public Leader() {
        register.put("writing", new EmployeeW());
        register.put("coding", new EmployeeC());
    }
    
    public void doing(String command) {
        Optional.ofNullable(register.get(command));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// EmplyeeW和EmployeeC是对Employee接口的实现，接口以及实现如下：

public interface Employee {

    /**
     * 接收任务指令工作
     * @param command
     */
    void working(String command);
    
}
1
2
3
4
5
6
7
8
9
10
11

public class EmployeeC implements Employee{

    @Override
    public void working(String command) {
        System.out.println("我是coder，我开始编码了" );
    }
}
public class EmployeeW implements Employee {

    @Override
    public void working(String command) {
        System.out.println("我是writer，我开始写字了" );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 如何进行委派呢？只需要
//输出：我是coder，我开始编码了

new Boss().command("coding", new Leader());
1
2
3
4

三、Java中的SPI机制

​ 所谓SPI（Service Provider Interface），就是JDK内置的一种 服务提供发现机制，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用。

比如java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，MySQL和PostgreSQL都有不同的实现提供给用户。而Java的SPI机制可以为某个接口

寻找服务实现。Java中SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是 解耦。

​ 当服务的提供者提供了一种接口的实现之后，需要在classpath下的META-INF/services/目录里创建一个以服务接口命名的文件

这个文件里的内容就是这个接口的具体的实现类，当其他的程序需要这个服务的时候，

就可以通过查找这个jar包（一般都是以jar包做依赖）的META-INF/services/中的配置文件，

配置文件中有接口的具体实现类名，可以根据这个类名进行加载实例化，就可以使用该服务了。JDK中查找服务的实现的工具类java.util.ServiceLoader。

SPI机制的应用

• SPI机制 - JDBC DriverManager

在JDBC4.0之前，我们开发有连接数据库的时候，通常会用Class.forName(“com.mysql.jdbc.Driver”)这句先加载数据库相关的驱动，然后再进行获取连接等的操作。而JDBC4.0之后不需要用Class.forName(“com.mysql.jdbc.Driver”)来加载驱动，直接获取连接就可以了，现在这种方式就是使用了Java的SPI扩展机制来实现。

• JDBC接口定义

首先在java中定义了接口java.sql.Driver，并没有具体的实现，具体的实现都是由不同厂商来提供的。

• mysql实现

在mysql的jar包mysql-connector-java-6.0.6.jar中，可以找到META-INF/services目录，该目录下会有一个名字为java.sql.Driver的文件，文件内容是com.mysql.cj.jdbc.Driver，这里面的内容就是针对Java中定义的接口的实现。

• postgresql实现

同样在postgresql的jar包postgresql-42.0.0.jar中，也可以找到同样的配置文件，文件内容是org.postgresql.Driver，这是postgresql对Java的java.sql.Driver的实现。

• 使用方法

上面说了，现在使用SPI扩展来加载具体的驱动，我们在Java中写连接数据库的代码的时候，不需要再使用Class.forName("com.mysql.jdbc.Driver")来加载驱动了，而是直接使用如下代码：

String url = "jdbc:xxxx://xxxx:xxxx/xxxx";
Connection conn = DriverManager.getConnection(url,username,password);
.....
1
2
3

SPI机制的简单示例

我们现在需要使用一个内容搜索接口，搜索的实现可能是基于文件系统的搜索，也可能是基于数据库的搜索。

// 首先定义好接口

public interface Search {
    
    public List<String> searchDoc(String keyword);   
    
}


// 然后去实现这个接口，以文件搜索来实现搜索

public class DatabaseSearch implements Search{
    
    @Override
    public List<String> searchDoc(String keyword) {
        System.out.println("数据搜索 "+keyword);
        return null;
    }
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

接下来可以在resources下新建META-INF/services/目录，然后新建接口全限定名的文件：com.cainiao.ys.spi.learn.Search，里面加上我们需要用到的实现类

com.cainiao.ys.spi.learn.FileSearch，如下图所示：（下图主要展示的是文件的创建以及内容的填充）

// 最后自己写一段代码测试一下：

public class TestCase {
    public static void main(String[] args) {
        ServiceLoader<Search> s = ServiceLoader.load(Search.class);
        Iterator<Search> iterator = s.iterator();
        while (iterator.hasNext()) {
           Search search =  iterator.next();
           search.searchDoc("hello world");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

如果在com.cainiao.ys.spi.learn.Search文件里写上两个实现类，那最后的输出结果就是两行了。

这就是因为ServiceLoader.load(Search.class)在加载某接口时，会去META-INF/services下找接口的全限定名文件，再根据里面的内容加载相应的实

现类。这就是SPI的思想，接口的实现由provider实现，provider只用在提交的jar包里的META-INF/services下根据平台定义的接口新建文件，并添加进相

应的实现类内容就好

未完待续…