Spring/spring-boot
Spring/spring-boot
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-boot.git synced 2024-08-29 03:06:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Update Javadoc to use the {@code ...} syntax when possible.
This commit is contained in:
Phillip Webb 2015-06-05 10:10:34 -07:00
parent 6230d905c6
commit 7609c43685
32 changed files with 100 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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

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

@ -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.
*

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

@ -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

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

@ -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

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

@ -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
*/

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

@ -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
*/

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

@ -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

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

@ -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

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

@ -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
*/

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

@ -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
*/

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

@ -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

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

@ -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

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

@ -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
*/

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

@ -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
*/

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

@ -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
*/

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

@ -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

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

@ -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>

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

@ -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)

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

@ -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

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

@ -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

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

@ -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>

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

@ -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";

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

@ -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

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

@ -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
*/

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

@ -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

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

@ -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

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

@ -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

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

@ -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()
*/

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

@ -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

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

@ -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

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

@ -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

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

@ -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