SpringBoot集成与应用Neo4j

文章目录

  • 前言
  • 集成
  • 使用
    • 定义实体
    • 配置
    • 定义Repository
    • 查询方法
      • 方式一:@Query
      • 方式二:Cypher语法构建器
      • 方式三:Example条件构建器
      • 方式四:DSL语法
    • 自定义方法
      • 自定义接口
      • 继承自定义接口
      • 实现自定义接口
        • neo4jTemplate
        • Neo4jClient
      • 自定义抽象类(执行与结果转换)

前言

本篇主要是对neo4j的集成应用,会给出普遍的用法,但不是很详细,如果需要详细的话,每种方式都可以单独一篇说明,但应用都是举一反三,并没有必要都进行详解,而且,一些特殊的用法也举例了,也给出了一个自定义方式的查询和结果转换,虽然算不上完美,但也是很简单的,也希望大家有所收获。

集成

使用高版本的Spring data,我boot版本2.7,下面两个依赖,随便引入一个就行,我试过都是可以地

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-neo4j</artifactId></dependency>
<!--两者任选其一,--><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-neo4j</artifactId><version>6.3.11</version></dependency>

使用

定义实体

我们先定义三个实体

  • job:作业实体
  • table:表实体
  • JobRelationship:关系实体
@Data
@Node("Job")
public class Job {@Id@GeneratedValueprivate Long id;private String name;@Propertyprivate String type;@Relationship("dep")private List<TableRelationship> tables;@Relationship("dep")private List<JobRelationship> jobs;
}
@Data
@Node
public class Table {@Id@GeneratedValueprivate Long id;private String name;private String type;@Relationship("dep")private List<Job> jobs;
}
@Data
@RelationshipProperties
public class JobRelationship {@Id@GeneratedValueprivate Long id;@TargetNodeprivate Job job;
}
@Data
@RelationshipProperties
public class TableRelationship {@Id@GeneratedValueprivate Long id;@TargetNodeprivate Table table;
}

上面三个实体的写法都一些不同,这里需要注意下:

  1. @Node:标注的实体为数据库对象实体,表示一个节点,其value值就是标签,如果不设置就是类名;
  2. @Id:标注的属性是主键字段;
  3. @GeneratedValue:主键字段,必须设置它的一个生成方式,如果是自己设置可以忽略;
  4. @Property标注的属性为数据库属性字段,可以不写这个注解,@Node标注的实体中的属性默认为数据库属性字段,同样,其value值也是数据库属性字段,也可以不写,类似做了映射;
  5. @Relationship:标注的属性为关系属性,值为关系的标签值,另一个值为关系的指向,默认从当前节点向外指向,类似关系型数据库的关系;
  6. @RelationshipProperties:标注的类为关系实体,是对@Relationship类型的描述;
  7. @TargetNode:标注的属性是关系中的目标节点;

更加详细说明在:spring Data Neo4j

配置

application.yml

spring:neo4j:uri: bolt://192.168.0.103:7687authentication:username: neo4jpassword: password

定义Repository

这里使用的是spring jpa的开发方式,它提供了增删改查的基础功能,定义如下:

@Repository
public interface TableRepository extends Neo4jRepository<Table, Long> {
}
@Repository
public interface JobRepository extends Neo4jRepository<Job, Long> {/*** 根据名称查找*/Job findByName(String name);/*** 节点name是否包含指定的值*/boolean existsByNameContaining(String name);/*** 强制删除节点*/Long deleteByName(String name);
}

那这个JPA的方式的话可以通过关键字和属性名定义查询方法,如上面的的findByName就可以实现通过名称查询,不需要写实现,这里只说这么多,详细的可以看:Spring Data JPA - Reference Documentation

查询方法

spring data提供的基础增删改查其实在在业务中是不够用的,但是,它额外的提供了一些条件构建器,使得我们可以借助一些快捷的API进行查询条件构造,以适应这些复杂查询,也就是动态语法。

方式一:@Query

说起JPA,自定义查询好像大多是用@Query注解进行标注的,比如:

    @Query("match(a:Job{name:$name}) return a")Job findByName2(@Param("name") String name);@Query("match(a:Job{name: $0) return a")List<Job> findByName3(@Param("name") String name);

