PROGRAMMER

extract item from list of dictionaries

2018-01-20T11:30:00.000-08:00

obj = {'data':[{'id':1,'price':200,'distance':20},{'id':5,'price':300,'distance':30},{'id':6,'price':225,'distance':22.5}]}

prince = 300

try:
print(next(x for x in obj['data'] if x['price'] == 300)['price'])
except :
print('not found')

Javascript functions

2017-12-17T11:04:00.003-08:00

1.
var multiply = new Function('x', 'y', 'return x * y');
console.log(multiply(2,9));

A function defined with the Function constructor assigned to the variable multiply

2.
function multiply(x,y){
return x*y;
}
console.log(multiply(2,9));

A function declaration of a function named multiply
Function declarations in JavaScript are hoisting the function definition

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function

3.
A function expression of an anonymous function assigned to the variable multiply:

var multiply = function(x,y) {
return x*y;
}
console.log(multiply(2,9));

A function expression of a function named func_name assigned to the variable multiply:

var multiply = function func_name_(x,y) {
return x*y;
}
console.log(multiply(2,9));

* Function expressions in JavaScript are not hoisted

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/function

4. var a = (x,y) => { return x*y; }
console.log(a(2,9));

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions

5.
(function(){
console.log(2*9);
})();

Immediately Invokable Function Expression

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions

javascript : map()

2017-12-15T02:45:00.003-08:00

The map() method creates a new array with the results of calling a provided function on every element in the calling array.

var numbers = [1, 4, 9];
var doubles = numbers.map(function(num) {
    return num * 2;
});

or

var numbers = [1, 4, 9];
var doubles = numbers.map(x => x*2);

another example

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log(roots);

or

var numbers = [1, 4, 9];
numbers.map(function(n){
    return Math.sqrt(n);
});

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map

fetch meta information from website

2017-11-26T04:16:00.000-08:00

from bs4 import BeautifulSoup
import urllib
import requests

url = 'http://www.bbc.com/future/story/20171124-what-if-all-animals-had-human-intelligence'
#page = urllib.urlopen(url).read()
agent = {"User-Agent": "Mozilla/5.0"}
page = requests.get(url, headers=agent).text
soup = BeautifulSoup(page,'html.parser')

try:
    title = soup.find("title").text
except:
    title = "no title found"

try:
    try:
        desc = soup.find("meta", property="og:description")['content'].encode('utf-8')
    except:
        try:
            desc = soup.find(attrs={'name': 'Description'})['content'].encode('utf-8')
        except:
            desc = soup.find(attrs={'name': 'description'})['content'].encode('utf-8')
except:
    desc = "no description found"

try:
    image = soup.find("meta", property="og:image")['content'].encode('utf-8')
except:
    image = "no image found"


try:
    try:
        keywords = soup.find(attrs={'name': 'Keywords'})['content'].encode('utf-8')
    except:
        keywords = soup.find(attrs={'name': 'keywords'})['content'].encode('utf-8')
except:
    keywords = 'NA'

print "Title : ",title
print "Image : ",image
print "Description : ",desc
print "Keywords : ",keywords

create Django rest application

2017-11-26T02:11:00.001-08:00

1. install rest framework

pip install djangorestframework

2. add 'rest_framework', into INSTALLED_APPS from settings.py

3. configure database ,add databse configuration in settings.py

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'webbookmark',
        'USER': 'root',
        'PASSWORD': 'password',
        'HOST': '127.0.0.1',
        'PORT': '3306',
    }
}
4. create our model in models.py

class Websites(models.Model):
    link = models.CharField(max_length=500)
    img = models.CharField(max_length=500)
    title = models.CharField(max_length=500)
    content = models.CharField(max_length=500)
    keywords = models.CharField(max_length=250)

    def __str__(self):
        return self.title

5. create a serializer , create a file serializer.py , and include this code

from rest_framework.serializers import ModelSerializer
from .models import Websites
class WebsitesSerializer(ModelSerializer):
    class Meta:
        model = Websites
        fields = '__all__'

here we want to apply operations (create , update , delete) on all fields
if we dont want to work with all fields , then we should add
fields = ('id', 'link', 'img', 'title')

6. from views.py add viewsets

class WebsitesViewSet(ModelViewSet):
    queryset = Websites.objects.all()
    serializer_class = WebsitesSerializer

router = DefaultRouter()
router.register('websites',WebsitesViewSet)

7. from urls.py , add router urls

urlpatterns = [
       url(r'^api/', include(router.urls)),
]

8. give command
python manage.py makemigrations
python manage.py migrate
python manage.py runserver

9. now we can control or manage rest request from
http://localhost:8000/api/websites/

