SpringBoot on F嘉阳

GraphQL实践10——Netflix Dgs Graphql异步订阅

Fri, 28 Oct 2022 21:59:23 +0800

介绍

GraphQL订阅模式支持服务端主动向客户端推送数据通知，避免客户端轮训

DGS Subscriptions

新增依赖

此处使用的是SpringBoot Web组件，故引入websockets依赖

如果使用的是WebFlux则要引入对应的dgs-webflux

		 <dependency>
 <groupId>com.netflix.graphql.dgs</groupId>
 <artifactId>graphql-dgs-subscriptions-websockets-autoconfigure</artifactId>
 </dependency>

异步通知解析

此处定义为当新增一个Actor就给所有订阅者发异步通知

@Slf4j
@DgsComponent
@RequiredArgsConstructor
public class ActorDataFetcher {

	private final ActorAssembler actorAssembler;

	private FluxSink<Actor> actorStream;

	private ConnectableFlux<Actor> actorPublisher;

	@PostConstruct
	private void createActorPublisher() {
		Flux<Actor> publisher = Flux.create(emitter -> {
			actorStream = emitter;
		});

		actorPublisher = publisher.publish();
		actorPublisher.connect();
	}

	@DgsMutation
	public Actor addActor(@InputArgument SubmitActor actor) {
		Actor actorEntity = actorAssembler.convert(actor);
		actorEntity.setActorId(10);
		actorEntity.setLastUpdate(DateUtil.format(new Date(), DatePattern.NORM_DATETIME_PATTERN));
		actorStream.next(actorEntity);
		log.info("服务端创建演员：{}", actor);
		return actorEntity;
	}

	/**
	 * 异步通知
	 *
	 * @return
	 */
	@DgsSubscription
	public Publisher<Actor> actorAdded() {
		return actorPublisher;
	}
}

单元测试

由于异步通知无法用浏览器自带的控制台测试，只能通过GraphQL客户端订阅后接收异步通知，此处参考官方最佳实践，使用单元测试模拟

@Slf4j
@SpringBootTest
class ActorDataFetcherTest {

	@Autowired
	private DgsQueryExecutor dgsQueryExecutor;

	@Test
	void addActor() {

		GraphQLQueryRequest graphQLQueryRequest = new GraphQLQueryRequest(
				AddActorGraphQLQuery.newRequest()
						.actor(
								SubmitActor.newBuilder()
										.firstName("fu")
										.lastName("jiayang")
										.build())
						.build(),
				new AddActorProjectionRoot()
						.actorId()
						.firstName()
						.lastUpdate());
		dgsQueryExecutor.execute(graphQLQueryRequest.serialize());
	}

	@Test
	void actorAdded() {
		ExecutionResult executionResult = dgsQueryExecutor.execute("""
				subscription {
				 actorAdded {
				 actorId
				 firstName
				 lastName
				 lastUpdate
				 }
				}
				""");
		Publisher<ExecutionResult> reviewPublisher = executionResult.getData();
		List<Actor> actors = new CopyOnWriteArrayList<>();

		reviewPublisher.subscribe(new Subscriber<>() {
			@Override
			public void onSubscribe(Subscription s) {
				s.request(2);
			}

			@Override
			public void onNext(ExecutionResult executionResult) {
				if (executionResult.getErrors().size() > 0) {
					executionResult.getErrors().forEach(error -> log.error(error.toString()));
				}
				Map<String, Object> actorResult = executionResult.getData();
				Actor actor = new ObjectMapper().convertValue(actorResult.get("actorAdded"), Actor.class);
 log.info("客户端监听到演员新增：{}",actor);
				actors.add(actor);
			}

			@Override
			public void onError(Throwable t) {
				t.printStackTrace();
			}

			@Override
			public void onComplete() {
			}
		});

		addActor();
		addActor();

		assertThat(actors.size()).isEqualTo(2);
	}
}

从日志输出可以看到客户端成功接收异步通知

总结

订阅模式属于GraphQL特色功能，类似消息队列实现方式，减少客户端对普通查询接口轮训性能开销

GraphQL实践9——Netflix Dgs Graphql数据更新

Fri, 28 Oct 2022 21:58:54 +0800

功能介绍

graphql-java提供了Mutations类型支持数据更新

NGS Mutations

类型定义

type Mutation {
 addActor(actor: SubmitActor!): Actor
}

type Subscription {
 actorAdded: Actor
}

input SubmitActor {
 firstName: String!
 lastName: String!
}

SubmitActor类型可以交给代码生成器自动生成

类型转换器

@Mapper(componentModel = SPRING)
public interface ActorAssembler {

	Actor convert(SubmitActor submit);
}

定义解析器

	@DgsMutation
	public Actor addActor(@InputArgument SubmitActor actor) {
		Actor actorEntity = actorAssembler.convert(actor);
		actorEntity.setActorId(10);
		actorEntity.setLastUpdate(new Date());
		return actorEntity;
	}

测试

访问http://localhost:8080/graphiql即可看到在线查询页面

GraphQL实践8——Netflix Dgs Graphql代码生成

Fri, 28 Oct 2022 21:57:00 +0800

功能介绍

DGS官方开发了识别schema配置生成对应类型、测试类的代码生成器，而Maven插件则由社区维护

Maven代码生成插件

新增依赖

<dependency> 
 <groupId>com.netflix.graphql.dgs.codegen</groupId> 
 <artifactId>graphql-dgs-codegen-client-core</artifactId> 
 <version>5.1.17</version> 
</dependency>

还需要新增构建插件

	 <plugin>
 <groupId>io.github.deweyjose</groupId>
 <artifactId>graphqlcodegen-maven-plugin</artifactId>
 <version>1.24</version>
 <executions>
 <execution>
 <goals>
 <goal>generate</goal>
 </goals>
 </execution>
 </executions>
 <configuration>
 <addGeneratedAnnotation>true</addGeneratedAnnotation>
 <packageName>top.fjy8018.graphsqldemo.generated</packageName>
 <schemaPaths>
 <param>src/main/resources/graphql/actor.graphqls</param>
 </schemaPaths>
 <!-- 生成测试客户端 -->
 <generateClient>true</generateClient>
 </configuration>
 </plugin>
 <plugin>
 <groupId>org.codehaus.mojo</groupId>
 <artifactId>build-helper-maven-plugin</artifactId>
 <executions>
 <execution>
 <phase>generate-sources</phase>
 <goals>
 <goal>add-source</goal>
 </goals>
 <configuration>
 <sources>
 <source>${project.build.directory}/generated-sources</source>
 </sources>
 </configuration>
 </execution>
 </executions>
 </plugin>

插件配置指引：deweyjose/graphqlcodegen: Maven port of the Netflix Gradle code generation plugin for graphql.

编译

执行

mvn clean package

即可生成对应的类

存在问题

IDEA默认不识别target目录下的资源文件，生成后会导致无法引用

解决方法

需要手动将对应的生成目录配置为Source Root即可

总结

DGS官方推荐开发者优先使用代码生成器生成标准类库后再开发，可以减少开发量

GraphQL实践7——Netflix Dgs Graphql分页查询

Fri, 28 Oct 2022 16:06:31 +0800

问题背景

上一篇文章提到，使用List查询每次都返回全量数据，而实际场景更多使用分页查询，graphql-java提供Connection实现游标分页，在Dgs也有对应功能扩展Relay Pagination

集成Relay Pagination

新增依赖

 <dependency>
 <groupId>com.netflix.graphql.dgs</groupId>
 <artifactId>graphql-dgs-pagination</artifactId>
 </dependency>

Mybatis Plus 配置分页插件

@Configuration
@MapperScan("top.fjy8018.graphsqldemo.mapper")
public class MybatisPlusConfig {

 /**
 * 分页插件配置
 *
 * @return
 */
 @Bean
 public MybatisPlusInterceptor mybatisPlusInterceptor() {
 MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
 PaginationInnerInterceptor pageConfig = new PaginationInnerInterceptor(DbType.MYSQL);
 interceptor.addInnerInterceptor(pageConfig);
 return interceptor;
 }
}

Relay Pagination配置

type Query {
 actorList: [Actor]
 findOneActor(id : Int!): Actor
 filmList(current: Int!,size: Int!): FilmConnection
 findOneFilm(id : Int!): Film
}

