【Spring】第一站：Spring框架介绍 & Spring IOC & Bean管理

一、Spring框架介绍

1. 框架概述

        Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

        Spring是于2003 年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE.

        Development and Design中阐述的部分理念和原型衍生而来。

        它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。

        Spring的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

IOC:控制反转，将创建对象的过程交给spring进行管理.

AOP:面向切面，在不修改源代码的情况之下进行代码功能的增强.

 2. Spring框架的优点

        方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理，这也是IOC的作用。

        AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。

        声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。

        方便程序的测试，Spring对Junit4支持，可以通过注解方便的测试Spring程序。

        方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis等）的直接支持。

        降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

二、搭建Spring框架

首先，新建项目，创建Maven项目。

Java当中如何创建对象？---  程序员来创建Java对象

new 关键字

反射

 IOC：控制权反转-- 表示创建对象的权利发生了转换。把创建对象的权利交给Spring框架进行管理。

 1. 举例

public static void main(){
    Class clazz=Class.forName("全类名");
    clazz.newInstance();//创建对象的方法
    //创建对象的形式就是反射
}

xml配置文件（写着关于当前全类名的方案）

path=com.qcby.Demo

只要main方法读取到path值，就能去生成对象。

        如果现在有100个类，为了创建出相应的对象，写100个path，主动去读取xml配置文件。我们一般把他称为IOC控制权反转。

        当前Spring不需要去写main方法，main方法默认自动配置好了，只需要配置xml文件就行。这样，在Spring启动之后或者在用户有需求的时候，就能生成对象，供用户进行调用。

2. 转换

        目前只是一个Maven壳子，把壳子转换成Spring框架。

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

运行maven。

3. 运行 

编写demo，编写具体的实现方法。

 public void run(){
        System.out.println("赶紧跑....");
    }

//传统创建对象的方式
    @org.junit.Test
    public void test1(){
        Demo demo=new Demo();
        demo.run();
    }

         编写Spring核心的配置文件，在resources目录下创建applicationContext.xml的配置文件，名称是可以任意的，但是一般都会使用默认名称。

 <bean id="demo" class="com.qcby.service.Demo">

id就是key值，class里是全类名。

public void test2(){
    ApplicationContext context=new ClassPathXmlApplicationContext("Spring.xml");
    Demo demo=(Demo)context.getBean("demo");
    demo.run();
}

读取Spring.xml文件，获取对象getbean()，类型是demo类型。

定义Cat类

public class Cat {
    public void run(){
        System.out.println("小猫跑的很快....");
    }
}

配置xml文件。

<bean id="cat" class="com.qcby.service.Cat"/>

@org.junit.Test
public void test3(){
    ApplicationContext context=new ClassPathXmlApplicationContext("Spring.xml");
    Cat cat=(Cat)context.getBean("cat");
    cat.run();
}

4. Spring创建对象的模式

        在Spring内部集成一个方法，用反射的方式直接读取配置文件，通过读取配置文件，利用反射的方式帮用户创建对象。

        创建好对象后，用户只需要去获取当前对象即可。

三、Spring IOC容器

1. IOC概念

        IOC -- Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！

        在java当中一个类想要使用另一个类的方法，就必须在这个类当中创建这个类的对象，那么可能会出现如下情况，

         比如A类当中创建着B对象，B类当中有C对象，C类当中有A对象，

        这个如果一个类出了问题，那么可能会导致这个框架出现问题。

        Spring 将创建对象的权利给了IOC，在IOC当中创建了ABC三个对象吗，那么我们其他的类只需要调用集合， 大大的解决了程序耦合性的问题。

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

解决问题：使用IOC可以解决程序耦合性高的问题。

2. IOC容器的底层原理

IOC的实现，依赖于以下3门技术

① dom4j解析xml文档；

② 工厂模式；

③ 采用反射设计模式创建对象

2.1 工厂模式

         在当前情况之下A类想要调用B类就必须自己在自己的内部新建B类的对象，这样的耦合度太高，那我们如何降低耦合度的呢？

         创建一个工厂类，这样就能够使得A和B的耦合度降低到最小值。

2.2 那么上边提到的三种技术如何实现IOC的呢？

第一步：xml配置文件，配置创建对象

<bean id="demo" class="com.qcby.service.Demo" />

第二步：创建工厂类

public class DemoFactory {
    //利用dom4j得到name所对应的value值
   public static Demo getDemo() throws Exception {
       //利用dom4j得到name所对应的value值
       String value="class路径";
       //通过反射创建对象
       Class clazz = Class.forName(value);
       //返回并创建demo对象
       return (Demo) clazz.newInstance();
   }
}

