jspruntimelibrary.java

JspRuntime自动填充机制；向对jsp深入了解的可以

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3)
// Source File Name:   JspRuntimeLibrary.java

package com.sun.jsp.runtime;

import com.sun.jsp.JspException;
import java.beans.*;
import java.io.File;
import java.lang.reflect.Method;
import java.util.Enumeration;
import javax.servlet.ServletRequest;

public class JspRuntimeLibrary
{

    public static Object convert(String s, Class class1)
        throws JspException
    {
        try
        {
            if(s == null)
                if(class1.equals(java.lang.Boolean.class) || class1.equals(Boolean.TYPE))
                    s = "false";
                else
                    return null;
            if(class1.equals(java.lang.Boolean.class) || class1.equals(Boolean.TYPE))
            {
                if(s.equalsIgnoreCase("on"))
                    s = "true";
                else
                    s = "false";
                return new Boolean(s);
            }
            if(class1.equals(java.lang.Byte.class) || class1.equals(Byte.TYPE))
                return new Byte(s);
            if(class1.equals(java.lang.Character.class) || class1.equals(Character.TYPE))
                if(s.length() > 0)
                    return new Character(s.charAt(0));
                else
                    return null;
            if(class1.equals(java.lang.Short.class) || class1.equals(Short.TYPE))
                return new Short(s);
            if(class1.equals(java.lang.Integer.class) || class1.equals(Integer.TYPE))
                return new Integer(s);
            if(class1.equals(java.lang.Float.class) || class1.equals(Float.TYPE))
                return new Float(s);
            if(class1.equals(java.lang.Long.class) || class1.equals(Long.TYPE))
                return new Long(s);
            if(class1.equals(java.lang.Double.class) || class1.equals(Double.TYPE))
                return new Double(s);
            if(class1.equals(java.lang.String.class))
                return s;
            if(class1.equals(java.io.File.class))
                return new File(s);
        }
        catch(Exception exception)
        {
            throw new JspException(exception);
        }
        return null;
    }

    public static void introspect(Object obj, ServletRequest servletrequest)
        throws JspException
    {
        for(Enumeration enumeration = servletrequest.getParameterNames(); enumeration.hasMoreElements();)
        {
            String s = (String)enumeration.nextElement();
            String s1 = servletrequest.getParameter(s);
            if(s1 != null && !s1.equals(""))
                introspecthelper(obj, s, s1, servletrequest);
        }

    }

    public static void introspecthelper(Object obj, String s, String s1, ServletRequest servletrequest)
        throws JspException
    {
        try
        {
            Method method = null;
            Class class1 = null;
            BeanInfo beaninfo = Introspector.getBeanInfo(obj.getClass());
            if(beaninfo != null)
            {
                PropertyDescriptor apropertydescriptor[] = beaninfo.getPropertyDescriptors();
                for(int i = 0; i < apropertydescriptor.length; i++)
                {
                    if(!apropertydescriptor[i].getName().equals(s))
                        continue;
                    method = apropertydescriptor[i].getWriteMethod();
                    class1 = apropertydescriptor[i].getPropertyType();
                    break;
                }

            }
            if(method != null)
            {
                if(class1.isArray())
                {
                    Class class2 = class1.getComponentType();
                    String as[] = servletrequest.getParameterValues(s);
                    if(class2.equals(java.lang.String.class))
                    {
                        method.invoke(obj, new Object[] {
                            as
                        });
                        return;
                    } else
                    {
                        createTypedArray(obj, method, as, class2);
                        return;
                    }
                }
                Object obj1 = convert(s1, class1);
                if(obj1 != null)
                {
                    method.invoke(obj, new Object[] {
                        obj1
                    });
                    return;
                }
            }
        }
        catch(Exception exception)
        {
            throw new JspException(exception);
        }
    }



