Spring Data Neo4J 使用

最新推荐文章于 2024-06-06 19:19:07 发布
最新推荐文章于 2024-06-06 19:19:07 发布
阅读量4.1k 收藏 14
点赞数
分类专栏： javaweb技术 互联网技术 文章标签： springboot neo4j springdataneo4j
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014229652/article/details/94385601
版权

  1. maven引入

    <dependency>    
    <groupId>org.springframework.boot</groupId>    			 
    <artifactId>spring-boot-starter-data-neo4j</artifactId>
</dependency>

  2. uri配置

    #neo4j
spring.data.neo4j.uri = bolt://neo4j:7687
spring.data.neo4j.username= neo4j
spring.data.neo4j.password= 123456

  3. 事务配置

    使用multiTransactionManager这个事务管理器，可以让mysql和neo4j的的修改同时提交或者回滚

    package com.zhibi.malling.aop;

import com.zhibi.malling.annotation.EnableNeo4j;
import org.neo4j.ogm.session.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.data.neo4j.transaction.Neo4jTransactionManager;
import org.springframework.data.transaction.ChainedTransactionManager;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;

/**
 * @author QinHe at 2019-05-31
 */
@SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
//@Aspect
@Configuration
@DependsOn("sessionFactory")
@ConditionalOnBean(annotation = EnableNeo4j.class)
//@EnableTransactionManagement
public class TransactionAspect {

    ThreadLocal<TransactionStatus> transactionStatusThreadLocal = new ThreadLocal<>();

    /**
     * 定义mysql事务管理器，必须有transactionManager作为默认事务管理器
     *
     * @param emf
     * @return
     */
    @Bean("transactionManager")
    @Primary
    public JpaTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }

    /**
     * 定义neo4j事务管理器
     *
     * @param sessionFactory
     * @return
     */
    @Bean("neo4jTransactionManager")
    public Neo4jTransactionManager neo4jTransactionManager(SessionFactory sessionFactory) {
        return new Neo4jTransactionManager(sessionFactory);
    }

//    @Autowired
//    @Qualifier("neo4jTransactionManager")
//    Neo4jTransactionManager neo4jTransactionManager;
//    @Autowired
//    @Qualifier("transactionManager")
//    JpaTransactionManager jpaTransactionManager;

    @Autowired
    @Bean(name = "multiTransactionManager")
    public PlatformTransactionManager multiTransactionManager(
            Neo4jTransactionManager neo4jTransactionManager,
            JpaTransactionManager mysqlTransactionManager) {
        return new ChainedTransactionManager(
                neo4jTransactionManager, mysqlTransactionManager);
    }

//    @Around("@annotation(com.zhibi.malling.annotation.MultiTransaction)")
//    public Object multiTransaction(ProceedingJoinPoint proceedingJoinPoint) {
//        TransactionStatus neo4jTransactionStatus = neo4jTransactionManager.getTransaction(new DefaultTransactionDefinition());
//        TransactionStatus jpaTransactionStatus = jpaTransactionManager.getTransaction(new DefaultTransactionDefinition());
//        try {
//            Object obj = proceedingJoinPoint.proceed();
//            //注意：事务之间必须是包含关系，不能交叉
//            jpaTransactionManager.commit(jpaTransactionStatus);
//            neo4jTransactionManager.commit(neo4jTransactionStatus);
//            return obj;
//        } catch (Throwable throwable) {
//            jpaTransactionManager.rollback(jpaTransactionStatus);
//            neo4jTransactionManager.rollback(neo4jTransactionStatus);
//            throw new RuntimeException(throwable);
//        }
//    }
}

  4. 节点实体类orm

    package com.zhibi.malling.user.spi.neo4j;

import com.alibaba.fastjson.JSONObject;
import com.zhibi.malling.user.spi.enums.BonusConfig;
import com.zhibi.malling.utils.DateUtil;
import io.swagger.annotations.ApiModelProperty;
import org.neo4j.ogm.annotation.*;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.*;

