使用SpringData同时访问MySQL和Neo4j数据库_Java

本文将以实例的方式探索「如何使用 spring data 同时访问 mysql 和 neo4j 数据库？」，涉及 spring boot 中多个数据源的配置、多个事务的配置，以及多组 repository 的使用。

为了使演示工程更接近于实际，我们特为该工程设定一个场景：即使用该工程实现 mysql 到 neo4j 的数据迁移。技术上会涉及使用两组 repository 进行读写，以及关系型数据库的表到 neo4j 的 node 和 relationship 的转换。

介绍工程结构和主要代码块之前，先演示一下该工程实现的功能：

1 功能展示

该工程针对 mysql 的三张表进行了数据迁移，迁移到 neo4j 后变为了 node 和 relationship。

mysql 中的三张表为：actor（演员）、movie（电影）、actor_movie（演员电影关系表）。

建表语句与插入语句如下：

create table actor (
    id bigint auto_increment primary key,
    name varchar(100) not null,
    nationality varchar(100) not null,
    year_of_birth int not null
);

create table movie (
    id bigint auto_increment primary key,
    name varchar(100) not null,
    released_at int not null
);

create table actor_movie (
    actor_id bigint not null,
    movie_id bigint not null,
    role varchar(100) not null,
    primary key (actor_id, movie_id)
);

insert into actor(name, nationality, year_of_birth) values
    ('吴京', '中国', 1974),
    ('卢靖姗', '中国', 1985);

insert into movie(name, released_at) values
    ('战狼 ⅱ', 2017),
    ('太极宗师', 1998),
    ('流浪地球 ⅱ', 2023),
    ('我和我的家乡', 2020);

insert into actor_movie(actor_id, movie_id, role) values
    (1, 1, '冷峰'),
    (1, 2, '杨昱乾'),
    (1, 3, '刘培强'),
    (2, 1, 'rachel'),
    (2, 4, 'emma meier');

进行数据迁移后，neo4j 中的 node 和 relationship 如下:

功能展示完成后，下面介绍该示例工程的结构以及关键代码块。

2 工程结构及关键代码分析

该示例工程是一个使用 maven 管理的 spring boot 工程，其各依赖项及其版本如下：

java: liberica jdk 17.0.7
maven: 3.9.2
spring boot: 3.4.5

2.1 工程结构及依赖

该示例工程的结构如下：

spring-data-jpa-and-neo4j-demo
├─ src
│  ├─ main
│  │  ├─ java
│  │  │  └─ com.example.demo
│  │  │     ├─ config
│  │  │     │  ├─ mysqlconfig.java
│  │  │     │  └─ neo4jconfig.java
│  │  │     ├─ repository
│  │  │     │  ├─ graph
│  │  │     │  │  ├─ graphactorrepository.java
│  │  │     │  │  └─ graphmovierepository.java
│  │  │     │  └─ relational
│  │  │     │  │  ├─ actorrepository.java
│  │  │     │  │  ├─ movierepository.java
│  │  │     │  │  └─ actormovierepository.java
│  │  │     ├─ service
│  │  │     │  ├─ migrationservice.java
│  │  │     │  └─ impl
│  │  │     │     └─ migrationserviceimpl.java
│  │  │     ├─ model
│  │  │     │  ├─ graph
│  │  │     │  │  ├─ graphactor.java
│  │  │     │  │  └─ graphmovie.java
│  │  │     │  └─ relational
│  │  │     │  │  ├─ actor.java
│  │  │     │  │  ├─ movie.java
│  │  │     │  │  └─ actormovie.java
│  │  │     └─ demoapplication.java
│  │  └─ resources
│  │     └─ application.yaml
│  └─ test
│     └─ java
│        └─ com.example.demo
│           └─ service
│              └─ migrationservicetest.java
└─ pom.xml

可以看到，其是一个标准的 maven 工程，demoapplication.java 为启动类，application.yaml 为配置文件。config 包下用于放置配置类，mysqlconfig.java 和 neo4jconfig.java 分别用于配置 mysql 和 neo4j 的连接信息读取和事务管理。repository 包下用于放置访问数据库的 repository 接口，其中 relational 子目录下放置的是访问 mysql 的 repository，graph 子目录下放置的是访问 neo4j 的 repository。model 包下放置 model 类，relational 子目录下放置的是对应 mysql 表的 model 类，graph 子目录下放置的是对应 neo4j node 的 model 类。此外 service 包下用于放置服务类，我们编写的 migrationservice.java 及其实现即是做 mysql 到 neo4j 数据迁移的。

该示例工程用到的依赖如下：