通过以上两步，我们基本上就可以得到我们所创建的对象。

3.IOC(接口)

1.IOC思想是基于IOC容器完成的，IOC的底层就是对象工厂

2.Spring里边提供了IOC容器的实现的两种方式

(1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用

* BeanFactroy:加载配置文件的时候不会去创建对象，在使用对象的时候才会去创建对象

 (2)ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用。

 *加载配置文件的时候会把对象创建

 四、Spring框架的Bean管理

1. Bean管理概念

bean管理指的是如下的两个操作。

        1.创建对象

        2.注入属性

2. Bean管理操作的两种方式

1.基于xml配置文件的方式实现

2.基于注解方式实现

3.基于xml配置文件的方式实现Bean管理和注入属性

 1>.基于xml方式创建对象

①：这个就是我们上边配置过

②：创建对象的时候，默认是执行无参构造方法完成对象

2>.基于xml方式注入属性

*依赖注入的概述

        IOC和DI的概念

        IOC：Inverse of Control，控制反转，将对象的创建权反转给Spring！！

        DI：Dependency Injection，依赖注入，就是注入属性

 1* 属性的set方法注入值

编写属性，提供该属性对应的set方法，编写配置文件完成属性值的注入

public class Demo {
    // 编写成员属性，一定需要提供该属性的set方法
    //IOC容器底层就通过属性的set方法方式注入值
    private int age;
    private String name;
    private Cat cat;

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", cat=" + cat+
                '}';
    }
}

<bean id="demo" class="com.qcby.service.Demo">
<!--
    使用property完成属性注入
    name:类里面属性名称
    value:向属性注入值
    ref:对象映射
-->
        <property name="name" value="张三"/>
        <property name="age" value="18"/>
        <property name="cat" ref="cat"/>
    </bean>

//Spring 创建对象的方案
@org.junit.Test
public void test2(){
    ApplicationContext context=new ClassPathXmlApplicationContext("Spring.xml");
    Demo demo=(Demo)context.getBean("demo");
    System.out.println(demo.toString());
}

2 * 特殊属性注入值

1.set/get

2.构造函数

get/set方式：

private String[] strings;
private List<String> list;
private Map<String,String> map;

数组：

<property name="strings">
    <array>
        <value>aa</value>
        <value>bb</value>
        <value>cc</value>
    </array>
</property>

list类型的集合：

<property name="list">
    <list>
        <value>dd</value>
        <value>ee</value>
    </list>
</property>

map类型的集合：

<property name="map">
    <map>
        <entry key="aa" value="老王"/>
        <entry key="bb" value="老张"></entry>
    </map>
</property>

3* 属性构造方法方式注入值

编写属性，提供该属性对应的set方法，编写配置文件完成属性值的注入

一般类型

public class Cat {

    private String name;
    private Double money;

    public Cat(String name, Double money) {
        this.name = name;
        this.money = money;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

<bean id="cat" class="com.qcby.service.Cat">
    <constructor-arg name="name" value="张三"/>
    <constructor-arg name="money" value="100.5"/>
</bean>

@org.junit.Test
public void test2(){
    ApplicationContext context=new ClassPathXmlApplicationContext("Spring.xml");
    Demo demo=(Demo)context.getBean("demo");
    System.out.println(demo.toString());

    Cat cat=(Cat)context.getBean("cat");
    System.out.println(cat.toString());
}

加上特殊类型

public class Cat {

    private String name;
    private Double money;
    private String[] strings;
    private List<String> list;
    private Map<String,String> map;

    public Cat(String name, Double money, String[] strings, List<String> list, Map<String, String> map) {
        this.name = name;
        this.money = money;
        this.strings = strings;
        this.list = list;
        this.map = map;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", money=" + money +
                ", strings=" + Arrays.toString(strings) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }

<bean id="cat" class="com.qcby.service.Cat">
    <constructor-arg name="name" value="张三"/>
    <constructor-arg name="money" value="100.5"/>
    <constructor-arg name="strings">
        <array>
            <value>aa</value>
            <value>bb</value>
            <value>cc</value>
        </array>
    </constructor-arg>
    <constructor-arg name="list">
        <list>
            <value>dd</value>
            <value>ee</value>
        </list>
    </constructor-arg>
    <constructor-arg name="map">
        <map>
            <entry key="aa" value="老王"/>
            <entry key="bb" value="老张"></entry>
        </map>
    </constructor-arg>
</bean>