/**
 * @author QinHe at 2019-05-27
 */
@NodeEntity(label = "User")
public class UserProfile implements Serializable {

    private static final long serialVersionUID = 3870028896024217898L;

    @Id
    @GeneratedValue
    private Long id;

    @Property(name = "userId")
    @Index(unique = true)
    private Long userId;

    @Property(name = "phone")
    private String phone;

    @Property(name = "nickname")
    private String nickname;

    @Property(name = "mallingBonusRole")
    @ApiModelProperty("mallingBonusRole(1=JP,2=SP,3=EP)")
    private Byte mallingBonusRole;

    @Property(name = "marginPaid")
    @ApiModelProperty("marginPaid(1=已交保证金)")
    private Byte marginPaid;

    @Property(name = "fastStartBonusRoleLastMonth")
    @ApiModelProperty("上个月FB级别(S/M/L)")
    private Byte fastStartBonusRoleLastMonth;

    @Property(name = "fastStartBonusRole")
    @ApiModelProperty("fastStartBonusRole(S/M/L)")
    private Byte fastStartBonusRole;

    @Property(name = "fastStartCheckTime")
    @ApiModelProperty("FastStart按钮点击时间，转换成yyyyMMddHHmmss格式，以Long型数据展示")
    private Long fastStartCheckTime;

    @Property(name = "unilevelBonusRole")
    @ApiModelProperty("unilevelBonusRole(L1..L7)")
    private Byte unilevelBonusRole;

    @Property(name = "depth")
    private Long depth;

    @Property(name = "version")
    @Version
    private Long version;

    @Transient
    private JSONObject other = new JSONObject();

    public UserProfile() {
    }

    public enum MallingBonusRoleEnum {
        COMMON((byte) 0),
        JP((byte) 1),
        SP((byte) 2),
        EP((byte) 3);
        private Byte code;

        MallingBonusRoleEnum(Byte code) {
            this.code = code;
        }

        public Byte getCode() {
            return code;
        }
    }

    public enum FastStartBonusRoleEnum {
        COMMON((byte) 0, (byte) 1, BigDecimal.ZERO),
        S((byte) 1, (byte) 2, BonusConfig.S_LEVEL_CONDITION, EarningsLevelForFBEnum.LEVEL_1, EarningsLevelForFBEnum.LEVEL_2),
        M((byte) 2, (byte) 3, BonusConfig.M_LEVEL_CONDITION, EarningsLevelForFBEnum.LEVEL_1, EarningsLevelForFBEnum.LEVEL_2, EarningsLevelForFBEnum.LEVEL_3),
        L((byte) 3, null, BonusConfig.L_LEVEL_CONDITION, EarningsLevelForFBEnum.LEVEL_1, EarningsLevelForFBEnum.LEVEL_2, EarningsLevelForFBEnum.LEVEL_3, EarningsLevelForFBEnum.LEVEL_4);

        private static Map<Byte, FastStartBonusRoleEnum> map = new HashMap<>();

        static {
            for (FastStartBonusRoleEnum fastStartBonusRoleEnum : FastStartBonusRoleEnum.values()) {
                map.put(fastStartBonusRoleEnum.getCode(), fastStartBonusRoleEnum);
            }
        }

        private Byte code;
        private Byte nextRoleCode;
        private BigDecimal pvNeed;
        private EarningsLevelForFBEnum[] levelEnums;

        FastStartBonusRoleEnum(Byte code, Byte nextRoleCode, BigDecimal pvNeed, EarningsLevelForFBEnum... bonusLevels) {
            this.code = code;
            this.nextRoleCode = nextRoleCode;
            this.pvNeed = pvNeed;
            this.levelEnums = bonusLevels;
        }

        public static FastStartBonusRoleEnum getEnumByCode(Byte code) {
            return map.get(code);
        }

        public Byte getCode() {
            return code;
        }

        public Byte getNextRoleCode() {
            return nextRoleCode;
        }

        public BigDecimal getPvNeed() {
            return pvNeed;
        }

