aesgcmjava的简单介绍

今天给各位分享aesgcmjava的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、java如何用Aes加密和解密2、有关AesGCM算法的一些总结3、关于Java的AES加密问题4、如何使用java对密码加密 加密方式aes5、使用https访问http/https通信协议，需要哪些配置文件6、java se8的新特性有哪些

java如何用Aes加密和解密

你解密的key必须是加密的key啊

你看看，你解密的时候又KeyGenerator.getInstance(“AES”).generateKey();这是重新搞了一个key啊，当然解不出来了

我估计你这代码人家原先是写在一起的吧，加密完了再直接解密给你看，人家只generateKey一次，自然很顺利，你分成了两个例子，居然分别generateKey，自然失败

有关AesGCM算法的一些总结

AesGCM是微信底层通信协议中使用的一种最为重要的加解密算法，在尝试使用OpenSSL库实现这套算法的过程中，遇到了以下几个值得注意的点：

在ECB/CCB模式下，补位信息是算法实现必须考虑的一个维度。但在GCM模式下，补位信息是完全不需要考虑的，明文与密文有着相同的长度。

在普通的Aes加解密算法中，需要从key/iv/padding/mode这四个维度来考虑算法的实现。而AesGcm算法中却需要从下面这几个维度来实现算法：

微信底层通信协议中，服务端下发的密文数据总是比明文数据长了16个字节，导致这种现象的主要原因是微信实现时将加密使用的tag信息拼接到了密文数据中，客户端使用JAVA接口解密时，在接口的内部能够自动的截取tag信息后再解密出明文数据。我并不能确认这种方式是BouncyCastle的固有实现还是微信自己的独有实现。关于拼接这块的逻辑，可以参见 这里 。

当使用OpenSSL实现解密微信下发的密文数据时，如果不知道拼接tag这层逻辑时，是不可能成功解密出明文数据的。

关于Java的AES加密问题

使用AES加密时，当密钥大于128时，代码会抛出java.security.InvalidKeyException: Illegal key size or default parameters

Illegal key size or default parameters是指密钥长度是受限制的，java运行时环境读到的是受限的policy文件。文件位于${java_home}/jre/lib/security

这种限制是因为美国对软件出口的控制。

解决办法：

去掉这种限制需要下载Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files.网址如下。

下载包的readme.txt 有安装说明。就是替换${java_home}/jre/lib/security/ 下面的local_policy.jar和US_export_policy.jar

jdk 5:

如何使用java对密码加密 加密方式aes

Java有相关的实现类：具体原理如下

对于任意长度的明文，AES首先对其进行分组，每组的长度为128位。分组之后将分别对每个128位的明文分组进行加密。

对于每个128位长度的明文分组的加密过程如下：

（1）将128位AES明文分组放入状态矩阵中。

（2）AddRoundKey变换：对状态矩阵进行AddRoundKey变换，与膨胀后的密钥进行异或操作（密钥膨胀将在实验原理七中详细讨论）。

（3）10轮循环：AES对状态矩阵进行了10轮类似的子加密过程。前9轮子加密过程中，每一轮子加密过程包括4种不同的变换，而最后一轮只有3种变换，前9轮的子加密步骤如下：

● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；

● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；

● MixColumns变换：MixColumns变换对状态矩阵的列进行变换；

● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或操作。

最后一轮的子加密步骤如下：

● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；

● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；

● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或操作；

（4）经过10轮循环的状态矩阵中的内容就是加密后的密文。

AES的加密算法的伪代码如下。

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的膨胀后的密钥，这44个字的膨胀后的密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。

三．AES的分组过程

对于任意长度的明文，AES首先对其进行分组，分组的方法与DES相同，即对长度不足的明文分组后面补充0即可，只是每一组的长度为128位。

AES的密钥长度有128比特，192比特和256比特三种标准，其他长度的密钥并没有列入到AES联邦标准中，在下面的介绍中，我们将以128位密钥为例。

四．状态矩阵

