extjs 基础部分

正文已授权InfoQ独家公布,如需转载请注脚出处更加多内容请查阅笔者个人站点http://www.jasongj.com ,可能订阅微信公众号【大数额架构】

成立对象的章程:

澳门美高梅手机网站 1

    使用new
关键字创造对象。

摘要

  Kafka是由LinkedIn开发并开源的分布式音信系统,因其分布式及高吞吐率而被大规模运用,现已与Cloudera
Hadoop,Apache Storm,Apache
Spark集成。本文介绍了Kafka的创制背景,设计目标,使用消息系统的优势以及当前风靡的新闻系统比较。并介绍了Kafka的架构,Producer音信路由,Consumer
Group以及由其已毕的不等音信分发方式,Topic & Partition,最终介绍了Kafka
Consumer为啥使用pull方式以及Kafka提供的二种delivery guarantee。

      new  classname ([config])

背景介绍

    使用Ext.create方法创造。

Kafka创制背景

  Kafka是1个消息系统,原本开发自LinkedIn,用作LinkedIn的移动流(Activity
Stream)和营业数量处理管道(Pipeline)的根基。今后它已被多家不一样类型的协作社 作为八连串型的多寡管道和音讯系统运用。
  活动流数据是几乎拥有站点在对其网站拔取状态做报表时都要用到的数量中最健康的部分。活动数量包蕴页面访问量(Page
View)、被翻开内容方面的消息以及查找意况等内容。那种数量一般的处理方式是先把种种活动以日记的款型写入某种文件,然北周期性地对这么些文件进行总括分析。运维数量指的是服务器的习性数据(CPU、IO使用率、请求时间、服务日志等等数据)。运行数量的计算形式体系层见迭出。
  近年来,活动和运行数量处理已经变为了网站软件出品特征中一个紧要的组成部分,那就需求一套稍微尤其错综复杂的根底设备对其提供支撑。
  

      Ext.create(classname,[config])

Kafka简介

  Kafka是一种分布式的,基于发表/订阅的音信系统。首要设计目的如下:

  • 以时间复杂度为O(1)的法门提供音信持久化能力,尽管对TB级以上数量也能担保常数时间复杂度的拜会质量
  • 高吞吐率。即便在越发廉价的商用机器上也能成功单机资助每秒100K条以上音信的传导
  • 援救Kafka
    Server间的音信分区,及分布式消费,同时确保各种Partition内的新闻顺序传输
  • 再者辅助离线数据处理和实时数据处理
  • Scale out:扶助在线水平扩充

    new Ext.Viewport({})

为何采打消息系统

  • 解耦
      在档次运维之初来预测今后项目会遇上什么必要,是无与伦比费劲的。新闻系统在处理进程中间插入了贰个含有的、基于数据的接口层,两边的处理进程都要兑现这一接口。那允许你独自的扩充或改动两边的处理进程,只要确保它们遵守同样的接口约束。

  • 冗余
      有些意况下,处理数量的进度会破产。除非数码被持久化,否则将招致丢失。音信队列把数据进行持久化直到它们曾经被完全处理,通过这一艺术规避了数据丢失风险。许多音信队列所使用的”插入-获取-删除”范式中,在把一个音讯从队列中去除以前,必要您的处理系统明显的提议该音讯已经被处理完成,从而确保您的数据被安全的保存直到你利用完成。

  • 扩展性
      因为信息队列解耦了你的处理进度,所以增大音信入队和处理的作用是很简单的,只要其余伸张处理进度即可。不要求改变代码、不须求调剂参数。扩大就像是调大电力按钮一样不难。

  • 圆滑 & 峰值处理能力
      在访问量剧增的情事下,应用照旧要求继续发挥成效,可是如此的发生流量并不常见;假诺为以能处理那类峰值访问为正规来投入能源随时待命无疑是高大的荒废。使用消息队列可以使重大组件顶住突发的造访压力,而不会因为突发的超负荷的伸手而完全崩溃。

  • 可苏醒性
      系统的一部分零件失效时,不会潜移默化到方方面面连串。信息队列下落了经过间的耦合度,所以尽管一个拍卖音讯的历程挂掉,插手队列中的音信还是可以在系统恢复生机后被拍卖。

  • 逐条保险
      在几乎使用意况下,数据处理的各样都很要紧。超过半数消息队列本来就是排序的,并且能确保数据会依照一定的依次来处理。Kafka保险三个Partition内的音讯的有序性。

  • 缓冲
      在其余重大的体系中,都会有亟待不一致的拍卖时间的因素。例如,加载一张图纸比选用过滤器成本更少的时日。音信队列通过二个缓冲层来赞助职分最高效用的施行———写入队列的处理会尽只怕的快速。该缓冲有助于控制和优化数据流经过系统的进程。

  • 异步通讯
      很多时候,用户不想也不需求登时处理音讯。新闻队列提供了异步处理机制,允许用户把二个消息放入队列,但并不立时处理它。想向队列中放入多少音讯就放多少,然后在要求的时候再去处理它们。

    修改为Ext.create(‘Ext.Viewport’,{})