这样的方式很简单是不是,但是存在的问题是,语句中的Job,name都是对应数据库里的标签和字段,所以这就和mybatis xml里的方式一样,如果数据库字段变更或标签变更需要全局替换。

方式二:Cypher语法构建器

Spring data提供了针对Cypher语法的构建器,可以让我们对复杂cypher的语法构建;

示例一:

match(a:Job) where a.name=‘liry’ return a order by a.id limit 1

// match(a:Job) where a.name='liry' return a order by a.id  limit 1// 创建节点对象:标签为 Job,别名 a  -> (a:Job)
Node temp = Cypher.node("Job").named("a");
// 构建查询声明对象
// 创建match查询:-> match(a:Job)
ResultStatement statement = Cypher.match(temp)// 添加条件:-> a.name=$name.where(temp.property("name").isEqualTo(Cypher.anonParameter(job.getName())))// 返回对象:return 别名 -> return a.returning(temp.getRequiredSymbolicName())// 排序:以属性id正序.orderBy(temp.property("id"))// 限制数量:1.limit(1)// 构建为语法对象.build();

示例二:

//  merge(a:Job{name:$name}) set a.type=$type return a// 构建参数
Map<String, Object> pro = new HashMap<>();
pro.put("name", job.getName());
// 创建节点对象:标签Job,别名a,并且设置参数  -> (a:Job{name:$name})
Node temp = Cypher.node("Job").named("a").withProperties(pro);
// 创建merge查询: -> merge(a:Job{name:$name})
ResultStatement statement = Cypher.merge(temp)// 设置值:-> a.type=$type.set(temp.property("type"),Cypher.anonParameter(job.getType()))// 返回对象:return别名 -> return a.returning(temp.getRequiredSymbolicName())// 构建声明对象.build();

示例三:

// MATCH (a:`Job` {name: $pcdsl01})-[r*..2]-(b:`Job`) RETURN a,b,r// 创建两个节点给,都死标签Job,别名分别是a,b,a节点关联属性name
Node node = Cypher.node("Job").named("a").withProperties("name", Cypher.anonParameter(name));
Node node2 = Cypher.node("Job").named("b");// 创建a-r-b的关系
Relationship r = node.relationshipBetween(node2).named("r").max(length);
// a-r->b
//        Relationship r = node.relationshipTo(node2).named("r").max(length);
// a<-r-b
//        Relationship r = node.relationshipFrom(node2).named("r").max(length);
// 创建match查询
ResultStatement statement = Cypher.match(r)// 返回对象.returning("a","b","r")// 构建声明对象.build();

这里的withProperties,我又用了另一种方式.withProperties("name", Cypher.anonParameter(name));,上面我传的是一个map,它这里其实很巧妙的做了一个适配,只要你以key value,那么便是偶数个参数,他会自动帮你绑定,或者传map也行。

方式三:Example条件构建器

Spring Data默认的Neo4jRepository是继承 了QueryByExampleExecutor,如下:

image-20231028185641361

那么它所能使用的方法是这些:

image-20231028222339087

其应用示例一:

// Neo4jRepository默认继承了example功能Job job = new Job();job.setName("liry");ExampleMatcher exampleMatcher = ExampleMatcher.matching().withMatcher("na", ExampleMatcher.GenericPropertyMatchers.endsWith());// 根据示例匹配器规则进行条件重组 查询List<Job> all1 = jobRepository.findAll(Example.of(job, exampleMatcher));// 精确查询List<Job> all2 = jobRepository.findAll(Example.of(job));List<Job> all3 = jobRepository.findAll(Example.of(job), Sort.by(Sort.Order.desc("id")));Page<Job> all4 = jobRepository.findAll(Example.of(job), PageRequest.of(1, 10));

示例二:

流处理查询

  Job job = new Job();job.setJobName(name);// 查询一个一个值Job one = jobRepository.findBy(Example.of(job), query -> query.oneValue());// lambda简化