状态矩阵是一个4行、4列的字节矩阵，所谓字节矩阵就是指矩阵中的每个元素都是一个1字节长度的数据。我们将状态矩阵记为State，State中的元素记为Sij，表示状态矩阵中第i行第j列的元素。128比特的明文分组按字节分成16块，第一块记为“块0”，第二块记为“块1”，依此类推，最后一块记为“块15”，然后将这16块明文数据放入到状态矩阵中，将这16块明文数据放入到状态矩阵中的方法如图2-2-1所示。

块0

块4

块8

块12

块1

块5

块9

块13

块2

块6

块10

块14

块3

块7

块11

块15

图2-2-1 将明文块放入状态矩阵中

五．AddRoundKey变换

状态矩阵生成以后，首先要进行AddRoundKey变换，AddRoundKey变换将状态矩阵与膨胀后的密钥进行按位异或运算，如下所示。

其中，c表示列数，数组W为膨胀后的密钥，round为加密轮数，Nb为状态矩阵的列数。

它的过程如图2-2-2所示。

图2-2-2 AES算法AddRoundKey变换

六．10轮循环

经过AddRoundKey的状态矩阵要继续进行10轮类似的子加密过程。前9轮子加密过程中，每一轮要经过4种不同的变换，即SubBytes变换、ShiftRows变换、MixColumns变换和AddRoundKey变换，而最后一轮只有3种变换，即SubBytes变换、ShiftRows变换和AddRoundKey变换。AddRoundKey变换已经讨论过，下面分别讨论余下的三种变换。

1．SubBytes变换

SubBytes是一个独立作用于状态字节的非线性变换，它由以下两个步骤组成：

（1）在GF（28）域，求乘法的逆运算，即对于α∈GF（28）求β∈GF（28），使αβ =βα = 1mod（x8 + x4 + x3 + x + 1）。

（2）在GF（28）域做变换，变换使用矩阵乘法，如下所示：

由于所有的运算都在GF（28）域上进行，所以最后的结果都在GF（28）上。若g∈GF（28）是GF（28）的本原元素，则对于α∈GF（28），α≠0，则存在

β ∈ GF（28），使得：

β = gαmod（x8 + x4 + x3 + x + 1）

由于g255 = 1mod（x8 + x4 + x3 + x + 1）

所以g255-α = β-1mod（x8 + x4 + x3 + x + 1）

根据SubBytes变换算法，可以得出SubBytes的置换表，如表2-2-1所示，这个表也叫做AES的S盒。该表的使用方法如下：状态矩阵中每个元素都要经过该表替换，每个元素为8比特，前4比特决定了行号，后4比特决定了列号，例如求SubBytes(0C)查表的0行C列得FE。

表2-2-1 AES的SubBytes置换表

它的变换过程如图2-2-3所示。

图2-2-3 SubBytes变换

AES加密过程需要用到一些数学基础，其中包括GF(2)域上的多项式、GF（28）域上的多项式的计算和矩阵乘法运算等，有兴趣的同学请参考相关的数学书籍。

2．ShiftRows变换

ShiftRows变换比较简单，状态矩阵的第1行不发生改变，第2行循环左移1字节，第3行循环左移2字节，第4行循环左移3字节。ShiftRows变换的过程如图2-2-4所示。

图2-2-4 AES的ShiftRows变换

3．MixColumns变换

在MixColumns变换中，状态矩阵的列看作是域GF（28）的多项式，模(x4＋1)乘以c（x）的结果：

c(x)＝(03)x3＋(01)x2+(01)x+(02)

这里(03)为十六进制表示，依此类推。c(x)与x4＋1互质，故存在逆：

d(x)=(0B)x3＋(0D)x2＋(0G)x＋(0E)使c(x)•d(x) = (D1)mod(x4＋1)。

设有：

它的过程如图2-2-5所示。

图2-2-5 AES算法MixColumns变换

七．密钥膨胀

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，膨胀后的密钥记为子密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的子密钥，这44个字的子密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。

密钥膨胀算法是以字为基础的（一个字由4个字节组成，即32比特）。128比特的原始密钥经过膨胀后将产生44个字的子密钥，我们将这44个密钥保存在一个字数组中，记为W[44]。128比特的原始密钥分成16份，存放在一个字节的数组：Key[0]，Key[1]……Key[15]中。

在密钥膨胀算法中，Rcon是一个10个字的数组，在数组中保存着算法定义的常数，分别为：

