Java Journey: A Traveler's Map

[[163802]]

Some time ago, I sorted out my Java knowledge system and wrote this article, hoping it can help programmers who are about to enter or are currently exploring the Java world.

*** Zhang, basic map

I started to know Java in 2003 (I was still using Delphi at that time), but I didn’t decide to learn Java until I graduated from college in 2004. At that time, I felt that writing client/server architecture programs with Delphi was meaningless. The J2EE specification concept and enterprise-level architecture proposed by Java at that time seemed so high-end. I couldn’t suppress my inner desire and started my journey of Java. To be honest, I was dizzy when I entered the door of Java world. All kinds of specifications, concepts and English abbreviations made me dizzy.

• J2SE
• J2EE
• J2ME
• JSP
• JDBC
• JMS
• EJB
• JNDI
• JDBC
• JTA

I casually recalled what I saw when I first came in. There were many unfamiliar English abbreviations (fortunately, Java didn’t have a variety of frameworks at that time, otherwise it would be even more confusing), and I didn’t know where to start learning. And my classmate happened to have a book on JSP, so I started with JSP. To be honest, it was a really bad book. I can’t even remember the name now. I roughly remember that I built a JSP Demo site based on some examples. After being tortured by various environments and container problems thousands of times, I finally ran an example. I finally saw the page in the example from the local browser. I felt a sense of accomplishment for a second, and then I was at a loss. Because I didn’t understand how all this worked at all, what were their principles? I went around in circles and took a lot of detours. If I were given another chance to start over, I would start with the basic Java language foundation.

What is the foundation? Java is an object-oriented language. The most important concept is the object, and all its syntax is just centered around it. The basic structures and variables of other programs: sequence, loop, branch, are just a different form of the previous language foundation. Once you understand objects, the concepts surrounding objects: classes and interfaces are natural extensions. Of course, mastering the core concepts and basic syntax is just the level of being able to write Hello World, but the point is that your starting point is right, and the journey is near.

At this stage, you can get familiar with the language and related libraries by reading good books and doing some basic exercises. In my impression, "Thinking In Java" is a good book for Java beginners (hey, I went around in circles to see this book), of course there are some other good books, such as "Introduction to Java Programming" and "Core Java". My feeling is that you can get a few more of these beginner books and read them for reference. After all, an author may have omissions. Read horizontally instead of reading a book from beginning to end vertically. Grasp each knowledge point one by one, understand it, and make a deep footprint with each step. Don't run around everywhere, the result will be general. Start slowly so that you can be fast later.

Regarding the basics, there are not many core and important parts in my eyes. I will briefly list them here:

◆Core Concept

• Object Model
• Interface design

◆Class Library

• lang
• collections
• concurrent
• io

I won't write much about the core concepts here, as they are basically reflected in all Java code libraries, and they are always there. The only difference is whether the understanding and abstraction are appropriate or not. There are so many libraries in JDK, but only a few are listed here. In fact, the most important thing I want to talk about in lang is String, which is overlooked by many people. There is no concept of String in C, but Java provides this object. However, if you fail to understand and use this object well, you will step on endless pits in the future, and step on them repeatedly. If you don't believe it, go and search for how many low-level problems there are about various character encodings and garbled characters. In addition, there are various performance problems caused by String. The core object String radiates out about character encoding, character byte expression (big endian, little endian, network byte order), the impact on GC, regular expressions, and pattern matching. This may be the object with the richest connotation in Java.

The Collections framework provides a large number of commonly used data structure encapsulations, which basically allows Java programmers to say goodbye to manually implementing most of the commonly used data structures you learned from the data structure course. Correctly understanding the applicable scenarios of different data structures is much more useful than being able to manually implement them yourself. Take a look at the code in Collections when you have nothing to do. They are all master-level implementations. I remember that when I was learning Java, it was still JDK 1.3. After I started working, the mainstream was 1.4. There was no concurrent library at that time. When I handled inter-thread communication myself, I was tortured by various notification omissions, early notifications, and deadlocks. So now Java programmers are much happier. Concurrent is another master-level class library implementation, and you can also take a look and think more when you have nothing to do. IO library, whether it is file IO or network IO, is the most common thing for Java programmers to deal with. It is important to be familiar with its API, but more importantly, it is to understand how to abstract and model IO operations, and understand the essence and principles behind different IO models.

Well, after completing the study of the above basic content, we got a map like the following.

The second skill map

Even if you have mastered the first picture, it is still a little difficult to roam freely in the world of Java. Now one of the mainstream use scenarios of Java is backend development. In its previous era, this field was dominated by J2EE (now called Java EE), also known as Java Enterprise Edition. J2EE contains a lot of content, and the core is EJB. At that time, I had just finished learning distributed object technology in school, using CORBA and EJB as examples for implementation. I also read several books on EJB design patterns and first practices. Then, before I graduated and entered the company for an internship, I found that everyone said that EJB is no longer used now. We use something called Spring. New English abbreviations such as IoC and DI appeared again. Before I could spit out a mouthful of old blood, I cheered up and started a new learning journey.

