From Java 8 to Java 11

Switching from Java 8 to Java 11 is more complicated than most updates. Here are some of my notes on the process.

Modules

Java 9 introduced one of the biggest changes in the history of Java modules. Much has been said on the subject, by other people. A key point is sometimes forgotten:

You do not need to modulate your code to update to Java 11.

In most cases, the code that runs in the class path will continue to run in Java 9 and later, where the modules will be completely ignored. This is terrible for library authors, but optimal for application developers.

So, my advice is to ignore the modules as much as you can when upgrading to Java 11. Transforming your application into Java modules can be a useful thing to consider in a few years when the free software dependencies really start adopting the modules. At the moment, trying to modularize is only painful, since few dependencies are modules.

(The main reason I found to modularize your application is to be able to use jlink to reduce the size of JDK.) But, in my opinion, you do not need to fully modulate to do this – just create a single jar – with dependencies with a simple no- requires no-exports module-info.)

Parties excluded from the JDK

Some parts of the JDK were removed. These were parts of Java EE and Corba that no longer fit the JDK or could be maintained elsewhere.

If you use Corba, then there is little that someone can do to help you. However, if you use the Java EE modules, the correction of the deleted code should be simple in most cases. You just have to add the appropriate Maven jars.

On the Java client side, things are more complicated with the removal of Java WebStart. Consider using Getdown or Update4Jinstead.

Unsafe and friends

Sun and Oracle have come to developers for years that do not use the sun.misc.Unsafe and other leading edge JDK APIs. For a long time, Java 9 was the launch where those classes disappeared. But that never really happened.

What you can get with Java 11, however, is a warning. This warning will only be printed once, on the first access to the restricted API. It is a useful reminder that your code, or a dependency, is doing something “impertinent” and will have to be corrected at some point.

What you will also discover is that Java 11 has several new APIs designed specifically to avoid the need to use Unsafee the friends. Make a priority to investigate these new APIs if you are using an “illegal” API. For example, Base64, MethodHandles.privateLookupIn, MethodHandles.Lookup.defineClass, StackWalker and Handles Variables.

Tools and Libraries

The modules and the new biannual launch cycle conspired to cause a real impact on the use of tools and libraries that developers use. Some projects were able to accompany. Some have fought. Some failed.

When updating to Java 11, an important task is to update all its dependencies to the latest version. If there is not a posting since Java 9 was released, then this dependency may need additional attention or testing. Make sure you have updated your IDE as well.

But it’s not just the dependencies of the applications that need to be updated, as well as Maven (and the Gradle too, but I do not know much about the Gradle). Most Maven plugins have changed major versions to v3.x, and upgrading Maven itself to v3.5.4 is also beneficial.

Unfortunately, the maven’s main equipment is very small, so there are still some errors / problems to solve. However, if your Maven construction is sensible and simple enough, it should usually be fine. But note that updating a plug-in from a v2.x to a v3.x can involve changes to the configuration in addition to those associated with the modules. For example, the Maven Javadoc plugin has changed the name of the argLine property.

Interested in learning Java? Join now:” java training in chennai “

An important point to be observed is the way in which Maven operates with the modules. When the Maven compiler or surefire plugin finds a jar file that is modular (that is, with a module-info.class), you can place that jar in the module path instead of the class path. In this way, even if you want to run the application completely on the classpath, Maven can compile and test the code partially on the classpath and partly on the module path. At the moment, there is nothing that can be done about it.

Sometimes, your compilation will need some larger changes. For example, you will have to change the Findbugs for SpotBugs. And change the Coverage to JaCoCo.

These compilation changes may take some time – they did it for me. But the information available for a simple investigation on the web is increasing all the time.

Interested in learning Java? Join now:” java training in bangalore “

Summary

I have updated several Joda / ThreeTen projects to support Java 9 or later now. It was very painful. But that’s because, as the author of a library, I have to produce a jar file with module information that is built and executed in Java 8, 9, 10 and 11. (In fact, some of my jar files run in Java 6 and 7 too!)

Having made these migrations, my conclusion is that the pain is mainly in maintaining compatibility with Java 8. Moving an application to Java 11 should be simpler, because there is no need to get stuck in Java 8.

November 27, 2018 0

Introduction to the Java Development Kit

Introduction

The Java Development Kit (JDK) is one of the three main technology packages used in Java programming, together with the JVM (Java Virtual Machine) and the JRE (Java Runtime Environment). It is important to differentiate these three technologies, as well as to understand how they are connected:

The JVM is the component of the Java platform that runs programs.
The JRE is the part of the Java disk that creates the JVM.
The JDK allows developers to create Java programs that can be executed and executed by JVM and JRE.

Beginning Java developers often confuse the Java Development Kit and the Java Runtime Environment. The distinction is that the JDK is a toolkit for Java-based software development, while the JRE is a suite of tools for executing Java code.

The JRE can be used as a separate component to run Java programs, but it is also part of the JDK. The JDK requires a JRE because running Java programs is part of their development.

