Using Sorted Sets with Jedis API

Sorted Sets and Jedis

In the previous post we started looking into Jedis API a Java Redis Client.
In this post we will look into the Sorted Set(zsets).

Sorted Set works like a Set in the way it doesn’t allow duplicated values. The big difference is that in Sorted Set each element has a score in order to keep the elements sorted.

We can see some  commands below:

import java.util.HashMap;
import java.util.Map;

import redis.clients.jedis.Jedis;
public class TestJedis {

public static void main(String[] args) {
 String key = "mostUsedLanguages";
 Jedis jedis = new Jedis("localhost");
 //Adding a value with score to the set
 jedis.zadd(key,100,"Java");//ZADD

 //We could add more than one value in one calling
 Map<Double, String> scoreMembers = new HashMap<Double, String>();
 scoreMembers.put(90d, "Python");
 scoreMembers.put(80d, "Javascript");
 jedis.zadd(key, scoreMembers);

 //We could get the score for a member
 System.out.println("Number of Java users:" + jedis.zscore(key, "Java"));

 //We could get the number of elements on the set
 System.out.println("Number of elements:" + jedis.zcard(key));//ZCARD
 }
}

In the example above we saw some Zset commands. To add elements to the zet we set the zadd method, the difference for the sets is that we pass also the score for the element. There is a overloaded version that we can pass many values using a map. The zadd could be used for both add and update the score for an existing element.

We can get a score for a given element with the zscore and the number of elements using the zcard command.

Below we can see other commands from zsets:


import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
public class TestJedis {

public static void main(String[] args) {
 String key = "mostUsedLanguages";
 Jedis jedis = new Jedis("localhost");

 //get all the elements sorted from bottom to top
 System.out.println(jedis.zrange(key, 0, -1));

 //get all the elements sorted from top to bottom
 System.out.println(jedis.zrevrange(key, 0, -1));
 //We could get the elements with the associated score
 Set<Tuple> elements = jedis.zrevrangeWithScores(key, 0, -1);
 for(Tuple tuple: elements){
 System.out.println(tuple.getElement() + "-" + tuple.getScore());
 }

 //We can increment a score for a element using ZINCRBY
 System.out.println("Score before zincrby:" + jedis.zscore(key, "Python"));
 //Incrementing the element score
 jedis.zincrby(key, 1, "Python");
 System.out.println("Score after zincrby:" + jedis.zscore(key, "Python"));
 }
}

With the zrange we can get the elements for the given range. It returns the elements sorted from bottom to top. We can get the elements from top to bottom using the method zrevrrange. Redis also allow us to get the elements with the associated scores. In redis we pass the option “withscores“. With Jedis API we use the method zrevrangeWithScores that returns a Set of Tuple objects. Other useful command is  zincrby that we can increment the score for a member in the set.

There are other commands for zsets, this post was intended only to show some basical usage with Jedis API.
We can find a good use case for sorted sets in this post.

See you in the next post.

Advertisements

Getting Started With Jedis

Hi,

These days I started looking into Redis. I’ve heard a lot about it so I decided to have a try.

Redis is defined in its websites as “an open source, advanced key-value store. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets and sorted sets“.

We can find very good examples on where Redis is a good fit on the Shades of Gray blog.

In this post we will not focus on the features and capabilities of Redis, we will have a quick look at Jedis, a Java Redis Client.

The Redis commands are very simple to learn, the Jedis api, it is also very simple to learn.

