啥也不是

最新推荐文章于 2024-01-26 09:16:34 发布

LZLLPLUS

最新推荐文章于 2024-01-26 09:16:34 发布

阅读量430

点赞数

本文链接：https://blog.csdn.net/weixin_39694434/article/details/104009471

版权

图片出自

在这里插入图片描述
mybatis是通过XML配置的方来定制化 SQL、存储过程以及高级映射等。所以首先他要解析相关mapper配置文件并将解析相互来的的结果放在Configuration类中。个人认为主要的一些放在如下(类名.方法)：
SqlSessionFactoryBuilder.build() 参数是配置文件(这个配置是mybatis的配置不是我们开发经常要写sql文件配置)的InputStream,功能是调用XMLConfigBuilder.parse()获取Configuration，然后创建DefaultSqlSessionFactory对象
XMLConfigBuilder.parse() 参数是配置文件(这个配置是mybatis的配置不是我们开发经常要写sql文件配置)的InputStream,功能是调用XPathParser.evalNode()获取XNode节点，然后调用XMLConfigBuilder.parseConfiguration解析节点。解析节点是通过不同的节点调用不同的方法解析并肩解析的结果保存到Configuration中。在解析中最主要还是解析我们的sql配置文件，它是在XMLConfigBuilder.mapperElement中解析
MLConfigBuilder.mapperElement() 参数是Xnode节点这里，功能主要是调用XMLMapperBuilder.parse方法这个方法才是重点解析每个我们开发经常要写的sql文件等。
XMLMapperBuilder.parse() 参数这个才是我们开发经常要写sql配置，功能主要是解析我们的sql文件，这里面又分为解析我们常常用到的、，，，，等标签，解析好后调用configuration.addMappedStatement方法将MappedStatement对象保存到mappedStatements这个map中，key就是namespace加标签的id。其实一般我们在使用SSM框架的时候也就是从这里开始的。mybaris-spring里面是从这里开始的。

在这里插入图片描述
SqlSession ：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能
Executor ： MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
StatementHandler ：封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合
ParameterHandler ：负责对用户传递的参数转换成JDBC Statement 所需要的参数
ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
TypeHandler 负责java数据类型和jdbc数据类型之间的映射和转换
MappedStatement MappedStatement维护了一条select
SqlSource 负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
BoundSql 表示动态生成的SQL语句以及相应的参数信息
MyBatis所有的配置信息都维持在Configuration对象之中

SqlSession	作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能
Executor	MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护

StatementHandler	封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合
–	–
ParameterHandler	责对用户传递的参数转换成JDBC Statement 所需要的参数
ResultSetHandler	负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
-MappedStatement -	-MappedStatement维护了一条select-
TypeHandler	负责java数据类型和jdbc数据类型之间的映射和转换
SqlSource	负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
-Configuration -	-MyBatis所有的配置信息都维持在Configuration对象之中-
BoundSql	表示动态生成的SQL语句以及相应的参数信息

			// 读取mybatis的核心配置文件mybatis-config.xml
			InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
			// 创建SqlSessionFactoryBuilder对象
			SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
			// 通过SqlSessionFactoryBuilder解析配置文件获取sqlSessionFactory对象
			SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
			// 通过SqlSessionFactory对象创建SqlSession对象
			sqlSession = sqlSessionFactory.openSession();
			// 利用selectOne()执行查询
			User user = sqlSession.selectOne("cn.com.pojo.User.selectUserById", 1);

RSA+AES混合加密

import javax.crypto.Cipher;
import java.io.IOException;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
 
public class RSAUtil {
 
