02_IoC和DI注解开发

1.Spring配置数据源

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

  • 数据源(连接池)是提高程序性能
  • 事先实例化数据源，初始化部分连接资源
  • 使用连接资源是从数据源中获取
  • 使用完毕后将连接资源归还给数据源

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

1.1 数据源的开发步骤

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

1.2 数据源的手动创建

① 导入数据源的坐标和数据库驱动坐标

导入c3p0和druid的坐标

  1. <dependency>
  2.     <groupId>c3p0</groupId>
  3.     <artifactId>c3p0</artifactId>
  4.     <version>0.9.1.2</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>com.alibaba</groupId>
  9.     <artifactId>druid</artifactId>
  10.     <version>1.1.10</version>
  11. </dependency>

导入mysql数据库驱动坐标

  1. <!--数据库链接-->
  2. <dependency>
  3.     <groupId>mysql</groupId>
  4.     <artifactId>mysql-connector-java</artifactId>
  5.     <version>5.1.32</version>
  6. </dependency>

② 创建C3P0连接池

  1. @Test
  2. // 测试手动创建 c3p0 数据源
  3. public void test01() throws Exception {
  4.     ComboPooledDataSource dataSource = new ComboPooledDataSource();
  5.     dataSource.setDriverClass("com.mysql.jdbc.Driver");
  6.     dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
  7.     dataSource.setUser("root");
  8.     dataSource.setPassword("root");
  9.     Connection connection = dataSource.getConnection();
  10.     System.out.println(connection);
  11.     connection.close();
  12. }
  1. @Test
  2. //测试手动创建 druid 数据源
  3. public void test2() throws Exception {
  4.     DruidDataSource dataSource = new DruidDataSource();
  5.     dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  6.     dataSource.setUrl("jdbc:mysql://localhost:3306/test");
  7.     dataSource.setUsername("root");
  8.     dataSource.setPassword("root");
  9.     DruidPooledConnection connection = dataSource.getConnection();
  10.     System.out.println(connection);
  11.     connection.close();
  12. }

③ 提取**jdbc.properties**配置文件

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

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

  1. @Test
  2. //测试手动创建 c3p0 数据源(加载properties配置文件)
  3. public void test3() throws Exception {
  4.     //读取配置文件
  5.     ResourceBundle rb = ResourceBundle.getBundle("jdbc");
  6.     String driver = rb.getString("jdbc.driver");
  7.     String url = rb.getString("jdbc.url");
  8.     String username = rb.getString("jdbc.username");
  9.     String password = rb.getString("jdbc.password");
  10.     //创建数据源对象  设置连接参数
  11.     ComboPooledDataSource dataSource = new ComboPooledDataSource();
  12.     dataSource.setDriverClass(driver);
  13.     dataSource.setJdbcUrl(url);
  14.     dataSource.setUser(username);
  15.     dataSource.setPassword(password);
  17.     Connection connection = dataSource.getConnection();
  18.     System.out.println(connection);
  19.     connection.close();
  20. }

1.3 Spring配置数据源

可以将DataSource的创建权交由Spring容器去完成

  • DataSource有无参构造方法，而Spring默认就是通过无参构造方法实例化对象的
  • DataSource要想使用需要通过set方法设置数据库连接信息，而Spring可以通过set方法进行字符串注入
  1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  2.     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  3.     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306"></property>
  4.     <property name="user" value="root"></property>
  5.     <property name="password" value="root"></property>
  6. </bean>

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

  1. @Test
  2. // 测试Spring容器产生数据源对象
  3. public void test04() throws SQLException {
  4.     ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  5.     DataSource dataSource = app.getBean(DataSource.class);
  6.     Connection connection = dataSource.getConnection();
  7.     System.out.println(connection);
  8.     connection.close();
  9. }

1.4 抽取jdbc配置文件

需要使用context命名空间和约束路径

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
  1. <context:property-placeholder location="classpath:jdbc.properties"/>
  2. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  3.     <property name="driverClass" value="${jdbc.driver}"/>
  4.     <property name="jdbcUrl" value="${jdbc.url}"/>
  5.     <property name="user" value="${jdbc.username}"/>
  6.     <property name="password" value="${jdbc.password}"/>
  7. </bean>

标准的写法
<context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>

system-properties-mode=”NEVER”：不去加载系统(电脑) 的属性

1.5 知识要点

Spring容器加载properties文件

  1. <context:property-placeholder location="xx.properties"/>
  2. <property name="" value="${key}"/>

1.6 容器

image.png

2.Spring注解开发

2.1 Spring原始注解

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

Spring原始注解主要是替代 <Bean>的配置

02_IoC和DI注解开发 - 图2

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

开头文件也需要进行更改，添加context

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  5.                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  1. <!--注解的组件扫描-->
  2. <context:component-scan base-package="com.itheima"></context:component-scan>
  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. }
  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;
  9.     @Override
  10.     public void save() {
  11.         userDao.save();
  12.     }
  13. }
  • 使用@Value 进行字符串的注入
  1. @Repository("userDao")
  2. public class UserDaoImpl implements UserDao {
  3.     @Value("注入普通数据")
  4.     private String str;
  6.     @Value("${jdbc.driver}")
  7.     private String driver;
  9.     @Override
  10.     public void save() {
  11.         System.out.println(str);
  12.         System.out.println(driver);
  13.         System.out.println("save running... ...");
  14.     }
  15. }
  1. //@Scope("prototype")
  2. @Scope("singleton")
  3. public class UserDaoImpl implements UserDao {
  4.     //此处省略代码
  5. }
  1. @PostConstruct
  2. public void init(){
  3.     System.out.println("初始化方法....");
  4. }
  6. @PreDestroy
  7. public void destroy(){
  8.     System.out.println("销毁方法.....");
  9. }

2.2 Spring新注解

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

  • 非自定义的Bean的配置：<bean>
  • 加载properties文件的配置：<context:property-placeholder>
  • 组件扫描的配置：<context:component-scan>
  • 引入其他文件：<import>
    02_IoC和DI注解开发 - 图3

@Configuration
@ComponentScan
@Import

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

@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;

@Bean

  1. @Bean(name="dataSource")
  2. public DataSource getDataSource() throws PropertyVetoException {
  3.     ComboPooledDataSource dataSource = new ComboPooledDataSource();
  4.     dataSource.setDriverClass(driver);
  5.     dataSource.setJdbcUrl(url);
  6.     dataSource.setUser(username);
  7.     dataSource.setPassword(password);
  8.     return dataSource;
  9. }

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

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

3. Spring集成Junit