What is String class

1) String is part of java.lang package. 2) String is a group of characters. "Hello" Important Point1: 3) String is immutable. Non changeable. If we create any string object, we can't modify it's value. But if we try to make any changes, new string will be created with new changes. Ex: String str = new String("Hello"); //Object1: "Hello" str.concat(" World!");//Object2: "Hello World!" no reference variable. eligible for garbage collection. System.out.println(str);//Print object1 StringBuffer is another class from java.lang package. Mutable: We can perform any change in the existing object. 4) StringBuffer stringBuffer = new StringBuffer("Hello");//Object1 stringBuffer.append(" World!");//Object1 stringBuffer reference variable pointing to "Hello World!" System.out.println(stringBuffer);//Print object1 "Hello World!" Important Point2: 5) String str1=new String("Hello"); String str2=new String("Hello"); System.out.println(str1 == str2); //False Reference comparison System.out.println(str1.equals(str2))//True Content comparison; 6) StringBuffer str1=new StringBuffer("Hello"); StringBuffer str2=new StringBuffer("Hello"); System.out.println(str1 == str2); //False Reference comparison System.out.println(str1.equals(str2))//False Reference comparison; Important Point3: Two ways to create string: String str1=new String("Hello"); //Two Objects will be created. one in HEAP and one in String common pool String str2="Hello"; //one object will be created in SCP JVM will check with the required content object is already there in SCP or not. if it's missing then only it makes entry in scp. GC is not allowed to access SCP. All entries will be removed only when JVM shutdown. SCP resides in method area. Important Point4: String str1=new String("Hello"); String str2=new String("Hello"); String str3="Hello"; String str4="Hello"; Only one entry in SCP. Two objects in heap. String str = new String("Spring");//Heap: Object(Spring) SCP: Spring str.concat("Summer");//Heap: Object(Spring),Object(Spring Summer) SCP: Spring,Summer String str2 = str.concat("Winter");//Heap: str->Object(Spring),Object(Spring Summer),str2->Object(Spring Winter) SCP: Spring,Summer,Winter str = str.concat(" Fall");//Heap: Object(Spring),str->Object(Spring Fall),Object(Spring Summer),str2->Object(Spring Winter) SCP: Spring,Summer,Winter,Fall

Java class skeleton and basic definations

Source File: filename.java to compile: javac filename.java -> after compilation filename.class [byte code] to execute: java filename Package Statement[optional] //syntax: package array import statements;[optional] //only when we are importing class from diff //package //Class Declaration: [Access Modifiers(public/default)] [Non Access Modiferes(Abstract/final)] class ClassName extends super class/implements interface { //Variables Section -> Reference variables(classname)/Primitive //variables(int,char,long,double,float,short,boolean and byte) 1) //instance Variables -> [Access modifiers(public/private/protected/default)] [final] type variableName; 2) //class variables/static variables just like instance variables but with static word : one common copy for all objects [Access Modifers] static [final] type variableName; //Constructor -> Method with No return type, class name as method name [AccessModifers(public/default/private/protected)]ClassName(type parameterName) { //initialize instance variables } //Instance Methods [AccessModifers(public/private/default/protected)] [final/abstract/synchronized] returntype methodName(type parameterName) { //logic } //Class method/static method: object is not required [AccessModifers(public/private/default/protected)] static returntype methodName(type parameterName) { //logic } // method ends }//class ends Object Creation: ClassName referenceVariableName = new ClassName([parameters]); // single line comments /*multiple line comments */ A Java program is mostly a collection of objects talking to other objects by invoking each other's methods. Every object is of a certain type, and that type is defined by a class or an interface. Most Java programs use a collection of objects of many different types. Class: A template that describes the kinds of state and behavior that objects of its type support. ■ Object At runtime, when the Java Virtual Machine (JVM) encounters the new keyword, it will use the appropriate class to make an object which is an instance of that class. That object will have its own state, and access to all of the behaviors defined by its class. ■ State (instance variables) Each object (instance of a class) will have its own unique set of instance variables as defined in the class. Collectively, the values assigned to an object's instance variables make up the object's state. ■ Behavior (methods) When a programmer creates a class, she creates meth- ods for that class. Methods are where the class' logic is stored. Methods are where the real work gets done. They are where algorithms get executed, and data gets manipulated.

Thread Pools

Java [Thread Pool] [Executor]: Manages pool of worker threads + contains a [queue] that keeps tasks waiting to get executed.

