Spring transaction management

Forget the book 2021-01-23 01:26:25
spring transaction management


Spring Transaction management of

Spring It simplifies the traditional transaction management process , Improved development efficiency . But first you have to understand Spring Database programming .

Spring Database programming

Database programming is the basis of Internet programming ,Spring The framework provides developers with JDBC Template pattern , namely jdbcTemplate, It can simplify a lot of code , But in practice jdbcTemplate Use is not common , Most of the time Spring combination MyBatis Development . ad locum , Tell only Spring Of jdbcTemplate Development .

SpringJDBC Configuration of

In this section, Spring Database programming mainly uses SpringJDBC Modular core and DataSource package ,core yes JDBC The core of the package , Including commonly used JdbcTemplate class ,DataSource It's a toolkit for accessing data sources . If you want to use SpringJDBC Operating the database , Configuration required , The configuration is as follows :

<!-- Configure data sources -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!--Mysql drive -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<!-- Connected url-->
<property name="url" value="jdbc:mysql://localhost:3306/spring?characterEncoding=utf-8"/>
<!-- Configuration of user name and password -->
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- To configure JDBC Templates -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>

In the example above , To configure JDBC The template needs to put dataSource Injection into jdbcTemplate, And in the data access layer (Dao) Required in jdbcTemplate It also needs to be jdbcTemplate Inject into the corresponding bean in .

@Repository("testDao")
public class TestDaoImpl implements TestDao {
@Autowired // Inject by type
private JdbcTemplate jdbcTemplate;

JDBCTemplate The common method of

public int update(String sql,Object args[]): This method can add data table 、 modify 、 Delete . Use args[] Set parameters , Function returns the number of updated rows . Examples are as follows :

String insertSQL="insert into user values(NULL,?,?)";
Onject param[] = {"chencheng","m"};
jdbcTemplate.update(insertSQL,param);

public List<T> query(String sql,RowMapper<T> rowmapper,Object args[]): This method can query the data table ,rowMapper Map the result set to a user-defined class ( The premise is that the property name of the class is the same as the field name ). Examples are as follows :

jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class),param);

Specific implementation steps

  1. Create and edit configuration files applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- Specify the packages to scan -->
<context:component-scan base-package="com.ch5"/>
<!-- Configure data sources -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!--Mysql drive -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<!-- Connected url-->
<property name="url" value="jdbc:mysql://localhost:3306/spring?characterEncoding=utf-8"/>
<!-- Configuration of user name and password -->
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- To configure JDBC Templates -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
  1. Create entity classes for mapping databases
package com.ch5;
public class User {
private Integer id;
private String name;
private double money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
  1. Create a database access layer TestDao and TestDaoImpl
package com.ch5.dao;
import com.ch5.User;
import java.util.List;
public interface TestDao {
public int update(String sql,Object[] param);
public List<User> query(String sql,Object[] param);
}
package com.ch5.dao.Impl;
import com.ch5.User;
import com.ch5.dao.TestDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository("testDao")
public class TestDaoImpl implements TestDao {
@Autowired // Inject by type
private JdbcTemplate jdbcTemplate;
@Override
public int update(String sql, Object[] param) {
return jdbcTemplate.update(sql,param);
}
@Override
public List<User> query(String sql, Object[] param) {
return jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class),param);
}
}
  1. Writing test classes JdbcTemplateTest
package com.ch5.Test;
import com.ch5.User;
import com.ch5.dao.TestDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class JdbcTemplateTest {
public static void main(String[] args) {
ApplicationContext appCo = new ClassPathXmlApplicationContext("appliationContext.xml");
TestDao testDao=(TestDao)appCo.getBean("testDao");
String insertSql="insert into account values(null,?,?)";
Object param[] = {"chencheng",1050.0};
testDao.update(insertSql,param);
String selectSql="select * from account";
List<User> list=testDao.query(selectSql,null);
for (User user : list) {
System.out.println(user);
}
}
}

Programmatic transaction management

