You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tomee.apache.org by jg...@apache.org on 2020/06/19 08:54:17 UTC
[tomee] branch master updated (ec8ed11 -> 6b6f337)
This is an automated email from the ASF dual-hosted git repository.
jgallimore pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/tomee.git.
from ec8ed11 Revert "Prepare for release"
new dd2d69e Exclude the Jakarta module from this build
new 6b6f337 Moved to new repo
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
jakarta/pom.xml | 336 ---
jakarta/src/main/assembly/tomee-microprofile.xml | 38 -
jakarta/src/main/assembly/tomee-plume.xml | 38 -
jakarta/src/main/assembly/tomee-plus.xml | 38 -
jakarta/src/main/assembly/tomee-webprofile.xml | 38 -
.../catalina/loader/WebappClassLoaderBase.java | 2725 --------------------
.../apache/cxf/jaxb/JAXBContextInitializer.java | 611 -----
.../openjpa/enhance/PCClassFileTransformer.java | 254 --
.../openjpa/lib/meta/ClassMetaDataIterator.java | 203 --
.../openjpa/lib/util/TemporaryClassLoader.java | 123 -
.../openjpa/meta/AbstractMetaDataDefaults.java | 422 ---
.../MbeansDescriptorsIntrospectionSource.java | 392 ---
.../webbeans/proxy/AbstractProxyFactory.java | 737 ------
.../jpa/deployment/JavaSECMPInitializer.java | 372 ---
.../accessors/objects/MetadataAsmFactory.java | 712 -----
.../metadata/accessors/objects/MetadataClass.java | 628 -----
.../eclipse/persistence/jaxb/javamodel/Helper.java | 478 ----
.../jaxb/javamodel/reflection/JavaClassImpl.java | 576 -----
.../persistence/jaxb/rs/MOXyJsonProvider.java | 986 -------
.../persistence/jpa/rs/PersistenceFactoryBase.java | 266 --
.../org/quartz/core/QuartzSchedulerMBeanImpl.java | 1011 --------
pom.xml | 1 -
22 files changed, 10985 deletions(-)
delete mode 100644 jakarta/pom.xml
delete mode 100644 jakarta/src/main/assembly/tomee-microprofile.xml
delete mode 100644 jakarta/src/main/assembly/tomee-plume.xml
delete mode 100644 jakarta/src/main/assembly/tomee-plus.xml
delete mode 100644 jakarta/src/main/assembly/tomee-webprofile.xml
delete mode 100644 jakarta/src/patch/java/org/apache/catalina/loader/WebappClassLoaderBase.java
delete mode 100644 jakarta/src/patch/java/org/apache/cxf/jaxb/JAXBContextInitializer.java
delete mode 100644 jakarta/src/patch/java/org/apache/openjpa/enhance/PCClassFileTransformer.java
delete mode 100644 jakarta/src/patch/java/org/apache/openjpa/lib/meta/ClassMetaDataIterator.java
delete mode 100644 jakarta/src/patch/java/org/apache/openjpa/lib/util/TemporaryClassLoader.java
delete mode 100644 jakarta/src/patch/java/org/apache/openjpa/meta/AbstractMetaDataDefaults.java
delete mode 100644 jakarta/src/patch/java/org/apache/tomcat/util/modeler/modules/MbeansDescriptorsIntrospectionSource.java
delete mode 100644 jakarta/src/patch/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/deployment/JavaSECMPInitializer.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataClass.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/Helper.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/reflection/JavaClassImpl.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java
delete mode 100644 jakarta/src/patch/java/org/eclipse/persistence/jpa/rs/PersistenceFactoryBase.java
delete mode 100644 jakarta/src/patch/java/org/quartz/core/QuartzSchedulerMBeanImpl.java
[tomee] 02/02: Moved to new repo
Posted by jg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jgallimore pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tomee.git
commit 6b6f337bf90e661f2fe2c62d4fe5e18409c8a83f
Author: Jonathan Gallimore <jo...@jrg.me.uk>
AuthorDate: Fri Jun 19 09:53:48 2020 +0100
Moved to new repo
---
jakarta/pom.xml | 336 ---
jakarta/src/main/assembly/tomee-microprofile.xml | 38 -
jakarta/src/main/assembly/tomee-plume.xml | 38 -
jakarta/src/main/assembly/tomee-plus.xml | 38 -
jakarta/src/main/assembly/tomee-webprofile.xml | 38 -
.../catalina/loader/WebappClassLoaderBase.java | 2725 --------------------
.../apache/cxf/jaxb/JAXBContextInitializer.java | 611 -----
.../openjpa/enhance/PCClassFileTransformer.java | 254 --
.../openjpa/lib/meta/ClassMetaDataIterator.java | 203 --
.../openjpa/lib/util/TemporaryClassLoader.java | 123 -
.../openjpa/meta/AbstractMetaDataDefaults.java | 422 ---
.../MbeansDescriptorsIntrospectionSource.java | 392 ---
.../webbeans/proxy/AbstractProxyFactory.java | 737 ------
.../jpa/deployment/JavaSECMPInitializer.java | 372 ---
.../accessors/objects/MetadataAsmFactory.java | 712 -----
.../metadata/accessors/objects/MetadataClass.java | 628 -----
.../eclipse/persistence/jaxb/javamodel/Helper.java | 478 ----
.../jaxb/javamodel/reflection/JavaClassImpl.java | 576 -----
.../persistence/jaxb/rs/MOXyJsonProvider.java | 986 -------
.../persistence/jpa/rs/PersistenceFactoryBase.java | 266 --
.../org/quartz/core/QuartzSchedulerMBeanImpl.java | 1011 --------
21 files changed, 10984 deletions(-)
diff --git a/jakarta/pom.xml b/jakarta/pom.xml
deleted file mode 100644
index 8f81e60..0000000
--- a/jakarta/pom.xml
+++ /dev/null
@@ -1,336 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- 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.
--->
-
-<!-- $Rev: 600338 $ $Date: 2007-12-02 09:08:04 -0800 (Sun, 02 Dec 2007) $ -->
-
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-
- <parent>
- <artifactId>tomee-project</artifactId>
- <groupId>org.apache.tomee</groupId>
- <version>8.0.3-SNAPSHOT</version>
- </parent>
-
- <modelVersion>4.0.0</modelVersion>
- <artifactId>apache-tomee</artifactId>
- <version>9.0.0-M1-SNAPSHOT</version>
- <packaging>jar</packaging>
- <name>TomEE :: TomEE :: Apache TomEE 9</name>
-
- <properties>
- <tomee.version>8.0.3-SNAPSHOT</tomee.version>
- <tomee.build.name>${project.groupId}.tomee.tomee</tomee.build.name>
- <webprofile.work-dir>${project.build.directory}/webprofile-work-dir</webprofile.work-dir>
- <plus.work-dir>${project.build.directory}/plus-work-dir</plus.work-dir>
- <plume.work-dir>${project.build.directory}/plume-work-dir</plume.work-dir>
- <microprofile.work-dir>${project.build.directory}/microprofile-work-dir</microprofile.work-dir>
- </properties>
-
- <dependencies>
- <dependency> <!-- to be sure to have it -->
- <groupId>${project.groupId}</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>webprofile</classifier>
- <type>zip</type>
- <scope>provided</scope>
- <exclusions>
- <exclusion>
- <groupId>*</groupId>
- <artifactId>*</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency> <!-- to be sure to have it -->
- <groupId>${project.groupId}</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>microprofile</classifier>
- <type>zip</type>
- <scope>provided</scope>
- <exclusions>
- <exclusion>
- <groupId>*</groupId>
- <artifactId>*</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency> <!-- to be sure to have it -->
- <groupId>${project.groupId}</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>plume</classifier>
- <type>zip</type>
- <scope>provided</scope>
- <exclusions>
- <exclusion>
- <groupId>*</groupId>
- <artifactId>*</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency> <!-- to be sure to have it -->
- <groupId>${project.groupId}</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>plus</classifier>
- <type>zip</type>
- <scope>provided</scope>
- <exclusions>
- <exclusion>
- <groupId>*</groupId>
- <artifactId>*</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- </dependencies>
-
- <build>
- <resources>
- <resource>
- <directory>src/main/resources</directory>
- <filtering>true</filtering>
- </resource>
- <resource>
- <directory>src/main/resources</directory>
- <filtering>false</filtering>
- </resource>
- </resources>
-
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-dependency-plugin</artifactId>
- <executions>
- <execution>
- <id>unpack-webprofile</id>
- <phase>process-resources</phase>
- <goals>
- <goal>unpack</goal>
- </goals>
- <configuration>
- <artifactItems>
- <artifactItem>
- <groupId>org.apache.tomee</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>webprofile</classifier>
- <type>zip</type>
- <outputDirectory>${webprofile.work-dir}</outputDirectory>
- </artifactItem>
- </artifactItems>
- </configuration>
- </execution>
- <execution>
- <id>unpack-microprofile</id>
- <phase>process-resources</phase>
- <goals>
- <goal>unpack</goal>
- </goals>
- <configuration>
- <artifactItems>
- <artifactItem>
- <groupId>org.apache.tomee</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>microprofile</classifier>
- <type>zip</type>
- <outputDirectory>${microprofile.work-dir}</outputDirectory>
- </artifactItem>
- </artifactItems>
- </configuration>
- </execution>
- <execution>
- <id>unpack-plume</id>
- <phase>process-resources</phase>
- <goals>
- <goal>unpack</goal>
- </goals>
- <configuration>
- <artifactItems>
- <artifactItem>
- <groupId>org.apache.tomee</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>plume</classifier>
- <type>zip</type>
- <outputDirectory>${plume.work-dir}</outputDirectory>
- </artifactItem>
- </artifactItems>
- </configuration>
- </execution>
- <execution>
- <id>unpack-plus</id>
- <phase>process-resources</phase>
- <goals>
- <goal>unpack</goal>
- </goals>
- <configuration>
- <artifactItems>
- <artifactItem>
- <groupId>org.apache.tomee</groupId>
- <artifactId>apache-tomee</artifactId>
- <version>${tomee.version}</version>
- <classifier>plus</classifier>
- <type>zip</type>
- <outputDirectory>${plus.work-dir}</outputDirectory>
- </artifactItem>
- </artifactItems>
- </configuration>
- </execution>
- </executions>
- </plugin>
-
-
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-assembly-plugin</artifactId>
- <executions>
- <execution>
- <id>webprofile</id>
- <phase>package</phase>
- <configuration>
- <descriptors>
- <descriptor>src/main/assembly/tomee-webprofile.xml</descriptor>
- </descriptors>
- <attach>false</attach>
- <appendAssemblyId>false</appendAssemblyId>
- <finalName>apache-tomee-webprofile-${project.version}</finalName>
- </configuration>
- <goals>
- <goal>single</goal>
- </goals>
- </execution>
- <execution>
- <id>plus</id>
- <phase>package</phase>
- <configuration>
- <descriptors>
- <descriptor>src/main/assembly/tomee-plus.xml</descriptor>
- </descriptors>
- <attach>false</attach>
- <appendAssemblyId>false</appendAssemblyId>
- <finalName>apache-tomee-plus-${project.version}</finalName>
- </configuration>
- <goals>
- <goal>single</goal>
- </goals>
- </execution>
- <execution>
- <id>plume</id>
- <phase>package</phase>
- <configuration>
- <descriptors>
- <descriptor>src/main/assembly/tomee-plume.xml</descriptor>
- </descriptors>
- <attach>false</attach>
- <appendAssemblyId>false</appendAssemblyId>
- <finalName>apache-tomee-plume-${project.version}</finalName>
- </configuration>
- <goals>
- <goal>single</goal>
- </goals>
- </execution>
- <execution>
- <id>microprofile</id>
- <phase>package</phase>
- <configuration>
- <descriptors>
- <descriptor>src/main/assembly/tomee-microprofile.xml</descriptor>
- </descriptors>
- <attach>false</attach>
- <appendAssemblyId>false</appendAssemblyId>
- <finalName>apache-tomee-microprofile-${project.version}</finalName>
- </configuration>
- <goals>
- <goal>single</goal>
- </goals>
- </execution>
- </executions>
- </plugin>
-
- <plugin>
- <groupId>org.codehaus.mojo</groupId>
- <artifactId>build-helper-maven-plugin</artifactId>
- <executions>
- <execution>
- <id>attach-artifacts</id>
- <phase>package</phase>
- <goals>
- <goal>attach-artifact</goal>
- </goals>
- <configuration>
- <artifacts>
- <artifact>
- <file>${project.build.directory}/apache-tomee-webprofile-${project.version}.zip</file>
- <type>zip</type>
- <classifier>webprofile</classifier>
- </artifact>
- <artifact>
- <file>${project.build.directory}/apache-tomee-plus-${project.version}.zip</file>
- <type>zip</type>
- <classifier>plus</classifier>
- </artifact>
- <artifact>
- <file>${project.build.directory}/apache-tomee-plume-${project.version}.zip</file>
- <type>zip</type>
- <classifier>plume</classifier>
- </artifact>
- <artifact>
- <file>${project.build.directory}/apache-tomee-microprofile-${project.version}.zip</file>
- <type>zip</type>
- <classifier>microprofile</classifier>
- </artifact>
- </artifacts>
- </configuration>
- </execution>
- </executions>
- </plugin>
- <plugin>
- <groupId>org.tomitribe.transformer</groupId>
- <artifactId>org.eclipse.transformer.maven</artifactId>
- <version>0.1.1a</version>
- <executions>
- <execution>
- <goals>
- <goal>run</goal>
- </goals>
- <phase>package</phase>
- </execution>
- </executions>
- </plugin>
- <plugin>
- <groupId>org.apache.tomee.patch</groupId>
- <artifactId>tomee-patch-plugin</artifactId>
- <version>0.1-SNAPSHOT</version>
- <configuration>
- <select>apache-tomee.*\.zip</select>
- </configuration>
- <executions>
- <execution>
- <goals>
- <goal>run</goal>
- </goals>
- <phase>package</phase>
- </execution>
- </executions>
- </plugin>
- </plugins>
- </build>
-
-</project>
diff --git a/jakarta/src/main/assembly/tomee-microprofile.xml b/jakarta/src/main/assembly/tomee-microprofile.xml
deleted file mode 100644
index 6a1e49b..0000000
--- a/jakarta/src/main/assembly/tomee-microprofile.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
- 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.
--->
-
-<!-- $Rev: 576067 $ $Date: 2007-09-16 03:17:08 -0700 (Sun, 16 Sep 2007) $ -->
-
-<assembly>
- <id>tomee-microprofile</id>
- <formats>
- <format>zip</format>
- </formats>
- <includeBaseDirectory>false</includeBaseDirectory>
- <fileSets>
- <fileSet>
- <directory>${microprofile.work-dir}/apache-tomee-microprofile-${tomee.version}</directory>
- <outputDirectory>/apache-tomee-microprofile-${project.version}</outputDirectory>
- <includes>
- <include>**/*</include>
- </includes>
- </fileSet>
- </fileSets>
-</assembly>
-
diff --git a/jakarta/src/main/assembly/tomee-plume.xml b/jakarta/src/main/assembly/tomee-plume.xml
deleted file mode 100644
index bb71e05..0000000
--- a/jakarta/src/main/assembly/tomee-plume.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
- 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.
--->
-
-<!-- $Rev: 576067 $ $Date: 2007-09-16 03:17:08 -0700 (Sun, 16 Sep 2007) $ -->
-
-<assembly>
- <id>tomee-plume</id>
- <formats>
- <format>zip</format>
- </formats>
- <includeBaseDirectory>false</includeBaseDirectory>
- <fileSets>
- <fileSet>
- <directory>${plume.work-dir}/apache-tomee-plume-${tomee.version}</directory>
- <outputDirectory>/apache-tomee-plume-${project.version}</outputDirectory>
- <includes>
- <include>**/*</include>
- </includes>
- </fileSet>
- </fileSets>
-</assembly>
-
diff --git a/jakarta/src/main/assembly/tomee-plus.xml b/jakarta/src/main/assembly/tomee-plus.xml
deleted file mode 100644
index e0c5708..0000000
--- a/jakarta/src/main/assembly/tomee-plus.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
- 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.
--->
-
-<!-- $Rev: 576067 $ $Date: 2007-09-16 03:17:08 -0700 (Sun, 16 Sep 2007) $ -->
-
-<assembly>
- <id>tomee-plus</id>
- <formats>
- <format>zip</format>
- </formats>
- <includeBaseDirectory>false</includeBaseDirectory>
- <fileSets>
- <fileSet>
- <directory>${plus.work-dir}/apache-tomee-plus-${tomee.version}</directory>
- <outputDirectory>/apache-tomee-plus-${project.version}</outputDirectory>
- <includes>
- <include>**/*</include>
- </includes>
- </fileSet>
- </fileSets>
-</assembly>
-
diff --git a/jakarta/src/main/assembly/tomee-webprofile.xml b/jakarta/src/main/assembly/tomee-webprofile.xml
deleted file mode 100644
index 1777653..0000000
--- a/jakarta/src/main/assembly/tomee-webprofile.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-
- 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.
--->
-
-<!-- $Rev: 576067 $ $Date: 2007-09-16 03:17:08 -0700 (Sun, 16 Sep 2007) $ -->
-
-<assembly>
- <id>tomee-webprofile</id>
- <formats>
- <format>zip</format>
- </formats>
- <includeBaseDirectory>false</includeBaseDirectory>
- <fileSets>
- <fileSet>
- <directory>${webprofile.work-dir}/apache-tomee-webprofile-${tomee.version}</directory>
- <outputDirectory>/apache-tomee-webprofile-${project.version}</outputDirectory>
- <includes>
- <include>**/*</include>
- </includes>
- </fileSet>
- </fileSets>
-</assembly>
-
diff --git a/jakarta/src/patch/java/org/apache/catalina/loader/WebappClassLoaderBase.java b/jakarta/src/patch/java/org/apache/catalina/loader/WebappClassLoaderBase.java
deleted file mode 100644
index 2e75d4c..0000000
--- a/jakarta/src/patch/java/org/apache/catalina/loader/WebappClassLoaderBase.java
+++ /dev/null
@@ -1,2725 +0,0 @@
-/*
- * 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.loader;
-
-import java.io.File;
-import java.io.FilePermission;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.instrument.ClassFileTransformer;
-import java.lang.instrument.IllegalClassFormatException;
-import java.lang.ref.Reference;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.security.AccessControlException;
-import java.security.AccessController;
-import java.security.CodeSource;
-import java.security.Permission;
-import java.security.PermissionCollection;
-import java.security.Policy;
-import java.security.PrivilegedAction;
-import java.security.ProtectionDomain;
-import java.security.cert.Certificate;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.ConcurrentModificationException;
-import java.util.Date;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.NoSuchElementException;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.jar.Attributes;
-import java.util.jar.Attributes.Name;
-import java.util.jar.Manifest;
-
-import org.apache.catalina.Container;
-import org.apache.catalina.Globals;
-import org.apache.catalina.Lifecycle;
-import org.apache.catalina.LifecycleException;
-import org.apache.catalina.LifecycleListener;
-import org.apache.catalina.LifecycleState;
-import org.apache.catalina.WebResource;
-import org.apache.catalina.WebResourceRoot;
-import org.apache.catalina.webresources.TomcatURLStreamHandlerFactory;
-import org.apache.juli.WebappProperties;
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.InstrumentableClassLoader;
-import org.apache.tomcat.util.ExceptionUtils;
-import org.apache.tomcat.util.IntrospectionUtils;
-import org.apache.tomcat.util.compat.JreCompat;
-import org.apache.tomcat.util.res.StringManager;
-import org.apache.tomcat.util.security.PermissionCheck;
-
-/**
- * Specialized web application class loader.
- * <p>
- * This class loader is a full reimplementation of the
- * <code>URLClassLoader</code> from the JDK. It is designed to be fully
- * compatible with a normal <code>URLClassLoader</code>, although its internal
- * behavior may be completely different.
- * <p>
- * <strong>IMPLEMENTATION NOTE</strong> - By default, this class loader follows
- * the delegation model required by the specification. The system class
- * loader will be queried first, then the local repositories, and only then
- * delegation to the parent class loader will occur. This allows the web
- * application to override any shared class except the classes from J2SE.
- * Special handling is provided from the JAXP XML parser interfaces, the JNDI
- * interfaces, and the classes from the servlet API, which are never loaded
- * from the webapp repositories. The <code>delegate</code> property
- * allows an application to modify this behavior to move the parent class loader
- * ahead of the local repositories.
- * <p>
- * <strong>IMPLEMENTATION NOTE</strong> - Due to limitations in Jasper
- * compilation technology, any repository which contains classes from
- * the servlet API will be ignored by the class loader.
- * <p>
- * <strong>IMPLEMENTATION NOTE</strong> - The class loader generates source
- * URLs which include the full JAR URL when a class is loaded from a JAR file,
- * which allows setting security permission at the class level, even when a
- * class is contained inside a JAR.
- * <p>
- * <strong>IMPLEMENTATION NOTE</strong> - Local repositories are searched in
- * the order they are added via the initial constructor.
- * <p>
- * <strong>IMPLEMENTATION NOTE</strong> - No check for sealing violations or
- * security is made unless a security manager is present.
- * <p>
- * <strong>IMPLEMENTATION NOTE</strong> - As of 8.0, this class
- * loader implements {@link InstrumentableClassLoader}, permitting web
- * application classes to instrument other classes in the same web
- * application. It does not permit instrumentation of system or container
- * classes or classes in other web apps.
- *
- * @author Remy Maucherat
- * @author Craig R. McClanahan
- */
-public abstract class WebappClassLoaderBase extends URLClassLoader
- implements Lifecycle, InstrumentableClassLoader, WebappProperties, PermissionCheck {
-
- private static final Log log = LogFactory.getLog(WebappClassLoaderBase.class);
-
- /**
- * List of ThreadGroup names to ignore when scanning for web application
- * started threads that need to be shut down.
- */
- private static final List<String> JVM_THREAD_GROUP_NAMES = new ArrayList<>();
-
- private static final String JVM_THREAD_GROUP_SYSTEM = "system";
-
- private static final String CLASS_FILE_SUFFIX = ".class";
-
- static {
- if (!JreCompat.isGraalAvailable()) {
- ClassLoader.registerAsParallelCapable();
- }
- JVM_THREAD_GROUP_NAMES.add(JVM_THREAD_GROUP_SYSTEM);
- JVM_THREAD_GROUP_NAMES.add("RMI Runtime");
- }
-
- protected class PrivilegedFindClassByName implements PrivilegedAction<Class<?>> {
-
- private final String name;
-
- PrivilegedFindClassByName(String name) {
- this.name = name;
- }
-
- @Override
- public Class<?> run() {
- return findClassInternal(name);
- }
- }
-
-
- protected static final class PrivilegedGetClassLoader implements PrivilegedAction<ClassLoader> {
-
- private final Class<?> clazz;
-
- public PrivilegedGetClassLoader(Class<?> clazz){
- this.clazz = clazz;
- }
-
- @Override
- public ClassLoader run() {
- return clazz.getClassLoader();
- }
- }
-
-
- protected final class PrivilegedJavaseGetResource implements PrivilegedAction<URL> {
-
- private final String name;
-
- public PrivilegedJavaseGetResource(String name) {
- this.name = name;
- }
-
- @Override
- public URL run() {
- return javaseClassLoader.getResource(name);
- }
- }
-
-
- // ------------------------------------------------------- Static Variables
-
- /**
- * The string manager for this package.
- */
- protected static final StringManager sm =
- StringManager.getManager(Constants.Package);
-
-
- // ----------------------------------------------------------- Constructors
-
- /**
- * Construct a new ClassLoader with no defined repositories and no
- * parent ClassLoader.
- */
- protected WebappClassLoaderBase() {
-
- super(new URL[0]);
-
- ClassLoader p = getParent();
- if (p == null) {
- p = getSystemClassLoader();
- }
- this.parent = p;
-
- ClassLoader j = String.class.getClassLoader();
- if (j == null) {
- j = getSystemClassLoader();
- while (j.getParent() != null) {
- j = j.getParent();
- }
- }
- this.javaseClassLoader = j;
-
- securityManager = System.getSecurityManager();
- if (securityManager != null) {
- refreshPolicy();
- }
- }
-
-
- /**
- * Construct a new ClassLoader with no defined repositories and the given
- * parent ClassLoader.
- * <p>
- * Method is used via reflection -
- * see {@link WebappLoader#createClassLoader()}
- *
- * @param parent Our parent class loader
- */
- protected WebappClassLoaderBase(ClassLoader parent) {
-
- super(new URL[0], parent);
-
- ClassLoader p = getParent();
- if (p == null) {
- p = getSystemClassLoader();
- }
- this.parent = p;
-
- ClassLoader j = String.class.getClassLoader();
- if (j == null) {
- j = getSystemClassLoader();
- while (j.getParent() != null) {
- j = j.getParent();
- }
- }
- this.javaseClassLoader = j;
-
- securityManager = System.getSecurityManager();
- if (securityManager != null) {
- refreshPolicy();
- }
- }
-
-
- // ----------------------------------------------------- Instance Variables
-
- /**
- * Associated web resources for this webapp.
- */
- protected WebResourceRoot resources = null;
-
-
- /**
- * The cache of ResourceEntry for classes and resources we have loaded,
- * keyed by resource path, not binary name. Path is used as the key since
- * resources may be requested by binary name (classes) or path (other
- * resources such as property files) and the mapping from binary name to
- * path is unambiguous but the reverse mapping is ambiguous.
- */
- protected final Map<String, ResourceEntry> resourceEntries =
- new ConcurrentHashMap<>();
-
-
- /**
- * Should this class loader delegate to the parent class loader
- * <strong>before</strong> searching its own repositories (i.e. the
- * usual Java2 delegation model)? If set to <code>false</code>,
- * this class loader will search its own repositories first, and
- * delegate to the parent only if the class or resource is not
- * found locally. Note that the default, <code>false</code>, is
- * the behavior called for by the servlet specification.
- */
- protected boolean delegate = false;
-
-
- private final Map<String,Long> jarModificationTimes = new HashMap<>();
-
-
- /**
- * A list of read File Permission's required if this loader is for a web
- * application context.
- */
- protected final ArrayList<Permission> permissionList = new ArrayList<>();
-
-
- /**
- * The PermissionCollection for each CodeSource for a web
- * application context.
- */
- protected final HashMap<String, PermissionCollection> loaderPC = new HashMap<>();
-
-
- /**
- * Instance of the SecurityManager installed.
- */
- protected final SecurityManager securityManager;
-
-
- /**
- * The parent class loader.
- */
- protected final ClassLoader parent;
-
-
- /**
- * The bootstrap class loader used to load the JavaSE classes. In some
- * implementations this class loader is always <code>null</code> and in
- * those cases {@link ClassLoader#getParent()} will be called recursively on
- * the system class loader and the last non-null result used.
- */
- private ClassLoader javaseClassLoader;
-
-
- /**
- * Enables the RMI Target memory leak detection to be controlled. This is
- * necessary since the detection can only work on Java 9 if some of the
- * modularity checks are disabled.
- */
- private boolean clearReferencesRmiTargets = true;
-
- /**
- * Should Tomcat attempt to terminate threads that have been started by the
- * web application? Stopping threads is performed via the deprecated (for
- * good reason) <code>Thread.stop()</code> method and is likely to result in
- * instability. As such, enabling this should be viewed as an option of last
- * resort in a development environment and is not recommended in a
- * production environment. If not specified, the default value of
- * <code>false</code> will be used.
- */
- private boolean clearReferencesStopThreads = false;
-
- /**
- * Should Tomcat attempt to terminate any {@link java.util.TimerThread}s
- * that have been started by the web application? If not specified, the
- * default value of <code>false</code> will be used.
- */
- private boolean clearReferencesStopTimerThreads = false;
-
- /**
- * Should Tomcat call
- * {@link org.apache.juli.logging.LogFactory#release(ClassLoader)}
- * when the class loader is stopped? If not specified, the default value
- * of <code>true</code> is used. Changing the default setting is likely to
- * lead to memory leaks and other issues.
- */
- private boolean clearReferencesLogFactoryRelease = true;
-
- /**
- * If an HttpClient keep-alive timer thread has been started by this web
- * application and is still running, should Tomcat change the context class
- * loader from the current {@link ClassLoader} to
- * {@link ClassLoader#getParent()} to prevent a memory leak? Note that the
- * keep-alive timer thread will stop on its own once the keep-alives all
- * expire however, on a busy system that might not happen for some time.
- */
- private boolean clearReferencesHttpClientKeepAliveThread = true;
-
- /**
- * Should Tomcat attempt to clear references to classes loaded by this class
- * loader from the ObjectStreamClass caches?
- */
- private boolean clearReferencesObjectStreamClassCaches = true;
-
- /**
- * Should Tomcat attempt to clear references to classes loaded by this class
- * loader from ThreadLocals?
- */
- private boolean clearReferencesThreadLocals = true;
-
- /**
- * Should Tomcat skip the memory leak checks when the web application is
- * stopped as part of the process of shutting down the JVM?
- */
- private boolean skipMemoryLeakChecksOnJvmShutdown = false;
-
- /**
- * Holds the class file transformers decorating this class loader. The
- * CopyOnWriteArrayList is thread safe. It is expensive on writes, but
- * those should be rare. It is very fast on reads, since synchronization
- * is not actually used. Importantly, the ClassLoader will never block
- * iterating over the transformers while loading a class.
- */
- private final List<ClassFileTransformer> transformers = new CopyOnWriteArrayList<>();
-
-
- /**
- * Flag that indicates that {@link #addURL(URL)} has been called which
- * creates a requirement to check the super class when searching for
- * resources.
- */
- private boolean hasExternalRepositories = false;
-
-
- /**
- * Repositories managed by this class rather than the super class.
- */
- private List<URL> localRepositories = new ArrayList<>();
-
-
- private volatile LifecycleState state = LifecycleState.NEW;
-
-
- // ------------------------------------------------------------- Properties
-
- /**
- * @return associated resources.
- */
- public WebResourceRoot getResources() {
- return this.resources;
- }
-
-
- /**
- * Set associated resources.
- * @param resources the resources from which the classloader will
- * load the classes
- */
- public void setResources(WebResourceRoot resources) {
- this.resources = resources;
- }
-
-
- /**
- * @return the context name for this class loader.
- */
- public String getContextName() {
- if (resources == null) {
- return "Unknown";
- } else {
- return resources.getContext().getBaseName();
- }
- }
-
-
- /**
- * Return the "delegate first" flag for this class loader.
- * @return <code>true</code> if the class lookup will delegate to
- * the parent first. The default in Tomcat is <code>false</code>.
- */
- public boolean getDelegate() {
- return this.delegate;
- }
-
-
- /**
- * Set the "delegate first" flag for this class loader.
- * If this flag is true, this class loader delegates
- * to the parent class loader
- * <strong>before</strong> searching its own repositories, as
- * in an ordinary (non-servlet) chain of Java class loaders.
- * If set to <code>false</code> (the default),
- * this class loader will search its own repositories first, and
- * delegate to the parent only if the class or resource is not
- * found locally, as per the servlet specification.
- *
- * @param delegate The new "delegate first" flag
- */
- public void setDelegate(boolean delegate) {
- this.delegate = delegate;
- }
-
-
- /**
- * If there is a Java SecurityManager create a read permission for the
- * target of the given URL as appropriate.
- *
- * @param url URL for a file or directory on local system
- */
- void addPermission(URL url) {
- if (url == null) {
- return;
- }
- if (securityManager != null) {
- String protocol = url.getProtocol();
- if ("file".equalsIgnoreCase(protocol)) {
- URI uri;
- File f;
- String path;
- try {
- uri = url.toURI();
- f = new File(uri);
- path = f.getCanonicalPath();
- } catch (IOException | URISyntaxException e) {
- log.warn(sm.getString(
- "webappClassLoader.addPermisionNoCanonicalFile",
- url.toExternalForm()));
- return;
- }
- if (f.isFile()) {
- // Allow the file to be read
- addPermission(new FilePermission(path, "read"));
- } else if (f.isDirectory()) {
- addPermission(new FilePermission(path, "read"));
- addPermission(new FilePermission(
- path + File.separator + "-", "read"));
- } else {
- // File does not exist - ignore (shouldn't happen)
- }
- } else {
- // Unsupported URL protocol
- log.warn(sm.getString(
- "webappClassLoader.addPermisionNoProtocol",
- protocol, url.toExternalForm()));
- }
- }
- }
-
-
- /**
- * If there is a Java SecurityManager create a Permission.
- *
- * @param permission The permission
- */
- void addPermission(Permission permission) {
- if ((securityManager != null) && (permission != null)) {
- permissionList.add(permission);
- }
- }
-
-
- public boolean getClearReferencesRmiTargets() {
- return this.clearReferencesRmiTargets;
- }
-
-
- public void setClearReferencesRmiTargets(boolean clearReferencesRmiTargets) {
- this.clearReferencesRmiTargets = clearReferencesRmiTargets;
- }
-
-
- /**
- * @return the clearReferencesStopThreads flag for this Context.
- */
- public boolean getClearReferencesStopThreads() {
- return this.clearReferencesStopThreads;
- }
-
-
- /**
- * Set the clearReferencesStopThreads feature for this Context.
- *
- * @param clearReferencesStopThreads The new flag value
- */
- public void setClearReferencesStopThreads(
- boolean clearReferencesStopThreads) {
- this.clearReferencesStopThreads = clearReferencesStopThreads;
- }
-
-
- /**
- * @return the clearReferencesStopTimerThreads flag for this Context.
- */
- public boolean getClearReferencesStopTimerThreads() {
- return this.clearReferencesStopTimerThreads;
- }
-
-
- /**
- * Set the clearReferencesStopTimerThreads feature for this Context.
- *
- * @param clearReferencesStopTimerThreads The new flag value
- */
- public void setClearReferencesStopTimerThreads(
- boolean clearReferencesStopTimerThreads) {
- this.clearReferencesStopTimerThreads = clearReferencesStopTimerThreads;
- }
-
-
- /**
- * @return the clearReferencesLogFactoryRelease flag for this Context.
- */
- public boolean getClearReferencesLogFactoryRelease() {
- return this.clearReferencesLogFactoryRelease;
- }
-
-
- /**
- * Set the clearReferencesLogFactoryRelease feature for this Context.
- *
- * @param clearReferencesLogFactoryRelease The new flag value
- */
- public void setClearReferencesLogFactoryRelease(
- boolean clearReferencesLogFactoryRelease) {
- this.clearReferencesLogFactoryRelease =
- clearReferencesLogFactoryRelease;
- }
-
-
- /**
- * @return the clearReferencesHttpClientKeepAliveThread flag for this
- * Context.
- */
- public boolean getClearReferencesHttpClientKeepAliveThread() {
- return this.clearReferencesHttpClientKeepAliveThread;
- }
-
-
- /**
- * Set the clearReferencesHttpClientKeepAliveThread feature for this
- * Context.
- *
- * @param clearReferencesHttpClientKeepAliveThread The new flag value
- */
- public void setClearReferencesHttpClientKeepAliveThread(
- boolean clearReferencesHttpClientKeepAliveThread) {
- this.clearReferencesHttpClientKeepAliveThread =
- clearReferencesHttpClientKeepAliveThread;
- }
-
-
- public boolean getClearReferencesObjectStreamClassCaches() {
- return clearReferencesObjectStreamClassCaches;
- }
-
-
- public void setClearReferencesObjectStreamClassCaches(
- boolean clearReferencesObjectStreamClassCaches) {
- this.clearReferencesObjectStreamClassCaches = clearReferencesObjectStreamClassCaches;
- }
-
-
- public boolean getClearReferencesThreadLocals() {
- return clearReferencesThreadLocals;
- }
-
-
- public void setClearReferencesThreadLocals(boolean clearReferencesThreadLocals) {
- this.clearReferencesThreadLocals = clearReferencesThreadLocals;
- }
-
-
- public boolean getSkipMemoryLeakChecksOnJvmShutdown() {
- return skipMemoryLeakChecksOnJvmShutdown;
- }
-
-
- public void setSkipMemoryLeakChecksOnJvmShutdown(boolean skipMemoryLeakChecksOnJvmShutdown) {
- this.skipMemoryLeakChecksOnJvmShutdown = skipMemoryLeakChecksOnJvmShutdown;
- }
-
-
- // ------------------------------------------------------- Reloader Methods
-
- /**
- * Adds the specified class file transformer to this class loader. The
- * transformer will then be able to modify the bytecode of any classes
- * loaded by this class loader after the invocation of this method.
- *
- * @param transformer The transformer to add to the class loader
- */
- @Override
- public void addTransformer(ClassFileTransformer transformer) {
-
- if (transformer == null) {
- throw new IllegalArgumentException(sm.getString(
- "webappClassLoader.addTransformer.illegalArgument", getContextName()));
- }
-
- if (this.transformers.contains(transformer)) {
- // if the same instance of this transformer was already added, bail out
- log.warn(sm.getString("webappClassLoader.addTransformer.duplicate",
- transformer, getContextName()));
- return;
- }
- this.transformers.add(transformer);
-
- log.info(sm.getString("webappClassLoader.addTransformer", transformer, getContextName()));
- }
-
- /**
- * Removes the specified class file transformer from this class loader.
- * It will no longer be able to modify the byte code of any classes
- * loaded by the class loader after the invocation of this method.
- * However, any classes already modified by this transformer will
- * remain transformed.
- *
- * @param transformer The transformer to remove
- */
- @Override
- public void removeTransformer(ClassFileTransformer transformer) {
-
- if (transformer == null) {
- return;
- }
-
- if (this.transformers.remove(transformer)) {
- log.info(sm.getString("webappClassLoader.removeTransformer",
- transformer, getContextName()));
- }
- }
-
- protected void copyStateWithoutTransformers(WebappClassLoaderBase base) {
- base.resources = this.resources;
- base.delegate = this.delegate;
- base.state = LifecycleState.NEW;
- base.clearReferencesStopThreads = this.clearReferencesStopThreads;
- base.clearReferencesStopTimerThreads = this.clearReferencesStopTimerThreads;
- base.clearReferencesLogFactoryRelease = this.clearReferencesLogFactoryRelease;
- base.clearReferencesHttpClientKeepAliveThread = this.clearReferencesHttpClientKeepAliveThread;
- base.jarModificationTimes.putAll(this.jarModificationTimes);
- base.permissionList.addAll(this.permissionList);
- base.loaderPC.putAll(this.loaderPC);
- }
-
- /**
- * Have one or more classes or resources been modified so that a reload
- * is appropriate?
- * @return <code>true</code> if there's been a modification
- */
- public boolean modified() {
-
- if (log.isDebugEnabled())
- log.debug("modified()");
-
- for (Entry<String,ResourceEntry> entry : resourceEntries.entrySet()) {
- long cachedLastModified = entry.getValue().lastModified;
- long lastModified = resources.getClassLoaderResource(
- entry.getKey()).getLastModified();
- if (lastModified != cachedLastModified) {
- if( log.isDebugEnabled() )
- log.debug(sm.getString("webappClassLoader.resourceModified",
- entry.getKey(),
- new Date(cachedLastModified),
- new Date(lastModified)));
- return true;
- }
- }
-
- // Check if JARs have been added or removed
- WebResource[] jars = resources.listResources("/WEB-INF/lib");
- // Filter out non-JAR resources
-
- int jarCount = 0;
- for (WebResource jar : jars) {
- if (jar.getName().endsWith(".jar") && jar.isFile() && jar.canRead()) {
- jarCount++;
- Long recordedLastModified = jarModificationTimes.get(jar.getName());
- if (recordedLastModified == null) {
- // Jar has been added
- log.info(sm.getString("webappClassLoader.jarsAdded",
- resources.getContext().getName()));
- return true;
- }
- if (recordedLastModified.longValue() != jar.getLastModified()) {
- // Jar has been changed
- log.info(sm.getString("webappClassLoader.jarsModified",
- resources.getContext().getName()));
- return true;
- }
- }
- }
-
- if (jarCount < jarModificationTimes.size()){
- log.info(sm.getString("webappClassLoader.jarsRemoved",
- resources.getContext().getName()));
- return true;
- }
-
-
- // No classes have been modified
- return false;
- }
-
-
- @Override
- public String toString() {
-
- StringBuilder sb = new StringBuilder(this.getClass().getSimpleName());
- sb.append("\r\n context: ");
- sb.append(getContextName());
- sb.append("\r\n delegate: ");
- sb.append(delegate);
- sb.append("\r\n");
- if (this.parent != null) {
- sb.append("----------> Parent Classloader:\r\n");
- sb.append(this.parent.toString());
- sb.append("\r\n");
- }
- if (this.transformers.size() > 0) {
- sb.append("----------> Class file transformers:\r\n");
- for (ClassFileTransformer transformer : this.transformers) {
- sb.append(transformer).append("\r\n");
- }
- }
- return sb.toString();
- }
-
-
- // ---------------------------------------------------- ClassLoader Methods
-
-
- // Note: exposed for use by tests
- protected final Class<?> doDefineClass(String name, byte[] b, int off, int len,
- ProtectionDomain protectionDomain) {
- return super.defineClass(name, b, off, len, protectionDomain);
- }
-
- /**
- * Find the specified class in our local repositories, if possible. If
- * not found, throw <code>ClassNotFoundException</code>.
- *
- * @param name The binary name of the class to be loaded
- *
- * @exception ClassNotFoundException if the class was not found
- */
- @Override
- public Class<?> findClass(String name) throws ClassNotFoundException {
-
- if (log.isDebugEnabled())
- log.debug(" findClass(" + name + ")");
-
- checkStateForClassLoading(name);
-
- // (1) Permission to define this class when using a SecurityManager
- if (securityManager != null) {
- int i = name.lastIndexOf('.');
- if (i >= 0) {
- try {
- if (log.isTraceEnabled())
- log.trace(" securityManager.checkPackageDefinition");
- securityManager.checkPackageDefinition(name.substring(0,i));
- } catch (Exception se) {
- if (log.isTraceEnabled())
- log.trace(" -->Exception-->ClassNotFoundException", se);
- throw new ClassNotFoundException(name, se);
- }
- }
- }
-
- // Ask our superclass to locate this class, if possible
- // (throws ClassNotFoundException if it is not found)
- Class<?> clazz = null;
- try {
- if (log.isTraceEnabled())
- log.trace(" findClassInternal(" + name + ")");
- try {
- if (securityManager != null) {
- PrivilegedAction<Class<?>> dp =
- new PrivilegedFindClassByName(name);
- clazz = AccessController.doPrivileged(dp);
- } else {
- clazz = findClassInternal(name);
- }
- } catch(AccessControlException ace) {
- log.warn(sm.getString("webappClassLoader.securityException", name,
- ace.getMessage()), ace);
- throw new ClassNotFoundException(name, ace);
- } catch (RuntimeException e) {
- if (log.isTraceEnabled())
- log.trace(" -->RuntimeException Rethrown", e);
- throw e;
- }
- if ((clazz == null) && hasExternalRepositories) {
- try {
- clazz = super.findClass(name);
- } catch(AccessControlException ace) {
- log.warn(sm.getString("webappClassLoader.securityException", name,
- ace.getMessage()), ace);
- throw new ClassNotFoundException(name, ace);
- } catch (RuntimeException e) {
- if (log.isTraceEnabled())
- log.trace(" -->RuntimeException Rethrown", e);
- throw e;
- }
- }
- if (clazz == null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning ClassNotFoundException");
- throw new ClassNotFoundException(name);
- }
- } catch (ClassNotFoundException e) {
- if (log.isTraceEnabled())
- log.trace(" --> Passing on ClassNotFoundException");
- throw e;
- }
-
- // Return the class we have located
- if (log.isTraceEnabled())
- log.debug(" Returning class " + clazz);
-
- if (log.isTraceEnabled()) {
- ClassLoader cl;
- if (Globals.IS_SECURITY_ENABLED){
- cl = AccessController.doPrivileged(
- new PrivilegedGetClassLoader(clazz));
- } else {
- cl = clazz.getClassLoader();
- }
- log.debug(" Loaded by " + cl.toString());
- }
- return clazz;
-
- }
-
-
- /**
- * Find the specified resource in our local repository, and return a
- * <code>URL</code> referring to it, or <code>null</code> if this resource
- * cannot be found.
- *
- * @param name Name of the resource to be found
- */
- @Override
- public URL findResource(final String name) {
-
- if (log.isDebugEnabled())
- log.debug(" findResource(" + name + ")");
-
- checkStateForResourceLoading(name);
-
- URL url = null;
-
- String path = nameToPath(name);
-
- WebResource resource = resources.getClassLoaderResource(path);
- if (resource.exists()) {
- url = resource.getURL();
- trackLastModified(path, resource);
- }
-
- if ((url == null) && hasExternalRepositories) {
- url = super.findResource(name);
- }
-
- if (log.isDebugEnabled()) {
- if (url != null)
- log.debug(" --> Returning '" + url.toString() + "'");
- else
- log.debug(" --> Resource not found, returning null");
- }
- return url;
- }
-
-
- private void trackLastModified(String path, WebResource resource) {
- if (resourceEntries.containsKey(path)) {
- return;
- }
- ResourceEntry entry = new ResourceEntry();
- entry.lastModified = resource.getLastModified();
- synchronized(resourceEntries) {
- resourceEntries.putIfAbsent(path, entry);
- }
- }
-
-
- /**
- * Return an enumeration of <code>URLs</code> representing all of the
- * resources with the given name. If no resources with this name are
- * found, return an empty enumeration.
- *
- * @param name Name of the resources to be found
- *
- * @exception IOException if an input/output error occurs
- */
- @Override
- public Enumeration<URL> findResources(String name) throws IOException {
-
- if (log.isDebugEnabled())
- log.debug(" findResources(" + name + ")");
-
- checkStateForResourceLoading(name);
-
- LinkedHashSet<URL> result = new LinkedHashSet<>();
-
- String path = nameToPath(name);
-
- WebResource[] webResources = resources.getClassLoaderResources(path);
- for (WebResource webResource : webResources) {
- if (webResource.exists()) {
- result.add(webResource.getURL());
- }
- }
-
- // Adding the results of a call to the superclass
- if (hasExternalRepositories) {
- Enumeration<URL> otherResourcePaths = super.findResources(name);
- while (otherResourcePaths.hasMoreElements()) {
- result.add(otherResourcePaths.nextElement());
- }
- }
-
- return Collections.enumeration(result);
- }
-
-
- /**
- * Find the resource with the given name. A resource is some data
- * (images, audio, text, etc.) that can be accessed by class code in a
- * way that is independent of the location of the code. The name of a
- * resource is a "/"-separated path name that identifies the resource.
- * If the resource cannot be found, return <code>null</code>.
- * <p>
- * This method searches according to the following algorithm, returning
- * as soon as it finds the appropriate URL. If the resource cannot be
- * found, returns <code>null</code>.
- * <ul>
- * <li>If the <code>delegate</code> property is set to <code>true</code>,
- * call the <code>getResource()</code> method of the parent class
- * loader, if any.</li>
- * <li>Call <code>findResource()</code> to find this resource in our
- * locally defined repositories.</li>
- * <li>Call the <code>getResource()</code> method of the parent class
- * loader, if any.</li>
- * </ul>
- *
- * @param name Name of the resource to return a URL for
- */
- @Override
- public URL getResource(String name) {
-
- if (log.isDebugEnabled())
- log.debug("getResource(" + name + ")");
-
- checkStateForResourceLoading(name);
-
- URL url = null;
-
- boolean delegateFirst = delegate || filter(name, false);
-
- // (1) Delegate to parent if requested
- if (delegateFirst) {
- if (log.isDebugEnabled())
- log.debug(" Delegating to parent classloader " + parent);
- url = parent.getResource(name);
- if (url != null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning '" + url.toString() + "'");
- return url;
- }
- }
-
- // (2) Search local repositories
- url = findResource(name);
- if (url != null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning '" + url.toString() + "'");
- return url;
- }
-
- // (3) Delegate to parent unconditionally if not already attempted
- if (!delegateFirst) {
- url = parent.getResource(name);
- if (url != null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning '" + url.toString() + "'");
- return url;
- }
- }
-
- // (4) Resource was not found
- if (log.isDebugEnabled())
- log.debug(" --> Resource not found, returning null");
- return null;
-
- }
-
-
- @Override
- public Enumeration<URL> getResources(String name) throws IOException {
-
- Enumeration<URL> parentResources = getParent().getResources(name);
- Enumeration<URL> localResources = findResources(name);
-
- // Need to combine these enumerations. The order in which the
- // Enumerations are combined depends on how delegation is configured
- boolean delegateFirst = delegate || filter(name, false);
-
- if (delegateFirst) {
- return new CombinedEnumeration(parentResources, localResources);
- } else {
- return new CombinedEnumeration(localResources, parentResources);
- }
- }
-
-
- /**
- * Find the resource with the given name, and return an input stream
- * that can be used for reading it. The search order is as described
- * for <code>getResource()</code>, after checking to see if the resource
- * data has been previously cached. If the resource cannot be found,
- * return <code>null</code>.
- *
- * @param name Name of the resource to return an input stream for
- */
- @Override
- public InputStream getResourceAsStream(String name) {
-
- if (log.isDebugEnabled())
- log.debug("getResourceAsStream(" + name + ")");
-
- checkStateForResourceLoading(name);
-
- InputStream stream = null;
-
- boolean delegateFirst = delegate || filter(name, false);
-
- // (1) Delegate to parent if requested
- if (delegateFirst) {
- if (log.isDebugEnabled())
- log.debug(" Delegating to parent classloader " + parent);
- stream = parent.getResourceAsStream(name);
- if (stream != null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning stream from parent");
- return stream;
- }
- }
-
- // (2) Search local repositories
- if (log.isDebugEnabled())
- log.debug(" Searching local repositories");
- String path = nameToPath(name);
- WebResource resource = resources.getClassLoaderResource(path);
- if (resource.exists()) {
- stream = resource.getInputStream();
- trackLastModified(path, resource);
- }
- try {
- if (hasExternalRepositories && stream == null) {
- URL url = super.findResource(name);
- if (url != null) {
- stream = url.openStream();
- }
- }
- } catch (IOException e) {
- // Ignore
- }
- if (stream != null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning stream from local");
- return stream;
- }
-
- // (3) Delegate to parent unconditionally
- if (!delegateFirst) {
- if (log.isDebugEnabled())
- log.debug(" Delegating to parent classloader unconditionally " + parent);
- stream = parent.getResourceAsStream(name);
- if (stream != null) {
- if (log.isDebugEnabled())
- log.debug(" --> Returning stream from parent");
- return stream;
- }
- }
-
- // (4) Resource was not found
- if (log.isDebugEnabled())
- log.debug(" --> Resource not found, returning null");
- return null;
- }
-
-
- /**
- * Load the class with the specified name. This method searches for
- * classes in the same manner as <code>loadClass(String, boolean)</code>
- * with <code>false</code> as the second argument.
- *
- * @param name The binary name of the class to be loaded
- *
- * @exception ClassNotFoundException if the class was not found
- */
- @Override
- public Class<?> loadClass(String name) throws ClassNotFoundException {
- return loadClass(name, false);
- }
-
-
- /**
- * Load the class with the specified name, searching using the following
- * algorithm until it finds and returns the class. If the class cannot
- * be found, returns <code>ClassNotFoundException</code>.
- * <ul>
- * <li>Call <code>findLoadedClass(String)</code> to check if the
- * class has already been loaded. If it has, the same
- * <code>Class</code> object is returned.</li>
- * <li>If the <code>delegate</code> property is set to <code>true</code>,
- * call the <code>loadClass()</code> method of the parent class
- * loader, if any.</li>
- * <li>Call <code>findClass()</code> to find this class in our locally
- * defined repositories.</li>
- * <li>Call the <code>loadClass()</code> method of our parent
- * class loader, if any.</li>
- * </ul>
- * If the class was found using the above steps, and the
- * <code>resolve</code> flag is <code>true</code>, this method will then
- * call <code>resolveClass(Class)</code> on the resulting Class object.
- *
- * @param name The binary name of the class to be loaded
- * @param resolve If <code>true</code> then resolve the class
- *
- * @exception ClassNotFoundException if the class was not found
- */
- @Override
- public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
-
- synchronized (JreCompat.isGraalAvailable() ? this : getClassLoadingLock(name)) {
- if (log.isDebugEnabled())
- log.debug("loadClass(" + name + ", " + resolve + ")");
- Class<?> clazz = null;
-
- // Log access to stopped class loader
- checkStateForClassLoading(name);
-
- // (0) Check our previously loaded local class cache
- clazz = findLoadedClass0(name);
- if (clazz != null) {
- if (log.isDebugEnabled())
- log.debug(" Returning class from cache");
- if (resolve)
- resolveClass(clazz);
- return clazz;
- }
-
- // (0.1) Check our previously loaded class cache
- clazz = JreCompat.isGraalAvailable() ? null : findLoadedClass(name);
- if (clazz != null) {
- if (log.isDebugEnabled())
- log.debug(" Returning class from cache");
- if (resolve)
- resolveClass(clazz);
- return clazz;
- }
-
- // (0.2) Try loading the class with the system class loader, to prevent
- // the webapp from overriding Java SE classes. This implements
- // SRV.10.7.2
- String resourceName = binaryNameToPath(name, false);
-
- ClassLoader javaseLoader = getJavaseClassLoader();
- boolean tryLoadingFromJavaseLoader;
- try {
- // Use getResource as it won't trigger an expensive
- // ClassNotFoundException if the resource is not available from
- // the Java SE class loader. However (see
- // https://bz.apache.org/bugzilla/show_bug.cgi?id=58125 for
- // details) when running under a security manager in rare cases
- // this call may trigger a ClassCircularityError.
- // See https://bz.apache.org/bugzilla/show_bug.cgi?id=61424 for
- // details of how this may trigger a StackOverflowError
- // Given these reported errors, catch Throwable to ensure any
- // other edge cases are also caught
- URL url;
- if (securityManager != null) {
- PrivilegedAction<URL> dp = new PrivilegedJavaseGetResource(resourceName);
- url = AccessController.doPrivileged(dp);
- } else {
- url = javaseLoader.getResource(resourceName);
- }
- tryLoadingFromJavaseLoader = (url != null);
- } catch (Throwable t) {
- // Swallow all exceptions apart from those that must be re-thrown
- ExceptionUtils.handleThrowable(t);
- // The getResource() trick won't work for this class. We have to
- // try loading it directly and accept that we might get a
- // ClassNotFoundException.
- tryLoadingFromJavaseLoader = true;
- }
-
- if (tryLoadingFromJavaseLoader) {
- try {
- clazz = javaseLoader.loadClass(name);
- if (clazz != null) {
- if (resolve)
- resolveClass(clazz);
- return clazz;
- }
- } catch (ClassNotFoundException e) {
- // Ignore
- }
- }
-
- // (0.5) Permission to access this class when using a SecurityManager
- if (securityManager != null) {
- int i = name.lastIndexOf('.');
- if (i >= 0) {
- try {
- securityManager.checkPackageAccess(name.substring(0,i));
- } catch (SecurityException se) {
- String error = sm.getString("webappClassLoader.restrictedPackage", name);
- log.info(error, se);
- throw new ClassNotFoundException(error, se);
- }
- }
- }
-
- boolean delegateLoad = delegate || filter(name, true);
-
- // (1) Delegate to our parent if requested
- if (delegateLoad) {
- if (log.isDebugEnabled())
- log.debug(" Delegating to parent classloader1 " + parent);
- try {
- clazz = Class.forName(name, false, parent);
- if (clazz != null) {
- if (log.isDebugEnabled())
- log.debug(" Loading class from parent");
- if (resolve)
- resolveClass(clazz);
- return clazz;
- }
- } catch (ClassNotFoundException e) {
- // Ignore
- }
- }
-
- // (2) Search local repositories
- if (log.isDebugEnabled())
- log.debug(" Searching local repositories");
- try {
- clazz = findClass(name);
- if (clazz != null) {
- if (log.isDebugEnabled())
- log.debug(" Loading class from local repository");
- if (resolve)
- resolveClass(clazz);
- return clazz;
- }
- } catch (ClassNotFoundException e) {
- // Ignore
- }
-
- // (3) Delegate to parent unconditionally
- if (!delegateLoad) {
- if (log.isDebugEnabled())
- log.debug(" Delegating to parent classloader at end: " + parent);
- try {
- clazz = Class.forName(name, false, parent);
- if (clazz != null) {
- if (log.isDebugEnabled())
- log.debug(" Loading class from parent");
- if (resolve)
- resolveClass(clazz);
- return clazz;
- }
- } catch (ClassNotFoundException e) {
- // Ignore
- }
- }
- }
-
- throw new ClassNotFoundException(name);
- }
-
-
- protected void checkStateForClassLoading(String className) throws ClassNotFoundException {
- // It is not permitted to load new classes once the web application has
- // been stopped.
- try {
- checkStateForResourceLoading(className);
- } catch (IllegalStateException ise) {
- throw new ClassNotFoundException(ise.getMessage(), ise);
- }
- }
-
-
- protected void checkStateForResourceLoading(String resource) throws IllegalStateException {
- // It is not permitted to load resources once the web application has
- // been stopped.
- if (!state.isAvailable()) {
- String msg = sm.getString("webappClassLoader.stopped", resource);
- IllegalStateException ise = new IllegalStateException(msg);
- log.info(msg, ise);
- throw ise;
- }
- }
-
- /**
- * Get the Permissions for a CodeSource. If this instance
- * of WebappClassLoaderBase is for a web application context,
- * add read FilePermission for the appropriate resources.
- *
- * @param codeSource where the code was loaded from
- * @return PermissionCollection for CodeSource
- */
- @Override
- protected PermissionCollection getPermissions(CodeSource codeSource) {
- String codeUrl = codeSource.getLocation().toString();
- PermissionCollection pc;
- if ((pc = loaderPC.get(codeUrl)) == null) {
- pc = super.getPermissions(codeSource);
- if (pc != null) {
- for (Permission p : permissionList) {
- pc.add(p);
- }
- loaderPC.put(codeUrl,pc);
- }
- }
- return pc;
- }
-
-
- @Override
- public boolean check(Permission permission) {
- if (!Globals.IS_SECURITY_ENABLED) {
- return true;
- }
- Policy currentPolicy = Policy.getPolicy();
- if (currentPolicy != null) {
- URL contextRootUrl = resources.getResource("/").getCodeBase();
- CodeSource cs = new CodeSource(contextRootUrl, (Certificate[]) null);
- PermissionCollection pc = currentPolicy.getPermissions(cs);
- if (pc.implies(permission)) {
- return true;
- }
- }
- return false;
- }
-
-
- /**
- * {@inheritDoc}
- * <p>
- * Note that list of URLs returned by this method may not be complete. The
- * web application class loader accesses class loader resources via the
- * {@link WebResourceRoot} which supports the arbitrary mapping of
- * additional files, directories and contents of JAR files under
- * WEB-INF/classes. Any such resources will not be included in the URLs
- * returned here.
- */
- @Override
- public URL[] getURLs() {
- ArrayList<URL> result = new ArrayList<>();
- result.addAll(localRepositories);
- result.addAll(Arrays.asList(super.getURLs()));
- return result.toArray(new URL[0]);
- }
-
-
- // ------------------------------------------------------ Lifecycle Methods
-
-
- /**
- * Add a lifecycle event listener to this component.
- *
- * @param listener The listener to add
- */
- @Override
- public void addLifecycleListener(LifecycleListener listener) {
- // NOOP
- }
-
-
- /**
- * Get the lifecycle listeners associated with this lifecycle. If this
- * Lifecycle has no listeners registered, a zero-length array is returned.
- */
- @Override
- public LifecycleListener[] findLifecycleListeners() {
- return new LifecycleListener[0];
- }
-
-
- /**
- * Remove a lifecycle event listener from this component.
- *
- * @param listener The listener to remove
- */
- @Override
- public void removeLifecycleListener(LifecycleListener listener) {
- // NOOP
- }
-
-
- /**
- * Obtain the current state of the source component.
- *
- * @return The current state of the source component.
- */
- @Override
- public LifecycleState getState() {
- return state;
- }
-
-
- /**
- * {@inheritDoc}
- */
- @Override
- public String getStateName() {
- return getState().toString();
- }
-
-
- @Override
- public void init() {
- state = LifecycleState.INITIALIZED;
- }
-
-
- /**
- * Start the class loader.
- *
- * @exception LifecycleException if a lifecycle error occurs
- */
- @Override
- public void start() throws LifecycleException {
-
- state = LifecycleState.STARTING_PREP;
-
- WebResource[] classesResources = resources.getResources("/WEB-INF/classes");
- for (WebResource classes : classesResources) {
- if (classes.isDirectory() && classes.canRead()) {
- localRepositories.add(classes.getURL());
- }
- }
- WebResource[] jars = resources.listResources("/WEB-INF/lib");
- for (WebResource jar : jars) {
- if (jar.getName().endsWith(".jar") && jar.isFile() && jar.canRead()) {
- localRepositories.add(jar.getURL());
- jarModificationTimes.put(
- jar.getName(), Long.valueOf(jar.getLastModified()));
- }
- }
-
- state = LifecycleState.STARTED;
- }
-
-
- /**
- * Stop the class loader.
- *
- * @exception LifecycleException if a lifecycle error occurs
- */
- @Override
- public void stop() throws LifecycleException {
-
- state = LifecycleState.STOPPING_PREP;
-
- // Clearing references should be done before setting started to
- // false, due to possible side effects
- clearReferences();
-
- state = LifecycleState.STOPPING;
-
- resourceEntries.clear();
- jarModificationTimes.clear();
- resources = null;
-
- permissionList.clear();
- loaderPC.clear();
-
- state = LifecycleState.STOPPED;
- }
-
-
- @Override
- public void destroy() {
- state = LifecycleState.DESTROYING;
-
- try {
- super.close();
- } catch (IOException ioe) {
- log.warn(sm.getString("webappClassLoader.superCloseFail"), ioe);
- }
- state = LifecycleState.DESTROYED;
- }
-
-
- // ------------------------------------------------------ Protected Methods
-
- protected ClassLoader getJavaseClassLoader() {
- return javaseClassLoader;
- }
-
- protected void setJavaseClassLoader(ClassLoader classLoader) {
- if (classLoader == null) {
- throw new IllegalArgumentException(
- sm.getString("webappClassLoader.javaseClassLoaderNull"));
- }
- javaseClassLoader = classLoader;
- }
-
- /**
- * Clear references.
- */
- protected void clearReferences() {
-
- // If the JVM is shutting down, skip the memory leak checks
- if (skipMemoryLeakChecksOnJvmShutdown
- && !resources.getContext().getParent().getState().isAvailable()) {
- // During reloading / redeployment the parent is expected to be
- // available. Parent is not available so this might be a JVM
- // shutdown.
- try {
- Thread dummyHook = new Thread();
- Runtime.getRuntime().addShutdownHook(dummyHook);
- Runtime.getRuntime().removeShutdownHook(dummyHook);
- } catch (IllegalStateException ise) {
- return;
- }
- }
-
- if (!JreCompat.isGraalAvailable()) {
- // De-register any remaining JDBC drivers
- clearReferencesJdbc();
- }
-
- // Stop any threads the web application started
- clearReferencesThreads();
-
- // Clear any references retained in the serialization caches
- if (clearReferencesObjectStreamClassCaches && !JreCompat.isGraalAvailable()) {
- clearReferencesObjectStreamClassCaches();
- }
-
- // Check for leaks triggered by ThreadLocals loaded by this class loader
- if (clearReferencesThreadLocals && !JreCompat.isGraalAvailable()) {
- checkThreadLocalsForLeaks();
- }
-
- // Clear RMI Targets loaded by this class loader
- if (clearReferencesRmiTargets) {
- clearReferencesRmiTargets();
- }
-
- // Clear the IntrospectionUtils cache.
- IntrospectionUtils.clear();
-
- // Clear the classloader reference in common-logging
- if (clearReferencesLogFactoryRelease) {
- org.apache.juli.logging.LogFactory.release(this);
- }
-
- // Clear the classloader reference in the VM's bean introspector
- java.beans.Introspector.flushCaches();
-
- // Clear any custom URLStreamHandlers
- TomcatURLStreamHandlerFactory.release(this);
- }
-
-
- /**
- * Deregister any JDBC drivers registered by the webapp that the webapp
- * forgot. This is made unnecessary complex because a) DriverManager
- * checks the class loader of the calling class (it would be much easier
- * if it checked the context class loader) b) using reflection would
- * create a dependency on the DriverManager implementation which can,
- * and has, changed.
- *
- * We can't just create an instance of JdbcLeakPrevention as it will be
- * loaded by the common class loader (since it's .class file is in the
- * $CATALINA_HOME/lib directory). This would fail DriverManager's check
- * on the class loader of the calling class. So, we load the bytes via
- * our parent class loader but define the class with this class loader
- * so the JdbcLeakPrevention looks like a webapp class to the
- * DriverManager.
- *
- * If only apps cleaned up after themselves...
- */
- private final void clearReferencesJdbc() {
- // We know roughly how big the class will be (~ 1K) so allow 2k as a
- // starting point
- byte[] classBytes = new byte[2048];
- int offset = 0;
- try (InputStream is = getResourceAsStream(
- "org/apache/catalina/loader/JdbcLeakPrevention.class")) {
- int read = is.read(classBytes, offset, classBytes.length-offset);
- while (read > -1) {
- offset += read;
- if (offset == classBytes.length) {
- // Buffer full - double size
- byte[] tmp = new byte[classBytes.length * 2];
- System.arraycopy(classBytes, 0, tmp, 0, classBytes.length);
- classBytes = tmp;
- }
- read = is.read(classBytes, offset, classBytes.length-offset);
- }
- Class<?> lpClass =
- defineClass("org.apache.catalina.loader.JdbcLeakPrevention",
- classBytes, 0, offset, this.getClass().getProtectionDomain());
- Object obj = lpClass.getConstructor().newInstance();
- @SuppressWarnings("unchecked")
- List<String> driverNames = (List<String>) obj.getClass().getMethod(
- "clearJdbcDriverRegistrations").invoke(obj);
- for (String name : driverNames) {
- log.warn(sm.getString("webappClassLoader.clearJdbc",
- getContextName(), name));
- }
- } catch (Exception e) {
- // So many things to go wrong above...
- Throwable t = ExceptionUtils.unwrapInvocationTargetException(e);
- ExceptionUtils.handleThrowable(t);
- log.warn(sm.getString(
- "webappClassLoader.jdbcRemoveFailed", getContextName()), t);
- }
- }
-
-
- @SuppressWarnings("deprecation") // thread.stop()
- private void clearReferencesThreads() {
- Thread[] threads = getThreads();
- List<Thread> threadsToStop = new ArrayList<>();
-
- // Iterate over the set of threads
- for (Thread thread : threads) {
- if (thread != null) {
- ClassLoader ccl = thread.getContextClassLoader();
- if (ccl == this) {
- // Don't warn about this thread
- if (thread == Thread.currentThread()) {
- continue;
- }
-
- final String threadName = thread.getName();
-
- // JVM controlled threads
- ThreadGroup tg = thread.getThreadGroup();
- if (tg != null && JVM_THREAD_GROUP_NAMES.contains(tg.getName())) {
- // HttpClient keep-alive threads
- if (clearReferencesHttpClientKeepAliveThread &&
- threadName.equals("Keep-Alive-Timer")) {
- thread.setContextClassLoader(parent);
- log.debug(sm.getString("webappClassLoader.checkThreadsHttpClient"));
- }
-
- // Don't warn about remaining JVM controlled threads
- continue;
- }
-
- // Skip threads that have already died
- if (!thread.isAlive()) {
- continue;
- }
-
- // TimerThread can be stopped safely so treat separately
- // "java.util.TimerThread" in Sun/Oracle JDK
- // "java.util.Timer$TimerImpl" in Apache Harmony and in IBM JDK
- if (thread.getClass().getName().startsWith("java.util.Timer") &&
- clearReferencesStopTimerThreads) {
- clearReferencesStopTimerThread(thread);
- continue;
- }
-
- if (isRequestThread(thread)) {
- log.warn(sm.getString("webappClassLoader.stackTraceRequestThread",
- getContextName(), threadName, getStackTrace(thread)));
- } else {
- log.warn(sm.getString("webappClassLoader.stackTrace",
- getContextName(), threadName, getStackTrace(thread)));
- }
-
- // Don't try and stop the threads unless explicitly
- // configured to do so
- if (!clearReferencesStopThreads) {
- continue;
- }
-
- // If the thread has been started via an executor, try
- // shutting down the executor
- boolean usingExecutor = false;
- try {
-
- // Runnable wrapped by Thread
- // "target" in Sun/Oracle JDK
- // "runnable" in IBM JDK
- // "action" in Apache Harmony
- Object target = null;
- for (String fieldName : new String[] { "target", "runnable", "action" }) {
- try {
- Field targetField = thread.getClass().getDeclaredField(fieldName);
- targetField.setAccessible(true);
- target = targetField.get(thread);
- break;
- } catch (NoSuchFieldException nfe) {
- continue;
- }
- }
-
- // "java.util.concurrent" code is in public domain,
- // so all implementations are similar
- if (target != null && target.getClass().getCanonicalName() != null &&
- target.getClass().getCanonicalName().equals(
- "java.util.concurrent.ThreadPoolExecutor.Worker")) {
- Field executorField = target.getClass().getDeclaredField("this$0");
- executorField.setAccessible(true);
- Object executor = executorField.get(target);
- if (executor instanceof ThreadPoolExecutor) {
- ((ThreadPoolExecutor) executor).shutdownNow();
- usingExecutor = true;
- }
- }
- } catch (SecurityException | NoSuchFieldException | IllegalArgumentException |
- IllegalAccessException e) {
- log.warn(sm.getString("webappClassLoader.stopThreadFail",
- thread.getName(), getContextName()), e);
- }
-
- // Stopping an executor automatically interrupts the
- // associated threads. For non-executor threads, interrupt
- // them here.
- if (!usingExecutor && !thread.isInterrupted()) {
- thread.interrupt();
- }
-
- // Threads are expected to take a short time to stop after
- // being interrupted. Make a note of all threads that are
- // expected to stop to enable them to be checked at the end
- // of this method.
- threadsToStop.add(thread);
- }
- }
- }
-
- // If thread stopping is enabled, threads should have been stopped above
- // when the executor was shut down or the thread was interrupted but
- // that depends on the thread correctly handling the interrupt. Check
- // each thread and if any are still running give all threads up to a
- // total of 2 seconds to shutdown.
- int count = 0;
- for (Thread t : threadsToStop) {
- while (t.isAlive() && count < 100) {
- try {
- Thread.sleep(20);
- } catch (InterruptedException e) {
- // Quit the while loop
- break;
- }
- count++;
- }
- if (t.isAlive()) {
- // This method is deprecated and for good reason. This is
- // very risky code but is the only option at this point.
- // A *very* good reason for apps to do this clean-up
- // themselves.
- t.stop();
- }
- }
- }
-
-
- /*
- * Look at a threads stack trace to see if it is a request thread or not. It
- * isn't perfect, but it should be good-enough for most cases.
- */
- private boolean isRequestThread(Thread thread) {
-
- StackTraceElement[] elements = thread.getStackTrace();
-
- if (elements == null || elements.length == 0) {
- // Must have stopped already. Too late to ignore it. Assume not a
- // request processing thread.
- return false;
- }
-
- // Step through the methods in reverse order looking for calls to any
- // CoyoteAdapter method. All request threads will have this unless
- // Tomcat has been heavily modified - in which case there isn't much we
- // can do.
- for (int i = 0; i < elements.length; i++) {
- StackTraceElement element = elements[elements.length - (i+1)];
- if ("org.apache.catalina.connector.CoyoteAdapter".equals(
- element.getClassName())) {
- return true;
- }
- }
- return false;
- }
-
-
- private void clearReferencesStopTimerThread(Thread thread) {
-
- // Need to get references to:
- // in Sun/Oracle JDK:
- // - newTasksMayBeScheduled field (in java.util.TimerThread)
- // - queue field
- // - queue.clear()
- // in IBM JDK, Apache Harmony:
- // - cancel() method (in java.util.Timer$TimerImpl)
-
- try {
-
- try {
- Field newTasksMayBeScheduledField =
- thread.getClass().getDeclaredField("newTasksMayBeScheduled");
- newTasksMayBeScheduledField.setAccessible(true);
- Field queueField = thread.getClass().getDeclaredField("queue");
- queueField.setAccessible(true);
-
- Object queue = queueField.get(thread);
-
- Method clearMethod = queue.getClass().getDeclaredMethod("clear");
- clearMethod.setAccessible(true);
-
- synchronized(queue) {
- newTasksMayBeScheduledField.setBoolean(thread, false);
- clearMethod.invoke(queue);
- // In case queue was already empty. Should only be one
- // thread waiting but use notifyAll() to be safe.
- queue.notifyAll();
- }
-
- }catch (NoSuchFieldException nfe){
- Method cancelMethod = thread.getClass().getDeclaredMethod("cancel");
- synchronized(thread) {
- cancelMethod.setAccessible(true);
- cancelMethod.invoke(thread);
- }
- }
-
- log.warn(sm.getString("webappClassLoader.warnTimerThread",
- getContextName(), thread.getName()));
-
- } catch (Exception e) {
- // So many things to go wrong above...
- Throwable t = ExceptionUtils.unwrapInvocationTargetException(e);
- ExceptionUtils.handleThrowable(t);
- log.warn(sm.getString(
- "webappClassLoader.stopTimerThreadFail",
- thread.getName(), getContextName()), t);
- }
- }
-
- private void checkThreadLocalsForLeaks() {
- Thread[] threads = getThreads();
-
- try {
- // Make the fields in the Thread class that store ThreadLocals
- // accessible
- Field threadLocalsField =
- Thread.class.getDeclaredField("threadLocals");
- threadLocalsField.setAccessible(true);
- Field inheritableThreadLocalsField =
- Thread.class.getDeclaredField("inheritableThreadLocals");
- inheritableThreadLocalsField.setAccessible(true);
- // Make the underlying array of ThreadLoad.ThreadLocalMap.Entry objects
- // accessible
- Class<?> tlmClass = Class.forName("java.lang.ThreadLocal$ThreadLocalMap");
- Field tableField = tlmClass.getDeclaredField("table");
- tableField.setAccessible(true);
- Method expungeStaleEntriesMethod = tlmClass.getDeclaredMethod("expungeStaleEntries");
- expungeStaleEntriesMethod.setAccessible(true);
-
- for (Thread thread : threads) {
- Object threadLocalMap;
- if (thread != null) {
-
- // Clear the first map
- threadLocalMap = threadLocalsField.get(thread);
- if (null != threadLocalMap) {
- expungeStaleEntriesMethod.invoke(threadLocalMap);
- checkThreadLocalMapForLeaks(threadLocalMap, tableField);
- }
-
- // Clear the second map
- threadLocalMap = inheritableThreadLocalsField.get(thread);
- if (null != threadLocalMap) {
- expungeStaleEntriesMethod.invoke(threadLocalMap);
- checkThreadLocalMapForLeaks(threadLocalMap, tableField);
- }
- }
- }
- } catch (Throwable t) {
- JreCompat jreCompat = JreCompat.getInstance();
- if (jreCompat.isInstanceOfInaccessibleObjectException(t)) {
- // Must be running on Java 9 without the necessary command line
- // options.
- log.warn(sm.getString("webappClassLoader.addExportsThreadLocal"));
- } else {
- ExceptionUtils.handleThrowable(t);
- log.warn(sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaksFail",
- getContextName()), t);
- }
- }
- }
-
-
- /**
- * Analyzes the given thread local map object. Also pass in the field that
- * points to the internal table to save re-calculating it on every
- * call to this method.
- */
- private void checkThreadLocalMapForLeaks(Object map,
- Field internalTableField) throws IllegalAccessException,
- NoSuchFieldException {
- if (map != null) {
- Object[] table = (Object[]) internalTableField.get(map);
- if (table != null) {
- for (Object obj : table) {
- if (obj != null) {
- boolean keyLoadedByWebapp = false;
- boolean valueLoadedByWebapp = false;
- // Check the key
- Object key = ((Reference<?>) obj).get();
- if (this.equals(key) || loadedByThisOrChild(key)) {
- keyLoadedByWebapp = true;
- }
- // Check the value
- Field valueField =
- obj.getClass().getDeclaredField("value");
- valueField.setAccessible(true);
- Object value = valueField.get(obj);
- if (this.equals(value) || loadedByThisOrChild(value)) {
- valueLoadedByWebapp = true;
- }
- if (keyLoadedByWebapp || valueLoadedByWebapp) {
- Object[] args = new Object[5];
- args[0] = getContextName();
- if (key != null) {
- args[1] = getPrettyClassName(key.getClass());
- try {
- args[2] = key.toString();
- } catch (Exception e) {
- log.warn(sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaks.badKey",
- args[1]), e);
- args[2] = sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaks.unknown");
- }
- }
- if (value != null) {
- args[3] = getPrettyClassName(value.getClass());
- try {
- args[4] = value.toString();
- } catch (Exception e) {
- log.warn(sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaks.badValue",
- args[3]), e);
- args[4] = sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaks.unknown");
- }
- }
- if (valueLoadedByWebapp) {
- log.error(sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaks",
- args));
- } else if (value == null) {
- if (log.isDebugEnabled()) {
- log.debug(sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaksNull",
- args));
- }
- } else {
- if (log.isDebugEnabled()) {
- log.debug(sm.getString(
- "webappClassLoader.checkThreadLocalsForLeaksNone",
- args));
- }
- }
- }
- }
- }
- }
- }
- }
-
- private String getPrettyClassName(Class<?> clazz) {
- String name = clazz.getCanonicalName();
- if (name==null){
- name = clazz.getName();
- }
- return name;
- }
-
- private String getStackTrace(Thread thread) {
- StringBuilder builder = new StringBuilder();
- for (StackTraceElement ste : thread.getStackTrace()) {
- builder.append("\n ").append(ste);
- }
- return builder.toString();
- }
-
- /**
- * @param o object to test, may be null
- * @return <code>true</code> if o has been loaded by the current classloader
- * or one of its descendants.
- */
- private boolean loadedByThisOrChild(Object o) {
- if (o == null) {
- return false;
- }
-
- Class<?> clazz;
- if (o instanceof Class) {
- clazz = (Class<?>) o;
- } else {
- clazz = o.getClass();
- }
-
- ClassLoader cl = clazz.getClassLoader();
- while (cl != null) {
- if (cl == this) {
- return true;
- }
- cl = cl.getParent();
- }
-
- if (o instanceof Collection<?>) {
- Iterator<?> iter = ((Collection<?>) o).iterator();
- try {
- while (iter.hasNext()) {
- Object entry = iter.next();
- if (loadedByThisOrChild(entry)) {
- return true;
- }
- }
- } catch (ConcurrentModificationException e) {
- log.warn(sm.getString(
- "webappClassLoader.loadedByThisOrChildFail", clazz.getName(), getContextName()),
- e);
- }
- }
- return false;
- }
-
- /*
- * Get the set of current threads as an array.
- */
- private Thread[] getThreads() {
- // Get the current thread group
- ThreadGroup tg = Thread.currentThread().getThreadGroup();
- // Find the root thread group
- try {
- while (tg.getParent() != null) {
- tg = tg.getParent();
- }
- } catch (SecurityException se) {
- String msg = sm.getString(
- "webappClassLoader.getThreadGroupError", tg.getName());
- if (log.isDebugEnabled()) {
- log.debug(msg, se);
- } else {
- log.warn(msg);
- }
- }
-
- int threadCountGuess = tg.activeCount() + 50;
- Thread[] threads = new Thread[threadCountGuess];
- int threadCountActual = tg.enumerate(threads);
- // Make sure we don't miss any threads
- while (threadCountActual == threadCountGuess) {
- threadCountGuess *=2;
- threads = new Thread[threadCountGuess];
- // Note tg.enumerate(Thread[]) silently ignores any threads that
- // can't fit into the array
- threadCountActual = tg.enumerate(threads);
- }
-
- return threads;
- }
-
-
- /**
- * This depends on the internals of the Sun JVM so it does everything by
- * reflection.
- */
- private void clearReferencesRmiTargets() {
- try {
- // Need access to the ccl field of sun.rmi.transport.Target to find
- // the leaks
- Class<?> objectTargetClass =
- Class.forName("sun.rmi.transport.Target");
- Field cclField = objectTargetClass.getDeclaredField("ccl");
- cclField.setAccessible(true);
- // Need access to the stub field to report the leaks
- Field stubField = objectTargetClass.getDeclaredField("stub");
- stubField.setAccessible(true);
-
- // Clear the objTable map
- Class<?> objectTableClass = Class.forName("sun.rmi.transport.ObjectTable");
- Field objTableField = objectTableClass.getDeclaredField("objTable");
- objTableField.setAccessible(true);
- Object objTable = objTableField.get(null);
- if (objTable == null) {
- return;
- }
- Field tableLockField = objectTableClass.getDeclaredField("tableLock");
- tableLockField.setAccessible(true);
- Object tableLock = tableLockField.get(null);
-
- synchronized (tableLock) {
- // Iterate over the values in the table
- if (objTable instanceof Map<?,?>) {
- Iterator<?> iter = ((Map<?,?>) objTable).values().iterator();
- while (iter.hasNext()) {
- Object obj = iter.next();
- Object cclObject = cclField.get(obj);
- if (this == cclObject) {
- iter.remove();
- Object stubObject = stubField.get(obj);
- log.error(sm.getString("webappClassLoader.clearRmi",
- stubObject.getClass().getName(), stubObject));
- }
- }
- }
-
- // Clear the implTable map
- Field implTableField = objectTableClass.getDeclaredField("implTable");
- implTableField.setAccessible(true);
- Object implTable = implTableField.get(null);
- if (implTable == null) {
- return;
- }
-
- // Iterate over the values in the table
- if (implTable instanceof Map<?,?>) {
- Iterator<?> iter = ((Map<?,?>) implTable).values().iterator();
- while (iter.hasNext()) {
- Object obj = iter.next();
- Object cclObject = cclField.get(obj);
- if (this == cclObject) {
- iter.remove();
- }
- }
- }
- }
- } catch (ClassNotFoundException e) {
- log.info(sm.getString("webappClassLoader.clearRmiInfo",
- getContextName()), e);
- } catch (SecurityException | NoSuchFieldException | IllegalArgumentException |
- IllegalAccessException e) {
- log.warn(sm.getString("webappClassLoader.clearRmiFail",
- getContextName()), e);
- } catch (Exception e) {
- JreCompat jreCompat = JreCompat.getInstance();
- if (jreCompat.isInstanceOfInaccessibleObjectException(e)) {
- // Must be running on Java 9 without the necessary command line
- // options.
- log.warn(sm.getString("webappClassLoader.addExportsRmi"));
- } else {
- // Re-throw all other exceptions
- throw e;
- }
- }
- }
-
-
- private void clearReferencesObjectStreamClassCaches() {
- try {
- Class<?> clazz = Class.forName("java.io.ObjectStreamClass$Caches");
- clearCache(clazz, "localDescs");
- clearCache(clazz, "reflectors");
- } catch (ReflectiveOperationException | SecurityException | ClassCastException e) {
- log.warn(sm.getString(
- "webappClassLoader.clearObjectStreamClassCachesFail", getContextName()), e);
- }
- }
-
-
- private void clearCache(Class<?> target, String mapName)
- throws ReflectiveOperationException, SecurityException, ClassCastException {
- Field f = target.getDeclaredField(mapName);
- f.setAccessible(true);
- Map<?,?> map = (Map<?,?>) f.get(null);
- Iterator<?> keys = map.keySet().iterator();
- while (keys.hasNext()) {
- Object key = keys.next();
- if (key instanceof Reference) {
- Object clazz = ((Reference<?>) key).get();
- if (loadedByThisOrChild(clazz)) {
- keys.remove();
- }
- }
- }
- }
-
-
- /**
- * Find specified class in local repositories.
- *
- * @param name The binary name of the class to be loaded
- *
- * @return the loaded class, or null if the class isn't found
- */
- protected Class<?> findClassInternal(String name) {
-
- checkStateForResourceLoading(name);
-
- if (name == null) {
- return null;
- }
- String path = binaryNameToPath(name, true);
-
- ResourceEntry entry = resourceEntries.get(path);
- WebResource resource = null;
-
- if (entry == null) {
- resource = resources.getClassLoaderResource(path);
-
- if (!resource.exists()) {
- return null;
- }
-
- entry = new ResourceEntry();
- entry.lastModified = resource.getLastModified();
-
- // Add the entry in the local resource repository
- synchronized (resourceEntries) {
- // Ensures that all the threads which may be in a race to load
- // a particular class all end up with the same ResourceEntry
- // instance
- ResourceEntry entry2 = resourceEntries.get(path);
- if (entry2 == null) {
- resourceEntries.put(path, entry);
- } else {
- entry = entry2;
- }
- }
- }
-
- Class<?> clazz = entry.loadedClass;
- if (clazz != null)
- return clazz;
-
- synchronized (JreCompat.isGraalAvailable() ? this : getClassLoadingLock(name)) {
- clazz = entry.loadedClass;
- if (clazz != null)
- return clazz;
-
- if (resource == null) {
- resource = resources.getClassLoaderResource(path);
- }
-
- if (!resource.exists()) {
- return null;
- }
-
- byte[] binaryContent = resource.getContent();
- if (binaryContent == null) {
- // Something went wrong reading the class bytes (and will have
- // been logged at debug level).
- return null;
- }
- Manifest manifest = resource.getManifest();
- URL codeBase = resource.getCodeBase();
- Certificate[] certificates = resource.getCertificates();
-
- if (transformers.size() > 0) {
- // If the resource is a class just being loaded, decorate it
- // with any attached transformers
-
- // Ignore leading '/' and trailing CLASS_FILE_SUFFIX
- // Should be cheaper than replacing '.' by '/' in class name.
- String internalName = path.substring(1, path.length() - CLASS_FILE_SUFFIX.length());
-
- for (ClassFileTransformer transformer : this.transformers) {
- try {
- byte[] transformed = transformer.transform(
- this, internalName, null, null, binaryContent);
- if (transformed != null) {
- binaryContent = transformed;
- }
- } catch (IllegalClassFormatException e) {
- log.error(sm.getString("webappClassLoader.transformError", name), e);
- return null;
- }
- }
- }
-
- // Looking up the package
- String packageName = null;
- int pos = name.lastIndexOf('.');
- if (pos != -1)
- packageName = name.substring(0, pos);
-
- Package pkg = null;
-
- if (packageName != null) {
- pkg = getPackage(packageName);
- // Define the package (if null)
- if (pkg == null) {
- try {
- if (manifest == null) {
- definePackage(packageName, null, null, null, null, null, null, null);
- } else {
- definePackage(packageName, manifest, codeBase);
- }
- } catch (IllegalArgumentException e) {
- // Ignore: normal error due to dual definition of package
- }
- pkg = getPackage(packageName);
- }
- }
-
- if (securityManager != null) {
-
- // Checking sealing
- if (pkg != null) {
- boolean sealCheck = true;
- if (pkg.isSealed()) {
- sealCheck = pkg.isSealed(codeBase);
- } else {
- sealCheck = (manifest == null) || !isPackageSealed(packageName, manifest);
- }
- if (!sealCheck)
- throw new SecurityException
- ("Sealing violation loading " + name + " : Package "
- + packageName + " is sealed.");
- }
-
- }
-
- try {
- clazz = defineClass(name, binaryContent, 0,
- binaryContent.length, new CodeSource(codeBase, certificates));
- } catch (UnsupportedClassVersionError ucve) {
- throw new UnsupportedClassVersionError(
- ucve.getLocalizedMessage() + " " +
- sm.getString("webappClassLoader.wrongVersion",
- name));
- }
- entry.loadedClass = clazz;
- }
-
- return clazz;
- }
-
-
- private String binaryNameToPath(String binaryName, boolean withLeadingSlash) {
- // 1 for leading '/', 6 for ".class"
- StringBuilder path = new StringBuilder(7 + binaryName.length());
- if (withLeadingSlash) {
- path.append('/');
- }
- path.append(binaryName.replace('.', '/'));
- path.append(CLASS_FILE_SUFFIX);
- return path.toString();
- }
-
-
- private String nameToPath(String name) {
- if (name.startsWith("/")) {
- return name;
- }
- StringBuilder path = new StringBuilder(
- 1 + name.length());
- path.append('/');
- path.append(name);
- return path.toString();
- }
-
-
- /**
- * Returns true if the specified package name is sealed according to the
- * given manifest.
- *
- * @param name Path name to check
- * @param man Associated manifest
- * @return <code>true</code> if the manifest associated says it is sealed
- */
- protected boolean isPackageSealed(String name, Manifest man) {
-
- String path = name.replace('.', '/') + '/';
- Attributes attr = man.getAttributes(path);
- String sealed = null;
- if (attr != null) {
- sealed = attr.getValue(Name.SEALED);
- }
- if (sealed == null) {
- if ((attr = man.getMainAttributes()) != null) {
- sealed = attr.getValue(Name.SEALED);
- }
- }
- return "true".equalsIgnoreCase(sealed);
-
- }
-
-
- /**
- * Finds the class with the given name if it has previously been
- * loaded and cached by this class loader, and return the Class object.
- * If this class has not been cached, return <code>null</code>.
- *
- * @param name The binary name of the resource to return
- * @return a loaded class
- */
- protected Class<?> findLoadedClass0(String name) {
-
- String path = binaryNameToPath(name, true);
-
- ResourceEntry entry = resourceEntries.get(path);
- if (entry != null) {
- return entry.loadedClass;
- }
- return null;
- }
-
-
- /**
- * Refresh the system policy file, to pick up eventual changes.
- */
- protected void refreshPolicy() {
-
- try {
- // The policy file may have been modified to adjust
- // permissions, so we're reloading it when loading or
- // reloading a Context
- Policy policy = Policy.getPolicy();
- policy.refresh();
- } catch (AccessControlException e) {
- // Some policy files may restrict this, even for the core,
- // so this exception is ignored
- }
-
- }
-
-
- /**
- * Filter classes.
- *
- * @param name class name
- * @param isClassName <code>true</code> if name is a class name,
- * <code>false</code> if name is a resource name
- * @return <code>true</code> if the class should be filtered
- */
- protected boolean filter(String name, boolean isClassName) {
-
- if (name == null)
- return false;
-
- char ch;
- if (name.startsWith("jakarta")) {
- /* 7 == length("jakarta") */
- if (name.length() == 7) {
- return false;
- }
- ch = name.charAt(7);
- if (isClassName && ch == '.') {
- /* 8 == length("jakarta.") */
- if (name.startsWith("servlet.jsp.jstl.", 8)) {
- return false;
- }
- if (name.startsWith("el.", 8) ||
- name.startsWith("servlet.", 8) ||
- name.startsWith("websocket.", 8) ||
- name.startsWith("security.auth.message.", 8)) {
- return true;
- }
- } else if (!isClassName && ch == '/') {
- /* 8 == length("jakarta/") */
- if (name.startsWith("servlet/jsp/jstl/", 8)) {
- return false;
- }
- if (name.startsWith("el/", 8) ||
- name.startsWith("servlet/", 8) ||
- name.startsWith("websocket/", 8) ||
- name.startsWith("security/auth/message/", 8)) {
- return true;
- }
- }
- } else if (name.startsWith("javax")) {
- /* 5 == length("javax") */
- if (name.length() == 5) {
- return false;
- }
- ch = name.charAt(5);
- if (isClassName && ch == '.') {
- /* 6 == length("javax.") */
- if (name.startsWith("websocket.", 6)) {
- return true;
- }
- } else if (!isClassName && ch == '/') {
- /* 6 == length("javax/") */
- if (name.startsWith("websocket/", 6)) {
- return true;
- }
- }
- } else if (name.startsWith("org")) {
- /* 3 == length("org") */
- if (name.length() == 3) {
- return false;
- }
- ch = name.charAt(3);
- if (isClassName && ch == '.') {
- /* 4 == length("org.") */
- if (name.startsWith("apache.", 4)) {
- /* 11 == length("org.apache.") */
- if (name.startsWith("tomcat.jdbc.", 11)) {
- return false;
- }
- if (name.startsWith("el.", 11) ||
- name.startsWith("catalina.", 11) ||
- name.startsWith("jasper.", 11) ||
- name.startsWith("juli.", 11) ||
- name.startsWith("tomcat.", 11) ||
- name.startsWith("naming.", 11) ||
- name.startsWith("coyote.", 11)) {
- return true;
- }
- }
- } else if (!isClassName && ch == '/') {
- /* 4 == length("org/") */
- if (name.startsWith("apache/", 4)) {
- /* 11 == length("org/apache/") */
- if (name.startsWith("tomcat/jdbc/", 11)) {
- return false;
- }
- if (name.startsWith("el/", 11) ||
- name.startsWith("catalina/", 11) ||
- name.startsWith("jasper/", 11) ||
- name.startsWith("juli/", 11) ||
- name.startsWith("tomcat/", 11) ||
- name.startsWith("naming/", 11) ||
- name.startsWith("coyote/", 11)) {
- return true;
- }
- }
- }
- }
- return false;
- }
-
-
- @Override
- protected void addURL(URL url) {
- super.addURL(url);
- hasExternalRepositories = true;
- }
-
-
- @Override
- public String getWebappName() {
- return getContextName();
- }
-
-
- @Override
- public String getHostName() {
- if (resources != null) {
- Container host = resources.getContext().getParent();
- if (host != null) {
- return host.getName();
- }
- }
- return null;
- }
-
-
- @Override
- public String getServiceName() {
- if (resources != null) {
- Container host = resources.getContext().getParent();
- if (host != null) {
- Container engine = host.getParent();
- if (engine != null) {
- return engine.getName();
- }
- }
- }
- return null;
- }
-
-
- @Override
- public boolean hasLoggingConfig() {
- if (Globals.IS_SECURITY_ENABLED) {
- Boolean result = AccessController.doPrivileged(new PrivilegedHasLoggingConfig());
- return result.booleanValue();
- } else {
- return findResource("logging.properties") != null;
- }
- }
-
-
- private class PrivilegedHasLoggingConfig implements PrivilegedAction<Boolean> {
-
- @Override
- public Boolean run() {
- return Boolean.valueOf(findResource("logging.properties") != null);
- }
- }
-
-
- private static class CombinedEnumeration implements Enumeration<URL> {
-
- private final Enumeration<URL>[] sources;
- private int index = 0;
-
- public CombinedEnumeration(Enumeration<URL> enum1, Enumeration<URL> enum2) {
- @SuppressWarnings("unchecked")
- Enumeration<URL>[] sources = new Enumeration[] { enum1, enum2 };
- this.sources = sources;
- }
-
-
- @Override
- public boolean hasMoreElements() {
- return inc();
- }
-
-
- @Override
- public URL nextElement() {
- if (inc()) {
- return sources[index].nextElement();
- }
- throw new NoSuchElementException();
- }
-
-
- private boolean inc() {
- while (index < sources.length) {
- if (sources[index].hasMoreElements()) {
- return true;
- }
- index++;
- }
- return false;
- }
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/apache/cxf/jaxb/JAXBContextInitializer.java b/jakarta/src/patch/java/org/apache/cxf/jaxb/JAXBContextInitializer.java
deleted file mode 100644
index 37b2d07..0000000
--- a/jakarta/src/patch/java/org/apache/cxf/jaxb/JAXBContextInitializer.java
+++ /dev/null
@@ -1,611 +0,0 @@
-/**
- * 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.jaxb;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Array;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.GenericArrayType;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
-import java.lang.reflect.WildcardType;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import jakarta.xml.bind.annotation.XmlAccessType;
-import jakarta.xml.bind.annotation.XmlAttribute;
-import jakarta.xml.bind.annotation.XmlElement;
-import jakarta.xml.bind.annotation.XmlRootElement;
-import jakarta.xml.bind.annotation.XmlSeeAlso;
-import jakarta.xml.bind.annotation.XmlTransient;
-import jakarta.xml.bind.annotation.XmlType;
-import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
-import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapters;
-import javax.xml.namespace.QName;
-
-import org.apache.cxf.common.classloader.ClassLoaderUtils;
-import org.apache.cxf.common.jaxb.JAXBUtils;
-import org.apache.cxf.common.logging.LogUtils;
-import org.apache.cxf.common.util.ASMHelper;
-import org.apache.cxf.common.util.ASMHelper.ClassWriter;
-import org.apache.cxf.common.util.ASMHelper.MethodVisitor;
-import org.apache.cxf.common.util.ASMHelper.Opcodes;
-import org.apache.cxf.common.util.ReflectionUtil;
-import org.apache.cxf.common.util.StringUtils;
-import org.apache.cxf.service.ServiceModelVisitor;
-import org.apache.cxf.service.model.MessageInfo;
-import org.apache.cxf.service.model.MessagePartInfo;
-import org.apache.cxf.service.model.OperationInfo;
-import org.apache.cxf.service.model.ServiceInfo;
-import org.apache.cxf.service.model.UnwrappedOperationInfo;
-
-/**
- * Walks the service model and sets up the classes for the context.
- */
-class JAXBContextInitializer extends ServiceModelVisitor {
- private static final Logger LOG = LogUtils.getL7dLogger(JAXBContextInitializer.class);
- private Set<Class<?>> classes;
- private Collection<Object> typeReferences;
- private Set<Class<?>> globalAdapters = new HashSet<>();
- private Map<String, Object> unmarshallerProperties;
-
- JAXBContextInitializer(ServiceInfo serviceInfo,
- Set<Class<?>> classes,
- Collection<Object> typeReferences,
- Map<String, Object> unmarshallerProperties) {
- super(serviceInfo);
- this.classes = classes;
- this.typeReferences = typeReferences;
- this.unmarshallerProperties = unmarshallerProperties;
- }
-
- @Override
- public void begin(MessagePartInfo part) {
- Class<?> clazz = part.getTypeClass();
- if (clazz == null) {
- return;
- }
-
- if (Exception.class.isAssignableFrom(clazz)) {
- //exceptions are handled special, make sure we mark it
- part.setProperty(JAXBDataBinding.class.getName() + ".CUSTOM_EXCEPTION",
- Boolean.TRUE);
- }
- boolean isFromWrapper = part.getMessageInfo().getOperation().isUnwrapped();
- if (isFromWrapper
- && !Boolean.TRUE.equals(part.getProperty("messagepart.isheader"))) {
- UnwrappedOperationInfo uop = (UnwrappedOperationInfo)part.getMessageInfo().getOperation();
- OperationInfo op = uop.getWrappedOperation();
- MessageInfo inf = null;
- if (uop.getInput() == part.getMessageInfo()) {
- inf = op.getInput();
- } else if (uop.getOutput() == part.getMessageInfo()) {
- inf = op.getOutput();
- }
- if (inf != null
- && inf.getFirstMessagePart().getTypeClass() != null) {
- //if the wrapper has a type class, we don't need to do anything
- //as everything would have been discovered when walking the
- //wrapper type (unless it's a header which wouldn't be in the wrapper)
- return;
- }
- }
- if (isFromWrapper
- && clazz.isArray()
- && !Byte.TYPE.equals(clazz.getComponentType())) {
- clazz = clazz.getComponentType();
- }
-
- Annotation[] a = (Annotation[])part.getProperty("parameter.annotations");
- checkForAdapter(clazz, a);
-
- Type genericType = (Type) part.getProperty("generic.type");
- if (genericType != null) {
- boolean isList = Collection.class.isAssignableFrom(clazz);
- if (isFromWrapper) {
- if (genericType instanceof Class
- && ((Class<?>)genericType).isArray()) {
- Class<?> cl2 = (Class<?>)genericType;
- if (cl2.isArray()
- && !Byte.TYPE.equals(cl2.getComponentType())) {
- genericType = cl2.getComponentType();
- }
- addType(genericType);
- } else if (!isList) {
- addType(genericType);
- }
- } else {
- addType(genericType, true);
- }
-
- if (isList
- && genericType instanceof ParameterizedType) {
- ParameterizedType pt = (ParameterizedType) genericType;
- if (pt.getActualTypeArguments().length > 0
- && pt.getActualTypeArguments()[0] instanceof Class) {
-
- Class<? extends Object> arrayCls =
- Array.newInstance((Class<?>) pt.getActualTypeArguments()[0], 0).getClass();
- clazz = arrayCls;
- part.setTypeClass(clazz);
- if (isFromWrapper) {
- addType(clazz.getComponentType(), true);
- }
- } else if (pt.getActualTypeArguments().length > 0
- && pt.getActualTypeArguments()[0] instanceof GenericArrayType) {
- GenericArrayType gat = (GenericArrayType)pt.getActualTypeArguments()[0];
- gat.getGenericComponentType();
- Class<? extends Object> arrayCls =
- Array.newInstance((Class<?>) gat.getGenericComponentType(), 0).getClass();
- clazz = Array.newInstance(arrayCls, 0).getClass();
- part.setTypeClass(clazz);
- if (isFromWrapper) {
- addType(clazz.getComponentType(), true);
- }
- }
- }
- if (isFromWrapper && isList) {
- clazz = null;
- }
- }
- if (clazz != null) {
- if (!isFromWrapper
- && clazz.getAnnotation(XmlRootElement.class) == null
- && clazz.getAnnotation(XmlType.class) != null
- && StringUtils.isEmpty(clazz.getAnnotation(XmlType.class).name())) {
- Object ref = createTypeReference(part.getName(), clazz);
- if (ref != null) {
- typeReferences.add(ref);
- }
- }
-
- addClass(clazz);
- }
- }
-
- private void checkForAdapter(Class<?> clazz, Annotation[] anns) {
- if (anns != null) {
- for (Annotation a : anns) {
- if (XmlJavaTypeAdapter.class.isAssignableFrom(a.annotationType())) {
- Type t = Utils.getTypeFromXmlAdapter((XmlJavaTypeAdapter)a);
- if (t != null) {
- addType(t);
- }
- }
- }
- }
- XmlJavaTypeAdapter xjta = clazz.getAnnotation(XmlJavaTypeAdapter.class);
- if (xjta != null) {
- Type t = Utils.getTypeFromXmlAdapter(xjta);
- if (t != null) {
- addType(t);
- }
- }
- if (clazz.getPackage() != null) {
- XmlJavaTypeAdapters adapt = clazz.getPackage().getAnnotation(XmlJavaTypeAdapters.class);
- if (adapt != null) {
- for (XmlJavaTypeAdapter a : adapt.value()) {
- globalAdapters.add(a.type());
- }
- for (XmlJavaTypeAdapter a : adapt.value()) {
- Type t = Utils.getTypeFromXmlAdapter(a);
- if (t != null) {
- addType(t);
- }
- }
- }
- }
- }
-
- private void addType(Type cls) {
- addType(cls, false);
- }
- private void addType(Type cls, boolean allowArray) {
- if (cls instanceof Class) {
- if (globalAdapters.contains(cls)) {
- return;
- }
- if (((Class<?>)cls).isArray() && !allowArray) {
- addClass(((Class<?>)cls).getComponentType());
- } else {
- addClass((Class<?>)cls);
- }
- } else if (cls instanceof ParameterizedType) {
- final ParameterizedType parameterizedType = (ParameterizedType)cls;
- addType(parameterizedType.getRawType());
- if (!parameterizedType.getRawType().equals(Enum.class)) {
- for (Type t2 : parameterizedType.getActualTypeArguments()) {
- if (shouldTypeBeAdded(t2, parameterizedType)) {
- addType(t2);
- }
- }
- }
- } else if (cls instanceof GenericArrayType) {
- Class<?> ct;
- GenericArrayType gt = (GenericArrayType)cls;
- Type componentType = gt.getGenericComponentType();
- if (componentType instanceof Class) {
- ct = (Class<?>)componentType;
- } else if (componentType instanceof ParameterizedType) {
- final ParameterizedType parameterizedType = (ParameterizedType)componentType;
- final Type rawType = parameterizedType.getRawType();
- if (rawType instanceof Class) {
- ct = (Class<?>)rawType;
- } else {
- throw new IllegalArgumentException("Unable to determine type for " + rawType);
- }
- if (!parameterizedType.getRawType().equals(Enum.class)) {
- for (Type t2 : parameterizedType.getActualTypeArguments()) {
- if (shouldTypeBeAdded(t2, parameterizedType)) {
- addType(t2);
- }
- }
- }
- } else {
- TypeVariable<?> tv = (TypeVariable<?>)componentType;
- Type[] bounds = tv.getBounds();
- if (bounds != null && bounds.length == 1) {
- if (bounds[0] instanceof Class) {
- ct = (Class<?>)bounds[0];
- } else {
- throw new IllegalArgumentException("Unable to determine type for: " + tv);
- }
- } else {
- throw new IllegalArgumentException("Unable to determine type for: " + tv);
- }
- }
- ct = Array.newInstance(ct, 0).getClass();
-
- addClass(ct);
- } else if (cls instanceof WildcardType) {
- for (Type t : ((WildcardType)cls).getUpperBounds()) {
- addType(t);
- }
- for (Type t : ((WildcardType)cls).getLowerBounds()) {
- addType(t);
- }
- } else if (cls instanceof TypeVariable) {
- for (Type t : ((TypeVariable<?>)cls).getBounds()) {
- addType(t);
- }
- }
- }
-
- private boolean shouldTypeBeAdded(final Type t2, final ParameterizedType parameterizedType) {
- if (!(t2 instanceof TypeVariable)) {
- return true;
- }
- TypeVariable<?> typeVariable = (TypeVariable<?>) t2;
- final Type[] bounds = typeVariable.getBounds();
- for (Type bound : bounds) {
- if (bound instanceof ParameterizedType && bound.equals(parameterizedType)) {
- return false;
- }
- }
- return true;
- }
-
- void addClass(Class<?> claz) {
- if (Throwable.class.isAssignableFrom(claz)) {
- if (!Throwable.class.equals(claz)
- && !Exception.class.equals(claz)) {
- walkReferences(claz);
- }
- addClass(String.class);
- } else if (claz.getName().startsWith("java.")
- || claz.getName().startsWith("javax.")
- || claz.getName().startsWith("jakarta.")) {
- return;
- } else {
- Class<?> cls = JAXBUtils.getValidClass(claz);
- if (cls == null
- && ReflectionUtil.getDeclaredConstructors(claz).length > 0
- && !Modifier.isAbstract(claz.getModifiers())) {
- if (LOG.isLoggable(Level.INFO)) {
- LOG.info("Class " + claz.getName() + " does not have a default constructor which JAXB requires.");
- }
- //there is no init(), but other constructors
- Object factory = createFactory(claz, ReflectionUtil.getDeclaredConstructors(claz)[0]);
- unmarshallerProperties.put("com.sun.xml.bind.ObjectFactory", factory);
- cls = claz;
- }
- if (null != cls) {
- if (classes.contains(cls)) {
- return;
- }
-
- if (!cls.isInterface()) {
- classes.add(cls);
- }
-
- XmlSeeAlso xsa = cls.getAnnotation(XmlSeeAlso.class);
- if (xsa != null) {
- for (Class<?> c : xsa.value()) {
- addClass(c);
- }
- }
- XmlJavaTypeAdapter xjta = cls.getAnnotation(XmlJavaTypeAdapter.class);
- if (xjta != null) {
- //has an adapter. We need to inspect the adapter and then
- //return as the adapter will handle the superclass
- //and interfaces and such
- Type t = Utils.getTypeFromXmlAdapter(xjta);
- if (t != null) {
- addType(t);
- }
- return;
- }
-
- if (cls.getSuperclass() != null) {
- //JAXB should do this, but it doesn't always.
- //in particular, older versions of jaxb don't
- addClass(cls.getSuperclass());
- }
-
- if (!cls.isInterface()) {
- walkReferences(cls);
- }
- }
- }
- }
-
- private void walkReferences(Class<?> cls) {
- if (cls == null) {
- return;
- }
- if (cls.getName().startsWith("java.")
- || cls.getName().startsWith("javax.")
- || cls.getName().startsWith("jakarta.")) {
- return;
- }
- //walk the public fields/methods to try and find all the classes. JAXB will only load the
- //EXACT classes in the fields/methods if they are in a different package. Thus,
- //subclasses won't be found and the xsi:type stuff won't work at all.
- //We'll grab the public field/method types and then add the ObjectFactory stuff
- //as well as look for jaxb.index files in those packages.
-
- XmlAccessType accessType = Utils.getXmlAccessType(cls);
-
- if (accessType != XmlAccessType.PROPERTY) { // only look for fields if we are instructed to
- //fields are accessible even if not public, must look at the declared fields
- //then walk to parents declared fields, etc...
- Field[] fields = ReflectionUtil.getDeclaredFields(cls);
- for (Field f : fields) {
- if (isFieldAccepted(f, accessType)) {
- XmlJavaTypeAdapter xjta = Utils.getFieldXJTA(f);
- if (xjta != null) {
- Type t = Utils.getTypeFromXmlAdapter(xjta);
- if (t != null) {
- addType(t);
- continue;
- }
- }
- addType(f.getGenericType());
- }
- }
- walkReferences(cls.getSuperclass());
- }
-
- if (accessType != XmlAccessType.FIELD) { // only look for methods if we are instructed to
- Method[] methods = ReflectionUtil.getDeclaredMethods(cls);
- for (Method m : methods) {
- if (isMethodAccepted(m, accessType)) {
- XmlJavaTypeAdapter xjta = Utils.getMethodXJTA(m);
- if (xjta != null) {
- Type t = Utils.getTypeFromXmlAdapter(xjta);
- if (t != null) {
- addType(t);
- continue;
- }
- }
- addType(m.getGenericReturnType());
- for (Type t : m.getGenericParameterTypes()) {
- addType(t);
- }
- }
- }
- }
- }
-
- /**
- * Checks if the field is accepted as a JAXB property.
- */
- static boolean isFieldAccepted(Field field, XmlAccessType accessType) {
- // We only accept non static fields which are not marked @XmlTransient or has transient modifier
- if (field.isAnnotationPresent(XmlTransient.class)
- || Modifier.isTransient(field.getModifiers())) {
- return false;
- }
- if (Modifier.isStatic(field.getModifiers())) {
- return field.isAnnotationPresent(XmlAttribute.class);
- }
- if (accessType == XmlAccessType.PUBLIC_MEMBER
- && !Modifier.isPublic(field.getModifiers())) {
- return false;
- }
- if (accessType == XmlAccessType.NONE
- || accessType == XmlAccessType.PROPERTY) {
- return checkJaxbAnnotation(field.getAnnotations());
- }
- return true;
- }
-
- /**
- * Checks if the method is accepted as a JAXB property getter.
- */
- static boolean isMethodAccepted(Method method, XmlAccessType accessType) {
- // We only accept non static property getters which are not marked @XmlTransient
- if (Modifier.isStatic(method.getModifiers())
- || method.isAnnotationPresent(XmlTransient.class)
- || !Modifier.isPublic(method.getModifiers())
- || "getClass".equals(method.getName())) {
- return false;
- }
-
- // must not have parameters and return type must not be void
- if (method.getReturnType() == Void.class || method.getReturnType() == Void.TYPE
- || method.getParameterTypes().length != 0
- || (method.getDeclaringClass().equals(Throwable.class)
- && !("getMessage".equals(method.getName())))
- || !(method.getName().startsWith("get")
- || method.getName().startsWith("is"))) {
- return false;
- }
- int beginIndex = 3;
- if (method.getName().startsWith("is")) {
- beginIndex = 2;
- }
-
- Method setter = null;
- try {
- setter = method.getDeclaringClass()
- .getMethod("set" + method.getName().substring(beginIndex),
- new Class[] {method.getReturnType()});
- } catch (Exception e) {
- //getter, but no setter
- }
- if (setter != null) {
- if (setter.isAnnotationPresent(XmlTransient.class)
- || !Modifier.isPublic(setter.getModifiers())) {
- return false;
- }
- } else if (!Collection.class.isAssignableFrom(method.getReturnType())
- && !Throwable.class.isAssignableFrom(method.getDeclaringClass())) {
- //no setter, it's not a collection (thus getter().add(...)), and
- //not an Exception,
- return false;
- }
-
- if (accessType == XmlAccessType.NONE
- || accessType == XmlAccessType.FIELD) {
- return checkJaxbAnnotation(method.getAnnotations());
- }
- return true;
- }
-
- /**
- * Checks if there are JAXB annotations among the annotations of the class member.
- * @param annotations the array of annotations from the class member
- * @return true if JAXB annotations are present, false otherwise
- */
- static boolean checkJaxbAnnotation(Annotation[] annotations) {
- // must check if there are any jaxb annotations
- Package jaxbAnnotationsPackage = XmlElement.class.getPackage();
- for (Annotation annotation : annotations) {
- if (annotation.annotationType().getPackage() == jaxbAnnotationsPackage) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * The TypeReference class is a sun specific class that is found in two different
- * locations depending on environment. In IBM JDK the class is not available at all.
- * So we have to load it at runtime.
- *
- * @param n
- * @param cls
- * @return initiated TypeReference
- */
- private static Object createTypeReference(QName n, Class<?> cls) {
- Class<?> refClass = null;
- try {
- refClass = ClassLoaderUtils.loadClass("com.sun.xml.bind.api.TypeReference",
- JAXBContextInitializer.class);
- } catch (Throwable ex) {
- try {
- refClass = ClassLoaderUtils.loadClass("com.sun.xml.internal.bind.api.TypeReference",
- JAXBContextInitializer.class);
- } catch (Throwable ex2) {
- //ignore
- }
- }
- if (refClass != null) {
- try {
- return refClass.getConstructor(QName.class, Type.class, new Annotation[0].getClass()) //NOPMD
- .newInstance(n, cls, new Annotation[0]);
- } catch (Throwable e) {
- //ignore
- }
- }
- return null;
- }
-
- @SuppressWarnings("unused")
- private Object createFactory(Class<?> cls, Constructor<?> contructor) {
- String newClassName = cls.getName() + "Factory";
- ASMHelper helper = new ASMHelper();
- ClassWriter cw = helper.createClassWriter();
- MethodVisitor mv;
-
- cw.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER,
- ASMHelper.periodToSlashes(newClassName), null, "java/lang/Object", null);
-
- cw.visitSource(cls.getSimpleName() + "Factory" + ".java", null);
-
- mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(Opcodes.ALOAD, 0);
- mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
- mv.visitInsn(Opcodes.RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
-
- mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "create" + cls.getSimpleName(),
- "()L" + ASMHelper.periodToSlashes(cls.getName()) + ";", null, null);
- mv.visitCode();
- String name = cls.getName().replace(".", "/");
- mv.visitTypeInsn(Opcodes.NEW, name);
- mv.visitInsn(Opcodes.DUP);
- StringBuilder paraString = new StringBuilder(32).append("(");
-
- for (Class<?> paraClass : contructor.getParameterTypes()) {
- mv.visitInsn(Opcodes.ACONST_NULL);
- paraString.append("Ljava/lang/Object;");
- }
- paraString.append(")V");
-
- mv.visitMethodInsn(Opcodes.INVOKESPECIAL, name, "<init>", paraString.toString(), false);
-
- mv.visitInsn(Opcodes.ARETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
-
- cw.visitEnd();
- Class<?> factoryClass = helper.loadClass(newClassName, cls, cw.toByteArray());
- try {
- return factoryClass.newInstance();
- } catch (Exception e) {
- //ignore
- }
- return null;
- }
-
-
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/apache/openjpa/enhance/PCClassFileTransformer.java b/jakarta/src/patch/java/org/apache/openjpa/enhance/PCClassFileTransformer.java
deleted file mode 100644
index ee2cdac..0000000
--- a/jakarta/src/patch/java/org/apache/openjpa/enhance/PCClassFileTransformer.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * 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.openjpa.enhance;
-
-import java.io.ByteArrayInputStream;
-import java.lang.instrument.ClassFileTransformer;
-import java.lang.instrument.IllegalClassFormatException;
-import java.security.AccessController;
-import java.security.ProtectionDomain;
-import java.util.Set;
-
-import org.apache.openjpa.conf.OpenJPAConfiguration;
-import org.apache.openjpa.lib.log.Log;
-import org.apache.openjpa.lib.util.J2DoPrivHelper;
-import org.apache.openjpa.lib.util.Localizer;
-import org.apache.openjpa.lib.util.Options;
-import org.apache.openjpa.meta.MetaDataRepository;
-import org.apache.openjpa.util.GeneralException;
-
-import serp.bytecode.BCClass;
-import serp.bytecode.Project;
-import serp.bytecode.lowlevel.ConstantPoolTable;
-
-
-/**
- * Transformer that makes persistent classes implement the
- * {@link PersistenceCapable} interface at runtime.
- *
- * @author Abe White
- */
-public class PCClassFileTransformer
- implements ClassFileTransformer {
-
- private static final Localizer _loc = Localizer.forPackage
- (PCClassFileTransformer.class);
-
- private final MetaDataRepository _repos;
- private final PCEnhancer.Flags _flags;
- private final ClassLoader _tmpLoader;
- private final Log _log;
- private final Set _names;
- private boolean _transforming = false;
-
- /**
- * Constructor.
- *
- * @param repos metadata repository to use internally
- * @param opts enhancer configuration options
- * @param loader temporary class loader for loading intermediate classes
- */
- public PCClassFileTransformer(MetaDataRepository repos, Options opts,
- ClassLoader loader) {
- this(repos, toFlags(opts), loader, opts.removeBooleanProperty
- ("scanDevPath", "ScanDevPath", false));
- }
-
- /**
- * Create enhancer flags from the given options.
- */
- private static PCEnhancer.Flags toFlags(Options opts) {
- PCEnhancer.Flags flags = new PCEnhancer.Flags();
- flags.addDefaultConstructor = opts.removeBooleanProperty
- ("addDefaultConstructor", "AddDefaultConstructor",
- flags.addDefaultConstructor);
- flags.enforcePropertyRestrictions = opts.removeBooleanProperty
- ("enforcePropertyRestrictions", "EnforcePropertyRestrictions",
- flags.enforcePropertyRestrictions);
- return flags;
- }
-
- /**
- * Constructor.
- *
- * @param repos metadata repository to use internally
- * @param flags enhancer configuration
- * @param tmpLoader temporary class loader for loading intermediate classes
- * @param devscan whether to scan the dev classpath for persistent types
- * if none are configured
- */
- public PCClassFileTransformer(MetaDataRepository repos,
- PCEnhancer.Flags flags, ClassLoader tmpLoader, boolean devscan) {
- _repos = repos;
- _tmpLoader = tmpLoader;
-
- _log = repos.getConfiguration().
- getLog(OpenJPAConfiguration.LOG_ENHANCE);
- _flags = flags;
-
- _names = repos.getPersistentTypeNames(devscan, tmpLoader);
- if (_names == null && _log.isInfoEnabled())
- _log.info(_loc.get("runtime-enhance-pcclasses"));
- }
-
- @Override
- public byte[] transform(ClassLoader loader, String className,
- Class redef, ProtectionDomain domain, byte[] bytes)
- throws IllegalClassFormatException {
- if (loader == _tmpLoader)
- return null;
-
- // JDK bug -- OPENJPA-1676
- if (className == null) {
- return null;
- }
- // prevent re-entrant calls, which can occur if the enhancing
- // loader is used to also load OpenJPA libraries; this is to prevent
- // recursive enhancement attempts for internal openjpa libraries
- if (_transforming)
- return null;
-
- _transforming = true;
-
- return transform0(className, redef, bytes);
- }
-
- /**
- * We have to split the transform method into two methods to avoid
- * ClassCircularityError when executing method using pure-JIT JVMs
- * such as JRockit.
- */
- private byte[] transform0(String className, Class redef, byte[] bytes)
- throws IllegalClassFormatException {
-
- byte[] returnBytes = null;
- try {
- Boolean enhance = needsEnhance(className, redef, bytes);
- if (enhance != null && _log.isTraceEnabled())
- _log.trace(_loc.get("needs-runtime-enhance", className,
- enhance));
- if (enhance != Boolean.TRUE)
- return null;
-
- ClassLoader oldLoader = AccessController.doPrivileged(J2DoPrivHelper.getContextClassLoaderAction());
- AccessController.doPrivileged(J2DoPrivHelper.setContextClassLoaderAction(_tmpLoader));
- try {
- PCEnhancer enhancer = new PCEnhancer(_repos.getConfiguration(),
- new Project().loadClass(new ByteArrayInputStream(bytes),
- _tmpLoader), _repos);
- enhancer.setAddDefaultConstructor(_flags.addDefaultConstructor);
- enhancer.setEnforcePropertyRestrictions
- (_flags.enforcePropertyRestrictions);
-
- if (enhancer.run() == PCEnhancer.ENHANCE_NONE)
- return null;
- BCClass pcb = enhancer.getPCBytecode();
- returnBytes = AsmAdaptor.toByteArray(pcb, pcb.toByteArray());
- return returnBytes;
- } finally {
- AccessController.doPrivileged(J2DoPrivHelper.setContextClassLoaderAction(oldLoader));
- }
- } catch (Throwable t) {
- _log.warn(_loc.get("cft-exception-thrown", className), t);
- if (t instanceof RuntimeException)
- throw (RuntimeException) t;
- if (t instanceof IllegalClassFormatException)
- throw (IllegalClassFormatException) t;
- throw new GeneralException(t);
- } finally {
- _transforming = false;
- if (returnBytes != null && _log.isTraceEnabled())
- _log.trace(_loc.get("runtime-enhance-complete", className,
- bytes.length, returnBytes.length));
- }
- }
-
- /**
- * Return whether the given class needs enhancement.
- */
- private Boolean needsEnhance(String clsName, Class redef, byte[] bytes) {
- if (redef != null) {
- Class[] intfs = redef.getInterfaces();
- for (int i = 0; i < intfs.length; i++)
- if (PersistenceCapable.class.getName().
- equals(intfs[i].getName()))
- return Boolean.valueOf(!isEnhanced(bytes));
- return null;
- }
-
- if (_names != null) {
- if (_names.contains(clsName.replace('/', '.')))
- return Boolean.valueOf(!isEnhanced(bytes));
- return null;
- }
-
- if (clsName.startsWith("java/") || clsName.startsWith("javax/") || clsName.startsWith("jakarta/"))
- return null;
- if (isEnhanced(bytes))
- return Boolean.FALSE;
-
- try {
- Class c = Class.forName(clsName.replace('/', '.'), false,
- _tmpLoader);
- if (_repos.getMetaData(c, null, false) != null)
- return Boolean.TRUE;
- return null;
- } catch (ClassNotFoundException cnfe) {
- // cannot load the class: this might mean that it is a proxy
- // or otherwise inaccessible class which can't be an entity
- return Boolean.FALSE;
- } catch (LinkageError cce) {
- // this can happen if we are loading classes that this
- // class depends on; these will never be enhanced anyway
- return Boolean.FALSE;
- } catch (RuntimeException re) {
- throw re;
- } catch (Throwable t) {
- throw new GeneralException(t);
- }
- }
-
- /**
- * Analyze the bytecode to see if the given class definition implements
- * {@link PersistenceCapable}.
- */
- private static boolean isEnhanced(byte[] b) {
- if (AsmAdaptor.use())
- {
- return AsmAdaptor.isEnhanced(b);
- }
-
- ConstantPoolTable table = new ConstantPoolTable(b);
- int idx = table.getEndIndex();
-
- idx += 6; // skip access, cls, super
- int ifaces = table.readUnsignedShort(idx);
- int clsEntry, utfEntry;
- String name;
- for (int i = 0; i < ifaces; i++) {
- idx += 2;
- clsEntry = table.readUnsignedShort(idx);
- utfEntry = table.readUnsignedShort(table.get(clsEntry));
- name = table.readString(table.get(utfEntry));
- if ("org/apache/openjpa/enhance/PersistenceCapable".equals(name))
- return true;
- }
- return false;
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/apache/openjpa/lib/meta/ClassMetaDataIterator.java b/jakarta/src/patch/java/org/apache/openjpa/lib/meta/ClassMetaDataIterator.java
deleted file mode 100644
index b972512..0000000
--- a/jakarta/src/patch/java/org/apache/openjpa/lib/meta/ClassMetaDataIterator.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * 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.openjpa.lib.meta;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URL;
-import java.net.URLDecoder;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.NoSuchElementException;
-
-import org.apache.openjpa.lib.util.ClassUtil;
-import org.apache.openjpa.lib.util.J2DoPrivHelper;
-import org.apache.openjpa.lib.util.MultiClassLoader;
-
-/**
- * Iterator over all metadata resources that might contain the
- * metadata for a given class, starting with the most general. Assumes that
- * package-level resources are named "package.<suffix>".
- *
- * @author Abe White
- */
-public class ClassMetaDataIterator implements MetaDataIterator {
-
- private final ClassLoader _loader;
- private final List<String> _locs;
- private int _loc = -1;
- private final List<URL> _urls = new ArrayList<>(3);
- private int _url = -1;
-
- /**
- * Constructor; supply the class whose metadata to find, the suffix
- * of metadata files, and whether to parse top-down or bottom-up.
- */
- public ClassMetaDataIterator(Class<?> cls, String suffix, boolean topDown) {
- this(cls, suffix, null, topDown);
- }
-
- /**
- * Constructor; supply the class whose metadata to find, the suffix
- * of metadata files, and whether to parse top-down or bottom-up.
- */
- public ClassMetaDataIterator(Class<?> cls, String suffix,
- ClassLoader loader, boolean topDown) {
- // skip classes that can't have metadata
- if (cls != null && (cls.isPrimitive()
- || cls.getName().startsWith("java.")
- || cls.getName().startsWith("javax.")
- || cls.getName().startsWith("jakarta."))) {
- _loader = null;
- _locs = Collections.emptyList();
- return;
- }
-
- if (loader == null) {
- MultiClassLoader multi = AccessController
- .doPrivileged(J2DoPrivHelper.newMultiClassLoaderAction());
- multi.addClassLoader(MultiClassLoader.SYSTEM_LOADER);
- multi.addClassLoader(MultiClassLoader.THREAD_LOADER);
- multi.addClassLoader(getClass().getClassLoader());
- if (cls != null)
- {
- ClassLoader clsLoader = (ClassLoader)
- AccessController.doPrivileged(
- J2DoPrivHelper.getClassLoaderAction(cls));
- if (clsLoader != null)
- multi.addClassLoader(clsLoader);
- }
- loader = multi;
- }
- _loader = loader;
-
- // collect the set of all possible metadata locations; start with
- // system locations
- _locs = new ArrayList<>();
- _locs.add("META-INF/package" + suffix);
- _locs.add("WEB-INF/package" + suffix);
- _locs.add("package" + suffix);
-
- // put this legacy location at the end regardless of whether we're
- // going top down or bottom up so we don't have to parse it as often
- // during testing
- if (!topDown)
- _locs.add("system" + suffix);
-
- if (cls != null) {
- // also check:
- // 1. for each package from the top down to cls' package:
- // <path>/package<suffix>
- // <path>/<package-name><suffix> (legacy support)
- // <path>/../<package-name><suffix> (legacy support)
- // 2. <path>/<class-name><suffix>
- String pkg = ClassUtil.getPackageName(cls).replace('.', '/');
- if (pkg.length() > 0) {
- int idx, start = 0;
- String pkgName, path, upPath = "";
- do {
- idx = pkg.indexOf('/', start);
- if (idx == -1) {
- pkgName = (start == 0) ? pkg : pkg.substring(start);
- path = pkg + "/";
- } else {
- pkgName = pkg.substring(start, idx);
- path = pkg.substring(0, idx + 1);
- }
-
- _locs.add(path + "package" + suffix);
- _locs.add(path + pkgName + suffix); // legacy
- _locs.add(upPath + pkgName + suffix); // legacy
- if (idx == -1)
- _locs.add(path + ClassUtil.getClassName(cls) + suffix);
-
- start = idx + 1;
- upPath = path;
- }
- while (idx != -1);
- } else {
- // <class-name><suffix> for top-level classes
- _locs.add(cls.getName() + suffix);
- }
- }
- if (topDown)
- _locs.add("system" + suffix); // legacy
- else
- Collections.reverse(_locs);
- }
-
- @Override
- public boolean hasNext() throws IOException {
- Enumeration<URL> e;
- while (_url + 1 >= _urls.size()) {
- if (++_loc >= _locs.size())
- return false;
-
- _url = -1;
- _urls.clear();
- try {
- e = AccessController.doPrivileged(
- J2DoPrivHelper.getResourcesAction(
- _loader, _locs.get(_loc)));
- } catch (PrivilegedActionException pae) {
- throw (IOException) pae.getException();
- }
- while (e.hasMoreElements())
- _urls.add(e.nextElement());
- }
- return true;
- }
-
- @Override
- public URL next() throws IOException {
- if (!hasNext())
- throw new NoSuchElementException();
- return _urls.get(++_url);
- }
-
- @Override
- public InputStream getInputStream() throws IOException {
- if (_url == -1 || _url >= _urls.size())
- throw new IllegalStateException();
- try {
- return AccessController.doPrivileged(
- J2DoPrivHelper.openStreamAction(_urls.get(_url)));
- } catch (PrivilegedActionException pae) {
- throw (IOException) pae.getException();
- }
- }
-
- @Override
- public File getFile() throws IOException {
- if (_url == -1 || _url >= _urls.size())
- throw new IllegalStateException();
- File file = new File(URLDecoder.decode((_urls.get(_url)).getFile()));
- return ((AccessController.doPrivileged(
- J2DoPrivHelper.existsAction(file))).booleanValue()) ? file:null;
- }
-
- @Override
- public void close() {
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/apache/openjpa/lib/util/TemporaryClassLoader.java b/jakarta/src/patch/java/org/apache/openjpa/lib/util/TemporaryClassLoader.java
deleted file mode 100644
index dc5a93c..0000000
--- a/jakarta/src/patch/java/org/apache/openjpa/lib/util/TemporaryClassLoader.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * 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.openjpa.lib.util;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-import serp.bytecode.lowlevel.ConstantPoolTable;
-
-/**
- * ClassLoader implementation that allows classes to be temporarily
- * loaded and then thrown away. Useful for the enhancer to be able
- * to run against a class without first loading(and thus polluting)
- * the parent ClassLoader.
- *
- * @author Marc Prud'hommeaux
- */
-public class TemporaryClassLoader extends ClassLoader {
-
- public TemporaryClassLoader(ClassLoader parent) {
- super(parent);
- }
-
- @Override
- public Class loadClass(String name) throws ClassNotFoundException {
- return loadClass(name, false);
- }
-
- @Override
- protected Class loadClass(String name, boolean resolve)
- throws ClassNotFoundException {
- // see if we've already loaded it
- Class c = findLoadedClass(name);
- if (c != null)
- return c;
-
- // bug #283. defer to system if the name is a protected name.
- // "sun." is required for JDK 1.4, which has an access check for
- // sun.reflect.GeneratedSerializationConstructorAccessor1
- if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("jakarta.")
- || name.startsWith("sun.") || name.startsWith("jdk.")) {
- return Class.forName(name, resolve, getClass().getClassLoader());
- }
-
- String resourceName = name.replace('.', '/') + ".class";
- InputStream resource = getResourceAsStream(resourceName);
- if (resource == null) {
- throw new ClassNotFoundException(name);
- }
-
- ByteArrayOutputStream bout = new ByteArrayOutputStream();
- byte[] b = new byte[1024];
- try {
- for (int n = 0; (n = resource.read(b, 0, b.length)) != -1;
- bout.write(b, 0, n))
- ;
- byte[] classBytes = bout.toByteArray();
- // To avoid classloader issues with the JVM (Sun and IBM), we
- // will not load Enums via the TemporaryClassLoader either.
- // Reference JIRA Issue OPENJPA-646 for more information.
- if (isAnnotation(classBytes) || isEnum(classBytes)) {
- try {
- Class<?> frameworkClass = Class.forName(name, resolve,
- getClass().getClassLoader());
- return frameworkClass;
- } catch (ClassNotFoundException e) {
- // OPENJPA-1121 continue, as it must be a user-defined class
- }
- }
-
- try {
- return defineClass(name, classBytes, 0, classBytes.length);
- } catch (SecurityException e) {
- // possible prohibited package: defer to the parent
- return super.loadClass(name, resolve);
- }
- } catch (IOException ioe) {
- // defer to the parent
- return super.loadClass(name, resolve);
- }
- }
-
- /**
- * Fast-parse the given class bytecode to determine if it is an
- * annotation class.
- */
- private static boolean isAnnotation(byte[] b) {
- if (JavaVersions.VERSION < 5)
- return false;
- int idx = ConstantPoolTable.getEndIndex(b);
- int access = ConstantPoolTable.readUnsignedShort(b, idx);
- return (access & 0x2000) != 0; // access constant for annotation type
- }
-
- /**
- * Fast-parse the given class bytecode to determine if it is an
- * enum class.
- */
- private static boolean isEnum(byte[] b) {
- if (JavaVersions.VERSION < 5)
- return false;
- int idx = ConstantPoolTable.getEndIndex(b);
- int access = ConstantPoolTable.readUnsignedShort(b, idx);
- return (access & 0x4000) != 0; // access constant for enum type
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/apache/openjpa/meta/AbstractMetaDataDefaults.java b/jakarta/src/patch/java/org/apache/openjpa/meta/AbstractMetaDataDefaults.java
deleted file mode 100644
index 03cd4fc..0000000
--- a/jakarta/src/patch/java/org/apache/openjpa/meta/AbstractMetaDataDefaults.java
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
- * 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.openjpa.meta;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Member;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.security.PrivilegedActionException;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.apache.openjpa.enhance.PCRegistry;
-import org.apache.openjpa.lib.log.Log;
-import org.apache.openjpa.lib.util.Localizer;
-import org.apache.openjpa.util.OpenJPAException;
-import org.apache.openjpa.util.UserException;
-
-/**
- * Abstract implementation provides a set of generic utilities for detecting
- * persistence meta-data of Field/Member. Also provides bean-style properties
- * such as access style or identity type to be used by default when such
- * information is not derivable from available meta-data.
- *
- * @author Abe White
- * @author Pinaki Poddar
- */
-public abstract class AbstractMetaDataDefaults
- implements MetaDataDefaults {
-
- private static final Localizer _loc = Localizer.forPackage
- (AbstractMetaDataDefaults.class);
-
- private int _access = AccessCode.FIELD;
- private int _identity = ClassMetaData.ID_UNKNOWN;
- private boolean _ignore = true;
- private boolean _interface = true;
- private boolean _pcRegistry = true;
- private int _callback = CALLBACK_RETHROW;
- private boolean _unwrapped = false;
-
- /**
- * Whether to attempt to use the information from registered classes
- * to populate metadata defaults. Defaults to true.
- */
- public boolean getUsePCRegistry() {
- return _pcRegistry;
- }
-
- /**
- * Whether to attempt to use the information from registered classes
- * to populate metadata defaults. Defaults to true.
- */
- public void setUsePCRegistry(boolean pcRegistry) {
- _pcRegistry = pcRegistry;
- }
-
- /**
- * The default access type for base classes with ACCESS_UNKNOWN.
- * ACCESS_FIELD by default.
- */
- @Override
- public int getDefaultAccessType() {
- return _access;
- }
-
- /**
- * The default access type for base classes with ACCESS_UNKNOWN.
- * ACCESS_FIELD by default.
- */
- public void setDefaultAccessType(int access) {
- _access = access;
- }
-
- /**
- * The default identity type for unmapped classes without primary
- * key fields. ID_UNKNOWN by default.
- */
- @Override
- public int getDefaultIdentityType() {
- return _identity;
- }
-
- /**
- * The default identity type for unmapped classes without primary
- * key fields. ID_UNKNOWN by default.
- */
- public void setDefaultIdentityType(int identity) {
- _identity = identity;
- }
-
- @Override
- public int getCallbackMode() {
- return _callback;
- }
-
- public void setCallbackMode(int mode) {
- _callback = mode;
- }
-
- public void setCallbackMode(int mode, boolean on) {
- if (on)
- _callback |= mode;
- else
- _callback &= ~mode;
- }
-
- @Override
- public boolean getCallbacksBeforeListeners(int type) {
- return false;
- }
-
- @Override
- public boolean isDeclaredInterfacePersistent() {
- return _interface;
- }
-
- public void setDeclaredInterfacePersistent(boolean pers) {
- _interface = pers;
- }
-
- @Override
- public boolean isDataStoreObjectIdFieldUnwrapped() {
- return _unwrapped;
- }
-
- public void setDataStoreObjectIdFieldUnwrapped(boolean unwrapped) {
- _unwrapped = unwrapped;
- }
-
- public boolean getIgnoreNonPersistent() {
- return _ignore;
- }
-
- @Override
- public void setIgnoreNonPersistent(boolean ignore) {
- _ignore = ignore;
- }
-
- @Override
- public void populate(ClassMetaData meta, int access) {
- populate(meta, access, false);
- }
-
- @Override
- public void populate(ClassMetaData meta, int access, boolean ignoreTransient) {
- if (meta.getDescribedType() == Object.class)
- return;
- meta.setAccessType(access);
-
- Log log = meta.getRepository().getLog();
- if (log.isTraceEnabled())
- log.trace(_loc.get("gen-meta", meta));
- if (!_pcRegistry || !populateFromPCRegistry(meta)) {
- if (log.isTraceEnabled())
- log.trace(_loc.get("meta-reflect"));
- populateFromReflection(meta, ignoreTransient);
- }
- }
-
- /**
- * Populate the given metadata using the {@link PCRegistry}.
- */
- private boolean populateFromPCRegistry(ClassMetaData meta) {
- Class<?> cls = meta.getDescribedType();
- if (!PCRegistry.isRegistered(cls))
- return false;
- try {
- String[] fieldNames = PCRegistry.getFieldNames(cls);
- Class<?>[] fieldTypes = PCRegistry.getFieldTypes(cls);
- Member member;
- FieldMetaData fmd;
- for (int i = 0; i < fieldNames.length; i ++) {
- String property = fieldNames[i];
- member = getMemberByProperty(meta, property,
- AccessCode.UNKNOWN, true);
- if (member == null) // transient or indeterminable access
- continue;
- fmd = meta.addDeclaredField(property, fieldTypes[i]);
- fmd.backingMember(member);
- populate(fmd);
- }
- return true;
- } catch (OpenJPAException ke) {
- throw ke;
- } catch (Exception e) {
- if (e instanceof PrivilegedActionException)
- e = ((PrivilegedActionException) e).getException();
- throw new UserException(e);
- }
- }
-
- protected abstract List<Member> getPersistentMembers(ClassMetaData meta, boolean ignoreTransient);
- /**
- * Generate the given meta-data using reflection.
- * Adds FieldMetaData for each persistent state.
- * Delegate to concrete implementation to determine the persistent
- * members.
- */
- private void populateFromReflection(ClassMetaData meta, boolean ignoreTransient) {
- List<Member> members = getPersistentMembers(meta, ignoreTransient);
- boolean iface = meta.getDescribedType().isInterface();
- // If access is mixed or if the default is currently unknown,
- // process all fields, otherwise only process members of the class
- // level default access type.
-
- String name;
- boolean def;
- FieldMetaData fmd;
- for (int i = 0; i < members.size(); i++) {
- Member member = members.get(i);
- name = getFieldName(member);
- if (name == null || isReservedFieldName(name))
- continue;
-
- def = isDefaultPersistent(meta, member, name, ignoreTransient);
- if (!def && _ignore)
- continue;
-
- // passed the tests; persistent type -- we construct with
- // Object.class because setting backing member will set proper
- // type anyway
- fmd = meta.addDeclaredField(name, Object.class);
- fmd.backingMember(member);
- if (!def) {
- fmd.setExplicit(true);
- fmd.setManagement(FieldMetaData.MANAGE_NONE);
- }
- populate(fmd);
- }
- }
-
- protected void populate(FieldMetaData fmd) {
-
- }
-
- /**
- * Return the list of fields in <code>meta</code> that use field access,
- * or <code>null</code> if a list of fields is unobtainable. An empty list
- * should be returned if the list of fields is obtainable, but there
- * happens to be no field access in <code>meta</code>.
- *
- * This is used for error reporting purposes only, so need not be efficient.
- *
- * This implementation returns <code>null</code>.
- */
- protected List<String> getFieldAccessNames(ClassMetaData meta) {
- return null;
- }
-
- /**
- * Return the list of methods in <code>meta</code> that use property access,
- * or <code>null</code> if a list of methods is unobtainable. An empty list
- * should be returned if the list of methods is obtainable, but there
- * happens to be no property access in <code>meta</code>.
- *
- * This is used for error reporting purposes only, so need not be efficient.
- *
- * This implementation returns <code>null</code>.
- */
- protected List<String> getPropertyAccessNames(ClassMetaData meta) {
- return null;
- }
-
- /**
- * Return the field name for the given member. This will only be invoked
- * on members of the right type (field vs. method). Return null if the
- * member cannot be managed. Default behavior: For fields, returns the
- * field name. For getter methods, returns the minus "get" or "is" with
- * the next letter lower-cased. For other methods, returns null.
- */
- public static String getFieldName(Member member) {
- if (member instanceof Field)
- return member.getName();
- if (member instanceof Method == false)
- return null;
- Method method = (Method) member;
- String name = method.getName();
- if (isNormalGetter(method))
- name = name.substring("get".length());
- else if (isBooleanGetter(method))
- name = name.substring("is".length());
- else
- return null;
-
- if (name.length() == 1)
- return name.toLowerCase();
- return Character.toLowerCase(name.charAt(0)) + name.substring(1);
- }
-
- /**
- * Returns true if the given field name is reserved for unmanaged fields.
- */
- protected boolean isReservedFieldName(String name) {
- // names used by enhancers
- return name.startsWith("openjpa") || name.startsWith("jdo");
- }
-
- /**
- * Return true if the given member is persistent by default. This will
- * only be invoked on members of the right type (field vs. method).
- * Returns false if member is static or final by default.
- *
- * @param name the field name from {@link #getFieldName}
- */
- protected abstract boolean isDefaultPersistent(ClassMetaData meta,
- Member member, String name, boolean ignoreTransient);
-
- /**
- * Gets the backing member of the given field. If the field has not been
- * assigned a backing member then get either the instance field or the
- * getter method depending upon the access style of the defining class.
- * <br>
- * Defining class is used instead of declaring class because this method
- * may be invoked during parsing phase when declaring metadata may not be
- * available.
- */
- @Override
- public Member getBackingMember(FieldMetaData fmd) {
- if (fmd == null)
- return null;
- if (fmd.getBackingMember() != null)
- return fmd.getBackingMember();
- return getMemberByProperty(fmd.getDeclaringMetaData(), fmd.getName(),
- fmd.getAccessType(), true);
- }
-
- @Override
- public Class<?> getUnimplementedExceptionType() {
- return UnsupportedOperationException.class;
- }
-
- /**
- * Helper method; returns true if the given class appears to be
- * user-defined.
- */
- protected static boolean isUserDefined(Class<?> cls) {
- return cls != null && !cls.getName().startsWith("java.")
- && !cls.getName().startsWith ("javax.")
- && !cls.getName().startsWith ("jakarta.");
- }
-
- /**
- * Affirms if the given method matches the following signature
- * <code> public T getXXX() </code>
- * where T is any non-void type.
- */
- public static boolean isNormalGetter(Method method) {
- String methodName = method.getName();
- return startsWith(methodName, "get")
- && method.getParameterTypes().length == 0
- && method.getReturnType() != void.class;
- }
-
- /**
- * Affirms if the given method matches the following signature
- * <code> public boolean isXXX() </code>
- * <code> public Boolean isXXX() </code>
- */
- public static boolean isBooleanGetter(Method method) {
- String methodName = method.getName();
- return startsWith(methodName, "is")
- && method.getParameterTypes().length == 0
- && isBoolean(method.getReturnType());
- }
-
- /**
- * Affirms if the given method signature matches bean-style getter method
- * signature.<br>
- * <code> public T getXXX()</code> where T is any non-void type.<br>
- * or<br>
- * <code> public T isXXX()</code> where T is boolean or Boolean.<br>
- */
- public static boolean isGetter(Method method, boolean includePrivate) {
- if (method == null)
- return false;
- int mods = method.getModifiers();
- if (!(Modifier.isPublic(mods)
- || Modifier.isProtected(mods)
- || (Modifier.isPrivate(mods) && includePrivate))
- || Modifier.isNative(mods)
- || Modifier.isStatic(mods))
- return false;
- return isNormalGetter(method) || isBooleanGetter(method);
- }
-
- /**
- * Affirms if the given full string starts with the given head.
- */
- public static boolean startsWith(String full, String head) {
- return full != null && head != null && full.startsWith(head)
- && full.length() > head.length();
- }
-
- public static boolean isBoolean(Class<?> cls) {
- return cls == boolean.class || cls == Boolean.class;
- }
-
- public static List<String> toNames(List<? extends Member> members) {
- List<String> result = new ArrayList<>();
- for (Member m : members)
- result.add(m.getName());
- return result;
- }
-
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/apache/tomcat/util/modeler/modules/MbeansDescriptorsIntrospectionSource.java b/jakarta/src/patch/java/org/apache/tomcat/util/modeler/modules/MbeansDescriptorsIntrospectionSource.java
deleted file mode 100644
index 0c59207..0000000
--- a/jakarta/src/patch/java/org/apache/tomcat/util/modeler/modules/MbeansDescriptorsIntrospectionSource.java
+++ /dev/null
@@ -1,392 +0,0 @@
-/*
- * 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.tomcat.util.modeler.modules;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Enumeration;
-import java.util.Hashtable;
-import java.util.List;
-import java.util.Map.Entry;
-
-import javax.management.ObjectName;
-
-import org.apache.juli.logging.Log;
-import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.util.modeler.AttributeInfo;
-import org.apache.tomcat.util.modeler.ManagedBean;
-import org.apache.tomcat.util.modeler.OperationInfo;
-import org.apache.tomcat.util.modeler.ParameterInfo;
-import org.apache.tomcat.util.modeler.Registry;
-
-public class MbeansDescriptorsIntrospectionSource extends ModelerSource
-{
- private static final Log log = LogFactory.getLog(MbeansDescriptorsIntrospectionSource.class);
-
- private Registry registry;
- private String type;
- private final List<ObjectName> mbeans = new ArrayList<>();
-
- public void setRegistry(Registry reg) {
- this.registry=reg;
- }
-
- /**
- * Used if a single component is loaded
- *
- * @param type The type
- */
- public void setType( String type ) {
- this.type=type;
- }
-
- public void setSource( Object source ) {
- this.source=source;
- }
-
- @Override
- public List<ObjectName> loadDescriptors(Registry registry, String type,
- Object source) throws Exception {
- setRegistry(registry);
- setType(type);
- setSource(source);
- execute();
- return mbeans;
- }
-
- public void execute() throws Exception {
- if( registry==null ) registry=Registry.getRegistry(null, null);
- try {
- ManagedBean managed = createManagedBean(registry, null,
- (Class<?>)source, type);
- if( managed==null ) return;
- managed.setName( type );
-
- registry.addManagedBean(managed);
-
- } catch( Exception ex ) {
- log.error(sm.getString("modules.readDescriptorsError"), ex);
- }
- }
-
-
-
- // ------------ Implementation for non-declared introspection classes
-
- private static final Hashtable<String,String> specialMethods = new Hashtable<>();
- static {
- specialMethods.put( "preDeregister", "");
- specialMethods.put( "postDeregister", "");
- }
-
- private static final Class<?>[] supportedTypes = new Class[] {
- Boolean.class,
- Boolean.TYPE,
- Byte.class,
- Byte.TYPE,
- Character.class,
- Character.TYPE,
- Short.class,
- Short.TYPE,
- Integer.class,
- Integer.TYPE,
- Long.class,
- Long.TYPE,
- Float.class,
- Float.TYPE,
- Double.class,
- Double.TYPE,
- String.class,
- String[].class,
- BigDecimal.class,
- BigInteger.class,
- ObjectName.class,
- Object[].class,
- java.io.File.class,
- };
-
- /**
- * Check if this class is one of the supported types.
- * If the class is supported, returns true. Otherwise,
- * returns false.
- * @param ret The class to check
- * @return boolean True if class is supported
- */
- private boolean supportedType(Class<?> ret) {
- for (Class<?> supportedType : supportedTypes) {
- if (ret == supportedType) {
- return true;
- }
- }
- if (isBeanCompatible(ret)) {
- return true;
- }
- return false;
- }
-
- /**
- * Check if this class conforms to JavaBeans specifications.
- * If the class is conformant, returns true.
- *
- * @param javaType The class to check
- * @return boolean True if the class is compatible.
- */
- private boolean isBeanCompatible(Class<?> javaType) {
- // Must be a non-primitive and non array
- if (javaType.isArray() || javaType.isPrimitive()) {
- return false;
- }
-
- // Anything in the java or javax package that
- // does not have a defined mapping is excluded.
- if (javaType.getName().startsWith("java.") ||
- javaType.getName().startsWith("javax.") ||
- javaType.getName().startsWith("jakarta.")) {
- return false;
- }
-
- try {
- javaType.getConstructor(new Class[]{});
- } catch (java.lang.NoSuchMethodException e) {
- return false;
- }
-
- // Make sure superclass is compatible
- Class<?> superClass = javaType.getSuperclass();
- if (superClass != null &&
- superClass != java.lang.Object.class &&
- superClass != java.lang.Exception.class &&
- superClass != java.lang.Throwable.class) {
- if (!isBeanCompatible(superClass)) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * Process the methods and extract 'attributes', methods, etc.
- *
- * @param realClass The class to process
- * @param methods The methods to process
- * @param attMap The attribute map (complete)
- * @param getAttMap The readable attributes map
- * @param setAttMap The settable attributes map
- * @param invokeAttMap The invokable attributes map
- */
- private void initMethods(Class<?> realClass, Method methods[], Hashtable<String,Method> attMap,
- Hashtable<String,Method> getAttMap, Hashtable<String,Method> setAttMap,
- Hashtable<String,Method> invokeAttMap) {
-
- for (Method method : methods) {
- String name = method.getName();
-
- if (Modifier.isStatic(method.getModifiers())) {
- continue;
- }
- if (!Modifier.isPublic(method.getModifiers())) {
- if (log.isDebugEnabled()) {
- log.debug("Not public " + method);
- }
- continue;
- }
- if (method.getDeclaringClass() == Object.class) {
- continue;
- }
- Class<?> params[] = method.getParameterTypes();
-
- if (name.startsWith("get") && params.length == 0) {
- Class<?> ret = method.getReturnType();
- if (!supportedType(ret)) {
- if (log.isDebugEnabled()) {
- log.debug("Unsupported type " + method);
- }
- continue;
- }
- name = unCapitalize(name.substring(3));
-
- getAttMap.put(name, method);
- // just a marker, we don't use the value
- attMap.put(name, method);
- } else if (name.startsWith("is") && params.length == 0) {
- Class<?> ret = method.getReturnType();
- if (Boolean.TYPE != ret) {
- if (log.isDebugEnabled()) {
- log.debug("Unsupported type " + method + " " + ret);
- }
- continue;
- }
- name = unCapitalize(name.substring(2));
-
- getAttMap.put(name, method);
- // just a marker, we don't use the value
- attMap.put(name, method);
-
- } else if (name.startsWith("set") && params.length == 1) {
- if (!supportedType(params[0])) {
- if (log.isDebugEnabled()) {
- log.debug("Unsupported type " + method + " " + params[0]);
- }
- continue;
- }
- name = unCapitalize(name.substring(3));
- setAttMap.put(name, method);
- attMap.put(name, method);
- } else {
- if (params.length == 0) {
- if (specialMethods.get(method.getName()) != null) {
- continue;
- }
- invokeAttMap.put(name, method);
- } else {
- boolean supported = true;
- for (Class<?> param : params) {
- if (!supportedType(param)) {
- supported = false;
- break;
- }
- }
- if (supported) {
- invokeAttMap.put(name, method);
- }
- }
- }
- }
- }
-
- /**
- * XXX Find if the 'className' is the name of the MBean or
- * the real class ( I suppose first )
- * XXX Read (optional) descriptions from a .properties, generated
- * from source
- * XXX Deal with constructors
- *
- * @param registry The Bean registry (not used)
- * @param domain The bean domain (not used)
- * @param realClass The class to analyze
- * @param type The bean type
- * @return ManagedBean The create MBean
- */
- public ManagedBean createManagedBean(Registry registry, String domain,
- Class<?> realClass, String type)
- {
- ManagedBean mbean= new ManagedBean();
-
- Method methods[]=null;
-
- Hashtable<String,Method> attMap = new Hashtable<>();
- // key: attribute val: getter method
- Hashtable<String,Method> getAttMap = new Hashtable<>();
- // key: attribute val: setter method
- Hashtable<String,Method> setAttMap = new Hashtable<>();
- // key: operation val: invoke method
- Hashtable<String,Method> invokeAttMap = new Hashtable<>();
-
- methods = realClass.getMethods();
-
- initMethods(realClass, methods, attMap, getAttMap, setAttMap, invokeAttMap );
-
- try {
-
- Enumeration<String> en = attMap.keys();
- while( en.hasMoreElements() ) {
- String name = en.nextElement();
- AttributeInfo ai=new AttributeInfo();
- ai.setName( name );
- Method gm = getAttMap.get(name);
- if( gm!=null ) {
- //ai.setGetMethodObj( gm );
- ai.setGetMethod( gm.getName());
- Class<?> t=gm.getReturnType();
- if( t!=null )
- ai.setType( t.getName() );
- }
- Method sm = setAttMap.get(name);
- if( sm!=null ) {
- //ai.setSetMethodObj(sm);
- Class<?> t = sm.getParameterTypes()[0];
- if( t!=null )
- ai.setType( t.getName());
- ai.setSetMethod( sm.getName());
- }
- ai.setDescription("Introspected attribute " + name);
- if( log.isDebugEnabled()) log.debug("Introspected attribute " +
- name + " " + gm + " " + sm);
- if( gm==null )
- ai.setReadable(false);
- if( sm==null )
- ai.setWriteable(false);
- if( sm!=null || gm!=null )
- mbean.addAttribute(ai);
- }
-
- // This map is populated by iterating the methods (which end up as
- // values in the Map) and obtaining the key from the value. It is
- // impossible for a key to be associated with a null value.
- for (Entry<String,Method> entry : invokeAttMap.entrySet()) {
- String name = entry.getKey();
- Method m = entry.getValue();
-
- OperationInfo op=new OperationInfo();
- op.setName(name);
- op.setReturnType(m.getReturnType().getName());
- op.setDescription("Introspected operation " + name);
- Class<?> parms[] = m.getParameterTypes();
- for(int i=0; i<parms.length; i++ ) {
- ParameterInfo pi=new ParameterInfo();
- pi.setType(parms[i].getName());
- pi.setName(("param" + i).intern());
- pi.setDescription(("Introspected parameter param" + i).intern());
- op.addParameter(pi);
- }
- mbean.addOperation(op);
- }
-
- if( log.isDebugEnabled())
- log.debug("Setting name: " + type );
- mbean.setName( type );
-
- return mbean;
- } catch( Exception ex ) {
- ex.printStackTrace();
- return null;
- }
- }
-
-
- // -------------------- Utils --------------------
- /**
- * Converts the first character of the given
- * String into lower-case.
- *
- * @param name The string to convert
- * @return String
- */
- private static String unCapitalize(String name) {
- if (name == null || name.length() == 0) {
- return name;
- }
- char chars[] = name.toCharArray();
- chars[0] = Character.toLowerCase(chars[0]);
- return new String(chars);
- }
-
-}
diff --git a/jakarta/src/patch/java/org/apache/webbeans/proxy/AbstractProxyFactory.java b/jakarta/src/patch/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
deleted file mode 100644
index eec5ba5..0000000
--- a/jakarta/src/patch/java/org/apache/webbeans/proxy/AbstractProxyFactory.java
+++ /dev/null
@@ -1,737 +0,0 @@
-/*
- * 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.webbeans.proxy;
-
-import static org.apache.xbean.asm7.ClassReader.SKIP_CODE;
-import static org.apache.xbean.asm7.ClassReader.SKIP_DEBUG;
-import static org.apache.xbean.asm7.ClassReader.SKIP_FRAMES;
-
-import java.io.InputStream;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Arrays;
-
-import org.apache.webbeans.config.WebBeansContext;
-import org.apache.webbeans.exception.ProxyGenerationException;
-import org.apache.webbeans.exception.WebBeansException;
-import org.apache.webbeans.spi.DefiningClassService;
-import org.apache.xbean.asm7.ClassReader;
-import org.apache.xbean.asm7.ClassWriter;
-import org.apache.xbean.asm7.MethodVisitor;
-import org.apache.xbean.asm7.Opcodes;
-import org.apache.xbean.asm7.Type;
-import org.apache.xbean.asm7.shade.commons.EmptyVisitor;
-
-/**
- * Base class for all OWB Proxy factories
- */
-public abstract class AbstractProxyFactory
-{
- public static final int MAX_CLASSLOAD_TRIES = 10000;
-
- /**
- * This is needed as the Modifier#VARARGS is not (yet) public.
- * Note that the bitcode is the same as Modifier#TRANSIENT.
- * But 'varargs' is only for methods, whereas 'transient' is only for fields.
- */
- public static final int MODIFIER_VARARGS = 0x00000080;
-
- protected final Unsafe unsafe;
-
- private final DefiningClassService definingService;
-
- protected WebBeansContext webBeansContext;
-
- private final int javaVersion;
-
-
- /**
- * The name of the field which stores the passivationID of the Bean this proxy serves.
- * This is needed in case the proxy gets de-serialized back into a JVM
- * which didn't have this bean loaded yet.
- */
- public static final String FIELD_BEAN_PASSIVATION_ID = "owbBeanPassivationId";
-
-
- protected AbstractProxyFactory(WebBeansContext webBeansContext)
- {
- this.webBeansContext = webBeansContext;
- javaVersion = determineDefaultJavaVersion();
- unsafe = new Unsafe();
- definingService = webBeansContext.getService(DefiningClassService.class);
- }
-
- private int determineDefaultJavaVersion()
- {
- String javaVersionProp = webBeansContext.getOpenWebBeansConfiguration().getGeneratorJavaVersion();
- if (javaVersionProp == null) // try to align on the runtime
- {
- javaVersionProp = System.getProperty("java.version");
- }
- if (javaVersionProp != null)
- {
- if (javaVersionProp.startsWith("1.8"))
- {
- return Opcodes.V1_8;
- }
- else if (javaVersionProp.startsWith("9") || javaVersionProp.startsWith("1.9"))
- {
- return Opcodes.V9;
- }
- else if (javaVersionProp.startsWith("10"))
- {
- return Opcodes.V10;
- }
- else if (javaVersionProp.startsWith("11"))
- {
- return Opcodes.V11;
- }
- else if (javaVersionProp.startsWith("12"))
- {
- return Opcodes.V12;
- }
- else if (javaVersionProp.startsWith("13"))
- {
- return Opcodes.V13;
- }
- else
- {
- try
- {
- final int i = Integer.parseInt(javaVersionProp);
- if (i > 13)
- {
- return Opcodes.V13 + (i - 13);
- }
- }
- catch (final NumberFormatException nfe)
- {
- // let's default
- }
- }
- }
-
- // the fallback is the lowest one to ensure it supports all possible classes of current environments
- return Opcodes.V1_8;
- }
-
-
- protected ClassLoader getProxyClassLoader(Class<?> beanClass)
- {
- if (definingService != null)
- {
- return definingService.getProxyClassLoader(beanClass);
- }
- return webBeansContext.getApplicationBoundaryService().getBoundaryClassLoader(beanClass);
- }
-
- /**
- * @return the marker interface which should be used for this proxy.
- */
- protected abstract Class getMarkerInterface();
-
- /**
- * generate the bytecode for creating the instance variables of the class
- */
- protected abstract void createInstanceVariables(ClassWriter cw, Class<?> classToProxy, String classFileName);
-
- /**
- * generate the bytecode for serialization.
- */
- protected abstract void createSerialisation(ClassWriter cw, String proxyClassFileName, Class<?> classToProxy, String classFileName);
-
- /**
- * Each of our interceptor/decorator proxies has exactly 1 constructor
- * which invokes the super ct + sets the delegation field.
- *
- * @param cw
- * @param classToProxy
- * @param classFileName
- * @throws org.apache.webbeans.exception.ProxyGenerationException
- */
- protected abstract void createConstructor(ClassWriter cw, String proxyClassFileName, Class<?> classToProxy, String classFileName, Constructor<?> injectConstructor)
- throws ProxyGenerationException;
-
- /**
- * generate the bytecode for invoking all intercepted methods
- */
- protected abstract void delegateInterceptedMethods(ClassLoader classLoader, ClassWriter cw, String proxyClassFileName, Class<?> classToProxy, Method[] interceptedMethods)
- throws ProxyGenerationException;
-
- /**
- * generate the bytecode for invoking all non-intercepted methods
- */
- protected abstract void delegateNonInterceptedMethods(ClassLoader classLoader, ClassWriter cw, String proxyClassFileName, Class<?> classToProxy, Method[] noninterceptedMethods)
- throws ProxyGenerationException;
-
- /**
- * Detect a free classname based on the given one
- * @param proxyClassName
- * @return
- */
- protected String getUnusedProxyClassName(ClassLoader classLoader, String proxyClassName)
- {
- proxyClassName = fixPreservedPackages(proxyClassName);
-
- String finalName = proxyClassName;
-
- for (int i = 0; i < MAX_CLASSLOAD_TRIES; i++)
- {
- try
- {
- finalName = proxyClassName + i;
- Class.forName(finalName, true, classLoader);
- }
- catch (ClassNotFoundException cnfe)
- {
- // this is exactly what we need!
- return finalName;
- }
- // otherwise we continue ;)
- }
-
- throw new WebBeansException("Unable to detect a free proxy class name based on: " + proxyClassName);
- }
-
- protected <T> String getSignedClassProxyName(final Class<T> classToProxy)
- {
- // avoid java.lang.SecurityException: class's signer information
- // does not match signer information of other classes in the same package
- return "org.apache.webbeans.custom.signed." + classToProxy.getName();
- }
-
- protected String fixPreservedPackages(String proxyClassName)
- {
- proxyClassName = fixPreservedPackage(proxyClassName, "java.");
- proxyClassName = fixPreservedPackage(proxyClassName, "javax.");
- proxyClassName = fixPreservedPackage(proxyClassName, "jakarta.");
- proxyClassName = fixPreservedPackage(proxyClassName, "sun.misc.");
-
- return proxyClassName;
- }
- /**
- * Detect if the provided className is in the forbidden package.
- * If so, move it to org.apache.webbeans.custom.
- * @param forbiddenPackagePrefix including the '.', e.g. 'javax.'
- */
- private String fixPreservedPackage(String className, String forbiddenPackagePrefix)
- {
- String fixedClassName = className;
-
- if (className.startsWith(forbiddenPackagePrefix))
- {
- fixedClassName = "org.apache.webbeans.custom." + className.substring(forbiddenPackagePrefix.length());
- }
-
- return fixedClassName;
- }
-
- protected <T> Class<T> createProxyClass(ClassLoader classLoader, String proxyClassName, Class<T> classToProxy,
- Method[] interceptedMethods, Method[] nonInterceptedMethods)
- throws ProxyGenerationException
- {
- return createProxyClass(classLoader, proxyClassName, classToProxy, interceptedMethods, nonInterceptedMethods, null);
- }
-
- /**
- * @param classLoader to use for creating the class in
- * @param classToProxy the class for which a subclass will get generated
- * @param interceptedMethods the list of intercepted or decorated business methods.
- * @param nonInterceptedMethods all methods which are <b>not</b> intercepted nor decorated and shall get delegated directly
- * @param <T>
- * @return the proxy class
- */
- protected <T> Class<T> createProxyClass(ClassLoader classLoader, String proxyClassName, Class<T> classToProxy,
- Method[] interceptedMethods, Method[] nonInterceptedMethods,
- Constructor<T> constructor)
- throws ProxyGenerationException
- {
- String proxyClassFileName = proxyClassName.replace('.', '/');
-
- byte[] proxyBytes = generateProxy(classLoader,
- classToProxy,
- proxyClassName,
- proxyClassFileName,
- sortOutDuplicateMethods(interceptedMethods),
- sortOutDuplicateMethods(nonInterceptedMethods),
- constructor);
-
- if (definingService != null)
- {
- return definingService.defineAndLoad(proxyClassName, proxyBytes, classToProxy);
- }
- return unsafe.defineAndLoadClass(classLoader, proxyClassName, proxyBytes);
- }
-
- private Method[] sortOutDuplicateMethods(Method[] methods)
- {
- if (methods == null || methods.length == 0)
- {
- return null;
- }
-
- ArrayList<Method> duplicates = new ArrayList<>();
-
- for (Method outer : methods)
- {
- for (Method inner : methods)
- {
- if (inner != outer
- && hasSameSignature(outer, inner)
- && !(duplicates.contains(outer) || duplicates.contains(inner)))
- {
- duplicates.add(inner);
- }
- }
- }
-
- ArrayList<Method> outsorted = new ArrayList<>(Arrays.asList(methods));
- outsorted.removeAll(duplicates);
- return outsorted.toArray(new Method[outsorted.size()]);
- }
-
- private boolean hasSameSignature(Method a, Method b)
- {
- return a.getName().equals(b.getName())
- && a.getReturnType().equals(b.getReturnType())
- && Arrays.equals(a.getParameterTypes(), b.getParameterTypes());
- }
-
- private byte[] generateProxy(ClassLoader classLoader, Class<?> classToProxy, String proxyClassName, String proxyClassFileName,
- Method[] interceptedMethods, Method[] nonInterceptedMethods, Constructor<?> constructor)
- throws ProxyGenerationException
- {
- ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
- String classFileName = classToProxy.getName().replace('.', '/');
-
- String[] interfaceNames = {Type.getInternalName(getMarkerInterface())};
- String superClassName = classFileName;
-
- if (classToProxy.isInterface())
- {
- interfaceNames = new String[]{Type.getInternalName(classToProxy), interfaceNames[0]};
- superClassName = Type.getInternalName(Object.class);
- }
-
- cw.visit(findJavaVersion(classToProxy), Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER + Opcodes.ACC_SYNTHETIC, proxyClassFileName, null, superClassName, interfaceNames);
- cw.visitSource(classFileName + ".java", null);
-
- createInstanceVariables(cw, classToProxy, classFileName);
- createSerialisation(cw, proxyClassFileName, classToProxy, classFileName);
-
-
-
- // create a static String Field which contains the passivationId of the Bean or null if not PassivationCapable
- cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC,
- FIELD_BEAN_PASSIVATION_ID, Type.getDescriptor(String.class), null, null).visitEnd();
-
- createConstructor(cw, proxyClassFileName, classToProxy, classFileName, constructor);
-
-
- if (nonInterceptedMethods != null)
- {
- delegateNonInterceptedMethods(classLoader, cw, proxyClassFileName, classToProxy, nonInterceptedMethods);
- }
-
- if (interceptedMethods != null)
- {
- delegateInterceptedMethods(classLoader, cw, proxyClassFileName, classToProxy, interceptedMethods);
- }
-
- return cw.toByteArray();
- }
-
- private int findJavaVersion(final Class<?> from)
- {
- final String resource = from.getName().replace('.', '/') + ".class";
- try (final InputStream stream = from.getClassLoader().getResourceAsStream(resource))
- {
- if (stream == null)
- {
- return javaVersion;
- }
- final ClassReader reader = new ClassReader(stream);
- final VersionVisitor visitor = new VersionVisitor();
- reader.accept(visitor, SKIP_DEBUG + SKIP_CODE + SKIP_FRAMES);
- if (visitor.version != 0)
- {
- return visitor.version;
- }
- }
- catch (final Exception e)
- {
- // no-op
- }
- // mainly for JVM classes - outside the classloader, find to fallback on the JVM version
- return javaVersion;
- }
-
-
-
- protected boolean unproxyableMethod(Method delegatedMethod)
- {
- int modifiers = delegatedMethod.getModifiers();
-
- return (modifiers & (Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL | Modifier.NATIVE)) > 0 ||
- "finalize".equals(delegatedMethod.getName()) || delegatedMethod.isBridge();
- }
-
- /**
- * @return the wrapper type for a primitive, e.g. java.lang.Integer for int
- */
- protected String getWrapperType(Class<?> type)
- {
- if (Integer.TYPE.equals(type))
- {
- return Integer.class.getCanonicalName().replace('.', '/');
- }
- else if (Boolean.TYPE.equals(type))
- {
- return Boolean.class.getCanonicalName().replace('.', '/');
- }
- else if (Character.TYPE.equals(type))
- {
- return Character.class.getCanonicalName().replace('.', '/');
- }
- else if (Byte.TYPE.equals(type))
- {
- return Byte.class.getCanonicalName().replace('.', '/');
- }
- else if (Short.TYPE.equals(type))
- {
- return Short.class.getCanonicalName().replace('.', '/');
- }
- else if (Float.TYPE.equals(type))
- {
- return Float.class.getCanonicalName().replace('.', '/');
- }
- else if (Long.TYPE.equals(type))
- {
- return Long.class.getCanonicalName().replace('.', '/');
- }
- else if (Double.TYPE.equals(type))
- {
- return Double.class.getCanonicalName().replace('.', '/');
- }
- else if (Void.TYPE.equals(type))
- {
- return Void.class.getCanonicalName().replace('.', '/');
- }
-
- throw new IllegalStateException("Type: " + type.getCanonicalName() + " is not a primitive type");
- }
-
- /**
- * Returns the appropriate bytecode instruction to load a value from a variable to the stack
- *
- * @param type Type to load
- * @return Bytecode instruction to use
- */
- protected int getVarInsn(Class<?> type)
- {
- if (type.isPrimitive())
- {
- if (Integer.TYPE.equals(type))
- {
- return Opcodes.ILOAD;
- }
- else if (Boolean.TYPE.equals(type))
- {
- return Opcodes.ILOAD;
- }
- else if (Character.TYPE.equals(type))
- {
- return Opcodes.ILOAD;
- }
- else if (Byte.TYPE.equals(type))
- {
- return Opcodes.ILOAD;
- }
- else if (Short.TYPE.equals(type))
- {
- return Opcodes.ILOAD;
- }
- else if (Float.TYPE.equals(type))
- {
- return Opcodes.FLOAD;
- }
- else if (Long.TYPE.equals(type))
- {
- return Opcodes.LLOAD;
- }
- else if (Double.TYPE.equals(type))
- {
- return Opcodes.DLOAD;
- }
- }
-
- throw new IllegalStateException("Type: " + type.getCanonicalName() + " is not a primitive type");
- }
-
- /**
- * Invokes the most appropriate bytecode instruction to put a number on the stack
- *
- * @param mv
- * @param i
- */
- protected void pushIntOntoStack(MethodVisitor mv, int i)
- {
- if (i == 0)
- {
- mv.visitInsn(Opcodes.ICONST_0);
- }
- else if (i == 1)
- {
- mv.visitInsn(Opcodes.ICONST_1);
- }
- else if (i == 2)
- {
- mv.visitInsn(Opcodes.ICONST_2);
- }
- else if (i == 3)
- {
- mv.visitInsn(Opcodes.ICONST_3);
- }
- else if (i == 4)
- {
- mv.visitInsn(Opcodes.ICONST_4);
- }
- else if (i == 5)
- {
- mv.visitInsn(Opcodes.ICONST_5);
- }
- else if (i > 5 && i <= 255)
- {
- mv.visitIntInsn(Opcodes.BIPUSH, i);
- }
- else
- {
- mv.visitIntInsn(Opcodes.SIPUSH, i);
- }
- }
-
- /**
- * Gets the appropriate bytecode instruction for RETURN, according to what type we need to return
- *
- * @param type Type the needs to be returned
- * @return The matching bytecode instruction
- */
- protected int getReturnInsn(Class<?> type)
- {
- if (type.isPrimitive())
- {
- if (Void.TYPE.equals(type))
- {
- return Opcodes.RETURN;
- }
- if (Integer.TYPE.equals(type))
- {
- return Opcodes.IRETURN;
- }
- else if (Boolean.TYPE.equals(type))
- {
- return Opcodes.IRETURN;
- }
- else if (Character.TYPE.equals(type))
- {
- return Opcodes.IRETURN;
- }
- else if (Byte.TYPE.equals(type))
- {
- return Opcodes.IRETURN;
- }
- else if (Short.TYPE.equals(type))
- {
- return Opcodes.IRETURN;
- }
- else if (Float.TYPE.equals(type))
- {
- return Opcodes.FRETURN;
- }
- else if (Long.TYPE.equals(type))
- {
- return Opcodes.LRETURN;
- }
- else if (Double.TYPE.equals(type))
- {
- return Opcodes.DRETURN;
- }
- }
-
- return Opcodes.ARETURN;
- }
-
- /**
- * Gets the string to use for CHECKCAST instruction, returning the correct value for any type, including primitives and arrays
- *
- * @param returnType The type to cast to with CHECKCAST
- * @return CHECKCAST parameter
- */
- protected String getCastType(Class<?> returnType)
- {
- if (returnType.isPrimitive())
- {
- return getWrapperType(returnType);
- }
- else
- {
- return Type.getInternalName(returnType);
- }
- }
-
- /**
- * Returns the name of the Java method to call to get the primitive value from an Object - e.g. intValue for java.lang.Integer
- *
- * @param type Type whose primitive method we want to lookup
- * @return The name of the method to use
- */
- protected String getPrimitiveMethod(Class<?> type)
- {
- if (Integer.TYPE.equals(type))
- {
- return "intValue";
- }
- else if (Boolean.TYPE.equals(type))
- {
- return "booleanValue";
- }
- else if (Character.TYPE.equals(type))
- {
- return "charValue";
- }
- else if (Byte.TYPE.equals(type))
- {
- return "byteValue";
- }
- else if (Short.TYPE.equals(type))
- {
- return "shortValue";
- }
- else if (Float.TYPE.equals(type))
- {
- return "floatValue";
- }
- else if (Long.TYPE.equals(type))
- {
- return "longValue";
- }
- else if (Double.TYPE.equals(type))
- {
- return "doubleValue";
- }
-
- throw new IllegalStateException("Type: " + type.getCanonicalName() + " is not a primitive type");
- }
-
- protected void generateReturn(MethodVisitor mv, Method delegatedMethod)
- {
- Class<?> returnType = delegatedMethod.getReturnType();
- mv.visitInsn(getReturnInsn(returnType));
- }
-
- /**
- * Create an Object[] parameter which contains all the parameters of the currently invoked method
- * and store this array for use in the call stack.
- * @param mv
- * @param parameterTypes
- */
- protected void pushMethodParameterArray(MethodVisitor mv, Class<?>[] parameterTypes)
- {
- // need to construct the array of objects passed in
- // create the Object[]
- createArrayDefinition(mv, parameterTypes.length, Object.class);
-
- int index = 1;
- // push parameters into array
- for (int i = 0; i < parameterTypes.length; i++)
- {
- // keep copy of array on stack
- mv.visitInsn(Opcodes.DUP);
-
- Class<?> parameterType = parameterTypes[i];
-
- // push number onto stack
- pushIntOntoStack(mv, i);
-
- if (parameterType.isPrimitive())
- {
- String wrapperType = getWrapperType(parameterType);
- mv.visitVarInsn(getVarInsn(parameterType), index);
-
- mv.visitMethodInsn(Opcodes.INVOKESTATIC, wrapperType, "valueOf",
- "(" + Type.getDescriptor(parameterType) + ")L" + wrapperType + ";", false);
- mv.visitInsn(Opcodes.AASTORE);
-
- if (Long.TYPE.equals(parameterType) || Double.TYPE.equals(parameterType))
- {
- index += 2;
- }
- else
- {
- index++;
- }
- }
- else
- {
- mv.visitVarInsn(Opcodes.ALOAD, index);
- mv.visitInsn(Opcodes.AASTORE);
- index++;
- }
- }
- }
-
- /**
- * pushes an array of the specified size to the method visitor. The generated bytecode will leave
- * the new array at the top of the stack.
- *
- * @param mv MethodVisitor to use
- * @param size Size of the array to create
- * @param type Type of array to create
- * @throws ProxyGenerationException
- */
- protected void createArrayDefinition(MethodVisitor mv, int size, Class<?> type)
- throws ProxyGenerationException
- {
- // create a new array of java.lang.class (2)
-
- if (size < 0)
- {
- throw new ProxyGenerationException("Array size cannot be less than zero");
- }
-
- pushIntOntoStack(mv, size);
-
- mv.visitTypeInsn(Opcodes.ANEWARRAY, type.getCanonicalName().replace('.', '/'));
- }
-
-
- private static class VersionVisitor extends EmptyVisitor
- {
- private int version;
-
- @Override
- public void visit(final int version, final int access, final String name,
- final String signature, final String superName, final String[] interfaces)
- {
- this.version = version;
- }
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/deployment/JavaSECMPInitializer.java b/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/deployment/JavaSECMPInitializer.java
deleted file mode 100644
index 3b773b3..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/deployment/JavaSECMPInitializer.java
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 1998, 2018 IBM Corporation. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// Oracle - initial API and implementation from Oracle TopLink
-// tware - 1.0RC1 - refactor for OSGi
-// zhao jianyong - Bug 324627 - JarList stream is not explicitly closed after use in JavaSECMPInitializer
-package org.eclipse.persistence.internal.jpa.deployment;
-
-import java.lang.instrument.ClassFileTransformer;
-import java.lang.instrument.IllegalClassFormatException;
-import java.lang.instrument.Instrumentation;
-import java.lang.reflect.Constructor;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.security.AccessController;
-import java.security.PrivilegedActionException;
-import java.security.ProtectionDomain;
-import java.util.Collection;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.Map;
-
-import jakarta.persistence.PersistenceException;
-import jakarta.persistence.spi.ClassTransformer;
-import jakarta.persistence.spi.PersistenceUnitInfo;
-
-import org.eclipse.persistence.config.PersistenceUnitProperties;
-import org.eclipse.persistence.exceptions.EntityManagerSetupException;
-import org.eclipse.persistence.internal.jpa.EntityManagerFactoryProvider;
-import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.internal.security.PrivilegedGetConstructorFor;
-import org.eclipse.persistence.internal.security.PrivilegedInvokeConstructor;
-import org.eclipse.persistence.logging.AbstractSessionLog;
-import org.eclipse.persistence.logging.SessionLog;
-
-/**
- * INTERNAL:
- *
- * JavaSECMPInitializer is used to bootstrap the deployment of EntityBeans in EJB 3.0
- * when deployed in a non-managed setting
- *
- * It is called internally by our Provider
- *
- * @see org.eclipse.persistence.internal.jpa.EntityManagerFactoryProvider
- */
-public class JavaSECMPInitializer extends JPAInitializer {
-
- // Used when byte code enhancing
- public static Instrumentation globalInstrumentation;
- // Adding this flag because globalInstrumentation could be set to null after weaving is done.
- protected static boolean usesAgent;
- // Adding this flag to know that within a JEE container so weaving should be enabled without an agent for non managed persistence units.
- protected static boolean isInContainer;
- // Indicates whether has been initialized - that could be done only once.
- protected static boolean isInitialized;
- // Singleton corresponding to the main class loader. Created only if agent is used.
- protected static JavaSECMPInitializer initializer;
- // Used as a lock in getJavaSECMPInitializer.
- private static final Object initializationLock = new Object();
-
- public static boolean isInContainer() {
- return isInContainer;
- }
- public static void setIsInContainer(boolean isInContainer) {
- JavaSECMPInitializer.isInContainer = isInContainer;
- }
-
- /**
- * Get the singleton entityContainer.
- */
- public static JavaSECMPInitializer getJavaSECMPInitializer() {
- return getJavaSECMPInitializer(Thread.currentThread().getContextClassLoader(), null, false);
- }
- public static JavaSECMPInitializer getJavaSECMPInitializer(ClassLoader classLoader) {
- return getJavaSECMPInitializer(classLoader, null, false);
- }
- public static JavaSECMPInitializer getJavaSECMPInitializerFromAgent() {
- return getJavaSECMPInitializer(Thread.currentThread().getContextClassLoader(), null, true);
- }
- public static JavaSECMPInitializer getJavaSECMPInitializerFromMain(Map m) {
- return getJavaSECMPInitializer(Thread.currentThread().getContextClassLoader(), m, false);
- }
- public static JavaSECMPInitializer getJavaSECMPInitializer(ClassLoader classLoader, Map m, boolean fromAgent) {
- if(!isInitialized) {
- if(globalInstrumentation != null) {
- synchronized(initializationLock) {
- if(!isInitialized) {
- initializeTopLinkLoggingFile();
- if(fromAgent) {
- AbstractSessionLog.getLog().log(SessionLog.FINER, SessionLog.WEAVER, "cmp_init_initialize_from_agent", (Object[])null);
- }
- usesAgent = true;
- initializer = new JavaSECMPInitializer(classLoader);
- initializer.initialize(m != null ? m : new HashMap(0));
- // all the transformers have been added to instrumentation, don't need it any more.
- globalInstrumentation = null;
- }
- }
- }
- isInitialized = true;
- }
- if(initializer != null && initializer.getInitializationClassLoader() == classLoader) {
- return initializer;
- } else {
- // when agent is not used initializer does not need to be initialized.
- return new JavaSECMPInitializer(classLoader);
- }
- }
-
- /**
- * User should not instantiate JavaSECMPInitializer.
- */
- protected JavaSECMPInitializer() {
- super();
- }
-
- protected JavaSECMPInitializer(ClassLoader loader) {
- super();
- this.initializationClassloader = loader;
- }
-
- /**
- * Check whether weaving is possible and update the properties and variable as appropriate
- * @param properties The list of properties to check for weaving and update if weaving is not needed
- */
- @Override
- public void checkWeaving(Map properties){
- String weaving = EntityManagerFactoryProvider.getConfigPropertyAsString(PersistenceUnitProperties.WEAVING, properties, null);
- // Check usesAgent instead of globalInstrumentation!=null because globalInstrumentation is set to null after initialization,
- // but we still have to keep weaving so that the resulting projects correspond to the woven (during initialization) classes.
- if (!usesAgent && !isInContainer) {
- if (weaving == null) {
- properties.put(PersistenceUnitProperties.WEAVING, "false");
- weaving = "false";
- } else if (weaving.equalsIgnoreCase("true")) {
- throw new PersistenceException(EntityManagerSetupException.wrongWeavingPropertyValue());
- }
- }
- if ((weaving != null) && ((weaving.equalsIgnoreCase("false")) || (weaving.equalsIgnoreCase("static")))){
- shouldCreateInternalLoader = false;
- }
- }
-
- /**
- * Create a temporary class loader that can be used to inspect classes and then
- * thrown away. This allows classes to be introspected prior to loading them
- * with application's main class loader enabling weaving.
- */
- @Override
- protected ClassLoader createTempLoader(Collection col) {
- return createTempLoader(col, true);
- }
-
- @Override
- protected ClassLoader createTempLoader(Collection col, boolean shouldOverrideLoadClassForCollectionMembers) {
- if (!shouldCreateInternalLoader) {
- return Thread.currentThread().getContextClassLoader();
- }
-
- ClassLoader currentLoader = Thread.currentThread().getContextClassLoader();
- if (!(currentLoader instanceof URLClassLoader)) {
- //we can't create a TempEntityLoader so just use the current one
- //shouldn't be a problem (and should only occur) in JavaSE
- return currentLoader;
- }
- URL[] urlPath = ((URLClassLoader)currentLoader).getURLs();
-
- ClassLoader tempLoader = null;
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- try {
- Class[] argsClasses = new Class[] { URL[].class, ClassLoader.class, Collection.class, boolean.class };
- Object[] args = new Object[] { urlPath, currentLoader, col, shouldOverrideLoadClassForCollectionMembers };
- Constructor classLoaderConstructor = AccessController.doPrivileged(new PrivilegedGetConstructorFor(TempEntityLoader.class, argsClasses, true));
- tempLoader = (ClassLoader) AccessController.doPrivileged(new PrivilegedInvokeConstructor(classLoaderConstructor, args));
- } catch (PrivilegedActionException privilegedException) {
- throw new PersistenceException(EntityManagerSetupException.failedToInstantiateTemporaryClassLoader(privilegedException));
- }
- } else {
- tempLoader = new TempEntityLoader(urlPath, currentLoader, col, shouldOverrideLoadClassForCollectionMembers);
- }
-
- AbstractSessionLog.getLog().log(SessionLog.FINER, SessionLog.WEAVER, "cmp_init_tempLoader_created", tempLoader);
- AbstractSessionLog.getLog().log(SessionLog.FINER, SessionLog.WEAVER, "cmp_init_shouldOverrideLoadClassForCollectionMembers", Boolean.valueOf(shouldOverrideLoadClassForCollectionMembers));
-
- return tempLoader;
- }
-
- /**
- * INTERNAL:
- * Should be called only by the agent. (when weaving classes)
- * If succeeded return true, false otherwise.
- */
- protected static void initializeFromAgent(Instrumentation instrumentation) throws Exception {
- // Squirrel away the instrumentation for later
- globalInstrumentation = instrumentation;
- getJavaSECMPInitializerFromAgent();
- }
-
- /**
- * Usually JavaSECMPInitializer is initialized from agent during premain
- * to ensure that the classes to be weaved haven't been loaded before initialization.
- * However, in this case initialization can't be debugged.
- * In order to be able to debug initialization specify
- * in java options -javaagent with parameter "main": (note: a separate eclipselink-agent.jar is no longer required)
- * -javaagent:c:\trunk\eclipselink.jar=main
- * that causes instrumentation to be cached during premain and postpones initialization until main.
- * With initialization done in main (during the first createEntityManagerFactory call)
- * there's a danger of the classes to be weaved being already loaded.
- * In that situation initializeFromMain should be called before any classes are loaded.
- * The sure-to-work method would be to create a new runnable class with a main method
- * consisting of just two lines: calling initializeFromMain
- * followed by reflective call to the main method of the original runnable class.
- * The same could be achieved by calling PersistenceProvider.createEntityManagerFactory method instead
- * of JavaSECMPInitializer.initializeFromMain method,
- * however initializeFromMain might be more convenient because it
- * doesn't require a persistence unit name.
- * The method doesn't do anything if JavaSECMPInitializer has been already initialized.
- * @param m - a map containing the set of properties to instantiate with.
- */
- public static void initializeFromMain(Map m) {
- getJavaSECMPInitializerFromMain(m);
- }
-
- /**
- * The version of initializeFromMain that passes an empty map.
- */
- public static void initializeFromMain() {
- initializeFromMain(new HashMap());
- }
-
- /**
- * Register a transformer. In this case, we use the instrumentation to add a transformer for the
- * JavaSE environment
- * @param transformer
- * @param persistenceUnitInfo
- */
- @Override
- public void registerTransformer(final ClassTransformer transformer, PersistenceUnitInfo persistenceUnitInfo, Map properties){
- if ((transformer != null) && (globalInstrumentation != null)) {
- AbstractSessionLog.getLog().log(SessionLog.FINER, SessionLog.WEAVER, "cmp_init_register_transformer", persistenceUnitInfo.getPersistenceUnitName());
- globalInstrumentation.addTransformer(new ClassFileTransformer() {
- // adapt ClassTransformer to ClassFileTransformer interface
- @Override
- public byte[] transform(
- ClassLoader loader, String className,
- Class<?> classBeingRedefined,
- ProtectionDomain protectionDomain,
- byte[] classfileBuffer) throws IllegalClassFormatException {
- return transformer.transform(loader, className, classBeingRedefined, protectionDomain, classfileBuffer);
- }
- });
- } else if (transformer == null) {
- AbstractSessionLog.getLog().log(SessionLog.FINER, SessionLog.WEAVER, "cmp_init_transformer_is_null", null, true);
- } else if (globalInstrumentation == null) {
- AbstractSessionLog.getLog().log(SessionLog.FINER, SessionLog.WEAVER, "cmp_init_globalInstrumentation_is_null", null, true);
- }
- }
-
- /**
- * Indicates whether puName uniquely defines the persistence unit.
- * usesAgent means that it is a stand alone SE case.
- * Otherwise it could be an application server case where different persistence units
- * may have the same name: that could happen if they are loaded by different classloaders;
- * the common case is the same persistence unit jar deployed in several applications.
- */
- @Override
- public boolean isPersistenceUnitUniquelyDefinedByName() {
- return usesAgent;
- }
-
- /**
- * Indicates whether initialization has already occurred.
- */
- public static boolean isInitialized() {
- return isInitialized;
- }
-
- /**
- * Indicates whether Java agent and globalInstrumentation was used.
- */
- public static boolean usesAgent() {
- return usesAgent;
- }
-
- /**
- * Indicates whether initialPuInfos and initialEmSetupImpls are used.
- */
- @Override
- protected boolean keepAllPredeployedPersistenceUnits() {
- return usesAgent;
- }
-
- /*********************************/
- /***** Temporary Classloader *****/
- /*********************************/
- /**
- * This class loader is provided at initialization time to allow us to temporarily load
- * domain classes so we can examine them for annotations. After they are loaded we will throw this
- * class loader away. Transformers can then be registered on the real class loader to allow
- * weaving to occur.
- *
- * It selectively loads classes based on the list of classnames it is instantiated with. Classes
- * not on that list are allowed to be loaded by the parent.
- */
- public static class TempEntityLoader extends URLClassLoader {
- Collection classNames;
- boolean shouldOverrideLoadClassForCollectionMembers;
-
- //added to resolved gf #589 - without this, the orm.xml url would be returned twice
- @Override
- public Enumeration<URL> getResources(String name) throws java.io.IOException {
- return this.getParent().getResources(name);
- }
-
- public TempEntityLoader(URL[] urls, ClassLoader parent, Collection classNames, boolean shouldOverrideLoadClassForCollectionMembers) {
- super(urls, parent);
- this.classNames = classNames;
- this.shouldOverrideLoadClassForCollectionMembers = shouldOverrideLoadClassForCollectionMembers;
- }
-
- public TempEntityLoader(URL[] urls, ClassLoader parent, Collection classNames) {
- this(urls, parent, classNames, true);
- }
-
- // Indicates if the classLoad should be overridden for the passed className.
- // Returns true in case the class should NOT be loaded by parent classLoader.
- protected boolean shouldOverrideLoadClass(String name) {
- if (shouldOverrideLoadClassForCollectionMembers) {
- // Override classLoad if the name is in collection
- return (classNames != null) && classNames.contains(name);
- } else {
- // Directly opposite: Override classLoad if the name is NOT in collection.
- // Forced to check for java. and javax. packages here, because even if the class
- // has been loaded by parent loader we would load it again
- // (see comment in loadClass)
- return !name.startsWith("java.") && !name.startsWith("javax.") && !name.startsWith("jakarta.") && ((classNames == null) || !classNames.contains(name));
- }
- }
-
- @Override
- protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
- if (shouldOverrideLoadClass(name)) {
- // First, check if the class has already been loaded.
- // Note that the check only for classes loaded by this loader,
- // it doesn't return true if the class has been loaded by parent loader
- // (forced to live with that because findLoadedClass method defined as final protected:
- // neither can override it nor call it on the parent loader)
- Class c = findLoadedClass(name);
- if (c == null) {
- c = findClass(name);
- }
- if (resolve) {
- resolveClass(c);
- }
- return c;
- } else {
- return super.loadClass(name, resolve);
- }
- }
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java b/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java
deleted file mode 100644
index 04fce33..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataAsmFactory.java
+++ /dev/null
@@ -1,712 +0,0 @@
-/*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 1998, 2018 Hans Harz, Andrew Rustleund, IBM Corporation. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// James Sutherland - initial impl
-// 05/14/2010-2.1 Guy Pelletier
-// - 253083: Add support for dynamic persistence using ORM.xml/eclipselink-orm.xml
-// Hans Harz, Andrew Rustleund - Bug 324862 - IndexOutOfBoundsException in
-// DatabaseSessionImpl.initializeDescriptors because @MapKey Annotation is not found.
-// 04/21/2011-2.3 dclarke: Upgraded to support ASM 3.3.1
-// 08/10/2011-2.3 Lloyd Fernandes : Bug 336133 - Validation error during processing on parameterized generic OneToMany Entity relationship from MappedSuperclass
-// 10/05/2012-2.4.1 Guy Pelletier
-// - 373092: Exceptions using generics, embedded key and entity inheritance
-// 19/04/2014-2.6 Lukas Jungmann
-// - 429992: JavaSE 8/ASM 5.0.1 support (EclipseLink silently ignores Entity classes with lambda expressions)
-// 11/05/2015-2.6 Dalia Abo Sheasha
-// - 480787 : Wrap several privileged method calls with a doPrivileged block
-package org.eclipse.persistence.internal.jpa.metadata.accessors.objects;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.util.ArrayList;
-import java.util.List;
-
-import org.eclipse.persistence.internal.helper.Helper;
-import org.eclipse.persistence.internal.jpa.metadata.MetadataDescriptor;
-import org.eclipse.persistence.internal.jpa.metadata.MetadataLogger;
-import org.eclipse.persistence.internal.libraries.asm.AnnotationVisitor;
-import org.eclipse.persistence.internal.libraries.asm.Attribute;
-import org.eclipse.persistence.internal.libraries.asm.ClassReader;
-import org.eclipse.persistence.internal.libraries.asm.ClassVisitor;
-import org.eclipse.persistence.internal.libraries.asm.EclipseLinkClassReader;
-import org.eclipse.persistence.internal.libraries.asm.FieldVisitor;
-import org.eclipse.persistence.internal.libraries.asm.MethodVisitor;
-import org.eclipse.persistence.internal.libraries.asm.Opcodes;
-import org.eclipse.persistence.internal.libraries.asm.Type;
-import org.eclipse.persistence.internal.localization.ExceptionLocalization;
-import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.logging.AbstractSessionLog;
-import org.eclipse.persistence.logging.SessionLog;
-import org.eclipse.persistence.logging.SessionLogEntry;
-
-/**
- * INTERNAL: A metadata factory that uses ASM technology and no reflection
- * whatsoever to process the metadata model.
- *
- * @author James Sutherland
- * @since EclipseLink 1.2
- */
-public class MetadataAsmFactory extends MetadataFactory {
- /** Set of primitive type codes. */
- public static final String PRIMITIVES = "VJIBZCSFD";
- /** Set of desc token characters. */
- public static final String TOKENS = "()<>;";
-
- /**
- * INTERNAL:
- */
- public MetadataAsmFactory(MetadataLogger logger, ClassLoader loader) {
- super(logger, loader);
-
- addMetadataClass("I", new MetadataClass(this, int.class));
- addMetadataClass("J", new MetadataClass(this, long.class));
- addMetadataClass("S", new MetadataClass(this, short.class));
- addMetadataClass("Z", new MetadataClass(this, boolean.class));
- addMetadataClass("F", new MetadataClass(this, float.class));
- addMetadataClass("D", new MetadataClass(this, double.class));
- addMetadataClass("C", new MetadataClass(this, char.class));
- addMetadataClass("B", new MetadataClass(this, byte.class));
- }
-
- /**
- * Build the class metadata for the class name using ASM to read the class
- * byte codes.
- */
- protected void buildClassMetadata(MetadataClass metadataClass, String className, boolean isLazy) {
- ClassMetadataVisitor visitor = new ClassMetadataVisitor(metadataClass, isLazy);
- InputStream stream = null;
- try {
- String resourceString = className.replace('.', '/') + ".class";
- if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
- final String f_resourceString = resourceString;
- stream = AccessController.doPrivileged(new PrivilegedAction<InputStream>() {
- @Override
- public InputStream run() {
- return m_loader.getResourceAsStream(f_resourceString);
- }
- });
- } else {
- stream = m_loader.getResourceAsStream(resourceString);
- }
-
- ClassReader reader = new ClassReader(stream);
- Attribute[] attributes = new Attribute[0];
- reader.accept(visitor, attributes, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
- } catch (IllegalArgumentException iae) {
- // class was probably compiled with some newer than officially
- // supported and tested JDK
- // in such case log a warning and try to re-read the class
- // without class version check
- SessionLog log = getLogger().getSession() != null
- ? getLogger().getSession().getSessionLog() : AbstractSessionLog.getLog();
- if (log.shouldLog(SessionLog.SEVERE, SessionLog.METADATA)) {
- SessionLogEntry entry = new SessionLogEntry(getLogger().getSession(), SessionLog.SEVERE, SessionLog.METADATA, iae);
- entry.setMessage(ExceptionLocalization.buildMessage("unsupported_classfile_version", new Object[] { className }));
- log.log(entry);
- }
- if (stream != null) {
- try {
- ClassReader reader = new EclipseLinkClassReader(stream);
- Attribute[] attributes = new Attribute[0];
- reader.accept(visitor, attributes, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
- } catch (Exception e) {
- if (log.shouldLog(SessionLog.SEVERE, SessionLog.METADATA)) {
- SessionLogEntry entry = new SessionLogEntry(getLogger().getSession(), SessionLog.SEVERE, SessionLog.METADATA, e);
- entry.setMessage(ExceptionLocalization.buildMessage("unsupported_classfile_version", new Object[] { className }));
- log.log(entry);
- }
- addMetadataClass(getVirtualMetadataClass(className));
- }
- } else {
- addMetadataClass(getVirtualMetadataClass(className));
- }
- } catch (Exception exception) {
- SessionLog log = getLogger().getSession() != null
- ? getLogger().getSession().getSessionLog() : AbstractSessionLog.getLog();
- if (log.shouldLog(SessionLog.FINEST, SessionLog.METADATA)) {
- log.logThrowable(SessionLog.FINEST, SessionLog.METADATA, exception);
- }
- addMetadataClass(getVirtualMetadataClass(className));
- } finally {
- try {
- if (stream != null) {
- stream.close();
- }
- } catch (IOException ignore) {
- // Ignore.
- }
- }
- }
-
- /**
- * Return the class metadata for the class name.
- */
- @Override
- public MetadataClass getMetadataClass(String className) {
- return getMetadataClass(className, false);
- }
-
- /**
- * Return the class metadata for the class name.
- */
- @Override
- public MetadataClass getMetadataClass(String className, boolean isLazy) {
- if (className == null) {
- return null;
- }
-
- MetadataClass metaClass = m_metadataClasses.get(className);
- if ((metaClass == null) || (!isLazy && metaClass.isLazy())) {
- if (metaClass != null) {
- metaClass.setIsLazy(false);
- }
- buildClassMetadata(metaClass, className, isLazy);
- metaClass = m_metadataClasses.get(className);
- }
-
- return metaClass;
- }
-
- /**
- * INTERNAL: This method resolves generic types based on the ASM class
- * metadata. Unless every other factory (e.g. APT mirror factory) respects
- * the generic format as built from ASM this method will not work since it
- * is very tied to it.
- */
- @Override
- public void resolveGenericTypes(MetadataClass child, List<String> genericTypes, MetadataClass parent, MetadataDescriptor descriptor) {
- // If we have a generic parent we need to grab our generic types
- // that may be used (and therefore need to be resolved) to map
- // accessors correctly.
- if (genericTypes != null) {
- // The generic types provided map to its parents generic types. The
- // generics also include the superclass, and interfaces. The parent
- // generics include the type and ":" and class.
-
- List<String> parentGenericTypes = parent.getGenericType();
- if (parentGenericTypes != null) {
- List genericParentTemp = new ArrayList(genericTypes);
- genericParentTemp.removeAll(child.getInterfaces());
-
- int size = genericParentTemp.size();
- int parentIndex = 0;
-
- for (int index = genericTypes.indexOf(parent.getName()) + 1; index < size; index++) {
- String actualTypeArgument = genericTypes.get(index);
- // Ignore extra types on the end of the child, such as
- // interface generics.
- if (parentIndex >= parentGenericTypes.size()) {
- break;
- }
- String variable = parentGenericTypes.get(parentIndex);
-
- // if we get as far as the superclass name in the parent generic type list,
- // there is nothing more to process. We have processed all the generics in the type definition
- if (variable.equals(parent.getSuperclassName())){
- break;
- }
- parentIndex = parentIndex + 3;
-
- // We are building bottom up and need to link up any
- // TypeVariables with the actual class from the originating
- // entity.
- if (actualTypeArgument.length() == 1) {
- index++;
- actualTypeArgument = genericTypes.get(index);
- descriptor.addGenericType(variable, descriptor.getGenericType(actualTypeArgument));
- } else {
- descriptor.addGenericType(variable, actualTypeArgument);
- }
- }
- }
- }
- }
-
- /**
- * Walk the class byte codes and collect the class info.
- */
- public class ClassMetadataVisitor extends ClassVisitor {
-
- private boolean isLazy;
- private boolean processedMemeber;
- private MetadataClass classMetadata;
-
- ClassMetadataVisitor(MetadataClass metadataClass, boolean isLazy) {
- super(Opcodes.ASM7);
- this.isLazy = isLazy;
- this.classMetadata = metadataClass;
- }
-
- @Override
- public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
- String className = toClassName(name);
- if ((this.classMetadata == null) || !this.classMetadata.getName().equals(className)) {
- this.classMetadata = new MetadataClass(MetadataAsmFactory.this, className, isLazy);
- addMetadataClass(this.classMetadata);
- }
- this.classMetadata.setName(className);
- this.classMetadata.setSuperclassName(toClassName(superName));
- this.classMetadata.setModifiers(access);
- this.classMetadata.setGenericType(processDescription(signature, true));
-
- for (String interfaceName : interfaces) {
- this.classMetadata.addInterface(toClassName(interfaceName));
- }
- }
-
- @Override
- public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
- this.processedMemeber = true;
- if (this.classMetadata.isLazy()) {
- return null;
- }
- return new MetadataFieldVisitor(this.classMetadata, access, name, desc, signature, value);
- }
-
- @Override
- public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
- this.processedMemeber = true;
- if (this.classMetadata.isLazy() || name.indexOf("init>") != -1) {
- return null;
- }
- return new MetadataMethodVisitor(this.classMetadata, access, name, signature, desc, exceptions);
- }
-
- @Override
- public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
- boolean isJPA = false;
- if (desc.startsWith("Lkotlin")) {
- //ignore kotlin annotations
- return null;
- }
- if (desc.startsWith("Ljava")) {
- char c = desc.charAt(5);
- //ignore annotations from 'java' namespace
- if (c == '/') {
- return null;
- }
- //ignore annotations from other then 'javax/persistence' namespace
- if (desc.regionMatches(5, "x/", 0, 2)) {
- if (desc.regionMatches(7, "persistence", 0, "persistence".length())) {
- isJPA = true;
- } else {
- return null;
- }
- }
- }
- if (desc.startsWith("Ljakarta")) {
- //ignore annotations from other then 'jakarta/persistence' namespace
- if (desc.regionMatches(9, "persistence", 0, "persistence".length())) {
- isJPA = true;
- } else {
- return null;
- }
- }
- if (!this.processedMemeber && this.classMetadata.isLazy()) {
- this.classMetadata.setIsLazy(false);
- }
- //this currently forbids us to use meta-annotations defined in EclipseLink packages
- return new MetadataAnnotationVisitor(this.classMetadata, desc, isJPA || desc.startsWith("Lorg/eclipse/persistence"));
- }
-
- }
-
- /**
- * {@link AnnotationVisitor} used to process class, field , and method
- * annotations populating a {@link MetadataAnnotation} and its nested state.
- *
- * @see MetadataAnnotationArrayVisitor for population of array attributes
- */
- class MetadataAnnotationVisitor extends AnnotationVisitor {
-
- /**
- * Element the annotation is being applied to. If this is null the
- * {@link MetadataAnnotation} being constructed is a nested annotation
- * and is already referenced from its parent.
- */
- private MetadataAnnotatedElement element;
-
- /**
- * {@link MetadataAnnotation} being populated
- */
- private MetadataAnnotation annotation;
-
- MetadataAnnotationVisitor(MetadataAnnotatedElement element, String name) {
- this(element, name, true);
- }
-
- MetadataAnnotationVisitor(MetadataAnnotatedElement element, String name, boolean isRegular) {
- super(Opcodes.ASM7);
- this.element = element;
- this.annotation = new MetadataAnnotation();
- this.annotation.setName(processDescription(name, false).get(0));
- this.annotation.setIsMeta(!isRegular);
- }
-
- public MetadataAnnotationVisitor(MetadataAnnotation annotation) {
- super(Opcodes.ASM7);
- this.annotation = annotation;
- }
-
- @Override
- public void visit(String name, Object value) {
- this.annotation.addAttribute(name, annotationValue(null, value));
- }
-
- @Override
- public void visitEnum(String name, String desc, String value) {
- this.annotation.addAttribute(name, annotationValue(desc, value));
- }
-
- @Override
- public AnnotationVisitor visitAnnotation(String name, String desc) {
- MetadataAnnotation mda = new MetadataAnnotation();
- mda.setName(processDescription(desc, false).get(0));
- this.annotation.addAttribute(name, mda);
- return new MetadataAnnotationVisitor(mda);
- }
-
- @Override
- public AnnotationVisitor visitArray(String name) {
- return new MetadataAnnotationArrayVisitor(this.annotation, name);
- }
-
- @Override
- public void visitEnd() {
- if (this.element != null) {
- if (this.annotation.isMeta()) {
- this.element.addMetaAnnotation(this.annotation);
- } else {
- this.element.addAnnotation(this.annotation);
- }
- }
- }
- }
-
- /**
- * Specialized visitor to handle the population of arrays of annotation
- * values.
- */
- class MetadataAnnotationArrayVisitor extends AnnotationVisitor {
-
- private MetadataAnnotation annotation;
-
- private String attributeName;
-
- private List<Object> values;
-
- public MetadataAnnotationArrayVisitor(MetadataAnnotation annotation, String name) {
- super(Opcodes.ASM7);
- this.annotation = annotation;
- this.attributeName = name;
- this.values = new ArrayList<Object>();
- }
-
- @Override
- public void visit(String name, Object value) {
- this.values.add(annotationValue(null, value));
- }
-
- @Override
- public void visitEnum(String name, String desc, String value) {
- this.values.add(annotationValue(desc, value));
- }
-
- @Override
- public AnnotationVisitor visitAnnotation(String name, String desc) {
- MetadataAnnotation mda = new MetadataAnnotation();
- mda.setName(processDescription(desc, false).get(0));
- this.values.add(mda);
- return new MetadataAnnotationVisitor(mda);
- }
-
- @Override
- public void visitEnd() {
- this.annotation.addAttribute(this.attributeName, this.values.toArray());
- }
- }
-
- /**
- * Factory for the creation of {@link MetadataField} handling basic type,
- * generics, and annotations.
- */
- class MetadataFieldVisitor extends FieldVisitor {
-
- private MetadataField field;
-
- public MetadataFieldVisitor(MetadataClass classMetadata, int access, String name, String desc, String signature, Object value) {
- super(Opcodes.ASM7);
- this.field = new MetadataField(classMetadata);
- this.field.setModifiers(access);
- this.field.setName(name);
- this.field.setAttributeName(name);
- this.field.setGenericType(processDescription(signature, true));
- this.field.setType(processDescription(desc, false).get(0));
- }
-
- @Override
- public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
- if (desc.startsWith("Ljavax/persistence") || desc.startsWith("Ljakarta/persistence")
- || desc.startsWith("Lorg/eclipse/persistence")) {
- return new MetadataAnnotationVisitor(this.field, desc);
- }
- return null;
- }
-
- @Override
- public void visitEnd() {
- this.field.getDeclaringClass().addField(this.field);
- }
- }
-
- /**
- * Factory for the creation of {@link MetadataMethod} handling basic type,
- * generics, and annotations.
- */
- // Note: Subclassed EmptyListener to minimize signature requirements for
- // ignored MethodVisitor API
- class MetadataMethodVisitor extends MethodVisitor {
-
- private MetadataMethod method;
-
- public MetadataMethodVisitor(MetadataClass classMetadata, int access, String name, String desc, String signature, String[] exceptions) {
- super(Opcodes.ASM7);
- this.method = new MetadataMethod(MetadataAsmFactory.this, classMetadata);
-
- this.method.setName(name);
- this.method.setAttributeName(Helper.getAttributeNameFromMethodName(name));
- this.method.setModifiers(access);
-
- this.method.setGenericType(processDescription(desc, true));
-
- List<String> argumentNames = processDescription(signature, false);
- if (argumentNames != null && !argumentNames.isEmpty()) {
- this.method.setReturnType(argumentNames.get(argumentNames.size() - 1));
- argumentNames.remove(argumentNames.size() - 1);
- this.method.setParameters(argumentNames);
- }
- }
-
- @Override
- public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
- if (desc.startsWith("Ljavax/persistence") || desc.startsWith("Ljakarta/persistence")
- || desc.startsWith("Lorg/eclipse/persistence")) {
- return new MetadataAnnotationVisitor(this.method, desc);
- }
- return null;
- }
-
- /**
- * At the end of visiting this method add it to the
- * {@link MetadataClass} and handle duplicate method names by chaining
- * them.
- */
- @Override
- public void visitEnd() {
- MetadataClass classMetadata = this.method.getMetadataClass();
-
- MetadataMethod existing = classMetadata.getMethods().get(this.method.getName());
- if (existing == null) {
- classMetadata.getMethods().put(this.method.getName(), this.method);
- } else {
- // Handle methods with the same name.
- while (existing.getNext() != null) {
- existing = existing.getNext();
- }
- existing.setNext(this.method);
- }
- }
-
- }
-
- /**
- * Get MetadataClass for a class which can not be found
- * @param className class which has not been found
- * @return MetadataClass
- */
- private MetadataClass getVirtualMetadataClass(String className) {
- // Some basic types can't be found, so can just be registered
- // (i.e. arrays). Also, VIRTUAL classes may also not exist,
- // therefore, tag the MetadataClass as loadable false. This will be
- // used to determine if a class will be dynamically created or not.
- MetadataClass metadataClass = new MetadataClass(this, className, false);
- // If the class is a JDK class, then maybe there is a class loader
- // issues,
- // since it is a JDK class, just use reflection.
- if ((className.length() > 5) && className.substring(0, 5).equals("java.")) {
- try {
- Class reflectClass = Class.forName(className);
- if (reflectClass.getSuperclass() != null) {
- metadataClass.setSuperclassName(reflectClass.getSuperclass().getName());
- }
- for (Class reflectInterface : reflectClass.getInterfaces()) {
- metadataClass.addInterface(reflectInterface.getName());
- }
- } catch (Exception failed) {
- SessionLog log = getLogger().getSession() != null
- ? getLogger().getSession().getSessionLog() : AbstractSessionLog.getLog();
- if (log.shouldLog(SessionLog.FINE, SessionLog.METADATA)) {
- log.logThrowable(SessionLog.FINE, SessionLog.METADATA, failed);
- }
- metadataClass.setIsAccessible(false);
- }
- } else {
- metadataClass.setIsAccessible(false);
- }
- return metadataClass;
- }
-
- /**
- * Process the byte-code argument description and return the array of Java
- * class names. i.e.
- * "(Lorg/foo/Bar;Z)Ljava/lang/Boolean;"=>[org.foo.Bar,boolean
- * ,java.lang.Boolean]
- */
- private static List<String> processDescription(String desc, boolean isGeneric) {
- if (desc == null) {
- return null;
- }
- List<String> arguments = new ArrayList<String>();
- int index = 0;
- int length = desc.length();
- boolean isGenericTyped=false;
- // PERF: Use char array to make char index faster (note this is a heavily optimized method, be very careful on changes)
- char[] chars = desc.toCharArray();
- while (index < length) {
- char next = chars[index];
- if (('(' != next) && (')' != next) && ('<' != next) && ('>' != next) && (';' != next)) {
- if (next == 'L') {
- index++;
- int start = index;
- next = chars[index];
- while (('(' != next) && (')' != next) && ('<' != next) && ('>' != next) && (';' != next)) {
- index++;
- next = chars[index];
- }
- arguments.add(toClassName(desc.substring(start, index)));
- if(isGenericTyped) {
- isGenericTyped=false;
- if(next == '<') {
- int cnt = 1;
- while((cnt > 0) && (++index<desc.length())) {
- switch (desc.charAt(index)) {
- case '<': cnt ++; break;
- case '>': cnt --; break;
- }
- }
- }
- }
- } else if (!isGeneric && (PRIMITIVES.indexOf(next) != -1)) {
- // Primitives.
- arguments.add(getPrimitiveName(next));
- } else if (next == '[') {
- // Arrays.
- int start = index;
- index++;
- next = chars[index];
- // Nested arrays.
- while (next == '[') {
- index++;
- next = chars[index];
- }
- if (PRIMITIVES.indexOf(next) == -1) {
- while (next != ';') {
- index++;
- next = chars[index];
- }
- arguments.add(toClassName(desc.substring(start, index + 1)));
- } else {
- arguments.add(desc.substring(start, index + 1));
- }
- } else {
- // Is a generic type variable.
- int start = index;
- int end = start;
-
- char myNext = next;
-
- while (':' != myNext && '(' != myNext && ')' != myNext && '<' != myNext && '>' != myNext && ';' != myNext && end < length - 1) {
- end++;
- myNext = chars[end];
- }
-
- if (myNext == ':') {
- arguments.add(desc.substring(start, end));
- isGenericTyped=true;
- index = end;
- arguments.add(":");
- if(desc.charAt(index+1)==':') {
- index ++;
- }
- } else if (myNext == ';' && next == 'T') {
- arguments.add(new String(new char[] { next }));
- arguments.add(desc.substring(start + 1, end));
- index = end - 1;
- } else {
- arguments.add(new String(new char[] { next }));
- }
- }
- }
- index++;
- }
- return arguments;
-
- }
-
- /**
- * Return the Java type name for the primitive code.
- */
- private static String getPrimitiveName(char primitive) {
- if (primitive == 'V') {
- return "void";
- } else if (primitive == 'I') {
- return "int";
- } else if (primitive == 'Z') {
- return "boolean";
- } else if (primitive == 'J') {
- return "long";
- } else if (primitive == 'F') {
- return "float";
- } else if (primitive == 'D') {
- return "double";
- } else if (primitive == 'B') {
- return "byte";
- } else if (primitive == 'C') {
- return "char";
- } else if (primitive == 'S') {
- return "short";
- } else {
- return new String(new char[] { primitive });
- }
- }
-
- private static String toClassName(String classDescription) {
- if (classDescription == null) {
- return "void";
- }
- return classDescription.replace('/', '.');
- }
-
- /**
- * Convert the annotation value into the value used in the meta model
- */
- private static Object annotationValue(String description, Object value) {
- if (value instanceof Type) {
- return ((Type) value).getClassName();
- }
- return value;
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataClass.java b/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataClass.java
deleted file mode 100644
index 0670e30..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/internal/jpa/metadata/accessors/objects/MetadataClass.java
+++ /dev/null
@@ -1,628 +0,0 @@
-/*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// Oracle - initial API and implementation from Oracle TopLink
-// 05/16/2008-1.0M8 Guy Pelletier
-// - 218084: Implement metadata merging functionality between mapping files
-// 03/08/2010-2.1 Guy Pelletier
-// - 303632: Add attribute-type for mapping attributes to EclipseLink-ORM
-// 05/04/2010-2.1 Guy Pelletier
-// - 309373: Add parent class attribute to EclipseLink-ORM
-// 05/14/2010-2.1 Guy Pelletier
-// - 253083: Add support for dynamic persistence using ORM.xml/eclipselink-orm.xml
-// 01/25/2011-2.3 Guy Pelletier
-// - 333488: Serializable attribute being defaulted to a variable one to one mapping and causing exception
-// 07/16/2013-2.5.1 Guy Pelletier
-// - 412384: Applying Converter for parameterized basic-type for joda-time's DateTime does not work
-package org.eclipse.persistence.internal.jpa.metadata.accessors.objects;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-
-import org.eclipse.persistence.internal.helper.Helper;
-import org.eclipse.persistence.internal.libraries.asm.Opcodes;
-
-/**
- * INTERNAL:
- * An object to hold onto a valid JPA decorated class.
- *
- * @author Guy Pelletier
- * @since TopLink 10.1.3/EJB 3.0 Preview
- */
-public class MetadataClass extends MetadataAnnotatedElement {
- protected boolean m_isLazy;
- protected boolean m_isAccessible;
- protected boolean m_isPrimitive;
- protected boolean m_isJDK;
- protected int m_modifiers;
-
- // Stores the implements interfaces of this class.
- protected List<String> m_interfaces;
-
- // Stores a list of enclosed classes found inside this metadata class.
- // E.g. inner classes, enums etc.
- protected List<MetadataClass> m_enclosedClasses;
-
- // Store the classes field metadata, keyed by the field's name.
- protected Map<String, MetadataField> m_fields;
-
- // Store the classes method metadata, keyed by the method's name.
- // Method's next is used if multiple method with the same name.
- protected Map<String, MetadataMethod> m_methods;
-
- protected MetadataClass m_superclass;
- protected String m_superclassName;
-
- /**
- * Create the metadata class with the class name.
- */
- public MetadataClass(MetadataFactory factory, String name, boolean isLazy) {
- super(factory);
- setName(name);
-
- // By default, set the type to be the same as the name. The canonical
- // model generator relies on types which in most cases is the name, but
- // the generator resolves generic types a little differently to
- // correctly generate model classes.
- setType(name);
-
- m_isAccessible = true;
- m_isLazy = isLazy;
- }
-
- /**
- * Create the metadata class with the class name.
- */
- public MetadataClass(MetadataFactory factory, String name) {
- this(factory, name, false);
- }
-
- /**
- * Create the metadata class based on the class.
- * Mainly used for primitive defaults.
- */
- public MetadataClass(MetadataFactory factory, Class cls) {
- this(factory, cls.getName(), false);
- m_isPrimitive = cls.isPrimitive();
- }
-
- /**
- * INTERNAL:
- */
- public void addEnclosedClass(MetadataClass enclosedClass) {
- if (m_enclosedClasses == null) {
- m_enclosedClasses = new ArrayList<MetadataClass>();
- }
-
- m_enclosedClasses.add(enclosedClass);
- }
-
- /**
- * INTERNAL:
- */
- public void addField(MetadataField field) {
- if (m_fields == null) {
- m_fields = new HashMap<String, MetadataField>();
- }
-
- m_fields.put(field.getName(), field);
- }
-
- /**
- * INTERNAL:
- */
- public void addInterface(String interfaceName) {
- if (m_interfaces == null) {
- m_interfaces = new ArrayList<String>();
- }
-
- m_interfaces.add(interfaceName);
- }
-
- /**
- * INTERNAL:
- */
- public void addMethod(MetadataMethod method) {
- if (m_methods == null) {
- m_methods = new HashMap<String, MetadataMethod>();
- }
-
- m_methods.put(method.getName(), method);
- }
-
- /**
- * Allow comparison to Java classes and Metadata classes.
- */
- @Override
- public boolean equals(Object object) {
- if (object instanceof Class) {
- if (getName() == null) {
- // Void's name is null.
- return ((Class)object).getName() == null;
- }
-
- return getName().equals(((Class)object).getName());
- }
-
- return super.equals(object);
- }
-
- /**
- * INTERNAL:
- * Return if this class is or extends, or super class extends the class.
- */
- public boolean extendsClass(Class javaClass) {
- return extendsClass(javaClass.getName());
- }
-
- /**
- * INTERNAL:
- * Return if this class is or extends, or super class extends the class.
- */
- public boolean extendsClass(String className) {
- if (getName() == null) {
- return className == null;
- }
-
- if (getName().equals(className)) {
- return true;
- }
-
- if (getSuperclassName() == null) {
- return false;
- }
-
- if (getSuperclassName().equals(className)) {
- return true;
- }
-
- return getSuperclass().extendsClass(className);
- }
-
- /**
- * INTERNAL:
- * Return if this class is or extends, or super class extends the interface.
- */
- public boolean extendsInterface(Class javaClass) {
- return extendsInterface(javaClass.getName());
- }
-
- /**
- * INTERNAL:
- * Return if this class is or extends, or super class extends the interface.
- */
- public boolean extendsInterface(String className) {
- if (getName() == null) {
- return false;
- }
-
- if (getName().equals(className)) {
- return true;
- }
-
- if (getInterfaces().contains(className)) {
- return true;
- }
-
- for (String interfaceName : getInterfaces()) {
- if (getMetadataClass(interfaceName).extendsInterface(className)) {
- return true;
- }
- }
-
- if (getSuperclassName() == null) {
- return false;
- }
-
- return getSuperclass().extendsInterface(className);
- }
-
- /**
- * INTERNAL:
- * Return the list of classes defined within this metadata class. E.g.
- * enums and inner classes.
- */
- public List<MetadataClass> getEnclosedClasses() {
- if (m_enclosedClasses == null) {
- m_enclosedClasses = new ArrayList<MetadataClass>();
- }
-
- return m_enclosedClasses;
- }
-
- /**
- * INTERNAL:
- * Return the field with the name.
- * Search for any declared or inherited field.
- */
- public MetadataField getField(String name) {
- return getField(name, true);
- }
-
- /**
- * INTERNAL:
- * Return the field with the name.
- * Search for any declared or inherited field.
- */
- public MetadataField getField(String name, boolean checkSuperClass) {
- MetadataField field = getFields().get(name);
-
- if (checkSuperClass && (field == null) && (getSuperclassName() != null)) {
- return getSuperclass().getField(name);
- }
-
- return field;
- }
-
- /**
- * INTERNAL:
- */
- public Map<String, MetadataField> getFields() {
- if (m_fields == null) {
- m_fields = new HashMap<String, MetadataField>();
-
- if (m_isLazy) {
- m_factory.getMetadataClass(getName(), false);
- }
- }
-
- return m_fields;
- }
-
- /**
- * INTERNAL:
- */
- public List<String> getInterfaces() {
- if (m_interfaces == null) {
- m_interfaces = new ArrayList<String>();
- }
-
- return m_interfaces;
- }
-
- /**
- * INTERNAL:
- * Return the method with the name and no arguments.
- */
- protected MetadataMethod getMethod(String name) {
- return getMethods().get(name);
- }
-
- /**
- * INTERNAL:
- * Return the method with the name and argument types.
- */
- public MetadataMethod getMethod(String name, Class[] arguments) {
- List<String> argumentNames = new ArrayList<String>(arguments.length);
-
- for (int index = 0; index < arguments.length; index++) {
- argumentNames.add(arguments[index].getName());
- }
-
- return getMethod(name, argumentNames);
- }
-
- /**
- * INTERNAL:
- * Return the method with the name and argument types (class names).
- */
- public MetadataMethod getMethod(String name, List<String> arguments) {
- return getMethod(name, arguments, true);
- }
-
- /**
- * INTERNAL:
- * Return the method with the name and argument types (class names).
- */
- public MetadataMethod getMethod(String name, List<String> arguments, boolean checkSuperClass) {
- MetadataMethod method = getMethods().get(name);
-
- while ((method != null) && !method.getParameters().equals(arguments)) {
- method = method.getNext();
- }
-
- if (checkSuperClass && (method == null) && (getSuperclassName() != null)) {
- return getSuperclass().getMethod(name, arguments);
- }
-
- return method;
- }
-
- /**
- * INTERNAL:
- * Return the method with the name and argument types (class names).
- */
- public MetadataMethod getMethod(String name, String[] arguments) {
- return getMethod(name, Arrays.asList(arguments));
- }
-
- /**
- * INTERNAL:
- * Return the method for the given property name.
- */
- public MetadataMethod getMethodForPropertyName(String propertyName) {
- MetadataMethod method;
-
- String leadingChar = String.valueOf(propertyName.charAt(0)).toUpperCase();
- String restOfName = propertyName.substring(1);
-
- // Look for a getPropertyName() method
- method = getMethod(Helper.GET_PROPERTY_METHOD_PREFIX.concat(leadingChar).concat(restOfName), new String[]{});
-
- if (method == null) {
- // Look for an isPropertyName() method
- method = getMethod(Helper.IS_PROPERTY_METHOD_PREFIX.concat(leadingChar).concat(restOfName), new String[]{});
- }
-
- if (method != null) {
- method.setSetMethod(method.getSetMethod(this));
- }
-
- return method;
- }
-
- /**
- * INTERNAL:
- */
- public Map<String, MetadataMethod> getMethods() {
- if (m_methods == null) {
- m_methods = new HashMap<String, MetadataMethod>();
-
- if (m_isLazy) {
- m_factory.getMetadataClass(getName(), false);
- }
- }
- return m_methods;
- }
-
- /**
- * INTERNAL:
- */
- @Override
- public int getModifiers() {
- return m_modifiers;
- }
-
- /**
- * INTERNAL:
- */
- public MetadataClass getSuperclass() {
- if (m_superclass == null) {
- m_superclass = getMetadataClass(m_superclassName);
- }
-
- return m_superclass;
- }
-
- /**
- * INTERNAL:
- */
- public String getSuperclassName() {
- return m_superclassName;
- }
-
- /**
- * Return the ASM type name.
- */
- public String getTypeName() {
- if (isArray()) {
- return getName().replace('.', '/');
- } else if (isPrimitive()) {
- if (getName().equals("int")) {
- return "I";
- } else if (getName().equals("long")) {
- return "J";
- } else if (getName().equals("short")) {
- return "S";
- } else if (getName().equals("boolean")) {
- return "Z";
- } else if (getName().equals("float")) {
- return "F";
- } else if (getName().equals("double")) {
- return "D";
- } else if (getName().equals("char")) {
- return "C";
- } else if (getName().equals("byte")) {
- return "B";
- }
- }
- return "L" + getName().replace('.', '/') + ";";
- }
-
- /**
- * INTERNAL:
- * Return true is this class accessible to be found.
- */
- public boolean isAccessible() {
- return m_isAccessible;
- }
-
- /**
- * INTERNAL:
- * Return if this class is an array type.
- */
- public boolean isArray() {
- return (getName() != null) && (getName().charAt(0) == '[');
- }
-
- /**
- * INTERNAL:
- * Return if this is extends Collection.
- */
- public boolean isCollection() {
- return extendsInterface(Collection.class);
- }
-
- /**
- * INTERNAL:
- * Return if this is extends Enum.
- */
- public boolean isEnum() {
- return extendsClass(Enum.class);
- }
-
- /**
- * INTERNAL:
- * Return if this is an interface (super is null).
- */
- public boolean isInterface() {
- return (Opcodes.ACC_INTERFACE & m_modifiers) != 0;
- }
-
- /**
- * INTERNAL:
- * Return if this is a JDK (java/javax) class.
- */
- public boolean isJDK() {
- return m_isJDK;
- }
-
- /**
- * INTERNAL:
- */
- public boolean isLazy() {
- return m_isLazy;
- }
-
- /**
- * INTERNAL:
- * Return if this is extends List.
- */
- public boolean isList() {
- return extendsInterface(List.class);
- }
-
- /**
- * INTERNAL:
- * Return if this is extends Map.
- */
- public boolean isMap() {
- return extendsInterface(Map.class);
- }
-
- /**
- * INTERNAL:
- * Return if this is Object class.
- */
- public boolean isObject() {
- return getName().equals(Object.class.getName());
- }
-
- /**
- * INTERNAL:
- * Return if this is a primitive.
- */
- public boolean isPrimitive() {
- return m_isPrimitive;
- }
-
- /**
- * INTERNAL:
- * Return if this class extends Serializable or is an array type.
- */
- public boolean isSerializable() {
- if (isArray()) {
- return true;
- }
-
- return extendsInterface(Serializable.class);
- }
-
- /**
- * INTENAL:
- * Return true is this class is the Serializable.class interface.
- */
- public boolean isSerializableInterface() {
- return getName().equals(Serializable.class.getName());
- }
-
- /**
- * INTERNAL:
- * Return true if this extends Set.
- */
- public boolean isSet() {
- return extendsInterface(Set.class);
- }
-
- /**
- * INTERNAL:
- * Return if this is the void class.
- */
- public boolean isVoid() {
- return getName().equals(void.class.getName()) || getName().equals(Void.class.getName());
- }
-
- /**
- * INTERNAL:
- */
- public void setIsAccessible(boolean isAccessible) {
- m_isAccessible = isAccessible;
- }
-
- /**
- * INTERNAL:
- */
- public void setIsJDK(boolean isJDK) {
- m_isJDK = isJDK;
- }
-
- /**
- * INTERNAL:
- */
- public void setIsLazy(boolean isLazy) {
- m_isLazy = isLazy;
- }
-
- /**
- * INTERNAL:
- */
- @Override
- public void setModifiers(int modifiers) {
- m_modifiers = modifiers;
- }
-
- /**
- * INTERNAL:
- */
- @Override
- public void setName(String name) {
- super.setName(name);
-
- if ((!MetadataFactory.ALLOW_JDK) && (name.startsWith("java.")
- || name.startsWith("javax.") || name.startsWith("jakarta.")
- || name.startsWith("org.eclipse.persistence.internal."))) {
- setIsJDK(true);
- }
- }
-
- /**
- * INTERNAL:
- */
- public void setSuperclass(MetadataClass superclass) {
- m_superclass = superclass;
- }
-
- /**
- * INTERNAL:
- */
- public void setSuperclassName(String superclass) {
- m_superclassName = superclass;
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/Helper.java b/jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/Helper.java
deleted file mode 100644
index a8318eb..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/Helper.java
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// Oracle - initial API and implementation from Oracle TopLink
-package org.eclipse.persistence.jaxb.javamodel;
-
-import static org.eclipse.persistence.jaxb.JAXBContextFactory.PKG_SEPARATOR;
-import static org.eclipse.persistence.jaxb.compiler.XMLProcessor.DEFAULT;
-
-import java.lang.annotation.Annotation;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-
-import org.eclipse.persistence.internal.core.helper.CoreClassConstants;
-
-import jakarta.xml.bind.JAXBElement;
-
-import org.eclipse.persistence.internal.oxm.Constants;
-
-/**
- * INTERNAL:
- * <p><b>Purpose:</b>To provide helper methods and constants to assist
- * in integrating TopLink JAXB 2.0 Generation with the JDEV JOT APIs.
- * <p><b>Responsibilities:</b>
- * <ul>
- * <li>Make available a map of JOT - XML type pairs</li>
- * <li>Redirect method calls to the current JavaModel implementation as
- * required</li>
- * <li>Provide methods for accessing generics, annotations, etc. on a
- * given implementaiton's classes</li>
- * <li>Provide a dynamic proxy instance for a given JavaAnnotation in
- * the JOT implementation (for reflection a Java SDK annotation is
- * returned)</li>
- * </ul>
- *
- * @since Oracle TopLink 11.1.1.0.0
- * @see JavaModel
- * @see AnnotationProxy
- *
- */
-public class Helper {
- protected ClassLoader loader;
- protected JavaModel jModel;
- private HashMap xmlToJavaTypeMap;
- private boolean facets;
-
- public final static String APBYTE = "byte[]";
- public final static String BIGDECIMAL = "java.math.BigDecimal";
- public final static String BIGINTEGER = "java.math.BigInteger";
- public final static String PBOOLEAN = "boolean";
- public final static String PBYTE = "byte";
- public final static String CALENDAR = "java.util.Calendar";
- public final static String CHARACTER = "java.lang.Character";
- public final static String CHAR = "char";
- public final static String OBJECT = "java.lang.Object";
- public final static String CLASS = "java.lang.Class";
- public final static String PDOUBLE = "double";
- public final static String PFLOAT = "float";
- public final static String PINT = "int";
- public final static String PLONG = "long";
- public final static String PSHORT = "short";
- public final static String QNAME_CLASS = "javax.xml.namespace.QName";
- public final static String STRING = "java.lang.String";
- public final static String ABYTE = "java.lang.Byte[]";
- public final static String BOOLEAN = "java.lang.Boolean";
- public final static String BYTE = "java.lang.Byte";
- public final static String GREGORIAN_CALENDAR = "java.util.GregorianCalendar";
- public final static String DOUBLE = "java.lang.Double";
- public final static String FLOAT = "java.lang.Float";
- public final static String INTEGER = "java.lang.Integer";
- public final static String UUID = "java.util.UUID";
- public final static String LONG = "java.lang.Long";
- public final static String SHORT = "java.lang.Short";
- public final static String UTIL_DATE = "java.util.Date";
- public final static String SQL_DATE = "java.sql.Date";
- public final static String SQL_TIME = "java.sql.Time";
- public final static String SQL_TIMESTAMP = "java.sql.Timestamp";
- public final static String DURATION = "javax.xml.datatype.Duration";
- public final static String XMLGREGORIANCALENDAR = "javax.xml.datatype.XMLGregorianCalendar";
- public final static String URI = "java.net.URI";
- public final static String URL = "java.net.URL";
- protected final static String JAVA_PKG = "java.";
- protected final static String JAVAX_PKG = "javax.";
- protected final static String JAKARTA_PKG = "jakarta.";
- protected final static String JAVAX_WS_PKG = "javax.xml.ws.";
- protected final static String JAKARTA_WS_PKG = "jakarta.xml.ws.";
- protected final static String JAVAX_RPC_PKG = "javax.xml.rpc.";
- protected final static String JAKARTA_RPC_PKG = "jakarta.xml.rpc.";
-
- private JavaClass collectionClass;
- private JavaClass setClass;
- private JavaClass listClass;
- private JavaClass mapClass;
- private JavaClass jaxbElementClass;
- private JavaClass objectClass;
-
- /**
- * INTERNAL:
- * This is the preferred constructor.
- *
- * This constructor builds the map of XML-Java type pairs,
- * and sets the JavaModel and ClassLoader.
- *
- * @param model
- */
- public Helper(JavaModel model) {
- xmlToJavaTypeMap = buildXMLToJavaTypeMap();
- setJavaModel(model);
- setClassLoader(model.getClassLoader());
- collectionClass = getJavaClass(CoreClassConstants.Collection_Class);
- listClass = getJavaClass(CoreClassConstants.List_Class);
- setClass = getJavaClass(CoreClassConstants.Set_Class);
- mapClass = getJavaClass(CoreClassConstants.Map_Class);
- jaxbElementClass = getJavaClass(JAXBElement.class);
- objectClass = getJavaClass(CoreClassConstants.OBJECT);
- }
-
- /**
- * Builds a map of Java types to XML types.
- *
- * @return
- */
- private HashMap buildXMLToJavaTypeMap() {
- HashMap javaTypes = new HashMap();
- // jaxb 2.0 spec pairs
- javaTypes.put(APBYTE, Constants.BASE_64_BINARY_QNAME);
- javaTypes.put(BIGDECIMAL, Constants.DECIMAL_QNAME);
- javaTypes.put(BIGINTEGER, Constants.INTEGER_QNAME);
- javaTypes.put(PBOOLEAN, Constants.BOOLEAN_QNAME);
- javaTypes.put(PBYTE, Constants.BYTE_QNAME);
- javaTypes.put(CALENDAR, Constants.DATE_TIME_QNAME);
- javaTypes.put(PDOUBLE, Constants.DOUBLE_QNAME);
- javaTypes.put(PFLOAT, Constants.FLOAT_QNAME);
- javaTypes.put(PINT, Constants.INT_QNAME);
- javaTypes.put(PLONG, Constants.LONG_QNAME);
- javaTypes.put(PSHORT, Constants.SHORT_QNAME);
- javaTypes.put(QNAME_CLASS, Constants.QNAME_QNAME);
- javaTypes.put(STRING, Constants.STRING_QNAME);
- javaTypes.put(CHAR, Constants.STRING_QNAME);
- javaTypes.put(CHARACTER, Constants.STRING_QNAME);
- // other pairs
- javaTypes.put(ABYTE, Constants.BYTE_QNAME);
- javaTypes.put(BOOLEAN, Constants.BOOLEAN_QNAME);
- javaTypes.put(BYTE, Constants.BYTE_QNAME);
- javaTypes.put(CLASS, Constants.STRING_QNAME);
- javaTypes.put(GREGORIAN_CALENDAR, Constants.DATE_TIME_QNAME);
- javaTypes.put(DOUBLE, Constants.DOUBLE_QNAME);
- javaTypes.put(FLOAT, Constants.FLOAT_QNAME);
- javaTypes.put(INTEGER, Constants.INT_QNAME);
- javaTypes.put(LONG, Constants.LONG_QNAME);
- javaTypes.put(OBJECT, Constants.ANY_TYPE_QNAME);
- javaTypes.put(SHORT, Constants.SHORT_QNAME);
- javaTypes.put(UTIL_DATE, Constants.DATE_TIME_QNAME);
- javaTypes.put(SQL_DATE, Constants.DATE_QNAME);
- javaTypes.put(SQL_TIME, Constants.TIME_QNAME);
- javaTypes.put(SQL_TIMESTAMP, Constants.DATE_TIME_QNAME);
- javaTypes.put(DURATION, Constants.DURATION_QNAME);
- javaTypes.put(UUID, Constants.STRING_QNAME);
- javaTypes.put(URI, Constants.STRING_QNAME);
- javaTypes.put(URL, Constants.ANY_URI_QNAME);
- return javaTypes;
- }
-
- /**
- * Return a given method's generic return type as a JavaClass.
- *
- * @param meth
- * @return
- */
- public JavaClass getGenericReturnType(JavaMethod meth) {
- JavaClass result = meth.getReturnType();
- JavaClass jClass = null;
- if (result == null) { return null; }
-
- Collection args = result.getActualTypeArguments();
- if (args.size() >0) {
- jClass = (JavaClass) args.iterator().next();
- }
- return jClass;
- }
-
- /**
- * Return a JavaClass instance created based the provided class.
- * This assumes that the provided class exists on the classpath
- * - null is returned otherwise.
- *
- * @param javaClass
- * @return
- */
- public JavaClass getJavaClass(Class javaClass) {
- return jModel.getClass(javaClass);
- }
-
- /**
- * Return array of JavaClass instances created based on the provided classes.
- * This assumes provided classes exist on the classpath.
- *
- * @param classes
- * @return JavaClass array
- */
- public JavaClass[] getJavaClassArray(Class... classes) {
- if (0 == classes.length) {
- return new JavaClass[0];
- }
- JavaClass[] result = new JavaClass[classes.length];
- int i = 0;
- for (Class clazz : classes) {
- result[i++] = getJavaClass(clazz);
- }
- return result;
- }
-
- /**
- * Return a JavaClass instance created based on fully qualified
- * class name. This assumes that a class with the provided name
- * exists on the classpath - null is returned otherwise.
- *
- * @param javaClassName
- * @return
- */
- public JavaClass getJavaClass(String javaClassName) {
- return jModel.getClass(javaClassName);
- }
-
- /**
- * Return a map of default Java types to XML types.
- * @return
- */
- public HashMap getXMLToJavaTypeMap() {
- return xmlToJavaTypeMap;
- }
-
- /**
- * Returns a either a dynamic proxy instance that allows an element
- * to be treated as an annotation (for JOT), or a Java annotation
- * (for Reflection), or null if the specified annotation does not
- * exist.
- * Intended to be used in conjunction with isAnnotationPresent.
- *
- * @param element
- * @param annotationClass
- * @return
- * @see #isAnnotationPresent
- */
- public Annotation getAnnotation(JavaHasAnnotations element, Class annotationClass) {
- JavaAnnotation janno = element.getAnnotation(jModel.getClass(annotationClass));
- if (janno == null) {
- return null;
- }
- return jModel.getAnnotation(janno, annotationClass);
- }
-
- /**
- * Returns a JavaClass instance wrapping the provided field's resolved
- * type.
- *
- * @param field
- * @return
- */
- public JavaClass getType(JavaField field) {
- JavaClass type = field.getResolvedType();
- try {
- return jModel.getClass(type.getRawName());
- } catch (Exception x) {}
- return null;
- }
-
- /**
- * Return a JavaClass instance based on the @see jakarta.xml.bind.JAXBElement .
- *
- * Replacement of direct access to JAXBELEMENT_CLASS field.
- *
- * @return
- */
- public JavaClass getJaxbElementClass() {
- return jaxbElementClass;
- }
-
- /**
- * Return a JavaClass instance based on the @see java.lang.Object .
- *
- * Replacement of direct access to OBJECT_CLASS field.
- *
- * @return
- */
- public JavaClass getObjectClass() {
- return objectClass;
- }
-
- /**
- * Indicates if element contains a given annotation.
- *
- * @param element
- * @param annotationClass
- * @return
- */
- public boolean isAnnotationPresent(JavaHasAnnotations element, Class annotationClass) {
- if (element == null || annotationClass == null) {
- return false;
- }
- return (element.getAnnotation(jModel.getClass(annotationClass)) != null);
- }
-
- /**
- * Indicates if a given JavaClass is a built-in Java type.
- *
- * A JavaClass is considered to be a built-in type if:
- * 1 - the XMLToJavaTypeMap map contains a key equal to the provided
- * JavaClass' raw name
- * 2 - the provided JavaClass' raw name starts with "java."
- * 3 - the provided JavaClass' raw name starts with "javax.", with
- * the exception of "jakarta.xml.ws." and "javax.xml.rpc"
- * @param jClass
- * @return
- */
- public boolean isBuiltInJavaType(JavaClass jClass) {
- String rawName = jClass.getRawName();
- if(null == rawName) {
- return true;
- }
- return (getXMLToJavaTypeMap().containsKey(rawName) || rawName.startsWith(JAVA_PKG) || ((rawName.startsWith(JAVAX_PKG) || rawName.startsWith(JAKARTA_PKG)) && !(
- rawName.startsWith(JAVAX_WS_PKG) ||
- rawName.startsWith(JAVAX_RPC_PKG) ||
- rawName.startsWith(JAKARTA_WS_PKG) ||
- rawName.startsWith(JAKARTA_RPC_PKG)
- )));
- }
-
- public void setClassLoader(ClassLoader loader) {
- this.loader = loader;
- }
-
- public void setJavaModel(JavaModel model) {
- jModel = model;
- }
- public ClassLoader getClassLoader() {
- return loader;
- }
-
- public Class getClassForJavaClass(JavaClass javaClass){
- String javaClassName = javaClass.getRawName();
- if (javaClass.isPrimitive() || javaClass.isArray() && javaClass.getComponentType().isPrimitive()){
- if (CoreClassConstants.APBYTE.getCanonicalName().equals(javaClassName)){
- return Byte[].class;
- }
- if (CoreClassConstants.PBYTE.getCanonicalName().equals(javaClassName)){
- return Byte.class;
- }
- if (CoreClassConstants.PBOOLEAN.getCanonicalName().equals(javaClassName)){
- return Boolean.class;
- }
- if (CoreClassConstants.PSHORT.getCanonicalName().equals(javaClassName)){
- return Short.class;
- }
- if (CoreClassConstants.PFLOAT.getCanonicalName().equals(javaClassName)){
- return Float.class;
- }
- if (CoreClassConstants.PCHAR.getCanonicalName().equals(javaClassName)){
- return Character.class;
- }
- if (CoreClassConstants.PDOUBLE.getCanonicalName().equals(javaClassName)){
- return Double.class;
- }
- if (CoreClassConstants.PINT.getCanonicalName().equals(javaClassName)){
- return Integer.class;
- }
- if (CoreClassConstants.PLONG.getCanonicalName().equals(javaClassName)){
- return Long.class;
- }
- return null;
- }
- return org.eclipse.persistence.internal.helper.Helper.getClassFromClasseName(javaClass.getQualifiedName(), loader);
- }
-
- /**
- * Convenience method to determine if a class exists in a given ArrayList.
- */
- public boolean classExistsInArray(JavaClass theClass, List<JavaClass> existingClasses) {
- for (JavaClass jClass : existingClasses) {
- if (areClassesEqual(jClass, theClass)) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * Convenience method to determine if two JavaClass instances are equal.
- *
- * @param classA
- * @param classB
- * @return
- */
- private boolean areClassesEqual(JavaClass classA, JavaClass classB) {
- if (classA == classB) {
- return true;
- }
- if (!(classA.getQualifiedName().equals(classB.getQualifiedName()))) {
- return false;
- }
-
- Collection classAargs = classA.getActualTypeArguments();
- Collection classBargs = classB.getActualTypeArguments();
- if (classAargs != null) {
- if (classBargs == null) {
- return false;
- }
- if (classAargs.size() != classBargs.size()) {
- return false;
- }
-
- Iterator classAargsIter = classAargs.iterator();
- Iterator classBargsIter = classBargs.iterator();
-
- while(classAargsIter.hasNext()){
- JavaClass nestedClassA = (JavaClass) classAargsIter.next();
- JavaClass nestedClassB = (JavaClass) classBargsIter.next();
- if (!areClassesEqual(nestedClassA, nestedClassB)) {
- return false;
- }
- }
- return true;
- }
- if (classBargs == null) {
- return true;
- }
- return false;
- }
-
-
- /**
- * Prepends a package name to a given java type name, if it is not already present.
- *
- * @param javaTypeName Java type name that may/may not contain 'packageName'
- * @param packageName package name to prepend to javaTypeName if not already
- * @return fully qualified java type name
- */
- public static String getQualifiedJavaTypeName(String javaTypeName, String packageName) {
- // prepend the package name if not already present
- if (packageName != null && packageName.length() > 0 && !packageName.equals(DEFAULT) && !javaTypeName.contains(PKG_SEPARATOR)) {
- return packageName + PKG_SEPARATOR + javaTypeName;
- }
- return javaTypeName;
- }
-
- public boolean isCollectionType(JavaClass type) {
- if (collectionClass.isAssignableFrom(type)
- || listClass.isAssignableFrom(type)
- || setClass.isAssignableFrom(type)) {
- return true;
- }
- return false;
- }
-
- public boolean isMapType(JavaClass type) {
- return mapClass.isAssignableFrom(type);
- }
-
- public boolean isFacets() {
- return facets;
- }
-
- public void setFacets(boolean facets) {
- this.facets = facets;
- }
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/reflection/JavaClassImpl.java b/jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/reflection/JavaClassImpl.java
deleted file mode 100644
index a1c74ba..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/jaxb/javamodel/reflection/JavaClassImpl.java
+++ /dev/null
@@ -1,576 +0,0 @@
-/*
- * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// Oracle - initial API and implementation from Oracle TopLink
-package org.eclipse.persistence.jaxb.javamodel.reflection;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.GenericArrayType;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
-import java.lang.reflect.WildcardType;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import org.eclipse.persistence.exceptions.JAXBException;
-import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
-import org.eclipse.persistence.jaxb.javamodel.JavaAnnotation;
-import org.eclipse.persistence.jaxb.javamodel.JavaClass;
-import org.eclipse.persistence.jaxb.javamodel.JavaClassInstanceOf;
-import org.eclipse.persistence.jaxb.javamodel.JavaConstructor;
-import org.eclipse.persistence.jaxb.javamodel.JavaField;
-import org.eclipse.persistence.jaxb.javamodel.JavaMethod;
-import org.eclipse.persistence.jaxb.javamodel.JavaPackage;
-
-/**
- * INTERNAL:
- * <p><b>Purpose:</b>A wrapper class for a JDK Class. This implementation
- * of the EclipseLink JAXB 2.X Java model simply makes reflective calls on the
- * underlying JDK object.
- *
- * <p><b>Responsibilities:</b>
- * <ul>
- * <li>Provide access to the underlying JDK Class' name, package,
- * method/field names and parameters, annotations, etc.</li>
- * </ul>
- *
- * @since Oracle TopLink 11.1.1.0.0
- * @see org.eclipse.persistence.jaxb.javamodel.JavaClass
- * @see java.lang.Class
- */
-public class JavaClassImpl implements JavaClass {
-
- protected ParameterizedType jType;
- protected Class jClass;
- protected JavaModelImpl javaModelImpl;
- protected boolean isMetadataComplete;
- protected JavaClass superClassOverride;
-
- protected static final String XML_REGISTRY_CLASS_NAME = "jakarta.xml.bind.annotation.XmlRegistry";
-
- public JavaClassImpl(Class javaClass, JavaModelImpl javaModelImpl) {
- this.jClass = javaClass;
- this.javaModelImpl = javaModelImpl;
- isMetadataComplete = false;
- }
-
- public JavaClassImpl(ParameterizedType javaType, Class javaClass, JavaModelImpl javaModelImpl) {
- this.jType = javaType;
- this.jClass = javaClass;
- this.javaModelImpl = javaModelImpl;
- isMetadataComplete = false;
- }
-
- public void setJavaModelImpl(JavaModelImpl javaModel) {
- this.javaModelImpl = javaModel;
- }
- public Collection getActualTypeArguments() {
- ArrayList<JavaClass> argCollection = new ArrayList<JavaClass>();
- if (jType != null) {
- Type[] params = jType.getActualTypeArguments();
- for (Type type : params) {
- if (type instanceof ParameterizedType) {
- ParameterizedType pt = (ParameterizedType) type;
- argCollection.add(new JavaClassImpl(pt, (Class) pt.getRawType(), javaModelImpl));
- } else if(type instanceof WildcardType){
- Type[] upperTypes = ((WildcardType)type).getUpperBounds();
- if(upperTypes.length >0){
- Type upperType = upperTypes[0];
- if(upperType instanceof Class){
- argCollection.add(javaModelImpl.getClass((Class) upperType));
- }
- }
- } else if (type instanceof Class) {
- argCollection.add(javaModelImpl.getClass((Class) type));
- } else if(type instanceof GenericArrayType) {
- Class genericTypeClass = (Class)((GenericArrayType)type).getGenericComponentType();
- genericTypeClass = java.lang.reflect.Array.newInstance(genericTypeClass, 0).getClass();
- argCollection.add(javaModelImpl.getClass(genericTypeClass));
- } else if(type instanceof TypeVariable) {
- Type[] boundTypes = ((TypeVariable) type).getBounds();
- if(boundTypes.length > 0) {
- Type boundType = boundTypes[0];
- if(boundType instanceof Class) {
- argCollection.add(javaModelImpl.getClass((Class) boundType));
- }
- }
- }
- }
- }
- return argCollection;
- }
-
- public String toString() {
- return getName();
- }
-
- /**
- * Assumes JavaType is a JavaClassImpl instance
- */
- public JavaAnnotation getAnnotation(JavaClass arg0) {
- // the only annotation we will return if isMetadataComplete == true is XmlRegistry
- if (arg0 != null && (!isMetadataComplete || arg0.getQualifiedName().equals(XML_REGISTRY_CLASS_NAME))) {
- Class annotationClass = ((JavaClassImpl) arg0).getJavaClass();
- if (javaModelImpl.getAnnotationHelper().isAnnotationPresent(getAnnotatedElement(), annotationClass)) {
- return new JavaAnnotationImpl(this.javaModelImpl.getAnnotationHelper().getAnnotation(getAnnotatedElement(), annotationClass));
- }
- }
- return null;
- }
-
- public Collection<JavaAnnotation> getAnnotations() {
- List<JavaAnnotation> annotationCollection = new ArrayList<JavaAnnotation>();
- if (!isMetadataComplete) {
- Annotation[] annotations = javaModelImpl.getAnnotationHelper().getAnnotations(getAnnotatedElement());
- for (Annotation annotation : annotations) {
- annotationCollection.add(new JavaAnnotationImpl(annotation));
- }
- }
- return annotationCollection;
- }
-
- public Collection<JavaClass> getDeclaredClasses() {
- List<JavaClass> classCollection = new ArrayList<JavaClass>();
- Class[] classes = jClass.getDeclaredClasses();
- for (Class javaClass : classes) {
- classCollection.add(javaModelImpl.getClass(javaClass));
- }
- return classCollection;
- }
-
- public JavaField getDeclaredField(String arg0) {
- try {
- return getJavaField(jClass.getDeclaredField(arg0));
- } catch (NoSuchFieldException nsfe) {
- return null;
- }
- }
-
- public Collection<JavaField> getDeclaredFields() {
- List<JavaField> fieldCollection = new ArrayList<JavaField>();
- Field[] fields = PrivilegedAccessHelper.getDeclaredFields(jClass);
-
- for (Field field : fields) {
- field.setAccessible(true);
- fieldCollection.add(getJavaField(field));
- }
- return fieldCollection;
- }
-
- /**
- * Assumes JavaType[] contains JavaClassImpl instances
- */
- public JavaMethod getDeclaredMethod(String arg0, JavaClass[] arg1) {
- if (arg1 == null) {
- arg1 = new JavaClass[0];
- }
- Class[] params = new Class[arg1.length];
- for (int i=0; i<arg1.length; i++) {
- JavaClass jType = arg1[i];
- if (jType != null) {
- params[i] = ((JavaClassImpl) jType).getJavaClass();
- }
- }
- try {
- return getJavaMethod(jClass.getDeclaredMethod(arg0, params));
- } catch (NoSuchMethodException nsme) {
- return null;
- }
- }
-
- public Collection getDeclaredMethods() {
- ArrayList<JavaMethod> methodCollection = new ArrayList<JavaMethod>();
- Method[] methods = jClass.getDeclaredMethods();
- for (Method method : methods) {
- methodCollection.add(getJavaMethod(method));
- }
- return methodCollection;
- }
-
- public JavaConstructor getConstructor(JavaClass[] paramTypes) {
- if (paramTypes == null) {
- paramTypes = new JavaClass[0];
- }
- Class[] params = new Class[paramTypes.length];
- for (int i=0; i<paramTypes.length; i++) {
- JavaClass jType = paramTypes[i];
- if (jType != null) {
- params[i] = ((JavaClassImpl) jType).getJavaClass();
- }
- }
- try {
- Constructor constructor = PrivilegedAccessHelper.getConstructorFor(jClass, params, true);
- return new JavaConstructorImpl(constructor, javaModelImpl);
- } catch (NoSuchMethodException nsme) {
- return null;
- }
- }
-
- public JavaConstructor getDeclaredConstructor(JavaClass[] paramTypes) {
- if (paramTypes == null) {
- paramTypes = new JavaClass[0];
- }
- Class[] params = new Class[paramTypes.length];
- for (int i=0; i<paramTypes.length; i++) {
- JavaClass jType = paramTypes[i];
- if (jType != null) {
- params[i] = ((JavaClassImpl) jType).getJavaClass();
- }
- }
- try {
- return new JavaConstructorImpl(PrivilegedAccessHelper.getDeclaredConstructorFor(this.jClass, params, true), javaModelImpl);
- } catch (NoSuchMethodException nsme) {
- return null;
- }
- }
-
- public Collection getConstructors() {
- Constructor[] constructors = this.jClass.getConstructors();
- ArrayList<JavaConstructor> constructorCollection = new ArrayList(constructors.length);
- for(Constructor next:constructors) {
- constructorCollection.add(new JavaConstructorImpl(next, javaModelImpl));
- }
- return constructorCollection;
- }
-
- public Collection getDeclaredConstructors() {
- Constructor[] constructors = this.jClass.getDeclaredConstructors();
- ArrayList<JavaConstructor> constructorCollection = new ArrayList(constructors.length);
- for(Constructor next:constructors) {
- constructorCollection.add(new JavaConstructorImpl(next, javaModelImpl));
- }
- return constructorCollection;
- }
-
- public JavaField getField(String arg0) {
- try {
- Field field = PrivilegedAccessHelper.getField(jClass, arg0, true);
- return getJavaField(field);
- } catch (NoSuchFieldException nsfe) {
- return null;
- }
- }
-
- public Collection getFields() {
- ArrayList<JavaField> fieldCollection = new ArrayList<JavaField>();
- Field[] fields = PrivilegedAccessHelper.getFields(jClass);
- for (Field field : fields) {
- fieldCollection.add(getJavaField(field));
- }
- return fieldCollection;
- }
-
- public Class getJavaClass() {
- return jClass;
- }
-
- /**
- * Assumes JavaType[] contains JavaClassImpl instances
- */
- public JavaMethod getMethod(String arg0, JavaClass[] arg1) {
- if (arg1 == null) {
- arg1 = new JavaClass[0];
- }
- Class[] params = new Class[arg1.length];
- for (int i=0; i<arg1.length; i++) {
- JavaClass jType = arg1[i];
- if (jType != null) {
- params[i] = ((JavaClassImpl) jType).getJavaClass();
- }
- }
- try {
- Method method = PrivilegedAccessHelper.getMethod(jClass, arg0, params, true);
- return getJavaMethod(method);
- } catch (NoSuchMethodException nsme) {
- return null;
- }
- }
-
- public Collection getMethods() {
- ArrayList<JavaMethod> methodCollection = new ArrayList<JavaMethod>();
- Method[] methods = PrivilegedAccessHelper.getMethods(jClass);
- for (Method method : methods) {
- methodCollection.add(getJavaMethod(method));
- }
- return methodCollection;
- }
-
- public String getName() {
- return jClass.getName();
- }
-
- public JavaPackage getPackage() {
- return new JavaPackageImpl(jClass.getPackage(), javaModelImpl, isMetadataComplete);
- }
-
- public String getPackageName() {
- if(jClass.getPackage() != null){
- return jClass.getPackage().getName();
- }else{
- Class nonInnerClass = jClass;
- Class enclosingClass = jClass.getEnclosingClass();
- while(enclosingClass != null){
- nonInnerClass = enclosingClass;
- enclosingClass = nonInnerClass.getEnclosingClass();
- }
- String className = nonInnerClass.getCanonicalName();
- if(className !=null){
- int index = className.lastIndexOf('.');
- if(index > -1){
- return className.substring(0, index);
- }
- }
- }
- return null;
- }
-
- public String getQualifiedName() {
- return jClass.getName();
- }
-
- public String getRawName() {
- return jClass.getCanonicalName();
- }
-
- public JavaClass getSuperclass() {
- if(this.superClassOverride != null) {
- return this.superClassOverride;
- }
- if(jClass.isInterface()) {
- Class[] superInterfaces = jClass.getInterfaces();
- if(superInterfaces != null) {
- if(superInterfaces.length == 1) {
- return javaModelImpl.getClass(superInterfaces[0]);
- } else {
- Class parent = null;
- for(Class next:superInterfaces) {
- if(!(next.getName().startsWith("java.")
- || next.getName().startsWith("javax.")
- || next.getName().startsWith("jakarta."))) {
- if(parent == null) {
- parent = next;
- } else {
- throw JAXBException.invalidInterface(jClass.getName());
- }
- }
- }
- return javaModelImpl.getClass(parent);
- }
- }
- }
- return javaModelImpl.getClass(jClass.getSuperclass());
- }
-
- @Override
- public Type[] getGenericInterfaces() {
- return jClass.getGenericInterfaces();
- }
-
- public Type getGenericSuperclass() {
- return jClass.getGenericSuperclass();
- }
-
- public boolean hasActualTypeArguments() {
- return getActualTypeArguments().size() > 0;
- }
-
- public JavaField getJavaField(Field field) {
- return new JavaFieldImpl(field, javaModelImpl, isMetadataComplete);
- }
-
- public JavaMethod getJavaMethod(Method method) {
- return new JavaMethodImpl(method, javaModelImpl, isMetadataComplete);
- }
-
- public JavaClass getOwningClass() {
- return javaModelImpl.getClass(jClass.getEnclosingClass());
- }
-
- public boolean isAnnotation() {
- return jClass.isAnnotation();
- }
-
- public boolean isArray() {
- return jClass.isArray();
- }
-
- public AnnotatedElement getAnnotatedElement() {
- return jClass;
- }
-
- public boolean isAssignableFrom(JavaClass arg0) {
- if (!(arg0 instanceof JavaClassImpl)) {
- return false;
- }
- if(hasCustomSuperClass(arg0)) {
- return this.customIsAssignableFrom(arg0);
- }
- return jClass.isAssignableFrom(((JavaClassImpl) arg0).getJavaClass());
- }
-
- private boolean customIsAssignableFrom(JavaClass arg0) {
- JavaClassImpl jClass = (JavaClassImpl)arg0;
- Class cls = jClass.getJavaClass();
-
- if(cls == this.jClass) {
- return true;
- }
- Class[] interfaces = cls.getInterfaces();
- for(Class nextInterface:interfaces) {
- if(nextInterface == this.jClass) {
- return true;
- }
- if(customIsAssignableFrom(javaModelImpl.getClass(nextInterface))) {
- return true;
- }
- }
-
- if(!(jClass.isInterface())) {
- JavaClassImpl superJavaClass = (JavaClassImpl)jClass.getSuperclass();
- if(superJavaClass.getName().equals("java.lang.Object")) {
- return this.jClass == superJavaClass.getJavaClass();
- }
- return customIsAssignableFrom(superJavaClass);
- }
- return false;
- }
-
- private boolean hasCustomSuperClass(JavaClass arg0) {
- if(arg0 == null) {
- return false;
- }
- if(!this.javaModelImpl.hasXmlBindings()) {
- return false;
- }
- if(!(arg0.getClass() == this.getClass())) {
- return false;
- }
- if(arg0.getName().equals("java.lang.Object")) {
- return false;
- }
- JavaClassImpl jClass = (JavaClassImpl)arg0;
- return jClass.getSuperClassOverride() != null || hasCustomSuperClass(jClass.getSuperclass());
- }
-
- public boolean isEnum() {
- return jClass.isEnum();
- }
-
- public boolean isInterface() {
- return jClass.isInterface();
- }
-
- public boolean isMemberClass() {
- return jClass.isMemberClass();
- }
-
- public boolean isPrimitive() {
- return jClass.isPrimitive();
- }
-
- public boolean isAbstract() {
- return Modifier.isAbstract(getModifiers());
- }
-
- public boolean isPrivate() {
- return Modifier.isPrivate(getModifiers());
- }
-
- public boolean isProtected() {
- return Modifier.isProtected(getModifiers());
- }
-
- public boolean isPublic() {
- return Modifier.isPublic(getModifiers());
- }
-
- public boolean isStatic() {
- return Modifier.isStatic(getModifiers());
- }
-
- public int getModifiers() {
- return jClass.getModifiers();
- }
-
- public boolean isFinal() {
- return Modifier.isFinal(getModifiers());
- }
-
- public boolean isSynthetic() {
- return jClass.isSynthetic();
- }
-
- @Override
- public JavaClassInstanceOf instanceOf() {
- return JavaClassInstanceOf.JAVA_CLASS_IMPL;
- }
-
- public JavaClass getComponentType() {
- if(!isArray()) {
- return null;
- }
- return javaModelImpl.getClass(this.jClass.getComponentType());
- }
-
- public JavaClass getSuperClassOverride() {
- return superClassOverride;
- }
-
- public void setSuperClassOverride(JavaClass superClassOverride) {
- this.superClassOverride = superClassOverride;
- }
- /**
- * Set the indicator for XML metadata complete - if true,
- * annotations will be ignored.
- *
- * @param isMetadataComplete
- */
- void setIsMetadataComplete(Boolean isMetadataComplete) {
- if(isMetadataComplete != null){
- this.isMetadataComplete = isMetadataComplete;
- }
- }
-
- public JavaAnnotation getDeclaredAnnotation(JavaClass arg0) {
- // the only annotation we will return if isMetadataComplete == true is XmlRegistry
- if (arg0 != null && (!isMetadataComplete || arg0.getQualifiedName().equals(XML_REGISTRY_CLASS_NAME))) {
- Class annotationClass = ((JavaClassImpl) arg0).getJavaClass();
- Annotation[] annotations = javaModelImpl.getAnnotationHelper().getDeclaredAnnotations(getAnnotatedElement());
- for (Annotation annotation : annotations) {
- if (annotation.annotationType().equals(annotationClass)) {
- return new JavaAnnotationImpl(annotation);
- }
- }
- }
- return null;
- }
-
- public Collection getDeclaredAnnotations() {
- List<JavaAnnotation> annotationCollection = new ArrayList<JavaAnnotation>();
- if (!isMetadataComplete) {
- Annotation[] annotations = javaModelImpl.getAnnotationHelper().getDeclaredAnnotations(getAnnotatedElement());
- for (Annotation annotation : annotations) {
- annotationCollection.add(new JavaAnnotationImpl(annotation));
- }
- }
- return annotationCollection;
- }
-
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java b/jakarta/src/patch/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java
deleted file mode 100644
index 7bce14a..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/jaxb/rs/MOXyJsonProvider.java
+++ /dev/null
@@ -1,986 +0,0 @@
-/*
- * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// Blaise Doughan - 2.4 - initial implementation
-package org.eclipse.persistence.jaxb.rs;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.Reader;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Array;
-import java.lang.reflect.GenericArrayType;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.lang.reflect.WildcardType;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.NavigableSet;
-import java.util.Queue;
-import java.util.Set;
-import java.util.SortedSet;
-import java.util.TreeSet;
-
-import jakarta.activation.DataSource;
-import jakarta.ws.rs.Consumes;
-import jakarta.ws.rs.Produces;
-import jakarta.ws.rs.WebApplicationException;
-import jakarta.ws.rs.core.Context;
-import jakarta.ws.rs.core.MediaType;
-import jakarta.ws.rs.core.MultivaluedMap;
-import jakarta.ws.rs.core.Response;
-import jakarta.ws.rs.core.Response.ResponseBuilder;
-import jakarta.ws.rs.core.Response.Status;
-import jakarta.ws.rs.core.StreamingOutput;
-import jakarta.ws.rs.ext.ContextResolver;
-import jakarta.ws.rs.ext.MessageBodyReader;
-import jakarta.ws.rs.ext.MessageBodyWriter;
-import jakarta.ws.rs.ext.Provider;
-import jakarta.ws.rs.ext.Providers;
-import jakarta.xml.bind.JAXBContext;
-import jakarta.xml.bind.JAXBElement;
-import jakarta.xml.bind.JAXBException;
-import jakarta.xml.bind.JAXBIntrospector;
-import jakarta.xml.bind.Marshaller;
-import jakarta.xml.bind.UnmarshalException;
-import jakarta.xml.bind.Unmarshaller;
-import javax.xml.namespace.QName;
-import javax.xml.transform.stream.StreamSource;
-
-import org.eclipse.persistence.internal.core.helper.CoreClassConstants;
-import org.eclipse.persistence.internal.helper.Helper;
-import org.eclipse.persistence.internal.oxm.Constants;
-import org.eclipse.persistence.internal.queries.CollectionContainerPolicy;
-import org.eclipse.persistence.internal.queries.ContainerPolicy;
-import org.eclipse.persistence.jaxb.JAXBContextFactory;
-import org.eclipse.persistence.jaxb.MarshallerProperties;
-import org.eclipse.persistence.jaxb.UnmarshallerProperties;
-import org.eclipse.persistence.logging.AbstractSessionLog;
-import org.eclipse.persistence.logging.SessionLog;
-import org.eclipse.persistence.oxm.JSONWithPadding;
-
-/**
- * <p>This is an implementation of <i>MessageBodyReader</i>/<i>MessageBodyWriter
- * </i> that can be used to enable EclipseLink JAXB (MOXy) as the JSON
- * provider.</p>
- * <p>
- * <b>Supported Media Type Patterns</b>
- * <ul>
- * <li>*/json (i.e. application/json and text/json)</li>
- * <li>*/*+json</li>
- * </ul>
- *
- * <p>Below are some different usage options.</p>
- *
- * <b>Option #1 - <i>MOXyJsonProvider</i> Default Behavior</b>
- * <p>You can use the <i>Application</i> class to specify that
- * <i>MOXyJsonProvider</i> should be used with your JAX-RS application.</p>
- * <pre>
- * package org.example;
-
- * import java.util.*;
- * import javax.ws.rs.core.Application;
- * import org.eclipse.persistence.jaxb.rs.MOXyJsonProvider;
- *
- * public class ExampleApplication extends Application {
- *
- * @Override
- * public Set<Class<?>> getClasses() {
- * HashSet<Class<?>> set = new HashSet<Class<?>>(2);
- * set.add(MOXyJsonProvider.class);
- * set.add(ExampleService.class);
- * return set;
- * }
- *
- * }
- * </pre>
- *
- * <b>Option #2 - Customize <i>MOXyJsonProvider</i></b>
- * <p>You can use the <i>Application</i> class to specify a configured instance
- * of <i>MOXyJsonProvider</i> should be used with your JAX-RS application.</p>
- * <pre>
- * package org.example;
- *
- * import java.util.*;
- * import javax.ws.rs.core.Application;
- * import org.eclipse.persistence.jaxb.rs.MOXyJsonProvider;
- *
- * public class CustomerApplication extends Application {
- *
- * @Override
- * public Set<Class<?>> getClasses() {
- * HashSet<Class<?>> set = new HashSet<Class<?>>(1);
- * set.add(ExampleService.class);
- * return set;
- * }
-
- * @Override
- * public Set<Object> getSingletons() {
- * moxyJsonProvider moxyJsonProvider = new MOXyJsonProvider();
- * moxyJsonProvider.setFormattedOutput(true);
- * moxyJsonProvider.setIncludeRoot(true);
- *
- * HashSet<Object> set = new HashSet<Object>(2);
- * set.add(moxyJsonProvider);
- * return set;
- * }
- *
- * }
- * </pre>
- * <b>Option #3 - Extend MOXyJsonProvider</b>
- * <p>You can use MOXyJsonProvider for creating your own
- * <i>MessageBodyReader</i>/<i>MessageBodyWriter</i>.</p>
- * <pre>
- * package org.example;
- *
- * import java.lang.annotation.Annotation;
- * import java.lang.reflect.Type;
- *
- * import javax.ws.rs.*;
- * import javax.ws.rs.core.*;
- * import javax.ws.rs.ext.Provider;
- * import javax.xml.bind.*;
- *
- * import org.eclipse.persistence.jaxb.MarshallerProperties;
- * import org.eclipse.persistence.jaxb.rs.MOXyJsonProvider;
- *
- * @Provider
- * @Produces(MediaType.APPLICATION_JSON)
- * @Consumes(MediaType.APPLICATION_JSON)
- * public class CustomerJSONProvider extends MOXyJsonProvider {
-
- * @Override
- * public boolean isReadable(Class<?> type, Type genericType,
- * Annotation[] annotations, MediaType mediaType) {
- * return getDomainClass(genericType) == Customer.class;
- * }
- *
- * @Override
- * public boolean isWriteable(Class<?> type, Type genericType,
- * Annotation[] annotations, MediaType mediaType) {
- * return isReadable(type, genericType, annotations, mediaType);
- * }
- *
- * @Override
- * protected void preReadFrom(Class<Object> type, Type genericType,
- * Annotation[] annotations, MediaType mediaType,
- * MultivaluedMap<String, String> httpHeaders,
- * Unmarshaller unmarshaller) throws JAXBException {
- * unmarshaller.setProperty(MarshallerProperties.JSON_VALUE_WRAPPER, "$");
- * }
- *
- * @Override
- * protected void preWriteTo(Object object, Class<?> type, Type genericType,
- * Annotation[] annotations, MediaType mediaType,
- * MultivaluedMap<String, Object> httpHeaders, Marshaller marshaller)
- * throws JAXBException {
- * marshaller.setProperty(MarshallerProperties.JSON_VALUE_WRAPPER, "$");
- * }
- *
- * }
- * </pre>
- * @since 2.4
- */
-@Produces({MediaType.APPLICATION_JSON, MediaType.WILDCARD, "application/x-javascript"})
-@Consumes({MediaType.APPLICATION_JSON, MediaType.WILDCARD})
-public class MOXyJsonProvider implements MessageBodyReader<Object>, MessageBodyWriter<Object>{
-
- private static final String APPLICATION_XJAVASCRIPT = "application/x-javascript";
- private static final String CHARSET = "charset";
- private static final QName EMPTY_STRING_QNAME = new QName("");
- private static final String JSON = "json";
- private static final String PLUS_JSON = "+json";
-
- @Context
- protected Providers providers;
-
- private String attributePrefix = null;
- private Map<Set<Class<?>>, JAXBContext> contextCache = new HashMap<Set<Class<?>>, JAXBContext>();
- private boolean formattedOutput = false;
- private boolean includeRoot = false;
- private boolean marshalEmptyCollections = true;
- private Map<String, String> namespacePrefixMapper;
- private char namespaceSeperator = Constants.DOT;
- private String valueWrapper;
- private boolean wrapperAsArrayName = false;
-
- /**
- * The value that will be prepended to all keys that are mapped to an XML
- * attribute. By default there is no attribute prefix.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_ATTRIBUTE_PREFIX
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_ATTRIBUTE_PREFIX
- */
- public String getAttributePrefix() {
- return attributePrefix;
- }
-
- /**
- * A convenience method to get the domain class (i.e. <i>Customer</i> or <i>Foo, Bar</i>) from
- * the parameter/return type (i.e. <i>Customer</i>, <i>List<Customer></i>,
- * <i>JAXBElement<Customer></i>, <i>JAXBElement<? extends Customer></i>,
- * <i>List<JAXBElement<Customer>></i>, or
- * <i>List<JAXBElement<? extends Customer>></i>
- * <i>List<Foo<Bar>></i>).
- * @param genericType - The parameter/return type of the JAX-RS operation.
- * @return The corresponding domain classes.
- */
- protected Set<Class<?>> getDomainClasses(Type genericType) {
- if(null == genericType) {
- return asSet(Object.class);
- }
- if(genericType instanceof Class && genericType != JAXBElement.class) {
- Class<?> clazz = (Class<?>) genericType;
- if(clazz.isArray()) {
- return getDomainClasses(clazz.getComponentType());
- }
- return asSet(clazz);
- } else if(genericType instanceof ParameterizedType) {
- Set<Class<?>> result = new LinkedHashSet<Class<?>>();
- result.add((Class<?>)((ParameterizedType) genericType).getRawType());
- Type[] types = ((ParameterizedType) genericType).getActualTypeArguments();
- if(types.length > 0){
- for (Type upperType : types) {
- result.addAll(getDomainClasses(upperType));
- }
- }
- return result;
- } else if (genericType instanceof GenericArrayType) {
- GenericArrayType genericArrayType = (GenericArrayType) genericType;
- return getDomainClasses(genericArrayType.getGenericComponentType());
- } else if(genericType instanceof WildcardType) {
- Set<Class<?>> result = new LinkedHashSet<Class<?>>();
- Type[] upperTypes = ((WildcardType)genericType).getUpperBounds();
- if(upperTypes.length > 0){
- for (Type upperType : upperTypes) {
- result.addAll(getDomainClasses(upperType));
- }
- } else {
- result.add(Object.class);
- }
- return result;
- } else {
- return asSet(Object.class);
- }
- }
-
- private Set<Class<?>> asSet(Class<?> clazz) {
- Set<Class<?>> result = new LinkedHashSet<>();
- result.add(clazz);
- return result;
- }
-
- /**
- * Return the <i>JAXBContext</i> that corresponds to the domain class. This
- * method does the following:
- * <ol>
- * <li>If an EclipseLink JAXB (MOXy) <i>JAXBContext</i> is available from
- * a <i>ContextResolver</i> then use it.</li>
- * <li>If an existing <i>JAXBContext</i> was not found in step one, then
- * create a new one on the domain class.</li>
- * </ol>
- * @param domainClasses - The domain classes we need a <i>JAXBContext</i> for.
- * @param annotations - The annotations corresponding to domain object.
- * @param mediaType - The media type for the HTTP entity.
- * @param httpHeaders - HTTP headers associated with HTTP entity.
- * @return
- * @throws JAXBException
- */
- protected JAXBContext getJAXBContext(Set<Class<?>> domainClasses, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, ?> httpHeaders) throws JAXBException {
-
- JAXBContext jaxbContext = contextCache.get(domainClasses);
- if(null != jaxbContext) {
- return jaxbContext;
- }
-
- synchronized (contextCache) {
- jaxbContext = contextCache.get(domainClasses);
- if(null != jaxbContext) {
- return jaxbContext;
- }
-
- ContextResolver<JAXBContext> resolver = null;
- if(null != providers) {
- resolver = providers.getContextResolver(JAXBContext.class, mediaType);
- }
-
- if (null != resolver && domainClasses.size() == 1) {
- jaxbContext = resolver.getContext(domainClasses.iterator().next());
- }
-
- if(null == jaxbContext) {
- jaxbContext = JAXBContextFactory.createContext(domainClasses.toArray(new Class[0]), null);
- contextCache.put(domainClasses, jaxbContext);
- return jaxbContext;
- } else if (jaxbContext instanceof org.eclipse.persistence.jaxb.JAXBContext) {
- return jaxbContext;
- } else {
- jaxbContext = JAXBContextFactory.createContext(domainClasses.toArray(new Class[0]), null);
- contextCache.put(domainClasses, jaxbContext);
- return jaxbContext;
- }
- }
- }
-
- private JAXBContext getJAXBContext(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
- if(null == genericType) {
- genericType = type;
- }
-
- try {
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
- return getJAXBContext(domainClasses, annotations, mediaType, null);
- } catch(JAXBException e) {
- AbstractSessionLog.getLog().logThrowable(SessionLog.WARNING, SessionLog.MOXY, e);
- return null;
- }
- }
-
- /**
- * By default the JSON-binding will ignore namespace qualification. If this
- * property is set the portion of the key before the namespace separator
- * will be used to determine the namespace URI.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#NAMESPACE_PREFIX_MAPPER
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_NAMESPACE_PREFIX_MAPPER
- */
- public Map<String, String> getNamespacePrefixMapper() {
- return namespacePrefixMapper;
- }
-
- /**
- * This character (default is '.') separates the prefix from the key name.
- * It is only used if namespace qualification has been enabled be setting a
- * namespace prefix mapper.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_NAMESPACE_SEPARATOR
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_NAMESPACE_SEPARATOR
- */
- public char getNamespaceSeparator() {
- return this.namespaceSeperator;
- }
-
- /*
- * @return -1 since the size of the JSON message is not known.
- * @see javax.ws.rs.ext.MessageBodyWriter#getSize(java.lang.Object, java.lang.Class, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)
- */
- @Override
- public long getSize(Object t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
- return -1;
- }
-
- /**
- * The key that will correspond to the property mapped with @XmlValue. This
- * key will only be used if there are other mapped properties.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_VALUE_WRAPPER
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_VALUE_WRAPPER
- */
- public String getValueWrapper() {
- return valueWrapper;
- }
-
- /**
- * @return true if the JSON output should be formatted (default is false).
- */
- public boolean isFormattedOutput() {
- return formattedOutput;
- }
-
- /**
- * @return true if the root node is included in the JSON message (default is
- * false).
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_INCLUDE_ROOT
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_INCLUDE_ROOT
- */
- public boolean isIncludeRoot() {
- return includeRoot;
- }
-
- /**
- * If true empty collections will be marshalled as empty arrays, else the
- * collection will not be marshalled to JSON (default is true).
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_MARSHAL_EMPTY_COLLECTIONS
- */
- public boolean isMarshalEmptyCollections() {
- return marshalEmptyCollections;
- }
-
- /**
- * @return true indicating that <i>MOXyJsonProvider</i> will
- * be used for the JSON binding if the media type is of the following
- * patterns */json or */*+json, and the type is not assignable from
- * any of (or a Collection or JAXBElement of) the following:
- * <ul>
- * <li>byte[]</li>
- * <li>java.io.File</li>
- * <li>java.io.InputStream</li>
- * <li>java.io.Reader</li>
- * <li>java.lang.Object</li>
- * <li>java.lang.String</li>
- * <li>javax.activation.DataSource</li>
- * </ul>
- */
- @Override
- public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
- if(!supportsMediaType(mediaType)) {
- return false;
- } else if(CoreClassConstants.APBYTE == type || CoreClassConstants.STRING == type) {
- return false;
- } else if(Map.class.isAssignableFrom(type)) {
- return false;
- } else if(File.class.isAssignableFrom(type)) {
- return false;
- } else if(DataSource.class.isAssignableFrom(type)) {
- return false;
- } else if(InputStream.class.isAssignableFrom(type)) {
- return false;
- } else if(Reader.class.isAssignableFrom(type)) {
- return false;
- } else if(Object.class == type) {
- return false;
- } else if(type.isPrimitive()) {
- return false;
- } else if(type.isArray() && (type.getComponentType().isArray() || type.getComponentType().isPrimitive() || type.getComponentType().getPackage().getName().startsWith("java."))) {
- return false;
- } else if(JAXBElement.class.isAssignableFrom(type)) {
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
- for (Class<?> domainClass : domainClasses) {
- if (isReadable(domainClass, null, annotations, mediaType) || String.class == domainClass) {
- return true;
- }
- }
- return false;
- } else if(Collection.class.isAssignableFrom(type)) {
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
- for (Class<?> domainClass : domainClasses) {
- if (isReadable(domainClass, null, annotations, mediaType) || String.class == domainClass) {
- return true;
- }
- }
- return false;
- } else {
- return null != getJAXBContext(type, genericType, annotations, mediaType);
- }
- }
-
- /**
- * If true the grouping element will be used as the JSON key.
- *
- * <p><b>Example</b></p>
- * <p>Given the following class:</p>
- * <pre>
- * @XmlAccessorType(XmlAccessType.FIELD)
- * public class Customer {
- *
- * @XmlElementWrapper(name="phone-numbers")
- * @XmlElement(name="phone-number")
- * private {@literal List<PhoneNumber>} phoneNumbers;
- *
- * }
- * </pre>
- * <p>If the property is set to false (the default) the JSON output will be:</p>
- * <pre>
- * {
- * "phone-numbers" : {
- * "phone-number" : [ {
- * ...
- * }, {
- * ...
- * }]
- * }
- * }
- * </pre>
- * <p>And if the property is set to true, then the JSON output will be:</p>
- * <pre>
- * {
- * "phone-numbers" : [ {
- * ...
- * }, {
- * ...
- * }]
- * }
- * </pre>
- * @since 2.4.2
- * @see org.eclipse.persistence.jaxb.JAXBContextProperties#JSON_WRAPPER_AS_ARRAY_NAME
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_WRAPPER_AS_ARRAY_NAME
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_WRAPPER_AS_ARRAY_NAME
- */
- public boolean isWrapperAsArrayName() {
- return wrapperAsArrayName;
- }
-
- /**
- * @return true indicating that <i>MOXyJsonProvider</i> will
- * be used for the JSON binding if the media type is of the following
- * patterns */json or */*+json, and the type is not assignable from
- * any of (or a Collection or JAXBElement of) the following:
- * <ul>
- * <li>byte[]</li>
- * <li>java.io.File</li>
- * <li>java.lang.Object</li>
- * <li>java.lang.String</li>
- * <li>jakarta.activation.DataSource</li>
- * <li>jakarta.ws.rs.core.StreamingOutput</li>
- * </ul>
- */
- @Override
- public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
- if(type == JSONWithPadding.class && APPLICATION_XJAVASCRIPT.equals(mediaType.toString())) {
- return true;
- }
- if(!supportsMediaType(mediaType)) {
- return false;
- } else if(CoreClassConstants.APBYTE == type || CoreClassConstants.STRING == type || type.isPrimitive()) {
- return false;
- } else if(Map.class.isAssignableFrom(type)) {
- return false;
- } else if(File.class.isAssignableFrom(type)) {
- return false;
- } else if(DataSource.class.isAssignableFrom(type)) {
- return false;
- } else if(StreamingOutput.class.isAssignableFrom(type)) {
- return false;
- } else if(Object.class == type) {
- return false;
- } else if(type.isPrimitive()) {
- return false;
- } else if(type.isArray() && (String.class.equals(type.getComponentType()) || type.getComponentType().isPrimitive() || Helper.isPrimitiveWrapper(type.getComponentType()))) {
- return true;
- } else if(type.isArray() && (type.getComponentType().isArray() || type.getComponentType().isPrimitive() || type.getComponentType().getPackage().getName().startsWith("java."))) {
- return false;
- } else if(JAXBElement.class.isAssignableFrom(type)) {
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
-
- for (Class<?> domainClass : domainClasses) {
- if (isWriteable(domainClass, null, annotations, mediaType) || domainClass == String.class) {
- return true;
- }
- }
-
- return false;
- } else if(Collection.class.isAssignableFrom(type)) {
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
-
- //special case for List<JAXBElement<String>>
- //this is quick fix, MOXyJsonProvider should be refactored as stated in issue #459541
- if (domainClasses.size() == 3) {
- Class[] domainArray = domainClasses.toArray(new Class[domainClasses.size()]);
- if (JAXBElement.class.isAssignableFrom(domainArray[1]) && String.class == domainArray[2]) {
- return true;
- }
- }
-
- for (Class<?> domainClass : domainClasses) {
-
- if (String.class.equals(domainClass) || domainClass.isPrimitive() || Helper.isPrimitiveWrapper(domainClass)) {
- return true;
- }
-
- String packageName = domainClass.getPackage().getName();
- if(null == packageName || !packageName.startsWith("java.")) {
- if (isWriteable(domainClass, null, annotations, mediaType)) {
- return true;
- }
- }
- }
- return false;
- } else {
- return null != getJAXBContext(type, genericType, annotations, mediaType);
- }
- }
-
- /**
- * Subclasses of <i>MOXyJsonProvider</i> can override this method to
- * customize the instance of <i>Unmarshaller</i> that will be used to
- * unmarshal the JSON message in the readFrom call.
- * @param type - The Class to be unmarshalled (i.e. <i>Customer</i> or
- * <i>List</i>)
- * @param genericType - The type of object to be unmarshalled (i.e
- * <i>Customer</i> or <i>List<Customer></i>).
- * @param annotations - The annotations corresponding to domain object.
- * @param mediaType - The media type for the HTTP entity.
- * @param httpHeaders - HTTP headers associated with HTTP entity.
- * @param unmarshaller - The instance of <i>Unmarshaller</i> that will be
- * used to unmarshal the JSON message.
- * @throws JAXBException
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties
- */
- protected void preReadFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, Unmarshaller unmarshaller) throws JAXBException {
- }
-
- /**
- * Subclasses of <i>MOXyJsonProvider</i> can override this method to
- * customize the instance of <i>Marshaller</i> that will be used to marshal
- * the domain objects to JSON in the writeTo call.
- * @param object - The domain object that will be marshalled to JSON.
- * @param type - The Class to be marshalled (i.e. <i>Customer</i> or
- * <i>List</i>)
- * @param genericType - The type of object to be marshalled (i.e
- * <i>Customer</i> or <i>List<Customer></i>).
- * @param annotations - The annotations corresponding to domain object.
- * @param mediaType - The media type for the HTTP entity.
- * @param httpHeaders - HTTP headers associated with HTTP entity.
- * @param marshaller - The instance of <i>Marshaller</i> that will be used
- * to marshal the domain object to JSON.
- * @throws JAXBException
- * @see org.eclipse.persistence.jaxb.MarshallerProperties
- */
- protected void preWriteTo(Object object, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, Marshaller marshaller) throws JAXBException {
- }
-
- /*
- * @see javax.ws.rs.ext.MessageBodyReader#readFrom(java.lang.Class, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap, java.io.InputStream)
- */
- @Override
- public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
- try {
- if(null == genericType) {
- genericType = type;
- }
-
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
- JAXBContext jaxbContext = getJAXBContext(domainClasses, annotations, mediaType, httpHeaders);
- Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
- unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, MediaType.APPLICATION_JSON);
- unmarshaller.setProperty(UnmarshallerProperties.JSON_ATTRIBUTE_PREFIX, attributePrefix);
- unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, includeRoot);
- unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_PREFIX_MAPPER, namespacePrefixMapper);
- unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_SEPARATOR, namespaceSeperator);
- if(null != valueWrapper) {
- unmarshaller.setProperty(UnmarshallerProperties.JSON_VALUE_WRAPPER, valueWrapper);
- }
- unmarshaller.setProperty(UnmarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, wrapperAsArrayName);
- preReadFrom(type, genericType, annotations, mediaType, httpHeaders, unmarshaller);
-
- StreamSource jsonSource;
- Map<String, String> mediaTypeParameters = null;
- if(null != mediaType) {
- mediaTypeParameters = mediaType.getParameters();
- }
- if(null != mediaTypeParameters && mediaTypeParameters.containsKey(CHARSET)) {
- String charSet = mediaTypeParameters.get(CHARSET);
- Reader entityReader = new InputStreamReader(entityStream, charSet);
- jsonSource = new StreamSource(entityReader);
- } else {
- jsonSource = new StreamSource(entityStream);
- }
-
- Class<?> domainClass = getDomainClass(domainClasses);
- JAXBElement<?> jaxbElement = unmarshaller.unmarshal(jsonSource, domainClass);
- if(type.isAssignableFrom(JAXBElement.class)) {
- return jaxbElement;
- } else {
- Object value = jaxbElement.getValue();
- if(value instanceof ArrayList) {
- if(type.isArray()) {
- ArrayList<Object> arrayList = (ArrayList<Object>) value;
- int arrayListSize = arrayList.size();
- boolean wrapItemInJAXBElement = wrapItemInJAXBElement(genericType);
- Object array;
- if(wrapItemInJAXBElement) {
- array = Array.newInstance(JAXBElement.class, arrayListSize);
- } else {
- array = Array.newInstance(domainClass, arrayListSize);
- }
- for(int x=0; x<arrayListSize; x++) {
- Object element = handleJAXBElement(arrayList.get(x), domainClass, wrapItemInJAXBElement);
- Array.set(array, x, element);
- }
- return array;
- } else {
- ContainerPolicy containerPolicy;
- if(type.isAssignableFrom(List.class) || type.isAssignableFrom(ArrayList.class) || type.isAssignableFrom(Collection.class)) {
- containerPolicy = new CollectionContainerPolicy(ArrayList.class);
- } else if(type.isAssignableFrom(Set.class)) {
- containerPolicy = new CollectionContainerPolicy(HashSet.class);
- } else if(type.isAssignableFrom(Deque.class) || type.isAssignableFrom(Queue.class)) {
- containerPolicy = new CollectionContainerPolicy(LinkedList.class);
- } else if(type.isAssignableFrom(NavigableSet.class) || type.isAssignableFrom(SortedSet.class)) {
- containerPolicy = new CollectionContainerPolicy(TreeSet.class);
- } else {
- containerPolicy = new CollectionContainerPolicy(type);
- }
- Object container = containerPolicy.containerInstance();
- boolean wrapItemInJAXBElement = wrapItemInJAXBElement(genericType);
- for(Object element : (Collection<Object>) value) {
- element = handleJAXBElement(element, domainClass, wrapItemInJAXBElement);
- containerPolicy.addInto(element, container, null);
- }
- return container;
- }
- } else {
- return value;
- }
- }
- } catch(UnmarshalException unmarshalException) {
- ResponseBuilder builder = Response.status(Status.BAD_REQUEST);
- throw new WebApplicationException(unmarshalException, builder.build());
- } catch(JAXBException jaxbException) {
- throw new WebApplicationException(jaxbException);
- }
- }
-
- /**
- * Get first non java class if exists.
- *
- * @param domainClasses
- * @return first domain class or first generic class or just the first class from the list
- */
- public Class<?> getDomainClass(Set<Class<?>> domainClasses) {
-
- if (domainClasses.size() == 1) {
- return domainClasses.iterator().next();
- }
-
- boolean isStringPresent = false;
-
- for (Class<?> clazz : domainClasses) {
- if (!clazz.getName().startsWith("java.")
- && !clazz.getName().startsWith("javax.")
- && !clazz.getName().startsWith("jakarta.")
- && !java.util.List.class.isAssignableFrom(clazz)) {
- return clazz;
- } else if (clazz == String.class) {
- isStringPresent = true;
- }
- }
-
- if (isStringPresent) {
- return String.class;
- }
-
- //handle simple generic case
- if (domainClasses.size() >= 2) {
- Iterator<Class<?>> it = domainClasses.iterator();
- it.next();
- return it.next();
- }
-
- return domainClasses.iterator().next();
- }
-
- private boolean wrapItemInJAXBElement(Type genericType) {
- if(genericType == JAXBElement.class) {
- return true;
- } else if(genericType instanceof GenericArrayType) {
- return wrapItemInJAXBElement(((GenericArrayType) genericType).getGenericComponentType());
- } else if(genericType instanceof ParameterizedType) {
- ParameterizedType parameterizedType = (ParameterizedType) genericType;
- Type actualType = parameterizedType.getActualTypeArguments()[0];
- return wrapItemInJAXBElement(parameterizedType.getOwnerType()) || wrapItemInJAXBElement(parameterizedType.getRawType()) || wrapItemInJAXBElement(actualType);
- } else {
- return false;
- }
- }
-
- private Object handleJAXBElement(Object element, Class domainClass, boolean wrapItemInJAXBElement) {
- if(wrapItemInJAXBElement) {
- if(element instanceof JAXBElement) {
- return element;
- } else {
- return new JAXBElement(EMPTY_STRING_QNAME, domainClass, element);
- }
- } else {
- return JAXBIntrospector.getValue(element);
- }
- }
-
- /**
- * Specify a value that will be prepended to all keys that are mapped to an
- * XML attribute. By default there is no attribute prefix.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_ATTRIBUTE_PREFIX
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_ATTRIBUTE_PREFIX
- */
- public void setAttributePrefix(String attributePrefix) {
- this.attributePrefix = attributePrefix;
- }
-
- /**
- * Specify if the JSON output should be formatted (default is false).
- * @param formattedOutput - true if the output should be formatted, else
- * false.
- */
- public void setFormattedOutput(boolean formattedOutput) {
- this.formattedOutput = formattedOutput;
- }
-
- /**
- * Specify if the root node should be included in the JSON message (default
- * is false).
- * @param includeRoot - true if the message includes the root node, else
- * false.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_INCLUDE_ROOT
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_INCLUDE_ROOT
- */
- public void setIncludeRoot(boolean includeRoot) {
- this.includeRoot = includeRoot;
- }
-
- /**
- * If true empty collections will be marshalled as empty arrays, else the
- * collection will not be marshalled to JSON (default is true).
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_MARSHAL_EMPTY_COLLECTIONS
- */
- public void setMarshalEmptyCollections(boolean marshalEmptyCollections) {
- this.marshalEmptyCollections = marshalEmptyCollections;
- }
-
- /**
- * By default the JSON-binding will ignore namespace qualification. If this
- * property is set then a prefix corresponding to the namespace URI and a
- * namespace separator will be prefixed to the key.
- * include it you can specify a Map of namespace URI to prefix.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#NAMESPACE_PREFIX_MAPPER
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_NAMESPACE_PREFIX_MAPPER
- */
- public void setNamespacePrefixMapper(Map<String, String> namespacePrefixMapper) {
- this.namespacePrefixMapper = namespacePrefixMapper;
- }
-
- /**
- * This character (default is '.') separates the prefix from the key name.
- * It is only used if namespace qualification has been enabled be setting a
- * namespace prefix mapper.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_NAMESPACE_SEPARATOR
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_NAMESPACE_SEPARATOR
- */
- public void setNamespaceSeparator(char namespaceSeparator) {
- this.namespaceSeperator = namespaceSeparator;
- }
-
- /**
- * If true the grouping element will be used as the JSON key.
- *
- * <p><b>Example</b></p>
- * <p>Given the following class:</p>
- * <pre>
- * @XmlAccessorType(XmlAccessType.FIELD)
- * public class Customer {
- *
- * @XmlElementWrapper(name="phone-numbers")
- * @XmlElement(name="phone-number")
- * private {@literal List<PhoneNumber>} phoneNumbers;
- *
- * }
- * </pre>
- * <p>If the property is set to false (the default) the JSON output will be:</p>
- * <pre>
- * {
- * "phone-numbers" : {
- * "phone-number" : [ {
- * ...
- * }, {
- * ...
- * }]
- * }
- * }
- * </pre>
- * <p>And if the property is set to true, then the JSON output will be:</p>
- * <pre>
- * {
- * "phone-numbers" : [ {
- * ...
- * }, {
- * ...
- * }]
- * }
- * </pre>
- * @since 2.4.2
- * @see org.eclipse.persistence.jaxb.JAXBContextProperties#JSON_WRAPPER_AS_ARRAY_NAME
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_WRAPPER_AS_ARRAY_NAME
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_WRAPPER_AS_ARRAY_NAME
- */
- public void setWrapperAsArrayName(boolean wrapperAsArrayName) {
- this.wrapperAsArrayName = wrapperAsArrayName;
- }
-
- /**
- * Specify the key that will correspond to the property mapped with
- * {@literal @XmlValue}. This key will only be used if there are other mapped
- * properties.
- * @see org.eclipse.persistence.jaxb.MarshallerProperties#JSON_VALUE_WRAPPER
- * @see org.eclipse.persistence.jaxb.UnmarshallerProperties#JSON_VALUE_WRAPPER
- */
- public void setValueWrapper(String valueWrapper) {
- this.valueWrapper = valueWrapper;
- }
-
- /**
- * @return true for all media types of the pattern */json and
- * */*+json.
- */
- protected boolean supportsMediaType(MediaType mediaType) {
- if(null == mediaType) {
- return true;
- }
- String subtype = mediaType.getSubtype();
- return subtype.equals(JSON) || subtype.endsWith(PLUS_JSON);
- }
-
- /**
- * @see javax.ws.rs.ext.MessageBodyWriter#writeTo(java.lang.Object, java.lang.Class, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap, java.io.OutputStream)
- */
- @Override
- public void writeTo(Object object, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
- try {
- if(null == genericType) {
- genericType = type;
- }
-
- Set<Class<?>> domainClasses = getDomainClasses(genericType);
- JAXBContext jaxbContext = getJAXBContext(domainClasses, annotations, mediaType, httpHeaders);
- Marshaller marshaller = jaxbContext.createMarshaller();
- marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, formattedOutput);
- marshaller.setProperty(MarshallerProperties.MEDIA_TYPE, MediaType.APPLICATION_JSON);
- marshaller.setProperty(MarshallerProperties.JSON_ATTRIBUTE_PREFIX, attributePrefix);
- marshaller.setProperty(MarshallerProperties.JSON_INCLUDE_ROOT, includeRoot);
- marshaller.setProperty(MarshallerProperties.JSON_MARSHAL_EMPTY_COLLECTIONS, marshalEmptyCollections);
- marshaller.setProperty(MarshallerProperties.JSON_NAMESPACE_SEPARATOR, namespaceSeperator);
- if(null != valueWrapper) {
- marshaller.setProperty(MarshallerProperties.JSON_VALUE_WRAPPER, valueWrapper);
- }
- marshaller.setProperty(MarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, wrapperAsArrayName);
- marshaller.setProperty(MarshallerProperties.NAMESPACE_PREFIX_MAPPER, namespacePrefixMapper);
-
- Map<String, String> mediaTypeParameters = null;
- if(null != mediaType) {
- mediaTypeParameters = mediaType.getParameters();
- }
- if(null != mediaTypeParameters && mediaTypeParameters.containsKey(CHARSET)) {
- String charSet = mediaTypeParameters.get(CHARSET);
- marshaller.setProperty(Marshaller.JAXB_ENCODING, charSet);
- }
-
- preWriteTo(object, type, genericType, annotations, mediaType, httpHeaders, marshaller);
- if (domainClasses.size() == 1) {
- Class<?> domainClass = domainClasses.iterator().next();
- if(!(List.class.isAssignableFrom(type) || type.isArray()) && domainClass.getPackage().getName().startsWith("java.")) {
- object = new JAXBElement(new QName((String) marshaller.getProperty(MarshallerProperties.JSON_VALUE_WRAPPER)), domainClass, object);
- }
- }
-
- marshaller.marshal(object, entityStream);
- } catch(JAXBException jaxbException) {
- throw new WebApplicationException(jaxbException);
- }
- }
-
-}
\ No newline at end of file
diff --git a/jakarta/src/patch/java/org/eclipse/persistence/jpa/rs/PersistenceFactoryBase.java b/jakarta/src/patch/java/org/eclipse/persistence/jpa/rs/PersistenceFactoryBase.java
deleted file mode 100644
index c83fdf6..0000000
--- a/jakarta/src/patch/java/org/eclipse/persistence/jpa/rs/PersistenceFactoryBase.java
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * Copyright (c) 2011, 2018 Oracle and/or its affiliates. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0,
- * or the Eclipse Distribution License v. 1.0 which is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
- */
-
-// Contributors:
-// dclarke/tware - initial implementation
-// gonural - version based persistence context
-// Dmitry Kornilov - JPARS 2.0 related changes
-package org.eclipse.persistence.jpa.rs;
-
-import java.net.URI;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import jakarta.persistence.EntityManagerFactory;
-import jakarta.persistence.Persistence;
-
-import org.eclipse.persistence.config.PersistenceUnitProperties;
-import org.eclipse.persistence.dynamic.DynamicClassLoader;
-import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl;
-import org.eclipse.persistence.internal.jpa.EntityManagerSetupImpl;
-import org.eclipse.persistence.internal.jpa.deployment.PersistenceUnitProcessor;
-import org.eclipse.persistence.internal.jpa.deployment.SEPersistenceUnitInfo;
-import org.eclipse.persistence.jpa.Archive;
-import org.eclipse.persistence.jpa.rs.exceptions.JPARSException;
-import org.eclipse.persistence.jpa.rs.features.ServiceVersion;
-import org.eclipse.persistence.jpa.rs.util.JPARSLogger;
-
-/**
- * Manages the PersistenceContexts that are used by a JPA-RS deployment. Provides a single point to bootstrap
- * and look up PersistenceContexts.
- *
- * @author tware
- */
-public class PersistenceFactoryBase implements PersistenceContextFactory {
- protected final Map<String, Set<PersistenceContext>> dynamicPersistenceContexts = new HashMap<>();
-
- /**
- * Bootstrap a PersistenceContext based on an pre-existing EntityManagerFactory.
- *
- * @param name persistence context name
- * @param emf entity manager factory
- * @param baseURI base URI
- * @param version JPARS version. See {@link ServiceVersion} for more details.
- * @param replace Indicates that existing persistence context with given name and version must be replaced
- * with the newly created one. If false passed the newly created context is not added to cache at all.
- * @return newly created persistence context
- */
- public PersistenceContext bootstrapPersistenceContext(String name, EntityManagerFactory emf, URI baseURI, String version, boolean replace) {
- final PersistenceContext persistenceContext = new PersistenceContext(name, (EntityManagerFactoryImpl) emf, baseURI, ServiceVersion.fromCode(version));
-
- if (replace) {
- addReplacePersistenceContext(persistenceContext);
- }
-
- return persistenceContext;
- }
-
- /**
- * Stop the factory. Remove all the PersistenceContexts.
- */
- @Override
- public void close() {
- synchronized (this) {
- for (Set<PersistenceContext> contextSet : dynamicPersistenceContexts.values()) {
- if (contextSet != null) {
- for (PersistenceContext context : contextSet) {
- context.stop();
- }
- }
- }
- dynamicPersistenceContexts.clear();
- }
- }
-
- /**
- * Close the PersistenceContext of a given name and clean it out of our list of PersistenceContexts.
- *
- * @param name name of the persistence context to close.
- */
- @Override
- public void closePersistenceContext(String name) {
- synchronized (this) {
- Set<PersistenceContext> contextSet = dynamicPersistenceContexts.get(name);
- if (contextSet != null) {
- for (PersistenceContext context : contextSet) {
- context.stop();
- }
- }
- dynamicPersistenceContexts.remove(name);
- }
- }
-
- /**
- * Close the PersistenceContext and clean it out of our list of PersistenceContexts.
- *
- * @param name name of the persistence context to close.
- * @param version persistence context version
- */
- public void closePersistenceContext(String name, String version) {
- synchronized (this) {
- final Set<PersistenceContext> contextSet = dynamicPersistenceContexts.get(name);
- if (contextSet != null) {
- for (Iterator<PersistenceContext> iter = contextSet.iterator(); iter.hasNext();) {
- PersistenceContext context = iter.next();
- if (context.getVersion().equals(version)) {
- context.stop();
- iter.remove();
- break;
- }
- }
-
- if (contextSet.size() == 0) {
- dynamicPersistenceContexts.remove(name);
- } else {
- dynamicPersistenceContexts.put(name, contextSet);
- }
- }
- }
... 1153 lines suppressed ...
[tomee] 01/02: Exclude the Jakarta module from this build
Posted by jg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jgallimore pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tomee.git
commit dd2d69e117f6ba1e9820d480542a32c19a2eb086
Author: Jonathan Gallimore <jo...@jrg.me.uk>
AuthorDate: Fri Jun 19 09:27:44 2020 +0100
Exclude the Jakarta module from this build
---
pom.xml | 1 -
1 file changed, 1 deletion(-)
diff --git a/pom.xml b/pom.xml
index 86003ff..32f2051 100644
--- a/pom.xml
+++ b/pom.xml
@@ -592,7 +592,6 @@
<module>arquillian</module>
<module>utils</module>
<module>tomee</module>
- <module>jakarta</module>
</modules>
<repositories>
<repository>