springJDBC

最新推荐文章于 2022-11-18 19:06:11 发布
最新推荐文章于 2022-11-18 19:06:11 发布
阅读量508 收藏 2
点赞数
分类专栏： java spring spring 文章标签： springJDBC dataSource如何配置 jdbcTemplate如何使用 springJDBC如何搭建项目 springAOP和SpringJDBC如何集成
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a18792721831/article/details/87823284
版权
java 同时被 3 个专栏收录
135 篇文章 2 订阅
订阅专栏
spring
27 篇文章 0 订阅
订阅专栏
spring
20 篇文章 1 订阅
订阅专栏

SpringJDBC

1.spring JDBC介绍

spring jdbcTemplate
针对数据库的操作，spring框架提供了JdbcTemplate类，该类是Spring框架数据抽象层的基础。
主要公共属性如下：
DataSource:主要功能是获取数据库连接，具体实现时还可以引入对数据库连接的缓冲池和分布式事物的支持，作为访问数据库资源的标准接口。
SQLExceptionTranslator负责对SQLException进行转义。
JdbcOperations接口定义了在JdbcTemplate类中可以使用的操作集合，包括增删改查等等。

2.springJDBC的配置

springJDBC主要包及说明
core：baohanlJDBC的核心功能，包括JdbcTemplate类，SimpleJdbcInsert类,SimpleJdbcCall类以及NamedParameterJdbcTemplate类。
dataSource访问数据源的使用工具类。
object以面向对象的方式访问数据库，允许执行查询并将返回结果作为业务对象，可以在数据表的列和业务对象之间映射查询结果。
support包含了core和object包的支持类。

3.例子

3.1准备

在这里插入图片描述
增加上图中红框框起来的jar

3.2创建一个springJDBC项目

在这里插入图片描述

3.3Java文件

在这里插入图片描述

package aspect;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component("myAspect")
public class MyAspect {

	@Pointcut("execution(* dao.*+.*(..))")
	public void pointCutDao(){}
	
	@Pointcut("execution(* service.*+.*(..))")
	public void pointCutService(){}
	
	@Before("pointCutDao()")
	public void beforeDao(JoinPoint joinPoint){
		System.out.println("Dao     Info  "+showTime() + "[" + joinPoint.getSignature().getName()+ "]    before");
	}
	
	@Before("pointCutService()")
	public void beforeService(JoinPoint joinPoint){
		System.out.println("Service Info  "+showTime() + "[" + joinPoint.getSignature().getName()+ "]    before");
	}
	
	@AfterReturning("pointCutDao()")
	public void afterReturnDao(JoinPoint joinPoint){
		System.out.println("Dao     Info  "+showTime() + "[" + joinPoint.getSignature().getName()+ "]    afterReturn");
	}
	
	@AfterReturning("pointCutService()")
	public void afterReturnService(JoinPoint joinPoint){
		System.out.println("Service Info  "+showTime() + "[" + joinPoint.getSignature().getName()+ "]    afterReturn");
	}
	
	private String showTime(){
		return "  "+new SimpleDateFormat("yyyy-mm-dd HH:mm:ss,s").format(new Date())+"  ";
	}
}


package bean;

import java.io.Serializable;

import org.springframework.stereotype.Component;

@Component("people")
public class People implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 5213848205077480400L;

	private Long id;
	
	private String name;
	
	private Integer age;
	
	private Integer sex;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public Integer getSex() {
		return sex;
	}

	public void setSex(Integer sex) {
		this.sex = sex;
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	@Override
	public String toString() {
		return "{ id = " + this.id + "\t ,name = " + this.name
				+ "\t ,age = " + this.age + "\t ,sex = " + this.sex + " }";
	}
	
}


package client;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import service.PeopleService;
import serviceimpl.PeopleServiceImpl;
import dao.PeopleDao;
import bean.People;

public class Main {

