1.Spring配置数据源

1.1 数据源（连接池）的作用

• 数据源(连接池)是提高程序性能如出现的
• 事先实例化数据源，初始化部分连接资源
• 使用连接资源时从数据源中获取
• 使用完毕后将连接资源归还给数据源
常见的数据源(连接池)：DBCP、C3P0、BoneCP、Druid等

1.1 数据源的开发步骤

① 导入数据源的坐标和数据库驱动坐标
② 创建数据源对象
③ 设置数据源的基本连接数据
④ 使用数据源获取连接资源和归还连接资源

1.2 数据源的手动创建

① 导入c3p0和druid的坐标

  1. <!-- C3P0连接池 --> 
  2. <dependency> 
  3.     <groupId>c3p0</groupId>
  4.     <artifactId>c3p0</artifactId> 
  5.     <version>0.9.1.2</version>
  6. </dependency>
  7. <!-- Druid连接池 --> 
  8. <dependency> 
  9.     <groupId>com.alibaba</groupId>
  10.     <artifactId>druid</artifactId> 
  11.     <version>1.1.10</version>
  12. </dependency>
  13. <!-- mysql驱动 --> 
  14. <dependency>
  15.     <groupId>mysql</groupId>
  16.     <artifactId>mysql-connector-java</artifactId>
  17.     <version>5.1.39</version>
  18. </dependency>

② 创建C3P0连接池和德鲁伊连接池

  1. package com.itheima.test;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import com.alibaba.druid.pool.DruidPooledConnection;
  5. import com.mchange.v2.c3p0.ComboPooledDataSource;
  6. import org.junit.Test;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.support.ClassPathXmlApplicationContext;
  10. import javax.sql.DataSource;
  11. import java.beans.PropertyVetoException;
  12. import java.sql.Connection;
  13. import java.util.ResourceBundle;
  15. public class DataSourceTest {
  17.     @Test
  18.     //测试Spring容器产生数据源对象
  19.     public void test4() throws Exception {
  20.         ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  21.         DataSource dataSource = app.getBean(DataSource.class);
  22.         Connection connection = dataSource.getConnection();
  23.         System.out.println(connection);
  24.         connection.close();
  25.     }
  27.     @Test
  28.     //测试手动创建 c3p0 数据源(加载properties配置文件)
  29.     public void test3() throws Exception {
  30.         //读取配置文件
  31.         ResourceBundle rb = ResourceBundle.getBundle("jdbc");
  32.         String driver = rb.getString("jdbc.driver");
  33.         String url = rb.getString("jdbc.url");
  34.         String username = rb.getString("jdbc.username");
  35.         String password = rb.getString("jdbc.password");
  36.         //创建数据源对象  设置连接参数
  37.         ComboPooledDataSource dataSource = new ComboPooledDataSource();
  38.         dataSource.setDriverClass(driver);
  39.         dataSource.setJdbcUrl(url);
  40.         dataSource.setUser(username);
  41.         dataSource.setPassword(password);
  43.         Connection connection = dataSource.getConnection();
  44.         System.out.println(connection);
  45.         connection.close();
  47.     }
  49.     @Test
  50.     //测试手动创建 druid 数据源
  51.     public void test2() throws Exception {
  52.         DruidDataSource dataSource = new DruidDataSource();
  53.         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  54.         dataSource.setUrl("jdbc:mysql://localhost:3306/test");
  55.         dataSource.setUsername("root");
  56.         dataSource.setPassword("root");
  57.         DruidPooledConnection connection = dataSource.getConnection();
  58.         System.out.println(connection);
  59.         connection.close();
  60.     }
  62.     @Test
  63.     //测试手动创建 c3p0 数据源
  64.     public void test1() throws Exception {
  65.         ComboPooledDataSource dataSource = new ComboPooledDataSource();
  66.         dataSource.setDriverClass("com.mysql.jdbc.Driver");
  67.         dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
  68.         dataSource.setUser("root");
  69.         dataSource.setPassword("root");
  70.         Connection connection = dataSource.getConnection();
  71.         System.out.println(connection);
  72.         connection.close();
  73.     }
  75. }

applicationContext.xml

  1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  2.     <property name="driverClass" value="com.mysql.jdbc.Driver"/>
  3.     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
  4.     <property name="user" value="root"/>
  5.     <property name="password" value="root"/>
  6. </bean>

③ 提取jdbc.properties配置文件
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

Spring容器加载properties文件,需要使用spel表达式：${}

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation=
  6.                "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7.                 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  9.     <!--加载外部的properties文件-->
  10.     <context:property-placeholder location="classpath:jdbc.properties"/>
  12.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  13.         <property name="driverClass" value="${jdbc.driver}"></property>
  14.         <property name="jdbcUrl" value="${jdbc.url}"></property>
  15.         <property name="user" value="${jdbc.username}"></property>
  16.         <property name="password" value="${jdbc.password}"></property>
  17.     </bean>
  19. </beans>

jdbc.properties

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/test
  3. jdbc.username=root
  4. jdbc.password=root

2.1 Spring原始注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。
Spring原始注解主要是替代的配置
image.png
注意：
使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean
需要进行扫描以便识别使用注解配置的类、字段和方法。
@Component注解可以作用任何mvc任何层，但是无法区别哪个层
@Autowired根据类型依赖注入，@Qualifier根据名字依赖注入，通常他们两个结合使用
@Resource（name=””）常用注解，相当于@Autowired+@Qualifier

  1. <!--注解的组件扫描--> 
  2. <context:component-scan base-package="com.itheima"></context:component-scan>

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

  1. //@Component("userDao")
  2. @Repository("userDao")
  3. public class UserDaoImpl implements UserDao {
  4.     @Override
  5.     public void save() {
  6.         System.out.println("save running... ...");
  7.     } 
  8. }

