Persisting information with Cassandra in java: Simple example

This article has the main objective show a little example for persist information in Cassandra using java.

• ColumnFamilyValue: annotations for identify the family column name

• ColumnValue: for identify the column in the Family Column, the classes can be used are:

• java.lang.Boolean
• java.util.Date
• java.lang.Double
• java.lang.Float
• java.lang.Integer
• java.lang.Long
• java.lang.String

• EmbeddedValue: The class with this is annotation has fields with ColumnValue inside itself, but the persistence way continues in the same Family of the Column. This annotation is to do the object’s modeling easily.

• EnumeratedValue: for be used in Enums

• IndexValue: The field with this annotation is an index, can search and retrieve information from the row like KeyValue, need also use the ColumnValue together with this annotation.

• KeyValue: The field with this annotation is an Key of the Row. If the auto value is true will generate auto increment, each new Key in the FamilyColumn there are a new value auto numeric.

• JDK 7 or above

• Apache Cassandra is running here
• Create the Keystore and Family column here
• Do annotations in the class Annotations
• Realize call for save the object in Cassandra Here
• Add Easy-Cassandra's Lib lhere
• Add Thrift Dependence: Easy Cassandra with Thrift dependences

• Do download of the apache-cassandra in: Here
• After that, unzip the file downloaded and enter it.
• Execute the command when you stay in Cassandra home:

• For execute the client's mode, also in Cassandra'home execute the command bellow:

• In the Client's mode run the script bellow:

• Download and add in ClassPath of the Project, the Easy-Cassandra's lib:
• You will have two choices of Download:

• Only the Easy-Cassandra's lib
• The Easy-Cassandra's lib with its dependencies (The Libs of the Thrift)

Party 10 year with Eclipse, around the Brazil

Welcome java 7 part 3 -NIO 2 JSR 203

Welcome java 7 part 3 -NIO 2 JSR 203

So like the coin project, in the NIO 2 there aren't unprecedented features in this e -specification, but now it's possible do some easier work I/Os in java. With the class java.io.Files are possible to perform several operations in simple mode. For that it needs and uses the java.io.file.Path, this interface represents files and directories in the operating system.

 Path path=Paths.get("file.txt");

Picture 1: Making a path, the String “file.txt” can be replace for any path in operating system, it's should directories, files, symbolic link and hard link.

    public static void moveFile(Path arquivoOrigem, Path arquivoDestino) throws Exception { 
         Files.move(arquivoOrigem, arquivoDestino, StandardCopyOption.REPLACE_EXISTING); 
     }

 

     public static void copyFile(Path arquivoOrigem, Path arquivoDestino) throws Exception { 
         Files.copy(arquivoOrigem, arquivoDestino, StandardCopyOption.REPLACE_EXISTING); 
     }

 

     public static void deleteFile(Path arquivo) throws Exception { 
         Files.delete(arquivo); 
     }

 

     public static Path createFile(String arquivo) throws Exception { 
         return Files.createFile(Paths.get(arquivo)); 
     }

 

     public static Path createDictory(String diretorio) throws Exception { 
         return Files.createDirectories(Paths.get(diretorio)); 
     }

 

     public static void creatSymbolicLink(Path linkSimbolico, Path arquivo) throws Exception { 
         Files.createSymbolicLink(linkSimbolico, arquivo); 
     }

 

     public static void createLink(Path link, Path arquivo) throws Exception { 
         Files.createLink(link, arquivo); 
     }

Picture 2: I/O's operations using the java.nio.Files

It's possible retrieve information in java.io.Path in an easier way, and can get more about one path with six new interfaces.

     public static void propertiesPath(Path path) throws Exception { 
  
         System.out.println("size in  bytes " + Files.size(path)); 
         System.out.println("is directory ? " + Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS)); 
         System.out.println("is regular ? " + Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)); 
         System.out.println("is hidden " + Files.isHidden(path)); 
         System.out.println("last modified " + Files.getLastModifiedTime(path, LinkOption.NOFOLLOW_LINKS)); 
         System.out.println("owner " + Files.getOwner(path, LinkOption.NOFOLLOW_LINKS)); 
  
  
         System.out.println("\n \n \n Basic Files attributes \n \n \n "); 
         BasicFileAttributes attr = Files.readAttributes(path, BasicFileAttributes.class); 
  
         System.out.println("creation time: " + attr.creationTime()); 
         System.out.println("last acess: " + attr.lastAccessTime()); 
         System.out.println("last modified: " + attr.lastModifiedTime()); 
  
         System.out.println("is directory " + attr.isDirectory()); 
         System.out.println("is other " + attr.isOther()); 
         System.out.println("is  regular: " + attr.isRegularFile()); 
         System.out.println("symbolic link: " + attr.isSymbolicLink()); 
         System.out.println("tamanho: " + attr.size()); 
  
         System.out.println("\n \n \n Dos atributes file \n \n \n "); 
  
         DosFileAttributes dosAttr = Files.readAttributes(path, DosFileAttributes.class); 
         System.out.println(" only read " + dosAttr.isReadOnly()); 
         System.out.println("hidden " + dosAttr.isHidden()); 
         System.out.println("file " + dosAttr.isArchive()); 
         System.out.println("system file " + dosAttr.isSystem()); 
 //The other interfaces 
 //PosixFileAttributeView 
 //FileOwnerAttributeView 
 //AclFileAttributeView  
 //UserDefinedFileAttributeView  
     }