    public static void createTypedArray(Object obj, Method method, String as[], Class class1)
        throws JspException
    {
        try
        {
            if(class1.equals(java.lang.Integer.class))
            {
                Integer ainteger[] = new Integer[as.length];
                for(int i = 0; i < as.length; i++)
                    ainteger[i] = new Integer(as[i]);

                method.invoke(obj, new Object[] {
                    ainteger
                });
                return;
            }
            if(class1.equals(java.lang.Byte.class))
            {
                Byte abyte[] = new Byte[as.length];
                for(int j = 0; j < as.length; j++)
                    abyte[j] = new Byte(as[j]);

                method.invoke(obj, new Object[] {
                    abyte
                });
                return;
            }
            if(class1.equals(java.lang.Boolean.class))
            {
                Boolean aboolean[] = new Boolean[as.length];
                for(int k = 0; k < as.length; k++)
                    aboolean[k] = new Boolean(as[k]);

                method.invoke(obj, new Object[] {
                    aboolean
                });
                return;
            }
            if(class1.equals(java.lang.Short.class))
            {
                Short ashort[] = new Short[as.length];
                for(int l = 0; l < as.length; l++)
                    ashort[l] = new Short(as[l]);

                method.invoke(obj, new Object[] {
                    ashort
                });
                return;
            }
            if(class1.equals(java.lang.Long.class))
            {
                Long along[] = new Long[as.length];
                for(int i1 = 0; i1 < as.length; i1++)
                    along[i1] = new Long(as[i1]);

                method.invoke(obj, new Object[] {
                    along
                });
                return;
            }
            if(class1.equals(java.lang.Double.class))
            {
                Double adouble[] = new Double[as.length];
                for(int j1 = 0; j1 < as.length; j1++)
                    adouble[j1] = new Double(as[j1]);

                method.invoke(obj, new Object[] {
                    adouble
                });
                return;
            }
            if(class1.equals(java.lang.Float.class))
            {
                Float afloat[] = new Float[as.length];
                for(int k1 = 0; k1 < as.length; k1++)
                    afloat[k1] = new Float(as[k1]);

                method.invoke(obj, new Object[] {
                    afloat
                });
                return;
            }
            if(class1.equals(java.lang.Character.class))
            {
                Character acharacter[] = new Character[as.length];
                for(int l1 = 0; l1 < as.length; l1++)
                    acharacter[l1] = new Character(as[l1].charAt(0));

                method.invoke(obj, new Object[] {
                    acharacter
                });
                return;
            }
            if(class1.equals(Integer.TYPE))
            {
                int ai[] = new int[as.length];
                for(int i2 = 0; i2 < as.length; i2++)
                    ai[i2] = Integer.parseInt(as[i2]);

                method.invoke(obj, new Object[] {
                    ai
                });
                return;
            }
            if(class1.equals(Byte.TYPE))
            {
                byte abyte0[] = new byte[as.length];
                for(int j2 = 0; j2 < as.length; j2++)
                    abyte0[j2] = Byte.parseByte(as[j2]);

                method.invoke(obj, new Object[] {
                    abyte0
                });
                return;
            }
            if(class1.equals(Boolean.TYPE))
            {
                boolean aflag[] = new boolean[as.length];
                for(int k2 = 0; k2 < as.length; k2++)
                    aflag[k2] = Boolean.getBoolean(as[k2]);

                method.invoke(obj, new Object[] {
                    aflag
                });
                return;
            }
            if(class1.equals(Short.TYPE))
            {
                short aword0[] = new short[as.length];
                for(int l2 = 0; l2 < as.length; l2++)
                    aword0[l2] = Short.parseShort(as[l2]);

                method.invoke(obj, new Object[] {
                    aword0
                });
                return;
            }
            if(class1.equals(Long.TYPE))
            {
                long al[] = new long[as.length];
                for(int i3 = 0; i3 < as.length; i3++)
                    al[i3] = Long.parseLong(as[i3]);

                method.invoke(obj, new Object[] {
                    al
                });
                return;
            }
            if(class1.equals(Double.TYPE))
            {
                double ad[] = new double[as.length];
                for(int j3 = 0; j3 < as.length; j3++)
                    ad[j3] = Double.valueOf(as[j3]).doubleValue();

                method.invoke(obj, new Object[] {
                    ad
                });
                return;
            }
            if(class1.equals(Float.TYPE))
            {
                float af[] = new float[as.length];
                for(int k3 = 0; k3 < as.length; k3++)
                    af[k3] = Float.valueOf(as[k3]).floatValue();

                method.invoke(obj, new Object[] {
                    af
                });
                return;
            }
            if(class1.equals(Character.TYPE))
            {
                char ac[] = new char[as.length];
                for(int l3 = 0; l3 < as.length; l3++)
                    ac[l3] = as[l3].charAt(0);

                method.invoke(obj, new Object[] {
                    ac
                });
                return;
            }
        }
        catch(Exception _ex)
        {
            throw new JspException("error in invoking method");
        }
    }


    public JspRuntimeLibrary()
    {
    }
}