spring - Ioc

Spring-IOC

IOC 概念

控制反转（Inverse Of Control）是一种设计思想。指的是对象控制权由原来由开发者在类中手动控制反转到由Spring容器控制，之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao()，现在我们需要一个userDao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制。

hello spring-ioc

1. 创建java项目，导入spring开发基本坐标
2. 编写Dao接口和实现类
3. 创建spring核心配置文件
4. 在spring配置文件中配置 UserDaoImpl
5. 使用spring相关API获得Bean实例

pom.xml

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.13</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>

接口和实现类

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("userDaoImpl save success");
    }
}

spring核心配置文件 applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置bean -->
    <bean id="userDao" class="com.dy.dao.impl.UserDaoImpl"/>

</beans>

测试

@Test
public void testSave() throws Exception {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    userDao.save();
}

applicationContext配置文件

bean配置

默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>
id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名
scope属性指对象的作用范围,singleton/prototype
init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

bean实例化方法

无参构造方法实例化 （默认）

工厂静态方法实例化

想要获取工厂静态方法生成的实例，交给spring管理。

public class StaticFactoryBean {
    public static UserDao createUserDao(){
        return new UserDaoImpl2();
    }
}

<bean id="userDao2" class="com.dy.StaticFactoryBean" factory-method="createUserDao"/>

工厂普通方法实例化

想要获取工厂普通方法生成的实例，交给spring管理

public class DynamicFactoryBean {
    public UserDao createUserDao(){
        return new UserDaoImpl3();
    }
}

<bean id="dynamicFactoryBean" class="com.dy.DynamicFactoryBean"/>
<bean id="userDao3" factory-bean="dynamicFactoryBean" factory-method="createUserDao"/>

bean依赖注入

依赖注入DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。通过框架把持久层对象传入业务层。（通过spring，把dao注入到service层使用）

构造方法注入

public class UserServiceImpl implements UserService {

    // 注入userDao
    private UserDao userDao;

    public UserServiceImpl(UserDao userDao){
        this.userDao = userDao;
    }

    @Override
    public void save() {
        System.out.println("in userService");
        userDao.save();
    }
}

<bean id="userService" class="com.dy.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

set方法注入

public class UserServiceImpl2 implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    @Override
    public void save() {
        System.out.println("in userServiceImpl 22222");
        userDao.save();
    }
}

<bean id="userService2" class="com.dy.service.impl.UserServiceImpl2">
    <property name="userDao" ref="userDao"/>
</bean>

bean注入数据类型

引用类型

见上 dao 注入

普通数据类型

<bean id="user" class="com.dy.domain.User">
    <property name="username" value="jack"/>
    <property name="age" value="18"/>
</bean>

集合数据类型

public class UserServiceImpl3 implements UserService {

    private List<Object> list;
    private Set<Object> set;
    private Object[] array;
    private Map<String, Object> map;
    private Properties properties;
    
    // set 注入
}

<bean id="userService3" class="com.dy.service.impl.UserServiceImpl3">
    <property name="list">
        <list>
            <value>aaa</value>
            <ref bean="user"/>
        </list>
    </property>

    <property name="set">
        <list>
            <value>bbb</value>
            <ref bean="user"/>
        </list>
    </property>

    <property name="array">
        <array>
            <value>ccc</value>
            <ref bean="user"/>
        </array>
    </property>

    <property name="map">
        <map>
            <entry key="k1" value="ddd"/>
            <entry key="k2" value-ref="user"/>
        </map>
    </property>

    <property name="properties">
        <props>
            <prop key="k1">v1</prop>
            <prop key="k2">v2</prop>
            <prop key="k3">v3</prop>
        </props>
    </property>
</bean>

配置文件模块化

主从配置文件，只加载主配置文件

<import resource="applicationContext-xxx.xml"/>
<import resource="applicationContext-xxx.xml"/>
<import resource="applicationContext-xxx.xml"/>

同一个xml中不能出现相同名称的bean,如果出现会报错
多个xml如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean

加载properties文件

<context:property-placeholder location="classpath:jdbc.properties"/>
<property name="" value="${key}"/>

Spring注解开发

开启组件扫描

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

IOC 实例化

@Compont 、@Controller、@Service 、@Repository

如果没有写value属性值，Bean的id为：类名首字母小写

DI 依赖注入

@Autowired 根据类型注入

@Autowired+@Qulifier = @Resource 根据名称注入

@Value 普通属性

其他

@Configuration 指定为配置类

@Bean 该方法的返回值存储到spring容器中

@ComponentScan(“com.dy”) 指定初始化容器时要扫描的包

@Import(DataSourceConfig.class) 导入其他配置类

@PropertySource(“classpath:jdbc.properties”) 加载properties配置类

简化测试类

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = {SpringConfig.class}) 加载配置文件或者配置类

@ContextConfiguration(value = {“classpath:applicationContext.xml”}) 加载spring核心配置文件

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class SpringJunitTest {
    @Autowired
    private AccountService accountService;
}