spring Boot构建的Web应用中，基于MySQL数据库的几种数据库连接方式进行介绍

包括JDBC、JPA、MyBatis、多数据源和事务。

一、JDBC 连接数据库

1、属性配置文件（application.properties）

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

如果使用JNDI，则可以替代 spring.datasource 的 url、username、password，如：

spring.datasource.jndi-name=java:tomcat/datasources/example

值得一提的是，无论是Spring Boot默认的DataSource配置还是你自己的DataSource bean，都会引用到外部属性文件中的属性配置。所以假设你自定义的DataSource bean，你可以在定义bean时设置属性，也可以在属性文件中，以“spring.datasource.*”的方式使属性配置外部化。

2、pom.xml 配置maven依赖

        <!-- MYSQL -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
         </dependency>
         <!-- Spring Boot JDBC -->
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
          </dependency>

3、Java代码范例

StudentService.java

package org.springboot.sample.service;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springboot.sample.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;

@Service
public class StudentService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<Student> getList(){
        String sql = "SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE   FROM STUDENT";
        return (List<Student>) jdbcTemplate.query(sql, new RowMapper<Student>(){

            @Override
            public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
                Student stu = new Student();
                stu.setId(rs.getInt("ID"));
                stu.setAge(rs.getInt("AGE"));
                stu.setName(rs.getString("NAME"));
                stu.setSumScore(rs.getString("SCORE_SUM"));
                stu.setAvgScore(rs.getString("SCORE_AVG"));
                return stu;
            }

        });
    }
}

Student.java 实体类

package org.springboot.sample.entity;

import java.io.Serializable;

public class Student implements Serializable{

    private static final long serialVersionUID = 2120869894112984147L;

    private int id;
    private String name;
    private String sumScore;
    private String avgScore;
    private int age;

    // 节省文章长度，get set 方法省略
}

StudentController.java

package org.springboot.sample.controller;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springboot.sample.entity.Student;
import org.springboot.sample.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/stu")
public class StudentController {

    private static final Logger logger = LoggerFactory.getLogger(StudentController.class);

    @Autowired
    private StudentService studentService;

    @RequestMapping("/list")
    public List<Student> getStus(){
        logger.info("从数据库读取Student集合");
        return studentService.getList();
    }
}

本文对工程添加文件后工程结构图： 

然后启动项目，访问地址： http://localhost:8080/myspringboot/stu/list 响应结果如下：

