您的位置 首页 java

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

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

要以xml的方式访问数据库需要用到 Jdbc Template ,因为 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. Spring framework</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="#34;
       xmlns:xsi="#34;
       xmlns:context="#34; xsi:schemaLocation="
         Bean s 
         #34;> <!-- 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.Druid dataSource ">
        <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. ClassPath XmlApplicationContext;

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
    作用:指定当前类是一个配置类
    细节:当配置类作为 Annotation ConfigApplicationContext对象创建的参数时,该注解可以不写。

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

文章地址:https://www.zhihuclub.com/200711.shtml

关于作者: 智云科技

热门文章

发表回复

您的电子邮箱地址不会被公开。

网站地图