root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Javadoc fixes and pruning of outdated references

This commit is contained in:
Juergen Hoeller 2016-07-15 22:12:11 +02:00
parent f0c397e4e2
commit dc1664939c
38 changed files with 145 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
spring-context/src/main/java/org/springframework/cache/interceptor/SimpleKeyGenerator.java vendored
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* Copyright 2002-2016 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,20 +19,19 @@ package org.springframework.cache.interceptor;
import java.lang.reflect.Method;
/**
* Simple key generator. Returns the parameter itself if a single non-null value
* is given, otherwise returns a {@link SimpleKey} of the parameters.
* Simple key generator. Returns the parameter itself if a single non-null
* value is given, otherwise returns a {@link SimpleKey} of the parameters.
*
* <p>Unlike {@link DefaultKeyGenerator}, no collisions will occur with the keys
* generated by this class. The returned {@link SimpleKey} object can be safely
* used with a {@link org.springframework.cache.concurrent.ConcurrentMapCache},
* however, might not be suitable for all {@link org.springframework.cache.Cache}
* <p>No collisions will occur with the keys generated by this class.
* The returned {@link SimpleKey} object can be safely used with a
* {@link org.springframework.cache.concurrent.ConcurrentMapCache}, however,
* might not be suitable for all {@link org.springframework.cache.Cache}
* implementations.
*
* @author Phillip Webb
* @author Juergen Hoeller
* @since 4.0
* @see SimpleKey
* @see DefaultKeyGenerator
* @see org.springframework.cache.annotation.CachingConfigurer
*/
public class SimpleKeyGenerator implements KeyGenerator {

10
spring-context/src/main/java/org/springframework/remoting/RemoteAccessException.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2008 the original author or authors.
* Copyright 2002-2016 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.
@ -24,10 +24,10 @@ import org.springframework.core.NestedRuntimeException;
* to transparently expose a plain Java business interface.
*
* <p>When using conforming proxies, switching the actual remoting protocol
* e.g. from Hessian to Burlap does not affect client code. Clients work
* with a plain natural Java business interface that the service exposes.
* A client object simply receives an implementation for the interface that
* it needs via a bean reference, like it does for a local bean as well.
* e.g. from Hessian does not affect client code. Clients work with a plain
* natural Java business interface that the service exposes. A client object
* simply receives an implementation for the interface that it needs via a
* bean reference, like it does for a local bean as well.
*
* <p>A client may catch RemoteAccessException if it wants to, but as
* remote access errors are typically unrecoverable, it will probably let

11
spring-context/src/main/java/org/springframework/remoting/rmi/RmiProxyFactoryBean.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2016 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.
@ -39,11 +39,11 @@ import org.springframework.beans.factory.FactoryBean;
* RemoteExceptions thrown by the RMI stub will automatically get converted to
* Spring's unchecked RemoteAccessException.
*
* <p>The major advantage of RMI, compared to Hessian and Burlap, is serialization.
* <p>The major advantage of RMI, compared to Hessian, is serialization.
* Effectively, any serializable Java object can be transported without hassle.
* Hessian and Burlap have their own (de-)serialization mechanisms, but are
* HTTP-based and thus much easier to setup than RMI. Alternatively, consider
* Spring's HTTP invoker to combine Java serialization with HTTP-based transport.
* Hessian has its own (de-)serialization mechanisms, but is HTTP-based and thus
* much easier to setup than RMI. Alternatively, consider Spring's HTTP invoker
* to combine Java serialization with HTTP-based transport.
*
* @author Juergen Hoeller
* @since 13.05.2003
@ -55,7 +55,6 @@ import org.springframework.beans.factory.FactoryBean;
* @see java.rmi.RemoteException
* @see org.springframework.remoting.RemoteAccessException
* @see org.springframework.remoting.caucho.HessianProxyFactoryBean
* @see org.springframework.remoting.caucho.BurlapProxyFactoryBean
* @see org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean
*/
public class RmiProxyFactoryBean extends RmiClientInterceptor implements FactoryBean<Object>, BeanClassLoaderAware {

11
spring-context/src/main/java/org/springframework/remoting/rmi/RmiServiceExporter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2016 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.
@ -42,11 +42,11 @@ import org.springframework.beans.factory.InitializingBean;
* extend {@code java.rmi.Remote} or throw {@code java.rmi.RemoteException}
* on all methods, but in and out parameters have to be serializable.
*
* <p>The major advantage of RMI, compared to Hessian and Burlap, is serialization.
* <p>The major advantage of RMI, compared to Hessian, is serialization.
* Effectively, any serializable Java object can be transported without hassle.
* Hessian and Burlap have their own (de-)serialization mechanisms, but are
* HTTP-based and thus much easier to setup than RMI. Alternatively, consider
* Spring's HTTP invoker to combine Java serialization with HTTP-based transport.
* Hessian has its own (de-)serialization mechanisms, but is HTTP-based and thus
* much easier to setup than RMI. Alternatively, consider Spring's HTTP invoker
* to combine Java serialization with HTTP-based transport.
*
* <p>Note: RMI makes a best-effort attempt to obtain the fully qualified host name.
* If one cannot be determined, it will fall back and use the IP address. Depending
@ -63,7 +63,6 @@ import org.springframework.beans.factory.InitializingBean;
* @see java.rmi.Remote
* @see java.rmi.RemoteException
* @see org.springframework.remoting.caucho.HessianServiceExporter
* @see org.springframework.remoting.caucho.BurlapServiceExporter
* @see org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
*/
public class RmiServiceExporter extends RmiBasedExporter implements InitializingBean, DisposableBean {

3
spring-context/src/main/java/org/springframework/remoting/support/SimpleHttpServerFactoryBean.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* Copyright 2002-2016 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.
@ -122,7 +122,6 @@ public class SimpleHttpServerFactoryBean implements FactoryBean<HttpServer>, Ini
* objects as values
* @see org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
* @see org.springframework.remoting.caucho.SimpleHessianServiceExporter
* @see org.springframework.remoting.caucho.SimpleBurlapServiceExporter
*/
public void setContexts(Map<String, HttpHandler> contexts) {
this.contexts = contexts;

82
spring-core/src/main/java/org/springframework/core/annotation/AnnotationAttributes.java
View File

@ -73,47 +73,6 @@ public class AnnotationAttributes extends LinkedHashMap<String, Object> {
this.displayName = UNKNOWN;
}
/**
* Create a new, empty {@link AnnotationAttributes} instance for the
* specified {@code annotationType}.
* @param annotationType the type of annotation represented by this
* {@code AnnotationAttributes} instance; never {@code null}
* @since 4.2
*/
public AnnotationAttributes(Class<? extends Annotation> annotationType) {
Assert.notNull(annotationType, "'annotationType' must not be null");
this.annotationType = annotationType;
this.displayName = annotationType.getName();
}
/**
* Create a new, empty {@link AnnotationAttributes} instance for the
* specified {@code annotationType}.
* @param annotationType the type of annotation represented by this
* {@code AnnotationAttributes} instance; never {@code null}
* @param classLoader the ClassLoader to try to load the annotation type on,
* or {@code null} to just store the annotation type name
* @since 4.3.2
*/
public AnnotationAttributes(String annotationType, ClassLoader classLoader) {
Assert.notNull(annotationType, "'annotationType' must not be null");
this.annotationType = getAnnotationType(annotationType, classLoader);
this.displayName = annotationType;
}
@SuppressWarnings("unchecked")
private static Class<? extends Annotation> getAnnotationType(String annotationType, ClassLoader classLoader) {
if (classLoader != null) {
try {
return (Class<? extends Annotation>) classLoader.loadClass(annotationType);
}
catch (ClassNotFoundException ex) {
// Annotation Class not resolvable
}
}
return null;
}
/**
* Create a new {@link AnnotationAttributes} instance, wrapping the provided
* map and all its <em>key-value</em> pairs.
@ -139,6 +98,47 @@ public class AnnotationAttributes extends LinkedHashMap<String, Object> {
this.validated = other.validated;
}
/**
* Create a new, empty {@link AnnotationAttributes} instance for the
* specified {@code annotationType}.
* @param annotationType the type of annotation represented by this
* {@code AnnotationAttributes} instance; never {@code null}
* @since 4.2
*/
public AnnotationAttributes(Class<? extends Annotation> annotationType) {
Assert.notNull(annotationType, "'annotationType' must not be null");
this.annotationType = annotationType;
this.displayName = annotationType.getName();
}
/**
* Create a new, empty {@link AnnotationAttributes} instance for the
* specified {@code annotationType}.
* @param annotationType the annotation type name represented by this
* {@code AnnotationAttributes} instance; never {@code null}
* @param classLoader the ClassLoader to try to load the annotation type on,
* or {@code null} to just store the annotation type name
* @since 4.3.2
*/
public AnnotationAttributes(String annotationType, ClassLoader classLoader) {
Assert.notNull(annotationType, "'annotationType' must not be null");
this.annotationType = getAnnotationType(annotationType, classLoader);
this.displayName = annotationType;
}
@SuppressWarnings("unchecked")
private static Class<? extends Annotation> getAnnotationType(String annotationType, ClassLoader classLoader) {
if (classLoader != null) {
try {
return (Class<? extends Annotation>) classLoader.loadClass(annotationType);
}
catch (ClassNotFoundException ex) {
// Annotation Class not resolvable
}
}
return null;
}
/**
* Get the type of annotation represented by this

3
spring-core/src/main/java/org/springframework/util/PathMatcher.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2016 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.
@ -24,7 +24,6 @@ import java.util.Map;
*
* <p>Used by {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver},
* {@link org.springframework.web.servlet.handler.AbstractUrlHandlerMapping},
* {@link org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver},
* and {@link org.springframework.web.servlet.mvc.WebContentInterceptor}.
*
* <p>The default implementation is {@link AntPathMatcher}, supporting the

8
spring-core/src/main/java/org/springframework/util/ResourceUtils.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 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.
@ -41,12 +41,6 @@ import org.springframework.core.io.Resource;
* object, which in turn allows one to obtain a {@code java.io.File} in the
* file system through its {@code getFile()} method.
*
* <p>The main reason for these utility methods for resource location handling
* is to support {@link Log4jConfigurer}, which must be able to resolve
* resource locations <i>before the logging system has been initialized</i>.
* Spring's {@code Resource} abstraction in the core package, on the other hand,
* already expects the logging system to be available.
*
* @author Juergen Hoeller
* @since 1.1.5
* @see org.springframework.core.io.Resource

7
spring-jdbc/src/main/java/org/springframework/jdbc/support/lob/DefaultLobHandler.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* Copyright 2002-2016 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.
@ -60,9 +60,8 @@ import org.apache.commons.logging.LogFactory;
* argument directly. Consider switching the {@link #setStreamAsLob "streamAsLob"}
* property to "true" when operating against a fully compliant JDBC 4.0 driver.
*
* <p>Finally, primarily as a direct equivalent to {@link OracleLobHandler},
* this LobHandler also supports the creation of temporary BLOB/CLOB objects.
* Consider switching the {@link #setCreateTemporaryLob "createTemporaryLob"}
* <p>Finally, this LobHandler also supports the creation of temporary BLOB/CLOB
* objects. Consider switching the {@link #setCreateTemporaryLob "createTemporaryLob"}
* property to "true" when "streamAsLob" happens to run into LOB size limitations.
*
* <p>See the {@link LobHandler} interface javadoc for a summary of recommendations.

3
spring-jdbc/src/main/java/org/springframework/jdbc/support/lob/LobCreator.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2016 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.
@ -48,7 +48,6 @@ import java.sql.SQLException;
* @see #close()
* @see LobHandler#getLobCreator()
* @see DefaultLobHandler.DefaultLobCreator
* @see OracleLobHandler.OracleLobCreator
* @see java.sql.PreparedStatement#setBlob
* @see java.sql.PreparedStatement#setClob
* @see java.sql.PreparedStatement#setBytes

20
spring-jdbc/src/main/java/org/springframework/jdbc/support/lob/LobHandler.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2016 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.
@ -24,9 +24,6 @@ import java.sql.SQLException;
/**
* Abstraction for handling large binary fields and large text fields in
* specific databases, no matter if represented as simple types or Large OBjects.
* Its main purpose is to isolate Oracle 9i's peculiar handling of LOBs in
* {@link OracleLobHandler}; most other databases should be able to work
* with the provided {@link DefaultLobHandler}.
*
* <p>Provides accessor methods for BLOBs and CLOBs, and acts as factory for
* LobCreator instances, to be used as sessions for creating BLOBs or CLOBs.
@ -41,15 +38,6 @@ import java.sql.SQLException;
* {@code PreparedStatement.setBlob/setClob} (e.g. for PostgreSQL), through
* setting the {@link DefaultLobHandler#setWrapAsLob "wrapAsLob"} property.
*
* <p>Unfortunately, Oracle 9i just accepts Blob/Clob instances created via its own
* proprietary BLOB/CLOB API, and additionally doesn't accept large streams for
* PreparedStatement's corresponding setter methods. Therefore, you need to use
* {@link OracleLobHandler} there, which uses Oracle's BLOB/CLOB API for both types
* of access. The Oracle 10g+ JDBC driver will work with {@link DefaultLobHandler}
* as well, with some limitations in terms of LOB sizes depending on DBMS setup;
* as of Oracle 11g (or actually, using the 11g driver even against older databases),
* there should be no need to use {@link OracleLobHandler} at all anymore.
*
* <p>Of course, you need to declare different field types for each database.
* In Oracle, any binary content needs to go into a BLOB, and all character content
* beyond 4000 bytes needs to go into a CLOB. In MySQL, there is no notion of a
@ -65,10 +53,7 @@ import java.sql.SQLException;
* if you happen to run into LOB size limitations with your (Oracle) database setup.
* <li><b>Oracle 10g driver:</b> Use {@link DefaultLobHandler} with standard setup.
* On Oracle 10.1, set the "SetBigStringTryClob" connection property; as of Oracle 10.2,
* DefaultLobHandler should work with standard setup out of the box. Alternatively,
* consider using the proprietary {@link OracleLobHandler} (see below).
* <li><b>Oracle 9i driver:</b> Use {@link OracleLobHandler} with a connection-pool-specific
* {@link OracleLobHandler#setNativeJdbcExtractor NativeJdbcExtractor}.
* DefaultLobHandler should work with standard setup out of the box.
* <li><b>PostgreSQL:</b> Configure {@link DefaultLobHandler} with {@code wrapAsLob=true},
* and use that LobHandler to access OID columns (but not BYTEA) in your database tables.
* <li>For all other database drivers (and for non-LOB fields that might potentially
@ -78,7 +63,6 @@ import java.sql.SQLException;
* @author Juergen Hoeller
* @since 23.12.2003
* @see DefaultLobHandler
* @see OracleLobHandler
* @see java.sql.ResultSet#getBlob
* @see java.sql.ResultSet#getClob
* @see java.sql.ResultSet#getBytes

1
spring-jdbc/src/main/java/org/springframework/jdbc/support/nativejdbc/Jdbc4NativeJdbcExtractor.java
View File

@ -42,7 +42,6 @@ import java.sql.Statement;
* @see java.sql.Wrapper#unwrap
* @see SimpleNativeJdbcExtractor
* @see org.springframework.jdbc.core.JdbcTemplate#setNativeJdbcExtractor
* @see org.springframework.jdbc.support.lob.OracleLobHandler#setNativeJdbcExtractor
*/
public class Jdbc4NativeJdbcExtractor extends NativeJdbcExtractorAdapter {

16
spring-jdbc/src/main/java/org/springframework/jdbc/support/nativejdbc/NativeJdbcExtractor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 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.
@ -41,29 +41,17 @@ import java.sql.Statement;
* <i>not</i> necessary to unwrap the Connection to retrieve a native ResultSet.
*
* <p>When working with a simple connection pool that wraps Connections but not
* Statements, a {@link SimpleNativeJdbcExtractor} is often sufficient. However,
* some pools (like Apache's Commons DBCP) wrap <i>all</i> JDBC objects that they
* return: Therefore, you need to use a specific {@code NativeJdbcExtractor}
* (like {@link CommonsDbcpNativeJdbcExtractor}) with them.
* Statements, a {@link SimpleNativeJdbcExtractor} is often sufficient.
*
* <p>{@link org.springframework.jdbc.core.JdbcTemplate} can properly apply a
* {@code NativeJdbcExtractor} if specified, unwrapping all JDBC objects
* that it creates. Note that this is just necessary if you intend to cast to
* native implementations in your data access code.
*
* <p>{@link org.springframework.jdbc.support.lob.OracleLobHandler},
* the Oracle-specific implementation of Spring's
* {@link org.springframework.jdbc.support.lob.LobHandler} interface, requires a
* {@code NativeJdbcExtractor} for obtaining the native {@code OracleConnection}.
* This is also necessary for other Oracle-specific features that you may want
* to leverage in your applications, such as Oracle InterMedia.
*
* @author Juergen Hoeller
* @since 25.08.2003
* @see SimpleNativeJdbcExtractor
* @see CommonsDbcpNativeJdbcExtractor
* @see org.springframework.jdbc.core.JdbcTemplate#setNativeJdbcExtractor
* @see org.springframework.jdbc.support.lob.OracleLobHandler#setNativeJdbcExtractor
*/
public interface NativeJdbcExtractor {

3
spring-jdbc/src/main/java/org/springframework/jdbc/support/nativejdbc/SimpleNativeJdbcExtractor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 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.
@ -58,7 +58,6 @@ package org.springframework.jdbc.support.nativejdbc;
* @see #setNativeConnectionNecessaryForNativeCallableStatements
* @see Jdbc4NativeJdbcExtractor
* @see org.springframework.jdbc.core.JdbcTemplate#setNativeJdbcExtractor
* @see org.springframework.jdbc.support.lob.OracleLobHandler#setNativeJdbcExtractor
*/
public class SimpleNativeJdbcExtractor extends NativeJdbcExtractorAdapter {

6
spring-tx/src/main/java/org/springframework/jca/work/WorkManagerTaskExecutor.java
View File

@ -61,12 +61,6 @@ import org.springframework.util.concurrent.ListenableFutureTask;
* can be linked into the J2EE environment through "gbean-ref" entries
* in the {@code geronimo-web.xml} deployment descriptor.
*
* <p><b>On JBoss and GlassFish, obtaining the default JCA WorkManager
* requires special lookup steps.</b> See the
* {@link org.springframework.jca.work.jboss.JBossWorkManagerTaskExecutor}
* {@link org.springframework.jca.work.glassfish.GlassFishWorkManagerTaskExecutor}
* classes which are the direct equivalent of this generic JCA adapter class.
*
* @author Juergen Hoeller
* @since 2.0.3
* @see #setWorkManager

21
spring-web/src/main/java/org/springframework/http/converter/reactive/HttpMessageConverter.java
View File

@ -30,6 +30,7 @@ import org.springframework.http.ReactiveHttpOutputMessage;
/**
* Strategy interface that specifies a converter that can convert from and to HTTP
* requests and responses.
*
* @author Arjen Poutsma
* @since 5.0
*/
@ -53,9 +54,8 @@ public interface HttpMessageConverter<T> {
/**
* Read a {@link Flux} of the given type form the given input message, and returns it.
* @param type the type of object to return. This type must have previously been
* passed to the
* {@link #canRead canRead} method of this interface, which must have returned {@code
* true}.
* passed to the {@link #canRead canRead} method of this interface, which must have
* returned {@code true}.
* @param inputMessage the HTTP input message to read from
* @return the converted {@link Flux} of elements
*/
@ -64,9 +64,8 @@ public interface HttpMessageConverter<T> {
/**
* Read a {@link Mono} of the given type form the given input message, and returns it.
* @param type the type of object to return. This type must have previously been
* passed to the
* {@link #canRead canRead} method of this interface, which must have returned {@code
* true}.
* passed to the {@link #canRead canRead} method of this interface, which must have
* returned {@code true}.
* @param inputMessage the HTTP input message to read from
* @return the converted {@link Mono} of object
*/
@ -82,8 +81,7 @@ public interface HttpMessageConverter<T> {
boolean canWrite(ResolvableType type, MediaType mediaType);
/**
* Return the list of {@link MediaType} objects that can be written by this
* converter.
* Return the list of {@link MediaType} objects that can be written by this converter.
* @return the list of supported readable media types
*/
List<MediaType> getWritableMediaTypes();
@ -95,10 +93,9 @@ public interface HttpMessageConverter<T> {
* @param contentType the content type to use when writing. May be {@code null} to
* indicate that the default content type of the converter must be used.
* @param outputMessage the message to write to
* @return
* @return the converted {@link Mono} of object
*/
Mono<Void> write(Publisher<? extends T> inputStream,
ResolvableType type, MediaType contentType,
ReactiveHttpOutputMessage outputMessage);
Mono<Void> write(Publisher<? extends T> inputStream, ResolvableType type,
MediaType contentType, ReactiveHttpOutputMessage outputMessage);
}

4
spring-web/src/main/java/org/springframework/remoting/httpinvoker/HttpInvokerClientInterceptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* Copyright 2002-2016 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.
@ -38,7 +38,7 @@ import org.springframework.remoting.support.RemoteInvocationResult;
*
* <p>Serializes remote invocation objects and deserializes remote invocation
* result objects. Uses Java serialization just like RMI, but provides the
* same ease of setup as Caucho's HTTP-based Hessian and Burlap protocols.
* same ease of setup as Caucho's HTTP-based Hessian protocol.
*
* <P>HTTP invoker is a very extensible and customizable protocol.
* It supports the RemoteInvocationFactory mechanism, like RMI invoker,

9
spring-web/src/main/java/org/springframework/remoting/httpinvoker/HttpInvokerProxyFactoryBean.java
View File

@ -29,12 +29,12 @@ import org.springframework.beans.factory.FactoryBean;
*
* <p>Serializes remote invocation objects and deserializes remote invocation
* result objects. Uses Java serialization just like RMI, but provides the
* same ease of setup as Caucho's HTTP-based Hessian and Burlap protocols.
* same ease of setup as Caucho's HTTP-based Hessian protocol.
*
* <p><b>HTTP invoker is the recommended protocol for Java-to-Java remoting.</b>
* It is more powerful and more extensible than Hessian and Burlap, at the
* expense of being tied to Java. Nevertheless, it is as easy to set up as
* Hessian and Burlap, which is its main advantage compared to RMI.
* It is more powerful and more extensible than Hessian, at the expense of
* being tied to Java. Nevertheless, it is as easy to set up as Hessian,
* which is its main advantage compared to RMI.
*
* <p><b>WARNING: Be aware of vulnerabilities due to unsafe Java deserialization:
* Manipulated input streams could lead to unwanted code execution on the server
@ -50,7 +50,6 @@ import org.springframework.beans.factory.FactoryBean;
* @see HttpInvokerServiceExporter
* @see org.springframework.remoting.rmi.RmiProxyFactoryBean
* @see org.springframework.remoting.caucho.HessianProxyFactoryBean
* @see org.springframework.remoting.caucho.BurlapProxyFactoryBean
*/
public class HttpInvokerProxyFactoryBean extends HttpInvokerClientInterceptor
implements FactoryBean<Object> {

9
spring-web/src/main/java/org/springframework/remoting/httpinvoker/HttpInvokerServiceExporter.java
View File

@ -41,12 +41,12 @@ import org.springframework.web.util.NestedServletException;
*
* <p>Deserializes remote invocation objects and serializes remote invocation
* result objects. Uses Java serialization just like RMI, but provides the
* same ease of setup as Caucho's HTTP-based Hessian and Burlap protocols.
* same ease of setup as Caucho's HTTP-based Hessian protocol.
*
* <p><b>HTTP invoker is the recommended protocol for Java-to-Java remoting.</b>
* It is more powerful and more extensible than Hessian and Burlap, at the
* expense of being tied to Java. Nevertheless, it is as easy to set up as
* Hessian and Burlap, which is its main advantage compared to RMI.
* It is more powerful and more extensible than Hessian, at the expense of
* being tied to Java. Nevertheless, it is as easy to set up as Hessian,
* which is its main advantage compared to RMI.
*
* <p><b>WARNING: Be aware of vulnerabilities due to unsafe Java deserialization:
* Manipulated input streams could lead to unwanted code execution on the server
@ -59,7 +59,6 @@ import org.springframework.web.util.NestedServletException;
* @see HttpInvokerProxyFactoryBean
* @see org.springframework.remoting.rmi.RmiServiceExporter
* @see org.springframework.remoting.caucho.HessianServiceExporter
* @see org.springframework.remoting.caucho.BurlapServiceExporter
*/
public class HttpInvokerServiceExporter extends RemoteInvocationSerializingExporter
implements HttpRequestHandler {

11
spring-web/src/main/java/org/springframework/remoting/httpinvoker/SimpleHttpInvokerServiceExporter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2014 the original author or authors.
* Copyright 2002-2016 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.
@ -38,19 +38,18 @@ import org.springframework.remoting.support.RemoteInvocationResult;
*
* <p>Deserializes remote invocation objects and serializes remote invocation
* result objects. Uses Java serialization just like RMI, but provides the
* same ease of setup as Caucho's HTTP-based Hessian and Burlap protocols.
* same ease of setup as Caucho's HTTP-based Hessian protocol.
*
* <p><b>HTTP invoker is the recommended protocol for Java-to-Java remoting.</b>
* It is more powerful and more extensible than Hessian and Burlap, at the
* expense of being tied to Java. Nevertheless, it is as easy to set up as
* Hessian and Burlap, which is its main advantage compared to RMI.
* It is more powerful and more extensible than Hessian, at the expense of
* being tied to Java. Nevertheless, it is as easy to set up as Hessian,
* which is its main advantage compared to RMI.
*
* @author Juergen Hoeller
* @since 2.5.1
* @see org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
* @see org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean
* @see org.springframework.remoting.caucho.SimpleHessianServiceExporter
* @see org.springframework.remoting.caucho.SimpleBurlapServiceExporter
*/
@UsesSunHttpServer
public class SimpleHttpInvokerServiceExporter extends RemoteInvocationSerializingExporter

8
spring-web/src/main/java/org/springframework/remoting/httpinvoker/package-info.java
View File

@ -1,11 +1,11 @@
/**
* Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
* Uses Java serialization just like RMI, but provides the same ease of setup
* as Caucho's HTTP-based Hessian and Burlap protocols.
* as Caucho's HTTP-based Hessian protocol.
*
* <p><b>HTTP invoker is the recommended protocol for Java-to-Java remoting.</b>
* It is more powerful and more extensible than Hessian and Burlap, at the
* expense of being tied to Java. Neverthelesss, it is as easy to set up as
* Hessian and Burlap, which is its main advantage compared to RMI.
* It is more powerful and more extensible than Hessian, at the expense of
* being tied to Java. Nevertheless, it is as easy to set up as Hessian,
* which is its main advantage compared to RMI.
*/
package org.springframework.remoting.httpinvoker;

1
spring-web/src/main/java/org/springframework/web/HttpRequestHandler.java
View File

@ -72,7 +72,6 @@ import javax.servlet.http.HttpServletResponse;
* @see org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter
* @see org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
* @see org.springframework.remoting.caucho.HessianServiceExporter
* @see org.springframework.remoting.caucho.BurlapServiceExporter
*/
@FunctionalInterface
public interface HttpRequestHandler {

2
spring-web/src/main/java/org/springframework/web/client/reactive/package-info.java
View File

@ -1,6 +1,6 @@
/**
* Provides a reactive {@link org.springframework.web.client.reactive.WebClient}
* that builds on top of the
* {@link org.springframework.http.client.reactive reactive HTTP adapter} layer.
* {@code org.springframework.http.client.reactive} reactive HTTP adapter} layer.
*/
package org.springframework.web.client.reactive;

6
spring-web/src/main/java/org/springframework/web/context/ContextLoaderListener.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 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.
@ -23,9 +23,6 @@ import javax.servlet.ServletContextListener;
* Bootstrap listener to start up and shut down Spring's root {@link WebApplicationContext}.
* Simply delegates to {@link ContextLoader} as well as to {@link ContextCleanupListener}.
*
* <p>This listener should be registered after {@link org.springframework.web.util.Log4jConfigListener}
* in {@code web.xml}, if the latter is used.
*
* <p>As of Spring 3.1, {@code ContextLoaderListener} supports injecting the root web
* application context via the {@link #ContextLoaderListener(WebApplicationContext)}
* constructor, allowing for programmatic configuration in Servlet 3.0+ environments.
@ -36,7 +33,6 @@ import javax.servlet.ServletContextListener;
* @since 17.02.2003
* @see #setContextInitializers
* @see org.springframework.web.WebApplicationInitializer
* @see org.springframework.web.util.Log4jConfigListener
*/
public class ContextLoaderListener extends ContextLoader implements ServletContextListener {

2
spring-web/src/main/java/org/springframework/web/server/adapter/package-info.java
View File

@ -1,6 +1,6 @@
/**
* Implementations to adapt to the underlying
* {@link org.springframework.http.client.reactive reactive HTTP adapter}
* {@code org.springframework.http.client.reactive} reactive HTTP adapter
* and {@link org.springframework.http.server.reactive.HttpHandler}.
*/
package org.springframework.web.server.adapter;

7
spring-web/src/main/java/org/springframework/web/server/package-info.java
View File

@ -1,8 +1,7 @@
/**
* Core interfaces and classes for Spring's generic, reactive web support.
* Builds on top of
* {@link org.springframework.http.client.reactive reactive HTTP adapter} layer
* providing additional constructs such as WebHandler, WebFilter, WebSession
* among others.
* Builds on top of the {@code org.springframework.http.client.reactive}
* reactive HTTP adapter layer, providing additional constructs such as
* WebHandler, WebFilter, WebSession among others.
*/
package org.springframework.web.server;

3
spring-web/src/main/java/org/springframework/web/util/HtmlUtils.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2015 the original author or authors.
* Copyright 2002-2016 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.
@ -36,7 +36,6 @@ import org.springframework.util.Assert;
* @author Martin Kersten
* @author Craig Andrews
* @since 01.03.2003
* @see org.apache.commons.lang.StringEscapeUtils
*/
public abstract class HtmlUtils {

7
spring-web/src/main/java/org/springframework/web/util/UrlPathHelper.java
View File

@ -35,8 +35,7 @@ import org.springframework.util.StringUtils;
* Helper class for URL path matching. Provides support for URL paths in
* RequestDispatcher includes and support for consistent URL decoding.
*
* <p>Used by {@link org.springframework.web.servlet.handler.AbstractUrlHandlerMapping},
* {@link org.springframework.web.servlet.mvc.multiaction.AbstractUrlMethodNameResolver}
* <p>Used by {@link org.springframework.web.servlet.handler.AbstractUrlHandlerMapping}
* and {@link org.springframework.web.servlet.support.RequestContext} for path matching
* and/or URI determination.
*
@ -179,8 +178,8 @@ public class UrlPathHelper {
String sanitizedPathWithinApp = getSanitizedPath(pathWithinApp);
String path;
// if the app container sanitized the servletPath, check against the sanitized version
if (servletPath.indexOf(sanitizedPathWithinApp) != -1) {
// If the app container sanitized the servletPath, check against the sanitized version
if (servletPath.contains(sanitizedPathWithinApp)) {
path = getRemainingPath(sanitizedPathWithinApp, servletPath, false);
}
else {

3
spring-web/src/main/java/org/springframework/web/util/WebAppRootListener.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2012 the original author or authors.
* Copyright 2002-2016 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.
@ -47,7 +47,6 @@ import javax.servlet.ServletContextListener;
* @author Juergen Hoeller
* @since 18.04.2003
* @see WebUtils#setWebAppRootSystemProperty
* @see Log4jConfigListener
* @see System#getProperty
*/
public class WebAppRootListener implements ServletContextListener {

1
spring-web/src/main/java/org/springframework/web/util/WebUtils.java
View File

@ -146,7 +146,6 @@ public abstract class WebUtils {
* @see #WEB_APP_ROOT_KEY_PARAM
* @see #DEFAULT_WEB_APP_ROOT_KEY
* @see WebAppRootListener
* @see Log4jWebConfigurer
*/
public static void setWebAppRootSystemProperty(ServletContext servletContext) throws IllegalStateException {
Assert.notNull(servletContext, "ServletContext must not be null");

1
spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/WebContentInterceptor.java
View File

@ -102,7 +102,6 @@ public class WebContentInterceptor extends WebContentGenerator implements Handle
* <p>Only relevant for the "cacheMappings" setting.
* @see #setCacheMappings
* @see org.springframework.web.servlet.handler.AbstractUrlHandlerMapping#setUrlPathHelper
* @see org.springframework.web.servlet.mvc.multiaction.AbstractUrlMethodNameResolver#setUrlPathHelper
*/
public void setUrlPathHelper(UrlPathHelper urlPathHelper) {
Assert.notNull(urlPathHelper, "UrlPathHelper must not be null");

14
spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/MvcUriComponentsBuilder.java
View File

@ -118,7 +118,7 @@ public class MvcUriComponentsBuilder {
* @see #fromMethodName(Class, String, Object...)
* @see #fromMethodCall(Object)
* @see #fromMappingName(String)
* @see #fromMethod(java.lang.reflect.Method, Object...)
* @see #fromMethod(Class, Method, Object...)
*/
protected MvcUriComponentsBuilder(UriComponentsBuilder baseUrl) {
Assert.notNull(baseUrl, "'baseUrl' is required");
@ -168,7 +168,7 @@ public class MvcUriComponentsBuilder {
/**
* Create a {@link UriComponentsBuilder} from the mapping of a controller
* method and an array of method argument values. This method delegates
* to {@link #fromMethod(java.lang.reflect.Method, Object...)}.
* to {@link #fromMethod(Class, Method, Object...)}.
* @param controllerType the controller
* @param methodName the method name
* @param args the argument values
@ -207,7 +207,7 @@ public class MvcUriComponentsBuilder {
/**
* Create a {@link UriComponentsBuilder} by invoking a "mock" controller method.
* The controller method and the supplied argument values are then used to
* delegate to {@link #fromMethod(java.lang.reflect.Method, Object...)}.
* delegate to {@link #fromMethod(Class, Method, Object...)}.
* <p>For example, given this controller:
* <pre class="code">
* &#064;RequestMapping("/people/{id}/addresses")
@ -361,7 +361,7 @@ public class MvcUriComponentsBuilder {
}
/**
* An alternative to {@link #fromMethod(java.lang.reflect.Method, Object...)}
* An alternative to {@link #fromMethod(Class, Method, Object...)}
* that accepts a {@code UriComponentsBuilder} representing the base URL.
* This is useful when using MvcUriComponentsBuilder outside the context of
* processing a request or to apply a custom baseUrl not matching the
@ -546,8 +546,7 @@ public class MvcUriComponentsBuilder {
* on the controller is invoked, the supplied argument values are remembered
* and the result can then be used to create a {@code UriComponentsBuilder}
* via {@link #fromMethodCall(Object)}.
* <p>
* Note that this is a shorthand version of {@link #controller(Class)} intended
* <p>Note that this is a shorthand version of {@link #controller(Class)} intended
* for inline use (with a static import), for example:
* <pre class="code">
* MvcUriComponentsBuilder.fromMethodCall(on(FooController.class).getFoo(1)).build();
@ -563,8 +562,7 @@ public class MvcUriComponentsBuilder {
* on the controller is invoked, the supplied argument values are remembered
* and the result can then be used to create {@code UriComponentsBuilder} via
* {@link #fromMethodCall(Object)}.
* <p>
* This is a longer version of {@link #on(Class)}. It is needed with controller
* <p>This is a longer version of {@link #on(Class)}. It is needed with controller
* methods returning void as well for repeated invocations.
* <pre class="code">
* FooController fooController = controller(FooController.class);

2
spring-webmvc/src/main/java/org/springframework/web/servlet/support/RequestContext.java
View File

@ -468,7 +468,7 @@ public class RequestContext {
/**
* (De)activate default HTML escaping for messages and errors, for the scope of this RequestContext.
* <p>The default is the application-wide setting (the "defaultHtmlEscape" context-param in web.xml).
* @see org.springframework.web.util.WebUtils#isDefaultHtmlEscape
* @see org.springframework.web.util.WebUtils#getDefaultHtmlEscape
*/
public void setDefaultHtmlEscape(boolean defaultHtmlEscape) {
this.defaultHtmlEscape = defaultHtmlEscape;

5
src/asciidoc/images/full.svg
View File

@ -222,7 +222,7 @@
x="15.55" dy="1.2em" class="st8">Email</tspan></text> </g>
<g id="shape17-74" v:mID="17" v:groupContext="shape" transform="translate(309.84,-107.999)">
<title>Box.17</title>
<desc>Remote access via Hession, Burlap, SOAP</desc>
<desc>Remote access via Hession or SOAP</desc>
<v:userDefs>
<v:ud v:nameU="visVersion" v:val="VT0(11):26"/>
</v:userDefs>
@ -234,8 +234,7 @@
</g>
<rect x="0" y="204.479" width="46.08" height="54.72" class="st6"/>
<text x="12.55" y="222.84" class="st7" v:langID="1033"><v:paragraph v:horizAlign="1"/><v:tabList/>Remote <tspan
x="9.04" dy="1.2em" class="st8">access via<v:newlineChar/></tspan><tspan x="11.38" dy="1.2em" class="st8">Hession</tspan>, <tspan
x="4.38" dy="1.2em" class="st8">Burlap</tspan>, SOAP</text> </g>
x="9.04" dy="1.2em" class="st8">access via<v:newlineChar/></tspan><tspan x="11.38" dy="1.2em" class="st8">Hession</tspan>, SOAP</text> </g>
<g id="shape18-82" v:mID="18" v:groupContext="shape" transform="translate(114,-172.799)">
<title>Box.18</title>
<desc>WebApplicationContext providing e.g. messaging</desc>

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 15 KiB

After

Width:  |  Height:  |  Size: 15 KiB

35
src/asciidoc/images/overview-remoting.graffle
View File

@ -128,41 +128,6 @@
{\colortbl;\red255\green255\blue255;}
\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc\pardirnatural
\f0\i\fs28 \cf0 Burlap Client}</string>
</dict>
</dict>
<dict>
<key>Bounds</key>
<string>{{222.995, 18.3863}, {123.908, 52.4129}}</string>
<key>Class</key>
<string>ShapedGraphic</string>
<key>ID</key>
<integer>84</integer>
<key>Shape</key>
<string>Rectangle</string>
<key>Style</key>
<dict>
<key>fill</key>
<dict>
<key>Color</key>
<dict>
<key>b</key>
<string>0.51301</string>
<key>g</key>
<string>0.996221</string>
<key>r</key>
<string>1</string>
</dict>
</dict>
</dict>
<key>Text</key>
<dict>
<key>Text</key>
<string>{\rtf1\ansi\ansicpg1252\cocoartf949\cocoasubrtf430
{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
{\colortbl;\red255\green255\blue255;}
\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc\pardirnatural
\f0\i\fs28 \cf0 Hessian Client}</string>
</dict>
</dict>

14
src/asciidoc/images/remoting.svg
View File

@ -110,20 +110,6 @@
</g>
<rect x="0" y="151.44" width="72.212" height="39.6" class="st6"/>
<text x="11.2" y="173.64" class="st7" v:langID="1033"><v:paragraph v:horizAlign="1"/><v:tabList/>Hessian client</text> </g>
<g id="shape8-31" v:mID="8" v:groupContext="shape" transform="translate(184.094,-151.2)">
<title>Box.6</title>
<desc>Burlap client</desc>
<v:userDefs>
<v:ud v:nameU="visVersion" v:val="VT0(11):26"/>
</v:userDefs>
<v:textBlock v:margins="rect(3.99999,3.99999,3.99999,3.99999)"/>
<v:textRect cx="33.6885" cy="171.24" width="67.38" height="39.6"/>
<g id="shadow8-32" v:groupContext="shadow" v:shadowOffsetX="1.8" v:shadowOffsetY="-1.8" v:shadowType="1"
transform="matrix(1,0,0,1,1.8,1.8)" class="st4">
<rect x="0" y="151.44" width="67.3778" height="39.6" class="st5"/>
</g>
<rect x="0" y="151.44" width="67.3778" height="39.6" class="st6"/>
<text x="11.69" y="173.64" class="st7" v:langID="1033"><v:paragraph v:horizAlign="1"/><v:tabList/>Burlap client</text> </g>
<g id="shape9-36" v:mID="9" v:groupContext="shape" transform="translate(266.126,-151.2)">
<title>Box.7</title>
<desc>RMI client</desc>

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 8.5 KiB

After

Width:  |  Height:  |  Size: 7.8 KiB

54
src/asciidoc/integration.adoc
View File

@ -39,8 +39,6 @@ usual (Spring) POJOs. Currently, Spring supports the following remoting technolo
* __Hessian__. By using Spring's `HessianProxyFactoryBean` and the
`HessianServiceExporter` you can transparently expose your services using the
lightweight binary HTTP-based protocol provided by Caucho.
* __Burlap__. Burlap is Caucho's XML-based alternative to Hessian. Spring provides
support classes such as `BurlapProxyFactoryBean` and `BurlapServiceExporter`.
* __JAX-WS__. Spring provides remoting support for web services via JAX-WS (the
successor of JAX-RPC, as introduced in Java EE 5 and Java 6).
* __JMS__. Remoting using JMS as the underlying protocol is supported via the
@ -207,7 +205,7 @@ will transparently create an invoker and remotely enable the account service thr
[[remoting-caucho-protocols]]
=== Using Hessian or Burlap to remotely call services via HTTP
=== Using Hessian to remotely call services via HTTP
Hessian offers a binary HTTP-based remoting protocol. It is developed by Caucho and more
information about Hessian itself can be found at http://www.caucho.com[].
@ -329,22 +327,13 @@ the `AccountService` to manage accounts:
[[remoting-caucho-protocols-burlap]]
==== Using Burlap
We won't discuss Burlap, the XML-based equivalent of Hessian, in detail here, since it
is configured and set up in exactly the same way as the Hessian variant explained above.
Just replace the word `Hessian` with `Burlap` and you're all set to go.
[[remoting-caucho-protocols-security]]
==== Applying HTTP basic authentication to a service exposed through Hessian or Burlap
One of the advantages of Hessian and Burlap is that we can easily apply HTTP basic
authentication, because both protocols are HTTP-based. Your normal HTTP server security
mechanism can easily be applied through using the `web.xml` security features, for
example. Usually, you don't use per-user security credentials here, but rather shared
credentials defined at the `Hessian/BurlapProxyFactoryBean` level (similar to a JDBC
`DataSource`).
==== Applying HTTP basic authentication to a service exposed through Hessian
One of the advantages of Hessian is that we can easily apply HTTP basic authentication,
because both protocols are HTTP-based. Your normal HTTP server security mechanism can
easily be applied through using the `web.xml` security features, for example. Usually,
you don't use per-user security credentials here, but rather shared credentials defined
at the `HessianProxyFactoryBean` level (similar to a JDBC `DataSource`).
[source,xml,indent=0]
[subs="verbatim,quotes"]
@ -375,12 +364,12 @@ at http://projects.spring.io/spring-security/[].
[[remoting-httpinvoker]]
=== Exposing services using HTTP invokers
As opposed to Burlap and Hessian, which are both lightweight protocols using their own
slim serialization mechanisms, Spring HTTP invokers use the standard Java serialization
As opposed to Hessian, which are both lightweight protocols using their own slim
serialization mechanisms, Spring HTTP invokers use the standard Java serialization
mechanism to expose services through HTTP. This has a huge advantage if your arguments
and return types are complex types that cannot be serialized using the serialization
mechanisms Hessian and Burlap use (refer to the next section for more considerations
when choosing a remoting technology).
mechanisms Hessian uses (refer to the next section for more considerations when
choosing a remoting technology).
Under the hood, Spring uses either the standard facilities provided by the JDK or
Apache `HttpComponents` to perform HTTP calls. Use the latter if you need more
@ -393,7 +382,7 @@ for more information.
[[remoting-httpinvoker-server]]
==== Exposing the service object
Setting up the HTTP invoker infrastructure for a service object resembles closely the
way you would do the same using Hessian or Burlap. Just as Hessian support provides the
way you would do the same using Hessian. Just as Hessian support provides the
`HessianServiceExporter`, Spring's HttpInvoker support provides the
`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter`.
@ -472,8 +461,8 @@ shown in this example:
[[remoting-httpinvoker-client]]
==== Linking in the service at the client
Again, linking in the service from the client much resembles the way you would do it
when using Hessian or Burlap. Using a proxy, Spring will be able to translate your calls
to HTTP POST requests to the URL pointing to the exported service.
when using Hessian. Using a proxy, Spring will be able to translate your calls to
HTTP POST requests to the URL pointing to the exported service.
[source,xml,indent=0]
[subs="verbatim,quotes"]
@ -924,11 +913,11 @@ HTTP as transport. Note that HTTP invokers are not only limited to Java-to-Java
but also to Spring on both the client and server side. (The latter also applies to
Spring's RMI invoker for non-RMI interfaces.)
Hessian and/or Burlap might provide significant value when operating in a heterogeneous
environment, because they explicitly allow for non-Java clients. However, non-Java
support is still limited. Known issues include the serialization of Hibernate objects in
combination with lazily-initialized collections. If you have such a data model, consider
using RMI or HTTP invokers instead of Hessian.
Hessian might provide significant value when operating in a heterogeneous environment,
because they explicitly allow for non-Java clients. However, non-Java support is still
limited. Known issues include the serialization of Hibernate objects in combination with
lazily-initialized collections. If you have such a data model, consider using RMI or
HTTP invokers instead of Hessian.
JMS can be useful for providing clusters of services and allowing the JMS broker to take
care of load balancing, discovery and auto-failover. By default: Java serialization is
@ -4170,13 +4159,12 @@ To create an `MBeanServerConnection` to a remote JSR-160 enabled `MBeanServer` u
[[jmx-jsr160-protocols]]
==== JMX over Burlap/Hessian/SOAP
==== JMX over Hessian or SOAP
JSR-160 permits extensions to the way in which communication is done between the client
and the server. The examples above are using the mandatory RMI-based implementation
required by the JSR-160 specification (IIOP and JRMP) and the (optional) JMXMP. By using
other providers or JMX implementations (such as http://mx4j.sourceforge.net[MX4J]) you
can take advantage of protocols like SOAP, Hessian, Burlap over simple HTTP or SSL and
others:
can take advantage of protocols like SOAP or Hessian over simple HTTP or SSL and others:
[source,xml,indent=0]
[subs="verbatim,quotes"]

2
src/asciidoc/overview.adoc
View File

@ -274,7 +274,7 @@ layer.
image::images/overview-remoting.png[width=400]
When you need to access existing code through web services, you can use Spring's
`Hessian-`, `Burlap-`, `Rmi-` or `JaxRpcProxyFactory` classes. Enabling remote access to
`Hessian-`, `Rmi-` or `HttpInvokerProxyFactoryBean` classes. Enabling remote access to
existing applications is not difficult.
.EJBs - Wrapping existing POJOs