Spring笔记(一)

Spring框架：

借鉴：http://www.cnblogs.com/cyjch/archive/2012/02/06/2340415.html

Spring框架依赖于两个jar包：spring.jar、commons-logging.jar。

为便于测试，加入了Junit.jar。

一、一个简单的示例：

接口类：

package com.imooc.myinterface;

public interface PersonInterface {
    void show();
}

实现类：

package com.imooc.mybean;

import com.imooc.myinterface.PersonInterface;

/**
 * UserBean实现了PersonInterface接口
 */
public class UserBean implements PersonInterface {
    @Override
    public void show() {
        System.out.println("UserBean 实现了 PersonInterface接口的 show方法");
    }
}

在spring.xml中配置实现类的bean：

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


    <bean id="userBean" class="com.imooc.mybean.UserBean"></bean>

</beans>

测试代码：

package com.imooc.test;

import com.imooc.myinterface.PersonInterface;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestBean {
    @Test
    public void testUserBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        PersonInterface person = (PersonInterface) context.getBean("userBean");
        person.show();
    }
}

测试代码的输出结果：

 UserBean 实现了 PersonInterface接口的 show方法 

二、实例化Bean的三种方式：

类构造器、静态工厂、实例工厂实例化bean。

BeanFactory类：

package com.imooc.factory;

import com.imooc.mybean.UserBean;
import com.imooc.myinterface.PersonInterface;

public class BeanFactory {

    //使用静态工厂实例化使用
    public static PersonInterface UserBeanService(){
        return new UserBean();
    }

    public PersonInterface getUserBeanService(){
        return new UserBean();
    }
}

spring.xml：

1　　 <!--使用类构造器直接实例化-->
    <bean id="userBean" class="com.imooc.mybean.UserBean"></bean>
    <!--使用静态工厂实例化-->
    <bean id="userBean2" class="com.imooc.factory.BeanFactory" factory-method="UserBeanService"></bean>
    <!--使用实例工厂实例化-->
    <bean id="factory" class="com.imooc.factory.BeanFactory"></bean>
    <bean id="userBean3" factory-bean="factory" factory-method="getUserBeanService"></bean>

三、Bean的节点信息：

默认情况下，Spring的IOC容器启动时会初始化bean，但可以设置bean的lazy-init="true",来延迟bean的启动，这时只有第一次获取bean的时候才会初始化bean。

若想对所有bean设置初始延时，则可以再根节点beans设置default-lazy-init="true"。

初始化方法可以在bean中加入init_method="init"属性，其中init为该bean的一个方法；对应有destory-method属性。

在Spring中通过getBean方法获得实例，可以用“==”来测试是一个还是多个实例。

 　　　　ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        PersonInterface person = (PersonInterface) context.getBean("userBean3");
        PersonInterface person2 = (PersonInterface) context.getBean("userBean3");
        person.show();
        System.out.println(person == person2);

结果：

 UserBean 实现了 PersonInterface接口的 show方法 2 true 

调用了2次getBean但只输出了一次：UserBean 实现了 PersonInterface接口的 show方法，且，返回true说明是一个实例。

Bean交给容器后，默认是单实例的，那么如何获取一个新的实例对象？

scope属性：

令scope=“prototype”即可。

四、Spring的核心机制---依赖注入（Dependence Injection）

依赖注入让bean与bean直接通过配置文件组织在一起；

依赖注入与控制反转(Inversion of Control)是同一个概念；

借鉴：http://www.cnblogs.com/xdp-gacl/p/4249939.html

A对象需要使用B对象时，A对B产生了依赖，传统上我们会new出B(主动权在自己)；

但在Spring中创建B的工作由Spring容器完成，然后注入到A中(控制权在Spring容器)

控制反转：创建对象的控制权进行了转移（自己-->spring容器）

什么被反转了？获得依赖对象的方式被反转了！！！

UserDao接口：

package com.imooc.myinterface;

public interface UserDao  {
    void show();
}

UserDao的实现类：UserDao4MysqlImpl和UserDao4OracleImpl

package com.imooc.impl;

import com.imooc.myinterface.UserDao;
public class UserDao4MysqlImpl implements UserDao {
    @Override
    public void show() {
        System.out.println("UserDao4MysqlImpl");
    }
}


package com.imooc.impl;

import com.imooc.myinterface.UserDao;

public class UserDao4OracleImpl  implements UserDao{
    @Override
    public void show() {
        System.out.println("UserDao4OracleImpl");
    }
}

UserService接口：

package com.imooc.impl;

import com.imooc.myinterface.UserDao;
import com.imooc.myinterface.UserService;

/**
 * 实现UserService接口是调用了userDao的show方法，一般需要实例化一个UserDao对象：
 * UserDao userDao = new UserDao4MysqlImpl();
 * 这样耦合度会上升；
 * 所以可以配置spring.xml进行注入。
 */
public class UserServiceImpl implements UserService {
    private UserDao userDao;　　　　//私有的，用于注入

    @Override
    public void show() {
        userDao.show();
    }

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

spring.xml:

 <bean id="mysqlDao" class="com.imooc.impl.UserDao4MysqlImpl"></bean>
    <bean id="oracleDao" class="com.imooc.impl.UserDao4OracleImpl"></bean>
    <bean id="userService" class="com.imooc.impl.UserServiceImpl">
        <property name="userDao" ref="mysqlDao"></property>
    </bean>

测试代码：

　　 @Test
    public void testUserService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.show();
    }

结果：

 UserDao4MysqlImpl 

这样就实现了注入！