SpringBoot升级到2.7.18后不兼容的地方及解决

private boolean allowcircularreferences;

/**
 * sets whether to allow circular references between beans and automatically try to
 * resolve them. defaults to {@code false}.
 * @param allowcircularreferences if circular references are allowed
 * @since 2.6.0
 * @see abstractautowirecapablebeanfactory#setallowcircularreferences(boolean)
 */
public void setallowcircularreferences(boolean allowcircularreferences) {
	this.allowcircularreferences = allowcircularreferences;
}

beandefinition existingdefinition = this.beandefinitionmap.get(beanname);
if (existingdefinition != null) {
	if (!isallowbeandefinitionoverriding()) {
		throw new beandefinitionoverrideexception(beanname, beandefinition, existingdefinition);
	}
	
  // ...
	this.beandefinitionmap.put(beanname, beandefinition);
}

private boolean allowbeandefinitionoverriding;

/**
 * sets if bean definition overriding, by registering a definition with the same name
 * as an existing definition, should be allowed. defaults to {@code false}.
 * @param allowbeandefinitionoverriding if overriding is allowed
 * @since 2.1.0
 * @see defaultlistablebeanfactory#setallowbeandefinitionoverriding(boolean)
 */
public void setallowbeandefinitionoverriding(boolean allowbeandefinitionoverriding) {
	this.allowbeandefinitionoverriding = allowbeandefinitionoverriding;
}

**spring.mvc.pathmatch.matching-strategy=***ant_path_matcher*

/**
	 * validate that when {@link #setallowcredentials allowcredentials} is {@code true},
	 * {@link #setallowedorigins allowedorigins} does not contain the special
	 * value {@code "*"} since in that case the "access-control-allow-origin"
	 * cannot be set to {@code "*"}.
	 * @throws illegalargumentexception if the validation fails
	 * @since 5.3
	 */
	public void validateallowcredentials() {
		if (this.allowcredentials == boolean.true &&
				this.allowedorigins != null && this.allowedorigins.contains(all)) {

			throw new illegalargumentexception(
					"when allowcredentials is true, allowedorigins cannot contain the special value \\"*\\" " +
							"since that cannot be set on the \\"access-control-allow-origin\\" response header. " +
							"to allow credentials to a set of origins, list them explicitly " +
							"or consider using \\"allowedoriginpatterns\\" instead.");
		}
	}

@configuration
public class corsconfig implements webmvcconfigurer {

    @override
    public void addcorsmappings(corsregistry registry) {
        registry.addmapping("/**")    // 允许跨域访问的路径
                .allowedoriginpatterns("*")    // 允许跨域访问的源
    }
}

/**
 * alternative to {@link #setallowedorigins} that supports more flexible
 * origins patterns with "*" anywhere in the host name in addition to port
 * lists. examples:
 * <ul>
 * <li>{@literal https://*.domain1.com} -- domains ending with domain1.com
 * <li>{@literal https://*.domain1.com:[8080,8081]} -- domains ending with
 * domain1.com on port 8080 or port 8081
 * <li>{@literal https://*.domain1.com:[*]} -- domains ending with
 * domain1.com on any port, including the default port
 * </ul>
 * <p>in contrast to {@link #setallowedorigins(list) allowedorigins} which
 * only supports "*" and cannot be used with {@code allowcredentials}, when
 * an allowedoriginpattern is matched, the {@code access-control-allow-origin}
 * response header is set to the matched origin and not to {@code "*"} nor
 * to the pattern. therefore allowedoriginpatterns can be used in combination
 * with {@link #setallowcredentials} set to {@code true}.
 * <p>by default this is not set.
 * @since 5.3
 */
public corsconfiguration setallowedoriginpatterns(@nullable list<string> allowedoriginpatterns) {
	if (allowedoriginpatterns == null) {
		this.allowedoriginpatterns = null;
	}
	else {
		this.allowedoriginpatterns = new arraylist<>(allowedoriginpatterns.size());
		for (string patternvalue : allowedoriginpatterns) {
			addallowedoriginpattern(patternvalue);
		}
	}
	return this;
}

// 5.3之前
@override
public boolean isreadable() {
	try {
		url url = geturl();
    // file/vfsfile/vfs开头的url
		if (resourceutils.isfileurl(url)) {
			// proceed with file system resolution
			file file = getfile();
			return (file.canread() && !file.isdirectory());
		}
		else {
			return true;
		}
	}
	catch (ioexception ex) {
		return false;
	}
}

@override
public boolean isreadable() {
	url url = resolveurl();
	return (url != null && checkreadable(url));
}

boolean checkreadable(url url) {
	try {
    // file/vfsfile/vfs开头的url
		if (resourceutils.isfileurl(url)) {
			// proceed with file system resolution
			file file = getfile();
			return (file.canread() && !file.isdirectory());
		}
		else {
			// try inputstream resolution for jar resources
			urlconnection con = url.openconnection();
			customizeconnection(con);
			if (con instanceof httpurlconnection) {
				httpurlconnection httpcon = (httpurlconnection) con;
				httpcon.setrequestmethod("head");
				int code = httpcon.getresponsecode();
				if (code != httpurlconnection.http_ok) {
					httpcon.disconnect();
					return false;
				}
			}
			long contentlength = con.getcontentlengthlong();
			if (contentlength > 0) {
				return true;
			}
			else if (contentlength == 0) {
				// empty file or directory -> not considered readable...
				return false;
			}
			else {
				// fall back to stream existence: can we open the stream?
				getinputstream().close();
				return true;
			}
		}
	}
	catch (ioexception ex) {
		return false;
	}
}

/**
 * returns either {@link #getpathpatternscondition()} or
 * {@link #getpatternscondition()} depending on which is not null.
 * @since 5.3
 */
@suppresswarnings("unchecked")
public <t> requestcondition<t> getactivepatternscondition() {
	if (this.pathpatternscondition != null) {
		return (requestcondition<t>) this.pathpatternscondition;
	}
	else if (this.patternscondition != null) {
		return (requestcondition<t>) this.patternscondition;
	}
	else {
		// already checked in the constructor...
		throw new illegalstateexception();
	}
}