分类 学习类 下的文章

JVM 指令集

指令码 助记符 说明
0×00 nop 什么都不做
0×01 aconst_null 将null推送至栈顶
0×02 iconst_m1 将int型-1推送至栈顶
0×03 iconst_0 将int型0推送至栈顶
0×04 iconst_1 将int型1推送至栈顶
0×05 iconst_2 将int型2推送至栈顶
0×06 iconst_3 将int型3推送至栈顶
0×07 iconst_4 将int型4推送至栈顶
0×08 iconst_5 将int型5推送至栈顶
0×09 lconst_0 将long型0推送至栈顶
0x0a lconst_1 将long型1推送至栈顶
0x0b fconst_0 将float型0推送至栈顶
0x0c fconst_1 将float型1推送至栈顶
0x0d fconst_2 将float型2推送至栈顶
0x0e dconst_0 将double型0推送至栈顶
0x0f dconst_1 将double型1推送至栈顶
0×10 bipush 将单字节的常量值(-128~127)推送至栈顶
0×11 sipush 将一个短整型常量值(-32768~32767)推送至栈顶
0×12 ldc 将int, float或String型常量值从常量池中推送至栈顶
0×13 ldc_w 将int, float或String型常量值从常量池中推送至栈顶(宽索引)
0×14 ldc2_w 将long或double型常量值从常量池中推送至栈顶(宽索引)
0×15 iload 将指定的int型本地变量推送至栈顶
0×16 lload 将指定的long型本地变量推送至栈顶
0×17 fload 将指定的float型本地变量推送至栈顶
0×18 dload 将指定的double型本地变量推送至栈顶
0×19 aload 将指定的引用类型本地变量推送至栈顶
0x1a iload_0 将第0个int型本地变量推送至栈顶
0x1b iload_1 将第1个int型本地变量推送至栈顶
0x1c iload_2 将第2个int型本地变量推送至栈顶
0x1d iload_3 将第3个int型本地变量推送至栈顶
0x1e lload_0 将第0个long型本地变量推送至栈顶
0x1f lload_1 将第1个long型本地变量推送至栈顶
0×20 lload_2 将第2个long型本地变量推送至栈顶
0×21 lload_3 将第3个long型本地变量推送至栈顶
0×22 fload_0 将第0个float型本地变量推送至栈顶
0×23 fload_1 将第1个float型本地变量推送至栈顶
0×24 fload_2 将第2个float型本地变量推送至栈顶
0×25 fload_3 将第3个float型本地变量推送至栈顶
0×26 dload_0 将第0个double型本地变量推送至栈顶
0×27 dload_1 将第1个double型本地变量推送至栈顶
0×28 dload_2 将第2个double型本地变量推送至栈顶
0×29 dload_3 将第3个double型本地变量推送至栈顶
0x2a aload_0 将第0个引用类型本地变量推送至栈顶
0x2b aload_1 将第1个引用类型本地变量推送至栈顶
0x2c aload_2 将第2个引用类型本地变量推送至栈顶
0x2d aload_3 将第3个引用类型本地变量推送至栈顶
0x2e iaload 将int型数组指定索引的值推送至栈顶
0x2f laload 将long型数组指定索引的值推送至栈顶
0×30 faload 将float型数组指定索引的值推送至栈顶
0×31 daload 将double型数组指定索引的值推送至栈顶
0×32 aaload 将引用型数组指定索引的值推送至栈顶
0×33 baload 将boolean或byte型数组指定索引的值推送至栈顶
0×34 caload 将char型数组指定索引的值推送至栈顶
0×35 saload 将short型数组指定索引的值推送至栈顶
0×36 istore 将栈顶int型数值存入指定本地变量
0×37 lstore 将栈顶long型数值存入指定本地变量
0×38 fstore 将栈顶float型数值存入指定本地变量
0×39 dstore 将栈顶double型数值存入指定本地变量
0x3a astore 将栈顶引用型数值存入指定本地变量
0x3b istore_0 将栈顶int型数值存入第0个本地变量
0x3c istore_1 将栈顶int型数值存入第1个本地变量
0x3d istore_2 将栈顶int型数值存入第2个本地变量
0x3e istore_3 将栈顶int型数值存入第3个本地变量
0x3f lstore_0 将栈顶long型数值存入第0个本地变量
0×40 lstore_1 将栈顶long型数值存入第1个本地变量
0×41 lstore_2 将栈顶long型数值存入第2个本地变量
0×42 lstore_3 将栈顶long型数值存入第3个本地变量
0×43 fstore_0 将栈顶float型数值存入第0个本地变量
0×44 fstore_1 将栈顶float型数值存入第1个本地变量
0×45 fstore_2 将栈顶float型数值存入第2个本地变量
0×46 fstore_3 将栈顶float型数值存入第3个本地变量
0×47 dstore_0 将栈顶double型数值存入第0个本地变量
0×48 dstore_1 将栈顶double型数值存入第1个本地变量
0×49 dstore_2 将栈顶double型数值存入第2个本地变量
0x4a dstore_3 将栈顶double型数值存入第3个本地变量
0x4b astore_0 将栈顶引用型数值存入第0个本地变量
0x4c astore_1 将栈顶引用型数值存入第1个本地变量
0x4d astore_2 将栈顶引用型数值存入第2个本地变量
0x4e astore_3 将栈顶引用型数值存入第3个本地变量
0x4f iastore 将栈顶int型数值存入指定数组的指定索引位置
0×50 lastore 将栈顶long型数值存入指定数组的指定索引位置
0×51 fastore 将栈顶float型数值存入指定数组的指定索引位置
0×52 dastore 将栈顶double型数值存入指定数组的指定索引位置
0×53 aastore 将栈顶引用型数值存入指定数组的指定索引位置
0×54 bastore 将栈顶boolean或byte型数值存入指定数组的指定索引位置
0×55 castore 将栈顶char型数值存入指定数组的指定索引位置
0×56 sastore 将栈顶short型数值存入指定数组的指定索引位置
0×57 pop 将栈顶数值弹出 (数值不能是long或double类型的)
0×58 pop2 将栈顶的一个(long或double类型的)或两个数值弹出(其它)
0×59 dup 复制栈顶数值并将复制值压入栈顶
0x5a dup_x1 复制栈顶数值并将两个复制值压入栈顶
0x5b dup_x2 复制栈顶数值并将三个(或两个)复制值压入栈顶
0x5c dup2 复制栈顶一个(long或double类型的)或两个(其它)数值并将复制值压入栈顶
0x5d dup2_x1 <待补充>
0x5e dup2_x2 <待补充>
0x5f swap 将栈最顶端的两个数值互换(数值不能是long或double类型的)
0×60 iadd 将栈顶两int型数值相加并将结果压入栈顶
0×61 ladd 将栈顶两long型数值相加并将结果压入栈顶
0×62 fadd 将栈顶两float型数值相加并将结果压入栈顶
0×63 dadd 将栈顶两double型数值相加并将结果压入栈顶
0×64 isub 将栈顶两int型数值相减并将结果压入栈顶
0×65 lsub 将栈顶两long型数值相减并将结果压入栈顶
0×66 fsub 将栈顶两float型数值相减并将结果压入栈顶
0×67 dsub 将栈顶两double型数值相减并将结果压入栈顶
0×68 imul 将栈顶两int型数值相乘并将结果压入栈顶
0×69 lmul 将栈顶两long型数值相乘并将结果压入栈顶
0x6a fmul 将栈顶两float型数值相乘并将结果压入栈顶
0x6b dmul 将栈顶两double型数值相乘并将结果压入栈顶
0x6c idiv 将栈顶两int型数值相除并将结果压入栈顶
0x6d ldiv 将栈顶两long型数值相除并将结果压入栈顶
0x6e fdiv 将栈顶两float型数值相除并将结果压入栈顶
0x6f ddiv 将栈顶两double型数值相除并将结果压入栈顶
0×70 irem 将栈顶两int型数值作取模运算并将结果压入栈顶
0×71 lrem 将栈顶两long型数值作取模运算并将结果压入栈顶
0×72 frem 将栈顶两float型数值作取模运算并将结果压入栈顶
0×73 drem 将栈顶两double型数值作取模运算并将结果压入栈顶
0×74 ineg 将栈顶int型数值取负并将结果压入栈顶
0×75 lneg 将栈顶long型数值取负并将结果压入栈顶
0×76 fneg 将栈顶float型数值取负并将结果压入栈顶
0×77 dneg 将栈顶double型数值取负并将结果压入栈顶
0×78 ishl 将int型数值左移位指定位数并将结果压入栈顶
0×79 lshl 将long型数值左移位指定位数并将结果压入栈顶
0x7a ishr 将int型数值右(符号)移位指定位数并将结果压入栈顶
0x7b lshr 将long型数值右(符号)移位指定位数并将结果压入栈顶
0x7c iushr 将int型数值右(无符号)移位指定位数并将结果压入栈顶
0x7d lushr 将long型数值右(无符号)移位指定位数并将结果压入栈顶
0x7e iand 将栈顶两int型数值作“按位与”并将结果压入栈顶
0x7f land 将栈顶两long型数值作“按位与”并将结果压入栈顶
0×80 ior 将栈顶两int型数值作“按位或”并将结果压入栈顶
0×81 lor 将栈顶两long型数值作“按位或”并将结果压入栈顶
0×82 ixor 将栈顶两int型数值作“按位异或”并将结果压入栈顶
0×83 lxor 将栈顶两long型数值作“按位异或”并将结果压入栈顶
0×84 iinc 将指定int型变量增加指定值,可以有两个变量,分别表示index, const,index指第index个int型本地变量,const增加的值
0×85 i2l 将栈顶int型数值强制转换成long型数值并将结果压入栈顶
0×86 i2f 将栈顶int型数值强制转换成float型数值并将结果压入栈顶
0×87 i2d 将栈顶int型数值强制转换成double型数值并将结果压入栈顶
0×88 l2i 将栈顶long型数值强制转换成int型数值并将结果压入栈顶
0×89 l2f 将栈顶long型数值强制转换成float型数值并将结果压入栈顶
0x8a l2d 将栈顶long型数值强制转换成double型数值并将结果压入栈顶
0x8b f2i 将栈顶float型数值强制转换成int型数值并将结果压入栈顶
0x8c f2l 将栈顶float型数值强制转换成long型数值并将结果压入栈顶
0x8d f2d 将栈顶float型数值强制转换成double型数值并将结果压入栈顶
0x8e d2i 将栈顶double型数值强制转换成int型数值并将结果压入栈顶
0x8f d2l 将栈顶double型数值强制转换成long型数值并将结果压入栈顶
0×90 d2f 将栈顶double型数值强制转换成float型数值并将结果压入栈顶
0×91 i2b 将栈顶int型数值强制转换成byte型数值并将结果压入栈顶
0×92 i2c 将栈顶int型数值强制转换成char型数值并将结果压入栈顶
0×93 i2s 将栈顶int型数值强制转换成short型数值并将结果压入栈顶
0×94 lcmp 比较栈顶两long型数值大小,并将结果(1,0,-1)压入栈顶
0×95 fcmpl 比较栈顶两float型数值大小,并将结果(1,0,-1)压入栈顶;当其中一个数值为NaN时,将-1压入栈顶
0×96 fcmpg 比较栈顶两float型数值大小,并将结果(1,0,-1)压入栈顶;当其中一个数值为NaN时,将1压入栈顶
0×97 dcmpl 比较栈顶两double型数值大小,并将结果(1,0,-1)压入栈顶;当其中一个数值为NaN时,将-1压入栈顶
0×98 dcmpg 比较栈顶两double型数值大小,并将结果(1,0,-1)压入栈顶;当其中一个数值为NaN时,将1压入栈顶
0×99 ifeq 当栈顶int型数值等于0时跳转
0x9a ifne 当栈顶int型数值不等于0时跳转
0x9b iflt 当栈顶int型数值小于0时跳转
0x9c ifge 当栈顶int型数值大于等于0时跳转
0x9d ifgt 当栈顶int型数值大于0时跳转
0x9e ifle 当栈顶int型数值小于等于0时跳转
0x9f if_icmpeq 比较栈顶两int型数值大小,当结果等于0时跳转
0xa0 if_icmpne 比较栈顶两int型数值大小,当结果不等于0时跳转
0xa1 if_icmplt 比较栈顶两int型数值大小,当结果小于0时跳转
0xa2 if_icmpge 比较栈顶两int型数值大小,当结果大于等于0时跳转
0xa3 if_icmpgt 比较栈顶两int型数值大小,当结果大于0时跳转
0xa4 if_icmple 比较栈顶两int型数值大小,当结果小于等于0时跳转
0xa5 if_acmpeq 比较栈顶两引用型数值,当结果相等时跳转
0xa6 if_acmpne 比较栈顶两引用型数值,当结果不相等时跳转
0xa7 goto 无条件跳转
0xa8 jsr 跳转至指定16位offset位置,并将jsr下一条指令地址压入栈顶
0xa9 ret 返回至本地变量指定的index的指令位置(一般与jsr, jsr_w联合使用)
0xaa tableswitch 用于switch条件跳转,case值连续(可变长度指令)
0xab lookupswitch 用于switch条件跳转,case值不连续(可变长度指令)
0xac ireturn 从当前方法返回int
0xad lreturn 从当前方法返回long
0xae freturn 从当前方法返回float
0xaf dreturn 从当前方法返回double
0xb0 areturn 从当前方法返回对象引用
0xb1 return 从当前方法返回void
0xb2 getstatic 获取指定类的静态域,并将其值压入栈顶
0xb3 putstatic 为指定的类的静态域赋值
0xb4 getfield 获取指定类的实例域,并将其值压入栈顶
0xb5 putfield 为指定的类的实例域赋值
0xb6 invokevirtual 调用实例方法
0xb7 invokespecial 调用超类构造方法,实例初始化方法,私有方法
0xb8 invokestatic 调用静态方法
0xb9 invokeinterface 调用接口方法
0xba
0xbb new 创建一个对象,并将其引用值压入栈顶
0xbc newarray 创建一个指定原始类型(如int, float, char…)的数组,并将其引用值压入栈顶
0xbd anewarray 创建一个引用型(如类,接口,数组)的数组,并将其引用值压入栈顶
0xbe arraylength 获得数组的长度值并压入栈顶
0xbf athrow 将栈顶的异常抛出
0xc0 checkcast 检验类型转换,检验未通过将抛出ClassCastException
0xc1 instanceof 检验对象是否是指定的类的实例,如果是将1压入栈顶,否则将0压入栈顶
0xc2 monitorenter 获得对象的锁,用于同步方法或同步块
0xc3 monitorexit 释放对象的锁,用于同步方法或同步块
0xc4 wide 当本地变量的索引超过255时使用该指令扩展索引宽度。
0xc5 multianewarray create a new array of dimensions dimensions with elements of type identified by class reference in constant pool index (indexbyte1 << 8 + indexbyte2); the sizes of each dimension is identified by count1, [count2, etc.]
0xc6 ifnull if value is null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
0xc7 ifnonnull if value is not null, branch to instruction at branchoffset (signed short constructed from unsigned bytes branchbyte1 << 8 + branchbyte2)
0xc8 goto_w goes to another instruction at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4)
0xc9 jsr_w jump to subroutine at branchoffset (signed int constructed from unsigned bytes branchbyte1 << 24 + branchbyte2 << 16 + branchbyte3 << 8 + branchbyte4) and place the return address on the stack
0xca breakpoint reserved for breakpoints in Java debuggers; should not appear in any class file
0xcb-0xfd 未命名 these values are currently unassigned for opcodes and are reserved for future use
0xfe impdep1 reserved for implementation-dependent operations within debuggers; should not appear in any class file
0xff impdep2 reserved for implementation-dependent operations within debuggers; should not appear in any class file