Call... Explicitly in code beginTransactioncommitrollback And other methods related to transaction processing , This is programmatic transaction management , When there are only a few transaction operations , Programming management is more suitable for .

be based on XML Of AOP Achieve transaction control

  1. Write transaction management classes
package com.itheima.utils;
/**
* Tools related to transaction management , It contains , Open transaction , Commit transaction , Rolling back transactions and releasing connections
*/
public class TransactionManager {
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
/**
* Open transaction
*/
public void beginTransaction(){
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
}catch (Exception e){
e.printStackTrace();
}
}
/**
* Commit transaction
*/
public void commit(){
try {
connectionUtils.getThreadConnection().commit();
}catch (Exception e){
e.printStackTrace();
}
}
/**
* Roll back the transaction
*/
public void rollback(){
try {
connectionUtils.getThreadConnection().rollback();
}catch (Exception e){
e.printStackTrace();
}
}
/**
* Release the connection
*/
public void release(){
try {
connectionUtils.getThreadConnection().close();// Return to connection pool
connectionUtils.removeConnection();
}catch (Exception e){
e.printStackTrace();
}
}
}
  1. To configure aop
<!-- Configure transaction manager -->
<bean id="txManager" class="com.itheima.utils.TransactionManager">
<!-- Inject ConnectionUtils -->
<property name="connectionUtils" ref="connectionUtils"></property>
</bean>
<aop:config>
<aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..)"/>
<aop:aspect id="txAdvice" ref="txManager">
<!-- Configure front-end transactions , Open transaction -->
<aop:before method="beginTransaction" pointcut-ref="pt1"/>
<!-- Configure post transaction , Commit transaction -->
<aop:after-returning method="commit" pointcut-ref="pt1"/>
<!-- Configure exception transactions , Roll back the transaction -->
<aop:after-throwing method="rollback" pointcut-ref="pt1"/>
<!-- Configure final transaction , Release the connection -->
<aop:after method="release" pointcut-ref="pt1"/>
</aop:aspect>
</aop:config>

Based on the underlying API Programming transaction management

Based on the underlying API The programmable transaction management is based on PlatformTransactionManager,TransactionDefinition and TeansactionStatus And so on , Transaction management through programming , The bottom layer is described by an example API Transaction management implementation of :

  1. Configure the transaction manager for the data source
<!-- Configure transaction manager -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
  1. Create a data access class
package com.ch5.dao.Impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
@Repository("codeTransaction")
public class CodeTransaction {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private DataSourceTransactionManager transactionManager;
public String testTransaction(){
// Default transaction definition
TransactionDefinition definition=new DefaultTransactionDefinition();
// Open transaction
TransactionStatus transactionStatus = transactionManager.getTransaction(definition);
String message=" Successful implementation , No rollback ";
try{
String sql = "delete * from account";
String insertSql = "insert into account values(?,?,?)";
Object param[] = {"1","chenheng",2000};
jdbcTemplate.update(sql);
//id repeat , So something went wrong .
jdbcTemplate.update(insertSql,param);
jdbcTemplate.update(insertSql,param);
// Commit transaction
transactionManager.commit(transactionStatus);
}catch (Exception e){
// Something unusual happened , Roll back
transactionManager.rollback(transactionStatus);
message=" Transaction rollback ";
e.printStackTrace();
}
return message;
}
}
  1. Define test classes
package com.ch5.Test;
import com.ch5.dao.Impl.CodeTransaction;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionMangagerTest {
public static void main(String[] args) {
ApplicationContext appCo=new ClassPathXmlApplicationContext("appliationContext.xml");
CodeTransaction codeTransaction = (CodeTransaction)appCo.getBean("codeTransaction");
String result = codeTransaction.testTransaction();
System.out.println(result);
}
}

be based on TransactionTemplate Programming transaction management

The code for transaction processing is scattered in the business logic code , Breaking the order of the original code , And every transaction has a similar start transaction , Code to commit and roll back transactions .

