liy_j

关于 Ruby 文档中 JSON 模块中方法的疑惑

liy_j — Thu, 10 Dec 2015 09:03:44 +0800

在http://ruby-doc.org”中看 JSON 模块文档时，JSON 可以响应 Public Class Methods 方法和 Public Instance Methods 方法，按道理说只能响应 Public Class Methods 方法才对啊？难道是我看文档的姿势有误？?? 还望各位前辈答疑解惑。

比如说：module 中类方法只有 module 自己才可以调用，而在模块中定义的实例方法，在包含模块的类的实例对象才可以调用；module 是不能响应自己的实例方法的。

module My
  def self.my_class_method
   end
  def my_instance_method
  end
end
p My.respond_to?(:my_class_method) #true
p My.respond_to?(:my_instance_method) #false

如下图中红色圈为 Public Class Methods 方法，荧蓝色为 Public Instance Methods 方法，按说 module JSON 是不能响应 Public Instance Methods 方法的啊

Ruby 中通过 AES-128-CBC 加密后密码和 Java 中通过 AES/CBC/PKCS5Padding 加密的密码不一致?

liy_j — Fri, 29 May 2015 16:56:02 +0800

最近在调试一个加密和解密的接口，用 ruby 加密，然后用 java 解密，在用 java 解密时错误。然后调试中分别用 ruby 和 java 给数据加密，看是否一致，结果发现加密的结果也不一致，大神帮看看是什么原因

data = "45b00417-f7ca-4f53-bced-c1743d85604"

cipher = OpenSSL::Cipher::AES.new(128, :CBC)
cipher.encrypt
key = "quck7295abvdefgh"
iv = "abcdefgh3762quck"

encrypted = cipher.update(data) + cipher.final
Base64.encode64(encrypted)

使用相同的 key 来加密 ruby 加密后结果为：

双次加密后结果："EAhESILT2j/MSa1CykE7yqtX7N8XvPVzrzewJoELRuPj+rK8DeSuxROD/uOq\nLqhy\n"

java 加密后结果为：

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class CipherUtil {

    private final static byte[] KEY = "quck7295abvdefgh".getBytes();
    private final static byte[] IV = "abcdefgh3762quck".getBytes();

    public static byte[] encryption(byte[] data) throws Exception {
        return cipherIV(Cipher.ENCRYPT_MODE, data);
    }

    public static byte[] decryption(byte[] data) throws Exception {
        return cipherIV(Cipher.DECRYPT_MODE, data);
    }

    private static byte[] cipherIV(int mode, byte[] data) throws Exception {
        SecretKeySpec sekey = new SecretKeySpec(KEY, "AES");
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(mode, sekey, new IvParameterSpec(IV));
        byte[] decrypted = cipher.doFinal(data);
        return decrypted;
    }

    private static byte[] cipher(int mode, byte[] data) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(mode, new SecretKeySpec(KEY, "AES"));
        byte[] decrypted = cipher.doFinal(data);
        return decrypted;
    }

    public static void main(String[] args) throws Exception {
        String str = "45b00417-f7ca-4f53-bced-c1743d85604";
        byte[] b = encryption(str.getBytes());
        String str1 = new String(Base64.encodeToString(b));
        System.out.println(str);
        System.out.println(str1);
        System.out.println(new String(decryption(Base64.decode(str1))));
    }
}

双次加密后：2TStMVj6tPz8m4o0hjSY/GwTfx4UXFfDti9yhiJ6fr2tQFQsfNDG4Mqb3wpNy6x1

还有就是，ruby 加密后所谓的标准填充模式是什么啊？

vim 命令行中能否运行 rails 命令啊？

liy_j — Tue, 03 Feb 2015 15:19:18 +0800

最近在折腾 VIM，想把 vim 变成类似于 subline 这种 IDE 的形式。各位大神，能不能在打开的 rails 工程中的 vim 命令行中运行 rails 命令，来生成文件或控制器之类的，还是说必须打开另外一个终端来进行 rails 命令的输入。例如：$rails generate controller Users(图片中最后用红线圈起来的行)

正确理解类变量

liy_j — Wed, 07 Aug 2013 20:14:15 +0800

测试环境是 ruby1.8.7。ruby1.9，ruby2.0 版本不适用 各位看官，请看回复中的用于 ruby1.9 和 2.0 的帖子 NOTE:类变量并不真正属于类，它们属于类体系结构，可以被类或类的实例所使用。（类变量必须被初始化） 场景一：

#   代码a
@@v = 1                          
class MyClass                 
 @@v                             