//        Job one = jobRepository.findBy(Example.of(job), FluentQuery.FetchableFluentQuery::oneValue);// 查询countLong count = jobRepository.findBy(Example.of(job), query -> query.count());// lambda简化
//        Long count = jobRepository.findBy(Example.of(job), FluentQuery.FetchableFluentQuery::count);// 是否存在Boolean exist = jobRepository.findBy(Example.of(job), query -> query.exists());// lambda简化
//        Boolean exist = jobRepository.findBy(Example.of(job), FluentQuery.FetchableFluentQuery::exists);// 查询全部List<Job> list = jobRepository.findBy(Example.of(job), query -> query.all());// lambda简化
//                List<Job> list = jobRepository.findBy(Example.of(job), FluentQuery.FetchableFluentQuery::all);// 查询2个List<Job> list2 = jobRepository.findBy(Example.of(job),query -> query.stream().limit(2).collect(Collectors.toList()));// 查询并进行处理List<Object> list3 = jobRepository.findBy(Example.of(job),query -> query.stream().peek(d -> d.setName(d.getName() + "1")).collect(Collectors.toList()));// 查询并排序List<Job> list4 = jobRepository.findBy(Example.of(job),query -> query.sortBy(Sort.by(Sort.Order.asc("id")))).all();

上面这个流处理查询都可以用lambda表达式来处理。

注意:使用example查询时,不要有关联关系,不然他会报错,即不要有@Relationship这个注解

方式四:DSL语法

这个是借助DSL框架实现的语法构建,添加DSL依赖

        <dependency><groupId>com.querydsl</groupId><artifactId>querydsl-jpa</artifactId></dependency><dependency><groupId>com.querydsl</groupId><artifactId>querydsl-apt</artifactId></dependency>

添加插件

 <plugin><groupId>com.mysema.maven</groupId><artifactId>apt-maven-plugin</artifactId><version>1.1.3</version><executions><execution><goals><goal>process</goal></goals><configuration><outputDirectory>target/generated-sources/java</outputDirectory><processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor></configuration></execution></executions>
</plugin>
  1. 实体类上需要加上@Entity

但是只引入neo4j的依赖,是不行的,还需要jpa的依赖,因为JPA依赖数据库,所以可以先引入,生成之后,再删除掉。

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version>
</dependency>

然后maven compile编译,一下,会在target/generated-sources/java目录下找到生成的Q类,把它复制到我们实体目录下

image-20231028192712827

  1. 继承接口QuerydslPredicateExecutor

    它的使用方式和Example一样。

    @Repository
    public interface JobRepository extends Neo4jRepository<Job, Long> ,  QuerydslPredicateExecutor<Job>{
    }
    

    这个接口下的功能都可以使用

    image-20231028222117957

示例一:

 QJob job = QJob.job;
// name=$nameIterable<Job> all = jobRepository.findAll(job.name.eq(name));// name like $name and type = $typeBooleanExpression exp = job.name.like(name).and(job.type.eq("test"));boolean exists = jobRepository.exists(exp);Iterable<Job> all1 = jobRepository.findAll(exp);
// 排序Iterable<Job> id = jobRepository.findAll(exp, Sort.by(Sort.Order.desc("id")));
// 分月Page<Job> all2 = jobRepository.findAll(exp, PageRequest.of(1, 10));// in查询  exp = job.name.in("liryc", "xx");jobRepository.findAll(exp);

示例二:

     // 查询一个一个值Job one = jobRepository.findBy(exp, query -> query.oneValue());// lambda简化//        Job one = jobRepository.findBy(exp, FluentQuery.FetchableFluentQuery::oneValue);// 查询countLong count = jobRepository.findBy(exp, query -> query.count());// lambda简化//        Long count = jobRepository.findBy(exp, FluentQuery.FetchableFluentQuery::count);// 是否存在Boolean exist = jobRepository.findBy(exp, query -> query.exists());// lambda简化//        Boolean exist = jobRepository.findBy(exp, FluentQuery.FetchableFluentQuery::exists);// 查询全部List<Job> list = jobRepository.findBy(exp, query -> query.all());// lambda简化//                List<Job> list = jobRepository.findBy(exp, FluentQuery.FetchableFluentQuery::all);// 查询2个List<Job> list2 = jobRepository.findBy(exp,query -> query.stream().limit(2).collect(Collectors.toList()));// 查询并进行处理List<Object> list3 = jobRepository.findBy(exp,query -> query.stream().peek(d -> d.setName(d.getName() + "1")).collect(Collectors.toList()));// 查询并排序List<Job> list4 = jobRepository.findBy(exp,query -> query.sortBy(Sort.by(Sort.Order.asc("id")))).all();

