Strait Fram Singapuur

Few days back I came across Spring social API library developed to access social networking sites from within the Java programs and finally Today I got chance to explore it :)

The current milestone includes templates for Twitter, Facebook and LinkedIn. These templates provide an easy way to access each social networking site and make integrating with those sites relatively straight forward. Each of these templates extend Spring's RestTemplate which is a generic template for accessing REST based web services. All hard core fans of Spring's JDBCTemplate and HibernateTemplate will love this.

To use Spring social:
1. Set up developer account with target social networking site.
2. Request an OAuth token from the target social networking site for each new user.
3. Use the right Spring Source template (e.g TwitterTemplate), passing in the developer keys (ApiKey and ApiSecret) as well as OAuth key for the current user.
4. Thats all :)

Once authorized, the application code required to access any given social site is very easy, so easy that even MBA guy can do it!

Check it out:

//Get Twitter template
TwitterTemplate twitter = new TwitterTemplate(apiKey, apiSecret, accessToken, accessTokenSecret);
twitter.updateStatus("Hey, I'm tweeting with #Spring Social! wow");

//Get Facebbook template
FacebookTemplate facebook = new FacebookTemplate(accessToken);
facebook.updateStatus("Hey, I'm posting with #Spring Social! wow");

//Get LinkedIn template
LinkedInTemplate template = new LinkedInTemplate(apiKey, apiSecret, accessToken, accessTokenSecret);
List <linkedinprofile> connections = template.getConnections(); 

The OAuth authorization part is not as clean as I would have liked. SpringSource has created a reference implementation called Greenhouse to demonstrate how to use the API.

Don't know what is OAuth?
So what is up with this OAuth. In just a few words, it is an authentication service. As an application you forward a visitor to the authentication service. The visitor authenticates itself and your application receives the result using a callback. If the result is positive, the visitor has authorized your application to act on the behalf of the visitor. That way you can use services of the provider without knowing who you are dealing with. It is also possible to store the provided authentication for future use (Greenhouse has this featute).

However we can also use some other OAuth libraries to avoid complexities in GreenHouse API and then just use the REST-like APIs of each service by directly manipulating URLs. The most interesting, easy to use and simple I found is Scribe, its a cool API that provides support for Facebook, Google ,Yahoo, LinkedIn, Twitter, Foursquare, Evernote, Vimeo and Yammer.

The latest version is 1.0.9 that should include Facebook API (as per GitHub), as of now this change is not available for 1.0.9 version in maven, I built it manually getting source from github repository.
You can pull scribe from a maven repository, just add this to your pom.xml file.

org.scribe
scribe
1.0.9

Now its time to create the OAuthService object
The OAuthService is the one you use to sign your requests. You create it using Scribe’s ServiceBuilder like shown below.

You can use the Facebook 'SpringSocialAPI' app that I created, details are:
Application ID: 175348469171013
Application Secret: c3301704fdd6da30b5b8ab68f9808b09

String apiKey = "c97dc03050b89baf893347f40f177d55";
    String apiSecret = "c3301704fdd6da30b5b8ab68f9808b09";
    OAuthService service = new ServiceBuilder()
                                  .provider(FacebookApi.class)
                                  .apiKey(apiKey)
                                  .apiSecret(apiSecret)
                                  .callback("http://localhost:8080/social/callback.jsp")
                                  .build();

The token will be generated and will be available on the mentioned callback url.

You need to get a request token, like this:
Token requestToken = service.getRequestToken();
String your_token = requestToken.getToken();

Now go authorize it! for this make a request to the authorize url (this varies between apis).
For Facebook this is it: https://graph.facebook.com/me?oauth_token=YOUR_TOKEN_HERE

Thanks, see u soon!!!

• Joint Account – Account having multiple owners.
• Cash Account: The basic account where you deposit cash to buy stocks, bonds, mutual funds, etc. 
• Margin Account: - Margin basically allows you to borrow from your broker against the cash and securities in your account. Profits can diminish quickly when you use margin, so be very careful!
• Forex Account etc.

