rails笔记

http://nottiansyf.iteye.com/blog/567710

绕了不少弯路,感觉这本书上说的还是比较简单 

rails是作为ruby的gem进行安装的,需要注意安装相关的依赖包
对于ODBC的连接SQL数据库,需要进行不少的设置,包括控制面板内的管理工具,设置本地的dsn设置

创建rails应用后,可以通过rake db:migrate检查是否配置完成,也可以使用idea来执行判断
数据库database.yml配置如下
development:
  adapter: sqlserver
  mode: odbc
  dsn: CHENHENG
  username :  sa
  password :  123
其他大体如上

controllers 目录下可以创建对应的c部分,里面创建的文件命名格式为
admin_controller.rb
访问时URL主体部分为admin/action,
其中action为方法名,可以通过直接定义def action来访问自定义的方法
方法执行完,会自动跳转views/admin/目录下的对应action.html.erb类似规则的文件

使用rails建立model时,会自动在db/migrate目录下创建rb文件,可以创建数据库所需的表信息

动态网页内容.两种方式
一:erb,
 使用<%=...%>执行ruby,输出变量,与Jsp标签类似
 使用<%%>执行ruby语句,循环等,注意end的使用 注意其中<% ...-%>格式的使用,似乎用于去除
 所产生的空格

 如果需要在<%=%>中输出带特殊字符的ruby代码,可以使用
 <%= h("Ann & Bill " ) %>中的h()

获取action中定义的局部变量的方式@var...
在action中定义的@var变量,可以直接在erb文件中使用<%= @var %>读取

创建超链接的方式, //指向其他的URL,将会忽视对相对和绝对路径的URL处理

修改rails数据库环境的方式,切换development等..
rake db:create RAILS_ENV='development'

在使用Idea开发时,需要注意使用scaffold生成脚手架时,参数格式如下
product title:string desc:text
product为model的名称,即数据库中表的名称映射,一般会被映射成复数s的形式
title为列名,string为orm的类型
完整的指令应该为generate scaffold -f product title:string desc:text image_url:string

在开发时,注意不要存在多个不同版本的gem,idea会默认使用最高版本的gem,忽视原有的配置,
可以使用gem uninstall 进行卸载,包括所依赖的相关版本

为已存在的model添加属性,主要目的是为数据库添加列,并且增加所需的记录
generate migration -f add_price_to_product price:decimal
将会生成新的migrate文件,用于记录新增的记录,同时也提供了还原的方式
然后运行rake db:migrate 执行语句即可,如果要在对应的html中进行显示,可以使用
generate scaffold -f product title:string desc:text image_url:string
再次执行生成

添加验证,
在model中添加验证的方式
validates_presence_of :title, :description, :image_url  //验证指定的字段非空
validates_numericality_of :price  //验证字段必须为数字

添加自定义验证的方式
validate :price_must_be_at_least_a_cent
protected
    def price_must_be_at_least_a_cent
        errors.add(:price, 'should be at least 0.01' ) if price.nil? ||price < 0.01 //这里主要是errors的使用
   end

通过正则进行定义验证的方式
validates_format_of :image_url,
:with => %r{\.(gif|jpg|png)$}i,
:message => 'must be a URL for GIF, JPG or PNG image.'

通过数据库进行验证
validates_uniqueness_of :title

可以通过建立controller时,可以使用带参数,同时创建action,并且会自动生成对应的erb页面

<%=h ... %> 用于转换内容中的HTML代码
格式化价格
<%= sprintf("$%0.02f" , product.price) %>

货币格式转换的方式
<%= number_to_currency(product.price) %>

rails提供了两种用于超链接的标签
button_to  用于生成一个form,并且使用post的提交方法
link_to  用于生成一个简单的a href,使用get方式

创建基于rails本身的session解决数据存储方案
rake db:sessions:create  //保存在数据库中
然后执行rake db:migrate ,创建所需的表
在rails2.3中,需要在config/initializers/session_store.rb中配置
Action_controller.session_store = :active_record_store

存储在数据库中,主要用于提供了一种跨多机器的存储环境
建立专属的controller
application_controller.rb  //注意是必须的重写,内容可以参考框架下的实现,可以直接拷贝

从http请求中获取参数
params[:key]

Flash域,用于保存临时显示的数据,原理与struts2类似,同样保存在session中,自动删除
常用于保存错误信息

记录错误信息与flash的使用
logger.error("Attempt to access invalid product #{params[:id]}" )
flash[:notice] = "Invalid product"
redirect_to :action => 'index" //URL跳转,重定向,可以通过重构抽取相同的内容到方法中

读取flash的时候,加入if判断是否存在会更好一些
<% if flash[:notice] -%>
"notice"><%= flash[:notice] %>

  

<% end -%>  

  

判断指定域中对象是否为空的方式  

if session[:counter].nil? ,也可以采取||=进行缩写  

  

在页面中使用标签导入其他erb内容,类似jsp的include  

<%= render(:partial => "cart_item" , :collection => @cart.items) %>  

同时在目标中,可以直接包含循环体内容,而不需要重新循环读取  

直接集合了c:foreach和include  

其中partial为var ,collection为items. 不过功能应该更丰富一些  

其中特殊的一点是,只要将需要嵌入的文件命名为_cart_item.html.erb即可自动寻找到,与partial属性相关  

  

:object => @cart 用于传入一个对象  

  

生成一个Ajax请求的标签  

<% form_remote_tag :url => { :action => 'add_to_cart', :id => product } do %>  

    <%= submit_tag "Add to Cart" %>  

<% end %>  

  

rjs文件,用于生成所需的js模板文件,使用上与erb类似  

在layout文件中,加入以下标签,用于导入默认所需的js文件  

