Switch Javadoc <code>...</code> to {@code ...}

Update Javadoc to use the {@code ...} syntax when possible.

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/autoconfigure/CrshAutoConfiguration.java

@@ -86,17 +86,16 @@ import org.springframework.util.StringUtils;
  * The default shell authentication method uses a username and password combination. If no
  * configuration is provided the default username is 'user' and the password will be
  * printed to console during application startup. Those default values can be overridden
- * by using <code>shell.auth.simple.username</code> and
- * <code>shell.auth.simple.password</code>.
+ * by using {@code shell.auth.simple.username} and {@code shell.auth.simple.password}.
  * <p>
  * If a Spring Security {@link AuthenticationManager} is detected, this configuration will
  * create a {@link CRaSHPlugin} to forward shell authentication requests to Spring
- * Security. This authentication method will get enabled if <code>shell.auth</code> is set
- * to <code>spring</code> or if no explicit <code>shell.auth</code> is provided and a
+ * Security. This authentication method will get enabled if {@code shell.auth} is set to
+ * {@code spring} or if no explicit {@code shell.auth} is provided and a
  * {@link AuthenticationManager} is available. In the latter case shell access will be
  * restricted to users having roles that match those configured in
  * {@link ManagementServerProperties}. Required roles can be overridden by
- * <code>shell.auth.spring.roles</code>.
+ * {@code shell.auth.spring.roles}.
  * <p>
  * To add customizations to the shell simply define beans of type {@link CRaSHPlugin} in
  * the application context. Those beans will get auto detected during startup and
@@ -106,9 +105,9 @@ import org.springframework.util.StringUtils;
  * <p>
  * Additional shell commands can be implemented using the guide and documentation at <a
  * href="http://www.crashub.org">crashub.org</a>. By default Boot will search for commands
- * using the following classpath scanning pattern <code>classpath*:/commands/**</code>. To
- * add different locations or override the default use
- * <code>shell.command_path_patterns</code> in your application configuration.
+ * using the following classpath scanning pattern {@code classpath*:/commands/**}. To add
+ * different locations or override the default use {@code shell.command_path_patterns} in
+ * your application configuration.
  *
  * @author Christian Dupuis
  * @see ShellProperties

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/autoconfigure/JolokiaAutoConfiguration.java

@@ -40,11 +40,11 @@ import org.springframework.context.annotation.Configuration;
  * <p>
  * This configuration will get automatically enabled as soon as the Jolokia
  * {@link AgentServlet} is on the classpath. To disable it set
- * <code>endpoints.jolokia.enabled: false</code> or <code>endpoints.enabled: false</code>.
+ * {@code endpoints.jolokia.enabled: false} or {@code endpoints.enabled: false}.
  *
  * <p>
  * Additional configuration parameters for Jolokia can be provided by specifying
- * <code>jolokia.config.*</code> properties. See the <a
+ * {@code jolokia.config.*} properties. See the <a
  * href="http://jolokia.org">http://jolokia.org</a> web site for more information on
  * supported configuration parameters.
  *

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/autoconfigure/MetricRepositoryAutoConfiguration.java

@@ -63,12 +63,12 @@ import com.codahale.metrics.MetricRegistry;
  * {@link MetricRegistry} will be created and the default counter and gauge services will
  * switch to using it instead of the default repository. Users can create "special"
  * Dropwizard metrics by prefixing their metric names with the appropriate type (e.g.
- * "histogram.*", "meter.*". "timer.*") and sending them to the <code>GaugeService</code>
- * or <code>CounterService</code>.
+ * "histogram.*", "meter.*". "timer.*") and sending them to the {@code GaugeService} or
+ * {@code CounterService}.
  * <p>
  * By default all metric updates go to all {@link MetricWriter} instances in the
  * application context via a {@link MetricCopyExporter} firing every 5 seconds (disable
- * this by setting <code>spring.metrics.export.enabled=false</code>).
+ * this by setting {@code spring.metrics.export.enabled=false}).
  *
  * @see GaugeService
  * @see CounterService

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/ConfigurationPropertiesReportEndpoint.java

@@ -64,8 +64,8 @@ import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
  * <p>
  * To protect sensitive information from being exposed, certain property values are masked
  * if their names end with a set of configurable values (default "password" and "secret").
- * Configure property names by using <code>endpoints.configprops.keys_to_sanitize</code>
- * in your Spring Boot application configuration.
+ * Configure property names by using {@code endpoints.configprops.keys_to_sanitize} in
+ * your Spring Boot application configuration.
  *
  * @author Christian Dupuis
  * @author Dave Syer

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/endpoint/mvc/MvcEndpoint.java

@@ -20,10 +20,10 @@ import org.springframework.boot.actuate.endpoint.Endpoint;
 
 /**
  * A strategy for the MVC layer on top of an {@link Endpoint}. Implementations are allowed
- * to use <code>@RequestMapping</code> and the full Spring MVC machinery, but should not
- * use <code>@Controller</code> or <code>@RequestMapping</code> at the type level (since
- * that would lead to a double mapping of paths, once by the regular MVC handler mappings
- * and once by the {@link EndpointHandlerMapping}).
+ * to use {@code @RequestMapping} and the full Spring MVC machinery, but should not use
+ * {@code @Controller} or {@code @RequestMapping} at the type level (since that would lead
+ * to a double mapping of paths, once by the regular MVC handler mappings and once by the
+ * {@link EndpointHandlerMapping}).
  *
  * @author Dave Syer
  */

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/Health.java