<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-jpa</artifactid>
    </dependency>
    <dependency>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-data-neo4j</artifactid>
    </dependency>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
        <optional>true</optional>
    </dependency>

    <!-- driver -->
    <dependency>
        <groupid>com.mysql</groupid>
        <artifactid>mysql-connector-j</artifactid>
        <version>9.2.0</version>
    </dependency>

    <!-- test -->
    <dependency>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-test</artifactid>
        <scope>test</scope>
    </dependency>
</dependencies>

可以看到，该工程主要有两项依赖 spring-boot-starter-data-jpa 和 spring-boot-starter-data-neo4j，前者用于访问 mysql，后者用于访问 neo4j。此外，使用 lombok 方便 getters 和 setters 的编写，mysql-connector-j 为访问 mysql 的驱动，spring-boot-starter-test 为单元测试依赖。

2.2 工程配置

该工程的配置文件 application.yaml 的内容如下

spring:
  datasource:
    jdbc-url: jdbc:mysql://localhost:3306/test?autoreconnect=true&useunicode=true&characterencoding=utf-8&servertimezone=gmt%2b8
    username: root
    password: root
  jpa:
    show-sql: true
  neo4j:
    uri: bolt://localhost:7687/neo4j
    authentication:
      username: neo4j
      password: neo4j

logging:
  level:
    org.neo4j.ogm: debug
    org.springframework.data.neo4j: debug

可以看到，我们配置了两个数据源：spring.datasource 配置的是 mysql 的连接信息，spring.neo4j 配置的是 neo4j 的连接信息。此外，我们还开启了 sql 和 neo4j cypher 语句的打印。

介绍完工程结构、依赖和配置后，下面介绍关键的代码块。

2.3 config 类

要支持在 spring boot 中同时操作 mysql 和 neo4j，配置类是关键。

下面是 mysqlconfig.java 的代码：

package com.example.demo.config;
// ...

@configuration
@enabletransactionmanagement
@enablejparepositories(
        basepackages = "com.example.demo.repository.relational",
        entitymanagerfactoryref = "mysqlentitymanagerfactory",
        transactionmanagerref = "mysqltransactionmanager"
)
public class mysqlconfig {

    @bean(name = "mysqldatasource")
    @configurationproperties(prefix = "spring.datasource")
    public datasource mysqldatasource() {
        return datasourcebuilder.create().build();
    }

    @bean(name = "mysqlentitymanagerfactory")
    public localcontainerentitymanagerfactorybean mysqlentitymanagerfactory(
            entitymanagerfactorybuilder builder,
            @qualifier("mysqldatasource") datasource datasource) {
        return builder.datasource(datasource)
                .packages("com.example.demo.model.relational")
                .persistenceunit("mysql")
                .build();
    }

    @bean(name = "mysqltransactionmanager")
    public platformtransactionmanager mysqltransactionmanager(
            @qualifier("mysqlentitymanagerfactory") entitymanagerfactory factory) {
        return new jpatransactionmanager(factory);
    }
}

可以看到，我们在该类中指定了 mysql repository 的位置、数据库连接信息在配置文件中的位置，并配置了 mysql 的实体管理器和事务管理器。

下面是 neo4jconfig.java 的代码：

package com.example.demo.config;
// ...

@configuration
@enabletransactionmanagement
@enableneo4jrepositories(
        basepackages = "com.example.demo.repository.graph",
        transactionmanagerref = "neo4jtransactionmanager"
)
public class neo4jconfig {

    @bean(name = "neo4jtransactionmanager")
    public platformtransactionmanager transactionmanager(driver driver) {
        return neo4jtransactionmanager.with(driver)
                .build();
    }
}

可以看到，我们在该配置类中指定了 neo4j repository 的位置并配置了 neo4j 的事务管理器。

2.4 model 类

model 类用于对应 mysql 数据库的表或对应 neo4j 数据库的 node。

下面是 actor.java 的代码，其对应 mysql 的 actor 表。

package com.example.demo.model.relational;
// ...

@data
@entity(name = "actor")
public class actor {

    @id
    @generatedvalue(strategy = generationtype.identity)
    @column(name = "id")
    private long actorid;
    private string name;
    private string nationality;
    private integer yearofbirth;
}

下面是 graphactor.java 的代码，其对应 neo4j 的 actor node。

package com.example.demo.model.graph;
// ...

@data
@node("actor")
public class graphactor {

    @id
    @generatedvalue
    private long id;

    private long actorid;
    private string name;
    private string nationality;
    private integer yearofbirth;
}