end

代码 a 中，@@v = 1 定义于 main 对象的上下文，因此它属于 main 的类 Object，所以也属于 Object 的所有子类。类 MyClass 继承自 Object，因此也共享了这个类变量

#   代码b
@@v = 1                          
class MyClass                 
 @@v =2                            
end     
p @@v #=>2

代码 b 中，类 MyClass 修改了共享类变量@@v，因此 Object 中类变量值也被改变了。

#   代码c                    
class MyClass                 
 @@v                            
end      
@@v = 1

代码 c 中，执行这个文件时，会报没有初始化类变量@@v 的错误，也就是说，在类 MyClass 的祖先链中未发现已定义的@@v，因此在类 MyClass 中开始定义@@v，并且必须被初始化

#   代码d                      
class MyClass                 
 @@v =2                            
end      
@@v = 1    
Object.class_variable_get :@@v   #=>1

代码 d 是代码 c 的进化版本，由于在类 MyClass 的祖先链中未发现已定义的@@v，因此在类 MyClass 中定义的@@v = 2 属于该类及所有子类，且可以被该类的实例所使用。代码 d 中在类下方定义了@@v=1，这里的@@v=1 属于 Object 可以被其子类共享，与 MyClass 中@@v 是两个不同的类变量。Object 中类变量@@v=1 不能被 MyClass 及其子类所共享。从代码 d 中可以看到，MyClass 中@@v 的改变不会影响 Object 中类变量（因为 MyClass 中类变量不是共享于 Object 的类变量）。也可以通过 MyClass 的子类来验证

#   代码e 
@@v = 1                    
class MyClass                 
  @@v =2 
  def my_method
    p @@v
  end                           
end      
MyClass.new.my_method #=> 2  
p  @@v #=>2

代码 e 中，MyClass 中@@v 是共享于 Object 中类变量（@@v 定义于 Object）,因此 MyClass 中@@v 的改变会影响定义于 Object 中@@v 的值

#   代码f                    
class MyClass                 
  @@v =2 
  def my_method
    p @@v
  end                           
end  
@@v = 1    
MyClass.new.my_method #=> 2  
p  @@v #=>1

代码 f 中，MyClass 中@@v=2 与 Object 中@@v=1 是两个不同的类变量，不存在共享的关系，而是分别定义于不同的类中。因此@@v 的改变不会影响彼此

#   代码g                 
class MyClass                 
  def my_method
     p @@v
     @@v = 2 #修改共享类变量值
  end                           
end  
@@v = 1    
MyClass.new.my_method #=> 1  
p  @@v #=>2

代码 g 中，MyClass 的方法 my_method 中@@v 属于共享的类变量，共享于 Object 中的@@v，因此在 my_method 中修改@@v 的值会影响定义于 Object 中@@v 的值。（定义于方法中的代码，只有在方法调用时才执行）

场景二

#  f1.rb
module M1
  @@via = "M1"
  def self.m1
    p @@via
  end
end

#  f2.rb
module M2
  @@via = "M2"
  def self.m2
    p @@via
  end
end

#   图1-1
@@via = "object"
require "f1.rb"
require "f2.rb"
class MyClass
  include M1
  include M2
  def my_method
    p @@via
  end
end
MyClass.new.my_method #=> "M2"
p @@via #=>"object"
M1.m1 #=> "M1"
M2.m2 #=> "M2"

#   图1-2
@@via = "object"
require "f1.rb"
require "f2.rb"
class MyClass
  include M1
  include M2
  @@via = "myclass"
  def my_method
    p @@via
  end
end
MyClass.new.my_method #=> "myclass"
p @@via #=>"object"
M1.m1 #=> "M1"
M2.m2 #=> "myclass"

图 1-1 和图 1-2 中分别在 M1、M2 和 Object 中定义了@@via，这三个@@via 是三个不同的类变量。Object 中定义的@@via 可以被其子类 MyTest 共享；M1 中定义的@@via 可以被 include 的类共享；M2 中定义的@@via 也可以被 include 的类共享；那么类 MyTest 中共享的@@via 应该是哪个类或模块中定义的@@via？ 通过图 1-1 和图 1-2 的例子可以理解为： 类也是按照祖先链的方向来查找定义@@via 的类或模块，修改共享@@via 的值则会影响首次查找到的定义@@via 的类或模块中@@via 的值。若在类的祖先链上未查找到有定义@@via 的类或模块，则类中显示@@via 的地方所表示的意思为：在此处定义@@via 且必须初始化（非共享的类变量）