@@ -184,7 +184,7 @@ public final class Health {
 		}
 
 		/**
-		 * Create new Builder instance, setting status to given <code>status</code>.
+		 * Create new Builder instance, setting status to given {@code status}.
 		 * @param status the {@link Status} to use
 		 */
 		public Builder(Status status) {
@@ -194,8 +194,8 @@ public final class Health {
 		}
 
 		/**
-		 * Create new Builder instance, setting status to given <code>status</code> and
-		 * details to given <code>details</code>.
+		 * Create new Builder instance, setting status to given {@code status} and details
+		 * to given {@code details}.
 		 * @param status the {@link Status} to use
 		 * @param details the details {@link Map} to use
 		 */
@@ -217,7 +217,7 @@ public final class Health {
 		}
 
 		/**
-		 * Record detail using <code>key</code> and <code>value</code>.
+		 * Record detail using {@code key} and {@code value}.
 		 * @param key the detail key
 		 * @param data the detail data
 		 * @return this {@link Builder} instance
@@ -271,7 +271,7 @@ public final class Health {
 		}
 
 		/**
-		 * Set status to given <code>statusCode</code>.
+		 * Set status to given {@code statusCode}.
 		 * @param statusCode the status code
 		 * @return this {@link Builder} instance
 		 */

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/jmx/DefaultMetricNamingStrategy.java

@@ -26,11 +26,11 @@ import org.springframework.jmx.export.naming.ObjectNamingStrategy;
 import org.springframework.util.StringUtils;
 
 /**
- * MBean naming strategy for metric keys. A metric name of
- * <code>counter.foo.bar.spam</code> translates to an object name with
- * <code>type=counter</code>, <code>name=foo</code> and <code>value=bar.spam</code>. This
- * results in a more or less pleasing view with no tweaks in jconsole or jvisualvm. The
- * domain is copied from the input key and the type in the input key is discarded.
+ * MBean naming strategy for metric keys. A metric name of {@code counter.foo.bar.spam}
+ * translates to an object name with {@code type=counter}, {@code name=foo} and
+ * {@code value=bar.spam}. This results in a more or less pleasing view with no tweaks in
+ * jconsole or jvisualvm. The domain is copied from the input key and the type in the
+ * input key is discarded.
  *
  * @author Dave Syer
  * @since 1.3.0

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/jmx/JmxMetricWriter.java

@@ -38,8 +38,8 @@ import org.springframework.jmx.export.naming.ObjectNamingStrategy;
  * A {@link MetricWriter} for MBeans. Each metric is registered as an individual MBean, so
  * (for instance) it can be graphed and monitored. The object names are provided by an
  * {@link ObjectNamingStrategy}, where the default is a
- * {@link DefaultMetricNamingStrategy} which provides <code>type</code>, <code>name</code>
- * and <code>value</code> keys by splitting up the metric name on periods.
+ * {@link DefaultMetricNamingStrategy} which provides {@code type}, {@code name} and
+ * {@code value} keys by splitting up the metric name on periods.
  *
  * @author Dave Syer
  * @since 1.3.0

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/repository/redis/RedisMultiMetricRepository.java

@@ -35,7 +35,7 @@ import org.springframework.util.Assert;
  * {@link MultiMetricRepository} implementation backed by a redis store. Metric values are
  * stored as zset values and the timestamps as regular values, both against a key composed
  * of the group name prefixed with a constant prefix (default "spring.groups."). The group
- * names are stored as a zset under "keys." + <code>[prefix]</code>.
+ * names are stored as a zset under "keys." + {@code [prefix]}.
  *
  * @author Dave Syer
  */

spring-boot-actuator/src/main/java/org/springframework/boot/actuate/metrics/writer/PrefixMetricWriter.java

@@ -38,7 +38,7 @@ public interface PrefixMetricWriter {
 
 	/**
 	 * Increment the value of a metric (or decrement if the delta is negative). The name
-	 * of the metric to increment is <code>group + "." + delta.name</code>.
+	 * of the metric to increment is {@code group + "." + delta.name}.
 	 * @param group the name of the group
 	 * @param delta the amount to increment by
 	 */

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/flyway/FlywayDataSource.java

@@ -26,7 +26,7 @@ import org.springframework.beans.factory.annotation.Qualifier;
 
 /**
  * Qualifier annotation for a DataSource to be injected in to Flyway. If used for a second
- * data source, the other (main) one would normally be marked as <code>@Primary</code>.
+ * data source, the other (main) one would normally be marked as {@code @Primary}.
  *
  * @author Dave Syer
  * @since 1.1.0

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceBuilder.java

@@ -33,7 +33,7 @@ import org.springframework.util.ClassUtils;
  * and so that there can be a fallback to an embedded database if one can be detected on
  * the classpath, only a small set of common configuration properties are supported. To
  * inject additional properties into the result you can downcast it, or use
- * <code>@ConfigurationProperties</code>.
+ * {@code @ConfigurationProperties}.
  *
  * @author Dave Syer
  * @since 1.1.0

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jmx/JmxAutoConfiguration.java

@@ -45,7 +45,7 @@ import org.springframework.util.StringUtils;
  * {@link EnableAutoConfiguration Auto-configuration} to enable/disable Spring's
  * {@link EnableMBeanExport} mechanism based on configuration properties.
  * <p>
- * To disable auto export of annotation beans set <code>spring.jmx.enabled: false</code>.
+ * To disable auto export of annotation beans set {@code spring.jmx.enabled: false}.
  *
  * @author Christian Dupuis
  */

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/orm/jpa/EntityManagerFactoryBuilder.java

@@ -34,7 +34,7 @@ import org.springframework.util.ClassUtils;
  * {@link LocalContainerEntityManagerFactoryBean} through a fluent builder pattern. The
  * most common options are covered in the builder, but you can always manipulate the
  * product of the builder if you need more control, before returning it from a
- * <code>@Bean</code> definition.
+ * {@code @Bean} definition.
  *
  * @author Dave Syer
  * @since 1.1.0
@@ -97,7 +97,7 @@ public class EntityManagerFactoryBuilder {
 		}
 
 		/**
-		 * The names of packages to scan for <code>@Entity</code> annotations.
+		 * The names of packages to scan for {@code @Entity} annotations.
 		 * @param packagesToScan packages to scan
 		 * @return the builder for fluent usage
 		 */
@@ -107,8 +107,7 @@ public class EntityManagerFactoryBuilder {
 		}
 
 		/**
-		 * The classes whose packages should be scanned for <code>@Entity</code>
-		 * annotations.
+		 * The classes whose packages should be scanned for {@code @Entity} annotations.
 		 * @param basePackageClasses the classes to use
 		 * @return the builder for fluent usage
 		 */

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/security/FallbackWebSecurityAutoConfiguration.java

@@ -28,10 +28,10 @@ import org.springframework.security.config.annotation.web.configuration.WebSecur
 
 /**
  * If the user explicitly disables the basic security features and forgets to
- * <code>@EnableWebSecurity</code>, and yet still wants a bean of type
+ * {@code @EnableWebSecurity}, and yet still wants a bean of type
  * WebSecurityConfigurerAdapter, he is trying to use a custom security setup. The app
  * would fail in a confusing way without this shim configuration, which just helpfully
- * defines an empty <code>@EnableWebSecurity</code>.
+ * defines an empty {@code @EnableWebSecurity}.
  *
  * @author Dave Syer
  */

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/security/SecurityAutoConfiguration.java

@@ -37,9 +37,9 @@ import org.springframework.security.config.annotation.web.configuration.WebSecur
  * random and printed on the console at INFO level during startup. In a webapp this
  * configuration also secures all web endpoints (except some well-known static resource)
  * locations with HTTP basic security. To replace all the default behaviour in a webapp
- * provide a <code>@Configuration</code> with <code>@EnableWebSecurity</code>. To just add
- * your own layer of application security in front of the defaults, add a
- * <code>@Configuration</code> of type {@link WebSecurityConfigurerAdapter}.
+ * provide a {@code @Configuration} with {@code @EnableWebSecurity}. To just add your own
+ * layer of application security in front of the defaults, add a {@code @Configuration} of
+ * type {@link WebSecurityConfigurerAdapter}.
  *
  * @author Dave Syer
  * @author Andy Wilkinson

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/security/SpringBootWebSecurityConfiguration.java

@@ -67,17 +67,16 @@ import org.springframework.web.servlet.support.RequestDataValueProcessor;
  * ). Many aspects of the behavior can be controller with {@link SecurityProperties} via
  * externalized application properties (or via an bean definition of that type to set the
  * defaults). The user details for authentication are just placeholders
- * <code>(username=user,
- * password=password)</code> but can easily be customized by providing a bean definition
- * of type {@link AuthenticationManager}. Also provides audit logging of authentication
- * events.
+ * {@code (username=user, password=password)} but can easily be customized by providing a
+ * bean definition of type {@link AuthenticationManager}. Also provides audit logging of
+ * authentication events.
  * <p>
  * Some common simple customizations:
  * <ul>
  * <li>Switch off security completely and permanently: remove Spring Security from the
  * classpath or {@link EnableAutoConfiguration#exclude() exclude} this configuration.</li>
  * <li>Switch off security temporarily (e.g. for a dev environment): set
- * <code>security.basic.enabled: false</code></li>
+ * {@code security.basic.enabled: false}</li>
  * <li>Customize the user details: add an AuthenticationManager bean</li>
  * <li>Add form login for user facing resources: add a
  * {@link WebSecurityConfigurerAdapter} and use {@link HttpSecurity#formLogin()}</li>

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/security/oauth2/client/OAuth2RestOperationsConfiguration.java

@@ -130,7 +130,7 @@ public class OAuth2RestOperationsConfiguration {
 	 * When the authentication is per cookie but the stored token is an oauth2 one, we can
 	 * pass that on to a client that wants to call downstream. We don't even need an
 	 * OAuth2ClientContextFilter until we need to refresh the access token. To handle
-	 * refresh tokens you need to <code>@EnableOAuth2Client</code>
+	 * refresh tokens you need to {@code @EnableOAuth2Client}
 	 */
 	@Configuration
 	@ConditionalOnMissingBean(OAuth2ClientConfiguration.class)

spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/security/oauth2/client/OAuth2SsoCustomConfiguration.java

@@ -42,7 +42,7 @@ import org.springframework.util.ReflectionUtils;
 /**
  * Configuration for OAuth2 Single Sign On (SSO) when there is an existing
  * {@link WebSecurityConfigurerAdapter} provided by the user and annotated with
- * <code>@EnableOAuth2Sso</code>. The user-provided configuration is enhanced by adding an
+ * {@code @EnableOAuth2Sso}. The user-provided configuration is enhanced by adding an
  * authentication filter and an authentication entry point.
  *
  * @author Dave Syer

spring-boot-cli/src/main/java/org/springframework/boot/cli/compiler/AstUtils.java

@@ -138,7 +138,7 @@ public abstract class AstUtils {
 	}
 
 	/**
-	 * Extract a top-level <code>name</code> closure from inside this block if there is
+	 * Extract a top-level {@code name} closure from inside this block if there is
 	 * one, optionally removing it from the block at the same time.
 	 * @param block a block statement (class definition)
 	 * @param name the name to look for

spring-boot-cli/src/main/java/org/springframework/boot/cli/compiler/GroovyCompiler.java

@@ -55,7 +55,7 @@ import org.springframework.core.annotation.AnnotationAwareOrderComparator;
  * features:
  * <ul>
  * <li>{@link CompilerAutoConfiguration} strategies will be read from
- * <code>META-INF/services/org.springframework.boot.cli.compiler.CompilerAutoConfiguration</code>
+ * {@code META-INF/services/org.springframework.boot.cli.compiler.CompilerAutoConfiguration}
  * (per the standard java {@link ServiceLoader} contract) and applied during compilation</li>
  *
  * <li>Multiple classes can be returned if the Groovy source defines more than one Class</li>

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/PropertiesLauncher.java

@@ -52,21 +52,21 @@ import org.springframework.boot.loader.util.SystemPropertyUtils;
  * well-behaved OS-level services than a model based on executable jars.
  * <p>
  * Looks in various places for a properties file to extract loader settings, defaulting to
- * <code>application.properties</code> either on the current classpath or in the current
+ * {@code application.properties} either on the current classpath or in the current
  * working directory. The name of the properties file can be changed by setting a System
- * property <code>loader.config.name</code> (e.g. <code>-Dloader.config.name=foo</code>
- * will look for <code>foo.properties</code>. If that file doesn't exist then tries
- * <code>loader.config.location</code> (with allowed prefixes <code>classpath:</code> and
- * <code>file:</code> or any valid URL). Once that file is located turns it into
+ * property {@code loader.config.name} (e.g. {@code -Dloader.config.name=foo}
+ * will look for {@code foo.properties}. If that file doesn't exist then tries
+ * {@code loader.config.location} (with allowed prefixes {@code classpath:} and
+ * {@code file:} or any valid URL). Once that file is located turns it into
  * Properties and extracts optional values (which can also be provided overridden as
  * System properties in case the file doesn't exist):
  * <ul>
- * <li><code>loader.path</code>: a comma-separated list of directories to append to the
+ * <li>{@code loader.path}: a comma-separated list of directories to append to the
  * classpath (containing file resources and/or nested archives in *.jar or *.zip).
- * Defaults to <code>lib</code> (i.e. a directory in the current working directory)</li>
- * <li><code>loader.main</code>: the main method to delegate execution to once the class
+ * Defaults to {@code lib} (i.e. a directory in the current working directory)</li>
+ * <li>{@code loader.main}: the main method to delegate execution to once the class
  * loader is set up. No default, but will fall back to looking for a
- * <code>Start-Class</code> in a <code>MANIFEST.MF</code>, if there is one in
+ * {@code Start-Class} in a {@code MANIFEST.MF}, if there is one in
  * <code>${loader.home}/META-INF</code>.</li>
  * </ul>
  *
@@ -79,7 +79,7 @@ public class PropertiesLauncher extends Launcher {
 
 	/**
 	 * Properties key for main class. As a manifest entry can also be specified as
-	 * <code>Start-Class</code>.
+	 * {@code Start-Class}.
 	 */
 	public static final String MAIN = "loader.main";
 

spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/util/SystemPropertyUtils.java

@@ -167,8 +167,8 @@ public abstract class SystemPropertyUtils {
 
 	/**
 	 * Search the System properties and environment variables for a value with the
-	 * provided key. Environment variables in <code>UPPER_CASE</code> style are allowed
-	 * where System properties would normally be <code>lower.case</code>.
+	 * provided key. Environment variables in {@code UPPER_CASE} style are allowed
+	 * where System properties would normally be {@code lower.case}.
 	 * @param key the key to resolve
 	 * @param defaultValue the default value
 	 * @param text optional extra context for an error message if the key resolution fails

spring-boot/src/main/java/org/springframework/boot/bind/RelaxedDataBinder.java

@@ -124,8 +124,8 @@ public class RelaxedDataBinder extends DataBinder {
 	/**
 	 * Modify the property values so that period separated property paths are valid for
 	 * map keys. Also creates new maps for properties of map type that are null (assuming
-	 * all maps are potentially nested). The standard bracket <code>[...]</code>
-	 * dereferencing is also accepted.
+	 * all maps are potentially nested). The standard bracket {@code[...]} dereferencing
+	 * is also accepted.
 	 * @param propertyValues the property values
 	 * @param target the target object
 	 */

spring-boot/src/main/java/org/springframework/boot/cloudfoundry/VcapApplicationListener.java

@@ -60,10 +60,10 @@ import org.springframework.util.StringUtils;
  * </pre>
  *
  * These objects are flattened into properties. The VCAP_APPLICATION object goes straight
- * to <code>vcap.application.*</code> in a fairly obvious way, and the VCAP_SERVICES
- * object is unwrapped so that it is a hash of objects with key equal to the service
- * instance name (e.g. "mysql" in the example above), and value equal to that instances
- * properties, and then flattened in the same way. E.g.
+ * to {@code vcap.application.*} in a fairly obvious way, and the VCAP_SERVICES object is
+ * unwrapped so that it is a hash of objects with key equal to the service instance name
+ * (e.g. "mysql" in the example above), and value equal to that instances properties, and
+ * then flattened in the same way. E.g.
  *
  * <pre class="code">
  * vcap.application.instance_id: 2ce0ac627a6c8e47e936d829a3a47b5b

spring-boot/src/main/java/org/springframework/boot/context/FileEncodingApplicationListener.java

@@ -26,18 +26,18 @@ import org.springframework.core.Ordered;
 /**
  * An {@link ApplicationListener} that halts application startup if the system file
  * encoding does not match an expected value set in the environment. By default has no
- * effect, but if you set <code>spring.mandatory_file_encoding</code> (or some camelCase
- * or UPPERCASE variant of that) to the name of a character encoding (e.g. "UTF-8") then
- * this initializer throws an exception when the <code>file.encoding</code> System
- * property does not equal it.
+ * effect, but if you set {@code spring.mandatory_file_encoding} (or some camelCase or
+ * UPPERCASE variant of that) to the name of a character encoding (e.g. "UTF-8") then this
+ * initializer throws an exception when the {@code file.encoding} System property does not
+ * equal it.
  *
  * <p>
- * The System property <code>file.encoding</code> is normally set by the JVM in response
- * to the <code>LANG</code> or <code>LC_ALL</code> environment variables. It is used
- * (along with other platform-dependent variables keyed off those environment variables)
- * to encode JVM arguments as well as file names and paths. In most cases you can override
- * the file encoding System property on the command line (with standard JVM features), but
- * also consider setting the <code>LANG</code> environment variable to an explicit
+ * The System property {@code file.encoding} is normally set by the JVM in response to the
+ * {@code LANG} or {@code LC_ALL} environment variables. It is used (along with other
+ * platform-dependent variables keyed off those environment variables) to encode JVM
+ * arguments as well as file names and paths. In most cases you can override the file
+ * encoding System property on the command line (with standard JVM features), but also
+ * consider setting the {@code LANG} environment variable to an explicit
  * character-encoding value (e.g. "en_GB.UTF-8").
  *
  * @author Dave Syer

spring-boot/src/main/java/org/springframework/boot/context/config/AnsiOutputApplicationListener.java

@@ -25,8 +25,8 @@ import org.springframework.core.Ordered;
 
 /**
  * An {@link ApplicationListener} that configures {@link AnsiOutput} depending on the the
- * value of the property <code>spring.output.ansi.enabled</code>. See {@link Enabled} for
- * valid values.
+ * value of the property {@code spring.output.ansi.enabled}. See {@link Enabled} for valid
+ * values.
  *
  * @author Raphael von der Grün
  * @since 1.2.0

spring-boot/src/main/java/org/springframework/boot/context/embedded/AnnotationConfigEmbeddedWebApplicationContext.java

@@ -22,20 +22,19 @@ import org.springframework.context.annotation.AnnotatedBeanDefinitionReader;
 import org.springframework.context.annotation.AnnotationConfigUtils;
 import org.springframework.context.annotation.AnnotationScopeMetadataResolver;
 import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
-import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.ScopeMetadataResolver;
 import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.stereotype.Component;
 import org.springframework.util.Assert;
 import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
 
 /**
  * {@link EmbeddedWebApplicationContext} that accepts annotated classes as input - in
- * particular {@link org.springframework.context.annotation.Configuration
- * <code>@Configuration</code>}-annotated classes, but also plain
- * {@link org.springframework.stereotype.Component <code>@Component</code>} classes and
- * JSR-330 compliant classes using {@code javax.inject} annotations. Allows for
- * registering classes one by one (specifying class names as config location) as well as
- * for classpath scanning (specifying base packages as config location).
+ * particular {@link org.springframework.context.annotation.Configuration @Configuration}
+ * -annotated classes, but also plain {@link Component @Component} classes and JSR-330
+ * compliant classes using {@code javax.inject} annotations. Allows for registering
+ * classes one by one (specifying class names as config location) as well as for classpath
+ * scanning (specifying base packages as config location).
  * <p>
  * Note: In case of multiple {@code @Configuration} classes, later {@code @Bean}
  * definitions will override ones defined in earlier loaded files. This can be leveraged
@@ -72,8 +71,8 @@ public class AnnotationConfigEmbeddedWebApplicationContext extends
 	 * Create a new {@link AnnotationConfigEmbeddedWebApplicationContext}, deriving bean
 	 * definitions from the given annotated classes and automatically refreshing the
 	 * context.
-	 * @param annotatedClasses one or more annotated classes, e.g. {@link Configuration
-	 * <code>@Configuration</code>} classes
+	 * @param annotatedClasses one or more annotated classes, e.g. {@code @Configuration}
+	 * classes
 	 */
 	public AnnotationConfigEmbeddedWebApplicationContext(Class<?>... annotatedClasses) {
 		this();
@@ -148,8 +147,8 @@ public class AnnotationConfigEmbeddedWebApplicationContext extends
 	 * <p>
 	 * Calls to {@link #register} are idempotent; adding the same annotated class more
 	 * than once has no additional effect.
-	 * @param annotatedClasses one or more annotated classes, e.g. {@link Configuration
-	 * <code>@Configuration</code>} classes
+	 * @param annotatedClasses one or more annotated classes, e.g. {@code @Configuration}
+	 * classes
 	 * @see #scan(String...)
 	 * @see #refresh()
 	 */

spring-boot/src/main/java/org/springframework/boot/context/embedded/ConfigurableEmbeddedServletContainer.java

@@ -81,10 +81,10 @@ public interface ConfigurableEmbeddedServletContainer {
 
 	/**
 	 * The class name for the jsp servlet if used. If
-	 * {@link #setRegisterJspServlet(boolean) <code>registerJspServlet</code>} is true
-	 * <b>and</b> this class is on the classpath then it will be registered. Since both
-	 * Tomcat and Jetty use Jasper for their JSP implementation the default is
-	 * <code>org.apache.jasper.servlet.JspServlet</code>.
+	 * {@link #setRegisterJspServlet(boolean) registerJspServlet} is true <b>and</b> this
+	 * class is on the classpath then it will be registered. Since both Tomcat and Jetty
+	 * use Jasper for their JSP implementation the default is
+	 * {@code org.apache.jasper.servlet.JspServlet}.
 	 * @param jspServletClassName the class name for the JSP servlet if used
 	 * @deprecated in 1.3.0 in favor of {@link JspServlet#setClassName(String)}
 	 * @see #setJspServlet

spring-boot/src/main/java/org/springframework/boot/context/embedded/EmbeddedServletContainerCustomizer.java

@@ -27,7 +27,7 @@ import org.springframework.beans.factory.config.BeanPostProcessor;
  * {@link EmbeddedServletContainerCustomizerBeanPostProcessor} which is a
  * {@link BeanPostProcessor} (so called very early in the ApplicationContext lifecycle).
  * It might be safer to lookup dependencies lazily in the enclosing BeanFactory rather
- * than injecting them with <code>@Autowired</code>.
+ * than injecting them with {@code @Autowired}.
  *
  * @author Dave Syer
  * @see EmbeddedServletContainerCustomizerBeanPostProcessor

spring-boot/src/main/java/org/springframework/boot/context/properties/ConfigurationBeanFactoryMetaData.java

@@ -31,8 +31,8 @@ import org.springframework.util.ReflectionUtils;
 import org.springframework.util.ReflectionUtils.MethodCallback;
 
 /**
- * Utility class to memorize <code>@Bean</code> definition meta data during initialization
- * of the bean factory.
+ * Utility class to memorize {@code @Bean} definition meta data during initialization of
+ * the bean factory.
  *
  * @author Dave Syer
  * @since 1.1.0

spring-boot/src/main/java/org/springframework/boot/test/SpringApplicationContextLoader.java

@@ -62,8 +62,8 @@ import org.springframework.web.context.support.GenericWebApplicationContext;
  * {@code @WebAppConfiguration}) to indicate that you want to use a real servlet container
  * or {@code @WebAppConfiguration} alone to use a {@link MockServletContext}.
  * <p>
- * If <code>@ActiveProfiles</code> are provided in the test class they will be used to
- * create the application context.
+ * If {@code @ActiveProfiles} are provided in the test class they will be used to create
+ * the application context.
  *
  * @author Dave Syer
  * @author Phillip Webb