自定义方法

上面都是spring data自带的方法,已经可以实现大部分的复杂查询了,当时在业务层的时候我们一般不会把这些数据访问放在业务层中,这些都应该是置于底层作为最基本的数据能力,不该带入业务,并且也不该把数据访问的逻辑赤裸的放到业务层中,那么我们就会需要子党员方法。

自定义接口

public interface JobCustomRepository {/*** 查询所有*/Object selectAll();/*** 保持节点信息,会先判断是否存在*/Job saveCondition(Job job);/*** 创建或合并节点*/Job saveMerge(Job job);
}

继承自定义接口

@Repository
public interface JobRepository extends Neo4jRepository<Job, Long> , JobCustomRepository {}

实现自定义接口

@Component("jobCustomRepository")
public class JobCustomRepositoryImpl implements JobCustomRepository {
}

如此我们就可以在业务层中这样:

// 这里引入的接口,就具备了原本spring的能力,和你自定义的能力
@Autowiredprivate JobRepository jobRepository;
neo4jTemplate

在自定义中可以引入这个作为执行类,这个类实现Neo4jOperations,template它是支持直接写cypher语句的,比如下面这个

image-20231029002709607

image-20231029003215340

如果需要参数分离的话,参数占位用$,那么cypher语句应该是这样:

match(a) where a.name=$name return a

示例:

        // 方式一:template执行cql字符串String cql = String.format("merge(a:Job{name:'%s'}) set a.time=2 return a", job.getName());List<Job> all = neo4jTemplate.findAll(cql, Job.class);// 方式二:cypher语句cql = String.format("merge(a:Job{name:'%s'}) set a.time=$time return a", job.getName());Map<String, Object> param = new HashMap<>();param.put("time", 1);all = neo4jTemplate.findAll(cql, param, Job.class);// 方式三:Cypher构建声明对象Map<String, Object> pro = new HashMap<>();pro.put("name", job.getName());Node temp = Cypher.node("Job").named("a").withProperties(pro);ResultStatement statement = Cypher.merge(temp).set(temp.property("type"), Cypher.anonParameter(job.getType())).returning(temp.getRequiredSymbolicName()).build();List<Job> all1 = neo4jTemplate.findAll(statement, statement.getParameters(), Job.class);
Neo4jClient

除了neo4jTemplate还可以用neo4jClient

示例

        String cpl = "match(a) where a.name contains 'liry' return a limit 1";// 执行cypherResult run = client.getQueryRunner().run(cpl);// 结果获取的方式// **** 注意,下面的几种方式中,只能选用一种,在结果读取后,就不能在读取了 ****// 方式一:迭代器while (run.hasNext()) {Record d = run.next();// 这几个的结构差不多List<Pair<String, Value>> fields = d.fields();List<Value> values = d.values();Map<String, Object> stringObjectMap = d.asMap();System.out.println(d);}// 方式二:lambda// 或者直接获取列表List<Record> list = run.list();List<Record> dd = list.stream().map(d -> {List<Pair<String, Value>> fields = d.fields();List<Value> values = d.values();Map<String, Object> stringObjectMap = d.asMap();return d;}).collect(Collectors.toList());// 方式三:函数式接口List<Object> result = run.list(map -> {return map;});

这里有需要注意的地方,就是在run执行后,只能获取一次结果,如上代码所示,不论用那种方式进行结果的获取,都只能获取一次;

自定义抽象类(执行与结果转换)

但是很多人就会觉得这个方式需要自己处理结果集,确实,它的这个结果集不是很友好,所以我这里也提供一个结果处理案例;

我这里就直接贴已经完成的代码了,可以直接复制使用,同时这个类也提供了执行cypher语句的方法,和JPA一样。

