spring sqlite resources怎么配置 spring配置mysql数据源

Spring配置数据源

数据源（连接池）的作用

数据源的开发步骤

数据源的手动创建

导入所需要的数据源以及mysql的坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Spring_loc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>mchange-commons-java</artifactId>
            <version>0.2.20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>

    </dependencies>

</project>

创建C3P0连接池

创建数据源，在数据源对象创建好了之后需要设置参数，参数主要有以下4种，mysql驱动，url，用户名，密码。坐标导入之后我们需要调用c3p0数据源的getconnection属性返回connection对象。

@Test
    // 手动测试c3p0数据源
    public void test1() throws Exception {
        // 创建数据源
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 设置参数
        // 设置驱动
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        // 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db1");

        dataSource.setUser("root");
        dataSource.setPassword("1234");

        Connection connection = dataSource.getConnection();
        System.out.println(connection);

        connection.close();
    }

创建Druid连接池

@Test
    // 手动测试druid数据源
    public void test2() throws SQLException, SQLException {
        DruidDataSource druidDataSource = new DruidDataSource();

        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/db1");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("1234");

        DruidPooledConnection connection = druidDataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

简化参数设置方法

我们可以发现，每次配置一个数据源就需要重复输入4个相同的参数指标，这样会造成冗余。

在当前文件路径下的resource文件夹下创建jdbc.proprities(我的代码为了方便都是写在test文件夹下)

jdbc文件配置如下

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/db1
jdbc.username = xxx
jdbc.password = xxx

读取jdbc.properties配置文件创建连接池

我们对jdbc.properties文件先进行解析，解析出来相关的参数，然后传入到C3P0的数据源解析代码中。

@Test
    // 手动测试c3p0数据源(加载配置源)
    public void test3() throws Exception {
        // 解析数据配置源
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.password");

        System.out.println(driver);
        System.out.println(url);
        System.out.println(username);
        System.out.println(password);
        
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);

        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

Spring创建数据源

• 可以将DataSource的创建权交由Spring容器去完成。
• DataSource有无参构造方法，而Spring默认就是通过无参构造方法实例化对象的。
• DataSource要想使用需要通过set方法设置数据库连接信息，而Spring可以通过set方法进行字符串注入。

<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3360/db1"/>
        <property name="user" value="xxxx"/>
        <property name="password" value="xxxx"/>
    </bean>

测试从容器当中获取数据源

@Test
    public void test4() throws Exception{

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationcontext.xml");

        System.out.println(app);

//        DataSources dataSources = app.getBean(DataSources.class);
        ComboPooledDataSource datasource = (ComboPooledDataSource) app.getBean("datasource");
        System.out.println(datasource);


//        System.out.println(datasource);

        Connection connection = datasource.getConnection();
        System.out.println(connection);
        connection.close();

    }

抽取jdbc配置文件

applicationContext.xml加载jdbc.properties配置文件获得连接信息。首先，需要引入context命名空间和约束路径：命名空间 : xmlns:context=“http://www.springframework.org/schema/context”约束路径：http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

<?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">

<!--    加载外部的propoties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

其中通过context配置文件我在bean文件中可以引入。

Spring注解开发

Spring原始注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效。Spring原始注解主要是替代的配置

使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--    配置组件扫描-->
    <context:component-scan base-package="com.peihj"/>

使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

在dao层用Repository

// <bean id="userdao" class="com.peihj.dao.impl.Userdaoimpl"/>
//@Component("userdao")
@Repository("userdao")
public class Userdaoimpl implements Userdao {

    @Override
    public void save() {
        System.out.println("save running dao........");
    }
}

使用@Compont或@Service标识UserServiceImpl需要Spring进行实例化

使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注@Autowired：是按照数据类型从容器中进行匹配的，在本代码中，先找一个userdao类型的bean然后将bean文件直接注入下方代码的userdao，在当前的Spring容器中也是有userdao类型的，因为之前dao包下用@Resposities将userdao注入了Spring容器。如果该容器有多个userdao类型的bean那么他再注入就不知道注入哪一个了。@Qualifier：根据id名称从容器中进行匹配但是需要结合@Autowired一起使用。@Resource(name = “userdao”) // 相当于前两个结合使用。

// <bean id="userservice" class="com.peihj.service.impl.Userserviceimpl">
//@Component("userservice")
@Service("userservice")
//@Scope()
public class Userserviceimpl implements Userservice {

    // <property name="userdao" ref="userdao"/>
//    @Autowired
//    @Qualifier("userdao")
    @Value("${jdbc.driver}")
    private String name;

    @Resource(name = "userdao")  // 相当于前两个结合使用
    private Userdao userdao;
    public void setUserdao(Userdao userdao) {
        this.userdao = userdao;
    }

    @Override
    public void save() {
        System.out.println(name);
        userdao.save();
    }
    @PostConstruct
    public void init(){
        System.out.println("service对象的创建方法。");
    }
    @PreDestroy
    public void destory(){
        System.out.println("service对象的销毁方法。");
    }
}

使用@Value进行字符串的注入

package com.peihj.service.impl;

import com.peihj.dao.Userdao;
import com.peihj.service.Userservice;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

// <bean id="userservice" class="com.peihj.service.impl.Userserviceimpl">
//@Component("userservice")
@Service("userservice")
//@Scope()
public class Userserviceimpl implements Userservice {

    // <property name="userdao" ref="userdao"/>
//    @Autowired
//    @Qualifier("userdao")
    @Value("注入普通数据")
    private String normal;
    
    @Value("${jdbc.driver}")
    private String name;

    @Resource(name = "userdao")  // 相当于前两个结合使用
    private Userdao userdao;
    public void setUserdao(Userdao userdao) {
        this.userdao = userdao;
    }

    @Override
    public void save() {
        System.out.println(normal);
        System.out.println(name);
        userdao.save();
    }
    @PostConstruct
    public void init(){
        System.out.println("service对象的创建方法。");
    }
    @PreDestroy
    public void destory(){
        System.out.println("service对象的销毁方法。");
    }
}

利用@value（“${}”）,可以对jdbc.properity数据进行解析。

使用@Scope标注Bean的范围

使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法

Spring新注解

例如这块代码如何利用新注解进行简化？

<!--    加载外部的propoties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

@Configuration：标志是Spring的一个核心配置文件。

配置组件扫描：@ComponentScan(“com.peihj”)

package com.peihj.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import java.beans.PropertyVetoException;

// 标志是Spring的一个核心配置文件
@Configuration
// <!--配置组件扫描-->
// <context:component-scan base-package="com.peihj"/>
@ComponentScan("com.peihj")

@Import({datasourceconfigration.class})
public class Springconfigration {

}

加载外部的propoties文件：

// <context:property-placeholder location=“classpath:jdbc.properties”/>

@PropertySource(“classpath:jdbc.properties”)

package com.peihj.config;


import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;

import java.beans.PropertyVetoException;

//  <!--加载外部的propoties文件-->
//    <context:property-placeholder location="classpath:jdbc.properties"/>
@PropertySource("classpath:jdbc.properties")
public class datasourceconfigration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;



    @Bean("datasource") // spring会将当前方法的返回值以指定名称返回到Spring容器中
    public ComboPooledDataSource getdatasource() throws PropertyVetoException {
        // 创建数据源
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // 设置参数
        // 设置驱动
        dataSource.setDriverClass(driver);
        // 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
        dataSource.setJdbcUrl(url);

        dataSource.setUser(username);
        dataSource.setPassword(password);

        return dataSource;
    }
}

