javadsa（JavaDS安装）

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

微信号：cloud7591
如需了解更多，欢迎添加客服微信咨询。
复制微信号

本文目录一览：

• 1、在Java中怎么使用断言
• 2、程序设计里面的断言是什么？？？Java里面的assert,assert.h又是什么？？？
• 3、如何识别java命令行编译参数
• 4、java 中assert的使用
• 5、java加密的几种方式

在Java中怎么使用断言

如果要开启断言检查，则需要用开关-enableassertions或-ea来开启。

assert关键字语法很简单，有两种用法：

1、assert boolean表达式

如果boolean表达式为true，则程序继续执行。

如果为false，则程序抛出AssertionError，并终止执行。

2、assert boolean表达式 : 错误信息表达式

如果boolean表达式为true，则程序继续执行。

如果为false，则程序抛出java.lang.AssertionError，并输入错误信息表达式。

三、应用实例

下面给出一个例子，通过例子说明其用法：

public class AssertFoo {

public static void main(String args[]) {

//断言1结果为true，则继续往下执行

assert true;

System.out.println("断言1没有问题，Go！");

System.out.println("\n-----------------\n");

//断言2结果为false,程序终止

assert false : "断言失败，此表达式的信息将会在抛出异常的时候输出！";

System.out.println("断言2没有问题，Go！");

}

}

保存代码到C:\AssertFoo.java，然后按照下面的方式执行，查看控制台输出结果：

1、编译程序：

C:\javac AssertFoo.java

2、默认执行程序，没有开启-ea开关：

C:\java AssertFoo

断言1没有问题，Go！

-----------------

断言2没有问题，Go！

3、开启-ea开关，执行程序：

C:\java -ea AssertFoo

断言1没有问题，Go！

-----------------

Exception in thread "main" java.lang.AssertionError: 断言失败，此表达式的信息将

会在抛出异常的时候输出！

at AssertFoo.main(AssertFoo.java:10)

四、陷阱

assert关键字用法简单，但是使用assert往往会让你陷入越来越深的陷阱中。应避免使用。笔者经过研究，总结了以下原因：

1、assert关键字需要在运行时候显式开启才能生效，否则你的断言就没有任何意义。而现在主流的Java IDE工具默认都没有开启-ea断言检查功能。这就意味着你如果使用IDE工具编码，调试运行时候会有一定的麻烦。并且，对于Java Web应用，程序代码都是部署在容器里面，你没法直接去控制程序的运行，如果一定要开启-ea的开关，则需要更改Web容器的运行配置参数。这对程序的移植和部署都带来很大的不便。

2、用assert代替if是陷阱之二。assert的判断和if语句差不多，但两者的作用有着本质的区别：assert关键字本意上是为测试调试程序时使用的，但如果不小心用assert来控制了程序的业务流程，那在测试调试结束后去掉assert关键字就意味着修改了程序的正常的逻辑。

3、assert断言失败将面临程序的退出。这在一个生产环境下的应用是绝不能容忍的。一般都是通过异常处理来解决程序中潜在的错误。但是使用断言就很危险，一旦失败系统就挂了。

五、对assert的思考

assert既然是为了调试测试程序用，不在正式生产环境下用，那应该考虑更好的测试JUint来代替其做用，JUint相对assert关键的所提供的功能是有过之而无不及。当然完全可以通过IDE debug来进行调试测试。在此看来，assert的前途一片昏暗。

因此，应当避免在Java中使用assert关键字，除非哪一天Java默认支持开启-ea的开关，这时候可以考虑。对比一下，assert能给你带来多少好处，多少麻烦，这是我们选择是否使用的的原则。

以上仅仅代表我个人观点，欢迎大家留言讨论。

-----------------------------------------------------------------------------------

下面是一些Assert的例子:

assert 0 value;

assert 0 value:"value="+value;

assert ref != null:"ref doesn''t equal null";

assert isBalanced();

-----------------------------------------------------------------------------------

AssertinError类是Error的直接子类，因此代表程序出现了严重的错误，这种异常通常是不需要程序员使用catch语句捕捉的。

