【Drools学习笔记篇】-【Drools整合SpringBoot】

通过Springboot开发已经是主流，所以这一篇将讲述Drools整合Springboot

1.创建Maven工程导入相关依赖

:blossom:父工程

 	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>

:blossom:SpringBoot

	<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.2</version>
    </dependency>

:blossom:Lombok

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
    </dependency>

:blossom:数据库

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

:blossom:Drools

	<dependency>
        <groupId>org.drools</groupId>
        <artifactId>drools-core</artifactId>
        <version>7.10.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.kie</groupId>
        <artifactId>kie-internal</artifactId>
        <version>7.10.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.kie</groupId>
        <artifactId>kie-api</artifactId>
        <version>7.10.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.drools</groupId>
        <artifactId>drools-templates</artifactId>
        <version>7.10.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.drools</groupId>
        <artifactId>drools-compiler</artifactId>
        <version>7.10.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.kie</groupId>
        <artifactId>kie-spring</artifactId>
        <version>7.10.0.Final</version>
    </dependency>

2.创建数据库及表

:maple_leaf:Drools.User

3.创建工程结构

:maple_leaf:pojo

 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.io.Serializable;
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 @TableName("User")
 public class User implements Serializable {
 
     @TableField("id")
     private Integer id;
 
     @TableField("username")
     private String username;
 
     @TableField("age")
     private Integer age;
 }

:maple_leaf:application.yml

server:
      port: 8080
    spring:
      application:
        name: spring-drools
      datasource:
        druid:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://localhost:3306/drools?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
          username: root
          password: root
    
    mybatis-plus:
      configuration:
        #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射
        map-underscore-to-camel-case: true
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
      global-config:
        db-config:
          id-type: ASSIGN_ID
      mapper-locations: classpath*:/mapper/**

:maple_leaf:规则文件需要放在resource目录下

 package SpringDrools;
    dialect  "mvel"
    import com.dr.lp.pojo.User
    
    rule "SpringDrools"
        when
           $u: User(username == "张三")
        then
        modify($u){
            setUsername("张三三")
        }
            System.out.println("整合springboot" + $u);
    end

:maple_leaf:DroolsConfig

 package com.dr.lp.config;
    
    import org.kie.api.KieBase;
    import org.kie.api.KieServices;
    import org.kie.api.builder.KieBuilder;
    import org.kie.api.builder.KieFileSystem;
    import org.kie.api.builder.KieRepository;
    import org.kie.api.runtime.KieContainer;
    import org.kie.internal.io.ResourceFactory;
    import org.kie.spring.KModuleBeanFactoryPostProcessor;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.Resource;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    
    import java.io.IOException;
    
    @Configuration
    public class DroolsConfig {
    
        private static final String RULE_PATH = "rule/"; // 规则文件路径，规则包为rule
        private final KieServices kieServices = KieServices.Factory.get();
    	
        // 加载文件路径
        @Bean
        @ConditionalOnMissingBean
        public KieFileSystem kieFileSystem() throws IOException {
            String path = null;
            KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
    
            PathMatchingResourcePatternResolver patternResolver = new PathMatchingResourcePatternResolver();
            Resource[] resourceFiles = patternResolver.getResources("classpath*:" + RULE_PATH + "*.*");
    
            for (Resource file : resourceFiles) {
                path = RULE_PATH + file.getFilename();
                kieFileSystem.write(ResourceFactory.newClassPathResource(path,"UTF-8"));
            }
    
            return kieFileSystem;
        }
    	// 获得KieModule
        @Bean
        @ConditionalOnMissingBean
        public KieContainer kieContainer() throws IOException {
            KieRepository repository = kieServices.getRepository();
            repository.addKieModule(repository::getDefaultReleaseId);
            KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem());
            kieBuilder.buildAll();
            return kieServices.newKieContainer(repository.getDefaultReleaseId());
        }
    	// 创建容器
        @Bean
        @ConditionalOnMissingBean
        public KieBase kieBase() throws IOException {
            return   kieContainer().getKieBase();
        }
    	// 后置处理
        @Bean
        @ConditionalOnMissingBean
        public KModuleBeanFactoryPostProcessor postProcessor(){
            return new KModuleBeanFactoryPostProcessor();
        }
    }

:maple_leaf:Mapper

	import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.dr.lp.pojo.User;
    import org.apache.ibatis.annotations.Mapper;
    
    @Mapper
    public interface UserMapper extends BaseMapper<User> {
    }

:maple_leaf:Service

import com.baomidou.mybatisplus.extension.service.IService;
    import com.dr.lp.pojo.User;
    
    public interface UserService extends IService<User> {
        /**
         * 执行规则
         */
        public void  rule();
    }

:maple_leaf:ServiceImpl

package com.dr.lp.service.impl;
    
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.dr.lp.mapper.UserMapper;
    import com.dr.lp.pojo.User;
    import com.dr.lp.service.UserService;
    import lombok.extern.slf4j.Slf4j;
    import org.kie.api.KieBase;
    import org.kie.api.runtime.KieSession;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Slf4j
    @Service
    public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    
        @Autowired
        private KieBase kieBase;
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public void  rule(){
            KieSession kieSession = kieBase.newKieSession();
            User user = userMapper.selectById(1);
            kieSession.insert(user);
            int count = kieSession.fireAllRules();
            System.out.println("执行了" + count + "条规则");
    
            kieSession.dispose();
        }
    }

:maple_leaf:Controller

 package com.dr.lp.controller;
    
    import com.dr.lp.pojo.User;
    import com.dr.lp.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    @RestController
    @RequestMapping("/user")
    public class UserController {
        @Autowired
        private UserService userService;
    
        /**
         * 查询
         * @return
         */
        @GetMapping("/findAll")
        public String findUser(){
            userService.rule();
           return "规则执行了";
        }
    }

:lemon:最后编写启动类

 package com.dr.lp;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringDroolsApplication {
        public static void main(String[] args) {
            SpringApplication.run(SpringDroolsApplication.class,args);
        }
    }

:lemon:执行结果