type Actor {
 actorId: Int!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

type Film @connection {
 filmId: Int!
 title: String!
 description: String
 releaseYear: Int
 languageId: Int!
 originalLanguageId: Int
 rentalDuration: Int
 rentalRate: Float
 length: Int
 replacementCost: Float
 rating: String
 specialFeatures: String
 lastUpdate: String
 actors: [Actor]
}

@connection和XXXConection已经由graphql-java底层框架自动生成，无需手动定义

类型转换器

public interface ConnectionAssembler {

 /**
 * mybatis plus分页对象转为Connection
 *
 * @param page 分页对象
 * @param <T> 泛型
 * @return Connection
 */
 static <T> Connection<T> convert(IPage<T> page) {
 AtomicInteger index = new AtomicInteger();
 List<Edge<T>> defaultEdges = Stream.ofNullable(page.getRecords())
 .flatMap(Collection::stream)
 .map(e -> (Edge<T>) new DefaultEdge<>(e, new DefaultConnectionCursor(String.valueOf(index.incrementAndGet()))))
 .toList();
 return new DefaultConnection<>(defaultEdges,
 new DefaultPageInfo(new DefaultConnectionCursor(String.valueOf(page.getCurrent())),
 new DefaultConnectionCursor(String.valueOf(page.getPages())),
 page.getCurrent() > 1,
 page.getCurrent() < page.getPages()));
 }
}

Graphql解析配置

	@DgsQuery
	public Connection<Film> filmList(@InputArgument("current") Integer current,
									 @InputArgument("size") Integer size,
									 DgsDataFetchingEnvironment dfe) {
		IPage<Film> page = new PageDTO<>(current, size);
		IPage<Film> pageResult = filmRepository.page(page);
		return ConnectionAssembler.convert(pageResult);
	}

将List查询改为返回Connection即可

测试

访问http://localhost:8080/graphiql即可看到在线查询页面

查看查询数量，确认是按照分页查询

总结

到此，DSG核心功能尝试基本完成，基本实现常用的Rest功能，同时集成方便，而且官方文档清晰，但目前开源社区还没有太多的基于DSG的系统集成样例，还需要在实践中评估摸索。

thoughtworks也从2016年开始关注graphql，目前给出的建议也是“评估”，可以进行小规模尝试并在合适的时候推广

We’ve seen many successful GraphQL implementations on our projects. We’ve seen some interesting patterns of use too, including GraphQL for server-side resource aggregation. That said, we’ve concerns about misuse of this framework and some of the problems that can occur. Examples include performance gotchas around N+1 queries and lots of boilerplate code needed when adding new models, leading to complexity. There are workarounds to these gotchas such as query caching. Even though it’s not a silver bullet, we still think it’s worth assessing as part of your architecture.

GraphQL实践6——Netflix Dgs Graphql N+1问题

Fri, 28 Oct 2022 16:05:51 +0800

N+1问题介绍

对于上一篇文章样例，如果要获取每个电影的演员名单，要执行如下动作

查询所有电影清单
遍历N个电影，查询对应电影的演员名单

总查询开销为N+1次查询，代价非常大，效率低

优化方案 DataLoader

对于一对一表关联的情况且每个关联对象只有一个值，可以直接使用BatchLoader

但实际上，对于大部分表关联情况，通常为一对多或者多对多，不保证每个关联都有值，此时需要使用MappedBatchLoader维护关联关系

维护多对多实体关系Map

public interface ActorService {
	Map<Integer, List<Actor>> listByFilmId(Collection<Integer> filmIds);
}

@Slf4j
@Service
@RequiredArgsConstructor
public class ActorServiceImpl implements ActorService {

	private final ActorRepository actorRepository;

	private final FilmActorRepository filmActorRepository;

	@Override
	public Map<Integer, List<Actor>> listByFilmId(Collection<Integer> filmIds) {
		List<FilmActor> filmActors = filmActorRepository.listByFilmId(filmIds);
		if (CollectionUtils.isEmpty(filmActors)) {
			return Collections.emptyMap();
		}
		Map<Integer, List<FilmActor>> filmActorMap = filmActors.stream().collect(Collectors.groupingBy(FilmActor::getFilmId));
		List<Integer> actorIds = filmActors.stream().map(FilmActor::getActorId).distinct().toList();
		List<Actor> actors = actorRepository.listByIds(actorIds);
		Map<Integer, Actor> actorsMap = Stream.ofNullable(actors).flatMap(Collection::stream).collect(Collectors.toMap(Actor::getActorId, Function.identity(), (e1, e2) -> e1));
		Map<Integer, List<Actor>> result = Maps.newHashMapWithExpectedSize(filmIds.size());
		filmActorMap.forEach((k, v) -> {
			List<Actor> actorList = Stream.ofNullable(filmActorMap.get(k)).flatMap(Collection::stream).map(e -> actorsMap.get(e.getActorId())).toList();
			result.put(k, actorList);
		});
		return result;
	}
}

Dgs MappedBatchLoader 配置

@DgsDataLoader(name = "actors")
@RequiredArgsConstructor
public class FilmActorsDataLoader implements MappedBatchLoader<Integer, List<Actor>> {

	private final ActorService actorService;

	@Override
	public CompletionStage<Map<Integer, List<Actor>>> load(Set<Integer> keys) {
		return CompletableFuture.supplyAsync(() -> actorService.listByFilmId(keys));
	}
}

测试

访问http://localhost:8080/graphiql即可看到在线查询页面

此时执行嵌套查询只会查询2次，一次查电影列表，一次查所有电影的Actor列表，非常快速

总结

使用BatchLoader实现对N+1问题优化，但还有一个潜在问题，即大数据分页，该样例中，有1000个电影，对应5000+演员，查询一次获取全量数据，对数据库压力较大，也不符合实际场景，还需要进行分页优化

GraphQL实践5——Netflix Dgs Graphql懒加载

Fri, 28 Oct 2022 16:04:43 +0800

问题背景

在graphql中，需要查询的字段由调用方传递，如果此时存在关联表才能获取的字段，但前端不需要该字段的时候，默认查询所有字段会带来较大开销

例如

type Actor {
 actorId: Int!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

type Film {
 filmId: Int!
 title: String!
 description: String
 actors: [Actor]
}

type Query {
 filmList: [Film]
}

解决方案——懒加载

DGS框架中支持配置调用方传递了指定字段才读取对应的数据

配置懒加载

增加实体定义，模拟嵌套实体

Mybatis Plus配置

扫描配置

@Configuration
@MapperScan("top.fjy8018.graphsqldemo.mapper")
public class MybatisPlusConfig {
}

实体

表结构还是使用sakila样例数据库的表

@Data
public class Actor implements Serializable {

 @Serial
 private static final long serialVersionUID = 1L;

 /**
 * 联系人ID
 */
 @TableId(type = IdType.AUTO)
 private Integer actorId;

 private String firstName;

 private String lastName;

 private Date lastUpdate;

}

@Data
public class Film implements Serializable {

	@Serial
	private static final long serialVersionUID = 1L;

	/**
	 * 联系人ID
	 */
	@TableId(type = IdType.AUTO)
	private Integer filmId;

	private String title;

	private String description;

	private Integer releaseYear;

	private Integer languageId;

	private Integer originalLanguageId;

	private Integer rentalDuration;

	private BigDecimal rentalRate;

	private Integer length;

	private BigDecimal replacementCost;

	private String rating;

	private String specialFeatures;

	private Date lastUpdate;
}

@Data
public class FilmActor implements Serializable {

	@Serial
	private static final long serialVersionUID = 1L;

	/**
	 * 联系人ID
	 */
	@TableId(type = IdType.AUTO)
	private Integer actorId;

	private Integer filmId;

	private Date lastUpdate;
}

Mapper

public interface ActorMapper extends BaseMapper<Actor> {}
public interface FilmActorMapper extends BaseMapper<FilmActor> {}
public interface FilmMapper extends BaseMapper<Film> {}

DAO

public interface ActorRepository extends IService<Actor> {
}
public interface FilmActorRepository extends IService<FilmActor> {
	List<FilmActor> listByFilmId(@Size.List({@Size(min = 1, message = "至少要有一个元素")}) List<Integer> filmIds);
}
public interface FilmRepository extends IService<Film> {
}

@Validated
@Repository
@RequiredArgsConstructor
public class ActorRepositoryImpl extends ServiceImpl<ActorMapper, Actor> implements ActorRepository {
}
@Validated
@Repository
@RequiredArgsConstructor
public class FilmActorRepositoryImpl extends ServiceImpl<FilmActorMapper, FilmActor> implements FilmActorRepository {
	@Override
	public List<FilmActor> listByFilmId(List<Integer> filmIds) {
		return lambdaQuery().in(FilmActor::getFilmId, filmIds).list();
	}
}
@Validated
@Repository
@RequiredArgsConstructor
public class FilmRepositoryImpl extends ServiceImpl<FilmMapper, Film> implements FilmRepository {
}

Service

多表查询聚合逻辑

public interface ActorService {
	List<Actor> listByFilmId(Integer filmId);
}

@Slf4j
@Service
@RequiredArgsConstructor
public class ActorServiceImpl implements ActorService {

	private final ActorRepository actorRepository;

	private final FilmActorRepository filmActorRepository;

	@Override
	public List<Actor> listByFilmId(Integer filmId) {
		List<FilmActor> filmActors = filmActorRepository.listByFilmId(List.of(filmId));
		if (CollectionUtils.isEmpty(filmActors)) {
			return Collections.emptyList();
		}
		List<Integer> actorIds = filmActors.stream().map(FilmActor::getActorId).toList();
		return actorRepository.listByIds(actorIds);
	}
}

Graphql 查询解析器

@DgsComponent
@RequiredArgsConstructor
public class FilmDataFetcher {

	private final FilmRepository filmRepository;

	private final ActorService actorService;

	@DgsQuery
	public Collection<Film> filmList() {
		return filmRepository.list();
	}

	@DgsData(parentType = "Film")
	public List<Actor> actors(DgsDataFetchingEnvironment dfe) {
		Film film = dfe.getSource();
		return actorService.listByFilmId(film.getFilmId());
	}

	@DgsQuery
	public Film findOneFilm(@InputArgument Integer id) {
		return filmRepository.getById(id);
	}
}

增加DgsDataFetchingEnvironment入参，DGS会自动获取请求上下文参数

此处定义即为传入了actors参数才执行该方法获取对应的Actor集合，实现懒加载

测试

访问http://localhost:8080/graphiql即可看到在线查询页面

不访问Actor

此时可以看到日志输出，没有查询Actor表

访问Actor

此时DSG会执行N+1查询Actor表，性能损耗非常大

总结

对于表关联，开销较大字段，都可以使用DSG懒加载实现性能优化，但此时还是存在N+1查询性能问题，将在后面使用DataLoader优化

GraphQL实践3——Spring-Graphql集成Mybatis Plus

Thu, 27 Oct 2022 15:37:00 +0800

介绍

考虑到国内大部分场景对接的是Mybatis或者Mybatis Plus生态，而不是JPA，同时Graphql版本也进一步迭代，故计划使用Mybatis Plus对接Graphql

集成过程

引入依赖

由于JDK已经发展到19，目前最新的LTS为17，我所在的公司也将生产升级到了JDK 17，未来更多新应用会直接基于17构建，故此处直接基于JDK17对接
SpringBoot版本为2.7.1，目前已知3.0.0 RC1还不兼容第三方graphql
此处不使用spring官方的starter，改为使用graphql-java-kickstart的starter，编写更加简单


 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>

 <!-- graphql-spring-boot-starter -->
 <dependency>
 <groupId>com.graphql-java-kickstart</groupId>
 <artifactId>graphql-spring-boot-starter</artifactId>
 <version>12.0.0</version>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <!-- mybatis-plus-boot-starter -->
 <dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>mybatis-plus-boot-starter</artifactId>
 <version>3.5.2</version>
 </dependency>
 <!-- querydsl-core -->
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-core</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 </dependencies>

配置文件

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: ****
 url: jdbc:mysql://localhost:3306/sakila?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
server:
 port: 8080
graphql:
 tools:
 schema-location-pattern: graphql/*.graphqls
 graphiql:
 # 开启可交互页面，用于调试
 enabled: true
logging:
 level:
 top.fjy8018.graphsqldemo.mapper: DEBUG

Mybatis Plus配置

扫描配置

@Configuration
@MapperScan("top.fjy8018.graphsqldemo.mapper")
public class MybatisPlusConfig {
}

实体

@Data
public class Actor implements Serializable {

 @Serial
 private static final long serialVersionUID = 1L;

 /**
 * 联系人ID
 */
 @TableId(type = IdType.AUTO)
 private Integer actorId;

 private String firstName;

 private String lastName;

 private Date lastUpdate;

}

Mapper

public interface ActorMapper extends BaseMapper<Actor> {
}

DAO

public interface ActorRepository extends IService<Actor> {
}

@Validated
@Repository
@RequiredArgsConstructor
public class ActorRepositoryImpl extends ServiceImpl<ActorMapper, Actor> implements ActorRepository {
}

Graphql 查询解析器

@Component
@AllArgsConstructor
public class ActorGraphQLQueryResolver implements GraphQLQueryResolver {

 private final ActorRepository actorRepository;

 public Collection<Actor> actorList() {
 return actorRepository.list();
 }

 public Actor findOneActor(Integer id) {
 return actorRepository.getById(id);
 }
}

查询文件定义在resources/graphql/actor.graphqls

type Query {
 actorList: [ActorEntity]
 findOneActor(id : ID!): ActorEntity
}

type ActorEntity {
 actorId: ID!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

测试

访问http://localhost:8080/graphiql即可看到在线查询页面

总结

依托Mybatis Plus强大的自带CRUD方法，可以实现和JPA类似的快速对接

GraphQL实践2——Spring-GraphQL集成JPA与MySQL

Mon, 15 Nov 2021 15:38:00 +0800

介绍

上一篇介绍到用第三方库集成GraphQL，目前spring-graphql项目已经出到1.0.0-M3版本，属于内部预览版，此处尝鲜验证

引入依赖

由于SpringBoot 2.6.0还未发布，因此需要引入较多依赖

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.experimental</groupId>
 <artifactId>graphql-spring-boot-starter</artifactId>
 <version>1.0.0-M3</version>
 </dependency>
 <!--升级到Spring Boot 2.6后可以移除-->
 <dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-commons</artifactId>
 <version>2.6.0-RC1</version>
 </dependency>
 <dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-jpa</artifactId>
 <version>2.6.0-RC1</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api -->
 <dependency>
 <groupId>org.hibernate.javax.persistence</groupId>
 <artifactId>hibernate-jpa-2.1-api</artifactId>
 <version>1.0.2.Final</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/com.querydsl/querydsl-jpa -->
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-jpa</artifactId>
 <version>4.4.0</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/com.querydsl/querydsl-apt -->
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-apt</artifactId>
 <version>4.4.0</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api -->
 <dependency>
 <groupId>javax.annotation</groupId>
 <artifactId>javax.annotation-api</artifactId>
 </dependency>
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-core</artifactId>
 </dependency>
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
</dependencies>

引入里程碑仓库

由于还没有GA，所以要引入里程碑仓库

<repositories>
 <repository>
 <id>spring-milestones</id>
 <name>Spring Milestones</name>
 <url>https://repo.spring.io/milestone</url>
 </repository>
 <repository>
 <id>spring-snapshots</id>
 <name>Spring Snapshots</name>
 <url>https://repo.spring.io/snapshot</url>
 <snapshots>
 <enabled>true</enabled>
 </snapshots>
 </repository>
</repositories>

引入插件

由于使用了dsl动态生成，还要引入注解处理器

<build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 <configuration>
 <excludes>
 <exclude>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </exclude>
 </excludes>
 </configuration>
 </plugin>
 <!-- added for QueryDsl-->
 <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>
 </plugins>
</build>

SpringBoot 配置

编写配置文件

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: "****"
 url: jdbc:mysql://localhost:3306/sakila?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 jpa:
 hibernate:
 ddl-auto: none
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true
 graphql:
 path: /graphql
 schema:
 locations: classpath:graphql/
 fileExtensions: .graphqls, .gqls
 printer:
 enabled: true
server:
 port: 8080

实体类

package top.fjy8018.graphsqldemo.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Timestamp;
import java.util.Objects;

/**
 * 演员表实体类
 *
 * @author F嘉阳
 * @date 2021/11/5 10:34
 */
@Data
@Entity
@Table(name = "actor", schema = "sakila")
public class ActorEntity {
 @Id
 @Column(name = "actor_id", nullable = false)
 private Integer actorId;

 @Column(name = "first_name", nullable = false, length = 45)
 private String firstName;

 @Column(name = "last_name", nullable = false, length = 45)
 private String lastName;

 @Column(name = "last_update", nullable = false)
 private Date lastUpdate;

}

DAO

DAO直接继承dsl相关处理器，可自动配对增删改查方法，相比第三方库更加简便

package top.fjy8018.graphsqldemo.repository;

import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.data.repository.CrudRepository;
import org.springframework.graphql.data.GraphQlRepository;
import top.fjy8018.graphsqldemo.entity.ActorEntity;

/**
 * 演员表DAO
 *
 * @author F嘉阳
 * @date 2021/11/5 10:35
 */
@GraphQlRepository
public interface ActorEntityRepository extends
 CrudRepository<ActorEntity, Integer>, QuerydslPredicateExecutor<ActorEntity> {
}

Graphql资源定义

在resources/graphql下定义接口和实体文件

接口声明和实体定义schema.graphqls

type Query {
 findOneActor(actorId : ID!): ActorEntity
 actorList: [ActorEntity]
}

type ActorEntity {
 actorId: ID!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

接口定义acotrEntity.graphql

query findOneActor($id: ID!) {
 findOneActor(actorId: $id) {
 actorId
 firstName
 lastName
 lastUpdate
 }
}

query actorList {
 actorList{
 actorId
 }
}

启动测试

Spring-Graphql默认不包含可视化界面，此处使用postman进行测试

唯一查询

列表查询

总结

使用Spring官方组件好处在于和Spring生态集成度很高，如果本身就采用Jpa方式进行业务开发，迁移更加方便，需要开发的代码也很少。

样例源码地址

FJiayang/graphql-demo

GraphQL实践1——集成JPA与MySQL

Fri, 05 Nov 2021 17:41:00 +0800

介绍

官方定义：

GraphQL 既是一种用于 API 的查询语言也是一个满足你数据查询的运行时。 GraphQL 对你的 API 中的数据提供了一套易于理解的完整描述，使得客户端能够准确地获得它需要的数据，而且没有任何冗余，也让 API 更容易地随着时间推移而演进，还能用于构建强大的开发者工具。

中文官网：

GraphQL — A query language for your API

集成方案选择

GraphQL经过近几年的发展，SpringBoot官方、第三方都提供了starter

SpringBoot官方提供的starter

Spring GraphQL

第三方提供的starter

graphql-spring-boot

两者活跃度都还不错，但考虑到SpringBoot官方的依赖库还未GA，而且使用起来与Spring家族耦合过大，最终决定采用第三方的starter

集成过程

数据库配置

此处采用MySQL数据库，数据内容采用MySQL官方样例sakila数据，表结构和数据地址如下

sakila database下载地址

导入后如下

工程配置

引入最新的SpringBoot框架，依赖如下

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>

 <!-- https://mvnrepository.com/artifact/com.graphql-java-kickstart/graphql-spring-boot-starter -->
 <dependency>
 <groupId>com.graphql-java-kickstart</groupId>
 <artifactId>graphql-spring-boot-starter</artifactId>
 <version>12.0.0</version>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
</dependencies>

增加数据库配置

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: "****"
 url: jdbc:mysql://localhost:3306/sakila?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true
server:
 port: 8080
graphql:
 tools:
 schema-location-pattern: graphql/*.graphqls
 graphiql:
 # 开启可交互页面，用于调试
 enabled: true

实体映射

新增实体映射，此处只映射Actor表作为样例

package top.fjy8018.graphsqldemo.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Timestamp;
import java.util.Objects;

/**
 * 演员表实体映射
 *
 * @author F嘉阳
 * @date 2021/11/5 10:34
 */
@Data
@Entity
@Table(name = "actor", schema = "sakila")
public class ActorEntity {
 @Id
 @Column(name = "actor_id", nullable = false)
 private Integer actorId;

 @Column(name = "first_name", nullable = false, length = 45)
 private String firstName;

 @Column(name = "last_name", nullable = false, length = 45)
 private String lastName;

 @Column(name = "last_update", nullable = false)
 private Timestamp lastUpdate;
}

新增DAO

package top.fjy8018.graphsqldemo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.graphsqldemo.entity.ActorEntity;

/**
 * 演员表DAO
 *
 * @author F嘉阳
 * @date 2021/11/5 10:35
 */
public interface ActorEntityRepository extends JpaRepository<ActorEntity, Integer> {
}

新增查询接口配置

在resources/graphql下新增文件actor.graphqls

type Query {
 actorList: [ActorEntity]
 findOneActor(id : ID!): ActorEntity
}

type ActorEntity {
 actorId: ID!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

新增查询解析器

package top.fjy8018.graphsqldemo.resolver;

import graphql.kickstart.tools.GraphQLQueryResolver;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;
import top.fjy8018.graphsqldemo.entity.ActorEntity;
import top.fjy8018.graphsqldemo.repository.ActorEntityRepository;

import java.util.Collection;

/**
 * 演员表GraphQL查询解析器
 *
 * @author F嘉阳
 * @date 2021/11/5 16:27
 */
@Component
@AllArgsConstructor
public class ActorGraphQLQueryResolver implements GraphQLQueryResolver {

 private final ActorEntityRepository actorRepository;

 public Collection<ActorEntity> actorList() {
 return actorRepository.findAll();
 }

 public ActorEntity findOneActor(Integer id) {
 return actorRepository.findById(id).orElse(null);
 }
}

启动验证

启动工程后，浏览器打开http://localhost:8080/graphiql

列表查询

由于采用交互式页面，输入也会有语法提示，比较方便

唯一查询

优缺点分析

优点

接口定义清晰，配置即接口
前端按需获取字段，减少数据传输量
接口整合、演进更加便利

缺点

减少字段个数对后端实现没有变化，并不能提升数据库性能

样例源码地址

FJiayang/graphql-demo

SpringCloudStream函数式编程模型

Sun, 21 Feb 2021 12:22:00 +0800

背景

SpringCloud 3.1版本之后，@EnableBinding、@Output等StreamApi注解都标记为废弃

/**
 * Indicates that an output binding target will be created by the framework.
 *
 * @author Dave Syer
 * @author Marius Bogoevici
 * @author Artem Bilan
 *
 * @deprecated as of 3.1 in favor of functional programming model
 */

@Qualifier
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE,
		ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Deprecated
public @interface Output {

	/**
	 * Specify the binding target name; used as a bean name for binding target and as a
	 * destination name by default.
	 * @return the binding target name
	 */
	String value() default "";

}

/**
 * Enables the binding of targets annotated with {@link Input} and {@link Output} to a
 * broker, according to the list of interfaces passed as value to the annotation.
 *
 * @author Dave Syer
 * @author Marius Bogoevici
 * @author David Turanski
 * @author Soby Chacko
 *
 * @deprecated as of 3.1 in favor of functional programming model
 */
@Target({ ElementType.TYPE, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Configuration
@Import({ BindingBeansRegistrar.class, BinderFactoryAutoConfiguration.class })
@EnableIntegration
@Deprecated
public @interface EnableBinding {

	/**
	 * A list of interfaces having methods annotated with {@link Input} and/or
	 * {@link Output} to indicate binding targets.
	 * @return list of interfaces
	 */
	Class<?>[] value() default {};

}

Producing and Consuming Messages — SpringCloud 官方文档

@EnableBinding @deprecated as of 3.1 in favor of functional programming model — stackoverflow

The type EnableBinding is deprecated — stackoverflow

因此，所有采用命令式编程的API，在升级到新版本时，官方推荐使用更加简单的函数式编程API

完整代码样例

FJiayang/spring-cloud-stream-rabbit-example — GitHub项目地址

升级方式

命令式编程模型

以简单多Topic消息为例，原本的编程方式如下

生产者

@SpringBootApplication
public class ProducerApplication {

 public static void main(String[] args) {
 SpringApplication.run(ProducerApplication.class, args);
 }
}

/**
 * @author F嘉阳
 * @date 2018-10-08 17:57
 */
@RestController
@EnableBinding(MySource.class)
public class Producer {

 @Autowired
 private MySource channel;

 @RequestMapping("/send")
 public String send() {
 channel.output().send(MessageBuilder.withPayload(new Date()).build());
 return "success";
 }
}

/**
 * @author F嘉阳
 * @date 2018-10-08 18:01
 */
public interface MySource {
 String OUTPUT = "output";

 @Output(MySource.OUTPUT)
 MessageChannel output();
}

配置文件

spring:
 rabbitmq:
 host: 192.168.163.128
 username: cms
 password: cms-mq-admin
 cloud:
 stream:
 bindings:
 output:
 destination: my-test-channel
server:
 port: 8082

消费者

@SpringBootApplication
public class ConsumerApplication {

 public static void main(String[] args) {
 SpringApplication.run(ConsumerApplication.class, args);
 }
}

/**
 * @author F嘉阳
 * @date 2018-10-08 18:10
 */
@EnableBinding(MySink.class)
public class Consumer {
 @StreamListener(MySink.INPUT)
 public void receive(Message<String> message) {
 System.out.println("接收到MQ消息:" + message.getPayload());
 }
}

/**
 * @author F嘉阳
 * @date 2018-10-08 18:07
 */
public interface MySink {
 String INPUT = "input";

 @Input(MySink.INPUT)
 SubscribableChannel input();
}

配置文件

spring:
 rabbitmq:
 host: 192.168.163.128
 username: cms
 password: cms-mq-admin
 cloud:
 stream:
 bindings:
 input:
 destination: my-test-channel
server:
 port: 8081

函数式编程模型

从命令式升级到函数式编程，首先需要升级SpringCloud版本至3.1以上，此处升级到最新版2020.0.1

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>top.fjy8018</groupId>
 <artifactId>cloud-stream</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>pom</packaging>

 <name>cloud-stream</name>
 <description>Demo project for Spring Boot</description>

 <modules>
 <module>producer</module>
 <module>consumer</module>
 </modules>

 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.4.2</version>
 <relativePath/> <!-- lookup parent from repository -->
 </parent>

 <properties>
 <spring-cloud.version>2020.0.1</spring-cloud.version>
 </properties>

 <dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>${spring-cloud.version}</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>
</project>

目前国内有清晰的升级指引的还比较少，目前只能参考官方文档材料

Programming Model — SpringCloud官方文档

模型1——系统定时驱动的消息队列

官方文档描述

Suppliers (Sources)
Function and Consumer are pretty straightforward when it comes to how their invocation is triggered. They are triggered based on data (events) sent to the destination they are bound to. In other words, they are classic event-driven components.

However, Supplier is in its own category when it comes to triggering. Since it is, by definition, the source (the origin) of the data, it does not subscribe to any in-bound destination and, therefore, has to be triggered by some other mechanism(s). There is also a question of Supplier implementation, which could be imperative or reactive and which directly relates to the triggering of such suppliers.

Consider the following sample:
@SpringBootApplication
public static class SupplierConfiguration {

	@Bean
	public Supplier<String> stringSupplier() {
		return () -> "Hello from Supplier";
	}
}
The preceding Supplier bean produces a string whenever its get() method is invoked. However, who invokes this method and how often? The framework provides a default polling mechanism (answering the question of “Who?”) that will trigger the invocation of the supplier and by default it will do so every second (answering the question of “How often?”). In other words, the above configuration produces a single message every second and each message is sent to an output destination that is exposed by the binder.

其大意为，若采用默认的函数式编程模型，会每秒钟发送一条消息到消费者，定时发送参数可以配置

按照文档升级后如下

生产者

@SpringBootApplication
public class ProducerApplication {

 public static void main(String[] args) {
 SpringApplication.run(ProducerApplication.class, args);
 }

 @Bean
 public Supplier<Date> source1() {
 return () -> new Date();
 }
}

函数式编程不需要在代码中定义监听队列，只需要按照约定写在配置文件中即可

官方文档描述

Functional binding names
Unlike the explicit naming required by annotation-based support (legacy) used in the previous versions of spring-cloud-stream, the functional programming model defaults to a simple convention when it comes to binding names, thus greatly simplifying application configuration. Let’s look at the first example:
@SpringBootApplication
public class SampleApplication {

	@Bean
	public Function<String, String> uppercase() {
	 return value -> value.toUpperCase();
	}
}
In the preceding example we have an application with a single function which acts as message handler. As a Function it has an input and output. The naming convention used to name input and output bindings is as follows:

input - <functionName> + -in- + <index>

output - <functionName> + -out- + <index>

The in and out corresponds to the type of binding (such as input or output). The index is the index of the input or output binding. It is always 0 for typical single input/output function, so it’s only relevant for Functions with multiple input and output arguments.

So if for example you would want to map the input of this function to a remote destination (e.g., topic, queue etc) called “my-topic” you would do so with the following property:
--spring.cloud.stream.bindings.uppercase-in-0.destination=my-topic
Note how uppercase-in-0 is used as a segment in property name. The same goes for uppercase-out-0.

配置文件

spring:
 rabbitmq:
 host: 192.168.163.128
 username: cms
 password: cms-mq-admin

 cloud:
 stream:
 bindings:
 source1-out-0:
 destination: test1
 function:
 definition: source1

server:
 port: 8083

由此可见，整体配置简化了很多，多为规约大于配置的方式进行定义，特别注意function配置的位置，是在stream配置的同级

消费者

@SpringBootApplication
public class ConsumerApplication {

 public static void main(String[] args) {
 SpringApplication.run(ConsumerApplication.class, args);
 }

 @Bean
 public Consumer<Date> sink1() {
 return System.out::println;
 }
}

配置文件同理

spring:
 rabbitmq:
 host: 192.168.163.128
 username: cms
 password: cms-mq-admin

 cloud:
 stream:
 bindings:
 sink1-in-0:
 destination: test1
 function:
 definition: sink1


server:
 port: 8081

运行结果

生产者每隔一秒发送一次消息

模型2——`StreamBridge`

但实际生产中，更多是由业务场景触发，故不能使用该模式进行配置，SpringCloud还提供了另外一种StreamBridge模式

官方文档介绍

Sending arbitrary data to an output (e.g. Foreign event-driven sources)
There are cases where the actual source of data may be coming from the external (foreign) system that is not a binder. For example, the source of the data may be a classic REST endpoint. How do we bridge such source with the functional mechanism used by spring-cloud-stream?

Spring Cloud Stream provides two mechanisms, so let’s look at them in more details

Here, for both samples we’ll use a standard MVC endpoint method called delegateToSupplier bound to the root web context, delegating incoming requests to stream via two different mechanisms - imperative (via StreamBridge) and reactive (via EmitterProcessor).

大意是，实际的数据源可以是外部事件驱动，例如通过Rest接口

官方样例

Using StreamBridge
@SpringBootApplication
@Controller
public class WebSourceApplication {

	public static void main(String[] args) {
		SpringApplication.run(WebSourceApplication.class, "--spring.cloud.stream.source=toStream");
	}

	@Autowired
	private StreamBridge streamBridge;

	@RequestMapping
	@ResponseStatus(HttpStatus.ACCEPTED)
	public void delegateToSupplier(@RequestBody String body) {
		System.out.println("Sending " + body);
		streamBridge.send("toStream-out-0", body);
	}
}
Here we autowire a StreamBridge bean which allows us to send data to an output binding effectively bridging non-stream application with spring-cloud-stream. Note that preceding example does not have any source functions defined (e.g., Supplier bean) leaving the framework with no trigger to create source bindings, which would be typical for cases where configuration contains function beans. So to trigger the creation of source binding we use spring.cloud.stream.source property where you can declare the name of your sources. The provided name will be used as a trigger to create a source binding. So in the preceding example the name of the output binding will be toStream-out-0 which is consistent with the binding naming convention used by functions (see Binding and Binding names). You can use ; to signify multiple sources (e.g., --spring.cloud.stream.source=foo;bar)

参考官方文档改造后

生产者

这里直接贴出多主题的消费模式，实际生产中多数也是订阅多个主题

@SpringBootApplication
public class ProducerApplication {

 public static void main(String[] args) {
 SpringApplication.run(ProducerApplication.class, args);
 }
}

/**
 * @author F嘉阳
 * @date 2018-10-08 17:57
 */
@RestController
public class Producer {

 @Autowired
 private StreamBridge streamBridge;

 @RequestMapping("/send1")
 public String send1() {
 streamBridge.send("source1-out-0", new Date());
 return "success1";
 }

 @RequestMapping("/send2")
 public String send2() {
 streamBridge.send("source2-out-0", LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
 return "success2";
 }

}

配置文件

spring:
 rabbitmq:
 host: 192.168.133.128
 username: dev-user
 password: devpassword

 cloud:
 stream:
 bindings:
 source1-out-0:
 destination: test2
 source2-out-0:
 destination: test3
 function:
 definition: source1;source2


server:
 port: 8083

消费者

@SpringBootApplication
public class ConsumerApplication {

 public static void main(String[] args) {
 SpringApplication.run(ConsumerApplication.class, args);
 }

 @Bean
 public Consumer<Date> sink1() {
 return System.out::println;
 }

 @Bean
 public Consumer<String> sink2() {
 return System.out::println;
 }
}

配置文件

spring:
 rabbitmq:
 host: 192.168.133.128
 username: dev-user
 password: devpassword

 cloud:
 stream:
 bindings:
 sink1-in-0:
 destination: test2
 sink2-in-0:
 destination: test3
 function:
 definition: sink1;sink2

server:
 port: 8081

运行结果

触发/send1

触发/send2

可见消息被正确的路由

总结

整体来看，函数式编程比命令式编程更加简洁，而且加上SpringCloud规约大于配置的特点，可以明显减少配置的代码量，是未来发展的趋势。

SpringBoot源码分析2——走向自动装配

Thu, 10 Dec 2020 17:28:00 +0800

Spring Framework 手动装配

Spring模式注解装配

定义:一种用于声明在应用中扮演“组件”角色的注解
举例:@Component、@Service、@Configuration等
装配:< context: component-scan>或@Componentscan

官方仓库说明

Stereotype Annotations
A *stereotype annotation* is an annotation that is used to declare the role that a component plays within the application. For example, the @Repository annotation in the Spring Framework is a marker for any class that fulfills the role or stereotype of a repository (also known as Data Access Object or DAO).

@Component is a generic stereotype for any Spring-managed component. Any component annotated with @Component is a candidate for component scanning. Similarly, any component annotated with an annotation that is itself meta-annotated with @Component is also a candidate for component scanning. For example, @Service is meta-annotated with @Component.

Core Spring provides several stereotype annotations out of the box, including but not limited to: @Component, @Service, @Repository, @Controller, @RestController, and @Configuration. @Repository, @Service, etc. are specializations of @Component.

模式注解是一种用于声明在应用中扮演“组件”角色的注解。如 Spring Framework 中的 @Repository 标注在任何类上，用于扮演仓储角色的模式注解。

@Component 作为一种由 Spring 容器托管的通用模式组件，任何被 @Component 标准的组件均为组件扫描的候选对象。类似地，凡是被 @Component 元标注（meta-annotated）的注解，如 @Service ，当任何组件标注它时，也被视作组件扫描的候选对象（派生性）

模式注解举例

Spring Framework 注解	场景说明	起始版本
`@Repository`	数据仓储模式注解	2.0
`@Component`	通用组件模式注解	2.5
`@Service`	服务模式注解	2.5
`@Controller`	Web控制器模式注解	2.5
`@Configuration`	配置类模式注解	3.0

装配方式

<context:component-scan> 方式

<?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:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-
context.xsd">
 
 <!-- 激活注解驱动特性 -->
 <context:annotation-config />
 
 <!-- 找寻被 @Component 或者其派生 Annotation 标记的类（Class），将它们注册为 Spring Bean -->
 <context:component-scan base-package="top.fjy8018.spring.boot" />
 
</beans>

@ComponentScan 方式

@ComponentScan(basePackages = "top.fjy8018.spring.boot")
public class SpringConfiguration {
 ...
}

Spring Framework手动装配

自定义模式注解

`@Component` “派生性”

package top.fjy8018.springboot.annotation;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.lang.annotation.*;

/**
 * @author F嘉阳
 * @date 2018-09-09 10:36
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repository
public @interface FirstLevelRepository {

 /**
 * 保证签名一致性
 */
 String value() default "";
}

三个级别并无明显区别，体现注解派生性，即使用@FirstLevelRepository和使用@Component效果一致

派生关系

@Component
- @Repository
  - @FirstLevelRepository

package org.springframework.stereotype;

/**
 * @since 2.5
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {

 /**
 * Component的签名
 */
 String value() default "";

}

Repository中元标注了@Component

package org.springframework.stereotype;

/**
 * @since 2.0
 * @see Component
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {

 /**
 * 签名与Component一致
 */
 @AliasFor(annotation = Component.class)
 String value() default "";
}

`@Component` “层次性”

package top.fjy8018.springboot.annotation;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.lang.annotation.*;

/**
 * Component层次性
 * 顶级 {@link Component}
 * 一级 {@link Repository @Repository}
 * 二级 {@link FirstLevelRepository}
 * 三级 {@link SecondLevelRepository}
 *
 * @author F嘉阳
 * @date 2018-09-09 10:54
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@FirstLevelRepository
public @interface SecondLevelRepository {

 /**
 * 层次性、派生性都必须保证签名一致
 */
 String value() default "";
}

@Component
- @Repository
  - FirstLevelRepository
    - SecondLevelRepository

注解目标类，value 为bean的名称，此处不管用@FirstLevelRepository还是用SecondLevelRepository，效果都和使用@Component一致

package top.fjy8018.springboot.repository;

import top.fjy8018.springboot.annotation.FirstLevelRepository;

/**
 * @author F嘉阳
 * @date 2018-09-09 10:40
 */
//@Component("myRepository")
@FirstLevelRepository(value = "myRepository")
//@SecondLevelRepository(value = "myRepository")
public class RepositoryDemo {
}

仓储引导类，使用@ComponentScan指定扫描Bean路径

package top.fjy8018.springboot.bootstrap;

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import top.fjy8018.springboot.repository.RepositoryDemo;

/**
 * @author F嘉阳
 * @date 2018-09-09 10:43
 */
@ComponentScan(basePackages = "top.fjy8018.springboot.repository")
public class RepositoryBootstrapDemo {

 public static void main(String[] args) {
 ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(RepositoryBootstrapDemo.class)
 .web(WebApplicationType.NONE)
 .run(args);

 // 通过bean名称获取bean
 RepositoryDemo myRepository = applicationContext.getBean("myRepository", RepositoryDemo.class);

 // myRepository是否存在，若不存在则报错
 System.out.println("myRepository是否存在：" + myRepository);

 // 关闭上下文
 applicationContext.close();
 }
}

执行结果

SpringBoot源码中也有体现该层次关系

@SpringBootApplication
- @SpringBootConfiguration
  - @Configuration
    - @Component
- @EnableAutoConfiguration
  - @AutoConfigurationPackage

Spring @Enable 模块装配

Spring Framework 3.1 开始支持“@Enable 模块驱动”。所谓“模块”是指具备相同领域的功能组件集合，组合所形成一个独立的单元。比如 Web MVC 模块、AspectJ代理模块、Caching（缓存）模块、JMX（Java 管理扩展）模块、Async（异步处理）模块等。

举例:@EnableWebmvc、@EnableAutoConfiguration等
实现:注解方式、编程方式

@Enable 注解模块举例

框架实现	`@Enable` 注解模块	激活模块
Spring Framework	`@EnableWebMvc`	Web
	`@EnableTransactionManagement`	事务管理模块
	`@EnableCaching`	Caching 模块
	`@EnableMBeanExport`	JMX 模块
	`@EnableAsync`	异步处理模块
	`EnableWebFlux`	Web Flux 模块
	`@EnableAspectJAutoProxy`	AspectJ 代理模块

Spring Boot	`@EnableAutoConfiguration`	自动装配模块
	`@EnableManagementContext`	Actuator 管理模块
	`@EnableConfigurationProperties`	配置属性绑定模块
	`@EnableOAuth2Sso`	OAuth2 单点登录模块

Spring Cloud	`@EnableEurekaServer`	Eureka服务器模块
	`@EnableConfigServer`	配置服务器模块
	`@EnableFeignClients`	Feign客户端模块
	`@EnableZuulProxy`	服务网关
	`@EnableCircuitBreaker`	服务熔断模块

实现方式

注解驱动方式

Spring源码，使用@Import注入配置Bean

package org.springframework.web.servlet.config.annotation;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {}

接口编程方式

Spring源码——激活缓存注解

package org.springframework.cache.annotation;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(CachingConfigurationSelector.class)
public @interface EnableCaching {...}

CachingConfigurationSelector类图

ImportSelector接口源码，该接口在3.1引入，目的在于增加灵活度

selectImports方法返回数组，即可以死是多个配置Bean

package org.springframework.context.annotation;

/**
 * @since 3.1
 */
public interface ImportSelector {
 
 String[] selectImports(AnnotationMetadata importingClassMetadata);
}

@Enable注解方式自定义实现

激活HelloWorld模块，使用@Import(HelloWorldConfiguration.class)直接注入HelloWorldConfiguration模块

package top.fjy8018.springboot.annotation;

import org.springframework.context.annotation.Import;
import top.fjy8018.springboot.configuration.HelloWorldConfiguration;

import java.lang.annotation.*;

/**
 * @author F嘉阳
 * @date 2018-09-09 11:35
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(HelloWorldConfiguration.class)
public @interface EnableHelloWorld {}

目标类，其注解@Configuration在Spring3.0时引入

package top.fjy8018.springboot.configuration;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author F嘉阳
 * @date 2018-09-09 11:31
 */
@Configuration
public class HelloWorldConfiguration {

 /**
 * 方法名称即Bean名称
 * @return Hello World!
 */
 @Bean
 public String helloWorld() {
 return "Hello world!";
 }
}

package org.springframework.context.annotation;

/**
 * @since 3.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
 @AliasFor(annotation = Component.class)
 String value() default "";
}

@Enable接口编程方式自定义实现

参考Spring包名路径创建自定义Selector，通过HelloWorldImportSelector实现HelloWorldConfiguration的配置Bean导入

package top.fjy8018.springboot.annotation;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;
import top.fjy8018.springboot.configuration.HelloWorldConfiguration;

/**
 * @author F嘉阳
 * @date 2018-09-09 11:28
 */
public class HelloWorldImportSelector implements ImportSelector {

 /**
 * @param importingClassMetadata 元数据信息
 * @return 一个或多个配置Bean
 */
 @Override
 public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 return new String[]{HelloWorldConfiguration.class.getName()};
 }
}

激活模块方式变化，使用@Import(HelloWorldImportSelector.class)注入HelloWorldImportSelector模块，在Selector里加载并返回 HelloWorldConfiguration 模块

package top.fjy8018.springboot.annotation;

import org.springframework.context.annotation.Import;
import top.fjy8018.springboot.configuration.HelloWorldConfiguration;

import java.lang.annotation.*;

/**
 * @author F嘉阳
 * @date 2018-09-09 11:35
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
//@Import(HelloWorldConfiguration.class)
@Import(HelloWorldImportSelector.class)
public @interface EnableHelloWorld {
}

实现逻辑

graph LR
A(EnableHelloWorld) --> B(HelloWorldImportSelector) 
 B-->C(HelloWorldConfiguration)
 C --> D(helloWorld)

此方法比直接注解驱动更有弹性，可增加switch条件返回不同的模块，源码样例CachingConfigurationSelector

package org.springframework.cache.annotation;
public class CachingConfigurationSelector extends AdviceModeImportSelector<EnableCaching> {
 
 @Override
 public String[] selectImports(AdviceMode adviceMode) {
 switch (adviceMode) {
 case PROXY:
 return getProxyImports();
 case ASPECTJ:
 return getAspectJImports();
 default:
 return null;
 }
 }
 ...
}

Spring条件装配

从 Spring Framework 3.1 开始，允许在 Bean 装配时增加前置条件判断

Spring 注解	场景说明	起始版本
`@Profile`	配置化条件装配	3.1
`@Conditional`	编程条件装配	4.0

条件注解实现方式

配置方式 - `@Profile`

在spring4后实现方式发生变化，依赖@Conditional和ProfileCondition实现

package org.springframework.context.annotation;

/**
* @since 3.1
*/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {...}

package org.springframework.context.annotation;

/**
 * @since 4.0
 */
class ProfileCondition implements Condition {...}

通过上下文对象和注解元信息判断

package org.springframework.context.annotation;

/**
 * @since 4.0
 */
@FunctionalInterface
public interface Condition {
 boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

编程方式 - `@Conditional`

ConditionalOnClass用于判断标识类在当前classpath下是否存在，该注解使用@Conditional搭配OnClassCondition实现

package org.springframework.boot.autoconfigure.condition;

/**
 * {@link Conditional} that only matches when the specified classes are on the classpath.
 */
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {...}

package org.springframework.boot.autoconfigure.condition;

/**
 * {@link Condition} that checks if properties are defined in environment.
 * @since 1.1.0
 * @see ConditionalOnProperty
 */
@Order(Ordered.HIGHEST_PRECEDENCE + 40)
class OnPropertyCondition extends SpringBootCondition {
 @Override
 public ConditionOutcome getMatchOutcome(ConditionContext context,
 AnnotatedTypeMetadata metadata) {
 // 获取元信息
 List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
 metadata.getAllAnnotationAttributes(
 ConditionalOnProperty.class.getName()));
 List<ConditionMessage> noMatch = new ArrayList<>();
 List<ConditionMessage> match = new ArrayList<>();
 for (AnnotationAttributes annotationAttributes : allAnnotationAttributes) {
 ConditionOutcome outcome = determineOutcome(annotationAttributes,
 context.getEnvironment());
 (outcome.isMatch() ? match : noMatch).add(outcome.getConditionMessage());
 }
 if (!noMatch.isEmpty()) {
 return ConditionOutcome.noMatch(ConditionMessage.of(noMatch));
 }
 return ConditionOutcome.match(ConditionMessage.of(match));
 }
 ...
}

OnPropertyCondition为抽象类，实际仍然是Condition接口的实现

package org.springframework.boot.autoconfigure.condition;

public abstract class SpringBootCondition implements Condition {...}

ConditionalOnProperty用于判断配置在上下文中是否存在

package org.springframework.boot.autoconfigure.condition;

/**
 * @since 1.1.0
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnPropertyCondition.class)
public @interface ConditionalOnProperty {...}

自定义条件装配

目标服务

package top.fjy8018.springboot.service;

/**
 * 计算模块
 * @author F嘉阳
 * @date 2018-09-09 11:56
 */
public interface CalculateService {

 /**
 * 多整数求和
 * @param values 多个整数
 * @return 累加值
 */
 Integer sum(Integer... values);
}

基于配置方式

服务实现类，分别使用 for循环实现和Lambda实现，均标注@Service作为Bean自动注入

指定@Profile("Java7")，当条件为Java7时才装配

package top.fjy8018.springboot.service.impl;

import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
import top.fjy8018.springboot.service.CalculateService;

/**
 * @author F嘉阳
 * @date 2018-09-09 11:57
 */
@Profile("Java7")
@Service
public class Java7CalculateServiceImpl implements CalculateService {

 /**
 * 多整数求和
 *
 * @param values 多个整数
 * @return 累加值
 */
 @Override
 public Integer sum(Integer... values) {
 System.out.println("计算模块java7 for循环实现");
 int sum = 0;
 for (int i = 0; i < values.length; i++) {
 sum += values[i];
 }
 return sum;
 }
}

指定@Profile("Java8")，当条件为Java7时才装配

package top.fjy8018.springboot.service.impl;

import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;
import top.fjy8018.springboot.service.CalculateService;

import java.util.stream.Stream;

/**
 * @author F嘉阳
 * @date 2018-09-09 11:57
 */
@Profile("Java8")
@Service
public class Java8CalculateServiceImpl implements CalculateService {

 /**
 * 多整数求和
 * @param values 多个整数
 * @return 累加值
 */
 @Override
 public Integer sum(Integer... values) {
 System.out.println("计算模块java8 Lambda实现");
 return Stream.of(values).reduce(0, Integer::sum);
 }
}

启动类，通过scanBasePackages指定报名扫描，该方法与@ComponentScan(basePackages = "xxx")效果一致

package top.fjy8018.springboot.bootstrap;

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import top.fjy8018.springboot.service.CalculateService;

/**
 * @author F嘉阳
 * @date 2018-09-09 12:06
 */
@SpringBootApplication(scanBasePackages = "top.fjy8018.springboot.service")
public class CalculateServiceDemo {

 public static void main(String[] args) {
 ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(CalculateServiceDemo.class)
 .profiles("Java8")
 .web(WebApplicationType.NONE)
 .run(args);

 // 直接用类获取bean
 CalculateService calculateService = applicationContext.getBean(CalculateService.class);

 // calculateService Bean 是否存在，若不添加Profile则必有报错
 Integer[] values = new Integer[10];
 for (int i = 1; i <= values.length; i++) {
 values[i - 1] = i;
 }
 System.out.println("calculateService Bean 求和: " + calculateService.sum(values));

 // 关闭上下文
 applicationContext.close();
 }
}

执行结果——java8

执行结果——java7

若不指定配置则报错

基于编程方式

系统属性条件判断实现类

package top.fjy8018.springboot.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;

/**
 * @author F嘉阳
 * @date 2018-09-09 17:15
 */
public class OnSystemPropertyCondition implements Condition {

 /**
 * 条件匹配规则，此处可实现复杂逻辑判断
 * @param context 上下文
 * @param metadata 元信息
 * @return 是否匹配
 */
 @Override
 public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

 // 通过类名称取元信息
 Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(ConditionalOnSystemProperty.class.getName());

 String propertyName = String.valueOf(annotationAttributes.get("name"));
 String propertyValue = String.valueOf(annotationAttributes.get("value"));

 // 取系统属性
 String systemPropertyValue = System.getProperty(propertyName);

 return propertyValue.equals(systemPropertyValue);
 }

Java 系统属性条件判断类装配，系统属性通过Java API获取java.lang.System#getProperty(java.lang.String)方法获取的属性值

package top.fjy8018.springboot.condition;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

/**
 * @author F嘉阳
 * @date 2018-09-09 17:14
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnSystemPropertyCondition.class)
public @interface ConditionalOnSystemProperty {

 /**
 * Java 系统属性名称
 * @return 系统属性名称
 */
 String name();

 /**
 * 系统属性值
 * @return 属性值
 */
 String value();
}

启动类，helloWorld仅在系统条件满足时自动装配，注解若作用于类上语义相同

package top.fjy8018.springboot.bootstrap;

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import top.fjy8018.springboot.condition.ConditionalOnSystemProperty;

/**
 * 系统属性条件引导类
 *
 * @author F嘉阳
 * @date 2018-09-09 17:26
 */
public class SystemPropertyConditionBootstrap {

 @Bean
 @ConditionalOnSystemProperty(name = "user.name", value = "11860")
 public String helloWorld() {
 return "Hello SpringBoot2.0";
 }

 public static void main(String[] args) {
 ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(SystemPropertyConditionBootstrap.class)
 .web(WebApplicationType.NONE)
 .run(args);

 // 通过类型和方法名获取Bean
 String helloWorldBean = applicationContext.getBean("helloWorld", String.class);
 // 若系统参数条件不匹配则报找不到Bean错误，以此实现编程方式条件加载
 System.out.println("ConditionalOnSystemProperty 加载内容：" + helloWorldBean);

 applicationContext.close();
 }
}

执行结果

条件不满足则报错

Spring Boot 自动装配

在 Spring Boot 场景下，基于规约大于配置的原则，实现 Spring 组件自动装配的目的（0配置）。

装配: 模式注解、@Eηable模块、条件装配、工厂加载机制
实现: 激活自动装配、实现自动装配、配置自动装配实现

底层装配技术

Spring 模式注解装配
Spring @Enable 模块装配
Spring 条件装配装配
Spring 工厂加载机制
- 实现类： SpringFactoriesLoader
- 配置资源： META-INF/spring.factories

package org.springframework.core.io.support;

/**
 * @since 3.2
 */
public abstract class SpringFactoriesLoader {

 public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
 
 public static <T> List<T> loadFactories(Class<T> factoryClass, @Nullable ClassLoader classLoader) {
 Assert.notNull(factoryClass, "'factoryClass' must not be null");
 // 获取类加载器
 ClassLoader classLoaderToUse = classLoader;
 if (classLoaderToUse == null) {
 classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
 }
 List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
 if (logger.isTraceEnabled()) {
 logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
 }
 List<T> result = new ArrayList<>(factoryNames.size());
 // 迭代装配
 for (String factoryName : factoryNames) {
 result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
 }
 AnnotationAwareOrderComparator.sort(result);
 return result;
 }
 ...
}

自动装配举例

参考 META-INF/spring.factories

实现方法

激活自动装配 - @EnableAutoConfiguration
实现自动装配 - XXXAutoConfiguration
配置自动装配实现 - META-INF/spring.factories

目的在于使用META-INF/spring.factories文件配置替代@ComponentScan手动装配注解，从而实现自动装配

而Spring大多数自动装配都由starter模块负责

自定义自动装配

设计逻辑

HelloWorldAutoConfiguration

条件判断： user.name == "Mercy"
模式注解： @Configuration
@Enable 模块：流程图

引导类

package top.fjy8018.springboot.bootstrap;

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * @author F嘉阳
 * @date 2018-09-10 17:13
 */
@EnableAutoConfiguration
public class HelloWorldAutoConfigurationBootstrap {

 public static void main(String[] args) {
 ConfigurableApplicationContext applicationContext = new SpringApplicationBuilder(HelloWorldAutoConfigurationBootstrap.class)
 .web(WebApplicationType.NONE)
 .run(args);

 // 通过bean名称获取helloWorld Bean
 String helloWorldBean = applicationContext.getBean("helloWorld", String.class);

 // helloWorld Bean 是否存在
 System.out.println("helloWorld Bean 内容: " + helloWorldBean);

 // 关闭上下文
 applicationContext.close();
 }
}

配置Bean，使用模式注解标注 @Configuration，该类实际上实现了条件装配、模式注解、自动装配

package top.fjy8018.springboot.configuration;

import org.springframework.context.annotation.Configuration;
import top.fjy8018.springboot.annotation.EnableHelloWorld;
import top.fjy8018.springboot.condition.ConditionalOnSystemProperty;

/**
 * @author F嘉阳
 * @date 2018-09-10 17:23
 */
@Configuration
@EnableHelloWorld
@ConditionalOnSystemProperty(name = "user.name", value = "11860")
public class HelloWorldAutoConfiguration {}

创建spring.factories，每行全类名顶格开始，防止在某些版本下产生不稳定的BUG

# 自动装配
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
top.fjy8018.springboot.configuration.HelloWorldAutoConfiguration

执行结果与之前一致

SpringBoot源码分析1——总览

Thu, 10 Dec 2020 17:11:00 +0800

SpringBoot 2.0 特点

组件自动装配

规约大于配置,专注核心业务

模式注解、@ Enable模块、条件装配、加载机制

外部化配置

一次构建、按需调配,到处运行

Environment抽象、生命周期、破坏性变更

嵌入式容器

内置容器、无需部署、独立运行

Servlet Web容器、 Reactive Web容器

Spring Boot Starter

简化依赖、按需装配、自我包含

依赖管理、装配条件、装配顺序

Production-Ready

一站式运维、生态无缝整合

健康检査、数据指标、@ Endpoint管控

SpringBoot 与Java EE规范

Web: Servlet( JSR-315, JSR-340）
SQL: JDBC(SR-221)
数据校验: Bean validation(JSR303、JSR-349)
缓存: Java Caching API(JSR-107)
Web Sockets: Java api for Web Socket(JSR-356
Web services: JAX-WS( JSR-224）
Java管理:JMX(JSR3)
消息:JMS(JSR-914)

核心特性介绍

三大特性

组件自动装配: Web mvc、 Web flux、JDBC等
嵌入式Web容器: Tomcat、 Jetty以及 Undertow
生产准备特性:指标、健康检査、外部化配置等

组件自动装配

激活： @EnableAutoConfiguration 配置： /META-INF/spring.factories 实质为key-value形式实现： XXXAutoConfiguration

官方文档样例

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class Example {

 @RequestMapping("/")
 String home() {
 return "Hello World!";
 }

 public static void main(String[] args) throws Exception {
 SpringApplication.run(Example.class, args);
 }

}

实际上@SpringBootApplication已经包含该注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
 @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
 @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
}

在IDEA中使用ctrl+shift+n可查看Spring源码中包含大量spring.factories文件

样例文件：

org/springframework/boot/spring-boot-autoconfigure/2.0.4.RELEASE/spring-boot-autoconfigure-2.0.4.RELEASE.jar!/META-INF/spring.factories

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnClassCondition

# 自动装配配置，自动装载Bean列表
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
...

WebMvcAutoConfiguration源码，其包含大量条件装配，若未检测到该类的依赖，则不会被装配

@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
 ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
...

嵌入式Web容器

Web servlet: Tomcat、 Jetty和 Undertow
Web reactive Netty Web Server

生产准备特性

指标:/ actuator/ metrics
健康检查:/ actuator/ health
外部化配置:/ actuator/ configprops

Web应用介绍

传统 Servlet应用概览

Servlet组件: Servlet、 Filter、 Listener
Servlet注册: Servlet注解、 Spring Bean、 RegistrationBean
异步非阻塞:异步 Servlet、非阻塞 Servlet

传统 Servelt 应用

加入springboot应用通用依赖前缀多为spring-boot-starter-xxx

加入Web依赖

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

Maven依赖变化

由此可看出默认的Web容器为Tomcat（内嵌Servlet容器）

Servlet 组件

Servlet
- 实现
  - @WebServlet
  - HttpServlet
  - 注册
- URL 映射
  - @WebServlet(urlPatterns = "/my/servlet")
- 注册 @ServletComponentScan(basePackages = "top.fjy8018.springboot.web.servlet")
Filter
Listener

Servlet 注册

Servlet 注解

@ServletComponentScan +
- @WebServlet
- @WebFilter
- @WebListener

Spring Bean

@Bean +
- Servlet
- Filter
- Listener
RegistrationBean
- ServletRegistrationBean
- FilterRegistrationBean
- ServletListenerRegistrationBean

Servlet 实现

参考源码包位置，由于出现了Reactive Web容器，SpringBoot 1.x的包路径与2.x有所不同，2.x包路径变更为org.springframework.boot.autoconfigure.web.servlet

HttpServlet

package top.fjy8018.springboot.web.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 结合servlet规范注册
 *
 * @author F嘉阳
 * @date 2018-09-08 19:17
 */
@WebServlet(urlPatterns = "/myservlet")
public class MyServlet extends HttpServlet {

 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 resp.getWriter().print("hello world");
 }
}

Servlet 3.0规范要求必须实现HttpServlet
其内部提供多种方法实现（ctrl+F12）
urlPatterns = "/myservlet"指明浏览器映射

注册

在主类中注册（包扫描）

package top.fjy8018.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan(basePackages = "top.fjy8018.springboot.web.servlet")
public class OverviewApplication {

 public static void main(String[] args) {
 SpringApplication.run(OverviewApplication.class, args);
 }
}

启动后从控制台可看出映射已经成功

异步非阻塞 Servlet

异步 Servlet

javax.servlet.ServletRequest#startAsync()
javax.servlet.AsyncContext

非阻塞 Servlet

javax.servlet.ServletInputStream#setReadListener
- javax.servlet.ReadListener
javax.servlet.ServletOutputStream#setWriteListener
- javax.servlet.WriteListener

异步非阻塞Servlet实现

package top.fjy8018.springboot.web.servlet;

import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 结合servlet规范注册
 * asyncSupported指定异步servlet，默认false
 *
 * @author F嘉阳
 * @date 2018-09-08 19:17
 */
@WebServlet(urlPatterns = "/myservlet", asyncSupported = true)
public class MyServlet extends HttpServlet {

 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
 AsyncContext asyncContext = req.startAsync();

 // 执行任务
 asyncContext.start(() -> {
 try {
 resp.getWriter().print("hello world");

 // 触发完成，必须步骤，否则客户端发生超时
 asyncContext.complete();
 } catch (IOException e) {
 e.printStackTrace();
 }
 });
 }
}

asyncSupported = true 启用异步支持，否则报500错误

Spring Web MVC 应用介绍

Web mvo视图:模板引擎、内容协商、异常处理等
Web mVc rest:资源服务、资源跨域、服务发现等

Web MVC 视图

ViewResolver
View

源码

package org.springframework.web.servlet;

import java.util.Locale;
import org.springframework.lang.Nullable;

public interface ViewResolver {
 @Nullable
 View resolveViewName(String viewName, Locale locale) throws Exception;

}

通过指定名称和路径加载视图

视图渲染View

package org.springframework.web.servlet;

public interface View {
 ...

 void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
 throws Exception;

}

提供接口供不同的模板引擎实现ViewResolver

模板引擎

Thymeleaf
Freemarker
JSP

若同时有多种模板引擎，则需要内容协商

内容协商

ContentNegotiationConfigurer
ContentNegotiationStrategy
ContentNegotiatingViewResolver

异常处理

@ExceptionHandler
HandlerExceptionResolver
- ExceptionHandlerExceptionResolver
BasicErrorController (Spring Boot默认白页404)

源码

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
 
 @RequestMapping(produces = "text/html")
 public ModelAndView errorHtml(HttpServletRequest request,
 HttpServletResponse response) {
 HttpStatus status = getStatus(request);
 Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
 request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
 response.setStatus(status.value());
 ModelAndView modelAndView = resolveErrorView(request, response, status, model);
 return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
 }
 
 @RequestMapping
 @ResponseBody
 public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
 Map<String, Object> body = getErrorAttributes(request,
 isIncludeStackTrace(request, MediaType.ALL));
 HttpStatus status = getStatus(request);
 return new ResponseEntity<>(body, status);
 }
}

