import akka.actor.{ ActorRef, ActorSystem, Props, Actor, Inbox }
import scala.concurrent.duration._

// Three messages, one is object, two are case classes
case object Greet
case class WhoToGreet(who: String)
case class Greeting(message: String)

class Greeter extends Actor {
  var greeting = ""

  def receive = {
    case WhoToGreet(who) => greeting = s"hello, $who"
    case Greet           => sender ! Greeting(greeting)
    // Send the current greeting back to the sender
  }
}

object HelloAkkaScala extends App {

  // Create the 'helloakka' actor system
  val system = ActorSystem("helloakka")

  // Create the 'greeter' actor
  val greeter = system.actorOf(Props[Greeter], "greeter")

  // Create an "actor-in-a-box"
  val inbox = Inbox.create(system)

  // Tell the 'greeter' to change its 'greeting' message
  greeter.tell(WhoToGreet("akka"), ActorRef.noSender)
  // Ask the 'greeter for the latest 'greeting'
  // Reply should go to the "actor-in-a-box"
  inbox.send(greeter, Greet)

  // Wait 5 seconds for the reply with the 'greeting' message
  val Greeting(message1) = inbox.receive(5.seconds)
  println(s"Greeting: $message1")

  // Change the greeting and ask for it again
  greeter.tell(WhoToGreet("typesafe"), ActorRef.noSender)
  inbox.send(greeter, Greet)
  val Greeting(message2) = inbox.receive(5.seconds)
  println(s"Greeting: $message2")

  val greetPrinter = system.actorOf(Props[GreetPrinter])
  // after zero seconds, send a Greet message every second to the greeter with a sender of the greetPrinter
  system.scheduler.schedule(0.seconds, 1.second, greeter, Greet)(system.dispatcher, greetPrinter)

}

// prints a greeting
class GreetPrinter extends Actor {
  def receive = {
    case Greeting(message) => println(message)
  }
}

• Sending messages
  1. actor ! message or actor.tell(message, sender).
  2. inbox.send(sender, message)
  3. system.scheduler.schedule(initDelay, interval, receiver, message)(executor, sender)
  4. actor ? message, it means “ask”, which resturns a Future representing a possible reply. When you implement ask function, you have to catch the exception and send a Failure to the sender

     try {
       val result = operation()
       sender() ! result
     } catch {
       case e: Exception =>
         sender() ! akka.actor.Status.Failure(e)
         throw e
     }
     

     You can set a timeout period for the Future by implicit value implicit val timeout = Timeout(5 seconds) or using curry function myActor.ask(msg)(5 seconds).

• Receiving messages
  1. receive defined method in actor will be called when message comes. Attention:, the sender() method returns the current sender when the method is called, DO NOT use this function in callbacks since the sender method may returns wrong sender (deadletter in many cases) when the callback is actually invoked.
  2. inbox.receive
  3. Set timeout period for receiving method, context.setReceiveTimeout(30 milliseconds). Then you can catch this event by receiving message case ReceiveTimeout.
• Forward message target forward message, it will keep the sender unchanged. A send msg to B, B forward msg to C, the sender for C is still A instead of B
• Stop actor akka.actor.PoisonPill message will stop the actor. gracefulStop is useful to wait for termination or compose ordered termination of several actors. It is a pattern, not precoded, it sends a user defined message to the actor and returns a Future, you can Await this future for a duration.

  actor ! Kill will also stop this actor, but it causes the actor to throw a ActorKilledException. This actor will suspend and like the supervisor to decide how to handle the failure.

• Become/Unbecome context.become method in Actor can setting the receive function, hence the behavior of Actor is changed. unbecome lets the actor returns to previews behavior.

  You can use stash and unstash to save mails into a queue in one behavior and get them back in another behavior. Of course, you have to mix the trait Stash to be able to use it.

• Extend actor and intialization patterns Use PartialFunction#orElse to chain the receive function of the extended actor.

  Three init patterns

  1. constructor
  2. preStart
  3. Message

Generally, we use maven to manage the directory layout. Hence, you will get a standard directory layout like below:

project
    src
        main
            java
            [scala]
            resources
                environment.properties
                environment.test.properties
                environment.prod.properties
                config
                    application.yml
                    application-dev.yml
                    application-[profile].yml
                [other]
        test
            java
            [scala]
    target

The files environment.[profile].properties are used to provide different profiles to maven.

Since maven is used to manage the package dependencies, different maven profiles enables you to use different dependencies for development and production, e.g. run different tasks. I am not farmiliar with maven, and cannot tell how and when it can be used.