<%= javascript_include_tag :defaults %>  

  

在rjs模板中同样适用标签进行声明  

page.replace_html("cart" , :partial => "cart" , :object => @cart)  

表示替换调用页面中id=cart元素中的html内容  

  

使用内置的effects.js 特效 其中:current_item 为html中元素的id  

page[:current_item].visual_effect :highlight,  

                                  :startcolor => "#88ff88",  

                                  :endcolor => "#114411"  

上述代码同样定义在rjs文件中  

  

helpers/ 目录中保存了与controller同名的module文件,用于为对应的controller提供更多功能  

将会被自动include,不需要手动编写  

  

在进行渲染时,可以通过判断选择不同的方式  

respond_to do |format|  

    format.js if request.xhr?  

    format.html {redirect_to_index}  

end  

  

在rails建立一对多的主外键关联  

在module中添加   

一方:has_many :line_items 后者为其他model  

多方:belongs_to :order 后者同上  

  

application_controller 作用类似web.xml,用于用代码代替配置工程中的属性  

before_filter :authorize, :except => :login 配置过滤器  

其中的anthorize  

protected  

    def authorize  

        unless User.find_by_id(session[:user_id])  

        flash[:notice] = "Please log in"  

        redirect_to :controller => 'admin' , :action => 'login'  

    end  

end  

  

:except 用于设置例外的界面或请求  

  

创建基于xml的渲染器,类似erb,rjs  

respond_to do |format|  

    format.html  //会根据http header中Accept:内容的不同,自动选择不同的请求render  

    format.xml { render :layout => false }  //false用于关闭使用layout模板  

end  

扩展名如下,使用时候比较特殊一些  

who_bought.xml.builder  

xml.order_list(:for_product => @product.title) do  

    for o in @orders  

            xml.order do  

            xml.name(o.name)  

            xml.email(o.email)  

            end  

    end  

end  

  

其他情况下,根据路由routes.rb的配置,可以直接使用扩展名,返回不同的渲染  

map.connect ':controller/:action/:id.:format   

  

使用内置自动生成xml文件  

format.xml { render :layout => false ,:xml => @product.to_xml(:include => :orders) }  

调用model的to_xml方法  

  

生成指定格式的feed xml格式文件  

format.atom { render :layout => false }  

生成JSON 的格式,针对http header请求  

format.json { render :layout => false ,:json => @product.to_json(:include => :orders) }  

  

生成文档  

rake doc:app  

  

i18n/test跳过,不研究  

  

rails项目的目录结构  

  

doc/ 用于存放项目的说明文档  

lib/ 可以用于放置一些rb类,可以被controller,view,model中引入,注意需要加上目录  

lib/tasks, 用用于放置自定义的take任务  

log/用于放置日志信息  

public/放置一些静态文件,css,js等,以及404等错误html页面  

script/开发用的脚本  

vendor/存放第三方插件,代码,用于采用非全局的gem等,  

    使用项目gem rake rails:freeze:gems  

    使用系统gem rake rails:unfreeze  

    其他rake rails:freeze:edge   

config / 目录 , 用于存放一些配置文件,数据库,环境等  

    ruby script/server -e development //切换运行环境,参数还包括test,production  

    config/database.yml 数据库连接的配置  

      

Active Support  

主要为model中的类,rails为其扩展了许多方便的方法  

  

对于集合的操作,继承了Enumerable中的方法  

groups = posts.group_by {|post| post.author_id}   

state_lookup = us_states.index_by {|state| state.short_name}  

total_orders = Order.find(:all).sum {|order| order.value }  

rails也对Array进行了扩展  

puts [ "ant" , "bat" , "cat" ].to_sentence #=> "ant, bat, and cat"  

  

对String的扩展也很多...除了字符的截取,还提供了一些英文 单数,复数的转换,大小写格式化  

扩展自己的语法转换规则  

ActiveSupport::Inflector.inflections do |inflect|  

    inflect.irregular "goose" , "geese"  

end  

  

对数字同样也提供了扩展  

提供了字节,时间的便捷操作  

  

时间和日期的扩展  

date = Date.today  

puts date.tomorrow  

以及更多的日期格式化获取  

  

对Ruby语法的扩展,如方法调用  

groups = posts.group_by {|post| post.author_id}  

转化成  

groups = posts.group_by(&:author_id) , 节约了临时对象的编写  

  

Migrations  

Rails中使用对Migration的维护,来对数据库进行DDL操作,同时对每次的处理,都使用单独的文件进行  

保存,便于版本的控制,其中也会将当前项目的db信息保存在表schema_migrations table中  

  

最常见的执行 rake db:migrate,将会比对当前数据库表中与文件的区别,进行执行  

  

对db版本的控制  

rake db:migrate VERSION=20080601000010  //将版本调整至指定版本,  

rake db:migrate:redo STEP=3 //效果一致  

  

常见的列类型,使用在Migration文件中的add_column:属性中  

:binary, :boolean, :date, :datetime, :decimal,:float, :integer, :string, :text, :time, and :timestamp.  

如:add_column :表名, :column名, :类型   

  

对列的属性设置  

:null => true or false //是否允许空  

:limit => size //列的长度  

:default => value //默认值  

decimal类型时候,:precision and :scale 用于设置精度  

  

重命名列  

rename_column :orders, :e_mail, :customer_email  

修改列属性  

change_column :orders, :order_type, :string  

  

重命名表,注意对原有的model代码也会修改  

rename_table :order_histories, :order_notes  

  

当添加一些不允许修改的表信息时,可以在self.down中抛出异常,防止错误的修改,导致数据丢失  

def self.down  

    raise ActiveRecord::IrreversibleMigration  