其根据浏览器类型提供两种方式渲染，分别为html和json

{
 "timestamp": "2019-03-13T04:47:18.445+0000",
 "status": 404,
 "error": "Not Found",
 "message": "Not Found",
 "path": "/hello"
}

Web MVC REST

资源服务

@RequestMapping
@GetMapping
@ResponseBody
@RequestBody

从源码分析可知@GetMapping是从@RequestMapping变化而来，通过委派（别名）方式实现，并且在SpringMVC 4.3后引入

package org.springframework.web.bind.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;

/**
 * Annotation for mapping HTTP {@code GET} requests onto specific handler
 * methods.
 *
 * <p>Specifically, {@code @GetMapping} is a <em>composed annotation</em> that
 * acts as a shortcut for {@code @RequestMapping(method = RequestMethod.GET)}.
 *
 *
 * @author Sam Brannen
 * @since 4.3
 * @see PostMapping
 * @see PutMapping
 * @see DeleteMapping
 * @see PatchMapping
 * @see RequestMapping
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {
 /**
 * 委派目标 {@link RequestMapping#name}.
 */
 @AliasFor(annotation = RequestMapping.class)
 String name() default "";
 ...
}

资源跨域

CrossOrigin
WebMvcConfigurer#addCorsMappings
传统解决方案
- IFrame
- JSONP

