language stringclasses 1
value | owner stringlengths 2 15 | repo stringlengths 2 21 | sha stringlengths 45 45 | message stringlengths 7 36.3k | path stringlengths 1 199 | patch stringlengths 15 102k | is_multipart bool 2
classes |
|---|---|---|---|---|---|---|---|
Other | spring-projects | spring-framework | ab4952a959174c496a194967eb873cf119dfeab9.json | Raise RestClientException for unknown status codes
HttpStatus cannot be created with an unknown status code. If a server
returns a status code that's not in the HttpStatus enum values, an
IllegalArgumentException is raised. Rather than allowing it to
propagate as such, this change ensures the actual exception raised is
a RestClientException.
Issue: SPR-9406 | spring-web/src/test/java/org/springframework/web/client/DefaultResponseErrorHandlerTests.java | @@ -124,4 +124,16 @@ public void handleErrorNullResponse() throws Exception {
verify(response);
}
+
+ // SPR-9406
+
+ @Test(expected=RestClientException.class)
+ public void unknownStatusCode() throws Exception {
+ expect(response.getStatusCode()).andThrow(new IllegalArgumentException("No matching constant for 999"));
+ expect(response.getRawStatusCode()).andReturn(999);
+
+ replay(response);
+
+ handler.handleError(response);
+ }
} | true |
Other | spring-projects | spring-framework | ab4952a959174c496a194967eb873cf119dfeab9.json | Raise RestClientException for unknown status codes
HttpStatus cannot be created with an unknown status code. If a server
returns a status code that's not in the HttpStatus enum values, an
IllegalArgumentException is raised. Rather than allowing it to
propagate as such, this change ensures the actual exception raised is
a RestClientException.
Issue: SPR-9406 | src/dist/changelog.txt | @@ -7,7 +7,7 @@ Changes in version 3.2 M2
-------------------------
* spring-test module now depends on junit:junit-dep
-
+* raise RestClientException instead of IllegalArgumentException for unknown status codes
Changes in version 3.2 M1 (2012-05-28)
-------------------------------------- | true |
Other | spring-projects | spring-framework | 0e3a1d81764f17a9f8612d35d3971aa8f6b85134.json | Require aopalliance dependency for spring-aop
A recent commit made aopalliance optional for spring-aop, while
continuing to require it for spring-tx. On review, this is probably
overly aggressive, and for convenience aopalliance should remain
required for spring-aop. There are use cases for which aopalliance is
indeed optional, but core functionality such as <aop:scoped-proxy>
should never result in a ClassNotFoundException.
This commit returns the aopalliance dependency for spring-aop to
required status, and also explicitly notes the same dependency in other
modules that compile directly against aopalliance types.
Issue: SPR-9501 | build.gradle | @@ -168,8 +168,8 @@ project('spring-aop') {
dependencies {
compile project(":spring-core")
compile project(":spring-beans")
+ compile("aopalliance:aopalliance:1.0")
compile("com.jamonapi:jamon:2.4", optional)
- compile("aopalliance:aopalliance:1.0", optional)
compile("commons-pool:commons-pool:1.5.3", optional)
}
}
@@ -248,9 +248,9 @@ project('spring-tx') {
compile(project(":spring-aop"), optional)
compile project(":spring-beans")
compile project(":spring-core")
+ compile("aopalliance:aopalliance:1.0")
compile("com.ibm.websphere:uow:6.0.2.17", provided)
compile("javax.resource:connector-api:1.5", optional)
- compile "aopalliance:aopalliance:1.0" // NOT optional, as opposed to in :spring-aop
compile("org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1", optional)
testCompile "org.easymock:easymockclassextension:2.3"
}
@@ -287,6 +287,7 @@ project('spring-jms') {
compile project(":spring-context")
compile project(":spring-tx")
compile(project(":spring-oxm"), optional)
+ compile("aopalliance:aopalliance:1.0")
compile("org.codehaus.jackson:jackson-mapper-asl:1.4.2", optional)
}
}
@@ -346,6 +347,7 @@ project('spring-web') {
compile project(":spring-aop") // for JaxWsPortProxyFactoryBean
compile project(":spring-context")
compile(project(":spring-oxm"), optional) // for MarshallingHttpMessageConverter
+ compile("aopalliance:aopalliance:1.0")
compile("com.caucho:hessian:3.2.1", optional)
compile("rome:rome:1.0", optional)
compile("javax.el:el-api:1.0", optional)
@@ -378,6 +380,7 @@ project('spring-orm') {
dependencies {
// compiling against both hibernate 3 and 4 here in order to support
// our respective orm.hibernate3 and orm.hibernate4 packages
+ compile("aopalliance:aopalliance:1.0")
compile("org.hibernate:com.springsource.org.hibernate:3.3.1.GA", optional)
compile("org.hibernate:hibernate-core:4.1.0.Final", optional)
compile("org.hibernate:hibernate-cglib-repack:2.1_3", optional) | false |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/Spr8849Tests.java | @@ -0,0 +1,45 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.junit4.spr8849;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * Test suite to investigate claims raised in
+ * <a href="https://jira.springsource.org/browse/SPR-8849">SPR-8849</a>.
+ *
+ * <p>By using a SpEL expression to generate a random {@code id} for the
+ * embedded database (see {@code datasource-config.xml}), we ensure that each
+ * {@code ApplicationContext} that imports the common configuration will create
+ * an embedded database with a unique name (since the {@code id} is used as the
+ * database name within
+ * {@link org.springframework.jdbc.config.EmbeddedDatabaseBeanDefinitionParser#useIdAsDatabaseNameIfGiven()}).
+ *
+ * <p>To reproduce the problem mentioned in SPEX-8849, change the {@code id} of
+ * the embedded database in {@code datasource-config.xml} to "dataSource" (or
+ * anything else that is not random) and run this <em>suite</em>.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(Suite.class)
+@SuiteClasses({ TestClass1.class, TestClass2.class })
+public class Spr8849Tests {
+
+} | true |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/TestClass1-context.xml | @@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
+
+ <import resource="datasource-config.xml"/>
+
+</beans> | true |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/TestClass1.java | @@ -0,0 +1,49 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.junit4.spr8849;
+
+import javax.sql.DataSource;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+/**
+ * This name of this class intentionally does not end with "Test" or "Tests"
+ * since it should only be run as part of the test suite: {@link Spr8849Tests}.
+ *
+ * @author Mickael Leduque
+ * @author Sam Brannen
+ * @since 3.2
+ * @see Spr8849Tests
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+public class TestClass1 {
+
+ @Autowired
+ DataSource datasource;
+
+
+ @Test
+ public void dummyTest() {
+ // it's sufficient if the ApplicationContext loads without errors.
+ }
+
+}
\ No newline at end of file | true |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/TestClass2-context.xml | @@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
+
+ <import resource="datasource-config.xml"/>
+
+</beans> | true |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/TestClass2.java | @@ -0,0 +1,49 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.context.junit4.spr8849;
+
+import javax.sql.DataSource;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+/**
+ * This name of this class intentionally does not end with "Test" or "Tests"
+ * since it should only be run as part of the test suite: {@link Spr8849Tests}.
+ *
+ * @author Mickael Leduque
+ * @author Sam Brannen
+ * @since 3.2
+ * @see Spr8849Tests
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+public class TestClass2 {
+
+ @Autowired
+ DataSource dataSource;
+
+
+ @Test
+ public void dummyTest() {
+ // it's sufficient if the ApplicationContext loads without errors.
+ }
+
+}
\ No newline at end of file | true |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/datasource-config.xml | @@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:jdbc="http://www.springframework.org/schema/jdbc"
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
+ http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd">
+
+ <jdbc:embedded-database id="#{T(java.util.UUID).randomUUID().toString()}">
+ <jdbc:script location="classpath:/org/springframework/test/context/junit4/spr8849/spr8849-schema.sql" />
+ </jdbc:embedded-database>
+
+</beans> | true |
Other | spring-projects | spring-framework | 04a682729020af09c70ebbf6a210f42b8cc1c36b.json | Reproduce claims raised in SPR-8849
This commit introduces a test suite (Spr8849Tests) that demonstrates
the claims made in SPR-8849.
Specifically, if <jdbc:embedded-database id="xyz" /> is used to create
an embedded HSQL database in an XML configuration file and that
configuration file is imported in different sets of configuration files
that are used to load ApplicationContexts for different integration
tests, the embedded database will be initialized multiple times using
any nested <jdbc:script /> elements. If such a script is used to create
a table, for example, subsequent attempts to initialize the database
named "xyz" will fail since an embedded database named "xyz" already
exists in the JVM.
As a work-around, this test suite uses a SpEL expression to generate a
random string for each embedded database instance:
id="#{T(java.util.UUID).randomUUID().toString()}"
See the Javadoc in Spr8849Tests for further information.
Issue: SPR-8849 | spring-test/src/test/java/org/springframework/test/context/junit4/spr8849/spr8849-schema.sql | @@ -0,0 +1,3 @@
+CREATE TABLE enigma (
+ id INTEGER NOT NULL IDENTITY PRIMARY KEY
+); | true |
Other | spring-projects | spring-framework | 49c9a2a9157861bad53ec47b67c8d821b0b4655a.json | Use transactional connection during db population
Previously, DatabasePopulatorUtils#execute looked up a Connection from
the given DataSource directly which resulted in the executed statements
not being executed against a transactional connection (if any) which in
turn resulted in the statements executed by the populator potentially
not being rolled back.
Now DataSourceUtils#getConnection is used to transparently take part in
any active transaction and #releaseConnection is used to ensure the
connection is closed if appropriate.
Issue: SPR-9457 | spring-jdbc/src/main/java/org/springframework/jdbc/datasource/init/DatabasePopulatorUtils.java | @@ -1,5 +1,5 @@
/*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,16 +17,18 @@
package org.springframework.jdbc.datasource.init;
import java.sql.Connection;
-import java.sql.SQLException;
+
import javax.sql.DataSource;
import org.springframework.dao.DataAccessResourceFailureException;
+import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.util.Assert;
/**
* Utility methods for executing a DatabasePopulator.
*
* @author Juergen Hoeller
+ * @author Oliver Gierke
* @since 3.1
*/
public abstract class DatabasePopulatorUtils {
@@ -40,16 +42,13 @@ public static void execute(DatabasePopulator populator, DataSource dataSource) {
Assert.notNull(populator, "DatabasePopulator must be provided");
Assert.notNull(dataSource, "DataSource must be provided");
try {
- Connection connection = dataSource.getConnection();
+ Connection connection = DataSourceUtils.getConnection(dataSource);
try {
populator.populate(connection);
}
finally {
- try {
- connection.close();
- }
- catch (SQLException ex) {
- // ignore
+ if (connection != null) {
+ DataSourceUtils.releaseConnection(connection, dataSource);
}
}
} | true |
Other | spring-projects | spring-framework | 49c9a2a9157861bad53ec47b67c8d821b0b4655a.json | Use transactional connection during db population
Previously, DatabasePopulatorUtils#execute looked up a Connection from
the given DataSource directly which resulted in the executed statements
not being executed against a transactional connection (if any) which in
turn resulted in the statements executed by the populator potentially
not being rolled back.
Now DataSourceUtils#getConnection is used to transparently take part in
any active transaction and #releaseConnection is used to ensure the
connection is closed if appropriate.
Issue: SPR-9457 | spring-jdbc/src/test/java/org/springframework/jdbc/datasource/init/DatabasePopulatorTests.java | @@ -1,5 +1,5 @@
/*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -19,17 +19,24 @@
import static org.junit.Assert.assertEquals;
import java.sql.Connection;
+import java.sql.SQLException;
+
+import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Test;
+
import org.springframework.core.io.ClassRelativeResourceLoader;
import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
/**
* @author Dave Syer
* @author Sam Brannen
+ * @author Oliver Gierke
*/
public class DatabasePopulatorTests {
@@ -54,6 +61,12 @@ private void assertUsersDatabaseCreated() {
@After
public void shutDown() {
+
+ if (TransactionSynchronizationManager.isSynchronizationActive()) {
+ TransactionSynchronizationManager.clear();
+ TransactionSynchronizationManager.unbindResource(db);
+ }
+
db.shutdown();
}
@@ -207,4 +220,22 @@ public void testBuildWithSelectStatements() throws Exception {
assertEquals(1, jdbcTemplate.queryForInt("select COUNT(NAME) from T_TEST where NAME='Dave'"));
}
+ /**
+ * @see SPR-9457
+ */
+ @Test
+ public void usesBoundConnectionIfAvailable() throws SQLException {
+
+ TransactionSynchronizationManager.initSynchronization();
+ Connection connection = DataSourceUtils.getConnection(db);
+
+ DatabasePopulator populator = EasyMock.createMock(DatabasePopulator.class);
+ populator.populate(connection);
+ EasyMock.expectLastCall();
+ EasyMock.replay(populator);
+
+ DatabasePopulatorUtils.execute(populator, db);
+
+ EasyMock.verify(populator);
+ }
} | true |
Other | spring-projects | spring-framework | eec2be05afd6a19c587407545657c9849839b200.json | Release version 3.2.0.M1 | gradle.properties | @@ -1 +1 @@
-version = 3.2.0.BUILD-SNAPSHOT
+version=3.2.0.M1 | false |
Other | spring-projects | spring-framework | 155b88ffcee5c85898cc6cc70c0527250a9e5772.json | Improve dependency management for spring-test
In Spring 3.1 the spring-test Maven artifact did not have a required
dependency on spring-core, but there is practically no part of
spring-test that can be used without spring-core. Most test utilities
that are intended to be stand-alone utilities in fact use utility
classes from spring-core (e.g., ReflectionTestUtils). Even some of the
web mocks/stubs use spring-core (e.g., DelegatingServletInputStream).
In addition, the current Gradle build configuration for the spring-test
module is very simplistic -- in that it does not explicitly list any
optional dependencies such as the Servlet and Portlet APIs -- and it
defines a 'compile' dependency on spring-webmvc-portlet.
The resulting Maven dependencies in the generated POM are therefore not
what a typical consumer of the spring-test artifact would reasonably
expect.
To address these issues, the Gradle build configuration for the
spring-test module now explicitly defines the following 'compile'
dependencies:
- spring-core
- spring-webmvc, optional
- spring-webmvc-portlet, optional
- junit, optional
- testng, optional
- servlet-api, optional
- jsp-api, optional
- portlet-api, optional
- activation, provided
The only required dependency is now spring-core; all other dependencies
are 'optional'.
Issue: SPR-8861 | build.gradle | @@ -423,11 +423,15 @@ project('spring-webmvc-portlet') {
project('spring-test') {
description = 'Spring TestContext Framework'
dependencies {
- compile project(":spring-webmvc-portlet")
- compile("javax.activation:activation:1.0", provided)
- compile("org.testng:testng:6.5.2", optional)
+ compile project(":spring-core")
+ compile(project(":spring-webmvc"), optional)
+ compile(project(":spring-webmvc-portlet"), optional)
compile("junit:junit:4.10", optional)
- compile("javax.servlet:servlet-api:2.5", provided)
+ compile("org.testng:testng:6.5.2", optional)
+ compile("javax.servlet:servlet-api:2.5", optional)
+ compile("javax.servlet.jsp:jsp-api:2.1", optional)
+ compile("javax.portlet:portlet-api:2.0", optional)
+ compile("javax.activation:activation:1.0", provided)
testCompile "org.slf4j:slf4j-jcl:1.5.3"
}
} | true |
Other | spring-projects | spring-framework | 155b88ffcee5c85898cc6cc70c0527250a9e5772.json | Improve dependency management for spring-test
In Spring 3.1 the spring-test Maven artifact did not have a required
dependency on spring-core, but there is practically no part of
spring-test that can be used without spring-core. Most test utilities
that are intended to be stand-alone utilities in fact use utility
classes from spring-core (e.g., ReflectionTestUtils). Even some of the
web mocks/stubs use spring-core (e.g., DelegatingServletInputStream).
In addition, the current Gradle build configuration for the spring-test
module is very simplistic -- in that it does not explicitly list any
optional dependencies such as the Servlet and Portlet APIs -- and it
defines a 'compile' dependency on spring-webmvc-portlet.
The resulting Maven dependencies in the generated POM are therefore not
what a typical consumer of the spring-test artifact would reasonably
expect.
To address these issues, the Gradle build configuration for the
spring-test module now explicitly defines the following 'compile'
dependencies:
- spring-core
- spring-webmvc, optional
- spring-webmvc-portlet, optional
- junit, optional
- testng, optional
- servlet-api, optional
- jsp-api, optional
- portlet-api, optional
- activation, provided
The only required dependency is now spring-core; all other dependencies
are 'optional'.
Issue: SPR-8861 | src/dist/changelog.txt | @@ -32,6 +32,15 @@ Changes in version 3.2 M1
* support executor qualification with @Async#value (SPR-6847)
* add convenient WebAppInitializer base classes (SPR-9300)
* support initial delay attribute for scheduled tasks (SPR-7022)
+* cache by-type lookups in DefaultListableBeanFactory (SPR-6870)
+* merge rather than add URI vars to data binding values (SPR-9349)
+* support not (!) operator for profile selection (SPR-8728)
+* fix regression in ClassPathResource descriptions (SPR-9413)
+* improve documentation of @Bean 'lite' mode (SPR-9401)
+* improve documentation of annotated class support in the TestContext framework (SPR-9401)
+* document support for JSR-250 lifecycle annotations in the TestContext framework (SPR-4868)
+* improve dependency management for spring-test (SPR-8861)
+
Changes in version 3.1.1 (2012-02-16)
------------------------------------- | true |
Other | spring-projects | spring-framework | 9b10d38e41150fdbd4120e1058a34c5b986dd849.json | Fix window state comparison in DAHandlerMapping | spring-webmvc-portlet/src/main/java/org/springframework/web/portlet/mvc/annotation/DefaultAnnotationHandlerMapping.java | @@ -1,5 +1,5 @@
/*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -411,8 +411,8 @@ public int compareTo(Object other) {
}
else if (other instanceof RenderMappingPredicate) {
RenderMappingPredicate otherRender = (RenderMappingPredicate) other;
- boolean hasWindowState = "".equals(this.windowState);
- boolean otherHasWindowState = "".equals(otherRender.windowState);
+ boolean hasWindowState = (this.windowState != null);
+ boolean otherHasWindowState = (otherRender.windowState != null);
if (hasWindowState != otherHasWindowState) {
return (hasWindowState ? -1 : 1);
} | false |
Other | spring-projects | spring-framework | 83fa8e12f0ea1aa3f5564de48a801b4d5d171898.json | Add initial support for JCache-compliant providers
Issue: SPR-8774 | build.gradle | @@ -217,6 +217,7 @@ project('spring-context') {
exclude group: 'org.slf4j', module: 'slf4j-api'
}
compile("joda-time:joda-time:1.6", optional)
+ compile("javax.cache:cache-api:0.5", optional)
compile("net.sf.ehcache:ehcache-core:2.0.0", optional)
compile("org.slf4j:slf4j-api:1.6.1", optional)
compile("org.codehaus.jsr166-mirror:jsr166:1.7.0", provided) | true |
Other | spring-projects | spring-framework | 83fa8e12f0ea1aa3f5564de48a801b4d5d171898.json | Add initial support for JCache-compliant providers
Issue: SPR-8774 | spring-context/src/main/java/org/springframework/cache/jcache/JCacheCache.java | @@ -0,0 +1,131 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cache.jcache;
+
+import java.io.Serializable;
+
+import javax.cache.Status;
+
+import org.springframework.cache.Cache;
+import org.springframework.cache.support.SimpleValueWrapper;
+import org.springframework.util.Assert;
+
+/**
+ * {@link org.springframework.cache.Cache} implementation on top of a
+ * {@link javax.cache.Cache} instance.
+ *
+ * @author Juergen Hoeller
+ * @since 3.2
+ */
+public class JCacheCache implements Cache {
+
+ private static final Object NULL_HOLDER = new NullHolder();
+
+ @SuppressWarnings("rawtypes")
+ private final javax.cache.Cache cache;
+
+ private final boolean allowNullValues;
+
+
+ /**
+ * Create an {@link org.springframework.cache.jcache.JCacheCache} instance.
+ * @param jcache backing JCache Cache instance
+ */
+ public JCacheCache(javax.cache.Cache<?,?> jcache) {
+ this(jcache, true);
+ }
+
+ /**
+ * Create an {@link org.springframework.cache.jcache.JCacheCache} instance.
+ * @param jcache backing JCache Cache instance
+ * @param allowNullValues whether to accept and convert null values for this cache
+ */
+ public JCacheCache(javax.cache.Cache<?,?> jcache, boolean allowNullValues) {
+ Assert.notNull(jcache, "Cache must not be null");
+ Status status = jcache.getStatus();
+ Assert.isTrue(Status.STARTED.equals(status),
+ "A 'started' cache is required - current cache is " + status.toString());
+ this.cache = jcache;
+ this.allowNullValues = allowNullValues;
+ }
+
+
+ public String getName() {
+ return this.cache.getName();
+ }
+
+ public javax.cache.Cache<?,?> getNativeCache() {
+ return this.cache;
+ }
+
+ public boolean isAllowNullValues() {
+ return this.allowNullValues;
+ }
+
+ @SuppressWarnings("unchecked")
+ public ValueWrapper get(Object key) {
+ Object value = this.cache.get(key);
+ return (value != null ? new SimpleValueWrapper(fromStoreValue(value)) : null);
+ }
+
+ @SuppressWarnings("unchecked")
+ public void put(Object key, Object value) {
+ this.cache.put(key, toStoreValue(value));
+ }
+
+ @SuppressWarnings("unchecked")
+ public void evict(Object key) {
+ this.cache.remove(key);
+ }
+
+ public void clear() {
+ this.cache.removeAll();
+ }
+
+
+ /**
+ * Convert the given value from the internal store to a user value
+ * returned from the get method (adapting <code>null</code>).
+ * @param storeValue the store value
+ * @return the value to return to the user
+ */
+ protected Object fromStoreValue(Object storeValue) {
+ if (this.allowNullValues && storeValue == NULL_HOLDER) {
+ return null;
+ }
+ return storeValue;
+ }
+
+ /**
+ * Convert the given user value, as passed into the put method,
+ * to a value in the internal store (adapting <code>null</code>).
+ * @param userValue the given user value
+ * @return the value to store
+ */
+ protected Object toStoreValue(Object userValue) {
+ if (this.allowNullValues && userValue == null) {
+ return NULL_HOLDER;
+ }
+ return userValue;
+ }
+
+
+ @SuppressWarnings("serial")
+ private static class NullHolder implements Serializable {
+ }
+
+} | true |
Other | spring-projects | spring-framework | 83fa8e12f0ea1aa3f5564de48a801b4d5d171898.json | Add initial support for JCache-compliant providers
Issue: SPR-8774 | spring-context/src/main/java/org/springframework/cache/jcache/JCacheCacheManager.java | @@ -0,0 +1,104 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cache.jcache;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+
+import javax.cache.Status;
+
+import org.springframework.cache.Cache;
+import org.springframework.cache.support.AbstractCacheManager;
+import org.springframework.util.Assert;
+
+/**
+ * {@link org.springframework.cache.CacheManager} implementation
+ * backed by a JCache {@link javax.cache.CacheManager}.
+ *
+ * @author Juergen Hoeller
+ * @since 3.2
+ */
+public class JCacheCacheManager extends AbstractCacheManager {
+
+ private javax.cache.CacheManager cacheManager;
+
+ private boolean allowNullValues = true;
+
+
+ /**
+ * Set the backing JCache {@link javax.cache.CacheManager}.
+ */
+ public void setCacheManager(javax.cache.CacheManager cacheManager) {
+ this.cacheManager = cacheManager;
+ }
+
+ /**
+ * Return the backing JCache {@link javax.cache.CacheManager}.
+ */
+ public javax.cache.CacheManager getCacheManager() {
+ return this.cacheManager;
+ }
+
+ /**
+ * Specify whether to accept and convert null values for all caches
+ * in this cache manager.
+ * <p>Default is "true", despite JSR-107 itself not supporting null values.
+ * An internal holder object will be used to store user-level null values.
+ */
+ public void setAllowNullValues(boolean allowNullValues) {
+ this.allowNullValues = allowNullValues;
+ }
+
+ /**
+ * Return whether this cache manager accepts and converts null values
+ * for all of its caches.
+ */
+ public boolean isAllowNullValues() {
+ return this.allowNullValues;
+ }
+
+
+ @Override
+ protected Collection<Cache> loadCaches() {
+ Assert.notNull(this.cacheManager, "A backing CacheManager is required");
+ Status status = this.cacheManager.getStatus();
+ Assert.isTrue(Status.STARTED.equals(status),
+ "A 'started' JCache CacheManager is required - current cache is " + status.toString());
+
+ Collection<Cache> caches = new LinkedHashSet<Cache>();
+ for (javax.cache.Cache<?,?> jcache : this.cacheManager.getCaches()) {
+ caches.add(new JCacheCache(jcache, this.allowNullValues));
+ }
+ return caches;
+ }
+
+ @Override
+ public Cache getCache(String name) {
+ Cache cache = super.getCache(name);
+ if (cache == null) {
+ // check the JCache cache again
+ // (in case the cache was added at runtime)
+ javax.cache.Cache<?,?> jcache = this.cacheManager.getCache(name);
+ if (jcache != null) {
+ cache = new JCacheCache(jcache, this.allowNullValues);
+ addCache(cache);
+ }
+ }
+ return cache;
+ }
+
+} | true |
Other | spring-projects | spring-framework | 83fa8e12f0ea1aa3f5564de48a801b4d5d171898.json | Add initial support for JCache-compliant providers
Issue: SPR-8774 | spring-context/src/main/java/org/springframework/cache/jcache/JCacheManagerFactoryBean.java | @@ -0,0 +1,77 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cache.jcache;
+
+import javax.cache.CacheManager;
+import javax.cache.Caching;
+
+import org.springframework.beans.factory.BeanClassLoaderAware;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+
+/**
+ * {@link FactoryBean} for a JCache {@link javax.cache.CacheManager},
+ * obtaining a pre-defined CacheManager by name through the standard
+ * JCache {@link javax.cache.Caching} class.
+ *
+ * @author Juergen Hoeller
+ * @since 3.2
+ * @see javax.cache.Caching#getCacheManager()
+ * @see javax.cache.Caching#getCacheManager(String)
+ */
+public class JCacheManagerFactoryBean implements FactoryBean<CacheManager>, BeanClassLoaderAware, InitializingBean {
+
+ private String cacheManagerName = Caching.DEFAULT_CACHE_MANAGER_NAME;
+
+ private ClassLoader beanClassLoader;
+
+ private CacheManager cacheManager;
+
+
+ /**
+ * Specify the name of the desired CacheManager.
+ * Default is JCache's default.
+ * @see Caching#DEFAULT_CACHE_MANAGER_NAME
+ */
+ public void setCacheManagerName(String cacheManagerName) {
+ this.cacheManagerName = cacheManagerName;
+ }
+
+ public void setBeanClassLoader(ClassLoader classLoader) {
+ this.beanClassLoader = classLoader;
+ }
+
+ public void afterPropertiesSet() {
+ this.cacheManager = (this.beanClassLoader != null ?
+ Caching.getCacheManager(this.beanClassLoader, this.cacheManagerName) :
+ Caching.getCacheManager(this.cacheManagerName));
+ }
+
+
+ public CacheManager getObject() {
+ return this.cacheManager;
+ }
+
+ public Class<?> getObjectType() {
+ return (this.cacheManager != null ? this.cacheManager.getClass() : CacheManager.class);
+ }
+
+ public boolean isSingleton() {
+ return true;
+ }
+
+} | true |
Other | spring-projects | spring-framework | 83fa8e12f0ea1aa3f5564de48a801b4d5d171898.json | Add initial support for JCache-compliant providers
Issue: SPR-8774 | spring-context/src/main/java/org/springframework/cache/jcache/package-info.java | @@ -0,0 +1,7 @@
+/**
+ * Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
+ * Provides a {@link org.springframework.cache.CacheManager CacheManager}
+ * and {@link org.springframework.cache.Cache Cache} implementation for
+ * use in a Spring context, using a JSR-107 compliant cache provider.
+ */
+package org.springframework.cache.jcache; | true |
Other | spring-projects | spring-framework | 5327a7a37d25b67ee2ae7d1ead2a3db6847767c0.json | Fix package cycle in @EnableSpringConfigured
@EnableSpringConfigured and its @Import'ed
SpringConfiguredConfiguration @Configuration class inadvertently
established a package cycle between beans.factory.aspectj and
context.annotation due to SpringConfiguredConfiguration's
dependency on annotations such as @Configuration, @Bean and @Role.
This commit fixes this architecture bug by moving
@EnableSpringConfigured and SpringConfiguredConfiguration from the
beans.factory.aspectj package to the context.annotation package where
they belong.
This change is assumed to be very low impact as @EnableSpringConfigured
was introduced in 3.1.0 and relocation is happening as quickly as
possible in 3.1.2. @EnableSpringConfigured is assumed to be infrequently
used at this point, and for those that are the migration path
is straightforward. When upgrading from Spring 3.1.0 or 3.1.1, update
import statements in any affected @Configuration classes to reflect the
new packaging.
Issue: SPR-9441 | spring-aspects/src/main/java/org/springframework/context/annotation/EnableSpringConfigured.java | @@ -1,5 +1,5 @@
/*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-package org.springframework.beans.factory.aspectj;
+package org.springframework.context.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
@@ -25,14 +25,16 @@
import org.springframework.context.annotation.Import;
/**
- * Signals the current application context to apply dependency injection to non-managed
- * classes that are instantiated outside of the Spring bean factory (typically classes
- * annotated with the @{@link org.springframework.beans.factory.annotation.Configurable
+ * Signals the current application context to apply dependency injection to
+ * non-managed classes that are instantiated outside of the Spring bean factory
+ * (typically classes annotated with the @
+ * {@link org.springframework.beans.factory.annotation.Configurable
* Configurable} annotation).
*
- * <p>Similar to functionality found in Spring's {@code <context:spring-configured>} XML
- * element. Often used in conjunction with {@link
- * org.springframework.context.annotation.EnableLoadTimeWeaving @EnableLoadTimeWeaving}.
+ * <p>Similar to functionality found in Spring's
+ * {@code <context:spring-configured>} XML element. Often used in conjunction
+ * with {@link org.springframework.context.annotation.EnableLoadTimeWeaving
+ * @EnableLoadTimeWeaving}.
*
* @author Chris Beams
* @since 3.1 | true |
Other | spring-projects | spring-framework | 5327a7a37d25b67ee2ae7d1ead2a3db6847767c0.json | Fix package cycle in @EnableSpringConfigured
@EnableSpringConfigured and its @Import'ed
SpringConfiguredConfiguration @Configuration class inadvertently
established a package cycle between beans.factory.aspectj and
context.annotation due to SpringConfiguredConfiguration's
dependency on annotations such as @Configuration, @Bean and @Role.
This commit fixes this architecture bug by moving
@EnableSpringConfigured and SpringConfiguredConfiguration from the
beans.factory.aspectj package to the context.annotation package where
they belong.
This change is assumed to be very low impact as @EnableSpringConfigured
was introduced in 3.1.0 and relocation is happening as quickly as
possible in 3.1.2. @EnableSpringConfigured is assumed to be infrequently
used at this point, and for those that are the migration path
is straightforward. When upgrading from Spring 3.1.0 or 3.1.1, update
import statements in any affected @Configuration classes to reflect the
new packaging.
Issue: SPR-9441 | spring-aspects/src/main/java/org/springframework/context/annotation/SpringConfiguredConfiguration.java | @@ -1,5 +1,5 @@
/*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -14,8 +14,9 @@
* limitations under the License.
*/
-package org.springframework.beans.factory.aspectj;
+package org.springframework.context.annotation;
+import org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; | true |
Other | spring-projects | spring-framework | 5327a7a37d25b67ee2ae7d1ead2a3db6847767c0.json | Fix package cycle in @EnableSpringConfigured
@EnableSpringConfigured and its @Import'ed
SpringConfiguredConfiguration @Configuration class inadvertently
established a package cycle between beans.factory.aspectj and
context.annotation due to SpringConfiguredConfiguration's
dependency on annotations such as @Configuration, @Bean and @Role.
This commit fixes this architecture bug by moving
@EnableSpringConfigured and SpringConfiguredConfiguration from the
beans.factory.aspectj package to the context.annotation package where
they belong.
This change is assumed to be very low impact as @EnableSpringConfigured
was introduced in 3.1.0 and relocation is happening as quickly as
possible in 3.1.2. @EnableSpringConfigured is assumed to be infrequently
used at this point, and for those that are the migration path
is straightforward. When upgrading from Spring 3.1.0 or 3.1.1, update
import statements in any affected @Configuration classes to reflect the
new packaging.
Issue: SPR-9441 | spring-aspects/src/test/java/org/springframework/context/annotation/AnnotationBeanConfigurerTests.java | @@ -1,5 +1,5 @@
/*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -14,16 +14,15 @@
* limitations under the License.
*/
-package org.springframework.beans.factory.aspectj;
+package org.springframework.context.annotation;
+import org.springframework.beans.factory.aspectj.AbstractBeanConfigurerTests;
import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.ImportResource;
/**
* Tests that @EnableSpringConfigured properly registers an
- * {@link AnnotationBeanConfigurerAspect}, just as does {@code <context:spring-configured>}
+ * {@link org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect}, just
+ * as does {@code <context:spring-configured>}
*
* @author Chris Beams
* @since 3.1 | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans-annotation-config.xml | @@ -73,14 +73,14 @@
</beans></programlisting>
<para>(The implicitly registered post-processors include <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessor.html"
><classname>AutowiredAnnotationBeanPostProcessor</classname></ulink>, <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/annotation/CommonAnnotationBeanPostProcessor.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/context/annotation/CommonAnnotationBeanPostProcessor.html"
><classname>CommonAnnotationBeanPostProcessor</classname></ulink>, <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/orm/jpa/support/PersistenceAnnotationBeanPostProcessor.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/orm/jpa/support/PersistenceAnnotationBeanPostProcessor.html"
><classname>PersistenceAnnotationBeanPostProcessor</classname></ulink>, as
well as the aforementioned <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/annotation/RequiredAnnotationBeanPostProcessor.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/annotation/RequiredAnnotationBeanPostProcessor.html"
><classname>RequiredAnnotationBeanPostProcessor</classname></ulink>.)</para>
<note>
@@ -639,7 +639,7 @@ public @interface MovieQualifier {
<title><classname>CustomAutowireConfigurer</classname></title>
<para>The <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/annotation/CustomAutowireConfigurer.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/annotation/CustomAutowireConfigurer.html"
><classname>CustomAutowireConfigurer</classname></ulink> is a
<interfacename>BeanFactoryPostProcessor</interfacename> that enables you
to register your own custom qualifier annotation types even if they are
@@ -720,7 +720,7 @@ public @interface MovieQualifier {
the <interfacename>ApplicationContext</interfacename> of which the
<classname>CommonAnnotationBeanPostProcessor</classname> is aware. The
names can be resolved through JNDI if you configure Spring's <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/jndi/support/SimpleJndiBeanFactory.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/jndi/support/SimpleJndiBeanFactory.html"
><classname>SimpleJndiBeanFactory</classname></ulink> explicitly.
However, it is recommended that you rely on the default behavior and
simply use Spring's JNDI lookup capabilities to preserve the level of | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans-classpath-scanning.xml | @@ -391,7 +391,7 @@ public class MovieFinderImpl implements MovieFinder {
<note>
<para>If you do not want to rely on the default bean-naming strategy, you
can provide a custom bean-naming strategy. First, implement the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/support/BeanNameGenerator.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/support/BeanNameGenerator.html"
><interfacename>BeanNameGenerator</interfacename></ulink> interface, and
be sure to include a default no-arg constructor. Then, provide the
fully-qualified class name when configuring the scanner:</para>
@@ -428,7 +428,7 @@ public class MovieFinderImpl implements MovieFinder {
<note>
<para>To provide a custom strategy for scope resolution rather than
relying on the annotation-based approach, implement the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/annotation/ScopeMetadataResolver.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/context/annotation/ScopeMetadataResolver.html"
><interfacename>ScopeMetadataResolver</interfacename></ulink> interface,
and be sure to include a default no-arg constructor. Then, provide the
fully-qualified class name when configuring the scanner:</para> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans-context-additional.xml | @@ -13,7 +13,7 @@
functionality for managing and manipulating beans, including in a
programmatic way. The <literal>org.springframework.context</literal> package
adds the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/ApplicationContext.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/context/ApplicationContext.html"
><interfacename>ApplicationContext</interfacename></ulink> interface, which
extends the <interfacename>BeanFactory</interfacename> interface, in
addition to extending other interfaces to provide additional functionality
@@ -635,7 +635,7 @@ argument.required=Ebagum lad, the '{0}' argument is required, I say, required.</
<interfacename>TaskExecutor</interfacename> abstraction.</para>
<para>Check out the JavaDoc of the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/jca/context/SpringContextResourceAdapter.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/jca/context/SpringContextResourceAdapter.html"
>SpringContextResourceAdapter</ulink> class for the configuration details
involved in RAR deployment.</para>
| true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans-extension-points.xml | @@ -231,7 +231,7 @@ org.springframework.scripting.groovy.GroovyMessenger@272961</programlisting>
<para>Using callback interfaces or annotations in conjunction with a
custom <interfacename>BeanPostProcessor</interfacename> implementation
is a common means of extending the Spring IoC container. An example is
- Spring's <classname>RequiredAnnotationBeanPostProcessor</classname> — a
+ Spring's <classname>RequiredAnnotationBeanPostProcessor</classname> — a
<interfacename>BeanPostProcessor</interfacename> implementation that
ships with the Spring distribution which ensures that JavaBean
properties on beans that are marked with an (arbitrary) annotation are | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans-scopes.xml | @@ -95,7 +95,7 @@
<para>As of Spring 3.0, a <emphasis>thread scope</emphasis> is available,
but is not registered by default. For more information, see the
documentation for <ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/support/SimpleThreadScope.html"
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/context/support/SimpleThreadScope.html"
>SimpleThreadScope</ulink>. For instructions on how to register this or
any other custom scope, see <xref
linkend="beans-factory-scopes-custom-using"/>.</para>
@@ -118,7 +118,8 @@
<para><mediaobject>
<imageobject role="fo">
- <imagedata align="center" fileref="images/singleton.png" format="PNG"/>
+ <imagedata align="center" fileref="images/singleton.png" format="PNG"
+ width="400"/>
</imageobject>
<imageobject role="html">
@@ -163,7 +164,8 @@
<para><mediaobject>
<imageobject role="fo">
- <imagedata align="center" fileref="images/prototype.png" format="PNG"/>
+ <imagedata align="center" fileref="images/prototype.png" format="PNG"
+ width="400" />
</imageobject>
<imageobject role="html">
@@ -556,7 +558,7 @@
implement your own scopes, see the <interfacename>Scope</interfacename>
implementations that are supplied with the Spring Framework itself and
the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/config/Scope.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/config/Scope.html"
>Scope Javadoc</ulink>, which explains the methods you need to implement
in more detail.</para>
| true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans-standard-annotations.xml | @@ -150,7 +150,7 @@ component-scanning in the exact same way as when using Spring annotations:
<row>
<entry>@Component</entry>
<entry>@Named</entry>
- <entry>—</entry>
+ <entry>—</entry>
</row>
<row>
<entry>@Scope("singleton")</entry>
@@ -174,21 +174,21 @@ component-scanning in the exact same way as when using Spring annotations:
<row>
<entry>@Qualifier</entry>
<entry>@Named</entry>
- <entry>—</entry>
+ <entry>—</entry>
</row>
<row>
<entry>@Value</entry>
- <entry>—</entry>
+ <entry>—</entry>
<entry>no equivalent</entry>
</row>
<row>
<entry>@Required</entry>
- <entry>—</entry>
+ <entry>—</entry>
<entry>no equivalent</entry>
</row>
<row>
<entry>@Lazy</entry>
- <entry>—</entry>
+ <entry>—</entry>
<entry>no equivalent</entry>
</row>
</tbody> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/beans.xml | @@ -29,11 +29,11 @@ The footnote should x-ref to first section in that chapter but I can't find the
<para>The <literal>org.springframework.beans</literal> and
<literal>org.springframework.context</literal> packages are the basis for
Spring Framework's IoC container. The <interfacename><ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/BeanFactory.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/BeanFactory.html"
>BeanFactory</ulink></interfacename> interface provides an advanced
configuration mechanism capable of managing any type of object.
<literal><ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/ApplicationContext.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/context/ApplicationContext.html"
>ApplicationContext</ulink></literal> is a sub-interface of
<interfacename>BeanFactory.</interfacename> It adds easier integration
with Spring's AOP features; message resource handling (for use in
@@ -80,9 +80,9 @@ The footnote should x-ref to first section in that chapter but I can't find the
<classname>ApplicationContext</classname> interface are supplied
out-of-the-box with Spring. In standalone applications it is common to
create an instance of <ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/support/ClassPathXmlApplicationContext.html"
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/context/support/ClassPathXmlApplicationContext.html"
><classname>ClassPathXmlApplicationContext</classname></ulink> or <ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/support/FileSystemXmlApplicationContext.html"
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/context/support/FileSystemXmlApplicationContext.html"
><classname>FileSystemXmlApplicationContext</classname></ulink>.
<!-- MLP: Beverly to review --> While XML has been the traditional format
for defining configuration metadata you can instruct the container to use
@@ -109,7 +109,7 @@ The footnote should x-ref to first section in that chapter but I can't find the
<para><mediaobject>
<imageobject>
<imagedata align="center" fileref="images/container-magic.png"
- format="PNG"/>
+ format="PNG" width="400" />
</imageobject>
<caption><para>The Spring IoC container</para></caption>
@@ -1170,7 +1170,7 @@ cfg.postProcessBeanFactory(factory);</programlisting>
a single ApplicationContext as a parent to WebApplicationContexts across
WAR files. In this case you should look into using the utility class
<ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/context/access/ContextSingletonBeanFactoryLocator.html"
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/context/access/ContextSingletonBeanFactoryLocator.html"
><classname>ContextSingletonBeanFactoryLocator</classname></ulink>
locator that is described in this <ulink
url="http://blog.springsource.com/2007/06/11/using-a-shared-parent-application-context-in-a-multi-war-spring-application/" | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/dao.xml | @@ -59,8 +59,14 @@
hierarchy.)</para>
<mediaobject>
- <imageobject>
- <imagedata align="center" fileref="images/DataAccessException.gif" />
+ <imageobject role="fo">
+ <imagedata align="center" fileref="images/DataAccessException.gif"
+ format="PNG" width="400"/>
+ </imageobject>
+
+ <imageobject role="html">
+ <imagedata align="center" fileref="images/DataAccessException.gif"
+ format="PNG" width="400"/>
</imageobject>
</mediaobject>
</section> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/index.xml | @@ -4,11 +4,11 @@
xmlns:xi="http://www.w3.org/2001/XInclude"
xmlns:xlink="http://www.w3.org/1999/xlink">
<bookinfo>
- <title>Reference Documentation</title>
+ <title>Spring Framework Reference Manual</title>
<productname>Spring Framework</productname>
- <releaseinfo>3.1</releaseinfo>
+ <releaseinfo>${version}</releaseinfo>
<mediaobject>
<imageobject role="fo">
@@ -182,7 +182,7 @@
</authorgroup>
<copyright>
- <year>2004-2011</year>
+ <year>2004-2012</year>
<holder>Rod Johnson, Juergen Hoeller, Keith Donald, Colin Sampaleanu,
Rob Harrop, Alef Arendsen, Thomas Risberg, Darren Davison, Dmitriy
@@ -509,9 +509,8 @@
<xi:include href="spring.tld.xml"
xmlns:xi="http://www.w3.org/2001/XInclude" />
-<!--
+
<xi:include href="spring-form.tld.xml"
xmlns:xi="http://www.w3.org/2001/XInclude" />
--->
</part>
</book> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/jdbc.xml | @@ -2600,93 +2600,74 @@ public class TitlesAfterDateStoredProcedure extends StoredProcedure {
of a <classname>DefaultLobHandler</classname>. You typically set this
value through dependency injection.<!--Rewording ok? (What does what through dependency injection?) TR: Revised.--></para>
- <!--
- <programlistingco>
- <areaspec>
- <area coords="8" id="jdbc.lobhandler.variableref" />
-
- <area coords="12" id="jdbc.lobhandler.setClob" />
-
- <area coords="13" id="jdbc.lobhandler.setBlob" />
- </areaspec>
-
- <programlisting language="java">final File blobIn = new File("spring2004.jpg");
+ <programlisting language="java"><![CDATA[final File blobIn = new File("spring2004.jpg");
final InputStream blobIs = new FileInputStream(blobIn);
final File clobIn = new File("large.txt");
final InputStream clobIs = new FileInputStream(clobIn);
final InputStreamReader clobReader = new InputStreamReader(clobIs);
jdbcTemplate.execute(
"INSERT INTO lob_table (id, a_clob, a_blob) VALUES (?, ?, ?)",
- new AbstractLobCreatingPreparedStatementCallback(lobHandler) {
+ new AbstractLobCreatingPreparedStatementCallback(lobHandler) {]]><co id="lobHandler"/><![CDATA[
protected void setValues(PreparedStatement ps, LobCreator lobCreator)
throws SQLException {
ps.setLong(1, 1L);
- lobCreator.setClobAsCharacterStream(ps, 2, clobReader, (int)clobIn.length());
- lobCreator.setBlobAsBinaryStream(ps, 3, blobIs, (int)blobIn.length());
+ lobCreator.setClobAsCharacterStream(ps, 2, clobReader, (int)clobIn.length());]]><co id="setClobAsCharacterStream"/><![CDATA[
+ lobCreator.setBlobAsBinaryStream(ps, 3, blobIs, (int)blobIn.length());]]><co id="setBlobAsBinaryStream"/><![CDATA[
}
}
);
blobIs.close();
-clobReader.close();</programlisting>
-
- <calloutlist>
- <callout arearefs="jdbc.lobhandler.variableref">
- <para>Pass in the lobHandler that in this example is a plain
- <classname>DefaultLobHandler</classname></para>
- </callout>
-
- <callout arearefs="jdbc.lobhandler.setClob">
- <para>Using the method
- <classname>setClobAsCharacterStream</classname>, pass in the
- contents of the CLOB.</para>
- </callout>
-
- <callout arearefs="jdbc.lobhandler.setBlob">
- <para>Using the method
- <classname>setBlobAsBinaryStream</classname>, pass in the contents
- of the BLOB.</para>
- </callout>
- </calloutlist>
- </programlistingco>
- -->
+clobReader.close();]]></programlisting>
+
+ <calloutlist>
+ <callout arearefs="lobHandler">
+ <para>Pass in the lobHandler that in this example is a plain
+ <classname>DefaultLobHandler</classname></para>
+ </callout>
+
+ <callout arearefs="setClobAsCharacterStream">
+ <para>Using the method
+ <classname>setClobAsCharacterStream</classname>, pass in the
+ contents of the CLOB.</para>
+ </callout>
+
+ <callout arearefs="setBlobAsBinaryStream">
+ <para>Using the method
+ <classname>setBlobAsBinaryStream</classname>, pass in the contents
+ of the BLOB.</para>
+ </callout>
+ </calloutlist>
<para>Now it's time to read the LOB data from the database. Again, you
use a <code>JdbcTemplate</code> with the same instance variable
<code>l</code><code>obHandler </code>and a reference to a
<classname>DefaultLobHandler</classname>.</para>
- <para><!--<programlistingco>
- <areaspec>
- <area coords="5" id="jdbc.lobhandler.getClob" />
-
- <area coords="7" id="jdbc.lobhandler.getBlob" />
- </areaspec>
-
- <programlisting language="java">List<Map<String, Object>> l = jdbcTemplate.query("select id, a_clob, a_blob from lob_table",
- new RowMapper<Map<String, Object>>() {
- public Map<String, Object> mapRow(ResultSet rs, int i) throws SQLException {
- Map<String, Object> results = new HashMap<String, Object>();
- String clobText = lobHandler.getClobAsString(rs, "a_clob");
+ <para>
+ <programlisting language="java"><![CDATA[List<Map<String, Object>> l = jdbcTemplate.query("select id, a_clob, a_blob from lob_table",
+ new RowMapper<Map<String, Object>>() {
+ public Map<String, Object> mapRow(ResultSet rs, int i) throws SQLException {
+ Map<String, Object> results = new HashMap<String, Object>();
+ String clobText = lobHandler.getClobAsString(rs, "a_clob");]]><co id="getClobAsString"/><![CDATA[
results.put("CLOB", clobText);
- byte[] blobBytes = lobHandler.getBlobAsBytes(rs, "a_blob");
+ byte[] blobBytes = lobHandler.getBlobAsBytes(rs, "a_blob");]]><co id="getBlobAsBytes"/><![CDATA[
results.put("BLOB", blobBytes);
return results;
}
- });
-</programlisting>
+ });]]></programlisting>
- <calloutlist>
- <callout arearefs="jdbc.lobhandler.setClob">
- <para>Using the method <classname>getClobAsString,
- </classname>retrieve the contents of the CLOB.</para>
- </callout>
-
- <callout arearefs="jdbc.lobhandler.setBlob">
- <para>Using the method <classname>getBlobAsBytes,</classname>
- retrieve the contents of the BLOB.</para>
- </callout>
- </calloutlist>
- </programlistingco>--></para>
+ <calloutlist>
+ <callout arearefs="getClobAsString">
+ <para>Using the method <classname>getClobAsString,
+ </classname>retrieve the contents of the CLOB.</para>
+ </callout>
+
+ <callout arearefs="getBlobAsBytes">
+ <para>Using the method <classname>getBlobAsBytes,</classname>
+ retrieve the contents of the BLOB.</para>
+ </callout>
+ </calloutlist>
+ </para>
</section>
<section id="jdbc-in-clause"> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/mvc.xml | @@ -232,7 +232,8 @@
<para><mediaobject>
<imageobject role="fo">
- <imagedata align="center" fileref="images/mvc.png" format="PNG" />
+ <imagedata align="center" fileref="images/mvc.png" format="PNG"
+ width="400" />
</imageobject>
<imageobject role="html">
@@ -290,7 +291,7 @@
<para><mediaobject>
<imageobject role="fo">
<imagedata align="center" fileref="images/mvc-contexts.gif"
- format="GIF" />
+ format="GIF" width="400" />
</imageobject>
<imageobject role="html"> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/overview.xml | @@ -97,7 +97,7 @@ TR: This section doesn't read well and I think we should try to rewrite it.-->Nu
<para><mediaobject>
<imageobject role="fo">
<imagedata align="left" fileref="images/spring-overview.png"
- format="PNG" />
+ format="PNG" width="400" />
</imageobject>
<imageobject role="html">
@@ -259,7 +259,7 @@ TR: OK. Added to diagram.--></para>
<para><mediaobject>
<imageobject role="fo">
<imagedata align="center" fileref="images/overview-full.png"
- format="PNG" />
+ format="PNG" width="400" />
</imageobject>
<imageobject role="html">
@@ -289,7 +289,8 @@ TR: OK. Added to diagram.--></para>
<para><mediaobject>
<imageobject role="fo">
<imagedata align="center"
- fileref="images/overview-thirdparty-web.png" format="PNG" />
+ fileref="images/overview-thirdparty-web.png" format="PNG"
+ width="400"/>
</imageobject>
<imageobject role="html">
@@ -315,7 +316,7 @@ TR: OK. Added to diagram.--></para>
<para><mediaobject>
<imageobject role="fo">
<imagedata align="center" fileref="images/overview-remoting.png"
- format="PNG" />
+ format="PNG" width="400" />
</imageobject>
<imageobject role="html">
@@ -335,7 +336,7 @@ TR: OK. Added to diagram.--></para>
<para><mediaobject>
<imageobject role="fo">
<imagedata align="center" fileref="images/overview-ejb.png"
- format="PNG" />
+ format="PNG" width="400" />
</imageobject>
<imageobject role="html">
@@ -620,7 +621,7 @@ TR: OK. Added to diagram.--></para>
<programlisting><repositories>
<repository>
<id>com.springsource.repository.maven.release</id>
- <url>http://maven.springframework.org/release/</url>
+ <url>http://repo.springsource.org/release/</url>
<snapshots><enabled>false</enabled></snapshots>
</repository>
</repositories></programlisting>
@@ -630,7 +631,7 @@ TR: OK. Added to diagram.--></para>
<programlisting><repositories>
<repository>
<id>com.springsource.repository.maven.milestone</id>
- <url>http://maven.springframework.org/milestone/</url>
+ <url>http://repo.springsource.org/milestone/</url>
<snapshots><enabled>false</enabled></snapshots>
</repository>
</repositories></programlisting>
@@ -640,7 +641,7 @@ TR: OK. Added to diagram.--></para>
<programlisting><repositories>
<repository>
<id>com.springsource.repository.maven.snapshot</id>
- <url>http://maven.springframework.org/snapshot/</url>
+ <url>http://repo.springsource.org/snapshot/</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
</repositories></programlisting> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/oxm.xml | @@ -185,8 +185,19 @@ public interface Unmarshaller {
<para>
The O/X Mapping exception hierarchy is shown in the following figure:
<mediaobject>
- <imageobject>
- <imagedata fileref="images/oxm-exceptions.png" align="center"/>
+ <imageobject role="fo">
+ <imagedata align="center" fileref="images/oxm-exceptions.png"
+ format="PNG" width="400"/>
+ </imageobject>
+ <caption>
+ <para>
+ O/X Mapping exception hierarchy
+ </para>
+ </caption>
+
+ <imageobject role="html">
+ <imagedata align="center" fileref="images/oxm-exceptions.png"
+ format="PNG" width="400"/>
</imageobject>
<caption>
<para>
@@ -680,7 +691,7 @@ public class Application {
This will make sure that only the registered classes are eligible for unmarshalling.
</para>
<para>
- Additionally, you can register <ulink url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/oxm/xstream/XStreamMarshaller.html#setConverters(com.thoughtworks.xstream.converters.ConverterMatcher[])">
+ Additionally, you can register <ulink url="http://static.springsource.org/spring/docs/current/api/org/springframework/oxm/xstream/XStreamMarshaller.html#setConverters(com.thoughtworks.xstream.converters.ConverterMatcher[])">
custom converters</ulink> to make sure that only your supported classes can be unmarshalled.
</para>
</warning> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/preface.xml | @@ -31,9 +31,8 @@
use and also on the Spring libraries, but these dependencies should be easy
to isolate from the rest of your code base.</para>
- <para>This document provides a reference guide to Spring's features. Since
- this document is still to be considered very much work-in-progress, if you
- have any requests or comments, please post them on the user mailing list or
- on the support forums at <ulink url="http://forum.springsource.org/" />.
+ <para>This document provides a reference guide to Spring's features. If you
+ have any requests or comments, please add an issue at
+ <ulink url="http://jira.springsource.org/SPR" />.
</para>
</preface> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/remoting.xml | @@ -1275,52 +1275,52 @@ if (HttpStatus.SC_CREATED == post.getStatusCode()) {
<entry>DELETE</entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#delete(String,%20Object...)">delete</ulink></entry>
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#delete(String,%20Object...)">delete</ulink></entry>
</row>
<row>
<entry>GET</entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#getForObject(String,%20Class,%20Object...)">getForObject</ulink></entry>
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#getForObject(String,%20Class,%20Object...)">getForObject</ulink></entry>
</row>
<row>
<entry></entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#getForEntity(String,%20Class,%20Object...)">getForEntity</ulink></entry>
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#getForEntity(String,%20Class,%20Object...)">getForEntity</ulink></entry>
</row>
<row>
<entry>HEAD</entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#headForHeaders(String,%20Object...)">headForHeaders(String
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#headForHeaders(String,%20Object...)">headForHeaders(String
url, String… urlVariables)</ulink></entry>
</row>
<row>
<entry>OPTIONS</entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#optionsForAllow(String,%20Object...)">optionsForAllow(String
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#optionsForAllow(String,%20Object...)">optionsForAllow(String
url, String… urlVariables)</ulink></entry>
</row>
<row>
<entry>POST</entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#postForLocation(String,%20Object,%20Object...)">postForLocation(String
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#postForLocation(String,%20Object,%20Object...)">postForLocation(String
url, Object request, String… urlVariables)</ulink></entry>
</row>
<row>
<entry></entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#postForObject(java.lang.String,%20java.lang.Object,%20java.lang.Class,%20java.lang.String...)">postForObject(String
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#postForObject(java.lang.String,%20java.lang.Object,%20java.lang.Class,%20java.lang.String...)">postForObject(String
url, Object request, Class<T> responseType, String…
uriVariables)</ulink></entry>
</row>
@@ -1329,7 +1329,7 @@ if (HttpStatus.SC_CREATED == post.getStatusCode()) {
<entry>PUT</entry>
<entry><ulink
- url="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/client/RestTemplate.html#put(String,%20Object,%20Object...)">put(String
+ url="http://static.springsource.org/spring/docs/current/api/org/springframework/web/client/RestTemplate.html#put(String,%20Object,%20Object...)">put(String
url, Object request, String…urlVariables)</ulink></entry>
</row>
</tbody> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/scheduling.xml | @@ -821,7 +821,7 @@ public class ExampleJob extends QuartzJobBean {
<classname>SchedulerFactoryBean</classname> for you to set, such as the
calendars used by the job details, properties to customize Quartz with,
etc. Have a look at the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/scheduling/quartz/SchedulerFactoryBean.html">SchedulerFactoryBean
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/scheduling/quartz/SchedulerFactoryBean.html">SchedulerFactoryBean
Javadoc</ulink> for more information.</para>
</section>
</section> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/spring-form.tld.xml | @@ -63,7 +63,7 @@
<para>Renders an HTML 'input' tag with type 'checkbox'.</para>
<table id="spring-form.tld.checkbox.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -464,7 +464,7 @@
<para>Renders multiple HTML 'input' tags with type 'checkbox'.</para>
<table id="spring-form.tld.checkboxes.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -907,7 +907,7 @@
<para>Renders field errors in an HTML 'span' tag.</para>
<table id="spring-form.tld.errors.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -1224,7 +1224,7 @@
<para>Renders an HTML 'form' tag and exposes a binding path to inner tags for binding.</para>
<table id="spring-form.tld.form.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -1627,7 +1627,7 @@
<para>Renders an HTML 'input' tag with type 'hidden' using the bound value.</para>
<table id="spring-form.tld.hidden.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -1692,7 +1692,7 @@
<para>Renders an HTML 'input' tag with type 'text' using the bound value.</para>
<table id="spring-form.tld.input.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -2149,7 +2149,7 @@
<para>Renders a form field label in an HTML 'label' tag.</para>
<table id="spring-form.tld.label.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -2466,7 +2466,7 @@
<para>Renders a single HTML 'option'. Sets 'selected' as appropriate based on bound value.</para>
<table id="spring-form.tld.option.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -2797,7 +2797,7 @@
<para>Renders a list of HTML 'option' tags. Sets 'selected' as appropriate based on bound value.</para>
<table id="spring-form.tld.options.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -3142,7 +3142,7 @@
<para>Renders an HTML 'input' tag with type 'password' using the bound value.</para>
<table id="spring-form.tld.password.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -3613,7 +3613,7 @@
<para>Renders an HTML 'input' tag with type 'radio'.</para>
<table id="spring-form.tld.radiobutton.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -4014,7 +4014,7 @@
<para>Renders multiple HTML 'input' tags with type 'radio'.</para>
<table id="spring-form.tld.radiobuttons.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -4457,7 +4457,7 @@
<para>Renders an HTML 'select' element. Supports databinding to the selected option.</para>
<table id="spring-form.tld.select.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/>
@@ -4900,7 +4900,7 @@
<para>Renders an HTML 'textarea'.</para>
<table id="spring-form.tld.textarea.table">
<title>Attributes</title>
- <tgroup cols="3">
+ <tgroup cols="4">
<colspec align="center" colname="Attribute"/>
<colspec align="center" colname="Required"/>
<colspec align="center" colname="Runtime.Expression"/> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/transaction.xml | @@ -718,7 +718,8 @@ TR: OK AS IS. images don't show up in the editor, but they do show up in the gen
<para><mediaobject>
<imageobject role="fo">
- <imagedata align="center" fileref="images/tx.png" format="PNG" />
+ <imagedata align="center" fileref="images/tx.png" format="PNG"
+ width="400"/>
</imageobject>
<imageobject role="html">
@@ -1847,13 +1848,18 @@ TR: REVISED, PLS REVIEW - changed it back; it's not just settings, the section d
<title>Required</title>
<para><mediaobject>
- <imageobject>
+ <imageobject role="fo">
<imagedata align="center" fileref="images/tx_prop_required.png"
- format="PNG" />
+ format="PNG" width="400"/>
</imageobject>
- <caption><para>PROPAGATION_REQUIRED</para></caption>
- </mediaobject></para>
+ <imageobject role="html">
+ <imagedata align="center" fileref="images/tx_prop_required.png"
+ format="PNG" width="400"/>
+ </imageobject>
+
+ <caption><para>PROPAGATION_REQUIRED</para></caption>
+ </mediaobject></para>
<para>When the propagation setting is
<literal>PROPAGATION_REQUIRED</literal>, a | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/validation.xml | @@ -211,9 +211,9 @@
<para>More information on the
<interfacename>MessageCodesResolver</interfacename> and the default
strategy can be found online with the Javadocs for <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/validation/MessageCodesResolver.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/validation/MessageCodesResolver.html"
>MessageCodesResolver</ulink> and <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/validation/DefaultMessageCodesResolver.html"
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/validation/DefaultMessageCodesResolver.html"
>DefaultMessageCodesResolver</ulink> respectively.</para>
</section>
| true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/view.xml | @@ -1141,7 +1141,7 @@ findOwnersForm.url=/WEB-INF/jsp/findOwners.jsp
</bean></programlisting>
<para>Refer to the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/ui/velocity/VelocityEngineFactory.html">API
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/ui/velocity/VelocityEngineFactory.html">API
documentation</ulink> for Spring configuration of Velocity, or the
Velocity documentation for examples and definitions of the
<filename>'velocity.properties'</filename> file itself.</para> | true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/web-integration.xml | @@ -84,7 +84,7 @@
contains all of the 'business beans' in one's application.</para>
<para>On to specifics: all that one need do is to declare a <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/context/ContextLoaderListener.html"><classname>ContextLoaderListener</classname></ulink>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/context/ContextLoaderListener.html"><classname>ContextLoaderListener</classname></ulink>
in the standard Java EE servlet <literal>web.xml</literal> file of one's web
application, and add a <literal>contextConfigLocation</literal>
<context-param/> section (in the same file) that defines which set
@@ -107,7 +107,7 @@
context parameter, the <classname>ContextLoaderListener</classname> will
look for a file called <literal>/WEB-INF/applicationContext.xml</literal>
to load. Once the context files are loaded, Spring creates a <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/context/WebApplicationContext.html"><classname>WebApplicationContext</classname></ulink>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/context/WebApplicationContext.html"><classname>WebApplicationContext</classname></ulink>
object based on the bean definitions and stores it in the
<interface>ServletContext</interface> of the web application.</para>
@@ -119,7 +119,7 @@
<programlisting language="java">WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);</programlisting>
<para>The <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/context/support/WebApplicationContextUtils.html"><classname>WebApplicationContextUtils</classname></ulink>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/context/support/WebApplicationContextUtils.html"><classname>WebApplicationContextUtils</classname></ulink>
class is for convenience, so you don't have to remember the name of the
<interface>ServletContext</interface> attribute. Its
<emphasis>getWebApplicationContext()</emphasis> method will return
@@ -177,7 +177,7 @@
<para>The easiest way to integrate one's Spring middle-tier with one's
JSF web layer is to use the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/jsf/DelegatingVariableResolver.html">
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/jsf/DelegatingVariableResolver.html">
<classname>DelegatingVariableResolver</classname></ulink> class. To
configure this variable resolver in one's application, one will need to
edit one's <emphasis>faces-context.xml</emphasis> file. After the
@@ -275,7 +275,7 @@
well when mapping one's properties to beans in
<emphasis>faces-config.xml</emphasis>, but at times one may need to grab
a bean explicitly. The <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/jsf/FacesContextUtils.html">
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/jsf/FacesContextUtils.html">
<classname>FacesContextUtils</classname></ulink> class makes this easy.
It is similar to <classname>WebApplicationContextUtils</classname>,
except that it takes a <classname>FacesContext</classname> parameter
@@ -334,7 +334,7 @@
<title>ContextLoaderPlugin</title>
<para>The <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/ContextLoaderPlugIn.html"><classname>ContextLoaderPlugin</classname></ulink>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/ContextLoaderPlugIn.html"><classname>ContextLoaderPlugin</classname></ulink>
is a Struts 1.1+ plug-in that loads a Spring context file for the Struts
<classname>ActionServlet</classname>. This context refers to the root
<classname>WebApplicationContext</classname> (loaded by the
@@ -405,7 +405,7 @@
<title>DelegatingRequestProcessor</title>
<para>To configure the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/DelegatingRequestProcessor.html">
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/DelegatingRequestProcessor.html">
<literal>DelegatingRequestProcessor</literal></ulink> in your
<emphasis>struts-config.xml</emphasis> file, override the
"processorClass" property in the <controller> element. These
@@ -433,7 +433,7 @@
<note>
<para>If you are using Tiles in your Struts application, you must
configure your <controller> with the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/DelegatingTilesRequestProcessor.html"><classname>DelegatingTilesRequestProcessor</classname></ulink>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/DelegatingTilesRequestProcessor.html"><classname>DelegatingTilesRequestProcessor</classname></ulink>
instead.</para>
</note>
</section>
@@ -445,7 +445,7 @@
can't use the <classname>DelegatingRequestProcessor</classname> or
<classname>DelegatingTilesRequestProcessor</classname> approaches, you
can use the <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/DelegatingActionProxy.html">
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/DelegatingActionProxy.html">
<classname>DelegatingActionProxy</classname></ulink> as the type in
your action-mapping.</para>
@@ -483,7 +483,7 @@
is to extend Spring's <classname>Action</classname> classes for Struts.
For example, instead of subclassing Struts'
<classname>Action</classname> class, you can subclass Spring's <ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/ActionSupport.html">
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/ActionSupport.html">
<classname>ActionSupport</classname></ulink> class.</para>
<para>The <classname>ActionSupport</classname> class provides additional
@@ -512,23 +512,23 @@
to the name: <itemizedlist spacing="compact">
<listitem>
<para><ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/ActionSupport.html"><classname>ActionSupport</classname></ulink>,</para>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/ActionSupport.html"><classname>ActionSupport</classname></ulink>,</para>
</listitem>
<listitem>
<para><ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/DispatchActionSupport.html"><literal>DispatchActionSupport</literal></ulink>,</para>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/DispatchActionSupport.html"><literal>DispatchActionSupport</literal></ulink>,</para>
</listitem>
<listitem>
<para><ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/LookupDispatchActionSupport.html"><literal>LookupDispatchActionSupport</literal></ulink>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/LookupDispatchActionSupport.html"><literal>LookupDispatchActionSupport</literal></ulink>
and</para>
</listitem>
<listitem>
<para><ulink
- url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/struts/MappingDispatchActionSupport.html"><literal>MappingDispatchActionSupport</literal></ulink>.</para>
+ url="http://static.springframework.org/spring/docs/current/api/org/springframework/web/struts/MappingDispatchActionSupport.html"><literal>MappingDispatchActionSupport</literal></ulink>.</para>
</listitem>
</itemizedlist></para>
| true |
Other | spring-projects | spring-framework | 86b5066a96d5b3f5b35ad932cedea806ae92676e.json | Fix minor problems and polish reference docs
Problems
- Eliminate — in favor of —
— was causing 'no such entity' errors during docbook
processing; — produces the equivalent output.
- Fix column issues in appendices
column counts were set to 3, when they are in fact 4. This passed
under DocBook 4 and Spring Build for unknown reasons, but caused a
hard stop under DocBook 5 and the docbook-reference-plugin.
- Add jdbc callout section in docbook 5-friendly style
use <co/> tags as advertised in DocBook documentation.
- Set correct widths for PDF ref doc images
images were rendering larger than the PDF page; just set all to
width=400 and everything looks good.
Polish
- Update reference doc copyright to 2012
- Remove "work-in-progress" language from ref docs
- Update maven URLs to repo.springsource.org
- Update javadoc urls from 3.0.x/javadoc-api => current/api
- Replace hardcoded "3.1" with ${version} in ref doc | src/reference/docbook/xsd-configuration.xml | @@ -140,7 +140,7 @@ http://www.springframework.org/schema/beans http://www.springframework.org/schem
<section id="xsd-config-body-schemas-util-frfb">
<title>Setting a bean property or constructor arg from a field value</title>
<para>
- <ulink url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/config/FieldRetrievingFactoryBean.html"><classname>FieldRetrievingFactoryBean</classname></ulink>
+ <ulink url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/config/FieldRetrievingFactoryBean.html"><classname>FieldRetrievingFactoryBean</classname></ulink>
is a <interfacename>FactoryBean</interfacename> which retrieves a
<literal>static</literal> or non-static field value. It is typically
used for retrieving <literal>public</literal> <literal>static</literal>
@@ -149,7 +149,7 @@ http://www.springframework.org/schema/beans http://www.springframework.org/schem
</para>
<para>
Find below an example which shows how a <literal>static</literal> field is exposed, by
- using the <ulink url="http://static.springframework.org/spring/docs/3.0.x/javadoc-api/org/springframework/beans/factory/config/FieldRetrievingFactoryBean.html#setStaticField(java.lang.String)"><literal>staticField</literal></ulink>
+ using the <ulink url="http://static.springframework.org/spring/docs/current/api/org/springframework/beans/factory/config/FieldRetrievingFactoryBean.html#setStaticField(java.lang.String)"><literal>staticField</literal></ulink>
property:
</para>
<programlisting language="xml"><
-and [Reference docs](http://static.springsource.org/spring/docs/current/spring-framework-reference).
+See the current [Javadoc](http://static.springsource.org/spring-framework/docs/current/api)
+and [Reference docs](http://static.springsource.org/spring-framework/docs/current/reference).
## Getting support
Check out the [Spring forums](http://forum.springsource.org) and the | false |
Other | spring-projects | spring-framework | 66d4e45b58b626e7fdd3f25206e06a20694a99e5.json | add getCacheManager() for access to native class | org.springframework.context/src/main/java/org/springframework/cache/ehcache/EhCacheCacheManager.java | @@ -39,7 +39,15 @@ public class EhCacheCacheManager extends AbstractCacheManager {
/**
- * Set the backing EhCache {@link net.sf.ehcache.CacheManager}.
+ * Returns the backing Ehcache {@link net.sf.ehcache.CacheManager}.
+ * @return
+ */
+ public net.sf.ehcache.CacheManager getCacheManager() {
+ return cacheManager;
+ }
+
+ /**
+ * Sets the backing EhCache {@link net.sf.ehcache.CacheManager}.
*/
public void setCacheManager(net.sf.ehcache.CacheManager cacheManager) {
this.cacheManager = cacheManager;
@@ -75,5 +83,4 @@ public Cache getCache(String name) {
}
return cache;
}
-
-}
+}
\ No newline at end of file | false |
Other | spring-projects | spring-framework | 0053319c6279a55094a723dc5fc0955b901cfd1c.json | Add test to corner potential bug with @CacheEvict
Cannot yet actually reproduce the issue, but this remains a useful
test case.
Issue: SPR-8934 | org.springframework.context/src/test/java/org/springframework/cache/annotation/AnnotationCacheOperationSourceTest.java | @@ -114,6 +114,10 @@ public void singleStereotype() {
@EvictBar
public void multipleStereotype() {
}
+
+ @Caching(cacheable = { @Cacheable(value = "test", key = "a"), @Cacheable(value = "test", key = "b") })
+ public void multipleCaching() {
+ }
}
@Retention(RetentionPolicy.RUNTIME) | true |
Other | spring-projects | spring-framework | 0053319c6279a55094a723dc5fc0955b901cfd1c.json | Add test to corner potential bug with @CacheEvict
Cannot yet actually reproduce the issue, but this remains a useful
test case.
Issue: SPR-8934 | org.springframework.context/src/test/java/org/springframework/cache/interceptor/ExpressionEvalutatorTest.java | @@ -0,0 +1,86 @@
+/*
+ * Copyright 2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cache.interceptor;
+
+import static org.junit.Assert.*;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.junit.Test;
+import org.springframework.cache.Cache;
+import org.springframework.cache.annotation.AnnotationCacheOperationSource;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.cache.annotation.Caching;
+import org.springframework.cache.concurrent.ConcurrentMapCache;
+import org.springframework.expression.EvaluationContext;
+import org.springframework.util.ReflectionUtils;
+
+import edu.emory.mathcs.backport.java.util.Collections;
+
+public class ExpressionEvalutatorTest {
+ private ExpressionEvaluator eval = new ExpressionEvaluator();
+
+ private AnnotationCacheOperationSource source = new AnnotationCacheOperationSource();
+
+ private Collection<CacheOperation> getOps(String name) {
+ Method method = ReflectionUtils.findMethod(AnnotatedClass.class, name, Object.class, Object.class);
+ return source.getCacheOperations(method, AnnotatedClass.class);
+ }
+
+ @Test
+ public void testMultipleCachingSource() throws Exception {
+ Collection<CacheOperation> ops = getOps("multipleCaching");
+ assertEquals(2, ops.size());
+ Iterator<CacheOperation> it = ops.iterator();
+ CacheOperation next = it.next();
+ assertTrue(next instanceof CacheableOperation);
+ assertTrue(next.getCacheNames().contains("test"));
+ assertEquals("#a", next.getKey());
+ next = it.next();
+ assertTrue(next instanceof CacheableOperation);
+ assertTrue(next.getCacheNames().contains("test"));
+ assertEquals("#b", next.getKey());
+ }
+
+ @Test
+ public void testMultipleCachingEval() throws Exception {
+ AnnotatedClass target = new AnnotatedClass();
+ Method method = ReflectionUtils.findMethod(AnnotatedClass.class, "multipleCaching", Object.class,
+ Object.class);
+ Object[] args = new Object[] { new Object(), new Object() };
+ Collection<Cache> map = Collections.singleton(new ConcurrentMapCache("test"));
+
+ EvaluationContext evalCtx = eval.createEvaluationContext(map, method, args, target, target.getClass());
+ Collection<CacheOperation> ops = getOps("multipleCaching");
+
+ Iterator<CacheOperation> it = ops.iterator();
+
+ Object keyA = eval.key(it.next().getKey(), method, evalCtx);
+ Object keyB = eval.key(it.next().getKey(), method, evalCtx);
+
+ assertEquals(args[0], keyA);
+ assertEquals(args[1], keyB);
+ }
+
+ private static class AnnotatedClass {
+ @Caching(cacheable = { @Cacheable(value = "test", key = "#a"), @Cacheable(value = "test", key = "#b") })
+ public void multipleCaching(Object a, Object b) {
+ }
+ }
+}
\ No newline at end of file | true |
Other | spring-projects | spring-framework | 02cd8681d42b069fc7040357738dd1ac8c1ce20b.json | Normalize whitespace in cache reference doc | spring-framework-reference/src/cache.xml | @@ -3,34 +3,34 @@
"http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
<chapter id="cache">
- <title>Cache Abstraction</title>
-
- <section id="cache-introduction">
- <title>Introduction</title>
-
- <para>Since version 3.1, Spring Framework provides support for transparently
- adding caching into an existing Spring application. Similar to the <link linkend="transaction">transaction</link>
- support, the caching abstraction allows consistent use of various caching
- solutions with minimal impact on the code.</para>
- </section>
-
- <section id="cache-strategies">
+ <title>Cache Abstraction</title>
+
+ <section id="cache-introduction">
+ <title>Introduction</title>
+
+ <para>Since version 3.1, Spring Framework provides support for transparently
+ adding caching into an existing Spring application. Similar to the <link linkend="transaction">transaction</link>
+ support, the caching abstraction allows consistent use of various caching
+ solutions with minimal impact on the code.</para>
+ </section>
+
+ <section id="cache-strategies">
<title>Understanding the cache abstraction</title>
-
+
<sidebar>
<title>Cache vs Buffer</title>
<para>The terms "buffer" and "cache" tend to be used interchangeably; note however they represent different things.
- A buffer is used traditionally as an intermediate temporary store for data between a fast and a slow entity. As one
+ A buffer is used traditionally as an intermediate temporary store for data between a fast and a slow entity. As one
party would have to <emphasis>wait</emphasis> for the other affecting performance, the buffer alleviates this by
allowing entire blocks of data to move at once rather then in small chunks. The data is written and read only once from
- the buffer. Further more, the buffers are <emphasis>visible</emphasis> to at least one party which is aware of it.</para>
+ the buffer. Furthermore, the buffers are <emphasis>visible</emphasis> to at least one party which is aware of it.</para>
<para>A cache on the other hand by definition is hidden and neither party is aware that caching occurs.It as well improves
- performance but does that by allowing the same data to be read multiple times in a fast fashion.</para>
-
- <para>A further explanation of the differences between two can be found
+ performance but does that by allowing the same data to be read multiple times in a fast fashion.</para>
+
+ <para>A further explanation of the differences between two can be found
<ulink url="http://en.wikipedia.org/wiki/Cache#The_difference_between_buffer_and_cache">here</ulink>.</para>
</sidebar>
-
+
<para>At its core, the abstraction applies caching to Java methods, reducing thus the number of executions based on the
information available in the cache. That is, each time a <emphasis>targeted</emphasis> method is invoked, the abstraction
will apply a caching behaviour checking whether the method has been already executed for the given arguments. If it has,
@@ -39,90 +39,90 @@
This way, expensive methods (whether CPU or IO bound) can be executed only once for a given set of parameters and the result
reused without having to actually execute the method again. The caching logic is applied transparently without any interference
to the invoker.</para>
-
+
<important>Obviously this approach works only for methods that are guaranteed to return the same output (result) for a given input
(or arguments) no matter how many times it is being executed.</important>
-
+
<para>To use the cache abstraction, the developer needs to take care of two aspects:
<itemizedlist>
<listitem>caching declaration - identify the methods that need to be cached and their policy</listitem>
<listitem>cache configuration - the backing cache where the data is stored and read from</listitem>
</itemizedlist>
</para>
-
+
<para>Note that just like other services in Spring Framework, the caching service is an abstraction (not a cache implementation) and requires
the use of an actual storage to store the cache data - that is, the abstraction frees the developer from having to write the caching
logic but does not provide the actual stores. There are two integrations available out of the box, for JDK <literal>java.util.concurrent.ConcurrentMap</literal>
and <ulink url="http://ehcache.org/">Ehcache</ulink> - see <xref linkend="cache-plug"/> for more information on plugging in other cache stores/providers.</para>
- </section>
-
- <section id="cache-annotations">
+ </section>
+
+ <section id="cache-annotations">
<title>Declarative annotation-based caching</title>
-
+
<para>For caching declaration, the abstraction provides two Java annotations: <literal>@Cacheable</literal> and <literal>@CacheEvict</literal> which allow methods
to trigger cache population or cache eviction. Let us take a closer look at each annotation:</para>
-
+
<section id="cache-annotations-cacheable">
<title><literal>@Cacheable</literal> annotation</title>
-
+
<para>As the name implies, <literal>@Cacheable</literal> is used to demarcate methods that are cacheable - that is, methods for whom the result is stored into the cache
- so on subsequent invocations (with the same arguments), the value in the cache is returned without having to actually execute the method. In its simplest form,
+ so on subsequent invocations (with the same arguments), the value in the cache is returned without having to actually execute the method. In its simplest form,
the annotation declaration requires the name of the cache associated with the annotated method:</para>
-
+
<programlisting language="java"><![CDATA[@Cacheable("books")
public Book findBook(ISBN isbn) {...}]]></programlisting>
-
+
<para>In the snippet above, the method <literal>findBook</literal> is associated with the cache named <literal>books</literal>. Each time the method is called, the cache
is checked to see whether the invocation has been already executed and does not have to be repeated. While in most cases, only one cache is declared, the annotation allows multiple
names to be specified so that more then one cache are being used. In this case, each of the caches will be checked before executing the method - if at least one cache is hit,
then the associated value will be returned:</para>
<note>All the other caches that do not contain the method will be updated as well even though the cached method was not actually
executed.</note>
-
+
<programlisting language="java"><![CDATA[@Cacheable({ "books", "isbns" })
public Book findBook(ISBN isbn) {...}]]></programlisting>
<section id="cache-annotations-cacheable-default-key">
<title>Default Key Generation</title>
-
+
<para>Since caches are essentially key-value stores, each invocation of a cached method needs to be translated into a suitable key for cache access.
Out of the box, the caching abstraction uses a simple <interfacename>KeyGenerator</interfacename> based on the following algorithm:</para>
<itemizedlist>
- <listitem>If no params are given, return 0.</listitem>
- <listitem>If only one param is given, return that instance.</listitem>
- <listitem>If more the one param is given, return a key computed from the hashes of all parameters.</listitem>
+ <listitem>If no params are given, return 0.</listitem>
+ <listitem>If only one param is given, return that instance.</listitem>
+ <listitem>If more the one param is given, return a key computed from the hashes of all parameters.</listitem>
</itemizedlist>
<para>
This approach works well for objects with <emphasis>natural keys</emphasis> as long as the <literal>hashCode()</literal> reflects that. If that is not the case then
- for distributed or persistent environments, the strategy needs to be changed as the objects hashCode is not preserved.
+ for distributed or persistent environments, the strategy needs to be changed as the objects hashCode is not preserved.
In fact, depending on the JVM implementation or running conditions, the same hashCode can be reused for different objects, in the same VM instance.</para>
-
+
<para>To provide a different <emphasis>default</emphasis> key generator, one needs to implement the <interfacename>org.springframework.cache.KeyGenerator</interfacename> interface.
Once configured, the generator will be used for each declaration that doesn not specify its own key generation strategy (see below).
</para>
</section>
<section id="cache-annotations-cacheable-key">
<title>Custom Key Generation Declaration</title>
-
- <para>Since caching is generic, it is quite likely the target methods have various signatures that cannot be simply mapped on top of the cache structure. This tends to become
+
+ <para>Since caching is generic, it is quite likely the target methods have various signatures that cannot be simply mapped on top of the cache structure. This tends to become
obvious when the target method has multiple arguments out of which only some are suitable for caching (while the rest are used only by the method logic). For example:</para>
-
+
<programlisting language="java"><![CDATA[@Cacheable("books")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed]]></programlisting>
<para>At first glance, while the two <literal>boolean</literal> arguments influence the way the book is found, they are no use for the cache. Further more what if only one of the two
is important while the other is not?</para>
-
+
<para>For such cases, the <literal>@Cacheable</literal> annotation allows the user to specify how the key is generated through its <literal>key</literal> attribute.
The developer can use <link linkend="expressions">SpEL</link> to pick the arguments of interest (or their nested properties), perform operations or even invoke arbitrary methods without
having to write any code or implement any interface. This is the recommended approach over the <link linkend="cache-annotations-cacheable-default-key">default</link> generator since
methods tend to be quite different in signatures as the code base grows; while the default strategy might work for some methods, it rarely does for all methods.</para>
-
+
<para>
- Below are some examples of various SpEL declarations - if you are not familiar with it, do yourself a favour and read <xref linkend="expressions"/>:
+ Below are some examples of various SpEL declarations - if you are not familiar with it, do yourself a favour and read <xref linkend="expressions"/>:
</para>
-
+
<programlisting language="java"><!-- select 'isbn' argument -->
@Cacheable(value="books", <emphasis role="bold">key="#isbn"</emphasis>
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)
@@ -137,83 +137,83 @@ public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)</pr
<para>The snippets above, show how easy it is to select a certain argument, one of its properties or even an arbitrary (static) method.</para>
</section>
-
+
<section id="cache-annotations-cacheable-condition">
<title>Conditional caching</title>
-
+
<para>Sometimes, a method might not be suitable for caching all the time (for example, it might depend on the given arguments). The cache annotations support such functionality
through the <literal>conditional</literal> parameter which takes a <literal>SpEL</literal> expression that is evaluated to either <literal>true</literal> or <literal>false</literal>.
If <literal>true</literal>, the method is cached - if not, it behaves as if the method is not cached, that is executed every since time no matter what values are in the cache or what
arguments are used. A quick example - the following method will be cached, only if the argument <literal>name</literal> has a length shorter then 32:</para>
-
+
<programlisting language="java"><![CDATA[@Cacheable(value="book", condition="#name.length < 32")
public Book findBook(String name)]]></programlisting>
</section>
-
+
<section id="cache-spel-context">
<title>Available caching <literal>SpEL</literal> evaluation context</title>
-
+
<para>Each <literal>SpEL</literal> expression evaluates again a dedicated <literal><link linkend="expressions-language-ref">context</link></literal>. In addition
to the build in parameters, the framework provides dedicated caching related metadata such as the argument names. The next table lists the items made available to the context
so one can use them for key and conditional(see next section) computations:</para>
-
- <table id="cache-spel-context-tbl" pgwide="1">
- <title>Cache SpEL available metadata</title>
- <tgroup cols="4">
- <colspec align="center" />
- <thead>
- <row>
- <entry>Name</entry>
- <entry>Location</entry>
- <entry>Description</entry>
- <entry>Example</entry>
- </row>
- </thead>
+
+ <table id="cache-spel-context-tbl" pgwide="1">
+ <title>Cache SpEL available metadata</title>
+ <tgroup cols="4">
+ <colspec align="center" />
+ <thead>
+ <row>
+ <entry>Name</entry>
+ <entry>Location</entry>
+ <entry>Description</entry>
+ <entry>Example</entry>
+ </row>
+ </thead>
<tbody>
- <row>
- <entry>methodName</entry>
- <entry>root object</entry>
- <entry>The name of the method being invoked</entry>
- <entry><screen>#root.methodName</screen></entry>
- </row>
- <row>
- <entry>method</entry>
- <entry>root object</entry>
- <entry>The method being invoked</entry>
- <entry><screen>#root.method.name</screen></entry>
- </row>
- <row>
- <entry>target</entry>
- <entry>root object</entry>
- <entry>The target object being invoked</entry>
- <entry><screen>#root.target</screen></entry>
- </row>
- <row>
- <entry>targetClass</entry>
- <entry>root object</entry>
- <entry>The class of the target being invoked</entry>
- <entry><screen>#root.targetClass</screen></entry>
- </row>
- <row>
- <entry>params</entry>
- <entry>root object</entry>
- <entry>The arguments (as array) used for invoking the target</entry>
- <entry><screen>#root.params[0]</screen></entry>
- </row>
- <row>
- <entry>caches</entry>
- <entry>root object</entry>
- <entry>Collection of caches against which the current method is executed</entry>
- <entry><screen>#root.caches[0].name</screen></entry>
- </row>
- <row>
- <entry><emphasis>parameter name</emphasis></entry>
- <entry>evaluation context</entry>
- <entry>Name of any of the method parameter. If for some reason the names are not available (ex: no debug information),
- the parameter names are also available under the <literal><![CDATA[p<#arg>]]></literal> where
- <emphasis><![CDATA[#arg]]></emphasis> stands for the parameter index (starting from 0).</entry>
- <entry><screen>iban</screen> or <screen>p0</screen></entry>
- </row>
+ <row>
+ <entry>methodName</entry>
+ <entry>root object</entry>
+ <entry>The name of the method being invoked</entry>
+ <entry><screen>#root.methodName</screen></entry>
+ </row>
+ <row>
+ <entry>method</entry>
+ <entry>root object</entry>
+ <entry>The method being invoked</entry>
+ <entry><screen>#root.method.name</screen></entry>
+ </row>
+ <row>
+ <entry>target</entry>
+ <entry>root object</entry>
+ <entry>The target object being invoked</entry>
+ <entry><screen>#root.target</screen></entry>
+ </row>
+ <row>
+ <entry>targetClass</entry>
+ <entry>root object</entry>
+ <entry>The class of the target being invoked</entry>
+ <entry><screen>#root.targetClass</screen></entry>
+ </row>
+ <row>
+ <entry>params</entry>
+ <entry>root object</entry>
+ <entry>The arguments (as array) used for invoking the target</entry>
+ <entry><screen>#root.params[0]</screen></entry>
+ </row>
+ <row>
+ <entry>caches</entry>
+ <entry>root object</entry>
+ <entry>Collection of caches against which the current method is executed</entry>
+ <entry><screen>#root.caches[0].name</screen></entry>
+ </row>
+ <row>
+ <entry><emphasis>parameter name</emphasis></entry>
+ <entry>evaluation context</entry>
+ <entry>Name of any of the method parameter. If for some reason the names are not available (ex: no debug information),
+ the parameter names are also available under the <literal><![CDATA[p<#arg>]]></literal> where
+ <emphasis><![CDATA[#arg]]></emphasis> stands for the parameter index (starting from 0).</entry>
+ <entry><screen>iban</screen> or <screen>p0</screen></entry>
+ </row>
</tbody>
</tgroup>
</table>
@@ -222,314 +222,314 @@ public Book findBook(String name)]]></programlisting>
<section id="cache-annotations-put">
<title><literal>@CachePut</literal> annotation</title>
-
+
<para>For cases where the cache needs to be updated without interferring with the method execution, one can use the <literal>@CachePut</literal> annotation. That is, the method will always
be executed and its result placed into the cache (according to the <literal>@CachePut</literal> options). It supports the same options as <literal>@Cacheable</literal> and should be used
for cache population rather then method flow optimization.</para>
-
+
<para>Note that using <literal>@CachePut</literal> and <literal>@Cacheable</literal> annotations on the same method is generaly discouraged because they have different behaviours. While the latter
causes the method execution to be skipped by using the cache, the former forces the execution in order to execute a cache update. This leads to unexpected behaviour and with the exception of specific
corner-cases (such as annotations having conditions that exclude them from each other), such declarations should be avoided.</para>
- </section>
-
+ </section>
+
<section id="cache-annotations-evict">
<title><literal>@CacheEvict</literal> annotation</title>
-
- <para>The cache abstraction allows not just population of a cache store but also eviction. This process is useful for removing stale or unused data from the cache. Opposed to
+
+ <para>The cache abstraction allows not just population of a cache store but also eviction. This process is useful for removing stale or unused data from the cache. Opposed to
<literal>@Cacheable</literal>, annotation <literal>@CacheEvict</literal> demarcates methods that perform cache <emphasis>eviction</emphasis>, that is methods that act as triggers
for removing data from the cache. Just like its sibling, <literal>@CacheEvict</literal> requires one to specify one (or multiple) caches that are affected by the action, allows a
key or a condition to be specified but in addition, features an extra parameter <literal>allEntries</literal> which indicates whether a cache-wide eviction needs to be performed
rather then just an entry one (based on the key):</para>
-
+
<programlisting language="java"><![CDATA[@CacheEvict(value = "books", allEntries=true)
public void loadBooks(InputStream batch)]]></programlisting>
-
- <para>This option comes in handy when an entire cache region needs to be cleared out - rather then evicting each entry (which would take a long time since it is inefficient),
+
+ <para>This option comes in handy when an entire cache region needs to be cleared out - rather then evicting each entry (which would take a long time since it is inefficient),
all the entires are removed in one operation as shown above. Note that the framework will ignore any key specified in this scenario as it does not apply (the entire cache is evicted not just
one entry).</para>
-
+
<para>One can also indicate whether the eviction should occur after (the default) or before the method executes through the <literal>beforeInvocation</literal> attribute.
The former provides the same semantics as the rest of the annotations - once the method completes successfully, an action (in this case eviction) on the cache is executed. If the method does not
execute (as it might be cached) or an exception is thrown, the eviction does not occur. The latter (<literal>beforeInvocation=true</literal>) causes the eviction to occur always, before the method
is invoked - this is useful in cases where the eviction does not need to be tied to the method outcome.</para>
-
+
<para>It is important to note that void methods can be used with <literal>@CacheEvict</literal> - as the methods act as triggers, the return values are ignored (as they don't interact with
the cache) - this is not the case with <literal>@Cacheable</literal> which adds/update data into the cache and thus requires a result.</para>
</section>
-
+
<section id="cache-annotations-caching">
<title><literal>@Caching</literal> annotation</title>
-
+
<para>There are cases when multiple annotations of the same type, such as <literal>@CacheEvict</literal> or <literal>@CachePut</literal> need to be specified, for example because the condition or the key
expression is different between different caches. Unfortunately Java does not support such declarations however there is a workaround - using a <emphasis>enclosing</emphasis> annotation, in this case,
<literal>@Caching</literal>. <literal>@Caching</literal> allows multiple nested <literal>@Cacheable</literal>, <literal>@CachePut</literal> and <literal>@CacheEvict</literal> to be used on the same method:</para>
-
+
<programlisting language="java"><![CDATA[@Caching(evict = { @CacheEvict("primary"), @CacheEvict(value = "secondary", key = "#p0") })
public Book importBooks(String deposit, Date date)]]></programlisting>
-
+
</section>
<section id="cache-annotation-enable">
<title>Enable caching annotations</title>
-
+
<para>It is important to note that even though declaring the cache annotations does not automatically triggers their actions - like many things in Spring, the feature has to be declaratively
enabled (which means if you ever suspect caching is to blame, you can disable it by removing only one configuration line rather then all the annotations in your code). In practice, this
translates to one line that informs Spring that it should process the cache annotations, namely:</para>
-
+
<programlisting language="xml"><![CDATA[<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"]]>
- <emphasis role="bold">xmlns:cache="http://www.springframework.org/schema/cache"</emphasis><![CDATA[
- xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd]]>
- <emphasis role="bold">http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd</emphasis><![CDATA[">]]>
- <emphasis role="bold"><![CDATA[<cache:annotation-driven />]]></emphasis>
+ <emphasis role="bold">xmlns:cache="http://www.springframework.org/schema/cache"</emphasis><![CDATA[
+ xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd]]>
+ <emphasis role="bold">http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd</emphasis><![CDATA[">]]>
+ <emphasis role="bold"><![CDATA[<cache:annotation-driven />]]></emphasis>
<![CDATA[</beans>]]></programlisting>
-
+
<para>The namespace allows various options to be specified that influence the way the caching behaviour is added to the application through AOP. The configuration is similar (on purpose)
with that of <literal><ulink url="tx-annotation-driven-settings">tx:annotation-driven</ulink></literal>:
</para>
-
- <para><table id="cache-annotation-driven-settings">
- <title><literal><cache:annotation-driven/></literal>
- settings</title>
-
- <tgroup cols="3">
- <thead>
- <row>
- <entry>Attribute</entry>
-
- <entry>Default</entry>
-
- <entry>Description</entry>
- </row>
- </thead>
-
- <tbody>
- <row>
- <entry><literal>cache-manager</literal></entry>
-
- <entry>cacheManager</entry>
-
- <entry><para>Name of cache manager to use. Only required
- if the name of the cache manager is not
- <literal>cacheManager</literal>, as in the example
- above.</para></entry>
- </row>
-
- <row>
- <entry><literal>mode</literal></entry>
-
- <entry>proxy</entry>
-
- <entry><para>The default mode "proxy" processes annotated
- beans to be proxied using Spring's AOP framework (following
- proxy semantics, as discussed above, applying to method calls
- coming in through the proxy only). The alternative mode
- "aspectj" instead weaves the affected classes with Spring's
- AspectJ caching aspect, modifying the target class byte
- code to apply to any kind of method call. AspectJ weaving
- requires spring-aspects.jar in the classpath as well as
- load-time weaving (or compile-time weaving) enabled. (See
- <xref linkend="aop-aj-ltw-spring" /> for details on how to set
- up load-time weaving.)</para></entry>
- </row>
-
- <row>
- <entry><literal>proxy-target-class</literal></entry>
-
- <entry>false</entry>
-
- <entry><para>Applies to proxy mode only. Controls what type of
- caching proxies are created for classes annotated with
- the <interfacename>@Cacheable</interfacename> or <interfacename>@CacheEvict</interfacename> annotations.
- If the <literal>proxy-target-class</literal> attribute is set
- to <literal>true</literal>, then class-based proxies are
- created. If <literal>proxy-target-class</literal> is
- <literal>false</literal> or if the attribute is omitted, then
- standard JDK interface-based proxies are created. (See <xref
- linkend="aop-proxying" /> for a detailed examination of the
- different proxy types.)</para></entry>
- </row>
-
- <row>
- <entry><literal>order</literal></entry>
-
- <entry>Ordered.LOWEST_PRECEDENCE</entry>
-
- <entry><para>Defines the order of the cache advice that
- is applied to beans annotated with
- <interfacename>@Cacheable</interfacename> or <interfacename>@CacheEvict</interfacename>.
- (For more
- information about the rules related to ordering of AOP advice,
- see <xref linkend="aop-ataspectj-advice-ordering" />.) No
- specified ordering means that the AOP subsystem determines the
- order of the advice.</para></entry>
- </row>
- </tbody>
- </tgroup>
- </table></para>
-
- <note>
- <para><literal><cache:annotation-driven/></literal> only looks for
- <interfacename>@Cacheable/@CacheEvict</interfacename> on beans in the same
- application context it is defined in. This means that, if you put
- <literal><cache:annotation-driven/></literal> in a
- <interfacename>WebApplicationContext</interfacename> for a
- <classname>DispatcherServlet</classname>, it only checks for
- <interfacename>@Cacheable/@CacheEvict</interfacename> beans in your
- controllers, and not your services. See <xref
- linkend="mvc-servlet" /> for more information.</para>
- </note>
-
- <sidebar>
- <title>Method visibility and
- <interfacename>@Cacheable/@CachePut/@CacheEvict</interfacename></title>
-
- <para>When using proxies, you should apply the
- <interfacename>@Cache*</interfacename> annotations only to
- methods with <emphasis>public</emphasis> visibility. If you do
- annotate protected, private or package-visible methods with these annotations,
- no error is raised, but the annotated method does not exhibit the configured
- caching settings. Consider the use of AspectJ (see below) if you
- need to annotate non-public methods as it changes the bytecode itself.</para>
- </sidebar>
-
- <para><tip>
- <para>Spring recommends that you only annotate concrete classes (and
- methods of concrete classes) with the
- <interfacename>@Cache*</interfacename> annotation, as opposed
- to annotating interfaces. You certainly can place the
- <interfacename>@Cache*</interfacename> annotation on an
- interface (or an interface method), but this works only as you would
- expect it to if you are using interface-based proxies. The fact that
- Java annotations are <emphasis>not inherited from interfaces</emphasis>
- means that if you are using class-based proxies
- (<literal>proxy-target-class="true"</literal>) or the weaving-based
- aspect (<literal>mode="aspectj"</literal>), then the caching
- settings are not recognized by the proxying and weaving
- infrastructure, and the object will not be wrapped in a
- caching proxy, which would be decidedly
- <emphasis>bad</emphasis>.</para>
- </tip></para>
-
- <note>
- <para>In proxy mode (which is the default), only external method calls
- coming in through the proxy are intercepted. This means that
- self-invocation, in effect, a method within the target object calling
- another method of the target object, will not lead to an actual
- caching at runtime even if the invoked method is marked with
- <interfacename>@Cacheable</interfacename> - considering using the aspectj mode in this case.</para>
- </note>
+
+ <para><table id="cache-annotation-driven-settings">
+ <title><literal><cache:annotation-driven/></literal>
+ settings</title>
+
+ <tgroup cols="3">
+ <thead>
+ <row>
+ <entry>Attribute</entry>
+
+ <entry>Default</entry>
+
+ <entry>Description</entry>
+ </row>
+ </thead>
+
+ <tbody>
+ <row>
+ <entry><literal>cache-manager</literal></entry>
+
+ <entry>cacheManager</entry>
+
+ <entry><para>Name of cache manager to use. Only required
+ if the name of the cache manager is not
+ <literal>cacheManager</literal>, as in the example
+ above.</para></entry>
+ </row>
+
+ <row>
+ <entry><literal>mode</literal></entry>
+
+ <entry>proxy</entry>
+
+ <entry><para>The default mode "proxy" processes annotated
+ beans to be proxied using Spring's AOP framework (following
+ proxy semantics, as discussed above, applying to method calls
+ coming in through the proxy only). The alternative mode
+ "aspectj" instead weaves the affected classes with Spring's
+ AspectJ caching aspect, modifying the target class byte
+ code to apply to any kind of method call. AspectJ weaving
+ requires spring-aspects.jar in the classpath as well as
+ load-time weaving (or compile-time weaving) enabled. (See
+ <xref linkend="aop-aj-ltw-spring" /> for details on how to set
+ up load-time weaving.)</para></entry>
+ </row>
+
+ <row>
+ <entry><literal>proxy-target-class</literal></entry>
+
+ <entry>false</entry>
+
+ <entry><para>Applies to proxy mode only. Controls what type of
+ caching proxies are created for classes annotated with
+ the <interfacename>@Cacheable</interfacename> or <interfacename>@CacheEvict</interfacename> annotations.
+ If the <literal>proxy-target-class</literal> attribute is set
+ to <literal>true</literal>, then class-based proxies are
+ created. If <literal>proxy-target-class</literal> is
+ <literal>false</literal> or if the attribute is omitted, then
+ standard JDK interface-based proxies are created. (See <xref
+ linkend="aop-proxying" /> for a detailed examination of the
+ different proxy types.)</para></entry>
+ </row>
+
+ <row>
+ <entry><literal>order</literal></entry>
+
+ <entry>Ordered.LOWEST_PRECEDENCE</entry>
+
+ <entry><para>Defines the order of the cache advice that
+ is applied to beans annotated with
+ <interfacename>@Cacheable</interfacename> or <interfacename>@CacheEvict</interfacename>.
+ (For more
+ information about the rules related to ordering of AOP advice,
+ see <xref linkend="aop-ataspectj-advice-ordering" />.) No
+ specified ordering means that the AOP subsystem determines the
+ order of the advice.</para></entry>
+ </row>
+ </tbody>
+ </tgroup>
+ </table></para>
+
+ <note>
+ <para><literal><cache:annotation-driven/></literal> only looks for
+ <interfacename>@Cacheable/@CacheEvict</interfacename> on beans in the same
+ application context it is defined in. This means that, if you put
+ <literal><cache:annotation-driven/></literal> in a
+ <interfacename>WebApplicationContext</interfacename> for a
+ <classname>DispatcherServlet</classname>, it only checks for
+ <interfacename>@Cacheable/@CacheEvict</interfacename> beans in your
+ controllers, and not your services. See <xref
+ linkend="mvc-servlet" /> for more information.</para>
+ </note>
+
+ <sidebar>
+ <title>Method visibility and
+ <interfacename>@Cacheable/@CachePut/@CacheEvict</interfacename></title>
+
+ <para>When using proxies, you should apply the
+ <interfacename>@Cache*</interfacename> annotations only to
+ methods with <emphasis>public</emphasis> visibility. If you do
+ annotate protected, private or package-visible methods with these annotations,
+ no error is raised, but the annotated method does not exhibit the configured
+ caching settings. Consider the use of AspectJ (see below) if you
+ need to annotate non-public methods as it changes the bytecode itself.</para>
+ </sidebar>
+
+ <para><tip>
+ <para>Spring recommends that you only annotate concrete classes (and
+ methods of concrete classes) with the
+ <interfacename>@Cache*</interfacename> annotation, as opposed
+ to annotating interfaces. You certainly can place the
+ <interfacename>@Cache*</interfacename> annotation on an
+ interface (or an interface method), but this works only as you would
+ expect it to if you are using interface-based proxies. The fact that
+ Java annotations are <emphasis>not inherited from interfaces</emphasis>
+ means that if you are using class-based proxies
+ (<literal>proxy-target-class="true"</literal>) or the weaving-based
+ aspect (<literal>mode="aspectj"</literal>), then the caching
+ settings are not recognized by the proxying and weaving
+ infrastructure, and the object will not be wrapped in a
+ caching proxy, which would be decidedly
+ <emphasis>bad</emphasis>.</para>
+ </tip></para>
+
+ <note>
+ <para>In proxy mode (which is the default), only external method calls
+ coming in through the proxy are intercepted. This means that
+ self-invocation, in effect, a method within the target object calling
+ another method of the target object, will not lead to an actual
+ caching at runtime even if the invoked method is marked with
+ <interfacename>@Cacheable</interfacename> - considering using the aspectj mode in this case.</para>
+ </note>
</section>
-
+
<section id="cache-annotation-stereotype">
<title>Using custom annotations</title>
-
+
<para>The caching abstraction allows one to use her own annotations to identify what method trigger cache population or eviction. This is quite handy as a template mechanism as it eliminates
the need to duplicate cache annotation declarations (especially useful if the key or condition are specified) or if the foreign imports (<literal>org.springframework</literal>) are not allowed
in your code base. Similar to the rest of the <link linkend="beans-stereotype-annotations">stereotype</link> annotations, both <literal>@Cacheable</literal> and <literal>@CacheEvict</literal>
- can be used as meta-annotations, that is annotations that can annotate other annotations. To wit, let us replace a common <literal>@Cacheable</literal> declaration with our own, custom
- annotation:
+ can be used as meta-annotations, that is annotations that can annotate other annotations. To wit, let us replace a common <literal>@Cacheable</literal> declaration with our own, custom
+ annotation:
</para>
-
+
<programlisting language="java"><![CDATA[@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Cacheable(value=“books”, key="#isbn")
public @interface SlowService {
}]]></programlisting>
<para>Above, we have defined our own <literal>SlowService</literal> annotation which itself is annotated with <literal>@Cacheable</literal> - now we can replace the following code:</para>
-
+
<programlisting language="java"><![CDATA[@Cacheable(value="books", key="#isbn")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)]]></programlisting>
<para>with:</para>
<programlisting language="java"><![CDATA[@SlowService
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)]]></programlisting>
-
+
<para>Even though <literal>@SlowService</literal> is not a Spring annotation, the container automatically picks up its declaration at runtime and understands its meaning. Note that as
mentined <link linkend="cache-annotation-enable">above</link>, the annotation-driven behaviour needs to be enabled.</para>
</section>
- </section>
-
- <section id="cache-declarative-xml">
- <title>Declarative XML-based caching</title>
-
- <para>If annotations are not an option (no access to the sources or no external code), one can use XML for declarative caching. So instead of annotating the methods for caching, one specifies
- the target method and the caching directives externally (similar to the declarative transaction management <link linkend="transaction-declarative-first-example">advice</link>). The previous example
- can be translated into:</para>
-
- <programlisting language="xml"><![CDATA[<!-- the service we want to make cacheable -->
+ </section>
+
+ <section id="cache-declarative-xml">
+ <title>Declarative XML-based caching</title>
+
+ <para>If annotations are not an option (no access to the sources or no external code), one can use XML for declarative caching. So instead of annotating the methods for caching, one specifies
+ the target method and the caching directives externally (similar to the declarative transaction management <link linkend="transaction-declarative-first-example">advice</link>). The previous example
+ can be translated into:</para>
+
+ <programlisting language="xml"><![CDATA[<!-- the service we want to make cacheable -->
<bean id="bookService" class="x.y.service.DefaultBookService"/>
-
+
<!-- cache definitions -->
<cache:advice id="cacheAdvice" cache-manager="cacheManager">
- <cache:caching cache="books">
- <cache:cacheable method="findBook" key="#isbn"/>
- <cache:cache-evict method="loadBooks" all-entries="true"/>
- </cache:caching>
+ <cache:caching cache="books">
+ <cache:cacheable method="findBook" key="#isbn"/>
+ <cache:cache-evict method="loadBooks" all-entries="true"/>
+ </cache:caching>
</cache:advice>
-
+
<!-- apply the cacheable behaviour to all BookService interfaces -->
<aop:config>
- <aop:advisor advice-ref="cacheAdvice" pointcut="execution(* x.y.BookService.*(..))"/>
+ <aop:advisor advice-ref="cacheAdvice" pointcut="execution(* x.y.BookService.*(..))"/>
</aop:config>
...
// cache manager definition omitted
]]>
- </programlisting>
-
- <para>In the configuration above, the <literal>bookService</literal> is made cacheable. The caching semantics to apply are encapsulated in the <literal>cache:advice</literal> definition which
- instructs method <literal>findBooks</literal> to be used for putting data into the cache while method <literal>loadBooks</literal> for evicting data. Both definitions are working against the
- <literal>books</literal> cache.</para>
-
- <para>The <literal>aop:config</literal> definition applies the cache advice to the appropriate points in the program by using the AspectJ pointcut expression (more information is available
- in <xref linkend="aop" />). In the example above, all methods from the <interfacename>BookService</interfacename> are considered and the cache advice applied to them.</para>
-
- <para>The declarative XML caching supports all of the annotation-based model so moving between the two should be fairly easy - further more both can be used inside the same application.
- The XML based approach does not touch the target code however it is inherently more verbose; when dealing with classes with overloaded methods that are targeted for caching, identifying the
- proper methods does take an extra effort since the <literal>method</literal> argument is not a good discriminator - in these cases, the AspectJ pointcut can be used to cherry pick the target
- methods and apply the appropriate caching functionality. Howeve through XML, it is easier to apply a package/group/interface-wide caching (again due to the AspectJ poincut) and to create
- template-like definitions (as we did in the example above by defining the target cache through the <literal>cache:definitions </literal><literal>cache</literal> attribute).
- </para>
- </section>
-
- <section id="cache-store-configuration">
+ </programlisting>
+
+ <para>In the configuration above, the <literal>bookService</literal> is made cacheable. The caching semantics to apply are encapsulated in the <literal>cache:advice</literal> definition which
+ instructs method <literal>findBooks</literal> to be used for putting data into the cache while method <literal>loadBooks</literal> for evicting data. Both definitions are working against the
+ <literal>books</literal> cache.</para>
+
+ <para>The <literal>aop:config</literal> definition applies the cache advice to the appropriate points in the program by using the AspectJ pointcut expression (more information is available
+ in <xref linkend="aop" />). In the example above, all methods from the <interfacename>BookService</interfacename> are considered and the cache advice applied to them.</para>
+
+ <para>The declarative XML caching supports all of the annotation-based model so moving between the two should be fairly easy - further more both can be used inside the same application.
+ The XML based approach does not touch the target code however it is inherently more verbose; when dealing with classes with overloaded methods that are targeted for caching, identifying the
+ proper methods does take an extra effort since the <literal>method</literal> argument is not a good discriminator - in these cases, the AspectJ pointcut can be used to cherry pick the target
+ methods and apply the appropriate caching functionality. Howeve through XML, it is easier to apply a package/group/interface-wide caching (again due to the AspectJ poincut) and to create
+ template-like definitions (as we did in the example above by defining the target cache through the <literal>cache:definitions </literal><literal>cache</literal> attribute).
+ </para>
+ </section>
+
+ <section id="cache-store-configuration">
<title>Configuring the cache storage</title>
-
- <para>Out of the box, the cache abstraction provides integration with two storages - one on top of the JDK <interfacename>ConcurrentMap</interfacename> and one
+
+ <para>Out of the box, the cache abstraction provides integration with two storages - one on top of the JDK <interfacename>ConcurrentMap</interfacename> and one
for <ulink url="ehcache.org">ehcache</ulink> library. To use them, one needs to simply declare an appropriate <interfacename>CacheManager</interfacename> - an entity that controls and manages
<interfacename>Cache</interfacename>s and can be used to retrieve these for storage.</para>
-
+
<section id="cache-store-configuration-jdk">
<title>JDK <interfacename>ConcurrentMap</interfacename>-based <interfacename>Cache</interfacename></title>
-
+
<para>The JDK-based <interfacename>Cache</interfacename> implementation resides under <literal>org.springframework.cache.concurrent</literal> package. It allows one to use <classname>
ConcurrentHashMap</classname> as a backing <interfacename>Cache</interfacename> store.</para>
-
- <programlisting language="xml"><![CDATA[<!-- generic cache manager -->
+
+ <programlisting language="xml"><![CDATA[<!-- generic cache manager -->
<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
- <property name="caches">
- <set>
- <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default"/>
- <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="books"/>
- </set>
- </property>
+ <property name="caches">
+ <set>
+ <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default"/>
+ <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="books"/>
+ </set>
+ </property>
</bean>]]></programlisting>
<para>The snippet above uses the <classname>SimpleCacheManager</classname> to create a <interfacename>CacheManager</interfacename> for the two, nested <interfacename>Concurrent</interfacename>
- <interfacename>Cache</interfacename> implementations named <emphasis>default</emphasis> and <emphasis>books</emphasis>.
+ <interfacename>Cache</interfacename> implementations named <emphasis>default</emphasis> and <emphasis>books</emphasis>.
Note that the names are configured directly for each cache.</para>
-
+
<para>As the cache is created by the application, it is bound to its lifecycle, making it suitable for basic use cases, tests or simple applications. The cache scales well and is very fast
but it does not provide any management or persistence capabilities nor eviction contracts.</para>
</section>
-
+
<section id="cache-store-configuration-ehcache">
<title>Ehcache-based <interfacename>Cache</interfacename></title>
-
- <para>The Ehcache implementation is located under <literal>org.springframework.cache.ehcache</literal> package. Again, to use it, one simply needs to declare the appropriate
+
+ <para>The Ehcache implementation is located under <literal>org.springframework.cache.ehcache</literal> package. Again, to use it, one simply needs to declare the appropriate
<interfacename>CacheManager</interfacename>:</para>
-
+
<programlisting language="xml"><![CDATA[<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager" p:cache-manager-ref="ehcache"/>
<!-- Ehcache library setup -->
@@ -538,47 +538,47 @@ public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)]]><
<para>This setup bootstraps ehcache library inside Spring IoC (through bean <literal>ehcache</literal>) which is then wired into the dedicated <interfacename>CacheManager</interfacename>
implementation. Note the entire ehcache-specific configuration is read from the resource <literal>ehcache.xml</literal>.</para>
</section>
-
+
<section id="cache-store-configuration-noop">
<title>Dealing with caches without a backing store</title>
-
+
<para>Sometimes when switching environments or doing testing, one might have cache declarations without an actual backing cache configured. As this is an invalid configuration, at runtime an
exception will be through since the caching infrastructure is unable to find a suitable store. In situations like this, rather then removing the cache declarations (which can prove tedious),
one can wire in a simple, dummy cache that performs no caching - that is, forces the cached methods to be executed every time:</para>
<programlisting language="xml"><![CDATA[<bean id="cacheManager" class="org.springframework.cache.support.CompositeCacheManager">
- <property name="cacheManagers"><list>
- <ref bean="jdkCache"/>
- <ref bean="gemfireCache"/>
- </list></property>
- <property name="addNoOpCache" value="true"/>
+ <property name="cacheManagers"><list>
+ <ref bean="jdkCache"/>
+ <ref bean="gemfireCache"/>
+ </list></property>
+ <property name="addNoOpCache" value="true"/>
</bean>]]></programlisting>
-
- <para>The <literal>CompositeCacheManager</literal> above chains multiple <literal>CacheManager</literal>s and aditionally, through the <literal>addNoOpManager</literal> flag, adds a
+
+ <para>The <literal>CompositeCacheManager</literal> above chains multiple <literal>CacheManager</literal>s and aditionally, through the <literal>addNoOpManager</literal> flag, adds a
<emphasis>no op</emphasis> cache that for all the definitions not handled by the configured cache managers. That is, every cache definition not found in either <literal>jdkCache</literal>
or <literal>gemfireCache</literal> (configured above) will be handled by the no op cache, which will not store any information causing the target method to be executed every time.
</para>
</section>
- </section>
-
- <section id="cache-plug">
+ </section>
+
+ <section id="cache-plug">
<title>Plugging-in different back-end caches</title>
-
+
<para>Clearly there are plenty of caching products out there that can be used as a backing store. To plug them in, one needs to provide a <interfacename>CacheManager</interfacename> and
- <interfacename>Cache</interfacename> implementation since unfortunately there is no available standard that we can use instead. This may sound harder then it is since in practice,
+ <interfacename>Cache</interfacename> implementation since unfortunately there is no available standard that we can use instead. This may sound harder then it is since in practice,
the classes tend to be simple <ulink url="http://en.wikipedia.org/wiki/Adapter_pattern">adapter</ulink>s that map the caching abstraction framework on top of the storage API as the <literal>ehcache</literal> classes can show.
Most <interfacename>CacheManager</interfacename> classes can use the classes in <literal>org.springframework.cache.support</literal> package, such as <classname>AbstractCacheManager</classname>
- which takes care of the boiler-plate code leaving only the actual <emphasis>mapping</emphasis> to be completed. We hope that in time, the libraries that provide integration with Spring
+ which takes care of the boiler-plate code leaving only the actual <emphasis>mapping</emphasis> to be completed. We hope that in time, the libraries that provide integration with Spring
can fill in this small configuration gap.</para>
- </section>
-
- <section id="cache-specific-config">
- <title>How can I set the TTL/TTI/Eviction policy/XXX feature?</title>
-
- <para>Directly through your cache provider. The cache abstraction is... well, an abstraction not a cache implementation. The solution you are using might support various data policies and different
- topologies which other solutions do not (take for example the JDK <literal>ConcurrentHashMap</literal>) - exposing that in the cache abstraction would be useless simply because there would
- no backing support. Such functionality should be controlled directly through the backing cache, when configuring it or through its native API.
- </para>
- </section>
-
+ </section>
+
+ <section id="cache-specific-config">
+ <title>How can I set the TTL/TTI/Eviction policy/XXX feature?</title>
+
+ <para>Directly through your cache provider. The cache abstraction is... well, an abstraction not a cache implementation. The solution you are using might support various data policies and different
+ topologies which other solutions do not (take for example the JDK <literal>ConcurrentHashMap</literal>) - exposing that in the cache abstraction would be useless simply because there would
+ no backing support. Such functionality should be controlled directly through the backing cache, when configuring it or through its native API.
+ </para>
+ </section>
+
</chapter> | false |
Other | spring-projects | spring-framework | 50d4ebcc711a0dcd9c3cfe5184ce6abfb4c572be.json | Fix typo in section id | src/reference/docbook/expressions.xml | @@ -787,7 +787,7 @@ boolean trueValue =
</programlisting>
</section>
- <section id="expressions-constrcutors">
+ <section id="expressions-constructors">
<title>Constructors</title>
<para>Constructors can be invoked using the new operator. The fully | false |
Other | spring-projects | spring-framework | 59084354e2277c4244e8949128466b33e7c9206d.json | Add validation of HTTP method in form tag
SPR-6945 | spring-webmvc/src/main/java/org/springframework/web/servlet/tags/form/FormTag.java | @@ -27,6 +27,7 @@
import org.springframework.beans.PropertyAccessor;
import org.springframework.core.Conventions;
+import org.springframework.http.HttpMethod;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.support.RequestDataValueProcessor;
@@ -319,7 +320,6 @@ protected boolean isMethodBrowserSupported(String method) {
return ("get".equalsIgnoreCase(method) || "post".equalsIgnoreCase(method));
}
-
/**
* Writes the opening part of the block '<code>form</code>' tag and exposes
* the form object name in the {@link javax.servlet.jsp.PageContext}.
@@ -345,6 +345,7 @@ protected int writeTagContent(TagWriter tagWriter) throws JspException {
tagWriter.forceBlock();
if (!isMethodBrowserSupported(getMethod())) {
+ assertHttpMethod(getMethod());
String inputName = getMethodParameter();
String inputType = "hidden";
tagWriter.startTag(INPUT_TAG);
@@ -369,6 +370,15 @@ protected int writeTagContent(TagWriter tagWriter) throws JspException {
return EVAL_BODY_INCLUDE;
}
+ private void assertHttpMethod(String method) {
+ for (HttpMethod httpMethod : HttpMethod.values()) {
+ if (httpMethod.name().equalsIgnoreCase(method)) {
+ return;
+ }
+ }
+ throw new IllegalArgumentException("Invalid HTTP method: " + method);
+ }
+
/**
* Autogenerated IDs correspond to the form object name.
*/ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.