Technical definition: The JDK is an implementation of the Java platform specification, including the compiler and the class libraries.
Definition of every day: JDK is a software package that downloads to create Java-based applications.

Start with the JDK

Obtaining Java configuration in your development environment is as easy as downloading a JDK and adding it to your classpath. When you download your JDK, you will need to select the Java version you want to use. Java 8 is the most commonly used version, but, so far, Java 10 is the most recent version. Java maintains compatibility with previous versions, so we will download the latest version.

Interested in learning Java? Join now:” java training in chennai “

JDK packages

In addition to choosing your version of Java, you will also have to select a Java package. The packages are Java development kits that are directed to different types of development. The available packages are Java Enterprise Edition (Java EE), Java Standard Edition (Java SE) and Java Mobile Edition (Java ME).

Beginning developers are sometimes not sure which package is right for their project. In general, each JDK version contains Java SE. If you download the Java EE or Java ME, you will get the standard edition with it. For example, the Jave EE is the standard platform with additional tools useful for the development of enterprise applications, such as Enterprise JavaBeans or support for Relational Object Mapping.

Interested in learning Java? Join now:” java training in bangalore “

It is also not difficult to change to a different JDK in the future if you find that you need it. Do not worry much about choosing the correct version of Java and the JDK package when you have just started.

November 24, 2018 0

Microservice Logging: Challenges and Advantages

One of the main developments in software design and delivery in recent years has been a movement of monolithic applications for microservices. One of the critical points that I have seen in several microservice applications is the registry. There are some unique challenges with the microsion log that need to be resolved. In this article, we will see how we can do the registration in a microservice as painless as in a monolith.

What is a microservice?

There are many definitions of microservices out there, but that’s the one I like.

Microservices: A high-level software design that favors small and weakly connected services that maintain data autonomy and are independently implantable.

Breaking this up using microinsurance is a high level decision. It is not a standard that applies only to a part of your application, but it must be a global decision. By using microservices, we create several smaller applications with very limited functionality. For example, we can have a service whose responsibility is to act as a container to chat with an external API. Services must be weakly connected: there are no direct connections between services or cross-talk between services. Services must have their own data storage solution that is not shared with another service. This means absolutely no integration at the database level! Finally, there should be no dependencies between the services at the time of implementation.

Setting limits between services in a microsystem cluster is a difficult problem. There are many ideas around it, but most of them revolve around domain-oriented design.

Different challenges of a monolith

Although there are many advantages in a microservice approach, there are also disadvantages. The monoliths are implemented as a single entity in one or more servers, each of which obtains the same code. This unique implantation is a curse and a blessing. Unique implementations mean that you have fewer moving parts in the creation and deployment pipeline. There are no concerns about data transport between various applications or discovering the limits for these applications. The most important advantage for this article is that the registration in the registry resides in only one location.

The log is a perfect example of a transversal concern: code that needs to cover several modules at different levels of the code base. When we divide our application into silos, the record is also divided into all services.

A single logging technology

A much discussed benefit of microinsurance is that each service can be written using appropriate technology. A component that does a lot of mathematics may not be as efficient written in JavaScript as in Go. Microservices allow you to select a technology that best suits each component. Generally, each microservice is built by a team specialized in the technology used in that service. Reinforcing a single data logging technology is a challenge to the microservice mentality. However, this is a time when it is justified to go back in academic perfection in favor of pragmatism.

A shared logging implementation for every service

A single registration technology provides us with a location for the records, regardless of which service originates the registration message. If we are trying to find a network problem, we do not want to have to go through several log files located all over the place to see what services have been affected. Ideally, we want to have a one-stop-shop that allows searching, classifying and designing registration information for several dozens of services. The technologies that allow this, registry aggregators, tend to have connectors for several languages. For example, Stackify Retrace has connectors for Java, .NET, PHP, Ruby and Node.js out of the box, as well as a Restful API that unlocks almost all other languages.

The errors can cover several microservices, so the registry as our best tool to track errors must also cover them.

A logging technology which allows queries

A single user interaction in a microsystem architecture can encompass many services. Being able to accompany a user interaction is much easier if you have a registration tool that allows you to use an advanced query language to search, design and add. The registration in aggregate can also be very useful. Queries like this one are super-valuable: “what percentage of requests for X service results in errors?”, Or “what time of day do we see the biggest load on the system”, or even “what is the average time that an application spend? in the X service. ”

Naturally, there are many registry aggregators out there, and choosing one that has an advanced query language is a good differential. Another aspect to consider is how easy it is to see the data after writing a query for them. A good chart will give you background information that are difficult to analyze from a record message.

Next, there is an example of a Retrace panel showing several important metrics, some of which are extracted from record searches.

Interested in learning Java? Join now:” java training in chennai “

Use a correlation identifier

When a client contacts you with a problem you had in your application, it is very good to be able to quickly find what has gone wrong. One method to do this in a micro security application is to include a correlation or transaction ID in each message. Fill this field with an ID removed from the initial event. Consider a scenario in which a user creates an account. This can trigger actions in the user’s service, in the customer loyalty service and in the billing service.

