Wednesday, November 27, 2013

Java .class version

javap - The Java Class File Disassembler



Usage


   javap -verbose YourClass

Output

  ...
  SourceFile: "YourClass.java"
  minor version: 0
  major version: 50
  flags: ACC_PUBLIC, ACC_SUPER
  ...

Major version

J2SE 7 = 51,
J2SE 6.0 = 50,
J2SE 5.0 = 49,
JDK 1.4 = 48,
JDK 1.3 = 47,
JDK 1.2 = 46,
JDK 1.1 = 45

Ref:
http://reverseengineering.stackexchange.com/questions/1328/find-out-a-java-class-files-compiler-version
http://docs.oracle.com/javase/7/docs/technotes/tools/windows/javap.html

Tuesday, November 12, 2013

Postgres tips

Log to database

psql -p port -U user database

Show databases

\l

Show tables

\d

Describe table

\d+ table_name


Exit

\q

Import script from terminal

(when database was exported in sql file)
psql -p port -U user -d dest_db -a -f fileName.sql
   (psql -U prov -d prov -a -f model-prov.sql)

Select TOP 5 records, char_length

SELECT string1, char_length(string1) FROM table1 ORDER BY createDate DESC LIMIT 5;

Dump (export) database

pg_dump -U user source_db -p port -f fileName.sql

List sequences

\ds
or by using SQL:
SELECT c.relname FROM pg_class c WHERE c.relkind = 'S';

list sequence dependencies

SELECT p.relname, a.adsrc FROM pg_class p JOIN pg_attrdef a ON (p.relfilenode = a.adrelid);

To get last value of a sequence use the following query:

SELECT last_value FROM test_id_seq;

remove a sequence


DROP SEQUENCE sequenceName;

Change column type