英文参照表:

https://en.wikipedia.org/wiki/Java_bytecode_instruction_listings

java Agent 简单学习

java_logo

前言

java.lang.instrument包是Java中来增强JVM上的应用的一种方式,机制是在JVM启动前或启动后attach上去进行修改方法字节码的方式。
instrument包的用途很多,主要体现在对代码侵入低的优点上,例如一些监控不方便修改业务代码,但是可以使用这种方式在方法中植入特定逻辑,这种方式能够直接修改JVM中加载的字节码的内容,而不需要在像Spring AOP实现中创建新的代理类,所以在底层侵入更高,但是对开发者更透明。用于自动添加getter/setter方法的工具lombok就使用了这一技术。另外btrace和housemd等动态诊断工具也是用了instrument技术。

创建一个简单的Agent

关于premain的介绍:

通常agent的包里面MATE-INF目录下的MANIFEST.MF中会有这样一段声明

Premain-Class: cn.org.javaweb.test.Agent

在你通过启动命令添加-javaagent:xxx.jar 的时候,JVM会去xxx.jar中找其中Premain-Class是你在MANIFEST.MF中声明的cn.org.javaweb.test.Agent这个类中的public static void premain(String agentOps, Instrumentation instrumentation)或者public static void premain(String agentOps)方法.

