类加载器加密class文件

需求介绍：Java本身是开源的技术，那么只要拥有反编译工具和项目的.class文件就可以获取源代码内容。

那么如何在源代码级别增强安全性呢？

答：对.class文件做加密操作，让反编译工具无法反编译.class文件

那么如何开始做这个加密操作呢？

答：修改.class文件底层的字节数据

代码演示：

/**
     * @throws Exception
     * 对Class文件进行加密
     */
    @Test
    public void test1() throws Exception {
        FileInputStream in = new FileInputStream(new File("d:/class/MD5Utils.class"));
​
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buf = new byte[2048];
        int len = 0;
        byte mi = 1;
        while ((len = in.read(buf)) != -1) {
            for (int i = 0; i < buf.length; i++) {
                System.out.println("第一次：" + buf);
                buf = (byte) (buf + mi);
                System.out.println("第二次：" + buf);
            }
            out.write(buf, 0, len);
        }
        byte[] byteArray = out.toByteArray();
​
        FileOutputStream fout = new FileOutputStream(new File("d:/clazz/MD5Utils.class"));
​
        fout.write(byteArray, 0, byteArray.length);
    }

那么加密完成之后这个文件如何运行呢？

答：使用类加载器，读取加载文件，创建类对象，调用方法

package cn.itcast.loader;
​
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
​
public class MyClassLoader extends ClassLoader{
​
    @Override
    public Class findClass(String name)  {
        
        //自定义一个类加载器：加载指定位置的.class文件（d:/class）
        String path = "d:/clazz";
        try {
            FileInputStream in = new FileInputStream(new File(path+"/"+name+".class"));
            //根据获取到的数据，创建Class对象
            //需要一个将数据转换为字节数组的输出流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            
            int len = 0;
            byte[] buf = new byte[1024];
            while((len = in.read(buf)) != -1){
               
                out.write(buf, 0, len);
            }
            byte[] byteArray = out.toByteArray();
            for (int i = 0; i < byteArray.length; i++) {
                byteArray = (byte) (byteArray - 1);
            }
            
            return defineClass(name, byteArray, 0, byteArray.length);
            
        } catch (Exception e) {
            e.printStackTrace();
            try {
                return super.findClass(name);
            } catch (ClassNotFoundException e1) {
                e1.printStackTrace();
                return null;
            }
        }
    }
}

在加密的转换过程中byte数据底层加减可能出现超出数据范围的情况（例如：127+1），但是，我们的转换过程中，没有出现任何问题，这是为什么呢？

接下来我们一点点来分析下：

/**
     * 问题：加密 加多少，解密，减多少——————》加密前是多少，加密后，数字也是多少？目前的效果，也是对的
     *
     * 问题：加法运算可能超出byte类型数据的范围，会导致加密解密失败，但是这里为什么没有失败？
     * 同学们的思路：
     *
     *    -127  1111 1111
     *  +   1   0000 0001
     *  ---------------------
     *         10000 0000
     * 最高丢弃       0000 0000 ————》  0
     *
     *      0   0000 0000
     *  -   1   0000 0001
     *  ------------------
     *     -1   1000 0001
     *     
     * 问题：数据经过加减之后，尽然可以，保持原样，那么计算底层到底是怎么计算的？
     *
     * 1 计算底层，所有都是加法运算
     *
     *      1 0000 0001
     *  -   1 0000 0001
     *  ----------------
     *  所有减法都是加法
     *  
     *      1 0000 0001
     *  +  -1 1000 0001
     *  -----------------
     *     -2 1000 0010
     * 错误的结果————按照普通人类的思路
     *
     * 按照机器思路做减法：
     *
     *      1 0000 0001
     *  +  -1 1000 0001
     *  -----------------
     *  获取当前数据（-1）的反码：0 ————》1  1————》0，最高位不动
     *  
     *      1 0000 0001
     *  +  -1 1111 1110
     *  -----------------
     *        1111 1111
     *  在反码计算结果的基础上加一（补码）：
     *        1111 1111
     *  +   1 0000 0001
     *  ----------------
     *       10000 0000
     * byte数据最高位去掉：
     *        0000 0000 ——————》 0
     *
     * 按照机器思路进行加密和解密
     *    -127  1111 1111
     *  +   1   0000 0001
     *  ---------------------
     *         10000 0000
     * byte数据最高位去掉：
     *          0000 0000 ——————》 0
     * 以上是加密
     *
     * 以下解密：
     *          0000 0000
     *    +     1000 0001
     *    ----------------
     *   
     *  反码：  
     *          0000 0000
     *    +     1111 1110
     *    ----------------
     *          1111 1110
     *     
     *  补码：
     *          1111 1110
     *    +     0000 0001
     *  -------------------
     *          1111 1111
     *         
     * 总结：加密和解密不会导致，数据前后不一致，是因为，二进制减法计算的是使用了反码和补码的方式。
     * */
​

通过以上分析，我们发现其实在计算的过程中，计算机使用的是二进制的补码和反码进行运算，因此，没有数据超出范围的问题。

我来占层楼啊