python decorator

2017-11-24T10:35:00.000-08:00

higher-order function : is a function that takes one or more functions as arguments (i.e., procedural parameters), returns a function as its result.

decorator : function that takes another function and extends the behavior of the latter function without explicitly modifying it

In Python, functions can be passed around, and used as arguments, just like any other value (e.g, string, int, float).

def test(val):
    return val + 1

def call_test(func,val):
    return func(val)

print call_test(test,5)

output : 6

nested functions : in Python, you can define functions inside other functions. Such functions are called nested functions.

def a():
    def b():
        return "call b()"
    def c():
        return "call c()"
    return b()+" and "+c()

print a()

output : call b() and call c()

If we call b(), we should get an error:

Traceback (most recent call last):
File "", line 1, in
NameError: name 'b' is not defined

we can change this a() function like :

def a(num):
    def b():
        return "call b()"
    def c():
        return "call c()"
    if num == 1:
        return b
    else:
        return c

func = a(2)
print func()

output : call c()

Python allows to simplify the calling of decorators using the @ symbol

def modified(func):
    def wrap():
        print "start calling function"
        func()
        print "end function"
    return wrap

def modified_with_args(func):
    def wrap(*args, **kwargs):
        print "calling function with param ",args
        return func(*args, **kwargs)+20
    return wrap

@modified
def func1():
    print "call func1()"

@modified_with_args
def func2(num):
    return num

func1()
print func2(20)

read OSC messages from casparcg

2017-11-23T12:15:00.001-08:00

1. install osc.js

npm install osc

2. sample code for listening OSC messages from casparcg server

var osc = require('osc')
// Create an osc.js UDP Port listening on port 7250.
var udpPort = new osc.UDPPort({
    localAddress: "127.0.0.1",
    localPort: 7250,
    metadata: true
});

// Listen for incoming OSC bundles.
udpPort.on("message", function (oscMessage, info) {
    console.log(" MESSAGE : ", oscMessage);
    console.log(oscMessage.address);
    console.log(oscMessage.args[0].type);
    console.log(oscMessage.args[0].value);
    console.log('===========================');
});

// Open the socket.
udpPort.open();

download and start jenkins

2017-11-20T04:24:00.001-08:00

1. download jenkins from https://jenkins.io/download/
I have downloaded generic java package (.war)

2. to start jenkins
goto jenkins.war file location and give command

java -jar jenkins.war

it will start jenkins in 8080 port

if we want to start jenkins in another port

java -jar jenkins.war --httpPort=9090

jenkins will start in 9090 port

save the administrator password to use it later

3. now goto http://localhost:8080/ and give administrator password

4. to install plugins , select plugins to install ,click all and install

JVM

2017-11-02T12:12:00.005-07:00

What Is Virtual Machine ?

VM acts as runtime engines to run particular programming language applications
JVM (Java virtual machine)
PVM (Parallel Virtual Machine) acts as runtime engine to run Perl
CLR ( Common Language Runtime) acts as runtime engine to run .net

What Is A Java Virtual Machine?
create a Java program,
compile this program.
The result of this compilation is the file with extension .class. It contains Java bytecode.
generated bytecode is identical no matter on what platform program has been compiled. It is platform neutral. That is why we can say that Java program is platform independent.

However bytecode can not be executed because system understands machine instructions.
In order to execute a Java program, we have to install a middleware component that fits between Java program and operating system. This component is called Java Virtual Machine.

JVM runs as an application on top of an operating system.
JVM reproduce Operating system environment for Java programs. Thats why it is called Java Virtual Machine.

Basic Architecture Diagram Of JVM
1. Class Loader SubSystem
Loading :The Class loader reads the .class file, generate the corresponding binary data and save it in method area.
Linking : Performs verification, preparation, and (optionally) resolution.
Initialization : In this phase, all static variables are assigned with their values defined in the code and static block(if any). This is executed from top to bottom in a class and from parent to child in class hierarchy.

2. Memory Management Area

Method area : all class level information like class name, immediate parent class name, methods and variables information etc. are stored, including static variables.
Heap area : Information of all objects is stored in heap area.
Stack area : For every thread, JVM create one run-time stack which is stored here. Every block of this stack is called activation record/stack frame which store methods calls. All local variables of that method are stored in their corresponding frame.The stack area is thread safe.
PC Registers : Each thread will have separate PC Registers, to hold the address of current executing instruction once the instruction is executed the PC register will be updated with the next instruction.
Native method stacks : For every thread, separate native stack is created. It stores native method information.

3. Execution Engine

The Execution Engine of JVM is Responsible for executing the program and it contains two parts.

Interpreter.
JIT Compiler (just in time compiler).