注意这里,public static void premain(String agentOps, Instrumentation instrumentation)public static void premain(String agentOps)这两个是有优先级的,其中当premain有两个参数,也就是public static void premain(String agentOps, Instrumentation instrumentation)的时候优先级最高,如果两个都存在,public static void premain(String agentOps)则会被忽略。

其中agentOps将获得程序的参数,会随着-javaagent一起传入,如下:

java -javaagent:agent-0.0.1.jar="Hello World.?"  -jar agent-1.0-SNAPSHOT.jar

将会将Hello World.?传入进去,和main方法不一样的是,该处传入的是一串完整的字符串,并不会传入解析以后的字符串,所以此处如果有需要的话,那么此处传入字符串将由agent完成解析

其中instrumentationjava.lang.instrument.Instrumentation 的实例,由 JVM 自动传入。java.lang.instrument.Instrumentationinstrument 包中定义的一个接口,也是这个包的核心部分,集中了其中几乎所有的功能方法,例如类定义的转换和操作等等。


了解了以上知识以后,我们来创建一个agent。

创建agent

首先创建一个名为cn.org.javaweb.test的包,然后在该包下创建一个为Agent的类,
如下:

package cn.org.javaweb.test;
/*
 * Copyright sky 2018-11-20 Email:sky@03sec.com.
 *
 * Licensed 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.
 */

