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框架访问数据库的两种方式的小案例

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框架访问数据库的两种方式的小案例的相关教程结束。

相关推荐

Unity的AssetPostprocessor之Model：深入解析与实用案例 1

Blazor前后端框架Known-V1.2.11

Unity的IUnityLinkerProcessor：深入解析与实用案例

C#/.NET/.NET Core优秀项目和框架每周精选（坑已挖，欢迎大家踊跃提交PR或者Issues中留言）

.Net Core 3.0 对 MongoDB 的多条件查询（两种）操作

js 关于 replace 取值、替换第几个匹配项（两种方式：正则、普通字符串操作）

Spring核心框架 - AOP的原理及源码解析

从案例中详解go-errgroup-源码

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框架访问数据库的两种方式的小案例的相关教程结束。

相关推荐

Unity的AssetPostprocessor之Model：深入解析与实用案例 1

Blazor前后端框架Known-V1.2.11

Unity的IUnityLinkerProcessor：深入解析与实用案例

C#/.NET/.NET Core优秀项目和框架每周精选（坑已挖，欢迎大家踊跃提交PR或者Issues中留言）

.Net Core 3.0 对 MongoDB 的多条件查询（两种）操作

js 关于 replace 取值、替换第几个匹配项（两种方式：正则、普通字符串操作）

Spring核心框架 - AOP的原理及源码解析

从案例中详解go-errgroup-源码

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

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

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