        public EarningsLevelForFBEnum[] getLevelEnums() {
            return levelEnums;
        }
    }

    public enum UnilevelBonusRoleEnum {
        COMMON((byte) 0),
        L1((byte) 1, EarningsLevelForUBEnum.LEVEL_1),
        L2((byte) 2, EarningsLevelForUBEnum.LEVEL_2, EarningsLevelForUBEnum.LEVEL_1),
        L3((byte) 3, EarningsLevelForUBEnum.LEVEL_3, EarningsLevelForUBEnum.LEVEL_2, EarningsLevelForUBEnum.LEVEL_1),
        L4((byte) 4, EarningsLevelForUBEnum.LEVEL_4, EarningsLevelForUBEnum.LEVEL_3, EarningsLevelForUBEnum.LEVEL_2, EarningsLevelForUBEnum.LEVEL_1),
        L5((byte) 5, EarningsLevelForUBEnum.LEVEL_5, EarningsLevelForUBEnum.LEVEL_4, EarningsLevelForUBEnum.LEVEL_3, EarningsLevelForUBEnum.LEVEL_2, EarningsLevelForUBEnum.LEVEL_1),
        L6((byte) 6, EarningsLevelForUBEnum.LEVEL_6, EarningsLevelForUBEnum.LEVEL_5, EarningsLevelForUBEnum.LEVEL_4, EarningsLevelForUBEnum.LEVEL_3, EarningsLevelForUBEnum.LEVEL_2, EarningsLevelForUBEnum.LEVEL_1),
        L7((byte) 7, EarningsLevelForUBEnum.LEVEL_7, EarningsLevelForUBEnum.LEVEL_6, EarningsLevelForUBEnum.LEVEL_5, EarningsLevelForUBEnum.LEVEL_4, EarningsLevelForUBEnum.LEVEL_3, EarningsLevelForUBEnum.LEVEL_2, EarningsLevelForUBEnum.LEVEL_1);

        private static Map<Byte, UnilevelBonusRoleEnum> map = new HashMap<>();

        static {
            for (UnilevelBonusRoleEnum unilevelBonusRoleEnum : UnilevelBonusRoleEnum.values()) {
                map.put(unilevelBonusRoleEnum.getCode(), unilevelBonusRoleEnum);
            }
        }

        private Byte code;
        private EarningsLevelForUBEnum[] levelEnums;

        UnilevelBonusRoleEnum(Byte code, EarningsLevelForUBEnum... levelEnums) {
            this.code = code;
            this.levelEnums = levelEnums;
        }

        public static UnilevelBonusRoleEnum getEnumByCode(Byte code) {
            return map.get(code);
        }

        public Byte getCode() {
            return code;
        }

        public EarningsLevelForUBEnum[] getLevelEnums() {
            return levelEnums;
        }
    }

    public enum EarningsLevelForFBEnum {
        LEVEL_1(1, BonusConfig.DIRECTLY_LEVEL1_INCOME),
        LEVEL_2(2, BonusConfig.DIRECTLY_LEVEL2_INCOME),
        LEVEL_3(3, BonusConfig.DIRECTLY_LEVEL3_INCOME),
        LEVEL_4(4, BonusConfig.DIRECTLY_LEVEL4_INCOME),
        ;

        private static Map<Integer, EarningsLevelForFBEnum> map = new HashMap<>();

        static {
            for (EarningsLevelForFBEnum earningsLevelForFBEnum : EarningsLevelForFBEnum.values()) {
                map.put(earningsLevelForFBEnum.getCode(), earningsLevelForFBEnum);
            }
        }

        private Integer code;
        private BigDecimal bonusPercentage;

        EarningsLevelForFBEnum(Integer code, BigDecimal bonusPercentage) {
            this.code = code;
            this.bonusPercentage = bonusPercentage;
        }

        public static EarningsLevelForFBEnum getEnumByCode(Integer code) {
            return map.get(code);
        }

        public Integer getCode() {
            return code;
        }