1) We add [Runnable] tasks to queue. From there, executor picks one task and assign to worker thread which is free.
2) Java.util.concurrent.Executor(interface) --> Java.util.concurrent.Executors(implementation).
   We use this implementation to create thread pool in java.


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleThreadPool
{
public static void main(String args[])
{
//Worker threads are five
// Executor(main interface) --> ExecutorService (impl) --> ThreadPoolExecutor;
ExecutorService executor = Executors.newFixedThreadPool(5);
//But submitting 10. so 5 tasks will end up in queue untill worker threads are free
//Task assignment will be taken care by pool.
for(int i=0;i<10;i++)
{
//Submitting runnable tasks
Runnable runnable = new WorkerThread(""+i);
// There is a submit method to get future object. async mode. can be used when u required to read results.
executor.execute(runnable);
}
//java app  will never end untill non-deamon threads are terminated.

executor.shutdown();
//Blocking main thread untill pool terminates.
while(!executor.isTerminated())
{

}
System.out.println("Finished all threads");
}
}


public class WorkerThread implements Runnable
{
  String command;

  WorkerThread(String command)
  {
    this.command = command;
  }

  @Override
  public void run()
  {
  System.out.println(Thread.currentThread().getName()+" Start. command = "+command);
  processCommand();
  System.out.println(Thread.currentThread().getName()+" End.");
  }
 
  private void processCommand()
  {
    try
    {
    Thread.sleep(1000);
    }
    catch(InterruptedException e)
    {
    e.printStackTrace();
    }
  }

  @Override
  public String toString()
  {
    return this.command;
  }
}

Output:
*************************************
pool-1-thread-2 Start. command = 1
pool-1-thread-5 Start. command = 4
pool-1-thread-3 Start. command = 2
pool-1-thread-4 Start. command = 3
pool-1-thread-1 Start. command = 0
pool-1-thread-1 End.
pool-1-thread-3 End.
pool-1-thread-5 End.
pool-1-thread-2 End.
pool-1-thread-4 End.
pool-1-thread-2 Start. command = 8
pool-1-thread-3 Start. command = 7
pool-1-thread-5 Start. command = 6
pool-1-thread-1 Start. command = 5
pool-1-thread-4 Start. command = 9
pool-1-thread-4 End.
pool-1-thread-2 End.
pool-1-thread-3 End.
pool-1-thread-1 End.
pool-1-thread-5 End.
Finished all threads

***************************************************************************************************************


1) ThreadPoolExecutor is more powerful than executors.
2) With threadpoolexecutor, we can provide min no.of threads to be alive,max no.of threads in pool at any given time, and RejectedExecutionHandler to handle jobs which can not fit into queue.


import java.util.concurrent.ThreadPoolExecutor;

public class MyMonitorThread implements Runnable
{
ThreadPoolExecutor executor;
private boolean run = true;
private int seconds;

    MyMonitorThread(ThreadPoolExecutor executor,int delay)
    {
      this.executor = executor;
      this.seconds = delay;
    }

    public void shutdown()
    {
    run = false;
    }

@Override
public void run()
{
       while(run)
       {
        System.out.println(String.format("[monitor] [%d/%d] Active: %d, Completed: %d,Task: %d,isShutdown: %s, isTerminated: %s",
        executor.getPoolSize(),executor.getCorePoolSize(),executor.getActiveCount(),executor.getCompletedTaskCount(),
        executor.getTaskCount(),executor.isShutdown(),executor.isTerminated()));

        try
        {
        Thread.sleep(seconds*1000);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
       }
}
}

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class RejectedExecutionHandlerImpl implements RejectedExecutionHandler
{
@Override
public void rejectedExecution(Runnable r,ThreadPoolExecutor executor)
{
       System.out.println(r.toString()+" is rejected.");
}
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

public class WorkerPool
{
public static void main(String args[]) throws InterruptedException
{
RejectedExecutionHandlerImpl rejectedExecutionHandlerImpl = new RejectedExecutionHandlerImpl();
ThreadFactory threadFactory = Executors.defaultThreadFactory();
//intial pool size 2,max pool size 4,keepAliveTime, for thread,worker queue size 2
ThreadPoolExecutor executorPool = new ThreadPoolExecutor(2,4,10,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2),
threadFactory,rejectedExecutionHandlerImpl);

MyMonitorThread myMonitorThread = new MyMonitorThread(executorPool,3);
Thread thread = new Thread(myMonitorThread);
thread.start();

for(int i=0;i<10;i++)
{
           executorPool.execute(new WorkerThread("cmd"+i));
}

Thread.sleep(30000);
executorPool.shutdown();
Thread.sleep(5000);
myMonitorThread.shutdown();
}
}

ScheduledThreadPoolExecutor --> to schedule tasks periodically.
CachedThreadPoolExecutor --> To spawn unlimited threads if free ones are not available. not recommended.
FixedTreadPoolExecutor --> Limited threads.
***************************************************************************************************************

1) ThreadPoolExecutor(which is subclass of Executor and ExecutorService) class has 4 constructors,but due to their complexity, the java concurrency API provides the 'Executors' class to construct the executor.

