transform/src/patch/java/org/apache/cxf/bus/extension/Extension.java - tomee-jakarta - Git at Google

 /**
  * 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.cxf.bus.extension;

 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 import org.apache.cxf.Bus;
 import org.apache.cxf.common.i18n.Message;
 import org.apache.cxf.common.logging.LogUtils;
 import org.apache.cxf.common.util.StringUtils;

 public class Extension {
     protected static final Logger LOG = LogUtils.getL7dLogger(Extension.class);

     private static final String PROBLEM_CREATING_EXTENSION_CLASS = "PROBLEM_CREATING_EXTENSION_CLASS";

     protected String className;
     protected ClassLoader classloader;
     protected volatile Class<?> clazz;
     protected volatile Class<?> intf;
     protected String interfaceName;
     protected boolean deferred;
     protected Collection<String> namespaces = new ArrayList<>();
     protected Object[] args;
     protected volatile Object obj;
     protected boolean optional;
     protected boolean notFound;


     public Extension() {
     }

     public Extension(Class<?> cls, Class<?> inf) {
         clazz = cls;
         intf = inf;
         interfaceName = inf.getName();
         className = cls.getName();
         classloader = cls.getClassLoader();
     }
     public Extension(Class<?> cls) {
         clazz = cls;
         className = cls.getName();
         classloader = cls.getClassLoader();
     }
     public Extension(ClassLoader loader) {
         classloader = loader;
     }

     public Extension(Extension ext) {
         className = ext.className;
         interfaceName = ext.interfaceName;
         deferred = ext.deferred;
         namespaces = ext.namespaces;
         obj = ext.obj;
         clazz = ext.clazz;
         intf = ext.intf;
         classloader = ext.classloader;
         args = ext.args;
         optional = ext.optional;
     }

     public void setOptional(boolean b) {
         optional = b;
     }
     public boolean isOptional() {
         return optional;
     }

     public String getName() {
         return StringUtils.isEmpty(interfaceName) ? className : interfaceName;
     }
     public Object getLoadedObject() {
         return obj;
     }

     public Extension cloneNoObject() {
         Extension ext = new Extension(this);
         ext.obj = null;
         ext.clazz = null;
         ext.intf = null;
         return ext;
     }

     public String toString() {
         StringBuilder buf = new StringBuilder(128);
         buf.append("class: ");
         buf.append(className);
         buf.append(", interface: ");
         buf.append(interfaceName);
         buf.append(", deferred: ");
         buf.append(deferred ? "true" : "false");
         buf.append(", namespaces: (");
         int n = 0;
         for (String ns : namespaces) {
             if (n > 0) {
                 buf.append(", ");
             }
             buf.append(ns);
             n++;
         }
         buf.append(')');
         return buf.toString();
     }

     public String getClassname() {
         return className;
     }

     public void setClassname(String i) {
         clazz = null;
         notFound = false;
         className = i;
     }

     public String getInterfaceName() {
         return interfaceName;
     }

     public void setInterfaceName(String i) {
         interfaceName = i;
         notFound = false;
     }

     public boolean isDeferred() {
         return deferred;
     }

     public void setDeferred(boolean d) {
         deferred = d;
     }

     public Collection<String> getNamespaces() {
         return namespaces;
     }

     public void setArgs(Object[] a) {
         args = a;
     }

     protected Class<?> tryClass(String name, ClassLoader cl) {
         Throwable origEx = null;
         if (classloader != null) {
             try {
                 return classloader.loadClass(name);
             } catch (Throwable nex) {
                 //ignore, fall into the stuff below
                 //save the exception though as this is likely the important one
                 origEx = nex;
             }
         }
         try {
             return cl.loadClass(name);
         } catch (Throwable ex) {
             try {
                 // using the extension classloader as a fallback
                 return this.getClass().getClassLoader().loadClass(name);
             } catch (Throwable nex) {
                 notFound = true;
                 if (!optional) {
                     throw new ExtensionException(new Message("PROBLEM_LOADING_EXTENSION_CLASS", LOG, name),
                         origEx != null ? origEx : ex);
                 }
             }
         }
         return null;
     }

     public Class<?> getClassObject(ClassLoader cl) {
         if (notFound) {
             return null;
         }
         if (clazz != null) {
             return clazz;
         }
         synchronized (this) {
             if (clazz == null) {
                 clazz = tryClass(className, cl);
             }
         }
         return clazz;
     }
     public Object load(ClassLoader cl, Bus b) {
         if (obj != null) {
             return obj;
         }
         Class<?> cls = getClassObject(cl);
         try {
             if (notFound) {
                 return null;
             }
             try {
                 //if there is a Bus constructor, use it.
                 if (b != null && args == null) {
                     Constructor<?> con = cls.getConstructor(Bus.class);
                     obj = con.newInstance(b);
                     return obj;
                 } else if (b != null && args != null) {
                     try {
                         obj = cls.getConstructor(Bus.class, Object[].class).newInstance(b, args);
                     } catch (NoSuchMethodException ex) { // no bus
                         obj = cls.getConstructor(Object[].class).newInstance(args);
                     }
                     return obj;
                 } else if (args != null) {
                     Constructor<?> con = cls.getConstructor(Object[].class);
                     obj = con.newInstance(args);
                     return obj;
                 }
             } catch (InvocationTargetException ex) {
                 throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()),
                                              ex.getCause());
             } catch (InstantiationException | SecurityException ex) {
                 throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()), ex);
             } catch (NoSuchMethodException e) {
                 //ignore
             }
             obj = cls.getConstructor().newInstance();
         } catch (ExtensionException ex) {
             notFound = true;
             if (!optional) {
                 throw ex;
             }
             LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
         } catch (InvocationTargetException ex) {
             notFound = true;
             if (!optional) {
                 throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()),
                                              ex.getCause());
             }
             LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
         } catch (NoSuchMethodException ex) {
             notFound = true;
             List<Object> a = new ArrayList<>();
             if (b != null) {
                 a.add(b);
             }
             if (args != null) {
                 a.add(args);
             }
             if (!optional) {
                 throw new ExtensionException(new Message("PROBLEM_FINDING_CONSTRUCTOR", LOG,
                                                          cls.getName(), a), ex);
             }
             LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
         } catch (Throwable e) {
             notFound = true;
             if (!optional) {
                 throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()), e);
             }
             LOG.log(Level.FINE, "Could not load optional extension " + getName(), e);
         }
         return obj;
     }

     public Class<?> loadInterface(ClassLoader cl) {
         if (intf != null || notFound) {
             return intf;
         }
         synchronized (this) {
             if (intf == null) {
                 intf = tryClass(interfaceName, cl);
             }
         }
         return intf;
     }


 }
	/**
	* 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.cxf.bus.extension;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	import org.apache.cxf.Bus;
	import org.apache.cxf.common.i18n.Message;
	import org.apache.cxf.common.logging.LogUtils;
	import org.apache.cxf.common.util.StringUtils;

	public class Extension {
	protected static final Logger LOG = LogUtils.getL7dLogger(Extension.class);

	private static final String PROBLEM_CREATING_EXTENSION_CLASS = "PROBLEM_CREATING_EXTENSION_CLASS";

	protected String className;
	protected ClassLoader classloader;
	protected volatile Class<?> clazz;
	protected volatile Class<?> intf;
	protected String interfaceName;
	protected boolean deferred;
	protected Collection<String> namespaces = new ArrayList<>();
	protected Object[] args;
	protected volatile Object obj;
	protected boolean optional;
	protected boolean notFound;


	public Extension() {
	}

	public Extension(Class<?> cls, Class<?> inf) {
	clazz = cls;
	intf = inf;
	interfaceName = inf.getName();
	className = cls.getName();
	classloader = cls.getClassLoader();
	}
	public Extension(Class<?> cls) {
	clazz = cls;
	className = cls.getName();
	classloader = cls.getClassLoader();
	}
	public Extension(ClassLoader loader) {
	classloader = loader;
	}

	public Extension(Extension ext) {
	className = ext.className;
	interfaceName = ext.interfaceName;
	deferred = ext.deferred;
	namespaces = ext.namespaces;
	obj = ext.obj;
	clazz = ext.clazz;
	intf = ext.intf;
	classloader = ext.classloader;
	args = ext.args;
	optional = ext.optional;
	}

	public void setOptional(boolean b) {
	optional = b;
	}
	public boolean isOptional() {
	return optional;
	}

	public String getName() {
	return StringUtils.isEmpty(interfaceName) ? className : interfaceName;
	}
	public Object getLoadedObject() {
	return obj;
	}

	public Extension cloneNoObject() {
	Extension ext = new Extension(this);
	ext.obj = null;
	ext.clazz = null;
	ext.intf = null;
	return ext;
	}

	public String toString() {
	StringBuilder buf = new StringBuilder(128);
	buf.append("class: ");
	buf.append(className);
	buf.append(", interface: ");
	buf.append(interfaceName);
	buf.append(", deferred: ");
	buf.append(deferred ? "true" : "false");
	buf.append(", namespaces: (");
	int n = 0;
	for (String ns : namespaces) {
	if (n > 0) {
	buf.append(", ");
	}
	buf.append(ns);
	n++;
	}
	buf.append(')');
	return buf.toString();
	}

	public String getClassname() {
	return className;
	}

	public void setClassname(String i) {
	clazz = null;
	notFound = false;
	className = i;
	}

	public String getInterfaceName() {
	return interfaceName;
	}

	public void setInterfaceName(String i) {
	interfaceName = i;
	notFound = false;
	}

	public boolean isDeferred() {
	return deferred;
	}

	public void setDeferred(boolean d) {
	deferred = d;
	}

	public Collection<String> getNamespaces() {
	return namespaces;
	}

	public void setArgs(Object[] a) {
	args = a;
	}

	protected Class<?> tryClass(String name, ClassLoader cl) {
	Throwable origEx = null;
	if (classloader != null) {
	try {
	return classloader.loadClass(name);
	} catch (Throwable nex) {
	//ignore, fall into the stuff below
	//save the exception though as this is likely the important one
	origEx = nex;
	}
	}
	try {
	return cl.loadClass(name);
	} catch (Throwable ex) {
	try {
	// using the extension classloader as a fallback
	return this.getClass().getClassLoader().loadClass(name);
	} catch (Throwable nex) {
	notFound = true;
	if (!optional) {
	throw new ExtensionException(new Message("PROBLEM_LOADING_EXTENSION_CLASS", LOG, name),
	origEx != null ? origEx : ex);
	}
	}
	}
	return null;
	}

	public Class<?> getClassObject(ClassLoader cl) {
	if (notFound) {
	return null;
	}
	if (clazz != null) {
	return clazz;
	}
	synchronized (this) {
	if (clazz == null) {
	clazz = tryClass(className, cl);
	}
	}
	return clazz;
	}
	public Object load(ClassLoader cl, Bus b) {
	if (obj != null) {
	return obj;
	}
	Class<?> cls = getClassObject(cl);
	try {
	if (notFound) {
	return null;
	}
	try {
	//if there is a Bus constructor, use it.
	if (b != null && args == null) {
	Constructor<?> con = cls.getConstructor(Bus.class);
	obj = con.newInstance(b);
	return obj;
	} else if (b != null && args != null) {
	try {
	obj = cls.getConstructor(Bus.class, Object[].class).newInstance(b, args);
	} catch (NoSuchMethodException ex) { // no bus
	obj = cls.getConstructor(Object[].class).newInstance(args);
	}
	return obj;
	} else if (args != null) {
	Constructor<?> con = cls.getConstructor(Object[].class);
	obj = con.newInstance(args);
	return obj;
	}
	} catch (InvocationTargetException ex) {
	throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()),
	ex.getCause());
	} catch (InstantiationException \| SecurityException ex) {
	throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()), ex);
	} catch (NoSuchMethodException e) {
	//ignore
	}
	obj = cls.getConstructor().newInstance();
	} catch (ExtensionException ex) {
	notFound = true;
	if (!optional) {
	throw ex;
	}
	LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
	} catch (InvocationTargetException ex) {
	notFound = true;
	if (!optional) {
	throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()),
	ex.getCause());
	}
	LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
	} catch (NoSuchMethodException ex) {
	notFound = true;
	List<Object> a = new ArrayList<>();
	if (b != null) {
	a.add(b);
	}
	if (args != null) {
	a.add(args);
	}
	if (!optional) {
	throw new ExtensionException(new Message("PROBLEM_FINDING_CONSTRUCTOR", LOG,
	cls.getName(), a), ex);
	}
	LOG.log(Level.FINE, "Could not load optional extension " + getName(), ex);
	} catch (Throwable e) {
	notFound = true;
	if (!optional) {
	throw new ExtensionException(new Message(PROBLEM_CREATING_EXTENSION_CLASS, LOG, cls.getName()), e);
	}
	LOG.log(Level.FINE, "Could not load optional extension " + getName(), e);
	}
	return obj;
	}

	public Class<?> loadInterface(ClassLoader cl) {
	if (intf != null \|\| notFound) {
	return intf;
	}
	synchronized (this) {
	if (intf == null) {
	intf = tryClass(interfaceName, cl);
	}
	}
	return intf;
	}


	}