springboot整合activity自动部署及部署文件命名流程

目录

• springboot整合activity自动部署及部署文件命名流程
• 问题描述
• 问题分析
• 查阅相关资料总结
• 解决方案
• Spring Boot集成Activiti工作流
• 项目搭建
• 核心代码
• 看看演示吧

springboot整合activity自动部署及部署文件命名流程

问题描述

springboot整合activity，部署流程定义的时候在数据库总是会自动的部署一次。

问题分析

查看启动日志，出现如下一段话：

ProcessEngine default created

Process deployed: {id: myProcess_1:1:db6bacd7-edbd-11ea-b883-1860249fb796, key: myProcess_1, name: null }

在项目启动的时候流程自动部署

查阅相关资料总结

1.项目中包含流程定义的xml或者bpmn文件，项目在第一次启动的时候会自动部署。

解决方案

在配置文件中增加如下配置：

#项目随着spring启动自动部署
spring.activiti.check-process-definitions=false

删除数据库中部署的流程定义，再次启动项目，没有出现自动部署的现象。

Spring Boot集成Activiti工作流

项目搭建

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.fengye.example</groupId>
	<artifactId>spring-boot-activiti</artifactId>
	<version>1.0-SNAPSHOT</version>
	<packaging>jar</packaging>
	<name>spring-boot-activiti</name>
	<description>Demo project for Spring Boot</description>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.3.0.RELEASE</version>
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
		<activiti.version>5.21.0</activiti.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-rest</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<dependency>
			<groupId>org.activiti</groupId>
			<artifactId>activiti-spring-boot-starter-basic</artifactId>
			<version>${activiti.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

application.properties配置

spring.jpa.hibernate.ddl-auto=update
spring.jpa.database=MYSQL
spring.datasource.url=jdbc:mysql://127.0.0.1:3307/spring-boot-activiti?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

核心代码

实体类

Person.java

package com.fengye.example.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

/**
 * Created by jery on 2016/11/23.
 */
@Entity
public class Person {

	@Id
	@GeneratedValue
	private Long personId;

	private String personName;

	@ManyToOne(targetEntity = Comp.class)
	private Comp comp;

	public Person() {

	}

	public Person(String personName) {
		this.personName = personName;
	}

	public Long getPersonId() {
		return personId;
	}

	public void setPersonId(Long personId) {
		this.personId = personId;
	}

	public String getPersonName() {
		return personName;
	}

	public void setPersonName(String personName) {
		this.personName = personName;
	}

	public Comp getComp() {
		return comp;
	}

	public void setComp(Comp comp) {
		this.comp = comp;
	}
}

Comp.java

package com.fengye.example.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.List;

/**
 * Created by jery on 2016/11/23.
 */

@Entity
public class Comp {
	@Id
	@GeneratedValue
	private Long compId;
	private String compName;
	@OneToMany(mappedBy = "comp", targetEntity = Person.class)
	private List<Person> people;
	public Comp(String compName)
	{this.compName = compName;}

	public Comp() {

	}

	public Long getCompId() {
		return compId;
	}

	public void setCompId(Long compId) {
		this.compId = compId;
	}

	public String getCompName() {
		return compName;
	}

	public void setCompName(String compName) {
		this.compName = compName;
	}

	public List<Person> getPeople() {
		return people;
	}

	public void setPeople(List<Person> people) {
		this.people = people;
	}
}

DAO

package com.fengye.example.dao;
import com.fengye.example.model.Person;
import org.springframework.data.jpa.repository.JpaRepository;
/**
 * Created by jery on 2016/11/23.
 */
public interface PersonRepository extends JpaRepository<Person, Long> {
	public Person findByPersonName(String personName);
}
 

package com.fengye.example.dao;
import com.fengye.example.model.Comp;
import org.springframework.data.jpa.repository.JpaRepository;
public interface CompRepository extends JpaRepository<Comp, Long> {
}

Activiti服务

package com.fengye.example.service;
import org.activiti.engine.RuntimeService;
import org.activiti.engine.TaskService;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by jery on 2016/11/23.
 */

@Service
@Transactional
public class ActivitiService {
	//注入为我们自动配置好的服务
	@Autowired
	private RuntimeService runtimeService;
	@Autowired
	private TaskService taskService;

	//开始流程，传入申请者的id以及公司的id
	public void startProcess(Long personId, Long compId) {
		Map<String, Object> variables = new HashMap<String, Object>();
		variables.put("personId", personId);
		variables.put("compId", compId);
		runtimeService.startProcessInstanceByKey("joinProcess", variables);
	}

	//获得某个人的任务别表
	public List<Task> getTasks(String assignee) {
		return taskService.createTaskQuery().taskCandidateUser(assignee).list();
	}

	//完成任务
	public void completeTasks(Boolean joinApproved, String taskId) {
		Map<String, Object> taskVariables = new HashMap<String, Object>();
		taskVariables.put("joinApproved", joinApproved);
		taskService.complete(taskId, taskVariables);
	}
}

Service Task服务

package com.fengye.example.service;
import com.fengye.example.dao.CompRepository;
import com.fengye.example.dao.PersonRepository;
import com.fengye.example.model.Comp;
import com.fengye.example.model.Person;
import org.activiti.engine.delegate.DelegateExecution;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Arrays;
import java.util.List;

/**
 * Created by jery on 2016/11/23.
 */
@Service
public class JoinService {
	@Autowired
	PersonRepository personRepository;
	@Autowired
	private CompRepository compRepository;

	//加入公司操作，可从DelegateExecution获取流程中的变量
	public void joinGroup(DelegateExecution execution) {
		Boolean bool = (Boolean) execution.getVariable("joinApproved");
		if (bool) {
			Long personId = (Long) execution.getVariable("personId");
			Long compId = (Long) execution.getVariable("compId");
			Comp comp = compRepository.findOne(compId);
			Person person = personRepository.findOne(personId);
			person.setComp(comp);
			personRepository.save(person);
			System.out.println("加入组织成功");
		} else {
			System.out.println("加入组织失败");
		}
	}

	//获取符合条件的审批人，演示这里写死，使用应用使用实际代码
	public List<String> findUsers(DelegateExecution execution) {
		return Arrays.asList("admin", "wtr");
	}
}

控制器

package com.fengye.example.controller;
/**
 * Created by jery on 2016/11/23.
 */
import com.fengye.example.service.ActivitiService;
import org.activiti.engine.task.Task;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;

@RestController
public class MyRestController {
	@Autowired
	private ActivitiService myService;

	//开启流程实例
	@RequestMapping(value = "/process/{personId}/{compId}", method = RequestMethod.GET)
	public void startProcessInstance(@PathVariable Long personId, @PathVariable Long compId) {
		myService.startProcess(personId, compId);
	}

	//获取当前人的任务
	@RequestMapping(value = "/tasks", method = RequestMethod.GET)
	public List<TaskRepresentation> getTasks(@RequestParam String assignee) {
		List<Task> tasks = myService.getTasks(assignee);
		List<TaskRepresentation> dtos = new ArrayList<TaskRepresentation>();
		for (Task task : tasks) {
			dtos.add(new TaskRepresentation(task.getId(), task.getName()));
		}
		return dtos;
	}

	//完成任务
	@RequestMapping(value = "/complete/{joinApproved}/{taskId}", method = RequestMethod.GET)
	public String complete(@PathVariable Boolean joinApproved, @PathVariable String taskId) {
		myService.completeTasks(joinApproved, taskId);
		return "ok";
	}

	//Task的dto
	static class TaskRepresentation

	{
		private String id;
		private String name;

		public TaskRepresentation(String id, String name) {
			this.id = id;
			this.name = name;
		}

		public String getId() {
			return id;
		}

		public void setId(String id) {
			this.id = id;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}
	}
}

入口类

import com.fengye.example.dao.CompRepository;
import com.fengye.example.dao.PersonRepository;
import com.fengye.example.model.Comp;
import com.fengye.example.model.Person;
import com.fengye.example.service.ActivitiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.orm.jpa.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
/**
 * Created by jery on 2016/11/23.
 */
@SpringBootApplication
@ComponentScan("com.fengye.example")
@EnableJpaRepositories("com.fengye.example.dao")
@EntityScan("com.fengye.example.model")
public class ActivitiApplication {
   @Autowired
   private CompRepository compRepository;
   @Autowired
   private PersonRepository personRepository;
   public static void main(String[] args) {
      SpringApplication.run(ActivitiApplication.class, args);
   }

   //初始化模拟数据
   @Bean
   public CommandLineRunner init(final ActivitiService myService) {
      return new CommandLineRunner() {
         public void run(String... strings) throws Exception {
            if (personRepository.findAll().size() == 0) {
               personRepository.save(new Person("wtr"));
               personRepository.save(new Person("wyf"));
               personRepository.save(new Person("admin"));
            }
            if (compRepository.findAll().size() == 0) {
               Comp group = new Comp("great company");
               compRepository.save(group);
               Person admin = personRepository.findByPersonName("admin");
               Person wtr = personRepository.findByPersonName("wtr");
               admin.setComp(group); wtr.setComp(group);
               personRepository.save(admin); personRepository.save(wtr);
            }
         }
      };
   }
}

看看演示吧

启动程序会自动初始化Activiti所用的数据库和我们的业务数据库，并自动发布我们的流程。

此时我们要加入的公司id为1，申请加入的人的id为2，使用PostMan访问http://localhost:8080/process/2/1 此时数据库发生如下变化

此时用户admin和wtr具备审批申请的权利，此时我们访问http://localhost:8080/tasks?assignee=admin 查看admin用户的任务，返回结果为：

[
{
"id":"10",
"name":"Approval Task"
}
]

我们现在通过访问http://localhost:8080/complete/true/10 完成任务，true为同意(可以选择false)，10为task的id，任务完成后会自动调用Service Task，此时wyf这条记录的comp_compId为更新为当前公司的id。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。