• A market order is an order to buy or sell immediately at the best available price. These orders do not guarantee a price, but they do guarantee the order's immediate execution. Typically, if you are going to buy a stock, then you will pay a price near the posted ask. If you are going to sell a stock, you will receive a price near the posted bid. 
• A limit order sets the maximum or minimum price at which you are willing to buy or sell. For example, if you wanted to buy a stock at $10, you could enter a limit order for this amount. This means that you would not pay a penny over $10 for the particular stock. It is still possible, however, that you buy it for less than the $10.

Source- wikipedia & encyclopedia

Recently I came across a situation where I had to create a jar file with similar contents as of some other available jar. As using maven we cannot copy one jar file within another and also I didn't want to reinvent the wheel again so here is how I achieved the same.


Let's say there is an artifact 'sandeep-ejb-client' (some client ejb jar which has some dependency on some other artifacts say log4j and junit)
What I am interested is in creating a new jar file that has all the ejb client classes without including dependencies of 'sandeep-ejb-client'.


Here is the POM file to achieve the same:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

 <modelVersion>4.0.0</modelVersion>
 <groupId>com.test.gognamunish</groupId>
 <artifactId>Test</artifactId>
 <version>1_0_0</version>
 <name>Test JAR</name>
 <packaging>jar</packaging>
 <build>
  <plugins>
   <plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
     <execution>
      <id>${project.artifactId}-fetch-deps</id>
      <phase>generate-sources</phase>
      <goals>
       <goal>unpack-dependencies</goal>
      </goals>
      <configuration>
       <outputDirectory>${project.build.outputDirectory}</outputDirectory>
       <stripVersion>true</stripVersion>
       <excludeTransitive>true</excludeTransitive>
       <excludeArtifactIds>log4j,junit</excludeArtifactIds>
      </configuration>
     </execution>
    </executions>
   </plugin>
  </plugins>
 </build>

 <dependencies>
  <dependency>
   <groupId>com.ejb.sandeepkadyan</groupId>
   <artifactId>sandeep-ejb-client</artifactId>
   <version>1_0_0</version>
  </dependency>
 </dependencies>

</project>

That's All, Simple? If anyone has got better approach please feel free to discuss !!!


- Munish

