public RecordDao_Impl(RoomDatabase __db) { this.__db = __db; this.__insertionAdapterOfRecord = new EntityInsertionAdapter<Record>(__db) { @Override public String createQuery() { return "INSERT OR ABORT INTO `records` (`id`,`content`,`hexadecimalContent`,`sendDevice`,`receiveDevice`,`messageType`,`createTime`,`itemType`) VALUES (nullif(?, 0),?,?,?,?,?,?,?)"; }

这段代码看起来是一个 Room 数据库的 DAO 实现类。其中的 RecordDao_Impl 类使用构造函数接收一个 RoomDatabase 对象，表示该 DAO 类需要访问的数据库实例。该类内部定义了一个 EntityInsertionAdapter 对象（名为 __insertionAdapterOfRecord），该对象用于插入 Record 实体对象到数据库表中。

在该类的构造函数中，会初始化这个 EntityInsertionAdapter 对象，并重写其 createQuery() 方法，返回一个插入语句。具体地，该插入语句用于将 Record 实体对象插入到名为 "records" 的数据库表中，包括 id、content、hexadecimalContent、sendDevice、receiveDevice、messageType、createTime 和 itemType 这几个列。其中插入语句使用了 SQLite 的 INSERT OR ABORT INTO 语法，保证了在插入过程中出现异常时的数据完整性。

相关问题

druid 多数据源_Springboot+mybatis(plus)+druid多数据源

在Spring Boot项目中使用MyBatis Plus和Druid多数据源的步骤如下：

1. 添加依赖

在`pom.xml`文件中添加以下依赖：

<!-- MyBatis Plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3.1</version>
</dependency>

<!-- Druid -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.6</version>
</dependency>

2. 配置Druid数据源

在`application.yml`中添加Druid数据源的配置：

spring:
  datasource:
    # 主数据源
    druid:
      url: jdbc:mysql://localhost:3306/main_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
      # Druid配置
      initialSize: 5
      minIdle: 5
      maxActive: 20
      testOnBorrow: false
      testOnReturn: false
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      validationQuery: SELECT 1 FROM DUAL
    # 从数据源
    druid2:
      url: jdbc:mysql://localhost:3306/sub_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
      # Druid配置
      initialSize: 5
      minIdle: 5
      maxActive: 20
      testOnBorrow: false
      testOnReturn: false
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      validationQuery: SELECT 1 FROM DUAL

3. 配置MyBatis Plus

在`application.yml`中添加MyBatis Plus的配置：

mybatis-plus:
  # 主数据源配置
  mapper-locations: classpath:mapper/main/*.xml
  type-aliases-package: com.example.main.entity
  global-config:
    db-config:
      id-type: auto
      field-strategy: not_empty
      logic-delete-value: 1
      logic-not-delete-value: 0
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # 从数据源配置
  multi-datasource:
    main:
      mapper-locations: classpath:mapper/main/*.xml
      type-aliases-package: com.example.main.entity
    sub:
      mapper-locations: classpath:mapper/sub/*.xml
      type-aliases-package: com.example.sub.entity

4. 配置数据源路由

在`com.example.config`包下创建`DynamicDataSourceConfig`类，用于配置数据源路由：

@Configuration
public class DynamicDataSourceConfig {

    @Bean
    @ConfigurationProperties("spring.datasource.druid")
    public DataSource mainDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid2")
    public DataSource subDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    public DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put("main", mainDataSource());
        dataSourceMap.put("sub", subDataSource());
        // 将主数据源作为默认数据源
        dynamicDataSource.setDefaultTargetDataSource(mainDataSource());
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        return dynamicDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dynamicDataSource());
        sqlSessionFactoryBean.setTypeAliasesPackage("com.example.main.entity");
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/main/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory());
    }

}

5. 配置数据源切换

在`com.example.config`包下创建`DynamicDataSource`类，用于实现数据源切换：

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }

}

在`com.example.config`包下创建`DataSourceContextHolder`类，用于存储当前数据源：

public class DataSourceContextHolder {

    private static final ThreadLocal<String> DATASOURCE_CONTEXT_HOLDER = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        DATASOURCE_CONTEXT_HOLDER.set(dataSource);
    }

    public static String getDataSource() {
        return DATASOURCE_CONTEXT_HOLDER.get();
    }

    public static void clearDataSource() {
        DATASOURCE_CONTEXT_HOLDER.remove();
    }

}

在`com.example.aop`包下创建`DataSourceAspect`类，用于切换数据源：

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(com.example.annotation.DataSource)")
    public void dataSourcePointCut() {
    }

    @Before("dataSourcePointCut()")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        DataSource dataSource = signature.getMethod().getAnnotation(DataSource.class);
        if (dataSource != null) {
            String value = dataSource.value();
            DataSourceContextHolder.setDataSource(value);
        }
    }

    @After("dataSourcePointCut()")
    public void after(JoinPoint joinPoint) {
        DataSourceContextHolder.clearDataSource();
    }

}

6. 使用多数据源

在需要使用从数据源的方法上加上`@DataSource("sub")`注解，如：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> listUsers() {
        DataSourceContextHolder.setDataSource("sub");
        List<User> users = userMapper.selectList(null);
        DataSourceContextHolder.clearDataSource();
        return users;
    }

}

这样就完成了Spring Boot项目中使用MyBatis Plus和Druid多数据源的配置。

java activiti 工作流引擎_Activiti 快速入门指南（创建流程引擎）

Activiti 是一个流程引擎框架，可以帮助开发者快速实现工作流相关的应用。下面是使用 Activiti 创建流程引擎的步骤：

1. 创建 maven 项目，添加 Activiti 依赖。

在项目的 pom.xml 文件中添加以下依赖：

<dependency>
    <groupId>org.activiti</groupId>
    <artifactId>activiti-engine</artifactId>
    <version>5.22.0</version>
</dependency>

2. 创建流程引擎配置类。

在项目中创建一个 Java 类，用于配置流程引擎。可以在该类中指定数据库连接信息、流程图文件路径等信息。以下是一个示例配置类：

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.activiti.engine.ProcessEngine;
import org.activiti.engine.ProcessEngineConfiguration;
import org.activiti.engine.impl.cfg.StandaloneProcessEngineConfiguration;

public class ActivitiConfig {

    public ProcessEngine getProcessEngine() throws IOException {
        // 读取配置文件
        InputStream inputStream = getClass().getResourceAsStream("/activiti.properties");
        Properties properties = new Properties();
        properties.load(inputStream);

        // 配置流程引擎
        ProcessEngineConfiguration cfg = new StandaloneProcessEngineConfiguration()
                .setJdbcUrl(properties.getProperty("jdbc.url"))
                .setJdbcUsername(properties.getProperty("jdbc.username"))
                .setJdbcPassword(properties.getProperty("jdbc.password"))
                .setJdbcDriver(properties.getProperty("jdbc.driver"))
                .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_FALSE);

        // 创建流程引擎
        ProcessEngine processEngine = cfg.buildProcessEngine();

        return processEngine;
    }

}

在该配置类中，我们读取一个名为 activiti.properties 的配置文件，该文件包含了数据库连接信息。在实际开发中，我们可以将这些信息存储在外部配置文件中，以便于修改和管理。

3. 创建流程图文件。

使用 Activiti Modeler 工具创建流程图文件，或者手动编写 BPMN 2.0 标准的 XML 文件。将该文件放置在项目的 classpath 下，以便于程序能够读取。

4. 启动流程引擎。

在程序中使用上述配置类创建流程引擎实例，并启动该实例。以下是一个示例代码：

public static void main(String[] args) throws IOException {
    // 创建流程引擎配置类
    ActivitiConfig config = new ActivitiConfig();

    // 获取流程引擎实例
    ProcessEngine processEngine = config.getProcessEngine();

    // 输出流程引擎信息
    String name = processEngine.getName();
    String version = ProcessEngine.VERSION;
    System.out.println("流程引擎名称：" + name);
    System.out.println("流程引擎版本：" + version);

    // 关闭流程引擎
    processEngine.close();
}

在上述示例代码中，我们创建了一个 ActivitiConfig 实例，并使用该实例获取了流程引擎。获取流程引擎后，我们可以输出其名称和版本信息，并在程序结束时关闭该引擎。

以上就是使用 Activiti 创建流程引擎的步骤。开发者可以根据自己的需求对流程引擎进行配置和使用。