源码

package org.springframework.web.servlet.config.annotation;

/**
 * @since 3.1
 */
public interface WebMvcConfigurer {
 /**
 * 跨域配置
 * @since 4.2
 */
 default void addCorsMappings(CorsRegistry registry) {
 }
}

注解实现方式

package org.springframework.web.bind.annotation;

/**
 * @since 4.2
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CrossOrigin {...}

两者均来自springframework，属于不同的实现维度（接口编程 / 注解驱动）

服务发现

HATEOS

核心组件

DispatcherServlet——Servlet实现请求转发到映射URL
HandlerMapping——处理映射URL方法
HandlerAdapter——方法处理
ViewResolver——交由视图处理
…

Spring WebFlux （Spring 5+）

Reactor 基础

Java Lambda —— Reactive Stream实现（JDK 9 flow api、RxJava）
Mono
Flux

Web Flux 核心

Web MVC 注解兼容

@Controller
@RequestMapping
@ResponseBody
@RequestBody
…

函数式声明

RouterFunction

异步非阻塞

Servlet 3.1 +
Netty Reactor

使用场景

页面渲染
REST 应用

性能测试

国外博客

结论：Webflux 性能不会显著提升，但Webflux提升吞吐量

Web Server 应用

切换 Web server
自定义 Servlet Web server
自定义 Reactive Web server

切换 Web Server

切换其他 Servlet 容器

Tomcat -> Jetty

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 <exclusions>
 <!-- tomcat加载优先级高于jetty，若不加排除，则仍然加载tomcat -->
 <exclusion>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-tomcat</artifactId>
 </exclusion>
 </exclusions>
</dependency>
<!-- 使用 Jetty 容器 -->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

替换 Servlet 容器

WebFlux

<!--使用webflux必须注释web依赖，当web和flux共存时，web优先级更高-->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

注释后相关类和的注解也已经失效，需要删除

@SpringBootApplication
//@ServletComponentScan(basePackages = "top.fjy8018.springboot.web.servlet")
public class SpringbootApplication {

 public static void main(String[] args) {
 SpringApplication.run(SpringbootApplication.class, args);
 }
}

依赖变化

启动后变为Netty容器

自定义 Servlet Web Server

WebServerFactoryCustomizer

SpringBoot 2.0 新增支持接口

package org.springframework.boot.web.server;

/**
 * @since 2.0.0
 * @see WebServerFactoryCustomizerBeanPostProcessor
 */
