Spring基础：Spring的简介以及了解IOC

一、认识Spring
1.spring简介
Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。
2.spring的好处

• 方便解耦，简化开发：通过spring提供的IOC容器，我们可以将对象之间的依赖关系交给spring进行控制，避免硬编码所造成的过度程序耦合。有了spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
• AOP编程的支持：通过spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付
• 声明式事务的支持：在spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方便灵活进行事务的管理，提高开发的效率和质量
• 方便程序的测试：可以用非容器依赖的编程方式进行几乎所有的测试工作，在spring里，测试不再是昂贵的操作，而是随手可做的事情，例如：spring对junit4的支持，可以通过注解方便的测试spring程序
• Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦；Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问

二、认识IOC
1.IOC简介
IOC，全名inversion of Control，翻译成中文为控制反转,它十一种思想，也可以说是一种模式。实现这个思想有个方式叫做依赖注入（Dependency Injection）简称DI（在下篇博文中会详细说到），它的本质就是设置接口，设置set方法。
2.使用IOC的好处是什么？
在IOC中把对象生成放在了XML里定义，所以当我们需要换一个实现子类将会变得很简单(一般这样的对象都是实现于某种接口的)，只要修改XML就可以了；让程序的耦合性大大降低。方便模块独立，实现了解耦；
缺点是什么?(1)生成一个对象的步骤变复杂了(事实上操作上还是挺简单的)，对于不习惯这种方式的人，会觉得有些别扭和不直观。(2)对象生成因为是使用反射编程，在效率上有些损耗。但相对于IoC提高的维护性和灵活性来说，这点损耗是微不足道的，除非某对象的生成对效率要求特别高。(3)缺少IDE重构操作的支持，如果在Eclipse要对类改名，那么你还需要去XML文件里手工去改了，这似乎是所有XML方式的缺陷所在。
3.简单程序HelloSpring来理解IOC
先导依赖的jar包（在pom.xml文件中）

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.3.9.RELEASE</version>
</dependency>

创建实体类Hello

package com.muzili.pojo;

public class Hello {

    private String name;

    public Hello() {
    }

    public Hello(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("Hello,"+name);
    }

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

编写spring的配置文件beans.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是一个java对象，由Spring管理和创建-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>

    <bean id="hello2" class="com.muzili.pojo.Hello">
        <property name="name" value="Summer"/>
    </bean>

   

</beans>

然后就写测试类进行测试了

package com.muzili.pojo;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloTest {
    @Test
    public void test(){

        //解析beans.xml配置文件,生产管理相应的Bean对象;
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //通过Bean得到这个对象的实体
        Hello hello = (Hello)context.getBean("hello2");

        hello.show();

    }
}

打印出的结果为 Hello,Summer

4.IOC创建对象的方式
我们都知道，调用有参构造和无参构造可以创建出对象，那么在Spring中是怎么创建对象的？请往下看
先创建一个实体类，方便创建对象

package com.muzili.pojo;

public class User {

    private String name;
    private String sex;
    private int age;

    public User() {
        System.out.println("User的无参构造");
    }

    public User(String name) {
        System.out.println("User的有参构造");
        this.name = name;
    }

    public User(String name, int age) {
        System.out.println("User的有参构造2");
        this.name = name;
        this.age = age;
    }

    public User(String name, String sex, int age) {
        System.out.println("User的有参构造3");
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public void setName(String name) {
        System.out.println(name+":"+System.currentTimeMillis());
        this.name = name;
    }

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

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

编写Spring的核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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">

    <!--
    Spring的配置文件
    bean 代表一个对象
    alias  别名
    import  导入一个其他资源
    -->

    <bean id="user" class="com.muzili.pojo.User">
        <property name="name" value="刘德华"/>
    </bean>

    <!--使用构造器的参数下标进行赋值-->
    <bean id="user2" class="com.muzili.pojo.User">
        <constructor-arg index="0" value="刘德华2"/>
        <constructor-arg index="1" value="18"/>
    </bean>

    <!--通过名字进行赋值-->
    <bean id="user3" class="com.muzili.pojo.User">
        <constructor-arg name="name" value="刘德华3"/>
        <constructor-arg name="age" value="3"/>
    </bean>

    <!--通过类型进行赋值-->
    <bean id="user4" class="com.muzili.pojo.User">
        <constructor-arg type="java.lang.String" value="刘德华4"/>
        <constructor-arg type="java.lang.Integer" value="18"/>
        <constructor-arg type="java.lang.String" value="男"/>
    </bean>


</beans>

测试类

package com.muzili.pojo;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User)context.getBean("user");

        System.out.println(user.toString());
    }


    @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user2");
        System.out.println(user);

    }
	    @Test
    public void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user3");
        System.out.println(user);

    }
        @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user4");
        System.out.println(user);

    }


}

结论：从上面的实例中，我们可以看到在Spring中创建对象的方式有：

• 通过有参构造
  通过下标
  通过参数名
  通过参数类型
• 通过无参构造
  默认会用无参构造