Coverage report

| %line | %branch
--- | --- | ---

org.apache.commons.jelly.impl.DefaultTagLibraryResolver

0%

0%

1

     /*

2

      * Copyright 2002,2004 The Apache Software Foundation.

3

      *

4

      * Licensed under the Apache License, Version 2.0 (the "License");

5

      * you may not use this file except in compliance with the License.

6

      * You may obtain a copy of the License at

7

      *

8

      *      http://www.apache.org/licenses/LICENSE-2.0

9

      *

10

      * Unless required by applicable law or agreed to in writing, software

11

      * distributed under the License is distributed on an "AS IS" BASIS,

12

      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

13

      * See the License for the specific language governing permissions and

14

      * limitations under the License.

15

      */

16

     package org.apache.commons.jelly.impl;

17

18

     import org.apache.commons.discovery.ResourceClass;

19

     import org.apache.commons.discovery.ResourceClassIterator;

20

     import org.apache.commons.discovery.resource.ClassLoaders;

21

     import org.apache.commons.discovery.resource.classes.DiscoverClasses;

22

     import org.apache.commons.jelly.TagLibrary;

23

     import org.apache.commons.jelly.util.ClassLoaderUtils;

24

     import org.apache.commons.logging.Log;

25

     import org.apache.commons.logging.LogFactory;

26

27

28

     /**

29

      * <p><code>DefaultTagLibraryResolver</code> is a default implemenation

30

      * which attempts to interpret the URI as a String called 'jelly:className'

31

      * and class load the given Java class. Otherwise META-INF/services/jelly/uri

32

      * is searched for on the thread context's class path and, if found, that

33

      * class will be loaded.</p>

34

      *

35

      * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>

36

      * @version $Revision: 155420 $

37

      */