常用Message Queue对比

  • RabbitMQ
      RabbitMQ是选拔Erlang编写的多个开源的消息队列,本人辅助广大的合计:AMQP,XMPP,
    SMTP,
    STOMP,也正因如此,它尤其重量级,更适合于公司级的付出。同时落到实处了Broker构架,那象征信息在发送给客户端时先在基本队列排队。对路由,负载均衡或然数额持久化都有很好的帮衬。

  • Redis
      Redis是3个基于Key-Value对的NoSQL数据库,开发珍惜很活泼。纵然它是3个Key-Value数据库存储系统,但它本人支持MQ功用,所以完全可以作为2个轻量级的行列服务来采用。对于RabbitMQ和Redis的入队和出队操作,各执行100万次,每10万次记录五回举行时间。测试数据分为128Bytes、512Bytes、1K和10K两个不等大小的数据。实验表明:入队时,当数码相比小时Redis的质量要高于RabbitMQ,而一旦数额大小超越了10K,Redis则慢的无法忍受;出队时,无论数额大小,Redis都显示出格外好的本性,而RabbitMQ的出队品质则远小于Redis。

  • ZeroMQ
      ZeroMQ号称最快的音讯队列系统,尤其针对大吞吐量的须要意况。ZMQ可以达成RabbitMQ不善于的高等级/复杂的行列,然而开发人员须求团结组合各个技巧框架,技术上的复杂度是对那MQ可以拔取成功的挑衅。ZeroMQ具有三个奇特的非中间件的格局,你不需求设置和运作3个新闻服务器或中间件,因为您的应用程序将饰演那个服务器角色。你只须要简单的引用ZeroMQ程序库,可以行使NuGet安装,然后你就可以神采飞扬的在应用程序之间发送新闻了。可是ZeroMQ仅提供非持久性的体系,约等于说假若宕机,数据将会丢掉。其中,推文(Tweet)的Storm
    0.9.0原先的版本中默许使用ZeroMQ作为数据流的传输(Storm从0.9本子开头还要辅助ZeroMQ和Netty作为传输模块)。

  • ActiveMQ
      ActiveMQ是Apache下的二个子项目。
    类似于ZeroMQ,它亦可以代办和点对点的技巧完成队列。同时类似于RabbitMQ,它少量代码就足以快捷地贯彻高级应用场景。

  • Kafka/Jafka
      Kafka是Apache下的1个子项目,是二个高质量跨语言分布式揭橥/订阅音讯队列系统,而Jafka是在Kafka之上孵化而来的,即Kafka的二个升级版。具有以下特点:疾速持久化,可以在O(1)的系统开发下开展消息持久化;高吞吐,在一台一般的服务器上既可以完成10W/s的吞吐速率;完全的分布式系统,Broker、Producer、Consumer都原生自动协助分布式,自动落成负载均衡;援救Hadoop数据交互加载,对于像Hadoop的均等的日记数据和离线分析系统,但又须求实时处理的限量,那是二个得力的化解方案。Kafka通过Hadoop的互动加载机制统一了在线和离线的新闻处理。Apache
    Kafka相对于ActiveMQ是三个格外轻量级的音讯系统,除了质量特别好之外,如故2个工作特出的分布式系统。

 

Kafka架构

  Ext.widget 或Ext.createWidget 创立对象

Terminology

  • Broker
      Kafka集群包括二个或七个服务器,那种服务器被喻为broker
  • Topic
      每条发布到Kafka集群的新闻都有3个类型,那一个类型被号称Topic。(物理上不一样Topic的新闻分开储存,逻辑上一个Topic的音讯就算保存于3个或多个broker上但用户只需点名音讯的Topic即可生育或消费数量而无需关注数据存于何处)
  • Partition
      Parition是物理上的定义,每种Topic包含一个或多少个Partition.
  • Producer
      负责公布信息到Kafka broker
  • Consumer
      新闻消费者,向Kafka broker读取音讯的客户端。
  • Consumer Group
      每一种Consumer属于二个特定的Consumer
    Group(可为各个Consumer钦点group name,若不钦命group
    name则属于暗中认可的group)。

    使用Ext.ns
只怕Ext.namespace  定义命名空间

Kafka拓扑结构

澳门美高梅手机网站 2
  如上图所示,2个头名的Kafka集群中富含若干Producer(可以是web前端暴发的Page
View,恐怕是服务器日志,系统CPU、Memory等),若干broker(Kafka扶助水平扩充,一般broker数量越多,集群吞吐率越高),若干Consumer
Group,以及三个Zookeeper集群。Kafka通过Zookeeper管理集群配置,大选leader,以及在Consumer
Group暴发变化时开展rebalance。Producer使用push格局将音信发布到broker,Consumer使用pull情势从broker订阅并用度新闻。
  

      Ext.ns 是  Ext.namespace 的简写

Topic & Partition

  Topic在逻辑上得以被认为是一个queue,每条消费都必须内定它的Topic,可以总结明了为必须指明把那条音讯放进哪个queue里。为了使得Kafka的吞吐率可以线性进步,物理上把Topic分成多个或五个Partition,每一个Partition在物理上相应三个文本夹,该公文夹下存储那个Partition的拥有音讯和目录文件。若创设topic1和topic2七个topic,且分别有1二个和二十一个分区,则全体集群上会相应会扭转共贰拾8个文件夹(本文所用集群共几个节点,此处topic1和topic2
replication-factor均为1),如下图所示。
  澳门美高梅手机网站 3
  
  每种日志文件都以多个log entrie序列,每个log entrie饱含一个4字节整型数值(值为N+5),二个字节的”magic
value”,六个字节的CPRADOC校验码,其后跟N个字节的新闻体。每条新闻都有三个脚下Partition下唯一的64字节的offset,它指明了那条音讯的开始地方。磁盘上囤积的音信格式如下:
  message length : 4 bytes (value: 1+4+n)
  “magic” value : 1 byte
  crc : 4 bytes
  payload : n bytes
  这个log entries不用由三个文件构成,而是分成多少个segment,各个segment以该segment第②条音讯的offset命名并以“.kafka”为后缀。其它会有3个索引文件,它标志了各类segment下富含的log entry的offset范围,如下图所示。
  澳门美高梅手机网站 4
  
  因为每条信息都被append到该Partition中,属于顺序写磁盘,因而功效越发高(经验证,顺序写磁盘效能比自由写内存还要高,那是Kafka高吞吐率的三个很重大的担保)。
  澳门美高梅手机网站 5
  
  对于古板的message
queue而言,一般会删除已经被消费的音信,而Kafka集群会保留全数的音讯,无论其被消费与否。当然,因为磁盘限制,不能永远保存全体数据(实际上也没必要),因而Kafka提供二种政策删除旧数据。一是依照时间,二是依据Partition文件大小。例如可以经过布置$KAFKA_HOME/config/server.properties,让Kafka删除1日前的数据,也可在Partition文件当先1GB时去除旧数据,配置如下所示。

  
# The minimum age of a log file to be eligible for deletion
log.retention.hours=168
# The maximum size of a log segment file. When this size is reached a new log segment will be created.
log.segment.bytes=1073741824
# The interval at which log segments are checked to see if they can be deleted according to the retention policies
log.retention.check.interval.ms=300000
# If log.cleaner.enable=true is set the cleaner will be enabled and individual logs can then be marked for log compaction.
log.cleaner.enable=false

  
  那里要留意,因为Kafka读取特定音讯的岁月复杂度为O(1),即与文件大小非亲非故,所以那边删除过期文件与增进Kafka质量无关。采Nash么样的删除策略只与磁盘以及现实的必要有关。其它,Kafka会为每3个Consumer
