SSM学习day03_Spring配置数据源、Spring注解开发、Spring整合Junit

目录

• 一、Spring配置数据源
  • 1.1 数据源(连接池)的作用
  • 1.2 数据源的手动创建
    • 1).c3p0数据源
    • 2) druid数据源
  • 1.3 Spring配置数据源
  • 1.4 抽取jdbc配置文件
• 二、Spring注解开发
  • 2.1 Spring原始注解
    • 一些注意点
  • 2.2 Spring的新注解
• 三、Spring整合Junit
  • 3.1 源时Junit测试Spring的问题
  • 3.2 解决问题
  • 3.3 Spring集成Junit步骤

一、Spring配置数据源

1.1 数据源(连接池)的作用

• 数据源就是为了提高程序性能而出现的
• 事先实例化数据源，初始化部分连接资源
• 使用连接资源时从数据源中获取
• 使用完毕后将连接资源归还给数据源

常见的数据源(连接池):DBCP、C3P0、BoneCP、Druid等

数据源的开发步骤

1. 导入数据源的坐标和数据库驱动坐标
2. 创建数据源对象
3. 设置数据源的基本连接数据
4. 使用数据源获取连接资源的归还连接资源

1.2 数据源的手动创建

1).c3p0数据源

新建maven项目hf_Spring_ioc_anno。修改pom.xml导四个包mysql-connector-java、c3p0、druid、junit。新建类com.hf.test.DataSourceTest

pom.xml

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

DataSourceTest.java

public class DataSourceTest {
    @Test
    //测试手动创建c3p0数据源
    public void test1() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("123456x");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

运行结果：
com.mchange.v2.c3p0.impl.NewProxyConnection@343f4d3d

2) druid数据源

几乎一样
DataSourceTest.java

    @Test
    //测试手动创建druid数据源
    public void test2() throws Exception {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("123456x");
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }
}

运行结果:
com.mysql.cj.jdbc.ConnectionImpl@180bc464

Druid和c3p0在这里的演示中，如果要换数据库必须改源码，参数字符串和当前库的具体设置耦合死了，所以需要将这些参数抽取到配置文件中.
resources下新建jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456x

DataSourceTest.java

    @Test
    //测试手动创建c3p0数据源(加载配置properties文件形式)
    public void test3() throws Exception {
        //读取配置文件
        ResourceBundle rb= ResourceBundle.getBundle("jdbc");
        //此处只要基本名称,所以不需要jdbc.properties。
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.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);
        dataSource.close();
    }

运行结果:
com.mchange.v2.c3p0.impl.NewProxyConnection@204f30ec

1.3 Spring配置数据源

可以将DataSource的创建权交给Spring容器,三步

1. 导坐标pom.xml中导入spring基本坐标，spring-context;
2. 按之前的联系，需要Userservice、dao等，但此处是导入第三方JAR包，编写好了
3. 创建配置文件，applicationContext.xml，配置bean
4. Spring，getBean获取对象

application.xml

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456x"></property>
    </bean>

name 是set方法后面的名，首字母小写

DataSourceTest.java

    @Test
    //测试Spring容器产生数据源对象
    public void test4() throws Exception {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//        app.getBean("dataSource");
        DataSource dataSource = app.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();

    }

1.4 抽取jdbc配置文件

applicationContext.xml加载jdbc.properties配置文件信息获得连接信息。

首先，需要引入命名空间,在beans前面加入

xmlns:context="http://www.springframework.org/schema/context"

在xsi：schemaLocation中加一行url

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

两者都是复制bean后，将bean改成context。

然后就可以使用标签。

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

修改bean中value

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

运行结果
com.mchange.v2.c3p0.impl.NewProxyConnection@49c386c8

二、Spring注解开发

2.1 Spring原始注解

注解代替xml配置文件可以简化配置，提高开发效率
Spring原始注解主要是替代的配置

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PerDestory	使用在方法上标注该方法时Bean的销毁方法

使用注解一点点代替配置文件中的语句:
UserDaoImpl.java

//<bean id="userDao" class="com.hf.dao.impl.UserDaoImpl"></bean>
@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save running....");
    }
}

UserServiceImpl.java

//<bean id="userService" class="com.hf.service.impl.UserServiceImpl">
//</bean>
@Component("userService")

public class UserServiceImpl implements UserService {
    private UserDaoImpl userDao;


    //<property name="userDao" ref="userDao"></property>
    @Autowired
    @Qualifier("userDao")
    public void setUserDao(UserDaoImpl userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.save();
    }
}

运行结果：
NoSuchBeanDefinitionException

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

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

一些注意点

• @Component和@Controller、@Service、@Respository并无本质不同，只是后三个语义更加明确，可以让使用者知道这是哪一层的标签。

• @Autowired是按类型从Spring容器中匹配，@Qulifier是按ID匹配，且@Qulifier必须配合@Autowired使用，不可单独使用。@Resource等于前两者结合，即@Autowired+@Qulifier。

• 当使用xml配置的方式时，set方法不可省略，需要通过反射，调用set方法进行注入。但用注解的方式可以省略set方法，此时注解在属性上，可以直接通过反射为属性赋值。

@Value：可以从properties文件中获取普通值并注入。但要结合SPEL

    @Value("${jdbc.driver}")
    private String driver;

需要使用context命名域，从外部加载jdbc.properties，此时jdbc文件中已有数据，可以直接进行复制
运行结果：
com.mysql.jdbc.Driver
save running....

@Scope

@PostConstruct和@PreDestroy

    @PostConstruct
    public void init(){
        System.out.println("Service对象的初始化方法");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("Service对象的销毁方法");
    }

2.2 Spring的新注解

使用上面的注解不能全部替代xml配置文件，还需要使用注解替代的配置如下：

• 非自定义的Bean的配置：<bean>
• 加载properties文件的配置：<context:property-placeholder>
• 组件扫描的设置:<context:component-scan>
• 引入其它文件:<import>

注解	说明
@Configuration	用于指定当前类时一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring在初始化容器时要扫描的包,作用等同<context:component-scan base-package="com.hf"/>
@Bean	使用在方法上，将标注该方法的返回值存储到Spring容器中
@PropertySource	用于加载.properties文件中的配置
@Import	用于导入其他配置类

SpringConfiguration.java是总配置类

//标志该类是Spring的一个核心配置类
@Configuration

//<context:component-scan base-package="com.hf"/>
@ComponentScan("com.hf")

//<import resource="classpath:"/>
@Import({DataSourceConfiguration.class})
//加载分配置类
public class SpringConfiguration {

}

DataSourceConfiguration.java是分配置类

//<context:property-placeholder location="classpath:jdbc.properties"/>
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @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 DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;

    }
}

修改Controller，让他从配置类里加载配置

    public static void main(String[] args) {
//        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
                                                                        //这个地方不加引号！
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserServiceImpl userService = app.getBean(UserServiceImpl.class);
        userService.save();
    }

三、Spring整合Junit

3.1 源时Junit测试Spring的问题

在测试类中，必须获取容器然后getBean

3.2 解决问题

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

3.3 Spring集成Junit步骤

1. 导入Spring集成Junit的坐标
2. 使用@Runwith注解替换原来的运行期
3. 使用@ContextConfiguration指定配置文件或配置类
4. 使用@Autowired注入需要测试的对象
5. 创建测试方法进行测试

先导包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.9</version>
        </dependency>

再编写测试类
SpringJunitTest.java

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {

    @Autowired
    private UserService userService;

    @Autowired
    private DataSource dataSource;

    @Test
    public void test1() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());
    }

}