mirror of
https://github.com/spring-projects/spring-security.git
synced 2025-03-01 10:59:16 +00:00
Minor faq updates
This commit is contained in:
Luke Taylor
parent
408e982b96
commit
44487293f0
@ -13,8 +13,15 @@
|
||||
requirements?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>
|
||||
Spring Security provides you with a very flexible framework for your authentication and authorization requirements, but there are many other considerations for building a secure application that are outside its scope. Web applications are vulnerable to all kinds of attacks which you should be familiar with, preferably before you start development so you can design and code with them in mind from the beginning. Check out the <link xlink:href="http://www.owasp.org/">OWASP web site</link> for information on the major issues facing web application developers and the countermeasures you can use against them.</para>
|
||||
<para> Spring Security provides you with a very flexible framework for your
|
||||
authentication and authorization requirements, but there are many other
|
||||
considerations for building a secure application that are outside its scope.
|
||||
Web applications are vulnerable to all kinds of attacks which you should be
|
||||
familiar with, preferably before you start development so you can design and
|
||||
code with them in mind from the beginning. Check out the <link
|
||||
xlink:href="http://www.owasp.org/">OWASP web site</link> for information
|
||||
on the major issues facing web application developers and the
|
||||
countermeasures you can use against them.</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry xml:id="faq-web-xml">
|
||||
@ -22,12 +29,34 @@
|
||||
<para>Why not just use web.xml security?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>Let's assume you're developing an enterprise application based on Spring. There are four security concerns you typically need to address: authentication, web request security, service layer security (i.e. your methods that implement business logic), and domain object instance security (i.e. different domain objects have different permissions). With these typical requirements in mind: <orderedlist>
|
||||
<para>Let's assume you're developing an enterprise application based on Spring.
|
||||
There are four security concerns you typically need to address:
|
||||
authentication, web request security, service layer security (i.e. your
|
||||
methods that implement business logic), and domain object instance security
|
||||
(i.e. different domain objects have different permissions). With these
|
||||
typical requirements in mind: <orderedlist>
|
||||
<listitem>
|
||||
<para><emphasis>Authentication</emphasis>: The servlet specification provides an approach to authentication. However, you will need to configure the container to perform authentication which typically requires editing of container-specific "realm" settings. This makes a non-portable configuration, and if you need to write an actual Java class to implement the container's authentication interface, it becomes even more non-portable. With Spring Security you achieve complete portability - right down to the WAR level. Also, Spring Security offers a choice of production-proven authentication providers and mechanisms, meaning you can switch your authentication approaches at deployment time. This is particularly valuable for software vendors writing products that need to work in an unknown target environment.</para>
|
||||
<para><emphasis>Authentication</emphasis>: The servlet specification
|
||||
provides an approach to authentication. However, you will need
|
||||
to configure the container to perform authentication which
|
||||
typically requires editing of container-specific "realm"
|
||||
settings. This makes a non-portable configuration, and if you
|
||||
need to write an actual Java class to implement the container's
|
||||
authentication interface, it becomes even more non-portable.
|
||||
With Spring Security you achieve complete portability - right
|
||||
down to the WAR level. Also, Spring Security offers a choice of
|
||||
production-proven authentication providers and mechanisms,
|
||||
meaning you can switch your authentication approaches at
|
||||
deployment time. This is particularly valuable for software
|
||||
vendors writing products that need to work in an unknown target
|
||||
environment.</para>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<para><emphasis>Web request security:</emphasis> The servlet specification provides an approach to secure your request URIs. However, these URIs can only be expressed in the servlet specification's own limited URI path format. Spring Security provides a far more comprehensive approach. For instance, you
|
||||
<para><emphasis>Web request security:</emphasis> The servlet
|
||||
specification provides an approach to secure your request URIs.
|
||||
However, these URIs can only be expressed in the servlet
|
||||
specification's own limited URI path format. Spring Security
|
||||
provides a far more comprehensive approach. For instance, you
|
||||
can use Ant paths or regular expressions, you can consider parts
|
||||
of the URI other than simply the requested page (e.g. you can
|
||||
consider HTTP GET parameters) and you can implement your own
|
||||
@ -43,8 +72,7 @@
|
||||
developers either ignore these requirements, or implement
|
||||
security logic within their MVC controller code (or even worse,
|
||||
inside the views). There are serious disadvantages with this
|
||||
approach:
|
||||
<orderedlist>
|
||||
approach: <orderedlist>
|
||||
<listitem>
|
||||
<para><emphasis>Separation of concerns:</emphasis>
|
||||
Authorization is a crosscutting concern and should
|
||||
@ -113,38 +141,39 @@
|
||||
<para> Spring Security 2.0.x requires a minimum JDK version of 1.4 and is built
|
||||
against Spring 2.0.x. It should also be compatible with applications using
|
||||
Spring 2.5.x. </para>
|
||||
<para> Spring Security 3.0 requires JDK 1.5 as a minimum and will also
|
||||
require Spring 3.0. </para>
|
||||
<para> Spring Security 3.0 requires JDK 1.5 as a minimum and will also require
|
||||
Spring 3.0. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry>
|
||||
<qandaentry xml:id="faq-start-simple">
|
||||
<question>
|
||||
<para>
|
||||
I'm new to Spring Security and I need to build an application that supports CAS single sign-on over HTTPS,
|
||||
while allowing Basic authentication locally for certain URLs, authenticating against multiple back end user information sources
|
||||
(LDAP and JDBC). I've copied some configuration files I found but it doesn't work. What could be wrong?
|
||||
</para>
|
||||
<para> I'm new to Spring Security and I need to build an application that
|
||||
supports CAS single sign-on over HTTPS, while allowing Basic authentication
|
||||
locally for certain URLs, authenticating against multiple back end user
|
||||
information sources (LDAP and JDBC). I've copied some configuration files I
|
||||
found but it doesn't work. What could be wrong? </para>
|
||||
<para>Or subsititute an alternative complex scenario...</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>
|
||||
Realistically, you need an understanding of the technolgies you are intending to use before you can successfully
|
||||
build applications with them. Security is complicated. Setting up a simple configuration using a login
|
||||
form and some hard-coded users using Spring Security's namespace is reasonably straightforward. Moving to using a
|
||||
backed JDBC database is also easy enough. But if you try and jump
|
||||
straight to a complicated deployment scenario like this you will almost certainly be frustrated.
|
||||
There is a big jump in the learning curve required to set up systems like CAS, configure LDAP servers and install SSL
|
||||
certificates properly. So you need to take things one step at a time.
|
||||
</para>
|
||||
<para>
|
||||
From a Spring Security perspective, the first thing you should do is follow the <quote>Getting Started</quote>
|
||||
guide on the web site. This will take you through a series of steps to get up and running and get some idea of
|
||||
how the framework operates. If you are using other technologies which you aren't familiar with then you should
|
||||
do some research and try to make sure you can use them in isolation before combining them in a complex system.
|
||||
<para> Realistically, you need an understanding of the technolgies you are
|
||||
intending to use before you can successfully build applications with them.
|
||||
Security is complicated. Setting up a simple configuration using a login
|
||||
form and some hard-coded users using Spring Security's namespace is
|
||||
reasonably straightforward. Moving to using a backed JDBC database is also
|
||||
easy enough. But if you try and jump straight to a complicated deployment
|
||||
scenario like this you will almost certainly be frustrated. There is a big
|
||||
jump in the learning curve required to set up systems like CAS, configure
|
||||
LDAP servers and install SSL certificates properly. So you need to take
|
||||
things one step at a time. </para>
|
||||
<para> From a Spring Security perspective, the first thing you should do is
|
||||
follow the <quote>Getting Started</quote> guide on the web site. This will
|
||||
take you through a series of steps to get up and running and get some idea
|
||||
of how the framework operates. If you are using other technologies which you
|
||||
aren't familiar with then you should do some research and try to make sure
|
||||
you can use them in isolation before combining them in a complex system.
|
||||
</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
|
||||
</qandadiv>
|
||||
<qandadiv>
|
||||
<title>Common Problems</title>
|
||||
@ -211,8 +240,8 @@
|
||||
<answer>
|
||||
<para> This happens because Tomcat sessions created under HTTPS cannot
|
||||
subsequently be used under HTTP and any session state is lost (including the
|
||||
security context information). Starting a session in HTTP first should work as the
|
||||
session cookie won't be marked as secure. </para>
|
||||
security context information). Starting a session in HTTP first should work
|
||||
as the session cookie won't be marked as secure. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry xml:id="faq-no-security-on-forward">
|
||||
@ -246,27 +275,52 @@
|
||||
</programlisting>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry xml:id="faq-no-filters-no-context">
|
||||
<question>
|
||||
<para>I have a user who has definitely been authenticated, but when I try to
|
||||
access the <classname>SecurityContextHolder</classname> during some
|
||||
requests, the <interfacename>Authentication</interfacename> is null. Why
|
||||
can't I see the user information? </para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>If you have excluded the request from the security filter chain using the
|
||||
attribute <literal>filters='none'</literal> in the
|
||||
<literal><intercept-url></literal> element that matches the URL
|
||||
pattern, then the <classname>SecurityContextHolder</classname> will not be
|
||||
populated for that request. Check the debug log to see whether the request
|
||||
is passing through the filter chain. (You are reading the debug log,
|
||||
right?).</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
</qandadiv>
|
||||
<qandadiv>
|
||||
<title>Spring Security Architecture Questions</title>
|
||||
<qandaentry xml:id="faq-where-is-class-x">
|
||||
<question><para>How do I know which package class X is in?</para></question>
|
||||
<answer><para>The best way of locating classes is by installing the Spring Security source in your IDE.
|
||||
The distribution includes source jars for each of the modules the project is divided up into.
|
||||
Add these to your project source path and you can navigate directly to Spring Security classes
|
||||
(<command>Ctrl-Shift-T</command> in Eclipse). This also makes debugging easer and allows you to troubleshoot
|
||||
exceptions by looking directly at the code where they occur to see what's going on there.
|
||||
</para></answer>
|
||||
<question>
|
||||
<para>How do I know which package class X is in?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>The best way of locating classes is by installing the Spring Security
|
||||
source in your IDE. The distribution includes source jars for each of the
|
||||
modules the project is divided up into. Add these to your project source
|
||||
path and you can navigate directly to Spring Security classes
|
||||
(<command>Ctrl-Shift-T</command> in Eclipse). This also makes debugging
|
||||
easer and allows you to troubleshoot exceptions by looking directly at the
|
||||
code where they occur to see what's going on there. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry xml:id="faq-namespace-to-bean-mapping">
|
||||
<question><para>How do the namespace elements map to conventional bean configurations?</para></question>
|
||||
<question>
|
||||
<para>How do the namespace elements map to conventional bean
|
||||
configurations?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>There is a general overview of what beans are created by the namespace in the namespace
|
||||
appendix of the reference guide. If want to know the full details then the code
|
||||
is in the <filename>spring-security-config</filename> module within the Spring Security 3.0
|
||||
distribution. You should probably read the chapters on namespace parsing in the
|
||||
standard Spring Framework reference documentation first.
|
||||
</para>
|
||||
<para>There is a general overview of what beans are created by the namespace in
|
||||
the namespace appendix of the reference guide. If want to know the full
|
||||
details then the code is in the <filename>spring-security-config</filename>
|
||||
module within the Spring Security 3.0 distribution. You should probably read
|
||||
the chapters on namespace parsing in the standard Spring Framework reference
|
||||
documentation first. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
</qandadiv>
|
||||
@ -298,52 +352,57 @@
|
||||
and loads the appropriate user data for authentication. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry>
|
||||
<question xml:id="faq-dynamic-url-metadata">
|
||||
<para>How do I define the secured URLs withing an application dynamically?</para>
|
||||
<qandaentry xml:id="faq-dynamic-url-metadata">
|
||||
<question>
|
||||
<para>How do I define the secured URLs withing an application
|
||||
dynamically?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>People often ask about how to store the mapping between secured URLs and
|
||||
security metadata attributes in a database, rather than in the application
|
||||
context.
|
||||
</para>
|
||||
<para>
|
||||
The first thing you should ask yourself is if you really need to do this. If an
|
||||
application requires securing, then it also requires that the security be tested
|
||||
thoroughly based on a defined policy. It may require auditing and acceptance
|
||||
testing before being rolled out into a production environment. A security-conscious
|
||||
organization should be aware that the benefits of their diligent testing process could
|
||||
be wiped out instantly by allowing the security settings to be modified at runtime
|
||||
by changing a row or two in a configuration database.
|
||||
If you have taken this into account (perhaps using multiple layers of security within your
|
||||
application) then Spring Security allows you to fully customize the source of security metadata.
|
||||
You can make it fully dynamic if you choose.
|
||||
</para>
|
||||
<para>
|
||||
Both method and web security are protected by subclasses of
|
||||
<classname>AbstractSecurityInterceptor</classname> which is configured with a
|
||||
<interfacename>SecurityMetadataSource</interfacename> from which it obtains
|
||||
the metadata for a particular method or filter invocation <footnote><para>This
|
||||
class previouly went by the rather obscure name of <classname>ObjectDefinitionSource</classname>,
|
||||
but has been renamed in Spring Security 3.0</para></footnote>. For web security, the
|
||||
interceptor class is <classname>FilterSecurityInterceptor</classname> and it uses
|
||||
the marker interface <interfacename>FilterInvocationSecurityMetadataSource</interfacename>.
|
||||
The <quote>secured object</quote> type it operates on is a <classname>FilterInvocation</classname>.
|
||||
The default implementation which is used (both in the namespace <literal><http></literal>
|
||||
and when configuring the interceptor explicitly, stores the list of URL patterns and their
|
||||
corresponding list of <quote>configuration attributes</quote> (instances of <interfacename>ConfigAttribute</interfacename>)
|
||||
in an in-memory map.
|
||||
</para>
|
||||
<para>
|
||||
To load the data from an alternative source, you must be using an explicitly declared security filter
|
||||
chain (typically Spring Security's <classname>FilterChainProxy</classname>) in order to customize the
|
||||
<classname>FilterSecurityInterceptor</classname> bean. You can't use the namespace. You would then implement
|
||||
<interfacename>FilterInvocationSecurityMetadataSource</interfacename> to load the data as you please for
|
||||
a particular <classname>FilterInvocation</classname><footnote><para>The <classname>FilterInvocation</classname>
|
||||
object contains the <classname>HttpServletRequest</classname>, so you can obtain the URL or any other
|
||||
relevant information on which to base your decision on what the list of returned attributes will contain.</para></footnote>.
|
||||
A very basic outline would look something like this:
|
||||
<programlisting language="java"><![CDATA[
|
||||
context. </para>
|
||||
<para> The first thing you should ask yourself is if you really need to do this.
|
||||
If an application requires securing, then it also requires that the security
|
||||
be tested thoroughly based on a defined policy. It may require auditing and
|
||||
acceptance testing before being rolled out into a production environment. A
|
||||
security-conscious organization should be aware that the benefits of their
|
||||
diligent testing process could be wiped out instantly by allowing the
|
||||
security settings to be modified at runtime by changing a row or two in a
|
||||
configuration database. If you have taken this into account (perhaps using
|
||||
multiple layers of security within your application) then Spring Security
|
||||
allows you to fully customize the source of security metadata. You can make
|
||||
it fully dynamic if you choose. </para>
|
||||
<para> Both method and web security are protected by subclasses of
|
||||
<classname>AbstractSecurityInterceptor</classname> which is configured
|
||||
with a <interfacename>SecurityMetadataSource</interfacename> from which it
|
||||
obtains the metadata for a particular method or filter invocation <footnote>
|
||||
<para>This class previouly went by the rather obscure name of
|
||||
<classname>ObjectDefinitionSource</classname>, but has been
|
||||
renamed in Spring Security 3.0</para>
|
||||
</footnote>. For web security, the interceptor class is
|
||||
<classname>FilterSecurityInterceptor</classname> and it uses the marker
|
||||
interface
|
||||
<interfacename>FilterInvocationSecurityMetadataSource</interfacename>.
|
||||
The <quote>secured object</quote> type it operates on is a
|
||||
<classname>FilterInvocation</classname>. The default implementation
|
||||
which is used (both in the namespace <literal><http></literal> and
|
||||
when configuring the interceptor explicitly, stores the list of URL patterns
|
||||
and their corresponding list of <quote>configuration attributes</quote>
|
||||
(instances of <interfacename>ConfigAttribute</interfacename>) in an
|
||||
in-memory map. </para>
|
||||
<para> To load the data from an alternative source, you must be using an
|
||||
explicitly declared security filter chain (typically Spring Security's
|
||||
<classname>FilterChainProxy</classname>) in order to customize the
|
||||
<classname>FilterSecurityInterceptor</classname> bean. You can't use the
|
||||
namespace. You would then implement
|
||||
<interfacename>FilterInvocationSecurityMetadataSource</interfacename> to
|
||||
load the data as you please for a particular
|
||||
<classname>FilterInvocation</classname><footnote>
|
||||
<para>The <classname>FilterInvocation</classname> object contains the
|
||||
<classname>HttpServletRequest</classname>, so you can obtain the
|
||||
URL or any other relevant information on which to base your decision
|
||||
on what the list of returned attributes will contain.</para>
|
||||
</footnote>. A very basic outline would look something like this: <programlisting language="java"><![CDATA[
|
||||
public class MyFilterSecurityMetadataSource implements FilterInvocationSecurityMetadataSource {
|
||||
|
||||
public List<ConfigAttribute> getAttributes(Object object) {
|
||||
@ -366,8 +425,8 @@
|
||||
return FilterInvocation.class.isAssignableFrom(clazz);
|
||||
}
|
||||
}
|
||||
]]></programlisting>
|
||||
For more information, look at the code for <classname>DefaultFilterInvocationSecurityMetadataSource</classname>.
|
||||
]]></programlisting> For more information, look at the code for
|
||||
<classname>DefaultFilterInvocationSecurityMetadataSource</classname>.
|
||||
</para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
@ -377,45 +436,45 @@
|
||||
Spring Security?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>It will depend on what features you
|
||||
are using and what type of application you are developing. With Spring Security 3.0,
|
||||
the project jars are divided into clearly distinct areas of functionality, so it is
|
||||
straightforward to work out which Spring Security jars you need from your application requirements.
|
||||
All applications will need the <filename>spring-security-core</filename> jar.
|
||||
If you're developing a web application,
|
||||
you need the <filename>spring-security-web</filename> jar. If you're using security namespace
|
||||
configuration you need the <filename>spring-security-config</filename> jar, for LDAP support you need the
|
||||
<filename>spring-security-ldap</filename> jar and so on.
|
||||
</para>
|
||||
<para>
|
||||
For third-party jars the situation isn't always quite so obvious.
|
||||
A good starting point is to copy those from one of the
|
||||
pre-built sample applications WEB-INF/lib directories. For a basic
|
||||
application, you can start with the tutorial sample. If you want to use
|
||||
LDAP, with an embedded test server, then use the LDAP sample as a starting
|
||||
point. </para>
|
||||
<para>It will depend on what features you are using and what type of application
|
||||
you are developing. With Spring Security 3.0, the project jars are divided
|
||||
into clearly distinct areas of functionality, so it is straightforward to
|
||||
work out which Spring Security jars you need from your application
|
||||
requirements. All applications will need the
|
||||
<filename>spring-security-core</filename> jar. If you're developing a
|
||||
web application, you need the <filename>spring-security-web</filename> jar.
|
||||
If you're using security namespace configuration you need the
|
||||
<filename>spring-security-config</filename> jar, for LDAP support you
|
||||
need the <filename>spring-security-ldap</filename> jar and so on. </para>
|
||||
<para> For third-party jars the situation isn't always quite so obvious. A good
|
||||
starting point is to copy those from one of the pre-built sample
|
||||
applications WEB-INF/lib directories. For a basic application, you can start
|
||||
with the tutorial sample. If you want to use LDAP, with an embedded test
|
||||
server, then use the LDAP sample as a starting point. </para>
|
||||
<para> If you are building your project with maven, then adding the appropriate
|
||||
Spring Security modules as dependencies to your pom.xml will automatically pull in the core
|
||||
jars that the framework requires. Any which are marked as "optional" in the
|
||||
Spring Security POM files will have to be added to your own pom.xml file if
|
||||
you need them. </para>
|
||||
Spring Security modules as dependencies to your pom.xml will automatically
|
||||
pull in the core jars that the framework requires. Any which are marked as
|
||||
"optional" in the Spring Security POM files will have to be added to your
|
||||
own pom.xml file if you need them. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
<qandaentry xml:id="faq-ldap-authorities">
|
||||
<question><para>How do I authenticate against LDAP but load user roles from a database?</para></question>
|
||||
<question>
|
||||
<para>How do I authenticate against LDAP but load user roles from a
|
||||
database?</para>
|
||||
</question>
|
||||
<answer>
|
||||
<para>
|
||||
The <code>LdapAuthenticationProvider</code> bean (which handles normal LDAP authentication in Spring
|
||||
Security) is configured with two separate strategy interfaces, one
|
||||
which performs the authenticatation and one which loads the user authorities, called
|
||||
<interfacename>LdapAuthenticator</interfacename> and <interfacename>LdapAuthoritiesPopulator</interfacename>
|
||||
respectively. The <classname>DefaultLdapAuthoitiesPopulator</classname> loads the user authorities
|
||||
from the LDAP directory and has various configuration parameters to allow you to
|
||||
specify how these should be retrieved.
|
||||
</para>
|
||||
<para>
|
||||
To use JDBC instead, you can implement the interface yourself, using whatever SQL is appropriate for your schema:
|
||||
<programlisting language="java"><![CDATA[
|
||||
<para> The <code>LdapAuthenticationProvider</code> bean (which handles normal
|
||||
LDAP authentication in Spring Security) is configured with two separate
|
||||
strategy interfaces, one which performs the authenticatation and one which
|
||||
loads the user authorities, called
|
||||
<interfacename>LdapAuthenticator</interfacename> and
|
||||
<interfacename>LdapAuthoritiesPopulator</interfacename> respectively.
|
||||
The <classname>DefaultLdapAuthoitiesPopulator</classname> loads the user
|
||||
authorities from the LDAP directory and has various configuration parameters
|
||||
to allow you to specify how these should be retrieved. </para>
|
||||
<para> To use JDBC instead, you can implement the interface yourself, using
|
||||
whatever SQL is appropriate for your schema: <programlisting language="java"><![CDATA[
|
||||
public class MyAuthoritiesPopulator implements LdapAuthoritiesPopulator {
|
||||
@Autowired
|
||||
JdbcTemplate template;
|
||||
@ -432,13 +491,12 @@
|
||||
}
|
||||
}
|
||||
}
|
||||
]]></programlisting>
|
||||
You would then add a bean of this type to your application context and inject it into the <code>LdapAuthenticationProvider</code>.
|
||||
This is covered in the section on configuring LDAP using explicit Spring beans in the LDAP chapter of the reference manual.
|
||||
Note that you can't use the namespace for configuration in this case.
|
||||
You should also consult the Javadoc for the relevant classes and interfaces.
|
||||
</para>
|
||||
|
||||
]]></programlisting> You would then add a bean of this type to your application context and inject
|
||||
it into the <code>LdapAuthenticationProvider</code>. This is covered in the
|
||||
section on configuring LDAP using explicit Spring beans in the LDAP chapter
|
||||
of the reference manual. Note that you can't use the namespace for
|
||||
configuration in this case. You should also consult the Javadoc for the
|
||||
relevant classes and interfaces. </para>
|
||||
</answer>
|
||||
</qandaentry>
|
||||
</qandadiv>
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user