By having a unique identifier that is disconnected by each of these services while processing a message, it is easy to find the creation flow of the user. All that is needed is to pop the unique identifier in the search engine of the record aggregator and get all the registration messages related to that transaction. You can even present the user with that correlation ID, if something goes wrong, so you have a reference number to quote when talking to your support organization; This is even more useful if you are the support organization.

Interested in learning Java? Join now:” java training in bangalore “

Include a lot of information

It is much more common that you want to have more information recorded than less. Obviously, there are some performance and storage considerations in relation to over-registration, but very small registration can lose the main information forever. Including context information in your log messages increases the chances that you can track problems. For example, it usually improves my log messages with information such as:

service name that generates the registration message
Correlation ID
username that triggered the action
machine name or container id
date of receipt of the message in UTC
date of sending the message in UTC
entire body of the drive message

Carefully consider what information would be useful in debugging problems and you would be wrong to include too much. If you are using a registration structure that supports structured registration (which is excellent), you can place all this information in the properties of the logging message and not overload your actual messages.

November 23, 2018 0

Java EE Overview

In this article, you will find information about the history of the Java EE ecosystem: where it came from and how it has changed in recent decades. You will discover the main milestones in its development, from J2EE 1.2 to its current incarnation Java EE 7, and we will see in the future what Java EE 8 has reserved.

You will discover how to get involved with the development of the platform itself and how to enter JCP.org to make an even greater contribution. Find out about the Java EE Guardians and how you can support the development and growth of the platform.

What is Java EE?

Java EE consists of a set of more than 28 specifications and a runtime environment. It is a superset of the Java SE platform. This means that Java EE components can take full advantage of all Java SE APIs.

This set of APIs creates multilayer applications based on standard components and implements in different containers, offering a variety of services. It is not only used to develop monolithic application structures, but also structured applications of microsystems. More information about Java EE and microservices checking Java EE and Microservices in 2016? You are interested in the development of tip in the space of microservices with respect to Java EE? Next, visit the Eclipse Microprofile project website.

The Java EE programming model has annotations to specify settings instead of XML description files and uses the configuration convention to help you start using the least possible ceremony.

It has its own contextually conscious dependency injection structure at the center of its programming model.

History of Enterprise Java

In 1998, the first incarnation of Enterprise Java was launched, but then important technologies soon joined the mix, such as Servlets, Messaging and Enterprise Java Beans.

These technologies still exist on the Enterprise platform today, but in a much more advanced and complete way.

In the following years, he developed a programming model that was difficult to use and very complicated. All this changed in the fifth edition, which saw a radical change of the XML configuration towards the notes and convention about the configuration.

The new programming model has been substantially simplified. Annotations replace the XML description files, the configuration convention replaces the tedious manual configuration, and dependency injection hides the creation and search for resources. Resources are created and injected into injection points marked by annotations such as @Inject. Therefore, all you need is a POJO that meets the conditions of the managed beans specification, JSR 299 and, depending on the annotation used, it will become an EJB, Servlet, Singleton or RESTful Web service.

The platform continued to grow, but at a much slower pace. To each new version, it becomes more friendly to the programmer and the number of APIs grew to reach 28+, above only a handful of five APIs in 1999.

Interested in learning Java? Join now:” java training in chennai “

What comes in Java EE 8?

Oracle is moving the focus of Java EE to microservices and the cloud, and the next version of Java EE will include the APIs that complement this new address.

As well as advances in some established technologies, such as Bean Validation, Context Injection and Dependency, JavaServer Faces, JAX-RS (RESTful web services), JSON-Processing and Servlets, there will be two new APIs.

JSON-binding, a dedicated security API and security API for Java EE, designed to standardize security.

The Java EE 9 will see even more APIs designed for the development of microsis and cloud-based applications.

Interested in learning Java? Join now:” java training in bangalore “

Java Community Process (JCP)

The development of the Java EE platform occurs through the Java Community Process (JCP), responsible for all Java technologies.

The group of experts consists of interested parties who created Java specification requests (JSR) to define the various Java EE technologies. All done in cooperation with the international community of Java developers.

The work of the Java community under the JCP program helps to guarantee the stability and compatibility standards between Java technology platforms.

Anyone can review and comment on draft specifications and JSR proposals, as well as read the JCP blog. Anyone can register as user

Anyone can review and comment on draft specifications and JSR proposals, as well as read the JCP blog. Anyone can register as a user of the site and can be authorized as a member of the Collaborator or the Group of Experts. You can become a JCP member and make an even greater contribution. Go to the link to discover more.

November 22, 2018 0

The profile of Java Profiler

Debugging performance problems in production can be a pain and, in some cases, impossible without the right tools. Java profile creators have always existed, but the projectors that most developers think are just one type – in fact, there are three:

Standard JVM profiles that track all the details of the JVM (CPU, chaining, memory, garbage collection, etc.).
Light profilers that emphasize its application with a little abstraction.
Application performance management (APM) tools used to monitor live applications in production environments.

Standard JVM profiles

A standard Java profiler certainly provides most of the data, but not necessarily the most useful information. This depends on the type of debugging task. These profiler will track all method calls and memory usage, allowing a developer to immerse themselves in the call structure at any angle they choose.

Lightweight transaction profiles in Java

The creators of light profiles adopt a different approach when tracking their application, injecting themselves directly into the code. Aspect Profilers uses aspect-oriented programming (AOP) to inject code at the beginning and end of the specified methods. The Java Agent profile creators use the Java Instrumentation API to inject code into their application.

Under Overload, Creating Java JVM Profile in Production (APM)

All profilers have been optimal for development so far, but monitoring how your system works in production is critical. Production is always a different landscape – the development and preparation configurations usually do not have the same data sets and load.

Java APM tools generally use the Java Agent profile creator method, but with different instrumentation rules to allow execution without affecting production performance. The trick with these proflets is to provide the correct information in a smart way so as not to occupy the CPU cycles.

Interested in learning Java? Join now:” java training in chennai “

Why are some Java profiles so expensive?

XRebel is a legal tool, but it costs US $ 365 per year. The Stackify Prefix is free and provides much of the same functionality.

The biggest problem with APM solutions is definitely its price. Traditionally, they are so expensive that only the largest companies can deal with them. It does not make much sense to spend $ 100 a month on a server in Azure or AWS and spend another $ 200 a month for a product like the new relic.

Interested in learning Java? Join now:” java training in bangalore “

The monitoring tools should not cost more than the servers! Both Prefix and Retrace have profile creation functionality and are incredibly accessible. The prefix is free for life and the Retrace is free in the first two weeks.

Applications for managing Java profiles and other Java tools, books, websites and blogs, YouTube channels, podcasts, events and LinkedIn can be found in our complete Java Developer’s Guide.

November 20, 2018 0

Introduction to the Java runtime environment

Together, the Java Development Kit (JDK), the Java Virtual Machine (JVM) and the Java Runtime Environment (JRE) form a powerful fragment of Java platform components to develop and execute Java applications. I have already presented the JDK and the JVM. In this quick tutorial, you will learn about the JRE, which is the runtime environment for Java.

In practice, a runtime environment is software developed to run other software. As the runtime environment for Java, the JRE contains the Java class libraries, the Java class loader, and the Java virtual machine. In this system:

• The class loader is responsible for correctly loading the classes and connecting them to the main Java class libraries.

• JVM is responsible for ensuring that Java applications have the necessary resources to run and run well on your device or cloud environment.

• The JRE is primarily a container for these other components and is responsible for orchestrating its activities.

What is a runtime environment?

A software program must be run and, for this, it needs an environment to run. The runtime environment loads class files and ensures that there is access to memory and other system resources to execute them. In the past, most software used the operating system (OS) as its runtime environment. The program worked inside the computer it was on, but it had operating system configurations for accessing resources. Resources in this case would be things like memory and program files and dependencies. Java Runtime Environment has changed all this, at least for Java programs.

The Java runtime environment

We can see the software as a series of layers that are located at the top of the system’s hardware. Each layer provides services that will be used (and needed) by the layers above it. Java Runtime Environment is a software layer that runs on a computer’s operating system, providing additional services specific to Java.

The JRE softens the diversity of operating systems, ensuring that Java programs can run on virtually any OS without modification. It also provides value-added services. Automatic memory management is one of the JRE’s most important services, ensuring that programmers do not need to manually control memory allocation and relocation.

In summary, the JRE is a kind of meta-operating system for Java programs. It is a classic example of abstraction, abstracting the underlying operating system into a consistent platform for running Java applications.

Java and JRE memory

Java memory consists of three components: the heap, the stack and the metapace (formerly called permgen).

• Metaspace is where Java keeps the immutable information of its program, as class definitions.

• Heap space is where Java maintains variable content.

• Stack space is where Java stores execution references and function variables.

Memory management in Java 8

Until Java 8, the metapace was known as permgen. In addition to being a much more legal name, the metaspace is a significant change in the way developers interact with Java’s memory space. Previously, use the java -XX: MaxPermSize command to monitor the size of the permgen space. From Java 8 below, Java automatically increases the size of the metaspace to accommodate the meta-needs of your program. Java 8 also introduced a new indicator, MaxMetaspaceSize, which can be used to limit the size of goals.

Heap space configuration

Heap space is the most dynamic part of the Java memory system. You can use the -Xms and -Xmx flags to inform Java of the size of the heap start and the size of the permission for it. Understanding how to adjust these indicators to specific program needs is an important aspect of memory management in Java. Ideally, the pile is sufficient to obtain the most efficient garbage collection. That is, you want to allow enough memory to allow the execution of the program, but you do not want it to be larger than necessary.