@FunctionalInterface
public interface WebServerFactoryCustomizer<T extends WebServerFactory> {
 
 void customize(T factory);
}

该接口为主接口，其下有大量实现，IDEA通过ctrl+alt+B或者ctrl+alt+左键点击查看

其中TomcatServletWebServerFactoryCustomizer就是实现类之一，但在启用Webflux后该类无效

package org.springframework.boot.autoconfigure.web.servlet;

/**
 * {@link WebServerFactoryCustomizer} to apply {@link ServerProperties} to Tomcat web
 * servers.
 *
 * @author Brian Clozel
 * @author Phillip Webb
 * @since 2.0.0
 */
public class TomcatServletWebServerFactoryCustomizer
 implements WebServerFactoryCustomizer<TomcatServletWebServerFactory>, Ordered {
 @Override
 public void customize(TomcatServletWebServerFactory factory) {
 ServerProperties.Tomcat tomcatProperties = this.serverProperties.getTomcat();
 if (!ObjectUtils.isEmpty(tomcatProperties.getAdditionalTldSkipPatterns())) {
 factory.getTldSkipPatterns()
 .addAll(tomcatProperties.getAdditionalTldSkipPatterns());
 }
 if (tomcatProperties.getRedirectContextRoot() != null) {
 customizeRedirectContextRoot(factory,
 tomcatProperties.getRedirectContextRoot());
 }
 if (tomcatProperties.getUseRelativeRedirects() != null) {
 customizeUseRelativeRedirects(factory,
 tomcatProperties.getUseRelativeRedirects());
 }
 }
 ...
}

自定义 Reactive Web Server

ReactiveWebServerFactoryCustomizer

其源码显示提供了最基础的实现，包括端口、SSL等，允许自行扩展实现

package org.springframework.boot.autoconfigure.web.reactive;

/**
 * {@link WebServerFactoryCustomizer} to apply {@link ServerProperties} to reactive
 * servers.
 * @since 2.0.0
 */
public class ReactiveWebServerFactoryCustomizer implements
 WebServerFactoryCustomizer<ConfigurableReactiveWebServerFactory>, Ordered {

 private final ServerProperties serverProperties;

 public ReactiveWebServerFactoryCustomizer(ServerProperties serverProperties) {
 this.serverProperties = serverProperties;
 }

 @Override
 public int getOrder() {
 return 0;
 }

 @Override
 public void customize(ConfigurableReactiveWebServerFactory factory) {
 PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
 map.from(this.serverProperties::getPort).to(factory::setPort);
 map.from(this.serverProperties::getAddress).to(factory::setAddress);
 map.from(this.serverProperties::getSsl).to(factory::setSsl);
 map.from(this.serverProperties::getCompression).to(factory::setCompression);
 map.from(this.serverProperties::getHttp2).to(factory::setHttp2);
 }
}

数据相关介绍

关系型数据

JDBC:数据源、 JdbcTemplate、自动装配
JPA:实体映射关系、实体操作、自动装配
事务∶ Spring事务抽象、JDBC事务处理、自动装配

JDBC

依赖

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

依赖变化，在SpringBoot2.0 后依赖新的连接池 HikariCP

数据源

javax.sql.DataSource
JdbcTemplate
自动装配
DataSourceAutoConfiguration

DataSource

连接池多数实现是对DataSource的二次封装，提高执行效率

package javax.sql;

/**
 * @since 1.4
 */

public interface DataSource extends CommonDataSource, Wrapper {
 Connection getConnection() throws SQLException;
 
 Connection getConnection(String username, String password)
 throws SQLException;
}

自动装配

JdbcTemplate自动装配，其依赖数据源配置项，故有@AutoConfigureAfter注解标识，该类执行于DataSourceAutoConfiguration之后，额外还有多个条件装配的标识

package org.springframework.boot.autoconfigure.jdbc;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for {@link JdbcTemplate} and
 * {@link NamedParameterJdbcTemplate}.
 * @since 1.4.0
 */
@Configuration
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnSingleCandidate(DataSource.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcTemplateAutoConfiguration {...}

DataSourceAutoConfiguration

package org.springframework.boot.autoconfigure.jdbc;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for {@link DataSource}.
 */
@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
 DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {...}

该类属于自动装配，故必然在spring.factories中，而数据源下即JdbcTemplateAutoConfiguration

此时直接启动会得到缺少数据源的错误报告

***************************
APPLICATION FAILED TO START
***************************

Description:

Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured.

Reason: Failed to determine a suitable driver class


Action:

Consider the following:
 If you want an embedded database (H2, HSQL or Derby), please put it on the classpath.
 If you have database settings to be loaded from a particular profile you may need to activate it (no profiles are currently active).

JPA

依赖

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

其属于SpringData项目，基于hibernate实现，同时也自动依赖JDBC

实体映射关系

@javax.persistence.OneToOne
@javax.persistence.OneToMany
@javax.persistence.ManyToOne
@javax.persistence.ManyToMany
…

实体操作

javax.persistence.EntityManager

属于Java类库的API

package javax.persistence;

public interface EntityManager {

 /**
 * 存
 */
 public void persist(Object entity);

 /**
 * 更新
 */
 public <T> T merge(T entity);

 /**
 * 删除
 */
 public void remove(Object entity);

 /**
 * 查询以及多个重载方法
 */
 public <T> T find(Class<T> entityClass, Object primaryKey);

 public <T> T find(Class<T> entityClass, Object primaryKey,
 Map<String, Object> properties);
 ...
}

自动装配

HibernateJpaAutoConfiguration

该类也同属于自动装配，且需要JDBC提供数据源，故其加载顺序标识为DataSourceAutoConfiguration之后

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for Hibernate JPA.
 */
@Configuration
@ConditionalOnClass({ LocalContainerEntityManagerFactoryBean.class, EntityManager.class })
@Conditional(HibernateEntityManagerCondition.class)
@EnableConfigurationProperties(JpaProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class })
@Import(HibernateJpaConfiguration.class)
public class HibernateJpaAutoConfiguration {...}

事务（Transaction）

依赖

<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
</dependency>

Spring 事务抽象

PlatformTransactionManager

该接口属于事务根接口，不仅限于数据库事务，默认实现包含分布式事务JtaTransactionManager和数据库事务DataSourceTransactionManager

package org.springframework.transaction;

import org.springframework.lang.Nullable;

/**
 * <p>The default implementations of this strategy interface are
 * {@link org.springframework.transaction.jta.JtaTransactionManager} and
 * {@link org.springframework.jdbc.datasource.DataSourceTransactionManager}

 * @see org.springframework.transaction.support.TransactionTemplate
 * @see org.springframework.transaction.interceptor.TransactionInterceptor
 * @see org.springframework.transaction.interceptor.TransactionProxyFactoryBean
 */
public interface PlatformTransactionManager {...}

JDBC 事务处理

DataSourceTransactionManager

内部通过IOC自动注入数据源接口

package org.springframework.jdbc.datasource;

@SuppressWarnings("serial")
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager
 implements ResourceTransactionManager, InitializingBean {

 @Nullable
 private DataSource dataSource;
 ...
}

自动装配

TransactionAutoConfiguration

自动装配的条件是Spring事务依赖存在PlatformTransactionManager

package org.springframework.boot.autoconfigure.transaction;

/**
 * {@link org.springframework.boot.autoconfigure.EnableAutoConfiguration
 * Auto-configuration} for Spring transaction.
 * @since 1.3.0
 */
@Configuration
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
 DataSourceTransactionManagerAutoConfiguration.class,
 Neo4jDataAutoConfiguration.class })
@EnableConfigurationProperties(TransactionProperties.class)
public class TransactionAutoConfiguration {...}

功能扩展介绍

Spring Boot 应用

Spring Application:失败分析、应用特性、事件监听等
Spring Boot配置:外部化配置、 Profile、配置属性
Spring Boot starter: Starter开发、最佳实践

SpringApplication

失败分析

FailureAnalysisReporter

该类在Spring Boot 1.4后开始支持

package org.springframework.boot.diagnostics;

/**
 * Reports a {@code FailureAnalysis} to the user.
 * @since 1.4.0
 */
@FunctionalInterface
public interface FailureAnalysisReporter {...}

应用特性

SpringApplication Fluent API

原始默认启动方法为SpringApplication.run(SpringbootApplication.class, args)其实际返回可配置上下文对象ConfigurableApplicationContext，可通过Builder模式重写

package top.fjy8018.springboot;

@SpringBootApplication
public class SpringbootApplication {

 public static void main(String[] args) {
 // Fluent API
 // 等价建造者设计模式调用方法
 new SpringApplicationBuilder(SpringbootApplication.class)
 // 不使用web模式
 .web(WebApplicationType.NONE)
 // 自定义参数
 .properties("name=fjy")
 .run(args);
 }
}

2.0 版本下提供3种WEB容器类型

package org.springframework.boot;

/**
 * @since 2.0.0
 */
public enum WebApplicationType {
 NONE,
 SERVLET,
 REACTIVE
}

Spring Boot 配置

外部化配置

ConfigurationProperty
@Profile

从SpringBoot 2.0 后引入，Origin类型支持其他配资源引入，非传统仅支持键值对，由此支持多数据源

package org.springframework.boot.context.properties.source;

/**
 * @since 2.0.0
 */
public final class ConfigurationProperty
 implements OriginProvider, Comparable<ConfigurationProperty> {
 
 private final ConfigurationPropertyName name;

 private final Object value;

 private final Origin origin;
 ...
}

官方文档

此处官方文档存在一定疏漏，部分场景配置无法实现

Spring Boot uses a very particular PropertySource order that is designed to allow sensible overriding of values. Properties are considered in the following order:

Devtools global settings properties on your home directory (~/.spring-boot-devtools.properties when devtools is active).

@TestPropertySource annotations on your tests.

@SpringBootTest#properties annotation attribute on your tests.

Command line arguments.

Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).

ServletConfig init parameters.

ServletContext init parameters.

JNDI attributes from java:comp/env.

Java System properties (System.getProperties()).

OS environment variables.

A RandomValuePropertySource that has properties only in random.*.

Profile-specific application properties outside of your packaged jar (application-{profile}.properties and YAML variants).

Profile-specific application properties packaged inside your jar (application-{profile}.properties and YAML variants).

Application properties outside of your packaged jar (application.properties and YAML variants).

Application properties packaged inside your jar (application.properties and YAML variants).

@PropertySource annotations on your @Configuration classes.

Default properties (specified by setting SpringApplication.setDefaultProperties).

Profile支持以注解方式条件开启配置，用于区分开发环境和生产环境等

package org.springframework.context.annotation;

/**
 * @since 3.1
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {
 
 String[] value();
}

配置属性

PropertySources

提供两种编程方式：接口、注解，支持保存多个配置，按照17种顺序排列，该接口在SpringBoot中重新设计变为ConfigurationProperty

package org.springframework.core.env;

/**
 * @since 3.1
 * @see PropertySource
 */
public interface PropertySources extends Iterable<PropertySource<?>> {...}

运维管理介绍

官方文档

Spring Boot Actuator

端点（Endpoints）

Web Endpoints
JMX Endpoints

依赖

<!--运维监控-->
<dependency>
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

启动效果

访问健康检查接口/actuator/health返回应用状态

{
 "status": "UP"
}

访问根路径

{
 "_links": {
 "self": {
 "href": "http://localhost:8080/actuator",
 "templated": false
 },
 "health": {
 "href": "http://localhost:8080/actuator/health",
 "templated": false
 },
 "info": {
 "href": "http://localhost:8080/actuator/info",
 "templated": false
 }
 }
}

依据SpringBoot打印的进程号或者依据应用名称使用Jconsole监控，该操作使用的为JMX端点

健康检查（Health Checks）

Health
HealthIndicator

使用JMX在默认情况下能获取比Web端点更多的信息，原因是JMX支持使用安全连接，具有更好的安全性

官方文档指出默认状态只暴露health和info，可通过配置文件调整

28.4 Actuator Security
For security purposes, all actuators other than /health and /info are disabled by default. The management.endpoints.web.exposure.include property can be used to enable the actuators.

在application.properties文件中加入配置重启应用

# 暴露所有健康监控点
management.endpoints.web.exposure.include=*

从日志输出可知增加了更多的URL映射

但尽管配置后，JMX显示的信息仍然比Web端更丰富，例如在JMX中不仅看到状态，还能看到磁盘、内存等信息，而Web端仅看到状态

指标（Metrics）

内建 Metrics
Web Endpoint : /actuator/metrics
自定义 Metrics

Web端点列举支持指标

{
 "names": [
 "jvm.memory.max",
 "jvm.gc.memory.promoted",
 "jvm.memory.used",
 "jvm.gc.max.data.size",
 "jvm.gc.pause",
 "jvm.memory.committed",
 "system.cpu.count",
 "logback.events",
 "jvm.buffer.memory.used",
 "jvm.threads.daemon",
 "system.cpu.usage",
 "jvm.gc.memory.allocated",
 "jvm.threads.live",
 "jvm.threads.peak",
 "process.uptime",
 "http.server.requests",
 "process.cpu.usage",
 "jvm.classes.loaded",
 "jvm.classes.unloaded",
 "jvm.gc.live.data.size",
 "jvm.buffer.count",
 "jvm.buffer.total.capacity",
 "process.start.time"
 ]
}