Group保留部分metadata音讯——当前开支的消息的position,也即offset。这么些offset由Consumer控制。平常意况下Consumer会在消费完一条新闻后递增该offset。当然,Consumer也可将offset设成1个较小的值,重新消费一些新闻。因为offet由Consumer控制,所以Kafka
broker是无状态的,它不须求标记哪些新闻被什么消费过,也不需求通过broker去保险同2个Consumer
Group唯有3个Consumer能消费某一条新闻,因而也就不需求锁机制,那也为Kafka的高吞吐率提供了强有力保证。
  

      定义全局变量的语法:Ext.namespace(

Producer新闻路由

  Producer发送新闻到broker时,会根据Paritition机制选取将其储存到哪二个Partition。假若Partition机制设置合理,全数新闻可以均匀分布到不相同的Partition里,这样就兑现了负荷均衡。若是一个Topic对应1个文件,那那些文件所在的机器I/O将会变成那几个Topic的习性瓶颈,而有了Partition后,区别的音讯可以相互写入不相同broker的不等Partition里,极大的滋长了吞吐率。可以在$KAFKA_HOME/config/server.properties中通过布置项num.partitions来钦赐新建Topic的暗中同意Partition数量,也可在开创Topic时经过参数指定,同时也得以在Topic创造之后通过Kafka提供的工具修改。
  
  在殡葬一条音讯时,可以内定那条新闻的key,Producer依据那一个key和Partition机制来判定相应将那条消息发送到哪个Parition。Paritition机制可以通过点名Producer的paritition. class这一参数来钦定,该class必须兑现kafka.producer.Partitioner接口。本例中如若key可以被分析为整数则将相应的整数与Partition总数取余,该信息会被发送到该数对应的Partition。(各个Parition都会有个序号,序号从0初叶)

import kafka.producer.Partitioner;
import kafka.utils.VerifiableProperties;

public class JasonPartitioner<T> implements Partitioner {

    public JasonPartitioner(VerifiableProperties verifiableProperties) {}

    @Override
    public int partition(Object key, int numPartitions) {
        try {
            int partitionNum = Integer.parseInt((String) key);
            return Math.abs(Integer.parseInt((String) key) % numPartitions);
        } catch (Exception e) {
            return Math.abs(key.hashCode() % numPartitions);
        }
    }
}

 
  若是将上例中的类作为partition.class,并透过如下代码发送20条音信(key分别为0,1,2,3)至topic3(包罗四个Partition)。
  

public void sendMessage() throws InterruptedException{
  for(int i = 1; i <= 5; i++){
        List messageList = new ArrayList<KeyedMessage<String, String>>();
        for(int j = 0; j < 4; j++){
            messageList.add(new KeyedMessage<String, String>("topic2", j+"", "The " + i + " message for key " + j));
        }
        producer.send(messageList);
    }
  producer.close();
}

  则key相同的新闻会被发送并蕴藏到同贰个partition里,而且key的序号正好和Partition序号相同。(Partition序号从0初步,本例中的key也从0伊始)。下图所示是通过Java程序调用Consumer后打印出的音信列表。
  澳门美高梅手机网站 6  

        namespace1,namespace2,namespace3

Consumer Group

  (本节有着描述都是依照Consumer hight level API而非low level
API)。
  使用Consumer high level
API时,同一Topic的一条消息只能被同三个Consumer
Group内的2个Consumer消费,但八个Consumer Group可同时成本这一音讯。
  澳门美高梅手机网站 7
  那是Kafka用来兑现一个Topic音讯的播音(发给具有的Consumer)和单播(发给某二个Consumer)的招数。1个Topic可以对应多个Consumer
Group。假设需求完毕广播,只要每一种Consumer有三个独自的Group就足以了。要兑现单播只要持有的Consumer在同3个Group里。用Consumer
Group还足以将Consumer实行自由的分组而不需求频仍殡葬音信到不相同的Topic。
  实际上,Kafka的宏图意见之一就是同时提供离线处理和实时处理。依照这一表征,可以应用Storm那种实时流处理系统对音讯进行实时在线处理,同时选择Hadoop那种批处理体系进行离线处理,还能而且将数据实时备份到另八个数额主题,只须要确保那五个操作所采纳的Consumer属于不相同的Consumer
Group即可。下图是Kafka在Linkedin的一种简化安插示意图。
  澳门美高梅手机网站 8
  
  上边那几个事例更清晰地突显了Kafka Consumer
Group的性状。首先成立1个Topic
(名为topic1,包蕴1个Partition),然后创制3个属于group1的Consumer实例,并创制多个属于group2的Consumer实例,最终通过Producer向topic1殡葬key分别为1,2,3的新闻。结果发现属于group1的Consumer收到了有着的那三条消息,同时group2中的壹个Consumer分别收到了key为1,2,3的新闻。如下图所示。
  澳门美高梅手机网站 9  

    )   

Push vs. Pull  

  作为1个消息系统,Kafka遵从了古板的主意,采纳由Producer向broker
push消息并由Consumer从broker pull音信。一些logging-centric
system,比如Facebook的Scribe和Cloudera的Flume,采取push方式。事实上,push情势和pull情势各有优劣。
  push方式很难适应消费速率不相同的买主,因为音信发送速率是由broker决定的。push方式的对象是尽或者以最急迅度传递音信,但是这么很简单造成Consumer来不及处理音信,典型的显现就是拒绝服务以及网络堵塞。而pull格局则足以依照Consumer的消费能力以适量的速率消费音信。
  对于Kafka而言,pull情势更合适。pull方式可简化broker的规划,Consumer可自主控制消费音信的速率,同时Consumer可以协调决定消费情势——即可批量消费也可依次消费,同时还是可以选取区其余交由情势因而已毕不一样的传导语义。
  

  namespace1 是命名空间的名字。

