Basic knowledge and optimization of MySQL database

itread01 2021-01-22 01:18:44
basic knowledge optimization mysql database


> MySQL The basic knowledge of database and the necessary knowledge of optimization , How much do you have ?** Recommended reading :** - [ Do you have all the necessary computer network knowledge ](https://www.cnblogs.com/zydybaby/p/14154148.html) - [ Knowledge about database transactions and locks , How much do you have ?](https://www.cnblogs.com/zydybaby/p/14235046.html) - [ About database index , The knowledge that must be mastered ](https://www.cnblogs.com/zydybaby/p/14205890.html)[TOC]### SQL Sentence basic knowledge and optimization #### SQL What are the main types of sentences *- By definition, language DDL(Data Definition Language): There are mainly CREATE,DROP,ALTER And so on have operations on the logical structure , Include table structure 、 View and index .- Database query language DQL(Data Query Language): Mainly with SELECT Mainly - Data manipulation language DML(Data Manipulation Language): It mainly includes INSERT,UPDATE,DELETE- Data control function DCL(Data Control Language): The main reason is that permission control can operate , Include GRANT,REVOKE,COMMIT,ROLLBACK etc. .#### SQL What are the constraints ? **- Primary key constraint : A primary key is a combination of one or more columns in a table , Can uniquely identify each row in the table . A table has only one primary key , And the column of primary key constraint cannot be empty .- Foreign key constraint : Foreign key constraints are used to establish a relationship between two tables , You need to specify which column of the main table is referenced . Only the primary key of the primary table can be used as a foreign key by the secondary table , The columns of the constrained slave table may not be primary keys , Therefore, to create foreign key constraints, you need to define the primary key of the main table first , Then define the foreign key from the table .- Unique constraint : Make sure that a column of data in the table does not have the same value , A table can define multiple unique constraints .- Preset constraints : When inserting new data , If the row does not specify data , The system assigns the default value to the line , If it's not set, it's not preset , It is NULL.- Check Constraint :Check Will judge the validity of data through logical expression , Used to limit the range of input values for one or more columns . When the column is updated , The input must satisfy Check The constraints .#### What is a subquery ? ** Subquery : Using the results of one query in another query can be divided into the following categories :- Scalar subquery : A subquery returns a value , have access to =,>,<,>=,<=,<> The scalar results of the subquery are compared with the scalar results of the subquery , Generally, subqueries are placed on the right side of the comparison . ```mysql SELECT * FROM user WHERE age = (SELECT max(age) from user) // Ask the oldest person ```- Column subquery : The result of a subquery is n Row by column , It is generally used to query a field of a table and return . have access to IN、ANY、SOME and ALL Wait for the operator , Can't be used directly ```mysql SELECT num1 FROM table1 WHERE num1 > ANY (SELECT num2 FROM table2) ```- Line sub query : A row of results returned by a subquery n Column ```mysql SELECT * FROM user WHERE (age,sex) = (SELECT age,sex FROM user WHERE name="zhangsan") ```- Table subquery : The subquery is n That's ok n A data table of columns ```mysql SELECT * FROM student WHERE (name,age,sex) IN (SELECT name,age,sex FROM class1) // Find the class in the student table 1 Class students ```#### Understanding MySQL Are there several kinds of online queries ? ***MySQl The connection query of can be divided into external connection , Internal connection , Cross connect - External connection The outer line is mainly divided into left outer line (LEFT JOIN)、 Right outer connection (RIGHT JOIN)、 All out connection . Left outer link : Display all the data in the left table and the qualified data in the right table , The unqualified data in the right table are null.![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121200805324.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center) Right outer connection : Display all the data in the left table and the qualified data in the right table , The unqualified data in the right table are null.![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121200819174.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center) MySQL All external connections are not supported in .- Internal connection : Only the qualified data will be displayed ![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121200829676.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center) - Cross connect : A kind of connection using Cartesian product . Cartesian product , Baidu Encyclopedia's explanation : Two sets *X* and *Y* The Cartesian product of is expressed as *X* × *Y*, The first object is *X* And the second object is *Y* One of the members of all possible ordered pairs of . for example :A={a,b},B={0,1,2},A × B = {(a,0),(a,1),(a,2),(b,0),(b,1),(b,2)} Here's an example : There are two tables divided into L Table and R surface .L surface | A | B || :--: | :--: || a1 | b1 || a2 | b2 || a3 | b3 |R surface | B | C || :--: | :--: || b1 | c1 || b2 | c2 || b4 | c3 |- Left outer link :```select L.`*`,R.`*` from L left join R on L.b=R.b``` | A | B | B | C | | :--: | :--: | :--: | :--: | | a1 | b1 | b1 | c1 | | a2 | b2 | b2 | c2 | | a3 | b3 | null | null |- Right outer connection :```select L.`*`,R.`*` from L right join R on L.b=R.b ``` | B | C | A | B | | :--: | :--: | :--: | :--: | | b1 | c1 | a1 | b1 | | b2 | c2 | a2 | b2 | | b4 | c3 | null | null |- Internal connection :```select L.`*`,R.`*` from L inner join R on L.b=R.b``` | A | B | B | C | | :--: | :--: | :--: | :--: | | a1 | b1 | b1 | c1 | | a2 | b2 | b2 | c2 |- Cross connect :```select L.`*`,R.`*` from L,R``` | A | B | B | C | | :--: | :--: | :--: | :--: | | a1 | b1 | b1 | c1 | | a1 | b1 | b2 | c2 | | a1 | b1 | b4 | c3 | | a2 | b2 | b1 | c1 | | a2 | b2 | b2 | c2 | | a2 | b2 | b4 | c3 | | a3 | b3 | b1 | c1 | | a3 | b3 | b2 | c2 | | a3 | b3 | b4 | c3 |#### mysql in in and exists The difference between ? **in and exists Generally used for subqueries .- Use exists The appearance query will be performed first , Bring the data in each row to the inner table to see if the conditions are met ; Use in Generally, we will first query the inner table to get the result set , Then query the surface to match the result set , Return data .- in Indexes are used in both inner table and outer table queries .- exists The index is only used when querying the inner table - In general , When the result set of a subquery is large , Small in appearance, use exist More efficient ; When a subquery finds a smaller result set , When the appearance is bigger , Use in More efficient .- For not in and not exists,not exists Efficient than not in The high efficiency , Independent of the result set of the subquery , Because not in Full table scanning has been carried out for both internal and external tables , Index not used .not exists The index on the table can be used in the subquery of .#### varchar and char The difference between ? ***- varchar It means getting longer ,char It means the length is fixed . When the inserted characters exceed their length , In strict mode , Will refuse to insert and prompt error information , In general mode , It will be retrieved and inserted . Such as char(5), No matter what the length of the inserted character is , The length is 5, The length of the insert is less than 5, Then fill in the blanks . For varchar(5), If the length of the inserted character is less than 5, The length of the stored character is the length of the inserted character , It doesn't fill .- Storage capacity is different , For char Say , The maximum number of characters that can be stored is 255. For varchar, The maximum number of characters that can be stored is 65532.- Different storage speeds ,char Fixed length , Storage speed will be faster than varchar faster , But it takes up extra space in terms of space , It belongs to a strategy of exchanging space for time . and varchar Space utilization will be higher , But storage is slow , It's a strategy of time for space .#### MySQL in int(10) and char(10) and varchar(10) The difference between ? ***int(10) Medium 10 It shows the length of the display data , and char(10) and varchar(10) It means the size of the stored data .#### drop、delete and truncate The difference between ? **| | drop | delete | truncate || :------: | :--------------------------------: | :----------------------------------: | :--------------------------: || Speed | fast | Delete line by line , slow | Faster || Type | DDL | DML | DDL || Roll back | Can't roll back | Rollback possible | Can't roll back || Delete content | Delete the entire table , Columns 、 Indexes will be deleted | The table structure is still , Delete some or all of the data in the table | The table structure is still , Delete all data of the table | Generally speaking , Delete the entire table , Use drop, Delete part of table data using delete, Keep the table structure and delete all data of the table truncate.#### UNION and UNION ALL The difference between ? **union and union all The role of both is to merge two result sets together .- union The results are de duplicated and sorted ,union all Directly return the merged result , No duplication, no sorting .- union all The efficiency ratio of union It works well .#### What is a temporary watch , When will the temporary table be used , When to delete the temporary table ? *MySQL In execution SQL Statement will temporarily create some tables to store intermediate result sets , This kind of table is called a temporary table , The temporary table is only visible to the current connection , After the connection is closed , Temporary tables are deleted and free up space . Temporary table is mainly divided into memory temporary table and disk temporary table . Memory temporary tables use MEMORY Storage engine , The disk temporary table uses MyISAM Storage engine . Temporary tables are usually used in the following situations :- FROM Subquery in - DISTINCT Query and add ORDER BY- ORDER BY and GROUP BY The temporary table will be generated when the clauses are different - Use UNION Queries produce temporary tables #### How to optimize large table data query ? ***- Index optimization - SQL Sentence optimization - Horizontal split - Split Vertically - Create an intermediate table - Using cache technology - Fixed length tables are faster to access - The smaller the column, the faster the access #### Learn about slow log queries ? Statistics too slow query ? How to optimize slow queries ? *** Slow queries are generally used to record queries whose execution time exceeds a critical value SQL Statement log . Correlation argument :- slow_query_log: Whether to enable slow log query ,1 Indicates on ,0 To close .- slow_query_log_file:MySQL Database slow query log storage path .- long_query_time: Slow query threshold , When SQL Statement query time is greater than threshold , It will be recorded in the log .- log_queries_not_using_indexes: Queries that do not use the index are recorded in the slow query log .- log_output: Log storage mode .“FILE” Means to save the log to a file .“TABLE” Means to store the log in the database . How to optimize slow queries ?- Analyze the execution plan of the statement , Look at SQL Whether the index of the statement hits - Optimize the structure of the database , Break a table with many fields into multiple tables , Or consider building intermediate tables .- Optimization LIMIT Pagination .#### Why set the primary key ? ** A primary key is a unique identifier that uniquely distinguishes each row in a table , If there is no primary key , Updating or deleting specific rows in a table can be difficult , Because you can't uniquely and accurately identify a line .#### The primary key is usually self incrementing ID Or UUID? ** Use self increasing ID The benefits of :- The length of the field is longer than uuid It will be much smaller .- The database is automatically numbered , Store in order , Easy to search - There is no need to worry about the duplication of primary keys ID The shortcomings of :- Because it's self increasing , In some business scenarios , It's easy for others to find the business volume .- When data migration occurs , Or table merging can be very cumbersome - In a high concurrency scenario , Competing for self incrementing locks will reduce the throughput of the database UUID: Universal unique identification code ,UUID It's based on the current time 、 Counter and hardware identification and other data generated by calculation . Use UUID The advantages of :- Unique logo , I don't think about repetition , In data splitting 、 The global uniqueness can also be achieved when merging .- It can be generated in the application layer , Improve the throughput of the database .- No need to worry about the leakage of business volume . Use UUID The shortcomings of :- Because UUID It's randomly generated , So random things happen IO, Affect the insertion speed , And it will result in the low utilization rate of hard disk .- UUID It takes up a lot of space , The more indexes you build , The greater the impact .- UUID The size of the comparison between them is more self increasing ID It's a lot slower , Affect query speed . Finally, let's draw a conclusion , General MySQL It is recommended to use self increasing ID. Because in MySQL Of InnoDB In the storage engine , A primary key index is a clustered index , Primary key index B+ The leaf nodes of the tree store the primary key values and data in order , If the primary key index is self incrementing ID, Just put it back in order , If it is UUID,ID It's randomly generated , When data is inserted, it will cause a lot of data movement , Generate a lot of memory fragmentation , It causes the decrease of insertion efficiency .#### Why should the field be set to not null? ** First of all ,NULL It's not the same as null , Null values don't take up space , and NULL It takes up space , So the field is set to NOT NULL After that, you can still insert null values . The field is set to not null The main reasons are as follows :- NULL Values affect the statistics of some functions , Such as count, encounter NULL value , This record won't count .- B Trees don't store NULL, So the index doesn't use NULL, It will cause the problems mentioned in the first point that can't be counted .- NOT IN Subquery has NULL In this case, all the returned results are null . for example user The table is as follows | id | username | | :--: | :------: | | 0 | zhangsan | | 1 | lisi | | 2 | null | ```select * from `user` where username NOT IN (select username from `user` where id != 0)```, This query should find zhangsan This information , But it turns out that null.- MySQL When comparing ,NULL Will participate in the field comparison , Because NULL It is a special data type , Special number processing is needed in database processing , Increases the complexity of database processing records .#### How to optimize data access in the process of query ? *** In terms of reducing data access :- Use the index correctly , Try to cover the index as much as possible - Optimization SQL The implementation plan is to return less information :- Data paging - Only return the required fields from the reduced server CPU In terms of cost :- Rational use of sorting - Reduce the operation of comparison - Complex computing in the client processing, from the perspective of increasing resources :- Client side multi program parallel access - Database Parallel Processing #### How to optimize long and difficult query statements ? **- Decompose a large query into several small queries - Decompose associated queries , Make cache more efficient #### How to optimize LIMIT Pagination ? **- stay LIMIT When the offset is large , Query efficiency will be lower , You can record the maximum number of... Taken out each time ID, Next time you query, you can use ID Query - Build composite indexes #### How to optimize UNION Inquire about ** If you do not need to de duplicate or sort the result set, it is recommended to use UNION ALL, It will be better .#### How to optimize WHERE Clause ***- Not in where Used in clauses != and <> To do something is not to judge , This will result in abandoning the index for a full table scan .- Not in where Used in clauses null Or null judgment , Try to set the field as not null.- Try to use union all Instead of or- stay where and order by Index the columns involved - Minimize the use of in perhaps not in, A full scan will be performed - stay where Using arguments in Clause results in a full table scan - To avoid the where The operation of expression or function on field and in clause will cause the storage engine to abandon the import and scan the whole table #### SQL What's the reason for the slow execution of statements ? ***- If SQL Statements are only occasionally slow , Maybe the lock was encountered during execution , It could be redo log The log is full of , Will be redo log Synchronize the data in to disk .- If SQL Sentences are always slow , It may be that there is no index on the field or that the field has an index but no index is used .#### SQL Statement execution order ? *```mysqlSELECT DISTINCT select_list FROM left_table LEFT JOIN right_table ON join_condition WHERE where_condition GROUP BY group_by_list HAVING having_condition ORDER BY order_by_condition``` The order of execution is as follows :![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121200917742.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center)- FROM: Yes SQL Statement when executing a query , First, the tables on both sides of the keyword are connected in the form of Cartesian product , And produce a virtual table V1. A virtual table is a view , The data will come from the execution results of multiple tables .- ON: Yes FROM The result of the connection is ON Filtration , And create a virtual table V2- JOIN: Will ON The filtered left table is added , And create a new virtual table V3- WHERE: For virtual tables V3 To carry out WHERE Screening , Create a virtual table V4- GROUP BY: Yes V4 Group the records in , Create a virtual table V5- HAVING: Yes V5 Filter , Create a virtual table V6- SELECT: Will V6 The results in are based on SELECT Screening , Create a virtual table V7- DISTINCT: Yes V7 The results in the table are de duplicated , Create a virtual table V8, If used GROUP BY Clause, you don't need to use DISTINCT, Because grouping is to group the only values in a column , And each group returns only one line of records , So all the records are h Is different .- ORDER BY: Yes V8 Sort the results in the table .### Database optimization #### How to optimize large tables ? ***- Limit the scope of information : Avoid query statements without any restrictions on data range .- Separation of reading and writing : The main database is responsible for writing , Read from the library .- Vertical sub table : Divide a table into multiple tables according to fields , Each table stores some of the fields .- Horizontal sub table : In the same database , Split the data of a table into multiple tables according to certain rules .- Optimize a single table : For the fields in the table 、 Indexes 、 Inquire about SQL Optimize .- New cache #### What is a vertical sub table 、 Vertical branch library 、 Horizontal sub table 、 Horizontal sub database ? *** Vertical sub table : Divide a table into multiple tables according to fields , Each table stores some of the fields . Generally, common fields are put into a table , Put the less frequently used fields in another table . The advantage of vertical scale :- avoid IO Competition reduces the probability of locking tables . Because big fields are less efficient , First, there is a large amount of information , It takes a long time to read . second , Large fields take up more space , The number of rows in a single page of memory is reduced , Will make IO More operations .- It can improve the query efficiency of popular data . Vertical branch library : Classify tables by business , Deploy to different databases , Different databases can be put on different servers . The advantage of vertical sub database :- Reduce coupling in the business , It is convenient to manage different businesses at different levels .- Can improve IO、 Database connections 、 Solve the bottleneck problem of stand-alone hardware resources . Split Vertically ( Sub Treasury 、 table ) The shortcomings of :- The primary key is redundant , Need to manage redundant columns - The processing of transactions becomes complicated - There is still a problem of large amount of data in a single table : In the same database , Split the data of the same table into multiple tables according to certain rules . The advantage of the horizontal scale :- The problem of too much data in a single table is solved - avoid IO Compete and reduce the probability level of lock table : Split the data of the same table into different databases according to certain rules , Different databases can be put on different servers . The advantage of horizontal sub pool :- It solves the bottleneck problem of large amount of data in a single database - IO Fewer conflicts , Less competition for locks , Problems in one database do not affect other databases ( Usability ), Improve the stability and availability of the system ( table 、 Sub Treasury ) The shortcomings of :- Fragmentation transaction consistency is difficult to solve - Cross node JOIN Poor efficiency , The logic gets complicated - The data expansion kit is very difficult , It is not easy to maintain. When designing the system, we should determine the scheme of vertical database and vertical table according to business coupling , Cache should be considered when data access pressure is not particularly high 、 Read write separation and other methods , If there's a lot of information , Or continuous growth can consider the level of sub library sub table , The logic involved in horizontal splitting is complex , Common solutions include client architecture and proxy architecture .#### After sub warehouse and sub table ,ID How to handle ? *** After the database is divided into tables, each table cannot be ID It's all from 1 Start , So we need a global ID, Set global ID There are mainly the following methods :- UUID: Advantages : Locally generated ID, There's no need for a remote call ; Global uniqueness without repetition . Disadvantages : It takes up a lot of space , Not suitable for indexing .- The database is growing ID: Use database auto increment after sub database and sub table ID, You need a library dedicated to generating primary keys , Every time the service receives a request , First insert a meaningless piece of data into this library , Get a database self incrementing ID, Use this ID Go to sub database and sub table to write data . Advantages : Easy to implement . Disadvantages : There is a bottleneck in the high parallel development . The system structure is shown in the figure below ( Pictures from the Internet )![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121200948324.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center)- Redis Generate ID: Advantages : Not relying on databases , Good performance . Disadvantages : The introduction of new components will increase the complexity of the system - Twitter Of snowflake Algorithm : It's a 64 Bit long Type ID, Among them is 1bit No need ,41bit As milliseconds ,10bit As a working machine ID,12bit As a serial number . 1bit: First bit The default is 0, Because the first binary system bit For 1 It's a negative number , however ID Can't be negative . 41bit: Represents a timestamp , It's in milliseconds . 10bit: Recording machines ID, among 5 One bit It means the computer room ID,5 One bit Means machine ID. 12bit: It's used to record differences in the same millisecond ID.- Meituan's Leaf Decentralized ID Generating system ,[ Meituan comments decentralized ID Generating system ](https://tech.meituan.com/2017/04/21/mt-leaf.html)#### MySQL The principle and process of replication ? How to achieve master-slave replication ? ***MySQL Copy : To ensure data consistency between master and slave servers , After inserting data into the master server , The slave server will automatically synchronize the modified data from the master server . The principle of master-slave replication : There are three main threads in master-slave replication :binlog Thread ,I/O Thread ,SQL Thread .- binlog Thread : Responsible for writing data changes on the master server to the binary log (Binary log) in .- I/O Thread : Responsible for reading binary log from master server (Binary log), And write to the relay log from the server (Relay log) in .- SQL Thread : Responsible for reading relay logs , Resolve the data changes that have been executed in the master server and replay them in the slave server. The replication process is as follows ( Pictures from the Internet ):![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121201012972.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center)1. Master Before each transaction updates the data , Write the operation record to binlog in .2. Slave Connect from the library Master Main warehouse , And Master How many Slave How many will be built binlog dump Thread . When Master Node's binlog When there is a change ,binlog dump All of you will be informed Slave, And the corresponding binlog Send to Slave.3. I/O Thread received binlog After content , Write it to the relay log (Relay log) in .4. SQL Thread reads relay log , And playing back from the server . Here is an easy to understand picture .![ Insert picture description here ](https://img-blog.csdnimg.cn/20210121201034210.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p5ZHliYWJ5,size_16,color_FFFFFF,t_70#pic_center) The role of master-slave replication :- High availability and fail over - Load balancing - Data backup - Upgrade test #### Do you understand the separation of reading and writing ? *** Read write separation mainly depends on master-slave replication , Master slave replication serves for the separation of read and write . Advantages of separation of reading and writing :- The master server is responsible for writing , Read from the server , Alleviates lock competition - From the server you can use MyISAM, Improve query efficiency and save system overhead - Add redundancy , Improve
版权声明
本文为[itread01]所创,转载请带上原文链接,感谢
https://javamana.com/2021/01/20210122011417526f.html

  1. 【计算机网络 12(1),尚学堂马士兵Java视频教程
  2. 【程序猿历程,史上最全的Java面试题集锦在这里
  3. 【程序猿历程(1),Javaweb视频教程百度云
  4. Notes on MySQL 45 lectures (1-7)
  5. [computer network 12 (1), Shang Xuetang Ma soldier java video tutorial
  6. The most complete collection of Java interview questions in history is here
  7. [process of program ape (1), JavaWeb video tutorial, baidu cloud
  8. Notes on MySQL 45 lectures (1-7)
  9. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  10. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  11. 精进 Spring Boot 03:Spring Boot 的配置文件和配置管理,以及用三种方式读取配置文件
  12. Refined spring boot 03: spring boot configuration files and configuration management, and reading configuration files in three ways
  13. 【递归,Java传智播客笔记
  14. [recursion, Java intelligence podcast notes
  15. [adhere to painting for 386 days] the beginning of spring of 24 solar terms
  16. K8S系列第八篇(Service、EndPoints以及高可用kubeadm部署)
  17. K8s Series Part 8 (service, endpoints and high availability kubeadm deployment)
  18. 【重识 HTML (3),350道Java面试真题分享
  19. 【重识 HTML (2),Java并发编程必会的多线程你竟然还不会
  20. 【重识 HTML (1),二本Java小菜鸟4面字节跳动被秒成渣渣
  21. [re recognize HTML (3) and share 350 real Java interview questions
  22. [re recognize HTML (2). Multithreading is a must for Java Concurrent Programming. How dare you not
  23. [re recognize HTML (1), two Java rookies' 4-sided bytes beat and become slag in seconds
  24. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  25. RPC 1: how to develop RPC framework from scratch
  26. 造轮子系列之RPC 1:如何从零开始开发RPC框架
  27. RPC 1: how to develop RPC framework from scratch
  28. 一次性捋清楚吧,对乱糟糟的,Spring事务扩展机制
  29. 一文彻底弄懂如何选择抽象类还是接口,连续四年百度Java岗必问面试题
  30. Redis常用命令
  31. 一双拖鞋引发的血案,狂神说Java系列笔记
  32. 一、mysql基础安装
  33. 一位程序员的独白:尽管我一生坎坷,Java框架面试基础
  34. Clear it all at once. For the messy, spring transaction extension mechanism
  35. A thorough understanding of how to choose abstract classes or interfaces, baidu Java post must ask interview questions for four consecutive years
  36. Redis common commands
  37. A pair of slippers triggered the murder, crazy God said java series notes
  38. 1、 MySQL basic installation
  39. Monologue of a programmer: despite my ups and downs in my life, Java framework is the foundation of interview
  40. 【大厂面试】三面三问Spring循环依赖,请一定要把这篇看完(建议收藏)
  41. 一线互联网企业中,springboot入门项目
  42. 一篇文带你入门SSM框架Spring开发,帮你快速拿Offer
  43. 【面试资料】Java全集、微服务、大数据、数据结构与算法、机器学习知识最全总结,283页pdf
  44. 【leetcode刷题】24.数组中重复的数字——Java版
  45. 【leetcode刷题】23.对称二叉树——Java版
  46. 【leetcode刷题】22.二叉树的中序遍历——Java版
  47. 【leetcode刷题】21.三数之和——Java版
  48. 【leetcode刷题】20.最长回文子串——Java版
  49. 【leetcode刷题】19.回文链表——Java版
  50. 【leetcode刷题】18.反转链表——Java版
  51. 【leetcode刷题】17.相交链表——Java&python版
  52. 【leetcode刷题】16.环形链表——Java版
  53. 【leetcode刷题】15.汉明距离——Java版
  54. 【leetcode刷题】14.找到所有数组中消失的数字——Java版
  55. 【leetcode刷题】13.比特位计数——Java版
  56. oracle控制用户权限命令
  57. 三年Java开发,继阿里,鲁班二期Java架构师
  58. Oracle必须要启动的服务
  59. 万字长文!深入剖析HashMap,Java基础笔试题大全带答案
  60. 一问Kafka就心慌?我却凭着这份,图灵学院vip课程百度云