Skip to main content

Understanding What Instrumentation is

By
It would be possible to change the Java bytecode of your classes?

It would be possible to create new procedures and change the body of his methods, even at runtime?

Yes, the answer is yes, this is possible!

Thanks to the APIs lowest level or higher level as java.lang.instrumentat and Apache BCEL among others.
 
For better transparency, you can always automatically generate code and add it to their classes. There are several frameworks. The java developer may be adding a simple enhancer code in their applications, which is relatively easy to do, with little intrusion into your creative process.

Byte code enhancement

Programs written in Java to compile a form of code called bytecode. The idea is through instrumentation, inject byte code to add services and still maintain transparency. For example, most implementations use an enhancer JDO bytecode.
Another excellent example was a project at IBM where test scenarios were created dynamically through bytecode instrumentation.
Often inject a code snippet actually is to inject methods that perform the work of their service it is intended, as with the intensifier source code in Figure below. Enhancement of the source code has a class as an input and then generate code, often called method to inject resources into service code, fully preserving transparency in the original class. Amazing, no?

Bytecode


JDO enhancers work like this: you create a class that is transparent with respect to persistence. The technique has many benefits:
 
- You do not have to make any changes to the source code. Ual!
- You do not imposes any restriction on their class, to completely preserve transparency.
- Code injection is fast at runtime. You have affected performance only in Build-time
 
Tasks like adding logs, code instrumentation for performance analysis, or methods of intercepting calls work fine with a simple injector code.

To have a deeper understanding of the topic, I recommend reading the following link:
http://docs.oracle.com/javase/7/docs/api/java/lang/instrument/package-summary.html
http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_orientada_a_aspecto
http://pt.wikipedia.org/wiki/AspectJ
Location: Moscow, Russia

Comments

Post a Comment

Popular posts from this blog

The Scala's Equivalent of Java ArrayList

By
ArrayList   is a widely misused "default"  List  in Java. It has terrible performance when elements are added/removed frequently, but works pretty well as a replacement for  Array .  But what about Scala? What is Scala's default collection? What Scala collection has characteristics similar to  ArrayList ? What's a good replacement for  Array   in Scala? So here are the answers for these: What is Scala's default collection? Scala's equivalent of Java's  List  interface is the  Seq . A more general interface exists as well, which is the  GenSeq  -- the main difference being that a  GenSeq  may have operations processed serially or in parallel, depending on the implementation. Because Scala allows programmers to use  Seq  as a factory, they don't often bother with defining a particular implementation unless they care about it. When they do, they'll usually pick either Scala's List  or  Vector . They are both immutable, and  Vector
Post a Comment
Read more

Always Use StringBuilder while concatenating Strings within loops

By
A common tendency of Java programmers is to always concatenate Strings using + operator. Which is actually very good, and simplifies the code by improves readability, since we would have to use StringBuilder.append(String), if the single + operator was not allowed. In fact if we look in byte code generate from such concatenation style, we will see a StringBuilder being used to perform the action. Check the JSL:    JLS Now , the point is, although this facility, you should not use the + operator in loop concatenation. Why? A new  StringBuilder  Object will be constructed at every single loop iteration (with initial value of str) and at the end of every iteration there will be concatenation with initial String (actually  StringBuilder  with initial value of  str ). So you need to create StringBuilder by yourself only when you work with String concatenation in loop. Let us procuce the evidence First, run this code, and see how long it takes to be executed: Now, bellow is th
Post a Comment
Read more

Maven Tips... and Tricks

By
Maven, one of the central actors in the Java World, resposible for managing the building life-cycles of many projects, is full of little features, that sometimes we forget to explore. Let us go straight away and take a look at some very useful Maven features that will make your builds shine. From where it stopped Sometimes it is needed to build a bunch of projects all together, artifact-a , artifact-b and so on. What do we usually do when one of them fail? Build it all again! But not anymore: By using this option you can run the build from the project that failed. Two out of ten Ok, suppose you have 10 projects, and you only want to build 2 of them, how would you do? The option -pl will do the job Multi-threaded Build If in the machine you run the build you have many Cores, tou can take advantage of them by using the following option(it means 2 Threads per Core): It is also possible to define 3 Threads per Core(T3C) Skip your Tests when you want to With a lot of test
Post a Comment
Read more