WPF+MVVM案例实战（二十三）- 阴影效果详解

文章目录

• • • 背景
    • 自动化检测前移：早发现，早解决
    • • 技术细节：静态代码分析与兼容性测试
      • 应用场景
    • 按需加载：优化性能，提升用户体验
    • • 技术细节：模块化与懒加载实现
      • 应用场景
    • 应用加密：保护应用代码安全，简化开发流程
    • • 技术细节：RSA与AES混合加密架构
      • 应用场景
    • 总结

背景

自动化检测前移：早发现，早解决

技术细节：静态代码分析与兼容性测试

应用场景

按需加载：优化性能，提升用户体验

技术细节：模块化与懒加载实现

// UserModule和OrderModule两个模块，封装用户与订单相关功能
public class UserModule {  
 // 用户相关功能  
 public void createUser(String name) {  
     System.out.println("User created: " + name);  
 }  

 public void getUserDetails(String userId) {  
     System.out.println("Fetching details for user: " + userId);  
 }  
}  

public class OrderModule {  
 // 订单相关功能  
 public void createOrder(String userId, double amount) {  
     System.out.println("Order created for user " + userId + " with amount " + amount);  
 }  

 public void getOrderHistory(String userId) {  
     System.out.println("Fetching order history for user: " + userId);  
 }  
}  

// LazyLoader类负责按需加载资源
public class LazyLoader {  
 private String resource;  
private boolean isLoaded = false;  
 private LazyLoader() {}  

private static class LazyHolder {  
     private static final LazyLoader INSTANCE = new LazyLoader();  
}  

public static LazyLoader getInstance() {  
  return LazyHolder.INSTANCE;  
}  

// 懒加载方法，资源未加载时才执行加载操作  
public String loadResource() {  
     if (!isLoaded) {  
         try {  
             Thread.sleep(2000); 
        } catch (InterruptedException e) {  
             e.printStackTrace();  
         }  
         resource = "Resource loaded!";  
        isLoaded = true;  
     }  
     return resource;  
 }  
}  

应用场景

// 按需加载支付模块
public class MainAbility extends Ability {  
 private boolean isPaymentModuleLoaded = false;  

@Override  
 public void onStart(Intent intent) {  
     super.onStart(intent);  

    Button payButton = (Button) findComponentById(ResourceTable.Id_pay_button);  
     payButton.setClickedListener(new Component.ClickedListener() {  
         @Override  
         public void onClick(Component component) {  
             if (!isPaymentModuleLoaded) {  
                 loadPaymentModule();  
                 isPaymentModuleLoaded = true;  
             } else {  
             }  
         }  
     });  
 }  

// 加载支付模块
 private void loadPaymentModule() {  
     Intent paymentIntent = new Intent();  
     paymentIntent.setElement(new ElementName("com.example.ecommerce", "com.example.ecommerce.PaymentAbility")); 
     startAbility(paymentIntent);  
 }  
}

应用加密：保护应用代码安全，简化开发流程

技术细节：RSA与AES混合加密架构

应用场景

// RSA与AES混合加密
public class EncryptionUtils {  

 // 生成AES密钥
 public static SecretKey generateAESKey() throws NoSuchAlgorithmException {  
     KeyGenerator keyGen = KeyGenerator.getInstance("AES"); 
     keyGen.init(256);   
     return keyGen.generateKey(); 
 }  

 // RSA公钥加密AES密钥
 public static String encryptAESKeyWithRSA(SecretKey aesKey, PublicKey rsaPublicKey) throws Exception {  
     Cipher rsaCipher = Cipher.getInstance("RSA");
     rsaCipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey); 
     byte[] encryptedAesKey = rsaCipher.doFinal(aesKey.getEncoded());
     return Base64.getEncoder().encodeToString(encryptedAesKey); 
 }  

 // AES密钥加密数据
 public static String encryptDataWithAES(String data, SecretKey aesKey) throws Exception {  
     Cipher aesCipher = Cipher.getInstance("AES"); 
     aesCipher.init(Cipher.ENCRYPT_MODE, aesKey); 
     byte[] encryptedData = aesCipher.doFinal(data.getBytes("UTF-8")); 
     return Base64.getEncoder().encodeToString(encryptedData); 
 }  

 // RSA私钥解密AES密钥
 public static SecretKey decryptAESKeyWithRSA(String encryptedAesKey, PrivateKey rsaPrivateKey) throws Exception {  
     Cipher rsaCipher = Cipher.getInstance("RSA");
     rsaCipher.init(Cipher.DECRYPT_MODE, rsaPrivateKey); 
     byte[] decodedAesKey = Base64.getDecoder().decode(encryptedAesKey);  
     byte[] decryptedAesKey = rsaCipher.doFinal(decodedAesKey); 
     return new SecretKeySpec(decryptedAesKey, 0, decryptedAesKey.length, "AES"); 
 }  

 // AES解密数据 
 public static String decryptDataWithAES(String encryptedData, SecretKey aesKey) throws Exception {  
     Cipher aesCipher = Cipher.getInstance("AES"); 
     aesCipher.init(Cipher.DECRYPT_MODE, aesKey); 
     byte[] decodedData = Base64.getDecoder().decode(encryptedData);
     byte[] decryptedData = aesCipher.doFinal(decodedData); 
     return new String(decryptedData, "UTF-8"); 
 }  
}

总结