Spring基础知识之IOC容器

什么事IOC？

　　控制反转（Inversion of Control，缩写为IoC），是向对象编程中的一种设计原则，可以用来降低计算机代码之间的耦合度，其中最常见的方式是“依赖注入”（Dependency Injection，简称DI），还有一种方式叫做“依赖查找（Dependency LookUp）”

控制反转（IOC）和依赖注入（DI）的关系？

　　控制反转（IOC）是想要实现的目标或者效果，而依赖注入（DI）则是实现这种效果的方式。

Spring实现IOC的思路和方法？

　　Spring实现IOC的思路是提供一些配置信息用来描述类之间的依赖关系，然后由容器去解析这些配置信息，继而维护好对象之间的依赖关系，前提是对象之间的依赖关系必须在类中定义好，比如A.class中有一个B.class的属性，那么我们可以理解为A依赖了B。

　　Spring实现IOC的思路大概可以拆分成3点：

　　　　1.应用程序中提供类，提供依赖关系（属性或者构造方法）

　　　　2.把需要交给容器管理的对象通过配置信息告诉容器（xml，annotation，javaconfig）

　　　　3.把各个类之间的依赖关系通过配置信息告诉容器

　　配置这些信息的方法有三种，分别是xml，annotation，javaconfig

　　维护的过程为自动注入，自动注入的方法有两种，构造方法（<constructor-arg>标签） 和 setter(<property>标签);

　　　　使用构造方法注入<constructor-arg>标签：　　

/**
 * Service接口实现类
 * @author Administrator
 *
 */
public class IndexServiceImpl implements IndexService {

    //引入IndexDao对象
    private IndexDao dao;
    //创建构造函数
    public IndexServiceImpl(IndexDao dao){
        this.dao = dao;
    }
    //方法
    public void ServiceTest() {
        dao.test();
    }
}

 　　　　使用setter方法注入（<property>标签）：

/**
 * Service接口实现类
 * @author Administrator
 *
 */
public class IndexServiceImpl implements IndexService {

    //引入IndexDao对象
    private IndexDao dao;
    public void ServiceTest() {
        dao.test();
    }
    /**
     * 通过set方法注入spring容器
     */
    public void setDao(IndexDao dao) {
        this.dao = dao;
    }
}

 　　　　使用P标签注入属性（简写的property标签）：

 　　　　使用C标签注入属性（简写的constructor标签）

 　　　　使用注解功能进行依赖注入：

　　　　　　@Component与@Controller（Action层），@Service（Service层），@Repository（Dao层）的区别：

　　　　　　　　@Component是其他三种的基类。

 　　　　使用@Service注解

/**
 * Service接口实现类
 * @author Administrator
 *
 */
@Service("service")
public class IndexServiceImpl implements IndexService {

    //使用注解方式引入IndexDao对象
    @Autowired
    private IndexDao dao;
    //创建构造函数
    public IndexServiceImpl(IndexDao dao){
        this.dao = dao;
    }
    //方法
    public void ServiceTest() {
        dao.test();
    }
}

　　使用@Component注解：

/**
 * Dao实现类
 * @author Administrator
 *
 */
@Component
public class IndexDaoImpl implements IndexDao {

    public void test() {
        System.out.println("Dao测试方法");
    }

}

　　使用Java-config方式进行依赖注入：

　　　　创建Java配置类：

/**
 * 使用Java-config配置
 * @author Administrator
 *
 */
@Configuration
@ComponentScan("org.wk.spring")
public class SpringAnnotation {

}

　　　　测试类：

/**
 * Java配置测试类
 * @author Administrator
 *
 */
public class Test1 {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringAnnotation.class);
        IndexService service =(IndexService) context.getBean("service");
        service.ServiceTest();
    }

}

　　　　使用ImportResource注解导入xml配置文件：

/**
 * 使用Java-config配置
 * @author Administrator
 *
 */
@Configuration
@ComponentScan("org.wk.spring")
@ImportResource("classpath:spring.xml")
public class SpringAnnotation {

}

Spring的自动装配：

　　在描述类之间的依赖关系的时候，如果使用spring的自动装配功能，那么我们可以省去很多配置，并且如果对象的依赖发生更新后，我们有不需要去重新配置。

　　自动装配的方法：

　　　　1.no：不使用自动装配，也是默认的default

　　　　2.byType:通过需要装配的属性对应的类，去配置文件中遍历寻找具有相同类的配置，然后进行装配，所有这就要求同一个类在配置文件中只能装配一次。

　　　　3.byName:通过需要装配的属性，在set方法时，spring通过解析set方法（将set方法名截取）来与配置文件中的注册类匹配。

　　　　4.constructor:通过构造器来进行自动装配，通过构造器中的参数进行装配。

@Autowired和@Resource的区别：

　　@Autowired：默认使用byType的方式进行装配，如果byType找不到就是用byName，使用byName也找不到就报错。如果在同一个接口有多个实现类的情况下，需要使用byType来装配，可以使用@Qualifier("daoImpl")来进行选择，防止报错。

　　@Resource：默认使用byName的方式进行装配，但是是根据属性名进行，不是根据set方法的截取进行的。但是@Resource有一个type属性，可以指定对应的类（@Resource（type=Aa.class））

 Spring生命周期的回调：

　　spring生命周期的回调有三种方法：

　　　　1.实现InitializingBean接口（初始化的回调），实现DisposableBean接口（销毁时的回调）

　　　　2.使用@PostConstruct注解（初始化回调），使用@PreDestroy注解（销毁时的回调）

　　　　3.使用配置文件配置，自定义回调方法：

　　　　　　　　　　　　　初始化的回调：<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>

　　　　　　　　　　　　　销毁时的回调：<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>

使用spring的@Bean来自动装配数据库连接：

　　1.引入mybatis的相关包，和spring-jdbc连接包

<!--Mybatis依赖  -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.1</version>
    </dependency>
    <!--mybatis自身实现的spring的整合依赖 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.2</version>
    </dependency>
    <!--spring的JDBC相关依赖  -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>

　　2.编写Java配置类，进行数据库配置加载

/**
 * 使用Java-config配置
 * @author Administrator
 *
 */
@Configuration
@ComponentScan("org.wk.spring")
@ImportResource("classpath:spring.xml")
public class SpringAnnotation {

    @Bean
    @Autowired
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){
        SqlSessionFactoryBean sqlBean = new SqlSessionFactoryBean();
        sqlBean.setDataSource(dataSource);
        return sqlBean;
    }
    //通过注解加入数据库连接
    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
        driverManagerDataSource.setPassword("root");
        driverManagerDataSource.setUsername("root");
        driverManagerDataSource.setUrl("jdbc:mysql://localhost:3306/test");
        driverManagerDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return driverManagerDataSource;
    }
}

 spring的BeanFactory和FactoryBean有什么区别？

　　BeanFactory是一个工厂类，用于产生和获取交给spring代理的bean。

　　FactoryBean是spring的一个接口，它可以把一些复杂的功能通过处理，返回给我们使用，但是，实现FactoryBean的类，不能使用getObject()方法获取，因为spring对它进行了特殊处理，需要加上"&"符号。getObject()返回的使我们处理好之后，方便外部使用的类。