Spring_Ioc容器

一、Spring框架概念

　　spring 是众多开源 java 项目中的一员，基于分层的 javaEE 应用一站式轻量级开源框架，主要核心是 Ioc(控制反转/依赖注入) 与 Aop(面向切面)两大技术，实现项目在开发过程中的轻松解耦， 提高项目的开发效率。

　　在项目中引入spring的好处：

　　　　·降低组件之间的耦合度，实现软件各层之间的解耦

　　　　·可以使用容器提供的众多服务，如：事务管理服务、消息服务等

　　　　·当使用容器管理事务时，开发人员就不需要手工控制事务，也不需要处理复杂的事务传播

　　　　·容器提供单例模式支持，开发人员不再需要自己编写实现代码

　　　　·容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能

二、Spring源码架构

　　1、核心容器:spring-beans 和 spring-core 模块是 Spring 框架的核心模块，包含控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI） ,核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory， 工厂模式的实现。 BeanFactory 使用控制反转（IOC） 思想将应用程序的配置和依赖性规范与实际的应用程序代码分开。

　　2、Spring 上下文 Spring Context： Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。 Spring 上下文包括企业服务，例如 JNDI、 EJB、电子邮件、国际化、校验和调度功能。

　　3、Spring-Expression 模块是统一表达式语言（unified EL）的扩展模块，可以查询、管理运行中的对象，同时也方便的可以调用对象方法、操作数组、集合等。它的语法类似于传统 EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。

　　4、Spring-AOP： spring-aop 是 Spring 的另一个核心模块, 在 Spring中，他是以 JVM 的动态代理技术为基础，然后设计出了一系列的Aop 横切实现，比如前置通知、返回通知、异常通知等。 通过其配置管理特性， Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。

　　......

 三、Spring容器工厂的简单实现

package com.shsxt.factory;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;

