【译】Spring 4 + Hibernate 4 + Mysql + Maven集成例子（注解 + XML）
前言
译文链接：http://websystique.com/spring/spring4-hibernate4-mysql-maven-integration-example-using-annotations/
本文将基于注解配置, 集成Spring 4和Hibernate 4，开发一个增删改查应用，涉及以下内容：
- 创建Hibernate实体
- 保存数据到mysql数据库中
- 在事务
transaction内部执行增删改查操作 - 典型企业应用中不同层之间的交互
- 基于注解配置
当然，我们也会给出XML配置作为对比。
如果你的应用是基于Spring MVC开发，那么可以参考该链接：Spring4 MVC Hibernate and MySQL integration.
涉及的技术及开发工具
- Spring 4.0.6.RELEASE
- Hibernate Core 4.3.6.Final
- MySQL Server 5.6
- Joda-time 2.3
- Maven 3
- JDK 1.6
- Eclipse JUNO Service Release 2
工程结构目录
步骤一：往pom.xml中添加依赖
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.websystique.spring</groupId>
<artifactId>Spring4HibernateExample</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging> <name>Spring4HibernateExample</name> <properties>
<springframework.version>4.0.6.RELEASE</springframework.version>
<hibernate.version>4.3.6.Final</hibernate.version>
<mysql.connector.version>5.1.31</mysql.connector.version>
<joda-time.version>2.3</joda-time.version>
</properties> <dependencies> <!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${springframework.version}</version>
</dependency> <!-- Hibernate -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency> <!-- MySQL -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.connector.version}</version>
</dependency> <!-- Joda-Time -->
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>${joda-time.version}</version>
</dependency> <!-- To map JodaTime with database type -->
<dependency>
<groupId>org.jadira.usertype</groupId>
<artifactId>usertype.core</artifactId>
<version>3.0.0.CR1</version>
</dependency> </dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build> </project>
很明显我们需要添加Spring、Hibernate和Mysql连接器相关依赖，另外，由于我们使用了joda-time库来处理时间，所以也引入了joda-time依赖。usertype-core库引入是为了提供数据库时间类型与joda-time LocalDate之间的映射。
步骤二：配置Hibernate
com.websystique.spring.configuration.HibernateConfiguration
package com.websystique.spring.configuration; import java.util.Properties; import javax.sql.DataSource; import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate4.HibernateTransactionManager;
import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement; @Configuration
@EnableTransactionManagement
@ComponentScan({ "com.websystique.spring.configuration" })
@PropertySource(value = { "classpath:application.properties" })
public class HibernateConfiguration { @Autowired
private Environment environment; @Bean
public LocalSessionFactoryBean sessionFactory() {
LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
sessionFactory.setDataSource(dataSource());
sessionFactory.setPackagesToScan(new String[] { "com.websystique.spring.model" });
sessionFactory.setHibernateProperties(hibernateProperties());
return sessionFactory;
} @Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
dataSource.setUrl(environment.getRequiredProperty("jdbc.url"));
dataSource.setUsername(environment.getRequiredProperty("jdbc.username"));
dataSource.setPassword(environment.getRequiredProperty("jdbc.password"));
return dataSource;
} private Properties hibernateProperties() {
Properties properties = new Properties();
properties.put("hibernate.dialect", environment.getRequiredProperty("hibernate.dialect"));
properties.put("hibernate.show_sql", environment.getRequiredProperty("hibernate.show_sql"));
properties.put("hibernate.format_sql", environment.getRequiredProperty("hibernate.format_sql"));
return properties;
} @Bean
@Autowired
public HibernateTransactionManager transactionManager(SessionFactory s) {
HibernateTransactionManager txManager = new HibernateTransactionManager();
txManager.setSessionFactory(s);
return txManager;
}
}
@Configuration注解表明该类包含了用@Bean标注的方法，这些被@Bean标注的方法可以生成bean并交由spring容器管理，在这里例子中，这个类代表了hibernate的配置。
@ComponentScan注解与xml配置中的“context:component-scan base-package="..."”等价，提供了扫描bean的包路径。
@EnableTransactionManagement注解与xml配置中Spring的tx:*命名空间等价，主要用于开启基于注解的事务管理。
@PropertySource注解用于在Spring运行时Environment中声明一组属性（在应用classpath路径下的properties文件中定义），可根据不同环境灵活改变属性值。
sessionFactory()方法创建了一个LocalSessionFactoryBean，与基于XML的配置类似，我们需要一个数据源dataSource和hibernate配置文件（如hibernate.properties）。
多亏了@PropertySource注解，我们可以从.properties文件中得到具体属性值，使用Spring的Environment接口获取对应项目的配置值。
一旦创建了SessionFactory，该bean将会被注入到transactionManager方法中，最终对sessionFactory创建的sessions提供事务支持功能。
如下是本文使用的属性配置文件：
/src/main/resources/application.properties
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/websystique
jdbc.username = myuser
jdbc.password = mypassword
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = false
hibernate.format_sql = false
另外，对应的基于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: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-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd"> <context:property-placeholder location="classpath:application.properties" /> <context:component-scan base-package="com.websystique.spring" /> <tx:annotation-driven transaction-manager="transactionManager"/> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}"/> </bean> <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" >
<property name="dataSource" ref="dataSource"/>
<property name="packagesToScan">
<list>
<value>com.websystique.spring.model</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql:false}</prop>
<prop key="hibernate.format_sql">${hibernate.format_sql:false}</prop>
</props>
</property>
</bean> <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean> <bean id="persistenceExceptionTranslationPostProcessor"
class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/> </beans>
步骤三：Spring配置
com.websystique.spring.configuration.AppConfig
package com.websystique.spring.configuration; import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration; @Configuration
@ComponentScan(basePackages = "com.websystique.spring")
public class AppConfig { }
在我们这个示例中，即使该配置类内部是空的，但是使用了@ComponentScan注解，可以自动检测到对应包下所有的beans。
其实你可以完全去除以上的配置，将bean扫描功能放在application context级别去实现(main方法里)。
在成熟的应用里，你会发现使用配置类配置beans（如messageSource、PropertySourcesPlaceHolderConfigurer...）非常方便。
对应的基于XML的配置
<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-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"> <context:component-scan base-package="com.websystique.spring" /> </beans>
以上就是关于本工程的所有配置了，现在，为了让工程能跑起来，我们还需要添加service、dao层，实体对象，数据库。
步骤四：DAO层
com.websystique.spring.dao.AbstractDao
package com.websystique.spring.dao; import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired; public abstract class AbstractDao { @Autowired
private SessionFactory sessionFactory; protected Session getSession() {
return sessionFactory.getCurrentSession();
} public void persist(Object entity) {
getSession().persist(entity);
} public void delete(Object entity) {
getSession().delete(entity);
}
}
注意，我们在步骤二创建的SessionFactory会被自动装配到这里，这个类将作为基类用于执行数据库相关操作。
com.websystique.spring.dao.EmployeeDao
package com.websystique.spring.dao;
import java.util.List;
import com.websystique.spring.model.Employee;
public interface EmployeeDao {
void saveEmployee(Employee employee);
List<Employee> findAllEmployees();
void deleteEmployeeBySsn(String ssn);
Employee findBySsn(String ssn);
void updateEmployee(Employee employee);
}
com.websystique.spring.dao.EmployeeDaoImpl
package com.websystique.spring.dao; import java.util.List; import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository; import com.websystique.spring.model.Employee; @Repository("employeeDao")
public class EmployeeDaoImpl extends AbstractDao implements EmployeeDao{ public void saveEmployee(Employee employee) {
persist(employee);
} @SuppressWarnings("unchecked")
public List<Employee> findAllEmployees() {
Criteria criteria = getSession().createCriteria(Employee.class);
return (List<Employee>) criteria.list();
} public void deleteEmployeeBySsn(String ssn) {
Query query = getSession().createSQLQuery("delete from Employee where ssn = :ssn");
query.setString("ssn", ssn);
query.executeUpdate();
} public Employee findBySsn(String ssn){
Criteria criteria = getSession().createCriteria(Employee.class);
criteria.add(Restrictions.eq("ssn",ssn));
return (Employee) criteria.uniqueResult();
} public void updateEmployee(Employee employee){
getSession().update(employee);
} }
步骤五：添加Service层代码
com.websystique.spring.service.EmployeeService
package com.websystique.spring.service;
import java.util.List;
import com.websystique.spring.model.Employee;
public interface EmployeeService {
void saveEmployee(Employee employee);
List<Employee> findAllEmployees();
void deleteEmployeeBySsn(String ssn);
Employee findBySsn(String ssn);
void updateEmployee(Employee employee);
}
com.websystique.spring.service.EmployeeServiceImpl
package com.websystique.spring.service; import java.util.List; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import com.websystique.spring.dao.EmployeeDao;
import com.websystique.spring.model.Employee; @Service("employeeService")
@Transactional
public class EmployeeServiceImpl implements EmployeeService{ @Autowired
private EmployeeDao dao; public void saveEmployee(Employee employee) {
dao.saveEmployee(employee);
} public List<Employee> findAllEmployees() {
return dao.findAllEmployees();
} public void deleteEmployeeBySsn(String ssn) {
dao.deleteEmployeeBySsn(ssn);
} public Employee findBySsn(String ssn) {
return dao.findBySsn(ssn);
} public void updateEmployee(Employee employee){
dao.updateEmployee(employee);
}
}
以上比较引人注目的部分是@Transactional注解，配置了该注解的类会在每个类方法开启事务，并在方法结束的时候提交事务（或者在方法内部出错时回滚事务）。
注意，由于以上事务范围是方法级别的，我们在方法内部使用DAO，DAO方法会在同样的事物内部执行。
步骤六：创建实体类（POJO）
com.websystique.spring.model.Employee
package com.websystique.spring.model; import java.math.BigDecimal; import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table; import org.hibernate.annotations.Type;
import org.joda.time.LocalDate; @Entity
@Table(name="EMPLOYEE")
public class Employee { @Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id; @Column(name = "NAME", nullable = false)
private String name; @Column(name = "JOINING_DATE", nullable = false)
@Type(type="org.jadira.usertype.dateandtime.joda.PersistentLocalDate")
private LocalDate joiningDate; @Column(name = "SALARY", nullable = false)
private BigDecimal salary; @Column(name = "SSN", unique=true, nullable = false)
private String ssn; public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public LocalDate getJoiningDate() {
return joiningDate;
} public void setJoiningDate(LocalDate joiningDate) {
this.joiningDate = joiningDate;
} public BigDecimal getSalary() {
return salary;
} public void setSalary(BigDecimal salary) {
this.salary = salary;
} public String getSsn() {
return ssn;
} public void setSsn(String ssn) {
this.ssn = ssn;
} @Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((ssn == null) ? 0 : ssn.hashCode());
return result;
} @Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Employee))
return false;
Employee other = (Employee) obj;
if (id != other.id)
return false;
if (ssn == null) {
if (other.ssn != null)
return false;
} else if (!ssn.equals(other.ssn))
return false;
return true;
} @Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", joiningDate="
+ joiningDate + ", salary=" + salary + ", ssn=" + ssn + "]";
} }
这是一个标准的实体类，基于JPA注解@Entity, @Table, @Column以及hibernate注解@Type（用于提供数据库类型与Joda-Time LocalDate的映射）。
步骤七：在数据库里创建Schema
CREATE TABLE EMPLOYEE(
id INT NOT NULL auto_increment,
name VARCHAR(50) NOT NULL,
joining_date DATE NOT NULL,
salary DOUBLE NOT NULL,
ssn VARCHAR(30) NOT NULL UNIQUE,
PRIMARY KEY (id)
);
步骤八：创建main方法执行程序
package com.websystique.spring; import java.math.BigDecimal;
import java.util.List; import org.joda.time.LocalDate;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext; import com.websystique.spring.configuration.AppConfig;
import com.websystique.spring.model.Employee;
import com.websystique.spring.service.EmployeeService; public class AppMain { public static void main(String args[]) {
AbstractApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); EmployeeService service = (EmployeeService) context.getBean("employeeService"); /*
* Create Employee1
*/
Employee employee1 = new Employee();
employee1.setName("Han Yenn");
employee1.setJoiningDate(new LocalDate(2010, 10, 10));
employee1.setSalary(new BigDecimal(10000));
employee1.setSsn("ssn00000001"); /*
* Create Employee2
*/
Employee employee2 = new Employee();
employee2.setName("Dan Thomas");
employee2.setJoiningDate(new LocalDate(2012, 11, 11));
employee2.setSalary(new BigDecimal(20000));
employee2.setSsn("ssn00000002"); /*
* Persist both Employees
*/
service.saveEmployee(employee1);
service.saveEmployee(employee2); /*
* Get all employees list from database
*/
List<Employee> employees = service.findAllEmployees();
for (Employee emp : employees) {
System.out.println(emp);
} /*
* delete an employee
*/
service.deleteEmployeeBySsn("ssn00000002"); /*
* update an employee
*/ Employee employee = service.findBySsn("ssn00000001");
employee.setSalary(new BigDecimal(50000));
service.updateEmployee(employee); /*
* Get all employees list from database
*/
List<Employee> employeeList = service.findAllEmployees();
for (Employee emp : employeeList) {
System.out.println(emp);
} context.close();
}
}
注意，假如你想删除AppConfig文件，那么只需将
AbstractApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
替换为
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();context.scan("com.websystique.spring"); context.refresh();Employee [id=1, name=Han Yenn, joiningDate=2010-10-10, salary=10000, ssn=ssn00000001]
Employee [id=2, name=Dan Thomas, joiningDate=2012-11-11, salary=20000, ssn=ssn00000002]
Employee [id=1, name=Han Yenn, joiningDate=2010-10-10, salary=50000, ssn=ssn00000001]
工程代码
http://websystique.com/?smd_process_download=1&download_id=802
注：源码EmployeeDaoImpl类中有一处错误，将26行表名Employee改成EMPLOYEE即可。
【译】Spring 4 + Hibernate 4 + Mysql + Maven集成例子（注解 + XML）的更多相关文章
- Spring 4 MVC+Hibernate 4+MySQL+Maven使用注解集成实例
Spring 4 MVC+Hibernate 4+MySQL+Maven使用注解集成实例 转自:通过注解的方式集成Spring 4 MVC+Hibernate 4+MySQL+Maven,开发项目样例 ...
- Spring第12篇—— Spring对Hibernate的SessionFactory的集成功能
由于Spring和Hibernate处于不同的层次,Spring关心的是业务逻辑之间的组合关系,Spring提供了对他们的强大的管理能力, 而Hibernate完成了OR的映射,使开发人员不用再去关心 ...
- Spring3 + Spring MVC+ Mybatis 3+Mysql 项目整合（注解及源码）
Spring3 + Spring MVC+ Mybatis 3+Mysql 项目整合(注解及源码) 备注: 之前在Spring3 + Spring MVC+ Mybatis 3+Mysql 项目整合中 ...
- spring+struts2+hibernate框架搭建(Maven工程)
搭建Spring 1.porm.xml中添加jar包 <!-- spring3 --> <dependency> <groupId>org.springframew ...
- spring+springmvc+hibernate架构、maven分模块开发样例小项目案例
maven分模块开发样例小项目案例 spring+springmvc+hibernate架构 以用户管理做測试,分dao,sevices,web层,分模块开发測试!因时间关系.仅仅測查询成功.其它的准 ...
- Spring和Hibernate结合的一个小例子
1.新建一个SpringHibernate的maven项目 2.pom文件的依赖为 <dependency> <groupId>junit</groupId> &l ...
- Spring Boot （五）Spring Data JPA 操作 MySQL 8
一.Spring Data JPA 介绍 JPA(Java Persistence API)Java持久化API,是 Java 持久化的标准规范,Hibernate是持久化规范的技术实现,而Sprin ...
- Spring MVC Hibernate MySQL Integration（集成） CRUD Example Tutorial【摘】
Spring MVC Hibernate MySQL Integration(集成) CRUD Example Tutorial We learned how to integrate Spring ...
- Maven+Spring+Hibernate+Shiro+Mysql简单的demo框架(二)
然后是项目下的文件:完整的项目请看 上一篇 Maven+Spring+Hibernate+Shiro+Mysql简单的demo框架(一) 项目下的springmvc-servlet.xml配置文件: ...
随机推荐
- BCL中String.Join的实现
在开发中,有时候会遇到需要把一个List对象中的某个字段用一个分隔符拼成一个字符串的情况.比如在SQL语句的in条件中,我们通常需要把List<int>这样的对象转换为“1,2,3”这样的 ...
- EasyPR--开发详解（4）形态学操作、尺寸验证、旋转等操作
在上一篇深度分析与调优讨论中,我们介绍了高斯模糊,灰度化和Sobel算子.在本文中,会分析剩余的定位步骤. 根据前文的内容,车牌定位的功能还剩下如下的步骤,见下图中未涂灰的部分. 图1 车牌定位步骤 ...
- 每日设置Bing首页图片为壁纸
闲来无事,手痒痒要做一个什么小工具. 于是乎便有了本文. 当有一个想法的时候,首先免不了网上搜索一番以便看一下有木有网友有过类似的想法. 很显然--有! 因此本文大代码是从几个地方搜索,然后组合的. ...
- svn diff 详解
UI版: 如果多人编辑同一段代码,常常容易出现冲突的情况: 如果出现冲突,我们如何解决他呢? 1 可以选择使用自己的文件mime file,也可以使用 他们的文件 their file 2 解决冲突, ...
- javascript学习之BOM
BOM是browser object model的缩写,简称浏览器对象模型.先看看下面这张图 window对象是BOM的顶层(核心)对象,所有对象都是通过它延伸出来的,也可以称为window的子对象. ...
- golang-web框架revel一个表单提交的总结
这里要介绍好是revel框架的表单post提交的列子,主要是用于入门学习,和一些知识点的讲解: 首先: 来了解一个问题那就是重复提交表单,做过form表单提交的同学都知道,如果表单提交后不做处理,那么 ...
- ITTC数据挖掘平台介绍（七）强化的数据库， 虚拟化，脚本编辑器
一. 前言 好久没有更新博客了,最近一直在忙着找工作,目前差不多尘埃落定.特别期待而且准备的都很少能成功,反而是没怎么在意的最终反而能拿到,真是神一样的人生. 言归正传,一直以来,数据挖掘系统的数据类 ...
- spring boot(七)：springboot+mybatis多数据源最简解决方案
说起多数据源,一般都来解决那些问题呢,主从模式或者业务比较复杂需要连接不同的分库来支持业务.我们项目是后者的模式,网上找了很多,大都是根据jpa来做多数据源解决方案,要不就是老的spring多数据源解 ...
- PowerShell 操作 Azure SQL Active Geo-Replication 实战
<Azure SQL Database Active Geo-Replication简介>一文中,我们比较全面的介绍了 Azure SQL Database Active Geo-Repl ...
- Nginx最大客户连接数算法一些遐想
Nginx最大客户连接数算法一些遐想 现在很多互联网公司都在使用nginx,并且替换掉以前的Apache,nginx的优点就不说了,浅聊两句nginx的某些配置参数,找到这些参数设置的目的和关联性,并 ...