Java practical operation Guide Business code – Integration framework – Storage – Cache common error details

Passed the interview, but worried that ** won’t pass the probation period? Clearly done seriously, or bugs flying everywhere? Java developers who are just starting out will always encounter some kind of pit. Senior technical experts, with years of experience, eliminate error-prone, easily ignored, easily misinterpreted “pits” for you, according to the business needs process, take your system to deal with business code-integration framework-storage-cache common mistakes, clean up knowledge mistakes. Through the course, let you understand the key, difficult points and knowledge points more clear and skilled, help you upgrade to a higher level!

** Chapter 1 Course Introduction ** ** Introduces the original intention of making this course, my positioning and vision of this course, what the course contains, what it can help you, and how to learn this course, so as to better digest and absorb it. ** **1-1 Why do you take this course and try ** **1-2 Why do we need every ** of you **1-3 In addition to feeling, you can also do this when you have a problem ** Chapter 2: Java Null Pointers and Exceptions — Frequent Offense index 5 stars ** This chapter will teach you how to avoid these problems, how to avoid null pointer problems with Optional, and how to use try catch correctly **2-1 how to avoid null pointer at the root **2-2 empty pointer ** is automatically unpacked during assignment **2-3 How to use a null pointer to a string, array, or collection? ** **2-4 What should I pay attention to when using Optional? ** **2-5 Try catch without exception ** **2-6 Common exceptions: concurrent modification, type conversion, enumeration lookup ** ** Common exceptions in 2-7 encoding ** **2-8 Using try Finally to leak resources ** ** Chapter 3 Java Computing, Collections, interfaces — Frequent Offender index 4 stars ** ** No matter what kind of business development is inseparable from the use of calculation and collection data structure, frequent use of frequent errors is obviously unacceptable, this chapter will show you the most common errors and solutions; Beginners often confuse interfaces with abstract classes, especially after Java8 added default and static methods. This chapter will teach you how to use and understand them properly… ** **3-1 BigDecimal error? It’s all precision **3-2 why do you always use bad date calculation? ** **3-3 Reasons why the SimpleDateFormat thread is unsafe ** **3-4 I just want to iterate over elements, I don’t need indexes ** **3-5 nested iterations, beware of premature exhaustion outside! ** **3-6 If not properly evaluated, the collection storage will be messed up ** **3-7 What if LOMbok annotations don’t meet expectations? ** **3-8 How to avoid abstract class and interface selection mistakes? ** **3-9 Interface default method and static method overwrite always not expected? ** **3-10 Lambda expressions can’t be written anywhere ** Are 3-11 lambda and Stream really efficient? ** ** Chapter 4 Generics, Reflection, and Compiler Optimization — Frequent Offense index 3 stars ** ** Generics and reflection are advanced features of the Java language. Beginners are prone to various exceptions and problems. This chapter takes you through the analysis, understanding and use of these advanced features. Although the compiler optimizes our code, it doesn’t always make sense, so we can’t rely on compiler optimizations, and this chapter will take you through that as well… ** **4-1 If the parent class does not implement Serializable, the subclass cannot implement Serializable. ** **4-2 Implements Serializable interface error how to do? ** **4-3 Generics are more than just specifying types in collections ** **4-4 Generic features you must know ** **4-5 Using primitive types may have disastrous consequences **4-6 reflection is also a flawed ** **4-7 Reflection can not get Method why? ** Not all string concatenation uses StringBuilder** **4-9 Will dark copy be used in practice? ** **4-10 Does your serialization implement deep copy or shallow copy? ** ** Chapter 5 Java Thread Safety — Frequent Offense index 3 stars ** ** on thread safety, multithreading and so on such problems, it can be said that a large number of Java beginners, so, because there is no idea, no way to break this kind of knowledge points, this chapter will take you to appreciate the charm of thread safety, multithreading, let you learn to use them correctly and reasonably. ** **5-1 Synchronized keyword ** **5-2 How to update variable values in multiple threads ** **5-3 When it comes to blocking queues, do you feel confused ** **5-4 Not always a good time to use copy-on-write ** **5-5 Using thread pools, have you ever encountered a denial of execution exception? ** **5-6 Thread pools are actually tools for managing threads ** **5-7 How to implement thread status monitoring? ** ThreadLocal is not designed to solve concurrency or sharing problems If ThreadLocal is not used properly, memory leaks are possible ** Chapter 6 Pit in Spring ** For students who are new to Spring, it is not easy to use Spring. There are endless questions about Bean names, automatic injection, container and context understanding, Scope, loop dependency, transactions and so on. This chapter will take you to read Spring features. Understand and use Spring well **6-1 Spring configuration files to be careful “one step in place” ** **6-2 Do you know the default name generation strategy for Spring beans? ** **6-3 uses the @autowired annotation, but the null pointer ** still appears **6-4 Do you get context without auto injection? (on) * * **6-5 Do you get context without auto injection? (bottom) * * ** What if the 6-6 Bean data does not conform to expectations ** **6-7 How often do you report the “multiple available beans” exception? (on) * * **6-8 How often do you report the “multiple available beans” exception? (bottom) * * **6-9 Spring Bean has cyclic dependencies. What should I do? ** **6-10 What else can we do before instantiating the Bean? ** **6-11 Learn to take advantage of the Bean life cycle and get twice the result with half the effort **6-12 Is your @Transactional mark in the correct position? ** **6-13 cannot rollback @transactional ** ** Pits in SpringMVC in Chapter 7 You may have encountered problems with response codes, serialization and deserialization, and may be confused about the difference between interceptors and filters, how to use them, and the mutual exclusion of streams. This chapter will help you understand these features and avoid common misuses **7-1 Do you always have trouble understanding other people’s custom exceptions? ** **7-2 Clearly should throw a custom exception, how to return 500? ** **7-3 Time format cannot be converted properly? Check the POST request ** **7-4 Time format local processing really good? ** **7-5 Can’t enter breakpoint during debugging? Multiple Fliters may be stuck **7-6 Whether logs should be placed in interceptors or filters ** **7-7 Reads the Request input stream, and the Request data is missing ** **7-8 Failed to obtain data? It is possible that methods are mutually exclusive ** Chapter 8 Pits in SpringBoot ** **SpringBoot depends on configuration, but have you figured out configuration priorities? Periodic tasks and asynchronous tasks are easy to write, but how to troubleshoot problems? What do you know about the default Jackson tool? This chapter will guide you through the proper use of these features and knowledge **8-1 Configuration error? Do you use both.properties and.yml? ** **8-2 Change the position of the configuration is invalid? Figure out the loading order ** **8-3 Timed tasks are not timed, what is wrong with this? ** **8-4 Thread pool error can’t see cause? It is possible that the asynchronous task was not handled properly **8-5 What can I do if an asynchronous task times out? ** **8-6 Slow speed, have you ever thought that ObjectMapper might be instantiated too many times? ** **8-7 What’s the difference between Jackson and fastJson? ** ** Chapter 9: MySQL MySQL ** Beginners must be able to understand and the correct use of data types, indexes and transactions, which is the most basic characteristics of the database, and then gradually advanced to slow query optimization, learn to sub-database sub-table and so on, this chapter with me to learn, understand these knowledge points it ** **9-1 table properties set to NULL, you may face a lot of trouble ** **9-2 No longer arbitrarily set data type, do not leave hidden trouble for the future ** **9-3 index added badly, the effect may be counterproductive (top) ** **9-4 index added badly, the effect may be counterproductive (below) ** **9-5 MySQL is disconnected ** **9-6 Transaction processing error? Maybe it’s the wrong lock **9-7 Your SQL may be slow, how can you optimize it? ** **9-8 Is it feasible to consider separate databases and tables only when the amount of data increases gradually? ** ** Chapter 10 Pits in Redis ** ** key-value type caching seems simple enough, but choosing the right data structure is not. It sounds even harder when you have to consider performance, memory optimization, data persistence, cache penetration and avalanche. However, this chapter will take you through each of these questions and knowledge points one by one… ** **10-1 How to correctly select the data type, so that maintenance is no longer a nightmare ** **10-2 uses transaction function, why not rollback? ** **10-3 Redis performance is not good, maybe there is a big key** **10-4 Redis running out of memory ** **10-5 What if memory is not enough after expiration? ** **10-6 How to solve the performance bottleneck caused by frequent command round-tripping? ** **10-7 Have you configured persistence? ** **10-8 Does your code have cache penetration problems? ** **10-9 What if a cache avalanche occurs? How to avoid it? ** ** This course has been completed **