38

     public class DefaultTagLibraryResolver implements TagLibraryResolver {

39

40

         /** The Log to which logging calls will be made. */

41

0

         private static final Log log = LogFactory.getLog(DefaultTagLibraryResolver.class);

42

43

         private DiscoverClasses discovery;

44

45

         /**

46

          * The class loader to use for instantiating application objects.

47

          * If not specified, the context class loader, or the class loader

48

          * used to load this class itself, is used, based on the value of the

49

          * <code>useContextClassLoader</code> variable.

50

          */

51

         private ClassLoader classLoader;

52

53

         /**

54

          * Do we want to use the Context ClassLoader when loading classes

55

          * for instantiating new objects?  Default is <code>false</code>.

56

          */

57

0

         private boolean useContextClassLoader = false;

58

59

60

0

         public DefaultTagLibraryResolver() {

61

0

         }

62

63

64

         // TagLibraryResolver interface

65

         //-------------------------------------------------------------------------

66

67

         /**

68

          * Attempts to resolve the given URI to be associated with a TagLibrary

69

          * otherwise null is returned to indicate no tag library could be found

70

          * so that the namespace URI should be treated as just vanilla XML.

71

          */

72

         public TagLibrary resolveTagLibrary(String uri) {

73

0

             DiscoverClasses discovery = getDiscoverClasses();

74

0

             String name = uri;

75

0

             if ( uri.startsWith( "jelly:" ) ) {

76

0

                 name = "jelly." + uri.substring(6);

77

             }

78

79

0

             log.info( "Looking up service name: " + name );

80

81

     /*

82

             ClassLoaders loaders = ClassLoaders.getAppLoaders(TagLibrary.class, getClass(), false);

83

84

             DiscoverClass discover = new DiscoverClass(loaders);

85

             Class implClass = discover.find(TestInterface2.class);

86

87

88

89

             TagLibrary answer = null;

90

             try {

91

                 answer = (TagLibrary) DiscoverSingleton.find(TagLibrary.class, name);

92

             }

93

             catch (Exception e) {

94

                 log.error( "Could not load service: " + name );

95

             }

96

             return answer;

97

     */

98

0

             ResourceClassIterator iter = discovery.findResourceClasses(name);

99

0

             while (iter.hasNext()) {

100

0

                 ResourceClass resource = iter.nextResourceClass();

101

                 try {

102

0

                     Class typeClass = resource.loadClass();

103

0

                     if ( typeClass != null ) {

104

0

                         return newInstance(uri, typeClass);

105

                     }

106

                 }

107

0

                 catch (Exception e) {

108

0

                     log.error( "Could not load service: " + resource );

109

0

                 }

110

0

             }

111

0

             log.info( "Could not find any services for name: " + name );

112

0

             return null;

113

         }

114

115

         // Properties

116

         //-------------------------------------------------------------------------

117

118

         /**

119

          * Return the class loader to be used for instantiating application objects

120

          * when required.  This is determined based upon the following rules:

121

          * <ul>

122

          * <li>The class loader set by <code>setClassLoader()</code>, if any</li>

123

          * <li>The thread context class loader, if it exists and the

124

          *     <code>useContextClassLoader</code> property is set to true</li>

125

          * <li>The class loader used to load the XMLParser class itself.

126

          * </ul>

127

          */

128

         public ClassLoader getClassLoader() {

129

0

             return ClassLoaderUtils.getClassLoader(classLoader, useContextClassLoader, getClass());

130

         }

131

132

         /**

133

          * Set the class loader to be used for instantiating application objects

134

          * when required.

135

          *

136

          * @param classLoader The new class loader to use, or <code>null</code>

137

          *  to revert to the standard rules

138

          */

139

         public void setClassLoader(ClassLoader classLoader) {

140

0

             this.classLoader = classLoader;

141

0

         }

142

143

         /**

144

          * Return the boolean as to whether the context classloader should be used.

145

          */

146

         public boolean getUseContextClassLoader() {

147

0

             return useContextClassLoader;

148

         }

149

150

         /**

151

          * Determine whether to use the Context ClassLoader (the one found by

152

          * calling <code>Thread.currentThread().getContextClassLoader()</code>)

153

          * to resolve/load classes.  If not

154

          * using Context ClassLoader, then the class-loading defaults to

155

          * using the calling-class' ClassLoader.

156

          *

157

          * @param boolean determines whether to use JellyContext ClassLoader.

158

          */

159

         public void setUseContextClassLoader(boolean use) {

160

0

             useContextClassLoader = use;

161

0

         }

162

163

         /**

164

          * @return the DiscoverClasses instance to use to locate services.

165

          *  This object is lazily created if it has not been configured.

166

          */

167

         public DiscoverClasses getDiscoverClasses() {

168

0

             if ( discovery == null ) {

169

0

                 ClassLoaders loaders = ClassLoaders.getAppLoaders(TagLibrary.class, getClass(), false);

170

0

                 discovery = new DiscoverClasses(loaders);

171

             }

172

0

             return discovery;

173

         }

174

175

         /**

176

          * Sets the fully configured DiscoverClasses instance to be used to

177

          * lookup services

178

          */

179

         public void setDiscoverClasses(DiscoverClasses discovery) {

180

0

             this.discovery = discovery;

181

0

         }

182

183

         // Implementation methods

184

         //-------------------------------------------------------------------------

185

186

         /**

187

          * Instantiates the given class name. Otherwise an exception is logged

188

          * and null is returned

189

          */

190

         protected TagLibrary loadClass(String uri, String className) {

191

             try {

192

0

                 Class theClass = getClassLoader().loadClass(className);

193

0

                 if ( theClass != null ) {

194

0

                     return newInstance(uri, theClass);

195

                 }

196

             }

197

0

             catch (ClassNotFoundException e) {

198

0

                 log.error("Could not find the class: " + className + " when trying to resolve URI: " + uri, e);

199

0

             }

200

0

             return null;

201

         }

202

203

204

         /**

205

          * Creates a new instance of the given TagLibrary class or

206

          * return null if it could not be instantiated.

207

          */

208

         protected TagLibrary newInstance(String uri, Class theClass) {

209

             try {

210

0

                 Object object = theClass.newInstance();

211

0

                 if (object instanceof TagLibrary) {

212

0

                     return (TagLibrary) object;

213

                 }

214

                 else {

215

0

                     log.error(

216

                         "The tag library object mapped to: "

217

                             + uri

218

                             + " is not a TagLibrary. Object = "

219

                             + object);

220

                 }

221

             }

222

0

             catch (Exception e) {

223

0

                 log.error(

224

                     "Could not instantiate instance of class: " + theClass.getName() + ". Reason: " + e,

225

                     e);

226

0

             }

227

0

             return null;

228

         }

229

230

     }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.