Spring集成持久层

spring对持久层提供了集成方案，包括对事务，jdbc等，还有MyBatis，MyBatis的集成由MyBatis自己提供

spring集成jdbc：

主要体现在JdbcTemplate类上面，spring自己提供的集成，是spring提供的对jdbc操作的便捷类。

提供了以DataSource（数据源）为构造参数的构造方法，使用步骤：

1.配置DataSource 因为不是自己写的所以要在配置类中引入，通过@Bean引入

2.定义Dao组件，Dao组件中定义JdbcTemplate属性，通过构造方法注入DataSource对象，创建JdbcTemplate，并赋值于jdbcTemplate属性。

3.定义业务组件，注入Dao组件

DataSource：

javax.sql.DataSource是Java提供的以连接池技术管理数据库连接的标准接口，具体实现由第三方提供，有C3P0,dbcp，proxool和druid

一. 导入必要的依赖

<dependencies>
        <!--spring上下文-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--spring对jdbc的集成-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <!--spring的测试方法-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--测试方法的具体依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>

二. 开发配置类

import com.alibaba.druid.pool.DruidDataSource;
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 javax.sql.DataSource;

@Configuration
@ComponentScan({"org.xupt.ygq.demo.dao","org.xupt.ygq.demo.service"})
//属性资源读取 ignoreResourceNotFound如果某个属性没找到忽略资源  不报错
@PropertySource(value = "classpath:application.properties",ignoreResourceNotFound = true)
public class MyConfig {
    //数据源需要的四个参数，我们从属性中进行加载，属性的值我们存放在资源文件中
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.url}")
    private String url;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    //数据源是第三方写的所以我们只能在配置类里面配置，自己写的就可以用@Component注解放入容器中
    @Bean
    public DataSource druidDataSource(){
        //创建一个数据源
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUrl(url);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }
}

 配置类总共四个注解：

①：@Configuration表示这是一个配置类

②：@ComponentScan表示这个配置类将要扫描的包，这里集成持久层，就去扫描持久底的包，最后还有引入业务组件

③：@PropertySource表示属性资源的读取，我们把对数据库操作需要的url等都定义在了资源文件夹下面，取值的时候需要在对应的属性上面加@Value通过${}赋值

④：@Bean表示这是受spring管理的一个bean，通过这样，把数据源引入spring容器中，以便注入到JdbcTemplate里面

三. 编写资源文件

 

 四. 开发Dao组件

 

import org.xupt.ygq.demo.dto.UserDto;
import org.xupt.ygq.demo.model.User;

import java.util.List;

public interface MyDao {
    public void createUserTable();

    public List<User> findUserList();

    public void insertOneUser(UserDto userDto);
}

主要来看Dao的实现类：

import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import org.xupt.ygq.demo.dao.MyDao;
import org.xupt.ygq.demo.dto.UserDto;
import org.xupt.ygq.demo.model.User;

import javax.sql.DataSource;
import java.util.List;

@Repository//本注解专门用在持久化组件上，说明组件为受spring管理的数据访问对象
public class MyDaoImpl implements MyDao {
    //JdbcTemplate是spring提供的jdbc操作便捷类
    private JdbcTemplate jdbcTemplate;
    //数据源在这里由构造方法注入，不需要加注解，只要方法上有spring bean注解、@Component、@RestController、@Service
    public MyDaoImpl(DataSource ds) {
        this.jdbcTemplate = new JdbcTemplate(ds);//以数据源为构造参数的构造方法
    }

    public void createUserTable(){
        jdbcTemplate.execute("drop table if exists t_user");
        String sql =
                "create table t_user(u_id varchar(20) primary key,u_name varchar(20) not null,u_pwd varchar(20) not null)";
        jdbcTemplate.execute(sql);
        for (int i =1001;i<=1100;i++){
            jdbcTemplate.update
                    ("insert into t_user (u_id,u_name,u_pwd) values (?,?,?)",i,"用户"+i,"123456");
        }
    }