Java Native Interface (JNI)
It is a interface which interacts with the Native Method Libraries

Native Method Libraries
It is a collection of the Native Libraries(C, C++) which are required by the Execution Engine.

http://codepumpkin.com/jvm-architecture-introduction/

Naive Bayes algorithm

2017-11-01T11:09:00.001-07:00

Above,

P(c|x) is the posterior probability of class (c, target) given predictor (x, attributes).
P(c) is the prior probability of class.
P(x|c) is the likelihood which is the probability of predictor given class.
P(x) is the prior probability of predictor.

we know
Probability of the joint of events A and B is
P(A and B) = P( probability of A given B)*P(probability of B)
P(A and B) = P(A|B)*P(B)
or
P(A and B) = P( probability of B given A)*P(probability of A)
P(A and B) = P(B|A)*P(A)
so , P(A|B)*P(B) = P(B|A)*P(A)
=> P(A|B) = (P(B|A)*P(A))/P(B)

this is conditional probability , when 2 events is not independent

For example, a fruit may be considered to be an apple if it is red, round, and about 3 inches in diameter. These features depend on each other to identify an apple. only red , or only round is not feature of an apple .

IDENTITY SEQUENCE TABLE (SEQUENCE)

2017-10-31T05:44:00.003-07:00

AUTO: Hibernate selects the generation strategy based on the used dialect,
IDENTITY: Hibernate relies on an auto-incremented database column to generate the primary key,
SEQUENCE: Hibernate requests the primary key value from a database sequence,
TABLE: Hibernate uses a database table to simulate a sequence.

IDENTITY

The IDENTITY generator allows an integer/bigint column to be auto-incremented on demand.
It relies on an auto-incremented database column and lets the database generate a new value with each insert operation
The increment process happens outside of the current running transaction, so a roll-back may end-up discarding already assigned values
The increment process is very efficient since it uses a database internal lightweight locking mechanism
drawback is that we can’t know the newly assigned value prior to executing the INSERT statement.
Hibernates disables the JDBC batch support for entities using the IDENTITY generator
Hibernate requires a primary key value for each managed entity and therefore has to perform the insert statement immediately. This prevents it from using different optimization techniques like JDBC batching.

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id", updatable = false, nullable = false)
private Long id;

SEQUENCE

A SEQUENCE is a database object that generates incremental integers on each successive request. SEQUENCES are much more flexible than IDENTIFIER columns
A SEQUENCE is table free and the same sequence can be assigned to multiple columns or tables
SEQUENCE requires additional select statements to get the next value from a database sequence
It additional information is not provided, Hibernate will request the next value from its default sequence. this can be changed by referencing the name of a @SequenceGenerator in the generator attribute of the @GeneratedValue annotation.
@SequenceGenerator annotation lets to define the name of the generator, the name, and schema of the database sequence and the allocation size of the sequence.
A SEQUENCE may preallocate values to improve performance
A SEQUENCE may define an incremental step
A SEQUENCE doesn’t restrict Hibernate JDBC batching
A SEQUENCE doesn’t restrict Hibernate inheritance models

@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "book_generator")
@SequenceGenerator(name="book_generator", sequenceName = "book_seq", allocationSize=50)
@Column(name = "id", updatable = false, nullable = false)
private Long id;

TABLE (SEQUENCE)

It simulates a sequence by storing and updating its current value in a database table
requires the use of pessimistic locks which put all transactions into a sequential order
row-level locking which comes at a higher cost than IDENTITY or SEQUENCE generators.
slows down your application -

For local transactions, it must open a new JDBC connection, putting more pressure on the current connection pooling mechanism
For global transactions, it requires suspending the current running transaction. After the sequence value is generated, the actual transaction has to be resumed. so the overall application performance might be affected

definitely less efficient than using a native IDENTITY or SEQUENCE.

difference save() vs persist()

2017-10-31T03:29:00.000-07:00

Save()

Returns generated Id after saving. Its Serializable return type.
INSERT happens immediately, no matter if you are inside or outside of a transaction.
save() method can return that primary key id value (int id = session.save(k);)
Saves the value to DB immediately and keeps track of the entity until the end of the session(I have tried to change the entity values outside of the transaction, it does not show any effect when session commits)
Does not save the changes to the db outside of the transaction.
Assigns the generated id to the entity you are persisting
Session.save() for a detached object will create a new row in the table.

Persist()

Does not returns generated Id after saving. Its void return type.
it will not execute an INSERT statement if it is called outside of transaction boundaries
Saves the value to DB immediately and keeps track of the entity until the end of the session.(I have tried to change the entity values outside of the transaction, it does not show any effect when session commits)
Does not save the changes to the db outside of the transaction.
Assigns the generated id to the entity you are persisting
session.persist() for a detached object will throw PersistentObjectException as it is not allowed.