使用assert的准则：assert语句的作用是保证程序内部的一致性，而不是用户与程序之间的一致性，所以不应用在保证命令行参数的正确性。可以用来保证传递给private方法参数的正确性。因为私有方法只是在类的内部被调用，因而是程序员可以控制的，我们可以预期它的状态是正确和一致的。公有方法则不适用。此外，assert语句可用于检查任何方法结束时状态的正确性，及在方法的开始检查相关的初始状态 等等。

assert语句并不构成程序正常运行逻辑的一部分，时刻记住在运行时它们可能不会被执行。

-----------------------------------------------------------------------------------

两类参数：

参数 -esa和 -dsa：

它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中，也使了 assertion语句，因此如果用户需要观察它们的运行情况，就需要打开系统类的assertion功能 ，我们可使用-esa参数打开，使用 -dsa参数关闭。 -esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions，全名和缩写名有同样的功能。

参数 -ea和 -ea：

它们含义为开启(关闭)用户类的assertion功能：通过这个参数，用户可以打开某些类或包的assertion功能，同样用户也可以关闭某些类和包的assertion功能。打开assertion功能参数为-ea；如果不带任何参数，表示打开所有用户类；如果带有包名称或者类名称，表示打开这些类或包；如果包名称后面跟有三个点，代表这个包及其子包；如果只有三个点，代表无名包。关闭 assertion功能参数为-da，使用方法与-ea类似。

-ea和-da的全名为-enableassertions和-disenableassertions，全名和缩写名有同样的功能。

下面表格表示了参数及其含义，并有例子说明如何使用。

参数 例子 说明

-ea java -ea 打开所有用户类的assertion

-da java -da 关闭所有用户类的assertion

-ea: java -ea:MyClass1 打开MyClass1的assertion

-da: java -da: MyClass1 关闭MyClass1的assertion

-ea: java -ea:pkg1 打开pkg1包的assertion

-da: java -da:pkg1 关闭pkg1包的assertion

-ea:... java -ea:... 打开缺省包(无名包)的assertion

-da:... java -da:... 关闭缺省包(无名包)的assertion

-ea:... java -ea:pkg1... 打开pkg1包和其子包的assertion

-da:... java -da:pkg1... 关闭pkg1包和其子包的assertion

-esa java -esa 打开系统类的assertion

-dsa java -dsa 关闭系统类的assertion

-----------------------------------------------------------------------------------

不要再public的方法里面检查参数是不是为null之类的操作，例如：

public int get(String s){

assert s != null;

}

如果需要检查也最好通过 if s = null 抛出 NullPointerException来检查。

不要用assert来检查方法操作的返回值来判断方法操作的结果，例如：

assert list.removeAll();这样看起来好像没有问题 但是想想如果assert 被disable呢，那样他就不会被执行了，所以removeAll()操作就没有被执行，可以这样代替

boolean boo = list.removeAl();

assert boo;

-----------------------------------------------------------------------------------

另外，Java为了让程序也能够动态开启和关闭某些类和包的assertion功能，Java修该了Class和ClassLoader的实现，增加了几个用于操作assert的API。下面简单说明一下几个API的作用。

ClassLoader类中的几个相关的API:

setDefaultAssertionStatus:用于开启/关闭assertion功能

setPackageAssertionStatus:用于开启/关闭某些包的assertion功能

setClassAssertionStatus: 用于开启/关闭某些类的assertion功能

clearAssertionStatus：用于关闭assertion功能

程序设计里面的断言是什么？？？Java里面的assert,assert.h又是什么？？？

（一）首先明确：

java断言Assert是jdk1.4引入的。

jvm 断言默认是关闭的。

断言是可以局部开启的，如：父类禁止断言，而子类开启断言，所以一般说“断言不具有继承性”。

断言只适用于复杂的调试过程。

断言一般用于程序执行结果的判断，千万不要让断言处理业务流程。

（二）判断eclipse是否开启了断言，代码如下：

public class AssertTest {

public static void main(String[] args) {

boolean isOpen = false;

assert isOpen=true; //如果开启了断言，会将isOpen的值改为true

System.out.println(isOpen);//打印是否开启了断言

}

}

执行上面代码，如果打印 true说明已经启用了断言，如果为 false 则没有启用断言。

如果没有启用断言，则按按照下面方法开启断言。

（三）eclipse中开启断言

选择菜单：Run --- Run... --- 选择 Arguments 选项卡