Kafka delivery guarantee

  有那样三种恐怕的delivery guarantee:

  • At most once 新闻大概会丢,但绝不会重复传输
  • At least one 音信绝不会丢,但或然会再一次传输
  • Exactly once 每条音信一定会被传输一回且仅传输一回,很多时候那是用户所想要的。
      
      当Producer向broker发送音讯时,一旦那条消息被commit,因数replication的存在,它就不会丢。不过一旦Producer发送数据给broker后,碰到网络难题而导致通信中断,那Producer就不能断定该条消息是不是业已commit。即便Kafka不或然分明网络故障时期暴发了什么样,然则Producer可以生成一连串似于主键的东西,暴发故障时幂等性的重试数拾叁回,那样就形成了Exactly once。截至到当下(Kafka
    0.8.2版本,二〇一五-03-04),这一Feature还并未已毕,有期待在Kafka今后的版本中贯彻。(所以近年来暗中认同意况下一条新闻从Producer到broker是保障了At least once,可透过设置Producer异步发送完毕At most once)。
      接下去商讨的是消息从broker到Consumer的delivery
    guarantee语义。(仅针对Kafka consumer high level
    API)。Consumer在从broker读取音讯后,可以挑选commit,该操作会在Zookeeper中保存该Consumer在该Partition中读取的音信的offset。该Consumer下五次再读该Partition时会从下一条发轫读取。如未commit,下三遍读取的上马地方会跟上几遍commit之后的启幕地点相同。当然可以将Consumer设置为autocommit,即Consumer一旦读到数据立马自行commit。如果只谈谈这一读取音信的进度,那Kafka是保证了Exactly once。但实际拔取中应用程序并非在Consumer读取完数据就谢世了,而是要拓展进一步处理,而数据处理与commit的各种在很大程度上决定了音信从broker和consumer的delivery
    guarantee semantic。
  • 读完新闻先commit再处理音讯。那种格局下,若是Consumer在commit后还没来得及处理音讯就crash了,下次再也初始工作后就无法读到刚刚已提交而未处理的音信,那就对应于At most once
  • 读完消息先处理再commit。那种格局下,要是在拍卖完音信随后commit此前Consumer
    crash了,下次再也早先工作时还会处理刚刚未commit的音信,实际上该音讯一度被拍卖过了。那就对应于At least once。在重重施用情状下,新闻都有壹个主键,所以消息的处理往往具有幂等性,即数十次甩卖这一条音信跟只处理两遍是均等的,那就足以认为是Exactly once。(我觉得那种说法相比牵强,毕竟它不是Kafka自身提供的编制,主键本身也并不只怕一心保障操作的幂等性。而且实际我们说delivery
    guarantee
    语义是座谈被处理多少次,而非处理结果怎么着,因为处理方式各类各个,大家不应有把处理进度的性状——如是还是不是幂等性,当成Kafka自己的Feature)
  • 比方一定要到位Exactly once,就须求协调offset和实际操作的出口。精典的做法是引入两品级提交。如若能让offset和操作输入存在同1个地点,会更精简和通用。那种方式或许更好,因为众多出口系统或许不协助两阶段提交。比如,Consumer得到数量后或者把数量放到HDFS,假设把新型的offset和多少本身一起写到HDFS,那就足以保障数据的出口和offset的立异要么都形成,要么都不完了,直接达成Exactly once。(近来就high
    level API而言,offset是存于Zookeeper中的,不能够存于HDFS,而low level
    API的offset是由自身去维护的,可以将之存于HDFS中)
      同理可得,Kafka默许保障At least once,并且同意通过设置Producer异步提交来促成At most once。而Exactly once渴求与外表存储系统同盟,幸运的是Kafka提供的offset可以卓殊直接卓殊不难得使用那种艺术。

    Ext.namespace(“Myapp”)      

下卷预先报告

  下一篇将深刻讲解Kafka是如何做Replication和Leader
Election的。在Kafka0.8在先的本子中,即便某些broker宕机,可能磁盘出现难点,则该broker上装有partition的多寡都会丢掉。而Kafka0.8自此参预了Replication机制,可以将各类Partition的数据备份多份,尽管一些broker宕机也能保障系统的可用性和数码的完整性。

 

  使用Ext.define
定义新类。

    语法:
Ext.define(classname,properties,callback);

      classname 定义新的类名。

      properties 新类的配备对象,对象里含有了类的属性集对象。

      callback:回调函数,当类创设完结后实施该函数。

 

    apply 和applylf 方法

      apply 方法中的功效是将具有配置对象的积极分子复制到对象

    数据及其类型检测

      typeOf 检测变量的序列

        语法:Ext.typeof(v)
 v是要检测的变量

      isEmpty  检测值是不是为空

        语法:
Ext.isEmpty(v,allowEmptyString)

          v是要检测的值,  allowEmptyString
 默许为false,表示不

      允许空字符串,反过来,空字符串也回到true;
当重回值为true时期表为空,false表示不为空。

    isObject 检测值是还是不是为JavaScript 的目的。

      语法:
Ext.isObject(v)

        islterable 检测值是不是足以迭代。

      语法:
Ext.islterable(v)

        isFunction 检测值是不是为函数

      语法:
Ext.isFunction(v)

   lterate   对数组或然目的开展迭代。

      语法:
Ext.iterate(object, fn,scope);

        object 是要开展迭代操作的数组恐怕目的

          fn 是要开展迭代操作的函数,

            scope 是功用域,f该方法没有重回值。

        Clone

          可以对克隆数组,对象,DOM
节点和日期等数码,以防保持旧的对准。

          语法:
Ext.clone(item)

        item: 要复制的数组, 对象,DOM
节点或日期,重返克隆后的。

  Id

    产生id

      语法:
Exd.id([el,prefix]) 101

  getBody

      重返当前document
对象的body 元素

      语法
Ext.getBody()

  getHead

    返回docuemnt
