javne的一亩三分地

淘宝产品分类

aslan — Mon, 02 Jan 2012 20:23:47 +0800

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

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

（3）活动产品。在对产品进行定位划分时，先考虑以上两项，再考虑清楚以上两项之后，接下来要做的就是用经验来判断出，哪些产品适合于做活动产品，因为要考虑到活动审核过程中淘宝小二和顾客对价格的敏感度，在选定活动产品之后，就需要对价格进行统一的规划，在这里涉及到的直接问题就是价格的定价，肯定是先要标高的，如果老老实实定价，则在后期的运营过程中就有吃不完的亏，尤其是对淘宝活动资源的争夺上。

（3）普通销售型产品。普通销售型产品基本上可以归纳到低利润型产品当中，在普通销售型产品的定价上，之前我已经写过相关文章，对企业而言，就是老老实实定价，因为压根没想过用它去做活动，也不靠活动，主要是通过这些普通产品来瓜分淘宝有限的流量。

（4）滞销型产品。包括无流量的产品，低利润低流量的产品，无流量的产品我们可以通过引流的方式来带来流量，低利润低流量的产品基本是可抛弃的产品

[转发]互联网竞争，本质是渠道之争

aslan — Fri, 30 Dec 2011 22:09:37 +0800

从周鸿祎的360谈起
如果周鸿祎要笼络几亿的用户，成为腾讯一样的巨头，做安全软件也许是最佳切入点。

06年前后，病毒、木马、流氓软件满天飞，这意味着一个潜在的巨大市场：安全需求；而同时，各大安全软件商，如瑞星、卡巴斯基的防火墙、杀毒软件都是付费的。360安全卫士横空出世，就所向披靡，因为它既强大又免费；紧接着，就是免费的360杀毒，这个市场几乎不攻自破。

就这样，360成为和腾讯抗衡的第二大互联网客户端巨头。不过，我还是没有谈到360的本质，也就是商业模式：如何赚钱。

当腾讯的QQ在几亿网民的电脑上遍地开花时，QQ这一互联网入口：渠道，就开始发力了。腾讯所有的服务都是从这里进去的，如腾讯游戏、腾讯网、拍拍网…. 这就是，为什么QQ始终不像MSN/gtalk那样，开放自己的API，也不允许珊瑚虫这类纯净版QQ传播。

360本质上也是打造一个渠道，然后将这个渠道打造成为一个平台，建立一个生态系统。不向用户收费，但向渠道的租赁者收费，就如同google的搜索引擎和广告主，也是facebook的商业模式：用户看到的是交友社区，App开发商看到的是渠道租赁费。

360安全卫士，帮助软件开发商其推广其软件(类似于Apple的AppStore)；360浏览器允许第三方插件接入(类似于Firefox插件)；360桌面，这才是360的真正野心：让软件商入驻用户桌面，这就是为什么360纳斯达克上市时说自己是中国的facebook。

渠道的本质，就是用户的入口，用户的汇集地。得渠道者得天下。

前不久雷军发布的小米手机，本质上也是推广其定制化的Android系统：MIUI。其实，雷军既不是卖手机，也不是卖操作系统MIUI，而是成为手机上的360。为什么小米手机这么强悍而又这么便宜？为什么它承诺每周五定时更新？雷军走的是周鸿祎在PC上走的老路：先让所有的智能机都装上MIUI(打造用户渠道)，形成一个繁荣的购物广场(Shopping Mall)，将地皮出租给APP开发商。

新浪微博怎么赢利？一般有这样三种想法，1、在140字的微博后面插入广告；2、通过微博导入流量，从而拉动广告收入，像新浪博客那样，本身并不赢利；3、在微博网页上植入广告。其实，这三种都成不了大器，因为这非常影响用户体验，另外，很多用户用第三方移动客户端，没有页面广告。

新浪微博最终也是打造一个用户渠道，现在有2亿多用户，已经给QQ造成威胁了。其网页版的导航栏已经有明显的应用和游戏入口；其微博桌面客户端，和QQ界面极其相似，下一步，就会采取腾讯类似的动作了：Push各种互联网服务给用户。

其实，新浪微博的野心也远不止如此，因为微博积累的真实用户，从而成为名副其实的互联网基础设施：用户身份数据库(用微博账号登录)；因为用户在微博上积累的用户关系，以及用户行为数据，成为社会化电子商务平台，指日可待(微商城已经有几家B2C入驻了)。

苹果的AppStore，本质上是iPhone和iPad的软件发布渠道(软件开发商必须缴纳30%的渠道租金)。为什么乔布斯在iOS上拒接支持Flash，因为商业利益，而不是所说的用户体验。Flash本质上是一种虚拟机(即AVM)，在该虚拟机上可以开发各种应用程序：如Flash游戏(如开心农场)、FLV视频(如优酷网)、Flash文本(如百度文库) 、Flex应用程序(如企业ERP软件)， 如果iPad/iPhone上支持Flash，AppStore如何生存？