	public static void main(String[] args) {

		//加载数据源
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
//				"resource/dataBase.xml");
//		JdbcTemplate jdbcTemplate = (JdbcTemplate) applicationContext
//				.getBean("jdbcTemplate");
//		String sql = "create table people("
//				+ "id number(8) not null,"
//				+ "name varchar2(10) not null,"
//				+ "age number(2),"
//				+ "sex number(1))";
//		System.out.println(sql);
//		jdbcTemplate.execute(sql);
		//加载bean
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
//				"resource/*.xml");
//		People people = (People) applicationContext.getBean("people");
//		people.setName("张三");
//		people.setAge(22);
//		people.setSex(1);
//		
//		PeopleDao peopleDao = (PeopleDao) applicationContext
//				.getBean("peopleDao");
//		people = peopleDao.add(people);
//		System.out.println(people.toString());
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
		"resource/*.xml");
		People people = (People)applicationContext.getBean("people");
		people.setName("李四");
		people.setAge(24);
		people.setSex(1);
		People people2 = new People();
		people2.setName("王五");
		people2.setAge(25);
		people2.setSex(0);
		List<People> peList = new ArrayList<>();
		peList.add(people);
		peList.add(people2);
		
		PeopleService peopleService = (PeopleService) applicationContext
				.getBean("peopleService");
		peopleService.batchAdd(peList);
	}

}


package dao;

import bean.People;

public interface PeopleDao {

	People add(People people);
	
	void del(People people);
	
	People update(People people);
	
}


package daoimpl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.ArgumentPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import bean.People;
import dao.PeopleDao;

@Repository("peopleDao")
public class PeopleDaoImpl implements PeopleDao{

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	private static final String SELECT = "P.ID,P.NAME,P.AGE,P.SEX";
	
	private static final String TABLE = "PEOPLE P";
	
	
	
	@Override
	public People add(People people) {
		String addSql = "INSERT INTO " + TABLE + "(" + SELECT
				+ ") VALUES(?,?,?,?)";
		people.setId(getSeq("SEQ_PEOPLE"));
		jdbcTemplate.update(
				addSql,
				new Object[] { people.getId(), people.getName(),
						people.getAge(), people.getSex()},
				new int[] { Types.INTEGER ,Types.VARCHAR,Types.INTEGER,Types.INTEGER});
		return people;
		
	}

	private class PeopleRowMapper implements RowMapper{

		@Override
		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
			People people = new People();
			people.setName(rs.getString("NAME"));
			people.setAge(rs.getInt("AGE"));
			people.setSex(rs.getInt("SEX"));
			return people;
		}
		
	}
	
	@SuppressWarnings("unchecked")
	private Long getSeq(String seqName){
		if(StringUtils.hasText(seqName)){
			return (Long) jdbcTemplate.queryForObject("SELECT " + seqName + ".NEXTVAL FROM DUAL",new RowMapper(){
				@Override
				public Object mapRow(ResultSet rs, int rowNum)
						throws SQLException {
					return rs.getLong("NEXTVAL");
				}
				
			});
		}
		return null;
	}
	
	@Override
	public void del(People people) {
		String delSql = "DELETE FROM " + TABLE + " WHERE P.ID = ? OR P.NAME = ? OR P.AGE = ? OR P.SEX = ?";
		jdbcTemplate.update(delSql, people);
	}

	@Override
	public People update(People people) {
		String updSql = "UPDATE " + TABLE + " SET P.NAME = ?,P.AGE = ?,P.SEX = ? WHERE P.ID = ?";
		jdbcTemplate.update(updSql, new Object[]{people.getName(),people.getAge(),people.getSex(),people.getId()}, new PeopleRowMapper());
		return people;
	}

	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

}


package service;

import java.util.List;

import bean.People;

public interface PeopleService {

	void batchAdd(List<People> peoples);
	
	void batchDel(List<People> peoples);
	
	List<People> batchUpdate(List<People> peoples);
	
}


package serviceimpl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import dao.PeopleDao;
import bean.People;
import service.PeopleService;