package com.liry.neo.repository;import com.liry.neo.entity.RelationshipInfo;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import org.neo4j.driver.internal.types.InternalTypeSystem;
import org.neo4j.driver.internal.value.NodeValue;
import org.neo4j.driver.types.MapAccessor;
import org.neo4j.driver.types.Relationship;
import org.neo4j.driver.types.TypeSystem;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.neo4j.core.Neo4jOperations;
import org.springframework.data.neo4j.core.Neo4jTemplate;
import org.springframework.data.neo4j.core.PreparedQuery;
import org.springframework.data.neo4j.core.mapping.EntityInstanceWithSource;
import org.springframework.data.neo4j.core.mapping.Neo4jMappingContext;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;/*** @author ALI* @since 2023/10/25*/
public abstract class AbstractCustomRepository implements ApplicationContextAware {protected ApplicationContext applicationContext;private Neo4jMappingContext neo4jMappingContext;private Neo4jTemplate neo4jTemplate;private static <T> Supplier<BiFunction<TypeSystem, MapAccessor, ?>> getAndDecorateMappingFunction(Neo4jMappingContext mappingContext, Class<T> domainType, @Nullable Class<?> resultType) {Assert.notNull(mappingContext.getPersistentEntity(domainType), "Cannot get or create persistent entity.");return () -> {BiFunction<TypeSystem, MapAccessor, ?> mappingFunction = mappingContext.getRequiredMappingFunctionFor(domainType);if (resultType != null && domainType != resultType && !resultType.isInterface()) {mappingFunction = EntityInstanceWithSource.decorateMappingFunction(mappingFunction);}return mappingFunction;};}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}private Neo4jMappingContext getNeo4jMappingContext() {if (neo4jMappingContext == null) {neo4jMappingContext = applicationContext.getBean(Neo4jMappingContext.class);}return neo4jMappingContext;}private Neo4jTemplate getNeo4jTemplate() {if (neo4jTemplate == null) {neo4jTemplate = applicationContext.getBean(Neo4jTemplate.class);}return neo4jTemplate;}/*** 执行cypher查询** @param domainType      实体类型* @param cypherStatement cypher语句* @param parameters      参数*/protected <T> Neo4jOperations.ExecutableQuery<T> createExecutableQuery(Class<T> domainType, String cypherStatement,Map<String, Object> parameters) {return createExecutableQuery(domainType, domainType, cypherStatement, parameters);}/*** 执行cypher查询** @param domainType      实体类型* @param resultType      返回的结果类型* @param cypherStatement cypher语句* @param parameters      参数*/protected <T> Neo4jOperations.ExecutableQuery<T> createExecutableQuery(Class<?> domainType, Class<T> resultType, String cypherStatement,Map<String, Object> parameters) {PreparedQuery.OptionalBuildSteps<T> step = PreparedQuery.queryFor(resultType).withCypherQuery(cypherStatement).withParameters(parameters);// 基本类型转换if (!Number.class.isAssignableFrom(resultType) && !Boolean.class.isAssignableFrom(resultType) && !String.class.isAssignableFrom(resultType)) {Supplier<BiFunction<TypeSystem, MapAccessor, ?>> mappingFunction = getAndDecorateMappingFunction(getNeo4jMappingContext(),domainType,resultType);step.usingMappingFunction(mappingFunction);}return getNeo4jTemplate().toExecutableQuery(step.build());}protected <T> T mapping(Class<T> domainType, NodeValue node) {Object apply = getMappingFunction(domainType).get().apply(InternalTypeSystem.TYPE_SYSTEM, node);return (T) ((EntityInstanceWithSource) apply).getEntityInstance();}protected RelationshipInfo mapping(Relationship node) {RelationshipInfo result = new RelationshipInfo();result.setStart(node.startNodeId());result.setEnd(node.endNodeId());result.setType(node.type());result.setId(node.id());return result;}/*** 结果映射** @param domainType 实体类型,也是结果类型* @return 映射方法*/protected <T> Supplier<BiFunction<TypeSystem, MapAccessor, ?>> getMappingFunction(Class<T> domainType) {return () -> {BiFunction<TypeSystem, MapAccessor, T> mappingFunction = getNeo4jMappingContext().getRequiredMappingFunctionFor(domainType);return EntityInstanceWithSource.decorateMappingFunction(mappingFunction);};}
}

之后我们自定义的Repository就要继承这个抽象类,以达到可以直接使用的功能,如下:

@Component("jobCustomRepository")
public class JobCustomRepositoryImpl extends AbstractCustomRepository implements JobCustomRepository {@Autowiredprivate Neo4jTemplate neo4jTemplate;
}

再定义一个关系实体:

@Data
public class RelationshipDto {private Long id;private Long start;private Long end;private String type;
}

然后我们查询并转换如下:

        String cpl = "match(a:Job)-[r*]-(b:Job) return a,b,r";// 执行cypherResult run = client.getQueryRunner().run(cpl);// 结果接受容器Set<Object> nodes = new HashSet<>();Set<Object> relationships = new HashSet<>();// 结果转换List<Record> list = run.list();list.forEach(d -> {// cypher中,别名a,b是表示节点,那么这里就取 a,b的值转换为实体nodes.add(mappingNode(Job.class, d.get("a")));nodes.add(mappingNode(Job.class, d.get("b")));// 然后获取关系Value r = d.get("r");Value a = d.get("a");List<Object> reList = r.asList().stream().map(rd -> {System.out.println(rd);return mappingRelationship((org.neo4j.driver.types.Relationship) rd);}).collect(Collectors.toList());relationships.addAll(reList);});

image-20231030210428356

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/176332.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

企业级JAVA、数据库等编程规范之命名风格 —— 超详细准确无误

&#x1f9f8;欢迎来到dream_ready的博客&#xff0c;&#x1f4dc;相信你对这两篇博客也感兴趣o (ˉ▽ˉ&#xff1b;) &#x1f4dc; 表白墙/留言墙 —— 初级SpringBoot项目&#xff0c;练手项目前后端开发(带完整源码) 全方位全步骤手把手教学 &#x1f4dc; 用户登录前后端…

【计算机网络笔记】传输层——可靠数据传输原理之Rdt协议

系列文章目录 什么是计算机网络&#xff1f; 什么是网络协议&#xff1f; 计算机网络的结构 数据交换之电路交换 数据交换之报文交换和分组交换 分组交换 vs 电路交换 计算机网络性能&#xff08;1&#xff09;——速率、带宽、延迟 计算机网络性能&#xff08;2&#xff09;…

基于深度学习的人脸表情识别 计算机竞赛

文章目录 0 前言1 技术介绍1.1 技术概括1.2 目前表情识别实现技术 2 实现效果3 深度学习表情识别实现过程3.1 网络架构3.2 数据3.3 实现流程3.4 部分实现代码 4 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 基于深度学习的人脸表情识别 该项目较…

视频汇聚平台EasyCVR分发的流如何进行token鉴权?具体步骤是什么?

视频监控EasyCVR平台能在复杂的网络环境中&#xff0c;将分散的各类视频资源进行统一汇聚、整合、集中管理&#xff0c;在视频监控播放上&#xff0c;TSINGSEE青犀视频安防监控汇聚平台可支持1、4、9、16个画面窗口播放&#xff0c;可同时播放多路视频流&#xff0c;也能支持视…

智安网络|保护您的应用程序免受攻击:重要的安全强化措施

在今天的数字化时代&#xff0c;应用程序安全成为了企业和个人必须重视的重要领域。应用程序普遍存在的安全漏洞成为黑客们进行攻击的一个突破口。为了保护敏感数据和个人隐私&#xff0c;我们必须了解并实施一系列的关键措施来加固应用程序的安全性。 首先&#xff0c;一个关…

SSM培训报名管理系统开发mysql数据库web结构java编程计算机网页源码eclipse项目

一、源码特点 SSM 培训报名管理系统是一套完善的信息系统&#xff0c;结合SSM框架完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用SSM框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主 要采用B/S模式开…

Mac docker+vscode

mac 使用docker vs code 通过vscode 可以使用docker容器的环境。 可以在容器安装gdb, 直接调试代码。 创建容易时候可以指定目录和容易目录可以共享文件。

十年回望 -- JAVA

十年 十年时间&#xff0c;弹指一挥&#xff0c;好像一直都是在为工作奔波&#xff0c;匆匆忙忙的十年。 一、个人介绍 本人毕业于一所很普通的公办专科院校&#xff08;全日制统招大专&#xff09;&#xff0c;专业是软件技术&#xff0c;当初能进入计算机这一行业&#xff0…