/**
 * @author sky
 */
public class Agent {
}

然后写一个premain方法

public static void premain(String agentOps, Instrumentation inst) {
        System.out.println("=======this is agent premain function=======");
    }

将其使用maven打包为jar文件,pom.xml文件中build的内容为:

<plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.0.2</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                        </manifest>
                        <manifestEntries>
                            <Premain-Class>
                                cn.org.javaweb.test.Agent
                            </Premain-Class>
                            <can-redefine-classes>
                                true
                            </can-redefine-classes>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>
</plugins>

然后使用maven中的clean install命令安装即可(或者使用mvn clean package),将会生成一个agent.jar的文件。

创建测试程序

此时我们随便新建一个带有main方法的程序,

package cn.org.javaweb.test;
/*
 * Copyright sky 2018-11-20 Email:sky@03sec.com.
 *
 * Licensed 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.
 */

/**
 * @author sky
 */
public class TestAgent {

    public static void main(String[] args) {
        System.out.print("Hello,This is TestAgent Program!");
    }
}

pom.xml文件中build的内容是


        <plugins>
            <plugin>
                <artifactId>maven-shade-plugin</artifactId>
                <groupId>org.apache.maven.plugins</groupId>
                <version>1.2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>cn.org.javaweb.test.TestAgent</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
</plugins>

然后使用maven生成jar文件。

测试agent

这时候我们会得到两个jar文件,

agent.jar --> agent生成的jar文件
test.jar  --> 测试程序

我们先来运行下测试程序,看是否正常

java -jar test.jar 

输出

Hello,This is TestAgent Program!

然后我们加入agent运行试试看

java -javaagent:agent.jar -jar test.jar

输出

=======this is agent premain function=======
Hello,This is TestAgent Program!

可以看到premain会在程序的main方法之前运行,此时我们可以简单的看下jvm中加入agent以及不加入agent的运行过程。

不加入agent的运行过程

加入agent的运行过程

可以简单明了的看到agent会在运行程序之前运行,但是其后面涉及到其他复杂的逻辑,这里不做解释。

使用instrumentation参数

在上面我们只是进入了premain方法,其中premain方法的instrumentation参数我们并没有用到,这里我们将简单的介绍使用instrumentation参数。

关于Transformer解释

此方法的实现可以转换提供的类文件,并返回一个新的替换类文件。
有两种装换器,由 Instrumentation.addTransformer(ClassFileTransformer,boolean)canRetransform 参数确定:

  • 可重转换 转换器,将 canRetransform 设为 true 可添加这种转换器
  • 不可重转换 转换器,将 canRetransform 设为 false 或者使用 Instrumentation.addTransformer(ClassFileTransformer)可添加这种转换器

在转换器使用 addTransformer 注册之后,每次定义新类和重定义类时都将调用该转换器。
每次重转换类时还将调用可重转换转换器。
对新类定义的请求通过 ClassLoader.defineClass或其本机等价方法进行。
对类重定义的请求通过 Instrumentation.redefineClasses 或其本机等价方法进行。
对类重转换的请求将通过Instrumentation.retransformClasses 或其本机等价方法进行。
转换器是在验证或应用类文件字节之前的请求处理过程中调用的。
当存在多个转换器时,转换将由 transform 调用链组成。 也就是说,一个 transform 调用返回的 byte 数组将成为下一个调用的输入(通过 classfileBuffer 参数)。

转换将按以下顺序应用:

  • 不可重转换转换器
  • 不可重转换本机转换器
  • 可重转换转换器
  • 可重转换本机转换器

对于重转换,不会调用不可重转换转换器,而是重用前一个转换的结果。对于所有其他情况,调用此方法。在每个这种调用组中,转换器将按照注册的顺序调用。本机转换器由 Java 虚拟机 Tool 接口中的 ClassFileLoadHook 事件提供。

ClassLoader loader                  ----> 这个没什么解释的,就是classloader
String className                    ----> 包名(jvm中包名是/而不是.)
Class<?> classBeingRedefined        ----> 如果是被重定义或重转换触发,则为重定义或重转换的类;如果是类加载,则为 null
ProtectionDomain protectionDomain   ----> 保护域
byte[] classfileBuffer              ----> 二进制字节码

添加一个新的Transformer类

我们新建一个名为TestTransformer的类,内容入下:

/*
 * Copyright sky 2018-11-20 Email:sky@03sec.com.
 *
 * Licensed 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 cn.org.javaweb.test;

import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

/**
 * @author sky
 */
