要想全面快速学习Spring的内容，最好的方法肯定是先去Spring官网去查阅文档，在Spring官网中找到了适合新手了解的官网Guides，一共68篇，打算全部过一遍，能尽量全面的了解Spring框架的每个特性和功能。
接着上篇看过的guide5，接着往下看。
guide6、Accessing data with neo4j
讲述了使用neo4j，将应用程序数据存储在基于图形的数据库neo4j中并从中检索数据。
首先了解下neo4j是什么
然后下载和启动neo4j
brew install neo4j
neo4j start
启动完成后，开始准备程序。
1、先定义一个简单的POJO
@Node
public class Person {
@Id @GeneratedValue private Long id;
private String name;
private Person() {
// Empty constructor required as of Neo4j API 2.0.5
};
public Person(String name) {
this.name = name;
}
/**
* Neo4j doesn't REALLY have bi-directional relationships. It just means when querying
* to ignore the direction of the relationship.
* https://dzone.com/articles/modelling-data-neo4j
*/
@Relationship(type = "TEAMMATE")
public Set<Person> teammates;
public void worksWith(Person person) {
if (teammates == null) {
teammates = new HashSet<>();
}
teammates.add(person);
}
public String toString() {
return this.name + "'s teammates => "
+ Optional.ofNullable(this.teammates).orElse(
Collections.emptySet()).stream()
.map(Person::getName)
.collect(Collectors.toList());
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Guide涉及注解：
@Node注解用来注释Person类。当 Neo4j 存储它时，会创建一个新节点。这个类也有一个id标记。@Node注解，声明这是一个节点类。
@Id与@GeneratedValue注解，声明该成员是一个自动生成的id，Neo4j中的id为长整型类Long；
@Relationship注解，声明该成员是与本节点有关的关系的列表，
type参数为该关系的名称； direction参数为该关系的方向，离开本节点（OUTGOING，默认）或进入本节点（INCOMING）。
注意：当关系一端的节点声明了此关系，另一端的节点一定不能声明同一关系，否侧会由于循环嵌套出现stackOverflow错误！
2、创建查询接口类
public interface PersonRepository extends Neo4jRepository<Person, Long> {
Person findByName(String name);
List<Person> findByTeammatesName(String name);
}
PersonRepository接口类继承了Neo4jRepository接口，并入参运行的类型Person. 该接口带有许多操作，包括标准的 CRUD（创建、读取、更新和删除）操作。
在本例中，添加了findByName，它通过name来寻找匹配的person节点。
3、具体的增删改操作
@Bean
CommandLineRunner demo(PersonRepository personRepository) {
return args -> {
personRepository.deleteAll();
Person greg = new Person("Greg");
Person roy = new Person("Roy");
Person craig = new Person("Craig");
List<Person> team = Arrays.asList(greg, roy, craig);
log.info("Before linking up with Neo4j...");
team.stream().forEach(person -> log.info("\t" + person.toString()));
personRepository.save(greg);
personRepository.save(roy);
personRepository.save(craig);
greg = personRepository.findByName(greg.getName());
greg.worksWith(roy);
greg.worksWith(craig);
personRepository.save(greg);
roy = personRepository.findByName(roy.getName());
roy.worksWith(craig);
personRepository.save(roy);
log.info("Lookup each person by name...");
team.stream().forEach(person -> log.info(
"\t" + personRepository.findByName(person.getName()).toString()));
List<Person> teammates = personRepository.findByTeammatesName(greg.getName());
log.info("The following have Greg as a teammate...");
teammates.stream().forEach(person -> log.info("\t" + person.getName()));
};
}
运行程序后，结果显示：
Before linking up with Neo4j...
Greg's teammates => []
Roy's teammates => []
Craig's teammates => []
Lookup each person by name...
Greg's teammates => [Roy, Craig]
Roy's teammates => [Greg, Craig]
Craig's teammates => [Roy, Greg]
guide7、buildinhg a restful web service with spring boot actuator
讲的是使用actuator创建一个restful服务。
Spring Boot Actuator是Spring Boot提供用于对应用系统进行自省和监控的功能模块，基于此开发人员可以方便地对应用系统某些监控指标进行查看、统计、审计、指标收集等。Actuator提供了基于Http端点或JMX来管理和监视应用程序。
它与SpringWeb提供的@Controller的对外服务有什么区别呢？它们都可以通过Http的方式让外部来访问应用程序，但功能的定义边界不同。就像上面说的Actuator通常用于应用程序本身运行情况的监控和操作，而@Controller更多的是业务层面运用。
通过Actuator可以监控应用程序的Health健康信息、Info应用信息、HTTP
Request跟踪信息、Metrics信息、@RequestMapping的路径信息、应用程序的各种配置信息、程序请求的次数时间等各种信息。
集成actuator到Spring boot项目，只需要添加依赖pom即可. 然后启动项目后，就可以通用http的方式访问其提供的端口。
$ curl localhost:9001/actuator/health
{"status":"UP"}
guide8、Integrating Data
主要讲的是使用Spring Integration创建一个应用服务，该应用程序从RSS提要(Spring Blog)检索数据，操作数据，然后将其写入文件。并且使用传统的Spring Integration XML配置。
定义一个Spring Integration流
- 在Spring.io上阅读RSS提要中的博客文章。
- 将它们转换为一个易于阅读的字符串，由文章标题和文章的URL组成。
- 将该字符串追加到文件的末尾(/tmp/si/SpringBlog)。
实施起来步骤也简单，就是引入jar包，然后编写integration.xml配置文件。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:int="http://www.springframework.org/schema/integration"
xmlns:file="http://www.springframework.org/schema/integration/file"
xmlns:feed="http://www.springframework.org/schema/integration/feed"
xsi:schemaLocation="http://www.springframework.org/schema/integration/feed https://www.springframework.org/schema/integration/feed/spring-integration-feed.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/integration/file https://www.springframework.org/schema/integration/file/spring-integration-file.xsd
http://www.springframework.org/schema/integration https://www.springframework.org/schema/integration/spring-integration.xsd">
<feed:inbound-channel-adapter id="news" url="https://spring.io/blog.atom" auto-startup="${auto.startup:true}">
<int:poller fixed-rate="5000"/>
</feed:inbound-channel-adapter>
<int:transformer
input-channel="news"
expression="payload.title + ' @ ' + payload.link + '#{systemProperties['line.separator']}'"
output-channel="file"/>
<file:outbound-channel-adapter id="file"
mode="APPEND"
charset="UTF-8"
directory="/tmp/si"
filename-generator-expression="'${feed.file.name:SpringBlog}'"/>
</beans>
这里有三个整合元素:
feed:inbound-channel-adapter:检索文章的入站适配器，每个轮询一个。按照这里的配置，它每5秒轮询一次。帖子被放置在一个名为news的频道中(对应于适配器的ID)。
int:transformer:转换新闻频道中的条目(com.rometools.rome.feed.synd.SyndEntry)，提取条目的标题(payload.title)和链接(payload.link)，并将它们连接到可读的String中(并添加换行符)。然后将字符串发送到名为file的输出通道。
<file:outbound-channel-adapter>:将内容从其通道(命名为文件)写入文件的出站通道适配器。具体来说，就像这里配置的那样，它将文件通道中的任何内容追加到/tmp/si/SpringBlog的文件中。
Guide涉及注解：
@ImportResource：
用于导入 Spring 的配置文件，例如：spring-mvc.xml、application-Context.xml。
Spring Boot 里面没有Spring 配置文件，都是通过 Java 代码进行配置。如果我们自己编写了配置文件，Spring Boot 是不能自动识别，此时需要使用 @ImportResource 注解将自己的配置文件加载进来。
guide9、Creating a Batch Service
构建一个服务，从CSV电子表格导入数据，使用自定义代码转换数据，并将最终结果存储在数据库中。
涉及到了spring batch, 将以下bean添加到BatchConfiguration类中，以定义读取器、处理器和写入器:
@Bean
public FlatFileItemReader<Person> reader() {
return new FlatFileItemReaderBuilder<Person>()
.name("personItemReader")
.resource(new ClassPathResource("sample-data.csv"))
.delimited()
.names(new String[]{"firstName", "lastName"})
.fieldSetMapper(new BeanWrapperFieldSetMapper<Person>() {{
setTargetType(Person.class);
}})
.build();
}
@Bean
public PersonItemProcessor processor() {
return new PersonItemProcessor();
}
@Bean
public JdbcBatchItemWriter<Person> writer(DataSource dataSource) {
return new JdbcBatchItemWriterBuilder<Person>()
.itemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>())
.sql("INSERT INTO people (first_name, last_name) VALUES (:firstName, :lastName)")
.dataSource(dataSource)
.build();
}
reader()创建一个ItemReader。它查找一个名为sample-data.csv的文件，并使用足够的信息解析每个行项以将其转换为Person。
processor()创建之前定义的PersonItemProcessor的实例，用于将数据转换为大写。
writer(DataSource)创建一个ItemWriter。它的目标是JDBC目的地，并自动获得@EnableBatchProcessing创建的dataSource的副本。它包括插入单个Person所需的SQL语句，由Java bean属性驱动。
@Bean
public Job importUserJob(JobRepository jobRepository,
JobCompletionNotificationListener listener, Step step1) {
return new JobBuilder("importUserJob", jobRepository)
.incrementer(new RunIdIncrementer())
.listener(listener)
.flow(step1)
.end()
.build();
}
@Bean
public Step step1(JobRepository jobRepository,
PlatformTransactionManager transactionManager, JdbcBatchItemWriter<Person> writer) {
return new StepBuilder("step1", jobRepository)
.<Person, Person> chunk(10, transactionManager)
.reader(reader())
.processor(processor())
.writer(writer)
.build();
}
第一个方法定义作业，第二个方法定义单个步骤。作业是按步骤构建的，其中每个步骤都涉及读取器、处理器和写入器。
在这个作业定义中，需要一个增量器，因为作业使用数据库来维护执行状态。然后列出每个步骤(尽管这个作业只有一个步骤)。作业结束，Java API生成一个配置完美的作业。
在步骤定义中，定义一次写入多少数据。在本例中，它一次最多写入10条记录。接下来，使用前面注入的bean配置读取器、处理器和写入器。
批处理配置的最后一点是在作业完成时获得通知的方法,如下：
@Component
public class JobCompletionNotificationListener implements JobExecutionListener {
private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
private final JdbcTemplate jdbcTemplate;
@Autowired
public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public void afterJob(JobExecution jobExecution) {
if(jobExecution.getStatus() == BatchStatus.COMPLETED) {
log.info("!!! JOB FINISHED! Time to verify the results");
jdbcTemplate.query("SELECT first_name, last_name FROM people",
(rs, row) -> new Person(
rs.getString(1),
rs.getString(2))
).forEach(person -> log.info("Found <{{}}> in the database.", person));
}
}
}
主要就是介绍了Spring batch，一个轻量级批处理框架的简单应用。https://juejin.cn/post/7064591679189155854
guide10、Building a Hypermedia-Driven RESTful Web Service
主要讲的是使用Spring HATEOAS构建一个超媒体驱动的restful 服务。
Spring HATEOAS: 一个api库，可以使用它创建指向Spring MVC控制器的链接，构建资源表示，并控制如何将它们呈现为受支持的超媒体格式。
感觉背后思想就是响应中包含指向其它资源的链接。客户端可以利用这些链接和服务器交互。
非HATEOAS的响应例子：
GET /posts/1 HTTP/1.1
Connection: keep-alive
Host: blog.example.com
{
"id" : 1,
"body" : "My first blog post",
"postdate" : "2015-05-30T21:41:12.650Z"
}
HATEOAS的响应例子：
{
"id" : 1,
"body" : "My first blog post",
"postdate" : "2015-05-30T21:41:12.650Z",
"links" : [
{
"rel" : "self",
"href" : http://blog.example.com/posts/1,
"method" : "GET"
}
]
}
上面的例子中，每一个在links中的link都包含了三部分：
rel：描述href指向的资源和现有资源的关系
href：用户可以用来检索资源或者改变应用状态的URI
method：和此URI需要的http方法
比较复杂：https://www.cnblogs.com/kaixinyufeng/p/8283289.html
涉及到rest成熟度模型，第四层次就是HATEOAS，在资源表达中包含了链接信息，客户端可根据链接来发现可执行的动作。