访问/actuator/metrics/jvm.memory.max可查看相关指标，转换后可知最大内存为5.2G

{
 "name": "jvm.memory.max",
 "description": "The maximum amount of memory in bytes that can be used for memory management",
 "baseUnit": "bytes",
 "measurements": [
 {
 "statistic": "VALUE",
 "value": 5595725823
 }
 ],
 "availableTags": [
 {
 "tag": "area",
 "values": [
 "heap",
 "nonheap"
 ]
 },
 {
 "tag": "id",
 "values": [
 "Compressed Class Space",
 "PS Survivor Space",
 "PS Old Gen",
 "Metaspace",
 "PS Eden Space",
 "Code Cache"
 ]
 }
 ]
}

微服务平台开发总结（1）——第一代密码管理系统

Thu, 07 May 2020 21:34:00 +0800

背景

随着网站、工作使用需要，对密码存储的需求越来越大，初期采用本地数据库进行存储，但不适合多地访问，一旦离开了本地电脑，就无法查询密码信息，故计划搭建个人使用的密码信息管理系统

概要

时间线

密码管理信息系统于2018年12月立项，2019年1月9日开始第一次提交
2019年2月7日第一个版本上线试运行
2019年4月7日进入维护阶段，不再支持新功能
2019年11月16日停止维护

架构

后端

JDK8
SpringBoot 2.1.1.RELEASE
Jetty
SpringData Jpa
MySQL 5.7
Docker
Kuberneties 1.14
Redis
Graylog
GitLab CICD

前端

Vue 2.5
element 2.4.11
vuex 3
vue-axios 2.1.4
eslint 5.8.0
nodejs
nginx
https
Docker
GitLab CICD

原理

后端存储密码数据字段和网站相关信息
采用SQL全字段模糊查询匹配结果
密码字段存储采用AES128结合SHA随机盐值加密存储，即使数据库被破解也无法查看对应的密码信息
密码加密秘钥不由服务端存储，只在用户登陆时录入并临时通过AES128加密后存储在Redis中，用户登出或者登陆超时后销毁

优势

单体项目，部署简单
容器化部署，迁移便利
Kuberneties云平台部署，支持灰度发布
无状态后端服务，支持集群化部署

安全审计

支持简单的安全审计

登陆日志记录
登陆归属地记录

安全问题

通过实现的Spring拦截器进行登陆拦截，安全性不高
没有采用session会话方式，故多地登陆账号且加密秘钥未过期则不需要再次录入
支持所有跨域行为，没有对客户端进行识别

其他问题

独立用户控制，扩展性不高
没有基于RBAC模型的权限控制
没有管理后台
单模块、单体项目，不利于扩展

界面演示

登陆页

若用户不存在则自动新增

录入加密秘钥

主页

信息录入

支持全字段模糊检索

支持Excel模板信息导入

登出

效果

系统稳定运行一年，符合系统初期设计目的
同时兼容移动端渲染

PXC系列学习笔记（六）——Java千万数据量导入和查询优化

Mon, 30 Dec 2019 08:49:04 +0800

一、介绍

通用导入方法：数据量大应当使用load data方式导入，而不是使用source sql文件的方式

此处为了验证PXC集群性能，需要创造一千万条数据进行SQL语句性能测试

二、数据生成

若对数据内容无要求，则可使用通用工具生成随机数据，此处面向具体业务场景，故使用Java应用程序生成数据

1. 创建SpringBoot工程

使用SpringBoot快速创建数据导入工程，引入jdbc和jpa依赖

...
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.2.2.RELEASE</version>
 <relativePath/> <!-- lookup parent from repository -->
</parent>
...
<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 <exclusions>
 <exclusion>
 <groupId>org.junit.vintage</groupId>
 <artifactId>junit-vintage-engine</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
</dependencies>

2. 编写实体类

package top.fjy8018.jdbcbench;

/**
 * @author F嘉阳
 * @date 2019-12-28 13:08
 */
@Entity(name = "tb_test")
@Data
public class DBTest {

 @Id
 private Integer id;

 private String name;
}

实现JPA接口

package top.fjy8018.jdbcbench;

/**
 * @author F嘉阳
 * @date 2019-12-28 13:09
 */
public interface DBTestRepository extends JpaRepository<DBTest,Integer> {}

3. 配置JDBC连接

此处有个重要配置，就是rewriteBatchedStatements=true，加上该配置，批量写入数据的性能能提升数百倍。

参考资料：jdbcTemplate.batchUpdate在批量执行的时候，性能差没有效果，看看怎么解决的。

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: admin
 password: password
 url: jdbc:mysql://192.168.1.9:13306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&rewriteBatchedStatements=true&serverTimezone=Asia/Shanghai
 jpa:
 properties:
 hibernate:
 jdbc:
 batch_size: 10000
 order_inserts: true
 generate_statistics: true

4.准备数据库

每个PXC分片只开启一个节点，导入一个节点中则不会产生限流，导入完成后拷贝数据文件到其他节点再启动即可

修改PXC节点文件，然后重启PXC服务

## 不等待事务提交先写入硬盘
innodb_flush_log_at_trx_commit = 0
## 日志数据直接写入磁盘，不进入日志缓冲区
innodb_flush_method = O_DIRECT
## 缓存越大越好
innodb_buffer_pool_size = 200M

创建t_test数据表

CREATE TABLE tb_test(
	id INT UNSIGNED PRIMARY KEY,
 name VARCHAR(200) NOT NULL
);

配置MyCat

<table name="t_test" dataNode="dn1,dn2" rule="mod-long" />

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
 <!--配置虚拟逻辑数据表-->
 <schema name="test" checkSQLschema="false" sqlMaxLimit="100">
 <table name="t_user" dataNode="dn1,dn2" rule="mod-long" />
 <table name="tb_test" dataNode="dn1,dn2" rule="mod-long" />
 <table name="t_customer" dataNode="dn1,dn2" rule="sharding-customer">
 <childTable name="t_orders" primaryKey="ID" joinKey="customer_id" parentKey="id"/>
 </table>
 </schema>
 <!--配置分片关系-->
 <dataNode name="dn1" dataHost="cluster1" database="test" />
 <dataNode name="dn2" dataHost="cluster2" database="test" />
 <!--配置连接信息-->
 <dataHost name="cluster1" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1"
 slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!--多数情况 读多写少-->
 <writeHost host="W1" url="pxc4:3306" user="admin"
 password="admin">
 </writeHost>
 </dataHost>
 <dataHost name="cluster2" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1"
 slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!--多数情况 读多写少-->
 <writeHost host="W1" url="pxc7:3306" user="admin"
 password="admin">
 </writeHost>
 </dataHost>
</mycat:schema>

5.编写单元测试

package top.fjy8018.jdbcbench;

@Slf4j
@Component
class JdbcBenchTest extends JdbcBenchApplicationTests{

 @Autowired
 private DBTestRepository repository;

 @Autowired
 private JdbcTemplate jdbcTemplate;

 @Test
 public void insertTest(){
 DBTest t = new DBTest();
 t.setId(1);
 t.setName(1+"，测试实体");
 DBTest save = repository.save(t);
 Assert.notNull(save,"保存测试失败");
 }

 @Test
 public void insertData() throws Exception {
 for (int i = 1; i <= 10000000;) {
 List<DBTest> tests = new LinkedList<>();
 for (int j = 1; j <= 50000; j++) {
 DBTest t = new DBTest();
 t.setId(j+i);
 t.setName(j+i+"，测试实体");
 tests.add(t);
 }
 i = i+50000;
 log.info("插入{}条数据",i);
 batchInsert(tests);
 tests.clear();
 }
 }

 @Transactional
 public void batchInsert(List<DBTest> dbTestList) {
 String sql = "insert into tb_test(id,name) values(?,?)";
 log.info("批次大小：{}",dbTestList.size());
 jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
 public void setValues(PreparedStatement ps, int i) throws SQLException {
 String name = dbTestList.get(i).getName();
 int id = dbTestList.get(i).getId();
 ps.setInt(1, id);
 ps.setString(2, name);
 }
 public int getBatchSize() {
 return dbTestList.size();
 }
 });
 }
}

执行单元测试，大约1小时写入完成，不同服务器配置写入性能差距明显，应当以实际为准

三、数据导入后的操作

关闭PXC节点(还原配置文件)
拷贝数据文件到其他PXC节点
关闭 MyCat(还原配置文件)
启动PC和 MyCat

四、大数据性能测试——limit关键字

SELECT id, name FROM tb_test LIMIT 100, 100;
SELECT id, name FROM tb_test LIMIT 10000, 100;
SELECT id, name FROM tb_test LIMIT 1000000, 100;
SELECT id, name From tb_test LIMIT 5000000, 100;

现象：执行最后一条sql语句时速度慢，且cpu和内存占用率极大，主要对mycat节点内存占用一直居高不下

分析索引使用情况，rows字段显示其操作了4746302条数据，走全表扫描

id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
1	SIMPLE	tb_test		ALL					4746302	100

原因：

全表扫描,速度极慢
limit语句的查询时间与起始记录的位置成正比
mysql limit的语句是很方便,但是对记录很多的表并不适合直接使用

SpringBoot 2.x quartz多数据定时任务源配置

Mon, 29 Jul 2019 15:04:00 +0800

基础环境

SpringBoot 2.0 开始官方提供了对quartz定时任务的自动配置支持依赖spring-boot-starter-quartz组件，无需自行集成

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

环境版本：

SpringBoot 2.1.6.RELEASE
Java 8

定时任务配置

添加依赖

在pom.xml中添加quartz、Jpa、mysql驱动、lombok依赖

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
</dependency>
<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

添加配置文件

添加数据库配置

spring:
 datasource:
 primary:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: hmdt
 url: jdbc:mysql://db/bussines_db?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 quartz:
 url: jdbc:mysql://db/bussines_quartz?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: hmdt

 quartz:
 #相关属性配置
 properties:
 org:
 quartz:
 scheduler:
 instanceName: clusteredScheduler
 instanceId: AUTO
 jobStore:
 # 数据源名称
 dataSource: quartzDataSource
 class: org.quartz.impl.jdbcjobstore.JobStoreTX
 driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
 tablePrefix: QRTZ_
 isClustered: true
 clusterCheckinInterval: 1000
 useProperties: false
 threadPool:
 class: org.quartz.simpl.SimpleThreadPool
 threadCount: 10
 threadPriority: 5
 threadsInheritContextClassLoaderOfInitializingThread: true
 job-store-type: jdbc
 #初始化表结构
 jdbc:
 initialize-schema: never
 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true

数据库配置也有样例配在spring.quartz.properties中，但亲测配置无效，并且由于还需要指定连接池等信息，此处配置在spring的连接池中更容易管理

下载官网建表语句

尽管使用了JPA，但由于没有实体关联，spring并不会帮我们自动建表，还需要去官网下载sql脚本

quartz官网

官网压缩包路径quartz-2.3.0-SNAPSHOT\src\org\quartz\impl\jdbcjobstore中支持大量数据库建表语句，选择对应的使用即可

配置多数据源

多配置源之前在文章中详细说过配置样例和原因，这里不再赘述

编写数据库配置，统一使用HikariCP连接池

package com.gcb.invest.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.quartz.QuartzDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * 定时任务数据源配置
 *
 * @author F嘉阳
 * @date 2019-07-28 21:52
 */
@Configuration
public class DataSourceConfig {

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.primary")
 public DataSourceProperties primaryDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.primary.configuration")
 public HikariDataSource firstDataSource() {
 return primaryDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.quartz")
 public DataSourceProperties quartzDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @QuartzDataSource
 @ConfigurationProperties("spring.datasource.quartz.configuration")
 public HikariDataSource quartzDataSource() {
 return quartzDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }
}

定时任务配置

配置样例1——Bean注入

编写定时任务，由于经过Spring的封装，使用变得更加方便

此处通过内部类配置定时任务，并使用@DisallowConcurrentExecution注解指定其在分布式环境下不可并发执行

import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * 定时任务配置
 *
 * @author ：F嘉阳
 * @date ：2019/7/29 9:16
 */
@Slf4j
@Configuration
public class QuartzConfig {

 /**
 * 测试定时任务构建
 *
 * @return
 */
 @Bean
 public JobDetail testTaskJobDetail() {
 return JobBuilder.newJob(TestTask.class)
 .withIdentity(TestTask.class.getName())
 .storeDurably(true)
 .build();
 }

 /**
 * 测试定时任务配置
 *
 * @return
 */
 @Bean
 public Trigger testTaskTrigger() {
 CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/2 * * * * ?");
 return TriggerBuilder.newTrigger()
 .forJob(testTaskJobDetail())
 .withIdentity(TestTask.class.getName())
 .withSchedule(scheduleBuilder)
 .build();
 }

 @DisallowConcurrentExecution
 private class TestTask extends QuartzJobBean {
 @Override
 protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
 log.debug("执行测试定时任务");
 }
 }
}

配置样例2——调度器注入

另一种方式可使用注入调度器手动构建任务，不过需要调用该方法之后调度器才会被创建

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.UUID;

/**
 * @author ：F嘉阳
 * @date ：2019/7/29 8:59
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class QuartzTimerService {

 @Autowired
 private Scheduler scheduler;

 public void buildGoodStockTimer() throws Exception {
 //任务名称
 String name = UUID.randomUUID().toString();
 //任务所属分组
 String group = CustomQuartzJob.class.getName();

 CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/1 * * * * ?");
 //创建任务
 JobDetail jobDetail = JobBuilder.newJob(CustomQuartzJob.class).withIdentity(name,group).build();
 //创建任务触发器
 Trigger trigger = TriggerBuilder.newTrigger().withIdentity(name,group).withSchedule(scheduleBuilder).build();
 //将触发器与任务绑定到调度器内
 scheduler.scheduleJob(jobDetail, trigger);
 }
}

定时任务类

import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @author ：F嘉阳
 * @date ：2019/7/29 8:55
 */
@Slf4j
@DisallowConcurrentExecution
public class CustomQuartzJob extends QuartzJobBean {
 @Override
 protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
 log.info("执行定时任务");
 }
}

执行结果

执行成功

在分布式环境下自动进行作业节点迁移

SpringBoot2.x Data JPA 多数据源爬坑

Sat, 30 Mar 2019 10:44:00 +0800

JPA 官方文档

官方文档

5.1.2. Annotation-based Configuration

The Spring Data JPA repositories support can be activated not only through an XML namespace but also by using an annotation through JavaConfig, as shown in the following example:

Example 51. Spring Data JPA repositories using JavaConfig

@Configuration
@EnableJpaRepositories
@EnableTransactionManagement
class ApplicationConfig {

 @Bean
 public DataSource dataSource() {

 EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
 return builder.setType(EmbeddedDatabaseType.HSQL).build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

 HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
 vendorAdapter.setGenerateDdl(true);

 LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
 factory.setJpaVendorAdapter(vendorAdapter);
 factory.setPackagesToScan("com.acme.domain");
 factory.setDataSource(dataSource());
 return factory;
 }

 @Bean
 public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

 JpaTransactionManager txManager = new JpaTransactionManager();
 txManager.setEntityManagerFactory(entityManagerFactory);
 return txManager;
 }
}

文档中说明，基于注解的配置包含三个关键Bean：

PlatformTransactionManager——事务管理
LocalContainerEntityManagerFactoryBean——实体类管理
DataSource——数据源

同时还有一个关键注解@EnableJpaRepositories

SpringBoot官方文档

官方文档

多数据源使用@Primary指明优先级

You can even go further by leveraging what DataSourceProperties does for you — that is, by providing a default embedded database with a sensible username and password if no URL is provided. You can easily initialize a DataSourceBuilder from the state of any DataSourceProperties object, so you could also inject the DataSource that Spring Boot creates automatically. However, that would split your configuration into two namespaces: url, username, password, type, and driver on spring.datasource and the rest on your custom namespace (app.datasource). To avoid that, you can redefine a custom DataSourceProperties on your custom namespace, as shown in the following example:
@Bean
@Primary
@ConfigurationProperties("app.datasource")
public DataSourceProperties dataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@ConfigurationProperties("app.datasource.configuration")
public HikariDataSource dataSource(DataSourceProperties properties) {
	return properties.initializeDataSourceBuilder().type(HikariDataSource.class)
			.build();
}
84.2 Configure Two DataSources
If you need to configure multiple data sources, you can apply the same tricks that are described in the previous section. You must, however, mark one of the DataSource instances as @Primary, because various auto-configurations down the road expect to be able to get one by type.

If you create your own DataSource, the auto-configuration backs off. In the following example, we provide the exact same feature set as the auto-configuration provides on the primary data source:
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@Primary
@ConfigurationProperties("app.datasource.first.configuration")
public HikariDataSource firstDataSource() {
	return firstDataSourceProperties().initializeDataSourceBuilder()
			.type(HikariDataSource.class).build();
}

@Bean
@ConfigurationProperties("app.datasource.second")
public BasicDataSource secondDataSource() {
	return DataSourceBuilder.create().type(BasicDataSource.class).build();
}

或者使用两个EntityManagers，并结合@EnableJpaRepositories进行配置

84.10 Use Two EntityManagers
Even if the default EntityManagerFactory works fine, you need to define a new one. Otherwise, the presence of the second bean of that type switches off the default. To make it easy to do, you can use the convenient EntityManagerBuilder provided by Spring Boot. Alternatively, you can just theLocalContainerEntityManagerFactoryBean directly from Spring ORM, as shown in the following example:
// add two data sources configured as above

