Spring集成ORM框架之JDBC的使用

最新推荐文章于 2023-10-05 20:15:25 发布
最新推荐文章于 2023-10-05 20:15:25 发布
阅读量1.7k 收藏 3
点赞数 1
分类专栏： Spring学习笔记 文章标签： Spring之ORM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/polo_longsan/article/details/46399477
版权

做程序开发，难免要操作数据库。在使用Spring框架的时候，Spring已经集成了传统的JDBC的使用，Hibernate，JPA，Ibatis等ORM框架。传统的JDBC的使用最让人心烦的就是随便写一个sql都要一大堆样板式代码；像获取数据库连接，准备参数，提交sql，关闭连接，关闭参数。这让程序员都不能专注于业务逻辑的开发，严重的影响了开发效率，代码臃肿。现在就来学习Spring集成JDBC的使用。

1、首先新建一个Maven项目（需要先安装好Maven），项目结构如下


2、在pom.xml（有几个jar包是aop，定时器用到的jar报，与本次内容无关）文件中配置如下：

<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.csii.spring</groupId>
  <artifactId>SpringBean_01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>SpringBean_01</name>
  <url>http://maven.apache.org</url>

 <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <springframework.version>3.2.3.RELEASE</springframework.version>  
  </properties>
  
 <repositories>  
    <repository>  
      <snapshots>  
        <enabled>false</enabled>  
      </snapshots>  
      <id>central</id>  
      <name>Maven Repository Switchboard</name>  
      <url>http://repo2.maven.org/maven2</url>  
    </repository>  
  </repositories>  

 <dependencies>  
  
     	<dependency>
		    <groupId>junit</groupId>
		    <artifactId>junit</artifactId>
		    <version>4.0</version>
		</dependency>
		 
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context-support</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-web</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
          <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-aspects</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
         <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-aspects</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
          <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-orm</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
           <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-jdbc</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>
        
          <dependency>  
            <groupId>org.aspectjweaver</groupId>  
            <artifactId>aspectjweaver</artifactId>  
            <version>1.7.2</version>  
        </dependency>
        
     	 <dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.0</version>
		</dependency>
		
     	 <dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>3.1</version>
		</dependency>
  
        <dependency>  
            <groupId>org.quartz-scheduler</groupId>  
            <artifactId>quartz</artifactId>  
            <version>1.8.5</version>  
        </dependency>
        
        <dependency>
		    <groupId>commons-pool</groupId>
		    <artifactId>commons-pool</artifactId>
		    <version>1.5.4</version>
		</dependency>
		
        <dependency>
			<groupId>commons-dbcp</groupId>
			<artifactId>commons-dbcp</artifactId>
			<version>1.2.2</version>
		</dependency>
		
       <dependency>
		    <groupId>com.mysql</groupId>
		    <artifactId>mysql-connector-java</artifactId>
		    <version>5.1.20</version>
		</dependency>
		
    </dependencies>  
    <build>  
        <finalName>${project.artifactId}</finalName>  
        <plugins>  
            <plugin>  
                <groupId>org.mortbay.jetty</groupId>  
                <artifactId>jetty-maven-plugin</artifactId>  
                <version>7.5.4.v20111024</version>  
                <configuration>  
                    <scanIntervalSeconds>10</scanIntervalSeconds>  
                    <webApp>  
                        <contextPath>/${project.artifactId}</contextPath>  
                    </webApp>  
                </configuration>  
            </plugin>  
        </plugins>  
    </build>  
  <!--   <properties>  
        <springframework.version>3.2.3.RELEASE</springframework.version>  
    </properties>   -->
</project>
上面通过maven引入的jar报有：

Spring核心jar报：Spring-core-3.2.2.Release.jar，Spring-beans-3.2.3.Release.jar，Spring-context-support-3.2.3.Release.jar。

Spring集成第三方orm需要用到的jar包：Spring-orm--3.2.2.Release.jar，Spring-jdbc-3.2.2.Release.jar。

数据库连接需要用到的jar包：commons-dbcp-1.2.2.jar,comoons-pool-1.5.4.jar，commons-collection-3.1.jar，mysql-connector-java-5.1.20.jar

(其它jar包现在用不到)

3、配置applicationContext.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"
    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-3.2.xsd">
    
    <import resource="bean/bean.xml"/>
    
    <import resource="datasource.xml"/>
    