Interested in learning Java? Join now:” java training in chennai “

Configuration of the stack space

The stack space is where function calls and variable references are routed. The stack space is the source of the second most notorious error in Java programming: the stack overflow exception (the first is the null pointer exception). The stack overflow exception indicates that you ran out of stack space because a lot of it was reserved. Normally, it receives a stack overflow when a method or method calls one another in a circular fashion, thus dedicating an increasing number of function calls to the stack.

You use the -Xss option to configure the initial size of the stack. The stack grows dynamically according to the needs of the program.

Interested in learning Java? Join now:” java training in bangalore “

Monitoring of Java applications

Although application monitoring is a function of JVM, the JRE provides configuration options, which are the baseline necessary for tracking. A variety of tools is available for monitoring Java applications, from the classic ones (such as the top Unix command) to sophisticated remote monitoring solutions, such as Oracle infrastructure monitoring.

Among these options are the creators of visual profiles, such as VisualVM, that allow you to inspect a running JVM. These tools allow you to track access points and memory leaks, as well as see the overall memory consumption in your system.

Conclusion

Java Runtime Environment is the disk program that loads Java applications so that the JVM runs. A JRE is included by default when you download the Java Development Kit, and each JRE includes the main Java class libraries, a Java class loader, and a Java virtual machine. It is useful to understand how JVM, JDK and JRE interact, especially to work in cloud and devops environments. In these environments, the JRE assumes a more important role in monitoring and configuration than in the traditional development of Java applications.

November 19, 2018 0

4 Types of Java Logs

Log is an important issue in software development, especially if you need to analyze errors and other unexpected events in your production environment. Implementing your registry usually seems easy. But, as you have probably experienced, the creation of log is much more complex than it seems. As an experienced developer, you should know the different Log structures available, the common pitfalls and best practices and, of course, the types of log files used in common deployment scenarios. In this article, I will focus on the last part. I’m going to talk about 4 different types of logs that you can find in almost every development or production environment.

Application Log

Let’s start with the most common type of Log: application log

Most developers think about that record when talking about the registry. The reason for this is simple. Your application produces this record. It contains all types of error messages, warnings or other events recorded by the application. These messages can provide high-level logical information connected to specific use cases. Typical examples are:

The stacktrace of an exception that occurred in a use case.
Warning messages about slow response times from an external system.
Information that a use case has been triggered or terminated.

The application record is probably the most important type of record that is mentioned in this article because you have full control over it. This means that you are responsible for writing the messages.

Each log message must provide useful information that helps you understand the behavior of your application. If you want to know more about application logs, take a look at Eric’s article, which describes an optimal set of best practices for registering applications.

Web server logs and applications

The next interesting and important type is the Log of your web server or applications.

Most business applications are implemented on a Web server, for example, Apache Tomcat or an application server, for example, Wildfly or WebSphere Liberty. Your log files provide information about technical problems and the current status of the server.

The configuration and resources of each server are different, and I will not explain them in detail in this article. But, please be sure to check the documentation of your server and configure it properly. Obtaining the correct information from your server can make the difference between identifying potential problems over time and a server unavailability.

Garbage collector Log

The garbage collector provides automatic memory management. It controls all the objects instantiated in a JVM and eliminates those that are no longer used. This is a very complex task and there are several different garbage collector implementations available.

In general, the garbage collection process in Java is very efficient. It is so efficient that there are many applications that use the default implementation with their default settings. But if your application has to handle high load or use many complex object structures, the performance of the application may decrease over time. This usually happens when the garbage collector needs to spend more and more time to manage the available memory. The garbage collector record provides the necessary information to analyze all the activities of the garbage collector.

The garbage collector log is disabled by default. You must enable it with a set of command line properties.

If you are using JDK 8 or earlier, you can do so using the following properties:

-XX: + PrintGCDetails -Xloggc:

From JDK 9, you must use the following properties:

class = “prettyprint” -Xlog: gc *: file = <path of file-del-gc-log>

After starting your application with these command line properties, your garbage collector will record detailed information about all the operations. Unfortunately, the content and format of the garbage collector log generated depend on the provider and the version of your JVM and the garbage collection algorithm.

System Logs

All the logs discussed above are written by JVM or a running application in JVM. In addition to these records, you must also be familiar with the Log recorded by your operating system.

As a Java developer, I probably never write in these logs. But your operating system logs certain events in these registers. Other applications, which are part of its implementation, can also do so. Therefore, system records are a good place to get an overview of external events.

If you are running your application on Windows, this is the event log. In Linux, you must know the syslog service and its successors.

Windows Log wvent

The Windows event log contains important hardware and software events in the categories, security, configuration, system, and forwarded events applications.

Especially the application events and the system category can be useful to understand the events that have occurred outside of your application. The application category contains events reported by other applications that run on the local Windows system. The events related to the hardware and the controller belong to the system category.

Interested in learning Java? Join now:” java training in chennai “

Linux system Logging