http://www.baeldung.com/hibernate-save-persist-update-merge-saveorupdate
https://stackoverflow.com/questions/5862680/whats-the-advantage-of-persist-vs-save-in-hibernate

difference between FetchType.LAZY and FetchType.EAGER

2017-10-31T02:55:00.000-07:00

suppose we have two entities and there's a relationship between them. For example,
an entity called University,
another entity called Student.

The University entity might have some basic properties such as id, name, address, etc. as well as a property called students:

public class University {
private String id;
private String name;
private String address;
private List students;

// setters and getters
}
Now when load a University from the database, JPA loads its id, name, and address fields. But we have two options for students: to load it together with the rest of the fields (i.e. eagerly) or to load it on-demand (i.e. lazily) when calling the university's getStudents() method.

* When a university has many students it is not efficient to load all of its students.
* When they are not needed. So in such like cases, you can declare that you want students to be loaded when they are actually needed. This is called lazy loading.

LAZY = fetch when needed
EAGER = fetch immediately

hibernate session.save() does not reflect in database

2017-10-29T12:39:00.002-07:00

we can avoid this issue in 2 ways :

1.
       Session session = new AnnotationConfiguration()
                .configure()
                .buildSessionFactory()
                .openSession();
        Transaction transaction = session.beginTransaction();

User user = new User("abc", "100");

        try {
            session.save(user);
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }

transaction created after openSession().

2.
adding following line in "hibernate.cfg.xml"
true

thus the code will be

     Session session = new AnnotationConfiguration()
                .configure()
                .buildSessionFactory()
                .openSession();
    User user = new User("abc", "100");
    session.save(user);
    session.close();

Maven : Updating Indexes Not working

2017-10-16T05:11:00.001-07:00