在 VM arguments 文本框中输入： -ea 注意 中间没有空格，如果输入 -da 表示禁止断言。

然后关闭该窗口，提示保存，然后保存就开启了断言。如下图：

再次执行第二步操作，如果打印true，说明开启断言成功。

如果禁止断言，则按第二步操作中，删除 -ea 或者将 -ea 改为 -da 即可。

（四）断言使用

第 1 种使用方法：

public static void main(String[] args) {

boolean isOk = 12;

assert isOk;

System.out.println("程序正常");

}

因为 12 显然是错误的，所以执行结果抛出异常：Exception in thread "main" java.lang.AssertionError

如果把 12 改为 12 则程序能顺利执行，打印 “程序正常”

第 2 种使用方法：

public static void main(String[] args) {

boolean isOk = 12;

try{

assert isOk : "程序错误";

System.out.println("程序正常");

}catch(AssertionError err){

System.out.println(err.getMessage());

}

}

assert 后面跟个冒号表达式。如果冒号前为 true，则冒号后面的被忽略。

如果冒号前为false，则抛出AssertionError ， 错误信息内容为冒号后面的内容，上面程序执行结果就是打印："程序错误"

（五）有关断言的更多参数：

-ea java -ea 打开所有用户类的assertion

-da java -da 关闭所有用户类的assertion

-ea:classname java -ea:MyClass1 打开MyClass1的assertion

-da:classname java -da: MyClass1 关闭MyClass1的assertion

-ea:packagename java -ea:pkg1 打开pkg1包的assertion

-da:packagename java -da:pkg1 关闭pkg1包的assertion

-ea:... java -ea:... 打开缺省包(无名包)的assertion

-da:... java -da:... 关闭缺省包(无名包)的assertion

-ea:packagename... java -ea:pkg1... 打开pkg1包和其子包的assertion

-da:packagename... java -da:pkg1... 关闭pkg1包和其子包的assertion

-esa java -esa 打开系统类的assertion

-dsa java -dsa 关闭系统类的assertion

综合使用 java -dsa:MyClass1:pkg1 关闭MyClass1和pkg1包的assertion

如何识别java命令行编译参数

javac

用法：javac 选项 源文件

其中，可能的选项包括：

-g 生成所有调试信息

-g:none 不生成任何调试信息

-g:{lines,vars,source} 只生成某些调试信息

-nowarn 不生成任何警告

-verbose 输出有关编译器正在执行的操作的消息

-deprecation 输出使用已过时的 API 的源位置

-classpath 路径 指定查找用户类文件的位置

-cp 路径 指定查找用户类文件的位置

-sourcepath 路径 指定查找输入源文件的位置

-bootclasspath 路径 覆盖引导类文件的位置

-extdirs 目录 覆盖安装的扩展目录的位置

-endorseddirs 目录 覆盖签名的标准路径的位置

-d 目录 指定存放生成的类文件的位置

使用-d参数，如类中定义了包，则编译时会自动生成包， 如：javac -d . helloworld.java

表示在当前目录下编译Helloworld 类。.表示当前目录，如helloword中定义有包，则在当前目录下生成包：

-encoding 编码 指定源文件使用的字符编码

-source 版本 提供与指定版本的源兼容性

-target 版本 生成特定 VM 版本的类文件

-version 版本信息

-help 输出标准选项的提要

-X 输出非标准选项的提要

-J标志 直接将 标志 传递给运行时系统

java

用法: java [-选项] 类 [参数...]

(执行一个类)

或者 java [-选项] -jar jar文件 [参数...]

(执行一个jar文件)

其中，可能的选项包括：

-client 选择 "client" VM(ginger547:应该是指Virtual Machine)

-server 选择 "server" VM

-hotspot 与 "client" VM同义 [不赞成]

默认情况的VM是client.

-cp 一个文件夹和zip/jar文件组成的类搜索路径

-classpath 一个文件夹和zip/jar文件组成的类搜索路径

一个由文件夹，JAR压缩文件，或者ZIP压缩文件组成的用来搜索类的列表

-D名字=值

设置一个系统属性

-verbose[:class|gc|jni]

使详细输出变的可用

-version 打印产品版本然后退出

-version:值