@Service("peopleService")
public class PeopleServiceImpl implements PeopleService{

	@Autowired
	private PeopleDao peopleDao;
	
	@Override
	public void batchAdd(List<People> peoples) {
		for(People people : peoples){
			peopleDao.add(people);
		}
	}

	@Override
	public void batchDel(List<People> peoples) {
		for(People people : peoples){
			peopleDao.del(people);
		}
	}

	@Override
	public List<People> batchUpdate(List<People> peoples) {
		for(People people : peoples){
			peopleDao.update(people);
		}
		return peoples;
	}

	public PeopleDao getPeopleDao() {
		return peopleDao;
	}

	public void setPeopleDao(PeopleDao peopleDao) {
		this.peopleDao = peopleDao;
	}

}

3.4xml文件

aop.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 指定需要扫描的包 -->
	<context:component-scan base-package="bean,aspect,daoimpl,serviceimpl"></context:component-scan>
	<!-- 启动基于注解的声明式AspectJ支持 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

bean.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:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd">
	<!-- 开启注解注入的装配方式 -->
	<context:annotation-config></context:annotation-config>
</beans>

dataBase.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 配置数据源 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<!-- 数据库驱动 -->
		<property name="driverClassName">
			<value>oracle.jdbc.driver.OracleDriver</value>
		</property>
		<!-- 连接数据库的url -->
		<property name="url">
			<value>jdbc:oracle:thin:@127.0.0.1:1521:oracle</value>
		</property>
		<property name="username">
			<value>study</value>
		</property>
		<property name="password">
			<value>study</value>
		</property>
	</bean>
	<!-- 配置JDBC的模板 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<!-- 默认必须使用数据源（也就是还可以不使用） -->
		<property name="dataSource" ref="dataSource">
		</property>
	</bean>
	<!-- 配置注入类 -->
	<!--注入就是使用模板的方法（按照普通属性看待） 
	<bean id="xxx" class="xxx">
	</bean>
	 -->
</beans>

3.5运行结果（数据库服务需要运行）

Service Info    2019-23-20 20:23:53,53  [batchAdd]    before
Dao     Info    2019-23-20 20:23:53,53  [add]    before
Dao     Info    2019-23-20 20:23:54,54  [add]    afterReturn
Dao     Info    2019-23-20 20:23:54,54  [add]    before
Dao     Info    2019-23-20 20:23:54,54  [add]    afterReturn
Service Info    2019-23-20 20:23:54,54  [batchAdd]    afterReturn

3.6 数据验证

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.方法解读

主要针对PeopleDaoImpl.java

package daoimpl;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.ArgumentPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import org.springframework.util.StringUtils;

import bean.People;
import dao.PeopleDao;

@Repository("peopleDao")
public class PeopleDaoImpl implements PeopleDao{

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	private static final String SELECT = "P.ID,P.NAME,P.AGE,P.SEX";
	
	private static final String TABLE = "PEOPLE P";
	
	
	
	@Override
	public People add(People people) {
		String addSql = "INSERT INTO " + TABLE + "(" + SELECT
				+ ") VALUES(?,?,?,?)";
		people.setId(getSeq("SEQ_PEOPLE"));
		jdbcTemplate.update(
				addSql,
				new Object[] { people.getId(), people.getName(),
						people.getAge(), people.getSex()},
				new int[] { Types.INTEGER ,Types.VARCHAR,Types.INTEGER,Types.INTEGER});
		return people;
		
	}

	private class PeopleRowMapper implements RowMapper{