Picture 3: get more with new interfaces

Now in NIO2 read and write in scalable manner is possible with the java.nio.channels.FileChannel, for example some big documents can use three Threads for reading and writing in quick mode.

     public static void acessoEscalavel(Path path) throws Exception { 
         String s = "I was here!\n"; 
         byte data[] = s.getBytes(); 
         ByteBuffer out = ByteBuffer.wrap(data); 
  
         ByteBuffer copy = ByteBuffer.allocate(12); 
  
         try (FileChannel fc = (FileChannel.open(path, StandardOpenOption.READ, StandardOpenOption.WRITE))) { 
             //read  
             int nread; 
             do { 
                 nread = fc.read(copy); 
                 byte[] bytearr = copy.array(); 
  
                 String ss = new String(bytearr); 
                 System.out.println("lendo: " + ss); 
  
             } while (nread != -1 && copy.hasRemaining()); 
  
             //write in the begin file 
             fc.position(0); 
             while (out.hasRemaining()) { 
  
                 fc.write(out); 
             } 
  
             out.rewind(); 
  
             
             long length = fc.size(); 
             fc.position(length - 1); 
             copy.flip(); 
             while (copy.hasRemaining()) { 
                 fc.write(copy); 
             } 
             while (out.hasRemaining()) { 
                 fc.write(out); 
             } 
         } catch (IOException x) { 
             System.out.println("I/O Exception: " + x); 
         } 
  
  
  
     } 

Picture 3: write and read from FileChannel

In Path it is also possible to read and write in a normal way like with the java.io.File.

     public static void readFile(Path arquivo) throws Exception { 
         Charset charset = Charset.forName("UTF-8"); 
 

 

         String strLine = null; 
         try (BufferedReader reader = Files.newBufferedReader(arquivo, charset)) { 
 

             while ((strLine = reader.readLine()) != null) { 
 

                 System.out.println("file line  " + strLine); 
 

             }

         } catch (IOException x) { 
             System.err.format("IOException: %s%n", x); 
         }

 

     }

 

     public static void writeFile(Path arquivo, String texto) throws Exception { 
 

         Charset charset = Charset.forName("UTF-8"); 
 

 

         try (BufferedWriter writer = Files.newBufferedWriter(arquivo, charset)) { 
             writer.write(texto, 0, texto.length()); 
 

         } catch (IOException x) { 
            System.err.format("IOException: %s%n", x); 
         }

 

     }

Picture 4: Writing and reading with the Path interface

Conclusion:

This article discusses the package NIO2, showing big features for facilitating I/Os process.

Welcome java 7 - Part 1

After a long 5 year wait, finally comes the new version of Java,  jdk 7. The entire Java 7 project was divided into two sub-projects:

• The coin project; which featured a few improvements to the language like switch with strings, mutil try etc.

• Lamba's project containing some of the most innovative and complex features results in leaving the language a lot more dynamic.

In order to launch this new version, which will be used primarily to develop the coin project and lambda project scheduled for release in 2012 along with  java 8, constant updates have had to be made. These innovations are not only a welcome development for commercial applications, but also on other platforms, for example, in Java EE 7 which is being developed on top of this new jdk.

This version contains JSR 392 the, Da Vinci Machine project whose main objective is to introducenew  languages to the JVM (java virtual machine). The idea is to use external bytecodes in JVM (invoke Dynamic) so when future languages in the JVM are released, the existing languages will process a lot faster, the Jruby( Ruby version run in JVM) for example, will not need about two thousand classes. Some other cool information is the open jdk now is the reference implementation.

New Improvements to Java 7

JSR 292: The Da Vinci machine project of which the main objective is to cater for more languages in the JVM.

JSR 334: Little features in Java like switch with String which i will expand on below.

Some modifications have been made to the API class-loader to avoid deadlocks in non-hierarchical class-loader topologies.

JSR 166y: Updates in API's concurrency also in API's Collections.

Improvement to internationalization like upgrading to Unicode 6.0 java.util.Locale to suport IETF BCP 47 (Tags identifying languages) e UTR 35 (dates local Markup Language)

JSR 203: New APIs for filesystem access, scalable asynchronous I/O operations, socket-channel binding and configuration, and multicast datagrams

A portable implementation of the standard Elliptic Curve Cryptographic (ECC) algorithms, so that all Java applications can use ECC out-of-the-box.

Update to JDBC 4.1 Among its improvements is the automatic closing of connections and the RowSet 1.1 now can support all cand data supported by JDBC Driver.

New improvements to some graphics components like the new Java2D pipeline with base extensions Xrender X11, provides similar functionality to the modern GPU. Window graphics are well done, with translucent resources. Ther is also a new look and feel Nimbus theme of Swing component, and the new Jlayer decorator component allows you to apply many effects inside its border.

Updates for JAXP 1.4, JAXB 2.2a, e JAX-WS 2.2.

Improvement to MBeans com.sun.management which is important for reporting CPU processes about the JVM.