You have to add spring-boot-maven-plugin as one of the plugins under build node in pom.xml.

• Development
  • Compile the project by maven clean insatll
  • More than Build

    Maven can help running test, web application and produceing reports by plugins. TODO

  • Compile and run: mvn spring-boot:run to run the application with default profile; mvn -Pprod spring-boot:run to run the application with prod profile.
• Production
  • Package the files
    • Jar file. Run mvn clean package to build the jar file and run it through command line.
    • War file. Add <packaging>war</packaging> in pom.xml file, under the root node. Then run mvn package as building the jar file.
  • Deploy

From command line, you can run the jar file with specification of profile.

java -jar -Dspring.profiles.active=production YOUR_JAR.jar

The files application-[profile].yml are used to provide different configurations for spring.

Spring configuration files let you to inject different configurations for development and production. For example, you can use different database for development and production (different host, port, username and password, etc.).

It is mainly implemented by HttpSecurity, which can be injected and configured in method of class that extends WebSecurityConfigurerAdapter.

public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Inject
    private UserDetailsService userDetailsService;
    // class access to the user database

    @Value("${drill.security.rememberme.key}")
    private String remerberMeKey;
    // key for cookies

    @Inject
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .userDetailsService(userDetailsService) // the point that connect the authentication module and user database
            .passwordEncoder(passwordEncoder());
    }

    @Override
    public void configure(WebSecurity web) throws Exception {
        // Spring security ignore following URL
        web.ignoring()
            .antMatchers("/bower_components/**")
            .antMatchers("/fonts/**")
            .antMatchers("/images/**")
            ...;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/app/**").authenticated()
                .antMatchers("/app/rest/register").permitAll()
                .antMatchers("/app/rest/logs/**").hasAuthority(Authority.ADMIN)
                // set authorities
            .and()
                .formLogin()
                .usernameParameter("username")
                .passwordParameter("password")
                .loginProcessingUrl("/app/authentication")
                .successHandler(ajaxAuthenticationSuccessHandler)
                .failureHandler(ajaxAuthenticationFailureHandler)
                .permitAll()
                // set login service url
            .and()
                .logout()
                .logoutUrl("/app/logout")
                .logoutSuccessHandler(ajaxLogoutSuccessHandler)
                .deleteCookies("JSESSIONID")
                .permitAll()
            .and()
                .exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPoint)
            .and()
                .rememberMe()
                .rememberMeServices(rememberMeServices)
                // it is not persistent token
                .key(remerberMeKey)
            .and()
                .csrf().disable()  // not clear
                .headers().cacheControl(); // not clear
    }
}

The foundation of user securing is about session and cookies. Once the user logged in, the server will set the cookies in browser. Then browser will send the cookies via HTTP protocol everytime it send new request to the server. On the server side, session is also kept with a unique random id to identify the client. Look another blog Init the project to see how to replace the in memory user store by a repository that connects to database. On the server side, programmer can get the user information by:

public static String getCurrentLogin() {
    SecurityContext securityContext = SecurityContextHolder.getContext();
    Authentication authentication = securityContext.getAuthentication();
    UserDetails springSecurityUser = null;
    String userName = null;

    if(authentication != null) {
        if (authentication.getPrincipal() instanceof UserDetails) {
            springSecurityUser = (UserDetails) authentication.getPrincipal();
            userName = springSecurityUser.getUsername();
        } else if (authentication.getPrincipal() instanceof String) {
            userName = (String) authentication.getPrincipal();
        }
    }

    return userName;
}

This example uses WebMvc framework, which uses WebMvcConfigurerAdapter and ViewControllerRegistry to connect the urls and html templates.

Add spring-boot-starter-security into dependency, make WebSecurityConfig.java.

@Configuration
@EnableWebMvcSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }

    @Autowired
    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
        // user repository in memory with username = "user" and password = "password"
        // it is just for demon
    }
}

Maven projects are defined with an XML file named pom.xml. This file gives the project’s name, version, and dependencies that it has on external libraries. Here is an example.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springframework</groupId>
    <artifactId>gs-maven</artifactId>
    <packaging>jar</packaging>
    <version>0.1.0</version>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                    implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>hello.HelloWorld</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

• <modelVerion> POM model version
• <groupId> Domain name of the group or organization.
• <artifactId> Name to the project’s library artifact (name of JAR file)
• <version> Version of the project
• <packaging> How it should be packaged (in JAR or WAR file)

mvn compile
mvn package
mvn install

The first command compiles the project, and the .classfiles shold be in the target/classes directory. The second command compile the code, run tests and finish by packaging the code up in a JAR file in the target directory. Tht third command does the same thing as the second command, then copy the JAR file into the local dependency repository, under the directories with name of groupId, artifactId and version. So on my machine, its location is ~/.m2/repository/org/springframework/gs-maven/0.1.0/gs-maven-0.1.0.jar.

Add dependencies of project into the pom.xml file, in the <project> element.

<dependencies>
     <dependency>
         <groupId>joda-time</groupId>
         <artifactId>joda-time</artifactId>
         <version>2.2</version>
     </dependency>
 </dependencies>

This description will tell the maven to get the joda-time package as external library. You can specify a <scope> element to specify if the dependencies are required for compiling the code but will be provided during runtime by provided; or decalre the dependencies are only necessary for compiling and running tests.

When I compile the command, maven downloads the joda-time pakcage from https://repo.maven.apache.org/maven2/joda-time/. Does the maven use its domain when the group id does not contain the domain by default?

You can also create a project from scratch

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

mvn scala:console can launch the scala console with the pom configurations (you have to specify maven-scala-plugin).

Honestly, I don’t understand it. But I collect my thoughts about it here. First, the monda is used to chain operations and if the first (preceding) operation fails, the whole chain stops. An example that I understand is the usage of for-expression with pattern match. If the pattern matches, go next operation, else skip this element.

Another point of view is about the unit operation. A monad flatMap with its unit operation will return the monad itself.

My conclusion:

A monad is a container that supports operation chain and follows the monad laws. The basic operations of this container are flatMap and unit, where flatMap actually accepts a function that maps each element to a container, then binds these containers together; unit returns a container given an element. Monad laws guarantee the reliability of operation chain on these contains.

Monad seems like a design pattern that enables the operation chain along with pattern match in functional programming. Because flatMap chain with different functions is equivalent to nested flatMap, the for-expression is a syntax sugar based on flatMap chain. The advantage of this design pattern is avoding side effect.

Generator is created by yield as well as for-expression. Pay attention, there is no generator class/type/trait. The genrator created through for-expression has the same type of the sequence/iterator/stream used in for-expression. That proves the for-expression is a syntax sugar of monad types. So, guess what will happen when we create a for-expression using both list and stream?

val fibo:Stream[Int] = 1 #:: 1 #:: fibo.zip(fibo.tail).map(x=>x._1+x._2)
val l = List(1,2,3,4,5)
val lsg = for{x <- l; fib <- fibo} yield (x,fib)// infinite loop, crash the software/your machine
val slg = for{fib <- fibo; x <- l} yield (x,fib)// return a stream

Following the definition of Monad, the first mixture lsg actually makes l flatMap (x => fibo), which returns a List that tries to expand infinite stream fibo, hence block your machine. The second mixture slg returns a Stream that expand the list l, hence, works well. Besides, I have to clarify one thing: different monads demonstrated above all accept GenTraversableOnce as parameter and return monad of their own type. That is why they can be mixed together and the first expression decides the type of the final output of for-expression.

In the example provided by the oneline course, they used JUnit, ScalaTest and ScalaCheck together. In their example, the class of Properties is in src/main/scala and is called by another class defined under src/test/scala. In the class under test folder, many instances of the Properties class are created to check different children classes of the target class.

abstract class QuickCheckHeap extends Properties("Heap") with IntHeap {

  property("min1") = forAll { a: Int =>
    val h = insert(a, empty)
    findMin(h) == a
  }

  lazy val genHeap: Gen[H] = for {
    a <- arbitrary[Int]
    h <- oneOf(value(empty), genHeap)
  } yield insert(a, h)

  implicit lazy val arbHeap: Arbitrary[H] = Arbitrary(genHeap)

}

@RunWith(classOf[JUnitRunner])
class QuickCheckSuite extends FunSuite with Checkers {
  def checkBogus(p: Prop) {
    var ok = false
    try {
      check(p)
    } catch {
      case e: TestFailedException =>
        ok = true
    }
    assert(ok, "A bogus heap should NOT satisfy all properties. Try to find the bug!")
  }
  test("Binomial heap satisfies properties.") {
    check(new QuickCheckHeap with BinomialHeap)
  }
  test("Bogus (1) binomial heap does not satisfy properties.") {
    checkBogus(new QuickCheckHeap with Bogus1BinomialHeap)
  }
  test("Bogus (2) binomial heap does not satisfy properties.") {
    checkBogus(new QuickCheckHeap with Bogus2BinomialHeap)
  }
  test("Bogus (3) binomial heap does not satisfy properties.") {
    checkBogus(new QuickCheckHeap with Bogus3BinomialHeap)
  }
  test("Bogus (4) binomial heap does not satisfy properties.") {
    checkBogus(new QuickCheckHeap with Bogus4BinomialHeap)
  }
  test("Bogus (5) binomial heap does not satisfy properties.") {
    checkBogus(new QuickCheckHeap with Bogus5BinomialHeap)
  }
}

Fully qualified name of project is “<groupId>:<artifactId>:<version>”. If groupId is a domain, it will be transformed into directory path while downloading. Download something with groupId=org.X.A from url.com will download things from url.com/org/X/A in the end.

When we have two projects, A and B, A is supposed to be parent project of B. You have to specify the pom.xml of project B to indicate that the parent of B is A with the groupId, artifactId and version of A. You can remove the groupId and version of B to make A and B have the same /groupId and version. One can also indicate the <relativePath> for parent project to put the A and B in the same directory level.

B inherite the dependencies from A.所以parent用来继承POM,dependency 用来解决代码依赖. parent的项目在代码上没有关系.

The packages downloaded by maven are put under HOME.m2/repository/.

所有 POM.xml 里面的元素都可以用 ${project.A.B.C} 的方式进行引用.比 方说如果在 XML 根路径下有这样的结构 <A><B>lalala<C>blabla<C/></B></A>, ${project.A.B.C} 就等于 blabla.

首先,maven可以使用一系列的plugin来支持各种功能,包括发布,运行测试等 等.在使用 spring-boot-maven-plugin 的时候,可以用 mvn spring-boot:run 来运行程序. spring-boot 应该是plugin的名字, run 则是定义好的task. 在使用 maven-scala-plugin 的时候,如果加入以下设 置

<executions>
    <execution>
        <goals>
            <goal>compile</goal>
            <goal>testCompile</goal>
        </goals>
    </execution>
</executions>

运行 mvn scala:testCompile 则只会编译test部分的代码.

• function is value,

  val f = (x:Int) => x*x
  

  One difference between def f = ... and val f = ... is: def is evaluated on call and returns a new function instance every time.

  val test: () => Int = {
      println("val")
      val r = util.Random.nextInt
      () => r
  }
  // returns the same result every time you call test(),
  // "val" will be printed after definition
  
  def test: () => Int = {
      println("def")
      val r = util.Random.nextInt
      () => r
  }
  // returns the difference results every time you call test(),
  // "def" will be printed every time you call it.
  
  val tt = test
  // acts like the first example
  
  val test = () => util.Random.nextInt
  def test = () => util.Random.nextInt
  // they are the same from behavior, you have to call the function by test()
  // the def declaration actually defined a function that returns a function.
  // if you type test without parenthesis, you will receive a function value.
  
  def test = util.Random.nextInt
  // this line directly assign the test function to the nextInt function,
  // you can call the function directly by name without the parenthesis
  

  method/expression starts by def will be evaluated when you call obj.f while those starts by val will be evaluated once. In addition, if you declare a val that assigns to def, the def will be evaluated immediately, and the new val acts like the first case in the examples above.

• Abbreviation:

  val l = List(1,2,3)
  l.map((x) => x*x)
  l.map( x => x*x) // ignore the parenthese
  l.map( _ % 2 == 0) // ignore the parameter, using the placeholder for expression
  l.map(f(_)) // using the placeholder for function
  l.map(f) // ignore the placeholder for function
  

abstract class is like Java, trait is like interface in Java. However, trait can have parameters and defined methods. In addition, trait is not abstract class since it cannot has constructors.

• Logical problem: is List<Parent> the parent of List<Childe>?

  It is not true for mutable collection.

  var s = new Array[Man](new Man())
  var t:Array[Human] = s
  t[0] = new Woman()
  var m:Man = s[0]// what is it? man or woman?
  

  But we can use imutable collection.

• Covariant, Contvariant, Invariant
  • Covariant: defined by Class<+T>, Class<Parent> is the parent of Class<Child>
  • Contvariant: defined by Class<-T>, Function<Parent> is the child of Function<Child>

  The principle is: child type can do anything that can be done by parent type.

• Check Rules and Boundary

  To avoid conflict, the compile force the +T can only be used for returned type, the -T can only be used for argument type. A method to by pass this problem is using boundary.

  class List<+T>{
       def prepend[U >: T](U elem)
  }
  

  Notice that in generic type definition, one can use A>:B and A<:B to add constraint to the meta type.

Case class enables you to make classes with different parameters

abstract class CodeTree
case class Fork(left: CodeTree, right: CodeTree, chars: List[Char], weight: Int) extends CodeTree
case class Leaf(char: Char, weight: Int) extends CodeTree

For the classes listed above, you cannot directly access to any paramter (field) of Fork or Leaf. You have to use case Fork(a,b,_,_) to access to the paramters.

case match can also be used in lambda function as a short version.

List.map(p => p._1 * p._2)

List.map({case (x,y) => x * y})
//List.map{case (x,y) => x * y} also works

Option calsss used for the condition that the returned type can be empty/null, etc.

If you want to match a variable in context, you have to weither use a capitalized variable name Variable or wrap it by backticks `variable`.

• List is a chain while Vector is a tree that each node is an array that contains 32 elements. Vector groups in depth slowly log_{32}(N). Important functions: map, filter, reduceRight, reduceLeft, foldRight, foldLeft, flatten, flatMap, take, drop, takeWhile, =dropWhile, span, group, groupBy.

  Sequence as parameter list is represented by this(par: T*).

• Map.
  • The + and ++ operations overwrite the existing key.
  • Initialized by Map(k1->v1, k2->v2, k3->v3)
  • Set default value by withDefaultValue, this function returns a new map (everything in this course are immutable).

Two-phase commits is used to update multiple documents as a fake atomic operation. The principle of two-phase commits is creating temporary, inter-media records to support rollback operations

The first method is adding a label to indicate the current accessing application.

The second method is using the old value of files to update as a part of query to ensure that the target fields of current document is not updated.

var myDoc = db.COLLECTION.findOne(condition);
if(myDoc){
   var oldValue = myDoc.value;
   var results = db.COLLECTION.update(
       {
           _id: myDoc._id,
           value: oldValue
       },
       {
           $inc:{value: -fee}
       }
       )
}

Another possible option is: if you want to deduct an amount of money from an account and the rest money should not be negative, you can use following commands:

db.COLLECTION.update({_id: id, value: {$gte: fee}}, {$inc:{value: -fee}})

It means the account will be updated only if the value is enough.

The third method is add an unique field (version) to the document.

db.COLLECTION.insert(doc/docs)

You can insert one document or a list of documents. When you insert a list of documents, the operation is not atomic. The returned result shows the statistics of the write operations including the write errors and the number of successfully inserted documents.

db.COLLECTION.find({name: value, 'name1.name2.name3':value/condition})

Check all the elements in array when ‘name#’ corresponds to array. Special conditions

• $in, $ne, $nin, $lt, $gt, $lte, $gte
• $and, $or, $not, $nor
• $exists, $type
• $regex, $text, $where, $mod
• $all, $elemMatch, $size
• $, $slice

Difference between with/without $elemMatch is that: $elemMatch restrict that one element in array should match all the conditions, while without $elemMatch, different elements in the array can match different part of the conditions.

Match element / array can be done by query {name: value} when value is a single variable/object or an array.

Elements in array can be retrieved by index db.COLLECTION.find({'name.0': value}).

• get attribute

  db.COLLECTION.find(***, {name:1})
  

• get elements in array

  db.COLLECTION.find(***, {'name1.name2':1})
  

  This projection will returns all the elments with the path ‘name1.name2’ when any one in the path represents an array.

  db.COLLECTION.find(***, {name1: {$elemMatch: {name2:value}}})
  

  $elemMatch can be used in the second argument to limit the returned elements in array. However, it CANNOT be used in nested array and only returns the FIRST element.

• get elements in nested array.

  Aggregation framework/unwind. Aggregations are operations that process data records and return computed results. Pipeline

  You can expand the nested arrays by several $unwind operations to get a large number of documents that each one contains a single combination of elements in different levels of nested arrays. Then match the elements you need and maybe regroup them together. However, if you want to aggregate the matched elements in nested arrays into array after $unwind operation, it is very complex.

  However, you can just return the tasks by $group operation that matches, for example, the nested element attributes.

• update attribute:

  db.COLLECTION.update(find condition, {$set: {name: value}})
  

  $inc increase number, etc. upsert will insert element when it does not exist in collection.

• update array:

  db.COLLECTION.update(find condition, {$push/$pull: value})
  

  db.students.update(
    { _id: 1 },
    {
    $push: {
            scores: {
               $each: [ { attempt: 3, score: 7 }, { attempt: 4, score: 4 } ],
               $sort: { score: 1 },
               $slice: -3
            }
    }
  
  })
  

  The command above append 2 elements, then sort them by ascending score, then keep the last 3 elements of the ordered array.

• update element in array:

  db.COLLECTION.update({"name1.name2":value}, {$set:{'name1.$.name2:value}})
  

  It only works for one match.

  If you want to update multiple elments, use forEach function.

  db.Projects.find().forEach(
      function(pj){
          pj.groups.forEach(
              function(gp){
                  gp.tasks.forEach(
                      function(task){
                          if (task.name.match(/update/)){
                              task.weight=5;
                          }
                      });
              });
          db.Projects.save(pj);
      }
  )
  

• update element in nested array.

  Impossible for only one query. The issue is reported on 2010, but is still there on 2015…

Functional key words:

• $currentDate, $inc, $max, $min, $mul, $rename, $setOnInsert, $set, $unset
• $, $addToSet, $pop, $pullAll, $pull, $pushAll, $push
• $each, $position, $slice, $sort

• remove document

  db.COLLECTION.remove(condition)
  

  remove all documents when condition is not provided.

• remove colleciton

  db.COLLECTION.drop()
  

• remove database

  use DATABASE
  db.dropDatabase()
  

• remove attribute

  db.COLLECTION.update(find, {$unset: {name: value}})
  

  value can be 1, “”, true/false.

• remove element in array

  db.COLLECTION.update({"name1.name2":value}, {$unset:{'name1.$.name2':1}})
  

show dbs use DB show collection help db.help() db.COLLECTION.help()

• count() // count of documents returned in a curcor
• explain() // report
• hint() // Forces MongoDB to use a specific index for a query
• limit() // constraints size of returned results
• skip() // skip the first number of documents
• sort()
• toArray()

db.COLLECTION.mapReduce(mapFunction,
                        reduceFunction,
                        {
                            query: "query performed at the beginning",
                            out: "out collection name",
                            finalize: finalizeFunction
                        })

Query -> map -> reduce -> finalize -> out.

• The reduce function muse return object with the same type of the output of the map function.
• The order of emited elements should not affect the output of reduce function.
• The reduce function must be Idempotent, which means f(f(x))=f(x).

Node.js 是一个JavaScript的平台,它提供了一个脱离浏览器的JavaScript运 行环境,同时也提供了一系列运行库和各种包. npm(nodejs package manager)则是这各平台的包管理系统.它通过读取package.json文件来安装项 目所需的依赖(就跟maven的pom.xml一样).

bower ,是nodejs之中的一个组件,本身用来专门管理前端开发所需要的包 (JavaScript,CSS).它与npm的区别在于管理对象的不同以及bower使用的是扁 平化的依赖关系而npm使用树形依赖.bower读取bower.json来安装依赖.

yoeman , 安装时叫做 yo,是一个用来创建项目骨架的工具.它根据 yeoman-generator,也就是模板来创建文件架结构.模板需要用npm来安装,比 方说

npm install -g generator-gulp-angular

模板名字以 generator 开头. 使用时运行

mkdir [app-name] && cd $_
yo gulp-angular [app-name]

来生成一个以generator-gulp-angular为模板的项目骨架,项目名字为 [app-name]. 就刚刚使用的这个模板为例,它在创建的时候会询问你需要什 么样的angular版本,哪一种CSS样式库(bootstrap, material),哪种angular 的实现方式(angular-strap),等等.

grunt / gulp 用来运行打包,压缩,发布等任务.在刚刚的例子中,我们使 用的是基于gulp的模板,所以要用gulp来运行以上任务.生成模板的事后,已经 在项目目录下建立了一个名为gulp的目录以及一个叫做gulpfile.js的文 件.gulp目录下面包含一系列js文件. gulpfile.js里面引入gulp库,定义一些 目录(src)的路径,并引入gulp目录,从而使得gulp目录下的js文件被gulp用来 进行相应的操作.这个模板的github说明上还指出一系列可选的特性,但是目 前看不出来在哪里定义的.

• Javascript
  • AngularJS
  • UI-Route
• UI Framework
  • Bootstrap
  • Angular Material
• CSS Preprocessor
  • Sass(Node.js)
  • Less
• JS Preprocessor
  • ES6
  • TypeScript
  • CoffeeScript
  • AtScript
• HTML template
  • .jade
  • .haml