流程引擎基于流程定义及流程实例架构图

转载

墨韵流香 2024-11-30 11:51:39

文章标签 流程引擎基于流程定义及流程实例架构图 activiti bc xml spring 文章分类 架构后端开发

文章目录

一、使用Activity的API设置流程引擎

1.读取默认的配置文件
2.读取自定义的配置文件
3.读取输入流配置

二、数据源配置

1.DBCP数据源配置
2.C3P0数据源配置
3.数据库策略配置
4.databaseType配置

三、其他属性配置

1.history配置
2.邮箱服务器配置

四、ProcessEngineConfigration及其子类

1.自定义ProcessEngineConfiguration

五、Activity的命令拦截器

1.自定义拦截器
2.配置拦截器
3.运行

一、使用Activity的API设置流程引擎

1.读取默认的配置文件

public static void main(String[] args) {
		//使用Activiti默认的方式创建ProcessEngineConfiguration
		ProcessEngineConfiguration config = ProcessEngineConfiguration.createProcessEngineConfigurationFromResourceDefault();	
	}

默认到Classpath下读取activity.cfg.xml文件。找到processEngineConfigration的Bean，找不到则报错。

public static ProcessEngineConfiguration parseProcessEngineConfiguration(Resource springResource, String beanName) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader xmlBeanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    xmlBeanDefinitionReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_XSD);
    xmlBeanDefinitionReader.loadBeanDefinitions(springResource);
    ProcessEngineConfigurationImpl processEngineConfiguration = (ProcessEngineConfigurationImpl) beanFactory.getBean(beanName);
    processEngineConfiguration.setBeans(new SpringBeanFactoryProxyMap(beanFactory));
    return processEngineConfiguration;
  }

2.读取自定义的配置文件

public static void main(String[] args) {
		// 指定配置文件创建ProcessEngineConfiguration
		ProcessEngineConfiguration config = ProcessEngineConfiguration
				.createProcessEngineConfigurationFromResource(
						"my-activiti2.xml", "test2");
		System.out.println(config.getProcessEngineName());
	}

告诉Activity需要到Classpath查找my-activiti2.xml文件，并且创建名称为test2的bean。

3.读取输入流配置

流程引擎基于流程定义及流程实例架构图_activiti

public static void main(String[] args) throws Exception {
		File file = new File("resource/activiti.cfg.xml");
		System.out.println(file.getAbsolutePath());
		System.out.println(file.getName());
		// 得到文件输入流
		InputStream fis = new FileInputStream(file);
		// 使用createProcessEngineConfigurationFromInputStream方法创建ProcessEngineConfiguration
		ProcessEngineConfiguration config = ProcessEngineConfiguration
				.createProcessEngineConfigurationFromInputStream(fis);
	}

二、数据源配置

1.DBCP数据源配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 使用DBCP数据源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://10.224.221.199:3306/activiti_study" />
		<property name="username" value="dble" />
		<property name="password" value="dble" />
	</bean>

	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="dataSource" ref="dataSource" />
	</bean>

</beans>

public static void main(String[] args) throws Exception {
		// 读取 dbcp-config.xml配置
		ProcessEngineConfiguration config = ProcessEngineConfiguration
				.createProcessEngineConfigurationFromResource("dbcp-config.xml");
		// 能正常输出，即完成配置
		DataSource ds = config.getDataSource();
		// 查询数据库元信息，如果能查询则表示连接成功
		ds.getConnection().getMetaData();
		// 结果为 org.apache.commons.dbcp.BasicDataSource
		System.out.println(ds.getClass().getName());
	}

也可以在Bean中不进行指定，使用时再Setter

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 不初始化任何属性 -->
	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
	</bean>

</beans>

public static void main(String[] args) throws Exception {
		// 创建DBCP数据源
		BasicDataSource ds = new BasicDataSource();
		// 设置JDBC连接的各个属性
		ds.setUsername("dble");
		ds.setPassword("dble");
		ds.setUrl("jdbc:mysql://10.224.221.199:3306/activiti_study");
		ds.setDriverClassName("com.mysql.jdbc.Driver");
		// 验证是否连接成功
		ds.getConnection().getMetaData();
		// 读取Activiti配置文件
		ProcessEngineConfiguration config = ProcessEngineConfiguration
				.createProcessEngineConfigurationFromResource("dbcp-coding.xml");
		// 为ProcessEngineConfiguration设置dataSource属性
		config.setDataSource(ds);
		System.out.println(config.getDataSource());
	}

2.C3P0数据源配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 使用C3P0数据源 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUrl" value="jdbc:mysql://10.224.221.199:3306/activiti_study" />
		<property name="user" value="dble" />
		<property name="password" value="dble" />
	</bean>

	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="dataSource" ref="dataSource" />
	</bean>