public class TestTransformer implements ClassFileTransformer {

    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                            ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {

        System.out.println(className.replace("/", "."));
        return classfileBuffer;
    }
}

在Agent.java中修改premain方法为

System.out.println("=======this is agent premain function=======");
inst.addTransformer(new TestTransformer());

将我们新建的TestTransformer注册进去
这时候我们在重新生成agent后运行如下命令

java -javaagent:agent.jar -jar test.jar

将会输出

=======this is agent premain function=======
sun.launcher.LauncherHelper
cn.org.javaweb.test.TestAgent
java.lang.Void
Hello,This is TestAgent Program!
java.lang.Shutdown
java.lang.Shutdown$Lock

可以看到会输出很多包名,这是因为我们在TestTransformer中将包名打印了出来。

结束语

关于agent的简单使用就介绍到了此处,此文仅抛砖引玉,更多用法可以发挥想象,比如性能监控,日志监控、管理会话、安全过滤、请求管理等。

文章中涉及到的代码全部都在下面地址:

https://gitlab.com/iiusky/javaagent

参考:

Spring中注解大全和应用

@Controller
@RestController:
@Service
@Autowired
@RequestMapping
@RequestParam
@ModelAttribute
@Cacheable
@CacheEvict
@Resource
@PostConstruct
@PreDestroy
@Repository
@Component
@Scope
@SessionAttributes
@Required
@Qualifier

@Controller

标识一个该类是Spring MVC controller处理器,用来创建处理http请求的对象.

@Controller
public class TestController {
        @RequestMapping("/test")
        public String test(Map<String,Object> map){

            return "hello";
        }
}

@RestController

Spring4之后加入的注解,原来在@Controller中返回json需要@ResponseBody来配合,如果直接用@RestController替代@Controller就不需要再配置@ResponseBody,默认返回json格式。

@RestController
public class TestController {
        @RequestMapping("/test")
        public String test(Map<String,Object> map){

            return "hello";
        }
}

@Service

用于标注业务层组件,说白了就是加入你有一个用注解的方式把这个类注入到spring配置中

@Autowired

用来装配bean,都可以写在字段上,或者方法上。
默认情况下必须要求依赖对象必须存在,如果要允许null值,可以设置它的required属性为false,例如:@Autowired(required=false)

@RequestMapping

类定义处: 提供初步的请求映射信息,相对于 WEB 应用的根目录。
方法处: 提供进一步的细分映射信息,相对于类定义处的 URL。
用过RequestMapping的同学都知道,他有非常多的作用,因此详细的用法
我会在下一篇文章专门讲述,请关注公众号哦,以免错过。

@RequestParam

用于将请求参数区数据映射到功能处理方法的参数上
例如

public Resp test(@RequestParam Integer id){
        return Resp.success(customerInfoService.fetch(id));
    }

这个id就是要接收从接口传递过来的参数id的值的,如果接口传递过来的参数名和你接收的不一致,也可以如下

public Resp test(@RequestParam(value="course_id") Integer id){
        return Resp.success(customerInfoService.fetch(id));
    }

其中course_id就是接口传递的参数,id就是映射course_id的参数名

@ModelAttribute

使用地方有三种:

1. 标记在方法上。

标记在方法上,会在每一个@RequestMapping标注的方法前执行,如果有返回值,则自动>将该返回值加入到ModelMap中。

A.在有返回的方法上:

当ModelAttribute设置了value,方法返回的值会以这个value为key,以参数接受到的值作为value,存入到Model中,如下面的方法执行之后,最终相当于 model.addAttribute("user_name", name);假如 @ModelAttribute没有自定义value,则相当于
model.addAttribute("name", name);

@ModelAttribute(value="user_name")
    public String before2(@RequestParam(required = false) String name, Model model) {
        System.out.println("进入了2:" + name);
        return name;
    }

B.在没返回的方法上:

需要手动model.add方法

@ModelAttribute
    public void before(@RequestParam(required = false) Integer age, Model model) {
        model.addAttribute("age", age);
        System.out.println("进入了1:" + age);
    }

我们在当前类下建一个请求方法:

@RequestMapping(value="/mod")
     public Resp mod(
             @RequestParam(required = false) String name,
             @RequestParam(required = false) Integer age, 
             Model model){
         System.out.println("进入mod");
         System.out.println("参数接受的数值{name="+name+";age="+age+"}");
         System.out.println("model传过来的值:"+model);
         return Resp.success("1");
    }

在浏览器中输入访问地址并且加上参数:
http://localhost:8081/api/test/mod?name=我是小菜&age=12

最终输出如下:

1进入了1:40
2进入了2:我是小菜
3进入mod
4参数接受的数值{name=我是小菜;age=12}
5model传过来的值:{age=40, user_name=我是小菜}

2. 标记在方法的参数上。

标记在方法的参数上,会将客户端传递过来的参数按名称注入到指定对象中,并且会将这个对象自动加入ModelMap中,便于View层使用.
我们在上面的类中加入一个方法如下

@RequestMapping(value="/mod2")
     public Resp mod2(@ModelAttribute("user_name") String user_name, 
             @ModelAttribute("name") String name,
             @ModelAttribute("age") Integer age,Model model){
         System.out.println("进入mod2");
         System.out.println("user_name:"+user_name);
         System.out.println("name:"+name);
         System.out.println("age:"+age);
         System.out.println("model:"+model);
        return Resp.success("1");
    }

