詳談Feign的配置類是如何生效的
說明，該源碼部分只是個人總結，隨手記錄，不保證正確性；
該源碼關注的不是底層Feign是如何完成遠程調用的具體細節(jié)，而關注在Feign在完成遠程調用之前的準備工作，他的一些配置是如何生效的；看完之后對Spring的ImportBeanDefinitionRegistrar接口比之前的理解更加深了，而且想玩自定義注解提供擴展功能的，熟悉了Feign的幾個流程之后還是能夠提供很大的指導意見的；
1. Feign
特別說明一下，是在使用了Ribbon的基礎上加入了Feign的研讀，不確定Ribbon是否會對Feign有影響
1.1 配置類：ApiConfiguration.java
@Configuration
@EnableAspectJAutoProxy
@EnableFeignClients(basePackages = "com.sinotrans.hd.microservice.api.feign")
public class ApiConfiguration {
}
重點來看一下@EnableFeignClients做了哪些事情，除了該注解本身提供的屬性配置外，可以看到還導入了一個配置類FeignClientsRegistrar
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
}
1.2 FeignClientsRegistrar
現(xiàn)在來看一下FeignClientsRegistrar做了什么事情，該類實現(xiàn)了Spring的眾多接口，ImportBeanDefinitionRegistrar接口，簡單點說該接口提供了可以給容器動態(tài)注入Bean的功能，ResourceLoaderAware可以獲得容器資源依賴，BeanClassLoaderAware提供Bean的回調功能，EnvironmentAware獲得當前應用的環(huán)境變量信息
class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
registerDefaultConfiguration(metadata, registry);
registerFeignClients(metadata, registry);
}
｝
先看一下第一個方法registerDefaultConfiguration(),代碼如下,
private void registerDefaultConfiguration(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
Map<String, Object> defaultAttrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
String name;
if (metadata.hasEnclosingClass()) {
name = "default." + metadata.getEnclosingClassName();
}
else {
name = "default." + metadata.getClassName();
}
registerClientConfiguration(registry, name,
defaultAttrs.get("defaultConfiguration"));
}
}
defaultAttrs，先獲得當前配置類的注解@EnableFeignClients類的全部屬性，目前能夠獲取到在前面配置的屬性basePackages = "com.sinotrans.hd.microservice.api.feign",再往下判斷屬性是否為空，是否包含defaultConfiguration，程序往下走，目前屬性不為空且包含defaultConfiguration，hasEnclosingClass()判斷當前注解類是否是內部類，如果是內部類，則使用default. + 頂級類名，否則使用default. + 自己的類名，當前name=default.com.sinotrans.hd.microservice.api.config.ApiConfiguration
registerClientConfiguration()方法，內部代碼如下
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientSpecification.class);
builder.addConstructorArgValue(name);
builder.addConstructorArgValue(configuration);
registry.registerBeanDefinition(
name + "." + FeignClientSpecification.class.getSimpleName(),
builder.getBeanDefinition());
}
第一行首先預定義一個org.springframework.cloud.netflix.feign.FeignClientSpecification類型的Bean信息，通過構造方法設置FeignClientSpecification的name和configuration類，結合上面name屬性的設置，定義的這個Bean的名稱為default.com.sinotrans.hd.microservice.api.config.ApiConfiguration.FeignClientSpecification，調用FeignClientSpecification的構造方法來初始化這個類
FeignClientSpecification.java
class FeignClientSpecification implements NamedContextFactory.Specification {
public FeignClientSpecification(String name, Class<?>[] configuration) {
this.name = name;
this.configuration = configuration;
}
}
現(xiàn)在來看一下registerFeignClients(metadata, registry);方法源碼如下：
public void registerFeignClients(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
Set<String> basePackages;
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
FeignClient.class);
final Class<?>[] clients = attrs == null ? null
: (Class<?>[]) attrs.get("clients");
if (clients == null || clients.length == 0) {
scanner.addIncludeFilter(annotationTypeFilter);
basePackages = getBasePackages(metadata);
}
else {
final Set<String> clientClasses = new HashSet<>();
basePackages = new HashSet<>();
for (Class<?> clazz : clients) {
basePackages.add(ClassUtils.getPackageName(clazz));
clientClasses.add(clazz.getCanonicalName());
}
AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
@Override
protected boolean match(ClassMetadata metadata) {
String cleaned = metadata.getClassName().replaceAll("\\$", ".");
return clientClasses.contains(cleaned);
}
};
scanner.addIncludeFilter(
new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
}
for (String basePackage : basePackages) {
Set<BeanDefinition> candidateComponents = scanner
.findCandidateComponents(basePackage);
for (BeanDefinition candidateComponent : candidateComponents) {
if (candidateComponent instanceof AnnotatedBeanDefinition) {
// verify annotated class is an interface
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
Assert.isTrue(annotationMetadata.isInterface(),
"@FeignClient can only be specified on an interface");
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(
FeignClient.class.getCanonicalName());
String name = getClientName(attributes);
registerClientConfiguration(registry, name,
attributes.get("configuration"));
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
}
① 這個方法的代碼有點長，首先獲得包掃描類，獲得系統(tǒng)資源加載類，然后獲得配置類的@EnableFeignClients注解的所有屬性，定義一個匹配FeignClient的過濾器，clients屬性，則是判斷當前@EnableFeignClients是否有配置過clients屬性，該屬性的作用是明確指定標注了@FeignClient注解的接口類，如果配置了這個屬性，則類路徑掃描會被禁用，則basePackages掃描包路徑的值會將clients屬性的接口類所在的包加入掃描路徑，否則使用類路徑掃描。當前使用類路徑掃描；clients的值一旦為空或長度為0，那么則包掃描規(guī)則加入一個includeFilters規(guī)則為只掃描帶@FeignClient注解的類,packageSearchPath=classpath*:com/sinotrans/hd/microservice/api/feign/**/*.class
② findCandidateComponents()方法循環(huán)包掃描路徑，查找指定包路徑下符合條件的class，然后作為BeanDefinition集合返回，代碼如下
/**
* Scan the class path for candidate components.
* @param basePackage the package to check for annotated classes
* @return a corresponding Set of autodetected bean definitions
*/
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
try {
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
③ 循環(huán)返回的candidateComponents，而且類型必須為AnnotatedBeanDefinition并且必須是接口，然后獲得該接口上的@FeignClient注解的屬性，包含服務名，和請求上下文（包含上下文和控制層的RequestMapping），內容如下
④ 通過方法getClientName()獲取服務名，可以看到服務名的規(guī)則是value > name > serviceId依次去取，直到取不到拋出異常
private String getClientName(Map<String, Object> client) {
if (client == null) {
return null;
}
String value = (String) client.get("value");
if (!StringUtils.hasText(value)) {
value = (String) client.get("name");
}
if (!StringUtils.hasText(value)) {
value = (String) client.get("serviceId");
}
if (StringUtils.hasText(value)) {
return value;
}
throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
+ FeignClient.class.getSimpleName());
}
⑤ registerClientConfiguration()方法將服務名注冊成FeignClientSpecification類型的Bean放入預定義Bean容器，名稱為服務名"." + FeignClientSpecification.class.getSimpleName()，同時也將服務名和配置類分別通過構造方法賦值給FeignClientSpecification的name和configuration屬性，每個服務所需要引用的接口類有多個，所以這里可能會重復注冊registerClientConfiguration，因為這里只是定義信息，所以應該是hi后來的會覆蓋之前的吧。所以最終注入的應當是服務名去重后的數(shù)量，注入的時候也應當使用集合來接收注入，這個在后面會碰到；所以到了這里加上之前定義的默認的配置類生成的FeignClientSpecification，目前一共會有（）服務數(shù) + 配置類默認生成的）個FeignClientSpecification
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
Object configuration) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientSpecification.class);
builder.addConstructorArgValue(name);
builder.addConstructorArgValue(configuration);
registry.registerBeanDefinition(
name + "." + FeignClientSpecification.class.getSimpleName(),
builder.getBeanDefinition());
}
⑥ registerFeignClient()方法，首先通過BeanDefinitionBuilder定義FeignClientFactoryBean類型的Bean，然后將@FeignClient里的所有屬性都加入到BeanDefinitionBuilder的propertyValues里，通過這種方式給FeignClientFactoryBean的屬性賦值，定義注入方式為AbstractBeanDefinition.AUTOWIRE_BY_TYPE，通過BeanDefinitionHolder對象將Bean的alias定義為服務名+“FeignClient”,beanName=類的全路徑，注冊beanName的alias，這一塊存疑，每個接口不同，但服務相同，alias會相同，不知道這個alias的作用是什么？
FeignClientFactoryBean.java屬性如下
class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
ApplicationContextAware {
/***********************************
* WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some lifecycle race condition.
***********************************/
private Class<?> type;
private String name;
private String url;
private String path;
private boolean decode404;
private ApplicationContext applicationContext;
private Class<?> fallback = void.class;
private Class<?> fallbackFactory = void.class;
}
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
String className = annotationMetadata.getClassName();
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
validate(attributes);
definition.addPropertyValue("url", getUrl(attributes));
definition.addPropertyValue("path", getPath(attributes));
String name = getName(attributes);
definition.addPropertyValue("name", name);
definition.addPropertyValue("type", className);
definition.addPropertyValue("decode404", attributes.get("decode404"));
definition.addPropertyValue("fallback", attributes.get("fallback"));
definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
String alias = name + "FeignClient";
AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null
beanDefinition.setPrimary(primary);
String qualifier = getQualifier(attributes);
if (StringUtils.hasText(qualifier)) {
alias = qualifier;
}
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
new String[] { alias });
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
1.3 FeignAutoConfiguration
先看一下該類的定義，@ConditionalOnClass(Feign.class)一旦類路徑下引入了Feign的包，則該配置類會自動生效，然后導入配置屬性類信息
@Configuration
@ConditionalOnClass(Feign.class)
@EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class})
public class FeignAutoConfiguration {
@Autowired(required = false)
private List<FeignClientSpecification> configurations = new ArrayList<>();
@Bean
public FeignContext feignContext() {
FeignContext context = new FeignContext();
context.setConfigurations(this.configurations);
return context;
}
｝
① 注入一個名為feignContext類型為FeignContext的bean,使用默認的配置類FeignClientsConfiguration通過父類NamedContextFactory來構建，，將所有feign相關的配置設置進去，包含了Feign的上下文信息，F(xiàn)eignClientsConfiguration通過實現(xiàn)ApplicationContextAware來注入ApplicationContext， 并將ApplicationContext作為FeignContext的父容器，關于FeignClientsConfiguration在后面章節(jié)講述
FeignContext.java
public FeignContext() {
super(FeignClientsConfiguration.class, "feign", "feign.client.name");
}
NamedContextFactory.java
/**
* Creates a set of child contexts that allows a set of Specifications to define the beans
* in each child context.
*
* Ported from spring-cloud-netflix FeignClientFactory and SpringClientFactory
*
* @author Spencer Gibb
* @author Dave Syer
*/
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
implements DisposableBean, ApplicationContextAware {
public interface Specification {
String getName();
Class<?>[] getConfiguration();
}
private Map<String, AnnotationConfigApplicationContext> contexts = new ConcurrentHashMap<>();
private Map<String, C> configurations = new ConcurrentHashMap<>();
private ApplicationContext parent;
private Class<?> defaultConfigType;
private final String propertySourceName;
private final String propertyName;
public NamedContextFactory(Class<?> defaultConfigType, String propertySourceName,
String propertyName) {
this.defaultConfigType = defaultConfigType;
this.propertySourceName = propertySourceName;
this.propertyName = propertyName;
}
public void setConfigurations(List<C> configurations) {
for (C client : configurations) {
this.configurations.put(client.getName(), client);
}
}
}
② FeignContext創(chuàng)建完成之后，下一步context.setConfigurations(this.configurations); 通過代碼可以看到this.configurations指向的是本類的一個屬性，通過@Autowired注入，然后我們看到注入的這個類型，F(xiàn)eignClientSpecification在前面我們看到了，這個是根據@FeignContext上的服務名來進行創(chuàng)建的類型，詳見org.springframework.cloud.netflix.feign.FeignClientsRegistrar#registerClientConfiguration方法，所以在之前我們注入的FeignClientSpecification，也解決了之前的疑惑，既然會注入多個同類型的Bean，所以這里只能通過集合來接收注入，根據NamedContextFactory的源碼可以看到它的configurations屬性是一個ConcurrentHashMap,ConcurrentHashMap的key是FeignClientSpecification的name屬性，關于name屬性的值的規(guī)則前面也已經看到了， ConcurrentHashMap的value就是每個FeignClientSpecification對象本身
@Autowired(required = false) private List<FeignClientSpecification> configurations = new ArrayList<>();
1.4 FeignClientFactoryBean的定義
該類部分源碼如下：
實現(xiàn)了FactoryBean接口來完成Bean的注入，最終注入的對象通過getObject()方法返回，實現(xiàn)了
InitializingBean接口通過afterPropertiesSet()方法來檢查name屬性的賦值，實現(xiàn)了ApplicationContextAware接口來獲得ApplicationContext容器，其中在前面也已經看到該類的屬性賦值過程是如何實現(xiàn)的，這里不再細述。
class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
ApplicationContextAware {
/***********************************
* WARNING! Nothing in this class should be @Autowired. It causes NPEs because of some lifecycle race condition.
***********************************/
private Class<?> type;
private String name;
private String url;
private String path;
private boolean decode404;
private ApplicationContext applicationContext;
private Class<?> fallback = void.class;
private Class<?> fallbackFactory = void.class;
@Override
public void afterPropertiesSet() throws Exception {
Assert.hasText(this.name, "Name must be set");
}
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
this.applicationContext = context;
}
@Override
public Object getObject() throws Exception {
FeignContext context = applicationContext.getBean(FeignContext.class);
Feign.Builder builder = feign(context);
}
｝
① 現(xiàn)在重點來看一下getObject()方法，首先從ApplicationContext容器中獲得FeignContext對象，該對象在上一步已經看到如何注入的，下一步調用feign()方法，該方法代碼如下
class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
ApplicationContextAware {
protected Feign.Builder feign(FeignContext context) {
FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
Logger logger = loggerFactory.create(this.type);
// @formatter:off
Feign.Builder builder = get(context, Feign.Builder.class)
// required values
.logger(logger)
.encoder(get(context, Encoder.class))
.decoder(get(context, Decoder.class))
.contract(get(context, Contract.class));
// @formatter:on
configureFeign(context, builder);
// 省略其它代碼
}
protected <T> T get(FeignContext context, Class<T> type) {
T instance = context.getInstance(this.name, type);
if (instance == null) {
throw new IllegalStateException("No bean found of type " + type + " for "
+ this.name);
}
return instance;
}
protected void configureFeign(FeignContext context, Feign.Builder builder) {
FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
// 省略其它代碼
}
}
首先第一步FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);點開get()方法，最終執(zhí)行org.springframework.cloud.context.named.NamedContextFactory#createContext，傳入的name即FeignClientFactoryBean的name屬性，也就是服務名，創(chuàng)建一個空的基于注解的容器類，先判斷configuration屬性的Map里是否包含當前name，之前已經看到configuration的屬性來源就是之前注入的FeignClientSpecification的name屬性也就是服務名，所以傳入的服務名是包含在這里的，判斷獲得當前name對應的FeignClientSpecification注冊到新創(chuàng)建的容器類中，將NamedContextFactory的defaultConfigType屬性注入到容器中類型為PropertyPlaceholderAutoConfiguration，當前defaultConfigType具體實現(xiàn)類是通過FeignContext的構造方法調用super也就是NamedContextFactory傳參復制為FeignClientSpecification對象，propertySourceName屬性添加到當前新創(chuàng)建的服務容器的MutablePropertySources中，并且規(guī)定讀取的name是當前propertySourceName,的就是說每個服務名所創(chuàng)建的子容器是不同的，如果不特殊指定父容器，則他們的父容器是相同的，都是ApplicationContext，關于FeignClientSpecification在下一節(jié)詳述
NamedContextFactory.java,getInstance() --> getContext() --> createContext()
public abstract class NamedContextFactory<C extends NamedContextFactory.Specification>
implements DisposableBean, ApplicationContextAware {
private Map<String, C> configurations = new ConcurrentHashMap<>();
public <T> T getInstance(String name, Class<T> type) {
AnnotationConfigApplicationContext context = getContext(name);
if (BeanFactoryUtils.beanNamesForTypeIncludingAncestors(context,
type).length > 0) {
return context.getBean(type);
}
return null;
}
protected AnnotationConfigApplicationContext getContext(String name) {
if (!this.contexts.containsKey(name)) {
synchronized (this.contexts) {
if (!this.contexts.containsKey(name)) {
this.contexts.put(name, createContext(name));
}
}
}
return this.contexts.get(name);
}
protected AnnotationConfigApplicationContext createContext(String name) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
if (this.configurations.containsKey(name)) {
for (Class<?> configuration : this.configurations.get(name)
.getConfiguration()) {
context.register(configuration);
}
}
for (Map.Entry<String, C> entry : this.configurations.entrySet()) {
if (entry.getKey().startsWith("default.")) {
for (Class<?> configuration : entry.getValue().getConfiguration()) {
context.register(configuration);
}
}
}
context.register(PropertyPlaceholderAutoConfiguration.class,
this.defaultConfigType);
context.getEnvironment().getPropertySources().addFirst(new MapPropertySource(
this.propertySourceName,
Collections.<String, Object> singletonMap(this.propertyName, name)));
if (this.parent != null) {
// Uses Environment from parent as well as beans
context.setParent(this.parent);
}
context.refresh();
return context;
}
}
現(xiàn)在來看Feign.Builder builder = get(context, Feign.Builder.class)這一行代碼，其實這一行代碼是在FeignClientsConfiguration這個類完成創(chuàng)建并完成Bean對象的注入之后才會執(zhí)行的，關于具體注入的對象在后面一個章節(jié)講述，這里先大致說一下這一塊代碼的功能，創(chuàng)建Feign.Builder對象，并將容器中（FeignClientsConfiguration注入的幾個Bean）對應的Bean調用setter方法來完成對Feign.Builder的logger-encoder, decoder, contract屬性賦值
1.5 FeignClientsConfiguration
接著上面的代碼，org.springframework.cloud.netflix.feign.FeignClientFactoryBean#feign里的FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);代碼，會去創(chuàng)建每個服務自己的容器，并且會去實例化當前配置類，下面就來看下該類的作用
@Configuration
public class FeignClientsConfiguration {
@Autowired
private ObjectFactory<HttpMessageConverters> messageConverters;
@Autowired(required = false)
private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();
@Autowired(required = false)
private List<FeignFormatterRegistrar> feignFormatterRegistrars = new ArrayList<>();
@Autowired(required = false)
private Logger logger;
@Bean
@ConditionalOnMissingBean
public Decoder feignDecoder() {
return new ResponseEntityDecoder(new SpringDecoder(this.messageConverters));
}
@Bean
@ConditionalOnMissingBean
public Encoder feignEncoder() {
return new SpringEncoder(this.messageConverters);
}
@Bean
@ConditionalOnMissingBean
public Contract feignContract(ConversionService feignConversionService) {
return new SpringMvcContract(this.parameterProcessors, feignConversionService);
}
@Bean
public FormattingConversionService feignConversionService() {
FormattingConversionService conversionService = new DefaultFormattingConversionService();
for (FeignFormatterRegistrar feignFormatterRegistrar : feignFormatterRegistrars) {
feignFormatterRegistrar.registerFormatters(conversionService);
}
return conversionService;
}
@Configuration
@ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
protected static class HystrixFeignConfiguration {
@Bean
@Scope("prototype")
@ConditionalOnMissingBean
@ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
public Feign.Builder feignHystrixBuilder() {
return HystrixFeign.builder();
}
}
@Bean
@ConditionalOnMissingBean
public Retryer feignRetryer() {
return Retryer.NEVER_RETRY;
}
@Bean
@Scope("prototype")
@ConditionalOnMissingBean
public Feign.Builder feignBuilder(Retryer retryer) {
return Feign.builder().retryer(retryer);
}
@Bean
@ConditionalOnMissingBean(FeignLoggerFactory.class)
public FeignLoggerFactory feignLoggerFactory() {
return new DefaultFeignLoggerFactory(logger);
}
}
① 該類為一個配置類，被實例化后，識別當前類下的注入的Bean，messageConverters，parameterProcessors,feignFormatterRegistrars,logger等允許注入，除messageConverters系統(tǒng)有默認值外，其它無默認值，但應該都可以自定義并注入容器，然后使之生效。同時下面默認也會像容器中注入幾個Bean，前提是用戶沒有自定義的時候，如 feignDecoder()注入Decoder, feignEncoder注入Encoder， feignContract()注入Contract, feignConversionService注入FormattingConversionService,同樣不細究作用；
② 有一個內部類，用來判斷如果當前類路徑下有Hystrix的包，則該配置類生效，并且如果配置了feign.hystrix.enabled屬性，則使用Hystrix來構建HystrixFeign`
@Configuration
@ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
protected static class HystrixFeignConfiguration {
@Bean
@Scope("prototype")
@ConditionalOnMissingBean
@ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
public Feign.Builder feignHystrixBuilder() {
return HystrixFeign.builder();
}
}
③ feignRetryer，可以看到Feign的重試機制默認是關閉的，該接口有一個內部類，目前調用的是空參的構造函數(shù)
@Bean
@ConditionalOnMissingBean
public Retryer feignRetryer() {
return Retryer.NEVER_RETRY;
}
④ feignBuilder()方法，構建一個默認的的Feign.Builder對象,入參的retryer會從容器中獲取注入的Retryer來覆蓋默認的builder中的Retryer沒有任何屬性，目前容器中已經通過③的方法feignRetryer()來注入了一個Retryer.NEVER_RETRY類型的Retryer,所以會覆蓋默認的Feign.builder()構建出來的重試機制，即不提供重試支持，默認值詳見⑤
@Bean
@Scope("prototype")
@ConditionalOnMissingBean
public Feign.Builder feignBuilder(Retryer retryer) {
return Feign.builder().retryer(retryer);
}
這里執(zhí)行結束后，各個參數(shù)的 值如下圖
⑤ Feign.Builder對象,看一下內部類Builder，這一塊的步驟往下細分一下，其實會覆蓋某些之前設置的屬性，下面來詳細看一下每個方法的默認實現(xiàn),某些方法不再貼里面的具體實現(xiàn)，到時候可以自行進入某些方法內部查看源碼
public abstract class Feign {
public static Builder builder() {
return new Builder();
}
public static class Builder {
private final List<RequestInterceptor> requestInterceptors =
new ArrayList<RequestInterceptor>();
// 默認的日志級別，可選值有NONE, BASIC, HEADERS, FULL
private Logger.Level logLevel = Logger.Level.NONE;
// Defines what annotations and values are valid on interfaces.
private Contract contract = new Contract.Default();
// 提交一個feign.Request的http請求，該實現(xiàn)是線程安全的
private Client client = new Client.Default(null, null);
// 默認的重試機制，有幾個屬性period為100，maxPeriod為1000，maxAttempts為5，attempt為1，sleptForMillis為0
private Retryer retryer = new Retryer.Default();
// 沒有任何屬性的logger
private Logger logger = new NoOpLogger();
// 編碼
private Encoder encoder = new Encoder.Default();
// 解碼
private Decoder decoder = new Decoder.Default();
// 允許自定義對響應異常的處理
private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
// 默認的Request.Options，connectTimeoutMillis為10 * 1000， readTimeoutMillis為60 * 1000
private Options options = new Options();
// Controls reflective method dispatch.
private InvocationHandlerFactory invocationHandlerFactory =
new InvocationHandlerFactory.Default();
private boolean decode404;
｝
1.6 FeignClientProperties
① 配置前綴feign.client
@ConfigurationProperties("feign.client")
public class FeignClientProperties {
private boolean defaultToProperties = true;
private String defaultConfig = "default";
private Map<String, FeignClientConfiguration> config = new HashMap<>();
}
② 該類有一個內部類FeignClientConfiguration，通過config屬性的setter/getter方法來將該內部類賦值給該類的屬性，而且該屬性是一個map形式，value才是內部類，所以再配置屬性的時候，可以指定一個Key,所以如果需要配置FeignClientConfiguration下的屬性，經后面分析，為什么使用map形式存儲屬性對象，是因為當前項目需要調用多個項目的Feign接口，所以可以使用注冊的服務名為每個服務單獨設置不同的屬性，而如果需要所有的服務公用的配置，則配置在default這個key下，為什么是default，是因為取值屬性defaultConfig,需要使用feign.client.key.config，可配置屬性如下
feign:
client:
myFeign:
readTimeout: 5000
connectTimeout: 2000
default:
readTimeout: 6000
connectTimeout: 3000
public static class FeignClientConfiguration {
private Logger.Level loggerLevel;
private Integer connectTimeout;
private Integer readTimeout;
private Class<Retryer> retryer;
private Class<ErrorDecoder> errorDecoder;
private List<Class<RequestInterceptor>> requestInterceptors;
private Boolean decode404;
}
1.7 再看FeignClientFactoryBean
接之前已經露過面的一次configureFeign()方法，這個方法獲取了上面FeignClientProperties這個bean，在這里會初始化FeignClientProperties的各種屬性，F(xiàn)eignClientProperties有一個屬性defaultToProperties默認為true,所以走的是if里的方法，代碼如下，
class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
ApplicationContextAware {
@Override
public Object getObject() throws Exception {
FeignContext context = applicationContext.getBean(FeignContext.class);
Feign.Builder builder = feign(context);
if (!StringUtils.hasText(this.url)) {
String url;
if (!this.name.startsWith("http")) {
url = "http://" + this.name;
}
else {
url = this.name;
}
url += cleanPath();
return loadBalance(builder, context, new HardCodedTarget<>(this.type,
this.name, url));
}
if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
this.url = "http://" + this.url;
}
String url = this.url + cleanPath();
Client client = getOptional(context, Client.class);
if (client != null) {
if (client instanceof LoadBalancerFeignClient) {
// not lod balancing because we have a url,
// but ribbon is on the classpath, so unwrap
client = ((LoadBalancerFeignClient)client).getDelegate();
}
builder.client(client);
}
Targeter targeter = get(context, Targeter.class);
return targeter.target(this, builder, context, new HardCodedTarget<>(
this.type, this.name, url));
}
protected Feign.Builder feign(FeignContext context) {
FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
Logger logger = loggerFactory.create(this.type);
// @formatter:off
Feign.Builder builder = get(context, Feign.Builder.class)
// required values
.logger(logger)
.encoder(get(context, Encoder.class))
.decoder(get(context, Decoder.class))
.contract(get(context, Contract.class));
// @formatter:on
configureFeign(context, builder);
return builder;
}
protected void configureFeign(FeignContext context, Feign.Builder builder) {
FeignClientProperties properties = applicationContext.getBean(FeignClientProperties.class);
if (properties != null) {
if (properties.isDefaultToProperties()) {
configureUsingConfiguration(context, builder);
configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
configureUsingProperties(properties.getConfig().get(this.name), builder);
} else {
configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder);
configureUsingProperties(properties.getConfig().get(this.name), builder);
configureUsingConfiguration(context, builder);
}
} else {
configureUsingConfiguration(context, builder);
}
}
protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
Logger.Level level = getOptional(context, Logger.Level.class);
if (level != null) {
builder.logLevel(level);
}
Retryer retryer = getOptional(context, Retryer.class);
if (retryer != null) {
builder.retryer(retryer);
}
ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
if (errorDecoder != null) {
builder.errorDecoder(errorDecoder);
}
Request.Options options = getOptional(context, Request.Options.class);
if (options != null) {
builder.options(options);
}
Map<String, RequestInterceptor> requestInterceptors = context.getInstances(
this.name, RequestInterceptor.class);
if (requestInterceptors != null) {
builder.requestInterceptors(requestInterceptors.values());
}
if (decode404) {
builder.decode404();
}
}
protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
if (config == null) {
return;
}
if (config.getLoggerLevel() != null) {
builder.logLevel(config.getLoggerLevel());
}
if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout()));
}
if (config.getRetryer() != null) {
Retryer retryer = getOrInstantiate(config.getRetryer());
builder.retryer(retryer);
}
if (config.getErrorDecoder() != null) {
ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
builder.errorDecoder(errorDecoder);
}
if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
// this will add request interceptor to builder, not replace existing
for (Class<RequestInterceptor> bean : config.getRequestInterceptors()) {
RequestInterceptor interceptor = getOrInstantiate(bean);
builder.requestInterceptor(interceptor);
}
}
if (config.getDecode404() != null) {
if (config.getDecode404()) {
builder.decode404();
}
}
}
}
① 先看方法configureUsingConfiguration,從FeignContext中獲取這些bean如果不為空的話，就覆蓋之前做的默認值，所以如果我們自定義這些bean的放入到容器的時候，則從FeignContext中一旦能夠獲取到這些bean，就可以覆蓋到系統(tǒng)默認的處理，這里給我們自定義留下了支持
configureUsingConfiguration(context, builder);
protected void configureUsingConfiguration(FeignContext context, Feign.Builder builder) {
// 目前容器沒有注入`Logger.Level`，所以這里使用的還是Feign.Builder的默認值
Logger.Level level = getOptional(context, Logger.Level.class);
if (level != null) {
builder.logLevel(level);
}
// 參考FeignClientsConfiguration，容器中默認注入了一個`Retryer.NEVER_RETRY`
Retryer retryer = getOptional(context, Retryer.class);
if (retryer != null) {
builder.retryer(retryer);
}
// 沒有注入`ErrorDecoder`，所以使用的還是Feign.Builder的默認值
ErrorDecoder errorDecoder = getOptional(context, ErrorDecoder.class);
if (errorDecoder != null) {
builder.errorDecoder(errorDecoder);
}
// 默認通過`FeignRibbonClientAutoConfiguration`的`feignRequestOptions()`方 // 注入了一個Request.Options
// 詳見下一節(jié)FeignRibbonClientAutoConfiguration，拿到這個`bean`，覆蓋原屬性
Request.Options options = getOptional(context, Request.Options.class);
if (options != null) {
builder.options(options);
}
// 未細究
Map<String, RequestInterceptor> requestInterceptors = context.getInstances(
this.name, RequestInterceptor.class);
if (requestInterceptors != null) {
builder.requestInterceptors(requestInterceptors.values());
}
// 未細究
if (decode404) {
builder.decode404();
}
}
② configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder)方法，作用是應用配置文件中的默認的配置,properties的類型為FeignClientProperties，config形式為Map，相關細節(jié)在FeignClientProperties這一節(jié)已詳細講解，所以這里是把配置文件下的feign.client.default下的屬性應用起來，可以配置的屬性有如下方法內部，可以看到按照順序，默認配置會覆蓋第一步里的配置，配置文件的優(yōu)先級高于配置類的優(yōu)先級（包括使用配置類的方法注入自定義的bean）
configureUsingProperties(properties.getConfig().get(properties.getDefaultConfig()), builder)
protected void configureUsingProperties(FeignClientProperties.FeignClientConfiguration config, Feign.Builder builder) {
if (config == null) {
return;
}
if (config.getLoggerLevel() != null) {
builder.logLevel(config.getLoggerLevel());
}
if (config.getConnectTimeout() != null && config.getReadTimeout() != null) {
builder.options(new Request.Options(config.getConnectTimeout(), config.getReadTimeout()));
}
if (config.getRetryer() != null) {
Retryer retryer = getOrInstantiate(config.getRetryer());
builder.retryer(retryer);
}
if (config.getErrorDecoder() != null) {
ErrorDecoder errorDecoder = getOrInstantiate(config.getErrorDecoder());
builder.errorDecoder(errorDecoder);
}
if (config.getRequestInterceptors() != null && !config.getRequestInterceptors().isEmpty()) {
// this will add request interceptor to builder, not replace existing
for (Class<RequestInterceptor> bean : config.getRequestInterceptors()) {
RequestInterceptor interceptor = getOrInstantiate(bean);
builder.requestInterceptor(interceptor);
}
}
if (config.getDecode404() != null) {
if (config.getDecode404()) {
builder.decode404();
}
}
}
③ configureUsingProperties(properties.getConfig().get(this.name), builder);作用是應用當前Feign應用特有的屬性配置，可配置的屬性與上面一樣，但是屬性類放入config屬性Map的key為Feign接口應用的名稱
④ properties.isDefaultToProperties()，defaultToProperties的默認值為true,如果為true,則應用配置的順序是先應用屬性類的key和自己應用一樣名稱的配置，然后再應用default的配置，最后應用配置類的屬性；而如果這個屬性的值為false,則應用順序正好相反
⑤ feign()方法執(zhí)行完成之后，回到getObject()方法，該類的type屬性是每個標注了@FeignClient接口類，判斷注解中是否明確了url地址，如果沒有的話，下面判斷來定義url的規(guī)則為http://name/path即服務名和注解指定的path屬性，即應用的ContextPath和每個接口類的具體實現(xiàn)類的@RequestMapping，new HardCodedTarget<>(this.type, this.name, url)生成調用目標地址信息的代理類
1.8 FeignRibbonClientAutoConfiguration
該類位于Feign包下的ribbon包下，F(xiàn)eign的負載均衡是基于ribbon的，該類的全路徑為org.springframework.cloud.netflix.feign.ribbon.FeignRibbonClientAutoConfiguration，
該類代碼如下：
@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@Configuration
@AutoConfigureBefore(FeignAutoConfiguration.class)
@EnableConfigurationProperties({ FeignHttpClientProperties.class })
//Order is important here, last should be the default, first should be optional
// see https://github.com/spring-cloud/spring-cloud-netflix/issues/2086#issuecomment-316281653
@Import({ HttpClientFeignLoadBalancedConfiguration.class,
OkHttpFeignLoadBalancedConfiguration.class,
DefaultFeignLoadBalancedConfiguration.class })
public class FeignRibbonClientAutoConfiguration {
@Bean
@Primary
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
public CachingSpringLoadBalancerFactory cachingLBClientFactory(
SpringClientFactory factory) {
return new CachingSpringLoadBalancerFactory(factory);
}
@Bean
@Primary
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
public CachingSpringLoadBalancerFactory retryabeCachingLBClientFactory(
SpringClientFactory factory,
LoadBalancedRetryPolicyFactory retryPolicyFactory,
LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
return new CachingSpringLoadBalancerFactory(factory, retryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
}
@Bean
@ConditionalOnMissingBean
public Request.Options feignRequestOptions() {
return LoadBalancerFeignClient.DEFAULT_OPTIONS;
}
}
① 先看方法feignRequestOptions()， @ConditionalOnMissingBean注解，如果當前項目中還沒有Request.Options這個Bean則注入這個Bean，屬于默認配置，可以看到如果自定義這個Bean的注入，則這里的代碼會失效。然后參考上一節(jié)的FeignClientFactoryBean的configureUsingConfiguration()方法，則我們注入的bean會生效。來看一下系統(tǒng)的默認配置，可以看到最終請求Request.Options.的 connectTimeoutMillis的默認值為10 * 1000， readTimeoutMillis的默認值為60 * 1000
@Bean
@ConditionalOnMissingBean
public Request.Options feignRequestOptions() {
return LoadBalancerFeignClient.DEFAULT_OPTIONS;
}
// 如上方法指向了這里
public class LoadBalancerFeignClient implements Client {
static final Request.Options DEFAULT_OPTIONS = new Request.Options();
}
// 如上方法指向了這里
public final class Request {
public static class Options {
private final int connectTimeoutMillis;
private final int readTimeoutMillis;
public Options(int connectTimeoutMillis, int readTimeoutMillis) {
this.connectTimeoutMillis = connectTimeoutMillis;
this.readTimeoutMillis = readTimeoutMillis;
}
public Options() {
this(10 * 1000, 60 * 1000);
}
}
1.9 LoadBalancerFeignClient
客戶端調用Feign接口通過反射最終執(zhí)行如下方法
@Override
public Response execute(Request request, Request.Options options) throws IOException {
try {
URI asUri = URI.create(request.url());
String clientName = asUri.getHost();
URI uriWithoutHost = cleanUrl(request.url(), clientName);
FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
this.delegate, request, uriWithoutHost);
IClientConfig requestConfig = getClientConfig(options, clientName);
return lbClient(clientName).executeWithLoadBalancer(ribbonRequest,
requestConfig).toResponse();
}
catch (ClientException e) {
IOException io = findIOException(e);
if (io != null) {
throw io;
}
throw new RuntimeException(e);
}
}
request包含當前請求信息url,head,body，charset，如下圖
options包含連接connectTimeoutMillis和readTimeoutMillis，這個在前面已經看到默認分別是10000和60000,關于如何zi自定義配置前面也已經說過
方法體內代碼asUri為完整請求地址，包含請求協(xié)議://服務名/服務上下文/請求映射路徑+參數(shù),clientName為解析請求中的服務名,uriWithoutHost解析請求地址去除服務名,下一步構建FeignLoadBalancer.RibbonRequest對象ribbonRequest，其中this.delegate的類型為feign.Client，默認使用的是它的實現(xiàn)類Client.Default，構建步驟具體為下，直接貼代碼看一眼就行,其中Uri往下看似乎已經是經過UTF-8編碼過了，但是body沒有經過編碼,總體而言該對象包含了當前請求所需要的重要信息 this.delegate的賦值通過以下類指定
@Configuration
class DefaultFeignLoadBalancedConfiguration {
@Bean
@ConditionalOnMissingBean
public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
SpringClientFactory clientFactory) {
return new LoadBalancerFeignClient(new Client.Default(null, null),
cachingFactory, clientFactory);
}
}
構建Request請求信息
RibbonRequest(Client client, Request request, URI uri) {
this.client = client;
setUri(uri);
this.request = toRequest(request);
}
private Request toRequest(Request request) {
Map<String, Collection<String>> headers = new LinkedHashMap<>(
request.headers());
return Request.create(request.method(),getUri().toASCIIString(),headers,request.body(),request.charset());
}
下面來看下面的代碼調用了一個方法getClientConfig(),可以看到這里配置IClientConfig對象的時候如果options使用的是系統(tǒng)默認的對象時，則會觸發(fā)方法getClientConfig(),而如果不是由系統(tǒng)默認的這個對象，而是我們自己自定義注入過這個對象（無論是配置類還是配置文件），則會觸發(fā)代碼new FeignOptionsClientConfig(options);
IClientConfig requestConfig = getClientConfig(options, clientName);
// 方法內部
IClientConfig getClientConfig(Request.Options options, String clientName) {
IClientConfig requestConfig;
if (options == DEFAULT_OPTIONS) {
requestConfig = this.clientFactory.getClientConfig(clientName);
} else {
requestConfig = new FeignOptionsClientConfig(options);
}
return requestConfig;
}
先看簡單的requestConfig = new FeignOptionsClientConfig(options);該方法內部如下，則可以看到最終IClientConfig 對象只會有兩個屬性，一個CommonClientConfigKey.ConnectTimeout，一個CommonClientConfigKey.ReadTimeout，而且兩個值的屬性使我們自定義的；
public FeignOptionsClientConfig(Request.Options options) {
setProperty(CommonClientConfigKey.ConnectTimeout,
options.connectTimeoutMillis());
setProperty(CommonClientConfigKey.ReadTimeout, options.readTimeoutMillis());
}
現(xiàn)在來看如果沒有修改過默認的請求屬性options == DEFAULT_OPTIONS，這一塊看的有點暈乎，在之前看到Feign如果沒有任何配置，系統(tǒng)已經默認了connectTimeoutMillis和readTimeoutMillis，這個在前面已經看到默認分別是10000和60000，但是代碼在這里處理判斷如果使用的是默認的,加載的屬性列表如下，會對之前所有的默認操作進行覆蓋
2.0 FeignLoadBalancer
@Override
public RibbonResponse execute(RibbonRequest request, IClientConfig configOverride)
throws IOException {
Request.Options options;
if (configOverride != null) {
options = new Request.Options(
configOverride.get(CommonClientConfigKey.ConnectTimeout,
this.connectTimeout),
(configOverride.get(CommonClientConfigKey.ReadTimeout,
this.readTimeout)));
}
else {
options = new Request.Options(this.connectTimeout, this.readTimeout);
}
Response response = request.client().execute(request.toRequest(), options);
return new RibbonResponse(request.getUri(), response);
}
如果在之前沒有對Feign進行過任何配置，那么這里就會加載默認的屬性，一旦加載默認的屬性，則目前調試下來會有40個屬性，默認的ReadTimeout=1000, ConnectTimeout=1000,如下圖所示
如果我們自定義過當前請求Feign的屬性，那么IClientConfig對象則會有我們設置的屬性以及值，比如我們設置了如下配置則，當前configOverride就會有這兩個屬性的值，而不是默認的40個。目前還沒搞清楚其余字段的意思
feign:
client:
config:
default:
readTimeout: 3333
connectTimeout: 4444
依然是上面的execute()方法，代碼從入參之后繼續(xù)往下走，現(xiàn)在看到new 了一個新的Request.Options對象，下面判斷configOverride是否為空，經過上面的描述，這個對象不為空，如果我們自定義過，則會有兩個屬性，如果沒有自定義過，則會有默認的屬性，通過configOverride來構建Request.Options對象的代碼，可以看到其實僅僅用到了ConnectTimeout和ReadTimeout兩個屬性，然后調用Request.Options的構造方法來進行賦值，構造方法如下：
public Options(int connectTimeoutMillis, int readTimeoutMillis) {
this.connectTimeoutMillis = connectTimeoutMillis;
this.readTimeoutMillis = readTimeoutMillis;
}
自此Request.Options對象的兩個屬性connectTimeoutMillis和readTimeoutMillis的屬性處理完成
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。
相關文章
maven父子工程多模塊統(tǒng)一管理版本號的解決方法
maven父子工程多模塊,每個模塊還都可以獨立存在,子模塊往往通常希望和父工程保持一樣的版本,如果每個工程單獨定義版本號,后期變更打包也非常麻煩,,所以本文給大家介紹了maven父子工程多模塊如何管理統(tǒng)一的版本號,需要的朋友可以參考下2024-09-09
RocketMQ NameServer保障數(shù)據一致性實現(xiàn)方法講解
這篇文章主要介紹了RocketMQ NameServer保障數(shù)據一致性實現(xiàn)方法，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-12-12
這篇文章主要介紹了Spring面向切面編程AOP詳情，文章圍繞主題展開詳細的內容介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-09-09
springboot使用com.github.binarywang包實現(xiàn)微信網頁上的支付和退款
最近做項目需要實現(xiàn)在pc端需要實現(xiàn)微信的支付,本文主要介紹了springboot使用com.github.binarywang包實現(xiàn)微信網頁上的支付和退款,具有一定的參考價值,感興趣的可以了解一下2024-05-05
在使用maven進行Java項目的開發(fā)過程中，難免會有些公共的私有庫，這些庫是不太方便放到中央倉庫的，可以通過Nexus搭建一個私有倉庫，這篇文章主要介紹了maven私服搭建與使用,需要的朋友可以參考下2023-03-03
簡單講解在Java編程中實現(xiàn)設計模式中的單例模式結構
這篇文章主要介紹了簡單講解在Java編程中實現(xiàn)設計模式中的單例模式結構,設計模式是最基本直白簡單的一種設計模式,需要的朋友可以參考下2016-04-04
這篇文章主要介紹了springboot讀取文件,打成jar包后訪問不到的解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-07-07
Spring boot搭建web應用集成thymeleaf模板實現(xiàn)登陸
這篇文章主要介紹了Spring boot搭建web應用集成thymeleaf模板實現(xiàn)登陸，頁面使用bootstrap，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-12-12
在使用MyBatis進行條件判斷時,如果條件中涉及到字符與數(shù)字的比較,需要特別注意比較方式,例如,在<if>標簽中,比較數(shù)字“1”時,應將其寫在雙引號中,或者使用.toString()方法,避免直接使用字符'1'進行比較2024-11-11
下面小編就為大家?guī)硪黄斦凩ock與synchronized 的區(qū)別。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-05-05