        public BigDecimal getBonusPercentage() {
            return bonusPercentage;
        }
    }

    public enum EarningsLevelForUBEnum {
        LEVEL_1(1, BonusConfig.UNILEVEL_L1, BonusConfig.UNILEVEL_LEVEL1_LEVEL4_INCOME),
        LEVEL_2(2, BonusConfig.UNILEVEL_L2, BonusConfig.UNILEVEL_LEVEL1_LEVEL4_INCOME),
        LEVEL_3(3, BonusConfig.UNILEVEL_L3_L7, BonusConfig.UNILEVEL_LEVEL1_LEVEL4_INCOME),
        LEVEL_4(4, BonusConfig.UNILEVEL_L3_L7, BonusConfig.UNILEVEL_LEVEL1_LEVEL4_INCOME),
        LEVEL_5(5, BonusConfig.UNILEVEL_L3_L7, BonusConfig.UNILEVEL_LEVEL5_INCOME),
        LEVEL_6(6, BonusConfig.UNILEVEL_L3_L7, BonusConfig.UNILEVEL_LEVEL6_INCOME),
        LEVEL_7(7, BonusConfig.UNILEVEL_L3_L7, BonusConfig.UNILEVEL_LEVEL7_INCOME);

        private static Map<Integer, EarningsLevelForUBEnum> map = new HashMap<>();

        static {
            for (EarningsLevelForUBEnum earningsLevelForUBEnum : EarningsLevelForUBEnum.values()) {
                map.put(earningsLevelForUBEnum.getCode(), earningsLevelForUBEnum);
            }
        }

        private Integer code;
        private BigDecimal pvCondition;
        private BigDecimal bonusPercentage;

        EarningsLevelForUBEnum(Integer code, BigDecimal pvCondition, BigDecimal bonusPercentage) {
            this.code = code;
            this.pvCondition = pvCondition;
            this.bonusPercentage = bonusPercentage;
        }

        public static EarningsLevelForUBEnum getEnumByCode(Integer code) {
            return map.get(code);
        }

        public Integer getCode() {
            return code;
        }

        public BigDecimal getPvCondition() {
            return pvCondition;
        }

        public BigDecimal getBonusPercentage() {
            return bonusPercentage;
        }
    }
}

  5. 关系实体类

    package com.zhibi.malling.user.spi.neo4j;

import com.alibaba.fastjson.JSONObject;
import org.neo4j.ogm.annotation.*;

import java.io.Serializable;
import java.util.Date;

/**
 * @author QinHe at 2019-05-27
 */

@RelationshipEntity(type = "Invite")
public class InviteRelation implements Serializable {
    private static final long serialVersionUID = 3870028896024217898L;

    @Id
    @GeneratedValue
    private Long id;

    /**
     * 定义关系的起始节点 == StartNode
     */
    @StartNode
    private UserProfile startNode;

    /**
     * 定义关系的终止节点 == EndNode
     */
    @EndNode
    private UserProfile endNode;

    private Date createTime;

    private Long inviterId;

    private Long inviteeId;

    @Transient
    private JSONObject other = new JSONObject();

    @Property(name = "version")
    @Version
    private Long version;

    public InviteRelation() {
    }

    public JSONObject getOther() {
        return other;
    }

    public void setOther(JSONObject other) {
        this.other = other;
    }

    public UserProfile getStartNode() {
        return startNode;
    }

    public void setStartNode(UserProfile startNode) {
        this.startNode = startNode;
    }

    public UserProfile getEndNode() {
        return endNode;
    }

    public void setEndNode(UserProfile endNode) {
        this.endNode = endNode;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Long getInviterId() {
        return inviterId;
    }

    public void setInviterId(Long inviterId) {
        this.inviterId = inviterId;
    }

    public Long getInviteeId() {
        return inviteeId;
    }

    public void setInviteeId(Long inviteeId) {
        this.inviteeId = inviteeId;
    }

    public Long getVersion() {
        return version;
    }

    public void setVersion(Long version) {
        this.version = version;
    }

}