		@Override
		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
			People people = new People();
			people.setName(rs.getString("NAME"));
			people.setAge(rs.getInt("AGE"));
			people.setSex(rs.getInt("SEX"));
			return people;
		}
		
	}
	
	@SuppressWarnings("unchecked")
	private Long getSeq(String seqName){
		if(StringUtils.hasText(seqName)){
			return (Long) jdbcTemplate.queryForObject("SELECT " + seqName + ".NEXTVAL FROM DUAL",new RowMapper(){
				@Override
				public Object mapRow(ResultSet rs, int rowNum)
						throws SQLException {
					return rs.getLong("NEXTVAL");
				}
				
			});
		}
		return null;
	}
	
	@Override
	public void del(People people) {
		String delSql = "DELETE FROM " + TABLE + " WHERE P.ID = ? OR P.NAME = ? OR P.AGE = ? OR P.SEX = ?";
		jdbcTemplate.update(delSql, people);
	}

	@Override
	public People update(People people) {
		String updSql = "UPDATE " + TABLE + " SET P.NAME = ?,P.AGE = ?,P.SEX = ? WHERE P.ID = ?";
		jdbcTemplate.update(updSql, new Object[]{people.getName(),people.getAge(),people.getSex(),people.getId()}, new PeopleRowMapper());
		return people;
	}

	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

}

首先是PeopleDaoImpl类有一个私有属性：
private JdbcTemplate jdbcTemplate;
可以看到这个属性在每一个方法基本上都用到了：
在这里插入图片描述
所以，DaoImple中对数据库的操作都是通过jdbcTemplate来实现的。
但是这个对象是怎么进行实例化的呢？
在spring容器中管理的对象就是bean，所以jdbcTemplate也是一个JavaBean。
那么这个JavaBean是在哪里配置的呢？
在这里插入图片描述
在配置数据源的时候，配置了JDBC的模板，在这里注册的JavaBean，然后在DaoImpl类中进行依赖注入：
在这里插入图片描述
自动注入。

private static final String SELECT = “P.ID,P.NAME,P.AGE,P.SEX”;
是查询的字段。
private static final String TABLE = “PEOPLE P”;
表名。

add方法：

@Override
	public People add(People people) {
		String addSql = "INSERT INTO " + TABLE + "(" + SELECT
				+ ") VALUES(?,?,?,?)";
		people.setId(getSeq("SEQ_PEOPLE"));
		jdbcTemplate.update(
				addSql,
				new Object[] { people.getId(), people.getName(),
						people.getAge(), people.getSex()},
				new int[] { Types.INTEGER ,Types.VARCHAR,Types.INTEGER,Types.INTEGER});
		return people;
		
	}

首先使用查询字段和表名拼接插入SQL语句，使用到了序列（oracle是序列）

调用jdbc的模板的update方法中这个方法：
参数为：
sql语句，
值集合，
类型集合

解释：
sql语句中值用？代替。
值集合会按照先后顺序代替SQL语句中的问号。
值处理按照类型集合进行处理（有顺序）。

这种方式非常的常见，也很常用。。

查询序列

@SuppressWarnings("unchecked")
	private Long getSeq(String seqName){
		if(StringUtils.hasText(seqName)){
			return (Long) jdbcTemplate.queryForObject("SELECT " + seqName + ".NEXTVAL FROM DUAL",new RowMapper(){
				@Override
				public Object mapRow(ResultSet rs, int rowNum)
						throws SQLException {
					return rs.getLong("NEXTVAL");
				}
				
			});
		}
		return null;
	}

查询语句调用的是jdbc模板的查询方法：
queryForObject的方法参数:
sql语句，
值集合（可以无），
结果集映射。

其中结果集映射的关系是实现RowMapper接口
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
}
中就是数据库结果对于对象的映射。

其实在spring访问数据库中，有两次映射：
1.对象映射到SQL语句实现面向对象映射数据库；
2.数据库查询结果映射对象实现数据库映射面向对象；

5.其他方法

execute()方法
这个方法能够执行SQL语句，方法定义为：
void execute(String sql);
query方法在高版本被废弃，转为queryForObject方法