end  

  

对表的创建,注意block的使用  

def self.up  

create_table :order_histories do |t|  

        t.integer :order_id, :null => false  

        t.text :notes  

        t.timestamps  

    end  

end  

  

定义索引,这里并不很了解,建议需要时查看API  

add_index :orders, :name,:unique => true  

orders 为表名称  

:name => "somename" 用于指定类名,默认为  

unique表示不允许重复   

  

rails创建表时,会自动创建名称为id的主键,也可以自定义  

create_table :tickets, :primary_key => :number do |t|...end  

  

创建不包含主键的表  

create_table :authors_books, :id => false do |t|..end  

  

可以通过在migration中创建对数据库的增加数据操作,来为测试提供便利,不过感觉数据可能会因此被  

固化在migration中,违反了原来的初衷  

  

Loading Data from Fixtures   

可以通过定义一些保存数据的yml文件,专门保存数据的内容,然后使用migration进行加载  

def self.up  

    down   //调用当前的down操作,用于清除数据  

    directory = File.join(File.dirname(__FILE__), 'dev_data' ) //dev_data用于保存数据yml文件的目录  

    Fixtures.create_fixtures(directory, "users" )//加载该目录下的users.yml文件  

end  

def self.down  

    User.delete_all  

end  

  

注意需要引入所需的类  

require 'active_record/fixtures'  

yml中的格式如下  

mike:  

name: Mike Clark  

status: admin    

  

不过上诉方式,只建议用于加载在开发环境和生产环境下都需要使用的数据,如果要用于加载测试数据,可以用  

rake的任务实现  

  

一些时候,比如在修改列的类型,也可以通过在数据库中更新列值,来避免有可能出现的数据丢失  

Product.update_all("price = price * 100" )  

change_column :products, :price, :integer  

  

使用原生的sql语句  

create_table :line_items do |t|  

    t.integer :product_id, :null => false, :options =>  

    "CONSTRAINT fk_line_item_products REFERENCES products(id)"  

  

