Spring JDBC 示例

最新推荐文章于 2024-03-05 10:36:57 发布
最新推荐文章于 2024-03-05 10:36:57 发布
阅读量466 收藏 1
点赞数 1
分类专栏： Spring JDBC 文章标签： Spring

 

Spring JDBC示例

 

Spring JDBC是本教程的主题。数据库是大多数企业应用程序不可或缺的一部分。因此，当谈到Java EE框架时，与JDBC的良好集成非常重要。

目录[ 隐藏 ]

Spring JDBC

spring jdbc，spring jdbc示例，spring JDBCTemplate，JDBCTemplate

Spring Framework提供了与JDBC API的出色集成，并提供JdbcTemplate了我们可以用来避免来自我们的数据库操作逻辑的bolier-plate代码的实用程序类，例如Opening / Closing Connection，ResultSet，PreparedStatement等。

让我们首先看一个简单的Spring JDBC示例应用程序，然后我们将看到JdbcTemplate类如何帮助我们轻松编写模块化代码，而不必担心资源是否正确关闭。

用于开发基于Spring的应用程序的Spring Tool Suite非常有用，因此我们将使用STS来创建Spring JDBC应用程序。我们的最终项目结构如下图所示。

Spring JDBC示例，Spring JDBC，Spring JdbcTemplate

 

从STS菜单创建一个简单的Spring Maven项目，您可以选择您喜欢的任何名称，或者将我的项目名称作为SpringJDBCExample。

Spring JDBC依赖项

首先，我们需要在maven项目pom.xml文件中包含Spring JDBC和Database驱动程序。我的最终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>org.springframework.samples</groupId>
	<artifactId>SpringJDBCExample</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>

		<!-- Generic properties -->
		<java.version>1.6</java.version>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

		<!-- Spring -->
		<spring-framework.version>4.0.2.RELEASE</spring-framework.version>

		<!-- Logging -->
		<logback.version>1.0.13</logback.version>
		<slf4j.version>1.7.5</slf4j.version>

	</properties>

	<dependencies>
		<!-- Spring and Transactions -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>

		<!-- Spring JDBC Support -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring-framework.version}</version>
		</dependency>
		
		<!-- MySQL Driver -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.0.5</version>
		</dependency>

		<!-- Logging with SLF4J & LogBack -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
			<scope>runtime</scope>
		</dependency>

	</dependencies>
</project>

大部分内容是由STS自动生成的，但我更新了Spring Framework版本，使用最新版本为4.0.2.RELEASE。

我们还添加了所需的工件spring-jdbc和mysql-connector-java。第一个包含Spring JDBC支持类，第二个包含数据库驱动程序。我正在使用MySQL数据库进行测试，因此我添加了MySQL JConnector jar依赖项。如果您正在使用其他一些RDBMS，那么您应该在依赖项中进行相应的更改。

Spring JDBC示例 - 数据库设置

让我们创建一个简单的表，我们将在我们的应用程序中使用CRUD操作示例。