  6. Jpa的Repository

    package com.zhibi.malling.repository.neo4j;

import com.zhibi.malling.user.spi.neo4j.UserProfile;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.neo4j.annotation.Query;
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.data.repository.query.Param;

import java.util.List;

/**
 * @author QinHe at 2019-05-27
 */
public interface UserNeo4jRepository extends Neo4jRepository<UserProfile, Long> {
    UserProfile findByUserId(Long userId);

    @Query(" match(inviter:User)-[r:Invite*1..]->(invitee:User) where inviter.userId = {inviterId} return  invitee")
    List<UserProfile> getAllInvitees(@Param("inviterId") Long inviterId);

    @Query(" match(invitee:User)<-[r:Invite*1..]-(inviter:User) where invitee.userId = {inviteeId} return  inviter")
    List<UserProfile> getAllInviters(@Param("inviteeId") Long inviteeId);

    @Query(" match(invitee:User)<-[r:Invite]-(inviter:User) where invitee.userId = {inviteeId} return  inviter")
    UserProfile getInviter(@Param("inviteeId") Long inviteeId);

    @Query(" match(inviter:User)-[r:Invite]->(invitee:User) where inviter.userId = {inviterId} return  count(invitee.userId)")
    long countDirectByInviterId(@Param("inviterId") Long inviterId);

    @Query(" match(inviter:User)-[r:Invite]->(invitee:User) where inviter.userId = {inviterId} and invitee.mallingBonusRole in {inviteeRoleList} return  count(invitee.userId)")
    long countDirectByInviterIdAndInviteeRole(@Param("inviterId") Long inviterId, @Param("inviteeRoleList") List<Byte> inviteeRoleList);

    @Query(" match(inviter:User)-[r:Invite]->(invitee:User) where inviter.userId = {inviterId} and invitee.mallingBonusRole={inviteeRole} return  count(invitee.userId)")
    long countDirectByInviterIdAndInviteeRole(@Param("inviterId") Long inviterId, @Param("inviteeRole") Byte inviteeRole);

    @Query(" match(inviter:User)-[r:Invite]->(invitee:User) where inviter.userId = {inviterId} return  count(invitee.userId)")
    UserProfile getNearestInviter(@Param("inviterId") Long inviterId);

    @Query(value = " match(inviter:User)-[r:Invite*0..]->(invitee:User) where inviter.userId = {inviterId} and invitee.userId in {userIdList}" +
            "  and invitee.totalDirectInviteJpCount<{mallingBonusJpUpgradeSpCondition} return invitee order by totalDirectInviteJpCount desc ",
            countQuery = " match(inviter:User)-[r:Invite*0..]->(invitee:User) where inviter.userId = {inviterId} and invitee.userId in {userIdList}" +
                    "  and invitee.totalDirectInviteJpCount<{mallingBonusJpUpgradeSpCondition} return count(invitee) ")
    Page<UserProfile> getInviteesForUpgradeEp(@Param("legId") Long legId, @Param("userIdList") List<Long> userIdList, Integer mallingBonusJpUpgradeSpCondition, Pageable pageable);

    @Query(" match(inviter:User)-[r1:Invite]->(leg:User)-[r2:Invite*0..]->(invitee:User) where inviter.userId = {inviterId} and invitee.userId={userId} return leg ")
    UserProfile findLeg(@Param("inviterId") Long inviterId, @Param("userId") Long userId);

    @Query("match(inviter:User)-[r:Invite*]->(invitee:User) where inviter.userId = {userId} and not (invitee)-->() RETURN count(invitee)")
    Long getFarthestInviteeCount(@Param("userId") Long userId);

    @Query("match(inviter:User)-[r:Invite*]->(invitee:User) where inviter.userId = {userId} and not (invitee)-->() RETURN invitee order by invitee.id skip {skip} limit {limit}")
    List<UserProfile> getFarthestInvitee(@Param("userId") Long userId, @Param("skip") Long skip, @Param("limit") Long limit);

