Attachment #29865 for bug #54448

View | Details | Raw Unified | Return to bug 54448
Collapse All | Expand All




                // No match - ignore this injection target
                continue;
            }
            targetType = Introspection.convertPrimitiveType(targetType);

            if (typeClass == null) {
                // Need to find a common type amongst the injection targets

        }
        return null;
    }

    private Class<?> convertPrimitiveType(Class<?> clazz) {
        if (clazz.equals(char.class)) {
            return Character.class;
        } else if (clazz.equals(int.class)) {
            return Integer.class;
        } else if (clazz.equals(boolean.class)) {
            return Boolean.class;
        } else if (clazz.equals(double.class)) {
            return Double.class;
        } else if (clazz.equals(byte.class)) {
            return Byte.class;
        } else if (clazz.equals(short.class)) {
            return Short.class;
        } else if (clazz.equals(long.class)) {
            return Long.class;
        } else if (clazz.equals(float.class)) {
            return Float.class;
        } else {
            return clazz;
        }
    }
}




                    Resource annotation = field.getAnnotation(Resource.class);
                    String defaultName =
                            classClass.getName() + SEPARATOR + field.getName();
                    Class<?> defaultType = field.getType();
                    addResource(context, annotation, defaultName, defaultType);
                }
            }

                    String defaultName = classClass.getName() + SEPARATOR +
                            Introspection.getPropertyName(method);

                    Class<?> defaultType =
                            (method.getParameterTypes()[0]);
                    addResource(context, annotation, defaultName, defaultType);
                }
            }

    }

    protected static void addResource(Context context, Resource annotation,
            String defaultName, Class<?> defaultType) {
        String name = getName(annotation, defaultName);
        String type = getType(annotation, defaultType);
            

    }


    private static String getType(Resource annotation, Class<?> defaultType) {
        Class<?> type = annotation.type();
        if (type == null || type.equals(Object.class)) {
            if (defaultType != null) {
                type = defaultType;
            }
        }
        return Introspection.convertPrimitiveType(type).getCanonicalName();
    }






        }
        return clazz;
    }

    /**
     * Converts the primitive type to its corresponding wrapper.
     * 
     * @param clazz
     *            Class that will be evaluated
     * @return if the parameter is a primitive type returns its wrapper;
     *         otherwise returns the same class
     */
    public static Class<?> convertPrimitiveType(Class<?> clazz) {
        if (clazz.equals(char.class)) {
            return Character.class;
        } else if (clazz.equals(int.class)) {
            return Integer.class;
        } else if (clazz.equals(boolean.class)) {
            return Boolean.class;
        } else if (clazz.equals(double.class)) {
            return Double.class;
        } else if (clazz.equals(byte.class)) {
            return Byte.class;
        } else if (clazz.equals(short.class)) {
            return Short.class;
        } else if (clazz.equals(long.class)) {
            return Long.class;
        } else if (clazz.equals(float.class)) {
            return Float.class;
        } else {
            return clazz;
        }
    }
}




        assertPageContains("/test/testServlet", "postConstruct1()");
    }

    @Test
    public void testBug54448() throws Exception {
        Tomcat tomcat = getTomcatInstance();

        File appDir = new File("test/webapp-3.0-fragments");
        Context context = tomcat.addWebapp(null, "/test",
                appDir.getAbsolutePath());

        Tomcat.addServlet(context, "TestServlet",
                "org.apache.catalina.startup.TesterServletWithAnnotations");
        context.addServletMapping("/testServlet", "TestServlet");

        tomcat.enableNaming();

        tomcat.start();

        assertPageContains("/test/testServlet", "envEntry: 1");
    }

    private static class CustomDefaultServletSCI
            implements ServletContainerInitializer {





/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.catalina.startup;

import java.io.IOException;

import javax.annotation.Resource;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TesterServletWithAnnotations extends HttpServlet {

    private static final long serialVersionUID = 1L;

    @Resource(mappedName = "1")
    private int envEntry;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.setContentType("text/plain");
        resp.getWriter().print("envEntry: " + envEntry);
    }
}
native