2) Shoutdown waits unitl running + pending tasks completion. Won't allow new tasks.
3) AwaitTermination can be used to block calling method untill termination happens or timeout happens.

http://www.journaldev.com/1069/threadpoolexecutor-java-thread-pool-example-executorservice
http://howtodoinjava.com/core-java/multi-threading/java-thread-pool-executor-example/
https://dzone.com/articles/scalable-java-thread-pool-executor

Gauva-Retryer

Retrier:  The guava-retrying module provides a [general purpose method] for retrying java arbitary code with specific stop,retry and exception handling capabilities that are enhanced by Gauva's predicate matching.

1) API calls,Network calls are failing are normal part of our programs. We handle them in Application specific ways.
2) Many times,we need to [retry] the operations before logging it as failure.
3) Data Fetcher ----------> Remote Server
   For demonstration, we have a Remote Server from where we need to fetch the data.
   It could be [streaming] the data or a [REST API] call or any other [RPC] call.

   static class UrlFetcher implements Callable<Boolean>{
     private String url;
     private String opMode;

     UrlFetcher(String url,String opMode){
      this.url = url;
      this.opMode = opMode;
     }

     @Override
     public Boolean call() throws Exception{
      if("fail".equals(opMode)){
       throw new TimeoutException("Connection timed out");
      }

      return true;
     }
   }

   Retryer<Boolean> retrier = RetryerBuilder.<Boolean>newBuilder()
                              .RetryIfExceptionOfType(TimeoutException.class)
                              .retryIfRuntimeException()
                              .withStopStrategy(StopStrategies.stopAfterAttempt(3))
                              .build();

  try{
    retrier.call(new UrlFetcher("http://www.google.com","normal"));
    retrier.call(new UrlFetcher("http://www.google.com","fail"));
  } catch(RetryException e){
        e.printStackTrace();
  } catch(ExecutionException e){
        e.printStackTrace();
  }

 4) a) We need to create retryer using builder.
    b) We can specify the conditons on which to retry.
    c) Here we have specified RuntimeException and TimeoutException, if there is any exception,it won't retry.
    d) We also need to specify strategy to stop. Here we have specified,retry 3 times and then abort.

5) Wait Strategy:
------------------
1) Here we retried immediately after failure, what if we want to change the behaviour.
.withWaitStrategy(WaitStrategies.exponentailWait(1000,5,TimeUnit.SECONDS))

Maven Notes

  Maven:    No need to write build script and manage dependencies
----------
Project management and comprehension tool based on concept of [POM] --> Project Object Model.

Maven -Manages--> [Build,Dependecies,SCMs] Releases,distribution, Reporting and Documentation.

a) Maven provides developers a [complete build life cycle framework].
b) Maven uses [**standard directory layout and ** default build cycle].
c) Maven project structure and contents are mentioned in pom.xml[project object model].
d) When Maven project created, maven creates a standard project structure, deveopers are required only to place files in those folders.

e) ${basedir}/src/main/java/ -> Source code.
   ${basedir}/src/main/resources --> resources.
   ${basedir}/src/test --> Test code.
   ${basedir}/src/test/resources --> Test resources.
   ${basedir}/src/target --> distibutable jar.
   ${basedir}/src/target/classes --> compiled class files.

7) In order to build the project, maven provides developers options to mention [life-cycle goals] and [project dependencies](in pom.xml).

8) Export M2_HOME=export M2_HOME=/usr/local/apache-maven/apache-maven-3.3.3 and add bin folder to PATH to run maven build from anywhere in sys.

9)POM.xml -> It's XML file
  a) Always resides in [base directory] of project.
  b) While executing maven task/goal, maven looks for pom.xml in current directory.
  c) POM might contains below information:
     a) project dependencies b) plugins(compiler plugin etc) c) goals(custom goals) d) build profiles (dev,prod,test) e) project version(under project element witch is root element) f) developers d) mailing list

     We can modify, project folder structure