</beans>
其中datasource.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"
    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-3.2.xsd">
           
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	    <property name="url" value="jdbc:mysql://127.0.0.1:3306/dbtest?useUnicode=true&characterEncoding=utf8"></property>
	     <property name="username" value="root"></property>
	     <property name="password" value="root"></property>
	      <!--maxActive: 最大连接数量-->    
        <property name="maxActive" value="20"/>  
        <!--minIdle: 最小空闲连接-->    
        <property name="minIdle" value="0"/>  
        <!--maxIdle: 最大空闲连接-->    
        <property name="maxIdle" value="2"/>  
        <!--initialSize: 初始化连接-->    
        <property name="initialSize" value="10"/>  
        <!-- 连接被泄露时是否打印 -->  
	</bean>
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	    <constructor-arg ref="dataSource"></constructor-arg>
	</bean>
	
	<bean id="userDao" class="com.csii.dao.impl.UserDAOImpl">
	    <property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>

</beans>
这里面主要是配置数据库连接池，jdbcTemplate模板。配置datasource的时候，一般最好是用数据库连接池BasicDataSource；像DriverManagerDataSource每个连接请求都要新建一个数据库连接，没有进行池化管理，对服务器性能消耗太大；SingleConnectionDataSource每个连接都会返回同一个连接，无法同时处理多个请求。JdbcTemplate封装了基本的样板式代码像打开数据库连接，关闭连接，返回参数映射。

4、接下来我们新建一个数据库dbtest，新建一个表user。然后新建一个User实体类，UserDAO接口类，UserDAOImpl实现类。

User.java

package com.csii.entity;

public class User {
	
	private int id;
	
	private String username;
	
	private String password;

	public int getId() {
		return id;
	}

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

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "user{id="+getId()+",username="+getUsername()+",password="+getPassword()+"}";
	}
	
	

}
UserDAO.java 

package com.csii.dao;

import java.util.List;
import java.util.Map;

import com.csii.entity.User;

public interface UserDAO {
	
	void addUser(User user);
	
	Map<String,Object> queryByUserName(String username);
	
	User queryById(int id);
	
	List<User> getUserList();

}
UserDAOImpl.java 

package com.csii.dao.impl;


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

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

import com.csii.dao.UserDAO;
import com.csii.entity.User;

public class UserDAOImpl implements UserDAO{
	
	public static final String SQL_INSERT="insert into user(username,password) values(?,?)";
	
	public static final String SQL_QUERY_BY_USERNAME="select * from user where username=?";
	
	public static final String SQL_QUERY_ALL_USER="select * from user";
	
	public static final String SQL_QUERY_BY_ID="select * from user where id=?";
	
	private JdbcTemplate jdbcTemplate;

	public void addUser(final User user) {
		
		getJdbcTemplate().update(SQL_INSERT, user.getUsername(),user.getPassword());
		
	}
	
	public List<User> getUserList() {
		
		//getJdbcTemplate().query(SQL_QUERY_ALL_USER, null, rowMapper)
		return null;
	}
	
	public Map<String,Object> queryByUserName(String username) {
		
		Map<String,Object> map=getJdbcTemplate().queryForMap(SQL_QUERY_BY_USERNAME, username);
		return map;
	}
	
	public User queryById(int id) {
		
		User user=getJdbcTemplate().queryForObject(SQL_QUERY_BY_ID, new Object[]{id},
					new RowMapper<User>(){public User mapRow(ResultSet resultset, int i)
							throws SQLException {
						User user=new User();
						user.setId(resultset.getInt("id"));
						user.setUsername(resultset.getString("username"));
						user.setPassword(resultset.getString("password"));
						return user;
					}});
		return user;
	}
	
	

	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

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



}
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"
    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-3.2.xsd">
           
	<bean id="user" class="com.csii.entity.User"></bean>

</beans>
5、写一个测试类 

package com.csii.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.csii.aop.SoccerGame;
import com.csii.aopwithparam.MindReader;
import com.csii.aopwithparam.Thinker;
import com.csii.aopwithparam.Volunteer;
import com.csii.dao.UserDAO;
import com.csii.entity.User;

public class Test {
	
	public static void main(String[] args) throws Exception {
		ApplicationContext ctx=
	      		   new ClassPathXmlApplicationContext("applicationContext.xml");
		
		UserDAO userDao=(UserDAO)ctx.getBean("userDao");
	/*	User user=new User();
		user.setUsername("李四");
		user.setPassword("123456");
		userDao.addUser(user);*/
		//System.out.println(userDao.queryByUserName("张三"));
		
		System.out.println(userDao.queryById(1));
	    
	    
	}

}
输出结果：

    user{id=1,username=张三,password=123456}