    /**
     * 生成秘钥对
     * @return
     * @throws Exception
     */
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        return keyPair;
    }
 
    /**
     * 获取公钥(Base64编码)
     * @param keyPair
     * @return
     */
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return byte2Base64(bytes);
    }
 
    /**
     * 获取私钥(Base64编码)
     * @param keyPair
     * @return
     */
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return byte2Base64(bytes);
    }
 
    /**
     * 将Base64编码后的公钥转换成PublicKey对象
     * @param pubStr
     * @return
     * @throws Exception
     */
    public static PublicKey string2PublicKey(String pubStr) throws Exception{
        byte[] keyBytes = base642Byte(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
 
    /**
     * 将Base64编码后的私钥转换成PrivateKey对象
     * @param priStr
     * @return
     * @throws Exception
     */
    public static PrivateKey string2PrivateKey(String priStr) throws Exception{
        byte[] keyBytes = base642Byte(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }
 
    /**
     * 公钥加密
     * @param content
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
 
    /**
     * 私钥解密
     * @param content
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
 
    /**
     * 字节数组转Base64编码
     * @param bytes
     * @return
     */
    public static String byte2Base64(byte[] bytes){
        return Base64.getEncoder().encodeToString(bytes);
    }
 
    /**
     * Base64编码转字节数组
     * @param base64Key
     * @return
     * @throws IOException
     */
    public static byte[] base642Byte(String base64Key) {
        return Base64.getDecoder().decode(base64Key);
    }
}

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
 
public class AESUtil {
 
    /**
     * 生成AES秘钥，然后Base64编码
     * @return
     * @throws Exception
     */
    public static String genKeyAES() throws Exception{
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(128);
        SecretKey key = keyGen.generateKey();
        String base64Str = byte2Base64(key.getEncoded());
        return base64Str;
    }
 
    /**
     * 将Base64编码后的AES秘钥转换成SecretKey对象
     * @param base64Key
     * @return
     * @throws Exception
     */
    public static SecretKey loadKeyAES(String base64Key) throws Exception{
        SecretKeySpec key = new SecretKeySpec(base64Key.getBytes("utf-8"), "AES");
        return key;
    }
 
    /**
     * 字节数组转Base64编码
     * @param bytes
     * @return
     */
    public static String byte2Base64(byte[] bytes){
        return Base64.getEncoder().encodeToString(bytes);
    }
 
    /**
     * Base64编码转字节数组
     * @param base64Key
     * @return
     */
    public static byte[] base642Byte(String base64Key) {
        return Base64.getDecoder().decode(base64Key);
    }
 
    /**
     * 加密
     * @param source
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptAES(byte[] source, SecretKey key) throws Exception{
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(source);
    }
 
    /**
     * 解密
     * @param source
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptAES(byte[] source, SecretKey key) throws Exception{
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        return cipher.doFinal(source);
    }
 
}

public class TestAesAndRsa {
    //测试RSA与AES的结合。
    //					客户端用公钥加密AES秘钥，AES秘钥加密实际内容；
    //					服务端用私钥解密AES秘钥，AES秘钥解密实际内容
    public static void testAesAndRsa() throws Exception {
        //===============生成公钥和私钥，公钥传给客户端，私钥服务端保留==================
        //生成RSA公钥和私钥，并Base64编码，生成一次以后，就写死在配置文件或代码中，下次不再重新生成
        KeyPair keyPair = RSAUtil.getKeyPair();
        String publicKeyStr = RSAUtil.getPublicKey(keyPair);
        String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
        System.out.println("RSA公钥Base64编码:" + publicKeyStr);
        System.out.println("RSA私钥Base64编码:" + privateKeyStr);
 
        //=================客户端=================
        //hello, i am infi, good night!  需要加密的实际内容
        String message = "hello, i am infi, good night!";
        //将Base64编码后的公钥转换成PublicKey对象
        PublicKey publicKey = RSAUtil.string2PublicKey(publicKeyStr);
        //生成AES秘钥，并Base64编码
        String aesKeyStr = AESUtil.genKeyAES();
        System.out.println("AES秘钥Base64编码:" + aesKeyStr);
        //用公钥加密AES秘钥
        byte[] publicEncrypt = RSAUtil.publicEncrypt(aesKeyStr.getBytes(), publicKey);
        //公钥加密AES秘钥后的内容Base64编码
        String publicEncryptStr = RSAUtil.byte2Base64(publicEncrypt);
        System.out.println("公钥加密AES秘钥并Base64编码的结果：" + publicEncryptStr);
 
        //将Base64编码后的AES秘钥转换成SecretKey对象
        SecretKey aesKey = AESUtil.loadKeyAES(aesKeyStr);
        //用AES秘钥加密实际的内容
        byte[] encryptAES = AESUtil.encryptAES(message.getBytes(), aesKey);
        //AES秘钥加密后的内容Base64编码
        String encryptAESStr = AESUtil.byte2Base64(encryptAES);
        System.out.println("AES秘钥加密实际的内容并Base64编码的结果：" + encryptAESStr);
 
 
        //##############	网络上传输的内容有Base64编码后的公钥加密AES秘钥的结果 和 Base64编码后的AES秘钥加密实际内容的结果   #################
        //##############	即publicEncryptStr和encryptAESStr	###################
 
 
        //===================服务端================
        //将Base64编码后的私钥转换成PrivateKey对象
        PrivateKey privateKey = RSAUtil.string2PrivateKey(privateKeyStr);
        //公钥加密AES秘钥后的内容(Base64编码)，进行Base64解码
        byte[] publicEncrypt2 = RSAUtil.base642Byte(publicEncryptStr);
        //用私钥解密,得到aesKey
        byte[] aesKeyStrBytes = RSAUtil.privateDecrypt(publicEncrypt2, privateKey);
        //解密后的aesKey
        String aesKeyStr2 = new String(aesKeyStrBytes);
        System.out.println("解密后的aesKey(Base64编码): " + aesKeyStr2);
 
        //将Base64编码后的AES秘钥转换成SecretKey对象
        SecretKey aesKey2 = AESUtil.loadKeyAES(aesKeyStr2);
        //AES秘钥加密后的内容(Base64编码)，进行Base64解码
        byte[] encryptAES2 = AESUtil.base642Byte(encryptAESStr);
        //用AES秘钥解密实际的内容
        byte[] decryptAES = AESUtil.decryptAES(encryptAES2, aesKey2);
        //解密后的实际内容
        System.out.println("解密后的实际内容: " + new String(decryptAES));
    }
 
 
}