[
{
id: 1,
name: "小明",
sumScore: "252",
avgScore: "84",
age: 1
},
{
id: 2,
name: "小王",
sumScore: "187",
avgScore: "62.3",
age: 1
},
{
id: 3,
name: "莉莉",
sumScore: "",
avgScore: "",
age: 0
},
{
id: 4,
name: "柱子",
sumScore: "230",
avgScore: "76.7",
age: 1
},
{
id: 5,
name: "大毛",
sumScore: "",
avgScore: "",
age: 0
},
{
id: 6,
name: "亮子",
sumScore: "0",
avgScore: "0",
age: 1
}

连接池说明

Tomcat7之前，Tomcat本质应用了DBCP连接池技术来实现的JDBC数据源，但在Tomcat7之后，Tomcat提供了新的JDBC连接池方案，作为DBCP的替换或备选方案，解决了许多之前使用DBCP的不利之处，并提高了性能。详细请参考：http://wiki.jikexueyuan.com/project/tomcat/tomcat-jdbc-pool.html

Spring Boot为我们准备了最佳的数据库连接池方案，只需要在属性文件（例如application.properties）中配置需要的连接池参数即可。 
我们使用Tomcat数据源连接池，需要依赖tomcat-jdbc，只要应用中添加了spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa依赖，则无需担心这点，因为将会自动添加 tomcat-jdbc 依赖。 
假如我们想用其他方式的连接池技术，只要配置自己的DataSource bean，即可覆盖Spring Boot的自动配置。

请看我的数据源配置：

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.max-idle=10
spring.datasource.max-wait=10000
spring.datasource.min-idle=5
spring.datasource.initial-size=5
spring.datasource.validation-query=SELECT 1
spring.datasource.test-on-borrow=false
spring.datasource.test-while-idle=true
spring.datasource.time-between-eviction-runs-millis=18800
spring.datasource.jdbc-interceptors=ConnectionState;SlowQueryReport(threshold=0)

配置过连接池的开发人员对这些属性的意义都有所认识。

我们打开DEBUG日志输出，logback.xml 中添加：

<logger name="org.springframework.boot" level="DEBUG"/>

然后启动项目，注意观察日志输出，如下图中会显示自动启用了连接池： 
 
在上面的数据源配置中添加了过滤器，并设置了延迟时间为0（故意设置很低，实际项目中请修改）：

spring.datasource.jdbc-interceptors=ConnectionState;SlowQueryReport(threshold=0)

这个时候，我们访问 http://localhost:8080/myspringboot/stu/list 观察日志，会发现框架自动将大于该时间的数据查询进行警告输出，如下：

 o.a.t.j.p.interceptor.SlowQueryReport    : Slow Query Report SQL=SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE   FROM STUDENT; time=3 ms;

二、将介绍如何在spring Boot 工程中添加JPA作为持久化方式。

修改 pom.xml 依赖

与上一篇介绍的 jdbc 不同的是 spring-boot-starter-jdbc 修改为 spring-boot-starter-data-jpa 即可，当然数据库驱动包也是不可少的，如下：

 <!-- MYSQL -->
 <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
 </dependency>
 <!-- Spring Boot JPA -->
 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>

注意：如果你想JDBC和JPA可以一起使用，Spring Boot 是支持的，你只需要把JDBC和JPA的依赖都添加在pom.xml 中即可。无需其他特殊处理，有关JDBC的使用介绍请看上一篇 “Spring-Boot JDBC 连接数据库”。

修改属性配置文件

在属性配置文件中添加 JPA 相关属性，注意这些并非必须，我们如果只添加dataSource 的 url\username\password\driver-class-name 也可以正常使用，有关JPA的其他配置都是可选的。

spring.jpa.database=
spring.jpa.show-sql=
spring.jpa.properties=
spring.jpa.generate-ddl=
spring.jpa.open-in-view=
spring.jpa.database-platform=
spring.jpa.hibernate.ddl-auto=
spring.data.jpa.repositories.enabled=
spring.jpa.hibernate.naming-strategy=

熟悉JPA的根据名字应基本知道这些分别的作用了。

传统上，JPA实体类在persistence.xml文件中指定的。使用Spring Boot，这个文件是没有必要的，因为它使用“实体扫描”，默认情况下主配置 @EnableAutoConfiguration 或 @SpringBootApplication 下面的所有包都将会被扫描。任何使用注解 @Entity, @Embeddable 或 @MappedSuperclass 的类都将被管理。

Java代码实例

  • 一个接口
  • 一个Controller

我们创建一个接口 IScoreDao.Java ，然后我们继承框架为我们提供好的接口 Repository 或 CrudRepository （CrudRepository 继承自 Repository），其中为我们提供了对数据库的基本操作方法。

package org.springboot.sample.dao;

import java.util.List;

import javax.transaction.Transactional;

import org.springboot.sample.entity.Score;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

public interface IScoreDao extends CrudRepository<Score, Integer> {

    @Transactional
    @Modifying
    @Query("update Score t set t.score = :score where t.id = :id")
    int updateScoreById(@Param("score") float score, @Param("id") int id);

    @Query("select t from Score t ")
    List<Score> getList();

}

注意，如果你其中使用了修改、新增、删除操作，则必须要在接口上面或者对应的方法上面添加 @Transactional 注解，否则会抛出异常。

实体类 Score.java

package org.springboot.sample.entity;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * 成绩
 *
 */
@Entity
@Table(name = "score")
public class Score implements Serializable {

    private static final long serialVersionUID = 8127035730921338189L;

    @Id
    @GeneratedValue
    private int id;

    @Column(nullable = false, name="STUDENTID") // 这里说一下，我使用指定数据库列的时候，使用小写会不起作用，修改为大写便正常了。不知道为何，如果遇到一样问题的可以尝试下。
    private int stuId;

    @Column(nullable = false, name="SUBJECTNAME")
    private String subjectName;

    @Column(nullable = false)
    private float score;

    @Column(nullable = false, name="EXAMTIME")
    private Date examTime; 

    // 省去get、set 方法（占用文章空间）

}

ScoreController.java

package org.springboot.sample.controller;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springboot.sample.dao.IScoreDao;
import org.springboot.sample.entity.Score;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/score")
public class ScoreController {

    private static final Logger logger = LoggerFactory.getLogger(ScoreController.class);

    @Autowired
    private IScoreDao scoreService;

    @RequestMapping("/scoreList")
    public List<Score> getScoreList(){
        logger.info("从数据库读取Score集合");
        // 测试更新数据库
        logger.info("更新的行数：" + scoreService.updateScoreById(88.8f, 2));
        scoreService.delete(23);

        return scoreService.getList();
    }
}

然后在浏览器访问地址：http://localhost:8080/myspringboot/score/scoreList 测试。


最后要说明的是，Spring 会自动为我们继承CrudRepository接口的接口创建实现类。我们只需要在使用的时候直接使用注解 @Autowired 注入即可（IScoreDao 接口上也没有必要增加 @Component 、 @Repository 等注解）。 
还有，我这里为了简单起见，直接将操作数据库的在Controller中使用，实际项目中，是不建议这样做的，IScoreDao 的所属角色是数据库持久，我们还应当有 Service（如ScoreService） 来调用 IScoreDao 的方法，然后在Controller 中调用 Service 中的方法。原因是因为，我们数据库访问层，都是接口定义方法，上面注解注入SQL和参数，没有具体的代码逻辑处理。如果我们想在执行SQL之前或之后执行逻辑处理，只能在 Service 中或者Controller（不建议）中。 
我们严格按照这种方式去做（持久层只与SQL有关，通过接口定义无逻辑处理），这样才是彻彻底底的持久层。越严格的规范制度，在某种程度上来说其实越有利于代码的管理和项目代码的迭代发展。

当然，如果你实在想要实现自己的 class 实现类，下面会附上一个实例代码，在此之前，我们先看一个图片： 

这个图是Spring 使用动态代理创建的接口实例，可以看出，其使用的是 SimpleJpaRepository 类，所以如果我们实现自己的 Repository ，可以扩展 SimpleJpaRepository 并 实现自己的 factory-class 入手，这里不做详解。注意凡事实现 Repository 接口的实现类都不需要添加 @Repository 注解，否则你会遇到问题。

本文介绍JPA 相比上一篇关于JDBC 的介绍增加的文件工程截图为： 

熟悉其中一种持久数据的方法后，其他类似的都大同小异。

三、SpringBoot种配置MyBatis

其实mybatis官网在2015年11月底就已经发布了对SpringBoot集成的Release版本，Github上有代码：https://github.com/mybatis/mybatis-spring-boot 
前面对JPA和JDBC连接数据库做了说明，本文也是参考官方的代码做个总结。

先说个题外话，SpringBoot默认使用 org.apache.tomcat.jdbc.pool.DataSource 
现在有个叫 HikariCP 的JDBC连接池组件，据说其性能比常用的 c3p0、tomcat、bone、vibur 这些要高很多。 
我打算把工程中的DataSource变更为HirakiDataSource，做法很简单： 
首先在application.properties配置文件中指定dataSourceType

spring.datasource.type=com.zaxxer.hikari.HikariDataSource

然后在pom中添加Hikari的依赖

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <!-- 版本号可以不用指定，Spring Boot会选用合适的版本 -->
</dependency>

言归正传，下面说在spring Boot中配置MyBatis。 
关于在Spring Boot中集成MyBatis，可以选用基于注解的方式，也可以选择xml文件配置的方式。通过对两者进行实际的使用，还是建议使用XML的方式（官方也建议使用XML）。

下面将介绍通过xml的方式来实现查询，其次会简单说一下注解方式，最后会附上分页插件（PageHelper）的集成。

一、通过xml配置文件方式

1、添加pom依赖

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <!-- 请不要使用1.0.0版本，因为还不支持拦截器插件，1.0.1-SNAPSHOT 是博主写帖子时候的版本，大家使用最新版本即可 -->
    <version>1.0.1-SNAPSHOT</version>
</dependency>

2、创建接口Mapper（不是类）和对应的Mapper.xml文件

定义相关方法，注意方法名称要和Mapper.xml文件中的id一致，这样会自动对应上 
StudentMapper.Java

package org.springboot.sample.mapper;

import java.util.List;

import org.springboot.sample.entity.Student;

/**
 * StudentMapper，映射SQL语句的接口，无逻辑实现
 *
 */
public interface StudentMapper extends MyMapper<Student> {

    List<Student> likeName(String name);

    Student getById(int id);

    String getNameById(int id);

}

MyMapper.java

package org.springboot.sample.config.mybatis;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

/**
 * 被继承的Mapper，一般业务Mapper继承它
 *
 */
public interface MyMapper<T> extends Mapper<T>, MySqlMapper<T> {
    //TODO
    //FIXME 特别注意，该接口不能被扫描到，否则会出错
}

StudentMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.springboot.sample.mapper.StudentMapper">

    <!-- type为实体类Student，包名已经配置，可以直接写类名 -->
    <resultMap id="stuMap" type="Student">
        <id property="id" column="id" />
        <result property="name" column="name" />
        <result property="sumScore" column="score_sum" />
        <result property="avgScore" column="score_avg" />
        <result property="age" column="age" />
    </resultMap>

    <select id="getById" resultMap="stuMap" resultType="Student">
        SELECT *
        FROM STUDENT
        WHERE ID = #{id}
    </select>

    <select id="likeName" resultMap="stuMap" parameterType="string" resultType="list">
        SELECT *
        FROM STUDENT
        WHERE NAME LIKE CONCAT(‘%‘,#{name},‘%‘)
    </select>

    <select id="getNameById" resultType="string">
        SELECT NAME
        FROM STUDENT
        WHERE ID = #{id}
    </select>

</mapper>

3、实体类

package org.springboot.sample.entity;

import java.io.Serializable;

/**
 * 学生实体
 *
 */
public class Student implements Serializable{

    private static final long serialVersionUID = 2120869894112984147L;

    private int id;
    private String name;
    private String sumScore;
    private String avgScore;
    private int age;

    // get set 方法省略

}

4、修改application.properties 配置文件

mybatis.mapper-locations=classpath*:org/springboot/sample/mapper/sql/mysql/*Mapper.xml
mybatis.type-aliases-package=org.springboot.sample.entity

5、在Controller或Service调用方法测试


    @Autowired
    private StudentMapper stuMapper;

    @RequestMapping("/likeName")
    public List<Student> likeName(@RequestParam String name){
        return stuMapper.likeName(name);
    }

二、使用注解方式

查看官方Git上的代码使用注解方式，配置上很简单，使用上要对注解多做了解。至于xml和注解这两种哪种方法好，众口难调还是要看每个人吧。

1、启动类（我的）中添加@MapperScan注解

@SpringBootApplication
@MapperScan("sample.mybatis.mapper")
public class SampleMybatisApplication implements CommandLineRunner {

    @Autowired
    private CityMapper cityMapper;

    public static void main(String[] args) {
        SpringApplication.run(SampleMybatisApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(this.cityMapper.findByState("CA"));
    }

}

2、在接口上使用注解定义CRUD语句

package sample.mybatis.mapper;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import sample.mybatis.domain.City;

/**
 * @author Eddú Meléndez
 */
public interface CityMapper {

    @Select("SELECT * FROM CITY WHERE state = #{state}")
    City findByState(@Param("state") String state);

}

其中City就是一个普通Java类。 
关于MyBatis的注解，有篇文章讲的很清楚，可以参考： http://blog.csdn.net/luanlouis/article/details/35780175

三、集成分页插件

这里与其说集成分页插件，不如说是介绍如何集成一个plugin。MyBatis提供了拦截器接口，我们可以实现自己的拦截器，将其作为一个plugin装入到SqlSessionFactory中。 
Github上有位开发者写了一个分页插件，我觉得使用起来还可以，挺方便的。 
Github项目地址： https://github.com/pagehelper/Mybatis-PageHelper

下面简单介绍下： 
首先要说的是，Spring在依赖注入bean的时候，会把所有实现MyBatis中Interceptor接口的所有类都注入到SqlSessionFactory中，作为plugin存在。既然如此，我们集成一个plugin便很简单了，只需要使用@Bean创建PageHelper对象即可。

1、添加pom依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>4.1.0</version>
</dependency>

2、新增MyBatisConfiguration.java

package org.springboot.sample.config;

import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.github.pagehelper.PageHelper;

/**
 * MyBatis 配置
 *
 */
@Configuration
public class MyBatisConfiguration {

    private static final Logger logger = LoggerFactory.getLogger(MyBatisConfiguration.class);

    @Bean
    public PageHelper pageHelper() {
        logger.info("注册MyBatis分页插件PageHelper");
        PageHelper pageHelper = new PageHelper();
        Properties p = new Properties();
        p.setProperty("offsetAsPageNum", "true");
        p.setProperty("rowBoundsWithCount", "true");
        p.setProperty("reasonable", "true");
        pageHelper.setProperties(p);
        return pageHelper;
    }

}

3、分页查询测试

    @RequestMapping("/likeName")
    public List<Student> likeName(@RequestParam String name){
        PageHelper.startPage(1, 1);
        return stuMapper.likeName(name);
    }

更多参数使用方法，详见PageHelper说明文档（上面的Github地址）。

 
时间： 2024-12-15 15:37:39

spring Boot构建的Web应用中，基于MySQL数据库的几种数据库连接方式进行介绍的相关文章

Spring Boot构建的Web项目如何在服务端校验表单输入

本文首发于个人网站:Spring Boot构建的Web项目如何在服务端校验表单输入 这个例子用于演示在Spring Boot应用中如何验证Web 应用的输入,我们将会建立一个简单的Spring MVC应用,来读取用户输入并使用validation注解来检查,并且当用户输入错误时,应用需要再屏幕上显示错误信息提示用户重新输入. 首先构建Maven项目,该项目的pom文件内容如下: <?xml version="1.0" encoding="UTF-8"?>

IOC容器在web容器中初始化——（一）两种配置方式

参考文章http://blog.csdn.net/liuganggao/article/details/44083817,http://blog.csdn.net/u013185616/article/details/52186184. 最近在研究IOC容器在web容器中初始化的过程.阅读了源码,参照了很多文章,在这里记录一下. 使用的web容器为tomcat7.spring的jar包为4.3.7.RELEASE版本. 我们可以通过web.xml配置文件web容器中声明spring容器.有以下两

在web项目中获取ApplicationContext上下文的3种主要方式及适用情况

最近在做web项目,需要写一些工具方法,涉及到通过Java代码来获取spring中配置的bean,并对该bean进行操作的情形.而最关键的一步就是获取ApplicationContext,过程中纠结和错误了很久,总结一下获取ApplicationContext的三种方式: 方式一:实现ApplicationContextAware接口 对于实现ApplicationContextAware接口的类,spring容器在初始化的时候会扫描他,并把容器的context环境注入给它.如下: 1 publ

使用Ratpack与Spring Boot构建高性能JVM微服务

在微服务天堂中Ratpack和Spring Boot是天造地设的一对.它们都是以开发者为中心的运行于JVM之上的web框架,侧重于生产率.效率以及轻量级部署.他们在服务程序的开发中带来了各自的好处.Ratpack通过一个高吞吐量.非阻塞式的web层提供了一个反应式编程模型,而且对应用程序结构的定义和HTTP请求过程提供了一个便利的处理程序链:Spring Boot集成了整个Spring生态系统,为应用程序提供了一种简单的方式来配置和启用组件.Ratpack和Spring Boot是构建原生支持计

使用Spring Boot构建微服务（文末福利）

本文主要内容 学习微服务的关键特征 了解微服务是如何适应云架构的 将业务领域分解成一组微服务 使用Spring Boot实现简单的微服务 掌握基于微服务架构构建应用程序的视角 学习什么时候不应该使用微服务 软件开发的历史充斥着大型开发项目崩溃的故事,这些项目可能投资了数百万美元.集中了行业里众多的顶尖人才.消耗了开发人员成千上万的工时,但从未给客户交付任何有价值的东西,最终由于其复杂性和负担而轰然倒塌. 这些庞大的项目倾向于遵循大型传统的瀑布开发方法,坚持在项目开始时界定应用的所有需求和设计.这

Spring mvc整合mybatis基于mysql数据库实现用户增删改查及其分页显示的完整入门实例【转】

Spring mvc整合mybatis例子, 基于mysql数据库实现对用户的增.删.改.查,及分页显示的完整例子. 查询显示用户 添加用户 更新用户 官方验证: 项目截图 必须修改applicationContext.xml中mysql的配置为本地的,否则启动失败. 另外jar包多一个ehcache.jar无关紧要,删除即可. 1. 使用阿里巴巴Druid连接池(高效.功能强大.可扩展性好的数据库连接池.监控数据库访问性能.支持Common-Logging.Log4j和JdkLog,监控数据库

Web开发中 前端路由 实现的几种方式和适用场景

浅析Web开发中前端路由实现的几种方式 主题 Web开发 故事从名叫Oliver的绿箭虾`说起,这位大虾酷爱社交网站,一天他打开了 Twitter ,从发过的tweets的选项卡一路切到followers选项卡,Oliver发现页面的内容变化了,URL也变化了,但为什么页面没有闪烁刷新呢?于是Oliver打开的网络监控器(没错,Oliver是个程序员),他惊讶地发现在切换选项卡时,只有几个XHR请求发生,但页面的URL却在对应着变化,这让Oliver不得不去思考这一机制的原因- 叙事体故事讲完,

Web Service 中返回DataSet结果的几种方法

Web Service 中返回DataSet结果的几种方法: 1)直接返回DataSet对象    特点:通常组件化的处理机制,不加任何修饰及处理:    优点:代码精减.易于处理,小数据量处理较快:    缺点:大数据量的传递处理慢,消耗网络资源:    建议:当应用系统在内网.专网(局域网)的应用时,或外网(广域网)且数据量在KB级时的应用时,采用此种模式. 2)返回DataSet对象用Binary序列化后的字节数组    特点:字节数组流的处理模式:    优点:易于处理,可以中文内容起到

Java嵌入式数据库H2学习总结(三)——在Web应用中嵌入H2数据库

H2作为一个嵌入型的数据库,它最大的好处就是可以嵌入到我们的Web应用中,和我们的Web应用绑定在一起,成为我们Web应用的一部分.下面来演示一下如何将H2数据库嵌入到我们的Web应用中. 一.搭建测试环境和项目 1.1.搭建JavaWeb测试项目 创建一个[H2DBTest]JavaWeb项目,找到H2数据库的jar文件,如下图所示: H2数据库就一个jar文件,这个Jar文件里面包含了使用JDBC方式连接H2数据库时使用的驱动类,将"h2-1.4.183.jar"加入到[H2DBT