    @Query("match(head:User{userId:{headUserId}}), (farthest:User{userId:{farthestUserId}}), p=shortestPath((head)-[Invite*]-(farthest)) RETURN p")
    List<UserProfile> getInviteePath(@Param("headUserId") Long headUserId, @Param("farthestUserId") Long farthestUserId);

    @Query(value = "match(inviter:User)-[r:Invite]->(invitee:User) where inviter.userId = {userId} return invitee order by invitee.userId desc",
            countQuery = "match(inviter:User)-[r:Invite]->(invitee:User) where inviter.userId = {userId} return count(invitee.userId)")
    Page<UserProfile> getDirectInviteePage(@Param("userId") Long userId, Pageable pageable);

    @Query("match(inviter:User)-[r:Invite*]->(invitee:User) where inviter.userId = {userId} return count(invitee.userId)")
    long countAllInvitee(@Param("userId") Long userId);

    @Query("match(:User{userId:{topUserId}})-[:Invite*1]->(leg:User)-[:Invite*0..]-> (:User{userId:{childUserId}}) return leg")
    UserProfile getLegUser(@Param("topUserId") Long headUserId, @Param("childUserId") Long childUserId);
}

  7. 事务的使用：

    @Transactional(rollbackFor = Exception.class, value = "multiTransactionManager")

  8. 使用原生的session进行复杂查询

    @Override
    public List<UserProfile> getAllInvitees(Long inviterId, Long depth, List<Byte> mallingBonusRoleList,
                                            List<Byte> fastStartBonusRoleList, List<Byte> unilevelBonusRoleList, Integer limit) {
        if (inviterId == null) {
            throw new CommonException("inviteeId is null");
        }
        String cql = "match(inviter:User)-[r:Invite*1..{depth}]->(invitee:User) where inviter.userId = {inviterId} ";
        if (depth != null) {
            cql = cql.replace("{depth}", depth.toString());
        } else {
            cql = cql.replace("{depth}", "");
        }
        cql = cql.replace("{inviterId}", inviterId.toString());

        if (mallingBonusRoleList != null && mallingBonusRoleList.size() > 0) {
            cql += " and invitee.mallingBonusRole in " + createInCypher(mallingBonusRoleList);
        }
        if (fastStartBonusRoleList != null && fastStartBonusRoleList.size() > 0) {
            cql += " and invitee.fastStartBonusRole in " + createInCypher(fastStartBonusRoleList);
        }
        if (unilevelBonusRoleList != null && unilevelBonusRoleList.size() > 0) {
            cql += " and invitee.unilevelBonusRole in " + createInCypher(unilevelBonusRoleList);
        }
        cql += " return  invitee ";
        if (limit != null) {
            cql += " limit " + limit;
        }
        Session session = SessionFactoryUtils.getSession(sessionFactory);
        Iterable<UserProfile> query = session.query(UserProfile.class, cql, Maps.newHashMap());
        return Lists.newArrayList(query);
    }

    @Override
    public String createInCypher(List<?> list) {
        if (list != null && list.size() > 0) {
            StringBuilder stringBuilder = new StringBuilder("[");
            list.forEach(o -> {
                if (o != null) {
                    if (o instanceof String) {
                        stringBuilder.append("\"").append(o).append("\",");
                    } else {
                        stringBuilder.append(o).append(",");
                    }
                }
            });
            stringBuilder.deleteCharAt(stringBuilder.length() - 1);
            stringBuilder.append("]");
            return stringBuilder.toString();
        }
        return null;
    }

  9. 异常信息解决

    在使用@Transactional(rollbackFor = Exception.class, value = “multiTransactionManager”)作为nei4j的事务管理的时候，commit时报异常：

    org.neo4j.ogm.exception.TransactionManagerException: "Transaction is not current for this thread"

    原因：因为springdataneo4j支持的cypher语句里面不支持depth，所以需要手动用原生的session来执行cql，在开启session时，使用了新的session而不是当前方法中当前线程的事务中的session，所以解决办法：

