Spring框架访问数据库的两种方式的小案例
1.1 以Xml的方式访问数据库的案例
要以xml的方式访问数据库需要用到JdbcTemplate ，因为 JdbcTemplate（jdbc的模板对象）在Spring 中提供了一个可以操作数据库的对象org.springframework.jdbc.core.JdbcTemplate。
以xml的方式访问数据库的案例主要是以下几个步骤：
（1） 创建user（对应的表）表并添加数据
CREATE TABLE USER(
id INT,
username VARCHAR(20),
PASSWORD VARCHAR(20)
) INSERT INTO USER(id,username,PASSWORD) VALUES(1001,'jack','123');
INSERT INTO USER(id,username,PASSWORD) VALUES(1002,'rose','456');
INSERT INTO USER(id,username,PASSWORD) VALUES(1003,'tom','789');
(2) 创建maven工程后，在pom.xml中导入依赖
<dependencies>
<!-- Spring的核心依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.10</version>
</dependency> <!-- jdbc模板对象依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.10</version>
</dependency> <!-- mysql数据库的依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency> <!-- 连接池的依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency> <!-- 注解的依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency> <!-- 用于测试的依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency> </dependencies>
（3）创建实体类
package com.qf.pojo; import lombok.Data; @Data
public class User { private Integer id;
private String name;
private String password; }
（4）创建Mapper层的UserMapper接口及UserMapperImpl实现类
package com.qf.mapper;
import com.qf.pojo.User;
import java.util.List;
public interface UserMapper {
//查询所有
public List<User> findAll();
}
package com.qf.mapper.impl; import com.qf.mapper.UserMapper;
import com.qf.pojo.User;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate; import java.util.List; public class UserMapperImpl implements UserMapper { //声明jdbc模板对象（jdbcTemplate），调用方法
private JdbcTemplate jdbcTemplate; //set方法注入
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
} @Override
public List<User> findAll() { //准备sql语句
String sql ="select id,name,password from t_user";
//调用方法，query：查询
// update: 修改
// BeanPropertyRowMapper：是jdbcTemplate内封装好的对象，保存着由查询所有方法及实体类属性得到的查询数据
List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class)); return users;
}
}
(5) 创建Service层的UserService接口以及UserServiceImpl实现类
package com.qf.service;
import com.qf.pojo.User;
import java.util.List;
public interface UserService {
public List<User> findAll();
}
package com.qf.service.impl; import com.qf.mapper.UserMapper;
import com.qf.pojo.User;
import com.qf.service.UserService; import java.util.List; public class UserServiceImpl implements UserService { // 声明userMapper
private UserMapper userMapper; // set注入
public void setUserMapper(UserMapper userMapper) {
this.userMapper = userMapper;
} @Override
public List<User> findAll() {
return userMapper.findAll();
}
}
（6）创建controller层的UserController
package com.qf.controller; import com.qf.pojo.User;
import com.qf.service.UserService; import java.util.List; public class UserController {
//声明userService
private UserService userService; //提供set方法，在配置文件通过set方法注入
public void setUserService(UserService userService) {
this.userService = userService;
}
//创建findAll方法
public List<User> findAll(){
return userService.findAll();
}
}
(7) 创建jdbc.properties配置文件
db.username = root
db.password = root
db.driverClassName = com.mysql.cj.jdbc.Driver
db.url = jdbc:mysql://localhost:3306/java2109?serverTimezone=Asia/Shanghai&characterEncoding=UTF8
（8） 创建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: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/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here --> <!--引入配置文件 将db.properties加载到配置文件用来连接数据库 -->
<!-- property-placeholder：引入外部配置文件
location：位置
classpath：当前src下的目录
-->
<context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <!-- 引入数据源（当前使用的数据连接池）
property：将对象的对应属性注入值
-->
<bean id="dataSoure" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="root"></property>
<property name="password" value="root"></property>
<property name="url" value="${db.url}"></property>
<property name="driverClassName" value="${db.driverClassName}"></property> </bean> <!-- 创建JdbcTemplate对象-->
<bean id="JdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSoure"></property>
</bean> <!-- Dao层-->
<bean id="userMapper" class="com.qf.mapper.impl.UserMapperImpl">
<property name="jdbcTemplate" ref="JdbcTemplate"></property>
</bean> <!-- Service层-->
<bean id="userService" class="com.qf.service.impl.UserServiceImpl">
<property name="userMapper" ref="userMapper"></property>
</bean> <!-- Controller层-->
<bean id="userController" class="com.qf.controller.UserController">
<property name="userService" ref="userService"></property>
</bean>
</beans>
（9）创建测试类SpringTest
package com.qf.test; import com.qf.controller.UserController;
import com.qf.pojo.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext; import java.util.List; public class SpringTest {
@Test public void testFindAll() {
//加载配置文件，创建applicationContext对象
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Bean对象（即userController）
UserController userController =(UserController) applicationContext.getBean("userController");
//调用findAll方法
List<User> userList = userController.findAll();
System.out.println(userList);
}
}
(10) 测试结果
[User(id=1, name=jack, password=123), User(id=2, name=tom, password=456), User(id=3, name=rose, password=789)] Process finished with exit code 0
2 以注解的方式访问数据库
（1）Spring中的注解
@Configuration
作用：指定当前类是一个配置类
细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。 @ComponentScan
作用：用于通过注解指定spring在创建容器时要扫描的包
属性：value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。
等同于xml中: <context:component-scan base-package="com.qf"/> @PropertySource
作用：用于指定properties文件的位置
属性：value：指定文件的名称和路径。
关键字：classpath，表示类路径下 等同于xml中: <context:property-placeholder location="classpath:jdbc.properties"/> @Bean
作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
属性:name:用于指定bean的id。当不写时，默认值是当前方法的名称
细节：当我们使用注解配置方法时，如果方法有参数，在参数前加：
@Qualifier("@Bean注解中name的值")，spring框架会去容器中查找有没有可用的bean对象查找的方式和Autowired注解的作用是一样的。
@Import
作用：用于导入其他的配置类
属性：value：用于指定其他配置类的字节码。
当我们使用Import的注解之后，有Import注解的类就父配置类，而导入的都是子配置类
等同于xml中: <import resource="xxx.xml"></import>
（2） 创建user（对应的表）表并添加数据
CREATE TABLE USER(
id INT,
username VARCHAR(20),
PASSWORD VARCHAR(20)
) INSERT INTO USER(id,username,PASSWORD) VALUES(1001,'jack','123');
INSERT INTO USER(id,username,PASSWORD) VALUES(1002,'rose','456');
INSERT INTO USER(id,username,PASSWORD) VALUES(1003,'tom','789');
(3) 创建maven工程后，在pom.xml中导入依赖
<dependencies>
<!-- Spring的核心依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.10</version>
</dependency>
<!-- jdbc模板对象依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.10</version>
</dependency>
<!-- mysql数据库的依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</dependency>
<!-- 连接池的依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<!-- 注解的依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
<!-- 用于测试的依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency> <!-- 集成junit包
为了解决纯注解时找不到配置文件不好测试问题
-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.10</version>
</dependency>
</dependencies>
(4) 创建jdbc.properties配置文件
db.username = root
db.password = root
db.driverClassName = com.mysql.cj.jdbc.Driver
db.url = jdbc:mysql://localhost:3306/java2109?serverTimezone=Asia/Shanghai&characterEncoding=UTF8
（5）创建SpringConfiguration.java作为注解配置类(==bean.xml)
package com.qf.config;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
import java.util.Properties;
//指定当前类为配置类，优于其他类先执行，替换applicationContext.xml文件
@Configuration
//@PropertySource用于指定properties文件的位置
//引入配置文件，连接数据库
@PropertySource(value = "classpath:db.properties")
@ComponentScan("com.qf")//扫描对应包下的注解
public class SpringConfiguration {
//引入配置文件db.properties的属性、值
@Value("${db.username}")
private String username;
@Value("${db.password}")
private String password;
@Value("${db.url}")
private String url;
@Value("${db.driverClassName}")
private String driverClassName;
@Bean//把当前方法的返回值放在Spring容器中，相当于<bean id = "" class = "">
//为了不再单独写一个数据源，将数据源（连接池）封装到JdbcTemplate，返回JdbcTemplate获得数据源
public JdbcTemplate getJdbcTemplate(){
//创建properties对象，为了获取数据源
Properties properties = new Properties();
//设置对应参数，获得对应数据源的值
properties.setProperty("username",username);
properties.setProperty("password",password);
properties.setProperty("url",url);
properties.setProperty("driverClassName",driverClassName);
try {
//获取数据源
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
//返回Jdbc模版对象
return new JdbcTemplate(dataSource);
} catch (Exception e) {
e.printStackTrace();
}
throw new RuntimeException("连接数据库异常");
}
}
（6）创建实体类
package com.qf.pojo;
import lombok.Data;
@Data
public class User {
private Integer id;
private String name;
private String password;
}
（7）创建controller层的UserController
package com.qf.controller;
import com.qf.pojo.User;
import com.qf.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller//把当前类对象存入spring容器中
public class UserController {
@Autowired//按照类型自动注入
private UserService userService;
public User findById(Integer id){
return userService.findById(id);
}
}
（8）创建Mapper层的UserMapper接口及UserMapperImpl实现类
package com.qf.mapper;
import com.qf.pojo.User;
public interface UserMapper { User findById(Integer id);
}
package com.qf.mapper.impl;
import com.qf.mapper.UserMapper;
import com.qf.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository//把当前类对象存入spring容器中
public class UserMapperImpl implements UserMapper {
@Autowired//按照类型自动注入
//引入jdbcTemplate，调用方法
private JdbcTemplate jdbcTemplate;
@Override
public User findById(Integer id) {
//准备sql语句
String sql = "select id,name,password from t_user where id = ?";
//调用方法，并返回查询数据
// query：查询
// update: 修改
// BeanPropertyRowMapper：是jdbcTemplate内封装好的对象，保存着由查询所有方法及实体类属性得到的查询数据
// 返回值是一个集合，加get(0)表示获取集合的第一个对象返回
return jdbcTemplate.query(sql,new BeanPropertyRowMapper<>(User.class),id).get(0);
}
}
(9) 创建Service层的UserService接口以及UserServiceImpl实现类
package com.qf.service;
import com.qf.pojo.User;
public interface UserService { User findById(Integer id);
}
package com.qf.service.impl;
import com.qf.mapper.UserMapper;
import com.qf.pojo.User;
import com.qf.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service////把当前类对象存入spring容器中
public class UserServiceImpl implements UserService {
@Autowired//按照类型自动注入
//引入userMapper，调用方法
private UserMapper userMapper;
@Override
public User findById(Integer id) {
return userMapper.findById(id);
}
}
(10) 创建测试类SpringTast
package com.qf.test;
import com.qf.config.SpringConfig;
import com.qf.config.SpringConfiguration;
import com.qf.controller.UserController;
import com.qf.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)//集成Juint，测试纯注解访问数据库
//@ContextConfiguration(classes= SpringConfiguration.class)//引入配置类
@ContextConfiguration(classes= SpringConfig.class)//引入配置类
public class SpringTest {
//按照类型自动注入
@Autowired
//引入userController，调用方法
private UserController userController;
@Test
public void testFindById(){
User user = userController.findById(3);
System.out.println(user);
}
}
(11) 测试结果
[User(id=1, name=jack, password=123), User(id=2, name=tom, password=456), User(id=3, name=rose, password=789)]
Process finished with exit code 0
Spring框架访问数据库的两种方式的小案例的更多相关文章
- Django框架操作数据库的两种方式
Django操作数据库的前提操作是成功连接数据库,详情见上篇:https://www.cnblogs.com/kristin/p/10791358.html Django查询数据库的方式一 from ...
- .NET访问数据库的两种方式(C#语言）
一.直接使用C#操作数据库的类库ADO.NETADO.NET使用Connection对象来连接数据库,使用Command或DataAdapter 对象来执行SQL语句,并将执行的结果返回给DataRe ...
- .Net 中读写Oracle数据库常用两种方式
.net中连接Oracle 的两种方式:OracleClient,OleDb转载 2015年04月24日 00:00:24 10820.Net 中读写Oracle数据库常用两种方式:OracleCli ...
- Spring Boot配置过滤器的两种方式
过滤器(Filter)是Servlet中常用的技术,可以实现用户在访问某个目标资源之前,对访问的请求和响应进行拦截,常用的场景有登录校验.权限控制.敏感词过滤等,下面介绍下Spring Boot配置过 ...
- Spring Boot 整合 Shiro ，两种方式全总结！
在 Spring Boot 中做权限管理,一般来说,主流的方案是 Spring Security ,但是,仅仅从技术角度来说,也可以使用 Shiro. 今天松哥就来和大家聊聊 Spring Boot ...
- JPA访问数据库的几种方式
JPA访问数据库的几种方式 本文为原创,转载请注明出处:https://www.cnblogs.com/supiaopiao/p/10901793.html 1. Repository 1.1. 通过 ...
- spring接收json字符串的两种方式
一.前言 前几天遇到一个问题,前端H5调用我的springboot一个接口(post方式,@RequestParameter接收参数),传入的参数接收不到.自己测试接口时使用postman的form- ...
- Android开发之使用sqlite3工具操作数据库的两种方式
使用 sqlite3 工具操作数据库的两种方式 请尊重他人的劳动成果,转载请注明出处:Android开发之使用sqlite3工具操作数据库的两种方式 http://blog.csdn.net/feng ...
- Servlet访问路径的两种方式、Servlet生命周期特点、计算服务启动后的访问次数、Get请求、Post请求
Servlet访问路径的两种方式: 1:注解 即在Servlet里写一个@WebServlet @WebServlet("/myServlet") 2:配置web.xml < ...
随机推荐
- 由Eratosthenes筛法演变出的一种素数新筛法
这两天和walls老师交流讨论了一个中学竞赛题,我把原题稍作增强和变形,得到如下一个题: 从105到204这100个数中至少要选取多少个数才能保证选出的数中必有两个不是互素的? 我们知道最小的几个素数 ...
- MySQL列举常见的关系型数据库和非关系型都有那些？
关系型数据库: Oracle.DB2.Microsoft SQL Server.Microsoft Access.MySQL 非关系型数据库: NoSql.Cloudant.MongoDb.redis ...
- MFC中L, _T(),TEXT,_TEXT区别以及含义
字符串前面加L表示该字符串是Unicode字符串. _T是一个宏,如果项目使用了Unicode字符集(定义了UNICODE宏),则自动在字符串前面加上L,否则字符串不变.因此,Visual C++里边 ...
- cmd（命令行 ）的命令
cmd是command的缩写.即命令行 CMD命令锦集 1. gpedit.msc-----组策略 2. sndrec32-------录音机 3. Nslookup-------IP地址侦测器 ,是 ...
- Python之uiautomation模块-获取CMD窗口中所打印的文字信息
当我们想以自动化的方式操作软件,以提高办公或测试效率时,有许多成熟的工具,比如针对Web端应用的Selenium.针对移动端应用的Appium.那么,PC端(Windows)桌面应用,又改如何处理呢? ...
- TreeView和ListView数据库查询数据联动操作
好久不用了,重新整理下放这里以备需要使用,功能见图 数据库表结构 定义TreeView addObject中data存储的记录集 type PNode = ^TNode; TNode = record ...
- Tars | 第2篇 TarsJava SpingBoot启动与负载均衡源码初探
目录 前言 1. Tars客户端启动 @EnableTarsServer 2. Communicator通信器 3. 客户端的负载均衡调用器LoadBalance 最后 前言 通过源码分析可以得出这样 ...
- FastAPI（4）- get 请求 - 路径参数 Path Parameters
什么是路径 假设一个 url 是: http://127.0.0.1:8080/items/abcd 那么路径 path 就是 /items/abcd 路径参数 就是将路径上的某一部分变成参数,可通过 ...
- COS控制台进阶 - 文件预览和在线编辑
导语 | COS控制台新上线了文件预览功能,用户可在控制台内直接预览.编辑文件内容. 前不久,微软发布了 vscode for web 的公告,是基于web的在线代码编辑器,无需下载安装可以直接在we ...
- 学习PHP中的国际化功能来查看货币及日期信息
做为一门在世界范围内广泛使用的编程语言,国际化能力往往是衡量一个编程语言是否能够大范围流行的重要内容.特别是对于 PHP 这种以 Web 页面编程为主战场的语言来说,国际化能力更是重中之重.在 PHP ...