</beans>

public static void main(String[] args) throws Exception {
		// 读取c3p0-config.xml配置
		ProcessEngineConfiguration config = ProcessEngineConfiguration
				.createProcessEngineConfigurationFromResource("config/c3p0-config.xml");
		// 能正常输出，即完成配置
		DataSource ds = config.getDataSource();
		// 查询数据库元信息，如果能查询则表示连接成功
		ds.getConnection().getMetaData();
		// 结果为 com.mchange.v2.c3p0.ComboPooledDataSource
		System.out.println(config.getDataSource().getClass().getName());
	}

3.数据库策略配置

activiti数据库表处理策略
false（默认）：检查数据库表的版本和依赖库的版本，如果版本不匹配就抛出异常。
true: 构建流程引擎时，执行检查，如果需要就执行更新。如果表不存在，就创建。（常用）
create-drop: 构建流程引擎时创建数据库表，关闭流程引擎时删除这些表。
drop-create：先删除表再创建表。（常用，使用完成后改为true）
create: 构建流程引擎时创建数据库表，关闭流程引擎时不删除这些表。

<bean id="processEngineConfiguration"
	class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
	<!-- 数据源 -->
	<property name="dataSource" ref="dataSource" />
	<!-- activiti数据库表处理策略 -->
	<!--    false（默认）：检查数据库表的版本和依赖库的版本， 如果版本不匹配就抛出异常。
			true: 构建流程引擎时，执行检查，如果需要就执行更新。 如果表不存在，就创建。（常用）
			create-drop: 构建流程引擎时创建数据库表， 关闭流程引擎时删除这些表。
			drop-create：先删除表再创建表。（常用，使用完成后改为true）
			create: 构建流程引擎时创建数据库表， 关闭流程引擎时不删除这些表。
	 -->
	<property name="databaseSchemaUpdate" value="true"/>
</bean>

4.databaseType配置

<property name="databaseType" value="mysql"/>

<!-- 将databaseType设置为oracle -->
	<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcUrl" value="jdbc:mysql://10.224.221.199:3306/act_test" />
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUsername" value="dble" />
		<property name="jdbcPassword" value="dble" />
		<property name="databaseSchemaUpdate" value="true"/>
        <!-- 可以设置数据库类型 -->
		<property name="databaseType" value="mysql"/>
	</bean>

默认可以不指定，会根据数据库连接进行推测数据库类型

流程引擎基于流程定义及流程实例架构图_activiti_02

三、其他属性配置

1.history配置

可以配置如下的历史级别：

none: skips all history archiving. This is the most performant for runtime process execution, but no historical information will be available.
忽略所有的历史归档。尽管对于运行期流程执行来说这是性能最高的，但是没有历史信息保留。
activity: archives all process instances and activity instances. No details will be archived
归档所有流程实例和活动实例。不归档细节。
audit: This is the default. It archives all process instances, activity instances and all form properties that are submitted so that all user interaction through forms is traceable and can be audited.
这是默认级别。它归档所有流程实例，活动实例和提交的表单属性。以至于通过表单的所有用户交互都是可跟踪并可以被审计。
full: This is the highest level of history archiving and hence the slowest. This level stores all information as in the audit level plus all other possible details like process variable updates.
这是历史归档的最高级别。所以是最慢的。这个水平保存audit级别的所有信息加上像流程变量的所有其它可能的细节。

2.邮箱服务器配置

<bean id="processEngineConfiguration"
		class="org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration">
		<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/act" />
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver" />
		<property name="jdbcUsername" value="root" />
		<property name="jdbcPassword" value="123456" />
		<property name="mailServerHost" value="smtp.163.com"></property>
		<property name="mailServerPort" value="25"></property>
		<property name="mailServerDefaultFrom" value="yangenxiong@163.com"></property>
		<property name="mailServerUsername" value="yangenxiong@163.com"></property>
		<property name="mailServerPassword" value="123456"></property>
	</bean>

四、ProcessEngineConfigration及其子类

ProcessEngineConfiguration代表Activiti的一个配置实例，ProcessEngineConfiguration本身是一个抽象类，因此要配置bean需要知道它的子类。在定制自己的ProcessEngineConfiguration之前，我们先来了解它及其几个子类：

流程引擎基于流程定义及流程实例架构图_xml_03

如上图所示，ProcessEngineConfiguration是全部配置类的父类，它有一个ProcessEngineConfigurationImpl子类，这个子类也是个抽象类，在这三个子类下面又有三个直接子类。

org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration：使用该类作为配置对象，Activiti将会对事务进行管理，默认情况下，流程引擎启动时会检查数据库结构以及版本是否正确。

org.activiti.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration：该类同样由Activiti进行事务管理，但是该类设置了databaseSchemaUpdate（create-drop）和jdbcUrl（jdbc:h2:mem:activiti）属性，以便可以在单元测试中使用。