    Session session = sessionFactory.openSession();

    替换为：

    Session session = SessionFactoryUtils.getSession(sessionFactory);
qinhej
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring-data-neo4j
Breaking_xu的博客
05-16 938
一：项目需求，做一个类似企查查的关系图。 前端选择用Echarts，后端springboot+cloud,数据库gbase（国产）,考虑到关系型数据库存取关系数据的速度，故选择图形neo4j，把gbase的数据导入neo4j，然后java从neo4j取数据。 二：neo4j的安装 官网：https://neo4j.com/download/ ...
Spring Data Neo4j简介
张龙（风中叶）的专栏
11-08 8624
本文来源于我在InfoQ中文站原创的文章，原文地址是：http://www.infoq.com/cn/news/2013/11/spring-data-neo4j-introNeo4j是一款非常流行的开源图型NoSQL数据库。它完全支持ACID数据库事务属性，由于其良好的图数据模型设计，Neo4j的速度非常快。对于连接的数据操作，Neo4j的速度要比传统的关系型数据库快1000倍。Spring D
Spring Boot2 集成 Neo4j 实现知识图谱
lovelichao12的专栏
05-05 5131
一 Neo4j 简介 Neo4j是一个高性能的,NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。Neo4j也可以被看作是一个高性能的图引擎，该引擎具有成熟数据库的所有特性。程序员工作在一个面向对象的、灵活的网络结构下而不是严格、静态的表中——但是他们可以享受到具备完全的事务特性、企业级的数据库的所有好处。 1.1 图形数据结构 在一个图中包含两种基本的数据类型：Nodes（节点） 和 Relationships（关系）。Nodes 和 Relationships 包含key/value形式
【springboot&neo4j】版本差异对比
最新发布
qq_41767061的博客
06-06 1074
在旧版本的Spring Data Neo4j中，主要基于Neo4j OGM（Object-Graph Mapping）。这意味着我们需要使用包中的注解来定义Neo4j节点和关系。@Id。
Spring Data Neo4j
fxtxz2的专栏
03-24 3973
问题 使用响应式编程方式来访问Neo4j，这里假设已经准备好Neo4j服务器了。 Spring Initializr https://start.spring.io/ 在这个界面初始化工程： application.properties spring.neo4j.uri=neo4j://localhost:7687 spring.neo4j.authentication.username=neo4j spring.neo4j.authentication.password=neo4j spring.dat
访问Neo4j spring-data-neo4j入门 （一）
热门推荐
russle的专栏
04-14 2万+
Spring-data-neo4j实例入门 本文通过一个简单的电影和演员的实例简要介绍如何使用spring-data-neo4j访问neo4j数据库。 关于图数据库的理论以及使用场景不在本文的讨论访问，关于图数据库和关系数据库的比较也不在本文的讨论范围。 本文主要介绍一个简单的使用场景，就是Movie和Person， person和movie的关系有actor和director， 一个movi...
Spring Data Neo4j个人笔记
倒着走的码农
01-13 6731
Neo4j、Spring、图数据库、Spring Data Neo4j
movies-java-spring-data-neo4j:使用Spring Data Neo4j的Neo4j电影示例
05-13
电影示例应用 如何一起使用Spring Boot，Spring Data和Neo4j。 Spring Data Neo4j可以在基于Spring的应用程序中方便地集成Neo4j。 它提供了对象图映射（OGM）功能以及Spring Data项目共有的其他功能。 笔记该项目...
spring data Neo4j 整合demo
01-14
spring data Neo4j 整合demo,基本整合案例，详细细节参考https://docs.spring.io/spring-data/neo4j/docs/5.1.3.RELEASE/reference/html
Spring Data Neo4j API（Spring Data Neo4j 开发文档）.CHM
08-31
官网 Spring Data Neo4j API。 Spring Data Neo4j 开发文档。 Spring Data Neo4j API
Spring-Data-Neo4j-Example
05-26
Spring-Data-Neo4j-示例在此示例中，以下是我的技术堆栈： Spring-Data-Neo4j 胸腺Lambok项目（注意：首先，对于lambok项目，您需要使用eclipse配置lambok项目） JDK 8 谷歌番石榴将项目导入为Maven，但在导入项目...
neo4j整合spring data文档
12-02
Spring Data Neo4j（SDN）是Spring Data项目的一部分，它提供了一种在Java应用中使用Neo4j的简便方式，包括自动映射对象到图模型以及事务管理。 **Spring Data Neo4j的配置** 1. **依赖添加**：首先，在Maven或...
小白学习记录之springboot连接neo4j配置
qq_43465336的博客
02-21 803
学习记录之springboot连接neo4j配置 项目场景： 最近在学配置 springboot连接Neo4j 问题描述： 看到许多博客都提示应该像下面这么写，但是我们这么写之后，显示后两句被划掉了，猜测可能是语法老了？ @Override #spring.data.neo4j.uri=bolt://localhost spring.data.neo4j.username=neo4j（用户名） spring.data.neo4j.password=123456（密码） 解决方案： 通过百度，发现
Springboot连接Neo4j 完整版（提供代码)
Karenmaxx的博客
05-18 7432
文章目录application.propertiespom.xmltest文件entity节点类RepositoryJsonSimple 先展示我的项目目录???? application.properties pom.xml test文件 entity节点类 Repository 每个节点需要对应写一个 JsonSimple 转换成Json格式输出 ...
springboot + neo4j 知识图谱开发
u012674854的博客
06-02 4719
一 、开发背景 最近公司里面要做知识图谱功能，需要后端支持一些查询操作，所以写了一个基本的例子。我自己对于知识图谱的理解也加深了很多。因为我是从零开始的，就是奔着出功能去的，所以可能有些操作会有过时了，或者不是最好的等问题，望担待。 二、一些基础知识 知识图谱相关： 什么是知识图谱? 知识图谱(Knowledge Graph)之综述理解 主要是了解知识图谱是个啥玩意，包括哪几部分等 cypher基本语法(neo4j数据库使用的，类似于mysql数据库使用的是sql语法。。。大概这样) Neo
springboot配置redis报错(报红线)Deprecated configuration property 'spring.redis.pool.max-active'
enthan809882的博客
03-08 7048
报错信息为： Deprecated configuration property ‘spring.redis.pool.max-active’ 报错配置为： #连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-active=80 # 连接池最大阻塞等待时间（使用负值表示没有限制） spring.redis.pool.max-wait=-1 # 连接池中的最大空闲...
Spring中简单使用Neo4j
fxtxz2的专栏
03-24 2083
问题 最近需要了解在Spring中使用Neo4j，这里就简单按照官网教程实践了一波。 Spring Initializr 访问https://start.spring.io/网页，完成工程的初始化： 这里主要依赖了Spring Data Neo4j的库，点击生成按钮获得工程初始化代码即可。 Neo4j Server 按照之前的neo4j的Hello World文章，准备一个neo4j服务器即可。neo4j初始化如下图： Entity 这里准备一个简单实体，具体代码如下： package com.exam
SpringDataNeo4j实现分页查询和使用Session的方法进行复杂查询
KimiKudo的博客
08-20 7453
主要记录使用repository的分页查询,session执行cql,apoc执行cql的复杂查询
【Neo4j】Springboot + Neo4j 使用原生查询遇到的坑
全力奔跑，梦在彼岸
09-08 2503
前言      小编最近在使用neo4j 查询的时候遇到一点小问题，特此记录下来，接下来的学习应用要先看官网文档。
Spring data neo4j的使用
05-02
使用Spring Data Neo4j，您可以将Neo4j作为您的应用程序的数据存储，使用Java对象来表示节点和关系，并使用注释或接口定义查询和持久性操作。 下面是Spring Data Neo4j的使用步骤： 1. 添加依赖项 您需要将以下...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值