说明：

UserDAOImpl中我们配置了一个JdbcTemplate的属性，然后通过set方法进行注入；这里假如我们有很多dao类的话，那么将会出现很多重复代码，因此另一种处理方式是写一个通用的父类，注入jdbcTemplet属性，来避免重复代码。Spring提供了一个JdbcDaoSupport来做这个工作。这样UserDAOImpl不需要再申明JdbcTemplate属性，set方法。

package com.csii.dao.impl;


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

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

import com.csii.dao.UserDAO;
import com.csii.entity.User;

public class UserDAOImpl extends JdbcDaoSupport  implements UserDAO{
	
	public static final String SQL_INSERT="insert into user(username,password) values(?,?)";
	
	public static final String SQL_QUERY_BY_USERNAME="select * from user where username=?";
	
	public static final String SQL_QUERY_ALL_USER="select * from user";
	
	public static final String SQL_QUERY_BY_ID="select * from user where id=?";
	
	//private JdbcTemplate jdbcTemplate;

	public void addUser(final User user) {
		
		getJdbcTemplate().update(SQL_INSERT, user.getUsername(),user.getPassword());
		
	}
	
	public List<User> getUserList() {
		
		//getJdbcTemplate().query(SQL_QUERY_ALL_USER, null, rowMapper)
		return null;
	}
	
	public Map<String,Object> queryByUserName(String username) {
		
		Map<String,Object> map=getJdbcTemplate().queryForMap(SQL_QUERY_BY_USERNAME, username);
		return map;
	}
	
	public User queryById(int id) {
		
		User user=getJdbcTemplate().queryForObject(SQL_QUERY_BY_ID, new Object[]{id},
					new RowMapper<User>(){public User mapRow(ResultSet resultset, int i)
							throws SQLException {
						User user=new User();
						user.setId(resultset.getInt("id"));
						user.setUsername(resultset.getString("username"));
						user.setPassword(resultset.getString("password"));
						return user;
					}});
		return user;
	}
	
	