The Linux syslog service and its successors provide a highly configurable registration system. It Log messages triggered by applications or by the operating system in a file or sends them to a remote system.

The Log service used and its configuration depend on your Linux distribution. Please check the documentation to know more about your specific operating system.

Interested in learning Java? Join now:” java training in bangalore “

Conclusion

Logging is an important issue with many different facets. In this article, I have summarized 4 important Logs that you should know as a Java developer:

The log of the application is the most obvious. It is written by your application and you are responsible for the content.
If you deploy your application to a Web or application server, you will also need to know the Logs provided by that server.
Garbage collector Logs can provide important information if you need to analyze performance problems.
You can check the system logs to get an overview of all external events that may have affected your application and cause the service incident.

November 17, 2018 0

Benefits and considerations of Java DevOps

DevOps sees the union of practices, philosophies and tools that allow you to create services and applications very quickly. This means that you can improve your applications and evolve at a much faster pace than developers who use traditional software development processes. We talk about DevOps, in general, a lot, but today, let’s dig a little deeper and take a look at Java DevOps specifically.

What is the devOps?

The DevOps is simply a portmanteau of software DEVelopment and IT OPerations. It was called for the first time agile operations and involves different disciplines in the creation, operation and development of applications and services.

Using a devOps model, you are gathering your development team and your operations team, and your work is no longer in silos. These teams, and sometimes in conjunction with the security and quality control teams, work together to implement the new application – development, testing, implementation and, later, operation.

Another important feature – developers often use tools that help automate processes that used to be done manually and, as such, are prone to errors and take much longer to be executed. They also use tools to operate and support applications quickly, as well as to perform tasks without the need for external help, such as implementing code or allocating resources.

What is Java DevOps?

Java DevOps is simply applying DevOps practices and philosophies to the development of Java applications. This means that compartmentalized equipment is no longer necessary when creating Java applications.

Some of the principles you should know include:

Continuous integration. This practice requires developers to periodically mix the code they recorded in a central repository. After the merger, tests and automated constructions are carried out. This allows a team to find problems and quickly eliminate bugs, improve the quality of the application and reduce the time needed to validate their applications. This also helps your team to release new updates more quickly.
Continuous delivery This practice requires that your team release all code changes after writing and then automatically create and test them. If the integration continues to place your code changes in a test environment, continuous delivery will place it in a production environment. What does this mean? You will always have a Java application ready for production!
Microservices. DevOps makes use of microservices. Instead of having a great monolithic Java application, your application is made up of smaller and independent applications.
Infrastructure as a code. This practice means that the infrastructure is assigned and then managed by code and development techniques. Cloud services can help your development teams and operations interact with the infrastructure on a scale that they feel comfortable with. With infrastructure as a code, servers and infrastructure are quickly implemented, automatically corrected and can be easily duplicated. Your team can also automate the administration of the configuration and also take advantage of the policy as a code, in which compliance with regulatory requirements is practically guaranteed.

Benefits of Java DevOps

DevOps take a people’s approach first. In addition to bringing together its development, operations and other equipment, DevOps requires team members to understand the perspective of other team members. This may mean that a developer is sharing their concerns with the team and a SysOp doing the same. This type of understanding can allow team members to help each other, as a developer by creating resources and tools that another team member needs. As such, collaboration is not only motivated by necessity. But, even when you join teams, you also put the focus on responsibility and ownership.
Java DevOps reduces the time to develop a Java application. This will help you deliver the correct Java applications to the end users more quickly and until it becomes more efficient as time passes. You can also adapt more quickly to all the conditions and demands of the constantly changing market.

Interested in learning Java? Join now:” java training in chennai “

Better application quality. DevOps almost always requires a change for continuous integration, which means that each stage of application development is tested and monitored. Each change is also tested. That’s why Java DevOps can guarantee that your Java applications have a positive experience for its users. In addition, the devOps can increase the security rather than hinder it.

4 You do not overload yourself. You can manage and operate your applications, processes and infrastructure at scale.

Interested in learning Java? Join now:” java training in bangalore “

Considerations and Risk Mitigation

Here are the things you should consider when switching to the devOps for your Java projects.

Visibility: it would be very tiring and difficult to check if your containers have the correct configuration or do not contain spyware.
Vulnerabilities: If there are problems or if you need to update or remove components, it will be very difficult to follow the different containers.
Consistency: there may be components that are not reviewed. And if you use microservices, this can also mean more configurations that are going to be checked.

The good news is that there are tools you can use to help you manage or minimize these risks. These tools include Artifactory, Sonatype Nexus and RogueWave OpenLogic, as well as several open source and paid tools.

November 16, 2018 0

Java performance tools

Performance tools for Java

Accompanying the performance of your application is a continuous task, so it is important to have the right tools. What works in the development may not be so useful in a production environment. Here, I’m going to talk about the best tools and the best time to use them. The goal is to help you create reliable, high-performance applications as quickly as possible.

1. Java Profilers