**d) Before creating POM, we need to come up with project group(groupid),project name(artifact) and version for [unique] identification of project in repository.

  e) It's allowed only one POM file per project.
  f) All POMs inherit from a parent POM known as super POM.
  g) Maven provides different archtypes to ssupport diff project structures.

Build Life cycle:
-------------------

Build Life Cycle Contains Phases --> Phases contains Goals

1) Typical build cycle contains following phases:
   a) prepare-resources (Resource copying can be customized in this phase.) b) compile (just compile source) c) package (build jar/war file) d) install (upload artifacts to local/remote repository)

2) Every phase has pre and post phases to register goals.

c) Maven has 3 standard life cycles: a) clean b) default or build d) site (Documentation)

d) Goal is a specific task which contributes to the build.
e) Order of invocation matters

   clean phase -> dependency goal -> package phase
   mvn clean dependency:copy-dependencies package
         |         |                         |
       Phase ->   Goal                 ->   Phase

f) Default/Build life cycle : Has 23 phases

Build Profiles:
----------------
a) Build profiles can be used to distinguish build definations for diff env like prod,dev and UAT
b) Build profiles are three types:
   Per Project -> Defined in project pom.xml
   Per User -> Defined in Users/username/.m2/settings.xml
   Global -> %M2_HOME%/conf/settings.xml

   mvn phase -Pprod
c) Profile can be activated in pom.xml using activeProfiles tag.

Repository:
----------------
a) Repository is a place, all project jars,library jars,plugins resides.
b) 3 types: Local,Central and Remote
Local: i)   Gets created in %USER_HOME% folder.
       ii)  Maven keeps all project dependencies in local repository when mvn build runs.
       iii) Path can be overridden by mentioning path in settings.xml in %M2_HOME%/conf folder.

Central: Provoded by maven community; http://repo1.maven.org/maven/

Remote: Developers own custom library

Order of reference for dependencies: Local -> Central -> Remote

Plugins:
------------

1) Maven is actually plugin execution framework where every task is done by plugins
2) Ex: Creating jar file,create war file,compile source code,unit testing code,create documentation and project reports
3) Plugins usually provides multiple goals can be executed like this: [mvn plugin-name:goal-name]
   For ex: Java project can be compiled by using mvn-compiler-plugin's mvn compiler:compile
4) PLugins are two types: Build plugins (under /build) and reporting plugins(under /reporting)
5) in POM.xml <plugins><plugin><executions><execution><goals><goal></goal><goals><configuration><tasks></tasks></configuration><executions><execution></plugin></plugins>

Creating Projects:
-------------------
1) Maven uses archtype plugin to create projects.

External Dependencies:
-----------------------

We can add lib folder with jars to maven to refer when those jars are not found in all 3 repos.
<dependency><groupid></groupid><artifactid></artifactid><version></version><scope>system</scope><systempath></systempath></dependency>

-U to force maven to download latest dependencies

****** if version contains snapshot, it means maven fetch copy from repo for every build. unlike normal version case
Build automation: Kick off build of dependent projects, once current build is done successfully.
This can be acieved by modifying pom.xml or else using continuous integration(CI) hudson
Whenever SVN check in happens, it will trigger build and then triggers dependent builds.

Transitive Dependencies Discovery:
----------------------------------------------
It is pretty often a case, when a library say A depends upon other library say B. In case another project C want to use A then that project requires to use library B too.

Maven helps to avoid such requirement to discover all the libraries required. Maven does so by reading project files(pom.xml) of dependencies, figure out their dependencies and so on.

We only need to define [direct dependency] in each project pom. Maven handles the rest automatically.

Common dependencies can be placed at single place using concept of parent pom.Dependencies

Scope Description
compile This scope indicates that dependency is available in classpath of project. It is default scope.
provided This scope indicates that dependency is to be provided by JDK or web-Server/Container at runtime
runtime This scope indicates that dependency is not required for compilation, but is required during execution.
test This scope indicates that the dependency is only available for the test compilation and execution phases.
system This scope indicates that you have to provide the system path.
import This scope is only used when dependency is of type pom. This scopes indicates that the specified POM should be replaced with the dependencies in that POM's <dependencyManagement> section.

mvn dependency:tree

Running jobs in background using nohup

We can use nohup to start jobs in background.

 Usage: nohup script.name > log file name 2>&1(send error log also to normal log) &

in the end, & is mandatory.

File Permissions in UNIX

rwx(owner user)-rwx(group)-rwx(other)

0 - no permission
1 -> x only
2 -> w only
3 -> wx only
4 -> r only
5 -> rx only
6 -> rw only
7 -> rwx - all


chmod -R 777 to change file permissions.