1. close Spring Tool Suite
2. Go to [your-workspace-folder]
3. Remove .metadata/.plugins/org.eclipse.m2e.core/nexus
4. Remove .metadata/.plugins/org.maven.ide.eclipse/nexus
5. Restart Spring Tool Suite
6. remove [your-home-folder]/.m2/repository/.cache/m2e/*
Click Window -> Show view -> Other -> Maven Repositories In the appeared tab click Global Repositories. Right click on central -> Rebuild Index.

It took me 30 minutes to rebuild it. All the time Progress bar was 0%. Eclipse downloaded about 10Gb in [your-home-folder]/.m2/repository folder. Then it deleted 8Gb.

To check if download is going, just refresh C drive (or the drive .m2 folder is loceted).

STS console Log

2017-10-16T01:37:00.001-07:00

to enable Spring tool Suite (STS ) full console log , then
1. goto pivotal-tc-server-developer-3.2.0.RELEASE\base-instance\conf\logging.properties
2. add/replace this below line
.handlers = 1catalina.org.apache.juli.FileHandler, java.util.logging.ConsoleHandler
3. restart Pivotal Tc server

@ExceptionHandler vs @ControllerAdvice

2017-10-10T06:23:00.001-07:00

Spring 3.2 introduced @ControllerAdvice annotation for handling exceptions in a Spring MVC application. But prior to this version Spring had @ExceptionHandler to handle exceptions.

@ExceptionHandler :

is local to a controller
only exceptions from this controller is routed to its @ExceptionHandler
it does not work for another controllers,it works only for specific controllers

/**************************************************
@Controller
public class TestController {
/*
some other @RequestMapping functions
*/
@ExceptionHandler(DataAccessException.class)
    public String DatabaseException(DataAccessException ex) {
        return "Error";
    }
}
/****************************************************
this @ExceptionHandler only works for this controller.
-------------------------------------------------------------------------------
@ControllerAdvice :

use for global error handling.
It also has full control over the body of the response and the status code.
it applies to all the defined controller.

/*****************************************************
@ControllerAdvice
public class ErrorHandler {

    @ExceptionHandler(DataAccessException.class)
    public String DatabaseException(DataAccessException ex) {
       return "Error";
    }
}
/******************************************************

this exception handler function works for all Controllers .

JNDI

2017-10-08T08:00:00.002-07:00

JNDI = Java Naming and Directory Interface

Naming and Directory Concepts :
1. naming service--the means by which names are associated with objects
2. objects are found based on their names.
3. A naming service's primary function is to map names to objects
example :
www.example.com ==> 192.0.2.5
c:\bin\autoexec.bat ==> File Reference
4. naming system or naming convention determines the syntax that the name must follow
5. The association of a name with an object is called a binding. (A file name is bound to a file)
6. A reference to the object is placed inside the naming service.
7. A reference represents information about how to access or communicate with an object by
looking up name. A name just point the object.
8. A context is a set of name-to-object bindings.
9. Every context has an associated naming convention. A context always provides a lookup (resolution) operation that returns the object. example : /usr/bin here , /usr is context and
/bin is subcontext. /usr is used to lookup /bin.

Naming Package
1. javax.naming package contains classes and interfaces for accessing naming services
2. lookup() use to look up object by name, and it returns the object bound to that name.
3. Name is an interface that represents a generic name. The Naming Systems use this interface to define the names that follow its conventions.
4. References : The JNDI defines the Reference class to represent reference.
5. A reference contains information on how to construct a copy of the object.

Directory Package
1. The javax.naming.directory package extends the javax.naming package to provide functionality for accessing directory services in addition to naming services.
2. This package allows applications to retrieve objects stored in the directory and search for objects using specified attributes

JNDI
1. JNDI just use references(how to construct a copy of the object) that are looked up from the directory to make Java objects that they represent , and thus JNDI clients have an idea/illusion that what is stored in the directory are Java objects.
2. In the JNDI, all naming and directory operations are performed relative to a context.(no absolute roots)
3. JNDI defines an InitialContext, which provides a starting point for naming and directory operations.
4. initial context use to look up other contexts and objects.

Overview of JNDI
1. The JNDI architecture consists of an API and a service provider interface (SPI).
2. Java applications use the JNDI API to access a variety of naming and directory services.
3. The SPI enables a variety of naming and directory services to be plugged in transparently,allowing the Java application using the JNDI API to access their services.

4. basic use of JNDI allows distributed applications to look up services in an abstract, resource-independent way.
5. Typical uses of JNDI include:

connecting a Java application to an external directory service (such as an address database or an LDAP server)
allowing a Java Servlet to look up configuration information provided by the hosting web container
most common use case is to set up a database connection pool on a Java EE application server. Any application that's deployed on that server can access to the connections.They only need JNDI name without having to know the details about the connection.
user can use the same JNDI name in each environment and can hide the actual database being used. Applications don't have to change if they migrate between environments.
safer alternative to having a properties file with jdbc connection info or exposing database connection info.
Java EE app server needs to know only JNDI, not necessary to know credentials for accessing a production database.

https://docs.oracle.com/javase/tutorial/jndi/overview/index.html
https://stackoverflow.com/questions/4365621/what-is-jndi-what-is-its-basic-use-when-is-it-used

Spring Auto scanning components, wiring from beans and autowiring

2017-10-07T04:35:00.000-07:00

1. we declare all the beans or components in XML bean configuration file, so that Spring container can detect and register your beans or components
2. Spring is able to auto scan, detect and instantiate beans from project package also.

declare beans from xml
----------------------------
Normal bean.
package com.customer.dao;
public class CustomerDAO
{
    @Override
    public String toString() {
        return "Hello , This is CustomerDAO";
    }
}

DAO layer.
package com.customer.services;
import com.customer.dao.CustomerDAO;
public class CustomerService
{
    CustomerDAO customerDAO;
    public void setCustomerDAO(CustomerDAO customerDAO) {
        this.customerDAO = customerDAO;
    }
    @Override
    public String toString() {
        return "CustomerService [customerDAO=" + customerDAO + "]";
    }
}

beans.xml
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">






here we have wired classes through 'ref'

App class

package com.common;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.customer.services.CustomerService;

public class App
{
    public static void main( String[] args )
    {
        ApplicationContext context =
        new ClassPathXmlApplicationContext(new String[] {"beans.xml"});

        CustomerService cust = (CustomerService)context.getBean("customerService");
        System.out.println(cust);
    }
}

output: CustomerService [customerDAO=Hello , This is CustomerDAO]

we can do this by auto scanning classes and annotation wiring

Auto Components Scanning

1. enable Spring auto component scanning features
Annotate with @Component to indicate this is class is an auto scan component.

package com.customer.dao;

import org.springframework.stereotype.Component;

@Component
public class CustomerDAO
{
    @Override
    public String toString() {
        return "Hello , This is CustomerDAO";
    }
}

DAO layer, add @Component to indicate this is an auto scan component also.

package com.customer.services;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.customer.dao.CustomerDAO;

@Component
public class CustomerService
{
    @Autowired
    CustomerDAO customerDAO;

    @Override
    public String toString() {
        return "CustomerService [customerDAO=" + customerDAO + "]";
    }
}

or ,
package com.customer.services;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.customer.dao.CustomerDAO;

@Component
public class CustomerService
{

    CustomerDAO customerDAO;
   @Autowired
    public void setCustomerDAO(CustomerDAO customerDAO) {
        this.customerDAO = customerDAO;
    }
    @Override
    public String toString() {
        return "CustomerService [customerDAO=" + customerDAO + "]";
    }
}

@Autowired just do the setter things.

beans.xml
enable auto scanning feature in Spring by adding “context:component” in bean configuration file.

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd">

The base-package is indicate where components stored, Spring will scan this folder and find out the bean (annotated with @Component) and register it in Spring container.

we can add 'component-scan' from Spring Tool Suite IDE.
to do it ,
1. click on
beans.xml > context > select beans(right click on beans) > select insert element
2. click on component-scan > give base package (com.customer,where java code reside) and save

App class :

package com.common;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.customer.services.CustomerService;

public class App
{
    public static void main( String[] args )
    {
        ApplicationContext context =
           new ClassPathXmlApplicationContext(new String[] {"beans.xml"});

        CustomerService cust = (CustomerService)context.getBean("customerService");
        System.out.println(cust);

    }
}

output : CustomerService [customerDAO=Hello , This is CustomerDAO]

https://www.mkyong.com/spring/spring-auto-scanning-components/

Object class in Java

2017-09-30T12:10:00.001-07:00

* Object class is present in java.lang package

* If a Class does not extend any other class then it is direct child class of Object

* If extends other class then it is an indirectly derived

* Object class methods are available to all Java classes

* There are 12 methods in Object class

* toString() :

toString() provides String representation of an Object
used to convert an object to String.
The default toString() method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@’, and the unsigned hexadecimal representation of the hash code of the object. example : A@1fee6fc

public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

* always recommended to override toString() method to get our own String representation of Object.

*hashCode() :

For every object, JVM generates a unique number which is hashcode.
It returns distinct integers for distinct objects.
A common misconception about this method is that hashCode() method returns the address of object, which is not correct.
hashCode() converts the internal address of object to an integer by using an algorithm.
hashCode() method is native because in Java it is impossible to find address of an object, so it uses native languages like C/C++ to find address of the object.
hashCode() method : Returns a hash value that is used to search object in a collection.
JVM(Java Virtual Machine) uses hashcode method while saving objects into hashing related data structures like HashSet, HashMap, Hashtable etc.
The main advantage of saving objects based on hash code is that searching becomes easy.

* equals(Object obj) :

Compares the given object to “this” object (the object on which the method is called).
It gives a generic way to compare objects for equality.
It is recommended to override equals(Object obj) method to get our own equality condition on Objects.
It is generally necessary to override the hashCode() method whenever equals() method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.

* getClass() :

Returns the class object of “this” object
used to get actual runtime class of the object.
It can also be used to get metadata of this class.
The returned Class object is the object that is locked by static synchronized methods of the represented class.
As it is final so we don’t override it.

public class Test
{
    public static void main(String[] args)
    {
        Object obj = new String("GeeksForGeeks");
        Class c = obj.getClass();
        System.out.println("Class of Object obj is : "
                           + c.getName());
    }
}
Class of Object obj is : java.lang.String

* After loading a .class file, JVM will create an object of the type java.lang.Class in the Heap area. We can use this class object to get Class level information. It is widely used in Reflection

finalize() method :

This method is called just before an object is garbage collected.
It is called by the Garbage Collector on an object when garbage collector determines that there are no more references to the object.
We should override finalize() method to dispose system resources, perform clean-up activities and minimize memory leaks.
finalize method is called just once on an object even though that object is eligible for garbage collection multiple times.
we can override finalize() method for perform our cleanup activities like closing connection from database.
finalize() method called by Garbage Collector not JVM
If an uncaught exception is thrown by the finalize() method, the exception is ignored and finalization of that object terminates.

public class Test
{
    public static void main(String[] args) throws InterruptedException
    {
        Test t1 = new Test();
        Test t2 = new Test();
        t1 = null;
        // requesting JVM for running Garbage Collector
        System.gc();
        t2 = null;
        // requesting JVM for running Garbage Collector
        Runtime.getRuntime().gc();
    }
    @Override
    protected void finalize() throws Throwable
    {
        System.out.println("Garbage collector called");
        System.out.println("Object garbage collected : " + this);
    }
}
output
Garbage collector called
Object garbage collected : Test@46d08f12
Garbage collector called
Object garbage collected : Test@481779b8

Clone() :

Object cloning refers to creation of exact copy of an object.
It creates a new instance of the class of current object
initializes all its fields with exactly the contents of the corresponding fields of this object.
Every class that implements clone() should call super.clone() to obtain the cloned object reference.
class must also implement java.lang.Cloneable interface whose object clone.otherwise it will throw CloneNotSupportedException when clone method is called on that class’s object.

class Test implements Cloneable
{
    int a,b;
    public Object clone() throws
                   CloneNotSupportedException
    {
        return super.clone();
    }
}
// Driver class
public class Main
{
    public static void main(String args[]) throws
                          CloneNotSupportedException
    {
       Test2 t1 = new Test2();
       t1.a = 10;
       t1.b = 20;
       Test2 t2 = (Test2)t1.clone();
       t2.a = 100;

       System.out.println(t1.a + " " + t1.b);
       System.out.println(t2.a + " " + t2.b);
    }
}

http://www.geeksforgeeks.org/object-class-in-java/
http://www.geeksforgeeks.org/clone-method-in-java-2/
http://www.geeksforgeeks.org/garbage-collection-java/
http://www.geeksforgeeks.org/overriding-equals-method-in-java/
http://www.geeksforgeeks.org/overriding-tostring-method-in-java/
https://www.javatpoint.com/Garbage-Collection

final keyword in Java

2017-09-29T14:01:00.001-07:00

* final is a non-access modifier
* final variable - to create constant variable
* final methods - prevent method overriding
* final classes - prevent inheritance

Final variables :

* variable is declared with final keyword, it’s value can’t be modified
static final double PI = 3.141592653589793;
* must initialize a final variable, otherwise compiler will throw compile-time error
* There are three ways to initialize a final variable :

initialize a final variable when it is declared.
A blank final variable can be initialized inside instance-initializer block or inside constructor. If you have more than one constructor in your class then it must be initialized in all of them, otherwise compile time error will be thrown.
A blank final static variable can be initialized inside static block.

class Gfg
{

    final int THRESHOLD = 5;
    final int CAPACITY;
    final int MINIMUM;
    static final double PI = 3.141592653589793;
    static final double EULERCONSTANT;

    {
        CAPACITY = 25;
    }

    static{
        EULERCONSTANT = 2.3;
    }

    public GFG()
    {
        MINIMUM = -1;
    }
}

* final variables must be used only for the values to remain constant throughout the execution of program.
* When a final variable is a reference to an object, then this final variable is called reference final variable.
final StringBuffer sb;

* final variable cannot be re-assign. But in case of a reference final variable, internal state of the object pointed by that reference variable can be changed. This property of final is called non-transitivity.
class Gfg
{
    public static void main(String[] args)
    {
        final StringBuilder sb = new StringBuilder("Geeks");
        System.out.println(sb);
        sb.append("ForGeeks");
        System.out.println(sb);
    }
}

output : Geeks
GeeksForGeeks
* Arrays with final keyword are also called final arrays.
* declare an object variable as final, it means that the variable cannot refer to anything else.

class Test
{
    int p = 20;
    public static void main(String args[])
    {
       final Test t = new Test();
       t.p = 30;
       System.out.println(t.p);
    }
}
it works fine !!!
class Test
{
    int p = 20;
    public static void main(String args[])
    {
       final Test t1 = new Test();
       Test t2 = new Test();
       t1 = t2;
       System.out.println(t1.p);
    }
}
Output: Compiler Error: cannot assign a value to final variable t1
* a final array means that

the array variable reference to an object,
cannot be changed to refer to anything,
but the members of array can be modified.

* When a final variable is created inside a method/constructor/block, it is called local final variable, and it must initialize once where it is created.
* final with foreach loop : final with for-each statement is a legal statement.
class Gfg
{
    public static void main(String[] args)
    {
        int arr[] = {1, 2, 3};
        for (final int i : arr)
            System.out.print(i + " ");
    }
}
Since the i variable goes out of scope with each iteration of the loop, it is actually re-declaration each iteration, allowing the same token (i.e. i) to be used to represent multiple variables.

final classes :

* A final class cannot be extended(inherited).
final class A
{
     // methods and fields
}
// The following class is illegal.
class B extends A
{
    // COMPILE-ERROR! Can't subclass A
}

* final with classes is to create an immutable class like the predefined String class.You can not make a class immutable without making it final.

Final methods:
* A final method cannot be overridden.
* The Object class does this—a number of its methods are final
* methods with final keyword required to follow the same implementation throughout all the derived classes.

class A
{
    final void m1()
    {
       System.out.println("This is a final method.");
    }
}
class B extends A
{
    void m1()
    {
       // COMPILE-ERROR! Can't override.
       System.out.println("Illegal!");
    }
}

* It is illegal to declare a class as both abstract and final since an abstract class is incomplete by itself and relies upon its subclasses to provide complete implementations.
* A final class cannot be subclassed.
* A final method cannot be overridden by subclasses

http://www.geeksforgeeks.org/final-keyword-java/
http://www.geeksforgeeks.org/using-final-with-inheritance-in-java/
https://stackoverflow.com/questions/15655012/how-final-keyword-works
http://www.geeksforgeeks.org/final-arrays-in-java/

Java Memory Management

2017-09-29T09:48:00.001-07:00

* Memory management is the process of allocating new objects and removing unused objects to make space for those new object allocations.

* Java objects reside in an area called the heap.

* The heap is created when the JVM starts up and may increase or decrease in size while the application runs.

* When the heap becomes full, garbage is collected.

* During the garbage collection objects that are no longer used are cleared, thus making space for new objects.

*The heap is sometimes divided into two areas (or generations) called

nursery(young space)
old space

* The nursery is a part of the heap reserved for allocation of new objects
* The reasoning behind a nursery is that most objects are temporary and short lived
* a young collection frees a given amount of memory much faster than an old collection
* When the nursery becomes full, garbage is collected by running a special young collection.

* all objects are promoted (moved) to the old space, thus freeing up the nursery for more object allocation

* When the old space becomes full garbage is collected there, a process called an old collection.

* In Java, when we only declare a variable of a class type(like Test t; ), only a reference is created (memory is not allocated for the object). To allocate memory to an object, we must use new(). So the object is always allocated memory on heap

How java internally works :

* An application starts running within a thread by default. Java uses stack memory ( green marked ) to handle this.

* declare a variable of primitive type,
int x;
int a;

Which means x and a will take place in main() method’s memory. That’s why you can’t access local variables of a method from another method.

* we call another method from the main method such as,
          public static void main(String args[]){
                check();
            }
            public static void check(){      }

Different space will be allocated for check() method.

* Assume we have a class,Book let’s have an instance of it in check() method.

         public static void main(String args[]){
             check();
         }
         public static void check(){
              Book b = new Book();
         }

it will create an instance in heap memory and keep a reference in check() method’s memory.

*Java puts primitive types directly in local memory but objects in heap and keeps a reference to it in method memory.

* we declare Book c and assign b to c ( i,e c = b;) it will create a reference to b‘s object.

* if change anything of c, b value will be updated too. Because
       everything you pass is Java other than method parameters is passed by reference.
   Method parameters are passed by value

* After completing execution of the method check(), it will be removed from the stack as well as all references.

* if we create another thread ,

   public static void check(){
    Thread t = new Thread(){
        public void run(){
            background();
        }
    };
    t.start();
    }
    public static void background(){
    }

As we are running a different thread so it will create a different stack to handle everything of it such as background() method in thread 2 stacks.

* String is immutable in Java. Immutable means you can’t change it after creation. One of the reasons of it is to save memory space

We have a String variable p1 in check() method having a value "abcd" and it creates a memory space in heap.
then we have declared p2 having the same value "abcd".
Now it won’t create another abcd in heap rather get a reference to it.
When method execution complete, only references will be removed not the object.

* == checks for references but equals method checks value.

*Garbage Collector ( GC ) cleans memory. it looks for unreferenced objects in heap and if found any GC removes it from memory.

found the information from :

https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/garbage_collect.html

https://jugbd.org/2017/09/16/steak-inside-java-inside/

NodeJs with Redis : Read and write data into Redis

2017-09-25T12:08:00.001-07:00

Node.js install

2017-09-25T10:11:00.000-07:00

> wget https://nodejs.org/dist/v6.11.3/node-v6.11.3.tar.gz
> tar xvzf node-v6.11.3.tar.gz
> cd node-v6.11.3
> ./configure
> make
> make install

to test node code :

1. open a file(here my file name test.js)
2. copy and paste the code and save it

var http = require('http');

http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World!');
}).listen(8080);

3. open command line and give the following command

> node test.js

4. open a browser and hit the url http://localhost:8080/
the output would be 'Hello World!'

Redis - Publish Subscribe

2017-09-25T08:28:00.000-07:00

publisher : the messaging system where the senders (in redis terminology called publishers) sends the messages
subscriber : messaging system the receivers (subscribers) receive messages from publisher.
channel : The link by which the messages are transferred is called channel.

127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channal1"
3) (integer) 1

27.0.0.1:6379> publish channel1 "hello"
(integer) 1

subscribe multiple channel with pattern :

127.0.0.1:6379> PSUBSCRIBE abc*

127.0.0.1:6379> publish abcc "hello abcc channel"
(integer) 1
127.0.0.1:6379> publish abctauwab "hello abctauwab channel"
(integer) 1
127.0.0.1:6379> publish random "hello random channel"
(integer) 0