（1）高利润型产品。这种产品本身的需求量一般不会太大，但不大不代表无需求，且在销售过程中，该类产品往往会成为旗舰店中最为盈利的大头，正如长尾理论中的百分之八十。

（2）低利润型产品。该类产品以销售量大见长。用户需求比较大。在有一次与淘宝工作人员的交流时，我们就谈到了产品的定价问题，尤其是涉及到了活动产品，据小二说，他们在审核活动产品时，首先就是压榨出定价中的水分，也就是说，首先考虑的就是是否低价，因为，对顾客而言，他们第一考虑的就是价格，其次才是产品本身的质量，因此，价格成为淘宝小二在审核活动商品是否过关并最终上活动的依据。而作为低利润型产品，通常会成为店铺流量在搜索中的主要来源。

记录下一个简单的scala sql DSL

一个日本人写的DSL 原网址:https://github.com/yuroyoro/Squire

总共两个类,基于twitter的querulous框架

package com.yuroyoro.squire
import java.sql.ResultSet
import scala.collection.mutable.ArrayBuffer
import com.twitter.querulous.evaluator.QueryEvaluator
trait SqlCommand {
val head:Option[SqlCommand]
val command:String
def arg:String
val pms = new ArrayBuffer[Any]
def constract = command format arg
def query:String = head match {
case None => constract
case Some(cmd) => cmd.query + " " + constract
}
def params:ArrayBuffer[Any] = head match{
case None => pms
case Some(cmd) => cmd.params ++ pms
}
override def toString = query
}
trait Selectable extends SqlCommand{
def apply[A](f: ResultSet => A)( implicit qe:QueryEvaluator ):Seq[A] = select( f )( qe )
def select[A](f: ResultSet => A)( implicit qe:QueryEvaluator ): Seq[A] =
qe.select( query , params: _* )(f)
def selectOne[A](f: ResultSet => A)( implicit qe:QueryEvaluator ): Option[A] =
qe.selectOne( query , params: _* )(f)
def count( implicit qe:QueryEvaluator ): Int =
qe.count( query , params: _* )
}
trait Executable extends SqlCommand{
def apply( implicit qe:QueryEvaluator ): Int = execute( qe )
def execute( implicit qe:QueryEvaluator ): Int = qe.execute( query ,  params: _* )
}
trait SelectConditionale extends Selectable {
def where( cond:Condition ) = new Where( this , cond ) with Selectable with Groupable with Sortable
}
trait ExecuteConditionale extends Executable {
def where( cond:Condition ) = new Where( this , cond ) with Executable
}
trait Groupable extends Selectable{
def group( cond:String ) = new Group( this, cond ) with Sortable
}
trait Sortable extends Selectable {
def order( cond:String ) = new Order( this, cond ) with Selectable
}
case class By( columns:String ) {
def asc = columns + " ASC"
def desc = columns + " DESC"
}
class Select ( val arg:String ) extends SqlCommand {
val head = None
val command = "SELECT %s"
def from( table:String ) = new From( this , table ) with SelectConditionale
}
class From( val h:SqlCommand, val arg:String ) extends SqlCommand {
val head = Some(h)
val command = "FROM %s"
}
class Where( val h:SqlCommand, cond:Condition ) extends SqlCommand{
val head = Some(h)
def arg = cond.condition
pms ++= cond.params
val command = "WHERE %s"
}
class Group( val h:SqlCommand, val arg:String ) extends SqlCommand {
val head = Some(h)
val command = "GROUP BY %s"
}
class Order( val h:SqlCommand, val arg:String ) extends SqlCommand {
val head = Some(h)
val command = "ORDER BY %s"
}
class Insert extends SqlCommand{
val head = None
def arg:String = ""
val command = "INSERT"
def into( table:String ) = new Into( this, table ) with SelectConditionale
def values( values:Any* ) = new Values( this , values: _* ) with Executable
}
class Into( val h:SqlCommand, table:String ) extends SqlCommand{
val head = Some(h)
val command = "INTO %s"
var cols:String = ""
override def arg = table + " " + cols
def apply( columns:String* ) = {
cols = columns.mkString( "(", ",", ")" )
this
}
def values( values:Any* ) = new Values( this , values: _* ) with Executable
}
class Values( val h:SqlCommand, values:Any* ) extends SqlCommand {
val head = Some(h)
val command = "VALUES %s"
pms ++= values
override def arg = Array.make( values.size, "?").mkString( "(", ",", ")" )
}
class Update( val arg:String ) extends SqlCommand{
val head = None
val command = "UPDATE %s"
def set( sets:SetVal* ) = new SetValues( this, sets: _* ) with ExecuteConditionale
}
class SetValues( val h:SqlCommand, sets:SetVal* ) extends SqlCommand {
val head = Some(h)
val command = "SET %s"
var cols:String = ""
pms ++= sets.map{ _.param }
override def arg = sets.mkString(",")
}
case class SetVal( column:String ){
var param:Any = null
def =/( v:Any ) = param = v
override def toString = "%s = ?".format( column )
}