JVM profiles offer a ton of raw data by tracking all method calls, allowing you to find CPU access points and memory consumption. A good test of size is to configure an Apache JMeter job to reach an endpoint that is developing a few thousand times while it is linked to a profile creator. This allows you to specify the memory and CPU requirements for production.

Pros: optimal for tracking memory leaks, the ability to manually run the garbage collection and then review the memory consumption can easily highlight the classes and processes that are kept in memory by mistake.

Cons: Requires a direct connection to the monitored JVM; This ends up limiting the use to development environments in most cases. (Note: some profile creators can work with subprocess frames and memory in limited ways).

2. Tracking web requests and transactions in Java

The standard profile creators focus on the performance of all methods throughout the application. These tools focus on the performance of individual requests or transactions on the web.

The prefix provides deep-level performance details about your application. Including ORM calls with generated SQL, SOAP / REST API calls and tracking details of the most used third-party libraries and structures.

XRebel is configured by a Java agent in the container of the web application and provides an overlay in the application that provides details about the current request.

Pros: these tools give order to the large amount of data available in a profiler of the JVM. By helping you track the flow of a request, you can see what types of method calls are responsible for your response time.

Cons: Designed only for the development cycle. The quality control and production environments require an APM solution.

3. Java Application Performance Management (APM)

Application performance management (APM) tools assume the task of tracking all requests in a production system. The trick of these proflets is to provide the correct information intelligently so as not to impact production performance. This is done by adding time statistics and sampling traces. This gives you visibility of the level of the method for your code that is running in production.

Pros: The ability to monitor your most critical environment: Production. Identify the problems before going into production, monitoring the QA / Staging. Debug production by analyzing traces and exceptions. Summaries added to see highly used requests to help focus development time.

Cons: normally expensive to run on all the quality control / preparation and production servers. Some tools do not support asynchronous queries or do not fit correctly and slow down your application.

4. Real user monitoring (RUM)

It is not uncommon for webapps to be very dependent on the client’s side; The provision of an interactive experience may require many dependencies, such as JavaScript / CSS structures, Web sources and images.

RUM provides information on the dependencies of your application, giving visibility to the download of resources and the time of representation of the page.

Some APM products include this as an additional resource. There are also independent products, such as Google PageSpeed.

Performance Metrics of the JVM

JVM provides a wealth of valuable information, such as garbage collection, memory usage, and thread counts. This data is available through JMX.

Stackify Retrace provides monitoring of JVM metrics through application monitors and automatically applies intelligent patterns based on the type of application discovered.

Pros: Available in any application that runs in JVM and easy to connect with applications such as JConsole.

Cons: It can be difficult to connect in a preparation and production environment. Aggregation and comparison of data can be time consuming. The statistics are collected only while the monitor is connected to the JVM.

Access logs to the Web server (Apache / Nginx)

If you have Apache or Nginx proxy requests for your Java application server, you can monitor the access records. This is a quick way to see how long applications are being made. You can add access logs to see which are the most popular / fastest / slowest endpoints. Doing this through the command line may take, however.

For small data sets, you can use a desktop tool such as Apache Viewer, but for preparation and production environments, a hosted registry solution is ideal.

The tracking of failed requests is also very useful, which can be done by aggregation in HTTP response codes.

Pros: quick way to get some simple statistics, by following the access records, or – if more information is needed – push a log analyzer.

Cons: does not provide details about why the request took so long. There is a lack of POST data and response content that can help pinpoint the cause of a performance problem.

Interested in learning Java? Join now:” java training in chennai “

Accompanying all Java exceptions

One of the biggest causes of performance problems may be application exceptions. When an exception is thrown, it causes the segment to stop while collecting the stack trace. Even manipulated exceptions that seem innocent can cause huge performance bottlenecks under heavy server load. It is important to add and monitor all your exceptions to find critical problems, new errors and monitor error rates over time.

More information: How GWB found hidden exceptions and application performance issues

Pros: Easy to configure, if you are using a registration structure, such as Log4j or Logback.

Cons: None

Interested in learning Java? Join now:” java training in bangalore “

Memory analysis

The memory analysis of the application after a failure can help identify the cause of a memory leak. You can instruct JVM to dump the heap in an OutOfMemoryErrorexception including the following argument in JVM:

-XX: + HeapDumpOnOutOfMemoryError

The heap dump file can be loaded into an analyzer – Eclipse MAT. You can immerse yourself in the Overview or Leaks Suspects reports to help identify the cause of the memory exception.

Conclusion on Java performance tools

The big conclusion is that creating and maintaining the performance of the Java application is easier than ever with all these tools. Do not be overloaded with all the things you should do. Start with the fruit hung first, as a follow-up to the exception. It is really good, at least, to know what options are available to you, and I hope you have found this list useful.

November 15, 2018 0

How to monitor Java services – performance, errors and much more

In the real world, a lot of mission critical business logic lives in background services. Buying something from an e-commerce site, such as Amazon, initiates a variety of tasks that must be completed after clicking to confirm your request. Monitoring the performance of your web applications is only part of the puzzle if you want to proactively ensure that your software is working correctly all the time.