TransactionTemplate Of excute There is one method TransactionCallback Parameters of interface type , This interface defines a DoInTransaction Methods , Usually implemented as anonymous inner classes TransactionCallback Interface , And in its doInTransaction Method to write business logic code . Here you can use the default transaction commit and rollback rules , There is no need to explicitly call any of the transactions in the business code API,doInTransaction There is one method TransactionStatus Parameters of type , The... Of this parameter can be called anywhere in the method setRollbackOnly Method identifies the transaction as a rollback , To perform a transaction rollback .

By default , If an unchecked exception is thrown during the execution of the callback method , Or explicitly call setRollbackOnly Method , Then roll back the transaction ; If the transaction is completed or thrown checked Exception of type , Then commit the transaction .

be based on TransactionTemplate The steps of programming transaction management are as follows :

  1. Add transaction templates for transaction management : Based on the underlying API Developed applicationContext.xml Configuration file springframwork Provided org,springframework,transaction.support.TransactionTemplate Class adds a transaction template for the transaction manager . The complete configuration file is as follows :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- Specify the packages to scan -->
<context:component-scan base-package="com.ch5"/>
<!-- Configure data sources -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!--Mysql drive -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<!-- Connected url-->
<property name="url" value="jdbc:mysql://localhost:3306/spring?characterEncoding=utf-8"/>
<!-- Configuration of user name and password -->
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- Configure transaction manager -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- For the transaction manager txManager establish transactionTemplate-->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="txManager"/>
</bean>
<!-- To configure JDBC Templates -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
  1. Create a data access class TransactionTemplateDao
package com.ch5;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
@Repository("transactionTemplateDao")
public class TransactionTemplateDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private TransactionTemplate transactionTemplate;
String message = "";
public String TransactionTemplateTest(){
// In the way that you ordered the inner class TransactionCallback Interface . Use the default transaction rules .
transactionTemplate.execute(new TransactionCallback<Object>() {
@Override
public Object doInTransaction(TransactionStatus status) {
String insertSql = "insert into account values(?,?,?)";
Object param[] = {9,"chen",5000.0};
try{
jdbcTemplate.update(insertSql,param);
jdbcTemplate.update(insertSql,param);
message=" Successful implementation , No rollback ";
}catch (Exception e){
message=" Transaction rollback ";
}
return message;
}
});
return message;
}
}
  1. Create test class TransactionTemplateDaoTest
package com.ch5.Test;
import com.ch5.TransactionTemplateDao;
import com.ch5.dao.Impl.CodeTransaction;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTemplateDaoTest {
public static void main(String[] args) {
ApplicationContext appCo=new ClassPathXmlApplicationContext("appliationContext.xml");
TransactionTemplateDao transactionTemplateDao = appCo.getBean("transactionTemplateDao", TransactionTemplateDao.class);
String result = transactionTemplateDao.TransactionTemplateTest();
System.out.println(result);
}
}

Declarative transaction management

Spring Declarative transaction management of is through AOP Technology implementation of transaction management , Its essence is to intercept the method , Then create a transaction before the target method starts , Commit or roll back the transaction after execution is complete .

Compared with programmed transaction management , The only drawback of declarative transactions is that the most fine-grained can only work at the method level , It can't act on the code block level like the programming transaction management , But even with the need , It can be solved in a flexible way . For example, the code block to be transacted can be encapsulated as a method .

Spring Declarative transaction management can be implemented in two ways , One is based on XML The way , The second is based on @Transactional How to annotate

be based on XML Mode of declarative transaction management

be based on XML The declarative transaction management of mode is realized by configuring the relevant declaration of transaction rules in the configuration file .Spring Provides tx Namespace to configure transaction management , Provides <tx:advice> Element to configure notification of transactions , In the configuration <tx:advice> In general, it is necessary to specify id and transaction-manager attribute , among id Is the unique identity of the configuration file .transaction-manager The transaction manager is specified . You also need to configure <tx:attributes> Subelement , This sub element can be configured with multiple <tx:method> The child elements determine the details of the execution of the transaction .