Rcon[0] = 0x01000000

Rcon[1] = 0x02000000

Rcon[2] = 0x04000000

Rcon[3] = 0x08000000

Rcon[4] = 0x10000000

Rcon[5] = 0x20000000

Rcon[6] = 0x40000000

Rcon[7] = 0x80000000

Rcon[8] = 0x1b000000

Rcon[9] = 0x36000000

另外，在密钥膨胀中包括其他两个操作RotWord和SubWord，下面对这两个操作做说明：

RotWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3进行循环移位，即

RotWord( B0,B1,B2,B3 ) = ( B1,B2,B3,B0 )

SubWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3使用AES的S盒，即

SubWord( B0,B1,B2,B3 ) = ( B’0,B’1,B’2,B’3 )

其中，B’i = SubBytes（Bi），i = 0,1,2,3。

密钥膨胀的算法如下：

八．解密过程

AES的加密和解密过程并不相同，首先密文按128位分组，分组方法和加密时的分组方法相同，然后进行轮变换。

AES的解密过程可以看成是加密过程的逆过程，它也由10轮循环组成，每一轮循环包括四个变换分别为InvShiftRows变换、InvSubBytes变换、InvMixColumns变换和AddRoundKey变换；

这个过程可以描述为如下代码片段所示：

九．InvShiftRows变换

InvShiftRows变换是ShiftRows变换的逆过程，十分简单，指定InvShiftRows的变换如下。

Sr,(c+shift(r,Nb))modNb= Sr,c for 0 r 4 and 0 ≤ c Nb

图2-2-6演示了这个过程。

图2-2-6 AES算法InvShiftRows变换

十．InvSubBytes变换

InvSubBytes变换是SubBytes变换的逆变换，利用AES的S盒的逆作字节置换，表2-2-2为InvSubBytes变换的置换表。

表2-2-2 InvSubBytes置换表

十一．InvMixColumns变换

InvMixColumns变换与MixColumns变换类似，每列乘以d(x)

d(x) = (OB)x3 + (0D)x2 + (0G)x + (0E)

下列等式成立：

( (03)x3 + (01)x2 + (01)x + (02) )⊙d(x) = (01)

上面的内容可以描述为以下的矩阵乘法：

十二．AddRoundKey变换

AES解密过程的AddRoundKey变换与加密过程中的AddRoundKey变换一样，都是按位与子密钥做异或操作。解密过程的密钥膨胀算法也与加密的密钥膨胀算法相同。最后状态矩阵中的数据就是明文。

使用https访问http/https通信协议，需要哪些配置文件

项目里需要访问其他接口，通过http/https协议。我们一般是用HttpClient类来实现具体的http/https协议接口的调用。

// Init a HttpClient

HttpClient client = new HttpClient();

String url=;

// Init a HttpMethod

HttpMethod get = new GetMethod(url);

get.setDoAuthentication(true);

get.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(1, false));

// Call http interface

try {

client.executeMethod(get);

// Handle the response from http interface

InputStream in = get.getResponseBodyAsStream();

SAXReader reader = new SAXReader();

Document doc = reader.read(in);

} finally {

// Release the http connection

get.releaseConnection();

}

以上代码在通过普通的http协议是没有问题的，但如果是https协议的话，就会有证书文件的要求了。一般情况下，是这样去做的。

// Init a HttpClient

HttpClient client = new HttpClient();

String url=;

if (url.startsWith(“https:”)) {

System.setProperty(“javax.net.ssl.trustStore”, “/.sis.cer”);

System.setProperty(“javax.net.ssl.trustStorePassword”, “public”);

}

于是，这里就需要事先生成一个.sis.cer的文件，生成这个文件的方法一般是先通过浏览器访问https://，导出证书文件，再用JAVA keytool command 生成证书

# $JAVA_HOME/bin/keytool -import -file sis.cer -keystore .sis.cer

但这样做，一比较麻烦，二来证书也有有效期，过了有效期之后，又需要重新生成一次证书。如果能够避开生成证书文件的方式来使用https的话，就比较好了。

还好，在最近的项目里，我们终于找到了方法。

// Init a HttpClient

HttpClient client = new HttpClient();

String url=;

