HikariCP简介（）：
It&s Faster.
There is nothing&. There is nothing more&. HikariCP is a &zero-overhead& production-quality connection pool.
Using a stub-JDBC implementation to isolate and measure the overhead of HikariCP, comparative benchmarks were performed on a commodity PC. The next fastest connection pool was BoneCP.
Maven Repository
&dependency&
&groupId&com.zaxxer&/groupId&
&artifactId&HikariCP&/artifactId&
&version&1.3.8&/version&
&scope&compile&/scope&
&/dependency&
Initialization and Configuration
See the&&for initialization examples.
You can find information about the&.
Google discussion group&.
Requirements
Java 6 and above
Javassist 3.18.1+ library
slf4j library
一、项目整体布局(为了区分HikariCP依赖的jar包，jar包都以Hikari-1.3.8-为前缀)。
二、测试的类,HikariCPSpring.java
三、日志打印文件,log4j.properties
四、Springle的配置文件
阅读(...) 评论()Spring Boot JDBC + MySQL + HikariCP example
| February 12, 2017 | Updated : February 15, 2017 | Viewed : 17,595 times +1,228 pv/w
In this article, we will show you how to create a Spring Boot JDBC application + MySQL and HikariCP.
Tools used in this article :
Spring Boot 1.5.1.RELEASE
MySQL 5.7.x
HikariCP 2.6
Related –
1. Project Structure
A standard Maven project structure.
2. Project Dependency
Declares a spring-boot-starter-jdbc for JDBC application.
&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/maven-v4_0_0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&com.mkyong&/groupId&
&artifactId&spring-boot-jdbc&/artifactId&
&packaging&jar&/packaging&
&version&1.0&/version&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.5.1.RELEASE&/version&
&properties&
&java.version&1.8&/java.version&
&/properties&
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter&/artifactId&
&/dependency&
&!-- exclude tomcat jdbc connection pool, use HikariCP --&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-jdbc&/artifactId&
&exclusions&
&exclusion&
&groupId&org.apache.tomcat&/groupId&
&artifactId&tomcat-jdbc&/artifactId&
&/exclusion&
&/exclusions&
&/dependency&
&!-- exclude tomcat-jdbc, Spring Boot will use HikariCP automatically
&dependency&
&groupId&com.zaxxer&/groupId&
&artifactId&HikariCP&/artifactId&
&version&2.6.0&/version&
&/dependency&
&!-- For MySQL --&
&dependency&
&groupId&mysql&/groupId&
&artifactId&mysql-connector-java&/artifactId&
&version&5.1.40&/version&
&/dependency&
&/dependencies&
&!-- Package as an executable jar/war --&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
&/project&
$ mvn dependency:tree
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------------
[INFO] Building spring-boot-jdbc 1.0
[INFO] ------------------------------------------------------------------------
[INFO] --- maven-dependency-plugin:2.10:tree (default-cli) @ spring-boot-jdbc ---
[INFO] com.mkyong:spring-boot-jdbc:jar:1.0
[INFO] +- org.springframework.boot:spring-boot-starter:jar:1.5.1.RELEASE:compile
+- org.springframework.boot:spring-boot:jar:1.5.1.RELEASE:compile
\- org.springframework:spring-context:jar:4.3.6.RELEASE:compile
+- org.springframework:spring-aop:jar:4.3.6.RELEASE:compile
\- org.springframework:spring-expression:jar:4.3.6.RELEASE:compile
+- org.springframework.boot:spring-boot-autoconfigure:jar:1.5.1.RELEASE:compile
+- org.springframework.boot:spring-boot-starter-logging:jar:1.5.1.RELEASE:compile
+- ch.qos.logback:logback-classic:jar:1.1.9:compile
\- ch.qos.logback:logback-core:jar:1.1.9:compile
+- org.slf4j:jcl-over-slf4j:jar:1.7.22:compile
+- org.slf4j:jul-to-slf4j:jar:1.7.22:compile
\- org.slf4j:log4j-over-slf4j:jar:1.7.22:compile
+- org.springframework:spring-core:jar:4.3.6.RELEASE:compile
\- org.yaml:snakeyaml:jar:1.17:runtime
[INFO] +- org.springframework.boot:spring-boot-starter-jdbc:jar:1.5.1.RELEASE:compile
\- org.springframework:spring-jdbc:jar:4.3.6.RELEASE:compile
+- org.springframework:spring-beans:jar:4.3.6.RELEASE:compile
\- org.springframework:spring-tx:jar:4.3.6.RELEASE:compile
[INFO] +- com.zaxxer:HikariCP:jar:2.6.0:compile
\- org.slf4j:slf4j-api:jar:1.7.22:compile
[INFO] \- mysql:mysql-connector-java:jar:5.1.40:compile
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.164 s
[INFO] Finished at: T23:42:47+08:00
[INFO] Final Memory: 20M/309M
[INFO] ------------------------------------------------------------------------
Database Connection Pooling
Spring Boot uses Tomcat pooling tomcat-jdbc by default, and follow this sequence to find the connection pool :
Tomcat pool --&& - HikariCP --&&
Commons DBCP --&&
Commons DBCP2
Read this official Spring Boot doc –
3. JdbcTemplate
3.1 Spring Boot will register a JdbcTemplate bean automatically, injects it via @Autowired
CustomerRepository.java
package com.mkyong.
import com.mkyong.model.C
import org.springframework.beans.factory.annotation.A
import org.springframework.jdbc.core.JdbcT
import org.springframework.stereotype.R
import java.util.D
import java.util.L
@Repository
public class CustomerRepository {
@Autowired
private JdbcTemplate jdbcT
// Find all customers, thanks Java 8, you can create a custom RowMapper like this :
public List&Customer& findAll() {
List&Customer& result = jdbcTemplate.query(
"SELECT id, name, email, created_date FROM customer",
(rs, rowNum) -& new Customer(rs.getInt("id"),
rs.getString("name"), rs.getString("email"), rs.getDate("created_date"))
// Add new customer
public void addCustomer(String name, String email) {
jdbcTemplate.update("INSERT INTO customer(name, email, created_date) VALUES (?,?,?)",
name, email, new Date());
3.2 Customer Model.
Customer.java
package com.mkyong.
import java.util.D
public class Customer {
public Customer(int id, String name, String email, Date date) {
this.name =
this.email =
this.date =
//getters and setters and toString...
4. Database Initialization
Spring boot enables the dataSource initializer by default and loads SQL scripts (schema.sql and data.sql) from the root of the classpath.
4.1 Create a customer table.
schema.sql
DROP TABLE IF EXISTS
CREATE TABLE customer (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
email VARCHAR(100) NOT NULL,
created_date DATE NOT NULL,
PRIMARY KEY (id));
4.2 Insert 3 rows into the customer table.
INSERT INTO customer(name,email,created_date)VALUES('mkyong','111@yahoo.com', '');
INSERT INTO customer(name,email,created_date)VALUES('yflow','222@yahoo.com', '');
INSERT INTO customer(name,email,created_date)VALUES('zilap','333@yahoo.com', '');
For detail, please refer to this official article –
4.3 To log the SQL scripts above, enable debug for org.springframework.jdbc
logback.xml
&?xml version="1.0" encoding="UTF-8"?&
&configuration&
&statusListener class="ch.qos.logback.core.status.NopStatusListener" /&
&appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"&
&layout class="ch.qos.logback.classic.PatternLayout"&
%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n
&/Pattern&
&/appender&
&logger name="org.springframework.jdbc" level="error" additivity="false"&
&appender-ref ref="STDOUT"/&
&logger name="com.mkyong" level="error" additivity="false"&
&appender-ref ref="STDOUT"/&
&root level="error"&
&appender-ref ref="STDOUT"/&
&/configuration&
5. Configuration
Configure MySQL and .
application.properties
#disbale Spring banner
spring.main.banner-mode=off
# Loads SQL scripts? schema.sql and data.sql
#spring.datasource.initialize=true
spring.datasource.url=jdbc:mysql://localhost/mkyong?useSSL=false
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# HikariCP settings
# spring.datasource.hikari.*
spring.datasource.hikari.connection-timeout=60000
spring.datasource.hikari.maximum-pool-size=5
6. @SpringBootApplication
Spring Boot console or CommandLineRunner application, accept arguments to perform either “display” or “insert” function.
SpringBootConsoleApplication.java
package com.
import com.mkyong.dao.CustomerR
import com.mkyong.model.C
import org.springframework.beans.factory.annotation.A
import org.mandLineR
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.SpringBootA
import javax.sql.DataS
import java.util.L
import static java.lang.System.
@SpringBootApplication
public class SpringBootConsoleApplication implements CommandLineRunner {
@Autowired
DataSource dataS
@Autowired
private CustomerRepository customerR
public static void main(String[] args) throws Exception {
SpringApplication.run(SpringBootConsoleApplication.class, args);
public void run(String... args) throws Exception {
System.out.println("DATASOURCE = " + dataSource);
// If you want to check the HikariDataSource settings
//HikariDataSource newds = (HikariDataSource)dataS
//System.out.println("DATASOURCE = " + newds.getMaximumPoolSize());
if (args.length &= 0) {
System.err.println("[Usage] java xxx.jar {insert name email | display}");
if (args[0].equalsIgnoreCase("insert")) {
System.out.println("Add customer...");
String name = args[1];
String email = args[2];
customerRepository.addCustomer(name, email);
if (args[0].equalsIgnoreCase("display")) {
System.out.println("Display all customers...");
List&Customer& list = customerRepository.findAll();
list.forEach(x -& System.out.println(x));
System.out.println("Done!");
$ mvn package
# 1. The database is initialized, the table is created, data is inserted
$ java -jar target/spring-boot-jdbc-1.0.jar
DATASOURCE = HikariDataSource (HikariPool-1)
[Usage] java xxx.jar {insert name email | display}
# 2. Disable database initialize process, and insert a new customer
$ java -Dspring.datasource.initialize=false -jar target/spring-boot-jdbc-1.0.jar insert newUser newPassword
DATASOURCE = HikariDataSource (null)
Add customer...
# 3. Display all customers
$ java -Dspring.datasource.initialize=false -jar target/spring-boot-jdbc-1.0.jar display
DATASOURCE = HikariDataSource (null)
Display all customers...
Customer{id=1, name='mkyong', email='111@yahoo.com', date=}
Customer{id=2, name='yflow', email='222@yahoo.com', date=}
Customer{id=3, name='zilap', email='333@yahoo.com', date=}
Customer{id=4, name='newUser', email='newPassword', date=}
Download Source Code
Download –
References
Share this article on
About the Author
Founder of , love Java and open source stuff. Follow him on , or befriend him on
or . If you like my tutorials, consider make a donation to .
Related Posts
Popular Posts
Loading...
Sort by: &
| most votedspring boot 4--访问数据库 - 简书
spring boot 4--访问数据库
Spring框架为使用SQL数据库提供了广泛的支持。从使用JdbcTemplate直接访问JDBC到完全的对象关系映射技术，比如Hibernate。Spring Data提供一个额外的功能，直接从接口创建Repository实现，并使用约定从你的方法名生成查询。
配置DataSourceJava的javax.sql.DataSource接口提供了一个标准的使用数据库连接的方法。传统做法是，一个DataSource使用一个URL连同相应的证书去初始化一个数据库连接。
对内嵌数据库的支持开发应用时使用内存数据库是很实用的。显而易见地，内存数据库不需要提供持久化存储。你不需要在应用启动时填充数据库，也不需要在应用结束时丢弃数据。
Spring Boot可以自动配置的内嵌数据库包括H2, HSQL和Derby。你不需要提供任何连接URLs，只需要简单的添加你想使用的内嵌数据库依赖。
示例：典型的POM依赖如下：
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-data-jpa&/artifactId&&/dependency&
&dependency&
&groupId&org.hsqldb&/groupId&
&artifactId&hsqldb&/artifactId&
&scope&runtime&/scope&&/dependency&注：对于自动配置的内嵌数据库，你需要依赖spring-jdbc。在示例中，它通过spring-boot-starter-data-jpa被传递地拉过来了。
连接到一个生产环境数据库在生产环境中，数据库连接可以使用DataSource池进行自动配置。下面是选取一个特定实现的算法：
由于Tomcat数据源连接池的性能和并发，在tomcat可用时，我们总是优先使用它。如果HikariCP可用，我们将使用它。如果Commons DBCP可用，我们将使用它，但在生产环境不推荐使用它。最后，如果Commons DBCP2可用，我们将使用它。如果你使用spring-boot-starter-jdbc或spring-boot-starter-data-jpa 'starter POMs'，你将会自动获取对tomcat-jdbc的依赖。
DataSource配置通过外部配置文件的spring.datasource.*属性控制。示例中，你可能会在application.properties中声明下面的片段：
spring.datasource.url=jdbc:mysql://localhost/testspring.datasource.username=dbuserspring.datasource.password=dbpassspring.datasource.driver-class-name=com.mysql.jdbc.Driver其他可选的配置可以查看DataSourceProperties。同时注意你可以通过spring.datasource.*配置任何DataSource实现相关的特定属性：具体参考你使用的连接池实现的文档。
注：既然Spring Boot能够从大多数数据库的url上推断出driver-class-name，那么你就不需要再指定它了。对于一个将要创建的DataSource连接池，我们需要能够验证Driver是否可用，所以我们会在做任何事情之前检查它。比如，如果你设置spring.datasource.driverClassName=com.mysql.jdbc.Driver，然后这个类就会被加载。
连接到一个JNDI数据库如果正在将Spring Boot应用部署到一个应用服务器，你可能想要用应用服务器内建的特性来配置和管理你的DataSource，并使用JNDI访问它。
spring.datasource.jndi-name属性可以用来替代spring.datasource.url，spring.datasource.username和spring.datasource.password去从一个特定的JNDI路径访问DataSource。比如，下面application.properties中的片段展示了如何获取JBoss定义的DataSource：
spring.datasource.jndi-name=java:jboss/datasources/customers
使用JdbcTemplateSpring的JdbcTemplate和NamedParameterJdbcTemplate类是被自动配置的，你可以在自己的beans中通过@Autowire直接注入它们。
import org.springframework.beans.factory.annotation.A
import org.springframework.jdbc.core.JdbcT
import org.
@Component
public class MyBean {
private final JdbcTemplate jdbcT
@Autowired
public MyBean(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcT
JPA和Spring DataJava持久化API是一个允许你将对象映射为关系数据库的标准技术。spring-boot-starter-data-jpa POM提供了一种快速上手的方式。它提供下列关键的依赖：
Hibernate - 一个非常流行的JPA实现。Spring Data JPA - 让实现基于JPA的repositories更容易。Spring ORMs - Spring框架的核心ORM支持。
实体类传统上，JPA实体类被定义到一个persistence.xml文件中。在Spring Boot中，这个文件不是必需的，并被'实体扫描'替代。默认情况下，在你主（main）配置类（被@EnableAutoConfiguration或@SpringBootApplication注解的类）下的所有包都将被查找。
任何被@Entity，@Embeddable或@MappedSuperclass注解的类都将被考虑。一个普通的实体类看起来像下面这样：
package com.example.myapp.
import java.io.Simport javax.persistence.*;
@Entitypublic class City implements Serializable {
@Id@GeneratedValueprivate L
@Column(nullable = false)private S
@Column(nullable = false)private S
// ... additional members, often include @OneToMany mappings
protected City() {
// no-args constructor required by JPA spec
// this one is protected since it shouldn't be used directly}
public City(String name, String state) {
this.name =
this.country =}
public String getName() {
return this.}
public String getState() {
return this.}// ... etc}注：你可以使用@EntityScan注解自定义实体扫描路径。
Spring Data JPA仓库Spring Data JPA仓库（repositories）是用来定义访问数据的接口。根据你的方法名，JPA查询会被自动创建。比如，一个CityRepository接口可能声明一个findAllByState(String state)方法，用来查找给定状态的所有城市。
对于比较复杂的查询，你可以使用Spring Data的Query来注解你的方法。
Spring Data仓库通常继承自Repository或CrudRepository接口。如果你使用自动配置，包括在你的主配置类（被@EnableAutoConfiguration或@SpringBootApplication注解的类）的包下的仓库将会被搜索。
下面是一个传统的Spring Data仓库：
package com.example.myapp.
import org.springframework.data.domain.*;
import org.springframework.data.repository.*;
public interface CityRepository extends Repository&City, Long& {
Page&City& findAll(Pageable pageable);
City findByNameAndCountryAllIgnoringCase(String name, String country);
创建和删除JPA数据库默认情况下，只有在你使用内嵌数据库（H2, HSQL或Derby）时，JPA数据库才会被自动创建。你可以使用spring.jpa.*属性显示的设置JPA。比如，为了创建和删除表你可以将下面的配置添加到application.properties中：
spring.jpa.hibernate.ddl-auto=create-drop注：Hibernate自己内部对创建，删除表支持（如果你恰好记得这回事更好）的属性是hibernate.hbm2ddl.auto。使用spring.jpa.properties.*（前缀在被添加到实体管理器之前会被剥离掉），你可以设置Hibernate本身的属性，比如hibernate.hbm2ddl.auto。示例：spring.jpa.properties.hibernate.globally_quoted_identifiers=true将传递hibernate.globally_quoted_identifiers到Hibernate实体管理器。
默认情况下，DDL执行（或验证）被延迟到ApplicationContext启动。这也有一个spring.jpa.generate-ddl标识，如果Hibernate自动配置被激活，那该标识就不会被使用，因为ddl-auto设置粒度更细。
专注java与web技术的研究，关注程序员的发展.
微信公众号: java技术
个人博客：
技术交流群:
java就业方向从零自学视频教程
百度传课：/s3377987.html
QQ课堂：https://bumishi.maven配置 Spring mvc我使用4.1.6，其对应的jpa版本为：Spring mvc我使用4.1.6，其对应的jpa版本为1.9.0.M1(不然mvc的一些方法，在jpa上使用不了，导致加载错误之类)： &dependency&
&groupId&org.springframework.data&/groupId&
&artifactId&spring-data-jpa&/artifactId&
&version&1.9.0.M1&/version&
&/dependency&
&dependency&
&groupId&com.zaxxer&/groupId&
&artifactId&HikariCP-java6&/artifactId&
&version&2.2.5&/version&
&/dependency&
&dependency&
&groupId&org.hibernate&/groupId&
&artifactId&hibernate-entitymanager&/artifactId&
&version&4.3.10.Final&/version&
&/dependency& data-access.properties （数据库配置） abc.jdbc.driverClassName=com.mysql.jdbc.Driver
abc.jdbc.url=jdbc:mysql://localhost:3306/test?autoReconnect=true&characterEncoding=utf-8
abc.user=xxx
abc.password=xxxx
abc.maxActive=10 datasource-config.xml （数据库连接池配置） &!-- HikariCP 高性能数据库连接池 --&
&bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig"&
&property name="poolName" value="springHikariCP" /&
&property name="maximumPoolSize" value="7" /&
&property name="idleTimeout" value="30000" /&
&property name="connectionTimeout" value="120000" /&
&property name="jdbcUrl" value="${uadb.jdbc.url}" /&
&property name="username" value="${uadb.user}" /&
&property name="password" value="${uadb.password}" /&
&property name="driverClassName" value="${uadb.jdbc.driverClassName}" /&
&!-- HikariCP configuration --&
&bean id="dataSourceMySql" class="com.zaxxer.hikari.HikariDataSource"
destroy-method="close"&
&constructor-arg ref="hikariConfig" /&
applicationcontext.xml（部分重要配置） &context:property-placeholder location="classpath:data-access.properties" /&
&context:component-scan base-package="com.test.devel.*" /&
&import resource="datasource-config.xml" /&
&!-- 数据库相关 --&
&tx:annotation-driven transaction-manager="transactionManager" /&
&bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"&
&property name="entityManagerFactory" ref="entityManagerFactory" /&
&bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"&
&property name="dataSource"&
&ref bean="dataSourceMySql" /& &!--指定数据库连接池--&
&/property&
&property name="jpaVendorAdapter"&
&bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"&
&property name="generateDdl" value="false" /&
&property name="showSql" value="true" /&
&property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" /&
&/property&
&property name="jpaProperties"&
&prop key="hibernate.cache.use_second_level_cache"&false&/prop&&!-- 二级缓存 --&
&prop key="hibernate.cache.provider_class"&org.hibernate.cache.internal.NoCacheProvider&/prop&
&prop key="hibernate.format_sql"&true&/prop&
&!-- &prop key="hibernate.cache.provider_class"&net.sf.ehcache.hibernate.EhCacheProvider&/prop&
&prop key="hibernate.cache.region.factory_class"&org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory&/prop& --&
&/property&
&property name="packagesToScan" value="com.test.devel.repositories.entity"/&
&jpa:repositories base-package="com.test.devel.repositories.*" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="transactionManager" /&
Entity: @Entity(name="develConfig")
@Table(name = "devel_config")
public class DevelConfig {
@Column(name = "config_id")
@GeneratedValue(strategy = GenerationType.AUTO)
private int configId;
@Column(name = "config_key")
private String configK
@Column(name = "config_value")
private String configV
@Column(name = "config_des")
private String configD
public int getConfigId() {
return configId;
public void setConfigId(int configId) {
this.configId = configId;
public String getConfigKey() {
return configK
public void setConfigKey(String configKey) {
this.configKey = configK
public String getConfigValue() {
return configV
public void setConfigValue(String configValue) {
this.configValue = configV
public String getConfigDes() {
return configD
public void setConfigDes(String configDes) {
this.configDes = configD
public String toString() {
return "DevelConfig [configId=" + configId + ", configKey=" + configKey + ", configValue=" + configValue
+ ", configDes=" + configDes + "]";
Dao: @Transactional(readOnly = true)
public interface DevelConfigDao extends Repository&DevelConfig, Long&{
public List&DevelConfig& findByConfigId(int configId);
public List&DevelConfig& findAll();
@Query("select a from develConfig a where a.configId = ?1 and a.configKey = ?2")
public List&DevelConfig& findmyQuery(int configId, String configKey);
Test @RunWith(SpringJUnit4ClassRunner.class )
@ContextConfiguration(locations= "classpath:applicationcontext.xml")
@Transactional
public class TestDevelConfig {
@Autowired
DevelConfigDao develConfigD
public void setUp() {
public void query() {
List&DevelConfig& list = develConfigDao.findAll();
for (DevelConfig develConfig : list) {
System.out.println(develConfig.toString());
public void findConfigById(){
List&DevelConfig& list = develConfigDao.findByConfigId(1);
for (DevelConfig develConfig : list) {
System.out.println(develConfig.toString());
public void findByConfigIdAndConfigKey(){
List&DevelConfig& list = develConfigDao.findmyQuery(1, "SVN_COUNT_URL");
for (DevelConfig develConfig : list) {
System.out.println(develConfig.toString());
如果您想留下此文，您可以将其发送至您的邮箱(将同时以邮件内容&PDF形式发送)
相关文章推荐
(Ctrl+Enter提交) &&
已有0人在此发表见解
&在& 08:15收藏到了
&&在信息爆炸的时代，您的知识需要整理，沉淀，积累！Lai18为您提供一个简单实用的文章整理收藏工具，在这里您可以收藏对您有用的技术文章，自由分门别类，在整理的过程中，用心梳理自己的知识！相信，用不了多久，您收藏整理的文章将是您一生的知识宝库！
· 蜀ICP备号-1