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 < ...
随机推荐
- python 文件批量改名重命名 rename
path = '/Volumes/Seagate/dev/imgs/' os.chdir(path) print('cwd: ', os.getcwd()) for f in os.listdir(' ...
- vue 上传头像悬浮显示文字
template部分: 头像外部加一个 div <div class="user-info-head"> </div> css 部分 <style ...
- 在node节点部署kubectl管理k8s集群
感谢!原文链接:https://blog.csdn.net/sinat_35930259/article/details/79994078 kubectl是k8s的客户端程序,也是k8s的命令行工具, ...
- C# Equals方法和==有什么区别
开发工具:VS2019 一.关于这两个比较,需要从值类型和引用类型两方面来说 (A)先说值类型 上图: 因为在对值类型进行比较时候,不管 .Equals() 方法还是 == 方法,都是对值类型变量(图 ...
- Gitlab（1）- 简单介绍
什么是 Gitlab 一个开源分布式版本控制系统 开发语言:Ruby 功能:管理项目源代码.版本控制.代码复用与查找.权限管控 Git 家族成员 Git:是一种版本控制系统,是一个命令,是一种工具 G ...
- MyBatis的多表查询笔记
MyBatis的多表查询 随着学习的进步,需求的提高,我们在实际开发中用的最多的还是多表查询,就让我们一起学习MyBatis中的多表查询. 数据库准备 Class表 Student表 项目结构 这次使 ...
- Sentry Web 性能监控 - Trends
系列 1 分钟快速使用 Docker 上手最新版 Sentry-CLI - 创建版本 快速使用 Docker 上手 Sentry-CLI - 30 秒上手 Source Maps Sentry For ...
- SpringBoot-Web-初见
目录 怎么开发一个网站? 静态资源 找到静态资源的存放目录 扩展自定义路径 首页定制 模板引擎Thymeleaf 员工管理系统-初见 国际化 国际化实现 编写国际化配置类 登陆功能 编写index.h ...
- 机器学习——逻辑回归（Logistic Regression）
1 前言 虽然该机器学习算法名字里面有"回归",但是它其实是个分类算法.取名逻辑回归主要是因为是从线性回归转变而来的. logistic回归,又叫对数几率回归. 2 回归模型 2. ...
- Android View post 方法
解析View.post方法.分析一下这个方法的流程. 说起post方法,我们很容易联想到Handler的post方法,都是接收一个Runnable对象.那么这两个方法有啥不同呢? Handler的po ...