MongoDB基础入门到深入（八）MongoDB整合SpringBoot、Chang Streams

2024-05-24 11:44
文章标签 java 基础 springboot 入门 spring 深入 整合 mongodb chang streams

本文主要是介绍MongoDB基础入门到深入（八）MongoDB整合SpringBoot、Chang Streams，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 系列文章索引
  • 十五、MongoDB整合SpringBoot
    • 1、环境准备
    • 2、集合操作
    • 3、文档操作
      • （1）相关注解
      • （2）创建实体
      • （3）添加文档
      • （4）查询文档
      • （5）更新文档
      • （6）删除文档
      • （7）聚合操作
      • （8）小技巧：如何去掉_class属性
    • 4、事务操作
      • （1）编程式事务
      • （2）声明式事务
  • 十六、Chang Streams
    • 1、什么是 Chang Streams
    • 2、Change Stream 的实现原理
    • 3、MongoShell测试
    • 4、Change Stream 故障恢复
    • 5、使用场景
    • 6、Chang Stream整合Spring Boot

系列文章索引

MongoDB基础入门到深入（一）安装、文档操作
MongoDB基础入门到深入（二）聚合高级操作
MongoDB基础入门到深入（三）索引高级操作
MongoDB基础入门到深入（四）复制（副本）集
MongoDB基础入门到深入（五）分片集群
MongoDB基础入门到深入（六）多文档事务
MongoDB基础入门到深入（七）建模、调优
MongoDB基础入门到深入（八）MongoDB整合SpringBoot、Chang Streams

十五、MongoDB整合SpringBoot

1、环境准备

1、引入依赖

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

2、配置yml

spring:data:mongodb:uri: mongodb://root:root@192.168.56.10:27017/test?authSource=admin#uri等同于下面的配置#database: test#host: 192.168.56.10#port: 27017#username: root#password: root#authentication-database: admin#复制集  https://docs.mongodb.com/manual/reference/connection-string/#uri: mongodb://root:root@192.168.56.10:28017,192.168.56.10:28018,192.168.56.10:28019/test?authSource=admin&replicaSet=rs0

连接配置参考文档：https://www.mongodb.com/docs/manual/reference/connection-string/

3、使用时注入mongoTemplate

@Autowired
MongoTemplate mongoTemplate;

4、demo

//连接单点
//MongoClient mongoClient = MongoClients.create("mongodb://192.168.56.10:27017");
//连接副本集
MongoClient mongoClient = MongoClients.create("mongodb://root:root@192.168.56.10:28017,192.168.56.10:28018,192.168.56.10:28019/test?authSource=admin&replicaSet=rs0");
//连接分片集群  节点：mongos
//MongoClient mongoClient = MongoClients.create("mongodb://192.168.56.10:27017,192.168.56.11:27017,192.168.56.12:27017");//获得数据库对象
MongoDatabase database = mongoClient.getDatabase("test");
//获得集合
MongoCollection<Document> collection = database.getCollection("emp");System.out.println("emp文档数："+collection.countDocuments());

2、集合操作