    @Override
    public List<User> findUserList() {
        //创建一个javabean与查询结果的映射器，负责将查询到的结果，封装到JavaBean中去 bean属性映射器，bean属性和行之间的映射
        RowMapper rowMapper = new BeanPropertyRowMapper(User.class);
        List<User> list = jdbcTemplate.query("select * from t_user",rowMapper);
        return list;
    }

    @Override
    public void insertOneUser(UserDto userDto) {
        jdbcTemplate.update("insert into t_user (u_id,u_name,u_pwd) values (?,?,?)",userDto.getU_id(),userDto.getU_name(),userDto.getU_pwd());
    }
}

一个注解：为什么只有一个注解，因为DataSource依赖构造方法注入不需要注解，只要保证类上面有注解表示这个类收spring容器管理即可

@Repository：本注解专门应用在持久化组件上面，说明组件为受spring管理的数据访问对象

一个属性：

JdbcTemplate：spring提供的对jdbc操作的便捷类，通过以DataSource为参数的构造方法创建，我们通过构造方法的方式对这个属性进行赋值，这样子可以不用注解

里面的方法自己结合后面的代码看吧：

public class UserDto {
    private String u_id;
    private String u_name;
    private String u_pwd;

    public String getU_id() {
        return u_id;
    }

    public void setU_id(String u_id) {
        this.u_id = u_id;
    }

    public String getU_name() {
        return u_name;
    }

    public void setU_name(String u_name) {
        this.u_name = u_name;
    }

    public String getU_pwd() {
        return u_pwd;
    }

    public void setU_pwd(String u_pwd) {
        this.u_pwd = u_pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "u_id='" + u_id + '\'' +
                ", u_name='" + u_name + '\'' +
                '}';
    }
}

public class User {
    private String u_id;
    private String u_name;

    public String getU_id() {
        return u_id;
    }

    public void setU_id(String u_id) {
        this.u_id = u_id;
    }

    public String getU_name() {
        return u_name;
    }

    public void setU_name(String u_name) {
        this.u_name = u_name;
    }

    @Override
    public String toString() {
        return "User{" +
                "u_id='" + u_id + '\'' +
                ", u_name='" + u_name + '\'' +
                '}';
    }
}

测试方法：

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.SpringRunner;
import org.xupt.ygq.demo.config.MyConfig;
import org.xupt.ygq.demo.dao.MyDao;
import org.xupt.ygq.demo.dto.UserDto;
import org.xupt.ygq.demo.model.User;
import org.xupt.ygq.demo.service.MyService;

import javax.sql.DataSource;
import java.util.List;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = MyConfig.class)
public class MyTest {
    @Autowired
    private DataSource ds;
    @Test
    public void test1(){
        System.out.println(ds);
    }
    @Autowired
    private MyDao myDao;
    @Test
    public void testDaoCreateUserTable(){
        myDao.createUserTable();
    }
    @Test
    public void testDaoFindUserList(){
        List<User> list = myDao.findUserList();
        list.stream().forEach(user-> System.out.println(user));
    }
    @Test
    public void testDaoInsertOneUser(){
        UserDto userDto = new UserDto();
        userDto.setU_id("A001");
        userDto.setU_name("人");
        userDto.setU_pwd("00000");
        myDao.insertOneUser(userDto);
    }
    @Autowired
    private MyService myService;
    @Test
    public void testFnOfMyService(){
        myService.fn();
    }
}

五. 业务组件的开发

 

public interface MyService {
    public void fn();
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.xupt.ygq.demo.dao.MyDao;
import org.xupt.ygq.demo.dto.UserDto;
import org.xupt.ygq.demo.service.MyService;
@Service
public class MyServiceImpl implements MyService {
    @Autowired
    private MyDao myDao;

    @Override
    public void fn() {
        UserDto userDto = new UserDto();
        userDto.setU_id("A002");
        userDto.setU_name("人2");
        userDto.setU_pwd("000002");
        myDao.insertOneUser(userDto);
    }
}

业务组件依靠Dao里面的方法，所以要把Dao注入进来，测试方法在上面。

最后包结构展示：