We all are familiar with log4j and use it in our projects to log various information. One of the most stunning features of log4j API is its manageability. Once the log statements have been inserted into the code, they can be controlled with configuration files. They can be selectively enabled or disabled, and sent to different and multiple output targets in user-chosen formats. Though there is nothing special in today's post yet it could be helpful to most of people out there. 
So let's get started....
Log4j has three main components: loggers, appenders and layouts.These three types of components work together to enable developers to log messages according to message type and level, and to control at runtime how these messages are formatted and where they are reported.
Loggers: are named entities. Logger names are case-sensitive and they follow the hierarchical naming rule. For example, the logger named "com.mg.log4j.test" is a parent of the logger named "com.mg.log4j.test.Log4j"  same as "java" is a parent of "java.util" and an ancestor of "java.util.Vector". This naming scheme is familiar to most of us. Loggers may also be assigned levels. The set of possible levels, that is: TRACE, DEBUG, INFO, WARN, ERROR and FATAL (For the standard levels, we have DEBUG < INFO < WARN < ERROR < FATAL)
Appenders and Layouts: The ability to selectively enable or disable logging requests based on their logger is only part of the picture. Log4j allows logging requests to print to multiple destinations. In log4j speak, an output destination is called an appender. Currently, appenders exist for the console, files, GUI components, remote socket servers, JMS, NT Event Loggers, and remote UNIX Syslog daemons. It is also possible to log asynchronously.
The PatternLayout, part of the standard log4j distribution, lets the user specify the output format according to conversion patterns similar to the C language printf function.
For example, the PatternLayout with the conversion pattern "%r [%t] %-5p %c - %m%n" will output something akin to:
12 [main] INFO  com.mg.log4j.test - Happy New Year !!!
The first field is the number of milliseconds elapsed since the start of the program. The second field is the thread making the log request. The third field is the level of the log statement. The fourth field is the name of the logger associated with the log request. The text after the '-' is the message of the statement.
Also more than one appender can be attached to a logger.
Lets understand all with some example.
log4j.xml (should be in classpath, for a quick eclipse run keep it in src folder)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

 <!-- Append messages to the console -->
 <appender name="console" class="org.apache.log4j.ConsoleAppender">
  <param name="Target" value="System.out" />
  <param name="Threshold" value="DEBUG" />
  <layout class="org.apache.log4j.PatternLayout">
   <param name="ConversionPattern" value="%d{ABSOLUTE} %5p [%c{1}:%L] - %m%n" />
  </layout>
 </appender>

 <!--
  Append messages to the file file.log , creating a new file once the
  size of file exceeds 1KB
 -->
 <appender name="file" class="org.apache.log4j.RollingFileAppender">
  <param name="file" value="C:/devel/workspace/log4j/file.log" />
  <param name="MaxFileSize" value="1KB" />
  <param name="Threshold" value="DEBUG" />
  <param name="Append" value="true" />
  <!-- maximum number of backup files that will be created -->
  <param name="maxBackupIndex" value="5" />
  <layout class="org.apache.log4j.PatternLayout">
   <param name="ConversionPattern" value="%d{dd-MMM-yy HH:mm:ss} %5p [%c{1}] - %m%n" />
  </layout>
 </appender>


 <!-- The level is set to WARN -->
 <logger name="com.mg.log4j">
  <level value="WARN" />
  <appender-ref ref="console" />
 </logger>


 <!-- The level is set to DEBUG -->
 <logger name="FileAppener">
  <level value="DEBUG" />
  <appender-ref ref="file" />
 </logger>

 <root>
  <priority value="ALL" />
 </root>

</log4j:configuration>

Let's test this configuration...

package com.mg.log4j.test;

import org.apache.log4j.Logger;

public class Log4j {

 public static void main(String[] args) {
  // Get the default console appender, level is WARN
  // Note as you can see there is no such appender
  // 'com.mg.log4j.test.Log4j' defined in log4j.xml file, it fall backs on
  // the parent package
  Logger logger = Logger.getLogger("com.mg.log4j.test.Log4j");

  // Remember: The hierarchy is DEBUG < INFO < WARN < ERROR < FATAL

  // This request is not enabled as INFO < WARN
  logger.info("INFO");
  // This request is not enabled as DEBUG < WARN
  logger.debug("DEBUG");
  // This request is enabled as FATAL > WARN
  logger.fatal("FATAL");
  // This request is enabled as ERROR > WARN
  logger.error("ERROR");
  // This request is enabled as WARN >= WARN
  logger.warn("WARN");

  // // let's write to file appender now, level is DEBUG meaning it will
  // log everything
  logger = Logger.getLogger("FileAppener");
  for (int i = 1; i < 100; i++)
   logger.info("log me to file please, i want to see what happens after the size exceeds 1KB");

 }

}

OUTPUT:
11:44:35,984 FATAL [Log4j:21] - FATAL
11:44:35,987 ERROR [Log4j:23] - ERROR
11:44:35,987 WARN [Log4j:25] - WARN
and six log files - file.log, file1.log, file2.log, file3.log, file4.log and file5.log ( ignoring rest of the log statements after file5.log file because our threshhold limit for backup files was 5)


Please make sure that in real code you always check before logging, something like:
if(logger.isDebugEnabled())
logger.debug("Log only if debug is enabled");


Hope this small capsule will be helpful in some or other way. For more detailed understanding of log4j please visit official page at -  http://logging.apache.org/log4j/index.html

Wish you all a happy new year !!!!