org.activiti.spring.SpringProcessEngineConfiguration：当Activiti与Spring进行整合时，可以使用该类。

org.activiti.engine.impl.cfg.JtaProcessEngineConfiguration：不使用Activiti的事务，使用JTA进行事务管理。

1.自定义ProcessEngineConfiguration

如果我们想自定义一个ProcessEngineConfiguration抽象类可以选择继承ProcessEngineConfiguration或者它的直接子类ProcessEngineConfigurationImpl。

继承ProcessEngineConfiguration类需要实现buildProcessEngine方法，继承ProcessEngineConfigurationImpl需要实现getDefaultCommandInterceptorsTxRequired和getDefaultCommandInterceptorsTxRequiresNew方法。如果需要添加自定义属性，可以为自己的ProcessEngineConfiguration类添加属性，并且添加相应的setter方法。

五、Activity的命令拦截器

1.自定义拦截器

Activiti提供了命令拦截器的功能，外界对Activit流程中各个实例进行操作，实际可以被看作是对数据进行相应的操作，在此过程中，Activiti使用了设计模式中的命令模式，
每一个操作数据库CRUD的操作，均可被看做为一个命令 Command，然后交由命令执行者 CommandExecutor去执行。除此之外，为了能让使用者可以对这些命令进行相应的拦截，Activiti还使用了设计模式中的职责链模式，使用者可以在其中添加相应的拦截器。

职责模式让多个对象都有机会处理请求，从而避免了请求发送者和请求接收者之间的耦合。这些请求接收者将组成一条链，并沿着这条链传递下去，
直到有一个对象处理这个请求为止，这就形成了一条责任链。

命令设计模式：

职责链设计模式：

Activiti使用了一个CommandContext类作为命令接收者，该对象维护一系列的Manager对象，这些Manager对象就是J2EE中的DAO对象。
除了命令接收者外，Activiti还使用一系列的CommandInterceptor（命令拦截器），这些命令拦截器扮演命令模式中的命令执行者角色。

参考链接学习：

1.创建拦截器

package org.crazyit.activiti;

import org.activiti.engine.impl.interceptor.Command;
import org.activiti.engine.impl.interceptor.CommandConfig;
import org.activiti.engine.impl.interceptor.CommandInterceptor;

/**
 * 拦截器实现A
 * 
 */
public class InterceptorA implements CommandInterceptor {

	private CommandInterceptor next;
	
	@Override
	public <T> T execute(CommandConfig config, Command<T> command) {
		// 输出字符串和命令
		System.out.println("this is interceptor A："
				+ command.getClass().getName());
		// 然后让责任链中的下一请求处理者处理命令
		return getNext().execute(config, command);
	}
	
	public CommandInterceptor getNext() {
		return this.next;
	}
	
	public void setNext(CommandInterceptor next) {
		this.next = next;
	}
}

2.配置拦截器

package org.crazyit.activiti;

import java.util.ArrayList;
import java.util.List;

import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
import org.activiti.engine.impl.interceptor.CommandInterceptor;

/**
 * 自定义配置类
 */
public class TestConfiguration extends ProcessEngineConfigurationImpl {
	
	public CommandInterceptor createTransactionInterceptor() {
		// 不实现事务拦截器
		return null;
	}
	
	/**
	 * 重写初始化命令拦截器方法
	 */
	public void initCommandInterceptors() {
		// 为父类的命令集合添加拦截器
		customPreCommandInterceptors = new ArrayList<CommandInterceptor>();
		// 依次将A和B两个拦截器加入集合（责任链）
		customPreCommandInterceptors.add(new InterceptorA());
		customPreCommandInterceptors.add(new InterceptorB());
		// 再调用父类的实始化方法
		super.initCommandInterceptors();
	}
}

3.运行

package org.crazyit.activiti;

import java.util.HashMap;
import java.util.Map;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.ProcessEngines;

public class MyConfig {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ProcessEngines.getDefaultProcessEngine();
		// 创建Activiti配置对象
		ProcessEngineConfiguration config = ProcessEngineConfiguration
				.createProcessEngineConfigurationFromResource("my-config.xml");		
		// 初始化流程引擎
		ProcessEngine engine = config.buildProcessEngine();
		// 部署一个最简单的流程
		engine.getRepositoryService().createDeployment()
				.addClasspathResource("bpmn/config.bpmn20.xml").deploy();
		// 构建流程参数
		Map<String, Object> vars = new HashMap<String, Object>();
		vars.put("day", 10);
		// 开始流程
		engine.getRuntimeService().startProcessInstanceByKey("vacationProcess",
				vars);
		System.exit(0);
	}
}

流程引擎基于流程定义及流程实例架构图_xml_04