Java开发是分模块开发，我们将代码中按功能进行分开并最后将该文件的类导入到Spring的核心配置文件会让开发更加的简洁。

导入：@Import({datasourceconfigration.class})

package com.peihj.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import java.beans.PropertyVetoException;

// 标志是Spring的一个核心配置文件
@Configuration
// <!--配置组件扫描-->
// <context:component-scan base-package="com.peihj"/>
@ComponentScan("com.peihj")

@Import({datasourceconfigration.class})
public class Springconfigration {

}

@Bean(“datasource”) // spring会将当前方法的返回值以指定名称返回到Spring容器中

测试加载核心配置类创建Spring容器

package com.peihj.web;

import com.peihj.config.Springconfigration;
import com.peihj.service.Userservice;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Usercontroller {
    public static void main(String[] args) {
//        ApplicationContext app  = new ClassPathXmlApplicationContext("applicationcontext.xml");
        ApplicationContext app  = new AnnotationConfigApplicationContext(Springconfigration.class);

        Userservice userservice = app.getBean(Userservice.class);

        userservice.save();
    }
}

Spring整合Junit

原始Junit测试Spring的问题

在测试类中，每个测试方法都有以下两行代码：

ApplicationContext app = new ClassPathXmlApplicationContext("applicationcontext.xml");
Userservice userservice = app.getBean(Userservice.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

上述问题解决思路

• 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它 将需要进行。
• 测试Bean直接在测试类中进行注入。

Spring集成Junit步骤

Spring集成Junit代码实现

导入spring集成Junit的坐标

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

使用@Runwith注解替换原来的运行期

@RunWith(SpringJUnit4ClassRunner.class)：声明当前方法是属于测试类；

使用@ContextConfiguration指定配置文件或配置类

@ContextConfiguration(“classpath:applicationcontext.xml”) 利用配置文件

@ContextConfiguration(classes = {Springconfigration.class}) // 全注解方式

使用@Autowired注入需要测试的对象

想测试谁就将谁进行注入；这个对象再容器中，那么就直接注入他即可.

创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationcontext.xml")   利用配置文件
@ContextConfiguration(classes = {Springconfigration.class})    // 全注解方式
public class Springjunittest {

    @Autowired
    private Userservice userservice;

    @Autowired
    private ComboPooledDataSource comboPooledDataSource;

    @Test
    public void test() throws SQLException {
        userservice.save();
        System.out.println(comboPooledDataSource.getConnection());
    }

}

小结

参考

黑马程序员