if (url.startsWith(“https:”)) {

this.supportSSL(url, client);

}

用到了supportSSL(url, client)这个方法，看看这个方法是如何实现的。

private void supportSSL(String url, HttpClient client) {

if(StringUtils.isBlank(url)) {

return;

}

String siteUrl = StringUtils.lowerCase(url);

if (!(siteUrl.startsWith(“https”))) {

return;

}

try {

setSSLProtocol(siteUrl, client);

} catch (Exception e) {

logger.error(“setProtocol error “, e);

}

Security.setProperty( “ssl.SocketFactory.provider”,

“com.tool.util.DummySSLSocketFactory”);

}

private static void setSSLProtocol(String strUrl, HttpClient client) throws Exception {

URL url = new URL(strUrl);

String host = url.getHost();

int port = url.getPort();

if (port = 0) {

port = 443;

}

ProtocolSocketFactory factory = new SSLSocketFactory();

Protocol authhttps = new Protocol(“https”, factory, port);

Protocol.registerProtocol(“https”, authhttps);

// set https protocol

client.getHostConfiguration().setHost(host, port, authhttps);

}

在supportSSL方法里，调用了Security.setProperty( “ssl.SocketFactory.provider”,

“com.tool.util.DummySSLSocketFactory”);

那么这个com.tool.util.DummySSLSocketFactory是这样的：

访问https 资源时,让httpclient接受所有ssl证书,在weblogic等容器中很有用

代码如下:

1. import java.io.IOException;

2. import java.net.InetAddress;

3. import java.net.InetSocketAddress;

4. import java.net.Socket;

5. import java.net.SocketAddress;

6. import java.net.UnknownHostException;

7. import java.security.KeyManagementException;

8. import java.security.NoSuchAlgorithmException;

9. import java.security.cert.CertificateException;

10. import java.security.cert.X509Certificate;

11.

12. import javax.net.SocketFactory;

13. import javax.net.ssl.SSLContext;

14. import javax.net.ssl.TrustManager;

15. import javax.net.ssl.X509TrustManager;

16.

17. import org.apache.commons.httpclient.ConnectTimeoutException;

18. import org.apache.commons.httpclient.params.HttpConnectionParams;

19. import org.apache.commons.httpclient.protocol.SecureProtocolSocketFactory;

20.

21. public class MySecureProtocolSocketFactory implements SecureProtocolSocketFactory {

22. static{

23. System.out.println(“in MySecureProtocolSocketFactory”);

24. }

25. private SSLContext sslcontext = null;

26.

27. private SSLContext createSSLContext() {

28. SSLContext sslcontext=null;

29. try {

30. sslcontext = SSLContext.getInstance(“SSL”);

31. sslcontext.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());

32. } catch (NoSuchAlgorithmException e) {

33. e.printStackTrace();

34. } catch (KeyManagementException e) {

35. e.printStackTrace();

36. }

37. return sslcontext;

38. }

39.

40. private SSLContext getSSLContext() {

41. if (this.sslcontext == null) {

42. this.sslcontext = createSSLContext();

43. }

44. return this.sslcontext;

45. }

46.

47. public Socket createSocket(Socket socket, String host, int port, boolean autoClose)

48. throws IOException, UnknownHostException {

49. return getSSLContext().getSocketFactory().createSocket(

50. socket,

51. host,

52. port,

53. autoClose

54. );

55. }

56.

57. public Socket createSocket(String host, int port) throws IOException,

58. UnknownHostException {

59. return getSSLContext().getSocketFactory().createSocket(

60. host,

61. port

62. );

63. }

64.

65.

66. public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort)

67. throws IOException, UnknownHostException {

68. return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);

69. }

70.

71. public Socket createSocket(String host, int port, InetAddress localAddress,

72. int localPort, HttpConnectionParams params) throws IOException,

73. UnknownHostException, ConnectTimeoutException {

74. if (params == null) {

75. throw new IllegalArgumentException(“Parameters may not be null”);

76. }

77. int timeout = params.getConnectionTimeout();

78. SocketFactory socketfactory = getSSLContext().getSocketFactory();

79. if (timeout == 0) {

80. return socketfactory.createSocket(host, port, localAddress, localPort);

81. } else {

82. Socket socket = socketfactory.createSocket();

83. SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);

84. SocketAddress remoteaddr = new InetSocketAddress(host, port);

85. socket.bind(localaddr);

86. socket.connect(remoteaddr, timeout);

87. return socket;

88. }

