Spring全家桶之SpringData——Spring 整合Hibernate与Hibernate Jpa
时间:2022-07-22
本文章向大家介绍Spring全家桶之SpringData——Spring 整合Hibernate与Hibernate Jpa，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。
Spring 整合Hibernate与Hibernate Jpa
- 一. Spring 整合Hibernate
- 二 .Spring整合Hibernate JPA
一. Spring 整合Hibernate
正向工程: 通过实体类和查询方法自动创建数据库表 如Hibernate与Hibernate Jpa 逆向工程: 通过数据库表自动创建对应的实体类以及查询方法 逆向工程的使用
Hibernate简单环境搭建
Hibernate介绍
Hibernate是一种ORM框架，ORM全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！
搭建步骤
1. 相关jar的的导入
IOC : 提供Spring的IOC容器 AOP :提供Spring对事务的处理 ORM :提供Spring整合hirebnate 单元测试 日志jar hiernate 核心jar 数据库连接池 jdbc的jar
antlr-2.7.7.jar
aopalliance.jar
aspectjrt.jar
aspectjweaver.jar
c3p0-0.9.2.1.jar
commons-logging-1.1.1.jar
dom4j-1.6.1.jar
geronimo-jta_1.1_spec-1.1.1.jar
hibernate-c3p0-5.0.7.Final.jar
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-core-5.0.7.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-2.0.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.3.0.Final.jar
mchange-commons-java-0.2.3.4.jar
mysql-connector-java-5.1.7-bin.jar
spring-aop-4.2.0.RELEASE.jar
spring-aspects-4.2.0.RELEASE.jar
spring-beans-4.2.0.RELEASE.jar
spring-context-4.2.0.RELEASE.jar
spring-core-4.2.0.RELEASE.jar
spring-expression-4.2.0.RELEASE.jar
spring-jdbc-4.2.0.RELEASE.jar
spring-orm-4.2.0.RELEASE.jar
spring-test-4.2.0.RELEASE.jar
spring-tx-4.2.0.RELEASE.jar2 .编写配置文件完成框架的整合(src下)
配置读取properties工具类 配置c3p0数据库连接池 配置Hibernate的sessionFactory 扫描实体类所在的包 配置HibernateTemplate对象 配置Hibernate的事务管理器 配置开启注解的事务管理 配置SpringIOC的注解扫描
<?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:aop="http://www.springframework.org/schema/aop"
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/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">
<!-- 配置读取properties工具类 -->
<context:property-placeholder location="classpath:*.properties" />
<!-- 配置c3p0数据库连接池 -->
<bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="driverClass" value="${jdbc.driver.class}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 配置Hibernate的SeesionFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- hibernateProperties属性：配置与hibernate相关的内容，如显示sql语句，开启正向工程 -->
<property name="hibernateProperties">
<props>
<!-- 显示当前执行的sql语句 -->
<prop key="hibernate.show_sql">true</prop>
<!-- 开启正向工程 -->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 扫描实体所在的包 -->
<property name="packagesToScan">
<list>
<value>ah.szxy.pojo</value>
</list>
</property>
</bean>
<!-- 配置HiberanteTemplate 对象 -->
<bean id="hibernateTemplate"
class="org.springframework.orm.hibernate5.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置Hibernate的事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置开启注解事务处理 -->
<tx:annotation-driven
transaction-manager="transactionManager" />
<!-- 配置springIOC的注解扫描 -->
<context:component-scan base-package="ah.szxy" />
</beans>db.properties
#数据库连接参数的配置
jdbc.url=jdbc:mysql://localhost:3306/springdata
jdbc.driver.class=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=root通过hibernate完成crud操作
项目结构
0. 创建数据库
新建一个数据库 ,无需建表,只需要和db.properties相对应即可
1. 创建实体 ,加注解
@Entity //表示当前类是实体类 @Table(name=“t_users”) //表示将该实体类通过正向工程时创建的表名为 t_users; //依次为主键 ,自增长 ,列名 ,注意导的是 persistence包 @Id @GeneratedValue(strategy=GenerationType.IDENTITY) @Column(name=“userid”)
package ah.szxy.pojo;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="t_users")
public class Users {
//依次为主键 ,自增长 ,列名
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="userid")
private Integer userid;
@Column(name="username")
private String username;
@Column(name="userage")
private Integer userage;
public Integer getUserid() {
return userid;
}
public void setUserid(Integer userid) {
this.userid = userid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Integer getUserage() {
return userage;
}
public void setUserage(Integer userage) {
this.userage = userage;
}
@Override
public String toString() {
return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
}
public Users(Integer userid, String username, Integer userage) {
super();
this.userid = userid;
this.username = username;
this.userage = userage;
}
public Users() {
super();
}
}2 .配置HibernateTemplate对象
位于事务管理器上方即可
<!-- 配置HiberanteTemplate 对象 -->
<bean id="hibernateTemplate"
class="org.springframework.orm.hibernate5.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>3. 编写user Dao接口与接口实现类(@Repository) ,增删改查(根据Interger userid)
@Repository //表名当前是dao层的实现类 注入 HibernateTemplate的对象 hibernateTemplate(增删改查方法如下) hibernateTemplate.save(users); hibernateTemplate.delete(users); hibernateTemplate.update(users); hibernateTemplate.get(Users.class, userid);
接口类
package ah.szxy.dao;
import java.util.List;
import ah.szxy.pojo.Users;
public interface UserDao {
void insert(Users users);
void delete(Users users);
void update(Users users);
Users selectByUserid(Integer userid);
}接口实现类
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;
import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;
@Repository
public class UserDaoImpl implements UserDao {
@Autowired
private HibernateTemplate hibernateTemplate;
public void insert(Users users) {
this.hibernateTemplate.save(users);
}
public void delete(Users users) {
this.hibernateTemplate.delete(users);
}
public void update(Users users) {
this.hibernateTemplate.update(users);
}
public Users selectByUserid(Integer userid) {
return this.hibernateTemplate.get(Users.class, userid);
}
}4. 编写测试代码 .加入相关注解
@RunWith(SpringJUnit4ClassRunner.class) //表示使用的测试工具版本 @ContextConfiguration(“classpath:applicationContext.xml”) //表示读取的配置文件 @Test //表示该方法可以被测试 @Transactional // 在测试类对于事务提交方式默认的是回滚。 @Rollback(false) // 取消自动回滚
package ah.szxy.test;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestHibernate {
@Autowired
private UserDao userDao;
/**
* 添加用户
*/
@Test
@Transactional // 在测试类对于事务提交方式默认的是回滚。
@Rollback(false) // 取消自动回滚
public void testInsertUsers() {
Users users = new Users();
users.setUserage(23);
users.setUsername("宿州学院");
this.userDao.insert(users);
}
/**
* 修改用户
*/
@Test
@Transactional
@Rollback(false)
public void testUpdateUsers() {
Users users = new Users();
users.setUserid(1);
users.setUsername("chy");
users.setUserage(24);
this.userDao.update(users);
}
/**
* 查询用户
*/
@Test
public void getUserByuserid() {
Integer userid=2;;
Users users = this.userDao.selectByUserid(userid);
System.out.println(users);
}
/**
* 删除用户
*/
@Test
@Transactional
@Rollback(false)
public void deleteUsers() {
Users users = new Users();
users.setUserid(1);
this.userDao.delete(users);
}
/**
* 测试HQL查询 ,根据用户名称查询用户信息
* 必须加上@Transactional注解
*/
@Test
@Transactional
public void selectByUsername() {
List<Users> users = this.userDao.selectByUserName("宿州学院");
System.out.println(users);
}Hibernate的查询(非主键列)-HQL查询
介绍
HQL：Hibernate Query Language HQL 的语法：就是将原来的sql 语句中的表与字段名称换成对象与属性的名称
接口类
List<Users> selectByUserName(String username);接口实现类
注意 1. sql语句 ,是通过对象查询的表 ,虽然可以出现select 但是却不能出现通配符 *,故可以省略 Select * 2 .区别 getCurrentSession 与openSession 方法的用法 getCurrentSession:当前session 必须要有事务边界， 且只能处理唯一的一个事务。当事务提交或者回滚后session 自动失效 openSession:每次都会打开一个新的session.加入每次使用多次。则获得的是不同session 对象。使用完毕后我们需要手动的调用colse方法关闭session
@Override
public List<Users> selectByUserName(String username) {
/**
* 1. getCurrentSession:当前session 必须要有事务边界，
* 且只能处理唯一的一个事务。当事务提交或者回滚后session 自动失效
* 2. openSession:每次都会打开一个新的session.加入每次使用多次。则获得的是不同session 对象。
* 使用完毕后我们需要手动的调用colse方法关闭session
*/
Session session = this.hibernateTemplate.getSessionFactory().getCurrentSession();
// sql:select * from t_users where username =
Query query = session.createQuery("from Users where username= :username");
Query queryTemp = query.setString("username", username);
return queryTemp.list();
}测试类
测试该查询时需要加上@Test @Transactional 注解
/**
* 测试HQL查询 ,根据用户名称查询用户信息
* 必须加上@Transactional注解
*/
@Test
@Transactional
public void selectByUsername() {
List<Users> users = this.userDao.selectByUserName("宿州学院");
System.out.println(users);
}Hibernate的查询-SQL查询
介绍
在Hibernate中使用正常的sql 语句,进行查询操作
接口类
List<Users> selectByUsernameUseSQL(String username);接口实现类
注意
sql语句后面的方法 , 绑定值从0开始
@Override
public List<Users> selectByUsernameUseSQL(String username) {
Session session = this.hibernateTemplate.getSessionFactory().getCurrentSession();
Query query = session.createSQLQuery("select * from t_users where username= ?"
).addEntity(Users.class).setString(0, username);
return query.list();
}测试类
/**
* 测试Hibernate的SQL查询
*/
@Test
@Transactional
public void selecByUserNameUseSql() {
List<Users> users = this.userDao.selectByUsernameUseSQL("宿州学院");
for(Users user:users) {
System.out.println(user);
}
}Hibernate的查询-QBC查询
QBC：Query By Criteria
接口实现类
@Override
public List<Users> selectUserByNameUseCriteria(String username) {
Session session = this.hibernateTemplate.getSessionFactory().getCurrentSession();
// sql:select * from t_users where username = 张三
Criteria c = session.createCriteria(Users.class);
c.add(Restrictions.eq("username", username));
return c.list();
}测试代码
/**
* Criteria 测试
*/
@Test
@Transactional
public void testSelectUserByNameUseCriteria() {
List<Users> list = this.usersDao.selectUserByNameUseCriteria("张三");
for (Users users : list) {
System.out.println(users);
}
}查漏补缺:
如果觉得不过瘾 ,请看这篇深入浅出的博文 Hibernate入门这一篇就够了
二 .Spring整合Hibernate JPA
介绍
步骤
1. 创建项目
可以复制以上的项目 ,在其基础上进行修改
2. 在项目中额外导入Hibernate JPA的jar包
hibernate-entitymanager-5.0.7.Final.jar3 .修改配置文件
配置EntityManagerFactory 修改事务管理器 hibernate原生不可以和Hibernate JPA混合使用
<?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:aop="http://www.springframework.org/schema/aop"
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/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">
<!-- 配置读取properties工具类 -->
<context:property-placeholder
location="classpath:*.properties" />
<!-- 配置c3p0数据库连接池 -->
<bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="driverClass" value="${jdbc.driver.class}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- Spring 整合JPA 配置EntityManagerFactory -->
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter">
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!-- hibernate 相关的属性的注入 -->
<!-- 配置数据库类型 -->
<property name="database" value="MYSQL" />
<!-- 正向工程自动创建表 -->
<property name="generateDdl" value="true" />
<!-- 显示执行的SQL -->
<property name="showSql" value="true" />
</bean>
</property>
<!-- 扫描实体的包 -->
<property name="packagesToScan">
<list>
<value>ah.szxy.pojo</value>
</list>
</property>
</bean>
<!-- 配置Hibernate 的事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 配置开启注解事务处理 -->
<tx:annotation-driven
transaction-manager="transactionManager" />
<!-- 配置springIOC的注解扫描 -->
<context:component-scan base-package="ah.szxy" />
</beans>Hibernate JPA整合实现curd操作
环境搭建.接口实现类 注入EntityManager ,注入的方式改变
@PersistenceContext(name = "entityManagerFactory")
private EntityManager entityManager;删除方式不同 ,要先查询 ,根据id删除
增删改查调用的方法改变 ,通过entityManager对象实现真删改查操作 具体情况请看下面代码
Hibernate JPA中的HQL语句
Hibernate JPA中的SQL语句
Hibernate JPA中的SQL语句的QBC查询
注意 : 为节约时间,特将代码合在一起写 ,可以通过注释区分
实体类
同上 ,代码如下
package ah.szxy.pojo;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="t_users")
public class Users implements Serializable{
//依次为主键 ,自增长 ,列名
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="userid")
private Integer userid;
@Column(name="username")
private String username;
@Column(name="userage")
private Integer userage;
public Integer getUserid() {
return userid;
}
public void setUserid(Integer userid) {
this.userid = userid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Integer getUserage() {
return userage;
}
public void setUserage(Integer userage) {
this.userage = userage;
}
@Override
public String toString() {
return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
}
public Users(Integer userid, String username, Integer userage) {
super();
this.userid = userid;
this.username = username;
this.userage = userage;
}
public Users() {
super();
}
}接口类
同上
package ah.szxy.dao;
import java.util.List;
import ah.szxy.pojo.Users;
public interface UserDao {
void insert(Users users);
void delete(Users users);
void update(Users users);
Users selectByUserid(Integer userid);
List<Users> selectByUserName(String username);
List<Users> selectByUsernameUseSQL(String username);
List<Users> selectUserByNameUseCriteria(String username);
}接口实现类
注意实现类中的书写方式 删除方式不同 ,要先查询 ,根据id删除
package ah.szxy.dao.impl;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.springframework.stereotype.Repository;
import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;
@Repository
public class UserDaoImpl implements UserDao {
// 都是持久化操作
@PersistenceContext(name = "entityManagerFactory")
private EntityManager entityManager;
public void insert(Users users) {
this.entityManager.persist(users);
}
public void delete(Users users) {
Users u = this.selectByUserid(users.getUserid());
this.entityManager.remove(u);
}
public void update(Users users) {
this.entityManager.merge(users);
}
public Users selectByUserid(Integer userid) {
return this.entityManager.find(Users.class, userid);
}
@Override
public List<Users> selectByUserName(String username) {
return this.entityManager.createQuery("from Users where username= :suibian").setParameter("suibian", username).getResultList();
}
@Override
public List<Users> selectByUsernameUseSQL(String username) {
/**
* 在Hibernate JPA 中如果通过？方式来绑定参数，那么他的查数下标是从1开始的。而hibernate 中是从0 开始的。
*/
return this.entityManager.createNativeQuery("select * from t_users where username = ?", Users.class).setParameter(1, username).getResultList();
}
/**
*采取QBC查询
*
*/
@Override
public List<Users> selectUserByNameUseCriteria(String username) {
// CriteriaBuilder 对象：创建一个CriteriaQuery,创建查询条件。
CriteriaBuilder builber = this.entityManager.getCriteriaBuilder();
// CriteriaQuery 对象：执行查询的Criteria 对象
// select * from t_users
CriteriaQuery<Users> query = builber.createQuery(Users.class);
// 获取要查询的实体类的对象
Root<Users> root = query.from(Users.class);
// 封装查询条件
Predicate cate = builber.equal(root.get("username"), username);
// select * from t_users where username = 张三
query.where(cate);
// 执行查询
TypedQuery<Users> typeQuery = this.entityManager.createQuery(query);
return typeQuery.getResultList();
}
}测试类
同上
package ah.szxy.test;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestHibernate {
@Autowired
private UserDao userDao;
/**
* 添加用户
*/
@Test
@Transactional // 在测试类对于事务提交方式默认的是回滚。
@Rollback(false) // 取消自动回滚
public void testInsertUsers() {
Users users = new Users();
users.setUserage(23);
users.setUsername("hello hibernate jpa");
this.userDao.insert(users);
}
/**
* 修改用户
*/
@Test
@Transactional
@Rollback(false)
public void testUpdateUsers() {
Users users = new Users();
users.setUserid(5);
users.setUsername("chy");
users.setUserage(24);
this.userDao.update(users);
}
/**
* 查询用户
*/
@Test
public void getUserByuserid() {
Integer userid=2;;
Users users = this.userDao.selectByUserid(userid);
System.out.println(users);
}
/**
* 删除用户
* 使用Hibernate JPA进行删除时,需要在dao层先查询用户id ,然后再删除
*/
@Test
@Transactional
@Rollback(false)
public void deleteUsers() {
Users users = new Users();
users.setUserid(5);
this.userDao.delete(users);
}
/**
* 测试Hibernate JPA的HQL查询 ,根据用户名称查询用户信息
* 必须加上@Transactional注解
*/
@Test
@Transactional
public void selectByUsername() {
List<Users> users = this.userDao.selectByUserName("宿州学院");
System.out.println(users);
}
/**
* 测试Hibernate JPA的SQL查询
*/
@Test
@Transactional
public void selecByUserNameUseSql() {
List<Users> users = this.userDao.selectByUsernameUseSQL("宿州学院");
for(Users user:users) {
System.out.println(user);
}
}
/**
* 测试Hibernate JPA的Criteria查询
*/
@Test
@Transactional
public void Criteria() {
List<Users> users = this.userDao.selectByUsernameUseSQL("宿州学院");
for(Users user:users) {
System.out.println(user);
}
}
}查漏补缺
如果觉得不过瘾 ,请看这篇深入浅出的博文 HibernateJPA入门
- java教程
- Java快速入门
- Java 开发环境配置
- Java基本语法
- Java 对象和类
- Java 基本数据类型
- Java 变量类型
- Java 修饰符
- Java 运算符
- Java 循环结构
- Java 分支结构
- Java Number类
- Java Character类
- Java String类
- Java StringBuffer和StringBuilder类
- Java 数组
- Java 日期时间
- Java 正则表达式
- Java 方法
- Java 流(Stream)、文件(File)和IO
- Java 异常处理
- Java 继承
- Java 重写(Override)与重载(Overload)
- Java 多态
- Java 抽象类
- Java 封装
- Java 接口
- Java 包(package)
- Java 数据结构
- Java 集合框架
- Java 泛型
- Java 序列化
- Java 网络编程
- Java 发送邮件
- Java 多线程编程
- Java Applet基础
- Java 文档注释
- SAP RFC函数RFC_READ_TABLE使用与优化
- 数据库PostrageSQL-升级一个PostgreSQL集簇
- 数据库PostrageSQL-用 SSL 进行安全的 TCP/IP 连接
- 数据库PostrageSQL-使用SSH隧道的安全 TCP/IP 连接
- 快速学习-Saturn(英文版入门指引)
- Promise.all 踩坑记录
- Springboot统一返回接口+统一异常处理+后端参数校验
- 面试Java基础问题汇总 part2
- org.springframework.util.xml.SimpleSaxErrorHandler warning org.xml.sax.SAXParseException； systemId:
- 贷款违约预测-Task1 赛题理解
- Android功耗优化（7）---如何分析wakelock（wakeup source）持锁问题
- 一道有意思的腾讯算法面试题
- 关于 JavaScript 错误处理的最完整指南(上半部)
- 排障集锦：九九八十一难之第十六难！-------------enoent ENOENT: no such file or directory, open ‘/root/package.json‘
- 大点干！早点散----------深入剖析GFS分布式文件系统