互联网巨头，本质上做的都是渠道，只要拥有的强势的渠道地位，推广任何服务，或是出租页面空间(广告位)，都是很容易的。如baidu、搜狐和优酷，本质上都是靠出租广告位赚钱。

像迅雷，最初是一个下载工具，当工具普及后，就将其电影网站推广出去了。大众软件很多都是走这条路，如播放器(如暴风影音)、输入法(如搜狗热榜)等。

淘宝，当它通过免费策略，打造成第一购物平台后，逐渐开始收租了。最直接的，就是顺利将淘宝商城推广出去了，现在又是一淘网，如果你仔细观察淘宝网导航栏，你会发现有很多新的淘宝系网站，如淘花网、淘宝游书园，就如同凡客推广其V+网。

零售业，本质就是渠道之争，如商超苏宁、国美、沃尔玛，还有商业地产，如各地的步行街，电器城。而电子商务的本质也是零售渠道，这就是为什么独立B2C现在很难赚钱，而入驻淘宝网、淘宝商城却可以，营销费(流通费)是一个核心原因。

记录下一个简单的scala sql DSL

aslan — Thu, 22 Dec 2011 16:55:01 +0800

记录下一个简单的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 )
}

condition类

package com.yuroyoro.squire

import scala.collection.mutable.ArrayBuffer

sealed trait Condition{
  val params = new ArrayBuffer[Any]

  def condition:String
  def and( left:Condition ) = And( this, left )
  def or( left:Condition ) = Or( this, left )
}

case class Not ( val cond:Condition ) extends Condition{
  params ++= cond.params
  override def condition = "NOT " + cond.condition
}

case class And( val right:Condition,val left:Condition ) extends Condition{
  params ++= right.params
  params ++= left.params
  override def condition = right.condition + " AND " + left.condition
}

case class Or( val right:Condition, val left:Condition ) extends Condition{
  params ++= right.params
  params ++= left.params
  override def condition = right.condition + " OR " + left.condition
}

sealed trait Criteria extends Condition{
  val col:String
  val op:String
  val paramPrefix = ""
  val paramSuffix = ""
  val delimitor = ","

  def addParam( v:Any ) = {
    params += v
    this
  }

  override def condition =
    "%s %s %s %s %s".format( col, op,
      Array.make( params.size, "?").mkString( paramPrefix,  delimitor,  paramSuffix) )

  override def toString = "%s %s %s ".format( col, op, params.mkString( paramPrefix, delimitor, paramSuffix) )
}

case class Eq(col:String) extends Criteria{
  val op = "="
  def =/( v:Any ) = addParam( v )
}

case class NotEq(col:String) extends Criteria{
  val op = "<>"
  def <>( v:Any ) = addParam( v )
}

case class Lt(col:String) extends Criteria{
  val op = "<"
  def <( v:Any ) = addParam( v )
}

case class Le(col:String) extends Criteria{
  val op = "<="
  def <=( v:Any ) = addParam( v )
}

case class Gt(col:String) extends Criteria{
  val op = ">"
  def >( v:Any ) = addParam( v )
}

case class Ge(col:String) extends Criteria{
  val op = ">="
  def >=( v:Any ) = addParam( v )
}

case class Is( col:String ) extends Criteria{
  val op = "IS"
  def is( v:Null ) = addParam( "null" )
}

case class Like( col:String ) extends Criteria{
  val op = "LIKE"
  def like( v:Any ) = addParam( v )
}

case class In( col:String) extends Criteria{
  val op = "IN"
  override val paramPrefix = "("
  override val paramSuffix = ")"
  def in( v:Any* ) = {
    params ++= v
    this
  }
}

object Implicits {
  val * = "*"
  def select = new Select("*")
  def select( columns:String* ) = new Select( columns.mkString(",") )
  def not( op:Criteria ) = Not( op )
  def by( columns:String*) = columns.mkString(",")
  implicit def string2by( columns:String) = By( columns )
  implicit def string2Eq( col:String ) = Eq( col )
  implicit def string2NotEq( col:String ) = NotEq( col )
  implicit def string2Lt( col:String ) = Lt( col )
  implicit def string2Le( col:String ) = Le( col )
  implicit def string2Gt( col:String ) = Gt( col )
  implicit def string2Ge( col:String ) = Ge( col )
  implicit def string2Is( col:String ) = Is( col )
  implicit def string2Like( col:String ) = Like( col )
  implicit def string2In( col:String ) = In( col )
  implicit def string2SetVal( col:String ) = SetVal( col )
}

使用方法：

在需要用到的地方import 下 Implicits._

implicit val queryEvaluator = QueryEvaluator("localhost:3306/dd", "root", "123456")
var ct=select("count(*)").from("scm_sale_order_entity").count
  println(ct)
select(*).from("scm_sale_order_entity soe")
  .where( " is_invalid " =? 2 and " soe.sale_api_id" =? 5 ){row => println(row.getString("order_no"))}

scala定义ruby中的times方法

aslan — Wed, 21 Dec 2011 10:21:47 +0800

在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给原生类加上新的方法

implicit def intWithTimes(n: Int) = new {        
      def times(f: => Unit) = 1 to n foreach { i => f}
   
  }

