SSM框架--Spring---ioc（控制反转）&di（依赖注入）

Spring

核心技术点： ioc   di  aop  声明式事务 

ioc的底层实现（理解）

spring提供的ioc技术帮助我们解决了程序的高耦合问题，让我们不再花费时间去关心程序的高耦合

耦合关系

耦合：在编程语言中，就是计算机代码之间的依赖关系

代码之间的依赖关系如果很高就意味着程序高耦合，不利于后期项目的扩展开发，因此我们需要给程序松耦合

高耦合—松耦合–低耦合

需求 ：自定义ioc的代码,实现更加松耦合的程序

代码实现：

webTest

public class webTest {

    @Test
    public void test2() throws Exception {

        UserService userService1= (UserService) Factory2.getBean("userService");
        System.out.println(userService1);
    }
}

单例工厂

package cn.itcast.utils;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;

//单例工厂模式
public class Factory2 {

        private static ResourceBundle bundle=null;
        private static Map map=new HashMap();
    static {

        try {

            //反射创建对象
            //只要加载后缀名为properties的文件 统一用ResourceBundle 不能加载xml 底层写死了后缀名
            bundle=ResourceBundle.getBundle("bean");
            //获取所有的key
            Enumeration keys = bundle.getKeys();
            while (keys.hasMoreElements()){
                //获取key  aaa
                String key = keys.nextElement();
                //cn.itcast.service.impl.UserServiceImpl--对象
                String value = bundle.getString(key);
                Class clazz = Class.forName(value);
                Object obj = clazz.newInstance();
                map.put(key,obj);

            }


        }catch (Exception e){
            e.printStackTrace();
        }

    }
    public static Object getBean(String id) throws Exception {

        Object obj = map.get(id);
        return obj;
    }
}

4）多例工厂

package cn.itcast.utils;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;

//多例工厂模式
public class Factory {

        private static ResourceBundle bundle=null;
        private static Map map=new HashMap();
    static {
        //反射创建对象
        //只要加载后缀名为properties的文件 统一用ResourceBundle  不能加载xml 底层写死了后缀名
        bundle=ResourceBundle.getBundle("bean");
        //获取所有的key
        Enumeration keys = bundle.getKeys();
        while (keys.hasMoreElements()){
            //获取key  aaa
            String key = keys.nextElement();
            //cn.itcast.service.impl.UserServiceImpl
            String value = bundle.getString(key);
            map.put(key,value);
        }

    }
    public static Object getBean(String id) throws Exception {

        String value =(String) map.get(id);
        Class clazz = Class.forName(value);
        Object obj = clazz.newInstance();
        return obj;
    }
}

5）UserService

public interface UserService {
    
}

UserServiceImpl

public class UserServiceImpl implements UserService {
   
}

application.xml

结论

通过以上的配置文件+反射+工厂的方式可以实现程序解耦合，而spring的底层封装的就类似这一套的实现（ioc）

一 认识Spring的ioc容器

ioc：控制反转

指的是对象的控制权由原来开发者在类中自己手动创建控制 反转到 由Spring/ioc容器创建控制
其实spirng底层已经做好了工厂，这个工厂就已经帮助我们创建好了对象，放入到ioc容器中（就是map集合）

ioc作用

帮助咱们创建管理对象，做到程序之间的解耦合

获取对象方式：

传统方式获取对象：主动出击 new
Spring方式获取对象：问ioc容器要对象 

二 Spring概述【了解】

Spring是分层的 Java SE/EE应用 full-stack 开源框架。以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

简单说：spring为三层开发提供了一站式的解决方案
web层： servlet---->springMvc框架
service层：声明式事务 --->事务
dao层：jdbc---->jdbcTemplate  （企业多用mybits）
友情提示 spring课程的学习侧重点：ioc技术（DI）  aop技术  声明式事务技术

spring的体系结构图

三 Spring的ioc快速入门【重点】

环境搭建

1 导入依赖
	  spring坐标依赖  要求junit4.12及以上版本

2 将对象的创建和管理交给spring容器
	  xml配置文件	
3 从spring容器中获取对象
	  java代码的API调用

1）spring的依赖

      org.springframework
      spring-context
      5.1.5.RELEASE

Demo2

public class Demo2 {

    public static void main(String[] args) {
        // 创建ioc容器管理对象
        ApplicationContext context=new ClassPathXmlApplicationContext("application.xml");
        // 问ioc容器要对象
        UserService userService =(UserService)context.getBean("userService");
        userService.save();
    }
}

application.xml

流程图

四 Spring相关API【理解】

实现类

* FileSystemXmlApplicationContext【了解】
	功能：从指定磁盘目录加载xml配置文件，创建spring的ioc容器

------------------------------------------

* ClassPathXmlApplicationContext (加载配置文件的)
	功能：从类路径下加载xml配置文件，创建spring的ioc容器
	
* AnnotationConfigApplicationContext （加载注解的）
	功能：加载注解配置类，创建spring的ioc容器

方法

1. public Object getBean(String id) throws BeansException; （掌握）
	功能：通过指定id获取对象的实例，需要手动强转

2. public  T getBean(Class requiredType);
	功能：通过指定类型获取对象的实例，不需要强转
	注意：同一个类型下只能有一个对象实例

五 Spring配置文件【重点】 5.1 Bean标签 配置信息

bean标签：指定创建对象的
	id属性：唯一标识（配置文件中唯一）
	class属性：实现类的全限定名
    scope属性：范围
	 	取值：singleton(单例默认) prototype（多例） 扩展：request,session,globesession..
	   		 singleton:对象是随着容器的创建而创建 随着容器的销毁而销毁 自始至终只有一个对象
			 prototype：对象的创建和销毁与容器的创建和销毁无关 
					   每次执行getBean的时候创建新的对象 调用一次创建一次
					   销毁是会等待垃圾回收机制自动完成的
   init-method属性: 对象创建之后指定调用方法
   destroy-method属性：对象销毁后指定调用方法

5.2 spring创建对象实例三种方式

1.构造方式（重要）
2.静态工厂： 该工厂中获取对象的方法是静态的 可以类名直接调用（了解）
3.实例化工厂：该工厂中获取对象的方法是非静态的 必须得有工厂对象才能调用方法（了解）

1）构造方法实例化【重点】

2）工厂静态方法实例化【了解】

public class Factory {
    public static Object getBean(){
        return new UserServiceImpl();
    }
}

3）工厂普通方法实例化【了解】

public class Factory2 {

    public  Object getBean(){
        return new UserServiceImpl();
    }
}

六 Bean依赖注入概述（掌握）

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

​ 在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是对象的属性应该如何管理，这里spring

提供了技术：依赖注入

依赖注入：对存在依赖关系的属性或者对象自动赋值
属性分类：
	注入简单数据类型的数据
	注入复杂类型的数据（单列（array，list，set）和 双列（map，properties对象））
	注入被spring容器管理的对象

依赖注入的两种方式：构造方法注入和set方法注入 

Bean依赖注入方式 1）构造方法注入（了解）

public class UserServiceImpl implements UserService {

    
    
  
  	// 简单属性
    private String name;
    private Integer age;
    // 构造器方式
    public UserServiceImpl(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void save() {
        System.out.println(name+":"+age);
    }
  
  	
  	// 对象属性
    private UserDao userDao;
    // 构造器方式
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    public void save() {
        userDao.save();
    }
}

2）set方法注入【重点】

public class UserServiceImpl implements UserService {

    
	
    private String name;
    private Integer age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public void save() {
        System.out.println(name+":"+age);
    }
    
    
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void save() {
        userDao.save();
    }
    
    
    private Set