ALTER TABLE ad_hoc_history ALTER COLUMN parameters TYPE text;
(http://www.postgresql.org/docs/9.3/static/sql-altertable.html)

* change the size of a varchar column:
ALTER TABLE simlocation ALTER COLUMN location TYPE varchar(30);

drop constrain (NOT NULL)


ALTER TABLE table ALTER COLUMN column DROP NOT NULL;

Is some range present in system


Table is msisdn and msisdn is key, but it is string.
select count(*) from msisdn where to_number(msisdn,'9999999999999') >=4366305707030 and to_number(msisdn,'9999999999999') <=4366305712029;

Ref:
http://www.postgresqlforbeginners.com/2010/11/interacting-with-postgresql-psql.html
http://www.postgresql.org/docs/9.3/static/app-psql.html
http://www.postgresql.org/docs/9.3/static/functions-string.html
dump:
http://www.thegeekstuff.com/2009/01/how-to-backup-and-restore-postgres-database-using-pg_dump-and-psql/
http://www.postgresql.org/docs/9.3/static/app-pgdump.html
sequences:
http://www.neilconway.org/docs/sequences/
http://blog.sensible.io/2013/08/24/postgresql-sequences-and-array-column-types.html http://www.linuxtopia.org/online_books/database_guides/Practical_PostgreSQL_database/PostgreSQL_x14316_001.htm
http://www.techonthenet.com/postgresql/functions/to_number.php

Linux tips

yum manager

The Yellowdog Updater, Modified (yum) is an open-source command-line package-management utility for Linux operating systems using the RPM Package Manager. Though yum has a command-line interface, several other tools provide graphical user interfaces to yum functionality. Yum allows automatic updates, package and dependency management, on RPM-based distributions. Yum works with software repositories (collections of packages), which can be accessed locally or over a network connection.

install: yum install mvno-paygw
find: yum search mvno-paygw
update: yum update mvno-paygw
info: yum info mvno-paygw  (information about package; what version is on repository)
check-update: Checks to see whether updates are available. If they are, yum displays their names, version and repository area.
provides: searches for which packages provide the requested dependency of file. This also takes wildcards for files. E.g. yum provides */ldapsearch

Process status

ps -ef | grep java

Change password for current user

passwd

Change password for user by using root account

sudo su
passwd someUser

Check if port 80 is open

netstat -tulpn | grep :80

Download web page

wget localhost:80/bugzilla

List hosts file

cat /etc/hosts

Copy file

cp [OPTION]... SOURCE... DIRECTORY
cp /wsdls/EID_Provision-V0.5.wsdl /var/opt/wsdls/EID_Provision-V0.5.wsdl

Delete file

rm fileName

Remove a directory and its contents without prompting you to make sure you want to delete each file in the directory.
rm -rf directory

Zip file

zip dest.zip sourceFile

The following command compresses the file archivefile1.txt and replaces it with the compressed version named "archivefile1.txt.bz2". bzip2 creates smaller files.
bzip2 archivefile1.txt

Read file/logs
[sudo] tail -100f /var/log/someLogFile.log

copy sourceFile.zip to another comp to user directory

 scp ./sourceFile.zip 10.200.0.133:./
(scp source_file_name username@destination_host:destination_folder)


Find 56952849307 that occured at 2015-02-06 10:2x in provisioning.log file
cat provisioning.log | grep "2015-02-06 10:2.*56952849307" | more
grep -A 3 "stringToFind" fileName   // show 3 lines after
grep -B 3 "stringToFind" fileName   // show 3 lines before
grep -C 3 "stringToFind" fileName   // show 3 lines around

Find 56952849307 in all files that begin with provisioning (e.g. provisioning.log.1)
ls provisioning* | xargs cat | grep 56952849307

Find USSD word in all provisioning.log files and show next 5 lines
cat /var/log/provisioning.log.* | grep MOVILB -A 5

grep all files in current directory for exact match:
grep -F "SIM card was deleted. MSISDN" *

dump tcp traffic to file
tcpdump -i any -w /tmp/test_001.pcap

ssh remote host identification has changed
ssh-keygen -R hostname

Change permission on folder
if needed switch to root user
$ sudo su
$ chmod -R 777 folderName

Ref:
15 Practical Grep Command Examples In Linux / UNIX

Unix Less Command: 10 Tips for Effective Navigation
How To Use Linux Screen


Sunday, September 15, 2013

Maven notes

<!-- user defined properties in the pom.xml -->

 <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <jdk.version>1.8</jdk.version>
  <log4j.version>1.2.17</log4j.version>
</properties>

<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.7</version>

</dependency>
</dependencies>

<build>

<plugins>

<!-- specify java version  -->

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
</configuration>
</plugin>

<!--download sources and javadocs -->

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId>
<configuration>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>

<!-- create manifest file-->

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>hr.samara.mock.StartService</mainClass>
<classpathPrefix>dependency-jars/</classpathPrefix>
</manifest>
</archive>
</configuration>
</plugin>

<!-- copy dependency jars to dependency-jars folder-->

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>

</plugins>

<pluginManagement>
<plugins>

<!-- Ignore/Execute plugin execution -->

<plugin>
<groupId>org.eclipse.m2e</groupId>
<artifactId>lifecycle-mapping</artifactId>
<version>1.0.0</version>
<configuration>
<lifecycleMappingMetadata>
<pluginExecutions>
<!-- copy-dependency plugin -->
<pluginExecution>
<pluginExecutionFilter>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<versionRange>[1.0.0,)</versionRange>
<goals>
<goal>copy-dependencies</goal>
</goals>
</pluginExecutionFilter>
<action>
<ignore />
</action>
</pluginExecution>
</pluginExecutions>
</lifecycleMappingMetadata>
</configuration>
</plugin>
</plugins>
</pluginManagement>

</build>

Install jar file to local repository

mvn install:install-file -Dfile=./mariadb-java-client-1.1.5.jar -DgroupId=org.mariadb.jdbc -DartifactId=mariadb-java-client -Dversion=1.1.5 -Dpackaging=jar


Resolving OutOfMemory Error

export MAVEN_OPTS="-Xmx1024m -XX:MaxPermSize=128m"

Sunday, August 25, 2013

Javadoc tips

Referencing class: 

     {@link hr.samara.RadiusMessageResultEvent RadiusMessageResultEvent}

Referencing public static field: 

     {@link hr.samara.RadiusMessageResultEvent#EVENT_TYPE_ID EventType}

   * if class is within same package there is no need for naming package in link
     {@link RadiusMessageResultEvent}
   * second String is label

Ref:
http://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html#link

Friday, July 26, 2013

Measuring time

How to measure time elapsed when invoking method or doing some processing.

long start = System.nanoTime();
sum_slow();
long end = System.nanoTime();
long diff = end - start;
System.out.println("Time: " + diff / 1000000000.0 + " seconds");
System.out.println("Time: " + TimeUnit.SECONDS.convert(diff, TimeUnit.NANOSECONDS) + " seconds");

Test:
Time: 18.596630883 seconds
Time: 18 seconds

Wednesday, July 24, 2013

Logging

log4j 1.2


Layouts:

#from mobicents-jainslee-2.7.0.FINAL-jboss-5.1.0.GA
%d{ABSOLUTE} %-5p [%c{1}] (%t) %m%n
21:47:59,146 WARN  [LogTest] (main) Sample warn message

%d [%t] %-5p %c - %m%n
2013-07-24 21:47:40,572 [main] WARN  org.mobicents.slee.test.LogTest - Sample warn message

# Pattern to output the caller's file name and line number.
%5p [%t] (%F:%L) - %m%n
 WARN [main] (LogTest.java:14) - Sample warn message

%d{ISO8601} [%t] %-5p (%F:%L) - %m%n 
 2013-07-24 21:55:03,407 [main] WARN  (LogTest.java:14) - Sample warn message

Appender's treshhold vs category

Treshhold is main filter, everything above Threshold value will go to appender. Then category can filter it further to priority's value.
In bellow example every logger in javax.slee.* package will be printed only if it is at least WARN level.

<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">
<param name="Threshold" value="INFO"/>
...
</appender>

<category name="javax.slee">
<priority value="WARN" />
</category>


Ref:


Complete log4j.xml


<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">



<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"

debug="true">



<appender name="consoleAppender" class="org.apache.log4j.ConsoleAppender">
<param name="Threshold" value="debug" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%d [%t] %-5p (%F:%L) - %m%n"/>
</layout>
</appender>

<category name="org.mobicents" additivity="false">
<level value="warn" />
<appender-ref ref="consoleAppender" />
</category>

</log4j:configuration>

Thursday, June 20, 2013

PKI (public key infrastructure)

Public-key cryptography is a cryptographic technique that enables users to securely communicate on an insecure public network, and reliably verify the identity of a user via digital signatures.

Sender and receiver both have pair of private and public keys.

To send encrypted message sender is using reveiver's public key.
Prior to that he can encrypt signature using his private key.

Receiver needs to decrypt message using his private key.
To decrypt signature and to authenticate the sender he is using sender's public key.




Certificate Signing Requests (CSRs)
A CSR consists mainly of the public key of a key pair, and some additional information. Both of these components are inserted into the certificate when it is signed.

Whenever you generate a CSR, you will be prompted to provide information regarding the certificate. This information is known as a Distinguised Name (DN). An important field in the DN is the Common Name (CN), which should be the exact Fully Qualified Domain Name (FQDN) of the host that you intend to use the certificate with.


Ref:

Wednesday, May 8, 2013

Design Principles


  • Encapsulation is breaking your application into logical parts that have a clear boundary that allows an object to hide its data and methods from other objects.
  • Encapsulate what varies.
Information hiding (encapsulation) is important for many reasons, most of which stem from the fact that it decouples the modules that comprise a system, allowing them to be developed, tested, optimized, used, understood, and modified in isolation. This speeds up system development because modules can be developed in parallel. It eases the burden of maintenance because modules can be understood more quickly and debugged with little fear of harming other modules.

The rule of thumb is simple: make each class or member as inaccessible as possible.
  • Code to an interface rather than to an implementation (software is easier to extend).
  • Classes are about behaviour and functionality.
  • Open-Closed Principle (OCP) - classes should be open for extension (new functionality), and closed for modification. (keeps your software reusable, but still flexible) If you want to add new functionality you should extend the entity.
    • open for extension: new behaviour can be added to satisfy the new requirements 
    • close for modification: to extending the new behaviour are not required modify the existing code
  • Don't Repeat Yourself (DRY) - avoid duplicate code by abstracting out things that are common and placing those things in a single location. (DRY is about having each piece of information and behavior in your system in a single, sensible place)
  • Single Responsibility Principle (SRP) - every object in your system should have a single responsibility, and all the object's services should be focused on carrying out that single responsibility. 
    • Each class in your application should have only one reason to change. 
    • Cohesion is another name for SRP. 
    • High cohesion is the desirable state of a class whose members support a single, well-focused role or responsibility.
  • Liskov Substitution Principle (LSP) - subtypes must be substitutable for their base types. (ensures that you use inheritance correctly)
  • Delegation is when you hand over the responsibility for a particular task to another class or method. (If you need to use functionality in another class, but you don't want to change that functionality, consider using delegation instead of inheritance.)
  • Composition lets you choose a behavior from a family of behaviors, often via several implementations of an interface. (the composing object owns the behaviors it uses, and they stop existing as soon as the composing object does)
  • Aggregation is when one class is used as part of another class, but still exists outside of that other class.
  • Dependency inversion principle (DIP)
    • High level modules should not depend upon low-level modules. Both should depend upon abstractions.
    • Abstractions should never depend upon details. Details should depend upon abstractions.
Unlike method invocation, inheritance violates encapsulation. In other words, a subclass depends on the implementation details of its superclass for its proper function. The superclass’s implementation may change from release to release, and if it does, the subclass may break, even though its code has not been touched. As a consequence, a subclass must evolve in tandem with its superclass, unless the superclass’s authors have designed and documented it specifically for the purpose of being extended.
Instead of extending an existing class, give your new class a private field that references an instance of the existing class. This design is called composition because the existing class becomes a component of the new one. Each instance method in the new class invokes the corresponding method on the contained instance of the existing class and returns the results. This is known as forwarding, and the methods in the new class are known as forwarding methods. The resulting class will be rock solid, with no dependencies on the implementation details of the existing class. Even adding new methods to the existing class will have no impact on the new class. 

The features in your system are what the system does (they reflect system's functionality).
Use cases show how the system is used. 
Features and use cases work together, but features are not always reflected in your use cases.

SOLID (single responsibility, open-closed, Liskov substitution, interface segregation and dependency inversion) is a mnemonic acronym introduced by Michael Feathers for the "first five principles" named by Robert C. Martin in the early 2000s that stands for five basic principles of object-oriented programming and design.


Ref: 


Head-First-Object-Oriented-Analysis-Design
Effective Java
10 Object Oriented Design Principles Java Programmer should know
YAGNI - Martin Fowler
Core Design Principles for Software Developers by Venkat Subramaniam
SOLID Principles : The Definitive Guide
The Principles of OOD (UncleBob)

Monday, May 6, 2013

Disk Helper


Utility class for saving, opening and zipping files.

public class DiskHelper
{

/**
* saveToDisk i openFile
*/
public static void printFileObject(FileObject fo)
{
File file = saveToDisk(fo, fo.getFilename());
openFile(file);
}

public static File saveToDisk(FileObject fo, String fileName)
{
String pdfSuffix = "";
if (!fileName.contains(".pdf"))
{
pdfSuffix = ".pdf";
}

File file = new File("c://tmp//" + fileName + pdfSuffix);

int i = 0;
while (file.exists())
{
i++;
file = new File("c://tmp//" + fileName.replace(".pdf", "") + "_" + i + ".pdf");
}

System.out.println("file.exists: " + file.exists());

OutputStream os;
try
{
os = new FileOutputStream(file);
os.write(fo.getContent());
os.flush();
os.close();
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
return file;

}

public static void openFile(File file)
{
StringBuilder sb = new StringBuilder();
sb.append("cmd.exe /C start ");
sb.append(file.getAbsolutePath());
System.out.println("openFile: " + sb);
try
{
Runtime.getRuntime().exec(sb.toString());
}
catch (IOException e)
{
e.printStackTrace();
}
}

private static int byteValue = 1024;

/**
* http://www.mkyong.com/java/how-to-compress-files-in-zip-format/
*/
public static void zipFile(String fileName, File... files)
{
byte[] buffer = new byte[1024];

try
{
File zipfile = new File("C:\\tmp\\" + fileName + ".zip");
FileOutputStream fos = new FileOutputStream(zipfile);
ZipOutputStream zos = new ZipOutputStream(fos);

for (File file : files)
{
System.out.println("file.getName(): " + file.getName() + ", file.length(): " + file.length() / byteValue + " KB");
ZipEntry ze = new ZipEntry(file.getName());
zos.putNextEntry(ze);
FileInputStream in = new FileInputStream(file.getAbsoluteFile());
System.out.println("file.getAbsoluteFile(): " + file.getAbsoluteFile());

int len;
while ((len = in.read(buffer)) > 0)
{
zos.write(buffer, 0, len);
}

in.close();
}

System.out.println("zipfile.getName(): " + zipfile.getName() + ", zipfile.length(): " + zipfile.length() / byteValue + " KB");

zos.closeEntry();
zos.close();

System.out.println("Done");

}
catch (IOException ex)
{
ex.printStackTrace();
}
}

public static void deleteFiles(File... files)
{
for (File file : files)
{
file.delete();
}
}

}



public class FileObject
{
private String filename;
private byte[] content;

public byte[] getContent()
{
return content;
}

public void setContent(byte[] content)
{
this.content = content;
}

public String getFilename()
{
return filename;
}

public void setFilename(String filename)
{
this.filename = filename;
}

}

Wednesday, April 3, 2013

Charts

Web

-using IceFaces 1.8.2 (JSF 1.2)

<ice:form id="chartPopUp">
<ice:panelPopup draggable="true" modal="true" rendered="#{activeBackingBean.chartPopUpVisible}">
  <f:facet name="header">
  <table width="100%">
  <tr>
  <td>
  <ice:outputText value="Grafički prikaz" />
  </td>
  <td align="right">
   
  <ice:commandButton id="closeOdabirButton" styleClass="xButton" actionListener="#{activeBackingBean.closeChartPopUpVisibleAction}" />
  </td>
  </tr>
  </table>
   </f:facet>

  <f:facet name="body">
  <ice:outputChart id="chart" type="pie2D" 

        chartTitle="#{activeBackingBean.title}" 
        colors="green, red" 
        data="#{activeBackingBean.chartData}" 
        labels="#{activeBackingBean.chartLabels}"/>
  </f:facet>
</ice:panelPopup>
</ice:form>

BackingBean

private int totalOkDPTs;
private int totalNotOkDPTs;

public String getChartData()
{
return totalOkDPTs + ", " + totalNotOkDPTs;
}
public String getTitle()

public String getChartLabels()


Result


Jasper report

- using iReport 3.6.2

Select colors:
Pie Chart - Properties - Series Colors ...

Data to display:
Right click Chart and select Chart Data - Details - Pie series
In this example I have 2 series

Parameters:
totalOkDPTsPercentage - String
totalNotOkDPTsPercentage - String
totalOkDPTsPercentageNumber - Double
totalNotOkDPTsPercentageNumber - Double

pieSeries definition:
keyExpression - what displays in bottom (bottom label)
valueExpression - used for calculating and displaying (Number)
labelExpression - label with arrow (String)

jrxml code:

<pieChart>
<chart isShowLegend="true">
<reportElement x="98" y="28" width="375" height="205"/>
<chartTitle>
<titleExpression><![CDATA["Grafički prikaz"]]></titleExpression>
</chartTitle>
<chartSubtitle/>
<chartLegend/>
</chart>
<pieDataset>
<pieSeries>
<keyExpression><![CDATA["Ispravnih DPK - " + $P{totalOkDPTsPercentageNumber} +"%"]]></keyExpression>
<valueExpression><![CDATA[$P{totalOkDPTsPercentageNumber}]]></valueExpression>
<labelExpression><![CDATA["Ispravnih DPK"]]></labelExpression>
</pieSeries>
<pieSeries>
<keyExpression><![CDATA["Pogrešnih DPK - " + $P{totalNotOkDPTsPercentageNumber} +"%"]]></keyExpression>
<valueExpression><![CDATA[$P{totalNotOkDPTsPercentageNumber}]]></valueExpression>
<labelExpression><![CDATA["Pogrešnih DPK"]]></labelExpression>
</pieSeries>
</pieDataset>
<piePlot>
<plot>
<seriesColor seriesOrder="0" color="#00FF33"/>
<seriesColor seriesOrder="1" color="#FF0033"/>
</plot>
<itemLabel color="#000000" backgroundColor="#FFFFFF"/>
</piePlot>
</pieChart>

Result


Stackedbar Chart

I have people and 2 values for them, OK and NOK

Result:
Add stackedbar chart:
- define series colors, Legend position

Define chart details:
- I have added 2 series since I have 2 values (OK and NOK)


The Series expression field is the name of the series. Its value can be any object that implements java.lang.Comparable. In most cases, the value of this field is a string.   --OK

The Category expression field is the label of each value in the chart. The value of this field is typically a string. In our example, each state is a different category, so we will use the state field ($F{state}) as our category expression.   --People's name

The Value expression field is a numeric value representing the value to be charted for a particular category. In our example, the number of aircraft in a particular state is the value we want to chart. Therefore, we use the implicit stateGroup_COUNT variable ($V{stateGroup_COUNT}) as our value expression. --OK in 1 serie and NOK in 2nd

The optional Label Expression field allows us to customize item labels in the chart.

Thursday, March 14, 2013

Design patterns

Pattern - describes a solution to a common problem arising within a context by:
·       Naming a recurring design structure
·       Specifying design structure explicitly by identifying key class/object
·       Abstracting from concrete design elements, e.g., problem domain, form factor, vendor, etc.
·       Distilling & codifying knowledge gleaned by experts from their successful design experiences


Patterns:


  1. Builder
  2. Proxy
  3. Broker
  4. Command Processor
  5. Observer
  6. Layered Architecture
  7. Strategy
  8. Abstract Factory
  9. Wrapper Facade
  10. Reactor
  11. Acceptor-Connector
  12. Template Method Pattern


Ref:
The 23 Gang of Four Design Patterns .. Revisited
Pattern-Oriented Software Architectures for Concurrent and Networked Software
https://dzone.com/articles/java-design-pattern-simplified-part-1-of-django-se


Builder

is GoF Object Creational pattern.
Separate the construction of a complex object from its representation so that the same construction process can create different representations. 



Ref:
http://java.dzone.com/news/design-pattern-builder-pattern
https://en.wikipedia.org/wiki/Builder_pattern


http://java.dzone.com/articles/intro-design-patterns-prototype


Proxy

is GoF Object Structural pattern.
Intent: Provide a surrogate or placeholder for another object to control access to it
Applicability: Proxies are useful wherever there is a need for a more sophisticated reference to a object than a simple pointer or simple reference can provide
Structure

Dynamics

Consequences
+ Decoupling client from object location
+ Simplify tedious & error-prone details
- Additional overhead from indirection
- May impose overly restrictive type system
- It’s not possible to entirely shield clients from networking & IPC



Broker

is POSA1 Architectural Pattern.
IntentConnect clients with remote objects by mediating invocations from clients to remote objects, while encapsulating the details of IPC or network communication
ApplicabilityApps need capabilities to support (potentially) remote communication, provide location transparency, handle faults, manage end-to-end QoS, & encapsulate low-level system details
Dynamics



Consequences
+ Location independence
+ Separation of concerns
+ Portability, modularity, reusability, etc.
- Additional time & space overhead
- May complicate debugging & testing



Command Processor

is POSA1 Design Pattern (it is similar to Command pattern in GoF book).
Intent: Encapsulate the request for a service as a command object
Applicability:
• Specify, queue, & execute service requests at different times
• Ensure service enhancements don’t break existing code
• Implement additional capabilities (such as undo/redo & persistence) consistently for all requests to a service
Structure & Dynamics

Consequences
+ Allow different users to work with service in different ways via commands
+ Client isn’t blocked for duration of command processing
– Additional programming to handle info passed with commands (cf. Broker)
– Supporting two-way operations requires additional patterns

The Command Processor pattern provides a relatively straightforward means for passing commands asynchronously between threads and/or processes in concurrent & networked software
In contrast, many implementations of Broker use synchronous (blocking) method invocations (Some brokers also support asynchronous method invocations)


Observer

is GoF Object Behavioral pattern (POSA1 book contains description of similar Publisher-Subscriber pattern)
Intent: Define a one-to-many dependency between objects so that when one object changes state, all dependents are notified & updated
Applicability:
• An abstraction has two aspects, one dependent on the other
• A change to one object requires changing untold others
• An object should notify unknown other objects
Structure 
Dynamics
Consequences
+ Modularity: subject & observers may vary independently
+ Extensibility: can define/add any # of observers
+ Customizability: different observers offer different views of subject
– Unexpected updates: observers don’t know about each other
– Update overhead: too many irrelevant updates


Layered Architecture

is POSA1 Design Pattern.

The Layered architectural pattern helps to structure applications that can be decomposed into groups of subtasks in which each group of subtasks Is at a particular level of abstraction.


Ref: http://posa1.blogspot.com/2008/05/layered-architecture-pattern.html


Strategy

(also known as the policy pattern) is a software design pattern, whereby an algorithm's behaviour can be selected at runtime. Formally speaking, the strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

You can apply this pattern to a multitude of scenarios, such as validating an input with different criteria, using different ways of parsing, or formatting an input.
The strategy pattern consists of three parts:

  1. An interface to represent some algorithm (the interface Strategy)
  2. One or more concrete implementations of that interface to represent multiple algorithms (the concrete classes ConcreteStrategyA and ConcreteStrategyB)
  3. One or more clients that use the strategy objects

Ref: https://en.wikipedia.org/wiki/Strategy_pattern


Abstract Factory

provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes. In normal usage, the client software creates a concrete implementation of the abstract factory and then uses the generic interfaces to create the concrete objects that are part of the theme. The client does not know (or care) which concrete objects it gets from each of these internal factories, since it uses only the generic interfaces of their products. This pattern separates the details of implementation of a set of objects from their general usage and relies on object composition, as object creation is implemented in methods exposed in the factory interface.

Ref: https://en.wikipedia.org/wiki/Abstract_factory_pattern


Wrapper Facade

is POSA 2 pattern - A Structural Pattern for Encapsulating Functions within Classes
Intent: Encapsulate low-level functions and data structures within more concise, robust, portable, and maintainable higher-level object-oriented class interfaces.




Benefits
Concise & robust higher-level OO programming interfaces
• Reduce the tedium & increase the type-safety of developing apps, which decreases certain types of accidental complexities
Portability & maintainability
• Shield app developers from non-portable aspects of lower-level APIs
Modularity, reusability, & configurability
• Creates cohesive & reusable class components that can be ‘plugged’ into other components in a wholesale fashion
• e.g., using OO language features like inheritance & parameterized types

Limitations
Loss of functionality
• Whenever a portable abstraction is layered on top of an existing API it’s possible to lose functionality
Performance degradation
• Performance can degrade if many forwarding function calls and/or indirections are made per wrapper façade method
Programming language & compiler limitations
• May be hard to define wrapper facades for certain languages due to a lack of language support or limitations with compilers



Known usages:
The Java Virtual Machine (JVM) and various Java foundation class libraries, such as AWT and Swing, provide a set of wrapper facades that encapsulate most of the lowlevel native OS system calls and GUI APIs.

Ref: https://en.wikipedia.org/wiki/Facade_pattern
       http://www.cs.wustl.edu/~schmidt/PDF/wrapper-facade.pdf


Reactor

-An Object Behavioral Pattern for Demultiplexing and Dispatching Handles for Synchronous Events
Intent: The Reactor design pattern handles service requests that are delivered concurrently to an application by one or more clients. Each service in an application may consist of serveral methods and is represented by a separate event handler that is responsible for dispatching service-specific requests. Dispatching of event handlers is performed by an initiation dispatcher, which manages the registered event handlers. Demultiplexing of service requests is performed by a synchronous event demultiplexer.


Acceptor-Connector

-An Object Creational Pattern for Connecting and Initializing Communication Services
Intent: The Acceptor-Connector design pattern decouples connection establishment and service initialization in a distributed system from the processing performed once a service is initialized. This decoupling is achieved with three components: acceptors, connectors, and service handlers. A connector actively establishes a connection with a remote acceptor component and initializes a service handler to process data exchanged on the connection. Likewise, an acceptor passively waits for connection requests from remote connectors, establishing a connection upon arrival of such a request, and initializing a service handler to process data exchanged on the connection. The initialized service handlers then perform application-specific processing and communicate via the connection established by the connector and acceptor components.

Template Method Pattern

The template method design pattern is a common solution when you need to represent the outline of an algorithm and have the additional flexibility to change certain parts of it. In other words, the template method pattern is useful when you ind yourself in a situation such as "I’d love to use this algorithm but I need to change a few lines so it does what I want."

A Template Method Pattern contains a method that provides the steps of the algorithm. It allows subclasses to override some of the methods.

Tuesday, February 5, 2013

Custom Converters

To make custom converter I found 4 ways of doing it:
  1. using Map in Bean object
  2. parsing Object to String
  3. using static Map
  4. defining inner class in backing bean

Using Map in Bean

In Bean class you need to have Map<key, Object>.
In converters getAsObject method you read object value from this map.

public Object getAsObject(FacesContext context, UIComponent component, String value) throws ConverterException
{
if (context == null) throw new NullPointerException("context");
if (component == null) throw new NullPointerException("component");
if (value == null || value.isEmpty()) return null;
// value je oid recorda

FacesContext ctx = FacesContext.getCurrentInstance();
ValueExpression vex = ctx.getApplication().getExpressionFactory().createValueExpression(ctx.getELContext(), "#{billViewBean}", BillViewBean.class);
BillViewBean view = (BillViewBean) vex.getValue(ctx.getELContext());

TowRecord record;
record = view.getRecordsMap().get(value);
if (record == null)
{

FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, "Unknown value", "The record is unknown!");
throw new ConverterException(message);
}

return record;
}


public String getAsString(FacesContext context, UIComponent component, Object value) throws ConverterException
{
if (context == null) throw new NullPointerException("context");
if (component == null) throw new NullPointerException("component");
if (value == null) return null;
if (!(value instanceof TowRecord))
{
log.error("Error converting TowRecord to String: Object is not an instance of TowRecord.");
throw new ConverterException("Object is not an instance of TowRecord.");
}

TowRecord record = (TowRecord) value;
return record.getOid();
}
    Ref: JSF 2.0 Cookbook: Using custom converters for h:selectOneMenu


Parsing Object to String

If using this approach you could be in problems with JPA.
Also if object if composed with many minor objects it can be heavy to parse to and from object.

public Object getAsObject(FacesContext context, UIComponent component, String value) throws ConverterException
{
if (value == null || value.isEmpty()) return null;

String[] attributes = StringUtils.delimitedListToStringArray(value, DELIMITER);

TowRecord record = new TowRecord(attributes[0], attributes[1], attributes[2]);
log.debug("Converter to object: " + record.getOid() + ", " + record.getNumber() + ", " + record.getRegistration().getLicensePlate());
return record;
}

public String getAsString(FacesContext context, UIComponent component, Object value) throws ConverterException
{
if (value == null)
return null;
else if (!(value instanceof TowRecord))
{
log.error("Error converting TowRecord to String: Object is not an instance of TowRecord.");
throw new ConverterException("Object is not an instance of TowRecord.");
}
else
{
TowRecord record = (TowRecord) value;
String recordString = record.getOid() + DELIMITER + record.getNumber() + DELIMITER + record.getRegistration().getLicensePlate();

log.debug("Converted record to String " + recordString);
return recordString;
}
}

   Ref: Core JavaServer Faces  3rd Edition: Implementing Custom Converter Classes


Using static Map

You create class that will hold static maps, and from converter class you can easily access it.
Drawback is that you need to be careful how many object you can put in map.. memory issue.

public class MapHolder

{
private static Map<String, AbstractDOM> recordsMap = Collections.synchronizedMap(new HashMap<String, AbstractDOM>());

public static Map<String, AbstractDOM> getRecordsMap()
{
return recordsMap;
}
}

public class TowRecordsSTATICConverter implements Converter :
public Object getAsObject(FacesContext context, UIComponent component, String value) throws ConverterException
{
if (value == null || value.isEmpty()) return null;

return MapHolder.getRecordsMap().get(value);
}

public String getAsString(FacesContext context, UIComponent component, Object value) throws ConverterException
{
if (value == null)
return null;
else if (!(value instanceof TowRecord))
{
log.error("Error converting TowRecord to String: Object is not an instance of TowRecord.");
throw new ConverterException("Object is not an instance of TowRecord.");
}
else
{
TowRecord record = (TowRecord) value;
return record.getOid();
}
}


Inner class in backing bean

using this approach you have access to Collection defined and populated in backing bean.

In this example you define:
private List<ReasonDPT> reasonList = new ArrayList<ReasonDPT>();
In xhtml you register converter as converter="#{backingBean.reasonDPTConverter}"

private class ReasonDPTConverter implements Converter
{

@Override
public Object getAsObject(FacesContext context, UIComponent component, String value)
{
for (ReasonDPT o : reasonList)
{
if (o.getOid().equals(value)) return o;
}
return null;
}

@Override
public String getAsString(FacesContext context, UIComponent component, Object value)
{
if (value == null) { return ""; }
return ((ReasonDPT) value).getOid();
}
}