a18792721831
关注
专栏目录
Spring JDBC事务管理
weixin_55558933的博客
04-20 1368
1.Spring JDBC的配置与JDBCTemplate对象 2.声明事务的配置方式 3.声明式事务的七种传播行为 1、Spring JDBC Spring JDBC是Spring框架用于处理关系型数据库的模块 Spring JDBC对JDBC aPI 进行封装，极大简化开发工作量 JDBCTemplate是Spring JDBC的核心类，提供数据的CRUD方法 为什么有了Mybatis还需要Spring JDBC? 答：Mybatis对JDBC的封装程度较高，Spring JD.
Spring JDBC—— 从零开始编写第一个Spring JDBC项目
m0_46093414的博客
10-09 1256
一、SpringJDBC简短概述 Spring JDBC 提供了几种方法和数据库中相应的不同的类与接口。我将给出使用 JdbcTemplate 类框架的经典和最受欢迎的方法。这是管理所有数据库通信和异常处理的中央框架类。 Spring框架除了提供IOC与AOP核心功能外，同样提供了基于JDBC的数据访问功能，使得访问持久层数据更加方便。使用SpringJDBC环境，首先需要一套Spring整合JDBC的环境。 废话不多说，开始搭建自己的SpringJDBC项目吧！ 注意：默认你是安装好MySQL和I
Spring JDBC
weixin_52629592的博客
11-18 2211
Spring JDBC是Spring所提供的持久层技术,它主要的目的是降低JDBC API的使用难度,以一种更直接,更简洁的方式使用JDBC API. ​ Spring JDBC 模块负责数据库资源和错误处理,大大简化了开发人员对数据库的操作.
SpringJDBC
weixin_47600732的博客
06-27 2467
SpringJDBC 1.Spring JDBC是什么？ ​ Spring框架对JDBC的封装，对通常jdbc的api做了一些封装，调用这些方法时，不再需要考虑如何获取连接，关闭连接以及处理异常等。 2.代码演示 2.1:db.properties文件内容 drivername=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/kungedb name=root password=521125lyc maxActive=1 maxWait=800
Spring JDBC的详解
lqn1998的博客
09-27 1万+
一.Spring jdbc概述 1.概述： Spring JDBC是Spring所提供的持久层技术，他主要目的降低JDBC API的使用难度，以一种更直接、更简洁的方式使用JDBC API。 2.作用： Spring的JDBC模块负责数据库资源和错误处理，大大简化了开发人员对数据库的操作。 3.包： core：核心包，包含了JDBC的核心功能。例如jdbcTemplate类 datasource：数据源包 object：对象包 support：支持包。是core包和object包的支持类。 二.Spri
【Spring JDBC】数据库连接基本步骤
懂得一千零一种,赋予你失败的方法！
04-02 2789
Spring JDBC 数据库连接基本步骤 1.配置依赖项 <!-- mysql jar包 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.17</version> // 这里我用的数据库是8.0.17版本的，一般的5.？的版本
Spring JDBC-使用Spring JDBC访问数据库
热门推荐
小工匠
09-28 2万+
概述 使用Spring JDBC 基本的数据操作 更改数据 返回数据库表的自增主键值 批量更改数据 查询数据 使用RowCallbackHandler处理结果集 使用RowMapperT处理结果集 RowCallbackHandler和RowMapperT的比较 查询单值数据 调用存储过程3种方式 示例源码概述Spring JDBC是Spring所提供的持久层技术，它的主要目的降低JDBC API的
spring jdbc和mybatis对比
m0_47300610的博客
12-12 3119
一 spring jdbc是通过JdbcTemplate这个类来实现增删改查操作。 1.下面是一个例子的核心代码块 首先是核心代码块applicationContext.xml的配置，用来链接数据库 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <!--数据库驱动--> <property name="drive
Spring JDBC 和事务控制
m0_61609890的博客
03-12 1731
1.Spring 整合 JDBC环境 Spring框架除了提供 IOC与AOP核心功能外，同样提供了基于JDBC的数据访问功能，使得访问持久层数据更加方便。使用Spring JDBC环境，首先需要一套整合的Spring 整合JDBC的环境。 1.1 添加依赖坐标 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://ww
spring JDBC
小灰狼与大白兔的博客
01-17 5963
转载于：https://www.cnblogs.com/ooooevan/p/5825392.html 先看一些定义： 在Spring JDBC模块中，所有的类可以被分到四个单独的包： 1、core 即核心包，它包含了JDBC的核心功能。此包内有很多重要的类，包括：JdbcTemplate类、SimpleJdbcInsert类，SimpleJdbcCall类，以及NamedParameterJdb...
Spring JDBC常用Jar包
11-20
Spring JDBC是Spring框架的一部分，主要用于简化Java数据库连接操作。它提供了一个抽象层，使得开发者能够以统一的方式处理各种数据库，而无需直接与JDBC API打交道，从而降低了代码的复杂性和错误率。在"Spring ...
SpringJDBC.rar_SpringJDBC_spring jdbc
09-24
通过这个SpringJDBC.rar的案例，初学者可以学习到如何配置DataSource，如何创建JdbcTemplate实例，以及如何编写和执行SQL语句。同时，实践中还可以了解到如何将Spring JDBC整合到Spring Boot项目中，以及如何处理...
Spring JDBC与事务管理
06-09
javaEE 实验三 Spring JDBC与事务管理， 一、实验目的 1、掌握Spring JDBC的配置； 2、掌握JdbcTemplae类中增删改查方法的使用； 3、了解Spring事务管理的3个核心接口； 4、了解Spring事务管理的两种方式； 5、掌握...
spring Bean初始化方法：无参构造、有参构造、set注入
a18792721831的博客
02-18 1万+
Bean初始化1.Bean的初始化方式：2.例子2.1新建一个空的spring项目2.2类文件创建2.3java文件2.4xml文件2.5运行结果3.总结 1.Bean的初始化方式： 1.无参构造（默认构造方法）； 2.有参构造（自定义构造方法）； 3.set方法 2.例子 2.1新建一个空的spring项目 其中： client包是主方法所在类的包； domain包是实体Bean的包； res...
spring Bean的实例化：无参构造器、静态工厂方法和实例工厂方法
a18792721831的博客
02-18 2759
Bean的实例化1.spring的三种实例化方式2.例子2.1创建一个空的spring工程2.2新建Java类2.3xml文件2.4运行结果3.总结 1.spring的三种实例化方式 1.默认无参的构造器实例化 2.静态工厂方法实例化 3.实例工厂方法实例化 构造器实例化是指spring容器通过Bean对应类中默认的无参构造方法来实例化。 静态工厂要求开发者创建一个静态工厂的方法来创建Bean的实...
spring核心容器创建的两种方式
a18792721831的博客
02-12 1923
spring核心容器1.spring核心容器2.例子2.1 BeanFactory绝对路径：2.2ApplicationContext相对路径3.分析4.扩展：ApplicationContext是一个接口：5.分析 1.spring核心容器 BeanFactory ApplicationContext 其中BeanFactory使用绝对路径加载配置文件 ApplicationContext使用相...
spring&mybatis整合--Mapper接口注解配置整合
a18792721831的博客
03-11 1213
spring&amp;amp;mybatis整合--Mapper接口注解配置整合1.创建一个Java工程2.导入jar包3.数据库准备4.创建实体5.创建增强类6.创建日志配置7.创建工具类8.配置数据源9.创建自定义注解10.创建工程配置10.增加服务11.增加Dao12.服务的实现13.Dao的实现14.编写测试类15.运行结果 1.创建一个Java工程 2.导入jar包 3.数据库准备 -- ...
spring jdbc
最新发布
06-03
Spring JDBC是Spring框架中的一个模块，它提供了一组JDBC抽象层，用于帮助开发人员更加方便地使用JDBC操作数据库。Spring JDBC提供了简单的方法来执行SQL查询、更新和存储过程调用等操作，同时也提供了异常处理、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值