Spring 3.0-无法定位到用于 XML 模式名称空间的 Spring NamespaceHandler [ http://www.springframework.org/schema/security ]

我需要添加一个额外的 Maven 依赖项:

    <dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-config</artifactId>
<version>3.0.1.RELEASE</version>
</dependency>

我用的是 Keystore Explorer

解决方案肯定是“ spring-security-config”，而不是在 WEB-INF/lib 中。

1. 用私钥打开 JKS
2. 检查 CA 签名的 PEM

对于我在 Eclipse 中使用 Maven 的项目，结果发现并非所有的 Maven 依赖项都被复制到 WEB-INF/lib。查看 Project-> Properties-> DeploymentAssembly，只有一些 jar 被复制。

3. 输入密钥

为了解决这个问题，我点击“添加”，然后点击“ JavaBuild 路径整体”，最后点击“ MavenDependency”。

4. 救救 JKS

我一直在搜索所以和网络的最后一个小时寻找这一点，所以希望这有助于其他人。

我需要在这里提供一些免责声明，我是图书馆维护人员

我今天遇到了非常相似的问题。由于某些原因，IntelliJ IDEA在部署应用程序时没有包含 SpringSecurityjar 文件。我认为我应该同意这里的大多数海报。

我使用 spring-security-config jar，它为我解决了这个问题

如果你想在 Android 上这样做，有一些小的调整，可以添加到 PEMImporter类从 这个伟大的答案。总结一下:

• 在11版中，从 java 核心中移除了 javax.xml.bind.DatatypeConverter:

• 首先，我使用 Android Studio 翻译成 Kotlin (这是不必要的，我只是喜欢它)。原始类包含所有静态方法，因此这导致了一个命名对象。

• 在11版中，从 java 核心中移除了 javax.xml.bind.DatatypeConverter: implementation("javax.xml.bind:jaxb-api:2.4.0-b180830.0359") ，这在 Android 上不起作用，对于它执行的任务(即将 base64转换为字节) ，使用 java.util.Base64更简单。输出是相同的(尽管您需要修剪原始 PEM 数据中的行结尾)。

implementation("javax.xml.bind:jaxb-api:2.4.0-b180830.0359") ，这在 Android 上不起作用，对于它执行的任务(即将 base64转换为字节) ，使用 java.util.Base64更简单。输出是相同的(尽管您需要修剪原始 PEM 数据中的行结尾)。

• 用 PKIX代替 SunX509和 JKS。它只在第一种情况下是必要的，而在第二种情况下可能是无关紧要的; 我不认为它有任何意义，如果您正在填充一个 KeyStore与已经初始化的 PrivateKey等对象，正如这里所做的。实际上，我在 createKeyStore中使用 getDefaultAlgorithm()代替“ JKS”，尽管默认值是“ JKS”，但密钥存储在使用 PKIX作为算法创建的 KeyManagerFactory中工作得很好。

我还应该注意到，我没有使用 createSSLFactory方法，而是使用 createKeyStore()的输出来初始化一个 KeyManagerFactory，并提取用于初始化一个 SSLContext的 KeyManagers:

val context = SSLContext.getInstance(contextProtocol)
val password = String(...)
val ks : KeyStore = try {
PEMImporter.createKeyStore(
File(keyPath),
File(certPath),
password
)
} catch (ex : Throwable) { ... }


val kmf = KeyManagerFactory.getInstance("PKIX")
try { kmf.init(ks, password.toCharArray()) }

我还应该注意到，我没有使用 createSSLFactory方法，而是使用 createKeyStore()的输出来初始化一个 KeyManagerFactory，并提取用于初始化一个 SSLContext的 KeyManagers:

val context = SSLContext.getInstance(contextProtocol)
val password = String(...)
val ks : KeyStore = try {
PEMImporter.createKeyStore(
File(keyPath),
File(certPath),
password
)
} catch (ex : Throwable) { ... }


val kmf = KeyManagerFactory.getInstance("PKIX")
try { kmf.init(ks, password.toCharArray()) }

这里的密码可能并不重要，因为 PEMImporter可以处理已经未加密的密钥数据——除非您想将 PrivateKey写回文件(我假设 getEncoded()是朝这个方向迈出的一步，但我从未需要这样做)。它只需要在以上两种用途中匹配即可。

这里的密码可能并不重要，因为 PEMImporter可以处理已经未加密的密钥数据——除非您想将 PrivateKey写回文件(我假设 getEncoded()是朝这个方向迈出的一步，但我从未需要这样做)。它只需要在以上两种用途中匹配。

我还为 RSA PRIVATE KEYS添加了一个捕获，结果是

我还为 RSA PRIVATE KEYS添加了一个捕获，结果是 不同于第一行中没有“ RSA”的 PEM 键; 这是我以前没有意识到的一个微妙之处。前者是 PKCS # 1，后者是 PKCS # 8; 您应该能够使用通常使用的任何工具来处理这些问题(例如，在使用 certtool创建密钥时，使用 --pkcs8)。注意，这并不意味着 PKCS # 8密钥不可能是基于 RSA 的，它只是关于用于存储和提取密钥数据的协议。

以下是我在 Kotlin 的安卓版 PEMImporter:

import java.io.*
import java.security.*
import java.security.cert.CertificateException
import java.security.cert.CertificateFactory
import java.security.cert.X509Certificate
import java.security.interfaces.RSAPrivateKey
import java.security.spec.InvalidKeySpecException
import java.security.spec.PKCS8EncodedKeySpec
import java.util.*
import javax.net.ssl.KeyManagerFactory
import javax.net.ssl.SSLContext
import javax.net.ssl.SSLServerSocketFactory


object PEMImporter {


@Throws(Exception::class)
fun createSSLFactory(
privateKeyPem: File,
certificatePem: File?,
password: String
): SSLServerSocketFactory {
val context = SSLContext.getInstance("TLS")
val keystore = createKeyStore(privateKeyPem, certificatePem, password)
val kmf = KeyManagerFactory.getInstance("PKIX")
kmf.init(keystore, password.toCharArray())
val km = kmf.keyManagers
context.init(km, null, null)
return context.serverSocketFactory
}


/**
* Create a KeyStore from standard PEM files
*
* @param privateKeyPem the private key PEM file
* @param certificatePem the certificate(s) PEM file
* @param password the password to set to protect the private key
*/
@Throws(
Exception::class,
KeyStoreException::class,
IOException::class,
NoSuchAlgorithmException::class,
CertificateException::class
)
fun createKeyStore(privateKeyPem: File, certificatePem: File?, password: String): KeyStore {
val cert = createCertificates(certificatePem)
val keystore = KeyStore.getInstance(KeyStore.getDefaultType())
keystore.load(null)
// Import private key
val key = createPrivateKey(privateKeyPem)
keystore.setKeyEntry(privateKeyPem.name, key, password.toCharArray(), cert)
return keystore
}


@Throws(Exception::class)
private fun createPrivateKey(privateKeyPem: File): PrivateKey {
val r = BufferedReader(FileReader(privateKeyPem))
var s = r.readLine()
if (s.contains("BEGIN RSA PRIVATE KEY")) {
r.close()
throw IllegalArgumentException(privateKeyPem.name +
" is a PKCS #1 key, not a PKCS #8.")
}
if (s == null || (!s.contains("BEGIN PRIVATE KEY"))) {
r.close()
throw IllegalArgumentException("Bad private key header (${privateKeyPem.name}): $s")
}
val b = StringBuilder()
s = ""
while (s != null) {
if (s.contains("END PRIVATE KEY")) {
break
}
b.append(s.trimEnd())
s = r.readLine()
}
r.close()
val hexString = b.toString()
// Base64 is in java.util.
val bytes = Base64.getDecoder().decode(hexString)
return generatePrivateKeyFromDER(bytes)
}


@Throws(Exception::class)
private fun createCertificates(certificatePem: File?): Array<X509Certificate> {
val result = mutableListOf<X509Certificate>()
val r = BufferedReader(FileReader(certificatePem))
var s = r.readLine()
if (s == null || !s.contains("BEGIN CERTIFICATE")) {
r.close()
throw IllegalArgumentException("No CERTIFICATE found")
}
var b = StringBuilder()
while (s != null) {
if (s.contains("END CERTIFICATE")) {
val hexString = b.toString()
val bytes = Base64.getDecoder().decode(hexString.trimEnd())
val cert = generateCertificateFromDER(bytes)
result.add(cert)
b = StringBuilder()
} else {
if (!s.startsWith("----")) {
b.append(s)
}
}
s = r.readLine()
}
r.close()
return result.toTypedArray()
}


@Throws(InvalidKeySpecException::class, NoSuchAlgorithmException::class)
private fun generatePrivateKeyFromDER(keyBytes: ByteArray): RSAPrivateKey {
val spec = PKCS8EncodedKeySpec(keyBytes)
val factory = KeyFactory.getInstance("RSA")
return factory.generatePrivate(spec) as RSAPrivateKey
}


@Throws(CertificateException::class)
private fun generateCertificateFromDER(certBytes: ByteArray): X509Certificate {
val factory = CertificateFactory.getInstance("X.509")
return factory.generateCertificate(ByteArrayInputStream(certBytes)) as X509Certificate
}
}

以下是我在 Kotlin 的安卓版 PEMImporter:

import java.io.*
import java.security.*
import java.security.cert.CertificateException
import java.security.cert.CertificateFactory
import java.security.cert.X509Certificate
import java.security.interfaces.RSAPrivateKey
import java.security.spec.InvalidKeySpecException
import java.security.spec.PKCS8EncodedKeySpec
import java.util.*
import javax.net.ssl.KeyManagerFactory
import javax.net.ssl.SSLContext
import javax.net.ssl.SSLServerSocketFactory


object PEMImporter {


@Throws(Exception::class)
fun createSSLFactory(
privateKeyPem: File,
certificatePem: File?,
password: String
): SSLServerSocketFactory {
val context = SSLContext.getInstance("TLS")
val keystore = createKeyStore(privateKeyPem, certificatePem, password)
val kmf = KeyManagerFactory.getInstance("PKIX")
kmf.init(keystore, password.toCharArray())
val km = kmf.keyManagers
context.init(km, null, null)
return context.serverSocketFactory
}


/**
* Create a KeyStore from standard PEM files
*
* @param privateKeyPem the private key PEM file
* @param certificatePem the certificate(s) PEM file
* @param password the password to set to protect the private key
*/
@Throws(
Exception::class,
KeyStoreException::class,
IOException::class,
NoSuchAlgorithmException::class,
CertificateException::class
)
fun createKeyStore(privateKeyPem: File, certificatePem: File?, password: String): KeyStore {
val cert = createCertificates(certificatePem)
val keystore = KeyStore.getInstance(KeyStore.getDefaultType())
keystore.load(null)
// Import private key
val key = createPrivateKey(privateKeyPem)
keystore.setKeyEntry(privateKeyPem.name, key, password.toCharArray(), cert)
return keystore
}


@Throws(Exception::class)
private fun createPrivateKey(privateKeyPem: File): PrivateKey {
val r = BufferedReader(FileReader(privateKeyPem))
var s = r.readLine()
if (s.contains("BEGIN RSA PRIVATE KEY")) {
r.close()
throw IllegalArgumentException(privateKeyPem.name +
" is a PKCS #1 key, not a PKCS #8.")
}
if (s == null || (!s.contains("BEGIN PRIVATE KEY"))) {
r.close()
throw IllegalArgumentException("Bad private key header (${privateKeyPem.name}): $s")
}
val b = StringBuilder()
s = ""
while (s != null) {
if (s.contains("END PRIVATE KEY")) {
break
}
b.append(s.trimEnd())
s = r.readLine()
}
r.close()
val hexString = b.toString()
// Base64 is in java.util.
val bytes = Base64.getDecoder().decode(hexString)
return generatePrivateKeyFromDER(bytes)
}


@Throws(Exception::class)
private fun createCertificates(certificatePem: File?): Array<X509Certificate> {
val result = mutableListOf<X509Certificate>()
val r = BufferedReader(FileReader(certificatePem))
var s = r.readLine()
if (s == null || !s.contains("BEGIN CERTIFICATE")) {
r.close()
throw IllegalArgumentException("No CERTIFICATE found")
}
var b = StringBuilder()
while (s != null) {
if (s.contains("END CERTIFICATE")) {
val hexString = b.toString()
val bytes = Base64.getDecoder().decode(hexString.trimEnd())
val cert = generateCertificateFromDER(bytes)
result.add(cert)
b = StringBuilder()
} else {
if (!s.startsWith("----")) {
b.append(s)
}
}
s = r.readLine()
}
r.close()
return result.toTypedArray()
}


@Throws(InvalidKeySpecException::class, NoSuchAlgorithmException::class)
private fun generatePrivateKeyFromDER(keyBytes: ByteArray): RSAPrivateKey {
val spec = PKCS8EncodedKeySpec(keyBytes)
val factory = KeyFactory.getInstance("RSA")
return factory.generatePrivate(spec) as RSAPrivateKey
}


@Throws(CertificateException::class)
private fun generateCertificateFromDER(certBytes: ByteArray): X509Certificate {
val factory = CertificateFactory.getInstance("X.509")
return factory.generateCertificate(ByteArrayInputStream(certBytes)) as X509Certificate
}
}

配合:

if(element.hasClass("class"))

在我的例子中，将它们都改为3.1解决了这个问题

我可以检查一个类，但是有没有一种简单的方法来检查“ element”是否有许多类中的任何一个？

我使用:

if(element.hasClass("class") || element.hasClass("class") ... )

很不幸，这招不管用。

这还不算太糟，不过我在想:

if(element.hasClass("class", "class2")

很不幸，这招不管用。

有这种事吗？

element.is('.class1, .class2')

我在部署到 Virgo 时遇到了这个错误，解决方案是将它添加到我的 bundle 导入中:

org.springframework.transaction.config;version="[3.1,3.2)",

有效，但是 慢35% 比

element.hasClass('class1') || element.hasClass('class2')

我注意到在 META-INF 下的 Spring jar 中有一个 Spring.schemas 和一个 Spring.handlers 部分，它们指向的类(在本例中是 org.springframework.transaction.config.TxNamespaceHandler)必须导入。

我使用了 Maven 的 Shade 插件来生成一个胖的 jar，所有的 spring.handlers(和 spring.schemas)文件都被每个 Spring 依赖项覆盖。

这个怎么样,

$.fn.extend({
hasClasses: function( selector ) {
var classNamesRegex = new RegExp("( " + selector.replace(/ +/g,"").replace(/,/g, " | ") + " )"),
rclass = /[\n\t\r]/g,
i = 0,
l = this.length;
for ( ; i < l; i++ ) {
if ( this[i].nodeType === 1 && classNamesRegex.test((" " + this[i].className + " ").replace(rclass, " "))) {
return true;
}
}
return false;
}
});

Maven 站点介绍了这个问题，以及如何通过将文件附加在一起来解决这个问题:

Http://maven.apache.org/plugins/maven-shade-plugin/examples/resource-transformers.html#appendingtransformer

易于使用,

if ( $("selector").hasClasses("class1, class2, class3") ) {
//Yes It does
}

使用默认的 js match ()函数:

if( element.attr('class') !== undefined && element.attr('class').match(/class1|class2|class3|class4|class5/) ) {
console.log("match");
}

几分钟前出现了同样的问题，我的部署程序集中缺少“ Maven 依赖项”库。

要在 regexp 中使用变量，请使用:

var reg = new RegExp(variable, 'g');
$(this).match(reg);

如果添加依赖项还没有解决您的问题，请再次创建 WAR 归档。在我的例子中，我使用了没有 security-web 和 security-conf jar 的过时 WAR 文件

Filter () 是另一个选项

选择器或

将匹配的元素集减少到匹配选择器或 通过函数测试。

$(selector).filter('.class1, .class2'); //Filter elements: class1 OR class2


$(selector).filter('.class1.class2'); // Filter elements: class1 AND class2

$(selector).filter('.class1, .class2'); //Filter elements: class1 OR class2


$(selector).filter('.class1.class2'); // Filter elements: class1 AND class2

我所做的:

      <dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-config</artifactId>
<version>3.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-web</artifactId>
<version>3.2.5.RELEASE</version>
</dependency>

还有

xsi:schemaLocation="
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

效果很好，再来点 Baeldung

还有

xsi:schemaLocation="
http://www.springframework.org/schema/security
http://www.springframework.org/schema/security/spring-security-3.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

在 pom.xml 文件中添加以下依赖项，如果使用 IntelliJ，则将相同的 jar 添加到 WEB-INF-> lib 文件夹..。路径是“项目结构”-> “文物”-> “从“可用元素”窗格中选择 jar，然后双击。”。它将添加到各自的文件夹

<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-config</artifactId>
<version>3.0.1.RELEASE</version>
</dependency>