由于早年在管理领域耕耘了一段时间，完美错过了Spring的活跃期，
多少对这个经典的技术带有一种遗憾的心态在里面的，
从下面的我的生涯手绘图中大概可以看出来我的经历。
最近由于新介入到了工业数字化领域，工作也专注于业务应用，
不怎么搞平台了，平台更多的是采取与友商战略合作的方式，
也有机会重新认识并学习一下这个被完美错过的经典技术。
以下是本次的随记。
一、本次的代码地址
https://github.com/quchunhui/demo-macket/tree/master/springboot
二、一个简单的需求场景
1) 从云平台按照一定频率拉取数据（每次间隔5秒）。
2) 将待获取的数据保存至本地数据库（MySQL）。
3）提供可视化web页面供查看流转数据状态。
4) 由DView工业软件从数据库中拉取数据（每次间隔5秒）。
5) 按照一定数量间隔向PLC下发加工数据（每次5个）。
其中，红色字体部分，为本次随记的范围。
三、学习书籍
我本在在正式开始学习及开发之前，通过书籍和付费视频对Spring boot进行了简单扫盲
学习的书籍为：《Spring 5企业级开发实战》
学习的收费视频为：极客时间《Spring全家桶》
书籍可以采用快速阅读的方式进行框架性学习
视频可以采用2倍速，按照需要先挑选部分模块学习
四、学习笔记
===初始化工程===
可以通过这个地址初始化工程
也可以通过IDEA的Spring initializr来进行初始设计。
可以选择一下组件：
Developer Tools
→Lombok
→Spring Configuration Processor
Web
→Spring Web
SQL
→Spring Boot JPA
→MySQL Driver
Ops
→Spring Boot Actuator
===spring boot actuator===
用于健康检查的模块，可以考虑引入进来。
===lombok===
Lombok想要解决了的是在我们实体Bean中大量的Getter/Setter方法，以及toString，hashCode等可能不会用到，
在使用Lombok之后，将由其来自动帮你实现代码生成，注意，其是 在运行过程中，帮你自动生成的 。就是说，将极大减少你的代码总量。
===JDBC与JPA区别===
1.定义
JDBC提供一种接口，它是由各种数据库厂商提供类和接口组成的数据库驱动，为多种数据库提供统一访问。我们使用数据库时只需要调用JDBC接口就行了。
JDBC的用途：与数据库建立连接、发送操作数据库的语句并处理结果。
JPA是Java持久层API。它是对java应用程序访问ORM（对象关系映射）框架的规范。为了我们能用相同的方法使用各种ORM框架。
JPA用途：简化现有Java EE和Java SE应用开发工作；整合ORM技术。
2.不同点：
1）使用的sql语言不同：
JDBC使用的是基于关系型数据库的标准SQL语言；
JPA通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。
2）操作的对象不同：
JDBC操作的是数据，将数据通过SQL语句直接传送到数据库中执行：
JPA操作的是持久化对象，由底层持久化对象的数据更新到数据库中。
3）数据状态不同：
JDBC操作的数据是“瞬时”的，变量的值无法与数据库中的值保持一致；
JPA操作的数据时可持久的，即持久化对象的数据属性的值是可以跟数据库中的值保持一致的。
===mvn package报错===
错误日志
Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.
问题原因:
Mybatis没有找到合适的加载类,其实是大部分spring - datasource - url没有加载成功,
解决办法：
在application.propertier中增加如下代码之后，编译通过。
spring.datasource.url=jdbc:mysql://localhost:3306/read_data?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username: root
spring.datasource.password: 123456
spring.datasource.driver-class-name: com.mysql.jdbc.Driver
参考博客：
https://www.cnblogs.com/wuxiang12580/archive/2019/01/25/10319914.html
===运行报错===
错误日志
com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure
问题原因：
数据库连接相关的配置不正确，连接不上数据库
解决办法：
application.propertier中的数据库连接信息修改为正确的即可。修改后如下：
spring.datasource.url=jdbc:mysql://localhost:3306/visual?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username: root
spring.datasource.password: 123456
spring.datasource.driver-class-name: com.mysql.jdbc.Driver
===@Builder注解===
在出现lombok之后，对象的创建工作更提供Builder方法，
它提供在设计数据实体时，对外保持private setter，而对属性的赋值采用Builder的方式，
这种方式最优雅，也更符合封装的原则，不对外公开属性的写操作！
@Builder声明实体，表示可以进行Builder方式初始化，
@Value注解，表示只公开getter，对所有属性的setter都封闭，即private修饰，所以它不能和@Builder一起使用
参考博客：
https://www.cnblogs.com/lori/p/9024933.html
===Builder注解没有builder方法===
解决办法：
在IDEA中下载lombok插件解决。vscode一样。
参考博客：
https://blog.csdn.net/Butterfly_resting/article/details/101377756
===Lombok中的@Data注解===
@Data：该注解相当于同时加上以下注解@Setter @Getter,@ToString,@EqualsAndHashCode
@Getter:生成getter方法
@Setter：生成setter方法
@AllArgsConstructor：全参构造
@NoArgsContructor：无参构造
===JdbcTemplate与NamedParameterJdbcTemplate===
SimpleJdbcTemplate加入了Java5的特性支持，例如可变参数、自动拆包封包、泛型等支持。
JdbcTemplate，已经基本能看到相对于JDBC比较强大的能力，
但是它有一个问题很不方便，就是使用参数的占位符时，必须得按照顺序来写参数，如果顺序不对，则操作失败，
NamedParameterJdbcTemplate可以用来解决这个问题，它提供了一个方式，可以通过参数名来映射参数而不是传统的"?"
可以使用SqlParameterSourceUtils.createBatch()方法，将list里的东西变成一个batch的值
List<Foo> list = new ArrayList<>();
list.add(Foo.builder().id(100L).bar("b-100").build());
list.add(Foo.builder().id(101L).bar("b-101").build());
namedParameterJdbcTemplate.batchUpdate("INSERT INTO FOO (ID, BAR) VALUES (:id, :bar)",
SqlParameterSourceUtils.createBatch(list));
===spring boot的定时任务（Scheduled）===
@Scheduled中的参数说明
@Scheduled(fixedRate=2000)：上一次开始执行时间点后2秒再次执行；
Scheduled(fixedDelay=2000)：上一次执行完毕时间点后2秒再次执行；
@Scheduled(initialDelay=1000, fixedDelay=2000)：第一次延迟1秒执行，然后在上一次执行完毕时间点后2秒再次执行；
@Scheduled(cron="* * * * * ?")：按cron规则执行。
参考博客：
https://www.cnblogs.com/mmzs/p/10161936.html
===Spring boot Scheduled没有被定时执行===
解决办法：
@ComponentScan(basePackages = {"com.xxx"})
这是spring扫描路径，Test 是否在 com.xxx 包下面
@ComponentScan做的事情就是告诉Spring从哪里找到bean
@Component 和 @ComponentScan的使用目的不一样
@Component注解，表明当需要创建类时，这个被注解的类是一个候选类。就像是举手。
@ComponentScan 用于扫描指定包下的类。就像看都有哪些举手了
参考博客：
https://blog.csdn.net/Lamb_IT/article/details/80918704
===JPA的一些注解===
主体
@Entity
@MappedSuperclass
@Table(name)
主键
@Id
@GeneratedValue(strategy, generator)
@SuquenceGenerator(name, sequenceName)
@GeneratedValue注解的strategy属性提供四种值:
-AUTO主键由程序控制, 是默认选项 ,不设置就是这个
-IDENTITY 主键由数据库生成, 采用数据库自增长, Oracle不支持这种方式
-SEQUENCE 通过数据库的序列产生主键, MYSQL 不支持
-Table 提供特定的数据库产生主键, 该方式更有利于数据库的移植
映射
@Column(name, nullable, length, insertable, updatable)
@JoinTable(name)
@JoinColumn(name)
关系
@OneToOne
@OneToMany
@ManyToOne
@ManyToMany
@OrderBy
===几种注解的关系===
@Repository、@Service、@Controller 和 @Component 将类标识为Bean
@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean
@Component 是一个泛化的概念，仅仅表示一个组件 (Bean) ，可以作用在任何层次。
@Service 通常作用在业务层，但是目前该功能与 @Component 相同。
@Constroller 通常作用在控制层，但是目前该功能与 @Component 相同。
通过在类上使用 @Repository、@Component、@Service 和 @Constroller 注解，
Spring会自动创建相应的 BeanDefinition 对象，并注册到 ApplicationContext 中。
这些类就成了Spring受管组件。
这三个注解除了作用于不同软件层次的类，其使用方式与 @Repository 是完全相同的。
===@GeneratedValue===
在JPA中
@GeneratedValue注解存在的意义主要就是为一个实体生成一个唯一标识的主键(JPA要求每一个实体Entity,必须有且只有一个主键)
@GeneratedValue提供了主键的生成策略。
@GeneratedValue注解有两个属性,分别是strategy和generator
generator属性的值是一个字符串,默认为"",其声明了主键生成器的名称(对应于同名的主键生成器@SequenceGenerator和@TableGenerator)
PA为开发人员提供了四种主键生成策略,其被定义在枚举类GenerationType中,包括
GenerationType.TABLE:
GenerationType.SEQUENCE:
GenerationType.IDENTITY:
GenerationType.AUTO:
参考博客：
https://blog.csdn.net/u012493207/article/details/50846616
===@Id 和 @GeneratedValue 注解===
@Id 标注用于声明一个实体类的属性映射为数据库的主键列。
该属性通常置于属性声明语句之前，可与声明语句同行，也可写在单独行上。
参考博客：
https://blog.csdn.net/Jae_Wang/article/details/80533137
===@Query===
@Query(value=" 这里就是查询语句")
@Query支持hql和原生sql两种方式，默认是hql，hql就是语句中用的是实体名字和实体属性，原生sql用的表名字和表字段,
hql方式不支持select * 要想查询全部字段可以用select 实体名 这里省略了value，参数使用了占位置符 ?1代表第一个参数?2代表第二个
@Param 代替参数占位符，hql或者sql里就用:firstname替换方法里的参数顺序可以打乱
如果是更新或者删除操作，方法上面要加@Modifying默认开启的事务只是可读的，更新操作加入@Modifying就会关闭可读
原生sql方式 不能和Pageable pageable 同时使用，要用自己的limit实现分页，原生的方式就和sql语法完全一样，使用的表名字，表字段
@Data 属于lombok注解，与jpa无关，自动生成getter/setter/equals/hashcode/tostring等方法
@Entity, @Table jpa注解，表示这个类与db的表关联，具体匹配的是表 money
@Id @GeneratedValue 作用与自增主键
@Column表明这个属性与表中的某列对应
@CreateDate根据当前时间来生成默认的时间戳
参考博客：
https://blog.csdn.net/qq_27886997/article/details/82982936
===启动报错===
Field processedDataDao in rexel.controller.RexelMiddlewareController required a bean of type 'rexel.dao.ProcessedDataDao' that could not be found. The injection point has the following annotations:
- @org.springframework.beans.factory.annotation.Autowired(required=true)
问题原因：
包扫描路径不正确
@ComponentScan("rexel")
===启动报错===
Composite-id class must implement Serializable: rexel.entity.DViewVarNameDic
如果该实体类对应的表只有一个主键，即图中的id，把linkName上面的@Id注解删除即可，重新启动就不会报错了。
如果该实体类对应的表确实使用的两个字段（联合主键），则要求该实体类必须可序列化，该类要实现 Serializable 接口，并添加如下代码：
private static final long serialVersionUID = 1L;
public class DViewVarNameDic implements Serializable {
参考博客：
http://www.mamicode.com/info-detail-2681892.html
===启动报错===
Invocation of init method failed; nested exception is java.lang.IllegalArgumentException: This class [class rexel.entity.DViewVarNameDicEntity] does not define an IdClass
解决办法：
在Entity类前面加上@IdClass()
===@Configuration和@Bean===
@Configuration底层是含有@Component ，所以@Configuration 具有和 @Component 的作用。
@Configuration可理解为用spring的时候xml里面的<beans>标签。
@Configuration注解可以达到在Spring中使用xml配置文件的作用。
@Configuration标注在类上，相当于把该类作为spring的xml配置文件中的<beans>，作用为：配置spring容器(应用上下文)
参考博客：
https://blog.csdn.net/qq_36472252/article/details/86623630
===RestRemplate样例程序运行报错===
Caused by: org.springframework.web.client.RestClientException: Could not extract response: no suitable HttpMessageConverter found for response type [class rexel.webservice.bean.ProcessedDataBean] and content type [text/html;charset=utf-8]
按照这个网址可以解决
https://www.jianshu.com/p/95bf08696cd7
然后再次运行，又会提示其他错误
Caused by: org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Unrecognized token 'H24': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false'); nested exception is com.fasterxml.jackson.core.JsonParseException: Unrecognized token 'H24': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')
at [Source: (PushbackInputStream); line: 6, column: 20]
检查之后，发现是我在postman里定义的json格式不正确引起的。
Shit，多少有些2B了，暂时放过自己一次。
===增加了事务注解，但是无法回滚===
我这里发生的原因是用@Transactional(rollbackFor = Exception.class)标注的方法没有是public
参考博客：
https://blog.csdn.net/zdyueguanyun/article/details/80236401
===读取application.properties文件的几种方法===
第一种方式：使用@ConfigurationProperties(prefix = "com.zyd")注解在class头
第二种方式：使用@Value("${propertyName}")注解在变量上
第三种方式：使用Environment evn; env.getProperty("com.zyd.type2")
第四种方式：使用Properties properties = PropertiesLoaderUtils.loadAllProperties(propertyFileName);
参考博客：
https://www.cnblogs.com/FraserYu/p/11261916.html
===Http报头Accept与Content-Type的区别===
Http报头分为通用报头，请求报头，响应报头和实体报头。
1.Accept属于请求头， Content-Type属于实体头。
Http报头分为通用报头，请求报头，响应报头和实体报头。
请求方的http报头结构：通用报头|请求报头|实体报头
响应方的http报头结构：通用报头|响应报头|实体报头
2.Accept代表发送端（客户端）希望接受的数据类型。
比如：Accept：text/xml;
代表客户端希望接受的数据类型是xml类型
3.Content-Type代表发送端（客户端|服务器）发送的实体数据的数据类型。
比如：Content-Type：text/html;
代表发送端发送的数据格式是html。
二者合起来，
Accept:text/xml；
Content-Type:text/html
即代表希望接受的数据类型是xml格式，本次请求发送的数据的数据格式是html。
===运行报错===
Caused by: org.hibernate.AnnotationException: No identifier specified for entity: rexel.entity.AccessTokenEntity
at org.hibernate.cfg.InheritanceState.determineDefaultAccessType(InheritanceState.java:266) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.cfg.InheritanceState.getElementsToProcess(InheritanceState.java:211) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.cfg.AnnotationBinder.bindClass(AnnotationBinder.java:781) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.boot.model.source.internal.annotations.AnnotationMetadataSourceProcessorImpl.processEntityHierarchies(AnnotationMetadataSourceProcessorImpl.java:254) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.boot.model.process.spi.MetadataBuildingProcess$1.processEntityHierarchies(MetadataBuildingProcess.java:230) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.boot.model.process.spi.MetadataBuildingProcess.complete(MetadataBuildingProcess.java:273) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.metadata(EntityManagerFactoryBuilderImpl.java:1214) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:1245) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
问题原因：
当使用idclass时,实体中须有和idclass类中属性个数的主键,并且一致
参考博客：
https://blog.csdn.net/Mosqiote/article/details/89227931
===Springboot的entity,dao,controller,service层级理解===
1.Dao层：持久层，主要与数据库交互
DAO层首先会创建Dao接口，接着就可以在配置文件中定义该接口的实现类；
接着就可以在模块中调用Dao的接口进行数据业务的处理，而不用关注此接口的具体实现类是哪一个类，
Dao层的数据源和数据库连接的参数都是在配置文件中进行配置的。
2.Entity层：实体层，数据库在项目中的类
主要用于定义与数据库对象应的属性，提供get/set方法,tostring方法,有参无参构造函数。
3.Service层：业务层 控制业务
业务模块的逻辑应用设计，和DAO层一样都是先设计接口，再创建要实现的类，然后在配置文件中进行配置其实现的关联。
接下来就可以在service层调用接口进行业务逻辑应用的处理。
好处：封装Service层的业务逻辑有利于业务逻辑的独立性和重复利用性。
4.Controller层：控制层 控制业务逻辑
具体的业务模块流程的控制，controller层主要调用Service层里面的接口控制具体的业务流程，控制的配置也要在配置文件中进行。
Controller和Service的区别是：Controller负责具体的业务模块流程的控制；Service层负责业务模块的逻辑应用设计
5、View层
此层与控制层结合比较紧密，需要二者结合起来协同工发。View层主要负责前台jsp页面的表示
总结：
Controller层调用了Service层的方法，Service层调用Dao层的方法，其中调用的参数是使用Entity层进行传递的。
参考博客：
https://www.cnblogs.com/almm/p/10802419.html
===请求报错===
Invalid character found in method name. HTTP method names must be tokens
解决办法：
请求由https修改为http之后解决。
===后端如何将数据返回给前端？===
@RequestBody：
用于读取Http请求的body部分数据——就是我们的请求数据。比如json或者xml。然后把数据绑定到 controller中方法的参数上
@ReponseBody：
放在controller层的方法上，将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。
使用时机： 当我们想让页面知道我们返回的数据不是按照html标签的页面来解析，而是其他某种格式的数据解析时（如json、xml等）使用。
===运行报错===
javax.persistence.TransactionRequiredException: Executing an update/delete query
at org.hibernate.internal.AbstractSharedSessionContract.checkTransactionNeededForUpdateOperation(AbstractSharedSessionContract.java:409) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
at org.hibernate.query.internal.AbstractProducedQuery.executeUpdate(AbstractProducedQuery.java:1601) ~[hibernate-core-5.4.8.Final.jar:5.4.8.Final]
问题原因
在@Query注解中编写JPQL语句， 但必须使用@Modifying进行修饰。以通知SpringData，这是一个UPDATE或DELETE操作
其中，nativeQuery = true 就代表使用原始 sql
修改之后代码如下：
@Modifying
@Query(nativeQuery = true, value = "insert into COLLECT_SWITCH(collect) values (:#{#entity.collect})")
public void insert(@Param("entity") CollectSwitchEntity entity);
===运行错误===
org.springframework.web.client.ResourceAccessException: I/O error on GET request for "https://3dd39ca6-40bd-41ae-a045-ff80d0e6aca8.mock.pstmn.io/openapi/ipm/wait/process/query": Read timed out; nested exception is java.net.SocketTimeoutException: Read timed out
解决办法：
增加对RestRemplate连接时间的配置。
解决后代码
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory){
return new RestTemplate(factory);
} @Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(15000);
factory.setReadTimeout(15000);
return factory;
}
}
===mysql传入时间正确，但是插入到数据库时间错误，相差几个小时===
解决办法：
直接在数据库连接地址后面添加引号内的内容“&serverTimezone=GMT%2B8”
spring.datasource.url=jdbc:mysql://192.168.29.100:3306/rexel_hzzg?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
===saveAll为啥每次都要查询数据？===
原因请参考博客：
https://www.cnblogs.com/blog5277/p/10661096.html
解决办法：
自己写插入的语句，不适用JPA自带的saveAll方法。
====运行错误===
错误日志：
2019-11-22 16:20:13.862 ERROR 98860 --- [ scheduling-1] o.s.s.s.TaskUtils$LoggingErrorHandler : Unexpected error occurred in scheduled task org.springframework.web.client.HttpClientErrorException$NotFound: 404 Not Found
at org.springframework.web.client.HttpClientErrorException.create(HttpClientErrorException.java:85) ~[spring-web-5.2.1.RELEASE.jar:5.2.1.RELEASE]
at org.springframework.web.client.DefaultResponseErrorHandler.handleError(DefaultResponseErrorHandler.java:123) ~[spring-web-5.2.1.RELEASE.jar:5.2.1.RELEASE]
at org.springframework.web.client.DefaultResponseErrorHandler.handleError(DefaultResponseErrorHandler.java:102) ~[spring-web-5.2.1.RELEASE.jar:5.2.1.RELEASE]
原因：
已经发布的系统，其中有一个quartz的定时器运行了一段时间后突然挂掉了。
并报错：Unexpected error occurred in scheduled task.
调查发现因为：定时器的动作是调用一个同步线程，而某一次该线程运行时间过长即锁未释放，而第二次定时器动作又并发执行了，所以就导致了冲突。
解决办法：
1、增加config配置
2、----------------------------不要使用https请求。。。。。。。。。。。。。
补充：
在博文最开始共享的代码中，我已经删除了ScheduleConfig的配置，代码中已经找不到这个配置了。
===mysql在台式机上安装报错（Windows10操作系统）===
mysql启动服务报错
Found option without preceding group in config file
问题原因：
mysql里面的配置文件my.ini文件格式是utf-8。
只要把my.ini文件格式改为ANSI就可以了。
===程序运行了一段时间之后，报错===
Hibernate: select collectswi0_.collect as collect1_1_ from COLLECT_SWITCH collectswi0_
Hibernate: select accesstoke0_.token as token1_0_, accesstoke0_.insertTime as insertTi2_0_ from ACCESS_TOKEN accesstoke0_ order by accesstoke0_.insertTime desc
2019-11-25 08:20:49.772 ERROR 15728 --- [pool-1-thread-2] o.s.s.s.TaskUtils$LoggingErrorHandler : Unexpected error occurred in scheduled task org.springframework.web.client.HttpClientErrorException$TooManyRequests: 429 Too Many Requests
at org.springframework.web.client.HttpClientErrorException.create(HttpClientErrorException.java:97) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.DefaultResponseErrorHandler.handleError(DefaultResponseErrorHandler.java:123) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.DefaultResponseErrorHandler.handleError(DefaultResponseErrorHandler.java:102) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.ResponseErrorHandler.handleError(ResponseErrorHandler.java:63) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.RestTemplate.handleResponse(RestTemplate.java:785) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.RestTemplate.doExecute(RestTemplate.java:743) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.RestTemplate.execute(RestTemplate.java:717) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.web.client.RestTemplate.exchange(RestTemplate.java:605) ~[spring-web-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at rexel.schedule.MiddleWareSchedule.exchange(MiddleWareSchedule.java:318) ~[classes!/:0.0.1]
at rexel.schedule.MiddleWareSchedule.getProcessData(MiddleWareSchedule.java:218) ~[classes!/:0.0.1]
at rexel.schedule.MiddleWareSchedule.scheduleProcess(MiddleWareSchedule.java:111) ~[classes!/:0.0.1]
at rexel.schedule.MiddleWareSchedule$$FastClassBySpringCGLIB$$3847585e.invoke(<generated>) ~[classes!/:0.0.1]
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218) ~[spring-core-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:769) ~[spring-aop-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:747) ~[spring-aop-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:366) ~[spring-tx-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:99) ~[spring-tx-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:747) ~[spring-aop-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:689) ~[spring-aop-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at rexel.schedule.MiddleWareSchedule$$EnhancerBySpringCGLIB$$3bdb64f9.scheduleProcess(<generated>) ~[classes!/:0.0.1]
at sun.reflect.GeneratedMethodAccessor96.invoke(Unknown Source) ~[na:na]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source) ~[na:1.8.0_77]
at java.lang.reflect.Method.invoke(Unknown Source) ~[na:1.8.0_77]
at org.springframework.scheduling.support.ScheduledMethodRunnable.run(ScheduledMethodRunnable.java:84) ~[spring-context-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at org.springframework.scheduling.support.DelegatingErrorHandlingRunnable.run(DelegatingErrorHandlingRunnable.java:54) ~[spring-context-5.2.1.RELEASE.jar!/:5.2.1.RELEASE]
at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source) [na:1.8.0_77]
at java.util.concurrent.FutureTask.runAndReset(Unknown Source) [na:1.8.0_77]
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(Unknown Source) [na:1.8.0_77]
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(Unknown Source) [na:1.8.0_77]
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source) [na:1.8.0_77]
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source) [na:1.8.0_77]
at java.lang.Thread.run(Unknown Source) [na:1.8.0_77]
原因是potstman已经达到了模拟请求的极限，需要升级到专业版
You’ve reached your limit for mock requests. Upgrade to Pro for more.
===cron表达式===
cron一共有7位，但是最后一位是年，可以留空，所以我们一般可以只写6位：
第一位，表示秒，取值0-59
第二位，表示分，取值0-59
第三位，表示小时，取值0-23
第四位，日期天/日，取值1-31
第五位，日期月份，取值1-12
第六位，星期，取值1-7，星期一，星期二…注意：1表示星期天，2表示星期一。
第7为，年份，可以留空，取值1970-2099
样例：
每隔5秒执行一次：*/5 * * * * ?
每隔1分钟执行一次：0 */1 * * * ?
每天凌晨1点执行一次：0 0 1 * * ?
每天23点执行一次：0 0 23 * * ?
每月最后一天23点执行一次：0 0 23 L * ?
每月1号凌晨1点执行一次：0 0 1 1 * ?
每天3点5分执行：0 5 3 * * ?
每天3点5分执行，与上面作用相同：0 5 3 ? * *
每天3点的 5分，15分，25分，35分，45分，55分这几个时间点执行：0 5/10 3 * * ?
每周星期天，3点10分 执行，注：1表示星期天：0 10 3 ? * 1
每个月的第三个星期，星期天 执行，注：#号只能出现在星期的位置：0 10 3 ? * 1#3
在26分、29分、33分执行一次：0 26,29,33 * * * ?
每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?
===@Scope("prototype")===
spring中bean的scope属性，有如下5种类型：
1）singleton 表示在spring容器中的单例，通过spring容器获得该bean时总是返回唯一的实例
2）prototype表示每次获得bean都会生成一个新的对象
3）request表示在一次http请求内有效（只适用于web应用）
4）session表示在一个用户会话内有效（只适用于web应用）
5）globalSession表示在全局会话内有效（只适用于web应用）
在多数情况，我们只会使用singleton和prototype两种scope，如果在spring配置文件内未指定scope属性，默认为singleton。
===接口Service有多个实现类===
//接口.java
public interface DeService {
} //接口实现类1.java
@Service("ud")
public class DeServiceImplUD implements DeService{
} //接口实现类2.java
@Service("ug")
public class DeServiceImplUG implements DeService{
} //调用类.java
@Autowired
@Qualifier("ug")
private DeService ds;
===all elements are null===
使用spring jpa查询书库的时候，数据库中明明有数据，查询出来的结果却显示all elements are null。
可以看出，实际上List中有38条数据，只不过都没能正确转换为Entity。
后来调查原因是因为我用的PostgreSQL中数据有的字段为null，所以没能转换成功。