使用spring框架实现数据库事务处理方式
使用spring框架实现数据库事务处理
事务对于数据库来说是，是对sql语句的一系列操作，这些操作被组织成为一个事务。事务具有原子性的，要么全部执行，要么不执行。若事务中sql语句发生错误，事务需要对已经执行的sql进行回滚操作，撤销先前对数据库的操作，防止数据库出现错误状态。
JDBC对数据库事务处理的支持
jdbc本身提供了对数据库处理的支持，使用java.sql.Connection对象完成事务的提交。使用Connection提交数据库事务处理如下：
发现里面有一个方法叫setAutoCommit()，设置为true时，就是自动提交sql，如果设置为false时，sql语句的提交由程序负责，应用程序必须调用Commit方法，同时在执行sql语句异常处理块中调用rollback方法，对异常发生前进行的数据库进行回滚。
在企业级中，事务一般都是并发执行的，当事务并发执行时，就会发生数据库同步的问题，具体问题可分为下面四种类型：
- 脏读：
- 不可重复读：
- 丢失更新：
- 幻读：
为了解决上面的四种问题，解决事务并发的问题
JDBC定义了五种事务隔离级别来解决这些并发导致的问题
transaction_read_uncommitted:数据级别最低，俗称脏读，在没有提交数据时，就已经读取到已经更新的数据。transaction_read_committed:当一个事务进行查询时，允许读取提交前的数据，数据提交后，当前查询就可以读取到数据，update数据的时候并不锁住表。(最长使用)transaction_repeatable_read:当一个事务进行查询时，不允许读取其他事务更新的数据，可以读取其他事务新增的数据。transaction_serializable:当一个事务进行查询时，不允许任何对这个事务进行查询，就是把并行改成了串行。不提倡使用。
在spring框架中调用一个数据库事务处理分三步走：
- 第一步就是配置数据源就是配置数据库的名称和密码，地址等。
- 第二步就是声明事务管理TransactionManagerspring框架提供了PlatformTransactionManager作为事务管理类的顶层接口，声明了初始化事务，提交事务，回滚事务等接口。接口实现由具体的数据库驱动类实现。具体包括DataTransactionManager等实现类。但是主要还是使用的是DataTransactionManager类。
- 定义可以执行事务的DAO类DAO提供了应用程序访问数据源必要的接口和方法。
spring 事务实现方式有哪些
编程式事务管理，
在代码中调用 commit()、rollback()等事务管理相关的方法
maven pom.xml文件
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.2.4.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.2.4.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>4.2.4.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>4.2.4.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.2.4.RELEASE</version> </dependency> <!-- mysql驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.18</version> </dependency>
编程式事务管理，可以通过 java.sql.Connection 控制事务。spring 配置文件
<?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: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">
<bean id="driver" class="com.mysql.jdbc.Driver"></bean>
<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
<constructor-arg index="0" name="driver" ref="driver" />
<constructor-arg index="1">
<value>jdbc:mysql://localhost:3306/test</value>
</constructor-arg>
<constructor-arg index="2">
<value>root</value>
</constructor-arg>
<constructor-arg index="3">
<value>root</value>
</constructor-arg>
</bean>
</beans>
测试代码
package constxiong.interview.transaction;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
public static void main(String[] args) throws Exception {
testManualTransaction();//测试函数式控制事务
}
private static void testManualTransaction() throws SQLException {
ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
DataSource ds = (DataSource)context.getBean("datasource");
Connection conn = ds.getConnection();
try {
initTable(conn);//初始化表
conn.setAutoCommit(false);//设置不自动提交事务
queryUsers(conn);//查询打印用户表
deleteUser(conn);//删除 id=1 用户
conn.rollback();//回滚
queryUsers(conn);//查询打印用户表
} finally {
conn.close();
}
}
private static void initTable(Connection conn) throws SQLException {
conn.createStatement().execute("drop table if exists user");
conn.createStatement().execute("create table user(id int, username varchar(60)) ENGINE=InnoDB DEFAULT CHARSET=utf8 ");//是否支持事务与数据库引擎有关，此处删除 ENGINE=InnoDB DEFAULT CHARSET=utf8 可能不支持事务
conn.createStatement().execute("insert into user values(1, 'user1')");
conn.createStatement().execute("insert into user values(2, 'user2')");
}
private static void deleteUser(Connection conn) throws SQLException {
conn.createStatement().execute("delete from user where id = 1");
}
private static void queryUsers(Connection conn) throws SQLException {
Statement st = conn.createStatement();
st.execute("select * from user");
ResultSet rs = st.getResultSet();
while (rs.next()) {
System.out.print(rs.getString("id"));
System.out.print(" ");
System.out.print(rs.getString("username"));
System.out.println();
}
}
}
删除用户语句回滚，打印出两个用户
1 user1
2 user2
1 user1
2 user2
TransactionProxyFactoryBean 的声明式事务管理
新增 UserDao 接口
package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
public interface UserDao {
/**
* 查询用户
* @return
*/
public List<Map<String, Object>> getUsers();
/**
* 删除用户
* @param id
* @return
*/
public int deleteUser(int id);
}
新增 UserDao 实现
package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
/**
* 查询用户
* @return
*/
public List<Map<String, Object>> getUsers() {
String sql = "select * from user";
return this.getJdbcTemplate().queryForList(sql);
}
/**
* 删除用户
* @param id
* @return
*/
public int deleteUser(int id){
String sql = "delete from user where id = " + id;
int result = this.getJdbcTemplate().update(sql);
if (id == 1) {
throw new RuntimeException();
}
return result;
}
}
修改 spring 配置文件，添加事务管理器 DataSourceTransactionManager 和事务代理类 TransactionProxyFactoryBean
<?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: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">
<bean id="driver" class="com.mysql.jdbc.Driver"></bean>
<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
<constructor-arg index="0" name="driver" ref="driver" />
<constructor-arg index="1">
<value>jdbc:mysql://localhost:3306/test</value>
</constructor-arg>
<constructor-arg index="2">
<value>root</value>
</constructor-arg>
<constructor-arg index="3">
<value>root</value>
</constructor-arg>
</bean>
<bean id="userDao" class="constxiong.interview.transaction.UserDaoImpl">
<property name="dataSource" ref="datasource"></property>
</bean>
<!-- 事务管理器 -->
<bean id="tracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"></property>
</bean>
<bean id="userProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="tracnsactionManager"></property>
<property name="target" ref="userDao"></property>
<property name="transactionAttributes">
<props>
<!-- 主要 key 是方法
ISOLATION_DEFAULT 事务的隔离级别
PROPAGATION_REQUIRED 传播行为
-->
<!-- -Exception 表示发生指定异常回滚，+Exception 表示发生指定异常提交 -->
<prop key="deleteUser">-java.lang.RuntimeException</prop>
</props>
</property>
</bean>
</beans>
测试代码
package constxiong.interview.transaction;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
static ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
public static void main(String[] args) throws Exception {
testUseTransactionProxy(); //测试使用 spring TransactionProxyFactoryBean
}
private static void testUseTransactionProxy() {
final UserDao userDao = (UserDao)context.getBean("userProxy");
printUsers(userDao);//打印用户
userDao.deleteUser(1);//删除 id=1 用户
}
private static void printUsers(UserDao userDao) {
for (Map<String, Object> user : userDao.getUsers()) {
System.out.println(user);
}
}
}
结果输出
{id=1, username=user1}
{id=2, username=user2}
Exception in thread "main" java.lang.RuntimeException
at constxiong.interview.transaction.UserDaoImpl.deleteUser(UserDaoImpl.java:28)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy3.deleteUser(Unknown Source)
at constxiong.interview.transaction.TransactionTest.testUseTransactionProxy(TransactionTest.java:32)
at constxiong.interview.transaction.TransactionTest.main(TransactionTest.java:13)
注解 @Transactional 的声明式事务管理
UserDaoImpl 删除用户方法添加注解 @Transactional(rollbackFor=RuntimeException.class) 出现 RuntimeException 回滚
package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.transaction.annotation.Transactional;
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
/**
* 查询用户
* @return
*/
public List<Map<String, Object>> getUsers() {
String sql = "select * from user";
return this.getJdbcTemplate().queryForList(sql);
}
/**
* 删除用户
* @param id
* @return
*/
@Transactional(rollbackFor=RuntimeException.class)
public int deleteUser(int id){
String sql = "delete from user where id = " + id;
int result = this.getJdbcTemplate().update(sql);
if (id == 1) {
throw new RuntimeException();
}
return result;
}
}
修改 spring 配置文件，开启 spring 的事务注解能力
<?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="driver" class="com.mysql.jdbc.Driver"></bean>
<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
<constructor-arg index="0" name="driver" ref="driver" />
<constructor-arg index="1">
<value>jdbc:mysql://localhost:3306/test</value>
</constructor-arg>
<constructor-arg index="2">
<value>root</value>
</constructor-arg>
<constructor-arg index="3">
<value>root</value>
</constructor-arg>
</bean>
<bean id="userDao" class="constxiong.interview.transaction.UserDaoImpl">
<property name="dataSource" ref="datasource"></property>
</bean>
<!-- 事务管理器 -->
<bean id="tracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"></property>
</bean>
<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="tracnsactionManager"/>
</beans>
测试代码
package constxiong.interview.transaction;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
static ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
public static void main(String[] args) throws Exception {
testAnnotationTransaction();
}
private static void testAnnotationTransaction() {
UserDao userDao = (UserDao)context.getBean("userDao");
printUsers(userDao);
userDao.deleteUser(1);
}
private static void printUsers(UserDao userDao) {
for (Map<String, Object> user : userDao.getUsers()) {
System.out.println(user);
}
}
}
输出结果
{id=1, username=user1}
{id=2, username=user2}
Exception in thread "main" java.lang.RuntimeException
at constxiong.interview.transaction.UserDaoImpl.deleteUser(UserDaoImpl.java:30)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy5.deleteUser(Unknown Source)
at constxiong.interview.transaction.TransactionTest.testAnnotationTransaction(TransactionTest.java:20)
at constxiong.interview.transaction.TransactionTest.main(TransactionTest.java:13)
Aspectj AOP 配置（注解）事务
maven pom.xml 添加 Aspectj 的支持
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
去除 UserDaoImpl 注解@Transactional(rollbackFor=RuntimeException.class)
package constxiong.interview.transaction;
import java.util.List;
import java.util.Map;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
/**
* 查询用户
* @return
*/
public List<Map<String, Object>> getUsers() {
String sql = "select * from user";
return this.getJdbcTemplate().queryForList(sql);
}
/**
* 删除用户
* @param id
* @return
*/
public int deleteUser(int id){
String sql = "delete from user where id = " + id;
int result = this.getJdbcTemplate().update(sql);
if (id == 1) {
throw new RuntimeException();
}
return result;
}
}
修改 spring 配置文件，织入切面
<?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.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">
<bean id="driver" class="com.mysql.jdbc.Driver"></bean>
<bean id="datasource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
<constructor-arg index="0" name="driver" ref="driver" />
<constructor-arg index="1">
<value>jdbc:mysql://localhost:3306/test</value>
</constructor-arg>
<constructor-arg index="2">
<value>root</value>
</constructor-arg>
<constructor-arg index="3">
<value>root</value>
</constructor-arg>
</bean>
<bean id="userDao" class="constxiong.interview.transaction.UserDaoImpl">
<property name="dataSource" ref="datasource"></property>
</bean>
<!-- 事务管理器 -->
<bean id="tracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="datasource"></property>
</bean>
<tx:advice id="txAdvice" transaction-manager="tracnsactionManager">
<tx:attributes>
<!-- 为连接点指定事务属性 -->
<tx:method name="deleteUser" rollback-for="java.lang.RuntimeException"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!-- 切入点配置 -->
<aop:pointcut id="point" expression="execution(* *constxiong.interview.transaction.UserDao.deleteUser(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="point"/>
</aop:config>
</beans>
测试代码
package constxiong.interview.transaction;
import java.util.Map;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
static ApplicationContext context = new ClassPathXmlApplicationContext("spring_transaction.xml");
public static void main(String[] args) throws Exception {
testAspectjTransaction();
}
private static void testAspectjTransaction() {
UserDao userDao = (UserDao)context.getBean("userDao");
printUsers(userDao);
userDao.deleteUser(1);
}
private static void printUsers(UserDao userDao) {
for (Map<String, Object> user : userDao.getUsers()) {
System.out.println(user);
}
}
}
输出结果
{id=1, username=user1}
{id=2, username=user2}
Exception in thread "main" java.lang.RuntimeException
at constxiong.interview.transaction.UserDaoImpl.deleteUser(UserDaoImpl.java:28)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:302)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99)
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:281)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:208)
at com.sun.proxy.$Proxy2.deleteUser(Unknown Source)
at constxiong.interview.transaction.TransactionTest.testAnnotationTransaction(TransactionTest.java:20)
at constxiong.interview.transaction.TransactionTest.main(TransactionTest.java:13)
PS：
这篇仅用事务回滚为例，了解 spring 事务控制，还需要关注数据库的ACID四种特性、事务传播特性、事务的隔离级别（脏读、不可重复读、幻读）。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持猪先飞。
相关文章
- 操作类就是把一些常用的一系列的数据库或相关操作写在一个类中，这样调用时我们只要调用类文件，如果要执行相关操作就直接调用类文件中的方法函数就可以实现了，下面整理了...2016-11-25
- 本文给大家分享C#连接SQL数据库和查询数据功能的操作技巧，本文通过图文并茂的形式给大家介绍的非常详细，需要的朋友参考下吧...2021-05-17
- 这篇文章主要介绍了Spring AOP 对象内部方法间的嵌套调用方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教...2021-08-29
- 这篇文章主要介绍了C#从数据库读取图片并保存的方法，帮助大家更好的理解和使用c#，感兴趣的朋友可以了解下...2021-01-16
Spring Cloud 中@FeignClient注解中的contextId属性详解
这篇文章主要介绍了Spring Cloud 中@FeignClient注解中的contextId属性详解，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教...2021-09-25- 这篇文章主要介绍了Intellij IDEA连接Navicat数据库的方法,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借价值，需要的朋友可以参考下...2021-03-25
Springboot如何实现Web系统License授权认证
这篇文章主要介绍了Springboot如何实现Web系统License授权认证,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下...2020-05-28- 在开发过程中，我们经常会将日期时间的毫秒数存放到数据库，但是它对应的时间看起来就十分不方便，我们可以使用一些函数将毫秒转换成date格式。 一、 在MySQL中，有内置的函数from_unixtime()来做相应的转换，使用如下： 复制...2014-05-31
- C#使用System.IO中的文件操作方法在Windows系统中处理本地文件相当顺手,这里我们还总结了在Oracle中保存文件的方法,嗯,接下来就来看看整理的C#操作本地文件及保存文件到数据库的基本方法总结...2020-06-25
- 通过内网连另外一台机器的mysql服务， 确发现速度N慢！ 等了大约几十秒才等到提示输入密码。 但是ping mysql所在服务器却很快！ 想到很久之前有过类似的经验， telnet等一些服务在连接请求的时候，会做一些反向域名解析（如果...2015-10-21
- 某些时候，例如为了搭建一个测试环境，或者克隆一个网站，需要复制一个已存在的mysql数据库。使用以下方法，可以非常简单地实现。假设已经存在的数据库名字叫db1，想要复制一份，命名为newdb。步骤如下：1. 首先创建新的数据库newd...2015-10-21
- mysqldump命令的用法1、导出所有库系统命令行mysqldump -uusername -ppassword --all-databases > all.sql 2、导入所有库mysql命令行mysql>source all.sql; 3、导出某些库系统命令行mysqldump -uusername -ppassword...2015-10-21
- 1005：创建表失败1006：创建数据库失败1007：数据库已存在，创建数据库失败1008：数据库不存在，删除数据库失败1009：不能删除数据库文件导致删除数据库失败1010：不能删除数据目录导致删除数据库失败1011：删除数据库...2013-09-23
如何在Spring WebFlux的任何地方获取Request对象
这篇文章主要介绍了如何在Spring WebFlux的任何地方获取Request对象，帮助大家更好的理解和使用springboot框架，感兴趣的朋友可以了解下...2021-01-26- 这篇文章主要介绍了详解SpringCloudGateway内存泄漏问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧...2020-07-16
- 这篇文章主要介绍了c#从数据库里取得数据并异步更新ui的方法，大家参考使用吧...2020-06-25
- yii2.0框架是PHP开发的一个比较高效率的框架，集合了作者的大量心血，下面通过用户为例给大家详解yii2使用中的一些基本的增删改查操作。 User::find()->all(); //返回所有用户数据； User::findOne($id); //返回 主键...2015-11-24
- 因此，正确的原子操作是真正被执行过的。是物理执行。在当前事务中确实能看到插入的记录。最后只不过删除了。但是AUTO_INCREMENT不会应删除而改变值。1、为什么auto_increament没有回滚？因为innodb的auto_increament的...2014-05-31
- 这篇文章主要介绍了springBoot 项目排除数据库启动方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教...2021-09-10
- 1.用phpmyadmin创建数据库和数据表 创建数据库的时候，请将“整理”设置为：“utf8_general_ci” 或执行语句： 复制代码 代码如下:CREATE DATABASE `dbname` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; 创...2015-10-21