只运行指定版本

-showversion 打印产品版本后继续

-jre-restrict-search | -jre-no-restrict-search

在版本搜索的时候，包含/排除用户私人的JRE

-? -help 打印帮助信息

-X 打印非标准选项帮助

-ea[:包名...|:类名]

-enableassertions[:包名...|:类名]

使断言可用

-da[:包名...|:类名]

-disableassertions[:包名...|:类名]

是断言不可用

-esa | -enablesystemassertions

使系统级断言可用

-dsa | -disablesystemassertions

使系统级断言不可用

-agentlib:库名[=选项]

加载本地代理库库名,例如. -agentlib:hprof

同时可查看, -agentlib:jdwp=help和 -agentlib:hprof=help

-agentpath:路径名[=选项]

通过全路径名来加载本地代理库

-javaagent:jar路径[=选项]

加载Java编程语言代理，可查看 java.lang.instrument

java 中assert的使用

一、assertion的意义和用法

J2SE 1.4在语言上提供了一个新特性，就是assertion功能，它是该版本在Java语言方面最大的革新。

从理论上来说，通过 assertion方式可以证明程序的正确性，但是这是一项相当复杂的工作，目前还没有太多的实践意义。

在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。

一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。

1、语法表示

在语法上，为了支持assertion，Java增加了一个关键字assert。它包括两种表达式，分别如下：

assert expression1;

assert expression1:expression2;

在两种表达式中，expression1表示一个boolean表达式， expression2表示一个基本类型或者是一个对象(Object)，基本类型包括boolean,char,double,float,int和 long。由于所有类都为Object的子类，因此这个参数可以用于所有对象。

2、含义

在运行时，如果关闭了assertion功能，这些语句将不起任何作用。如果打开了assertion功能，那么expression1的值将被计算，如果它的值为false，该语句强抛出一个AssertionError对象。

如果assertion语句包括expression2参数，程序将计算出 expression2的结果，然后将这个结果作为AssertionError的构造函数的参数，来创建AssertionError对象，并抛出该对 象；如果expression1值为true，expression2将不被计算。

一种特殊情况是，如果在计算表达式时，表达式本身抛出Exception，那么assert将停止运行，而抛出这个Exception。

3、编译

由于assert是一个新关键字，使用老版本的JDK是无法编译带有assert的 源程序。因此，我们必须使用JDK1.4(或者更新)的Java编译器，在使用Javac命令时，我们必须加上-source 1.4作为参数。-source 1.4表示使用JDK 1.4版本的方式来编译源代码，否则编译就不能通过，因为缺省的Javac编译器使用JDK1.3的语法规则。

大家在使用eclipse,jbuilder等IDE工具的时候,要注意编译器的版本,使用的jre,不等于是javac 的版本

一个简单的例子如下：javac -source 1.4 AssertTest.java

4、运行

由于我们可以选择开启assertion功能，或者不开启，另外我们还可以开启一部 分类或包的assertion功能。通过这些选项，我们可以过滤所有我们不关心的类，只选择我们关心的类或包来观察。

参数 -esa 和 -dsa：

它们含义为开启(关闭)系统类的assertion功能。由于新版本的Java的系统类中，也使了assertion语句，因此如果用户需要观察它们的运行情况，就需要打开系统类的assertion功能 ，我们可使用-esa参数打开，使用 -dsa参数关闭。

-esa和-dsa的全名为-enablesystemassertions和-disenablesystemassertions，全名和缩写名有同样的功能。

参数 -ea和-ea：

它们含义为开启(关闭)用户类的assertion功能：通过这个参数，用户可以打 开某些类或包的assertion功能，同样用户也可以关闭某些类和包的assertion功能。打开assertion功能参数为-ea；如果不带任何 参数，表示打开所有用户类；如果带有包名称或者类名称，表示打开这些类或包；如果包名称后面跟有三个点，代表这个包及其子包；如果只有三个点，代表无名 包。关闭assertion功能参数为-da，使用方法与-ea类似。

-ea和-da的全名为-enableassertions和-disenableassertions，全名和缩写名有同样的功能。下面表示了参数及其含义。

参数 例子 说明

-ea java -ea 打开所有用户类的assertion

-da java -da 关闭所有用户类的assertion

