| Major version | Update time | note |
|---|---|---|
| v3.0 | 2020-03-31 | Perfect knowledge system, on the basis of V2.0, add about 20% knowledge Adjust the order and structure of some knowledge to facilitate reading and understanding Built on GitHub Page for easy reading |
| v2.0 | 2019-02-19 | Structural adjustment, more suitable from entry to mastery; Further improve the knowledge system; New technology supplement; |
| v1.1 | 2018-03-12 | Increase the knowledge of new technology and improve the knowledge system |
| v1.0 | 2015-08-01 | First release |
GitHub project address: Enter
GitHub Pages to read in full: Enter
Gitee Pages full read: Entry (faster domestic access)
Based on article
object-oriented
What is object Orientation
Object oriented and procedure oriented
Three basic features of object orientation
Five basic principles of object Orientation
Encapsulation, inheritance, polymorphism
What is polymorphism
Method overrides and overrides
Java inheritance and implementation
Inheritance and composition in Java
Constructor and default constructor
Class variables, member variables, and local variables
Member variables and method scope
Platform independence
How is Java platform independent
Which other languages are supported by the JVM
Value passed
Pass by value, pass by reference
Why is there only value passing in Java
Java Basics
Basic data type
Eight basic data types
The value range of integer byte, short, int, and long
What is a floating point?
What are single precision and double precision?
Why can’t you use floating-point amounts?
Automatic unpacking
Automatic unpacking
The caching mechanism for Integer
How to correctly define the type and name of the interface return value (Boolean /Boolean) (Success/SUCCESS)
String
Immutability of strings
The length limit of a String
How substring works in JDK 6 and JDK 7
ReplaceFirst, replaceAll, and Replace are different
The differences and associations between String, StringBuilder and StingBuffer
String overloading of “+”
Several ways and differences of string concatenation
The difference between string. valueOf and integer.toString
Switch’s support for strings
String pooling
Constant pool (runtime constant pool, Class constant pool)
intern
Keywords in Java
transient
instanceof
volatile
synchronized
final
static
const
Collection classes
The difference between Collection and Collections
The use of common collection classes
Set is different from List
ArrayList versus LinkedList versus Vector
The difference between SynchronizedList and Vector
How does a Set ensure that elements are not repeated
Difference between HashMap, HashTable, and ConcurrentHashMap
Java 8 Map related red-black tree reference background, principles, etc
HashMap capacity, expansion, and hash principles
Stream in Java 8
Use of the Apache collection processing tool classes
How different versions of the JDK implement HashMap and why
What should we pay attention to when using the List obtained by Arrays.asList
How to iterate a Collection
The difference between Enumeration and Iterator
How do I delete elements in an ArrayList while iterating
Fail fast and fail – safe
CopyOnWriteArrayList
ConcurrentSkipListMap
The enumeration
Use of enumerations
Implementation of enumerations
Enumerations and singletons
An Enum
How do Java enumerations compare
Switch support for enumerations
How is serialization of enumerations implemented
Thread safety of enumerations
IO
Character stream, byte stream
Input stream, output stream
Conversion between byte streams and character streams
Synchronous, asynchronous
Blocking, non-blocking
Linux has five I/O models
The difference between BIO, NIO and AIO
The usage and principle of the three IO
netty
reflection
What is reflection
What does reflex do
Class Class
java.lang.reflect.*
A dynamic proxy
Static agent
A dynamic proxy
Relationship between dynamic proxy and reflection
Dynamic proxy is implemented in several ways
AOP
serialization
What is serialization and deserialization
How does Java implement serialization and deserialization
How Serializable is different from Externalizable
Why you need serialization
serialVersionUID
Why can’t serialVersionUID be changed
transient
Underlying principles of serialization
How does serialization break singletons
protobuf
Why is serialization unsafe
annotations
Yuan notes
Custom annotations
Java commonly used in annotations
A combination of annotations and reflection
How do I customize an annotation?
Spring Common Annotations
The generic
What is a generic
Type erasure
Problems with generics
In generics, K, T, V, E? Meaning of object, etc
Various uses of generics
Qualified wildcards and unqualified wildcards
The upper and lower bounds are extends and super
What’s the difference between List and the original List?
List<? What is the difference between > and List?
Unit testing
junit
Junit and Spring
mock
mockito
In-memory database (H2)
Regular expressions
java.lang.util.regex.*
Common Java tool libraries
apache-commons
google-guava
netty
API&SPI
API
The relationship and difference between API and SPI
How to define SPI
The implementation principle of SPI
abnormal
The Error and the Exception
Exception types
Exception related keywords
Handling exceptions correctly
Custom exception
Abnormal chain
try-with-resources
Finally and return execution order
Time to deal with
The time zone
Winter time and daylight time
The time stamp
Time in Java API(Java 8)
Greenwich mean time
The meaning and relationship of CET, UTC, GMT and CST
Thread safety issues with SimpleDateFormat
Time processing in Java 8
How do I get American time on the e8 computers
What’s the difference between YYYY and YYYY?
encoding
What is ASCII?
Unicode
Why you need UTF-8 when you have Unicode
UTF8, UTF16 and UTF32 are different
Why GBK is needed when you have UTF8?
The difference between GBK, GB2312 and GB18030
URL decoding
Big Endian and Little Endian
How to solve the garbled characters problem
Syntactic sugar
Java grammar sugar principle, solution sugar
Principle of sugar Switch supports strings and enumerations, generics, autoboxing and unboxing, method variable length arguments, enumerations, inner classes, conditional compilation, assertions, numeric literals, for-each, try-with-resource, Lambda expressions, local variable type inference, and record
JMS
What is the Java Message Service
JMS messaging model
JMX
java.lang.management.*
javax.management.*
Java 8
Lambda expressions
Stream API
Time API
Read the source code
String
Integer
Long
Enum
BigDecimal
ThreadLocal
ClassLoader & URLClassLoader
ArrayList & LinkedList
HashMap & LinkedHashMap & TreeMap & CouncurrentHashMap
HashSet & LinkedHashSet & TreeSet
Java Concurrent programming
Concurrency and parallelism
What is concurrency
What is parallelism
The difference between concurrent and parallel
thread
The difference between threads and processes
Implementation of threads
Thread state
Thread priority
Thread scheduling
How to Debug multithreading
Daemon thread
Multiple ways to create threads
Create a Thread by inheriting the Thread class
Implement the Runnable interface to create threads
Create threads from Callable and FutureTask
Create a thread from a thread pool
The thread pool
Design your own thread pool
Submit () and execute ()
Thread pool Principle
Why don’t YOU allow Executors to create a thread pool
Thread safety
What is thread-safe
Multi-level caching and consistency issues
CPU time slices and atomicity problems
Order rearrangement and order problems
Relationship between thread safety and memory model
happens-before
as-if-serial
The lock
Reentrant lock
Blocking locks
Optimistic lock and pessimistic lock
Database-related locking mechanism
A distributed lock
unlocked
CAS
ABA problems in CAS
Lock the optimization
Biased locking
Lightweight lock
Heavyweight lock
Lock elimination
Lock coarsening
spinlocks
A deadlock
What is a deadlock
The cause of the deadlock
How do I avoid deadlocks
Write a deadlock program
How do I troubleshoot a deadlock
synchronized
How is synchronized implemented?
The relationship between synchronized and lock
How do you implement a thread-safe singleton without using synchronized
Synchronized and atomicity
Synchronized and visibility
Synchronized and synchronized
volatile
Compiler instruction reorder and CPU instruction reorder
The implementation principle of volatile
The memory barrier
Volatile and atomicity
Volatile and visibility
Volatile and order
Why do you need volatile when you have symchronized
Thread dependent method
start & run
sleep & wait
notify & notifyAll
ThreadLocal
ThreadLocal principle
The underlying data structure of a ThreadLocal
Write code to solve producer-consumer problems
And contract
Synchronizing containers with concurrent containers
Thread
Runnable
Callable
ReentrantLock
ReentrantReadWriteLock
Atomic*
Semaphore
CountDownLatch
ConcurrentHashMap
Executors
The underlying article
JVM
JVM memory structure
Runtime data area
Which run-time data areas are exclusive to threads
The difference between heap and stack
The location of the method area in different versions of the JDK
Out of memory
TLAB
Are objects in Java necessarily allocated on the heap?
The garbage collection
GC algorithm: mark clear, reference count, copy, mark compression, generational collection, incremental collection
The GC parameter
Determination of object survival
Garbage collector (CMS, G1, ZGC, Epsilon)
JVM parameters and tuning
-Xmx
-Xmn
-Xms
Xss
-XX:SurvivorRatio
-XX:PermSize
-XX:MaxPermSize
-XX:MaxTenuringThreshold
Java Object Model
oop-klass
Object head
HotSpot
Just-in-time compiler
Compiler optimization
Java Memory Model
Computer memory model
Cache consistency
The msci agreement
visibility
atomic
sequential
happens-before
as-if-serial
The memory barrier
synchronized
volatile
final
The lock
Vm performance monitoring and troubleshooting tool
jps
jstack
jmap
jstat
jconsole
jinfo
jhat
javap
btrace
TProfiler
Arthas
Class loading mechanism
classLoader
Is the class loading process thread-safe?
Class loading process
Parental delegation (breaking parental delegation)
Modularity (Jboss Modules, OSGI, Jigsaw)
Packaging tools
Jar, jlink, jPackage
Compile and decompile
What is compilation
What is decompilation
Compile tool: Javac
Decompiler tools: JavAP, JAD, and CRF
JIT
JIT optimization (escape analysis, allocation on stack, scalar substitution, lock optimization)
Advanced article
Java Underlying knowledge
The bytecode
Class File Format
CAFEBABE
An operation
With bit operations to achieve addition, subtraction, multiplication, division, take mod
Design patterns
Six principles of design patterns
The open closed principle
Richter’s substitution principle
Rely on the inversion principle
Interface isolation Rule
Demeter’s Law (least known principle)
Principle of composite reuse
Creative design patterns
The singleton pattern
Abstract Factory pattern
Builder mode
The factory pattern
The prototype pattern
Structural design mode
Adapter mode
The bridge model
Decorative pattern
Portfolio model
The appearance model
The flyweight pattern
The proxy pattern
Behavioral design patterns
Template method pattern
Command mode
Iterator pattern
Observer mode
The mediator model
Memorandum Mode
Interpreter mode
The state pattern
The strategy pattern
Chain of responsibility model
Visitor pattern
Seven ways to write singletons
Slob – Thread unsafe
Slob — thread safe
The hungry
Hungry man — variant
Static inner class
The enumeration
Double check lock
Why is it recommended to implement singletons using enumerations?
The difference and connection of three factory modes
Simple factory, factory method, template factory
Common design patterns are used
Adapter mode
The strategy pattern
Template method pattern
Observer mode
The appearance model
The proxy pattern
Implement a thread-safe singleton pattern without synchronized or lock
Nio and REACTOR design model
What design patterns are used in Spring
Knowledge of network programming
Commonly used protocol
TCP, UDP, HTTP, and HTTPS
Using Java to achieve FTP, SMTP protocol
OSI seven-layer model
Main protocols for each layer
TCP/UDP
Three handshakes with four closes
Flow control and congestion control
TCP bonding and unpacking
TCP/IP
IPV4
IPV6
HTTP
Differences between HTTP /1.0 HTTP /1.1 HTTP /2
Differences between HTTP and HTTPS
The difference between GET and POST in HTTP
Common Web request return status code
What do 404, 302, 301 and 500 stand for
An HTTP server that writes a simple static file in Java
http/2
Java RMI, Socket, HttpClient
The cookie and session
If cookie is disabled, how to implement session
Understand the nginx and Apache server features and set up a corresponding server
Means of interprocess communication
What is a CDN? If implemented?
DNS
What is the DNS
Record type :A record, CNAME record, and AAAA record
Domain name resolution
Root DNS server
DNS pollution
DNS hijacking
Public DNS: 114 DNS, Google DNS, and OpenDNS
The agent
The reverse proxy
Forward agent
Reverse proxy server
Framework of knowledge
Servlet
The life cycle
Thread safety issues
The filter and the listener
Common configurations and functions in web. XML
Hibernate
What is OR Mapping
Hibernate’s caching mechanism
Lazy loading of Hibernate
Hibernate/Ibatis/MyBatis
MyBatis
Mybatis caching mechanism
${} = ${
Multiple parameters are passed in mapper
Mybatis dynamic SQL
Lazy loading for Mybatis
Spring
Initialization of the Bean
AOP principle
Implement Spring’s IOC
Spring has four dependency injection methods
Spring MVC
What is the MVC
Differences between Spring MVC and Struts MVC
Spring Boot
Spring Boot 2.0
Start relying on
Automatic configuration
The starter principle of Spring Boot
Create your own starter
Why can Spring Boot start web projects from Main
Spring Security
Spring Cloud
Service discovery and registration: Eureka, Zookeeper, Consul
Load balancing: Feign, Spring Cloud Loadbalance
Service configuration: Spring Cloud Config
Service current limiting and fusing: Hystrix
Service link tracking: Dapper
Service gateway, security, messaging
Knowledge of application servers
JBoss
tomcat
jetty
Weblogic
tool
git & svn
maven & gradle
Git skills
Branch merge
Conflict resolution
Commit rollback
Maven skills
Rely on the tree
Rely on arbitration
Intellij IDEA
Common plugins: Maven Helper, FindBug-idea, Alibaba code specification detection, GsonFormat, Lombok Plugin,.ignore, Mybatis Plugin
Senior post
The new technology
Java 9
Jigsaw
Jshell
Reactive Streams
Java 10
Local variable type inference
Parallel Full GC for G1
ThreadLocal handshake mechanism
Java 11
ZGC
Epsilon
Enhance the var
Java 12
Switch
Java 13
Text Blocks
Dynamic CDS Archives
Java 14
Java packaging tools
The more valuable NullPointerException
Record type
Spring 5
Responsive programming
Spring Boot 2.0
http/2
http/3
Performance optimization
Use the singleton
Using the Future pattern
Using thread pools
Choose ready
Reduce context switching
Reduce lock size
Data compression
Results the cache
Parallel flow Stream
The GC tuning
JVM memory allocation tuning
SQL tuning
On-line problem analysis
dump
A thread Dump
Memory Dump
The gc conditions
Dump obtaining and analyzing tool
jstack
jstat
jmap
jhat
Arthas
Dump analyzes deadlocks
Dump analyzes memory leaks
Write a variety of outofMemory, StackOverflow program
HeapOutOfMemory
Young OutOfMemory
MethodArea OutOfMemory
ConstantPool OutOfMemory
DirectMemory OutOfMemory
Stack OutOfMemory Stack OverFlow
Arthas
The JVM related
The class/this correlation
Monitor/watch/trace
options
The pipe
Background Asynchronous Task
Solutions to common problems
Out of memory
The thread deadlock
Class loading conflict
The load high
CPU usage skyrocketed
Slow SQL
Use the tool to try to solve the following problems and write a summary
How do you find problems when a Java program is slow to respond
How to solve the problem when a Java program frequently FullGC
How do I view garbage collection logs
What happens when OutOfMemory occurs in a Java application
How can I tell if a deadlock has occurred
How do I know if there is a memory leak
Use Arthas to quickly troubleshoot Spring Boot application 404/401
Use Arthas to troubleshoot the online application log filling problem
Use Arthas to check the Spring Boot application NoSuchMethodError
Knowledge of compilation principles
Compile and decompile
Compilation and decompilation of Java code
Java decompile tool
javap
jad
CRF
Just-in-time compiler
Compiler optimization
Operating system knowledge
Common Linux commands
Find, grep, ps, cp, move, tar, head, tail, netstat, lsof, tree, wget, curl, ping, SSH, echo, free, and top
Interprocess communication
Server Performance Indicators
load
CPU utilization
Memory usage
qps
rt
Process synchronization
Producer consumer problem
The Philosopher’s Dining problem
Reader writer question
Buffer overflow
Segmentation and pagination
Virtual memory and main memory
Virtual memory management
Form-feed algorithm
Database knowledge
MySql Execution Engine
MySQL Execution Plan
How do I view an execution plan
How to optimize SQL according to the execution plan
The index
Hash index &B tree index
Common index & unique index
Clustered index & non-clustered index
Cover index
Leftmost prefix rule
An index pushdown
Index of the failure
Back to the table
SQL optimization
Database transaction and isolation levels
The transaction of the ACID
Transaction isolation level and read phenomenon
Transaction can implement the lock function
encoding
utf8
utf8mb4
Why not use UTF8 encoding in the database
The number of rows of statistical
Difference between count(1), count(*), and count(field)
Why count(*) is recommended
The database lock
Shared locks, exclusive locks
Row lock, table lock
Optimistic lock, pessimistic lock
Use database locks to implement optimistic locking
Gap Lock, next-key Lock
The connection
In the connection
Left connection
The right connection
Set up the active and standby databases
log
binlog
redolog
In-memory database
h2
Depots table
Reading and writing separation
Common NOSQL databases
redis
memcached
Database lock and NoSql are used to implement distributed lock respectively
Performance tuning
Database connection Pool
Knowledge of data structures and algorithms
Simple data structures
The stack
The queue
The list
An array of
Hash table
The similarities and differences between stacks and queues
Stack usually adopts two kinds of storage structure
Two stacks implement the queue, and two queues implement the stack
The tree
Binary tree
The dictionary tree
Balanced tree
Sort tree
B tree
B + tree
R tree
Many trees
Red and black tree
The heap
Big root pile
Small root pile
figure
Directed graph
Undirected graph
The topology
Stable sorting algorithm
Bubble sort
Insertion sort
Cocktail order
Bucket sort
Count sorting
Merge sort
Merge sort in place
Binary sort tree sort
Pigeon nest order
Radix sort
Gnome sorting
Library sorting
Piece of sorting
Unstable sorting algorithm
Selection sort
Hill sorting
Clover sorting algorithm
Comb the sorting
Heap sort
Smooth sorting
Quick sort
Introspective sort
Patience to sort
Time complexity & space complexity
How to calculate time and space complexity
Time complexity of common sorting algorithms
Depth first and breadth first search
The whole arrangement
Greedy algorithm
KMP algorithm
The hash algorithm
Mass data processing
Divide and conquer
The hash map
Heap sort
Double barrel division
Bloom Filter
bitmap
Database index
Graphs etc.
Big Data knowledge
search
Solr
Lucene
ElasticSearch
Flow calculation
Storm
Spark
Flink
Hadoop, offline computing
HDFS
MapReduce
Distributed Log Collection
flume
kafka
logstash
Data mining
mahout
Network Security Knowledge
XSS
XSS defenses
CSRF
Injection attacks
SQL injection
XML injection
CRLF injection
File upload Vulnerability
Encryption and decryption
Symmetric encryption
Asymmetric encryption
The hash algorithm
Salt hashing algorithm
The encryption algorithm
MD5
SHA1
DES
AES
RSA
DSA
Rainbow table
DDOS attack
DOS attack
DDOS attack
Why can Memcached cause DDos attacks
What is reflective DDoS
How do I use Hash collisions to launch DOS attacks
SSL, TLS, and HTTPS
Destocking, washing and colliding
Architecture article
Architectural Design Principles
Single responsibility principle
Open and closed principle
Richter’s principle of substitution
Principle of dependence inversion
Interface separation Principle
distributed
Distributed and Clustered
Data consistency
Service governance
Service degradation
Distributed theory
2PC
3PC
CAP
BASE
Distributed coordination with Zookeeper
The basic concept
Common use
ZAB algorithm
Split brain
Distributed transaction
Local transactions & distributed transactions
Reliable message ultimate consistency
Best effort notice
TCC
Dubbo
The service registry
Service discovery
Service governance
Distributed database
How do you build a distributed database
When do you need a distributed database
mycat
otter
HBase
Distributed file system
mfs
fastdfs
Distributed cache
Cache consistency
Cache hit ratio
Cache redundancy
Current limiting the drop
Fuse mode
Hystrix
Sentinal
resilience4j
Distributed algorithm
Byzantine problems and algorithms
2PC
3PC
Consensus algorithm
Paxos algorithm and Raft algorithm
ZAB algorithm
Domain driven design
Entities, value objects
Polymerization, polymerization root
Bounded context
How is DDD layered
Hyperemia model and anemia model
What does DDD have to do with microservices
Micro service
SOA
Conway’s law
ServiceMesh
sidecar
Docker & Kubernets
Spring Boot
Spring Cloud
High concurrency
Depots table
Horizontal split and horizontal split
Distributed transaction problem after dividing database and table
CDN technology
The message queue
RabbitMQ, RocketMQ, ActiveMQ, Kafka
Comparison of message queues
High availability
Double machine architecture
Lord for copy
A master-slave replication
The main master replicates
Different live
A high performance
High performance database
Reading and writing separation
Depots table
High performance cache
The cache to penetrate
Cache avalanche
Caching hot
Load balancing
PPC, TPC
monitoring
What to monitor
CPU
memory
Disk I/O
Network I/O, etc
Monitoring means
Process monitoring
Semantic monitoring
Machine resource monitoring
Data fluctuation
Monitoring Data Collection
The log
Buried point
Dapper
Load balancing
Load balancing classification
Layer 2 Load Balancing
Layer 3 load balancing
Layer 4 load balancing
Seven layers of load balancing
Load balancing tool
LVS
Nginx
HAProxy
Load balancing algorithm
Static load balancing algorithm: polling, ratio, priority
Dynamic load balancing algorithm: Minimum number of connections, fastest response time, observation method, prediction method, dynamic performance allocation, dynamic server complement, quality of service, service type, regular pattern.
DNS
Principle of DNS
The design of the DNS
CDN
Data consistency
Expand the article
Cloud computing
IaaS
SaaS
PaaS
Virtualization technology
openstack
Serverlsess
Search engine
Solr
Lucene
Nutch
Elasticsearch
Rights management
Shiro
Block chain
The hash algorithm
Merkle tree
Public key cryptography algorithm
Consensus algorithm
Raft agreement
Paxos algorithm and Raft algorithm
Byzantine problems and algorithms
Message authentication code and digital signature
The currency
dig
Consensus mechanism
Lightning network
Side chain
Hot issue
y
The etheric fang
Super books
Artificial intelligence (ai)
Mathematical basis
Machine learning
Artificial neural network
Deep learning
Application scenarios
Common framework
TensorFlow
DeepLearning4J
IoT
Quantum computing
AR & VR
Other languages
Groovy
Kotlin
Python
Go
NodeJs
Swift
Rust