对象的head 元素

    语法: Ext.getHead()

  getDoc

    返回document 对象

    语法: Ext.getDoc()

  Destroy

    删除对象及其事件,从DOM 中
删除节点。

    语法:
Ext.destroy(obj1,obj2,…)

  urlAppend

    为url
追加查询字符串。

    语法:Ext.urlAppend(url,s)

  addBehaviors

    为匹配采用符的成分绑定事件。

    语法:Ext.addBehaviors(o)
   o为对象。

  getScrollBarWidth

    获取滚动条宽度

      语法:
Ext.getScrollBarWidth([force])

      force
的法力是逼迫重新总结滚动条宽度,该格局再次来到滚动条的宽度。

  destroyMembers

    删除对象的分子。

      语法:Ext.destroyMembers(o,namel,
name2…);

        o 是要刨除的其成员对象,namel
要删减成员的要害字,该模式没有再次来到值。

  copyTo

    从3个对象复制属性名称到另3个对象。

      语法:
Ext.copyTo(dest,source,name[,useProtoypeKeys]);

    平台检测工具 Ext.is

    Ext.Function中静态方法:

    1.flexSetter

      封装二个只收取五个参数的函数,封装后,函数的参数会变的灵敏。

        语法:
Ext.Function.flexSetter(fn);

          fn 要卷入的函数; 该办法再次来到封装厚度函数。

    2.Bind

      绑定函数的法子,首要功用是保持作用域。

        语法:
Ext.Function.bind(fn[,scope,args,appendArgs]);

              Ext.bind(fn[,scope,args,appendArgs]);  // 简写

    3.Pass

      封装一个新函数,在调用旧函数时,将预设的参数插入到新函数的参数前面作为旧函数的参数

        该办法主要用以成立回调函数。

      语法:
Ext.Function.pass(fn,args[,scope])

        fn 是要卷入的函数: args 是数组,为预设的参数,
scope是可选参数,为函数的效用域。

    4.Alias

      为格局创立1个别名。

        语法:Ext.Function.alias(object,methodName);

          object 是要创造别名的靶子; methodName
是字符串,成立

      别名的措施名称,该办法再次来到要成立别名的函数。

    5.createInterceptor

      创制2个挡住函数。

        语法:Ext.Function.createInterceptor(origFn,newFn[,scope,returnValue])

    6.createDelayed

      创造一个延时实施的回调函数。

        语法:
Ext.Function.createDelayed(fn,delay[,scope,args,appends]);

    7.Defer

      在钦定时间后执行函数。

        语法:
Ext.Function.defer(fn,defay[,scope,args,appends]);

           Ext.defer(fn,defay[,scope,args,appends])

    8.createSequence

      创造五个函数,在推行原始函数之后执行钦命的函数。

        语法:
Ext.Function.createSequence(origFn,newFn[,scope]);

    9.createBuffered

      成立五个缓冲函数。

        语法:
Ext.function.createBuffered(fn,buffer,scopr,args);

    10.createThrottled

      封装那三个被频仍且高效调用的函数。如鼠标移动事件,唯有在相距上调用时间达到内定间隔后才会执行操作。

    11.Clone

      为指定的函数创建三个克隆函数。

        语法:
Ext.Function.clone(fn);

          其中,fn是要克隆的函数。

    12.interceptBefore

      在函数的原来操作在此之前实施贰个钦命的操作。

        Ext.Function.interceptBefore(object,methodName,fn[,scope]);

    13.interceptAfter

      在函数的固有操作之后执行一个钦定的操作。

        语法:
Ext.Function.interceptAfter(object, methodName,fn[,scope]);

Ext.Array 中的静态方法

  1.each

    枚举数组。

      语法:
Ext.Arrary.each(array,fn[,scope,reverse]);

              Ext.each(array,fn[,scope,reverse])  // 简写

            array 是要枚举的数组, fn
是枚举每种品种时要推行的回调函数,  函数能够承受多少个参数, item ,index
和items

                item 是枚举的数组成分,index
时数组的目前目录。

               items  数组本身。 scope 是可选参数,
为函数成效域。

                reverse 是可选参数。为布尔值。

  2.forEach

      遍历一数组,并且动用指定函数处理数组的各个成分。

      语法:
Ext.Array.forEach(array,fn[,scope]);

        array
是要遍历的数组,fn是处理函数,函数可以承受多个参数, item ,index 和items

            item 是遍历的数组成分,index 时数组的脚下目录。

          items  数组自身。

  3.toArray

    将可迭代的多少转发为数组。

      语法Ext.Array.toArray(iterable[,start,end]);

        Ext.toArray(iterable[,start,end]);  // 简写

           iterable
的数据类型为任何可迭代的数量。表示要转型为数组的数目;

         start 是可选参数,为数字值,表示转换的上马位置,end
代表转换 后的终结地方,该措施重临转换后的数组。

  4.pluck

    依据内定的习性,获取数组内每种队形钦命关键字的值。

      语法:Ext.Array.pluck(array,name);

          Ext.pluck(array,name); // 简写

        array 是获取数据的数组, name 是字符串,
未内定的根本字,该措施再次来到由内定关键字的值所组成的数组。

  5. from

    将一个值换为数组。

      语法:
Ext.Array.from(value[,newReference]);

          value 是更换为数组的值; newReference
是可选参数,决定采用数组成分是或不是利用心得 指向。

  6.sort

    对数组中的成分举行排序。

      语法:
Ext.Array.sort(array[,fn]);

  7.别样数组方法    

 

指鹿为马中的静态方法:

   1.ignore  布尔值, 暗许值为false 呈现错误报告。

   2.notify 效应与ignore 属性相同。

    创设类的类
 Ext.Class    

    全部继承类的基类:
Ext.Base

    完结动态加载:
Ext.Loader   

    管理类的类:
Ext.ClassManager

    动态加载的路线设置:   

  事件及使用

    绑定浏览器的时间的经过
Ext.伊夫ntManager

    要为成分绑定事件,统称会使用Ext.伊芙ntManager
的on 方法。

      语法:
Ext.EventManager.on(el,eventNmae,fn[,scope,opticons]);

    封装浏览器事件:
Ext.伊芙ntObject    180

      删除浏览器事件:
 un(removerListener)  removeAll purgeElement

    内部事件.

      内部事件目标Ext.util.伊夫nt

      为组件时间累加接口。
 Ext.util.Observable

    为组件绑定事件。

      特定作用的绑定事件。

          延时义务:
Ext.util.DelayedTask

          一般职分:
Ext.util.TaskRunner 与Ext.TaskManager

          封装好的单机事件:
Ext.util.ClickPepeater

    键盘事件

      为要素绑定键盘事件。
Ext.util.KeyMap

      键盘导航
  Ext.util.KeyNav

  基本选拔符

     1.* 任何拔取器

       语法:
Ext.query(“*”)

    2.依照成分标记 E  采纳元素

      语法:
Ext.query(“E”)

    3.增选包涵在标记E 中的F

      语法:
Ext.query(“E F”)

    4. 精选在含蓄在标记E 中的直接子标记F

      语法:
Ext.query(“E >F”)

    5.抉择在拥有紧跟在要素E 后的成分F

      语法:
Ext.query(“E+F”)

    6.增选在成分E从此的同层的因素 F

      语法:
Ext.query(“E~F”)

    7.精选id 属性值为ID 的成分。

      语法:
Ext.query(“#ID”)

    8.选择css 类名为classname 的元素。

      语法:
Ext.query(“E.classname”)

  属性选拔器:

    1. 摘取带有属性 attribute 的因素

        语法:Ext.query(“[attribute]”)

        Ext.query(“E[attribute]”)  // E 为成分标记。

    2.精选 attribute  的属性值为value 的要素。

      语法:Ext.query(“[attribute=vale]”)

         Ext.query(“E[attribute=vale]”) // E为因素标记。

    3. 取舍 attribute 的属性值以 value 初阶的因素。

      语法:
Ext.query(“[attribute^=value]”)

             Ext.query(“E[attribute^=value]”)  // E 为要素标记

    4.[attribute$=value]: 采取attribute 的属性值 value 结尾的要素

      语法:
Ext.query(“[attribute$=value]”)

            Ext.query(“E[attribute$=value]”)

    5.[attribute*=value] 选用 attribute 的属性值包涵 value 的因素

      语法:
Ext.query(“[attribute*=value]”)

        Ext.query(“E[attribute*=value]”)

    6.增选attribute 的属性值能整除 value 的成分

      语法:
Ext.query(“[attribute%= vale]”)

            Ext.query(“E[attribute%= vale]”)

    7.[attribute!=value]  接纳 attribute 的属性值不等于 value
的成分。

      语法:
Ext.query(“[attribute != vale]”)

          Ext.query(“E[attribute != vale]”)

css 属性值采用符

  伪拔取器

    1. first-child

        且其父节点的率先身长节点。

      语法:
Ext.query(“E: first-child”)

    2. last-child

    3.nth-child(n)

    4.nth-child(odd)

    5.nth-child(even)

    6.only-child

    7.checked

    8.first

    9.last

    10.nth(n)

    11.contains

    12.nodeValue

    13.not

    14.has

    15.next

    16.prev

    17.any(S1 | S2)

恢宏采用器

    使用Ext.get 获取成分

      语法:var el = Ext.get(id)

    数据交互。

      Reader 对象的配备项

      Reader
对象的布局决定了什么样从重返的数据中回到的数量中领到数额。

        1.idProperty
字符串,钦定那份字段为各个记录的绝无仅有标识字段。

        2.totalProperty
  从再次来到数据得到数据库记录总数的习性名称,专擅认同为total。

        3.successProperty   

        4.root

        5.messageProperty

        6.implicitIncludes

    数据模型

      数据模型的骨子——字段
Ext.data.Field

    数据集

      数据申明及错误处理

        模型的关系

        管理数据模型

        定义数据模型

        数据模型的概念进程

        数据模型的创始

        数据模型的布局项,属性和章程。

    Store

      定义类:

        定义三个stadent
的类; 在MyApp.student 命名空间。

          Ext.defne(“MyApp.student.Student”,{

              name: “tom”,

              sex: “box”,

              // 添加构造函数

        constructor: function(name,sex){

            if(name) {

                this.name= name

              }

            if(sex){

              this.sex= sex

            }

        }

      showInfo:function(){

        alert(“hello”+this.name+”sex”+this.sex)

      }

    })

 

  调用类

        // 开运营态加载

      Ext.Loader.setConfig({enabled:true});

        // 动态加载  My.App 命名空间 MyApp 目录

      Ext.Loader.setPath(“My.App”,”MyApp”)

        // 动态加载类。

      Ext.require(‘MyApp.student.Student’)

      Ext.onReady(function(){

        var student =
Ext.create(“MyApp.student.Student”,”lisi”,”girl”);

        student.showInfo();

      })

 

    加载三个类

      Ext.require({

          ’Ext.grid.*’,

          ’Ext.data.*’

          ’Ext.util.*’,

          ’Ext.grid.PaginScroller’

      })

      // 加载全数类 ,除了 Ext.data.* 所有类。

     Ext.exclude(‘Ext.data.*’).require(“*”);

  基本数据类型

     字符串类型,日期型,布尔等中央数据类类型。

      // 定义一个日期类型的数额。

    var datel = new Date(“2011-11-12”);

    var date = new Date(2011,11,12,12,1,12);

      // 转化为 字符串类型

     alert(date.toLocaleDateString());

      // 转化为数值类型

     alert(Number(data))

      // 转化为 布尔  假

    var myFalse = new Boolean(false);

      // 定义数值

    var num = new Number(45.6)

      alert(num)

 

  函数执行时间决定

    首要有五个地点1.让某些函数等待一段时间后自推行吗,

    有些函数按那必将的频率往往实践。

     1.等待函数执行,页面加载已毕等带 3秒后弹出提醒。

Eet.onReady(function(){

  var funcl = function(name1,name2){

    Ext.Msg.alert(“hello,”+name1+”+name2”)

  }

  Ext.defer(funcl,3000,this,[“zhangsan”,”lisi”]);

})

 

    2.让mydiv 各个1秒 更新一回

Ext.onReady(function() {

var i= 0;

var task = {

  run : function() {

    Ext.fly(‘mydiv’).update(new Date().toLocaleTimeString());

    if(i > 10)

    Ext.TaskManager.stop(task);

    i++;

    },

          interval: 1000

        }

      Ext.TaskManager.start(task);

    })

    页面上 <div
id=”mydiv”></div>

键盘事件监听

    1.Ext.KeyMap   简历键盘和用户动作之间的炫耀。

       Ext.getDoc  当前的document 集合

      Ext.onReady(function() {

        var f = function () {

          alert(“B 被按下”)

      }

      var map = new Ext.KeyMap(Ext.getDoc(), [

      {

        key: Ext.EventObject.B,

        fn: f

      },

      {

      key: “bc”,

      fn: function() {

        alert( alert(‘b c 其中3个被按下’))

      }

     },

    {

      key: “x”,

      ctrl: true,

      shift: true,

      alt: true

      fn: function () { alert(‘Control + shift + alt +
x组合按下’);},

      stopEvent: true

    },{

      key:’a’,

      ctrl: true

      fn:function () {

        alert(‘Control + A 全选事件被集团,自定义执行事件。’)

      },

        stopEvent: true

      }

    ])

  })

 

  Ext.KeyNav

      Ext.keyNav  紧假如用来绑定方向建的

var div1 = Ext.get(“div1);

    var nav = new Ext.KeyNav(Ext.getDoc(),{

      “left”: function (e) {

          div1.setXY([div1.getX() -1, div1.getY()]);

        },

      “right”: function (e) {

        div1.setXY([div1.getX() -1, div1.getY()]);

      },

      “up”: function (e) {

        div1.move(“up”,1);

      },

      “down”: function (e) {

        div1.moveTo([div1.getX() -1, div1.getY() + 1]);

    },

      ”enter”:function (e) {}

  })

   

  新的类库

    Ext.define(className, members, onClassCreated)

      className 要声明的类的名字

      members 二个目的,包含类成员

      onClassCreated
 贰个可选的回调函数,类创建好了后来,那么些函数会被调用

    例子:

Ext.define(‘My.sample.Person’, {

    name: ‘Unknown’,

    constructor: function(name) {

if(name) {

this.name = name

}

    },

  eat: function(foodType) {

    alert(this.name + ” this eating ” + foodType)

  }

})

var aaron = Ext.create(‘My.sample.Person’, ‘Aaron’)

aaron.eat(“Salad”)

继承

    Ext.namespace(“MyApp”);

    MyApp.MyWindow = Ext.extend(Ext.window,{

title: “Welcome!”,

initComponent: function() {

Ext.apply(this,{

items: [{

xtype: “textfield”,

name: “tfName”,

fieldLabel: Enter your name“

    }]

})

    MyApp.MyWindow.superclass.inotComponent.apply(this,argumemts)

  }

});

var win = new MyApp.Mywindow();

win.show();

 

Ext.define(“MyApp.MyWindow”,{

// 继承window

extend: “Ext.window”,

title: “Wecome”,

initComponent: function() {

this.items = [{

xtype: “textfild”,

name: “tfName”,

fieldLabel: “Enter your name”

}];

      // 把子类的总体传递过去。

      this.callParent(arguments)

      }

    })

  //  使用那个类

  var win = Ext.create(“MyApp.MyWindow”);

  //  突显出来

  win.show()

    (initComponent 开始化部件方法)

 

子类从父类继承

Ext.define(“Parent”,{

constructor: function(name){

this.name = name;

}

});

Ext.define(“Child”,{

extend: “Parent”,

constructor:function(name, sex){

this.sex = sex;

this.callParent([name]);

}

});

  var c = new Child(“John Huang”, “male”)

    或许 :  var c = Ext.create(“Child”,
“John Huang”, “male”)  // 提议选择实

例化对象

    console.log(c.name)

    console.log(c.sex)

 

  指出使用Ext.create
 实例化

Ext.onReady(function(){

Ext.define(“MyApp.Parent”,{

constructor: function(name){

this.name = name;

}

});

Ext.define(“MyApp.Child”,{

extend: “MyApp.Parent”,

constructor:function(name, sex){

this.sex = sex;

this.callParent([name]);

}

});

 var c = Ext.create(“MyApp.Child”, “John Huang”, “male”);

console.log(c.name)

console.log(c.sex)

  })

 

Configuration 配置 (实例成员)

  配置属性 config,
自动创造 setters 和 getters

    基本接纳办法:

Ext.define(“MyClass.A”,{

config: {

name: “tom”,

set: “mate”

age: 18

},

show: function() {

alert(this.config.name)

}

  });

var objA = Ext.create(“MyClass.A”);

objA.show();

objA.setName(“John”);

objA.show();

alert(objA.getName())

 

Ext.onReady(function(){

Ext.define(“MyClass.A”,{

config: {

name: “tom”,

set: “mate”

},

show: function() {

alert(this.config.name);

alert(this.config.set)

}

});

var objA = Ext.create(“MyClass.A”);

objA.show();

var name = a.getName();

alert(name);

objA.setName(“John”);

alert(objA.getName());

objA.setAge(11);

alert(a.getAge());

})

 

 

config 属性将为其特性自动抬高 setter 和  getter 函数。

  倘若想修改 setter
的表现,可以重写 apply 属性方法, 该措施为setter 的里边贯彻

   具体代码如下

Ext.define (“MyClass.A”,{

config: {

name: “John Huang”,

sex:”male”

},

applyName: function(val){

this.name = “dev” + val;

  },

show: function() {

console.log(this.name)

}

})

 

var a = Ext.create(“MyClass.A”);

a.setName(“John”);

console.show();  // 控制台结果: dev: 约翰

 

Ext.onReady(function(){

Ext.define(“MyClass.A”,{

config: {

name: “tom”,

set: “mate”,

age: 18

},

applyAge: function(val){

if(val < = 18){

alert(“对不起,您未成年, 系统拒绝访问”);

this.config.age = 18;

}else{

this.config.age = val;

}

  },

show: function() {

alert(this.config.name);

alert(this.config.set)

}

});

澳门美高梅手机网站,var objA = Ext.create(“MyClass.A”);

objA.show();

var name = a.getName();

alert(name);

objA.setName(“John”);

alert(objA.getName());

objA.setAge(11);

alert(a.getAge());

})

Ext.define(“MyClass.A”, {

conifg: {

name: “John Huamg”,

sex: “male”

},

applyName: function(val) {

this.name = “dev” + val;

    },

show: function() {

console.log(this.name);

}

  })

Ext.onReady(function(){

var a = Ext.create(“MyClass.A”);

a.setName(“John”);

a.show();   //  控制台结果为 dev: john

})

 

Ext.onReady(function(){

var a = Ext.create(“MyClass.A”);

console.log(a.config.name);  // john Huang

console.log(a.name);  // undefined

console.log(a.getName);  // dev: John Huang

console.log(a.name); // dev: John Huang

console.log(a.config.name); //  John Huang

})

getName 内部贯彻第四回调用和第n 此调用时分化的

    第二回调用时 getName
方法时内部贯彻步骤如下 :

  1. 检测对象是否有name 属性,有则举办步骤2 ,无责执行步骤3,

2.回到name 属性,并跟新中间贯彻。

3.以config.name 为参数执行 applyName 函数,因为applyName

函数具体无 this.name = ….,
就会添加 name 属性到目的中,

下一场更新内部贯彻(若
applyName 函数 体无 this.name=…

的语句,那么getName
方法内部如下:

function() { retrun this [q];},直接回到对象的质量。)

setter 和 getter  是将 config 的成员属性复制当前类的分子属性,

下一场对成员属性进后续操作。

由此我在重写 applyName
时候要专注遵从原则

 不要涂改 config
的积极分子属性值

而在类内部成员函数中做客config
的积极分子属性如下

Ext.define(“MyClass.A”,function() {

config: {

name: “John Huang”,

sex: “male”

},

showName: function()
{

var  name = this.name
|| 

this.config.name;  

},

updateName:function(val){

this.name = val

})

 

重组属性:

可用于完成多延续,该属性可以协同格局加载类文件,并实例化类。

骨干用法:

Ext.define(“MyClass.A”,{

showA: function() {

console.log(“A”)

}

});

Ext.define(“MyClass.B”, {

showB: function() {

  consle.log(“B”)

}

})

 

Ext.define(“MyClass.C”,{

mixins: {

classA: “MyClass.A”,

classB: “MyClass.B”

},

showC: function() {

console.log(“C”)

}

})

 

var objC = Ext.create(“MyClass.C”);

objC.showA();  // A

objC.showB();  // B

objC.showC();  // C

 

艺术同名时

三个mixins 类拥有同名函数

Ext.define(“MyClass.A”,{

show: function() {

console.log(“A”)

}

});

Ext.define(“MyClass.B”,{

show: function() {

console.log(“B”)

}

});

 

Ext.define(“MyClass.C”,{

mixins: {

classA: “MyClass.A”,

ClassB: “MyClass.B”

}

});

var objC = Ext.create(“MyClass.C”);

objC.show();   // A

mixins 中后者的方式无法覆盖前者的同名方法。

方式的调用坚守近日事先条件,优先级别顺序从高到底——当前类,

父类, mixins 类

  当前类引用mixins
类成员。

Ext.define(“MyClass”,{

show: function() {

console.log(“A”)

}

});

Ext.define(“MyClass.c”,{

mixins: {

dassA: “MyClass.A”

},

alert: function() {

this.mixins.classA.show();

  }

})

var ObjC = Ext.create(“MyClass.C”);

objC.alert();   // A

 

类的静态成员属性(statics)

    可以通过Ext.Class.statics
属性来设置类的静态成员。

Ext.define(“A”,{

statics: {

count: 0,

appName: “A”

},

constructor: function() {

return this.statics().count;

},

getCount: function() {

return this.statics().count;

    },

getAppName: function () {

return this.self.appName;

}

   })

 

var a  = Ext.create(“A”);

a.getCount();   // 1

a.getAppName(); // A

A.count; // 1

A.appName; A

 

概念内部不可能利用this.statics,成员名
的办法访问静态成员,而是要拔取this.self

 静态成员名, 或 this.statics(), 静态成员名。

类定义外部使用“类名静态成员”,来访问静态成员。

 

 

MVC

Ext.application({

requires: [‘Ext.container.Viewport’],

name: ‘FWY’  // 全局的名字 一般按照项目

appFolder : ‘app’, // 动态加载js文件夹

lauch: function() {

Ext.create(‘Ext.container.Viewport’,{

layout: “fit”,

item: [{

xtype: ‘panel’,

title: “标题”,

html:”内容”

}]

  })

}})

 

 

controller model store view

controller  作为连续model store 和 view 的大桥, 在mvc 开发情势中

起了重点的法力。如若说model
定义了数量方式, store 提供了数码

读取的办法, view
用来突显数据,那么controller 将用来支配具体的

数量操作。

 

Application.js 文件

1.name : 应用程序名称  自定义的

2.appFolder 应用程序的目录,用来举办动态加载代码的。

3.controllers 应用程序使用到的控制器。

4.autoCreateViewport 是或不是自动成立 Viewport,暗许为flase ,设置为 true

应用程序自动成立Viewport
,那些Viewport 的概念在我的们的app/

view/viewport.js 中;若是为false 的时候,作者要在launch
中吸收创建应用视图。

Viewport.js 的定义

Viewport 作为大家应用程序的视图模板,可以被单个定义在Viewport.js 文件中

它定义的很简短,常常用来将二个依然两个view
作为它的子控件。

 

 

 

store  作为数据仓库, store 起到了多少存取的成效, grid, form 等

表现的数量是因而store
来提供的

controller 层

 

alias: ‘widget.创设别名

 

initComonent: function () {

    

}’

      demo
下载 https://github.com/ningmengxs/Extjs.git

发表评论

电子邮件地址不会被公开。 必填项已用*标注