mina-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Jörg Michelberger (JIRA) <j...@apache.org>
Subject [jira] [Updated] (DIRMINA-991) Possible faster deserialization in AbstractIoBuffer object deserialization.
Date Mon, 20 Oct 2014 11:50:33 GMT

     [ https://issues.apache.org/jira/browse/DIRMINA-991?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]

Jörg Michelberger updated DIRMINA-991:
--------------------------------------
    Description: 
In ObjectInputStream.resolveClass() of AbstractIoBuffer.getObject() there is a possibility
to avoid duplicate call to Class.forName(). First call is done in readClassDescriptor() and
second in resolveClass() in case we deal with Serializables, class descriptors are cached
by the java platform, and a call of desc.forClass() in resolveClass() returns a previous resolved
class, which allows skipping the ClassLoader call.  I append the original source and a possible
fix for this issue. Is it possible to get this in the upcomming 2.0.9 release of MINA?
Original
{source}
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException
{
                    String name = desc.getName();
                    try {
                        return Class.forName(name, false, classLoader);
                    } catch (ClassNotFoundException ex) {
                        return super.resolveClass(desc);
                    }

{source}
Possible fix
{source}
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException
{
                    if (null == desc.forClass()) {  //this works for serializable desc classes.
                        String name = desc.getName();
                        try {
                            return Class.forName(name, false, classLoader);
                        } catch (ClassNotFoundException ex) {
                            return super.resolveClass(desc);
                        }
                    } else {
                        return desc.forClass();
                    }
                }
{source}

  was:
In ObjectInputStream.resolveClass() of AbstractIoBuffer.getObject() there is a possibility
to avoid duplicate call to Class.forName(). First call is done in readClassDescriptor() and
second in resolveClass() in case we deal with Serializables, class descriptors are cached
by the java platform, and a call of desc.forClass() in resolveClass() returns a previous resolved
class, which allows skipping the ClassLoader call.  I append the original source and a possible
fix for this issue. Is it possible to get this in the upcomming 2.0.9 release of MINA?
Original
{source}
 protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException
{
                    String name = desc.getName();
                    try {
                        return Class.forName(name, false, classLoader);
                    } catch (ClassNotFoundException ex) {
                        return super.resolveClass(desc);
                    }
                }
{source}
Possible fix
{source}
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException
{
                    if (null == desc.forClass()) {  //this works for serializable desc classes.
                        String name = desc.getName();
                        try {
                            return Class.forName(name, false, classLoader);
                        } catch (ClassNotFoundException ex) {
                            return super.resolveClass(desc);
                        }
                    } else {
                        return desc.forClass();
                    }
                }
{source}


> Possible faster deserialization in AbstractIoBuffer object deserialization.
> ---------------------------------------------------------------------------
>
>                 Key: DIRMINA-991
>                 URL: https://issues.apache.org/jira/browse/DIRMINA-991
>             Project: MINA
>          Issue Type: Improvement
>          Components: Core
>    Affects Versions: 2.0.8
>            Reporter: Jörg Michelberger
>              Labels: patch, performance
>
> In ObjectInputStream.resolveClass() of AbstractIoBuffer.getObject() there is a possibility
to avoid duplicate call to Class.forName(). First call is done in readClassDescriptor() and
second in resolveClass() in case we deal with Serializables, class descriptors are cached
by the java platform, and a call of desc.forClass() in resolveClass() returns a previous resolved
class, which allows skipping the ClassLoader call.  I append the original source and a possible
fix for this issue. Is it possible to get this in the upcomming 2.0.9 release of MINA?
> Original
> {source}
> protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException
{
>                     String name = desc.getName();
>                     try {
>                         return Class.forName(name, false, classLoader);
>                     } catch (ClassNotFoundException ex) {
>                         return super.resolveClass(desc);
>                     }
> {source}
> Possible fix
> {source}
> protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException
{
>                     if (null == desc.forClass()) {  //this works for serializable desc
classes.
>                         String name = desc.getName();
>                         try {
>                             return Class.forName(name, false, classLoader);
>                         } catch (ClassNotFoundException ex) {
>                             return super.resolveClass(desc);
>                         }
>                     } else {
>                         return desc.forClass();
>                     }
>                 }
> {source}



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)

Mime
View raw message