If you want to make sure that your software is working properly, you should monitor your Java services that deal with these mission critical tasks in the background.

Why monitoring a Java service is different

Monitoring of Java Services is different from monitoring of Java web applications. Web applications have very defined “transactions” based on each Web request that is running in the application container. It is very simple that services such as the Retrace identify each request of the individual Web and accompany the performance of them.

Java services are not started or defined for the work they perform. They usually start and run continuously until the server shuts down. To properly monitor the performance of your Java services, you must define the start and end of the transactions or the operations that are executed.

Identifying “Operations” in your Java services

Java services generally follow several commonly used standards. By identifying these patterns, you can quickly assess the best way to identify operations in your code.

Think of an operation as a small unit of work that is repeated several times. You need to identify which of them you want to monitor in your code.

Common standards of use:

• Queue listener: the application listens continuously in a queue and each message captured in a queue would be an exclusive operation.

• Timer-based – Many Java services use timers to repeat a specific operation at intervals of a few seconds, such as searching a database.

• Job scheduler: it is possible to incorporate a task scheduler such as Quartz in your Java service to trigger small jobs and scale them on all servers.

Most Java services will probably execute several operations. I would suggest dividing them into the smallest logical units of work. It is better if you supervise smaller work units. This is similar to monitoring each web application in your web application compared to monitoring the performance of the web application in its entirety.

For example, our monitoring agent for Linux is a Java service. He makes a ton of different operations on a schedule every few seconds. Each of these tasks that you execute must be defined as exclusive operations so that you can follow everything you do.

How to Instrument “Operations” in Your Code for Retrace

After identifying the operations you want to accompany, you will need to make some smaller code annotations to define your operations. This is done by adding the dependency of the Stackify Java APM annotations to the pom.xml file of your project.

<dependency> <groupId>com.stackify</groupId> <artifactId>stackify-java-apm-annot</artifactId> <version>1.0.4</version></dependency>

Example of instrumenting your code for Retrace:

import com.stackify.apm.Trace; @Tracepublic class ClassToBeInstrumented{ @Trace(start = true) public void methodToStartNewTrace() { … }}

How to install Retrace for Java Services

The Retrace uses the lightweight Java profile and other data collection techniques. A service is installed on your Linux server and runs in the background. Our agent is easily installed by means of a curl or wget command. Please, check our documents for complete instructions.

Retrace provides developers with many advantages for monitoring Java service performance. Retrace provides holistic monitoring of Java service performance, including code profile, errors, logs, metrics and much more.

Benefits of monitoring Java services with Retrace

Once your code has been instrumented and the Retrace is collecting data about your Java service, you can get some incredible details about what your code is doing. Retrace can monitor independent Java applications executed through various service managers.

Retrace automatically supports dependencies and the most common Java frameworks, without code changes. You can instantly see how they are used in your application and how they affect performance. This includes PostgreSQL, MySQL, Oracle, external web services, MongoDB, Elasticsearch, Redis, Quartz, Hibernate and much more.

Identifying the main operations

Retrace allows you to see all the operations that are running in your Java service. Quickly identify the frequency with which each of them runs, the average time of execution and much more. The performance of Java services is typically a “black box.” Retrace allows you to understand exactly what your Java service is doing.

Tracking Top SQL Queries

Retrace automatically crawls all SQL queries executed by your code. This includes stored procedures, dynamic SQL, Hibernate queries with crazy appearance and much more. Quickly identify which queries are running, how long they take and how often they are being called.

View Application Exceptions & Logs

Because Retrace works through the Java light code profile, it also has the ability to collect untreated exceptions by being thrown by its code. You can also track exceptions that are recorded in your registration structure.

Retrace provides powerful functions for error monitoring and record management. You can send all your records to the Retrace via log4j, logback and others. With Retrace, you can search all your records in a single location and perform many other advanced records management features.

Interested in learning Java? Join now:” java training in chennai “

Tracking Custom Application Metrics

Retrace automatically monitors the use of the CPU and the memory of your Java service. You can also use it to track many other JMX standard MBeans. Including statistics on garbage collection and exceptions are counted per second. Retrace can also monitor custom JMX mBeans created by your applications.

The custom metrics are also compatible with the use of Stackify’s maven “stackify-metric” package. With just a few lines of code, you can accompany how often or for a long time your Java service does practically anything.

Interested in learning Java? Join now:” java training in bangalore “

View Code Level Traces

One of the most powerful features of Retrace are the snapshots of the level of code that it collects. For any of the operations tracked for your Java service, you can see all the main methods, dependencies that are called, exceptions, records and much more in context.

Summary

The developers depend a lot on Java services to do a great job of mission critical. Monitoring Java services is essential to ensure that they are functioning correctly and with good performance.

Retrace is an excellent solution to monitor the performance of your Java services. For more information, see our product page on Retrace and our overview of application tracking.

November 14, 2018 0