Springboot Episode 4: integrating jdbctemplate and JPA

itread01 2020-11-06 01:18:02
springboot episode integrating jdbctemplate jpa


SpringBoot Episode four : Integrate JdbcTemplate and JPA(2020 Up to date and easy to understand )

The current environment states :

Windows10_64

Maven3.x

JDK1.8

MySQL5.6

SpringToolSuite4(Spring Official development tools , It's actually a Eclipse)

One . Integrate JdbcTemplate

1. summary

In a real project , When the database access layer operates on the database , We use it most of the time MyBatis/Hibernate, But sometimes it's useful to use JDBC When , In general use JDBC If you want to, you can package it yourself JDBC Connection pool for use , If you want to use Apache Common Provided DbUtils Tool class , There is also Spring JDBC , Provided JdbcTemplate Tool class .

Spring It belongs to a trestle frame , For JAVAEE Each of the three layers , All provide solutions . stay DAO In the layer Spring Use in JdbcTemplate Complete the technical requirements .( Please pay attention to the following publication for details Spring Set )

 1 JdbcTemplate Introduction to common classes in :
2 DriverManagerDataSource Class :DataSource Implementation subclass of connection pool
3 effect : It is mainly used to set the information related to the connection database . Such as : Connection address 、 User name 、 Passwords, etc
4 Common methods :
5 setDriverClassName(……): Set the driver class
6 setUsername(……): Set user name
7 setPassword(……): Set the password
8 setUrl(……): Set the connection address
9 JdbcTemplate Class :
10 effect : from Spring Provided JDBC Operation template class . Used to complete CURD operation
11 Commonly used construction methods :
12 JdbcTemplate(DataSource dataSource): Create an object and specify the connection management source
13 Other methods are commonly used :
14 update(……): Execution increases 、 Delete 、 Change . The return value is int Type , Indicates that the result affects the number of rows .
15 queryXXX(……); Execute the query . More on bloggers Spring Complete cases 

2. Preparation work

  1. Build a database .
  2. Add the corresponding database entity class .
    1 @Data
    2 @AllArgsConstructor
    3 @NoArgsConstructor
    4 public class Person {
    5 private Integer id;
    6 private String name;
    7 private String password;
    8 }
  3. modify pom.xml Introduce dependencies
    SpringBoot introduce MySQL The default version of the driver is 8.x, You can manually configure the version .
     1 <!-- SpringBoot Integrate JdbcTemplate -->
    2 <dependency>
    3 <groupId>org.springframework.boot</groupId>
    4 <artifactId>spring-boot-starter-jdbc</artifactId>
    5 </dependency>
    6
    7 <!-- MySQL Drive (SpringBoot The default import version is 8.x) Manual configuration version -->
    8 <dependency>
    9 <groupId>mysql</groupId>
    10 <artifactId>mysql-connector-java</artifactId>
    11 <scope>runtime</scope>
    12 </dependency>
  4. modify application.yml File add data source configuration
     1 spring:
    2 datasource:
    3 # According to MySQL Version configuration driver class 5.x----8.x Driver class “com.mysql.jdbc.Driver” or “com.mysql.cj.jdbc.Driver”.
    4 driver-class-name: com.mysql.cj.jdbc.Driver
    5 #useSSL:SSL The main role of the agreement to provide services :( It is not recommended to create without server authentication SSL Connect .)
    6 # 1) Certified user server , Make sure the data is sent to the correct server ; .
    7 # 2) Encrypted data , To prevent data from being stolen in transit ;
    8 # 3) Maintain data integrity , Verify whether the data is lost during transmission ;
    9 #serverTimezone: Set the time zone , If you don't set it, you will report an error .GMT%2B8: East eight district Beijing time Asia/Shanghai: Shanghai time
    10 #useServerPrepStmts: stay url It is given in useServerPrepStmts=true Arguments , Turn on precompiling ( Presupposition PS It's closed )
    11 #allowMultiQueries: Set to true, Turn on batch execution sql The switch for . For more, please keep an eye on the blogger file
    12 url: jdbc:mysql://localhost:3306/springboot?useSSL=false&serverTimezone=GMT%2B8
    13 username: root
    14 password: xsge

3. Integration to achieve

  1. Write DAO Layer based CURD.
    Use annotations @Repository Marked as Spring--DAO Layer element . Inject JdbcTemplate thing
    BeanPropertyRowMapper yes JdbcTemplate Provides a result set processor class , yes RowMapper Implementation of the result set processor interface .
    Be careful : The two query methods are different
     1 @Repository // Spring Note that DAO Layer element
    2 public class PersonDao{
    3
    4 @Autowired // Inject jdbcTemplate
    5 private JdbcTemplate jdbcTemplate;
    6
    7 /**
    8 * Insert data
    9 */
    10 public void insertPerson(Person p) {
    11 jdbcTemplate.update("INSERT INTO person(name,password) VALUES (?,?)",
    12 p.getName(),p.getPassword());
    13 }
    14 /**
    15 * According to ID Inquire about
    16 * Method queryForObject You can query single row and single column , You can also query single row and multiple columns
    17 * Arguments 1:SQL
    18 * Arguments 2: A type perhaps A result set processor ( Depending on the results and requirements of the query )
    19 * Arguments 3: Variable arguments
    20 */
    21 public Person selectPersonById(Integer id) {
    22 Person person = jdbcTemplate.queryForObject("SELECT * FROM person WHERE id =?",
    23 new BeanPropertyRowMapper<Person>(Person.class), id);
    24 return person;
    25 }
    26 /**
    27 * Query all
    28 * Method query You can query multiple rows and columns .
    29 * Arguments 1:SQL
    30 * Arguments 2: A result set processor ( Depending on the results and requirements of the query )
    31 * Arguments 3: Variable arguments
    32 */
    33 public List<Person> selectPersonList() {
    34 List<Person> personList = jdbcTemplate.query("SELECT * FROM person",
    35 new BeanPropertyRowMapper<Person>(Person.class));
    36 return personList;
    37 }
    38
    39 }
  2. Write Service Interface
     1 public interface PersonService {
    2 /**
    3 * newly added
    4 */
    5 void insertPerson(Person p);
    6 /**
    7 * Look up a
    8 */
    9 Person selectPersonById(Integer id);
    10 /**
    11 * Query multiple
    12 */
    13 List<Person> selectPersonList();
    14
    15 }
  3. Write Service Implementation class
    Use annotations @Service Marked as Spring Components . Inject DAO thing
     1 @Service
    2 public class PersonServiceImpl implements PersonService {
    3
    4 @Autowired
    5 private PersonDao personDao;
    6
    7 @Override
    8 public void insertPerson(Person p) {
    9 personDao.insertPerson(p);
    10 }
    11
    12 @Override
    13 public Person selectPersonById(Integer id) {
    14 return personDao.selectPersonById(id);
    15 }
    16
    17 @Override
    18 public List<Person> selectPersonList() {
    19 return personDao.selectPersonList();
    20 }
    21
    22 }
  4. Write Controller, Provide a group of restFUL The interface of style
    Use annotations @RestController Label controller class , Make it return data and the result is JSON Format . Inject Service thing , Use RestFUL Styles provide access interfaces
     1 @RestController
    2 public class PersonController {
    3
    4 @Autowired
    5 private PersonService personService;
    6
    7 /**
    8 * Interface address :http://localhost:8080/insertPerson
    9 * How to request :PUT Enter the reference :JSON Information
    10 */
    11 @RequestMapping(value = "/insertPerson", method = RequestMethod.PUT)
    12 public void insertPerson(@RequestBody Person p) {
    13 personService.insertPerson(p);
    14 };
    15 /**
    16 * Interface address :http://localhost:8080/selectPersonById/1
    17 * How to request :GET Enter the reference :id
    18 */
    19 @GetMapping(value = "/selectPersonById/{id}")
    20 public Person selectPersonById(@PathVariable Integer id) {
    21 System.err.println("id The value is :"+id);
    22 return personService.selectPersonById(id);
    23 };
    24 /**
    25 * Interface address :http://localhost:8080/selectPersonList
    26 * How to request :POST Enter the reference : Nothing
    27 */
    28 @PostMapping("/selectPersonList")
    29 public List<Person> selectPersonList(){
    30 return personService.selectPersonList();
    31 };
    32 }
  5. Install Postman Tools , Access the test interface .
    Start SpirngBoot Project main program , Request interface test !
    Postman Is a commonly used interface testing tool , You can test sending different requests , Passing different arguments , Please pay attention to the specific operation of bloggers, and look forward to it .PostMan Download address

 

Two . Integrate JPA

JPA yes Java Persistence API Short for , Chinese name Java Persistence layer API. yes SUN The company has launched a set based on ORM The specification of .Hibernate The framework provides JPA The realization of ,Spring Data JPA yes Spring Based on Hibernate One developed JPA frame . Can greatly simplify JPA How to write , It can be done almost without writing specific code , Realize the access and operation of data . except CRUD Outside , It also includes things like Pagination Sort And other common functions . What's more powerful is , It can also be done through Method naming rules Database query operation

Spring Data JPA Provided interface :

  1. Repository: Top level interface , It's an empty interface , The aim is to unify all Repository The type of , And it can automatically identify the components when scanning .
  2. CrudRepository : yes Repository The subinterface of , Provide CRUD The function of ( The built-in default is simple CURD Method , You can quote )
  3. PagingAndSortingRepository: yes CrudRepository The subinterface of , New paging and sorting capabilities .
  4. JpaRepository: yes PagingAndSortingRepository The subinterface of , Added some practical features , such as : Batch operation, etc .( The relatively complete built-in method : Simple CURD/ Pagination / Batch )
  5. JpaSpecificationExecutor: It is used to do the query interface
  6. Specification: yes Spring Data JPA Provides a query specification for , To do complex queries , Just set the query conditions around this specification .

among , Custom query , The naming rules of method names are as follows :

Name optional keywords Method naming example When the method is executed SQL,Where Clause
And findByNameAndPwd where name= ? and pwd =?
Or findByNameOrSex where name= ? or sex=?
Is,Equals findById,findByIdEquals where id= ?
Between findByIdBetween where id between ? and ?
LessThan findByIdLessThan where id < ?
LessThanEquals findByIdLessThanEquals where id <= ?
GreaterThan findByIdGreaterThan where id > ?
GreaterThanEquals findByIdGreaterThanEquals where id > = ?
After findByIdAfter where id > ?
Before findByIdBefore where id < ?
IsNull findByNameIsNull where name is null
isNotNull,NotNull findByNameNotNull where name is not null
Like findByNameLike where name like ?
NotLike findByNameNotLike where name not like ?
StartingWith findByNameStartingWith where name like ‘?%’
EndingWith findByNameEndingWith where name like ‘%?’
Containing findByNameContaining where name like ‘%?%’
OrderBy findByIdOrderByXDesc where id=? order by x desc
Not findByNameNot where name <> ?
In findByIdIn(Collection<?> c) where id in (?)
NotIn findByIdNotIn(Collection<?> c) where id not in (?)
True findByAaaTue where aaa = true
False findByAaaFalse where aaa = false
IgnoreCase findByNameIgnoreCase where UPPER(name)=UPPER(?)

This is really , Strong enough ! But there are more than one query condition , The name of this method will be very long ……

Spring Data JPA A brief summary :

  1. Provides basic CURD Method , Batch processing , Pagination method, etc .
  2. Allow custom method names , Query according to the specified naming rules .
  3. Allow to use @Query Notes , Custom higher level , More complicated SQL

1. Preparation work

  1. introduce spring-data-jap Rely on
    1 <!-- SpringBoot Integrate JPA -->
    2 <dependency>
    3 <groupId>org.springframework.boot</groupId>
    4 <artifactId>spring-boot-starter-data-jpa</artifactId>
    5 </dependency>
  2. modify yml Configuration file settings JPA Configuration and database configuration
     1 spring:
    2 datasource:
    3 # According to MySQL Version configuration driver class 5.x----8.x Driver class “com.mysql.jdbc.Driver” or “com.mysql.cj.jdbc.Driver”.
    4 driver-class-name: com.mysql.cj.jdbc.Driver
    5 #useSSL:SSL The main role of the agreement to provide services :( It is not recommended to create without server authentication SSL Connect .)
    6 # 1) Certified user server , Make sure the data is sent to the correct server ; .
    7 # 2) Encrypted data , To prevent data from being stolen in transit ;
    8 # 3) Maintain data integrity , Verify whether the data is lost during transmission ;
    9 #serverTimezone: Set the time zone , If you don't set it, you will report an error .GMT%2B8: East eight district Beijing time Asia/Shanghai: Shanghai time
    10 #useServerPrepStmts: stay url It is given in useServerPrepStmts=true Arguments , Turn on precompiling ( Presupposition PS It's closed )
    11 #allowMultiQueries: Set to true, Turn on batch execution sql The switch for . For more, please keep an eye on the blogger file
    12 url: jdbc:mysql://localhost:3306/springboot?useSSL=false&serverTimezone=GMT%2B8
    13 username: root
    14 password: xsge
    15 #JPA To configure ——————————————————————————————————————————————————————————————————————————
    16 jpa:
    17 # Whether to show SQL
    18 show-sql: true
    19 hibernate:
    20 # Structure table .update Express , The first execution creates a table structure based on the entity class , After the operation only do data update
    21 ddl-auto: update
  3. Add an entity class corresponding to the database table

    Common notes for configuration entities :( Here's just a list of , Please follow the blogger for more details Hibernate article )

    @Entity

    effect : Identifies the current entity as a data entity class

    @Table(name= value )

    effect : Identify that the current entity corresponds to the database table

    Properties :Name: Specifies the database table name of the current entity

    @Id

    effect : Identifies the current property as the primary key column attribute

    @Column

    effect : Identify the field of the database corresponding to the current property

    Properties :Name: Specifies the database column name for the current property

    @GeneratedValue

    effect : Specifies the primary key policy for the column

    Properties :Generator: The attribute value , Appoint Hibernate The primary key policy declaration alias provided in

    Strategy: The attribute , Mark JPA The provided primary key generation strategy ( The primary key generation method ).

    Value GenerationType:

    AUTO: Adaptive , Choose three , Default selection TABLE

    IDENTITY:Mysql Self growth , To judge whether to support

         SEQUENCE:Oracle Self growth , To judge whether to support

        TABLE: Similar to Helw High low algorithm , There is no need to judge , Because it uses a fixed format algorithm to generate .

     1 @Entity // Identifies the current entity as a data entity class
    2 @Data // Automatically generate get/set etc.
    3 @AllArgsConstructor // All parameter constructors
    4 @NoArgsConstructor // Nonparametric constructors
    5 @Table(name = "student") // Identify the table name corresponding to the entity
    6 @EntityListeners(AuditingEntityListener.class) // spring-data-jap Listener annotation for entity class data update
    7 public class Student {
    8 // Identifies the current property as the primary key column attribute
    9 @Id
    10 // Primary key policy for tab columns ( How the primary key is generated )GenerationType.IDENTITY Express shiyongMySQL Default self growth to generate primary key value
    11 @GeneratedValue(strategy = GenerationType.IDENTITY)
    12 private Integer sid;
    13
    14 // Identify the field of the database corresponding to the current property
    15 @Column(name = "name")
    16 private String name;
    17 @Column(name = "age")
    18 private Integer age;
    19
    20 // spring-data-jap Auto fill provided in , Auto fill time when adding ( coordination SPRING-DATA-JPA Listen to comments using )
    21 @CreatedDate
    22 private Date createTime;
    23
    24 // spring-data-jap Auto fill provided in , Automatically fill in the update time when there is an update ( coordination SPING-DATA-JPA Listen to comments using )
    25 @LastModifiedDate
    26 private Date updateTime;
    27 }

    Here we need to pay attention to , stay 《Mybatis-Plus Use the total solution 》 in , This paper introduces how to set the automatic filling function of public fields . Such as creation time and modification time , Creator and reviser, etc , All of them can be assigned a value . stay spring-data-jap in , It's using @CreatedDate and @LastModifiedDate Mark , At the same time , Need to be on the entity class , Add @EntityListeners(AuditingEntityListener.class), Then add annotations to the startup class @EnableJpaAuditing( Turn on JPA Auto fill ), In this way, the function of automatic filling of public fields is realized .(JPA Auto fill annotations are shown in the figure below )

  4. modify SpringBoot Main program
    Add annotations to the startup class @EnableJpaAuditing
     1 @SpringBootApplication
    2 @EnableJpaAuditing // Turn on JPA Auto fill function
    3 @Slf4j
    4 public class AnnotaticSpringBootApplication {
    5 // The main function
    6 public static void main(String[] args) {
    7 // Start App
    8 SpringApplication.run(AnnotaticSpringBootApplication.class, args);
    9 log.info(" The main program starts ………………");
    10 }
    11 }

     

2. Integration to achieve CURD

stay Spring-Data-Jpa In summary , A brief summary of JPA How to operate , There are three kinds of generalizations : Calling the original interface method is easy to implement CURD, The implementation of custom method name is simple CURD, Customize SQL Realize CURD. Usually , A combination of the three , If the functional requirements themselves can be implemented directly using the original interface method, there is no need to change , If the requirements require different conditions , Then you can customize the method name , If more complex requirements , Use custom directly SQL Realize .

A, Interface source method implementation CURD

  1. Write subinterfaces, inherit interfaces JpaRepository.
    Explain :JpaRepository The interface inherits the simplicity from various parent classes CURD Method , Including pagination / Sort, etc . These methods can directly refer to , No need to pay attention to SQL.
    1 /**
    2 * Write DAO Interface inheritance JpaRepository Interface
    3 * Generic arguments 1:CURD Entity type
    4 * Generic arguments 2: The type of primary key ( Usually it is Integer or Long)
    5 */
    6 public interface StudentDao extends JpaRepository<Student, Integer>{
    7 }
  2. Write Service Realize .
    ( Abstract interfaces are needed in actual development (Inteface) Can't omit , Here the figure is convenient to omit , The interface implementation class is shown directly )
    DAO The object can be injected directly and automatically ,SpringBoot-Data-JPA Autonomous scanning Repository And all its subinterfaces / Sub implementation class components .
    Please refer to the appendix for more details
     1 @Service
    2 public class StudentServiceImpl implements StudentService {
    3
    4 @Autowired
    5 private StudentDao studentDao;
    6
    7 /**
    8 * newly added : call JpaRepository The default method of save Realize storage
    9 * The return value is the new data object , At the same time, it will also add new information id To return to
    10 */
    11 @Override
    12 public Student save(Student student) {
    13 return studentDao.save(student);
    14 }
    15 /**
    16 * According to ID Inquire about : call JpaRepository The default method of findById The realization is based on id Inquire about
    17 * The return result is Optional<Student>, yes JDK1.8 New defense null A core class of object problem .
    18 * You can think of it as querying an object , There is put into a Optional In the container . Call method get You can take the object out
    19 */
    20 @Override
    21 public Student findById(Integer sid) {
    22 return studentDao.findById(sid).get();
    23 }
    24 /**
    25 * Paging query : call JpaRepository The default method of findAll Query all
    26 * The actual argument type is :Pageable Paging interface ,PageRequest Subclass the implementation between them .
    27 * Arguments 1: The current page number ( From 0 Start , Can't be negative )
    28 * Arguments 2: The number of rows displayed in the current page ( From 1 Start , Can't be negative )
    29 */
    30 @Override
    31 public Page<Student> findAll(Integer page,Integer size) {
    32 return studentDao.findAll(PageRequest.of(page,size));
    33 }
    34
    35 }
  3. New controller , Provide interface testing

     1 @RestController
    2 public class StudentController {
    3
    4 @Autowired
    5 private StudentService studentService;
    6
    7 /**
    8 * Test interface :http://localhost:8080/saveStu
    9 * How to request :PUT Enter the reference :JSON Information
    10 */
    11 @RequestMapping(value = "/saveStu",method = RequestMethod.PUT)
    12 public Student save(@RequestBody Student student) {
    13 return studentService.save(student);
    14 }
    15
    16 /**
    17 * Test interface :http://localhost:8080/findById
    18 * How to request :GET Enter the reference : Place holder arguments sid
    19 */
    20 @GetMapping("/findById/{id}")
    21 public Student findById(@PathVariable(name = "id") Integer sid) {
    22 return studentService.findById(sid);
    23 }
    24 /**
    25 * Test interface :http://localhost:8080/findAll
    26 * How to request :POST Enter the reference :page=?& size=?
    27 */
    28 @PostMapping("/findAll")
    29 public Page<Student> findAll(Integer page,Integer size) {
    30 return studentService.findAll(page,size);
    31 }
    32
    33 }
  4. Start the main program , utilize Postman Tool testing

     

     

B, Custom method name and custom SQL Implement the operation

When the functional requirements cannot be realized by the original interface method , You need to customize the method manually , Or customize SQL Realize CURD. It doesn't really take a lot of complicated deployment , Based on the source method case , Add a method with a custom method name directly in the persistence layer interface or add a custom SQL It's a good way to do it .

 1 public interface StudentDao extends JpaRepository<Student, Integer>{
2 // Use custom naming rules , Make inquiries , And add paging function
3 List<Student> findByNameContaining(String name,Pageable pageable);// …… where name like ‘%?%’
4
5 /**
6 * @Query To carry out Customize sql Write
7 * nativeQuery=true: Denotes defined SQL For the standard SQL( There is no such item ,SQL Table name and column name in statement are entity class name and column name in entity class )
8 * Arguments use placeholders ? Instead of , But it should be noted that the place holder here needs to be followed by a number ( Number one ?N Numbers N From 1 Start )
9 */
10 @Query(value="select * from student where name = ?1",nativeQuery=true)
11 List<Student> queryByName(String name);
12 }

Other tests are omitted ……

 

Appendix

JPA Default method description : Check the source code structure as follows ( Take a good look at the internal method !)

1 QueryDslJpaRepository
2 ┣━ QueryDslPredicateExecutor
3 ┗━ SimpleJpaRepository
4 ┣━ JpaSpecificationExecutor
5 ┗━ JpaRepository
6 ┣━ QueryByExampleExecutor
7 ┗━ PagingAndSortingRepository
8 ┗━ CrudRepository
9 ┗━Repository

 

&n

版权声明
本文为[itread01]所创,转载请带上原文链接,感谢

  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课程百度云