现在我们也可以这样使用了

5 times (pritln("xxx")

现在times方法已经很好用了，但是我们可以更进一步times 迭达的时候吧i也传给 f函数

var i=0;
5 times {println("i:"+i);i+=1;}

现在我们迭达类似于 while

implicit def intWithTimes(n: Int) = new {        
      def times(f:(Int) => Unit) = 1 to n foreach { i => f(i)}
   
  }

ok,我们已经重新定义了我们的 times方法了

5 times(i => {prinltn(i+": hell world")})以后

以后我们只需要在我们使用times方法的类中implicit隐式转换下就可以使用times方法了,感觉就像scala的原生int自带有times方法一模一样

scala用while循环读取reader或者流

aslan — Tue, 06 Dec 2011 15:07:06 +0800

在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})

用花括号来包括一个代码块，这个代码块返回true

不过在scala中不推荐来使用while循环，那我们有其他的方法吗?

val it= Iterator.continually(reader.readNext).takeWhile(_ !=null)
	it.foreach(i => println(i.mkString))

可以通过continually方法来返回一个iterator对象，然后就可以使用scala集合的foreach方法了

上面的代码还可以简写为

Iterator.continually(reader.readNext).takeWhile(_ !=null) foreach(i => println(i.mkString))

上面代码中的i 本来想简写为_下划线但是报错，目前不知道神原因,

另外那个continuall方法也需要去了解下

在scala中使用java的集合类

aslan — Wed, 30 Nov 2011 13:49:27 +0800

在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中的占位符

aslan — Tue, 29 Nov 2011 11:44:05 +0800

本文特意介绍了下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))

而且占位符可以使用在不同的地方

def say(greeting: String, title: String, name: String) = println(greeting + "," + title + " " + name)
  val callNotyy = say(_: String, "Mr", _: String)
  callNotyy("hello", "notyy")

scala中的MD5加密

aslan — Thu, 24 Nov 2011 13:38:45 +0800

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无理由退换货政策-凡客诚品

aslan — Mon, 14 Mar 2011 11:29:04 +0800

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

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

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

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

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

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

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

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

有了上面两条条款的巧妙限制,假设你购买了一件衣服,不满意,你能处理的方式只有三种:

1.退货

2.换货

3.自认倒霉

先分析第一种处理方式:退货:

因为凡客诚品公司支付退换货运费的方式是“报销”而不是快递到付的方式，这一条很巧妙，因为他们给你报销运费的方式在第2条中已经明确规定是存到你在他们网站的虚拟账户中。

这就决定了你确实不要支付这笔运费,但你要想真正再利用这十几块钱，那么必须再重新买他们的产品。因为这钱是在他们网站上的虚拟账户上的

而这个过程中凡客诚品损失了什么呢？他们损失的就是当初发货时候的一点运费，但是这点损失换来的是你随时可能的重复购买行为，因为他们给你“报销”的运费在你的凡客诚品账户里面。

即便如此关于退货是连运费和货款一起退还是只退货款，他们在购物条款里面没有明确说明。

退货的话对他们来说最坏的情况就是：他们所有的货款和运费都退给你，他们给你报销的那点运费被你扔在账户里面不要了，也坚决不再买他们东西。那么这一来一回发生的运费相当于是你和凡客诚品各负担一半，因为这种情况对你来说也产生了经济损失，所以根本不会形成竞争对手的恶意退换货漏洞。

再分析第二种处理方式：换货

这对凡客诚品来说就更轻松了，换一次货需要支付来回两次运费。

发回凡客诚品的运费其实是你自己掏的，然后他们给你“报销”到你的虚拟账户里面，要想利用这十几钱你必须再次购买，对他们来说这是最高兴的事，说起来是为你报销了运费，其实只是一个让你重复购买的商业政策而已。

凡客诚品给你发回来的运费是他们直接付的，但是他们已经在第6条中规定每笔订单只能退换货一次，假设运费平均是15块钱的话，也就是说凡客诚品为你这比笔订单最多会支付15块钱的换货成本。

承担这15块钱根本不成问题，售后服务的费用只是平摊到所有买家头上而已。总体分析来说凡客的无理由退换货，既能让客户享受到无理由退换货，降低竞争对手的恶意打击漏洞,还能提高客户的重复购买力。

何乐而不为呢?

Grails映射字段到text类型

aslan — Wed, 09 Mar 2011 15:19:31 +0800

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

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

String title
String author
String content

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

比如下面的代码:

static constraints = {
        author(size:5..125)
        metaTitle(size:5..100)
    }

在数据库中的长度分别是author varchar 125的长度,metaTitle varchar 长度是100.grails很聪明的帮我们自动分配好了长度.

这里我们先来说我们的第一种映射字符串字段到text类型的方法:

就是在grails constraints中设置验证长度超过255即可,grails就会把字段映射成为text类型

第二种方法

static mapping={
        //content 字段映射到text类型
        content type:'text'
    }

不过我看了下数据库结构是映射到longtext而不是text类型