	/*public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

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


}










polo_longsan
关注
专栏目录
Spring整合JDBC
RXiaoYao0412的博客
09-10 141
回顾JDBC java操作关系型数据的API。 导入相关数据库的驱动包后可以通过JDBC提供的接口来操作数据库。 实现JDBC的六个步骤 注册数据库驱动 获取数据库连接 获取传输器对象 传输sql执行获取结果集对象 遍历结果集获取信息 关闭资源 package cn.tedu.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.R
springboot集成ORM框架开发
yzq102873的博客
11-27 109
springboot集成ORM框架开发
框架学习之Spring 第四节 Spring集成JDBC组件开发
08-23 109
1.与JDBC集成的配置步骤： ①配置数据源,如: 第一种方式：直接在XML中配置数据源： <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" va...
Spring集成JDBC
weixin_30478619的博客
06-12 86
不同spring版本合成的方式，有时候不一样，需要查看帮助文档来看如何集成，帮助文档在spring发行包中。 1.导入spring的包(这里吧Spring-3.1.3 Release的所有jar包都导入了)和导入MySQL的依赖包mysql-connector-java-5.1.17-bin.jar 2.选择一个数据源(JDBC自己的数据源管理器，DBCP和C3p0)，我们一般用DBCP &...
Spring集成Jdbc
qq_41854180的博客
11-16 158
JdbcTemplate是Spring对JDBC的封装，目的是使JDBC更加易于使用。 JdbcTemplate是Spring的一部分。JdbcTemplate处理了资源的建立和释放。 他帮助我们避免一些常见的错误，比如忘了总要关闭连接。他运行核心的JDBC工作流， 如Statement的建立和执行，而我们只需要提供SQL语句和提取结果。 Spring配置数据源三种方式 测试类 package com.it.jdbc; import org.junit.Test; import org.junit.runn
spring 集成 jdbc
weixin_30885111的博客
03-10 42
1、导入Spring的包（spring的dist中的jar包和commons-logging包）和数据库的驱动包 2、选择一个数据源（DBCP和C3p0） 3、导入数据源的包:DBCP （commons-dbcp-jar,commons-pool.jar） 4、在beans.xml中创建dataSource数据源 <bean id="dataSource" ...
SpringJDBC.rar_jdbc spring_spring jd_spring jdbc_spring使用JDBC进行数
09-21
5. **SqlSessionFactoryBean与SqlSessionTemplate**：对于使用MyBatis作为ORM框架的项目，Spring JDBC提供了这些组件来简化MyBatis的集成。 6. **事务管理**：Spring JDBC与Spring的事务管理功能紧密集成，可以轻松...
编程语言+JAVAspring+ORM框架+数据持久化
最新发布
03-04
它介绍了JAVAspring的ORM框架的概念、原理和作用，以及如何使用JAVAspring的ORM框架来实现数据持久化，包括JDBC、Hibernate、MyBatis等常用的ORM框架的集成和使用，以及一些配置文件和注解的用法。
基于SpringJDBC的轻量级ORM框架sborm.zip
07-19
一、SBORM 介绍 1、目前只考虑支持 mysql； 2、基于spring jdbc的上层封装，底层jdbc操作基于JdbcTemplate，对于使用spring jdbc的人会有一点价值，比较简洁的封装可以节省很多重复劳动，具体节省多少可以看看example； 3、实现一套简单的ORM（直接使用spring rowmapper,insert自己实现），可以基于对象进行crud和相对复杂（感觉比hibernate强大一点）的sql操作； 4、基于对象指定查询的字段，大部分时候可以忘掉表结构进行业务开发； 5、支持简单的数据库路由，读写分离（半自动，需要指定取writer还是reader，默认规则reader采用随机的方式，当然也可以手动指定）； 6、支持简单的分表，主要是针对一定规则的分表，比如百分表、千分表，也可以自己指定分表后缀； 7、简单的单表查询（比如所有条件是and或者or结构），基本实现0sql代码编写（类似HibernateTemplate selectByExample、findByCriteria、find等方法）； 8、简单的单表排序支持，支持多个排序条件组合； 9、对于复杂的sql查询，提供获取jdbctemplate实例进行操作，类似spring jdbc的常规用法； 10、提供Entity代码生成接口，Entity并非简单的pojo（尽可能不要去修改此类），引入字段常量类，方便查询的时候指定选择字段，从而更好实现查询条件的封装； 二、为什么写SBORM？ 1、hibernate：过于臃肿，使用不够灵活，优化难(其实主要是因为很少用)，HQL感觉就是个渣，在 mysql几乎一统天下的背景下，跨数据库级别的兼容吃力不讨好。Hibernate的对象化关联处理确实挺强大，但是使用起来坑太多，有多少人敢在项目 中大范围使用真不知道，屠龙刀不是人人都提的起啊。 2、mybatis：轻量级，基于xml的模式感觉不利于封装，代码量不小，基于xml维护也麻烦（个人观点， 现在注解模式貌似也挺不错），感觉mybatis更适合存在dba角色的年代，可以远离代码进行sql调优，复杂的查询拼装起来也更加优雅（java基本 就是if else ...）,但是对于查询业务简单但是数据库集群环境的场景有点憋屈（其实对mybatis使用也不多，瞎评论^_^）。 3、spring jdbc：小巧，灵活，足够优秀，个人比较喜欢使用，但是代码量偏大，原生的接口重复劳动量大，比如insert、mapper之类的； SBORM只是针对spring jdbc的一些不方便的地方，做了一些封装，更加简化日常的开发工作，基于spring jdbc的RowMapper自动实现对象映射，也勉强算的上叫ORM，只是大部分功能已经由spring jdbc实现了。 平时不太喜欢使用hibernate和mybatis，主要是使用spring jdbc，写这个东西的出发点主要是平时使用spring jdbc觉 得比较麻烦，重复性的代码偏多，一方面通过自动mapper降低返回结果处理工作量，另一方面参考hibernate对象化查询条件的模式，写了一个 QueryBudiler，使得更多简单的单表查询可以通过对象组织查询、更改逻辑，避免过多去写相似性的SQL语句，减少DAO接口量。 三、一些亮点 1、Entity的设计：很多人看了也许会说，这个不是POJO，不是纯粹的Java Bean，显得很另类。但是有多人在开发过程中（特别是在写sql的时候），经常要去看看表结构设计？还有多少次因为改了表某个字段，还得遍历去查找哪些 sql使用了这个字段？多少次看到在代码中直接传入字段名作为查询参数感到别扭？如果将表结构字段都用java对象去描述，能够解决这些问题，就不必要在 乎是不是POJO了，后面看example的时候应该能体会这么做的一些好处，至少我觉得是挺方便的，将大部分查询脱离表结构设计。 2、简单的数据库路由：如果分库结构不是太复杂（比如简单的读写分离、或者多个库集成），BaseDao可以自 动进行路由（比如读写分离，根据业务模式指定读、写库），如果非默认的路由规则，也可以通过手动设置的模式，进行数据库路由。数据库路由直接由 Entity指定，所有的路由都是根据Entity识别，也就是说查询也是围绕Entity展开的，避免类似使用spring jdbc的时候，各种 template实例跳来跳去，硬编码引入，写一个业务还得看看到底该用哪个template，尤其是多个数据库共用一个template实例的时候。 3、QueryBuilder：单表查询基本上都可以实现零Sql（除非查询条件特别复杂的），更新、删除等操作也可以通过QueryBuilder进行批量处理，不局限于根据主键来处理。 4、分表操作的支持：对于分表操作和常规的使用没有区别，只是指定分表规则，mybatis好像也可以通过制定参数实现分表处理，没搞清楚hibernate对这个是怎么处理的(hibernate好像是bean和表一对一绑定的)？ 标签：sborm
spring整合JDBC
dreamzuora的博客
04-15 1093
spring提供了很多模板整合Dao技术 因为在jdbc、Hibernate、Mybatis中都有对数据库封装好方法，但是不同的框架中方法名称都不相同，为了方便开发者调用和整理代码，Spring中提供了很多模板来整合Dao技术 spring中提供了一个可以操作数据库的对象.对象封装了jdbc技术. JDBCTemplate =&gt; JDBC模板对象 其实Sprin...
spring与jdbc集成
weixin_43031438的博客
10-10 154
一，先导个包，建立数据库 然后进行add path 建立联系 建立数据库 xml文件放进src文件 二，配置dbcp池 在spring 容器中定义，（xml） &lt;!--获取数据源--&gt; &lt;bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" &gt; &lt;prope...
spring框架集成JDBC
weixin_52394141的博客
09-30 385
Spring 是个一站式框架：Spring 自身也提供了控制层的 SpringMVC 和 持久层的 Spring JdbcTemplate。
Spring对jdbc的整合
wh123__的博客
10-05 163
Spring整合jdbc的步骤1.分别引入spring-context,mysql,druid,spring-jdbc等依赖2.在resources中创建application.xml配置文件3.在resources中创建jdbc.properties.xml,连接数据库的相关信息4.在application.xml中配置数据源,并检测是否成功Spring 提供了两个核心类去整合JDBC1.JdbcDaoSupport: 利用JDBC技术编写Dao父类,通过该类提供的方法,
spring对JDBC的整合支持
IT小生
06-07 2556
1、Spring对jdbc等数据库技术编写Dao提供了重要支持。      a、Spring对DAO异常提供了统一处理      b、Spring对DAO编写提供了支持的抽象类      c、提高编程效率，减少jdbc编码量spring对DAO异常支持spring把特定某种技术的异常，比如SQLException，统一转化为自己的异常类型，这些异
Spring --- Spring 集成 JdbcTemplate 完整步骤
yuanchenglong的博客
08-08 378
日常的开发工作中，数据库的操作几乎是必须的。在现有的框架中，springboot集成的mybatis，mybatis-plus较为友好。但是，在早期的开发中，spring的jdbcTemplate应用的尤为广泛。小编所在公司的老系统，用的几乎都是spring集成jdbcTemplate，老古董啦！不过确实没出啥问题，较为健壮吧。那么今天呢，小编给大家演示一下，如何在spring框架系统中，集成JdbcTemplate。1，编写xml配置文件：JdbcConfig.xml。3，编写Service。...
JDBC与ORM发展与联系 JDBC简介（九）
noteless的博客
01-29 389
JDBC与ORM发展与联系 JDBC简介（九） 概念回顾 回顾下JDBC的概念： JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。 JDBC提供了一种基准，据此可以构建更高级的工具和接...
java orm框架 博客园_基于springJDBC手写ORM框架
weixin_42316286的博客
02-28 166
一、添加MySQLjar包依赖二、结构三、文件内容(一)、bean包1、ColumnInfo.java2、javaFiledInfo.java3、TableInfo.java4、Configration.java 用于映射properities配置文件的属性(二)、配置文件1、properties配置文件(三)、util包1、2、3、4、运用反射机制getClass获得当前的传入来的类的Cl...
Spring JDBC与ORM集成实例详解及其异常处理
Spring框架对JDBC（Java Database Connectivity）和ORM（Object-Relational Mapping）提供了全面的支持，使得开发者能够在不同的数据库访问技术之间轻松切换，同时保持代码的简洁和异常处理的一致性。以下是Spring对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值