Spring简介及IOC使用

Spring介绍

官网：https://spring.io/

Spring是一个对象的容器，负责管理对象的创建、销毁，以及对象的属性注入，对象的之间的依赖关系。

Spring可以整合其它框架，他基于IOC和AOP来构架多层JavaEE系统，以帮助分离项目组件之间的依赖关系，简化企业开发。

Spring的组成

可分为：

数据访问/集成：Data Access/Integration

Web：springmvc
 
面向切面：AOP、Aspects
 
设备：Instrumentation
 
消息：Messaging
 
核心容器：Core Container
 
测试：Test

两个概念：依赖注入、控制反转 

依赖注入(DI)

Dependency Injection，创建对象实例时，同时为这个对象注入它所依赖的属性，也就是把每个bean与bean之间的关系交给容器管理，例如：在Service层注入它所依赖的Dao层的实例；在Controller层注入它所依赖的Service层的实例。

控制反转(IOC)

Inversion of Control，是一种设计思想，意思是说，开发者不需要人工的创建对象(只需要关注对象创建之后的操作)，而是把创建的对象权利转交给Spring容器，让Spring容器去创建并管理这些对象，以达到程序的高度解耦的目的。

IOC使用

pom依赖等

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.qzcsbj.myspring</groupId>
    <artifactId>myspring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <spring.version>4.3.14.RELEASE</spring.version>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
    </properties>

    <dependencies>
        <!-- spring需要的jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--<dependency>-->
            <!--<groupId>org.springframework</groupId>-->
            <!--<artifactId>spring-context-support</artifactId>-->
            <!--<version>${spring.version}</version>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

创建一个实体类，添加：get、set方法、无参、有参构造方法、toString方法

package com.qzcsbj.bean;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <创建一个类，添加：get、set方法、无参、有参构造方法、toString方法>
 */
public class Person {
    private String name;
    private String job;

    public Person() {
        System.out.println("==============无参构造方法");
    }

    public Person(String name, String job) {
        System.out.println("==============带参构造方法");
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

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

创建对象方式一：传统方式，new创建 

package com.qzcsbj.test;

import com.qzcsbj.bean.Person;
import org.junit.Test;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class TestPerson {
    @Test
    public void test(){
        Person p = new Person("jack", "dev");
        System.out.println(p);
    }
}

创建对象方式二：Spring底层用反射创建对象

resources下创建spring配置文件

xml文件名字可以改，但是一般都保持这个名称： applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="p1" class="com.qzcsbj.bean.Person">
        <property name="name" value="jack"/>
        <property name="job" value="tester"/>
    </bean>
</beans>

测试：

package com.qzcsbj.test;

import com.qzcsbj.bean.Person;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @公众号 : 全栈测试笔记
 * @博客 : www.cnblogs.com/uncleyong
 * @微信 : ren168632201
 * @描述 : <>
 */
public class TestPerson {
    // 创建对象方式一：传统方式，new创建
    @Test
    public void test(){
        Person p = new Person("jack", "dev");
        System.out.println(p);
    }

    // 创建对象方式二：使用Spring帮我们创建对象
    @Test
    public void test2(){
        // 启动加载配置文件，并启动Spring框架，得到一个context对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 从Spring容器中获取对象
        Person p1 = context.getBean("p1", Person.class);
        System.out.println(p1);
    }
}

结果

上面有红色警告，加日志，添加：log4j.properties

总结：

　　第二种方式更灵活，对象没直接创建死，配置文件可以随时被修改，然后通过反射修改对象

　　创建对象(不管是new还是通过反射)一定会调用构造方法，Spring帮我们创建对象默认调用无参构造方法

【bak1】

【bak2】

原文会持续更新，原文地址：https://www.cnblogs.com/uncleyong/p/17018342.html