-ea: java -ea:MyClass1 打开MyClass1的assertion

-da: java -da: MyClass1 关闭MyClass1的assertion

-ea: java -ea:pkg1 打开pkg1包的assertion

-da: java -da:pkg1 关闭pkg1包的assertion

-ea:... java -ea:... 打开缺省包(无名包)的assertion

-da:... java -da:... 关闭缺省包(无名包)的assertion

-ea:... java -ea:pkg1... 打开pkg1包和其子包的assertion

-da:... java -da:pkg1... 关闭pkg1包和其子包的assertion

-esa java -esa 打开系统类的assertion

-dsa java -dsa 关闭系统类的assertion

综合使用 java -dsa:MyClass1:pkg1 关闭MyClass1和pkg1包的assertion

其中...代表，此包和其子包的含义。例如我们有两个包为pkg1和pkg1.subpkg。

那么pkg1...就代表pkg1和pkg1.subpkg两个包。

另外，Java为了让程序也能够动态开启和关闭某些类和包的assertion功能，Java修该了Class和ClassLoader的实现，增加了几个用于操作assert的API。下面简单说明一下几个API的作用。

ClassLoader类中的几个相关的API:

setDefaultAssertionStatus:

用于开启/关闭assertion功能

setPackageAssertionStatus:

用于开启/关闭某些包的assertion功能

setClassAssertionStatus:

用于开启/关闭某些类的assertion功能

clearAssertionStatus：

用于关闭assertion功能

二、assertion的设计问题

首先，我们认为assertion是必要的。因为，如果没有统一的assertion机制，Java程序通常使用if-then-else或者switch-case语句进行assertion检查，而且检查的数据类型也不完全相同。

assertion机制让Java程序员用统一的方式处理assertion问题， 而不是按自己的方式处理。另外，如果用户使用自己的方式进行检查，那么这些代码在发布以后仍然将起作用，这可能会影响程序的性能。而从语言言层次支持 assertion功能，这将把assertion对性能带来的负面影响降到最小。

Java是通过增强一个关键字assert实现支持assertion，而不是 使用一个库函数支持，这说明Java认为assertion对于语言本身来说是非常重要的。C语言就是 通过Assert.h函数库实现断言的支持。

Java的assertion的开启也和C语言不太一样，我们都知道在C语言中，assertion的开启是在编译时候决定的。当我们使用debug方式编译程序时候，assertion被开启，而使用release方式编译时候，assertion自动被关闭。

而Java的assertion却是在运行的时候进行决定的。其实，这两种方式是各有优缺点。如果采用编译时决定方式，开发人员将处理两种类型的目标码，debug版本和release版本，这加大了文档管理的难度，但是提高了代码的运行效率。

Java采用运行时决定的方式，这样所有的assertion信息将置于目标代码 中，同一目标代码可以选择不同方式运行，增强目标代码的灵活性，但是它将牺牲因为assertion而引起一部分性能损失。

另外，我们注意到AssertionError作为Error的一个子类，而不 是RuntimeException。Error代表一些异常的错误，通常是不可以恢复的，而 RuntimeException强调该错误在运行时才发生的特点。AssertionError通常为非常关键的错误，这些错误往往是不容易恢复的，而且assertion机制也不鼓励程序员对这种错误进行恢复。

三、assertion与继承

如果一个assert语句在父类，而当它的子类调用它时，该assert为false。父类的assert语句将只有在父类的assert开启才起作用，如果仅仅开启子类的assert，父类的assert仍然不运行。因此，assert语句不具有继承功能。

四、assertion的使用

assertion的使用是一个复杂的问题，通常来说，assertion用于检查一些关键的值，并且这些值对整个程序，或者局部功能的完成有很大的影响，并且这种错误不容易恢复的。

assertion表达式应该短小、易懂，如果需要评估复杂的表达式，应该使用函数计算。以下是一些使用assertion的情况的例子，这些方式可以让java程序的可靠性更高。

检查控制流； 在if-then-else和swith-case语句中，我们可以在不应该发生的控制支流上加上assert false语句。如果这种情况发生了，assert能够检查出来。

在私有函数计算前，检查输入参数是否有效；对于一私有些函数，要求输入满足一些特定的条件，那么我们可以在函数开始处使用assert进行参数检查。