在Ruby中int类有个times方法,大概使用方式是:

5 times{pritln("hello world"}

将打印出5次hello world

在scala中类似的使用方法是

(1 to 5).foreach(println("hello world")

不过还是不如ruby的使用直观

下面我们可以通过scala强大的implicit 翻译过来就是隐式转换来实现这个功能，scala的隐式转换就好像js.protype给原生类加上新的方法

在scala中希望通过JAVA的那种方式来读取文件while( (line = reader.readNext()) != null ) { .... }

编译的时候警告 values of types Unit and Null using `!=' will always yield true

原因是scala中并不支持A=B=C这种方式来赋值

搜索了相关资料，可以通过花括号来解决装这个问题

while({line=reader.readNext; line != null})

在scala中默认就可以使用JAVA的集合类比如list,set,map等。但是只能使用JAVA中的方法。

比如scala非常方便的foreach就不能使用了

编译器提示如下错误:

value foreach is not a member of java.util.List

难道scala对JAVA的兼容性只能用java的原始方法？

google了下 在类中导入如下语句

import scala.collection.JavaConversions._
objs.toList.foreach(obj => 。。。)

本文特意介绍了下scala语言中的占位符,主要是一些语法糖,和编程上的一些便利性, scala中的占位符让人眼前一亮,这种魔术代码在写代码的时候还是很有用的;

占用符，就是_ 在scala的代码中会看到大量的_

先来段简单的

def sum(x:Int,y:Int,z:Int) :Int = x+y+z
val s=sum _
println(s(4,5,6))

再看这个

def sum(x:Int,y:Int,z:Int) :Int = x+y+z
val s=sum(2,3,_:Int)
println(s(4))

scala中的MD5还是调用java.security.messagedigest类来实现的

主要是不能直接返回Array[Byte]

目前不知道是怎么一回事，先上代码

def md5(s: String) = {
val m = java.security.MessageDigest.getInstance("MD5")
val b = s.getBytes("UTF-8")
m.update(b, 0, b.length)
new java.math.BigInteger(1, m.digest()).toString(16)
}

退换货在B2C商城中是不可避免的一件事情.

像麦考林这样的大头，退换货居然高达30%。电商业界中，退还率的平均水平是10%。

退换货考验的是B2C的售后阶段，这里才是真正的用户体验价值所在。。

如果客户在退货或者换货的过程中遇到重重阻挠，相信该客户对网站的好感肯定剧减.

我们先来分析下凡客诚品的无理由退换货政策:

凡客诚品提供30天无理由退换货.其中有这样两条

“2. 报销的运费将存入您在VANCL的虚拟账户中，您可以进入“我的帐户”进行查询。

” “6. 通常情况下，一张订单只能进行一次退换货操作，所以为了确保您的权益，请您考虑周全后与我们联系。”

Grails默认不是映射字符串类型字段到text类型.

我们在domain class中的字段是字符串的时候,grails默认映射字段是到varchar类型

String title
String author
String content

这三个字符串类型的字段默认映射到数据库是varchar类型,如果你没有在domian类中设置grails constraints也就是Grails验证,默认varchar的长度是255,如果你设置了constraints

比如下面的代码: