springboot使用flowable（8）

我是一只代码狗

已于 2022-11-30 17:24:24 修改

阅读量1.8k

点赞数 2

分类专栏： flowable java 文章标签： spring boot java 数据库

于 2022-11-28 17:59:48 首次发布

原文链接：https://blog.csdn.net/qq_21277357/article/details/128081661?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22128081661%22%2C%22source%22%3A%22qq_21277357%22%7D

版权

java 同时被 2 个专栏收录

280 篇文章 7 订阅

订阅专栏

flowable

22 篇文章 3 订阅

订阅专栏

如果我们在flowable想使用自己自定义的用户,角色该怎么办呢？

我们先把用户,用户,角色用户关联表先创建好

CREATE TABLE `sys_role` (
`id` int NOT NULL AUTO_INCREMENT,
`name` varchar(50) DEFAULT NULL COMMENT '角色名称',
`code` varchar(50) DEFAULT NULL COMMENT '角色编码',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='角色表';

CREATE TABLE `sys_user` (
`id` int NOT NULL AUTO_INCREMENT,
`name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '姓名',
`account` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '账号',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户表';

CREATE TABLE `sys_role_user` (
`role_code` varchar(50) NOT NULL COMMENT '角色编号',
`user_account` varchar(50) NOT NULL COMMENT '用户账号'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='角色用户关联表';

INSERT INTO `flowable`.`sys_role_user` (`role_code`, `user_account`) VALUES ('sys', 'zhangsan');
INSERT INTO `flowable`.`sys_role_user` (`role_code`, `user_account`) VALUES ('pt', 'lisi');
INSERT INTO `flowable`.`sys_role_user` (`role_code`, `user_account`) VALUES ('sys', 'wangwu');
INSERT INTO `flowable`.`sys_role_user` (`role_code`, `user_account`) VALUES ('pt', 'zhaoliu');

INSERT INTO `flowable`.`sys_role` (`id`, `name`, `code`) VALUES (1, '管理员', 'sys');
INSERT INTO `flowable`.`sys_role` (`id`, `name`, `code`) VALUES (2, '普通员工', 'pt');

INSERT INTO `flowable`.`sys_user` (`id`, `name`, `account`) VALUES (1, '张三', 'zhangsan');
INSERT INTO `flowable`.`sys_user` (`id`, `name`, `account`) VALUES (2, '李四', 'lisi');
INSERT INTO `flowable`.`sys_user` (`id`, `name`, `account`) VALUES (3, '王五', 'wangwu');
INSERT INTO `flowable`.`sys_user` (`id`, `name`, `account`) VALUES (4, '赵六', 'zhaoliu');

我们在创建一个starter的项目,然后被其他项目所引用

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.dmg</groupId>
    <artifactId>system</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>system</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.7</version>
        </dependency>

        <!-- 添加MyBatisPlus的依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!-- MySQL数据 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <!-- druid  连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.14</version>
        </dependency>
        <!-- MyBatisPlus 代码生成器 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>


    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <!--这个build内容是starter到其他项目 必须要有的 否则找不到starter的内容 -->
    <build>
        <plugins>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <!--这一行代码一定要有否则报错-->
                    <skip>true</skip>
                </configuration>

            </plugin>

        </plugins>

    </build>
</project>

创建application.properties ,注意这里不要写端口号，否则就会吧其他项目的端口号覆盖掉

# 应用名称
spring.application.name=system


spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
#&nullCatalogMeansCurrent=true 一定要有 否则报错
spring.datasource.url=jdbc:mysql://localhost:3306/flowable?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=true&nullCatalogMeansCurrent=true
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource


mybatis-plus.mapper-locations=classpath:mapper/*.xml
# 控制台打印sql语句
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

package com.dmg.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
    * 角色表
    */
@TableName("sys_role")
@Data
public class SysRole {
    private Integer id;

    /**
    * 角色名称
    */
    private String name;

    /**
    * 角色编码
    */
    private String code;
}

package com.dmg.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
    * 角色用户关联表
    */
@TableName("sys_role_user")
@Data
public class SysRoleUser {
    /**
    * 角色编号
    */
    private String roleCode;

    /**
    * 用户账号
    */
    private String userAccount;
}

package com.dmg.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
    * 用户表
    */
@Data
@TableName("sys_user")
public class SysUser {
    private Integer id;

    /**
    * 姓名
    */
    private String name;

    /**
    * 账号
    */
    private String account;

}

package com.dmg.service;

import com.dmg.entity.SysRole;

import java.util.List;

public interface SysRoleService{


    List<SysRole> getList();
}

package com.dmg.service;

import com.dmg.entity.SysRoleUser;

import java.util.List;

public interface SysRoleUserService{


    List<SysRoleUser> getList();

}

package com.dmg.service;


import com.dmg.entity.SysUser;

import java.util.List;

public interface SysUserService {


    public List<SysUser> getList();

}

package com.dmg.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dmg.entity.SysRole;

public interface SysRoleMapper extends BaseMapper<SysRole> {

}

package com.dmg.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dmg.entity.SysRoleUser;

public interface SysRoleUserMapper extends BaseMapper<SysRoleUser> {

}

package com.dmg.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dmg.entity.SysUser;

public interface SysUserMapper extends BaseMapper<SysUser> {

}

package com.dmg.service.impl;

@Service
public class SysRoleServiceImpl implements SysRoleService{

    @Resource
    private SysRoleMapper sysRoleMapper;


    @Override
    public List<SysRole> getList() {
        return sysRoleMapper.selectList(null);
    }
}

package com.dmg.service.impl;

@Service
public class SysRoleUserServiceImpl implements SysRoleUserService{

    @Resource
    private SysRoleUserMapper sysRoleUserMapper;


    @Override
    public List<SysRoleUser> getList() {
        return sysRoleUserMapper.selectList(null);
    }
}

package com.dmg.service.impl;

@Service
public class SysUserServiceImpl implements SysUserService {


    @Autowired
    private SysUserMapper sysUserMapper;


    @Override
    public List<SysUser> getList() {
        return sysUserMapper.selectList(null);
    }
}

package com.dmg;

@MapperScan("com.dmg.mapper")
@SpringBootApplication
public class SystemApplication {

    public static void main(String[] args) {
        SpringApplication.run(SystemApplication.class, args);
    }

}

项目创建好之后,我们执行maven clean,maven install，吧项目打入到本地仓库中

然后在我们flow02的项目的pom.xml中引入,然后刷新maven，从下面开始都是我们的flow02项目的代码了

       <!--引入系统项目-->
        <dependency>
            <groupId>com.dmg</groupId>
            <artifactId>system</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

然后在我们的flow02项目添加对应的代码

package com.dmg.service;



public interface FlowService {

   
    public void loadSys();
}

package com.dmg.service.impl;

/**
 * 流程定义服务实现类
 */
@Service
public class FlowServiceImpl extends FlowServiceFactory implements FlowService {

    @Autowired
    private HisApprovalMapper hisApprovalMapper;
    @Autowired
    private QjMapper qjMapper;

    @Autowired
    private SysUserService sysUserService;
    @Autowired
    private SysRoleService sysRoleService;
    @Autowired
    private SysRoleUserService sysRoleUserService;

   
    

    /**
     * 加载自定义信息到flowable的表中
     */
    @Override
    public void loadSys() {
        //查询自定义用户信息
        List<SysUser>userList=sysUserService.getList();
        //查询自定义角色信息
        List<SysRole>roleList=sysRoleService.getList();
        //查询自定义角色用户关联信息
        List<SysRoleUser>roleUserList=sysRoleUserService.getList();

        for (SysRole x : roleList) {
            String groupId=x.getCode();
            Group group = identityService.newGroup(groupId);
            group.setName(x.getName());
            //添加到act_id_group(角色表)
            identityService.saveGroup(group);
        }

        for (SysUser x : userList) {
            String userId=x.getAccount();
            User user=identityService.newUser(userId);
            user.setDisplayName(x.getName());
            user.setFirstName(x.getName());
            user.setLastName(x.getName());
            //添加到act_id_user（用户表）
            identityService.saveUser(user);
        }

        for (SysRoleUser x : roleUserList) {
            String userId=x.getUserAccount();
            String groupId=x.getRoleCode();
            //添加到act_id_membership（角色用户关联表）表中
            identityService.createMembership(userId,groupId);
        }

    }

}

package com.dmg.controller;

@RestController
public class IdmController {

    @Autowired
    private FlowService flowService;

    /**
     * 把自定义表的用户 角色 用户关联信息 放入到
     * flowable的 act_id_user（用户表），act_id_group(角色表)，
     * act_id_membership（角色用户关联表）表中
     *
     */
    @PostMapping("/loadSys")
    public Result loadSys(){
        flowService.loadSys();
        return Result.success();
    }

}

然后我们来看下结果

http://localhost:8080/loadSys

可以看到这3张表,都已经有数据了，admin是flowable-ui默认的用户，密码是test

我们来登录一下flowable-ui的项目来看下,在浏览器输入

http://localhost:8081/flowable-ui

找到流程图,选择一个任务,我们去给他分配用户

在这里,我们可以给他分配单个用户,分配候选用户,分配候选组（就是角色）

然后我们点击搜索输入我们同步过来的张三，选中

我们的分配这里就显示张三了,点击保存

然后我们给其他任务分配候选组和候选用户,输入我们同步过来的角色用户信息,选中保存

然后我们保存流程图

然后点击下载

我们打开流程图,可以看到flowable:assignee="zhangsan" 这是分配指定用户，

flowable:candidateUsers="lisi" 这是分配了候选用户，

flowable:candidateGroups="pt" 这是分配了候选组

指定用户,到了这个任务，act_ru_task的ASSIGNEE_字段自动就有审批人了，

如果是候选人和候选组，那么需要先认领任务,才能显示，我们先来看看，怎么查询候选任务

package com.dmg.controller;

/**
 * 任务控制层
 */
@RestController
public class TaskController {


    @Autowired
    private QjService qjService;
    @Autowired
    private FlowService flowService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private IdentityService identityService;


  

    /**
     *  查询候选人能认领的任务
     */
    @PostMapping("getCandidateTask")
    public Result getCandidateTask(@RequestBody FlowReq req){
        //根据账号 和流程实例id 查询任务 是否可以认领
        Task task = taskService.createTaskQuery()
                .taskCandidateUser(req.getAccount())
                .processInstanceId(req.getProcessInstanceId())
                .singleResult();
        if(task==null){
            return Result.success();
        }
        return Result.success(task.getId()+"=="+task.getName());
    }


    /**
     *  查询候选组(角色)能认领的任务
     */
    @PostMapping("candidateGroup")
    public Result candidateGroup(@RequestBody FlowReq req){
        //去组（角色）查询是否存在
        Group group = identityService.createGroupQuery()
                .groupMember(req.getAccount()).singleResult();
        //根据组id(角色) 获取任务
        Task task = taskService.createTaskQuery().taskCandidateGroup(group.getId())
                .singleResult();
        if(task==null){
            return Result.success();
        }
        return Result.success(task.getId()+"=="+task.getName());
    }
}

http://localhost:8080/candidateGroup

{

"account":"zhangsan",

"processInstanceId":"92086fa7-6f01-11ed-9ba5-005056c00008"

}

http://localhost:8080/getCandidateTask

{

"account":"zhaoliu",

"processInstanceId":"92086fa7-6f01-11ed-9ba5-005056c00008"

}

我们可以看到属于候选人,候选组的就能查询出来,不属于的就无法领取任务,不能审批

我们查询出来之后,就可以做认领的功能了,之前已经说过了,这里就不在介绍了

如果不想同步用户,角色到的flowable-ui里面,还有没有其他的方式呢？

是有的,我们先吧act_id_user,act_id_group,act_id_membership

之前同步的数据删掉,保留admin的用户,不要删,否则登录不了了；

我们启动flowable-ui的项目

在分配用户这里

会看到如果是候选组他会找这个地址

http://localhost:8081/flowable-ui/modeler-app/rest/editor-groups?filter=asd

如果是候选人和分配单个人他走这个地址

http://localhost:8081/flowable-ui/modeler-app/rest/editor-users?filter=%E9%98%BF%E6%9D%BE%E5%A4%A7a%27s%27da

我们拿着地址去源码搜一下，发现并没有找到,是为什么呢？

我们先跟着路径去找下源码包

我们随便选中一个类,点击下载源码

然后使用ctrl+shift+r快捷键，输入地址，可以看到这个时候就有了，

为啥呢？因为源码里面是class文件,所以找不到，我们下载源码就变成了java文件，所以在搜索就找到了

我们点击这个箭头的位置，进去看一看

我们可以看到如果这个远程的idm服务不为空就去查询用户信息，

最后吧用户信息放入到一个集合对象里面去

我们在看下这个findUsersByNameFilter方法是干啥的,我们点进去

我们在点击callRemoteIdmService去看看他是干嘛的

我们可以看到,他就是走的http请求，吧拿到的数据放入RemoteUser里面

我们在看下RemoteUser,可以发现他就是实现了User

我们可以看到,这不就是对应act_id_user的表字段的数据吗

有了用户的基础，我们在看下角色的源码

我们可以看到,他们2个都是使用了remoteIdmService

我们先点击findGroupsByNameFilter

可以看到,他走的也是http请求，这个时候我们不就知道怎么去写了吗

我们吧之前写的哪个system的starter拿过来放入flowable-ui的项目里面

<!--引入系统项目-->
<dependency>
    <groupId>com.dmg</groupId>
    <artifactId>system</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

然后在flowable-ui项目里面去实现RemoteIdmService接口，

重写他的方法

package com.dmg.service.impl;


import com.dmg.entity.SysRole;
import com.dmg.entity.SysUser;
import com.dmg.mapper.SysRoleMapper;
import com.dmg.mapper.SysUserMapper;
import com.fasterxml.jackson.databind.JsonNode;
import org.flowable.ui.common.model.RemoteGroup;
import org.flowable.ui.common.model.RemoteToken;
import org.flowable.ui.common.model.RemoteUser;
import org.flowable.ui.common.service.idm.RemoteIdmService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * 重写 flowable的idm服务
 */
@Service
public class MyRemoteIdmServiceImpl implements RemoteIdmService {

    private Logger logger= LoggerFactory.getLogger(MyRemoteIdmServiceImpl.class);

    @Resource
    private SysRoleMapper sysRoleMapper;
    @Resource
    private SysUserMapper sysUserMapper;

    @Override
    public RemoteUser authenticateUser(String s, String s1) {
        logger.info("authenticateUser========{},======={}",s,s1);
        return null;
    }

    @Override
    public RemoteToken getToken(String s) {
        logger.info("getToken========{},======={}",s);
        return null;
    }

    /**
     * 获取单个用户信息 我这就写死了,你可以改为根据s查询的用户接口
     * @param s
     * @return
     */
    @Override
    public RemoteUser getUser(String s) {
        RemoteUser remoteUser=new RemoteUser();
        remoteUser.setId("admin");
        remoteUser.setFirstName("Test");
        remoteUser.setLastName("Administrator");
        remoteUser.setEmail("test-admin@example-domain.tld");
        return remoteUser;
    }

    /**
     * 按名称过滤器查找用户
     * @param s
     * @return
     */
    @Override
    public List<RemoteUser> findUsersByNameFilter(String s) {
        List<RemoteUser>list=new ArrayList<>();
        //查询自己业务系统的用户
        List<SysUser> roleList = sysUserMapper.selectList(null);
        for (SysUser x : roleList) {
            //放入flowable里面的用户
            RemoteUser remoteUser=new RemoteUser();
            remoteUser.setId(x.getAccount());
            remoteUser.setDisplayName(x.getName());
            remoteUser.setFirstName(x.getName());
            remoteUser.setFullName(x.getName());
            remoteUser.setLastName(x.getName());
            list.add(remoteUser);
        }
        return list;
    }

    /**
     * 按组查找用户
     * @param s
     * @return
     */
    @Override
    public List<RemoteUser> findUsersByGroup(String s) {
        logger.info("findUsersByGroup========{},======={}",s);

        return null;
    }

    /**
     * 获取组
     * @param s
     * @return
     */
    @Override
    public RemoteGroup getGroup(String s) {
        logger.info("getGroup========{},======={}",s);
        return null;
    }

    /**
     * 按名称过滤器查找组
     * @param s
     * @return
     */
    @Override
    public List<RemoteGroup> findGroupsByNameFilter(String s) {
        List<RemoteGroup>list=new ArrayList<>();
        //查询自己业务系统的角色
        List<SysRole> roleList = sysRoleMapper.selectList(null);
        for (SysRole x : roleList) {
            //放入flowable里面的组
            RemoteGroup remoteGroup=new RemoteGroup();
            remoteGroup.setId(x.getCode());
            remoteGroup.setName(x.getName());
            list.add(remoteGroup);
        }
        return list;
    }
}

还需要加入一些配置

package com.dmg.config;

import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
import com.baomidou.mybatisplus.autoconfigure.SpringBootVFS;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.baomidou.mybatisplus.core.incrementer.IKeyGenerator;
import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.mapping.DatabaseIdProvider;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.ResourceLoader;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;

public class AbstractMybatisPlusConfiguration {
    protected SqlSessionFactory getSqlSessionFactory(
            DataSource dataSource,
            MybatisPlusProperties properties,
            ResourceLoader resourceLoader,
            Interceptor[] interceptors,
            DatabaseIdProvider databaseIdProvider,
            ApplicationContext applicationContext
    ) throws Exception {
        MybatisSqlSessionFactoryBean factory = new MybatisSqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setVfs(SpringBootVFS.class);

        if (StringUtils.hasText(properties.getConfigLocation())) {
            factory.setConfigLocation(resourceLoader.getResource(properties.getConfigLocation()));
        }
        applyConfiguration(factory, properties);
        if (properties.getConfigurationProperties() != null) {
            factory.setConfigurationProperties(properties.getConfigurationProperties());
        }
        if (!ObjectUtils.isEmpty(interceptors)) {
            factory.setPlugins(interceptors);
        }
        if (databaseIdProvider != null) {
            factory.setDatabaseIdProvider(databaseIdProvider);
        }
        if (StringUtils.hasLength(properties.getTypeAliasesPackage())) {
            factory.setTypeAliasesPackage(properties.getTypeAliasesPackage());
        }
        // TODO 自定义枚举包
        if (StringUtils.hasLength(properties.getTypeEnumsPackage())) {
            factory.setTypeEnumsPackage(properties.getTypeEnumsPackage());
        }
        if (properties.getTypeAliasesSuperType() != null) {
            factory.setTypeAliasesSuperType(properties.getTypeAliasesSuperType());
        }
        if (StringUtils.hasLength(properties.getTypeHandlersPackage())) {
            factory.setTypeHandlersPackage(properties.getTypeHandlersPackage());
        }
        if (!ObjectUtils.isEmpty(properties.resolveMapperLocations())) {
            factory.setMapperLocations(properties.resolveMapperLocations());
        }
        // TODO 此处必为非 NULL
        GlobalConfig globalConfig = properties.getGlobalConfig();
        //注入填充器
        if (applicationContext.getBeanNamesForType(MetaObjectHandler.class,
                false, false).length > 0) {
            MetaObjectHandler metaObjectHandler = applicationContext.getBean(MetaObjectHandler.class);
            globalConfig.setMetaObjectHandler(metaObjectHandler);
        }
        //注入主键生成器
        if (applicationContext.getBeanNamesForType(IKeyGenerator.class, false,
                false).length > 0) {
            IKeyGenerator keyGenerator = applicationContext.getBean(IKeyGenerator.class);
            List<IKeyGenerator> keyGenerators = new ArrayList<>();
            keyGenerators.add(keyGenerator);
            globalConfig.getDbConfig().setKeyGenerators(keyGenerators);

        }
        //注入sql注入器
        if (applicationContext.getBeanNamesForType(ISqlInjector.class, false,
                false).length > 0) {
            ISqlInjector iSqlInjector = applicationContext.getBean(ISqlInjector.class);
            globalConfig.setSqlInjector(iSqlInjector);
        }
        factory.setGlobalConfig(globalConfig);
        return factory.getObject();
    }

    private void applyConfiguration(MybatisSqlSessionFactoryBean factory, MybatisPlusProperties properties) {
        MybatisConfiguration configuration = properties.getConfiguration();
        if (configuration == null && !StringUtils.hasText(properties.getConfigLocation())) {
            configuration = new MybatisConfiguration();
        }
//        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
//            for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
//                customizer.customize(configuration);
//            }
//        }
        factory.setConfiguration(configuration);
    }


    public SqlSessionTemplate getSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, MybatisPlusProperties properties) {
        ExecutorType executorType = properties.getExecutorType();
        if (executorType != null) {
            return new SqlSessionTemplate(sqlSessionFactory, executorType);
        } else {
            return new SqlSessionTemplate(sqlSessionFactory);
        }
    }
}

package com.dmg.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ResourceLoader;

import javax.sql.DataSource;

/**
 * 扫描mapper路径,不加会报错
 */
@MapperScan(basePackages = {
        "com.dmg.mapper",
}
,
        sqlSessionTemplateRef = "appSqlSessionTemplate",
        sqlSessionFactoryRef = "appSqlSessionFactory"
)
@EnableConfigurationProperties(MybatisPlusProperties.class)
@Configuration
public class AppMybatisPlusConfiguration extends AbstractMybatisPlusConfiguration {

    @Bean(name = "appSqlSessionFactory")
    public SqlSessionFactory sqlSessionFactoryBean(DataSource dataSource,
                                                   MybatisPlusProperties properties,
                                                   ResourceLoader resourceLoader,
                                                   ApplicationContext applicationContext) throws Exception {
        // 显示的添加分页的拦截器
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return getSqlSessionFactory(dataSource,
                properties,
                resourceLoader,
                new Interceptor[]{interceptor},
                null,
                applicationContext);
    }

    @Bean(name = "appSqlSessionTemplate")
    public SqlSessionTemplate sqlSessionTemplate(MybatisPlusProperties properties,
                                                 @Qualifier("appSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return getSqlSessionTemplate(sqlSessionFactory, properties);
    }


}

注意 MapperScan会扫描你的mapper的路径，如果不加就会报错

一定要注意,flowable-ui的项目和其他的项目还不一样,一定要注意,

他不是在启动类加MapperScan，一定要注意

这时候我们在启动项目，可以看到用户和候选组已经有数据了

我们可以点击保存,下载,然后就可以部署到我们的项目里面了

我们还可以进行,在线发布,点击建模器应用程序，点击应用程序,创建应用程序

然后点击app

然后和我们之前画好的流程图进行绑定,然后保存

然后进入app详情点击发布

然后我们就可以看到act_de_model就有了我们应用程序的数据

这三张表都有数据了

springboot使用flowable（9）_我是一只代码狗的博客-CSDN博客

我是一只代码狗

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
springboot使用flowable（8）

ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='角色表';) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户表';指定用户,到了这个任务，act_ru_task的ASSIGNEE_字段自动就有审批人了，
复制链接

扫一扫

专栏目录