对于公共函数，我们通常不使用assertion检查，因为一般来说，公共函数必须对无效的参数进行检查和处理。而私有函数往往是直接使用的。例如：某函数可能要求输入的参数必须不为null。那么我们可以在函数的一开始加上：

assert parameter1!=null : "paramerter is null in test method";

在函数计算后，检查函数结果是否有效；对于一些计算函数，函数运行完成后，某些值需要保证一定的性质，因此我们可以通过assert检查该值。例如，我们有一个计算绝对值的函数，那么我们就可以在函数的结果处，加上一个语句：

assert value=0:"Value should be bigger than 0:"+value;

通过这种方式，我们可以对函数计算完的结果进行检查。检查程序不变量；有些程序中，存在一些不变量，在程序的运行生命周期，这些不变量的值都是不变的。这些不变量可能是一个简单表达式，也可能是一个复杂的表达式。

对于一些关键的不变量，我们可以通过assert进行检查。例如，在一个财会系统中，公司的支出和收入必须保持一定的平衡关系，因此我们可以编写一个表达式检查这种平衡关系，如下表示：

private boolean isBalance() { …… }

在这个系统中，在一些可能影响这种平衡关系的方法的前后，我们都可以加上assert验证：

assert isBalance():"balance is destoried";

五、补充

必须清楚AssertionError是继承自Error得，因此你可以不再程序中catch它的，当然你也可以在程序中catch它然后程序可以继续执行。

例如：

public class AssertTest

{

public static void main(String[] args)

{

AssertTest at = new AssertTest();

try

{

at.assertMe(true);

at.assertMe(false);

}

catch(AssertionError ae)

{

System.out.println("AsseriontError catched");

}

System.out.println("go on");

}

private void assertMe(boolean boo)

{

assert boo?true:false;

System.out.println("true condition");

}

}

Assert最好不要滥用，原因是assert并不一定都是enable的，下面两种情况就不应该用assert

不要再public的方法里面检查参数是不是为null之类的操作

例如public int get(String s)

{

assert s != null;

}

如果需要检查也最好通过if s = null 抛出NullPointerException来检查

不要用assert来检查方法操作的返回值来判断方法操作的结果

例如 assert list.removeAll();这样看起来好像没有问题 但是想想如果assert 被disable呢，那样他就不会被执行了 所以removeAll()操作就没有被执行 可以这样代替

boolean boo = list.removeAl();

assert boo;

java加密的几种方式

基本的单向加密算法：

BASE64 严格地说，属于编码格式，而非加密算法

MD5(Message Digest algorithm 5，信息摘要算法)

SHA(Secure Hash Algorithm，安全散列算法)

HMAC(Hash Message Authentication Code，散列消息鉴别码)

复杂的对称加密（DES、PBE）、非对称加密算法：

DES(Data Encryption Standard，数据加密算法)

PBE(Password-based encryption，基于密码验证)

RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)

DH(Diffie-Hellman算法，密钥一致协议)

DSA(Digital Signature Algorithm，数字签名)

ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)

代码参考：

/**

* BASE64加密

*

* @param key

* @return

* @throws Exception

*/

public static String encryptBASE64(byte[] key) throws Exception {

return (new BASE64Encoder()).encodeBuffer(key);

}

/**

* MD5加密

*

* @param data

* @return

* @throws Exception

*/

public static byte[] encryptMD5(byte[] data) throws Exception {

MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);

md5.update(data);

return md5.digest();

}

/**

* SHA加密

*

* @param data

* @return

* @throws Exception

*/

public static byte[] encryptSHA(byte[] data) throws Exception {

MessageDigest sha = MessageDigest.getInstance(KEY_SHA);

sha.update(data);

return sha.digest();

}

}

/**

* 初始化HMAC密钥

*

* @return

* @throws Exception

*/

public static String initMacKey() throws Exception {

KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

SecretKey secretKey = keyGenerator.generateKey();

return encryptBASE64(secretKey.getEncoded());

}

/**

* HMAC加密

*

* @param data

* @param key

* @return

* @throws Exception

*/

public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);

Mac mac = Mac.getInstance(secretKey.getAlgorithm());

mac.init(secretKey);

return mac.doFinal(data);

}

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