We can download the Jedis on its github repository (https://github.com/xetorthio/jedis). It is a simple jar that we can just add it to our application and start using it.

Below we can see a simple example of the Jedis api:


import redis.clients.jedis.Jedis;
public class TestJedis {

public static void main(String[] args) {
  //Connecting to Redis on localhost
  Jedis jedis = new Jedis("localhost");
  //adding a new key
  jedis.set("key", "value");
  //getting the key value
  System.out.println(jedis.get("key"));

 }

}

On the example above, we create a connection to the redis server, once we connect we add a new key on the datastore, using the method set, this method will call the SET command on Redis. With that we created a new key called “key” with a value “value”.Once we have a value for that key, we can get its value using the method get which calls the GET command on Redis.

A very useful command is the INCR that increments a key value. We can see an example of using this command below:

import redis.clients.jedis.Jedis;
public class IncrTest {

public static void main(String[] args) {
 Jedis jedis = new Jedis("localhost");
 System.out.println(jedis.get("counter"));
 jedis.incr("counter");
 System.out.println(jedis.get("counter"));
 }

}

One of the good use cases for Redis is caching. We can use it as caching system, it is very good for that because we can set a expiration time for a given key through the EXPIRE commad. Also we can get the TTL for the key using the TTL command. Below we can see an example with Jedis api.

import redis.clients.jedis.Jedis;
public class TestJedis {

public static void main(String[] args) throws InterruptedException {
 String cacheKey = "cachekey";
 Jedis jedis = new Jedis("localhost");
 //adding a new key
 jedis.set(cacheKey, "cached value");
 //setting the TTL in seconds
 jedis.expire(cacheKey, 15);
 //Getting the remaining ttl
 System.out.println("TTL:" + jedis.ttl(cacheKey));
 Thread.sleep(1000);
 System.out.println("TTL:" + jedis.ttl(cacheKey));
 //Getting the cache value
 System.out.println("Cached Value:" + jedis.get(cacheKey));

 //Wait for the TTL finishs
 Thread.sleep(15000);

 //trying to get the expired key
 System.out.println("Expired Key:" + jedis.get(cacheKey));
 }

}

Also redis can store some other values like Lists, Hashs, set and others. Below we can see an example of using Sets in Redis.

import redis.clients.jedis.Jedis;
public class TestJedis {

public static void main(String[] args) {
 String cacheKey = "languages";
 Jedis jedis = new Jedis("localhost");
 //Adding a set as value
 jedis.sadd(cacheKey,"Java","C#","Python");//SADD

 //Getting all values in the set: SMEMBERS
 System.out.println("Languages: " + jedis.smembers(cacheKey));
 //Adding new values
 jedis.sadd(cacheKey,"Java","Ruby");
 //Getting the values... it doesn't allow duplicates
 System.out.println("Languages: " + jedis.smembers(cacheKey));

 }

}

There are many other use cases for Redis, this post was intended to give an little introduction to the Jedis library.
See you in the next post

Batch Insert with JDBC

Hi,

In the current project I’m working on, we had a requirement to import some data from an Excel Spreadsheet and import them into the database. So, bascially we need to read from the spreadsheet and insert into the database. Initally we started using single insert statements, but we realized that wouldn’t be a good choice, for performance reasons. If we have a spreadsheet with too much data, we could decrease the database performance with so many single statements executed.

JDBC offers support for batch statements, follows a simple example of batch insert using prepared statements:


package com.xicojunior.db;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;


import com.xicojunior.factory.ConnectionFactory;

public class BatchInserter {
	
	public static void main(String args[]) throws SQLException{
		Connection conn = null;
		PreparedStatement statement = null;
		
		try {
			conn = ConnectionFactory.getConnection();
			statement = conn.prepareStatement("INSERT INTO USER values(?,?,?)");
			
			
			statement.setInt(1, 3);
			statement.setString(2, "User01");
			statement.setString(3, "user1@usersmine.com");
			
			statement.addBatch();
			
			statement.setInt(1, 4);
			statement.setString(2, "User02");
			statement.setString(3, "user2@usersmine.com");
			
			statement.addBatch();
			
			int[] results = statement.executeBatch();
			
			
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			
			conn.close();
			statement.close();
		}
		
	}
	
}

This code could be changed for example for some other batch operations like update.

Thanks and see you on the next post.

Private variables in javascript

In OOP we learned the importance of the encapsulation.
In java we could encapsulate a variable through the
keyword private, that says that variable is visible only in
that object.

In javascript we don’t have a specific keyword like that, but
there are different ways to accomplish this behavior.

In this post I’ll talk about two ways of doing that:

1- Declaring function scoped variables using var:

Let’s say we have an contructor function called User,
and this function defines that an user object will have the following
properties:

name, phone, email, password

We could see the constructor function below:

	function User(name, phone,email, pass){
		this.name = name;
		this.phone = phone;
		this.email = email;
		this.password = pass;
	}

With this constructor all those properties are visible outside the function as we
could see below:

	user = new User("John Doe","888-888-888","john@doe.com","pass123");
	console.log("Name:"+ user.name);
	console.log("Phone:"+ user.phone);
	console.log("Email:"+ user.email);
	console.log("Pass:"+ user.password);//do we really like this be available????

One of the ways we can make that property password be visible only for the function is using the var keyword:

	function User(name, phone,email, pass){
		this.name = name;
		this.phone = phone;
		this.email = email;
		var password = pass;
	}

	user = new User("John Doe","888-888-888","john@doe.com","pass123");
	console.log("Name:"+ user.name);
	console.log("Phone:"+ user.phone);
	console.log("Email:"+ user.email);
	console.log("Pass:"+ user.password);//undefined -- now we can't access that

And to make that property available we can have a public method that exposes or change the variable value

	function User(name, phone,email, pass){
		this.name = name;
		this.phone = phone;
		this.email = email;
		var password = pass;

		this.myPassword = function(){
			var protectedPass= '';
			for(var i=0,count = password.length; i< count; i++){				
                             protectedPass += "*";
			}
			return protectedPass ;
		}
	}

	user = new User("John Doe","888-888-888","john@doe.com","pass123");
	console.log("Name:"+ user.name);
	console.log("Phone:"+ user.phone);
	console.log("Email:"+ user.email);
	console.log("Pass:"+ user.password);//undefined -- now we can't access that
	console.log("Protected Password:" + user.myPassword());

2- Using Module Pattern

You can find a better description of the module pattern here:
http://addyosmani.com/resources/essentialjsdesignpatterns/book/#modulepatternjavascript

It is another way to promote encapsulation using Javascript.

A simple module can be seen in the code below:


moduleTest = (function(){
	return {
		displayMessage: function(msg){
			console.log("Displaying Message: " + msg);
		}
	};
})();

moduleTest.displayMessage("Testing the module");

Now let us see how we can use the Module Pattern to create private variables.
So let’s create the user class using the Module Pattern:


User = (function(){
	var password = "";

	function changePassword(newPass){
		password = newPass;
	};

	return function(name,email,phone,pass){
		this.name = name;
		this.email = email;
		this.phone = phone;
		password = pass;
		this.showMyPassword= function(){
			console.log(password.replace(/./g,"*"))
		};

		this.newPassword = function(){
			changePassword("123passwordNew");
			console.log("Password Changed!!");
		};
	};
})();

user = new User("John Doe", "john@doe.com",888-888-888,"pass123");
user.showMyPassword();
user.newPassword();
user.showMyPassword();

Using this pattern, the variable password and the function changePassword are not visible
oustide the module, but they are visible to the returned function through closure.

These are some of the ways to create private variables in javascript,
the first one seems to be simpler than the second one. But I think the second one
more elegant than the first.

Using the var keyword in the constructor function we would make the function too much bloated.
But using the module pattern, we can declare the private variable and functions inside the module,
and expose through the returned function or object.

That’s it.
See you in the next post.

Playing with classes and objects in Javascript

So, let’s play a little bit with classes and objects in Javascript. If you come from the class based languages like Java and C++, the way we handle classes in javascript looks a little bit strange. First, javascript is not class based, so, it doesn’t have the entity class. A class in javascript is a function. So we can see a simple class in the example below:

MyClass = function(){
};
var instance = new MyClass();

So, to create a new class in javascript we only need to define a new function.

As we know, class has attributes. We could  add attributes to our class this way:

MyClass = function(){
  this.attribute = 'Hello';
}
var instance = new MyClass();
alert(instance.attribute);

So, it is not too different as we have on other languages.

We also could pass parameters in the constructor , so we can initialize the class attributes.

MyClass = function(attrValue){
  this.attribute = attrValue;
}
var instance = new MyClass("Hello Class");
alert(instance.attribute);

We can do the same for  functions on our class:

MyClass = function(attrValue){
  this.attribute = attrValue;
  this.classFunction = function (){alert('Class function')};
}
var instance = new MyClass("Hello Class");
alert(instance.attribute);
instance.classFunction();

Let’s us create a new class called Person. It should have two attributes: name and age, and a function toString that should display its attributes values. The code will be like this:

var Person = function(){
	this.name = '';
	this.age = '';
	this.toString = function(){
		return "Name:"+ this.name + " - Age:" + this.age;
	};
}
var onePerson = new Person();
onePerson.name = 'Junior';
onePerson.age = '23';

alert(onePerson.toString());

This was a simple introduction for classes on Javascript.

See you in the next post.

Dicas para conseguir o primeiro emprego/estágio em programação

Eu não sou um super especialista nesse assunto, mas aqui vão dicas que no meu ponto de vista me ajudaram a conseguir meu primeiro estágio, além de outras dicas que teriam me ajudado se soubesse na época 😉

Basicamente a lista se resume a um ponto:

Ganhe experiência com trabalho voluntário

Muitas das vagas de estágio pedem candidatos com experiência. Mas aí você se pergunta, “se é um estágio por que pedem experiência?”. Não vou entrar no mérito de isso estar certo ou errado, vou dar algumas dicas de como você pode ganhar experiência durante a faculdade.

Na faculdade posso dizer que ganhei experiência das seguintes formas:

  1. Monitor em um curso de Java:  Basicamente foi assim, um professor abriu um curso de extensão na faculdade de Java e eu e um colega nos oferecemos para ser monitores no curso. Na época, eu tinha um conhecimento básico da linguagem, mas já sabia fazer algumas besteirinhas como: configuração da IDE (Eclipse/JCreator), troubleshooting – “por que não tá compilando??”, “Tá dando erro na classe…”. Como disse, besteirinhas, mas como estávamos lá o professor não precisava checar cada problema, por que havia nós para fazer isso. Além da experiência, de quebra ainda assistia as aulas do curso e aprimorava o conhecimento.
  2. Grupo de estudos:  Grupos de estudo na faculdade são bastante interessantes, no meu caso, além do conhecimento adquirido durante os estudos, também ganhei um pouco de experiência trabalhando em pequenos projetos que a gente fazia para praticar a linguagem;
  3. Desenvolvedor Voluntário em Projeto Open-Source: Uma certa vez na faculdade uma pessoa foi fazer uma apresentação sobre um projeto open-source do qual ele era o líder e além disso era em Java. Essa pessoa é o Carlos Delfino e o projeto o SGAP. Durante a apresentação ele convidou quem estaria interessado em participar do projeto.  Eu e um colega (o mesmo da monitoria 🙂 ) resolvemos participar do projeto. E com certeza foi uma das melhores formas pelas quais eu consegui ganhar experiência. O Projeto era baseado no Struts, e utilizava outros frameworks como o Apache Commons Chain, Site Mesh entre outros.  Além disso aprendi bastante de Javascript. A verdade é que não trabalhei muito no projeto, mas durante o curto período de tempo em que fui voluntário consegui aprender bastante coisa. Na época pra quem sabia o básico de JSP e Servlets, eu realmente aprendi bastante coisa. Além de todo o conhecimento técnico, também tem a questão do trabalho voluntário que é bastante bem visto.

Bem, parece uma lista pequena, e na verdade é, mas isso me ajudou bastante na hora de conseguir um estágio. Por exemplo, uma certa vez apareceu uma vaga de estágio que pedia conhecimentos em Java e OO, Java Web e Struts. Eu e meu colega nos candidatamos a vaga, e pra nossa surpresa a pessoa respnsável pela seleção nos falou que  somente nós dois tinhamos o perfil O.O. Foi a partir daí que comecei a perceber a importância das coisas que fiz durante a faculdade e também ver que poderia ter feito mais.

De início parece complicado, mas é relativamente simples pra você conseguir experiência e conseqüentemente conseguir sua vaga no mercado.

Sendo assim, se hoje fosse começar a faculdade do Zero, essas seriam as minhas dicas:

  • Participe de grupos de estudo, se na sua faculdade não tem se junte com alguns colegas e professores e monte;
  • Faça amizade com seus professores: muitos além de serem professores, são profissionais e podem dar dicas ou até mesmo indicações para vagas;
  • Participe de grupos de discussão: por exemplo, um pouco tempo depois que consegui meu primeiro estágio é que fui descobrir que existia um Grupo de Usuários Java no Ceará, o CEJUG, que possui uma lista de discussão onde os membros podem postar dúvidas sobre Java, vagas, e discutir sobre Java e sua utilização. O bom é que além de você ficar sabendo das vagas, você fica por dentro das novidades da tecnologia: o que as empresas estão utilizando? o que deve estudar?, ou seja, você fica preparado para as mudanças no mercado. E ainda tem a questão do networking, que é bastante importante;
  • Projetos Open-Source: Esse pra mim acho que é um dos principais e seria algo em que investiria mais se soubesse da sua importância no início da faculdade. Importante por que: você pratica conhecimentos adquiridos na faculdade, conhece novas tecnologias, conhece outras pessoas que são membros do projeto, e fica muito bem visto pela comunidade por ser um contribuidor de software livre.
  • Inglês: Esse com certeza um dos mais, se não for o mais,  importantes pontos. Muita gente (incluindo eu) foca no aprendizado das tecnologias durante o início da faculdade e fica deixando o inglês de lado. Isso é um erro, por que na área de tecnologia é praticamente obrigatório o conhecimento da língua inglesa, vejamos algums motivos: grande parte, se não a maioria, do material disponível de estudo é disponibilizado em inglês; todas as novidades na área de tecnologia são divulgadas em inglês, o que significa que você não consegue se atualizar em determinada nova tecnologia por que não sabe inglês; e além disso tudo, o inglês abre fronteiras, por que se você tem um inglês afiado, você pode conseguir emprego não somente no Brasil mas praticamente no mundo todo. O Guilherme Chapiewski nos dá outros motivos.

Bom, espero que essas pequenas dicas possam lhe ajudar a alcançar o tão esperado primeiro emprego/estágio na área de programação. Sintam-se à vontade para sugerir outras dicas que não mencionei.

[]’s

Junior