spring学习（DI）依赖注入

spring学习（DI）依赖注入

（一）

• spring是当下一款非常流行的javaEE框架，其主要运用于java web开发
• 从一种打的视角来看spring，spring就是一个主要用来管理java对象的容器

（二）

• spring主要分为两大块

• DI（Dependency Injection，依赖注入）

• AOP（Aspect Oriented Programming，面向切面编程）

(三)

• java Bean
• 每一个java类实现了java Bean的规范后才能够让spring来接管
• java Bean的规范如下：
• 必须是个公有（public）的类
• 要有无参构造函数
• 要有公共方法setter和getter用于暴露内部私有成员属性

(四)

DI依赖注入

• 简单来说，一个系统中可能会有成千上万个对象。如果要手工维护它们之间的关系，这是不可想象的。我们可以在Spring的XML文件描述它们之间的关系，由Spring来自动注入它们——比如A类的实例需要B类的实例作为参数set进去。
• 依赖注入有xml文件配置法和注解配置法两种

Bean的作用域

• Spring定义了多种Bean作用域，可以基于这些作用域创建bean

1. 单例（Singleton）：在整个应用中，只创建bean的一个实例。

2. 原型（Prototype）：每次注入或者通过Spring应用上下文获取的时候，都会创建一个新的bean实例。

3. 会话（Session）：在Web应用中，为每个会话创建一个bean实例。

4. 请求（Rquest）：在Web应用中，为每个请求创建一个bean实例。

5. 一般常用的就Singleton和Prototype这两种

6. spring还可以在Bean中定义Bean的属性和方法

（五）spring的xml文件中配置Bean

5.1 xml配置Bean

<bean id="userDao" class="com.li.impl.UserDaoImpl" scope="singleton">
        <property name="userName" value="zhangsan"></property>
        <property name="age" value="12"></property>
        <property name="strList">
            <list>
                <value>a</value>
                <value>b</value>
                <value>c</value>
            </list>
        </property>
        <property name="userMap">
            <map>
                <entry key="user1" value-ref="user1"></entry>
                <entry key="user2" value-ref="user2"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="a1">li</prop>
                <prop key="a2">zh</prop>
            </props>
        </property>
    </bean>

5.2 调用spring容器实现Bean中配置的java类对象

public class userDemo1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDaoImpl userDao1 = (UserDaoImpl) app.getBean("userDao");
        userDao1.save();

    }
}

5.3 Bean中成员变量的属性从外部properties文件中获取，以及Bean中的成员变量属性为其他引用成员类

<!--    加载外部的properties文件-->
    <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>
    <bean id="userDao" class="com.li.dao.impl.UserDaoImpl"></bean>
    <bean id="userService" class="com.li.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

（六）使用注解开发
6.1 要在xml文件中配置注解扫描包

<!-- 要在头部<beans>中添加如下代码注册context，得到如下头部<beans>标签-->
<!--  xmlns:context="http://www.springframework.org/schema/context
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd-->
<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">
<!--    注解组件扫描,base-package:基本包，会扫描他和他的子包中的注解-->
    <context:component-scan base-package="com.li"></context:component-scan>

6.2 原始注解和新注解

6.2.1原始注解

6.2.2 新注解

6.2.3 使用原始注解代码

package com.li.dao.impl;

import com.li.dao.UserDao;
import org.springframework.stereotype.Component;

@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("我是save running...");
    }
}

package com.li.service.impl;

import com.li.dao.UserDao;
import com.li.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 javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

@Component("userService")
@Scope("singleton")//Bean的作用范围  singleton单一的 prototype 多个的
//@Scope("prototype")
public class UserServiceImpl implements UserService {

    @Value("${jdbc.driver}")//普通属性注入
    private String user;

//    @Autowried  依赖注入   @Qualifier 注入的引用类名
    @Autowired
    @Qualifier("userDao") //根据类型依赖注入
//    @Resource(name = "userDao")// 等效于@Autowired+@Qualifier
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        System.out.println(this.user);
        userDao.save();
        System.out.println(user);
    }

    @PostConstruct//构造之后   Bean的初始化方法
    public void innit(){
        System.out.println("Userservice创建了");
    }
    @PreDestroy//销毁前   Bean的销毁方法
    public void destroy(){
        System.out.println("Userservice销毁了");
    }
}

6.2.4 使用新注解代码

package com.li.config;

import com.li.dao.impl.UserDaoImpl;
import com.li.service.impl.UserServiceImpl;
import com.mchange.v2.c3p0.ComboPooledDataSource;
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;
import java.beans.PropertyVetoException;

@Configuration//标志该文件是spring的核心配置类
@ComponentScan("com.li")//组件扫描包   <context:component-scan base-package="com.li"></context:component-scan>
@PropertySource("classpath:jdbc.properties")//加载外部properties文件 相当于
// <context:property-placeholder location="classpath:jdbc.properties"/>
public class SpringConfiguration {

    @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容器中创建的对象名称为dataSource
    public DataSource dataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }

}