Return to bug 54448

Lines 1190-1196 Link Here

(-)java/org/apache/catalina/deploy/NamingResources.java (-23 / +1 lines)
1190	// No match - ignore this injection target	1190	// No match - ignore this injection target
1191	continue;	1191	continue;
1192	}	1192	}
1193	targetType = convertPrimitiveType(targetType);	1193	targetType = Introspection.convertPrimitiveType(targetType);
1194		1194
1195	if (typeClass == null) {	1195	if (typeClass == null) {
1196	// Need to find a common type amongst the injection targets	1196	// Need to find a common type amongst the injection targets
Lines 1243-1268 Link Here
1243	}	1243	}
1244	return null;	1244	return null;
1245	}	1245	}
1246
1247	private Class<?> convertPrimitiveType(Class<?> clazz) {
1248	if (clazz.equals(char.class)) {
1249	return Character.class;
1250	} else if (clazz.equals(int.class)) {
1251	return Integer.class;
1252	} else if (clazz.equals(boolean.class)) {
1253	return Boolean.class;
1254	} else if (clazz.equals(double.class)) {
1255	return Double.class;
1256	} else if (clazz.equals(byte.class)) {
1257	return Byte.class;
1258	} else if (clazz.equals(short.class)) {
1259	return Short.class;
1260	} else if (clazz.equals(long.class)) {
1261	return Long.class;
1262	} else if (clazz.equals(float.class)) {
1263	return Float.class;
1264	} else {
1265	return clazz;
1266	}
1267	}
1268	}	1246	}

Lines 265-271 Link Here

(-)java/org/apache/catalina/startup/WebAnnotationSet.java (-8 / +8 lines)
265	Resource annotation = field.getAnnotation(Resource.class);	265	Resource annotation = field.getAnnotation(Resource.class);
266	String defaultName =	266	String defaultName =
267	classClass.getName() + SEPARATOR + field.getName();	267	classClass.getName() + SEPARATOR + field.getName();
268	String defaultType = field.getType().getCanonicalName();	268	Class<?> defaultType = field.getType();
269	addResource(context, annotation, defaultName, defaultType);	269	addResource(context, annotation, defaultName, defaultType);
270	}	270	}
271	}	271	}
Lines 290-297 Link Here
290	String defaultName = classClass.getName() + SEPARATOR +	290	String defaultName = classClass.getName() + SEPARATOR +
291	Introspection.getPropertyName(method);	291	Introspection.getPropertyName(method);
292		292
293	String defaultType =	293	Class<?> defaultType =
294	(method.getParameterTypes()[0]).getCanonicalName();	294	(method.getParameterTypes()[0]);
295	addResource(context, annotation, defaultName, defaultType);	295	addResource(context, annotation, defaultName, defaultType);
296	}	296	}
297	}	297	}
Lines 309-315 Link Here
309	}	309	}
310		310
311	protected static void addResource(Context context, Resource annotation,	311	protected static void addResource(Context context, Resource annotation,
312	String defaultName, String defaultType) {	312	String defaultName, Class<?> defaultType) {
313	String name = getName(annotation, defaultName);	313	String name = getName(annotation, defaultName);
314	String type = getType(annotation, defaultType);	314	String type = getType(annotation, defaultType);
315		315
Lines 412-425 Link Here
412	}	412	}
413		413
414		414
415	private static String getType(Resource annotation, String defaultType) {	415	private static String getType(Resource annotation, Class<?> defaultType) {
416	String type = annotation.type().getCanonicalName();	416	Class<?> type = annotation.type();
417	if (type == null \|\| type.equals("java.lang.Object")) {	417	if (type == null \|\| type.equals(Object.class)) {
418	if (defaultType != null) {	418	if (defaultType != null) {
419	type = defaultType;	419	type = defaultType;
420	}	420	}
421	}	421	}
422	return type;	422	return Introspection.convertPrimitiveType(type).getCanonicalName();
423	}	423	}
424		424
425		425

