Docker的环境配置 - 《java笔记》

1.加解密
可以把明文转为密文

加密规则：数字自动加一<br />    真实传递：1234：明文<br />    传输：2345（密文）--接收-解析：1234<br />    拜见过阿妈啦？（密文）（你从小拜谁为师？-明文）
1.编码格式<br />        Base64、Base64URL<br />        特点：可以编码，也可以解码<br />        Encoder(编码-加密)/Decoder（解码-解密）<br />    2.摘要算法<br />        按照一定算法规则，将明文生成摘要（密文）<br />        特点：自有加密没有解密，不可逆<br />        常见的摘要算法：1.MD5 2.SHA 3.HMAC<br />        摘要算法不可逆，只能加不能解<br />    3.加解密算法<br />        可以加密，也可以解密<br />        又分为2类，根据密钥的类型<br />        1.对称加解密<br />            加密和解密使用一个密钥<br />            典型算法：AES<br />        2.非对称加解密<br />            加密和解密使用一对儿密钥（公钥和私钥）<br />            公钥加密必须使用私钥解密<br />            私钥加密必须使用公钥解密<br />            如果同一个字符串的密文必须一样，那么应该私钥加密，公钥解密<br />            如果同一个字符串的密文允许不一样，那么就需要公钥加密，私钥解密<br />        <br />            典型算法：RSA<br />    带一个封装好工具类，走哪带哪<br />加密工具类

package com.qyz.common.util;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;

/**
 * 实现常用的加解密 方法，支持 SHA AES RSA Base64
 * @program: HungryApi
 * @description: 常用的加解密
 * @author: Feri(邢朋辉)
 * @create: 2020-06-19 10:01
 */
public class EncryptUtil {
    public static final String SHA1 = "SHA-1";
    public static final String SHA256 = "SHA-256";
    public static final String SHA384 = "SHA-384";
    public static final String SHA512 = "SHA-512";

    public static final String PUBKEY = "public_key";
    public static final String PRIKEY = "private_key";

    //1、编码格式
    //base64 编码
    public static String base64enc(String msg) {
        return Base64.getEncoder ().encodeToString (msg.getBytes ());
    }

    private static String base64encByte(byte[] msg) {
        return Base64.getEncoder ().encodeToString (msg);
    }

    private static byte[] base64decByte(String msg) {
        return Base64.getDecoder ().decode (msg);
    }

    //
    // base64 解码
    public static String base64dec(String msg) {
        return new String (Base64.getDecoder ().decode (msg));
    }

    //MD5 摘要
    public static String md5(String msg) {
        try {
            //创建摘要算法对象
            MessageDigest messageDigest = MessageDigest.getInstance ("MD5");
            messageDigest.update (msg.getBytes ());
            return base64encByte (messageDigest.digest ());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace ();
        }
        return null;
    }

    //SHA 摘要 SHA-1 SHA-256 SHA-384 SHA-512
    public static String sha(String type, String msg) {
        try {
            //创建摘要算法对象
            MessageDigest messageDigest = MessageDigest.getInstance (type);
            messageDigest.update (msg.getBytes ());
            return base64encByte (messageDigest.digest ());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace ();
        }
        return null;
    }

    //创建 对称加密---密钥
    public static String createAESKey() {
        try {
            //1、创建随机key
            KeyGenerator generator = KeyGenerator.getInstance ("AES");
            generator.init (128);
            SecretKey key = generator.generateKey ();
            return base64encByte (key.getEncoded ());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace ();
        }
        return null;
    }
    //AES 加密 返回的是base64格式
    public static String aesenc(String key, String msg) {
        SecretKeySpec secretKeySpec = new SecretKeySpec (base64decByte (key), "AES");
        try {
            Cipher cipher = Cipher.getInstance ("AES");
            cipher.init (Cipher.ENCRYPT_MODE, secretKeySpec);
            return base64encByte (cipher.doFinal (msg.getBytes ()));
        } catch (Exception e) {
            e.printStackTrace ();
        }
        return null;
    }
    //AES 解密 返回的是base64格式
    public static String aesdec(String key, String msg) {
        SecretKeySpec secretKeySpec = new SecretKeySpec (base64decByte (key), "AES");
        try {
            Cipher cipher = Cipher.getInstance ("AES");
            cipher.init (Cipher.DECRYPT_MODE, secretKeySpec);
            return new String (cipher.doFinal (base64decByte (msg)));
        } catch (Exception e) {
            e.printStackTrace ();
        }
        return null;
    }