@Test
public void testCollection() {boolean exists = mongoTemplate.collectionExists("emp");if (exists) {//删除集合mongoTemplate.dropCollection("emp");}//创建集合mongoTemplate.createCollection("emp");
}

3、文档操作

（1）相关注解

@Document
修饰范围: 用在类上
作用: 用来映射这个类的一个对象为mongo中一条文档数据。
属性:( value 、collection )用来指定操作的集合名称

@Id
修饰范围: 用在成员变量、方法上
作用: 用来将成员变量的值映射为文档的_id的值

@Field
修饰范围: 用在成员变量、方法上
作用: 用来将成员变量及其值映射为文档中一个key:value对。
属性:( name , value )用来指定在文档中 key的名称,默认为成员变量名

@Transient
修饰范围:用在成员变量、方法上
作用:用来指定此成员变量不参与文档的序列化

（2）创建实体

import java.util.Date;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;@Document("emp")  //对应emp集合中的一个文档
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Employee {@Id   //映射文档中的_idprivate Integer id;@Field("username")private String name;@Fieldprivate int age;@Fieldprivate Double salary;@Fieldprivate Date birthday;
}

（3）添加文档

insert方法返回值是新增的Document对象，里面包含了新增后_id的值。如果集合不存在会自动创建集合。通过Spring Data MongoDB还会给集合中多加一个_class的属性，存储新增时Document对应Java中类的全限定路径。这么做为了查询时能把Document转换为Java类型。

@Test
public void testInsert() {Employee employee = new Employee(1, "小明", 30, 10000.00, new Date());//添加文档// sava:  _id存在时更新数据//mongoTemplate.save(employee);// insert： _id存在抛出异常   支持批量操作mongoTemplate.insert(employee);List<Employee> list = Arrays.asList(new Employee(2, "张三", 21, 5000.00, new Date()),new Employee(3, "李四", 26, 8000.00, new Date()),new Employee(4, "王五", 22, 8000.00, new Date()),new Employee(5, "张龙", 28, 6000.00, new Date()),new Employee(6, "赵虎", 24, 7000.00, new Date()),new Employee(7, "赵六", 28, 12000.00, new Date()));//插入多条数据mongoTemplate.insert(list, Employee.class);
}

插入重复数据时: insert报 DuplicateKeyException提示主键重复; save对已存在的数据进行更新。
批处理操作时: insert可以一次性插入所有数据，效率较高;save需遍历所有数据，一次插入或更新，效率较低。

（4）查询文档

Criteria是标准查询的接口，可以引用静态的Criteria.where的把多个条件组合在一起，就可以轻松地将多个方法标准和查询连接起来，方便我们操作查询语句。
在这里插入图片描述

@Test
public void testFind() {System.out.println("==========查询所有文档===========");//查询所有文档List<Employee> list = mongoTemplate.findAll(Employee.class);list.forEach(System.out::println);System.out.println("==========根据_id查询===========");//根据_id查询Employee e = mongoTemplate.findById(1, Employee.class);System.out.println(e);System.out.println("==========findOne返回第一个文档===========");//如果查询结果是多个，返回其中第一个文档对象Employee one = mongoTemplate.findOne(new Query(), Employee.class);System.out.println(one);System.out.println("==========条件查询===========");//new Query() 表示没有条件//查询薪资大于等于8000的员工//Query query = new Query(Criteria.where("salary").gte(8000));//查询薪资大于4000小于10000的员工//Query query = new Query(Criteria.where("salary").gt(4000).lt(10000));//正则查询（模糊查询）  java中正则不需要有////Query query = new Query(Criteria.where("name").regex("张"));//and  or  多条件查询Criteria criteria = new Criteria();//and  查询年龄大于25&薪资大于8000的员工//criteria.andOperator(Criteria.where("age").gt(25),Criteria.where("salary").gt(8000));//or 查询姓名是张三或者薪资大于8000的员工criteria.orOperator(Criteria.where("name").is("张三"), Criteria.where("salary").gt(5000));Query query = new Query(criteria);//sort排序//query.with(Sort.by(Sort.Order.desc("salary")));//skip limit 分页  skip用于指定跳过记录数，limit则用于限定返回结果数量。query.with(Sort.by(Sort.Order.desc("salary"))).skip(0)  //指定跳过记录数.limit(4);  //每页显示记录数//查询结果List<Employee> employees = mongoTemplate.find(query, Employee.class);employees.forEach(System.out::println);
}

@Test
public void testFindByJson() {//使用json字符串方式查询//等值查询//String json = "{name:'张三'}";//多条件查询String json = "{$or:[{age:{$gt:25}},{salary:{$gte:8000}}]}";Query query = new BasicQuery(json);//查询结果List<Employee> employees = mongoTemplate.find(query, Employee.class);employees.forEach(System.out::println);
}

（5）更新文档

在Mongodb中无论是使用客户端API还是使用Spring Data，更新返回结果一定是受行数影响。如果更新后的结果和更新前的结果是相同，返回0。
updateFirst() 只更新满足条件的第一条记录
updateMulti() 更新所有满足条件的记录
upsert() 没有符合条件的记录则插入数据

@Test
public void testUpdate() {//query设置查询条件Query query = new Query(Criteria.where("salary").gte(15000));System.out.println("==========更新前===========");List<Employee> employees = mongoTemplate.find(query, Employee.class);employees.forEach(System.out::println);Update update = new Update();//设置更新属性update.set("salary", 13000);//updateFirst() 只更新满足条件的第一条记录//UpdateResult updateResult = mongoTemplate.updateFirst(query, update, Employee.class);//updateMulti() 更新所有满足条件的记录//UpdateResult updateResult = mongoTemplate.updateMulti(query, update, Employee.class);//upsert() 没有符合条件的记录则插入数据//update.setOnInsert("id",11);  //指定_idUpdateResult updateResult = mongoTemplate.upsert(query, update, Employee.class);//返回修改的记录数System.out.println(updateResult.getModifiedCount());//返回匹配的记录数System.out.println(updateResult.getMatchedCount());System.out.println("==========更新后===========");employees = mongoTemplate.find(query, Employee.class);employees.forEach(System.out::println);
}

（6）删除文档

@Test
public void testDelete() {//删除所有文档//mongoTemplate.remove(new Query(),Employee.class);//条件删除Query query = new Query(Criteria.where("salary").gte(10000));mongoTemplate.remove(query, Employee.class);}

（7）聚合操作

MongoTemplate提供了aggregate方法来实现对数据的聚合操作。

在这里插入图片描述
基于聚合管道mongodb提供的可操作的内容：
在这里插入图片描述
基于聚合操作Aggregation.group，mongodb提供可选的表达式：
在这里插入图片描述

// 以聚合管道示例2为例
// 返回人口超过1000万的州
db.zips.aggregate( [{ $group: { _id: "$state", totalPop: { $sum: "$pop" } } },{ $match: { totalPop: { $gt: 10*1000*1000 } } }
] )@Test
public void test(){//$groupGroupOperation groupOperation = Aggregation.group("state").sum("pop").as("totalPop");//$matchMatchOperation matchOperation = Aggregation.match(Criteria.where("totalPop").gte(10*1000*1000));// 按顺序组合每一个聚合步骤TypedAggregation<Zips> typedAggregation = Aggregation.newAggregation(Zips.class, groupOperation, matchOperation);//执行聚合操作,如果不使用 Map，也可以使用自定义的实体类来接收数据AggregationResults<Map> aggregationResults = mongoTemplate.aggregate(typedAggregation, Map.class);// 取出最终结果List<Map> mappedResults = aggregationResults.getMappedResults();for(Map map:mappedResults){System.out.println(map);}
}
// 返回各州平均城市人口
db.zips.aggregate( [{ $group: { _id: { state: "$state", city: "$city" }, cityPop: { $sum: "$pop" } } },{ $group: { _id: "$_id.state", avgCityPop: { $avg: "$cityPop" } } },{ $sort:{avgCityPop:-1}}
] )@Test
public void test2(){//$groupGroupOperation groupOperation = Aggregation.group("state","city").sum("pop").as("cityPop");//$groupGroupOperation groupOperation2 = Aggregation.group("_id.state").avg("cityPop").as("avgCityPop");//$sortSortOperation sortOperation = Aggregation.sort(Sort.Direction.DESC,"avgCityPop");// 按顺序组合每一个聚合步骤TypedAggregation<Zips> typedAggregation = Aggregation.newAggregation(Zips.class, groupOperation, groupOperation2,sortOperation);//执行聚合操作,如果不使用 Map，也可以使用自定义的实体类来接收数据AggregationResults<Map> aggregationResults = mongoTemplate.aggregate(typedAggregation, Map.class);// 取出最终结果List<Map> mappedResults = aggregationResults.getMappedResults();for(Map map:mappedResults){System.out.println(map);}
}

// 按州返回最大和最小的城市
db.zips.aggregate( [{ $group:{_id: { state: "$state", city: "$city" },pop: { $sum: "$pop" }}},{ $sort: { pop: 1 } },{ $group:{_id : "$_id.state",biggestCity:  { $last: "$_id.city" },biggestPop:   { $last: "$pop" },smallestCity: { $first: "$_id.city" },smallestPop:  { $first: "$pop" }}},{ $project:{ _id: 0,state: "$_id",biggestCity:  { name: "$biggestCity",  pop: "$biggestPop" },smallestCity: { name: "$smallestCity", pop: "$smallestPop" }}},{ $sort: { state: 1 } }
] )@Test
public void test3(){//$groupGroupOperation groupOperation = Aggregation.group("state","city").sum("pop").as("pop");//$sortSortOperation sortOperation = Aggregation.sort(Sort.Direction.ASC,"pop");//$groupGroupOperation groupOperation2 = Aggregation.group("_id.state").last("_id.city").as("biggestCity").last("pop").as("biggestPop").first("_id.city").as("smallestCity").first("pop").as("smallestPop");//$projectProjectionOperation projectionOperation = Aggregation.project("state","biggestCity","smallestCity").and("_id").as("state").andExpression("{ name: \"$biggestCity\",  pop: \"$biggestPop\" }").as("biggestCity").andExpression("{ name: \"$smallestCity\", pop: \"$smallestPop\" }").as("smallestCity").andExclude("_id");//$sortSortOperation sortOperation2 = Aggregation.sort(Sort.Direction.ASC,"state");// 按顺序组合每一个聚合步骤TypedAggregation<Zips> typedAggregation = Aggregation.newAggregation(Zips.class, groupOperation, sortOperation, groupOperation2,projectionOperation,sortOperation2);//执行聚合操作,如果不使用 Map，也可以使用自定义的实体类来接收数据AggregationResults<Map> aggregationResults = mongoTemplate.aggregate(typedAggregation, Map.class);// 取出最终结果List<Map> mappedResults = aggregationResults.getMappedResults();for(Map map:mappedResults){System.out.println(map);}}

（8）小技巧：如何去掉_class属性

@Configuration
public class MongoConfig {/*** 定制TypeMapper去掉_class属性* @param mongoDatabaseFactory* @param context* @param conversions* @return*/@BeanMappingMongoConverter mappingMongoConverter(MongoDatabaseFactory mongoDatabaseFactory,MongoMappingContext context, MongoCustomConversions conversions){DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDatabaseFactory);MappingMongoConverter mappingMongoConverter =new MappingMongoConverter(dbRefResolver,context);mappingMongoConverter.setCustomConversions(conversions);//构造DefaultMongoTypeMapper，将typeKey设置为空值mappingMongoConverter.setTypeMapper(new DefaultMongoTypeMapper(null));return mappingMongoConverter;}}

4、事务操作

官方文档：https://www.mongodb.com/docs/upcoming/core/transactions/

（1）编程式事务

/*** 事务操作API* https://docs.mongodb.com/upcoming/core/transactions/*/
@Test
public void updateEmployeeInfo() {//连接复制集MongoClient client = MongoClients.create("mongodb://root:root@192.168.56.10:28017,192.168.56.10:28018,192.168.56.10:28019/test?authSource=admin&replicaSet=rs0");MongoCollection<Document> emp = client.getDatabase("test").getCollection("emp");MongoCollection<Document> events = client.getDatabase("test").getCollection("events");//事务操作配置TransactionOptions txnOptions = TransactionOptions.builder().readPreference(ReadPreference.primary()).readConcern(ReadConcern.MAJORITY).writeConcern(WriteConcern.MAJORITY).build();try (ClientSession clientSession = client.startSession()) {//开启事务clientSession.startTransaction(txnOptions);try {emp.updateOne(clientSession,Filters.eq("username", "张三"),Updates.set("status", "inactive"));int i=1/0;events.insertOne(clientSession,new Document("username", "张三").append("status", new Document("new", "inactive").append("old", "Active")));//提交事务clientSession.commitTransaction();}catch (Exception e){e.printStackTrace();//回滚事务clientSession.abortTransaction();}}
}

（2）声明式事务

1、配置事务管理器

@Bean
MongoTransactionManager transactionManager(MongoDatabaseFactory factory){//事务操作配置
TransactionOptions txnOptions = TransactionOptions.builder().readPreference(ReadPreference.primary()).readConcern(ReadConcern.MAJORITY).writeConcern(WriteConcern.MAJORITY).build();return new MongoTransactionManager(factory);
}

2、编程测试service

@Service
public class EmployeeService {@AutowiredMongoTemplate mongoTemplate;@Transactionalpublic void addEmployee(){Employee employee = new Employee(100,"张三", 21,15000.00, new Date());Employee employee2 = new Employee(101,"赵六", 28,10000.00, new Date());mongoTemplate.save(employee);//int i=1/0;mongoTemplate.save(employee2);}
}

十六、Chang Streams

1、什么是 Chang Streams

Change Stream指数据的变化事件流，MongoDB从3.6版本开始提供订阅数据变更的功能。
Change Stream 是 MongoDB 用于实现变更追踪的解决方案，类似于关系数据库的触发器，但原理不完全相同：
在这里插入图片描述

2、Change Stream 的实现原理

Change Stream 是基于 oplog 实现的，提供推送实时增量的推送功能。它在 oplog 上开启一个 tailable cursor 来追踪所有复制集上的变更操作，最终调用应用中定义的回调函数。

被追踪的变更事件主要包括：
insert/update/delete：插入、更新、删除；
drop：集合被删除；
rename：集合被重命名；
dropDatabase：数据库被删除；
invalidate：drop/rename/dropDatabase 将导致 invalidate 被触发， 并关闭 change stream；
在这里插入图片描述

如果只对某些类型的变更事件感兴趣，可以使用使用聚合管道的过滤步骤过滤事件：

var cs = db.user.watch([{$match:{operationType:{$in:["insert","delete"]}}
}])

Change Stream会采用 "readConcern：majority"这样的一致性级别，保证写入的变更不会被回滚。因此：
未开启 majority readConcern 的集群无法使用 Change Stream；
当集群无法满足 {w: “majority”} 时，不会触发 Change Stream（例如 PSA 架构 中的 S 因故障宕机）。

3、MongoShell测试

# 窗口1
db.user.watch([],{maxAwaitTimeMS:1000000}).pretty()# 窗口2
db.user.insert({name:"xxxx"})

在这里插入图片描述
变更事件字段说明
在这里插入图片描述

4、Change Stream 故障恢复

假设在一系列写入操作的过程中，订阅 Change Stream 的应用在接收到“写3”之后 于 t0 时刻崩溃，重启后后续的变更怎么办？
在这里插入图片描述
想要从上次中断的地方继续获取变更流，只需要保留上次变更通知中的 _id 即可。 Change Stream 回调所返回的的数据带有 _id，这个 _id 可以用于断点恢复。例如：

var cs = db.collection.watch([], {resumeAfter: <_id>})

即可从上一条通知中断处继续获取后续的变更通知。

5、使用场景

跨集群的变更复制——在源集群中订阅 Change Stream，一旦得到任何变更立即写 入目标集群。
微服务联动——当一个微服务变更数据库时，其他微服务得到通知并做出相应的变更。
其他任何需要系统联动的场景。

案例 1.监控
用户需要及时获取变更信息（例如账户相关的表），ChangeStreams 可以提供监控功能，一旦相关的表信息发生变更，就会将变更的消息实时推送出去。

案例 2.分析平台
例如需要基于增量去分析用户的一些行为，可以基于 ChangeStreams 把数据拉出来，推到下游的计算平台， 比如 类似 Flink、Spark 等计算平台等等。

案例 3.数据同步
基于 ChangeStreams，用户可以搭建额外的 MongoDB 集群，这个集群是从原端的 MongoDB 拉取过来的， 那么这个集群可以做一个热备份，假如源端集群发生 网络不通等等之类的变故,备集群就可以接管服务。 还可以做一个冷备份，如用户基于 ChangeStreams 把数据同步到文件，万一源端数据库发生不可服务， 就可以从文件里恢复出完整的 MongoDB 数据库， 继续提供服务。（当然，此处还需要借助定期全量备份来一同完成恢复） 另外数据同步它不仅仅局限于同一地域，可以跨地域，从北京到上海甚至从中国到美国等等。

案例 4.消息推送
假如用户想实时了解公交车的信息，那么公交车的位置每次变动，都实时推送变更的信息给想了解的用 户，用户能够实时收到公交车变更的数据，非常便捷实用。

注意事项
Change Stream 依赖于 oplog，因此中断时间不可超过 oplog 回收的最大时间窗；
在执行 update 操作时，如果只更新了部分数据，那么 Change Stream 通知的也是增量部分；
删除数据时通知的仅是删除数据的 _id。

6、Chang Stream整合Spring Boot

1、引入依赖

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

2、配置yml

spring:data:mongodb:uri: mongodb://root:root@192.168.56.10:27017/test?authSource=admin#uri等同于下面的配置#database: test#host: 192.168.56.10#port: 27017#username: root#password: root#authentication-database: admin#复制集  https://docs.mongodb.com/manual/reference/connection-string/#uri: mongodb://root:root@192.168.56.10:28017,192.168.56.10:28018,192.168.56.10:28019/test?authSource=admin&replicaSet=rs0

3、配置 mongo监听器的容器MessageListenerContainer，spring启动时会自动启动监听的任务用于接收changestream

@Configuration
public class MongodbConfig {@BeanMessageListenerContainer messageListenerContainer(MongoTemplate template, DocumentMessageListener documentMessageListener) {Executor executor = Executors.newFixedThreadPool(5);MessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer(template, executor) {@Overridepublic boolean isAutoStartup() {return true;}};ChangeStreamRequest<Document> request = ChangeStreamRequest.builder(documentMessageListener).collection("user")  //需要监听的集合名//过滤需要监听的操作类型，可以根据需求指定过滤条件.filter(Aggregation.newAggregation(Aggregation.match(Criteria.where("operationType").in("insert", "update", "delete"))))//不设置时，文档更新时，只会发送变更字段的信息，设置UPDATE_LOOKUP会返回文档的全部信息.fullDocumentLookup(FullDocument.UPDATE_LOOKUP).build();messageListenerContainer.register(request, Document.class);return messageListenerContainer;}
}

4、配置mongo监听器，用于接收数据库的变更信息

@Component
public class DocumentMessageListener<S, T> implements MessageListener<S, T> {@Overridepublic void onMessage(Message<S, T> message) {System.out.println(String.format("Received Message in collection %s.\n\trawsource: %s\n\tconverted: %s",message.getProperties().getCollectionName(), message.getRaw(), message.getBody()));}}

5、测试
mongo shell插入一条文档
在这里插入图片描述
6、控制台输出
在这里插入图片描述

这篇关于MongoDB基础入门到深入（八）MongoDB整合SpringBoot、Chang Streams的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/998314。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
深入探索协同过滤：从原理到推荐模块案例

深入探索协同过滤：从原理到推荐模块案例

文章目录 前言一、协同过滤1. 基于用户的协同过滤（UserCF）2. 基于物品的协同过滤（ItemCF）3. 相似度计算方法 二、相似度计算方法1. 欧氏距离2. 皮尔逊相关系数3. 杰卡德相似系数4. 余弦相似度 三、推荐模块案例1.基于文章的协同过滤推荐功能2.基于用户的协同过滤推荐功能 前言     在信息过载的时代，推荐系统成为连接用户与内容的桥梁。本文聚焦于
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2