relational 或 graph 包下其它的 model 类与此两者类似，为了控制篇幅，其代码就不在这里一一列出了。

2.5 repository 接口

repository 用于真正与数据库交互。

下面是 actorrepository.java 的代码，其用于对 mysql 的 actor 表进行增删改查。

package com.example.demo.repository.relational;
// ...

public interface actorrepository extends jparepository<actor, long> {
}

下面是 graphactorrepository.java 的代码，其用于对 neo4j 的 actor node 进行增删改查。

package com.example.demo.repository.graph;
// ...

public interface graphactorrepository extends neo4jrepository<graphactor, long> {

    @transactional("neo4jtransactionmanager")
    @query("""
            unwind $actors as actor
            merge (a:actor {actorid: actor.actorid})
            on create set a = actor
            on match set a += actor
            """)
    void batchinsertorupdate(list<map<string, object>> actors);
}

可以看到，与普通 jpa repository 类似，neo4j 的 repository 上同样支持编写自定义查询。之所以编写该方法，是因为使用该自定义 cypher 方式编写的 actor 批量插入或更新方法比原生方式效率更高。

relational 或 graph 包下其它的 repository 与此两者类似，这里也不一一列出了。

2.6 service 类

migrationservice 实现类的代码如下，其对前面的 model 和 repository 进行了使用，实现了 mysql 到 neo4j 的数据迁移。

package com.example.demo.service.impl;
// ...

@service
public class migrationserviceimpl implements migrationservice {

    @autowired
    private actorrepository actorrepository;
    @autowired
    private movierepository movierepository;
    @autowired
    private actormovierepository actormovierepository;
    @autowired
    private graphactorrepository graphactorrepository;
    @autowired
    private graphmovierepository graphmovierepository;

    @override
    public void migrateactorsandmovies() {
        // migrate all actors
        migrateallactors();

        // migrate all movies
        migrateallmovies();

        // delete all acted_in relations
        graphmovierepository.deleteallactedinrelations();

        // rebuild acted_in relations
        list<map<string, object>> actedinrelations = getallactedinrelations();
        graphmovierepository.batchinsertorupdateactedinrelations(actedinrelations);
    }

    private void migrateallactors() {
        list<actor> actors = actorrepository.findall();

        list<map<string, object>> graphactors = actors.stream()
                .map(this::assembleactor)
                .tolist();

        graphactorrepository.batchinsertorupdate(graphactors);
    }

    private void migrateallmovies() {
        list<movie> movies = movierepository.findall();

        list<map<string, object>> graphmovies = movies.stream()
                .map(this::assemblemovie)
                .tolist();

        graphmovierepository.batchinsertorupdate(graphmovies);
    }

    private list<map<string, object>> getallactedinrelations() {
        list<actormovie> actormovies = actormovierepository.findall();

        return actormovies.stream()
                .map(this::assembleactedin)
                .tolist();
    }

    private map<string, object> assembleactor(actor actor) {
        graphactor graphactor = new graphactor();
        beanutils.copyproperties(actor, graphactor);
        graphactor.setid(null);

        return objecttomaputil.tomap(graphactor);
    }

    private map<string, object> assemblemovie(movie movie) {
        graphmovie graphmovie = new graphmovie();
        beanutils.copyproperties(movie, graphmovie);
        graphmovie.setid(null);

        return objecttomaputil.tomap(graphmovie);
    }

    private map<string, object> assembleactedin(actormovie actormovie) {
        return map.of(
                "actorid", actormovie.getid().getactorid(),
                "movieid", actormovie.getid().getmovieid(),
                "role", actormovie.getrole()
        );
    }
}

可以看到，该实现类对 mysql 进行读取，对 neo4j 进行写入，实现了两个数据库的模式转换和数据迁移。

需要注意的是，我们使用了一个 java 对象到 map 类型转换的工具类 objecttomaputil.java，这是因为 neo4j 的 repository 目前还不能很好的支持直接传入一个 list<actor> 对象。

最后，在单元测试类中调用该实现类后，即可出现文章开头展示的效果。

3 小结

综上，我们以实现 mysql 到 neo4j 数据迁移为目的演示了如何使用 spring data 同时访问 mysql 和 neo4j 数据库。

参考资料

[1] spring: spring data jpa - https://docs.spring.io/spring-data/jpa/reference/jpa.html

[2] spring: spring data neo4j reference documentation - https://docs.spring.io/spring-data/neo4j/reference/

到此这篇关于使用springdata同时访问mysql和neo4j数据库的文章就介绍到这了,更多相关springdata同时访问mysql和neo4j内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！