Yes, EJB began to slowly fade out of the mainstream at that time (2005). Rod Johnson, a doctor of musicology, pronounced the death sentence on EJB in his book "Expert One-on-One J2EE Development without EJB", and Spring came on the stage of history. Since then, Java has entered the era of great development of Framework, and the combination of technical frameworks such as SSH/SSI has become the mainstream of Java development, and continues to have an impact to this day.

There are more and more Java frameworks, and the ecosystem is getting bigger and bigger. Beginners must be confused when facing such a complex framework, and feel that there is no end to learning. In fact, in real projects, there are not many frameworks that are really used. SSH/SSI is basically the core framework of Java Web projects. It is your core tool to get started and you need to master it. But you need to know why. Spring takes over the work of object creation and interdependency management, and hides the design pattern in the application of the framework. Many people only know how to use it but never think about it. Web development has evolved from the early JSP stew (HTML + CSS + JS + Java + SQL. In the early days, I put all of these in a JSP. Think about how difficult it is to maintain) to the division of responsibilities of MVC. Only a View layer has also experienced the evolution from tag library to page template (Velocity, Freemarker). Now I prefer the more thorough front-end and back-end separation model. Once upon a time, adjusting the CSS styles of several pages killed so much of my time. Professional division of labor is conducive to efficiency and depth. The evolution of Web versions caused by the rapid development of the Internet and mobile Internet has made the complexity of the front-end no less than that of the back-end.

So how many frameworks should I master as a Java engineer? This is a false answer, because mastering any number of them will not be enough. The solution is to master a few core ones, have a general understanding of a large number of them, and master the ability to quickly learn frameworks. Taking SSH/SSI as an example, the trend of professional front-end division of labor is becoming more and more obvious, which completely liberates the distress of back-end Java engineers. Frameworks such as Spring solve a large number of general problems. Today's Spring is more than dozens of times larger than it was at the beginning (if all sub-projects named Spring are counted), and they all solve specific general problems. So when you are writing code and suddenly want to write a class named Util, stop and think about whether this is a class that solves general problems. You might as well search for ready-made class libraries, such as Apache Commons, which may have the code you need. General class libraries and frameworks free us to focus on business logic and efficiency, which may be the most valuable part of your code. Some programmers may complain that these are not technically content, but I think that being able to maximize business value with the most effective technology is the most technically content.

Frameworks are like weapons. I may not be able to use all eighteen (much more than eighteen) weapons, but we must have one ability, just like Zhang Wuji learning Tai Chi sword, he can defeat the enemy by learning sword. The trick here is not to learn moves, just like you may think you have mastered the use of Hibernate to perfection, but the database crashes as soon as it goes online. The essence here is still to understand relational (SQL) databases, and now perhaps we need to add the understanding of the principles and mechanisms of specific non-relational (NoSQL) databases, and even the essential understanding of O/R mapping models.

Therefore, the foundation is like internal strength, the framework is like a weapon, and the application is the moves. If you have a thorough understanding of the three, you can dominate the Java world. As mentioned above, based on this we have a second map.

The third extended picture

As for the third picture, I can no longer give a suggestion that I think is slightly universal. At this stage, everyone's growth and development direction will be affected by their environment and actual situation. I will use myself as an example to illustrate. In the past few years since I joined the Internet company, the development of Java technology has begun to change from a single application of J2EE containerization to SOA and microservices. Large-scale distributed systems have become the norm, so more of my related work is concentrated in this field. On the one hand, in-depth digging continues to fill in knowledge blind spots, such as the basis of distributed programs is RPC calls, and the essence of RPC is network plus object serialization. Correspondingly, you should thoroughly understand the principles of TCP, the network programming model under Unix/Linux, and several different network IO models. Then rise to the network programming model provided by Java based on this, BIO (blocking), NIO (non-blocking) and AIO (asynchronous IO), and combine it with actual work practice to have a deep understanding.

During this process, I came into contact with a large number of different RPC technologies, from Java's own RMI to WebService technical specifications. After that, some simpler and more powerful RPC frameworks emerged one after another, such as Hessian, Thrift, etc. The essence of different frameworks remains the same. With the development of service-oriented, service frameworks that provide additional value-added functions have been further derived based on the RPC framework, such as Alibaba's open source Dubbo. As work practice deepens, it is possible to go down to the JVM level to analyze the memory usage of objects, thread scheduling and delay. The core role of this stage is still the ability to quickly learn and apply to work practice mentioned above.

The other side of depth is horizontal expansion. As the nature of work changes, you may also need a broader technical knowledge. For example, after becoming an architect, the breadth of technical knowledge required will be higher in some aspects. Methodical technical learning and dabbling skills allow you to expand your technical breadth faster, examine different technical directions and products from a higher dimension, and make the most effective technical decisions.

Everyone at this stage may face different environments and practices, so the maps formed at this stage will vary greatly. The following is my third map, which is only for reference by fellow travelers on the Java journey. And the paths taken according to these different maps just happen to constitute you.

Even if you don't have a map yet, don't be confused and stop forever. Keep moving forward and you will always find a way. In fact, this is how I got here. I never dared to stop.