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 < ...

随机推荐

Hadoop及Hbase部署
原文转自:https://www.cnblogs.com/itzgr/p/10233932.html作者:木二目录一环境准备 1.1 相关环境 1.2 网络环境二基础环境配置 2.1 配置相 ...
整理之Service
Service 基础一个Service的基本结构 class MyService : Service() { private val mBinder = MyBinder() override fu ...
vue element-ui 组件上传图片以及对图片的宽高和大小格式等做出限制
vue 文件: 自行引用 elemen-ui <el-upload action=" 让后端给你上传地址 " ...
MyBatis学习总结(三)——MyBatis配置文件配置的优化
一.连接数据库的配置单独放在一个properties文件中上文连接数据库的配置写在 mybatisConf.xml中,本文直接放在 db.properties 中, 在mybatisConf.xm ...
Vs code自动生成Doxygen格式注释
前言程序中注释的规范和统一性的重要性不言而喻,本文就推荐一种在用vscode编写代码时自动化生成标准化注释格式的方法,关于Doxygen规范及其使用可查看博文代码注释规范之Doxygen. ...
Linux常用命令 - rm命令详解
21篇测试必备的Linux常用命令,每天敲一篇,每次敲三遍,每月一循环,全都可记住!! https://www.cnblogs.com/poloyy/category/1672457.html 删除/ ...
Spring Boot 2.x 之 H2 数据库
1. Spring Boot下H2数据库的常用配置项 # 指定数据库的类型 spring.datasource.platform=h2 # 数据库连接地址(文件模式) ## AUTO_SERVER=T ...
Linux 文本相关命令（1）
Linux 文本相关命令(1) 前言最近线上环境(Windows Server)出现了一些问题,需要分析一下日志.感觉 Windows 下缺少了一些 Linux 系统中的小工具,像在这波操作中用到的 ...
spark相关介绍-提取hive表（一）
本文环境说明 centos服务器 jupyter的scala核spylon-kernel spark-2.4.0 scala-2.11.12 hadoop-2.6.0 本文主要内容 spark读取hi ...
洛谷P1603——斯诺登的密码（字符串处理）
https://www.luogu.org/problem/show?pid=1603#sub 题目描述 2013年X月X日,俄罗斯办理了斯诺登的护照,于是他混迹于一架开往委内瑞拉的飞机.但是,这件事 ...

Spring框架访问数据库的两种方式的小案例

1.1 以Xml的方式访问数据库的案例

（1） 创建user（对应的表）表并添加数据

(2) 创建maven工程后，在pom.xml中导入依赖

（3）创建实体类

（4）创建Mapper层的UserMapper接口及UserMapperImpl实现类

(5) 创建Service层的UserService接口以及UserServiceImpl实现类

（6）创建controller层的UserController

(7) 创建jdbc.properties配置文件

（8） 创建applicationContext.xml配置文件

（9）创建测试类SpringTest

(10) 测试结果

2 以注解的方式访问数据库

（1）Spring中的注解

（2） 创建user（对应的表）表并添加数据

(3) 创建maven工程后，在pom.xml中导入依赖

(4) 创建jdbc.properties配置文件

（5）创建SpringConfiguration.java作为注解配置类(==bean.xml)

（6）创建实体类

（7）创建controller层的UserController

（8）创建Mapper层的UserMapper接口及UserMapperImpl实现类

(9) 创建Service层的UserService接口以及UserServiceImpl实现类

(10) 创建测试类SpringTast

(11) 测试结果

Spring框架访问数据库的两种方式的小案例的更多相关文章

随机推荐

热门专题

（1）创建user（对应的表）表并添加数据

（8）创建applicationContext.xml配置文件

（2）创建user（对应的表）表并添加数据