execute %{  

    CREATE TRIGGER #{constraint_name}_delete  

    BEFORE DELETE ON #{to_table}  

    FOR EACH ROW BEGIN  

        SELECT  

            RAISE(ABORT, "constraint violation: #{constraint_name}" )  

        WHERE  

            (SELECT id FROM #{from_table} WHERE #{from_column} = OLD.id) IS NOT NULL;  

    END;  

}  

      

对model类的控制  

class Sheep < ActiveRecord::Base  

    set_table_name "sheep" #手动设置表名  

end  

也可以使用self.table_name = "sheep"  

  

在model中也比较特别的一点,就是在model中并不能看到表中的属性,也就是看不到所对应的映射属性,当却可以被正常使用和显示,因为在创建migration时,rails将会自动保存这些信息,如果直接使用scaffold时,也可以自动创建所有的信息.所以并不会重复在model class中显示,包括id  

  

如果需要添加属性,可以通过新建migration来使用  

可以通过在命令台执行  

ruby script/console  

Order.column_names 来查看Order model内的列名  

  

对于Boolean值的使用.因为数据库本身的有些支持Boolean,有些则需要使用int或char代替  

建议使用user.superuser?进行判断,注意?的使用  

然后在model定义该方法,superuser,返回对内部字符的判断返回结果,而不直接依赖数据库中属性  

  

自定义主键列,默认会使用自增的Integer作为主键列,并且使用id进行索引  

class LegacyBook < ActiveRecord::Base  

    self.primary_key = "isbn"  

end  

在设置值时,需要使用.id进行设置值,当访问时,使用设置的列名进行访问,使用id来读,使用列名来取,并且保持唯一  

  

在model中类,因为都是继承ActiveRecord类中,所以也会默认使用你所配置的数据库连接  

也可以在model中进行覆盖  

establish_connection(  

:adapter => "mysql" ,  

:host => "dbserver.com" ,  

:database => "backend" ,  

:username => "chicho" ,  

:password => "piano" )  

  

CRUD操作  

使用model类的  

Model.new创建一个新的对象,设置属性后,调用save就可以保存  

也可以使用block的方式  

Order.new do |o|  

    o.name = "Dave Thomas"  

    # . . .  

    o.save  

end  

  

也可以通过hash的形式构建对象,在调用save更新到数据库  

an_order = Order.new(  

    :name => "Dave Thomas" ,  

    :email => "[e-mail]" ,  

    :address => "123 Main St" ,  

    :pay_type => "check" )  

an_order.save  

  

与Hibernate类似,save后,该对象也自动会有id出现  

  

从表单参数中直接创建对象  

order = Order.new(params[:order])  //form名字为order  

  

使用create保存对象,无须调用save方法  

an_order = Order.create(  

    :name => "Dave Thomas" ,  

    :email => "[e-mail]" ,  

    :address => "123 Main St" ,  

    :pay_type => "check" )  

其实这里的save方法可以理解成hibernate中的saveorupdate方法  

  

create方法可以从array中直接保存一组对象到数据库中  

orders = Order.create(  

    [ { :name => "Dave Thomas" ,  

    :email => "[e-mail]" ,  

    :address => "123 Main St" ,  

    :pay_type => "check"  

    },  

    { :name => "Andy Hunt" ,  

    :email => "[e-mail]" ,  

    :address => "456 Gentle Drive" ,  

    :pay_type => "po"  

    } ] )  

      

查找对象的方式  

Order.find(27) //使用id进行搜索  

product_list = params[:product_ids]  

Product.find(product_list).sum(&:price) 从一组id中获取对象,并计算其中的price属性  

Person.find(:first, :conditions=>"name=’Dave’") 带条件的find  

Give me the first person row that has the name Dave.”  

也可以使用:all代替first,表示搜索全部  

conditions中带上and ,可以附带更多的搜索条件,其实也就是在sql中带上where从句,注意引号的使用  

  

在参数中,使用#{}带上ruby变量  

:conditions => "name = '#{name}' and pay_type = 'po'"  

注意以上方法,有可能导致注入的发生  

  

使用?的形式,设置参数  

pos = Order.find(:all,:conditions => ["name = ? and pay_type = 'po'" , name])  

使用key的形式,设置参数  

pos = Order.find(:all,:conditions => ["name = :name and pay_type = :pay_type" ,{:pay_type => pay_type, :name => name}])  

  

注意这里的conditions的两种形式字符串与[]数组,其中数组形式的就省去and的使用.会自动进行组合  

  

使用like子句  

User.find(:all, :conditions => ["name like ?" , params[:name]+"%" ]).  

不能直接使用?+字符串的%拼接  

  

find()中的其他参数  

:order  sql中的order子句字符串  

:limit  在使用:all时,限制返回的数量  

:offset 用于分页时,可以限制返回的数据开始的位置:offset => page_num*page_size  

:joins sql中的join子句  

    :joins => "as li inner join products as pr on li.product_id = pr.id"  

注意:model提供了许多对外键操作的映射方式,所以并不需要经常自定义joins  

:select 返回需要的列,其实也就是sql中的select中的列  

    :select => "*, a.name" //用于多表join查询时  

:readonly 只读的查询方式  

:from 代替table表名的查询方式  

:group sql的分组子句 :group => "sku"  

:lock 设置锁,太麻烦,不研究  

  

使用自定义的sql语句  

orders = LineItem.find_by_sql("select line_items.* from line_items, orders where order_id = orders.id and orders.name = 'Dave Thomas' " )  

  

只要写出标准的格式,rails会自动完成映射,也可以理解成封装成hash的形式,访问时直接使用order.列名进行访问即可  

  

也可以扩展成带参数形式的sql  

Order.find_by_sql(["select * from orders where amount > ?" ,params[:amount]])  

  

还提供了对多种列的统计  

average = Order.average(:amount) # average amount of orders  

max = Order.maximum(:amount)  

min = Order.minimum(:amount)  

total = Order.sum(:amount)  

number = Order.count  

  

注意ruby中方法调用时,可以省略掉()  

result = Order.maximum :amount,  

                                            :group => "state" ,  

                                            :limit => 3,  

                                            :order => "max(amount) desc"  

  

count的扩展  

result1 = Order.count ["amount > ?" , minimum_purchase]  

Order.count :conditions => "amount > 10" ,:group => "state"  

也可以使用自定义的sql语句,注意方法的不同  

count = LineItem.count_by_sql("sql...")  

  

动态方法查询,rails提供了多种语义丰富的方法,便于理解和使用  

order = Order.find_by_name("Dave Thomas" )  

orders = Order.find_all_by_name("Dave Thomas" )  

orders = Order.find_all_by_email(params['email' ])  

  

使用!感叹号,用于在查找不到对象时,抛出异常,而不是返回nil  

order = Order.find_by_name!("Dave Thomas" )  

  

更丰富的动态方法  

user = User.find_by_name_and_password(name, pw)  #多列条件查询  

还有更多语义丰富的方法  

User.find_all_by_name  

Cart.find_or_initialize_by_user_id(user.id)  

  

可以通过在model内部添加name_scope,为model添加更多的动态方法  

named_scope :last_n_days, lambda { |days| :condition =>['updated < ?' , days] }  

调用:orders = Orders.last_n_days(7)  

  

重载加载数据库对象,用于读取出一个对象后,更新该对象为最新的数据库中的属性  

Object.reload  

  

更新数据  

save方法已经介绍,会自动判断新建还是更新  

update属性方法,使用hash的参数形式  

order.update_attributes(:name => "Barney",:email => "[e-mail]" )  

  

常用的还是update 和update_all方法  

order = Order.update(12, :name => "Barney" , :email => "[e-mail]" ) #,12为id  

result = Product.update_all("price = 1.1*price" , "title like '%Java%'" )  

  

save与create方法的!版本  

失败都会抛出异常,成功则返回true与完整的record对象  

  

删除数据  

Order.delete(123) #id  

User.delete([2,3,4,5]) #id  

Product.delete_all(["price > ?" , @expensive_price]) #条件  

order.destroy //单个对象,实例级别方法  

Order.destroy_all(["shipped_at < ?" , 30.days.ago]) //类级别方法  

  

将Ruby对象序列化到数据库中  

class Purchase < ActiveRecord::Base  

    serialize :last_five  #声明为存储序列化数据  

    # ...  

end  

写入  

purchase.last_five = [ 'shoes' , 'shirt' , 'socks' , 'ski mask' , 'shorts' ]  

purchase.save  

读取时,将会自动转换成ruby的数组对象,注:列的类型最好为text  

  

将一张表存放在不同的对象之中  

class Customer < ActiveRecord::Base  

    composed_of :name, :class_name => 'Name' , ...  

end  

其中name为单独的一个class,并不继承activerecord类  

注意其构造函数和内置属性,必须能否与表名内的列名对应  

def initialize(first, initials, last)  

    @first = first  

    @initials = initials  

    @last = last  

end  

  

也可以手动指定所需的列名与字段的映射  

composed_of :name,:class_name => "Name" ,  

                :mapping =>[ # database ruby  

                                    %w[ first_name first ], #列名,属性名  

                                    %w[ initials initials ],  

                                    %w[ last_name last ]  

                                    ]  

                                      

使用底层的sql连接,来执行sql,并且返回结果  

res = Order.connection.select_all("select id, quantity*unit_price as total  from line_items" )                    

将会返回hash形式的对象数组  

  

注意使用自定义的sql查询时,默认将不会返回id,有此可能造成id确实,update变成create  

  

注意一些rails在table中定义的保留字段的列  

created_at, created_on, updated_at, updated_on //记录相关日期  

lock_version //锁  

id //默认生成的主键  

xxx_id //外键中使用  

xxx_count //保存子表的字段数目  

position //acts_as_list使用时  

parent_id  //acts_as_tree使用时  

type //单表继承使用时  

  

rails也提供了一系列的方法,跟踪对象的变化情况..changed?,name_change等.  

  

类似hibernate,rails也提供了查询的缓存  

  

在rails中也可以通过在表中手动创建_id的外键列方式,来维护主外键关系,注意可以通过创建index,来提高join查询时的性能  

  

常见的关系配置  

One-to-One  

A:belongs_to :order  

B:has_one :invoice  

  

One-to-Many  

A:belongs_to :order     #一方  

B:has_many :line_items  #多方  

  

Many-to-Many  

A:has_and_belongs_to_many :products   

B:has_and_belongs_to_many :categories    

无须关心中间表的配置  

  

belongs_to,用于在多方设置,或者理解成外键一方  

Declaration in child            Foreign Key                     Parent Class                Parent Table  

belongs_to :product             product_id                  Product                     products  

belongs_to :invoice_item   invoice_item_id    InvoiceItem  invoice_items  

belongs_to :paid_order,  

    :class_name => "Order" ,  

    :foreign_key => "order_id" ,  

    :conditions => "paid_on is not null"  

  

has_one: 在一方设置,属于一对一关系  

Declaration               Foreign Key     Target Class Target Tabl  

has_one :invoice      order_id            Invoice         invoices  

可以使用 :dependent => :destroy 设置级联  

  

has_many:用于设置在一方,表示拥有多个元素  

Declaration                 Foreign Key Target Class Target Table  

has_many :line_items order_id   LineItem                line_items  

  

高级设置,可以配置sql查询的方式  

has_many :rails_line_items,  

    :class_name => "LineItem" ,  

    :finder_sql => "select l.* from line_items l, products p " +  

                " where l.product_id = p.id " +  

                " and p.title like '%rails%'"  

还可以设置  

:order => "quantity, unit_price DESC"  

多表查询时,可以使用:uniq => true属性,来防止出现重复的数据  

或者:select => "distinct users.*"  

  

对象生命周期  

Object Life Cycle  

  

Validation 验证  

在model进行save等操作时,都会自动执行验证  

也可以自定义进行设置,不同情况下验证的方法  

class User < ActiveRecord::Base  

    validate :valid_name?  

    validate_on_create :unique_name?  

      

private  

    def valid_name?  

        unless name && name =~ /^\w+$/  

        errors.add(:name, "is missing or invalid" )  

    end  

end  

进行验证的时候,注意判断的方法,可以用使用带?的方法,将返回true,而不会跑出异常或者nil  

  

内置的一些验证helper方法  

格式验证  

validates_format_of :name,  

                                :with => /^\w+$/,  

                                :message => "is missing or invalid  

唯一验证  

validates_uniqueness_of :name,  

                                :on => :create,   #表示开启时机  

                                :message => "is already being used" #错误信息  

验证被选择  

validates_acceptance_of :terms,  

                                :message => "Please accept the terms to proceed"  

对相关对象进行验证  

validates_associated :line_items,  

                                :message => "are messed up"  

                                validates_associated :user  

验证指定格式字段的值相同, //常用于密码验证  

validates_confirmation_of :password  

注意html的name属性  

<%= password_field "user" , "password" %>  

<%= password_field "user" , "password_confirmation" %>  

循环验证属性 使用block  

validates_each :name, :email do |model, attr, value|  

    if value =~ /groucho|harpo|chico/i  

        model.errors.add(attr, "You can't be serious, #{value}" )  

    end  

end  

对集合中内容进行过滤验证  

validates_exclusion_of :genre,  

                :in => %w{ polka twostep foxtrot },  

                :message => "no wild music allowed"  

格式验证,也是使用正则  

validates_format_of :length, :with => /^\d+(in|cm)/  

验证集合必须包含内容  

validates_inclusion_of :gender,  

                        :in => %w{ male female },  

                        :message => "should be 'male' or 'female'"  

验证长度  

validates_length_of :name, :maximum => 50  

validates_length_of :password, :in => 6..20  

验证数据格式  

validates_numericality_of :age, :only_integer => true  

validates_numericality_of :height_in_meters  

非空的属性验证  

validates_presence_of :name, :address  

验证大小,与length长度使用一致  

validates_size_of  

验证值的唯一  

validates_uniqueness_of :name, :scope => "group_id"  //可以设置验证的域  

  

Callbacks 回调函数,也可以理解成监听ActiveRecord操作后,自动执行的方法  

使用的方式,只要在class中重载这些方法即可, 如:  

def before_save  

    self.payment_due ||= Time.now + 30.days  

end  

  

也可以使用类似validate的方式,使用自定义的函数  

before_validation :normalize_credit_card_number  

protected   //注意域  

def normalize_credit_card_number  

    self.cc_number.gsub!(/[-\s]/, '' )  

end  

  

也可以使用  

after_create do |order|  

    logger.info "Order #{order.id} created"  

end  

  

Observers的使用  

ActiveRecord::Observer  

可以用于监视指定的model类,而无须写入在model中,也提供了复用  

根据约定大于配置  

OrderObserver将会自动作用于名称为Order的类  

如果需要手动控制同时控制多个类,可以使用以下方法  

observe Order, Payment, Refund  

  

默认情况下 observer类也放置在model目录下  

  

默认情况下,Active record对象执行查询时,会用hash的方式从数据库中得到对象,再封装到column对象中,如果要自己定义查询时,如.find_by_sql,那么返回的将会是以数组形式保存的hash对象,访问的时候,默认hash的key与sql中的列名相关,也可以使用as语句来进行简化  

  

缓存对象,具体用途不知  

def length  

    # ...  

end  

memoize :length  

  

Transactions 事务  

事务的使用 ,手动调用方式  

Account.transaction do  

    account1.deposit(100)  

    account2.withdraw(100)  

end  

乐观锁 省略....  

  

Action Controller: Routing and URLs  

  

默认的路由设置 Routing Requests  

config/routes.rb 文件中 ,如果符合路由设置,将会默认将参数对应的保存在@params变量中,使用hash方式  

  

自定义路由规则时,可以使用script/console 进行测试  

depot> ruby script/console  

>> rs = ActionController::Routing::Routes  

>> rs.recognize_path "/store"  

将会打印出匹配的route规则  

  

如果更新文件后,需要使用下面命令进行加载  

>> load "config/routes.rb"    

  

map.connect用于设置单条规则,使用方法参数的方式设置参数  

在route中,设置了一些默认值,用于对不完整URL的补充  

defaults => { :action => "index" , :id => nil }  

  

必须匹配规则  

:requirements => { :name =>/regexp/, ...}  

条件  

:conditions => { :name =>/regexp/orstring, ...}  

  

例子  

map.connect 'store/checkout' ,  

    :conditions => { :method => :get },  

    :controller => "store" ,  

    :action => "display_checkout_form"  

也可以进一步对匹配的内容,进行再验证  

map.connect "blog/:year/:month/:day" ,  

        :controller => "blog" ,  

        :action => "show_date" ,  

        :requirements => { :year => /(19|20)\d\d/,  

        :month => /[01]?\d/,  

        :day => /[0-3]?\d/},  

        :day => nil,  

        :month => nil  

  

生成符合指定route规则的url  

@link = url_for(:controller => "store" , :action => "display" , :id => 123)  

  

其他的依据路由设置,来便捷实用url的方式  

redirect_to(:action => 'delete' , :id => user.id)  

  

可以方便的为model类添加route的rest效果  

map.resources :articles   # articles为model类名  

  

Rails中controller的方法定义  

  

index   返回model的集合,包含多个对象  

create  创建一个model对象,保存到数据库中   POST  

new     创建一个新资源,当并不保存到数据库中,返回给客户端进行填充  

show   根据唯一的条件,返回符合该条件的唯一对象model  

update根据id更新自定内容  _POST  

edit     返回根据ID提取出来的内容,填充到界面的编辑表单中  

destory 根据id,销毁对象  

  

上诉的操作,都能包含了简单的CRUD操作  

  

route中限制controller中action的方式  

map.resources :comments, :except => [:update, :destroy]  

  

这里还是回顾一下.使用内置的scaffold生成包括model在内的rest服务  

ruby script/generate scaffold article title:string summary:text content:text  

  

controller中创建的环境变量  

action_name 当前所处的action名称  

cookies cookie中的内容,可以进行读写  

headers 一组用hash保存的http请求中的头信息,只用于返回使用,不用来编写cookie  

params  保存提交上来的参数,form and url  

request 获取请求的信息,包括http方法等  

    可以用于访问 protocol://host:port/path?query_string. 对应的所有属性  

    也可以只用其中的属性,获取客户端信息 request.env['HTTP_ACCEPT_LANGUAGE' ]  

    包括大量属性的使用,建议有需要的时候直接查看API  

response ,保存http请求返回内容  

session, 会话  

  

填充模板的方法  

render() 方法,用于执行填充操作,如果不附带参数,将会自动填充对应的action的模板界面  

render(:text =>string) ,使用text为key,添加指定的内容要模板中  

render(:inline =>string, [ :type =>"erb"|"builder"|"rjs" ], [ :locals =>hash] )  

    添加更详细的参数,可以选择要填充的模板类型  

render(:action =>action_name) 调用其他的action模板,注意不会调用其他的action方法  

render(:file =>path, [ :use_full_path =>true|false], [:locals =>hash]) 填充指定的模板  

render(:template =>name, [:locals =>hash] ) 转发向指定的action,跨controller  

render(:partial =>name, ...) 填充部分模板  

render(:nothing => true) 返回空内容给浏览者  

render(:xml =>stuff )  填充指定的内容为xml,同样会设置Application/xml  

render(:json =>stuff, [callback =>hash] ) ,返回内容给json,当后面函数未知  

render(:update) do |page| ... end 使用block的方式填充一个类似rjs的模板  

render还附带了一些通用的参数 :status, :layout, and :content_type  

    :status,用于返回http状态码,正常的为200,不建议返回30x  

    :layout 布尔值,用于设置是否使用模板,似乎还能用于选择其他布局文件  

    :content_type 设置Content-Type HTTP header  

  

返回其他内容,或者字符的方式  

send_data  

    send_data(data, options...)  

    如:send_data(png_data, :type => "image/png" , :disposition => "inline" )  

  

send_file  

    send_file(path, options...) 将指定的文件发送给客户端  

    send_file("/files/secret_list" )  

  

Redirects 重定向, 常见的http status code 为301, or  307  

redirect_to(:action => 'display'), 如果要传递变量,可以使用flash域进行保存与读取  

  

redirect_to("/help/order_entry.html") 跳转指定的url  

redirect_to(:action => ..., options...) 跳转指定的action  

返回上一页的请求 ----HTTP_REFERER中获取信息  

redirect_to(:back)  

  

修改头信息,并重定向  

headers["Status" ] = "301 Moved Permanently"  

redirect_to("http://my.new.home" )  

  

Cookies and Sessions  

  

操作cookie的例子  

cookies[:marsupial] = { :value => "wombat" ,:expires => 30.days.from_now,:path => "/store" }  

  

可以在controller中,对session进行设置  

session :off, :only => %w{ fetch_rss fetch_atom }  

  

rails中有多种对session的存储机制  

session_store = :cookie_store 默认的存储机制,在2.0后使用特别的格式进行存储,可以保存任何对象,限制为4k的存储上限  

  

session_store = :p_store  

存储在一个flat文件中,使用PStore format格式,可以在environment.rb文件中进行设置文件保存目录  

config.action_controller.session_store = CGI::Session::PStore  

config.action_controller.session_options[:tmpdir] = "/Users/dave/tmp"  

config.action_controller.session_options[:prefix] = "myapp_session_"  

  

session_store = :active_record_store   

存储在数据库中  

rake db:sessions:create //在数据库中创建所需的表  

  

session_store = :drb_store  

使用Ruby的DRb协议,允许在ruby进程之间共享对象,存储在drb服务中,独立web服务  

  

session_store = :mem_cache_store  

存储在memcached中  

  

session_store = :memory_store  

存储在内存中,对于ruby并不是一个好的处理方法  

  

session_store = :file_store   

存储在文件中,但只能保存字符串  

  

可以在controller或者action中 开关session的使用  

session :off  

也可以附带更多参数  

session :off, :only => [ :show, :list ]  

session :off, :if => proc { Time.now.wday == 0 }  

  

Flash: Communicating Between Actions   

flash,用于在action之间传递参数,是指在重定向操作时,可以将对象保存在flash中进行传递  

flash.keep() 可以将flash内的值持久保存在session中,可以带参数保存指定的key对象  

  

Filters and Verification 过滤与验证  

rails支持三种类型的过滤器before, after, and around,都是使用def的方法,经过配置规则进行调用  

  

Before and After Filters 使用  

before_filter :authorize, :except => :login  

protected  

def authorize  

    unless User.find_by_id(session[:user_id])  

        flash[:notice] = "Please log in"  

        redirect_to :controller => 'admin' , :action => 'login'  

    end  

end  

  

也可以通过block与class的形式,设置filter  

before_filter do |controller|  

    logger.info("Processing #{controller.action_name}" )  

end  

  

after_filter AuditFilter  

class AuditFilter  

    def self.filter(controller)  

        AuditLog.create(:action => controller.action_name)  

    end  

end  

  

after filter常用于修改返回的内容,比如压缩返回的字符,修改头信息  

  

Around Filters  

around_filter :time_an_action  

def time_an_action  

    started = Time.now  

        yield  //用于执行代码块  

    elapsed = Time.now - started  

    logger.info("#{action_name} took #{elapsed} seconds" )  

end  

  

同样也可以使用class和block的形式进行设置  

这里使用class实例的设置方式  

class TimingFilter  

    def filter(controller)  

        started = Time.now  

        yield  

        elapsed = Time.now - started   

        controller.logger.info("#{controller.action_name} took #{elapsed} seconds" )  

    end  

end  

around_filter TimingFilter.new  //注意这里使用的是实例  

  

当同时使用两个around_filter时, 执行的顺序为 1 2 .. 2 1  

  

filter可以被子类继承,也可以被重写覆盖  

  

Verification验证  

区别于对于字段属性的验证, 是用于权限验证的机制  

verify :only => :post_comment,  #action 名称  

                        :session => :user_id, #session中的key  

                        :add_flash => { :note => "You must log in to comment" }, #错误信息,添加到flash中  

                        :redirect_to => :index #重定向的action 名称  

  

过滤设置  

:only =>:name or [ :name, ... ]  

    Verifies only the listed action or actions.  

:except =>:name or [ :name, ... ]  

    Verifies all actions except those listed.                     

  

可以进行判断的内容  

:flash =>:key or [ :key, ... ]  

:method =>:symbol or [ :symbol, ... ]  #http 请求方法  

:params =>:key or [ :key, ... ] #请求的参数  

:session =>:key or [ :key, ... ]  

:xhr => true or false  #是否为ajax请求  

  

Actions 添加值进行传递  

:add_flash =>hash  

:add_headers =>hash  #均为:key=>value  

:redirect_to =>params #使用指定的hash进行重定向  

:render =>params #使用指定参数进行渲染设置  

  

Caching  缓存  

rails提供了三种缓存 page caching , action caching ,fragment caching,  

  

设置的方式也很简单,只要添加action即可  

caches_page :public_content   

caches_action :premium_content  

  

默认情况下,只有在production环境下才开启缓存,可以通过设置调整  

ActionController::Base.perform_caching = true | false  

config.action_controller.perform_caching = true  

  

对于page的缓存,使用基于url的机制控制页面缓存  

清理缓存的方式  

expire_page :action => "public_content"  

expire_action :action => "premium_content" , :id => article  

  

配置缓存策略  

多服务器情况下,使用一台专门的服务器放置缓存文件,通过局域网进行读取  

ActionController::Base.cache_store = :file_store, "#{RAILS_ROOT}/cache"  

  

sweeper 用于专门清理缓存内容的类  

app/sweepers:  

导入使用:  

cache_sweeper :article_sweeper,  

                            :only => [ :create_article,  

                            :update_article,  

                            :delete_article ]  

  

设置客户端缓存  

在controller中可以设置Expires header  

expires_in 20.minutes  

expires_in 1.year  

  

相应的再Apache中,也需要通过配置对于的扩展名添加缓存的http header  

ExpiresActive On  

"\.(ico|gif|jpe?g|png|js|css)$">  

ExpiresDefault "access plus 1 year"  

  

  

LastModified and ETag Support  

304 Not Modified  

不过似乎用于只读的使用,没有太大意义,忽略之  

  

使用get获取数据,使用post提交数据,注意方法的使用  

  

Action View  

填充的方式  

render(:action => 'fake_action_name' )  

render(:template => 'controller/name' )  

render(:file => 'dir/template' )  

  

rails支持三种模板  

builder 用于构建xml的返回内容  

erb 用于生成html内容  

rjs 用于生成JavaScript内容  

  

environment.rb中配置如下,用于修改erb界面中,设置标签的类型 默认为>  

<% 3.times do %>  

Ho!
  

<% end %>  

  

config.action_view.erb_trim_mode = "%"   

  

% 5.downto(1) do |i|  

<%= i %>... 
  

% end  

  

对encode后的参数读取  

<%=h params[:name] %>  #h的使用  

  

Helpers 的使用,针对controller,可以将部分方法抽取到对于的helper后,直接在页面上使用,减少标签的代码  

  

module StoreHelper  

    def page_title  

        @page_title || "Pragmatic Store"  

    end  

end  

  

<%= page_title %>

  

  

rails也提供了大量内置的helper,主要为格式化字符串提供了便利  

如:  

<%= number_to_percentage(66.66666, :precision => 1) %>  

66.7%  

  

在开发环境下 也可以使用debug获取参数的信息  

<%= debug(params) %>  

  

Linking to Other Pages and Resources 连接其他资源,提供了一些便利的方法  

<%= link_to "Add Comment" , :action => "add_comment" %>  

  

<%= link_to "Delete" , { :action => "delete" , :id => @product},  

                                        { :class => "dangerous" ,  

                                        :confirm => "Are you sure?" ,  

                                        :method => :delete}  

%>  

提供了很详细的设置  

  

绝对路径的连接  

<%= link_to("Help" , "http://my.site/help/index.html" ) %>  

  

还包括了对mail,css等文件的链接生成方式  

  

可以通过安装'will_paginate的gem,为rails添加分页功能  

  

表单的使用 ,(多种)  

form_for  

<% form_for :product, :url => { :action => :create } do |form| %>  

    

Title: <%= form.text_field :title, :size => 30 %>

  

    

Description: <%= form.text_area :description, :rows => 3 %>

  

    

Image URL: <%= form.text_field :image_url %>

  

    

Price: <%= form.text_field :price, :size => 10 %>

  

    <%= form.select :title, %w{ one two three } %>  

    

<%= submit_tag %>

  

<% end %>  

  

<% form_for :product,  

                    :url => { :action => :create, :id => @product },  

                    :html => { :class => "my_form" , :method => :put } do |form| %>  

  

表单字段  

Text  

form.text_field(:attribute, options)  

form.hidden_field(:attribute, options)  

form.password_field(:attribute, options)  

  

Text Areas  

form.text_area(:attribute, options)  

  

Radio Buttons  

form.radio_button(:attribute, tag_value, options)  

  

Checkboxes  

form.check_box(:attribute, options, on_value, off_value)  

  

Selection Lists  

form.select(:attribute, choices, options, html_options)  

如:  

    <% form_for :user do |form| %>  

        <%= form.select(:name, %w{ Andy Bert Chas Dave Eric Fred }) %>  

    <% end %>  

也提供了内置对时间等组件  

  

Multiple Models in a Form  

显示model的值  

<% form_for :user do |form| %>  

Name: <%= form.text_field :name %>  

  

通过建立model级别的表关系,可以直接在form中对多表进行直接的处理  

  

scaffold.css文件保存了许多样式设置,可以通过重写,或者自定义的覆盖,来达到自定义的效果  

  

rails 使用Layouts,最大程度的减少了常见的页面内容重复  

<%= yield :layout %> 用于在layout中加载内容  

  

默认会使用同名的layout,也可以在controller中进行自定义  

layout "standard"  

layout "standard" , :except => [ :rss, :atom ]  

通过方法,动态选择layout  

def determine_layout  

    if Store.is_closed?  

        "store_down"  

    else  

        "standard"  

    end  

end  

  

不适用layout的填充  

render(:partial => 'article' ,  

            :object => @an_article,  

            :locals => { :authorized_by => session[:user_name],  

            :from_ip => request.remote_ip })  

  

使用layout的填充  

<%= render :partial => "user" , :layout => "administrator" %>  

  

共享的填充模板  

<%= render("shared/header" , :title => @article.title) %>  

<%= render(:partial => "shared/post" , :object => @article) %>  

  

部分页面的缓存设置  

<% cache do %>   

    

  
•         <% for article in Article.find_recent -%>  
•             

• <%= h(article.body) %>

  
•         <% end -%>  
•     

  

<% end %>  

  

清理片段缓存的方式  

<% cache(:action => 'list', :part => 'articles') do %>  

    

  
•         <% for article in @articles -%>  
•             

• <%= h(article.body) %>

  
•         <% end -%>  
•     

  

<% end %>  

清理:expire_fragment(:action => 'list' , :part => 'articles' )  

  

缓存机制选项  

ActionController::Base.cache_store =   

:memory_store,  

:file_store, "/path/to/cache/directory"  

:drb_store, "druby://localhost:9192"  

:mem_cache_store, "localhost" ActionController::Base.cache_store =MyOwnStore.new("parameter")  

  

标签生成的form格式  

"text" name="user[password]" />  

  

ssl_requirement  gem用于提供ssl的https连接