04-Spring01-IOC

今日知识

1. Spring IOC控制反转(Inverse of control)
2. Spring DI依赖注入(Dependency Injection )

Spring

1. 概念：简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。
2. Spring好处：
    1. 方便解耦，简化开发:	Spring就是一个大工厂，专门负责生成Bean，可以将所有对象创建和依赖关系维护由Spring管理
    2. AOP编程的支持：
    3. 申明事务的支持：只需要通过配置就可以完成对事务的管理，而无需手动编程
    4. 方便程序测试：Spring对Junit4支持，可以通过注解方便的测试Spring程序
    5. 方便集成各种优秀框架：	Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的支持
    6. 降低javaAPI的使用的难度Spring:	对JavaEE开发中一些难用的API（JDBC、JavaMail、远程调webservice用等），都提供了封装，使这些API应用难度大大降低

IOC

1. 概念：所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。
所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。
对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

DI依赖注入

1. 谁依赖了谁：应用程序依赖于IoC容器
2. 为什么要依赖：应用程序需要IoC容器来提供对象需要的外部资源
3. 谁注入谁：IoC容器注入应用程序某个对象，应用程序依赖的对象
4. 注入了什么：注入某个对象所需要的外部资源（包括对象、资源、常量数据）

IOC/DI入门案例

1. 导包：5+1四个核心一个依赖（spring5多一个）
    * <dependency>
    *   <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    * </dependency>
2. 新建类
3. 配置文件
4. 测试

装配Bean(xml)

1. 实例化Bean的三种方式
    1. 使用构造方法实例化
        *  <!-- 第一种方式: new 实现类-->
        <bean id="userService1" class="com.gyf.service.UserServiceImpl"></bean>

        * public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans3.xml");

        //new 对象
        //IUserService userService1 = (IUserService) context.getBean("userService1");
        //userService1.add();

    2. 使用静态工厂方法实例化
        *  <!-- 第二种方式：通过静态工厂方法
        spring的版本过低，3.0版本,把jdk改成1.7
      -->
         <bean id="userService2" class="com.gyf.service.UserSereviceFactory1" factory-method="createUserService"></bean>
           //静态工厂
        //IUserService userService2 = UserSereviceFactory1.createUserService();
        //IUserService userService2 = (IUserService) context.getBean("userService2");
        //userService2.add();

    3. 使用实例工厂方法实例化
        *  <!--第三种方式：通过实例工厂方法 -->
         <!-- 创建实例factory2 bean-->
         <bean id="factory2" class="com.gyf.service.UserSereviceFactory2"></bean>

         <bean id="userService3" factory-bean="factory2" factory-method="createUserService"></bean>
2. Bean的作用域
    1. singleton：
        * 在Spring IoC容器中仅存在一个Bean实例，Bean以单例方式存在，默认值
    2. prototype：
        * 每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean()
    3. request
        * 每次HTTP请求都会创建一个新的Bean，该作用域仅适用于WebApplicationContext环境
    4. session
        * 同一个HTTP Session 共享一个Bean，不同Session使用不同Bean，仅适用于WebApplicationContext 环境
    5. globalSession
        * 一般用于Portlet应用环境，该作用域仅适用于WebApplicationContext 环境

依赖注入Bean属性（xml）

1. 手动装配，使用xml配置
    1. 构造方法注入
    2. 属性setter方法注入
2. 集合注入
    1. 集合类型
        集合的注入都是给<property>添加子标签
		数组：<array>
		List：<list>
		Set：<set>
		Map：<map> ，map存放k/v 键值对，使用<entry>描述
		Properties：<props>  <prop key=""></prop>  【】
        JavaBean：对象注入，依赖<bean>标签注入
        普通数据：<value>
        引用数据：<ref>
    2. 实例
    3. <bean id="user" class="com.rqy.bean.User">
        <property name="arrays">
            <array>
                <value>123</value>
                <value>456</value>
            </array>
        </property>
        <property name="users" >//存放对象
            <list>
                <bean class="com.cskaoyan.bean.User">
                    <property name="username" value="user1"/>
                    <property name="password" value="password1"/>
                </bean>
                <ref bean="secondUserInlist"/>
            </list>
        </property>
        <property name="lists">
            <list>
                <value>123</value>
                <value>456</value>
            </list>
        </property>
        <property name="sets">
            <set>
                <value>123</value>
                <value>456</value>
            </set>
        </property>
        <property name="maps">
            <map>
               <entry key="1" value="123"/>
                <entry key="2" value="456"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="1">123</prop>
                <prop key="2">456</prop>
            </props>
        </property>
    </bean>
3. 注解注入
    1. 注解：就是一个类，使用@注解名称
    2. 开发中：使用注解 取代 xml配置文件。
    3. @Component 取代<bean class="">
    4. @Component("id")  取代 <bean id="" class="">
    5. web开发，提供3个@Component注解衍生注解（功能一样）取代<bean class="">
        * @Repository(“名称”)：dao层
        * @Service(“名称”)：service层
        * @Controller(“名称”)：web层
        * @Autowired：自动根据类型注入
        * @Qualifier(“名称”):指定自动注入的id名称
        * @Resource(“名称”)
        * @ PostConstruct 自定义初始化
        * @ PreDestroy 自定义销毁
    6. @Component
        public class UserDaoImpl implements UserDao{
            public String selectPasswordByName(String name) {
                if ("zhangsong".equals(name))
                {
                    return "jiaochunidemima";
                }
                return "ok";
            }
        }
        @Component
        public class UserServiceImpl implements UserService {
            @Autowired
            UserDao userDao;

            public String queryPasswordByUsername(String name) {
                return userDao.selectPasswordByName(name);
            }
        }
        @RunWith(SpringJUnit4ClassRunner.class)
        @ContextConfiguration("classpath:application.xml")
        public class mytest {
            @Autowired
            UserService userService;
            @Resource(name="user1")
            User user;
            @Test
            public  void test(){
                String s = userService.queryPasswordByUsername("123");
                System.out.println(s);
            }
        }