89. }

90.

91. //自定义私有类

92. private static class TrustAnyTrustManager implements X509TrustManager {

93.

94. public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {

95. }

96.

97. public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {

98. }

99.

100. public X509Certificate[] getAcceptedIssuers() {

101. return new X509Certificate[]{};

102. }

103. }

104.

105. }

public class MySecureProtocolSocketFactory implements SecureProtocolSocketFactory {

static{

System.out.println(“in MySecureProtocolSocketFactory”);

}

private SSLContext sslcontext = null;

private SSLContext createSSLContext() {

SSLContext sslcontext=null;

try {

sslcontext = SSLContext.getInstance(“SSL”);

sslcontext.init(null, new TrustManager[]{new TrustAnyTrustManager()}, new java.security.SecureRandom());

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

} catch (KeyManagementException e) {

e.printStackTrace();

}

return sslcontext;

}

private SSLContext getSSLContext() {

if (this.sslcontext == null) {

this.sslcontext = createSSLContext();

}

return this.sslcontext;

}

public Socket createSocket(Socket socket, String host, int port, boolean autoClose)

throws IOException, UnknownHostException {

return getSSLContext().getSocketFactory().createSocket(

socket,

host,

port,

autoClose

);

}

public Socket createSocket(String host, int port) throws IOException,

UnknownHostException {

return getSSLContext().getSocketFactory().createSocket(

host,

port

然后按如下方式使用HttpClient

Protocol myhttps = new Protocol(“https”, new MySecureProtocolSocketFactory (), 443);

Protocol.registerProtocol(“https”, myhttps);

HttpClient httpclient=new HttpClient();

java se8的新特性有哪些

java se8新特性如下：

Java Programming Language

1、lambda expressions，一个新的语言特性，它可以将功能作为方法的参数or代码作为数据，它使你表达单一方法接口的实例更加简洁。

2、对已经有方法名的方法提供一个更加可读的lambda expressions为方法的引用。

3、默认方法使新的功能添加到库的接口，确保与旧版本的接口编写的代码的二进制兼容

4、重复注解提供不止一次应用同样的注解类型

5、类型注解提供应用注解的能力，任何一个类型的使用，不仅在声明上使用。用于一个可插拔式的系统，此功能提高你代码的类型检查。

6、提高类型的推断

7、方法参数的反射

Collections

1、新的java.util.stream包，提供了stream api支持流元素上的功能性操作。stream api集成到collections api中，使用批量操作，如串行or并行 map-reduce 转换。

2、使用key collisions改进HashMap的性能

compact profiles

包含java SE平台预定义的子集和使不需要整个平台被部署和运行在小型设备中的应用

security

1、客户端默认启用TLS1.2

2、新的AccessController.doPrivileged,用代码断言它的privileges的子集，没有防止全栈遍历时检查其他权限

3、更强的基于密码的加密算法

4、SSL/TLS SNI扩展在JSSE服务器中支持

5、支持AEAD算法：SunJCE提供增强的支持AES / GCM / nopadding密码的实现以及GCM算法参数，SunJSSE提供基于密码套件的AEAD模式增强

6、keystore增强，包含新的keystore类型java.security.DomainLoadStoreParameter,和新的命令行选项-importpassword

7、SHA-224 Message Digests

8、NSA Suite B加密支持

9、更好的支持High Entropy 随机数生成

10、新的java.security.cert.PKIXRevocationChecker类为配置撤销X.509证书

11、win下64-bit PKCS11

12、新的rcache 类型在Kerberos 5 Replay Caching

13、支持Kerberos 5协议转换和约束代理

14、默认禁用Kerberos 5弱的加密

15、未绑定SASL为GSS-API/Kerberos 5机制

16、多主机名下SASL服务

17、在Mac OS X上JNI桥接到native JGSS

18、在sunjsse提供更强的实力，EDH键的支持

19、在JSSE支持服务器端密码套件个性设置

JavaFX

1、新Modena theme实现

2、新SwingNode类容许开发者嵌套Swing内容到javaFX应用中

3、新UI Controls 包含DatePicker 和TreeTableView

4、javafx.print包为JavaFX提供公共printing API

5、三维图形特性，目前包含3D shapes、camera、lights、subscene、material、picking和antialiasing

6、WebView类提供的新功能和改进，支持更多关于HTML5的特性，Web Scokets，Web Workers和Web Fonts

7、增强文本的支持

8、支持Hi-DPI 显示

9、css样式类变成公共API

10、新的ScheduledService类允许自动重启服务

11、ARM平台可用JavaFX

tools

1、jjs命令调用Nashorn引擎

2、java命令允许JavaFX应用

3、java man page已经更新

4、jdeps命令行工具提供分析类文件

5、Java Management Extensions (JMX) 提供远程诊断命令

6、jarsiger工具可选，从TSA请求签名时间抽

7、javac tool

7.1、-parameters选项存储正式的参数名和反射API检索正式参数的名称

7.2、JLS 15.21相等操作的类型规则通过javac命令正确的执行

7.3、javac工具现在支持检查javadoc注释的内容，该特性通过-Xdoclint选项

7.4、javac工具现在提供生成native header的能力。移除javah工具，通过javac的-h选项使用

8、javadoc tool

8.1、javadoc工具支持新DocTree API

8.2、javadoc工具支持新的javadoc 访问API，允许在java 应用直接调用javadoc 工具，没有执行新的进程

8.3、javadoc工具现在支持检查javadoc注释的内容，该特性通过-Xdoclint选项

Internationalization

1、unicode增强，支持unicode6.2.0

2、采用unicode CLDR数据和java.locale.providers 系统属性

3、新的Calendar和Locale APIs

4、安装一个自定义的资源包作为一个扩展的能力

Deployment

1、对sandbox applet和 java web start app，URLPermission现在是用来允许连接到服务器从它们启动完成后。SocketPermission不再授权

2、在所有安全级别，在主要jar文件的jar文件的manifest中必须给定权限属性

Date-Time Package

一个新的软件包，提供更加全面的日期-时间模型

Scripting

Nashorn js 引擎

Pack200

1、Pack200支持常量池条目和由JSR 292引入了新的字节码

2、JDK8支持由JSR-292, JSR-308 and JSR-335指定类文件的变化

IO and NIO

1、基于Solaris在Solaris事件端口机制实现新的SelectorProvider。使用系统属性java.nio.channels.spi.Selector设置的值sun.nio.ch.EventPortSelectorProvder运行

2、减少JDK_HOME/jre/lib/charsets.jar文件中数量

3、提高java.lang.String(byte[], *)构造器和java.lang.String.getBytes()方法的性能

java.lang and java.util.Pack ages

1、并发的数组排序

2、标准的编码和解码Base64

3、无符号运算的支持

JDBC

1、移除JDBC-ODBC桥

2、JDBC4.2引入新的功能

Java DB

1、JDK8 包含 Java DB 10.10

Networking

1、添加java.net.URLPermission类

2、在java.net.HttpURLConnection中，如果安装安全管理，请求要求打开一个连接请求的权限

Concurrency

1、在java.util.concurrent包中新增类和接口

2、java.util.concurrent.ConcurrentHashMap类添加方法支持聚合操作，基于新的流设施和lambda expressions

3、java.util.concurrent.atomic包中添加类支持可扩展可更新的变量

4、 java.util.concurrent.ForkJoinPool类中添加方法支持通用池

5、 java.util.concurrent.locks.StampedLock类已经添加使用3种模式控制读/写访问的基于能力的锁

Java XML – JAXP

HotSpot

1、硬件特性增加了AES，UseAES和UseAESIntrinsics标签在打开基于硬件AES可用（Inter 硬件），硬件必须是2010或更新Westmere硬件，如：打开硬件AES，使用下面标记

-XX:+UseAES -XX:+UseAESIntrinsics

关闭硬件AES：

-XX:-UseAES -XX:-UseAESIntrinsics

2、移除PermGen

3、通过为方法调用引入字节码指令支持默认方法

aesgcmjava的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、aesgcmjava的信息别忘了在本站进行查找喔。