使用@Component或@Service标识UserServiceImpl需要Spring进行实例化
使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

  1. //@Component("userService")
  2. @Service("userService")
  3. public class UserServiceImpl implements UserService {
  4.     /*@Autowired
  5.     @Qualifier("userDao")*/
  6.     @Resource(name="userDao")
  7.     private UserDao userDao;
  8.     @Override
  9.     public void save() {
  10.         userDao.save();
  11.     } 
  12. }

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

  1. @Repository("userDao")
  2. public class UserDaoImpl implements UserDao {
  3.     @Value("注入普通数据")
  4.     private String str;
  5.     @Value("${jdbc.driver}")
  6.     private String driver;
  7.     @Override
  8.     public void save() {
  9.         System.out.println(str);
  10.         System.out.println(driver);
  11.         System.out.println("save running... ...");
  12.     } 
  13. }

使用@Scope标注Bean的范围

  1. //@Scope("prototype")
  2. @Scope("singleton")
  3. public class UserDaoImpl implements UserDao {
  4.     //此处省略代码
  5. }

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

  1. @PostConstruct
  2. public void init(){
  3.     System.out.println("初始化方法....");
  4. }
  5. @PreDestroy
  6. public void destroy(){
  7.     System.out.println("销毁方法.....");
  8. }

2.2 Spring新注解

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：
 非自定义的Bean的配置：
 加载properties文件的配置：
 组件扫描的配置：
 引入其他文件：
image.png
@Configuration
@ComponentScan
@Import

  1. @Configuration
  2. @ComponentScan("com.itheima")
  3. @Import({DataSourceConfiguration.class})
  4. public class SpringConfiguration {
  6. }

@PropertySource
@value

  1. @PropertySource("classpath:jdbc.properties")
  2. public class DataSourceConfiguration {
  3.     @Value("${jdbc.driver}")
  4.     private String driver;
  5.     @Value("${jdbc.url}")
  6.     private String url;
  7.     @Value("${jdbc.username}")
  8.     private String username;
  9.     @Value("${jdbc.password}")
  10.     private String password;
  12.     @Bean(name="dataSource")
  13.     public DataSource getDataSource() throws PropertyVetoException {
  14.         ComboPooledDataSource dataSource = new ComboPooledDataSource();
  15.         dataSource.setDriverClass(driver);
  16.         dataSource.setJdbcUrl(url);
  17.         dataSource.setUser(username);
  18.         dataSource.setPassword(password);
  19.         return dataSource; 
  20.     }

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

  1. @Test
  2. public void testAnnoConfiguration() throws Exception {
  3.     ApplicationContext applicationContext = new 
  4.         AnnotationConfigApplicationContext(SpringConfiguration.class);
  5.     UserService userService = (UserService)applicationContext.getBean("userService");
  6.     userService.save();
  7.     DataSource dataSource = (DataSource)applicationContext.getBean("dataSource");
  8.     Connection connection = dataSource.getConnection();
  9.     System.out.println(connection);
  10. }

3. Spring集成Junit

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

  1. ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  2. IAccountService as = ac.getBean("accountService",IAccountService.class);

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

3.2 上述问题解决思路

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

3.3 Spring集成Junit步骤

① 导入spring集成Junit的坐标
② 使用@Runwith注解替换原来的运行期
③ 使用@ContextConfiguration指定配置文件或配置类
④ 使用@Autowired注入需要测试的对象
⑤ 创建测试方法进行测试

3.4 Spring集成Junit代码实现

① 导入spring集成Junit的坐标

  1. <!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上-->
  2. <dependency> 
  3.     <groupId>org.springframework</groupId>
  4.     <artifactId>spring-test</artifactId> 
  5.     <version>5.0.2.RELEASE</version>
  6. </dependency> 
  7. <dependency> 
  8.     <groupId>junit</groupId> 
  9.     <artifactId>junit</artifactId> 
  10.     <version>4.12</version> 
  11.     <scope>test</scope>
  12. </dependency>

3.4 Spring集成Junit代码实现

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

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. public class SpringJunitTest {
  4. }

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

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. //加载spring核心配置文件
  3. //@ContextConfiguration(value = {"classpath:applicationContext.xml"})
  4. //加载spring核心配置类
  5. @ContextConfiguration(classes = {SpringConfiguration.class})
  6. public class SpringJunitTest {
  7. }

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

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = {SpringConfiguration.class})
  3. public class SpringJunitTest {
  4.     @Autowired
  5.     private UserService userService;
  6. }

⑤ 创建测试方法进行测试

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = {SpringConfiguration.class})
  3. public class SpringJunitTest {
  4.     @Autowired
  5.     private UserService userService;
  6.     @Test
  7.     public void testUserService(){
  8.         userService.save();
  9.     } 
  10. }

3.5 知识要点

Spring集成Junit步骤
① 导入spring集成Junit的坐标
② 使用@Runwith注解替换原来的运行期
③ 使用@ContextConfiguration指定配置文件或配置类
④ 使用@Autowired注入需要测试的对象
⑤ 创建测试方法进行测试