@Bean
public LocalContainerEntityManagerFactoryBean customerEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(customerDataSource())
			.packages(Customer.class)
			.persistenceUnit("customers")
			.build();
}

@Bean
public LocalContainerEntityManagerFactoryBean orderEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(orderDataSource())
			.packages(Order.class)
			.persistenceUnit("orders")
			.build();
}
The configuration above almost works on its own. To complete the picture, you need to configure TransactionManagers for the two EntityManagers as well. If you mark one of them as @Primary, it could be picked up by the default JpaTransactionManager in Spring Boot. The other would have to be explicitly injected into a new instance. Alternatively, you might be able to use a JTA transaction manager that spans both.

If you use Spring Data, you need to configure @EnableJpaRepositories accordingly, as shown in the following example:
@Configuration
@EnableJpaRepositories(basePackageClasses = Customer.class,
		entityManagerFactoryRef = "customerEntityManagerFactory")
public class CustomerConfiguration {
	...
}

@Configuration
@EnableJpaRepositories(basePackageClasses = Order.class,
		entityManagerFactoryRef = "orderEntityManagerFactory")
public class OrderConfiguration {
	...
}

源码分析

自动装配类中声明了配置Bean和条件装配顺序

package org.springframework.boot.autoconfigure.data.jpa;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's JPA Repositories.
 * <p>
 * Activates when there is a bean of type {@link javax.sql.DataSource} configured in the
 * context, the Spring Data JPA
 * {@link org.springframework.data.jpa.repository.JpaRepository} type is on the classpath,
 * and there is no other, existing
 * {@link org.springframework.data.jpa.repository.JpaRepository} configured.
 * <p>
 * Once in effect, the auto-configuration is the equivalent of enabling JPA repositories
 * using the {@link org.springframework.data.jpa.repository.config.EnableJpaRepositories}
 * annotation.
 * <p>
 * This configuration class will activate <em>after</em> the Hibernate auto-configuration.
 *
 * @author Phillip Webb
 * @author Josh Long
 * @see EnableJpaRepositories
 */
@Configuration
@ConditionalOnBean(DataSource.class)
@ConditionalOnClass(JpaRepository.class)
@ConditionalOnMissingBean({ JpaRepositoryFactoryBean.class,
		JpaRepositoryConfigExtension.class })
@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "enabled", havingValue = "true", matchIfMissing = true)
@Import(JpaRepositoriesAutoConfigureRegistrar.class)
@AutoConfigureAfter({ HibernateJpaAutoConfiguration.class,
		TaskExecutionAutoConfiguration.class })
public class JpaRepositoriesAutoConfiguration {

	@Bean
	@Conditional(BootstrapExecutorCondition.class)
	public EntityManagerFactoryBuilderCustomizer entityManagerFactoryBootstrapExecutorCustomizer(
			Map<String, AsyncTaskExecutor> taskExecutors) {
		return (builder) -> {
			AsyncTaskExecutor bootstrapExecutor = determineBootstrapExecutor(
					taskExecutors);
			if (bootstrapExecutor != null) {
				builder.setBootstrapExecutor(bootstrapExecutor);
			}
		};
	}

	private AsyncTaskExecutor determineBootstrapExecutor(
			Map<String, AsyncTaskExecutor> taskExecutors) {
		if (taskExecutors.size() == 1) {
			return taskExecutors.values().iterator().next();
		}
		return taskExecutors
				.get(TaskExecutionAutoConfiguration.APPLICATION_TASK_EXECUTOR_BEAN_NAME);
	}

	private static final class BootstrapExecutorCondition extends AnyNestedCondition {

		BootstrapExecutorCondition() {
			super(ConfigurationPhase.REGISTER_BEAN);
		}

		@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "bootstrap-mode", havingValue = "deferred", matchIfMissing = false)
		static class DeferredBootstrapMode {

		}

		@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "bootstrap-mode", havingValue = "lazy", matchIfMissing = false)
		static class LazyBootstrapMode {

		}

	}
}

引入的配置类中声明了EnableJpaRepositories注解

package org.springframework.boot.autoconfigure.data.jpa;

class JpaRepositoriesAutoConfigureRegistrar
		extends AbstractRepositoryConfigurationSourceSupport {

	private BootstrapMode bootstrapMode = null;

	@Override
	protected Class<? extends Annotation> getAnnotation() {
		return EnableJpaRepositories.class;
	}

	@Override
	protected Class<?> getConfiguration() {
		return EnableJpaRepositoriesConfiguration.class;
	}

	@Override
	protected RepositoryConfigurationExtension getRepositoryConfigurationExtension() {
		return new JpaRepositoryConfigExtension();
	}

	@Override
	protected BootstrapMode getBootstrapMode() {
		return (this.bootstrapMode == null) ? super.getBootstrapMode()
				: this.bootstrapMode;
	}

	@Override
	public void setEnvironment(Environment environment) {
		super.setEnvironment(environment);
		configureBootstrapMode(environment);
	}

	private void configureBootstrapMode(Environment environment) {
		String property = environment
				.getProperty("spring.data.jpa.repositories.bootstrap-mode");
		if (StringUtils.hasText(property)) {
			this.bootstrapMode = BootstrapMode
					.valueOf(property.toUpperCase(Locale.ENGLISH));
		}
	}
 
	@EnableJpaRepositories
	private static class EnableJpaRepositoriesConfiguration {}
}

EnableJpaRepositories注解定义

package org.springframework.data.jpa.repository.config;

/**
 * Annotation to enable JPA repositories. Will scan the package of the annotated configuration class for Spring Data
 * repositories by default.
 *
 * @author Oliver Gierke
 * @author Thomas Darimont
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(JpaRepositoriesRegistrar.class)
public @interface EnableJpaRepositories {

	String[] value() default {};

	String[] basePackages() default {};

	Class<?>[] basePackageClasses() default {};

	Filter[] includeFilters() default {};

	Filter[] excludeFilters() default {};

	String repositoryImplementationPostfix() default "Impl";

	String namedQueriesLocation() default "";

	Key queryLookupStrategy() default Key.CREATE_IF_NOT_FOUND;

	Class<?> repositoryFactoryBeanClass() default JpaRepositoryFactoryBean.class;

	Class<?> repositoryBaseClass() default DefaultRepositoryBaseClass.class;

	/**
	 * 实体管理工厂
	 * @return
	 */
	String entityManagerFactoryRef() default "entityManagerFactory";

	/**
	 * 事务管理
	 * @return
	 */
	String transactionManagerRef() default "transactionManager";

	boolean considerNestedRepositories() default false;

	boolean enableDefaultTransactions() default true;

	/**
	 * Configures when the repositories are initialized in the bootstrap lifecycle. {@link BootstrapMode#DEFAULT}
	 * (default) means eager initialization except all repository interfaces annotated with {@link Lazy},
	 * {@link BootstrapMode#LAZY} means lazy by default including injection of lazy-initialization proxies into client
	 * beans so that those can be instantiated but will only trigger the initialization upon first repository usage (i.e a
	 * method invocation on it). This means repositories can still be uninitialized when the application context has
	 * completed its bootstrap. {@link BootstrapMode#DEFERRED} is fundamentally the same as {@link BootstrapMode#LAZY},
	 * but triggers repository initialization when the application context finishes its bootstrap.
	 * 
	 * @return
	 * @since 2.1
	 */
	BootstrapMode bootstrapMode() default BootstrapMode.DEFAULT;
}

查找关键Bean的注册时机

package org.springframework.boot.autoconfigure.orm.jpa;

@Configuration
@ConditionalOnClass({ LocalContainerEntityManagerFactoryBean.class, EntityManager.class })
@Conditional(HibernateEntityManagerCondition.class)
@EnableConfigurationProperties(JpaProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class })
@Import(HibernateJpaConfiguration.class)
public class HibernateJpaAutoConfiguration {}

进入配置Bean

package org.springframework.boot.autoconfigure.orm.jpa;

@Configuration
@EnableConfigurationProperties(HibernateProperties.class)
@ConditionalOnSingleCandidate(DataSource.class)
class HibernateJpaConfiguration extends JpaBaseConfiguration {}

在其父类JpaBaseConfiguration中声明了装配时机和条件

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * 该类在2.0版本进行了重构
 * @since 2.0.0
 */
@Configuration
@EnableConfigurationProperties(JpaProperties.class)
@Import(DataSourceInitializedPublisher.Registrar.class)
public abstract class JpaBaseConfiguration implements BeanFactoryAware {
 
 @Bean
	@ConditionalOnMissingBean
	public PlatformTransactionManager transactionManager() {
		JpaTransactionManager transactionManager = new JpaTransactionManager();
		if (this.transactionManagerCustomizers != null) {
 // 默认使用方法名称
			this.transactionManagerCustomizers.customize(transactionManager);
		}
		return transactionManager;
	}

	@Bean
	@ConditionalOnMissingBean
	public JpaVendorAdapter jpaVendorAdapter() {
		AbstractJpaVendorAdapter adapter = createJpaVendorAdapter();
		adapter.setShowSql(this.properties.isShowSql());
		adapter.setDatabase(this.properties.determineDatabase(this.dataSource));
		adapter.setDatabasePlatform(this.properties.getDatabasePlatform());
		adapter.setGenerateDdl(this.properties.isGenerateDdl());
		return adapter;
	}

	@Bean
	@ConditionalOnMissingBean
	public EntityManagerFactoryBuilder entityManagerFactoryBuilder(
			JpaVendorAdapter jpaVendorAdapter,
			ObjectProvider<PersistenceUnitManager> persistenceUnitManager,
			ObjectProvider<EntityManagerFactoryBuilderCustomizer> customizers) {
		EntityManagerFactoryBuilder builder = new EntityManagerFactoryBuilder(
				jpaVendorAdapter, this.properties.getProperties(),
				persistenceUnitManager.getIfAvailable());
		customizers.orderedStream()
				.forEach((customizer) -> customizer.customize(builder));
		return builder;
	}

	@Bean
	@Primary
	@ConditionalOnMissingBean({ LocalContainerEntityManagerFactoryBean.class,
			EntityManagerFactory.class })
	public LocalContainerEntityManagerFactoryBean entityManagerFactory(
			EntityManagerFactoryBuilder factoryBuilder) {
		Map<String, Object> vendorProperties = getVendorProperties();
		customizeVendorProperties(vendorProperties);
		return factoryBuilder.dataSource(this.dataSource).packages(getPackagesToScan())
				.properties(vendorProperties).mappingResources(getMappingResources())
				.jta(isJta()).build();
	}
}

测试

爬完文档和源码，对需要配置Bean有了基本了解，新建工程进行多数据源测试

以当前最新版本SpringBoot进行测试

maven

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.1.3.RELEASE</version>
 <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>top.fjy8018</groupId>
 <artifactId>jpadatasource</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>jpadatasource</name>
 <description>Demo project for Spring Boot</description>

 <properties>
 <java.version>1.8</java.version>
 </properties>

 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>

 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </dependency>

 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 </dependencies>

 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>

</project>

实体类

通过包路径区分主库和备份库

主库实体类

package top.fjy8018.jpadatasource.entity.primary;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:11
 */
@Data
@Entity
public class Product {

 @Id
 private Integer id;

 private String name;

 private Integer price;
}

备份库实体类

package top.fjy8018.jpadatasource.entity.backup;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:36
 */
@Data
@Entity(name = "tb_order")
public class Order {

 @Id
 private Integer id;

 private String orderName;

 private Integer price;
}

坑一：表名关键字冲突

若此处不指定表名为tb_order则会与MySQL关键字冲突导致建表失败

报错：

org.hibernate.tool.schema.spi.CommandAcceptanceException: Error executing DDL "
 create table Order (
 id integer not null,
 orderName varchar(255),
 price integer,
 primary key (id)
 ) engine=InnoDB" via JDBC Statement
 ...

DAO

package top.fjy8018.jpadatasource.repository.backup;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.jpadatasource.entity.backup.Order;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:12
 */
public interface OrderRepository extends JpaRepository<Order, Integer> {
}

package top.fjy8018.jpadatasource.repository.primary;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.jpadatasource.entity.primary.Product;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:12
 */
public interface ProductRepository extends JpaRepository<Product, Integer> {
}

配置Bean

官方配置样例：

Both data sources are also bound for advanced customizations. For instance, you could configure them as follows:

app.datasource.first.url=jdbc:mysql://localhost/first
app.datasource.first.username=dbuser
app.datasource.first.password=dbpass
app.datasource.first.configuration.maximum-pool-size=30

app.datasource.second.url=jdbc:mysql://localhost/second
app.datasource.second.username=dbuser
app.datasource.second.password=dbpass
app.datasource.second.max-total=30

You can apply the same concept to the secondary DataSource as well, as shown in the following example:

@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@Primary
@ConfigurationProperties("app.datasource.first.configuration")
public HikariDataSource firstDataSource() {
	return firstDataSourceProperties().initializeDataSourceBuilder()
			.type(HikariDataSource.class).build();
}

@Bean
@ConfigurationProperties("app.datasource.second")
public DataSourceProperties secondDataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@ConfigurationProperties("app.datasource.second.configuration")
public BasicDataSource secondDataSource() {
	return secondDataSourceProperties().initializeDataSourceBuilder()
			.type(BasicDataSource.class).build();
}

The preceding example configures two data sources on custom namespaces with the same logic as Spring Boot would use in auto-configuration. Note that each configuration sub namespace provides advanced settings based on the chosen implementation.

参照编写配置文件，此处注意SpringBoot 2.x的驱动变化

坑二：mysql驱动类名变化

spring:
 datasource:
 first:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://localhost/jpa_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 30
 second:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://localhost/jpa_test_bak?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 20

 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true

配置类

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {
 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }
}

配置完成后发现只在主库自动建表，备份库无变化，属于预期情况，因为目前仅配置了三个必须Bean的其中一个

继续配置实体管理和事务管理Bean

官方文档样例

84.10 Use Two EntityManagers
Even if the default EntityManagerFactory works fine, you need to define a new one. Otherwise, the presence of the second bean of that type switches off the default. To make it easy to do, you can use the convenient EntityManagerBuilder provided by Spring Boot. Alternatively, you can just theLocalContainerEntityManagerFactoryBean directly from Spring ORM, as shown in the following example:
// add two data sources configured as above

@Bean
public LocalContainerEntityManagerFactoryBean customerEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(customerDataSource())
			.packages(Customer.class)
			.persistenceUnit("customers")
			.build();
}

@Bean
public LocalContainerEntityManagerFactoryBean orderEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(orderDataSource())
			.packages(Order.class)
			.persistenceUnit("orders")
			.build();
}
The configuration above almost works on its own. To complete the picture, you need to configure TransactionManagers for the two EntityManagers as well. If you mark one of them as @Primary, it could be picked up by the default JpaTransactionManager in Spring Boot. The other would have to be explicitly injected into a new instance. Alternatively, you might be able to use a JTA transaction manager that spans both.

If you use Spring Data, you need to configure @EnableJpaRepositories accordingly, as shown in the following example:
@Configuration
@EnableJpaRepositories(basePackageClasses = Customer.class,
		entityManagerFactoryRef = "customerEntityManagerFactory")
public class CustomerConfiguration {
	...
}

@Configuration
@EnableJpaRepositories(basePackageClasses = Order.class,
		entityManagerFactoryRef = "orderEntityManagerFactory")
public class OrderConfiguration {
	...
}

工程配置

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import top.fjy8018.jpadatasource.entity.backup.Order;
import top.fjy8018.jpadatasource.entity.primary.Product;
import top.fjy8018.jpadatasource.repository.backup.OrderRepository;
import top.fjy8018.jpadatasource.repository.primary.ProductRepository;