import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Factory_01 implements Factory {
    // Map集合用来存放id和class
    Map<String, Object> map = new HashMap<>();
    List<Bean> beans = new ArrayList<>();

    // 实例化工厂对象时就完成以下操作
    public Factory_01(String fileName) {
        // xml解析
        this.pathXml(fileName);
        // 实例化对象
        this.instanceBean();
        // 属性赋值
        this.setProperty();
    }

    // 属性赋值
    private void setProperty() {
        try {
            if(null!=beans && beans.size()>0){
                for(Bean bean:beans){
                    List<Property> properties=bean.getProperties();
                    if(null!=properties && properties.size()>0){
                        for(Property property:properties){
                            // 得到property的id和ref
                            String id=property.getId();
                            String ref=property.getRef();
                            // set方法中首字母大写
                            id=id.toUpperCase().charAt(0)+id.substring(1);
                            // 获取到当前class
                            Class clz=map.get(bean.getId()).getClass();
                            // 找到set方法
                            Method method=clz.getDeclaredMethod("set"+id,map.get(ref).getClass());
                            method.invoke(map.get(bean.getId()),map.get(ref));
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 实例化
    private void instanceBean() {
        if (null != beans && beans.size() > 0) {
            try {
                for (Bean bean : beans) {
                    // 放到map集合中，通过key找到value，实例化该对象
                    map.put(bean.getId(), Class.forName(bean.getClz()).newInstance());
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * xml解析
     *
     * @param fileName xml文件名
     */
    private void pathXml(String fileName) {
        // 获取xml文件
        URL url = this.getClass().getClassLoader().getResource(fileName);
        try {
            if (null != url) {
                // 获取解析器
                SAXReader saxReader = new SAXReader();
                // 解析xml文件，返回document对象
                Document document = saxReader.read(url);
                // 获取xpath对象
                XPath xPath = document.createXPath("beans/bean");
                // 查询选择的节点，返回的是list集合
                List<Element> elements = xPath.selectNodes(document);
                // 为空判断
                if (null != elements && elements.size() > 0) {
                    for (Element element : elements) {
                        // 获取property
                        xPath = document.createXPath("property");
                        // 查询选择的节点
                        List<Element> subElements = xPath.selectNodes(element);
                        // 为空判断
                        List<Property> properties = null;
                        // 实例化Bean
                        Bean bean = new Bean(element.attributeValue("id"), element.attributeValue("class"));
                        if (null != subElements && subElements.size() > 0) {
                            properties = new ArrayList<>();
                            for (Element subElement : subElements) {
                                // 实例化Property
                                Property property = new Property(subElement.attributeValue("id"), subElement.attributeValue("ref"));
                                // 将对象放到集合中
                                properties.add(property);
                            }
                            bean.setProperties(properties);
                        }
                        beans.add(bean);
                    }
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Object getObj(String name) {
        // 通过id返回class
        return map.get(name);
    }
}

四、Spring多文件的加载情况

　　1、ClassPathXmlApplicationContext类的构造器参数是一个可变长参数

　　　　　　可同时配置多个xml文件

　　2、import标签，将自配置文件导入总配置

　　　　

四、Spring Ioc实例化bean的三种方式

　　1、构造器的方式实例化bean对象

　　　　通过默认构造器实例化bean对象，默认空构造器必须存在

　　2、静态工厂方式实例化bean

　　　　要有工厂类和静态工厂方法

　　　　　　通过反射调用静态工厂的静态方法，将该静态方法的返回值作为bean的实例，可以统一管理各个bean的创建

 　　3、实例化工厂方式实例化bean

　　　　工厂类和实例化方法

　　　　　　工厂方法为非静态，需要配置工厂bean，并在bean中配置factory-bean和factory-method属性

　　　　　　1) 可用于集成其他框架的bean创建管理方法  2)能够使bean和factory的角色互换

五、Spring 依赖注入

　　在面向接口编程中，依赖接口可以动态传入多种实现

　　1、set注入

　　　　property标签，属性的set方法（不会出现循环引用问题）

　　　　

　　　　name：属性名称；ref：bean对象的引用；value：给属性直接赋值（List，Set，Map，properties）

　　　　

　　2、构造器注入

　　　　constructor-arg标签，带参构造器（会出现循环引用问题，彼此互相依赖对方导致bean无法实例化）

　　　　

　　　　name：属性名称；ref：bean对象id的引用；index：属性的索引

　　3、静态工厂注入

　　　　

　　4、实例化工厂注入

　　　　

六、注解方式注入bean

　　xml配置：加入context命名空间和xsd地址

　　添加<context:annotation-config/>配置

　　@Resource （属于J2EE）

　　@Autowired （Spring）

　　常用于属性字段或set方法上

　　区别：

　　　　　@Autowired 默认按bean的类型匹配，和@Qualifier配合使用可以修改按名称匹配

　　　　　@Resource 默认按名称进行装配，可以通过name属性指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行匹配注入，如果注解写在set方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配（当name属性指定，只会按照名称装配）

注解方式注入的简单模拟：

　　

package com.shsxt02;

import com.shsxt.annotaioms.Component;
import com.shsxt.annotaioms.Component02;
import com.shsxt02.controller.UserController;

import java.io.File;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {

    private static List<String>  clz=new ArrayList<>();
    private static  Map<String,Object> map=new HashMap<>();

    public static void main(String[] args){
        String pkg="com.shsxt02";
        // 获取标记注解的类
        getClZ(pkg);
        // 实例化这些类
        instanceClz();
        // 属性赋值
        property();
        UserController userController= (UserController) map.get("userController");
        userController.test();
    }

    private static void property() {
        try {
            if (null!=map){
                for(Map.Entry entry:map.entrySet()){
                    Field[] fields=entry.getValue().getClass().getDeclaredFields();
                    if (null!=fields){
                        for(Field field:fields){
                            Component02 component02=field.getAnnotation(Component02.class);
                            if (null!=component02){
                                field.setAccessible(true);
                                field.set(entry.getValue(),map.get(component02.value()));
                            }
                        }
                    }
                }
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }


    private static void instanceClz() {
        try {
            if (null!=clz && clz.size()>0){
                for(String cls:clz){
                    //System.out.println(str);
                    cls=cls.replace(".class","");
                    //System.out.println(cls);
                    Component component=Class.forName(cls).getAnnotation(Component.class);
                    if (null!=component){
                        //System.out.println(cls);
                        String id= getId(cls);
                        Object obj=Class.forName(cls).newInstance();
                        map.put(id,obj);
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

    private static String getId(String cls) {
        cls=cls.substring(cls.lastIndexOf(".")+1);
        cls= cls.toLowerCase().charAt(0)+cls.substring(1);
        return cls;
    }

    private static void getClZ(String pkg) {
        // 获取url
        URL url=Thread.currentThread().getContextClassLoader().getResource(repStr(pkg));
        String urlPath=url.getFile();
        //System.out.println(urlPath);
        String[] subFileStrs=new File(urlPath).list();
        for(String str:subFileStrs){
            String subFilePath=urlPath+"/"+str;
            //System.out.println(subFilePath);
            File subFile=new File(subFilePath);
            if (subFile.isDirectory()){
                //System.out.println(pkg+"."+subFile.getName());
                getClZ(pkg+"."+subFile.getName());
            }else{
                clz.add(pkg+"."+subFile.getName());
            }
        }
    }

    private static String repStr(String str){
        str=str.replace(".","/");
        return str;
    }
}

七、Spring IOC 容器自动扫描管理bean

　　xml配置<context:component-scan base-package=""/>

　　建议的注解

　　　　Dao层：@Repository

　　　　Service层：@Service

　　　　控制层：@Controller

　　　　不明确：@Component

八、Bean的作用域问题(scope)

　　1、singleton作用域（单例，默认）

　　　　lazy-init 懒加载 默认为false

　　　　　　如果等于true时，spring容器启动的时候不会去实例化这个bean，而是在程序调用时才会去实例化

　　　　　　在启动情况下实例化所有singleton的bean对象并缓存与容器中单例的好处：

　　　　　　　　1、提前发现潜在的配置问题

　　　　　　　　2、bean对象存在于缓存中，使用时不用再实例化bean，提高执行性能

　　　　

　　　　　　无状态对象适合做单例bean对象（无可变的成员变量）

　　2、prototype作用域（原型）

　　　　每次向Spring容器请求获取Bean都返回一个全新的Bean，相对于“singleton”来说就是不缓存Bean。IOC不会维护该对象

　　3、Web应用中的作用域（request、session、globalsession）

　　　　request作用域：每一次请求

　　　　session：当前会话

　　　　globlasession：同session（Portlet环境）