数字孪生与智慧城市:开启未来智慧生活

在数字时代的浪潮中&#xff0c;数字孪生技术和智慧城市的理念相互交织&#xff0c;共同塑造了一个更智能、更可持续、更宜居的未来。数字孪生是一项前沿技术&#xff0c;将虚拟世界与现实世界相融合&#xff0c;为城市管理者和市民带来了前所未有的机遇和便捷。 数字孪生模型是…

FreeRTOS深入教程(空闲任务和Tick中断深入分析)

文章目录 前言一、空闲任务源码分析二、Tick中断深入分析总结 前言 本篇文章主要带大家深入分析空闲任务和Tick中断的作用。 一、空闲任务源码分析 在启动调度器时会创建出空闲任务&#xff1a; /* 启动调度器 */ vTaskStartScheduler();在空闲任务中会调用到prvCheckTasks…

Unity地面交互效果——2、动态法线贴图实现轨迹效果

Unity引擎动态法线贴图制作球滚动轨迹 大家好&#xff0c;我是阿赵。   之前说了一个使用局部UV采样来实现轨迹的方法。这一篇在之前的基础上&#xff0c;使用法线贴图进行凹凸轨迹的绘制。 一、实现的目标 先来回顾一下&#xff0c;上一篇最终我们已经绘制了一个轨迹的贴图…

ASCB1系列智能微型断路器在科技馆中的应用-安科瑞黄安南

【摘要】&#xff1a;安科瑞电气厂家直供黄安南1876-15//06-237&#xff0c;ASCB1系列智能微型断路器是安科瑞电气股份有限公司全新推出的智慧用电产品&#xff0c;产品由智能微型断路器与智能网关两部分组成&#xff0c;可用于对用电线路的关键电气因素&#xff0c;如电压、电…

数据交易是什么?国内的数据交易有哪些?

目录 数据交易是什么&#xff1f;国内的数据交易有哪些&#xff1f; 数据交易的概念 国内数据交易发展历程 数据交易主体 国内数据交易市场面临的问题 如何解决&#xff1a; 明确交易标准&#xff0c;推动交易市场&#xff0c;制定规则&#xff0c;完善数据监管机制&…

coturn服务器的搭建

Window下搭建coturn服务器&#xff1a; 准备材料&#xff1a; 1、安装Cygwin&#xff0c;地址&#xff1a;https://cygwin.com/install.html 由于Window无法直接部署coturn&#xff0c;因此需要下载安装Cygwin在Window上部署Linux虚拟环境。 在安装的时候需要安装几下packe…

第18期 | GPTSecurity周报

GPTSecurity是一个涵盖了前沿学术研究和实践经验分享的社区&#xff0c;集成了生成预训练 Transformer&#xff08;GPT&#xff09;、人工智能生成内容&#xff08;AIGC&#xff09;以及大型语言模型&#xff08;LLM&#xff09;等安全领域应用的知识。在这里&#xff0c;您可以…

框架安全-CVE 漏洞复现DjangoFlaskNode.jsJQuery框架漏洞复现

目录 服务攻防-框架安全&CVE复现&Django&Flask&Node.JS&JQuery漏洞复现中间件列表介绍常见语言开发框架Python开发框架安全-Django&Flask漏洞复现Django开发框架漏洞复现CVE-2019-14234&#xff08;Django JSONField/HStoreField SQL注入漏洞&#xff…

实用篇-Linux

一、Linux介绍 linux特点 免费开源多用户多任务 Linux系统版本分为内核版和发行版 发行版是基于内核版进行扩展&#xff0c;由各个Linux厂商开发和维护&#xff0c;因为我们真正使用linux最终安装的其实是linux的发行版 下面以CentOS为例来学习Linux 二、Linux安装 安装方式…

编写Groovy Hello World 程序

使用 IntelliJ IDEA 打开 IntelliJ IDEA&#xff0c;并创建一个新的 Groovy 项目。 在项目中创建一个新的 Groovy 类文件&#xff0c;命名为 HelloWorld.groovy。 在 HelloWorld.groovy 文件中&#xff0c;编写以下代码&#xff1a; class HelloWorld {static void main(Stri…