stay <tx:advice> After the element is configured with enhanced transaction processing, you can write AOP Configure let Spring Automatically generate proxies for target objects , Here is an example XML The way to make Spring Implement declarative transaction management . In order to reflect the process of transaction management , establish Dao、Service、Controller3 Layer implementation .

  1. establish Dao Interface and implementation classes
package statment.dao;
public interface TestDao {
public int save(String sql,Object param[]);
public int delete(String sql,Object param[]);
}
package statment.dao.Impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import statment.dao.TestDao;
@Repository("testDao")
public class TestDaoImpl implements TestDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public int save(String sql, Object[] param) {
return jdbcTemplate.update(sql,param);
}
public int delete(String sql, Object[] param) {
return jdbcTemplate.update(sql,param);
}
}
  1. establish Service Interface and implementation classes
package statment.Service;
public interface TestService {
public void test();
}
package statment.Service.Impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import statment.Service.TestService;
import statment.dao.TestDao;
@Service("testService")
public class TestServiceImpl implements TestService {
@Autowired
private TestDao testDao;
public void test() {
String deleteSql="delete from account";
String saveSql="insert into account values(?,?,?)";
Object param[] = {1,"shitji",5000};
testDao.delete(deleteSql,null);
testDao.save(saveSql,param);
}
}
  1. establish Controller class
package statment.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import statment.Service.TestService;
@Controller
public class StatementController {
@Autowired
private TestService testService;
public void test(){
testService.test();
}
}
  1. Writing configuration files bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:component-scan base-package="statment"/>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/spring"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<tx:advice id="myAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="txPonintCut" expression="execution(* statment.Service.*.*(..))"/>
<aop:advisor advice-ref="myAdvice" pointcut-ref="txPonintCut"/>
</aop:config>
</beans>
  1. Writing test classes
package statment.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import statment.controller.StatementController;
public class XMLTest {
public static void main(String[] args) {
ApplicationContext appCo=new ClassPathXmlApplicationContext("bean.xml");
StatementController controller = appCo.getBean("statementController", StatementController.class);
controller.test();
}
}

Annotation based declarative transaction management

package statment.Service.Impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import statment.Service.TestService;
import statment.dao.TestDao;
@Service("testService")
@Transactional
public class TestServiceImpl implements TestService {
@Autowired
private TestDao testDao;
public void test() {
String deleteSql="delete from account";
String saveSql="insert into account values(?,?,?)";
Object param[] = {1,"shitji",5000};
testDao.delete(deleteSql,null);
testDao.save(saveSql,param);
}
}

Join in @Transactional, You can specify that this class needs to be Spring Transaction management of , Note that this annotation is only for public Modify the way to add .

Catching exceptions in transactions

The process of declarative transaction is :

  1. Spring Complete the transaction definition according to the configuration , Set transaction properties .
  2. Execute the developer's code logic .
  3. If the developer's code generates an exception and meets the configuration conditions for transaction rollback , The transaction is rolled back , Otherwise commit the transaction .
  4. Transaction resource release .

If the developer adds try...catch sentence ,Spring The rollback of a transaction cannot be performed normally in a declarative transaction . as a result of Spring It's only when something happens that's not captured RuntimeException The transaction will be rolled back when the transaction . So it needs to be dealt with .

be based on XML Method of declarative transaction management

Based on XML Method of declarative transaction management , Two additional steps are needed :

  1. Modify the configuration of the declared transaction
<tx:method name="*" rollback-for="java.lang.Exception"/>
  1. stay catch Add... To the statement throw new RuntimeException();

Exception capture in declarative transaction management based on annotation

  1. Modify the notes , add to rollbackFor attribute
@Transactional(rollbackFor = {Exception.class})
  1. stay catch Add... To the statement throw new RuntimeException();
版权声明
本文为[Forget the book]所创,转载请带上原文链接,感谢
https://javamana.com/2021/01/20210122214258297M.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课程百度云