```在浏览器中输入访问地址并且加上参数:
http://localhost:8081/api/test/mod2?name=我是小菜&age=12
最终输出:

1进入了1:40
2进入了2:我是小菜
3进入mod2
4user_name:我是小菜
5name:我是小菜
6age:40
7model:{user_name=我是小菜, 
org.springframework.validation.BindingResult.user_name=org.springframework.validation.BeanPropertyBindingResult: 0 errors, name=我是小菜, org.springframework.validation.BindingResult.name=org.springframework.validation.BeanPropertyBindingResult: 0 errors, age=40, org.springframework.validation.BindingResult.age=org.springframework.validation.BeanPropertyBindingResult: 0 errors}
从结果就能看出,用在方法参数中的@ModelAttribute注解,实际上是一种接受参数并且自动放入Model对象中,便于使用。

@Cacheable

用来标记缓存查询。可用用于方法或者类中,

当标记在一个方法上时表示该方法是支持缓存的,
当标记在一个类上时则表示该类所有的方法都是支持缓存的。
参数列表

参数 解释 例子
value 名称 @Cacheable(value={”c1”,”c2”}
key key @Cacheable(value=”c1”,key=”#id”)
condition 条件 @Cacheable(value=”c1”,condition=”#id=1”)比如@Cacheable(value="UserCache") 标识的是当调用了标记了这个注解的方法时,逻辑默认加上从缓存中获取结果的逻辑,如果缓存中没有数据,则执行用户编写查询逻辑,查询成功之后,同时将结果放入缓存中。但凡说到缓存,都是key-value的形式的,因此key就是方法中的参数(id),value就是查询的结果,而命名空间UserCache是在spring*.xml中定义.
@Cacheable(value="UserCache")// 使用了一个缓存名叫 accountCache   
public Account getUserAge(int id) {  
     //这里不用写缓存的逻辑,直接按正常业务逻辑走即可,
     //缓存通过切面自动切入  
    int age=getUser(id);   
     return age;   
} 

@CacheEvict

用来标记要清空缓存的方法,当这个方法被调用后,即会清空缓存。 @CacheEvict(value=”UserCache”)

参数列表

参数 解释 例子
value 名称 @CachEvict(value={”c1”,”c2”}
key key @CachEvict(value=”c1”,key=”#id”)
condition 缓存的条件,可以为空
allEntries 是否清空所有缓存内容 @CachEvict(value=”c1”,allEntries=true)
beforeInvocation 是否在方法执行前就清空 @CachEvict(value=”c1”,beforeInvocation=true)

@Resource

@Resource的作用相当于@Autowired
只不过@Autowired按byType自动注入,
而@Resource默认按 byName自动注入罢了。

@Resource有两个属性是比较重要的,分是name和type,Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性,这时将通过反射机制使用byName自动注入策略。

@Resource装配顺序:
如果同时指定了name和type,则从Spring上下文中找到唯一匹配的bean进行装配,找不到则抛出异常
如果指定了name,则从上下文中查找名称(id)匹配的bean进行装配,找不到则抛出异常

如果指定了type,则从上下文中找到类型匹配的唯一bean进行装配,找不到或者找到多个,都会抛出异常

如果既没有指定name,又没有指定type,则自动按照byName方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配;

@PostConstruct

用来标记是在项目启动的时候执行这个方法。用来修饰一个非静态的void()方法
也就是spring容器启动时就执行,多用于一些全局配置、数据字典之类的加载

被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行,并且只会被服务器执行一次。PostConstruct在构造函数之后执行,init()方法之前执行。PreDestroy()方法在destroy()方法执行执行之后执

@PreDestroy

被@PreDestroy修饰的方法会在服务器卸载Servlet的时候运行,并且只会被服务器调用一次,类似于Servlet的destroy()方法。被@PreDestroy修饰的方法会在destroy()方法之后运行,在Servlet被彻底卸载之前

@Repository

用于标注数据访问组件,即DAO组件

@Component

泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注

@Scope

用来配置 spring bean 的作用域,它标识 bean 的作用域。
默认值是单例

singleton:单例模式,全局有且仅有一个实例
prototype:原型模式,每次获取Bean的时候会有一个新的实例

request:request表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP request内有效

session:session作用域表示该针对每一次HTTP请求都会产生一个新的bean,同时该bean仅在当前HTTP session内有效

global session:只在portal应用中有用,给每一个 global http session 新建一个Bean实例。

@SessionAttributes

默认情况下Spring MVC将模型中的数据存储到request域中。当一个请求结束后,数据就失效了。如果要跨页面使用。那么需要使用到session。而@SessionAttributes注解就可以使得模型中的数据存储一份到session域中

参数:

names:这是一个字符串数组。里面应写需要存储到session中数据的名称。
types:根据指定参数的类型,将模型中对应类型的参数存储到session中
value:和names是一样的。

@Controller
 @SessionAttributes(value={"names"},types={Integer.class})
 public class ScopeService {
         @RequestMapping("/testSession")
         public String test(Map<String,Object> map){
             map.put("names", Arrays.asList("a","b","c"));
             map.put("age", 12);
             return "hello";
         }
}

@Required

适用于bean属性setter方法,并表示受影响的bean属性必须在XML配置文件在配置时进行填充。否则,容器会抛出一个BeanInitializationException异常。

@Qualifier

当你创建多个具有相同类型的 bean 时,并且想要用一个属性只为它们其中的一个进行装配,在这种情况下,你可以使用 @Qualifier 注释和 @Autowired 注释通过指定哪一个真正的 bean 将会被装配来消除混乱。

Idea 中使用Groovy 脚本自动生成Entitys类

原生成脚本来自园长:from:http://javaweb.org

import com.intellij.database.model.DasTable
import com.intellij.database.model.ObjectKind
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

/*
 * 默认可用的 context 绑定:
 *   SELECTION   Iterable<DasObject>
 *   PROJECT     project
 *   FILES       files helper
 */

packageName = ""
typeMapping = [
        (~/(?i)tinyint|smallint|mediumint/)      : "Integer",
        (~/(?i)int/)                             : "Long",
        (~/(?i)bool|bit/)                        : "Boolean",
        (~/(?i)float|double|decimal|real/)       : "Double",
        (~/(?i)datetime|timestamp|date|time/)    : "Date",
        (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
        (~/(?i)/)                                : "String"
]

FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
    SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    packageName = getPackageName(dir)
    new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields) }
}

/**
 * 获取包名称
 * @param dir 实体类所在目录
 * @return
 */
def getPackageName(dir) {
    return dir.toString().replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
}

/**
 * 实体类代码生成
 * @param out
 * @param className
 * @param fields
 * @return
 */
def generate(out, className, fields) {
    out.println "package $packageName"
    out.println ""

    Set<String> types = new HashSet<String>()

    fields.each() {
        types.add(it.type)
    }


    out.println "import com.alibaba.fastjson.annotation.JSONField;"
    out.println "import javax.persistence.Column;"
    if (types.contains("Date")) {
        out.println "import java.util.Date;"
    }

    if (types.contains("InputStream")) {
        out.println "import java.io.InputStream;"
    }
    out.println "import java.io.Serializable;"

    out.println ""
    out.println "public class $className implements Serializable {"
    fields.each() {
        out.println ""
        if (it.annos != "") out.println "  ${it.annos}"

        // 输出注释
        if (isNotEmpty(it.commoent)) {
            out.println "\t/**"
            out.println "\t * ${it.commoent}"
            out.println "\t */"
        }

        // 输出成员变量
        out.println "\tprivate ${it.type} ${it.name};"
    }

    // 输出get/set方法
    fields.each() {
        out.println ""

        if (isNotEmpty(it.comment)) {
            out.println "\t/**"
            out.println "\t * 获取${it.comment}"
            out.println "\t * @return"
            out.println "\t */"
        }

        def actionName = "Boolean".equals(it.type.toString()) ? "is" : "get"

        out.println "\tpublic ${it.type} ${actionName}${it.name.capitalize()}() {"
        out.println "\t\treturn this.${it.name};"
        out.println "\t}"
        out.println ""

        if (isNotEmpty(it.comment)) {
            out.println "\t/**"
            out.println "\t * 设置${it.comment}"
            out.println "\t * @param ${it.name}"
            out.println "\t */"
        }
        out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
        out.println "\t\tthis.${it.name} = ${it.name};"
        out.println "\t}"
    }
    out.println ""
    out.println "}"
}

def calcFields(table) {
    DasUtil.getColumns(table).reduce([]) { fields, col ->
        def spec = Case.LOWER.apply(col.getDataType().getSpecification())
        def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
        fields += [[
                           colName : col.getName(),
                           name    : javaName(col.getName(), false),
                           type    : typeStr,
                           comment: col.getComment(),
                           annos   : ""]]
    }
}

def javaName(str, capitalize) {
    def s = str.split(/[^\p{Alnum}]/).collect { def s = Case.LOWER.apply(it).capitalize() }.join("")
    capitalize ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

def isNotEmpty(content) {
    return content != null && content.toString().trim().length() > 0
}

增强版本

增加Serializable ID
增加@JSONField以及@Column注解生成方式
增加添加@Entity注解以及添加@Table 名

import com.intellij.database.model.DasTable
import com.intellij.database.model.ObjectKind
import com.intellij.database.util.Case
import com.intellij.database.util.DasUtil

/*
 * 默认可用的 context 绑定:
 *   SELECTION   Iterable<DasObject>
 *   PROJECT     project
 *   FILES       files helper
 */

packageName = ""
tableName = ""
typeMapping = [
        (~/(?i)tinyint|smallint|mediumint/)      : "Integer",
        (~/(?i)int/)                             : "Long",
        (~/(?i)bool|bit/)                        : "Boolean",
        (~/(?i)float|double|decimal|real/)       : "Double",
        (~/(?i)datetime|timestamp|date|time/)    : "Date",
        (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
        (~/(?i)/)                                : "String"
]

FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
    SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
}

def generate(table, dir) {
    def className = javaName(table.getName(), true)
    def fields = calcFields(table)
    packageName = getPackageName(dir)
    tableName = table.getName()
    new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields) }
}

/**
 * 获取包名称
 * @param dir 实体类所在目录
 * @return
 */
def getPackageName(dir) {
    return dir.toString().replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
}

/**
 * 实体类代码生成
 * @param out
 * @param className
 * @param fields
 * @return
 */
def generate(out, className, fields) {
    out.println "package $packageName"
    out.println ""

    Set<String> types = new HashSet<String>()

    fields.each() {
        types.add(it.type)
    }


    out.println "import com.alibaba.fastjson.annotation.JSONField;"
    out.println "import javax.persistence.Column;"
    out.println "import javax.persistence.Entity;"
    out.println "import javax.persistence.Table;"
    if (types.contains("Date")) {
        out.println "import java.util.Date;"
    }

    if (types.contains("InputStream")) {
        out.println "import java.io.InputStream;"
    }
    out.println "import java.io.Serializable;"

    out.println ""
    out.println "@Entity"
    out.println "@Table(name = \"$tableName\")"
    out.println "public class $className implements Serializable {"
    fields.each() {
        out.println ""
        if (it.annos != "") out.println "  ${it.annos}"

        // 输出注释
        if (isNotEmpty(it.commont)) {
            out.println "\t/**"
            out.println "\t * ${it.commont}"
            out.println "\t */"
        }

        def matcher = ("${it.colName}" =~ /[0-9]/);

        if (matcher.getCount() > 0) {
            //输出Column
            out.println "\t@Column(name = \"${it.colName}\")"
        }

        //输出JSONField
        out.println "\t@JSONField(name = \"${it.colName}\")"
        // 输出成员变量
        out.println "\tprivate ${it.type} ${it.name};"
    }

    // 输出get/set方法
    fields.each() {
        out.println ""

        if (isNotEmpty(it.comment)) {
            out.println "\t/**"
            out.println "\t * 获取${it.comment}"
            out.println "\t * @return"
            out.println "\t */"
        }

        def actionName = "Boolean".equals(it.type.toString()) ? "is" : "get"

        out.println "\tpublic ${it.type} ${actionName}${it.name.capitalize()}() {"
        out.println "\t\treturn this.${it.name};"
        out.println "\t}"
        out.println ""

        if (isNotEmpty(it.comment)) {
            out.println "\t/**"
            out.println "\t * 设置${it.comment}"
            out.println "\t * @param ${it.name}"
            out.println "\t */"
        }
        out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
        out.println "\t\tthis.${it.name} = ${it.name};"
        out.println "\t}"
    }
    out.println ""
    out.println "}"
}

def calcFields(table) {
    DasUtil.getColumns(table).reduce([]) { fields, col ->
        def spec = Case.LOWER.apply(col.getDataType().getSpecification())
        def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
        fields += [[
                           colName: col.getName(),
                           name   : javaName(col.getName(), false),
                           type   : typeStr,
                           comment: col.getComment(),
                           annos  : ""]]
    }
}

def javaName(str, capitalize) {
    def s = str.split(/[^\p{Alnum}]/).collect { def s = Case.LOWER.apply(it).capitalize() }.join("")
    capitalize ? s : Case.LOWER.apply(s[0]) + s[1..-1]
}

def isNotEmpty(content) {
    return content != null && content.toString().trim().length() > 0
}

乐尚视界APP数据包加解密脚本

突然看到一个APP叫乐尚视界,能看十几个网站的vip视频,感觉和之前的网页在线观看vip视频没有实名区别。
在抓包的时候发现了APP对数据包进行了加密,对APP进行反编译后,一边练手一边写出下面的加解密脚本,仅供参考。

/*
 * Copyright sky 2018-01-18 Email:sky@03sec.com.
 *
 * Licensed 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.javaweb.demo;

import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.security.*;
import java.util.Base64;

public class LeeShang {


    public static String aaaaa(String var0) {
        byte[] var3;
        try {
            var3 = MessageDigest.getInstance("md5").digest(var0.getBytes());
        } catch (NoSuchAlgorithmException var2) {
            throw new RuntimeException("没有md5这个算法!");
        }

        var0 = (new BigInteger(1, var3)).toString(16);

        for (int var1 = 0; var1 < 32 - var0.length(); ++var1) {
            var0 = "0" + var0;
        }

        return var0;
    }

    public static byte[] encrypt(byte[] paramArrayOfByte, String password, String secureRandom) {
        try {
            SecretKeySpec keySpec     = secretKeySpec(password);
            Cipher        localCipher = Cipher.getInstance("AES/CBC/NoPadding");
            while (paramArrayOfByte.length % 16 != 0) { //如果paramArrayOfByte的长度不是16的倍数AES加密会报错,这边对paramArrayOfByte进行长度扩展,使它必须为16的倍数
                byte[] tmpByte = {0x00};
                paramArrayOfByte = ByteBuffer.allocate(paramArrayOfByte.length + 1).put(tmpByte).array();
            }
            localCipher.init(2, keySpec, ivParameterSpec(secureRandom));
            paramArrayOfByte = localCipher.doFinal(paramArrayOfByte);
            return paramArrayOfByte;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static byte[] decrypt(byte[] content, String password, String secureRandom) {
        try {
            SecretKeySpec keySpec = secretKeySpec(password);
            Cipher        cipher  = Cipher.getInstance("AES/CBC/NoPadding");// 创建密码器
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec(secureRandom));// 初始化
            byte[] result = cipher.doFinal(content);
            return result; // 加密
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private static SecretKeySpec secretKeySpec(String var0) {
        Object var2 = null;
        String var1 = var0;
        if (var0 == null) {
            var1 = "";
        }

        StringBuffer var4 = new StringBuffer(16);
        var4.append(var1);

        while (var4.length() < 16) {
            var4.append("0");
        }

        if (var4.length() > 16) {
            var4.setLength(16);
        }

        byte[] var5;
        try {
            var5 = var4.toString().getBytes("UTF-8");
        } catch (UnsupportedEncodingException var3) {
            var3.printStackTrace();
            var5 = (byte[]) var2;
        }

        return new SecretKeySpec(var5, "AES");
    }


    private static IvParameterSpec ivParameterSpec(String var0) {
        Object var2 = null;
        String var1 = var0;
        if (var0 == null) {
            var1 = "";
        }

        StringBuffer var4 = new StringBuffer(16);
        var4.append(var1);

        while (var4.length() < 16) {
            var4.append("0");
        }

        if (var4.length() > 16) {
            var4.setLength(16);
        }

        byte[] var5;
        try {
            var5 = var4.toString().getBytes("UTF-8");
        } catch (UnsupportedEncodingException var3) {
            var3.printStackTrace();
            var5 = (byte[]) var2;
        }

        return new IvParameterSpec(var5);
    }

    public static String convertByteArrayToString(byte[] var1) {

        String value = new String(var1);
        return value;
    }

    public static void main(String[] args) {
        String key          = "$75k!xxH&$EhQLmv";
        String secureRandom = aaaaa("$75k!xxH&$EhQLmv").substring(0, 16);
        //解密
        String content      = "jStVIqaSUdIm0aF8mcs8GAjohYApwOUYVXenyG7zeQV86ZFrmO3Z1ixPLEM9srKRaVR1nE+0V3gTKGtlgwWgCg==";
        System.out.println(convertByteArrayToString(decrypt(Base64.getDecoder().decode(content), key, secureRandom)));
        //加密
        String s = "{'token':'x','code':'ghhhh'}";
        System.out.println(Base64.getEncoder().encodeToString(encrypt(s.getBytes(), key, secureRandom)));
    }
}