    //创建-RSA 密钥 一对儿 公私钥
    public static HashMap<String, String> createRSAKey() {
        try {
            KeyPairGenerator generator = KeyPairGenerator.getInstance ("RSA");
            KeyPair keyPair = generator.generateKeyPair ();
            //创建使用私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate ();
            //创建使用公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic ();
            HashMap<String, String> keys = new HashMap<> ();
            keys.put (PUBKEY, base64encByte (publicKey.getEncoded ()));
            keys.put (PRIKEY, base64encByte (privateKey.getEncoded ()));
            return keys;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace ();
        }
        return null;
    }
    /**
     * rsa 公钥-加密*/
    public static String rsaEncPub(String key,String msg){
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(base64decByte(key));
        try {
            KeyFactory keyFactory = KeyFactory.getInstance ("RSA");
            PublicKey publicKey = keyFactory.generatePublic (keySpec);
            Cipher cipher = Cipher.getInstance ("RSA");
            cipher.init (Cipher.ENCRYPT_MODE, publicKey);
            return base64encByte(cipher.doFinal(msg.getBytes()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //RSA  私钥-加密
    public static String rsaEnc(String key, String msg) {
        try {
            //转换私钥
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec (base64decByte (key));
            KeyFactory keyFactory = KeyFactory.getInstance ("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate (keySpec);
            Cipher cipher = Cipher.getInstance ("RSA");
            cipher.init (Cipher.ENCRYPT_MODE, privateKey);
            return  base64encByte(cipher.doFinal(msg.getBytes()));
        } catch (Exception e) {
            e.printStackTrace ();
        }
        return null;
    }
    //RSA  公钥-解密
    public static String rsaDec(String key, String msg) {
        try {
            //转换公钥
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec (base64decByte (key));
            KeyFactory keyFactory = KeyFactory.getInstance ("RSA");
            PublicKey publicKey = keyFactory.generatePublic (keySpec);
            Cipher cipher = Cipher.getInstance ("RSA");
            cipher.init (Cipher.DECRYPT_MODE, publicKey);
            return new String (cipher.doFinal (base64decByte (msg)), "UTF-8");
        } catch (Exception e) {
            e.printStackTrace ();
        }
        return null;
    }
    /**
     * RSA  私钥-解密
     */
    public static String rsaDecPri(String key, String msg) {
        try {
            //转换私钥
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec (base64decByte (key));
            KeyFactory keyFactory = KeyFactory.getInstance ("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate (keySpec);
            Cipher cipher = Cipher.getInstance ("RSA");
            cipher.init (Cipher.DECRYPT_MODE, privateKey);
            return new String(cipher.doFinal(base64decByte(msg)),"UTF-8");
        } catch (Exception e) {
            e.printStackTrace ();
        }
        return null;
    }
}

[https://www.hutool.cn/](https://www.hutool.cn/)<br />2.Docker<br />    Docker:容器化引擎，新型的虚拟机，具备更快的性能，简化<br />    特点：<br />        1.更高效资源使用率<br />        2.性能卓越，时间短<br />        3.一致的环境（研发、测试、生产）<br />        4.可以部署CI&CD(持续集成持续部署)<br />    概念：<br />        1.镜像：安装包，一套软件集合<br />        2.容器：通过镜像安装的软件<br />        3.数据卷：容器所需要的磁盘，虚拟的<br />        4.网络：容器可以有网络<br />        5.仓库：存储镜像的地方<br />    云平台的轻量级应用服务器，可以直接选择Docker镜像，就无需再次安装，默认安装且已启动<br />    如果服务器不带Docker,需要手动安装<br />    <br />    <br />3.Docker常用命令<br />    docker images：查看本地的镜像列表<br />    docker search 镜像名称：搜索镜像是否存在<br />    docker pull 镜像名称:版本号:下载镜像<br />    docker rmi 镜像名称:版本号：删除镜像<br />    docker create :创建容器<br />    docker start 容器名称：启动容器<br />    docker stop 容器名称：停止容器<br />    docker rm 容器名称：删除容器<br />    docker restart 容器名称：重启容器<br />    docker ps -a：查看所有容器<br />    docker ps ：查看运行中的容器<br />    docker run：运行容器，如果容器不存在就创建，如果镜像不存在就下载<br />    docker logs 容器名称：查看容器的运行日志<br />    docker exec -it 容器名称 bash：进入到容器内部<br />    docker inspect 容器名称：查看容器的详细信息<br />    <br />

4.Docker配置环境
1.安装Tomcat
1.创建映射文件夹
发布项目，就发布到本文件夹下面
mkdir -p /docker/tomcat/webapp8081
2.创建容器并启动
docker run -d —name tomcat8081 -p 8081:8080 -v /docker/tomcat/webapp8081:/usr/local/tomcat/webapps/ tomcat:9.0.33
解释参数：
-d:后台运行，不会占用主窗口
—name:为容器起个名，名称唯一
-p:设置内外端口号，外部端口:软件本身的端口
-v:设置磁盘映射，外部真实存在的路径:虚拟机内部路径（路径不能随便写）
3.访问测试
http://49.235.88.52:8081/
2.Docker搭建Mysql
1.执行如下命令
docker run -d —name mysql3307 -e MYSQL_ROOT_PASSWORD=zzjava -p 3307:3306 mysql:5.7
参数说明：
-d:后台运行，不会占用主窗口
—name:为容器起个名，名称唯一
-p:设置内外端口号，外部端口:软件本身的端口
-e：设置额外的参数，主要设置root的密码
2.连接测试
主机：49.235.88.52
端口号：3307
账号：root
密码：zzjava
3.Docker搭建Redis
1.创建文件夹，执行如下命令：
mkdir -p /docker/redis/redis6380
2.上传Redis的配置文件
修改：
1.取消本机访问
2.设置访问密码
上传到/docker/redis/redis6380
3.执行如下命令，创建Redis容器并启动
docker run -d —name redis6380 -p 6380:6379 -v /docker/redis/redis6380/redis.conf:/etc/redis/redis.conf redis:6.2.1 redis-server /etc/redis/redis.conf
4.访问测试
主机：49.235.88.52
端口号：6380
密码：zzjava

给你一台服务器，你可以把项目部署成功！

明天任务：
1.团队项目收尾
1.源码完成编写
2.文档收集（思维导图、数据库设计文档、日报完整性）
3.汇报PPT(1.我的团队 2.我的项目 3.核心亮点 4.项目收获 5.展望未来)
4.上线地址（二维码）
5.Leader为组员评分（满分10分）
周六任务：
1.复盘-最近学的知识点
做成思维导图
根据真实的情况，打个评级
A-知识点可以在项目中应用
B-Demo会写，项目中只能CV
C-大概知道，会写Demo
D-听过，代码不会
下周讲解：
SpringBoot
Mybatis-Plus
Swagger
Lombok
Redis
Jedis
写写前后端项目的后端接口

下下周：
Vue全家桶（Vue.js Vuex Vue-cli Vue-router Axios 地图）
正式开工前后端分离项目（APP开发-偏向于互联网项目）