CREATE TABLE `Employee` (
  `id` int(11) unsigned NOT NULL,
  `name` varchar(20) DEFAULT NULL,
  `role` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Spring JDBC示例 - 模型类

我们将使用DAO Pattern进行JDBC操作，所以让我们创建一个将为Employee表建模的java bean。


package com.journaldev.spring.jdbc.model;

public class Employee {

	private int id;
	private String name;
	private String role;
	
	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 String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	
	@Override
	public String toString(){
		return "{ID="+id+",Name="+name+",Role="+role+"}";
	}
}

Spring JDBC示例 - DAO接口和实现

对于DAO模式，我们首先会有一个接口来声明我们想要实现的所有操作。


package com.journaldev.spring.jdbc.dao;

import java.util.List;

import com.journaldev.spring.jdbc.model.Employee;

//CRUD operations
public interface EmployeeDAO {
	
	//Create
	public void save(Employee employee);
	//Read
	public Employee getById(int id);
	//Update
	public void update(Employee employee);
	//Delete
	public void deleteById(int id);
	//Get All
	public List<Employee> getAll();
}


package com.journaldev.spring.jdbc.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.sql.DataSource;

import com.journaldev.spring.jdbc.model.Employee;

public class EmployeeDAOImpl implements EmployeeDAO {

	private DataSource dataSource;

	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}

	@Override
	public void save(Employee employee) {
		String query = "insert into Employee (id, name, role) values (?,?,?)";
		Connection con = null;
		PreparedStatement ps = null;
		try{
			con = dataSource.getConnection();
			ps = con.prepareStatement(query);
			ps.setInt(1, employee.getId());
			ps.setString(2, employee.getName());
			ps.setString(3, employee.getRole());
			int out = ps.executeUpdate();
			if(out !=0){
				System.out.println("Employee saved with id="+employee.getId());
			}else System.out.println("Employee save failed with id="+employee.getId());
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			try {
				ps.close();
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public Employee getById(int id) {
		String query = "select name, role from Employee where id = ?";
		Employee emp = null;
		Connection con = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try{
			con = dataSource.getConnection();
			ps = con.prepareStatement(query);
			ps.setInt(1, id);
			rs = ps.executeQuery();
			if(rs.next()){
				emp = new Employee();
				emp.setId(id);
				emp.setName(rs.getString("name"));
				emp.setRole(rs.getString("role"));
				System.out.println("Employee Found::"+emp);
			}else{
				System.out.println("No Employee found with id="+id);
			}
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			try {
				rs.close();
				ps.close();
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return emp;
	}

	@Override
	public void update(Employee employee) {
		String query = "update Employee set name=?, role=? where id=?";
		Connection con = null;
		PreparedStatement ps = null;
		try{
			con = dataSource.getConnection();
			ps = con.prepareStatement(query);
			ps.setString(1, employee.getName());
			ps.setString(2, employee.getRole());
			ps.setInt(3, employee.getId());
			int out = ps.executeUpdate();
			if(out !=0){
				System.out.println("Employee updated with id="+employee.getId());
			}else System.out.println("No Employee found with id="+employee.getId());
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			try {
				ps.close();
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public void deleteById(int id) {
		String query = "delete from Employee where id=?";
		Connection con = null;
		PreparedStatement ps = null;
		try{
			con = dataSource.getConnection();
			ps = con.prepareStatement(query);
			ps.setInt(1, id);
			int out = ps.executeUpdate();
			if(out !=0){
				System.out.println("Employee deleted with id="+id);
			}else System.out.println("No Employee found with id="+id);
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			try {
				ps.close();
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public List<Employee> getAll() {
		String query = "select id, name, role from Employee";
		List<Employee> empList = new ArrayList<Employee>();
		Connection con = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try{
			con = dataSource.getConnection();
			ps = con.prepareStatement(query);
			rs = ps.executeQuery();
			while(rs.next()){
				Employee emp = new Employee();
				emp.setId(rs.getInt("id"));
				emp.setName(rs.getString("name"));
				emp.setRole(rs.getString("role"));
				empList.add(emp);
			}
		}catch(SQLException e){
			e.printStackTrace();
		}finally{
			try {
				rs.close();
				ps.close();
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return empList;
	}

}

CRUD操作的实现很容易理解。如果您想了解有关DataSource的更多信息，请阅读JDBC DataSource示例。

 

Spring JDBC示例 - Bean配置

如果查看上面的所有类，它们都使用标准JDBC API，并且没有对Spring JDBC框架的引用。当我们创建Spring Bean配置文件并定义bean时，Spring JDBC框架类就会出现。我们将在Spring Bean上下文文件中创建DataSource并将其设置为我们的DAO实现类。

我的Spring Bean配置文件如下所示。


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="employeeDAO" class="com.journaldev.spring.jdbc.dao.EmployeeDAOImpl">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/TestDB" />
		<property name="username" value="pankaj" />
		<property name="password" value="pankaj123" />
	</bean>

</beans>

首先，我们要创建一个类的DataSource对象DriverManagerDataSource。该类提供了我们可以使用的DataSource的基本实现。我们将MySQL数据库URL，用户名和密码作为属性传递给DataSource bean。

再次将dataSource bean设置为EmployeeDAOImplbean，我们已准备好使用Spring JDBC实现。实现是松散耦合的，如果我们想切换到其他实现或转移到其他数据库服务器，我们所需要的只是在bean配置中进行相应的更改。这是Spring JDBC框架提供的主要优势之一。

Spring JDBC测试类

让我们编写一个简单的测试类来确保一切正常。


package com.journaldev.spring.jdbc.main;

import java.util.List;
import java.util.Random;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.journaldev.spring.jdbc.dao.EmployeeDAO;
import com.journaldev.spring.jdbc.model.Employee;

public class SpringMain {

	public static void main(String[] args) {
		//Get the Spring Context
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
		
		//Get the EmployeeDAO Bean
		EmployeeDAO employeeDAO = ctx.getBean("employeeDAO", EmployeeDAO.class);
		
		//Run some tests for JDBC CRUD operations
		Employee emp = new Employee();
		int rand = new Random().nextInt(1000);
		emp.setId(rand);
		emp.setName("Pankaj");
		emp.setRole("Java Developer");
		
		//Create
		employeeDAO.save(emp);
		
		//Read
		Employee emp1 = employeeDAO.getById(rand);
		System.out.println("Employee Retrieved::"+emp1);
		
		//Update
		emp.setRole("CEO");
		employeeDAO.update(emp);
		
		//Get All
		List<Employee> empList = employeeDAO.getAll();
		System.out.println(empList);
		
		//Delete
		employeeDAO.deleteById(rand);
		
		//Close Spring Context
		ctx.close();
		
		System.out.println("DONE");
	}

}

我使用随机类为员工ID生成随机数。当我们运行上面的程序时，我们得到以下输出。


Mar 25, 2014 12:54:18 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@4b9af9a9: startup date [Tue Mar 25 12:54:18 PDT 2014]; root of context hierarchy
Mar 25, 2014 12:54:18 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring.xml]
Mar 25, 2014 12:54:19 PM org.springframework.jdbc.datasource.DriverManagerDataSource setDriverClassName
INFO: Loaded JDBC driver: com.mysql.jdbc.Driver
Employee saved with id=726
Employee Found::{ID=726,Name=Pankaj,Role=Java Developer}
Employee Retrieved::{ID=726,Name=Pankaj,Role=Java Developer}
Employee updated with id=726
[{ID=726,Name=Pankaj,Role=CEO}]
Employee deleted with id=726
Mar 25, 2014 12:54:19 PM org.springframework.context.support.ClassPathXmlApplicationContext doClose
INFO: Closing org.springframework.context.support.ClassPathXmlApplicationContext@4b9af9a9: startup date [Tue Mar 25 12:54:18 PDT 2014]; root of context hierarchy
DONE

Spring JdbcTemplate示例

如果你看看DAO实现类，我们打开和关闭Connection，PreparedStatements和ResultSet有很多样板代码。如果有人忘记正确关闭资源，这可能会导致资源泄漏。我们可以使用org.springframework.jdbc.core.JdbcTemplateclass来避免这些错误。Spring JdbcTemplate是Spring JDBC核心包中的中心类，它提供了许多方法来执行查询并自动解析ResultSet以获取Object或Object列表。

我们所需要的只是将参数提供为Object数组并实现Callback接口，例如PreparedStatementSetter和RowMapper用于映射参数或将ResultSet数据转换为bean对象。

让我们看一下EmployeeDAO的另一个实现，我们将使用Spring JdbcTemplate类来执行不同类型的查询。


package com.journaldev.spring.jdbc.dao;

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

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import com.journaldev.spring.jdbc.model.Employee;

public class EmployeeDAOJDBCTemplateImpl implements EmployeeDAO {

	private DataSource dataSource;

	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}
	
	@Override
	public void save(Employee employee) {
		String query = "insert into Employee (id, name, role) values (?,?,?)";
		
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		
		Object[] args = new Object[] {employee.getId(), employee.getName(), employee.getRole()};
		
		int out = jdbcTemplate.update(query, args);
		
		if(out !=0){
			System.out.println("Employee saved with id="+employee.getId());
		}else System.out.println("Employee save failed with id="+employee.getId());
	}

	@Override
	public Employee getById(int id) {
		String query = "select id, name, role from Employee where id = ?";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		
		//using RowMapper anonymous class, we can create a separate RowMapper for reuse
		Employee emp = jdbcTemplate.queryForObject(query, new Object[]{id}, new RowMapper<Employee>(){

			@Override
			public Employee mapRow(ResultSet rs, int rowNum)
					throws SQLException {
				Employee emp = new Employee();
				emp.setId(rs.getInt("id"));
				emp.setName(rs.getString("name"));
				emp.setRole(rs.getString("role"));
				return emp;
			}});
		
		return emp;
	}

	@Override
	public void update(Employee employee) {
		String query = "update Employee set name=?, role=? where id=?";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		Object[] args = new Object[] {employee.getName(), employee.getRole(), employee.getId()};
		
		int out = jdbcTemplate.update(query, args);
		if(out !=0){
			System.out.println("Employee updated with id="+employee.getId());
		}else System.out.println("No Employee found with id="+employee.getId());
	}

	@Override
	public void deleteById(int id) {

		String query = "delete from Employee where id=?";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		
		int out = jdbcTemplate.update(query, id);
		if(out !=0){
			System.out.println("Employee deleted with id="+id);
		}else System.out.println("No Employee found with id="+id);
	}

	@Override
	public List<Employee> getAll() {
		String query = "select id, name, role from Employee";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		List<Employee> empList = new ArrayList<Employee>();

		List<Map<String,Object>> empRows = jdbcTemplate.queryForList(query);
		
		for(Map<String,Object> empRow : empRows){
			Employee emp = new Employee();
			emp.setId(Integer.parseInt(String.valueOf(empRow.get("id"))));
			emp.setName(String.valueOf(empRow.get("name")));
			emp.setRole(String.valueOf(empRow.get("role")));
			empList.add(emp);
		}
		return empList;
	}

}

查看Spring JdbcTemplate的上述代码的重点是：

  • 使用Object数组传递PreparedStatement参数，我们也可以使用PreparedStatementSetter实现，但传递Object数组似乎很容易使用。
  • 没有与打开和关闭连接，语句或结果集相关的代码。所有这些都是由Spring JdbcTemplate类内部处理的。
  • RowMapper匿名类实现将ResultSet数据映射到queryForObject（）方法中的Employee bean对象。
  • queryForList（）方法返回Map列表，而Map包含使用key映射的行数据作为列名和来自符合条件的数据库行的值。

要使用Spring JdbcTemplate实现，我们只需要更改Spring Bean配置文件中的employeeDAO类，如下所示。


<bean id="employeeDAO" class="com.journaldev.spring.jdbc.dao.EmployeeDAOJDBCTemplateImpl">
	<property name="dataSource" ref="dataSource" />
</bean>

当您运行主类时，Spring JdbcTemplate实现的输出将类似于上面使用普通JDBC实现的输出。这就是Spring JDBC示例教程的全部内容，从下面的链接下载示例项目并使用它来了解更多信息。

下载Spring JDBC Project

 

转载来源：https://www.journaldev.com/2593/spring-jdbc-example

星河_赵梓宇
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring jdbc示例代码
10-24
本示例代码将展示如何在Spring环境中使用JDBC进行数据的增删改查操作，并对比它与原生JDBC以及ORM（Object-Relational Mapping）框架如Hibernate或MyBatis的差异。 首先，让我们深入理解Spring JDBC的核心概念： 1...
SpringJdbcMysql:带有 MySql 的 Spring JDBC 示例
07-16
在IT行业中，Spring框架是Java开发中的一个核心组件，它为构建企业级应用程序提供了全面的解决方案。...这个项目是学习和实践Spring JDBC与MySQL结合的优秀示例，有助于提升Java开发者的数据库访问技能。
Spring JDBC
m0_51457307的博客
11-24 5956
Spring JDBC模块负责数据库资源管理和错误处理。 针对数据库操作，Spring框架提供了JdbcTemplate类，该类是Spring JDBC的核心类。 一、Spring JDBC的配置 Spring JDBC主要由4个包组成： Spring JDBC所需要的jar包： Spring对数据库的操作都封装在了这几个包中，想要使用JDBC就需要对其进行配置，在Spring容器中，对JDBC的配置是在applicationContext.xml文件中进行的。 <?xml ..
Spring JDBC（配置数据源，操作数据库）
yu的博客
09-13 2844
Spring JDBC（配置数据源，操作数据库）
Spring中JdbcTemplate 和DataSource的联系
yyd_Diablo的博客
10-22 2634
原文地址： http://1358440610-qq-com.iteye.com/blog/1826816#comments 一、首先配置JdbcTemplate； 要使用Jdbctemplate 对象来完成jdbc 操作。通常情况下，有三种种方式得到JdbcTemplate 对象。        第一种方式：我们可以在自己定义的DAO 实现类中注入一个DataSource
DataSourceBuilder转换JdbcTemplate
怪只怪满眼尽是人间烟火
08-08 612
import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.jdbc.core.JdbcTemplate; import java.sql.Connection; import java.util.LinkedList; import java.util.List; import java.util.Map; public class DataBase { private static .
1. 数据库连接池 2. Spring JDBC
羽扬 -- YYDCYY
09-15 283
内容 1. 数据库连接池 2. Spring JDBC : JDBC Template 数据库连接池 1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 2. 好处： 1. 节约资源 2. 用户访问高效 3. 实现： 1. ...
SpringJDBC批量处理数据代码示例
09-09
在Java开发中，Spring JDBC是Spring框架的一部分，用于简化数据库操作。它提供了一种更方便的方式来处理数据库事务，包括批量处理。批量处理是提高数据库性能的重要手段，尤其在插入、更新大量数据时，能显著减少...
spring接管jdbc详解
11-30
在本文中，我们将详细介绍 Spring 是如何接管 JDBC 的，并提供一个简单的示例来展示如何使用 Spring 来访问数据库。 首先，让我们来介绍一下 JDBC 是什么。JDBC（Java Database Connectivity）是 Java 语言中用来...
JDBC_Spring.zip_spring jdbc
09-23
压缩包中的"JDBC_2_Spring"可能包含了一些示例代码或配置文件，这些资源可以帮助你更直观地了解Spring JDBC的实际应用。通过学习这些示例，你可以掌握如何将Spring的JDBC支持与MySQL数据库集成，以及如何编写和执行...
Spring使用DriverManagerDataSource和C3P0分别配置MySql6.0.6数据源
09-13
Spring使用DriverManagerDataSource和C3P0分别配置MySql6.0.6数据源
Springboot---配置jdbcTemplate的Datasource
huyishero的博客
11-30 5901
spingboot使用jdbcTemplate可以便捷的访问数据库，配置访问方式如下 1.在配置文件中，写入数据库连接信息 application.properties配置如下 spring.datasource.primary.url=jdbc:mysql://localhost:3306/test1 spring.datasource.primary.username=root spr...
Spring系列四之JDBC
gengermao的博客
03-13 2774
Spring JDBCSpring JDBC之数据库环境MySQL及辅助jar包的下载MySQL解压缩版的安装登录MySQLEclipse连接MySQL Spring JDBC之数据库环境 下面开始学习Sping中数据库的相关内容 MySQL及辅助jar包的下载 在学习Spring JDBC中，我们采用的数据库是MySQL，版本是社区版+解压缩版，因为社区版是免费的，解压缩版相对msi安装版更锻炼...
springboot整合jdbc--spring-data-jdbc入门
最新发布
qq_62377885的博客
03-05 1391
JDBC(Java Data Base Connectivity):提供了一组Java程序访问关系数据库的API,使ava程序可以与任何支持SQL标准的数据库交互。JDBC优点·简洁的SQL处理·针对大型数据的良好性能·接口语法简单·非常适合小型应用程序JDBC缺点·SQL语句以硬编码写于代码中，不利于维护移植需了解并掌握数据库技术·需手动实现封装·大型项目维护复杂，编程开销大ORM，即对象关系映射（Object-Relational Mapping）
Spring配置内置的连接池DriverManagerDataSource
热门推荐
学亮编程手记
02-11 1万+
applicationContext.xml配置 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns...
spring配置dataSource:DriverManagerDataSource
weixin_34245169的博客
03-04 8610
2019独角兽企业重金招聘Python工程师标准>>> ...
HikariDataSource 和jdbcTemplate
xiaoguangtouqiang的博客
03-03 1472
1.常用的数据库连接池有这些 2.其中hikaricp是性能最快的连接池，使用它来构造jdbcTemplate对数据库进行操作； 首先构造一个HikariDataSource，并配置数据库的属性 private static final String DRIVER_NAME = "org.apache.hive.jdbc.HiveDriver"; HikariDataSource...
Spring源码分析七：JdbcTemplate连接数据库原理
小萌新的博客
05-25 1075
文章目录（一）Spring连接数据库程序1、创建数据库表2、创建实体PO3、创建mapper映射4、创建业务接口5、创建业务接口实现类6、Spring配置文件7、测试类（二）JdbcTemplate核心原理1、update方法（执行DML语句）2、execute底层方法（底层核心，DDL）（1）获取数据库连接（2）用户查询参数设置（3）执行回调方法（4）告警处理（5）资源释放3、query方法（执行DQL语句）（三）总结 （一）Spring连接数据库程序 1、创建数据库表 CREATE TABLE `stu
Spring JdbcTemplate基本使用(基于maven)简洁版
qq_46199553的博客
08-05 1448
JdbcTemplate在现在用得并不多，使用mybatis更多一些 1.1 JdbcTemplate概述 它是spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。 1.2 JdbcTemplate开发步骤 导入spring-jdbc和spring-tx坐标 创
Spring Integration Jdbc RowMapper示例
06-01
以下是一个Spring Integration Jdbc RowMapper示例： ```java import org.springframework.integration.jdbc.JdbcMessageHandler; import org.springframework.jdbc.core.RowMapper; public class MyRowMapper ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值