Domain Modelling Patterns

-
Image
There are two main patterns for organizing business logic: the procedural Transaction script pattern, and the object-oriented Domain model pattern. 1. Transaction script pattern: An important characteristic of this approach is that the classes that implement behavior are separate from those that store state. When using the Transaction script pattern, the scripts are usually located in serviceclasses, which in this example is the OrderService class. A service class has one method for each request/system operation. The method implements the business logic for that request. It accesses the database using data access objects (DAOs), such as the OrderDao. The data objects, which in this example is the Order class, are pure data with little or no behavior. This style of design is highly procedural and relies on few of the capabilities of objectorientedprogramming (OOP) languages. This what you would create if you were writing the application in C or another non-OOP language. Neverthe
Post a Comment

Ruby Syntax Cheat Sheet

-
In this post I am sharing out a short and concise cheat sheet to help you learn or reminisce ruby syntax and constructs.

1. To print multiple Lines
print <<EOF
   This is the first way of creating
   here document ie. multiple line string.
EOF

2. To run in the beginning of program

BEGIN {
   puts "Initializing Ruby Program"
}

3. To run at the end of the Program

END {
puts "at end"
}

4. Class in Ruby

class Customer
end

cust1 = Customer.new

5. Local variable start with lowercase or _
instance variable start with @
class variables start with @@
global variable start with $

6. When you plan to declare the new method with parameters, you need to declare the method initialize at the time of the class creation.
The initialize method is a special type of method, which will be executed when the new method of the class is called with parameters.
Here is the example to create initialize method −

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
      @@no_of_customers+=1
   end
end

cust1 = Customer.new("1","akash","Indiranagar")

7. In ruby methods are defined with def keyword and they are ended with end keyword
class Customer
@@no_of_customers=0

def display
puts "cust = #@@no_of_customers name = #@name"
end

def initialize(id,name)
  @@no_of_customers+=1
  @id = id
  @name = name
end
end

cust1 = Customer.new("1","akash")
cust1.display

8. Constants in Ruby
class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

object = Example.new()
object.show

9. Arrays

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |v|
   puts v
end

ary = ["akash",1,"foo","bar"]
ary.each_with_index do |k,v|
   puts "#{k} , #{v}"
 end

 10. Hashmap

 h = {"a" => 1 , "b" => 2}
 puts h

 h = {"a" => 1 , "b" => 2}
 h.each do |k,v|
   puts "#{k} => #{v}"
 end

11. if/elsif/else

  x = 1
  if x > 2
     puts "x is greater than 2"
  elsif x <= 2 and x!=0
     puts "x is 1"
  else
     puts "I can't guess the number"
  end

12. Default agurments with method
def test(a1 = "Ruby", a2 = "Perl")
   puts "The programming language is #{a1}"
   puts "The programming language is #{a2}"
end
test "C", "C++"
test

13. Return in ruby can return one or more values
def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

It will return an array

14.Variable no of parameters
def sample (*test)
   puts "The number of parameters is #{test.length}"
   for i in 0...test.length
      puts "The parameters are #{test[i]}"
   end
end
sample "Zara", "6", "F"

15.Multiple Inheritence

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1

Subclassing/Inheritance
Just add a < character and the name of the superclass to your class statement.

class BigBox < Box
   # add a new instance method
   def printArea
      @area = @width * @height
      puts "Big box area is : #@area"
   end
end

16.Array declaration

a)nums = Array[1, 2, 3, 4,5]
b)nums = Array.new(20)

17.Accessing array element
num = arr.at(6)

18.Hashmap declaration
a)h = Hash.new
b) With defult value as "month" if key not present in hashmap
months = Hash.new( "month" )

puts "#{months[0]}"
puts "#{months[72]}"
c) H = Hash["a" => 100, "b" => 200]
d)h[1]="bar"
OR
h.store(1, "bar")

19.Exception handling

Put everything btw begin and end block ; everything between rescue and begin is protected
In an event that an exception does not match any of the error types specified, we are allowed to use an
else clause after all the rescue clauses.

begin
# -
rescue OneTypeOfException
# -
rescue AnotherTypeOfException
# -
else
# Any Other exceptions will be caght here
ensure
# Always will be executed
end

20. Class methods - can be called using classname.methodname

class Box
   # Initialize our class variables
   @@count = 0
   def initialize(w,h)
      # assign instance avriables
      @width, @height = w, h

      @@count += 1
   end

   def Box.printCount()
      puts "Box count is : #@@count"
   end

   def self.printCount2()
     puts "Box count is : #@@count"
  end
end

# create two object
box1 = Box.new(10, 20)
box2 = Box.new(30, 100)

# call class method to print box count
Box.printCount()
Box.printCount2()

21. toString method in Ruby class
class foo
  .....
def to_s
      "(w:#@width,h:#@height)"  # string formatting of the object.
   end


22.Ruby does not have any access control over class/instance variables.
It has private,protected,public access specicifier for instance methods
add this to class
private :getWidth, :getHeight

23. attr_reader,attr_writer can be used to avoid declaring getter and setter methods respectively in class for instance variables
attr_accessor is combo of both
class Box
  attr_accessor  :w,:h
  def initialize(a=10 , b=20)
    @w = a
    @h = b
  end
end

Comments

Post a Comment

Popular posts from this blog

Introduction to Kafka

-
Image
Below and the following blog spot will not only give you a kick start about the working of kafka but also give you a fair idea about how it can be used to scale out your application in production. Kafka is a pub-sub (publish-subscribe) messaging system which can be used for messaging passing to develop highly scalable and fault tolerant applications. Here I will start with the basic introduction to kafka in this post and will move further to the designing and development part. Let's say you have a food delivery app where there are different systems which needs to interact with each other and needs to do some type of message passing ; better understood from the architectural diagram below: This is an overly simplified architectural diagram where you have your consumer application from where your customer actually places an order for a particular food item and from a particular restaurant. You have a matching logic right in the middle block which matches the driver with
Read more

Guice Tutorial

-
Below is a short & crisp tutorial on Guice and the functionalities offered by it What is Guice? Guice is framework in Java to inject dependencies to configure Java Objects. The dependency injection pattern leads to code that is more modular & testable. Consider an interface BillingService as below: Consider below implementation of the BillingService Class: It is easy to see the problems with above solutioning as it would make testing the code impossible! Let's model the BillingService implementation by including its dependencies in constructor: It is now possible to send mock Object or FakeCreditCard Object using a custom FakeCreditCardProcessor. But it still has a problem that BillingService's client need to lookup it dependencies , basically you will need to construct dependencies recursively while you need to use a service. This is where Guice comes for rescue! Dependency Injection with Guice To Use Guice for dependency injection in above examp
Read more

GraphQL Introduction

-
Image
In this post I will give a brief introduction to graphQL.Please go thoroughly with the introduction shared in a short and concise manner below as in the next post we will have a look at actually implementing a server using graphQL in Java. What is GraphQL? GraphQL is a new API standard which provides more powerful and flexible alternative to REST. It Enables declarative data fetching (Client can tell exactly what fields to fetch). Exposes a single endpoint and responds to queries unlike REST It solves below problems :                  underfetching: An endpoint doesn't return sufficient information; need to send                                                     multiple requests to server                  overfetching: Downloading unnecessary data Let's say you have an entity called product with attributes productId, productname ,price,productSeller No need to adjust api if product requirement or design changes Fields which are not required by client also easily v
Read more