Lines 153-156 Link Here

(-)java/org/apache/catalina/util/Introspection.java (+30 lines)
153	}	153	}
154	return clazz;	154	return clazz;
155	}	155	}
		156
		157	/**
		158	* Converts the primitive type to its corresponding wrapper.
		159	*
		160	* @param clazz
		161	* Class that will be evaluated
		162	* @return if the parameter is a primitive type returns its wrapper;
		163	* otherwise returns the same class
		164	*/
		165	public static Class<?> convertPrimitiveType(Class<?> clazz) {
		166	if (clazz.equals(char.class)) {
		167	return Character.class;
		168	} else if (clazz.equals(int.class)) {
		169	return Integer.class;
		170	} else if (clazz.equals(boolean.class)) {
		171	return Boolean.class;
		172	} else if (clazz.equals(double.class)) {
		173	return Double.class;
		174	} else if (clazz.equals(byte.class)) {
		175	return Byte.class;
		176	} else if (clazz.equals(short.class)) {
		177	return Short.class;
		178	} else if (clazz.equals(long.class)) {
		179	return Long.class;
		180	} else if (clazz.equals(float.class)) {
		181	return Float.class;
		182	} else {
		183	return clazz;
		184	}
		185	}
156	}	186	}

Lines 126-131 Link Here

(-)test/org/apache/catalina/startup/TestContextConfig.java (+19 lines)
126	assertPageContains("/test/testServlet", "postConstruct1()");	126	assertPageContains("/test/testServlet", "postConstruct1()");
127	}	127	}
128		128
		129	@Test
		130	public void testBug54448() throws Exception {
		131	Tomcat tomcat = getTomcatInstance();
		132
		133	File appDir = new File("test/webapp-3.0-fragments");
		134	Context context = tomcat.addWebapp(null, "/test",
		135	appDir.getAbsolutePath());
		136
		137	Tomcat.addServlet(context, "TestServlet",
		138	"org.apache.catalina.startup.TesterServletWithAnnotations");
		139	context.addServletMapping("/testServlet", "TestServlet");
		140
		141	tomcat.enableNaming();
		142
		143	tomcat.start();
		144
		145	assertPageContains("/test/testServlet", "envEntry: 1");
		146	}
		147
129	private static class CustomDefaultServletSCI	148	private static class CustomDefaultServletSCI
130	implements ServletContainerInitializer {	149	implements ServletContainerInitializer {
131		150

Line 0 Link Here

(-)test/org/apache/catalina/startup/TesterServletWithAnnotations.java (+42 lines)
	1	/*
	2	* Licensed to the Apache Software Foundation (ASF) under one or more
	3	* contributor license agreements. See the NOTICE file distributed with
	4	* this work for additional information regarding copyright ownership.
	5	* The ASF licenses this file to You under the Apache License, Version 2.0
	6	* (the "License"); you may not use this file except in compliance with
	7	* the License. You may obtain a copy of the License at
	8	*
	9	* http://www.apache.org/licenses/LICENSE-2.0
	10	*
	11	* Unless required by applicable law or agreed to in writing, software
	12	* distributed under the License is distributed on an "AS IS" BASIS,
	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	14	* See the License for the specific language governing permissions and
	15	* limitations under the License.
	16	*/
	17
	18	package org.apache.catalina.startup;
	19
	20	import java.io.IOException;
	21
	22	import javax.annotation.Resource;
	23	import javax.servlet.ServletException;
	24	import javax.servlet.http.HttpServlet;
	25	import javax.servlet.http.HttpServletRequest;
	26	import javax.servlet.http.HttpServletResponse;
	27
	28	public class TesterServletWithAnnotations extends HttpServlet {
	29
	30	private static final long serialVersionUID = 1L;
	31
	32	@Resource(mappedName = "1")
	33	private int envEntry;
	34
	35	@Override
	36	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
	37	throws ServletException, IOException {
	38	resp.setContentType("text/plain");
	39	resp.getWriter().print("envEntry: " + envEntry);
	40	}
	41	}
	42	native