import javax.sql.DataSource;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {
 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("firstDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Product.class)
 .persistenceUnit("first")
 .build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("secondDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Order.class)
 .persistenceUnit("second")
 .build();
 }

 @Bean
 public PlatformTransactionManager primaryTransactionManager(
 @Qualifier("firstEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @Bean
 public PlatformTransactionManager backupTransactionManager(
 @Qualifier("secondEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @EnableJpaRepositories(basePackageClasses = ProductRepository.class,
 entityManagerFactoryRef = "firstEntityManagerFactory")
 @Primary
 public class PrimaryConfiguration {
 }

 @EnableJpaRepositories(basePackageClasses = OrderRepository.class,
 entityManagerFactoryRef = "secondEntityManagerFactory")
 public class secondConfiguration {
 }
}

坑三：官方文档样例有误

此时配置直接启动会报错

Method requestMappingHandlerMapping in org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$EnableWebMvcConfiguration required a single bean, but 2 were found:
	- firstEntityManagerFactory: defined by method 'firstEntityManagerFactory' in class path resource [top/fjy8018/jpadatasource/config/DataAccessConfig.class]
	- secondEntityManagerFactory: defined by method 'secondEntityManagerFactory' in class path resource [top/fjy8018/jpadatasource/config/DataAccessConfig.class]


Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

意思是自动装配时发现两个类型一致的Bean，主要指定优先级，而官方文档对此处可能出现的问题并未提示

指定firstEntityManagerFactory为优先Bean，同时文档样例创建了事务管理器但未配置到@EnableJpaRepositories注解中，此处也一并配置

最终配置类如下

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import top.fjy8018.jpadatasource.entity.backup.Order;
import top.fjy8018.jpadatasource.entity.primary.Product;
import top.fjy8018.jpadatasource.repository.backup.OrderRepository;
import top.fjy8018.jpadatasource.repository.primary.ProductRepository;

import javax.sql.DataSource;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {
 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("firstDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Product.class)
 .persistenceUnit("first")
 .build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("secondDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Order.class)
 .persistenceUnit("second")
 .build();
 }

 @Bean
 public PlatformTransactionManager primaryTransactionManager(
 @Qualifier("firstEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @Bean
 public PlatformTransactionManager backupTransactionManager(
 @Qualifier("secondEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @EnableJpaRepositories(basePackageClasses = ProductRepository.class,
 entityManagerFactoryRef = "firstEntityManagerFactory", transactionManagerRef = "primaryTransactionManager")
 @Primary
 public class PrimaryConfiguration {
 }

 @EnableJpaRepositories(basePackageClasses = OrderRepository.class,
 entityManagerFactoryRef = "secondEntityManagerFactory", transactionManagerRef = "backupTransactionManager")
 public class secondConfiguration {
 }
}

坑四：JPA不会自动建表

配置完成后启动

发现日志中建表SQL没有输出，同时查看数据库，确认表未创建

但官方文档对多数据源的配置说明已经结束，令人疑惑

自动建表语句没生成猜想可能由于与ddl相关的属性未配置导致

进入配置文件查看ddl配置，发现默认为false

将其配置为true后总配置文件如下

spring:
 datasource:
 first:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://120.79.226.26/jpa_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 30
 second:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://120.79.226.26/jpa_test_bak?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 20

 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true
 generate-ddl: true

启动工程发现自动建表生效

查看数据库情况，与预期一致，主库只包含主库的表，备份库只包含备份库的表，多数据配置完成

坑五：hibernate默认配置被覆盖

若在单数据源配置下应当无需配置该项，同时发现本应该默认将驼峰属性名映射为_拼接名称策略也失效，说明自定义配置源时覆盖了默认配置或者导致默认配置失效

查询源码分析原因，发现hibernate相关配置均在HibernateProperties配置类中

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * Configuration properties for Hibernate.
 *
 * @author Stephane Nicoll
 * @since 2.1.0
 * @see JpaProperties
 */
@ConfigurationProperties("spring.jpa.hibernate")
public class HibernateProperties {}

而该类在HibernateJpaConfiguration中进行注入，但配置类中进行了条件装配注解@ConditionalOnSingleCandidate标注，导致在多数据源情况下不满足该配置，类没有被装配到Spring Bean中

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * {@link JpaBaseConfiguration} implementation for Hibernate.
 * @since 2.0.0
 */
@Configuration
@EnableConfigurationProperties(HibernateProperties.class)
@ConditionalOnSingleCandidate(DataSource.class)
class HibernateJpaConfiguration extends JpaBaseConfiguration {

	private final HibernateProperties hibernateProperties;

	HibernateJpaConfiguration(DataSource dataSource, JpaProperties jpaProperties,
			ConfigurableListableBeanFactory beanFactory,
			ObjectProvider<JtaTransactionManager> jtaTransactionManager,
			ObjectProvider<TransactionManagerCustomizers> transactionManagerCustomizers,
			HibernateProperties hibernateProperties,
			ObjectProvider<Collection<DataSourcePoolMetadataProvider>> metadataProviders,
			ObjectProvider<SchemaManagementProvider> providers,
			ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy,
			ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy,
			ObjectProvider<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers) {
		super(dataSource, jpaProperties, jtaTransactionManager,
				transactionManagerCustomizers);
		this.hibernateProperties = hibernateProperties;
		this.defaultDdlAutoProvider = new HibernateDefaultDdlAutoProvider(providers);
		this.poolMetadataProvider = new CompositeDataSourcePoolMetadataProvider(
				metadataProviders.getIfAvailable());
		this.hibernatePropertiesCustomizers = determineHibernatePropertiesCustomizers(
				physicalNamingStrategy.getIfAvailable(),
				implicitNamingStrategy.getIfAvailable(), beanFactory,
				hibernatePropertiesCustomizers.orderedStream()
						.collect(Collectors.toList()));
	}
 ...
}

解决方法就只能自己工程内实现该类的配置，注意，Spring 2.x版本自动装配变化较大，当前配置基于最新版2.1.3有效，并不代表对后续版本一定兼容

工程配置

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.hibernate.cfg.AvailableSettings;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.EmbeddedDatabaseConnection;
import org.springframework.boot.jdbc.SchemaManagement;
import org.springframework.boot.jdbc.SchemaManagementProvider;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.hibernate5.SpringBeanContainer;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.util.ClassUtils;
import top.fjy8018.jpadatasource.entity.backup.Order;
import top.fjy8018.jpadatasource.entity.primary.Product;
import top.fjy8018.jpadatasource.repository.backup.OrderRepository;
import top.fjy8018.jpadatasource.repository.primary.ProductRepository;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {

 private final ObjectProvider<SchemaManagementProvider> providers;

 private final HibernateProperties hibernateProperties;

 private final JpaProperties properties;

 private final ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy;

 private final ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy;

 private final ConfigurableListableBeanFactory beanFactory;

 private final ObjectProvider<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers;

 @Autowired
 public DataAccessConfig(ObjectProvider<SchemaManagementProvider> providers, HibernateProperties hibernateProperties, JpaProperties properties, ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy, ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy, ConfigurableListableBeanFactory beanFactory, ObjectProvider<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers) {
 this.providers = providers;
 this.hibernateProperties = hibernateProperties;
 this.properties = properties;
 this.physicalNamingStrategy = physicalNamingStrategy;
 this.implicitNamingStrategy = implicitNamingStrategy;
 this.beanFactory = beanFactory;
 this.hibernatePropertiesCustomizers = hibernatePropertiesCustomizers;
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @Primary
 public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("firstDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 // 加入规约配置
 .properties(getVendorProperties(dataSource))
 .packages(Product.class)
 .persistenceUnit("first")
 .build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("secondDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .properties(getVendorProperties(dataSource))
 .packages(Order.class)
 .persistenceUnit("second")
 .build();
 }

 @Bean
 public PlatformTransactionManager primaryTransactionManager(
 @Qualifier("firstEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @Bean
 public PlatformTransactionManager backupTransactionManager(
 @Qualifier("secondEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @EnableJpaRepositories(basePackageClasses = ProductRepository.class,
 entityManagerFactoryRef = "firstEntityManagerFactory", transactionManagerRef = "primaryTransactionManager")
 @Primary
 public class PrimaryConfiguration {
 }

 @EnableJpaRepositories(basePackageClasses = OrderRepository.class,
 entityManagerFactoryRef = "secondEntityManagerFactory", transactionManagerRef = "backupTransactionManager")
 public class secondConfiguration {
 }

 /**
 * 获取配置文件信息
 *
 * @param dataSource
 * @return
 */
 private Map<String, Object> getVendorProperties(DataSource dataSource) {
 List<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers = determineHibernatePropertiesCustomizers(
 physicalNamingStrategy.getIfAvailable(),
 implicitNamingStrategy.getIfAvailable(), beanFactory,
 this.hibernatePropertiesCustomizers.orderedStream()
 .collect(Collectors.toList()));
 Supplier<String> defaultDdlMode = () -> new HibernateDefaultDdlAutoProvider(providers)
 .getDefaultDdlAuto(dataSource);
 return new LinkedHashMap<>(this.hibernateProperties.determineHibernateProperties(
 properties.getProperties(),
 new HibernateSettings().ddlAuto(defaultDdlMode)
 .hibernatePropertiesCustomizers(
 hibernatePropertiesCustomizers)));
 }

 /**
 * 命名策略自动判断
 *
 * @param physicalNamingStrategy
 * @param implicitNamingStrategy
 * @param beanFactory
 * @param hibernatePropertiesCustomizers
 * @return
 */
 private List<HibernatePropertiesCustomizer> determineHibernatePropertiesCustomizers(
 PhysicalNamingStrategy physicalNamingStrategy,
 ImplicitNamingStrategy implicitNamingStrategy,
 ConfigurableListableBeanFactory beanFactory,
 List<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers) {
 List<HibernatePropertiesCustomizer> customizers = new ArrayList<>();
 if (ClassUtils.isPresent(
 "org.hibernate.resource.beans.container.spi.BeanContainer",
 getClass().getClassLoader())) {
 customizers
 .add((properties) -> properties.put(AvailableSettings.BEAN_CONTAINER,
 new SpringBeanContainer(beanFactory)));
 }
 if (physicalNamingStrategy != null || implicitNamingStrategy != null) {
 customizers.add(new NamingStrategiesHibernatePropertiesCustomizer(
 physicalNamingStrategy, implicitNamingStrategy));
 }
 customizers.addAll(hibernatePropertiesCustomizers);
 return customizers;
 }

 /**
 * 自动进行建表操作
 */
 class HibernateDefaultDdlAutoProvider implements SchemaManagementProvider {

 private final Iterable<SchemaManagementProvider> providers;

 HibernateDefaultDdlAutoProvider(Iterable<SchemaManagementProvider> providers) {
 this.providers = providers;
 }

 public String getDefaultDdlAuto(DataSource dataSource) {
 if (!EmbeddedDatabaseConnection.isEmbedded(dataSource)) {
 return "none";
 }
 SchemaManagement schemaManagement = getSchemaManagement(dataSource);
 if (SchemaManagement.MANAGED.equals(schemaManagement)) {
 return "none";
 }
 return "create-drop";

 }

 @Override
 public SchemaManagement getSchemaManagement(DataSource dataSource) {
 return StreamSupport.stream(this.providers.spliterator(), false)
 .map((provider) -> provider.getSchemaManagement(dataSource))
 .filter(SchemaManagement.MANAGED::equals).findFirst()
 .orElse(SchemaManagement.UNMANAGED);
 }

 }

 private static class NamingStrategiesHibernatePropertiesCustomizer
 implements HibernatePropertiesCustomizer {

 private final PhysicalNamingStrategy physicalNamingStrategy;

 private final ImplicitNamingStrategy implicitNamingStrategy;

 NamingStrategiesHibernatePropertiesCustomizer(
 PhysicalNamingStrategy physicalNamingStrategy,
 ImplicitNamingStrategy implicitNamingStrategy) {
 this.physicalNamingStrategy = physicalNamingStrategy;
 this.implicitNamingStrategy = implicitNamingStrategy;
 }

 /**
 * 数据库命名映射策略
 *
 * @param hibernateProperties the JPA vendor properties to customize
 */
 @Override
 public void customize(Map<String, Object> hibernateProperties) {
 if (this.physicalNamingStrategy != null) {
 hibernateProperties.put("hibernate.physical_naming_strategy",
 this.physicalNamingStrategy);
 }
 if (this.implicitNamingStrategy != null) {
 hibernateProperties.put("hibernate.implicit_naming_strategy",
 this.implicitNamingStrategy);
 }
 }
 }
}

配置Bean完成后则规约配置会生效，便无需在配置文件显示配置DDL语句执行开关

启动日志也可看出结果符合预期

总结

由此发现，在SpringBoot版本迁移过程中不一定互相兼容，同时官方文档尽管全面，但随着版本变化文档也有不准确情况。而如果完全依靠爬源码复制源码配置也是无法实现最简单化的配置，需要结合文档、源码、日志逐一分析

工程源码已开放，注意配置自己的数据库连接地址，工程内的连接地址已经失效

GitHub源码

mybatis中遇到的坑

Thu, 27 Dec 2018 12:37:00 +0800

mysql驱动问题

问题描述

问题发生时间（2018-12-27）

环境版本：

SpringBoot 2.1.1
Mybatis 1.3.2

原始配置

spring:
 datasource:
 driver-class-name: com.mysql.jdbc.Driver
 username: hikaricp
 password: hikaricp
 url: jdbc:mysql://localhost:3306/db_test?characterEncoding=utf-8&useSSL=false

报错信息

Registered driver with driverClassName=com.mysql.jdbc.Driver was not found,

报错提示

Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

解决办法

从提示中可看出，驱动名称有变，更正驱动名称即可

更正后配置

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: hikaricp
 password: hikaricp
 url: jdbc:mysql://localhost:3306/db_test?characterEncoding=utf-8&useSSL=false

同时若使用IDEA自带提示也可看出问题，有两种驱动都存在的问题，希望后续修复

另一种解决方案，从SpringBoot2.0之后连接池使用hikari，可根据url自动识别驱动，即如下配置也可成功运行

spring:
 datasource:
 username: hikaricp
 password: hikaricp
 url: jdbc:mysql://localhost:3306/db_test?characterEncoding=utf-8&useSSL=false

注解使用简化

前景提要

进入SpringBoot时代后“注解驱动开发”就已经成为趋势，mybatis官方也提供注解替代xml配置的方案

问题描述

问题发现时间（2018-12-27）

环境版本：

SpringBoot 2.1.1
Mybatis 1.3.2

在早期版本的mybatis-starter还需要进行实体映射xml文件配置，这次在使用1.3.2版本时再次查了下官方源码，发现已经无需使用映射文件，其底层会自动通过反射识别对象属性类型，并且去除了不少早期版本使用的注解（当前仍可以使用，但不使用功能正常）

无需手动创建SqlSession或DataSource

官方文档说明：

As you may already know, to use MyBatis with Spring you need at least an SqlSessionFactory and at least one mapper interface.

MyBatis-Spring-Boot-Starter will:

Autodetect an existing DataSource.

Will create and register an instance of a SqlSessionFactory passing that DataSource as an input using the SqlSessionFactoryBean.

Will create and register an instance of a SqlSessionTemplate got out of the SqlSessionFactory.

Autoscan your mappers, link them to the SqlSessionTemplate and register them to Spring context so they can be injected into your beans.

支持版本为Spring 4.3+

You just need to create a normal Spring boot application and let the mapper be injected like follows(available on Spring 4.3+):

@MapperScan -> @Mapper

早期版本需要在启动类上加上@MapperScan(basePackages = "xxx")注解扫描mapper类，新版本可直接在mapper包上使用@Mapper注解即可

The MyBatis-Spring-Boot-Starter will search, by default, for mappers marked with the @Mapper annotation.

除非需要自定义注解或者不使用@Mapper才需要加上@MapperScan

You may want to specify a custom annotation or a marker interface for scanning. If so, you must use the @MapperScan annotation.

@Results与Mapper.xml

早期版本需要手动指定类型映射，并在resources目录下进行xml配置，新版本自动通过反射识别属性类型，无需进行xml配置

SpringCloud中遇到的坑

Tue, 24 Jul 2018 21:34:00 +0800

SpringCloud Config

配置无法读取

问题描述

配置中心的配置文件如下

eureka:
 client:
 service-url:
 defaultZone: http://localhost:8761/eureka/
spring:
 application:
 name: config
 cloud:
 config:
 server:
 git:
 uri: http://XXX/fjy8018/config-repo
 username: 1186032234@qq.com
 password: XXX
 basedir: spring-cloud\config\basedir
server:
 port: 8084

已经通过网页测试该账号和密码可以访问该仓库，并有权限，启动配置中心后通过页面访问提示Cannot clone or checkout repository

解决方法

SpringCloud正式版的配置中心路径必须是带.git结尾的全路径，将配置改为全路径即可

eureka:
 client:
 service-url:
 defaultZone: http://localhost:8761/eureka/
spring:
 application:
 name: config
 cloud:
 config:
 server:
 git:
 uri: http://XXX/fjy8018/config-repo.git
 username: 1186032234@qq.com
 password: XXX
 basedir: spring-cloud\config\basedir
server:
server:
 port: 8084

SpringBoot的一些坑

Sun, 08 Jul 2018 16:03:00 +0800

bindingResult无法捕获校验错误

错误复现

原工程代码，RegisterForm对象设置了校验规则

预期的返回结果

{
 "code": 4,
 "msg": "表单错误",
 "data": null
}

实际执行结果

并且控制台打出了异常堆栈，而且记录的log4j日志也没有显示

原因

经过查阅资料，得到原因

@Valid 和 BindingResult 是一一对应的，如果有多个@Valid，那么每个@Valid后面跟着的BindingResult就是这个@Valid的验证结果，顺序不能乱

解决

故将BindingResult跟在RegisterForm后面即可

public ResultVO doRegister(@Valid RegisterForm registerForm, BindingResult bindingResult, HttpServletRequest request) throws Exception{

再次执行得到预期返回值

控制台也打出预期的日志，并没有显示异常

Redis分布式锁在高并发情况下偶然突然失效

Mon, 11 Jun 2018 12:40:00 +0800

背景

原理

在学习Redis分布式锁时编写Service类，其中包含加锁和解锁两个方法，通过调用Redis的SETNX和GETSET方法加锁

源码

为便于查看，加了logback进行日志打印

需要加锁的方法，该方法为模拟抢购场景的实现

交由SpringBoot自动注入写好的RedisLock包（其实问题出在这里，本应该是10*1000，手误写成10*000结果为0，故所有超时为0）

访问Controller，一个为抢购地址，抢购地址访问一次则数量减一，一个为查询地址

压测工具

使用Apache AB模拟高并发访问

并发测试

手动测试

手动访问，测试功能是否正常查询

订购

压测

10个请求，单线程发起测试

数量正常

50个请求，2个线程发起测试

出错

数量显然不对

查看日志，发现后续请求都从判断锁是否过期的方法获得的锁，但执行上数值一致，逻辑也没问题

原因

后来发现在高并发情况下超时时间如果设置过小，多个线程可能获得的时间戳一致，导致加锁无效，即每个线程都在判断时间戳时可以获得锁，导致“超售”

再次压测

数量正常

提高并发量

数量正常，问题解决